From 9d10633660a3dff5469f4e7a0a009a6c9994c0d7 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Fri, 16 Oct 2026 20:07:34 +0100 Subject: [PATCH 1/5] feat(research): release the T148 restore composition --- .../rank7-t148-restore-release/.gitattributes | 1 + .../GENERAL-CEILING.json | 21 + research/rank7-t148-restore-release/README.md | 195 ++++ .../rank7-t148-restore-release/SOURCES.json | 54 ++ research/rank7-t148-restore-release/TASK.json | 117 +++ .../rank7-t148-restore-release/VENDOR.json | 107 +++ .../rank7-t148-restore-release/VERIFY.json | 33 + .../evidence/ADAPTER-DERIVATION.json | 147 +++ .../evidence/ADMISSION-RESULT.json | 383 ++++++++ .../evidence/ADMISSION-STAGES.json | 113 +++ .../evidence/ENVIRONMENT.json | 9 + .../evidence/FINITE.json | 72 ++ .../evidence/NATIVE-RECEIPT.json | 113 +++ .../evidence/OUTER-CLAIM.json | 13 + .../evidence/PREFIX-AND-INVOICE.json.gz | Bin 0 -> 18866 bytes .../evidence/RECIPE.json | 237 +++++ .../evidence/RELEASE-RECEIPT.json | 7 + .../evidence/RESULT.json | 117 +++ .../evidence/VALIDATION.json | 28 + .../evidence/VERIFY-RESULT.json | 128 +++ .../evidence/VERIFY-STAGES.json | 104 +++ .../evidence/logs/complete-admission.log.txt | 8 + .../evidence/logs/declared-edit-stage.log.txt | 1 + .../logs/derive-closed-adapters.log.txt | 1 + .../evidence/logs/export-pr2833.log.txt | 1 + .../evidence/logs/export-pr2894.log.txt | 1 + .../evidence/logs/four-kernel-stage.log.txt | 1 + .../logs/fresh-current-native.log.txt | 3 + .../logs/fresh-retained-bootstrap.log.txt | 6 + .../logs/paired-extension-stage.log.txt | 1 + .../evidence/logs/parent-paired-stage.log.txt | 1 + .../evidence/logs/preload-stage.log.txt | 1 + .../evidence/logs/rank7-overlay-stage.log.txt | 1 + .../evidence/logs/source-preflight.log.txt | 1 + .../rank7-t148-restore-release/reproduce.py | 130 +++ .../rank7-t148-restore-release/test_verify.py | 116 +++ .../vendor/PR3018-EXCHANGE.json | 126 +++ .../vendor/PR3021-RESULT.json | 92 ++ .../vendor/PR3022-EXCHANGE.json | 124 +++ .../vendor/PR3022-RESULT.json | 187 ++++ .../vendor/geometry.py | 285 ++++++ .../vendor/moment.py | 138 +++ .../vendor/pr3015/CLAIM.json | 229 +++++ .../vendor/pr3015/CREDITS.md | 17 + .../vendor/pr3015/FINAL-WORD-base.json.gz | Bin 0 -> 71434 bytes .../vendor/pr3015/FINAL-WORD-extra.json.gz | Bin 0 -> 71430 bytes .../vendor/pr3015/MANIFEST.json | 156 ++++ .../vendor/pr3015/NOTICE | 28 + .../vendor/pr3015/PROVIDERS.json | 842 ++++++++++++++++++ .../vendor/pr3015/RELAX-CAP.json | 124 +++ .../vendor/release_driver.py | 260 ++++++ research/rank7-t148-restore-release/verify.py | 235 +++++ .../verify_release.py | 99 ++ 53 files changed, 5214 insertions(+) create mode 100644 research/rank7-t148-restore-release/.gitattributes create mode 100644 research/rank7-t148-restore-release/GENERAL-CEILING.json create mode 100644 research/rank7-t148-restore-release/README.md create mode 100644 research/rank7-t148-restore-release/SOURCES.json create mode 100644 research/rank7-t148-restore-release/TASK.json create mode 100644 research/rank7-t148-restore-release/VENDOR.json create mode 100644 research/rank7-t148-restore-release/VERIFY.json create mode 100644 research/rank7-t148-restore-release/evidence/ADAPTER-DERIVATION.json create mode 100644 research/rank7-t148-restore-release/evidence/ADMISSION-RESULT.json create mode 100644 research/rank7-t148-restore-release/evidence/ADMISSION-STAGES.json create mode 100644 research/rank7-t148-restore-release/evidence/ENVIRONMENT.json create mode 100644 research/rank7-t148-restore-release/evidence/FINITE.json create mode 100644 research/rank7-t148-restore-release/evidence/NATIVE-RECEIPT.json create mode 100644 research/rank7-t148-restore-release/evidence/OUTER-CLAIM.json create mode 100644 research/rank7-t148-restore-release/evidence/PREFIX-AND-INVOICE.json.gz create mode 100644 research/rank7-t148-restore-release/evidence/RECIPE.json create mode 100644 research/rank7-t148-restore-release/evidence/RELEASE-RECEIPT.json create mode 100644 research/rank7-t148-restore-release/evidence/RESULT.json create mode 100644 research/rank7-t148-restore-release/evidence/VALIDATION.json create mode 100644 research/rank7-t148-restore-release/evidence/VERIFY-RESULT.json create mode 100644 research/rank7-t148-restore-release/evidence/VERIFY-STAGES.json create mode 100644 research/rank7-t148-restore-release/evidence/logs/complete-admission.log.txt create mode 100644 research/rank7-t148-restore-release/evidence/logs/declared-edit-stage.log.txt create mode 100644 research/rank7-t148-restore-release/evidence/logs/derive-closed-adapters.log.txt create mode 100644 research/rank7-t148-restore-release/evidence/logs/export-pr2833.log.txt create mode 100644 research/rank7-t148-restore-release/evidence/logs/export-pr2894.log.txt create mode 100644 research/rank7-t148-restore-release/evidence/logs/four-kernel-stage.log.txt create mode 100644 research/rank7-t148-restore-release/evidence/logs/fresh-current-native.log.txt create mode 100644 research/rank7-t148-restore-release/evidence/logs/fresh-retained-bootstrap.log.txt create mode 100644 research/rank7-t148-restore-release/evidence/logs/paired-extension-stage.log.txt create mode 100644 research/rank7-t148-restore-release/evidence/logs/parent-paired-stage.log.txt create mode 100644 research/rank7-t148-restore-release/evidence/logs/preload-stage.log.txt create mode 100644 research/rank7-t148-restore-release/evidence/logs/rank7-overlay-stage.log.txt create mode 100644 research/rank7-t148-restore-release/evidence/logs/source-preflight.log.txt create mode 100644 research/rank7-t148-restore-release/reproduce.py create mode 100644 research/rank7-t148-restore-release/test_verify.py create mode 100644 research/rank7-t148-restore-release/vendor/PR3018-EXCHANGE.json create mode 100644 research/rank7-t148-restore-release/vendor/PR3021-RESULT.json create mode 100644 research/rank7-t148-restore-release/vendor/PR3022-EXCHANGE.json create mode 100644 research/rank7-t148-restore-release/vendor/PR3022-RESULT.json create mode 100644 research/rank7-t148-restore-release/vendor/geometry.py create mode 100644 research/rank7-t148-restore-release/vendor/moment.py create mode 100644 research/rank7-t148-restore-release/vendor/pr3015/CLAIM.json create mode 100644 research/rank7-t148-restore-release/vendor/pr3015/CREDITS.md create mode 100644 research/rank7-t148-restore-release/vendor/pr3015/FINAL-WORD-base.json.gz create mode 100644 research/rank7-t148-restore-release/vendor/pr3015/FINAL-WORD-extra.json.gz create mode 100644 research/rank7-t148-restore-release/vendor/pr3015/MANIFEST.json create mode 100644 research/rank7-t148-restore-release/vendor/pr3015/NOTICE create mode 100644 research/rank7-t148-restore-release/vendor/pr3015/PROVIDERS.json create mode 100644 research/rank7-t148-restore-release/vendor/pr3015/RELAX-CAP.json create mode 100644 research/rank7-t148-restore-release/vendor/release_driver.py create mode 100644 research/rank7-t148-restore-release/verify.py create mode 100644 research/rank7-t148-restore-release/verify_release.py diff --git a/research/rank7-t148-restore-release/.gitattributes b/research/rank7-t148-restore-release/.gitattributes new file mode 100644 index 0000000000..fa1385d99a --- /dev/null +++ b/research/rank7-t148-restore-release/.gitattributes @@ -0,0 +1 @@ +* -text diff --git a/research/rank7-t148-restore-release/GENERAL-CEILING.json b/research/rank7-t148-restore-release/GENERAL-CEILING.json new file mode 100644 index 0000000000..085fd64744 --- /dev/null +++ b/research/rank7-t148-restore-release/GENERAL-CEILING.json @@ -0,0 +1,21 @@ +{ + "model": "nine-stage coverage, one unpaid coordinate/family, centre64, idle rank<=51", + "local_profile": { + "1": 2443, + "2": 707, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "primitive_saving_cap": [ + "439088585719/250000000000000", + "1756354342877/1000000000000000" + ], + "realized_fraction_lower": "8645761685714791828251/8781771714385000000000", + "scope": "Primitive-moment cap only. The older retained a/(1+a) transfer is not substituted for the source release modern outer contract.", + "source_commit": "d8e0f83f00191df62174b641e9fff055c357f641", + "source_path": "research/complex-local-word-ceiling/ceiling.py", + "source_sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc", + "call": "ceiling(local, 73, 896, 9, 64)" +} diff --git a/research/rank7-t148-restore-release/README.md b/research/rank7-t148-restore-release/README.md new file mode 100644 index 0000000000..8af566fde2 --- /dev/null +++ b/research/rank7-t148-restore-release/README.md @@ -0,0 +1,195 @@ +# T148 packing composed with the R1 restore edit + +This package takes PR3022's released admission handoff. It composes its literal +T148 allocation with Jeremy Kothe's PR3015 R1 word edit, using PR3021's complete +release recipe. The selected result and all frozen predecessors stay unchanged. + +A fresh complete finite source/native/admission/outer release passed at + +```text +kappa = 0.001729152337142958365650 - 10^-46 - 10^-70 +PR3021 = 0.001729151203983018442998 - 10^-46 - 10^-70 +gain = 283289984980663 / 250000000000000000000000 + = 1.133159939922652e-9 +``` + +The finite complete-moment root lies strictly between +`0.0017291523371429583656502` and `0.0017291523371429583656503`. +This is an author-checked conditional candidate, not an adopted supplier or +selected-frontier update. `evidence/RESULT.json` binds the exact released point. + +## What changes + +PR3021 combines R1 with PR3018's T74 journal. Here the unchanged edited providers +run on PR3022's doubled order, fill and dispatch. These are the only three +scientific arguments changed in the source's complete-admission command. +Every preceding source derivation and native-provider command is retained. +The source admission retains its pinned PR2969 comparator. This wrapper also +checks strict improvement over the newer pinned PR3021 endpoint; the two gain +fields therefore have different baselines. Some inherited directory and status +names still say `packing74` or `T74`; actual geometry is checked as 148 replicas, +1,332 calls and 133,117 physical families. + +The complete profile is + +```text +{1:3288708, 2:941724, 3:318948, 4:143856, + 5:27416, 8:10656, 32:1, 48:56380}. +``` + +Relative to exactly twice PR3021, the difference is +`4 H1 + 4 H3 - 4 H5 - 2 H14 + H32`. +The new empty rank-32 bin is paid. Every one of 543,456 helper roles and all +91 private cleanup buffers remain charged. The scalar words, helper widths, +source derivation and native operations are exactly PR3015's, not a new word +search. The inherited geometry and moment kernels are reused and credited; +this package does not call them independent new implementations. + +## Composition and cost argument + +1. PR3018's journal applies literally to PR3015's unchanged original fill. + The complete T74 invoice with the edited providers equals PR3021's profile. +2. Map each old call time `t` to `2t+c` and replica `r` to `r+74c`, for + `c=0,1`. Each replica projects to the same nine source stages. Exact doubling + alone leaves the normalized moment unchanged. Apply PR3022's 86-row journal + only after that lift. Full geometry checks every resulting role, source + window, family exclusion, mask and compact prefix. +3. R1 changes the local per-call profile by `-2 H1 + H2`, without changing the + ordered helper widths. It therefore composes with the owner journal. The + geometry checker recomputes the sum of actual local calls + and actual idle remainders; it does not infer that sum from rank mass. +4. With `H_r(b)=(r/73)^(1-b)`, compare the complete moment divided by `896T`. + Directed integer intervals certify both endpoint signs. Every child rank + is below 73, so this moment is strictly increasing and the bracket isolates + its unique root. The new root exceeds PR3021's by between + `1.1331599399226515e-9` and `1.1331599399226517e-9`. This interval is for the + composed edited words, not PR3022's unedited-word interval. +5. Replica-dependent costs are not held fixed. Live families increase from + 66,304 to 132,608; complete physical families increase from 66,813 to 133,117. + The serial scratch namespace remains 408 reserved helper tableaux, + 8 centres, 91 private buffers and 2 coefficient families. Both 1,332 local + sweeps and 1,332 bridges are charged. Completed-event depth per replica + remains 18 under the inherited block-energy contract. +6. Compute the group exactly as + `|Sp(72,2)| = 2^1296 product(j=1..36, 2^(2j)-1)`. + The physical-stock bit length increases from 2644 to 2645, so the charged + stock-to-L2 exponent increases from 1322 to 1323. The conservative prefix + reserve becomes `128+37+18+1323+1+4 = 1511`, up from 1510, still below the + retained 2048-bit payload. Thus this composition needs no precision-cap + edit. The complete release checks these bounds against the emitted physical + schedule and actual native prefixes. The observed native + prefix is 93 bits, giving an actual global prefix of 1476 bits. The stored + complete invoice and explicit one-bit-undercharge controls bind these values. + +The last step is conditional on the inherited universal block-energy lemma. +Finite premise checking is not a proof of that universal implication. + +PR3015's source-specific fixed-inventory fractional packing cap is bracketed by +`0.0017291527560043309345350` and `0.0017291527560043309345351`. +The candidate realizes at least `0.9999997577649683` of that cap and remains about +`4.188613726e-10` below it. This is the inherited 2,551-pattern capacity-8/16/32/48 +relaxation, with the cap certificate's local profile and inventory checked +against both edited words. It is more restrictive than a rank-mass-only packing +relaxation. The new package does not independently recertify the cap's dual +proof; exact attainment and a more general owner optimum are not claimed. + +The broader `complex-local-word-ceiling/ceiling.py` calculation on this paid local +profile gives primitive-moment cap `[0.001756354342876, 0.001756354342877]` under +its nine-stage coverage and rank-51 halving relaxation. The candidate realizes +at least `0.9845122336250876` of that broader cap. `GENERAL-CEILING.json` records +that call with `local={1:2443,2:707,3:232,4:108,5:18,8:8}`, `m=73`, +`families=896`, `stages=9`, `centre=64`. The bounded verifier separately checks +both signs after clearing the fractional rank-51 count by scaling all counts +by 51. The source's modern outer release, not the older calculator's optional +`a/(1+a)` planning transfer, determines the final conditional kappa. + +## Reproduction + +The fresh chain's measured stage time was 1494.85 seconds on the recorded +Linux/Python 3.12.15/NumPy 1.26.4 environment. It covers a fresh retained +bootstrap, both current native-provider chains, actual owners, parent lift, +rebind, discovery, independent outer checks and the complete modern release. +The final wrapper's stronger payload/cap/invoice postchecks were rerun against +the completed artifacts. Its normalized scientific recipe is identical to the +recipe that ran. `evidence/VALIDATION.json` records that distinction. + +The bounded registered replay recomputes geometry and exact moment arithmetic, +checks the stored complete-release relations, runs 13 behavioral tests and +rejects ten receipt/actual-invoice corruptions. It does not rerun the full +supplier chain. Optimized Python 3.12 and ordinary Python 3.13 produce the same +finite receipt; warning-as-error execution and Ruff correctness checks pass. + +```sh +python3.12 -B scripts/research_package.py \ + --package research/rank7-t148-restore-release +``` + +For the full fresh chain, use Python 3.12 with NumPy 1.26.4. The recipe exports +historical exact Git objects, including PR3015, PR2894 and PR2833; the complete +predecessor pins are retained in the exported PR3015 recipe. If an object is +absent, fetch its exact public commit before replay. No fetch is hidden inside +the verifier. + +```sh +git fetch origin e244296debb45fe6f4da84d29e4d64fbab55fda0 +git fetch origin 18d03c447886895ef9abf888398178e0428533ca +git fetch origin e9307b48d7d1b690939935ecef0f8e524e6d92f4 +python3.12 -B research/rank7-t148-restore-release/reproduce.py \ + --repo "$PWD" --work /tmp/fresh-t148-r1-release +``` + +Use a fresh external workspace. POSIX process-group cleanup and enabled +assertions are required by the inherited chain. `--dry-run` checks exact source +exports and the changed recipe only. Container hashes bind this particular run; +canonical decompressed fill and JSON semantics define cross-environment equality. + +`VENDOR.json` pins exact source Git blobs and hashes. `SOURCES.json` pins live +inputs and historical provenance. The package changes no shared validator. + +## Limits and engineering notes + +This is a finite conditional construction, not a complete multiplication +proof, practical speedup, independent human review or selected-frontier update. +All-size/compiler, physical backing and movement, precision/fixed-tape, +analytic transfer and universal block-energy obligations remain inherited. +Replica-dependent storage doubles; this is not a storage-saving claim. +There is no integral-optimality claim. PR3024's T740 cap attainment and its +active R1/admission follow-up have a different, larger-stock scope. They are +not preempted or validated here. + +The new code has bounded input counts, finite bisection and source-authenticated +imports. Retained kernels execute compiled authenticated source bytes rather +than possibly stale default-import bytecode. Python requires managed allocation. +Geometry limits live collections to 1,332 calls, 543,456 roles and 298,368 bins. The three retained import targets +are fixed by hashes. Existing source exporters and native validators retain +their original assertion and dynamic-code mechanisms rather than undergoing an +unrelated rewrite. Full stages have a 1,800-second timeout with process-group +cleanup; the registered finite commands have 120-second limits. These are +bounded research-runtime deviations from fixed allocation and direct dispatch. +Future changes to the source interface must revalidate those bounds and pins. + +## Open next questions + +Independently rerun and review this exact complete T148+R1 release before +supplier adoption. Inspect the emitted stock-norm and prefix increase alongside +the actual owner schedule, then review the inherited universal block-energy +premise separately. A fresh replay took about 25 minutes on this development +host; another host may differ. Exact source access and the documented environment +are prerequisites. Structured details are in `TASK.json`. + +## Sources and credit + +- Jeremy Kothe, PR3015 `e244296debb45fe6f4da84d29e4d64fbab55fda0`, supplies R1. +- Nick Petalas, PR3021 `217edac2ebfa6250536bd6df153de14901a69395`, supplies the + T74 composition, exporter, process cleanup and source-chain postchecks. +- Nick Petalas, PR3022 `553dc9d8fc8c1489aa2b0378331a0de4b5e9b44e`, supplies the + doubled journal and retained geometry. PR3018 supplies the earlier journal + and directed moment kernel. +- Marius-Paul Dumitrean's PR2979 supplies the joint rank-seven construction. + Mason Hale, Jeremy Diviney, Yiyang Lu, Tekalign, Ross Richardson, Dugongue, + icekylinx, themilkman216 and the retained word/native/geometry/owner lineage + keep their predecessor credit and source notices. + +New here is the T148+R1 composition, rederived replica-dependent bill and its +source-bound release. Substantial automated assistance was used. No independent +human or formal-kernel review is claimed. Apache-2.0. diff --git a/research/rank7-t148-restore-release/SOURCES.json b/research/rank7-t148-restore-release/SOURCES.json new file mode 100644 index 0000000000..bf3d015a38 --- /dev/null +++ b/research/rank7-t148-restore-release/SOURCES.json @@ -0,0 +1,54 @@ +{ + "schema_version": 1, + "base_commit": "d8e0f83f00191df62174b641e9fff055c357f641", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/rank7-joint-endframes/allocation/DISPATCH.json", + "usage": "input", + "git_blob": "9544fee4e6ee1f202cee22bfaeaf229ee3b2515e", + "sha256": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c" + }, + { + "path": "research/rank7-joint-endframes/allocation/FILL.json.gz", + "usage": "input", + "git_blob": "8d4fd644d60ba2c98106dc770803b647afdf0963", + "sha256": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39" + }, + { + "path": "research/rank7-joint-endframes/allocation/ORDER.json", + "usage": "input", + "git_blob": "7409c4df1092241729739596c7648bda504e6aad", + "sha256": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "provenance", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + } + ] +} diff --git a/research/rank7-t148-restore-release/TASK.json b/research/rank7-t148-restore-release/TASK.json new file mode 100644 index 0000000000..855f4a3190 --- /dev/null +++ b/research/rank7-t148-restore-release/TASK.json @@ -0,0 +1,117 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 6, + "base_commit": "d8e0f83f00191df62174b641e9fff055c357f641", + "original_card": { + "id": "independent-moment", + "question": "Does one changed supplier or assembly claim lack a source-bound independent check of a specific new implication?", + "starting_points": [ + "certificates/selected-result.json", + "research/rank7-joint-endframes/README.md", + "docs/research/research-family-status.md" + ], + "methods": [ + "Independently reconstruct a coordinated frame/circuit change and its single-change control, then derive the complete rank and physical ledger.", + "Implement certified moment inequalities through a different exact enclosure method." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2979 joint rank-7 end-frame proposal and the revision-6 evidence status. Its claimed kappa is not selected. Compare coordinated changes with the losing single-change controls and locate the complete physical ledger; an aggregate moment alone does not validate the mechanism.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Prioritize a bounded independent audit of #2979: reconstruct one joint group and its single-lowering control, check the declared frames/chronology, then trace changed children, idle widths and cleanup buffers into the complete invoice and both supplier caps. Choose one still-missing implication after checking existing audits. Stop with exact unresolved dependencies if full admission exceeds the session; do not launch a new lowering census on an unvalidated premise or substitute extra root digits for mechanism checking.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Promoting #2979 from merged source archive to validated supplier solely from author PASS receipts or aggregate pricing." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering" + ] + }, + "scope_status": "changed", + "actual_scope": "Compose PR3022 T148 literal packing with PR3015 R1 and obtain a fresh complete conditional supplier/outer release beyond PR3021.", + "scope_change_reason": "The live PR3022 handoff requests source-bound admission, and the donor explicitly requests a mathematical improvement. Retained geometry and moment kernels are credited, not called independent new verification.", + "bottleneck_link": "Remove the exceptional-bin integrality loss without losing the gain to doubled physical stock or precision charges.", + "budget_minutes": 60, + "stop_rule": "One composition and one complete source/native/admission/outer chain; stop on a failed semantic, stock, prefix or release gate. No larger packing or word search.", + "outcome": "completed", + "evidence": "Fresh source/bootstrap/native/owners/admission/modern-outer release passes at kappa=0.001729152337142958365650-1e-46-1e-70. Exact gain over PR3021 is 283289984980663/250000000000000000000000. Stage time 1494.85 s. Registered checks cover 13 tests and 10 receipt/actual-invoice rejections; inherited hypotheses remain.", + "author": "Nick Petalas", + "ai_assistance": "Substantial automated assistance. No independent human or formal-kernel review is claimed.", + "open_questions": [ + { + "question": "Does an independent source-bound review accept the complete T148+R1 finite release and inherited block-energy premises?", + "why_it_matters": "A larger author-checked conditional endpoint is not supplier admission or a selected-frontier update.", + "first_step": "Run the explicit full reproduction in a fresh external workspace and inspect the one-bit stock-norm increase against the emitted invoice.", + "blocked_by": "Access to pinned historical Git objects and the documented numerical environment; universal inherited lemmas need separate mathematical review." + } + ], + "canonical_discussion": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2612#discussioncomment-18980713", + "predecessors": [ + { + "pr": 3015, + "head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "contribution": "Jeremy Kothe R1 scalar/frame edit" + }, + { + "pr": 3021, + "head": "217edac2ebfa6250536bd6df153de14901a69395", + "contribution": "Nick Petalas T74 restore/packing composition and complete release driver" + }, + { + "pr": 3022, + "head": "553dc9d8fc8c1489aa2b0378331a0de4b5e9b44e", + "contribution": "Nick Petalas T148 literal doubled exchange" + } + ], + "existing_checks": [ + "PR3022 validates the T148 allocation on the unedited PR2979 words, not R1 or complete supplier admission.", + "PR3021 validates R1 plus the T74 journal, not the doubled artifacts or T-dependent costs." + ], + "family_expansion_decision": { + "decision": "narrow", + "reason": "Close the explicit finite admission handoff; no additional construction search.", + "unknowns": [ + "Inherited universal block-energy lemma, all-size/compiler, backing/movement and precision/tape/analytic contracts remain conditional." + ], + "paid": [ + "All 543456 helper roles, all idle children, 91 private buffers and 133117 physical families." + ] + }, + "upstream_refresh": { + "commit": "d8e0f83f00191df62174b641e9fff055c357f641", + "priority_revision": 6, + "checked_at": "2026-10-16T19:02:24Z", + "guidance_and_selected_record_changed": false + }, + "overlap": { + "checked_at": "2026-10-16T19:02:24Z", + "open_pr_bodies": 269, + "discussion_records": 1750, + "complete_pagination": true, + "coverage_limits": "No arbitrary code diffs, unpublished work or remote closed bodies in this refresh. Local package notes and ledger were searched.", + "nearest": [ + "PR3015 provides the R1 source edit.", + "PR3021 releases R1 plus T74 packing; not T148.", + "PR3022 supplies T148 packing without R1 or complete release.", + "PR3024 attains the unedited-word cap at T740. Its active R1/admission follow-up is distinct and remains credited. This package supplies the smaller-stock T148 complete release." + ] + } +} diff --git a/research/rank7-t148-restore-release/VENDOR.json b/research/rank7-t148-restore-release/VENDOR.json new file mode 100644 index 0000000000..00cec56e9c --- /dev/null +++ b/research/rank7-t148-restore-release/VENDOR.json @@ -0,0 +1,107 @@ +[ + { + "path": "vendor/release_driver.py", + "sha256": "8dffca928c1ad1a36423b18a33a3f591af0e46bb3482e0e1cf127ddb613ef11b", + "source_commit": "217edac2ebfa6250536bd6df153de14901a69395", + "source_path": "research/rank7-restore-packing-composition/reproduce.py", + "git_blob": "f8f295f6cf377559ae59c6e40972b635b5ce2f21" + }, + { + "path": "vendor/pr3015/MANIFEST.json", + "sha256": "5e113822c0c36ee7dd9366578fbaf5daa108b8c51e37f4d10eda25dd6ed52cae", + "source_commit": "217edac2ebfa6250536bd6df153de14901a69395", + "source_path": "research/rank7-restore-packing-composition/vendor/pr3015/MANIFEST.json", + "git_blob": "a331a50f94b698f02092d4647c8be5385d9dd57c" + }, + { + "path": "vendor/pr3015/CLAIM.json", + "sha256": "f9b9fbaaac794c0ce279c238a33a2f34f8c91a34d97ccdeb5ec98b7b8ba56d73", + "source_commit": "217edac2ebfa6250536bd6df153de14901a69395", + "source_path": "research/rank7-restore-packing-composition/vendor/pr3015/CLAIM.json", + "git_blob": "70813f559e2878f0c5403c0b859eefe602f70abc" + }, + { + "path": "vendor/pr3015/PROVIDERS.json", + "sha256": "f52d926752eac5d847092dd58bfb9f3f3c6ac36adf39cd6a3c4d4a3b2d1fce15", + "source_commit": "217edac2ebfa6250536bd6df153de14901a69395", + "source_path": "research/rank7-restore-packing-composition/vendor/pr3015/allocation/PROVIDERS.json", + "git_blob": "cac6220d3dcb1d323e083d6ff04bc7bc0f00eba9" + }, + { + "path": "vendor/pr3015/FINAL-WORD-base.json.gz", + "sha256": "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5", + "source_commit": "217edac2ebfa6250536bd6df153de14901a69395", + "source_path": "research/rank7-restore-packing-composition/vendor/pr3015/edits/FINAL-WORD-base.json.gz", + "git_blob": "4f0483657396a7f735873e1b252482c53dfb2eb6" + }, + { + "path": "vendor/pr3015/FINAL-WORD-extra.json.gz", + "sha256": "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea", + "source_commit": "217edac2ebfa6250536bd6df153de14901a69395", + "source_path": "research/rank7-restore-packing-composition/vendor/pr3015/edits/FINAL-WORD-extra.json.gz", + "git_blob": "81f95e21ede115e8bdb6bd522c641b37b740bdf7" + }, + { + "path": "vendor/PR3018-EXCHANGE.json", + "sha256": "8a103f643ad12d8074972f41e4359d9487eb8b96fc6849e1a178adb61b36578b", + "source_commit": "217edac2ebfa6250536bd6df153de14901a69395", + "source_path": "research/rank7-restore-packing-composition/vendor/pr3018/EXCHANGE.json", + "git_blob": "1260c8d95f573a574e007038263adf883b5ecbd2" + }, + { + "path": "vendor/moment.py", + "sha256": "339b52eb637add91264347797d4b49cef1a412fd3843bf736cc5bb74c6bdce7c", + "source_commit": "217edac2ebfa6250536bd6df153de14901a69395", + "source_path": "research/rank7-restore-packing-composition/vendor/pr3018/moment.py", + "git_blob": "939427c5158efe99c91455a3204d62dc33ee2b2b" + }, + { + "path": "vendor/PR3021-RESULT.json", + "sha256": "cdc4874dcb17714fbe10f003a4a4516b80a9ddccfc7199278a53baa13c5d3a04", + "source_commit": "217edac2ebfa6250536bd6df153de14901a69395", + "source_path": "research/rank7-restore-packing-composition/evidence/COMPOSITION-RESULT.json", + "git_blob": "399bcc26f0684cced978e3a4c90f834551f62dd7" + }, + { + "path": "vendor/geometry.py", + "sha256": "fddefb9d4555d1b0d89766d29e6a320ccb38ba0b2a24a7df0f34a9a4545ab8f2", + "source_commit": "553dc9d8fc8c1489aa2b0378331a0de4b5e9b44e", + "source_path": "research/rank7-doubled-residual-exchange/geometry.py", + "git_blob": "c1f1771327703a307f7681c28ad02192406c7837" + }, + { + "path": "vendor/PR3022-EXCHANGE.json", + "sha256": "8f6e53068fe91885ab3121da1eeaf8ff49a5c918dcea61e07457d33701fe7ed3", + "source_commit": "553dc9d8fc8c1489aa2b0378331a0de4b5e9b44e", + "source_path": "research/rank7-doubled-residual-exchange/EXCHANGE.json", + "git_blob": "5370296a7c5b0966e40e461f37f7e4eadd94e4b4" + }, + { + "path": "vendor/PR3022-RESULT.json", + "sha256": "77780197928a9b52a6c0abce023011974692ce5cd96eca3360f9cddc16c0b2e9", + "source_commit": "553dc9d8fc8c1489aa2b0378331a0de4b5e9b44e", + "source_path": "research/rank7-doubled-residual-exchange/RESULT.json", + "git_blob": "59c0e6cc7771152961fac29acf7b79851b1f068b" + }, + { + "path": "vendor/pr3015/RELAX-CAP.json", + "sha256": "6380d23931bfcdf4bd2684dd19bb60db543f570bc88873f5effd53387beb28b0", + "source_commit": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "source_path": "research/rank7-joint-endframes-restore-edit/certificates/RELAX-CAP.json", + "git_blob": "41ec3a5f037dd64daade435a4c02468ecbdae524" + }, + { + "path": "vendor/pr3015/NOTICE", + "sha256": "ffcc3de2243815db0e9fb8d820b4ca511fce3c7673c966e14b486f05d30ac11a", + "source_commit": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "source_path": "research/rank7-joint-endframes-restore-edit/NOTICE", + "git_blob": "70a09b472e3c2d82b3e805d82ef898d3ad48e758" + }, + { + "path": "vendor/pr3015/CREDITS.md", + "sha256": "bd4b09fcd2861933883cbce6ecf0e30743d5d3b4cb0cc38e258530c370c121b9", + "source_commit": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "source_path": "research/rank7-joint-endframes-restore-edit/CREDITS.md", + "git_blob": "3b6022cd64d7753e65e1c710d91a69596e389042" + } +] diff --git a/research/rank7-t148-restore-release/VERIFY.json b/research/rank7-t148-restore-release/VERIFY.json new file mode 100644 index 0000000000..1dea96c592 --- /dev/null +++ b/research/rank7-t148-restore-release/VERIFY.json @@ -0,0 +1,33 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/rank7-joint-endframes/allocation/DISPATCH.json", + "research/rank7-joint-endframes/allocation/FILL.json.gz", + "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" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/test_verify.py" + ], + "timeout_seconds": 120, + "checks": "Thirteen positive/negative behavioral groups, including paid remainder, exact doubling control, paid-profile cap, strict gain, source drift, fixed import targets, stock/prefix increase and geometry rejection." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/verify_release.py" + ], + "timeout_seconds": 120, + "checks": "Recompute the complete finite T148+R1 invoice; check stored release/source/native/input relations and ten receipt/actual-invoice corruptions. This is not a new cold replay." + } + ] +} diff --git a/research/rank7-t148-restore-release/evidence/ADAPTER-DERIVATION.json b/research/rank7-t148-restore-release/evidence/ADAPTER-DERIVATION.json new file mode 100644 index 0000000000..6f006d0f51 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/ADAPTER-DERIVATION.json @@ -0,0 +1,147 @@ +{ + "status": "PASS_CHECKED_91_BUFFER_ADAPTER_DERIVATION_R13", + "parent_head": "51309592971e3b5be935599eed2a95404dc7781e", + "parent_manifest_sha256": "9dba3fe371602ec023a54e26c0fd66f69eb7a74be86aab89923529083c14b36f", + "source_commit": "rank7-joint-endframes-pr2917", + "source_profile": "rank7-joint-endframes", + "upstream_head": "224bd5e56041c40078ff6b5fa7393733a215de5c", + "source_manifest_sha256": "9215312229c431078ba61daf106edb8caf20b33f48317d46438a341552cf153f", + "source_files": 642, + "comparisons": { + "pr2908": { + "pr": 2908, + "head": "51309592971e3b5be935599eed2a95404dc7781e", + "sha256": "2406680a07b43a69b0f12f8462cc43f3616f3c8cb0a46bc767541b45945cd2bf" + }, + "pr2917": { + "pr": 2917, + "head": "224bd5e56041c40078ff6b5fa7393733a215de5c", + "sha256": "e6c836c0178661a53a69cd91f29d83585e876f2511ff40c6b6204cd270fbdeac" + }, + "pr2966": { + "pr": 2966, + "head": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "sha256": "4d4c4800bf3bcb36d09021313b2712aebd4aa0830c74dda30991daf6851c220a" + }, + "pr2969": { + "pr": 2969, + "head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "sha256": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77" + } + }, + "retained_receipt_sha256": "576bb9b5733f003959405d0d54625a1906f6c9f1589b321abf29c116eb73dae1", + "buffer_count": 91, + "physical_overhead": 509, + "width_classes": { + "gauge44": 6, + "extra": 6 + }, + "admission_controls": 139, + "changes": { + "prepare_extension_native.py": { + "source": "/tmp/imb-t148-full-2/run/pr2908/tools/prepare_channel_native.py", + "before_sha256": "4d207b9bbe3e0b8a86d10ad5d5f329a81da0cf56dce6c03e6fdd5b78e581ce91", + "after_sha256": "e7a407ff2d5ae2b3a285a7952dc27fc24b122c4e1ccce3e7429501b376b6e5ac", + "replacements": [ + { + "old": "SOURCE_SHA='56cf455752722051d598a7da1e5ee700637fbaef09189f534413dbe6e0525a83'", + "new": "SOURCE_SHA='9215312229c431078ba61daf106edb8caf20b33f48317d46438a341552cf153f'" + }, + { + "old": "SOURCE_FILES=610", + "new": "SOURCE_FILES=642" + }, + { + "old": "SOURCE_COMMIT='two-sided-helper408-pr2894'", + "new": "SOURCE_COMMIT='rank7-joint-endframes-pr2917'" + }, + { + "old": "OLD_RECEIPT_SHA='dd36443f2789ffa6deca7210c76ada781e2b9b7e622a546b366f51a475faff3e'", + "new": "OLD_RECEIPT_SHA='576bb9b5733f003959405d0d54625a1906f6c9f1589b321abf29c116eb73dae1'" + }, + { + "old": "len(can['zero_buffers'])==73", + "new": "len(can['zero_buffers'])==91" + } + ] + }, + "admit_extension.py": { + "source": "/tmp/imb-t148-full-2/run/pr2908/tools/admit_channel408.py", + "before_sha256": "a62c21eac4e0df502cbfb78c88b19a763fd351cde3c11c0588874f84db6992bf", + "after_sha256": "e0250e81477b2f623ef4330319bdfffbdd1efaba298430f816149bf669ba0b54", + "replacements": [ + { + "old": " 'channel408': dict(commit='two-sided-helper408-pr2894',manifest='56cf455752722051d598a7da1e5ee700637fbaef09189f534413dbe6e0525a83',helpers=408,source_file_count=610,upstream_head='18d03c447886895ef9abf888398178e0428533ca'),", + "new": " 'rank7-joint-endframes': dict(commit='rank7-joint-endframes-pr2917',manifest='9215312229c431078ba61daf106edb8caf20b33f48317d46438a341552cf153f',helpers=408,source_file_count=642,upstream_head='224bd5e56041c40078ff6b5fa7393733a215de5c')," + }, + { + "old": "COMPARISONS = {", + "new": "COMPARISONS = {\n 'pr2908': dict(pr=2908,head='51309592971e3b5be935599eed2a95404dc7781e',sha256='2406680a07b43a69b0f12f8462cc43f3616f3c8cb0a46bc767541b45945cd2bf',field='kappa'),\n 'pr2917': dict(pr=2917,head='224bd5e56041c40078ff6b5fa7393733a215de5c',sha256='e6c836c0178661a53a69cd91f29d83585e876f2511ff40c6b6204cd270fbdeac',field='kappa'),\n 'pr2966': dict(pr=2966,head='e62d3eb9005117d82a9babcfa937ecc53237c490',sha256='4d4c4800bf3bcb36d09021313b2712aebd4aa0830c74dda30991daf6851c220a',field='kappa'),\n 'pr2969': dict(pr=2969,head='e2ca469b08385d3d5e29a918d66dbefaf889e9f3',sha256='656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77',field='kappa')," + }, + { + "old": "ap.add_argument('--source-profile', choices=['channel408'], default='channel408')", + "new": "ap.add_argument('--source-profile', choices=['rank7-joint-endframes'], default='rank7-joint-endframes')" + }, + { + "old": "ap.add_argument('--comparison-profile', choices=['pr2894'], default='pr2894')", + "new": "ap.add_argument('--comparison-profile', choices=['pr2908','pr2917','pr2966','pr2969'], default='pr2908')" + }, + { + "old": "zero_buffers_allocated_and_cleared=73", + "new": "zero_buffers_allocated_and_cleared=91" + }, + { + "old": "len(c.get('zero_buffers',[]))==73, 'helper408 physical ABI including all 73 private buffers'", + "new": "len(c.get('zero_buffers',[]))==91, 'paired extension physical ABI including all 91 private buffers'" + }, + { + "old": "896*T+expected_helpers+8+73+2, 'complete physical cost including all actual helpers and 73 buffers'", + "new": "896*T+expected_helpers+8+91+2, 'complete physical cost including all actual helpers and 91 buffers'" + }, + { + "old": "\"len(rd(work/'ADMISSION-CONTROLS.json')['rejected_controls'])==119\")", + "new": "\"len(rd(work/'ADMISSION-CONTROLS.json')['rejected_controls'])==139\")" + }, + { + "old": "\"controls=dict(admission=119,", + "new": "\"controls=dict(admission=139," + } + ] + }, + "extension_blocknorm.py": { + "source": "/tmp/imb-t148-full-2/run/pr2908/tools/channel_blocknorm.py", + "before_sha256": "b53ebd53e3948f658c6da4f487a9ea10c9cb0a6acf2435750a32d6efeb9869c0", + "after_sha256": "6e6b8683cc87a84e5410c399b1128eb68694f852a3927cb124067f503ed7d7c7", + "replacements": [ + { + "old": "len(allocated)==73, 'all73 private zero buffers released'", + "new": "len(allocated)==91, 'all91 private zero buffers released'" + }, + { + "old": "'zero_buffers_allocated_and_cleared':73", + "new": "'zero_buffers_allocated_and_cleared':91" + }, + { + "old": "r['zero_buffers_returned_to_zero']==73", + "new": "r['zero_buffers_returned_to_zero']==91" + }, + { + "old": "physical==live+8+408+73+2", + "new": "physical==live+8+408+91+2" + }, + { + "old": "'zero_buffers':[live+416,live+489], 'coefficient':[live+489,live+491]", + "new": "'zero_buffers':[live+416,live+507], 'coefficient':[live+507,live+509]" + }, + { + "old": "len(mp)==73 and set(mp.values())==set(range(*ns['zero_buffers'])), '73distinct private Z slots'", + "new": "len(mp)==91 and set(mp.values())==set(range(*ns['zero_buffers'])), '91distinct private Z slots'" + }, + { + "old": "T=len(order)//9; live=896*T; physical=live+490", + "new": "T=len(order)//9; live=896*T; physical=live+509" + } + ] + } + } +} diff --git a/research/rank7-t148-restore-release/evidence/ADMISSION-RESULT.json b/research/rank7-t148-restore-release/evidence/ADMISSION-RESULT.json new file mode 100644 index 0000000000..e859168f5c --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/ADMISSION-RESULT.json @@ -0,0 +1,383 @@ +{ + "actual_expected_helpers": 408, + "comparison_claim_sha256": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77", + "comparison_head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "comparison_kappa": "17240352247481048785499999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "comparison_pr": 2969, + "complex_lower": "34583046742859167313/20000000000000000000000", + "dispatch_sha256": "3690b221024a87348025bcfcc6bc2c4cf508e3dfa119b422ef036e7052fe46c2", + "external_input_sha256": { + "/tmp/imb-t148-full-2/DISPATCH.json": "3690b221024a87348025bcfcc6bc2c4cf508e3dfa119b422ef036e7052fe46c2", + "/tmp/imb-t148-full-2/FILL.json.gz": "82d4fe9be5f5f74c72a36291f19fda8737039e1b6d9df4458a297673a841e466", + "/tmp/imb-t148-full-2/ORDER.json": "caef6c8ddc25d057c0fd16bff771651366641774939fd6352ca70cdf5f0d68ea", + "/tmp/imb-t148-full-2/run/adapters/extension_blocknorm.py": "6e6b8683cc87a84e5410c399b1128eb68694f852a3927cb124067f503ed7d7c7", + "/tmp/imb-t148-full-2/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839/lift_parent.py": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "/tmp/imb-t148-full-2/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839/reconstruct_replica.py": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "/tmp/imb-t148-full-2/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839/replica_parent.py": "48bdbf28f59d80edb266803ec61bf5e22e8fb5e5a0e2b88004b6039147589bd4", + "/tmp/imb-t148-full-2/run/pr2969/CLAIM.json": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77" + }, + "fill_sha256": "82d4fe9be5f5f74c72a36291f19fda8737039e1b6d9df4458a297673a841e466", + "gain": "51171123948534871/10000000000000000000000", + "kappa": "17291523371429583656499999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017291523371429583656499999999999999999999998999999999999999999999999", + "native_receipt_sha256": "9f053b09b3184b952450c5a9a61077ef0732c7c180be60a7fde82eeaec0c1bab", + "order_sha256": "caef6c8ddc25d057c0fd16bff771651366641774939fd6352ca70cdf5f0d68ea", + "package_manifest_sha256": "e49030aac2e718747d62198b28d24f722d4bc730b87864378f6f714bad0bcc2b", + "patches": [ + { + "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "path": "new/rebind.py", + "replacements": [ + [ + "physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))" + ] + ] + }, + { + "after_sha256": "99bef04f24a99088e5c0c9b8f6bbc8386669d8315b8f572d6bbfb932c5d51145", + "before_sha256": "7edb4732b34e5814b27650a55c938626cb50d68f06397744dd4fe451437e90e0", + "path": "geometry_controls.py", + "replacements": [ + [ + " i['complete_invocation_sweeps']=i['bridge_sweeps']=333", + " i['complete_invocation_sweeps']-=1;i['bridge_sweeps']-=1" + ], + [ + " o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);oh=digest(o);i['owner_audit_sha256']=oh", + " o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);assert (o,i)!=(owner,invoice), 'geometry mutant must change actual receipts';oh=digest(o);i['owner_audit_sha256']=oh" + ] + ] + }, + { + "after_sha256": "6cfefe80c02a6c0f243f50ca9e146e1ab1440b84a033d8a71d42be5a5fa27f6b", + "before_sha256": "c43680a2da390f79925547a5ee1919d8a76637cccf98e2c8164b6f667fbc3183", + "path": "verify_release.py", + "replacements": [ + [ + "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)", + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))" + ], + [ + "epsilon=1-(1025/1024)e-3080", + "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}" + ], + [ + "at the one 3000-digit rejection call", + "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call" + ] + ] + }, + { + "after_sha256": "1dd56009986eb14dd6603c9193c7ad71dd45c7d005bf71c9cd3f916e66f54d98", + "before_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "path": "outer/check_ledger.py", + "replacements": [ + [ + "assert (m,W)==(73,66304)", + "T=spec['geometry']['replicas']\nassert type(T) is int and T>0\nassert m==73 and W==896*T and W==BJ['live']" + ] + ] + }, + { + "after_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "before_sha256": "08ca58abff11bdfba721dc56ab8acf06ec1b7c48a8699a0955cf35324680aca7", + "path": "code/witness.py", + "replacements": [ + [ + " with open(os.environ['WITNESS_RECORD'],'a')as f:f.write(json.dumps([key,got],default=str)+chr(10))", + " import time as _wr_time\n _wr_path=Path(os.environ['WITNESS_RECORD'])\n _wr_lock=_wr_path.with_name(_wr_path.name+'.append.lock')\n _wr_deadline=_wr_time.monotonic()+60\n _wr_fd=None\n while _wr_fd is None:\n try:_wr_fd=os.open(_wr_lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY)\n except FileExistsError:\n if _wr_time.monotonic()>=_wr_deadline:raise TimeoutError('discovery record lock timeout; existing lock preserved')\n _wr_time.sleep(.005)\n try:\n with _wr_path.open('a',encoding='utf-8',newline='\\n')as _wr_out:\n _wr_out.write(json.dumps([key,got],default=str)+chr(10))\n _wr_out.flush()\n finally:\n os.close(_wr_fd)\n _wr_lock.unlink()" + ] + ] + }, + { + "after_sha256": "2964ea185a64061d72e4a6c648a48cd0ddbfc7ea8174ecb39be2a2eee52a3be8", + "before_sha256": "8dee5aa1663a70edcf1099a30b72166d89c29fa29ba2025fb5707fdbcc237f83", + "path": "verify.py", + "replacements": [ + [ + "run('lift-parent',P/'lift_parent.py','--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')", + "run('lift-parent',P/'lift_parent.py','--package',P,'--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')" + ] + ] + }, + { + "after_sha256": "0d8cc021d2401d047aaec79060ec2ea28ba06f12eca8dbf4c60c78bb31975c4e", + "before_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "path": "code/witness.py", + "replacements": [ + [ + "PAYLOAD==1<<(192+(GEO['dimension']+1)//2+2*CALLS+4).bit_length()", + "PAYLOAD==1<<(128+(GEO['dimension']+1)//2+18+1330+1+4).bit_length()" + ] + ] + }, + { + "after_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "before_sha256": "bb213d0af12218ff7c9c572717e522d8bbeeb2856b87a253f4a7f44e0fd71f15", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " required_prefix=localbits+input_l2_bits+call_count+bridge_sweeps+4", + " from blocknorm_certificate import certify\n blocknorm=certify(template, {pid:base/'providers'/pid for pid in template['local_providers']})\n assert blocknorm['status'] == 'PASS_TENSOR_BLOCK_NORM_CERTIFICATE'\n assert localbits <= 128, 'actual native scalar/Horner prefix exceeds charged local reserve'\n required_prefix=localbits+input_l2_bits+blocknorm['max_active_depth']+blocknorm['stock_l2_bits']+1+4" + ] + ] + }, + { + "after_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "before_sha256": "02502a217fe8c9e10229075b50745518beac512c48db20e64c3e06514a4da5b5", + "path": "independent_core.py", + "replacements": [ + [ + " payload = 1 << (192 + (M+1)//2 + 2*len(c['order']) + 4).bit_length()", + " require(localbits <= 128, 'measured native prefix exceeds local reserve')\n payload = 1 << (128 + (M+1)//2 + 18 + 1330 + 1 + 4).bit_length()" + ] + ] + }, + { + "after_sha256": "d598a2ac1e2e8eaee14a8c285e0277a7ae44ca6a15bd2b5cfc67fb40844fb387", + "before_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,", + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,blocknorm=blocknorm," + ], + [ + " primitive_arithmetic_margin_bits=4,controller_audit_sha256=", + " tensor_block_norm=blocknorm,partial_cover_margin_bits=1,physical_stock_l2_bits=blocknorm['stock_l2_bits'],primitive_arithmetic_margin_bits=4,controller_audit_sha256=" + ], + [ + "Sum every actual invocation and bridge sweep and take the maximum local scalar/Horner prefix over both orientations of the fixed provider.", + "All invocations and bridge sweeps remain charged. Bound completed-boundary energy by at most eighteen active steps per owner replica, using exact tensor-isomorphic whole-family helper unitaries. Add the full group-indexed physical-stock sup-to-l2 factor and one partial-cover margin, then the maximum local scalar/Horner prefix." + ] + ] + }, + { + "after_sha256": "e051aaa166e01263780d5ae03699690670b597fed6593af4c37a7e978825eb85", + "before_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "path": "independent_core.py", + "replacements": [ + [ + " prefix = localbits + (M + 1) // 2 + len(c['order']) + c['bridges'] + 4", + " bn=c['blocknorm']\n require(bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['max_active_depth']==18 and bn['stock_l2_bits']<=1330, 'independent tensor block certificate')\n prefix = localbits + (M + 1) // 2 + bn['max_active_depth'] + bn['stock_l2_bits'] + 1 + 4" + ], + [ + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], margin=4)", + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], active_block_depth=18,stock_l2=bn['stock_l2_bits'],partial_cover=1,margin=4),blocknorm=bn" + ] + ] + }, + { + "after_sha256": "393323f150d0bb686419804d51cf43d0f58450d2a1e7929725acdd26fdbb3640", + "before_sha256": "2286f00e462ff28abbb3f396095463482a1e063213b9526a7225275980c77eaf", + "path": "audit_mixed.py", + "replacements": [ + [ + "pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)", + "import blocknorm_certificate as BN;ctx['blocknorm']=BN.certify_context(ctx,roles,dirs,source_parent=parent);pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)" + ] + ] + }, + { + "after_sha256": "0542dde915af8902324db2f59136da078d5256bfaa8f1510f3e59336be7e2680", + "before_sha256": "f25e1e870df5d5a16a1e367b3df8843cb01644ab4b75895d7939af81e4fcb833", + "path": "code/assemble.py", + "replacements": [ + [ + " assert invoice['global_prefix_bits']==max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())+37+CALLS+CALLS+4", + " bn=invoice['blocknorm']\n assert bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['replicas']==REPLICAS\n assert bn['max_active_depth']==bn['boundary_depth_bits']==18 and bn['active_calls_per_block']==bn['bridges_per_block']==9\n assert bn['block_width_families']==896 and bn['physical_families']==invoice['physical'] and bn['live_families']==invoice['live']\n assert bn['partial_cover_bits']==1 and bn['input_l2_bits']==37 and bn['local_reserve_bits']==128 and bn['retained_payload_bits']==PAYLOAD\n localbits=max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())\n assert bn['local_actual_prefix_bits']==localbits and localbits<=128\n assert invoice['global_prefix_bits']==bn['actual_prefix_bits']==localbits+37+18+bn['stock_l2_bits']+1+4\n assert bn['required_reserve_bits']==128+37+18+bn['stock_l2_bits']+1+4sb=`Aj_IQL2 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 literal 0 HcmV?d00001 diff --git a/research/rank7-t148-restore-release/evidence/RECIPE.json b/research/rank7-t148-restore-release/evidence/RECIPE.json new file mode 100644 index 0000000000..c51562f820 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/RECIPE.json @@ -0,0 +1,237 @@ +{ + "changes": [ + { + "argument": "--fill", + "new": "/tmp/imb-t148-full-2/FILL.json.gz", + "old": "/tmp/imb-t148-full-2/pr3015/allocation/FILL.json.gz", + "stage": "complete-admission" + }, + { + "argument": "--order", + "new": "/tmp/imb-t148-full-2/ORDER.json", + "old": "/tmp/imb-t148-full-2/pr3015/allocation/ORDER.json", + "stage": "complete-admission" + }, + { + "argument": "--dispatch", + "new": "/tmp/imb-t148-full-2/DISPATCH.json", + "old": "/tmp/imb-t148-full-2/pr3015/allocation/DISPATCH.json", + "stage": "complete-admission" + } + ], + "commands": [ + [ + "export-pr2894", + [ + "/home/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/tmp/imb-t148-full-2/run/pr2908/reproduce.py", + "--repo", + "/home/nick/git/imb-t148-composition", + "--work", + "/tmp/imb-t148-full-2/run/parent-export", + "--dry-run" + ] + ], + [ + "export-pr2833", + [ + "/home/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/tmp/imb-t148-full-2/run/parent-export/pr2894/tools/materialize_source.py", + "--repo", + "/home/nick/git/imb-t148-composition", + "--out", + "/tmp/imb-t148-full-2/run/pr2833" + ] + ], + [ + "fresh-retained-bootstrap", + [ + "/home/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/tmp/imb-t148-full-2/run/parent-export/pr2894/tools/prepare_retained.py", + "--source", + "/tmp/imb-t148-full-2/run/pr2833", + "--out", + "/tmp/imb-t148-full-2/run/retained", + "--jobs", + "1" + ] + ], + [ + "four-kernel-stage", + [ + "/home/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/tmp/imb-t148-full-2/run/parent-export/pr2894/vendor/pr2857/build_overlay.py", + "--source", + "/tmp/imb-t148-full-2/run/pr2833", + "--generator", + "/tmp/imb-t148-full-2/run/parent-export/pr2894/vendor/pr2857/shared_kernel.py", + "--review", + "/tmp/imb-t148-full-2/run/parent-export/pr2894/vendor/pr2857/review_four_groups.py", + "--candidate-dir", + "/tmp/imb-t148-full-2/run/parent-export/pr2894/vendor/pr2857/words", + "--out", + "/tmp/imb-t148-full-2/run/source4" + ] + ], + [ + "preload-stage", + [ + "/home/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/tmp/imb-t148-full-2/run/parent-export/pr2894/vendor/pm/build_pm_overlay.py", + "--overlay", + "/tmp/imb-t148-full-2/run/source4", + "--pm-dir", + "/tmp/imb-t148-full-2/run/parent-export/pr2894/vendor/pm", + "--out", + "/tmp/imb-t148-full-2/run/source-pm" + ] + ], + [ + "parent-paired-stage", + [ + "/home/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/tmp/imb-t148-full-2/run/pr2908/tools/build_channel_overlay.py", + "--source", + "/tmp/imb-t148-full-2/run/source-pm", + "--local-package", + "/tmp/imb-t148-full-2/run/pr2908", + "--out", + "/tmp/imb-t148-full-2/run/source2908" + ] + ], + [ + "paired-extension-stage", + [ + "/home/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/tmp/imb-t148-full-2/run/pr2917/tools/build_extension.py", + "--source", + "/tmp/imb-t148-full-2/run/source2908", + "--local-package", + "/tmp/imb-t148-full-2/run/pr2917", + "--out", + "/tmp/imb-t148-full-2/run/source" + ] + ], + [ + "rank7-overlay-stage", + [ + "/home/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/tmp/imb-t148-full-2/pr3015/tools/build_overlay.py", + "--source", + "/tmp/imb-t148-full-2/run/source", + "--candidate-dir", + "/tmp/imb-t148-full-2/run/candidate-words", + "--out", + "/tmp/imb-t148-full-2/run/source-rank7", + "--stage-name", + "rank7-joint-endframes" + ] + ], + [ + "declared-edit-stage", + [ + "/home/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/tmp/imb-t148-full-2/pr3015/tools/build_edits.py", + "--source", + "/tmp/imb-t148-full-2/run/source-rank7", + "--local-package", + "/tmp/imb-t148-full-2/pr3015", + "--out", + "/tmp/imb-t148-full-2/run/source-edits" + ] + ], + [ + "derive-closed-adapters", + [ + "/home/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/tmp/imb-t148-full-2/pr3015/tools/derive_adapters.py", + "--parent-package", + "/tmp/imb-t148-full-2/run/pr2908", + "--source", + "/tmp/imb-t148-full-2/run/source-edits", + "--retained-receipt", + "/tmp/imb-t148-full-2/run/retained/NATIVE-RECEIPT.json", + "--out", + "/tmp/imb-t148-full-2/run/adapters", + "--buffers", + "91", + "--source-commit", + "rank7-joint-endframes-pr2917", + "--source-profile", + "rank7-joint-endframes", + "--upstream-head", + "224bd5e56041c40078ff6b5fa7393733a215de5c", + "--comparison", + "pr2917=/tmp/imb-t148-full-2/run/pr2917/CLAIM.json", + "--comparison", + "pr2966=/tmp/imb-t148-full-2/run/pr2966/CLAIM.json", + "--comparison", + "pr2969=/tmp/imb-t148-full-2/run/pr2969/CLAIM.json" + ] + ], + [ + "fresh-current-native", + [ + "/home/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/tmp/imb-t148-full-2/run/adapters/prepare_extension_native.py", + "--source", + "/tmp/imb-t148-full-2/run/source-edits", + "--retained-cache", + "/tmp/imb-t148-full-2/run/retained/native-cache", + "--retained-receipt", + "/tmp/imb-t148-full-2/run/retained/NATIVE-RECEIPT.json", + "--out", + "/tmp/imb-t148-full-2/run/native", + "--jobs", + "1" + ] + ], + [ + "complete-admission", + [ + "/home/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/tmp/imb-t148-full-2/run/adapters/admit_extension.py", + "--source", + "/tmp/imb-t148-full-2/run/source-edits", + "--fill", + "/tmp/imb-t148-full-2/FILL.json.gz", + "--order", + "/tmp/imb-t148-full-2/ORDER.json", + "--dispatch", + "/tmp/imb-t148-full-2/DISPATCH.json", + "--native-cache", + "/tmp/imb-t148-full-2/run/native/native-cache", + "--native-receipt", + "/tmp/imb-t148-full-2/run/native/NATIVE-RECEIPT.json", + "--work", + "/tmp/imb-t148-full-2/run/candidate", + "--replica-helper-dir", + "/tmp/imb-t148-full-2/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839", + "--reconstructor", + "/tmp/imb-t148-full-2/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839/reconstruct_replica.py", + "--blocknorm-checker", + "/tmp/imb-t148-full-2/run/adapters/extension_blocknorm.py", + "--comparison-claim", + "/tmp/imb-t148-full-2/run/pr2969/CLAIM.json", + "--source-profile", + "rank7-joint-endframes", + "--comparison-profile", + "pr2969", + "--jobs", + "1" + ] + ] + ] +} diff --git a/research/rank7-t148-restore-release/evidence/RELEASE-RECEIPT.json b/research/rank7-t148-restore-release/evidence/RELEASE-RECEIPT.json new file mode 100644 index 0000000000..f5ead542ad --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/RELEASE-RECEIPT.json @@ -0,0 +1,7 @@ +{ + "status": "PASS_RELEASE", + "kappa_decimal": "0.0017291523371429583656499999999999999999999998999999999999999999999999", + "manifest_sha256": "e49030aac2e718747d62198b28d24f722d4bc730b87864378f6f714bad0bcc2b", + "proof": "Supplier: the package's own unchanged `verify.py` (retained PR1297 provider and parent admission, owner reconstruction, parent lift, strict T74 admission, geometry controls): `PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION`, native reuse {'base': 'e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e', 'extra': '7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905'}; its complex endpoint 34583046742859167313/200000000... brackets the ledger's b = 172915233714295836564999999999999999999999999999999999999999999999999999999999999999999999999999999999/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000. Outer (PR1673 capped phase-cell fusion): regenerated exact ledger (63 strict inequalities: the 62 retained rows plus the explicit main-binding row gaussian_above_main, the fixed-grid maximum kappa = C - 1/F - B asserted, 17 rejecting controls incl. the old g-factor union row, the old linear and old-theta chirp guards, the old 2*beta tag test, epsilon at 1 or at the r0 slack and beta outside its window, larger endpoint rejected by the native moment), independent balance derivation, the exact union-schedule simulation, the (retained, not used for kappa) structured-boundary displacement-rank check, the gauge-free identity/symbol/circuit checks, PR1786's finite prime/underflow controls and 19 exact evidence replays all pass. Conditional kappa 0.0017291523371429583656499999999999999999999998999999999999999999999999 (union schedule outer/UNION-SCHEDULE.md; explicit Strassen boundary tau=45/16 (the structured boundary of outer/STRUCTURED-BOUNDARY.md is not used); gauge-free interiors outer/GAUGEFREE-INTERIORS.md; fine source-prime padding PR1786 at the free point epsilon=1-(1025/1024)e-104, outer/FINE-PADDING-COMPOSITION.md; fixed-grid maximum of PR2180/PR2161 (dataisfire), outer/PROOF-GRID-MAX.md; exact-integer coarse exponential PR2168/PR2184 (dataisfire) at the one 24-digit rejection call).", + "seconds": 535.71 +} diff --git a/research/rank7-t148-restore-release/evidence/RESULT.json b/research/rank7-t148-restore-release/evidence/RESULT.json new file mode 100644 index 0000000000..e9b5bbe251 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/RESULT.json @@ -0,0 +1,117 @@ +{ + "admission_result_sha256": "c0c4273e72f439cd61c8b9a17f40f0183433b19e6984c8ac82c7efbddbe65d03", + "comparison_kappa": "17291512039830184429979999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "dispatch_sha256": "3690b221024a87348025bcfcc6bc2c4cf508e3dfa119b422ef036e7052fe46c2", + "fill_payload_sha256": "ae2a7e5f3e0842a831f72f2510760e2c5d9f09a5a77232faeffe8aa645804d64", + "fill_sha256": "82d4fe9be5f5f74c72a36291f19fda8737039e1b6d9df4458a297673a841e466", + "fresh_retained_bootstrap": true, + "gain": "283289984980663/250000000000000000000000", + "invoice_payload_sha256": "443a0c77099f85e31b74998b3f60aed951958f6a2e396145cae6f07fb4d0fcbb", + "kappa": "17291523371429583656499999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "native_receipt_sha256": "9f053b09b3184b952450c5a9a61077ef0732c7c180be60a7fde82eeaec0c1bab", + "order_sha256": "caef6c8ddc25d057c0fd16bff771651366641774939fd6352ca70cdf5f0d68ea", + "profile": { + "1": 3288708, + "2": 941724, + "3": 318948, + "4": 143856, + "5": 27416, + "8": 10656, + "32": 1, + "48": 56380 + }, + "release_receipt_sha256": "279bcccd3644b08ce13ee9f5ae8040ad836a5765c23a4898b42b0a6bcec2255a", + "replicas": 148, + "scope": "Conditional finite release; universal inherited hypotheses remain.", + "stages": [ + { + "exit_code": 0, + "log_sha256": "33398f425eb773647292f653df20b6bec51ab4a6ea56e9a3ee71a47978deef98", + "seconds": 1.0162173119970248, + "stage": "source-preflight" + }, + { + "exit_code": 0, + "log_sha256": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "seconds": 0.3147803940009908, + "stage": "export-pr2894" + }, + { + "exit_code": 0, + "log_sha256": "8d8ca31360aaba9440d9555bcd2f69293f186d3e2e505bf3af35b67a29046fd5", + "seconds": 0.7657782710011816, + "stage": "export-pr2833" + }, + { + "exit_code": 0, + "log_sha256": "4a1625fdd9a947187583e67492c492f309e28669082f2e6f2aa97b5da345ea29", + "seconds": 553.7218391360002, + "stage": "fresh-retained-bootstrap" + }, + { + "exit_code": 0, + "log_sha256": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "seconds": 0.9667071450021467, + "stage": "four-kernel-stage" + }, + { + "exit_code": 0, + "log_sha256": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "seconds": 0.9160308549980982, + "stage": "preload-stage" + }, + { + "exit_code": 0, + "log_sha256": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "seconds": 0.5653925189981237, + "stage": "parent-paired-stage" + }, + { + "exit_code": 0, + "log_sha256": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "seconds": 0.5655126950005069, + "stage": "paired-extension-stage" + }, + { + "exit_code": 0, + "log_sha256": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "seconds": 1.1166025990023627, + "stage": "rank7-overlay-stage" + }, + { + "exit_code": 0, + "log_sha256": "3ad47363c45012cd4f09aee995e551a314b89da7fb70310cabc437cf78957097", + "seconds": 0.6655931729983422, + "stage": "declared-edit-stage" + }, + { + "exit_code": 0, + "log_sha256": "ee4dbc4d3602d2f45ebca2ffadae889ff0bb2497e2a576530126858f6eca4bd2", + "seconds": 0.264596528999391, + "stage": "derive-closed-adapters" + }, + { + "exit_code": 0, + "log_sha256": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "seconds": 130.43893533899973, + "stage": "fresh-current-native" + }, + { + "exit_code": 0, + "log_sha256": "284191bb321ec8a14e2fd25d0d522e76957828ec50313ff374dba636ce65f762", + "seconds": 803.5288017000057, + "stage": "complete-admission" + } + ], + "status": "PASS_T148_R1_COMPLETE_RELEASE", + "stock": { + "active_depth": 18, + "bridges": 1332, + "calls": 1332, + "physical": 133117, + "physical_stock_bits": 2645, + "required_reserve_bits": 1511, + "retained_payload_bits": 2048, + "stock_l2_bits": 1323 + } +} diff --git a/research/rank7-t148-restore-release/evidence/VALIDATION.json b/research/rank7-t148-restore-release/evidence/VALIDATION.json new file mode 100644 index 0000000000..654a1223b4 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/VALIDATION.json @@ -0,0 +1,28 @@ +{ + "checked_at": "2026-10-16T19:06:04.400284+00:00", + "full_replay": "/tmp/imb-t148-full-2", + "full_stage_seconds": 1494.8467876670038, + "full_status": "PASS_T148_R1_COMPLETE_RELEASE", + "final_postchecks": "Current reproduce.check_release rerun against completed source trees, native and full-release receipts, exact payload/order/dispatch and actual strict invoice. Same endpoint as initial wrapper.", + "recipe_equivalence": "Current --dry-run at /tmp/imb-t148-final-preflight exactly matches the executed RECIPE after normalizing the fresh workspace path. Added cap/payload/invoice postchecks do not change the scientific recipe.", + "initial_preflight": "The first attempt lacked historical Git object 18d03c447886895ef9abf888398178e0428533ca and stopped before mathematics. Fetching that exact public object resolved it. The failed workspace was preserved.", + "finite_checks": [ + "13 positive/negative behavioral tests", + "10 stored-receipt and actual-prefix-invoice corruptions rejected", + "Python 3.12 ordinary/optimized and Python 3.13 finite JSON equality", + "Python 3.12 -W error", + "Ruff E4,E7,E9,F,I,B,UP" + ], + "review": "Local mathematical-boundary and source inspection; no independent human, subagent or formal-kernel review.", + "code_sha256": { + "verify.py": "5b28450721edc925d274a88bb597bdf5814f1ae7e2c009106fccc2daa91b7ccc", + "reproduce.py": "dc234b5f5e7af0e11f88d3836346e6d33dad2f1b3021c89b9a311e3511df9ba0", + "test_verify.py": "7145eb8716a831b36552222fb0a85fe1791fa896963f0417cc27bced41bbd14d", + "verify_release.py": "e1454b3e03cf1f09ea386e75a9913b5d8906b9e50e7c8938e2db9eae5b126994" + }, + "limitations": [ + "Registered replay recomputes the finite proof and checks stored full-release relations, not a new cold replay.", + "Inherited all-size/compiler, physical, precision/tape, analytic and universal block-energy hypotheses remain.", + "Hosted CI and maintainer review are separate." + ] +} diff --git a/research/rank7-t148-restore-release/evidence/VERIFY-RESULT.json b/research/rank7-t148-restore-release/evidence/VERIFY-RESULT.json new file mode 100644 index 0000000000..3720b63d0d --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/VERIFY-RESULT.json @@ -0,0 +1,128 @@ +{ + "status": "PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION", + "kappa": "1726167530523253/1000000000000000000", + "kappa_decimal": "0.001726167530523253", + "manifest_sha256": "e49030aac2e718747d62198b28d24f722d4bc730b87864378f6f714bad0bcc2b", + "native_reuse": { + "base": true, + "extra": true + }, + "provider_verification": "PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION", + "roles": 543456, + "prefix_bits": 1476, + "charged_prefix_bits": 2048, + "physical_row_coefficient": 19547, + "row_limit": 20161, + "controls": { + "admission": 139, + "bit": 12, + "controller": 15, + "independent_owner": 8, + "geometry": 6 + }, + "stages": [ + { + "name": "fine-engine-oracle", + "exit_code": 0, + "seconds": 1.3681398409971735, + "log_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3" + }, + { + "name": "retained-provider-and-parent-admission", + "reused_receipt": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "exit_code": 0, + "seconds": 0.3504967460030457 + }, + { + "name": "rebuild-words-566", + "exit_code": 0, + "seconds": 2.670659148003324, + "log_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f" + }, + { + "name": "reconstruct-owners", + "exit_code": 0, + "seconds": 10.553042218001792, + "log_sha256": "cf3e1b97ca90d454e7d659bdf686ab81e74718bb8d6935d4b6d194422f6124ac" + }, + { + "name": "lift-parent", + "exit_code": 0, + "seconds": 24.009936119000486, + "log_sha256": "effc12a113b4c4c0b08aeaa86cc0a67030271a6cbfd76b0b6906dcfce3dd11c6" + }, + { + "name": "rebuild-borrow-words", + "exit_code": 0, + "seconds": 189.45981907699752, + "log_sha256": "5db6d40e7b6cd9910fbec065df7594d4d6034cd14bafb64edd11dfab241a165f" + }, + { + "name": "shared-kernel-independent-review", + "exit_code": 0, + "seconds": 11.484602667995205, + "log_sha256": "3dc6eb8940cf8a4b993f80129c98b6c4846ad346ccf773a78af225cff3339cc3" + }, + { + "name": "preload-move-independent-review", + "exit_code": 0, + "seconds": 14.55188956400525, + "log_sha256": "c456d3e39c09e960ceebf80251d5e808fa9299991471fd86f4093d9bc4dd3eda" + }, + { + "name": "two-sided-helper408-review", + "exit_code": 0, + "seconds": 5.312296310003148, + "log_sha256": "e2d126de63448f7d1e89e16d958fcd3d16bf477902246ef8e3ae489d6da13ab8" + }, + { + "name": "paired-extension-review", + "exit_code": 0, + "seconds": 29.847781865995785, + "log_sha256": "63cc4d58a128293544cb62aa41c13ee02b3a365060db6c7d680d6a4cea4b64d2" + }, + { + "name": "declared-edit-review", + "exit_code": 0, + "seconds": 9.61299928999506, + "log_sha256": "d64bc6efeac8a0eece37f05061591f37145d94893151cc893023ec989951082d" + }, + { + "name": "audit-local-566-base", + "exit_code": 0, + "seconds": 1.0189615470007993, + "log_sha256": "f090f6136d908e03ebdb96eaf9ecaae6b7cf8e6005e7b1cd75246d1b2bc36278" + }, + { + "name": "audit-local-566-extra", + "exit_code": 0, + "seconds": 0.9754864530041232, + "log_sha256": "dd9f733cc8028b7d505975e1300232a1f16fba0536ecca2fa4f13adb7b8b4bc6" + }, + { + "name": "rebind-566", + "exit_code": 0, + "seconds": 2.202464219000831, + "log_sha256": "cd2d6adc0522adceb674f80578947944e5ac1e65bf6b73b6f43ae89cb7322f31" + }, + { + "name": "lemmag-labels", + "exit_code": 0, + "seconds": 29.352078144002007, + "log_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469" + }, + { + "name": "strict-t74", + "exit_code": 0, + "seconds": 234.87765523000417, + "log_sha256": "863c3c3e7b8c8101f448567d926cc8a110fc75c3d7d23545f4ed72a28052f233" + }, + { + "name": "geometry-controls", + "exit_code": 0, + "seconds": 0.5600305250045494, + "log_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9" + } + ], + "scope": "Conditional finite construction only. All-size compiler, common-label/mutable-source realization, whole-call hosting, precision/tape, exact recovery, analytic transfer, PR559 recurrence correction and PR589 bit H1-H5 assumptions remain. No unconditional theorem, full Lean certification, or global packing claim." +} diff --git a/research/rank7-t148-restore-release/evidence/VERIFY-STAGES.json b/research/rank7-t148-restore-release/evidence/VERIFY-STAGES.json new file mode 100644 index 0000000000..ebb06169b4 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/VERIFY-STAGES.json @@ -0,0 +1,104 @@ +[ + { + "name": "fine-engine-oracle", + "exit_code": 0, + "seconds": 1.3681398409971735, + "log_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3" + }, + { + "name": "retained-provider-and-parent-admission", + "reused_receipt": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "exit_code": 0, + "seconds": 0.3504967460030457 + }, + { + "name": "rebuild-words-566", + "exit_code": 0, + "seconds": 2.670659148003324, + "log_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f" + }, + { + "name": "reconstruct-owners", + "exit_code": 0, + "seconds": 10.553042218001792, + "log_sha256": "cf3e1b97ca90d454e7d659bdf686ab81e74718bb8d6935d4b6d194422f6124ac" + }, + { + "name": "lift-parent", + "exit_code": 0, + "seconds": 24.009936119000486, + "log_sha256": "effc12a113b4c4c0b08aeaa86cc0a67030271a6cbfd76b0b6906dcfce3dd11c6" + }, + { + "name": "rebuild-borrow-words", + "exit_code": 0, + "seconds": 189.45981907699752, + "log_sha256": "5db6d40e7b6cd9910fbec065df7594d4d6034cd14bafb64edd11dfab241a165f" + }, + { + "name": "shared-kernel-independent-review", + "exit_code": 0, + "seconds": 11.484602667995205, + "log_sha256": "3dc6eb8940cf8a4b993f80129c98b6c4846ad346ccf773a78af225cff3339cc3" + }, + { + "name": "preload-move-independent-review", + "exit_code": 0, + "seconds": 14.55188956400525, + "log_sha256": "c456d3e39c09e960ceebf80251d5e808fa9299991471fd86f4093d9bc4dd3eda" + }, + { + "name": "two-sided-helper408-review", + "exit_code": 0, + "seconds": 5.312296310003148, + "log_sha256": "e2d126de63448f7d1e89e16d958fcd3d16bf477902246ef8e3ae489d6da13ab8" + }, + { + "name": "paired-extension-review", + "exit_code": 0, + "seconds": 29.847781865995785, + "log_sha256": "63cc4d58a128293544cb62aa41c13ee02b3a365060db6c7d680d6a4cea4b64d2" + }, + { + "name": "declared-edit-review", + "exit_code": 0, + "seconds": 9.61299928999506, + "log_sha256": "d64bc6efeac8a0eece37f05061591f37145d94893151cc893023ec989951082d" + }, + { + "name": "audit-local-566-base", + "exit_code": 0, + "seconds": 1.0189615470007993, + "log_sha256": "f090f6136d908e03ebdb96eaf9ecaae6b7cf8e6005e7b1cd75246d1b2bc36278" + }, + { + "name": "audit-local-566-extra", + "exit_code": 0, + "seconds": 0.9754864530041232, + "log_sha256": "dd9f733cc8028b7d505975e1300232a1f16fba0536ecca2fa4f13adb7b8b4bc6" + }, + { + "name": "rebind-566", + "exit_code": 0, + "seconds": 2.202464219000831, + "log_sha256": "cd2d6adc0522adceb674f80578947944e5ac1e65bf6b73b6f43ae89cb7322f31" + }, + { + "name": "lemmag-labels", + "exit_code": 0, + "seconds": 29.352078144002007, + "log_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469" + }, + { + "name": "strict-t74", + "exit_code": 0, + "seconds": 234.87765523000417, + "log_sha256": "863c3c3e7b8c8101f448567d926cc8a110fc75c3d7d23545f4ed72a28052f233" + }, + { + "name": "geometry-controls", + "exit_code": 0, + "seconds": 0.5600305250045494, + "log_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9" + } +] \ No newline at end of file diff --git a/research/rank7-t148-restore-release/evidence/logs/complete-admission.log.txt b/research/rank7-t148-restore-release/evidence/logs/complete-admission.log.txt new file mode 100644 index 0000000000..4dd4be5938 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/logs/complete-admission.log.txt @@ -0,0 +1,8 @@ +PASS owners +PASS parent-lift +PASS rebind +PASS discovery +PASS outer-check_ledger.py +PASS outer-independent_check.py +PASS release +PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE 0.0017291523371429583656499999999999999999999998999999999999999999999999 diff --git a/research/rank7-t148-restore-release/evidence/logs/declared-edit-stage.log.txt b/research/rank7-t148-restore-release/evidence/logs/declared-edit-stage.log.txt new file mode 100644 index 0000000000..99ee5533b2 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/logs/declared-edit-stage.log.txt @@ -0,0 +1 @@ +PASS_SOURCE_BOUND_DECLARED_EDIT_OVERLAY 9215312229c431078ba61daf106edb8caf20b33f48317d46438a341552cf153f 642 diff --git a/research/rank7-t148-restore-release/evidence/logs/derive-closed-adapters.log.txt b/research/rank7-t148-restore-release/evidence/logs/derive-closed-adapters.log.txt new file mode 100644 index 0000000000..09cdb8c291 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/logs/derive-closed-adapters.log.txt @@ -0,0 +1 @@ +PASS_CHECKED_91_BUFFER_ADAPTER_DERIVATION_R13 9215312229c431078ba61daf106edb8caf20b33f48317d46438a341552cf153f 642 {'prepare_extension_native.py': 'e7a407ff2d5ae2b3', 'admit_extension.py': 'e0250e81477b2f62', 'extension_blocknorm.py': '6e6b8683cc87a84e'} diff --git a/research/rank7-t148-restore-release/evidence/logs/export-pr2833.log.txt b/research/rank7-t148-restore-release/evidence/logs/export-pr2833.log.txt new file mode 100644 index 0000000000..c2ff3dfb96 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/logs/export-pr2833.log.txt @@ -0,0 +1 @@ +{"head": "e9307b48d7d1b690939935ecef0f8e524e6d92f4", "manifest_entries": 541, "manifest_sha256": "c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f", "network_fetch": false, "source": "/tmp/imb-t148-full-2/run/pr2833", "status": "PASS_EXACT_PR2833_SOURCE_EXPORT"} diff --git a/research/rank7-t148-restore-release/evidence/logs/export-pr2894.log.txt b/research/rank7-t148-restore-release/evidence/logs/export-pr2894.log.txt new file mode 100644 index 0000000000..2bed900376 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/logs/export-pr2894.log.txt @@ -0,0 +1 @@ +PASS_PINNED_PR2894_EXPORT_RECIPE_ONLY diff --git a/research/rank7-t148-restore-release/evidence/logs/four-kernel-stage.log.txt b/research/rank7-t148-restore-release/evidence/logs/four-kernel-stage.log.txt new file mode 100644 index 0000000000..257be58c74 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/logs/four-kernel-stage.log.txt @@ -0,0 +1 @@ +{"derived_manifest_sha256": "54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869", "source_file_count": 547, "status": "PASS_SOURCE_BOUND_FOUR_KERNEL_OVERLAY_DERIVATION"} diff --git a/research/rank7-t148-restore-release/evidence/logs/fresh-current-native.log.txt b/research/rank7-t148-restore-release/evidence/logs/fresh-current-native.log.txt new file mode 100644 index 0000000000..820460ef57 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/logs/fresh-current-native.log.txt @@ -0,0 +1,3 @@ +PASS fresh-current-base +PASS fresh-current-extra +PASS_TWO_FRESH_SHARED_KERNEL_NATIVE_CHAINS_AUTHENTICATED_PARENT_REUSE diff --git a/research/rank7-t148-restore-release/evidence/logs/fresh-retained-bootstrap.log.txt b/research/rank7-t148-restore-release/evidence/logs/fresh-retained-bootstrap.log.txt new file mode 100644 index 0000000000..9308a84963 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/logs/fresh-retained-bootstrap.log.txt @@ -0,0 +1,6 @@ +PASS native-base +PASS native-extra +PASS native-retained-base +PASS native-retained-extra +PASS retained-parent +PASS_PR2833_FRESH_NATIVE_PREPARATION diff --git a/research/rank7-t148-restore-release/evidence/logs/paired-extension-stage.log.txt b/research/rank7-t148-restore-release/evidence/logs/paired-extension-stage.log.txt new file mode 100644 index 0000000000..9ca3a42521 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/logs/paired-extension-stage.log.txt @@ -0,0 +1 @@ +PASS_SOURCE_BOUND_PAIRED_EXTENSION_OVERLAY 98d57c82a1c7318be3c330c3b66897844d57232f0aaeaea88fb4bebd0a1bedf1 632 diff --git a/research/rank7-t148-restore-release/evidence/logs/parent-paired-stage.log.txt b/research/rank7-t148-restore-release/evidence/logs/parent-paired-stage.log.txt new file mode 100644 index 0000000000..de80347a90 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/logs/parent-paired-stage.log.txt @@ -0,0 +1 @@ +PASS_SOURCE_BOUND_TWO_SIDED_HELPER408_OVERLAY 56cf455752722051d598a7da1e5ee700637fbaef09189f534413dbe6e0525a83 610 diff --git a/research/rank7-t148-restore-release/evidence/logs/preload-stage.log.txt b/research/rank7-t148-restore-release/evidence/logs/preload-stage.log.txt new file mode 100644 index 0000000000..4fa79b5e48 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/logs/preload-stage.log.txt @@ -0,0 +1 @@ +{"derived_manifest_sha256": "4da246899e2c509dd8c6e5af34905c6124ca17671b188e11ac37e36adf449504", "source_file_count": 553, "status": "PASS_SOURCE_BOUND_PRELOAD_MOVE_OVERLAY_DERIVATION"} diff --git a/research/rank7-t148-restore-release/evidence/logs/rank7-overlay-stage.log.txt b/research/rank7-t148-restore-release/evidence/logs/rank7-overlay-stage.log.txt new file mode 100644 index 0000000000..d058b55c96 --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/logs/rank7-overlay-stage.log.txt @@ -0,0 +1 @@ +{"buffers": 91, "derived_manifest_sha256": "751b46364742cbb947f7db07c130ff09085b38b52c520d3b47f2dadc1e21ba80", "source_file_count": 637, "status": "PASS_SOURCE_BOUND_WORDEDIT_OVERLAY_DERIVATION"} diff --git a/research/rank7-t148-restore-release/evidence/logs/source-preflight.log.txt b/research/rank7-t148-restore-release/evidence/logs/source-preflight.log.txt new file mode 100644 index 0000000000..fbfbb199ad --- /dev/null +++ b/research/rank7-t148-restore-release/evidence/logs/source-preflight.log.txt @@ -0,0 +1 @@ +PASS_PINNED_PR2908_PR2917_PR2942_PR2957_PR2966_PR2969_EXPORT_RECIPE_ONLY diff --git a/research/rank7-t148-restore-release/reproduce.py b/research/rank7-t148-restore-release/reproduce.py new file mode 100644 index 0000000000..bbe567e649 --- /dev/null +++ b/research/rank7-t148-restore-release/reproduce.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Fresh PR3015 source/native chain with the T148 order, fill and dispatch. + +Uses PR3021's authenticated exporter, process cleanup and source-chain checks. +No scientific source or retained validator is patched by this wrapper. +""" + +import argparse +import gzip +import hashlib +import os +import sys +from fractions import Fraction +from pathlib import Path + +import verify + +PACKAGE = Path(__file__).resolve().parent + + +def prepare(repo, work): + verify.authenticate() + verify.need(not work.exists(), "refusing an existing replay workspace") + verify.need(not work.is_relative_to(PACKAGE) and not PACKAGE.is_relative_to(work), + "external replay workspace") + verify.need(sys.flags.optimize == 0 and os.name == "posix", "POSIX with assertions enabled") + driver = verify.retained("release_driver") + driver.PACKAGE = PACKAGE + work.mkdir(parents=True) + source, run = work / "pr3015", work / "run" + driver.export(repo, source) + _, _, _, order, _, fill, dispatch = verify.allocation() + paths = {} + for name, value in [("fill", fill), ("order", order), ("dispatch", dispatch)]: + path = work / (name.upper() + (".json.gz" if name == "fill" else ".json")) + raw = verify.canonical(value) + path.write_bytes(gzip.compress(raw, compresslevel=1, mtime=0) if name == "fill" else raw) + paths[name] = path + env = dict(os.environ, PYTHONDONTWRITEBYTECODE="1", PYTHONPYCACHEPREFIX=str(work / "bytecode"), + OPENBLAS_NUM_THREADS="1", OMP_NUM_THREADS="1", PYTHONINTMAXSTRDIGITS="0") + for key in ("PYTHONPATH", "PYTHONOPTIMIZE", "WITNESS_SPEC", "WITNESS_RECORD", "WITNESS_DISCOVER"): + env.pop(key, None) + stages = [] + driver.run_stage("source-preflight", [sys.executable, "-B", source / "reproduce.py", + "--repo", repo, "--work", run, "--jobs", "1", "--dry-run"], work, env, stages, 120) + recipe = verify.read(run / "PREFLIGHT.json")["commands"] + verify.need([name for name, _ in recipe] == driver.RECIPE_NAMES, "complete source recipe") + changes = [] + for name, command in recipe: + if name != "complete-admission": + continue + for argument, path in paths.items(): + index = command.index("--" + argument) + 1 + expected = source / "allocation" / path.name + verify.need(command[index] == str(expected), "recipe preimage: " + argument) + changes.append(dict(stage=name, argument="--" + argument, + old=command[index], new=str(path))) + command[index] = str(path) + verify.need(len(changes) == 3, "only fill/order/dispatch arguments change") + driver.save(work / "RECIPE.json", dict(commands=recipe, changes=changes)) + return driver, source, recipe, paths, env, stages + + +def check_release(driver, work, source, paths, stages, finite): + candidate = work / "run/candidate" + admission = verify.read(candidate / "RESULT.json") + release_path = candidate / "release/RELEASE-RECEIPT.json" + release = verify.read(release_path) + verify.need(admission["status"] == "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", + "complete admission") + verify.need(release["status"] == "PASS_RELEASE", "complete outer release") + verify.need(admission["replicas"] == 148, "actual T148 admission") + verify.need({int(k): n for k, n in admission["profile"].items()} == verify.EXPECTED, + "actual complete profile") + for name, path in paths.items(): + verify.need(admission[name + "_sha256"] == verify.digest(path), "admitted " + name) + payload = hashlib.sha256(verify.canonical(verify.read(paths["fill"]))).hexdigest() + verify.need(payload == finite["fill_payload_sha256"], "actual admitted canonical fill") + for name in ("order", "dispatch"): + verify.need(verify.digest(paths[name]) == finite[name + "_sha256"], "literal " + name) + verify.need(admission["release_receipt_sha256"] == verify.digest(release_path), "release binding") + verify.need(admission["package_manifest_sha256"] == release["manifest_sha256"], "package binding") + verify.need(admission["source_manifest_sha256"] == verify.read(source / "CLAIM.json")[ + "source_manifest_sha256"], "unchanged edited source") + endpoint = Fraction(admission["kappa"]) + previous = Fraction(finite["comparison_kappa"]) + verify.need(previous < endpoint < Fraction(finite["new_root"][0]), "strict valid gain over PR3021") + verify.need(endpoint == Fraction(release["kappa_decimal"]), "same released endpoint") + driver.check_source_chain(work, source, admission, stages) + driver.authenticate_tree(candidate / "package") + invoice = candidate / "release/verify/strict/global/audit/PREFIX-AND-INVOICE.json" + verify.check_invoice(verify.read(invoice), finite) + return dict(status="PASS_T148_R1_COMPLETE_RELEASE", kappa=str(endpoint), + invoice_payload_sha256=verify.digest(invoice), + comparison_kappa=str(previous), gain=str(endpoint - previous), + fresh_retained_bootstrap=True, replicas=148, profile=verify.EXPECTED, + stock=finite["stock148"], fill_payload_sha256=finite["fill_payload_sha256"], + fill_sha256=verify.digest(paths["fill"]), + order_sha256=verify.digest(paths["order"]), + dispatch_sha256=verify.digest(paths["dispatch"]), + admission_result_sha256=verify.digest(candidate / "RESULT.json"), + release_receipt_sha256=verify.digest(release_path), + native_receipt_sha256=verify.digest(work / "run/native/NATIVE-RECEIPT.json"), + stages=stages, + scope="Conditional finite release; universal inherited hypotheses remain.") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--repo", required=True, type=Path) + parser.add_argument("--work", required=True, type=Path) + parser.add_argument("--dry-run", action="store_true") + args = parser.parse_args() + finite = verify.run() + work = args.work.resolve() + driver, source, recipe, paths, env, stages = prepare(args.repo.resolve(), work) + driver.save(work / "FINITE.json", finite) + if args.dry_run: + print("PASS_T148_PREFLIGHT_ONLY_NOT_A_RELEASE") + return + for name, command in recipe: + driver.run_stage(name, command, work, env, stages, 1800) + result = check_release(driver, work, source, paths, stages, finite) + driver.save(work / "RESULT.json", result) + print(result["status"], result["kappa"], flush=True) + + +if __name__ == "__main__": + main() diff --git a/research/rank7-t148-restore-release/test_verify.py b/research/rank7-t148-restore-release/test_verify.py new file mode 100644 index 0000000000..8ee89e667a --- /dev/null +++ b/research/rank7-t148-restore-release/test_verify.py @@ -0,0 +1,116 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Behavioral controls for the composed allocation, tariff and release boundary.""" + +import copy +import tempfile +import unittest +from fractions import Fraction +from pathlib import Path + +import verify + + +class CompositionTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.geometry = verify.retained("geometry") + cls.moment = verify.retained("moment") + cls.data = verify.allocation() + cls.plan = verify.read(verify.SOURCE / "vendor/PLAN.json.gz") + cls.template = verify.read(verify.SOURCE / "vendor/TEMPLATE.json.gz") + cls.providers = verify.read(verify.PACKAGE / "vendor/pr3015/PROVIDERS.json") + + def check(self, order, fill, routes): + dispatch = {(stage, owner): name for stage, owner, name in routes} + return self.geometry.check(order, fill, dispatch, self.plan, self.template, self.providers) + + def test_complete_candidate_and_paid_remainder(self): + _, _, _, order, _, fill, routes = self.data + result = self.check(order, fill, routes) + self.assertEqual(result["profile"], verify.EXPECTED) + self.assertEqual((result["roles"], result["physical"], result["rank_mass"]), + (543456, 133117, 9633024)) + self.assertEqual(result["idle"][32], 1) + self.assertNotIn(14, result["idle"]) + + def test_unknown_retained_module_rejects(self): + with self.assertRaisesRegex(ValueError, "module name"): + verify.retained("../verify") + + def test_stale_journal_rejects(self): + journal = verify.read(verify.PACKAGE / "vendor/PR3022-EXCHANGE.json") + with self.assertRaisesRegex(ValueError, "preimage"): + verify.apply(self.data[5], journal, 86) + + def test_duplicate_journal_rejects(self): + journal = copy.deepcopy(verify.read(verify.PACKAGE / "vendor/PR3022-EXCHANGE.json")) + journal["edits"][1] = journal["edits"][0] + with self.assertRaisesRegex(ValueError, "preimage"): + verify.apply(self.data[4], journal, 86) + + def test_missing_role_rejects(self): + _, _, _, order, _, fill, routes = self.data + with self.assertRaisesRegex(ValueError, "role count"): + self.check(order, {**fill, "rows": fill["rows"][:-1]}, routes) + + def test_wrong_dispatch_rejects(self): + _, _, _, order, _, fill, routes = self.data + wrong = [*routes[:-1], routes[0]] + with self.assertRaisesRegex(ValueError, "dispatch count"): + self.check(order, fill, wrong) + + def test_undercharged_idle_rejects(self): + profile = dict(verify.EXPECTED) + del profile[32] + with self.assertRaisesRegex(ValueError, "rank mass"): + verify.root(profile, 148, self.moment) + + def test_exact_doubling_has_no_gain(self): + doubled = {rank: 2 * count for rank, count in verify.BASELINE.items()} + self.assertEqual(verify.root(verify.BASELINE, 74, self.moment), + verify.root(doubled, 148, self.moment)) + + def test_strict_rational_gain(self): + old = verify.root(verify.BASELINE, 74, self.moment) + new = verify.root(verify.EXPECTED, 148, self.moment) + self.assertGreater(new[0] - old[1], Fraction(1133, 10**12)) + self.assertLess(new[1] - old[0], Fraction(1134, 10**12)) + + def test_paid_profile_packing_cap(self): + local = {"1": 2443, "2": 707, "3": 232, "4": 108, "5": 18, "8": 8} + bounds = verify.general_ceiling(self.moment, local) + self.assertEqual(bounds, (Fraction(439088585719, 250000000000000), + Fraction(1756354342877, 1000000000000000))) + with self.assertRaisesRegex(ValueError, "actual paid profile"): + verify.general_ceiling(self.moment, {**local, "1": 2445}) + + def test_actual_stock_and_prefix_increase(self): + old, new = verify.stock(74), verify.stock(148) + self.assertEqual((old["physical"], new["physical"]), (66813, 133117)) + self.assertEqual((old["stock_l2_bits"], new["stock_l2_bits"]), (1322, 1323)) + self.assertEqual((old["required_reserve_bits"], new["required_reserve_bits"]), + (1510, 1511)) + self.assertEqual(new["retained_payload_bits"], 2048) + + def test_outside_replica_domain_rejects(self): + with self.assertRaisesRegex(ValueError, "replica domain"): + verify.stock(740) + + def test_source_drift_rejects_without_touching_inputs(self): + with tempfile.TemporaryDirectory() as temporary: + root = Path(temporary) + source = root / "input.txt" + source.write_bytes(b"original\n") + sources = {"files": [{"path": "input.txt", "usage": "input", + "sha256": verify.digest(source)}]} + (root / "SOURCES.json").write_bytes(verify.canonical(sources)) + (root / "VENDOR.json").write_bytes(b"[]\n") + verify.authenticate(root, root) + source.write_bytes(b"changed\n") + with self.assertRaisesRegex(ValueError, "source drift"): + verify.authenticate(root, root) + + +if __name__ == "__main__": + unittest.main() diff --git a/research/rank7-t148-restore-release/vendor/PR3018-EXCHANGE.json b/research/rank7-t148-restore-release/vendor/PR3018-EXCHANGE.json new file mode 100644 index 0000000000..1260c8d95f --- /dev/null +++ b/research/rank7-t148-restore-release/vendor/PR3018-EXCHANGE.json @@ -0,0 +1,126 @@ +{ + "schema_version": 1, + "source_pr": 2979, + "source_head": "be191346391661f4d35fc0d1508d0a6029572576", + "edits": [ + [0,[0,0,13,0,41,0],[0,0,32,6,95,0]], + [816,[2,0,32,6,95,0],[2,0,32,6,95,9]], + [16336,[40,16,3,4,0,9],[40,16,32,6,94,9]], + [20453,[50,53,26,6,5,0],[50,53,3,4,4,9]], + [20458,[50,58,26,6,4,0],[50,58,3,4,3,9]], + [20469,[50,69,26,6,3,0],[50,69,3,4,2,18]], + [20474,[50,74,26,6,2,0],[50,74,3,4,1,18]], + [26450,[64,338,3,4,4,9],[64,338,3,4,4,13]], + [26452,[64,340,3,4,3,9],[64,340,3,4,3,13]], + [29401,[72,25,28,4,0,0],[72,25,3,4,0,9]], + [30439,[74,247,3,4,4,18],[74,247,3,4,4,22]], + [30447,[74,255,3,4,3,18],[74,255,3,4,3,22]], + [30449,[74,257,3,4,2,18],[74,257,3,4,2,22]], + [30456,[74,264,3,4,1,18],[74,264,3,4,1,22]], + [30457,[74,265,3,4,0,18],[74,265,32,6,93,9]], + [30847,[75,247,40,4,4,18],[75,247,32,6,92,9]], + [31281,[76,273,2,5,31,0],[76,273,3,4,0,16]], + [33559,[82,103,12,1,9,0],[82,103,13,0,41,0]], + [33595,[82,139,12,1,8,0],[82,139,3,4,0,24]], + [33967,[83,103,49,1,9,0],[83,103,13,0,41,8]], + [35384,[86,296,13,0,41,9],[86,296,28,4,0,0]], + [44066,[108,2,5,5,98,0],[108,2,2,5,31,0]], + [49778,[122,2,11,4,7,24],[122,2,49,1,9,0]], + [49915,[122,139,11,4,0,24],[122,139,12,1,9,0]], + [50323,[123,139,48,4,0,24],[123,139,12,1,8,0]], + [52434,[128,210,26,6,5,4],[128,210,26,6,5,0]], + [52435,[128,211,26,6,4,4],[128,211,26,6,4,0]], + [52436,[128,212,26,6,3,4],[128,212,26,6,3,0]], + [52437,[128,213,26,6,2,4],[128,213,26,6,2,0]], + [58754,[144,2,18,1,98,0],[144,2,5,5,98,0]], + [66098,[162,2,28,6,13,0],[162,2,11,4,0,24]], + [66100,[162,4,17,6,88,9],[162,4,11,4,7,24]], + [66506,[163,2,65,6,13,0],[163,2,48,4,0,24]], + [67768,[166,40,28,6,13,8],[166,40,28,6,13,0]], + [68176,[167,40,65,6,13,8],[167,40,65,6,13,0]], + [78338,[192,2,19,6,3,0],[192,2,17,6,88,9]], + [78340,[192,4,19,6,2,0],[192,4,18,1,98,0]], + [84180,[206,132,19,6,3,8],[206,132,19,6,3,0]], + [84182,[206,134,19,6,2,8],[206,134,19,6,2,0]], + [86594,[212,98,19,6,3,17],[212,98,19,6,3,9]], + [86596,[212,100,19,6,2,17],[212,100,19,6,2,9]], + [107848,[264,136,26,6,5,13],[264,136,26,6,5,9]], + [107849,[264,137,26,6,4,13],[264,137,26,6,4,9]], + [107852,[264,140,26,6,3,13],[264,140,26,6,3,9]], + [107853,[264,141,26,6,2,13],[264,141,26,6,2,9]], + [109346,[268,2,36,4,1,6],[268,2,19,6,3,18]], + [109348,[268,4,36,4,0,6],[268,4,19,6,2,18]], + [133061,[326,53,23,13,111,9],[326,53,26,6,5,18]], + [133469,[327,53,60,13,111,9],[327,53,26,6,4,18]], + [134760,[330,120,36,4,1,14],[330,120,36,4,1,6]], + [134761,[330,121,36,4,0,14],[330,121,36,4,0,6]], + [144485,[354,53,19,15,58,0],[354,53,26,6,3,18]], + [144490,[354,58,19,15,57,0],[354,58,26,6,2,18]], + [161079,[394,327,28,6,13,17],[394,327,28,6,13,9]], + [161487,[395,327,65,6,13,17],[395,327,65,6,13,9]], + [161961,[396,393,21,14,39,0],[396,393,28,6,13,15]], + [161962,[396,394,21,14,38,0],[396,394,65,6,13,15]], + [161963,[396,395,21,14,37,0],[396,395,36,4,1,15]], + [161964,[396,396,21,14,36,0],[396,396,36,4,0,15]], + [165872,[406,224,32,6,95,9],[406,224,32,6,95,18]], + [165873,[406,225,32,6,94,9],[406,225,32,6,94,18]], + [165874,[406,226,32,6,93,9],[406,226,32,6,93,18]], + [165875,[406,227,32,6,92,9],[406,227,32,6,92,18]], + [167396,[410,116,21,14,39,8],[410,116,21,14,39,0]], + [167398,[410,118,21,14,38,8],[410,118,21,14,38,0]], + [167399,[410,119,21,14,37,8],[410,119,21,14,37,0]], + [167400,[410,120,21,14,36,8],[410,120,21,14,36,0]], + [172176,[422,0,32,6,95,15],[422,0,23,13,111,9]], + [172177,[422,1,32,6,94,15],[422,1,60,13,111,9]], + [172179,[422,3,32,6,93,15],[422,3,26,13,111,9]], + [172181,[422,5,32,6,92,15],[422,5,63,13,111,9]], + [175513,[430,73,19,15,58,4],[430,73,19,15,58,0]], + [175516,[430,76,19,15,57,4],[430,76,19,15,57,0]], + [189539,[464,227,21,14,39,17],[464,227,21,14,39,9]], + [189540,[464,228,21,14,38,17],[464,228,21,14,38,9]], + [189541,[464,229,21,14,37,17],[464,229,21,14,37,9]], + [189542,[464,230,21,14,36,17],[464,230,21,14,36,9]], + [204318,[500,318,19,15,58,13],[500,318,19,15,58,9]], + [204319,[500,319,19,15,57,13],[500,319,19,15,57,9]], + [218754,[536,66,26,13,111,9],[536,66,26,13,111,18]], + [219162,[537,66,63,13,111,9],[537,66,63,13,111,18]], + [219721,[538,217,19,15,58,22],[538,217,19,15,58,18]], + [219722,[538,218,19,15,57,22],[538,218,19,15,57,18]], + [226106,[554,74,26,13,111,18],[554,74,19,15,58,27]], + [226514,[555,74,63,13,111,18],[555,74,19,15,57,27]], + [229431,[562,135,21,14,39,23],[562,135,21,14,39,15]], + [229432,[562,136,21,14,38,23],[562,136,21,14,38,15]], + [229433,[562,137,21,14,37,23],[562,137,21,14,37,15]], + [229436,[562,140,21,14,36,23],[562,140,21,14,36,15]], + [232084,[568,340,26,13,111,22],[568,340,26,13,111,27]], + [232492,[569,340,63,13,111,22],[569,340,63,13,111,27]], + [233782,[572,406,26,13,111,31],[572,406,21,14,38,24]], + [233783,[572,407,23,13,111,13],[572,407,21,14,39,24]], + [234190,[573,406,63,13,111,31],[573,406,21,14,36,24]], + [234191,[573,407,60,13,111,13],[573,407,21,14,37,24]], + [237796,[582,340,23,13,111,21],[582,340,23,13,111,18]], + [238204,[583,340,60,13,111,21],[583,340,60,13,111,18]], + [240720,[590,0,26,13,111,39],[590,0,26,13,111,36]], + [241128,[591,0,63,13,111,39],[591,0,63,13,111,36]], + [243508,[596,340,23,13,111,30],[596,340,23,13,111,27]], + [243916,[597,340,60,13,111,30],[597,340,60,13,111,27]], + [245140,[600,340,23,13,111,39],[600,340,23,13,111,36]], + [245548,[601,340,60,13,111,39],[601,340,60,13,111,36]] + ], + "routes": [ + [[20453,[3,4,4]],[133061,[26,6,5]]], + [[20458,[3,4,3]],[133469,[26,6,4]]], + [[20469,[3,4,2]],[144485,[26,6,3]],[226106,[19,15,58]]], + [[20474,[3,4,1]],[144490,[26,6,2]],[226514,[19,15,57]]], + [[29401,[3,4,0]],[35384,[28,4,0]]], + [[33559,[13,0,41]],[49915,[12,1,9]],[66098,[11,4,0]],[161961,[28,6,13]],[233783,[21,14,39]]], + [[33595,[3,4,0]],[50323,[12,1,8]],[66506,[48,4,0]],[161962,[65,6,13]],[233782,[21,14,38]]], + [[33967,[13,0,41]],[49778,[49,1,9]],[66100,[11,4,7]],[78338,[17,6,88]],[109346,[19,6,3]],[161963,[36,4,1]],[234191,[21,14,37]]], + [[31281,[3,4,0]],[44066,[2,5,31]],[58754,[5,5,98]],[78340,[18,1,98]],[109348,[19,6,2]],[161964,[36,4,0]],[234190,[21,14,36]]], + [[172176,[23,13,111]],[0,[32,6,95]]], + [[172177,[60,13,111]],[16336,[32,6,94]]], + [[172179,[26,13,111]],[30457,[32,6,93]]], + [[172181,[63,13,111]],[30847,[32,6,92]]] + ], + "changed_pattern_bins": [[23,13,111],[60,13,111],[26,13,111],[63,13,111],[3,4,4],[3,4,3],[3,4,2],[3,4,1],[3,4,0],[40,4,4],[13,0,41]] +} diff --git a/research/rank7-t148-restore-release/vendor/PR3021-RESULT.json b/research/rank7-t148-restore-release/vendor/PR3021-RESULT.json new file mode 100644 index 0000000000..399bcc26f0 --- /dev/null +++ b/research/rank7-t148-restore-release/vendor/PR3021-RESULT.json @@ -0,0 +1,92 @@ +{ + "admission_result_sha256": "4c03eeb067b33eb79dcbce1dce1c0dc41185b3185292ecda3ed6d37d2617713f", + "comparison_kappa": "17291509735342244286949999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "fill_payload_sha256": "070cbce2f7d609986afb2ecd8439ca9b3280e7d1d7c9eb7389a65f7dc8caa28f", + "fill_sha256": "15328dd296152417f9d207479fbdd15da05ddb7b499ea7491ce3cae91cc9b27b", + "fresh_retained_bootstrap": true, + "gain": "230448794014303/1000000000000000000000000", + "kappa": "17291512039830184429979999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "release_receipt_sha256": "247d9f03b9cd15b9dc0f49c7bf52d0ca1b2f027186b9b62e7f22020cfbb0f90e", + "scope": "Conditional finite release; inherited theorem hypotheses remain.", + "stages": [ + { + "exit_code": 0, + "log_sha256": "33398f425eb773647292f653df20b6bec51ab4a6ea56e9a3ee71a47978deef98", + "seconds": 1.024184999987483, + "stage": "source-preflight" + }, + { + "exit_code": 0, + "log_sha256": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "seconds": 0.281794958980754, + "stage": "export-pr2894" + }, + { + "exit_code": 0, + "log_sha256": "27c4924f28ac159cf7f0db82313f5007db8729ec1b3ba2815176e7675228cece", + "seconds": 0.5389136250014417, + "stage": "export-pr2833" + }, + { + "exit_code": 0, + "log_sha256": "4a1625fdd9a947187583e67492c492f309e28669082f2e6f2aa97b5da345ea29", + "seconds": 296.06436333298916, + "stage": "fresh-retained-bootstrap" + }, + { + "exit_code": 0, + "log_sha256": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "seconds": 0.517102874990087, + "stage": "four-kernel-stage" + }, + { + "exit_code": 0, + "log_sha256": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "seconds": 0.5696059170004446, + "stage": "preload-stage" + }, + { + "exit_code": 0, + "log_sha256": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "seconds": 0.3528053330082912, + "stage": "parent-paired-stage" + }, + { + "exit_code": 0, + "log_sha256": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "seconds": 0.40792808300466277, + "stage": "paired-extension-stage" + }, + { + "exit_code": 0, + "log_sha256": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "seconds": 0.676031208015047, + "stage": "rank7-overlay-stage" + }, + { + "exit_code": 0, + "log_sha256": "3ad47363c45012cd4f09aee995e551a314b89da7fb70310cabc437cf78957097", + "seconds": 0.3996767089993227, + "stage": "declared-edit-stage" + }, + { + "exit_code": 0, + "log_sha256": "8340209b638d921852def42e529ef2a6cf04eef138ab1235fb6ce4a7101290b9", + "seconds": 0.1875800830021035, + "stage": "derive-closed-adapters" + }, + { + "exit_code": 0, + "log_sha256": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "seconds": 52.94589850000921, + "stage": "fresh-current-native" + }, + { + "exit_code": 0, + "log_sha256": "2b1aeaaf0367d9665773d8646eeac7b4af3a2a89e4848f621bf2e13efcdaab14", + "seconds": 294.33291362499585, + "stage": "complete-admission" + } + ], + "status": "PASS_RESTORE_PACKING_COMPLETE_RELEASE" +} diff --git a/research/rank7-t148-restore-release/vendor/PR3022-EXCHANGE.json b/research/rank7-t148-restore-release/vendor/PR3022-EXCHANGE.json new file mode 100644 index 0000000000..5370296a7c --- /dev/null +++ b/research/rank7-t148-restore-release/vendor/PR3022-EXCHANGE.json @@ -0,0 +1,124 @@ +{ + "edits": [ + [91,[1,45,77,4,0,0],[1,45,31,10,91,0]], + [894,[2,39,40,4,4,0],[2,39,31,10,92,0]], + [895,[3,39,114,4,4,0],[3,39,31,10,94,0]], + [6528,[16,0,31,10,91,0],[16,0,31,10,91,9]], + [53716,[130,338,40,4,4,9],[130,338,31,10,93,9]], + [53717,[131,338,114,4,4,9],[131,338,3,4,0,9]], + [58802,[144,25,3,4,0,9],[144,25,3,4,0,18]], + [58803,[145,25,77,4,0,9],[145,25,3,4,0,25]], + [62562,[152,273,3,4,0,16],[152,273,40,4,4,0]], + [62563,[153,273,77,4,0,16],[153,273,40,4,4,8]], + [67190,[164,139,3,4,0,24],[164,139,40,4,4,16]], + [67191,[165,139,77,4,0,24],[165,139,40,4,4,24]], + [67384,[164,236,12,1,0,0],[164,236,114,4,4,0]], + [67385,[165,236,86,1,0,0],[165,236,114,4,4,8]], + [68200,[166,236,49,1,0,0],[166,236,114,4,4,16]], + [68201,[167,236,123,1,0,0],[167,236,114,4,4,24]], + [83021,[203,302,122,4,4,18],[203,302,122,4,4,26]], + [83023,[203,303,122,4,3,18],[203,303,122,4,3,26]], + [83069,[203,326,122,4,2,18],[203,326,122,4,2,26]], + [83071,[203,327,122,4,1,18],[203,327,122,4,1,26]], + [100529,[247,80,122,4,4,24],[247,80,12,1,0,0]], + [100543,[247,87,122,4,3,24],[247,87,86,1,0,0]], + [100561,[247,96,122,4,2,24],[247,96,49,1,0,0]], + [100575,[247,103,122,4,1,24],[247,103,123,1,0,0]], + [133475,[327,233,128,6,37,9],[327,233,122,4,4,18]], + [133477,[327,234,128,6,36,9],[327,234,122,4,3,18]], + [133481,[327,236,128,6,35,9],[327,236,122,4,2,18]], + [133485,[327,238,128,6,34,9],[327,238,122,4,1,18]], + [153448,[376,20,31,10,94,0],[376,20,31,10,94,9]], + [153452,[376,22,31,10,92,0],[376,22,31,10,92,9]], + [153454,[376,23,31,10,91,9],[376,23,31,10,91,18]], + [200729,[491,404,136,1,3,0],[491,404,128,6,37,9]], + [200731,[491,405,136,1,2,0],[491,405,128,6,36,9]], + [200733,[491,406,136,1,1,0],[491,406,128,6,35,9]], + [200735,[491,407,136,1,0,0],[491,407,128,6,34,9]], + [219508,[538,2,73,4,1,6],[538,2,136,1,3,0]], + [219509,[539,2,147,4,1,6],[539,2,136,1,1,0]], + [219512,[538,4,73,4,0,6],[538,4,136,1,2,0]], + [219513,[539,4,147,4,0,6],[539,4,136,1,0,0]], + [267692,[656,22,31,10,94,9],[656,22,31,10,94,18]], + [267694,[656,23,31,10,93,9],[656,23,31,10,93,18]], + [267696,[656,24,31,10,92,9],[656,24,31,10,92,18]], + [267700,[656,26,31,10,91,18],[656,26,31,10,91,27]], + [272544,[668,0,31,10,92,18],[668,0,31,10,92,27]], + [310120,[760,20,31,10,94,18],[760,20,31,10,94,27]], + [310122,[760,21,31,10,93,18],[760,21,31,10,93,27]], + [310124,[760,22,31,10,92,27],[760,22,31,10,92,36]], + [310126,[760,23,31,10,91,27],[760,23,31,10,91,36]], + [324755,[795,401,132,14,19,0],[795,401,73,4,1,6]], + [324761,[795,404,132,14,18,0],[795,404,73,4,0,6]], + [324763,[795,405,132,14,17,0],[795,405,147,4,1,6]], + [324765,[795,406,132,14,16,0],[795,406,147,4,0,6]], + [335981,[823,302,132,14,19,8],[823,302,132,14,19,0]], + [335983,[823,303,132,14,18,8],[823,303,132,14,18,0]], + [336029,[823,326,132,14,17,8],[823,326,132,14,17,0]], + [336031,[823,327,132,14,16,8],[823,327,132,14,16,0]], + [355818,[872,21,31,10,94,27],[872,21,31,10,94,36]], + [355820,[872,22,31,10,93,27],[872,22,31,10,93,36]], + [377032,[924,20,31,10,94,36],[924,20,146,13,111,36]], + [377034,[924,21,31,10,93,36],[924,21,109,13,111,36]], + [377036,[924,22,31,10,92,36],[924,22,72,13,111,36]], + [377038,[924,23,31,10,91,36],[924,23,35,13,111,36]], + [455332,[1116,2,31,14,0,9],[1116,2,132,14,16,6]], + [455333,[1117,2,105,14,0,9],[1117,2,132,14,18,6]], + [456148,[1118,2,68,14,0,9],[1118,2,132,14,17,6]], + [456149,[1119,2,142,14,0,9],[1119,2,132,14,19,6]], + [488644,[1196,338,31,14,0,17],[1196,338,31,14,0,9]], + [488645,[1197,338,105,14,0,17],[1197,338,105,14,0,9]], + [489460,[1198,338,68,14,0,17],[1198,338,68,14,0,9]], + [489461,[1199,338,142,14,0,17],[1199,338,142,14,0,9]], + [489930,[1200,165,35,13,111,27],[1200,165,137,14,0,27]], + [489931,[1201,165,109,13,111,27],[1201,165,26,14,0,27]], + [490746,[1202,165,72,13,111,27],[1202,165,63,14,0,27]], + [490747,[1203,165,146,13,111,27],[1203,165,100,14,0,27]], + [509186,[1248,1,35,13,111,31],[1248,1,35,13,111,27]], + [509187,[1249,1,109,13,111,31],[1249,1,109,13,111,27]], + [510002,[1250,1,72,13,111,31],[1250,1,72,13,111,27]], + [510003,[1251,1,146,13,111,31],[1251,1,146,13,111,27]], + [527906,[1292,385,35,13,111,40],[1292,385,31,14,0,24]], + [527907,[1293,385,109,13,111,40],[1293,385,105,14,0,24]], + [528722,[1294,385,72,13,111,40],[1294,385,68,14,0,24]], + [528723,[1295,385,146,13,111,40],[1295,385,142,14,0,24]], + [531054,[1300,327,31,14,0,26],[1300,327,31,14,0,18]], + [531055,[1301,327,105,14,0,26],[1301,327,105,14,0,18]], + [531870,[1302,327,68,14,0,26],[1302,327,68,14,0,18]], + [531871,[1303,327,142,14,0,26],[1303,327,142,14,0,18]] + ], + "routes": [ + [[91,[31,10,91]],[377038,[35,13,111]]], + [[894,[31,10,92]],[377036,[72,13,111]]], + [[53716,[31,10,93]],[377034,[109,13,111]]], + [[895,[31,10,94]],[377032,[146,13,111]]], + [[53717,[3,4,0]]], + [[62562,[40,4,4]]], + [[67190,[40,4,4]]], + [[62563,[40,4,4]]], + [[67191,[40,4,4]]], + [[527906,[31,14,0]],[455332,[132,14,16]],[324765,[147,4,0]],[219513,[136,1,0]],[200735,[128,6,34]],[133485,[122,4,1]],[100575,[123,1,0]],[68201,[114,4,4]]], + [[528722,[68,14,0]],[456148,[132,14,17]],[324763,[147,4,1]],[219509,[136,1,1]],[200733,[128,6,35]],[133481,[122,4,2]],[100561,[49,1,0]],[68200,[114,4,4]]], + [[527907,[105,14,0]],[455333,[132,14,18]],[324761,[73,4,0]],[219512,[136,1,2]],[200731,[128,6,36]],[133477,[122,4,3]],[100543,[86,1,0]],[67385,[114,4,4]]], + [[528723,[142,14,0]],[456149,[132,14,19]],[324755,[73,4,1]],[219508,[136,1,3]],[200729,[128,6,37]],[133475,[122,4,4]],[100529,[12,1,0]],[67384,[114,4,4]]], + [[58803,[3,4,0]]], + [[489930,[137,14,0]]], + [[490746,[63,14,0]]], + [[489931,[26,14,0]]], + [[490747,[100,14,0]]] + ], + "targets": [ + [[35,13,111],[9,9,9,9,9]], + [[72,13,111],[9,9,9,9,9]], + [[109,13,111],[9,9,9,9,9]], + [[146,13,111],[9,9,9,9,9]], + [[3,4,0],[7,7,9,9]], + [[77,4,0],[]], + [[40,4,4],[8,8,8,8]], + [[114,4,4],[8,8,8,8]], + [[137,14,0],[4,9,9,9]], + [[63,14,0],[4,9,9,9]], + [[26,14,0],[4,9,9,9]], + [[100,14,0],[4,9,9,9]] + ] +} diff --git a/research/rank7-t148-restore-release/vendor/PR3022-RESULT.json b/research/rank7-t148-restore-release/vendor/PR3022-RESULT.json new file mode 100644 index 0000000000..59c0e6cc77 --- /dev/null +++ b/research/rank7-t148-restore-release/vendor/PR3022-RESULT.json @@ -0,0 +1,187 @@ +{ + "baseline_root": [ + "4322585532660640773777/2500000000000000000000000", + "17290342130642563095109/10000000000000000000000000" + ], + "calls": 1332, + "delta": { + "1": 4, + "3": 4, + "5": -4, + "14": -2, + "32": 1 + }, + "edits": 86, + "gain": [ + "2266013143776813/2000000000000000000000000", + "11330065718884067/10000000000000000000000000" + ], + "gap_to_cap": [ + "837609375967053/2000000000000000000000000", + "4188046879835267/10000000000000000000000000" + ], + "idle": { + "1": 34632, + "3": 9924, + "5": 3440, + "32": 1, + "48": 56380 + }, + "journal_sha256": "8f6e53068fe91885ab3121da1eeaf8ff49a5c918dcea61e07457d33701fe7ed3", + "legacy_checker_physical": 133098, + "moved_roles": 50, + "new_root": [ + "8645176730354140989587/5000000000000000000000000", + "691614138428331279167/400000000000000000000000" + ], + "patterns": [ + [ + 8, + [ + 8 + ], + 99456 + ], + [ + 16, + [ + 7, + 9 + ], + 60758 + ], + [ + 16, + [ + 8, + 8 + ], + 5546 + ], + [ + 32, + [], + 1 + ], + [ + 32, + [ + 4, + 9, + 9, + 9 + ], + 34632 + ], + [ + 32, + [ + 5, + 9, + 9, + 9 + ], + 2664 + ], + [ + 32, + [ + 6, + 8, + 9, + 9 + ], + 21312 + ], + [ + 32, + [ + 7, + 7, + 9, + 9 + ], + 4253 + ], + [ + 32, + [ + 8, + 8, + 8, + 8 + ], + 2 + ], + [ + 32, + [ + 9, + 9, + 9 + ], + 3440 + ], + [ + 48, + [], + 56380 + ], + [ + 48, + [ + 9, + 9, + 9, + 9, + 9 + ], + 9924 + ] + ], + "physical": 133117, + "private_buffers": 91, + "profile": { + "1": 3291372, + "2": 940392, + "3": 318948, + "4": 143856, + "5": 27416, + "8": 10656, + "32": 1, + "48": 56380 + }, + "rank_mass": 9633024, + "realized_fraction_of_cap": "17290353460708281979174/17290357648755161814441", + "rejected_controls": [ + "stale_preimage", + "duplicate_edit", + "missing_role", + "duplicate_role", + "capacity", + "omitted_relay_edit", + "omitted_idle_child", + "no_op_gain", + "reversed_gain" + ], + "replicas": 148, + "roles": 543456, + "sign_certificate": { + "derivative_upper": "-1711767/125000", + "domain": "0 < b <= 1/100" + }, + "source_sha256": { + "research/rank7-joint-endframes/allocation/DISPATCH.json": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c", + "research/rank7-joint-endframes/allocation/FILL.json.gz": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "research/rank7-joint-endframes/allocation/ORDER.json": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1", + "research/rank7-joint-endframes/allocation/PROFILE.json": "94a819747f3ced41f1544ada0036c983fc0c92847b9644380f877a06cd7931cf", + "research/rank7-joint-endframes/allocation/PROVIDERS.json": "f2edb7922f3029a5d607437e737775ff3371bca49ebab62e5e2495d16d3bf573", + "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "research/rank7-joint-endframes/allocation/vendor/independent_owners.py": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461", + "research/rank7-joint-endframes/certificates/RELAX-CAP.json": "b272680de5842f7fd5f442cd0aeadfd317fe6af266ddee1a1e0738a919ba856e", + "research/rank7-joint-endframes/data/WORD-base.json.gz": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "research/rank7-joint-endframes/data/WORD-extra.json.gz": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7" + }, + "status": "PASS_RANK7_DOUBLED_RESIDUAL_EXCHANGE" +} diff --git a/research/rank7-t148-restore-release/vendor/geometry.py b/research/rank7-t148-restore-release/vendor/geometry.py new file mode 100644 index 0000000000..c1f1771327 --- /dev/null +++ b/research/rank7-t148-restore-release/vendor/geometry.py @@ -0,0 +1,285 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Independent finite owner geometry, with no predecessor Python imports. + +Source-event semantics and physical-family identities follow the pinned +rank7-joint-endframes allocation. Windows are derived first in stage coordinates +and then translated into the literal interleaved call order. + +Derived from PR3018 geometry.py at ca7113157d7c959fdfa9d7cd17ef92d3877070d0. +Only explicit capacity bounds are extended for the doubled construction. +Python allocates during checking. The managed-runtime deviation from fixed +allocation is bounded by 148 replicas, 1332 calls, 543456 roles and 298368 bins. +The checker owns all temporary state and performs no I/O or shared mutation. +""" + +from collections import Counter + +MAX_REPLICAS = 148 +MAX_EVENTS = 4096 +HELPERS = 408 +PORTS = 112 + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def _call_times(order, replicas): + need(type(replicas) is int and 1 <= replicas <= MAX_REPLICAS, "replica limit") + need(type(order) is list and len(order) == 9 * replicas, "call count") + progress = [0] * replicas + times = {} + for time, call in enumerate(order): + need(type(call) in (list, tuple) and len(call) == 2, "call shape") + stage, owner = call + need(type(stage) is int and type(owner) is int, "integer call") + need(0 <= owner < replicas and stage == progress[owner], "call chronology") + need(0 <= stage < 9, "stage bounds") + times[owner, stage] = time + progress[owner] += 1 + need(progress == [9] * replicas, "complete call coverage") + return times + + +def _stage_intervals(template): + need(type(template) is dict, "template object") + children = template.get("idle_children") + recipe = template.get("recipe") + events = template.get("execution_schedule") + need(type(children) is list and len(children) == 18 * PORTS, "idle child count") + need(type(recipe) is list and len(recipe) < MAX_EVENTS, "recipe limit") + need(type(events) is list and len(events) < MAX_EVENTS, "event limit") + ranks, pairs, slots = {}, {}, set() + for child in children: + need(type(child) is dict, "idle child shape") + index, rank, port = child.get("child"), child.get("rank"), child.get("port") + need(type(index) is int and 0 <= index < 18, "idle child index") + need(type(rank) is int and rank in (8, 16, 32, 48), "idle child rank") + need(type(port) is int and 0 <= port < PORTS, "idle child port") + need((index, port) not in slots, "duplicate idle child port") + need(index not in ranks or ranks[index] == rank, "idle child rank disagreement") + slots.add((index, port)) + ranks[index] = rank + for event in recipe: + need(type(event) is dict, "recipe event shape") + if event.get("kind") == "local": + stage, pair = event.get("stage"), event.get("pair") + need(type(stage) is int and 0 <= stage < 9, "local recipe stage") + need(type(pair) is int and 0 <= pair < 4, "local recipe pair") + need(stage not in pairs, "duplicate local recipe stage") + pairs[stage] = pair + need(set(pairs) == set(range(9)), "nine local recipe stages") + return _scan_intervals(events, ranks, pairs), ranks + + +def _scan_intervals(events, ranks, pairs): + touched, intervals, seen = {}, {}, set() + stage = None + for event in events: + need(type(event) is dict, "source event shape") + kind = event.get("kind") + if kind in ("bank_padding_cover_sweep", "translate_every_live_family"): + continue + if kind == "local_cover_sweep": + stage = event.get("stage") + need(type(stage) is int and stage == len(seen), "source stage order") + need(stage in pairs and stage not in seen, "source local stage") + seen.add(stage) + touched[pairs[stage]] = stage + else: + need(stage is not None, "source event before first local stage") + if kind == "bridge": + source, target = event.get("src"), event.get("dst") + need( + all(type(p) is int and 0 <= p < 4 for p in (source, target)), + "bridge pair", + ) + touched[source] = touched[target] = stage + elif kind == "idle_cover_sweep": + pair, indices = event.get("pair"), event.get("child_indices") + need(type(pair) is int and 0 <= pair < 4, "idle source pair") + need( + type(indices) is list and len(indices) <= 18, "idle source children" + ) + for child in indices: + need( + type(child) is int and 0 <= child < 20, + "unknown idle source child", + ) + if child not in ranks: + continue # Terminal children 18 and 19 have no borrowable rank. + need(child not in intervals, "repeated idle source child") + intervals[child] = touched.get(pair, -1), stage + else: + need( + kind in ("terminal_Y_translations", "terminal"), + "unknown source event", + ) + need( + seen == set(range(9)) and set(intervals) == set(ranks), + "complete source intervals", + ) + return intervals + + +def windows(template, order, T): + """Map each owner and child to its capacity and half-open source window.""" + times = _call_times(order, T) + intervals, ranks = _stage_intervals(template) + result = {} + for owner in range(T): + for child, (start_stage, end_stage) in intervals.items(): + lower = -1 if start_stage == -1 else times[owner, start_stage] + result[owner, child] = ranks[child], lower, times[owner, end_stage] + return result + + +def _provider_data(dispatch, order, providers): + need(type(providers) is dict and 1 <= len(providers) <= 8, "provider count") + parsed = {} + for name, provider in providers.items(): + need(type(name) is str and len(name) <= 128, "provider name") + need(type(provider) is dict, "provider shape") + widths, profile = provider.get("widths"), provider.get("actual_paid_profile") + need(type(widths) is list and len(widths) == HELPERS, "ordered helper widths") + need(all(type(w) is int and 4 <= w <= 9 for w in widths), "helper width bounds") + need(type(profile) is dict and 1 <= len(profile) <= 72, "local profile shape") + paid = Counter() + for rank, count in profile.items(): + need( + type(rank) is int or (type(rank) is str and len(rank) <= 2), + "local rank length", + ) + need(type(rank) is int or rank.isdecimal(), "local rank") + rank = int(rank) + need(1 <= rank < 73 and rank not in paid, "local rank bounds or duplicate") + need(type(count) is int and 0 < count <= 10000, "local count bounds") + paid[rank] = count + parsed[name] = widths, paid + need(type(dispatch) is dict and len(dispatch) == len(order), "dispatch count") + need(set(dispatch) == set(map(tuple, order)), "dispatch call coverage") + need( + all(type(name) is str and name in parsed for name in dispatch.values()), + "dispatch provider", + ) + return parsed + + +def _physical_families(plan, children): + need(type(plan) is dict, "plan shape") + pairs, sides = plan.get("pairs"), plan.get("sides") + need(type(pairs) is dict and type(sides) is dict, "plan family maps") + need(len(pairs) == len(sides) == len(children), "plan family count") + expected = {str(child) for child in children} + need(set(pairs) == set(sides) == expected, "plan family child coverage") + result = {} + for child in children: + pair, side = pairs[str(child)], sides[str(child)] + need(type(pair) is int and 0 <= pair < 4, "family pair bounds") + need(type(side) is int and side in (0, 1), "family side bounds") + result[child] = 2 * pair + side + return result + + +def _roles(order, fill, dispatch, win, families, providers): + need(type(fill) is dict, "fill object") + columns = ["time", "helper", "owner_replica", "child", "port", "offset"] + need(fill.get("columns") == columns, "literal role columns") + rows = fill.get("rows") + need( + type(rows) is list and len(rows) == len(order) * HELPERS, "complete role count" + ) + need(len(rows) <= 543456, "role limit") + overrides = fill.get("dispatch_overrides", []) + need( + type(overrides) is list and len(overrides) <= len(order), + "dispatch override limit", + ) + for override in overrides: + need(type(override) is list and len(override) == 3, "dispatch override shape") + stage, owner, provider = override + need(type(stage) is int and type(owner) is int, "dispatch override call") + need(dispatch.get((stage, owner)) == provider, "dispatch override binding") + helpers = [0] * len(order) + occupied_families = [set() for _ in order] + masks, patterns = {}, {} + for row in rows: + need(type(row) is list and len(row) == 6, "integer role shape") + need(all(type(x) is int for x in row), "integer role shape") + time, helper, owner, child, port, offset = row + need( + 0 <= time < len(order) and 0 <= helper < HELPERS, + "role call or helper bounds", + ) + need(0 <= port < PORTS and (owner, child) in win, "owner child or port bounds") + cap, lower, upper = win[owner, child] + need(lower < time <= upper, "literal source window") + helper_bit = 1 << helper + need(not helpers[time] & helper_bit, "duplicate helper") + helpers[time] |= helper_bit + family = owner, families[child], port + need(family not in occupied_families[time], "same-call family collision") + occupied_families[time].add(family) + widths, _ = providers[dispatch[tuple(order[time])]] + width = widths[helper] + need(0 <= offset and offset + width <= cap, "bin capacity") + key = owner, child, port + mask = ((1 << width) - 1) << offset + need(not masks.get(key, 0) & mask, "bin overlap") + masks[key] = masks.get(key, 0) | mask + patterns.setdefault(key, []).append(width) + need(helpers == [(1 << HELPERS) - 1] * len(order), "complete helper identities") + return masks, patterns + + +def _invoice(win, masks, patterns, order, dispatch, providers): + idle, histogram = Counter(), Counter() + for (owner, child), (capacity, _, _) in win.items(): + for port in range(PORTS): + key = owner, child, port + mask = masks.get(key, 0) + used = mask.bit_count() + need(mask == (1 << used) - 1, "compact bin prefix") + if used < capacity: + idle[capacity - used] += 1 + histogram[capacity, tuple(sorted(patterns.get(key, [])))] += 1 + profile = idle.copy() + for call in order: + _, local = providers[dispatch[tuple(call)]] + profile.update(local) + return ( + profile, + idle, + [ + [cap, list(widths), count] + for (cap, widths), count in sorted(histogram.items()) + ], + ) + + +def check(order, fill, dispatch, plan, template, providers, buffers=91): + """Check all literal owners and return the complete invoice and stock count.""" + need(type(order) is list and 0 < len(order) <= 9 * MAX_REPLICAS, "call limit") + need(len(order) % 9 == 0, "nine calls per replica") + need(type(buffers) is int and 0 <= buffers <= 480, "private buffer limit") + replicas = len(order) // 9 + win = windows(template, order, replicas) + parsed = _provider_data(dispatch, order, providers) + families = _physical_families(plan, {child for _, child in win}) + masks, patterns = _roles(order, fill, dispatch, win, families, parsed) + profile, idle, histogram = _invoice(win, masks, patterns, order, dispatch, parsed) + rank_mass = sum(rank * count for rank, count in profile.items()) + need(rank_mass == 65088 * replicas, "complete rank-mass identity") + return { + "replicas": replicas, + "calls": len(order), + "roles": len(fill["rows"]), + "live": 896 * replicas, + "physical": 896 * replicas + HELPERS + 8 + buffers + 2, + "private_buffers": buffers, + "rank_mass": rank_mass, + "idle": dict(sorted(idle.items())), + "profile": dict(sorted(profile.items())), + "bin_pattern_histogram": histogram, + } diff --git a/research/rank7-t148-restore-release/vendor/moment.py b/research/rank7-t148-restore-release/vendor/moment.py new file mode 100644 index 0000000000..939427c515 --- /dev/null +++ b/research/rank7-t148-restore-release/vendor/moment.py @@ -0,0 +1,138 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Directed integer intervals and a sign proof for the finite packing exchange.""" + +from fractions import Fraction +from functools import lru_cache + +SCALE = 10**60 +GRID = 10**25 + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def ceildiv(numerator, denominator): + return -(-numerator // denominator) + + +def rational(value): + value = Fraction(value) + return (value * SCALE).__floor__(), (value * SCALE).__ceil__() + + +def multiply(left, right): + need(min(*left, *right) >= 0, "nonnegative interval multiplication") + return ( + left[0] * right[0] // SCALE, + ceildiv(left[1] * right[1], SCALE), + ) + + +def unit_log(value): + """Enclose log(value) on [1,2] by 64 positive atanh terms.""" + need(1 <= value <= 2, "unit logarithm range") + z = rational((value - 1) / (value + 1)) + square = multiply(z, z) + power, lower, upper = z, 0, 0 + for index in range(64): + denominator = 2 * index + 1 + lower += power[0] // denominator + upper += ceildiv(power[1], denominator) + power = multiply(power, square) + tail = ceildiv(2 * power[1] * SCALE, 129 * (SCALE - square[1])) + return 2 * lower, 2 * upper + tail + + +@lru_cache(maxsize=73) +def logarithm(value): + value = Fraction(value) + need(1 <= value <= 73, "logarithm range") + exponent = 0 + for _ in range(7): + if value <= 2: + break + value /= 2 + exponent += 1 + lower, upper = unit_log(value) + low_two, high_two = unit_log(Fraction(2)) + return lower + exponent * low_two, upper + exponent * high_two + + +def exponential(value): + """24 Taylor terms and a geometric remainder, with directed rounding.""" + need(0 <= value[0] <= value[1] < SCALE, "exponential range") + term = (SCALE, SCALE) + lower = upper = SCALE + for index in range(1, 25): + product = multiply(term, value) + term = product[0] // index, ceildiv(product[1], index) + lower += term[0] + upper += term[1] + following = ceildiv(term[1] * value[1], 25 * SCALE) + tail = ceildiv(following * 26 * SCALE, 26 * SCALE - value[1]) + return lower, upper + tail + + +def moment_numerator(profile, saving): + need(0 <= saving <= Fraction(1, 100), "saving range") + need(1 <= len(profile) <= 72, "profile size") + lower = upper = 0 + for rank, count in profile.items(): + need(type(rank) is int and 0 < rank < 73, "child rank") + need(type(count) is int and 0 < count <= 10**7, "child count") + power = exponential(multiply(rational(saving), logarithm(Fraction(73, rank)))) + lower += count * rank * power[0] + upper += count * rank * power[1] + return lower, upper + + +def root(profile, replicas=74): + need(replicas == 74, "this certificate has 74 replicas") + need(sum(r * n for r, n in profile.items()) == 65088 * replicas, "rank mass") + threshold = 73 * 896 * replicas * SCALE + low, high = 0, GRID // 100 + need(moment_numerator(profile, Fraction(low, GRID))[1] < threshold, "lower root") + need(moment_numerator(profile, Fraction(high, GRID))[0] > threshold, "upper root") + for _ in range(GRID.bit_length()): + if high - low == 1: + return Fraction(low, GRID), Fraction(high, GRID) + middle = (low + high) // 2 + lower, upper = moment_numerator(profile, Fraction(middle, GRID)) + if upper < threshold: + low = middle + elif lower > threshold: + high = middle + else: + raise ValueError("interval precision exhausted") + raise ValueError("bisection bound exhausted") + + +def short_log(value): + z = (value - 1) / (value + 1) + lower = 2 * sum(z ** (2 * j + 1) / (2 * j + 1) for j in range(3)) + return lower, lower + 2 * z**7 / (7 * (1 - z * z)) + + +def sign_certificate(): + """Prove 4 H1 + 4 H3 - 6 H5 + H14 < 0 for 0 < b <= .01.""" + two = short_log(Fraction(2)) + bounds = {} + for value, exponent, unit in [ + (3, 1, Fraction(3, 2)), + (5, 2, Fraction(5, 4)), + (14, 3, Fraction(7, 4)), + ]: + low, high = short_log(unit) + bounds[value] = low + exponent * two[0], high + exponent * two[1] + need(Fraction(109, 100) < bounds[3][0] < bounds[3][1] < Fraction(11, 10), "log3") + need(bounds[5][1] < Fraction(161, 100), "log5") + need(Fraction(263, 100) < bounds[14][0] < bounds[14][1] < Fraction(66, 25), "log14") + derivative = ( + 30 * Fraction(161, 100) + - 12 * Fraction(109, 100) * Fraction(989, 1000) + - 14 * Fraction(263, 100) * Fraction(1217, 1250) + ) + need(derivative == -Fraction(60509, 125000), "negative derivative bound") + return {"derivative_upper": str(derivative), "saving_interval": "0 < b <= 1/100"} diff --git a/research/rank7-t148-restore-release/vendor/pr3015/CLAIM.json b/research/rank7-t148-restore-release/vendor/pr3015/CLAIM.json new file mode 100644 index 0000000000..70813f559e --- /dev/null +++ b/research/rank7-t148-restore-release/vendor/pr3015/CLAIM.json @@ -0,0 +1,229 @@ +{ + "admitted_package_manifest_sha256": "75a1536a7eaafa59c553d62c0ec8ce9a0b68f7365ecadea590ab85c7a78e0c1b", + "baseline_head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "baseline_kappa": "17240352247481048785499999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "baseline_pr": 2969, + "baseline_status": "FINITE_NATIVE_OWNER_AND_MOMENT_CANDIDATE_OUTER_PENDING", + "calls": 666, + "complex_lower": "345830194706844885739/200000000000000000000000", + "declared_edits": { + "count": 1, + "edits_sha256": "c9c68660d07bfd12ed20fd8cbfe3d36301ceb2d7bb9b4ea11350cc399b19e0b1", + "previous_kappa": "0.0017290339826465135177169999999999999999999998999999999999999999999999", + "previous_pr": 2979 + }, + "fill_sha256": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "fixed_inventory_cap": { + "cap_lower": "345830551200866186907/200000000000000000000000", + "cap_upper": "17291527560043309345351/10000000000000000000000000", + "realized": "below the fractional optimum by the recorded gap (check_cap.py); the cap basis is fractional at T74" + }, + "gain": "1023149757223910029/200000000000000000000000", + "helpers": 408, + "independent_inputs": 632, + "kappa": "17291509735342244286949999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017291509735342244286949999999999999999999998999999999999999999999999", + "live_families": 66304, + "local_profile": { + "1": 2443, + "2": 707, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "native_receipt_sha256": "bc03c643a2209ec74f6efe9f74c29d7a1836b1be4b6bfe6e9ee5f3d82c01d19c", + "physical_families": 66813, + "previous_claims": { + "pr2942": { + "claim_file": "comparators/PR2942-CLAIM.json", + "gain": "6334653671010100699/1000000000000000000000000", + "head": "a027b0f6fdb0ab2b42ba10fc31b53960166bf2bf", + "kappa": "17228163198632143279959999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2942 + }, + "pr2957": { + "claim_file": "comparators/PR2957-CLAIM.json", + "gain": "1358389615871564431/250000000000000000000000", + "head": "b74b25f3ccc84c16e1a801d73b2f47e5ea764c78", + "kappa": "17237174150707381709709999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2957 + }, + "pr2966": { + "claim_file": "comparators/PR2966-CLAIM.json", + "gain": "5116701010772251283/1000000000000000000000000", + "head": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "kappa": "17240342725234521774119999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2966 + }, + "pr2969": { + "claim_file": "allocation/baseline/CLAIM.json", + "gain": "1023149757223910029/200000000000000000000000", + "head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "kappa": "17240352247481048785499999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2969 + }, + "pr2979": { + "claim_file": "comparators/PR2979-CLAIM.json", + "gain": "58495443855455489/500000000000000000000000", + "head": "be191346391661f4d35fc0d1508d0a6029572576", + "kappa": "17290339826465135177169999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2979 + } + }, + "profile": { + "1": 1644348, + "2": 470862, + "3": 159468, + "4": 71928, + "48": 28190, + "5": 13716, + "8": 5328 + }, + "release_receipt_sha256": "f6ddfdbbdd343cfd0a11e1d7b00cb9a8a6fbc9c7a64159b0d5abaf7de88cecf2", + "replicas": 74, + "scope": "Conditional finite supplier/outer certificate for PR2979's words (mdumitrean: joint rank-7 end frames, five further paired extractions, fourteen PR2957 rewrites) with one declared literal restore edit (R1, Stack2979 / Jeremy Kothe) and PR2979's literal T74 allocation unchanged (paid profile re-derived). Inherited all-size/compiler/theorem hypotheses remain. No selected-frontier change or independent-human-review claim.", + "source_manifest_sha256": "9215312229c431078ba61daf106edb8caf20b33f48317d46438a341552cf153f", + "stages": { + "stage1": { + "frame_edits": 139, + "groups": { + "A": { + "W": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "helpers": [ + 331, + 450, + 451, + 508, + 509 + ] + }, + "B": { + "W": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "helpers": [ + 299, + 448, + 449, + 484, + 485 + ] + }, + "C": { + "W": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "helpers": [ + 452, + 453, + 532, + 533 + ] + }, + "D": { + "W": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "helpers": [ + 454, + 455, + 556, + 557 + ] + }, + "V45": { + "W": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "helpers": [ + 249, + 251, + 265, + 267 + ] + } + }, + "kind": "joint codimension-2 end-frame lowering (frame-only)", + "record_sha256": "5fbfce004330ebc1fbac8de264614fe295f1a074811b478db4892c3bc3852cd3" + }, + "stage2": { + "extractions": [ + { + "helper": 226, + "normal": 42, + "step": 1 + }, + { + "helper": 228, + "normal": 42, + "step": 2 + }, + { + "helper": 230, + "normal": 42, + "step": 3 + }, + { + "helper": 363, + "normal": 7, + "step": 4 + }, + { + "helper": 395, + "normal": 7, + "step": 5 + } + ], + "kind": "rank-8 paired input/output extractions" + }, + "stage3": { + "applier_sha256": "2509f1335e47543f8814b42d6bf83032b30c5899b4f7cc62a6adc03f5138ae13", + "count": 14, + "kind": "declared exactness-preserving gate rewrites (Jeremy Kothe, PR2957), re-addressed", + "rewrites_sha256": "a37ade675876e4f5b00b33066c84f495fccd264863b7eb5d813837b1d01c3e7d" + } + }, + "status": "CONDITIONAL_CANDIDATE_COMPLETE_FINITE_RELEASE", + "width_inventory": { + "4": 26, + "5": 2, + "6": 16, + "7": 52, + "8": 99, + "9": 213 + }, + "zero_buffers": 91 +} diff --git a/research/rank7-t148-restore-release/vendor/pr3015/CREDITS.md b/research/rank7-t148-restore-release/vendor/pr3015/CREDITS.md new file mode 100644 index 0000000000..3b6022cd64 --- /dev/null +++ b/research/rank7-t148-restore-release/vendor/pr3015/CREDITS.md @@ -0,0 +1,17 @@ +# Credits + +- **PR #2908, Jeremy Diviney**: the paired input/output extraction, its compensation rule `C*S`, the exact two-sided certificate (`structure.py`, vendored unchanged) and the closed-adapter admission chain. +- **PR #2917, Mason Hale**: the nine paired extractions and 82-endpoint words under PR2942, the refit/compose producer model that stage 2 follows, the T74 chronology (ORDER/DISPATCH), the allocation checker, moment auditor, extension stage and adapter derivation reused here. +- **PR #2957 / #2948 / #2966, Jeremy Kothe (jeremykothe2)**: the fourteen declared exactness-preserving gate rewrites in five classes (R-retime, A3779-cut-start-read, PM-carrier-lender-entry, B-carrier-retime, A-commuting-swap) and their pure applier (`vendor/declared_rewrites.py`, vendored unchanged); stage 3 composes exactly these rewrites onto this package's stage-2 word (`data/REWRITES-2957.json`, re-addressed with exact preimages). PR2966 composed the same rewrites onto our PR2942 words. +- **PR #2969, Dugongue**: the PR2942 + PR2957 composition at T370 and its cap-level headline nomination, this package's comparator and moment baseline (`allocation/baseline/`). Our stage 3 composes the same fourteen rewrites, here onto the stage-2 word. +- **PR #2918 (research/helper408-rank7-pairing), RossRichardson**: the fixed-cut rank-seven obstruction for helper408; this package's census of fresh rank-7 extractions reproduces it exactly and is consistent with it. +- **PR #2894 / #2833, Jeremy Kothe**: the preload re-synthesis supplier, the frame accounting and inverse-reverse cleanup (`vendor/preload_move.py`), the source materializer and the inherited supplier lineage. +- **PR #2857 / #2848, Yiyang Lu (Lyy-iiis)**: the shared-kernel words, the staged native/overlay tooling and the chronological flow model and realization (edge colouring) used to construct the allocation; PR2843 (Marius-Paul Dumitrean) is that flow model's starting point. +- **PR #2863 / #2839, Dugongue**: the packing lineage and the PR2839 owner engine. +- **Tekalign**: the independent owner/chronology checker (`allocation/vendor/independent_owners.py`) and admission tooling. +- **icekylinx**: the exact free-operator auditor retained as `vendor/audit_local.py` (PR2833). +- **themilkman216**: the observation that a cap-level allocation of these inventories needs a T whose basic counts are integral, which the allocation's degenerate-face step builds on. +- **Gareth Davidson (bitplane), PR #1995 / #2013**: the fixed-word terminal-subspace bounds that frame stage 1's scope; earlier rank-seven helper ends on other words are in `research/complex-rank7-end-pair`, `research/k8-rank7-composition` and the PR1090/PR1104 lineage (credited there). +- **PR #2930 / #2942, Marius-Paul Dumitrean**: the cap allocation of PR2917's words, the four normal-45 extractions under these words, the relaxation tools and the overlay/producer conventions reused here. +- **New here (Marius-Paul Dumitrean, with substantial AI assistance from Anthropic Claude via Claude Code)**: the codimension-2 census on paired-extraction words, the joint end-frame lowering of 22 restored helpers in five groups (stage 1), the five further extractions it makes profitable (stage 2), the exact composition with PR2957's rewrites (stage 3), the producer and local verification for all three stages, the overlay stage `rank7-joint-endframes` with its rebuild guards, the adapter generalization to six width classes, the literal T74 allocation of the changed inventory, its relaxation certificates and recorded gap, and the complete fresh replay. +- **New here (Jeremy Kothe (jeremykothe2), with AI assistance; edit found by our Stack2979 search)**: the declared literal edit stage (`edits/`, `tools/build_edits.py`) with its independent review, the edit R1 on PR #2979's restore section, the re-derived paid profile and cap certificate. PR #2979 (mdumitrean) is the base and is credited first for everything else. diff --git a/research/rank7-t148-restore-release/vendor/pr3015/FINAL-WORD-base.json.gz b/research/rank7-t148-restore-release/vendor/pr3015/FINAL-WORD-base.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..4f0483657396a7f735873e1b252482c53dfb2eb6 GIT binary patch literal 71434 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 literal 0 HcmV?d00001 diff --git a/research/rank7-t148-restore-release/vendor/pr3015/FINAL-WORD-extra.json.gz b/research/rank7-t148-restore-release/vendor/pr3015/FINAL-WORD-extra.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..81f95e21ede115e8bdb6bd522c641b37b740bdf7 GIT binary patch literal 71430 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 literal 0 HcmV?d00001 diff --git a/research/rank7-t148-restore-release/vendor/pr3015/MANIFEST.json b/research/rank7-t148-restore-release/vendor/pr3015/MANIFEST.json new file mode 100644 index 0000000000..a331a50f94 --- /dev/null +++ b/research/rank7-t148-restore-release/vendor/pr3015/MANIFEST.json @@ -0,0 +1,156 @@ +{ + ".gitattributes": "056f4f66161e333f3a8d4c20de323ca05599a7deac1aa02d47ba6f6b96335573", + "allocation/baseline/CLAIM.json": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77", + "allocation/baseline/ORDER.json": "d559a1dcb83707724afc0310f6ef8e3a36ad6cda0a895ca6abae9d6f39a0fc76", + "allocation/baseline/PROFILE.json": "6de8ac1fd628cdd2afa5a43872da69c7dab9d7219bdc318f9db55fd8ccdb5eb2", + "allocation/DISPATCH.json": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c", + "allocation/FILL.json.gz": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "allocation/ORDER.json": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1", + "allocation/PROFILE.json": "5626c44edd6d5b209cd4e2d2a824e07bfba696e0856f3964b81fcb01c78eaad8", + "allocation/PROVIDERS.json": "f52d926752eac5d847092dd58bfb9f3f3c6ac36adf39cd6a3c4d4a3b2d1fce15", + "allocation/SEARCH.json": "2ceb1f825cb68e44d17d4251f74c3975ae5122c845391c1ca8de2e564ac4246a", + "allocation/vendor/independent_owners.py": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461", + "allocation/vendor/PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "allocation/vendor/TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "ALLOCATION-PINS.json": "5ea15a726c5fd3960ae2042ee21e7b3ad56aa46b65619233d5da117ae6349a92", + "certificates/RELAX-CAP.json": "6380d23931bfcdf4bd2684dd19bb60db543f570bc88873f5effd53387beb28b0", + "certificates/RELAX-STAGES.json": "0e5ec700a191b668ba3d4b6d675f5c047d264b9a5109fc55fa92961b3fcb7d68", + "check_allocation.py": "64b2bacd98728a25195d80e5be6c0374e24fba1400290edaafb895dcc5d54368", + "check_cap.py": "3f7901f4c1849074478df3c08ea98b792ae7325fd700948f01d80c11c9106893", + "CLAIM.json": "f9b9fbaaac794c0ce279c238a33a2f34f8c91a34d97ccdeb5ec98b7b8ba56d73", + "comparators/PR2942-CLAIM.json": "011aaac80ad79f7f29dc429a672441bb6b3c21a68bbcb34c7a0d5f943c3c3c2e", + "comparators/PR2957-CLAIM.json": "a93e6c9e94bc9bf5664b5e23506dda9647fad1930e1eede66d5ba9f3718b598a", + "comparators/PR2966-CLAIM.json": "4d4c4800bf3bcb36d09021313b2712aebd4aa0830c74dda30991daf6851c220a", + "comparators/PR2979-CLAIM.json": "436e0d297cbdf195445d3697d496ac675e95210b79e70ce602a6a6667a4c6ce9", + "construction/allocation/assemble.py": "57fcc8dd6f08b5557add7f34c0deb993574f71b3e565d6668085f1f65df5eccd", + "construction/allocation/controls.py": "9e10e5c21fab8ea2fdaf07ce92a141c4e6d63a7ef02d9de25bc9022ad1ae7998", + "construction/allocation/diag_lp.py": "59bfeb9586820f7b653370e20619760e23a4b170e4b7e14dc4e2abad9f5d9c61", + "construction/allocation/double.py": "8a89fafcd69cacb0a5a8d19a90d76f8740cf8f12585dc83796fcd8bc428dd94f", + "construction/allocation/fill17.py": "933be460381d65ea04a6e7f288f977ba22a7e4068b69494d65c38ccd7e5f4dbf", + "construction/allocation/providers_from_words.py": "8cf55c2859a626d86f21b447460321c19db92fec8e1f893b3cd37267f3b145fd", + "construction/allocation/round_mix.py": "0d0a423817b30fda9cceaa61b9bcc90e07710f9829e65098c9a31ed1734341bd", + "construction/allocation/T37-FACE-MIX.json": "10598b7ea2e26fbd49db2b4d2f08122415fd6673b87fb7b458019d503ae60744", + "construction/allocation/T37-FLOW.json.gz": "765c6b774ca207f715dd5f579995700f4787c1f4eb92a7855bfc1424f683eca4", + "construction/allocation/T37-MODEL.json": "74849384ad2160f0402f6577e9d3ea849c21704abcf839af50f3353e141a4355", + "construction/allocation/T37-PATTERNS.json": "df09e4581d7ed73fa22253909197ceb26ced59333f50c008c822894a4082f0e4", + "construction/allocation/T37-SOLVER.json": "f56caa18e9638c568c57e699a8576fa6dcbdfe6ba54ae2da3fc8bc626168d863", + "construction/allocation/T74-CONTROLS.json": "0de2d067d957bbca2580566576030d4f10508b7827a0d83a0bd8c05f19b23bbf", + "construction/allocation/T74-OWNER-CHECK.json": "996234db3632983effc279a93cb5599a945688a3ea476fc9f88e3a714fb330be", + "construction/records/derive_stage2.py": "f2518333cea351376ee094e8212b71ad753710d4038c55937a9e3bb212249f9e", + "construction/records/make_data.py": "b9528bcb26bc3c1a8e582032fa3899c79dc4cb463814dc6fea617fd83a5b4858", + "construction/records/make_prices.py": "5fcf593b5672b4f66cabd9d2bd5b4e843453248186d95794386331d801280b78", + "construction/search/codim2.py": "1dd77f4ceb0c4cf82ee5f3f4c04123724db09ebb0e7b9f856c4bd000d4e57531", + "construction/search/combine.py": "d06e041082f120b903937a8c7fdf2189eb42411330af625492ff5a24109b49d0", + "construction/search/deliver_l22.py": "b5f0a6ee2eaf1cbef95f0447efb08b75937e7e03c6d27d0b73d5c884c24a91b5", + "construction/search/final_l27.py": "e964d48e7b7705cc64a57bd42d81eb990d69606689349240e5a18155d08f7350", + "construction/search/lowerA.py": "1aba1edb5397701151b2c95afaf23cd8e675ddc48b5ccca1738bc0c5370e9a6c", + "construction/search/lowerA_joint.py": "eb0efbe0c40d063a606dc370362a8d3fe3f4f57877e2e79f63be940fe06ce41b", + "construction/search/realize.py": "6d524f4a1ce0a4bf77f8e5a859e46922334956688c9268dbea3004e3aea6898e", + "construction/search/vlower.py": "3052c96b4f00239fe679f460bbbad2b7271089b5aa73665cb92c052755143ec4", + "construction/STAGE-PRICES.json": "dfb7d06724bf95367f3fdb398f4828fc70f803d23030bc0eee0b00541457f546", + "CREDITS.md": "bd4b09fcd2861933883cbce6ecf0e30743d5d3b4cb0cc38e258530c370c121b9", + "data/PARENT-base.json.gz": "54ca34c749e3228d7e2df3d8dbf7aa1568c2872490166997c5962f12fd03da35", + "data/PARENT-extra.json.gz": "eded756dfe8f411c3d1f80a3ac16516f0ea5dd6f9866728b2179b157630fa7b6", + "data/REWRITES-2957.json": "a37ade675876e4f5b00b33066c84f495fccd264863b7eb5d813837b1d01c3e7d", + "data/STAGE1-FRAME-EDITS.json": "5fbfce004330ebc1fbac8de264614fe295f1a074811b478db4892c3bc3852cd3", + "data/TRANSFORM-226.json": "1732a39728c068f9d663111c7876b4e0b96088f3dd3b8e6ff824551b5a711338", + "data/TRANSFORM-228.json": "82346e6a5173c4822e16b2dad06ca232111b6795a340079f9aceabe0098797c0", + "data/TRANSFORM-230.json": "8ad70d545695b5d2246fb9e09d46abcc1e42926c1161884f69b77f978a28f46d", + "data/TRANSFORM-363.json": "84d2a609739eb30d4d9356fb6f04b2ff32c8823a978d7a51db1ace1d6d2352cc", + "data/TRANSFORM-395.json": "065aa5d7713683942bc2156b543681857e33c6e2f30f32cba47e2cbb9d1bef69", + "data/WORD-base.json.gz": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "data/WORD-extra.json.gz": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7", + "EDIT-PINS.json": "0cd0ae761bdb53ef1aedefac2f82e0ecb83ce555e422e326c55412d637118dcd", + "edits/declared_edits.py": "d3e49b844e9522808a439d505487839addbd957c7d1055bb57fa00e32cbba7b8", + "edits/EDITS.json": "c9c68660d07bfd12ed20fd8cbfe3d36301ceb2d7bb9b4ea11350cc399b19e0b1", + "edits/edits_review.py": "41734b21dfef4fe9c0917e6afcfb2d0652a4a55583f9cbc300af0ffc275af28c", + "edits/FINAL-WORD-base.json.gz": "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5", + "edits/FINAL-WORD-extra.json.gz": "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea", + "evidence/ADAPTER-DERIVATION.json": "2f09d2bcaa32ed2c65dc4549b7bdc98da1616fe99bad25056be53cb6b9811c6a", + "evidence/ADMISSION-RESULT.json": "f65b098a5cad1402f2badfe08f0e32ed9cdf93c7b4b5acc6be1c189ebff27f85", + "evidence/ADMISSION-STAGES.json": "ebbea57281a5effb1048e3585cea620cd07fe576121d564c417379ed160e18f5", + "evidence/EDITS-DERIVATION.json": "a69cf29822525b02a9e01317ff9e4fd12d7d70dcb24bc068ae24b2de65cbbf36", + "evidence/EDITS-REVIEW.json": "b7a485d2c5a3ec8bbe56182af355360dad584bc8efd63891b817e9856a1bfa07", + "evidence/ENVIRONMENT.json": "7d3ec720e565ce8461b95b28162f25ffe1b1dfbd7576eab70c0b6ff84fbf792d", + "evidence/FULL-NATIVE-RECEIPT.json": "bc03c643a2209ec74f6efe9f74c29d7a1836b1be4b6bfe6e9ee5f3d82c01d19c", + "evidence/FULL-NATIVE-RESULT.json": "ebcb0d2a6750dbd6f99252b9cc4ff8a0348e29f6e3150c8c2896a2f2e1ced528", + "evidence/FULL-REPLAY-RESULT.json": "f2686e9ad61b717e3bf917286bdbe8ebf21d1e14e64856e868a077db8d72929e", + "evidence/FULL-REPLAY-STAGES.json": "0d982174d950fff6c1ae168b51902c47e03b38ca47012216c511900f7cc106f3", + "evidence/logs/admission-discovery.log.txt": "1d520540cb875d2dc90db71fcbead647852d1e2b02ae01ba1c265f7aa51a4c57", + "evidence/logs/admission-outer-check_ledger.py.log.txt": "972a55790dc93979669a700deb02d02a3be936e93ac724a470a2b04a974e5461", + "evidence/logs/admission-outer-independent_check.py.log.txt": "714d3541e97dbcbc11080cee25dee15ca56f5e2b7b3769b29f5038dbc1420340", + "evidence/logs/admission-owners.log.txt": "869df7d6f2381446c933a28bdf53340e11b447ba1e90d620d017195a1a7410da", + "evidence/logs/admission-parent-lift.log.txt": "2389e2ae8c710f1a6ee0b25cccf0b4fef3a87812dc1cbe83a41c14ae32087487", + "evidence/logs/admission-rebind.log.txt": "18bc354417c5a6ceac79a96b0f88c3234f0309e9122c6e6c51affa49198e82f2", + "evidence/logs/admission-release.log.txt": "28e3fde8609d83a6eeb9f31cb5e3256cd939ccf5d220e63bcc9f108325006e31", + "evidence/logs/complete-admission.log.txt": "9681b993ad0c728a013435176a820a007e793104aa84ff5368437ecaac054ee4", + "evidence/logs/declared-edit-stage.log.txt": "70b401477abb6e419570f236f7ccb648101b90794bec5feac3f1d1cccd1ce956", + "evidence/logs/derive-closed-adapters.log.txt": "d79bd114c998f3fd6fd463c401ffd28b5cfbb760c5d4232e169f8c7eed34b509", + "evidence/logs/export-pr2833.log.txt": "f552acd4dabe475385662550ad1c15852259e2da3aeecb9b13cab04c5aefa1ba", + "evidence/logs/export-pr2894.log.txt": "cd3a45db2c9d74f2bd2e05a740e03a2a399209de4a0cbacbd5e527436bb6af76", + "evidence/logs/four-kernel-stage.log.txt": "eaa688738314d328fdd78cdd4ebac700fa044ebe672de6f6b15a3608ba7e9a18", + "evidence/logs/fresh-current-native.log.txt": "23a07eea566458947dadad21fa194ecf8dac8ebe9142d829bbfef66538a8cc53", + "evidence/logs/paired-extension-stage.log.txt": "d0eacd00db46fbaf4cc97af7b94eea3a9ad27f76dd3bc75632e2014a5eab5334", + "evidence/logs/parent-paired-stage.log.txt": "4ef095c17a64356df1155566be29f284d924df678691ef89b79548b95b1565df", + "evidence/logs/preload-stage.log.txt": "e94aa478b278850cc7eb29dd2347cd71c35d52ae220d64624da8d06e53063912", + "evidence/logs/rank7-overlay-stage.log.txt": "0d7805b2d8480a959ef4afd284a80bbe53df3f783a322cbe7c3b135aba50247a", + "evidence/OVERLAY-DERIVATION.json": "145a9491cca7b22f0d04cccb66795a7b6914a1ee415ecfc65e1db7b586573826", + "evidence/pr2979/ADAPTER-DERIVATION.json": "abfe60c965953c567392b587cbcc4703f2f80fc60e267539251a1eac0f9db2f3", + "evidence/pr2979/ADMISSION-RESULT.json": "be9652312a88fd670eb09a4303679b4e875516d02a008ce90ccbca8a92e6b2ac", + "evidence/pr2979/ADMISSION-STAGES.json": "bf2fcb3012c65d861ccc4ba5950e5b97cbff31f603268afdb7e9ae2a0ac9696f", + "evidence/pr2979/ENVIRONMENT.json": "c6faaaa9b538ddbf0ea3c624bbe2f1c7e4074f8cb504d4bee0f3353f1e7f32a1", + "evidence/pr2979/FULL-NATIVE-RECEIPT.json": "6d27c89d5e3a2c7f28387e4b20c462b0dff6c9fa92aacdde715d4b29cc286d41", + "evidence/pr2979/FULL-NATIVE-RESULT.json": "ee10e7b8f2196b3bd28f5389b9be3372c216f3cfe67e00c7a2bcd130746ac364", + "evidence/pr2979/FULL-REPLAY-RESULT.json": "0293261edd3696408e1067df358644a7f43fd05f6c7b78e255aeac3f4a2530a2", + "evidence/pr2979/FULL-REPLAY-STAGES.json": "d8764bbbc029b13e20dc881783c44b74c689064d9ddf8286fc18371f2ec0d503", + "evidence/pr2979/logs/admission-discovery.log.txt": "68845b7e19574ee2040677640848f0f7aaf71854250dfe0470dfae3ff09210b3", + "evidence/pr2979/logs/admission-outer-check_ledger.py.log.txt": "c56f8e0232d749e0ff33b76a8f9de18d28a7bb3abcd736ba69a4b167f2b5a824", + "evidence/pr2979/logs/admission-outer-independent_check.py.log.txt": "7eab2e50c0b03f058ae320c4791a0ea5a0ae3eae3393d29971663428ca79547a", + "evidence/pr2979/logs/admission-owners.log.txt": "dc4840d279e447e42af2ece9437cb92ab13c7f631440911ca5e8a676e3fa418c", + "evidence/pr2979/logs/admission-parent-lift.log.txt": "7b6249a123ca39fae7b7a6339dd9e8ae8777b081f4336418f2cc101704b70644", + "evidence/pr2979/logs/admission-rebind.log.txt": "6126af0a7935a1605ddad6074978494d462ed67cbd54be809ce13fcb32469d67", + "evidence/pr2979/logs/admission-release.log.txt": "d1e575ccd284596605baf38e5ed5b751cd5f506572ef9cfc578bd88d917b46a0", + "evidence/pr2979/logs/complete-admission.log.txt": "37584a0aed98b08f491b676ba0e4914518027f556495b1ae4e8a9a123d360b4f", + "evidence/pr2979/logs/derive-closed-adapters.log.txt": "d11d75855720cfa75a26f667a61467b5122a7b7ae5521030509bf1cbdd00a496", + "evidence/pr2979/logs/export-pr2833.log.txt": "0fa7e0c6a0f0e31c60aadd0fe2afa6841d046d3272a02d3dc873f999b8508654", + "evidence/pr2979/logs/export-pr2894.log.txt": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "evidence/pr2979/logs/four-kernel-stage.log.txt": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "evidence/pr2979/logs/fresh-current-native.log.txt": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "evidence/pr2979/logs/fresh-retained-bootstrap.log.txt": "4a1625fdd9a947187583e67492c492f309e28669082f2e6f2aa97b5da345ea29", + "evidence/pr2979/logs/paired-extension-stage.log.txt": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "evidence/pr2979/logs/parent-paired-stage.log.txt": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "evidence/pr2979/logs/preload-stage.log.txt": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "evidence/pr2979/logs/rank7-overlay-stage.log.txt": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "evidence/pr2979/OVERLAY-DERIVATION.json": "145a9491cca7b22f0d04cccb66795a7b6914a1ee415ecfc65e1db7b586573826", + "evidence/pr2979/RELEASE-RECEIPT.json": "473a5f8e048e45d7e83747077a18985ef87d58da370ca3f2fe5748a057ffdb2d", + "evidence/pr2979/RETAINED-BOOTSTRAP-RECEIPT.json": "ba9ef5709319ceb54928aed10cb250f3d018b3f654a2902c53df27d9e2e1157f", + "evidence/pr2979/RUNTIME-PATCHES.json": "6e4fe608caae2cdc28abc0ab772514d03ede2a4a50b06e9ede2853ab6889f218", + "evidence/README.md": "5b4d6054ee8410f01405bb8adb2b28f4f4a6f293b35426b4f7d32f0a73bd4695", + "evidence/RELEASE-RECEIPT.json": "f6ddfdbbdd343cfd0a11e1d7b00cb9a8a6fbc9c7a64159b0d5abaf7de88cecf2", + "evidence/RUNTIME-PATCHES.json": "25a75bcbc9535bce28c14fbe2fdff6ab42ed7a8193da6d473258ebd53901315c", + "NOTICE": "ffcc3de2243815db0e9fb8d820b4ca511fce3c7673c966e14b486f05d30ac11a", + "PINS.json": "2bd63d7767c5e2c2caa337b32b7c8c3c4adb65ce9d7b79997340865a536fe759", + "producer.py": "d4577cee26314b36b59723cc68df9b8895b22449cc15807c95f325f555c4da3a", + "README.md": "186a01ff053630b6451464ed61b779e3747602d85805f5f0ad0dca8c3b9407f0", + "RELEASE.json": "e6bbe07c74ca07adb4b37c955aa7485e474ff83133a2715cea9a291fdf33fa8d", + "reproduce.py": "ec9cbbf3d11377804e419745bc43ae5ad35c3b6f5fcde41df5f61f482f36e595", + "run_registered.py": "3439d214a163223c2ca7b50562bfb24b284551d5c8a36f4cc74791f890d4dd4a", + "SOURCES.json": "d5f3f498d4d34125bcaed14dafaceaff342223d511d1099993d5b217a147019c", + "structure.py": "83f63b6d9a1a543ecfa2c98d479dbe4e7a1c3caf6fd1c3566123308efbc32e96", + "TASK.json": "b1f2b3c1eb570009689fd6fd408c011e5a851c3ab1e407ba4ed0cdd60a4474b1", + "tools/audit_allocation_moment.py": "c632527ecf092f013862660dbd7f52b599a50b321a8aa88ddc45af0547e79cb5", + "tools/build_edits.py": "7292e18bbbcd2fabc87ed423e3d5d648d03709d0a061563087786ad0d57fb832", + "tools/build_overlay.py": "9d98ace9bffb37aeebd05b93ed386f73e6eee169d960e4956cf14a66e6852140", + "tools/derive_adapters.py": "5c06828151cd230add3e328b42dda72c4a2ed1075bd2902f38ee28727870bc84", + "tools/relax.py": "0fed1c56b50a2e6d44deeeb6db0f1c7e1f71b86d1747130e1a9202216249a728", + "tools/relax_exact.py": "baf1855d6095c951a90d19a0d8094bd33290519940b732e2b758c5647830f044", + "tools/root.py": "55f5aca39b5ee2fe4687ac8863e6c24569010f27a332883c069b8e14b8fe09e3", + "tools/wordedit.py": "cae8ae0f5d7fb3387ec6922fe966068aae05e3a6d3586830d4361b650cfb3617", + "vendor/audit_local.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "vendor/declared_rewrites.py": "2509f1335e47543f8814b42d6bf83032b30c5899b4f7cc62a6adc03f5138ae13", + "vendor/preload_move.py": "c8fda4674644fcd5cbf39b6645ce148a21daa90a998b678cbe51f970b78b0044", + "VERIFY.json": "620001c99145f78fbb639218e97620a956e87fe0a11b541e22b3ccb68fa29ffb", + "verify.py": "5c6bdd35c81d9a2b3a12e020874a5d32e8b0783a3c35bff7a28d070586003401", + "verify_manifest.py": "723d726dbbe5b65a49caecae0f1aab664a1413fb639abfd3e826a5a538e14e5b", + "verify_release.py": "a74e909c70869186bddb8952f049c09fc444800999123d2fac53c7ecda075581" +} diff --git a/research/rank7-t148-restore-release/vendor/pr3015/NOTICE b/research/rank7-t148-restore-release/vendor/pr3015/NOTICE new file mode 100644 index 0000000000..70a09b472e --- /dev/null +++ b/research/rank7-t148-restore-release/vendor/pr3015/NOTICE @@ -0,0 +1,28 @@ +research/rank7-joint-endframes +Copyright 2026 Marius-Paul Dumitrean. Licensed under the Apache License, Version 2.0. +Prepared with substantial AI assistance (Anthropic Claude, via Claude Code). + +This package retains, byte-identical, Apache-2.0 files from: PR #2942 (Marius-Paul Dumitrean, head +a027b0f6fdb0ab2b42ba10fc31b53960166bf2bf, research/paired-extension-normal45): data/PARENT-base.json.gz and +data/PARENT-extra.json.gz (its data/WORD-*.json.gz), comparators/PR2942-CLAIM.json and tools/wordedit.py; PR #2917 +(Mason Hale, head 224bd5e56041c40078ff6b5fa7393733a215de5c, research/paired-helper-extension): structure.py (Jeremy +Diviney's PR2908 two-sided certificate checker), vendor/audit_local.py (PR2833's independent exact auditor, icekylinx +attribution), vendor/preload_move.py (Jeremy Kothe's PR2894 frame accounting and cleanup), allocation/ORDER.json, +allocation/DISPATCH.json and allocation/vendor/ (independent_owners.py: Tekalign's independent owner checker as vendored +by PR2839/PR2917; PLAN.json.gz, TEMPLATE.json.gz); PR #2957 (Jeremy Kothe, head b74b25f3ccc84c16e1a801d73b2f47e5ea764c78, +research/paired-extension-cap-fill-swaps): vendor/declared_rewrites.py (the pure applier of the fourteen declared +rewrites) and comparators/PR2957-CLAIM.json; PR #2966 (Jeremy Kothe, head e62d3eb9005117d82a9babcfa937ecc53237c490, +research/paired-extension-normal45-rewrites): comparators/PR2966-CLAIM.json; PR #2969 (Dugongue, head +e2ca469b08385d3d5e29a918d66dbefaf889e9f3, research/paired-swap-normal45): allocation/baseline/ (its CLAIM.json and its +allocation ORDER.json and PROFILE.json); and PR #2930 (head 81f3b5d12977eba09e06fbff729167d59faabe90): tools/relax.py, +tools/root.py, tools/relax_exact.py. +data/REWRITES-2957.json is Jeremy Kothe's PR2957 rewrite list, re-addressed to this package's stage-2 word with exact +preimages (every entry keeps a credit field). producer.py follows PR2917's producer.py (Mason Hale) for its paired steps; +verify.py, check_allocation.py, check_cap.py, run_registered.py and reproduce.py adapt our PR2942 versions of PR2917's and +PR2930's; tools/audit_allocation_moment.py is PR2917's exact moment auditor with only its authenticated baseline changed (to +the PR2969 headline); tools/derive_adapters.py generalizes PR2917's adapter derivation (PR2908, Jeremy Diviney); +tools/build_overlay.py follows the overlay conventions of PR2908's and PR2917's builders. construction/allocation/ retains +the flow model of PR2857/PR2843 (Yiyang Lu, Marius-Paul Dumitrean) as adapted for this allocation. All original notices of +the exported predecessor packages remain in force. + +Derived work (Apache-2.0): this package is PR #2979's (Marius-Paul Dumitrean, head be191346, research/rank7-joint-endframes) package, retained byte-identical except for the files named in README.md, plus a declared literal edit stage by Jeremy Kothe (jeremykothe2), with AI assistance: edits/ (declared_edits.py, edits_review.py, EDITS.json, FINAL-WORD-*.json.gz), tools/build_edits.py, EDIT-PINS.json, comparators/PR2979-CLAIM.json, and the edits to reproduce.py, run_registered.py, check_allocation.py, check_cap.py, allocation/PROFILE.json, allocation/PROVIDERS.json, certificates/RELAX-CAP.json, CLAIM.json, PINS.json and the release contract files (RELEASE.json, verify_release.py, verify_manifest.py). PR #2979's own evidence is kept under evidence/pr2979/. diff --git a/research/rank7-t148-restore-release/vendor/pr3015/PROVIDERS.json b/research/rank7-t148-restore-release/vendor/pr3015/PROVIDERS.json new file mode 100644 index 0000000000..cac6220d3d --- /dev/null +++ b/research/rank7-t148-restore-release/vendor/pr3015/PROVIDERS.json @@ -0,0 +1,842 @@ +{ + "extra": { + "actual_paid_profile": { + "1": 2443, + "2": 707, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "widths": [ + 9, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 9, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 6, + 6, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 6, + 6, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 6, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 6, + 6, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 5, + 5, + 8, + 8, + 8, + 8 + ] + }, + "gauge44": { + "actual_paid_profile": { + "1": 2443, + "2": 707, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "widths": [ + 9, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 9, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 6, + 6, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 6, + 6, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 6, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 6, + 6, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 5, + 5, + 8, + 8, + 8, + 8 + ] + } +} \ No newline at end of file diff --git a/research/rank7-t148-restore-release/vendor/pr3015/RELAX-CAP.json b/research/rank7-t148-restore-release/vendor/pr3015/RELAX-CAP.json new file mode 100644 index 0000000000..41ec3a5f03 --- /dev/null +++ b/research/rank7-t148-restore-release/vendor/pr3015/RELAX-CAP.json @@ -0,0 +1,124 @@ +{ + "basis_patterns": [ + { + "capacity": 8, + "count_per_replica": "672", + "widths": [ + 8 + ] + }, + { + "capacity": 32, + "count_per_replica": "115/4", + "widths": [ + 7, + 8, + 8, + 9 + ] + }, + { + "capacity": 32, + "count_per_replica": "234", + "widths": [ + 4, + 9, + 9, + 9 + ] + }, + { + "capacity": 48, + "count_per_replica": "1341/20", + "widths": [ + 9, + 9, + 9, + 9, + 9 + ] + }, + { + "capacity": 32, + "count_per_replica": "93/4", + "widths": [ + 9, + 9, + 9 + ] + }, + { + "capacity": 32, + "count_per_replica": "144", + "widths": [ + 6, + 8, + 9, + 9 + ] + }, + { + "capacity": 32, + "count_per_replica": "18", + "widths": [ + 5, + 9, + 9, + 9 + ] + }, + { + "capacity": 16, + "count_per_replica": "35/4", + "widths": [ + 8, + 8 + ] + }, + { + "capacity": 16, + "count_per_replica": "1757/4", + "widths": [ + 7, + 9 + ] + }, + { + "capacity": 48, + "count_per_replica": "7619/20", + "widths": [] + } + ], + "cap_lower": "345830551200866186907/200000000000000000000000", + "cap_lower_decimal": "0.001729152756004330934535", + "cap_upper": "17291527560043309345351/10000000000000000000000000", + "cap_upper_decimal": "0.0017291527560043309345351", + "idle_per_replica": { + "1": "234", + "3": "1341/20", + "48": "7619/20", + "5": "93/4" + }, + "inventory_per_call": { + "4": 26, + "5": 2, + "6": 16, + "7": 52, + "8": 99, + "9": 213 + }, + "local_per_call": { + "1": 2443, + "2": 707, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "patterns": 2551, + "rank_mass_identity": true, + "scenario": "final words of PR2979 plus declared restore edit list (R1, Stack2979)", + "status": "PASS_EXACT_RELAXATION_CAP", + "strict_patterns": 2539, + "tight_patterns": 12 +} diff --git a/research/rank7-t148-restore-release/vendor/release_driver.py b/research/rank7-t148-restore-release/vendor/release_driver.py new file mode 100644 index 0000000000..f8f295f6cf --- /dev/null +++ b/research/rank7-t148-restore-release/vendor/release_driver.py @@ -0,0 +1,260 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Compose two exact sources and run PR3015's fresh finite release recipe. + +The source recipes and all their mathematical checks remain unchanged. Only +the complete-admission --fill argument is replaced by the journal-derived fill. +Source credit: Jeremy Kothe, Marius-Paul Dumitrean and the retained lineage. +""" + +import argparse +import gzip +import hashlib +import io +import json +import os +import signal +import subprocess +import sys +import tarfile +import time +from fractions import Fraction +from pathlib import Path, PurePosixPath + +PACKAGE = Path(__file__).resolve().parent +HEAD = "e244296debb45fe6f4da84d29e4d64fbab55fda0" +PREFIX = "research/rank7-joint-endframes-restore-edit" +EXPECTED = {1: 1644352, 2: 470862, 3: 159472, 4: 71928, + 5: 13710, 8: 5328, 14: 1, 48: 28190} +RECIPE_NAMES = ["export-pr2894", "export-pr2833", "fresh-retained-bootstrap", + "four-kernel-stage", "preload-stage", "parent-paired-stage", + "paired-extension-stage", "rank7-overlay-stage", "declared-edit-stage", + "derive-closed-adapters", "fresh-current-native", "complete-admission"] +DEPENDENCY_MANIFESTS = { + "pr2908": "9dba3fe371602ec023a54e26c0fd66f69eb7a74be86aab89923529083c14b36f", + "pr2917": "55c46ddf2e3edc87dfe1ba3320947466d36980d457eb37f6cd6fba341dae0192", + "pr2942": "23bd270f440c4c7ad0d106990ae391e1af799a61ef3601d00e27f1824ae8ba69", + "pr2957": "9cd226a2bf7391e7fbf4a23741bb1934afafbd596aef06f2999a935cd6e44e28", + "pr2966": "9e410c244efb370e20a5f9dc366550e11bcb14ebcecf8f2cb850512e82573914", + "pr2969": "797c55c560dec5b5a657296f49d918fc5db708b7bed3eba046b3358b1666e55b", +} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def digest(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == ".gz" else raw) + + +def save(path, value): + path.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n") + + +def authenticate_tree(directory): + manifest = read(directory / "MANIFEST.json") + paths = list(directory.rglob("*")) + need(len(paths) <= 10000 and len(manifest) <= 5000, "source tree bound") + need(not any(p.is_symlink() for p in paths), "regular source tree") + actual = {p.relative_to(directory).as_posix(): digest(p) for p in paths + if p.is_file() and p != directory / "MANIFEST.json"} + need(actual == manifest, "complete source inventory: " + str(directory)) + + +def export(repo, out): + """Export only bounded regular files, then authenticate the whole package.""" + raw = subprocess.run( + ["git", "-C", str(repo), "archive", HEAD, PREFIX], + check=True, capture_output=True, timeout=60, + ).stdout + need(len(raw) < 10_000_000, "bounded source archive") + out.mkdir() + with tarfile.open(fileobj=io.BytesIO(raw)) as archive: + members = archive.getmembers() + need(len(members) <= 256, "source file bound") + for member in members: + name = PurePosixPath(member.name) + need(not name.is_absolute() and ".." not in name.parts, "archive path") + need(member.isfile() or member.isdir(), "regular source entries") + if member.isdir(): + continue + need(name.is_relative_to(PurePosixPath(PREFIX)), "source prefix") + target = out / name.relative_to(PurePosixPath(PREFIX)) + target.parent.mkdir(parents=True, exist_ok=True) + stream = archive.extractfile(member) + need(stream is not None, "source file stream") + with stream: + target.write_bytes(stream.read()) + manifest = out / "MANIFEST.json" + need(digest(manifest) == digest(PACKAGE / "vendor/pr3015/MANIFEST.json"), + "exact PR3015 source manifest") + authenticate_tree(out) + + +def fill_from_journal(source, target): + fill = read(source / "allocation/FILL.json.gz") + need(digest(source / "allocation/FILL.json.gz") == read(source / "CLAIM.json")["fill_sha256"], + "PR3015 literal baseline fill") + journal = read(PACKAGE / "vendor/pr3018/EXCHANGE.json") + need(len(journal["edits"]) == 103, "exact 103-row journal") + rows, seen = list(fill["rows"]), set() + for index, old, new in journal["edits"]: + need(type(index) is int and 0 <= index < len(rows), "journal index") + need(index not in seen and rows[index] == old, "unique literal preimage") + need(len(new) == 6 and old[:2] == new[:2], "same call and helper") + seen.add(index) + rows[index] = new + candidate = {**fill, "rows": rows} + raw = (json.dumps(candidate, sort_keys=True, separators=(",", ":")) + "\n").encode() + target.write_bytes(gzip.compress(raw, compresslevel=1, mtime=0)) + return digest(target) + + +def run_stage(name, command, work, env, stages, timeout): + log = work / (name + ".log") + started = time.monotonic() + with log.open("w") as stream: + process = subprocess.Popen( + list(map(str, command)), cwd=work, env=env, stdin=subprocess.DEVNULL, + stdout=stream, stderr=subprocess.STDOUT, start_new_session=True, + ) + try: + code = process.wait(timeout=timeout) + finally: + try: + os.killpg(process.pid, signal.SIGTERM) + except ProcessLookupError: + pass + try: + process.wait(timeout=5) + except subprocess.TimeoutExpired: + os.killpg(process.pid, signal.SIGKILL) + process.wait(timeout=5) + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + stages.append(dict(stage=name, exit_code=code, + seconds=time.monotonic() - started, log_sha256=digest(log))) + save(work / "STAGES.json", stages) + need(code == 0, "failed " + name + "; see " + str(log)) + print("PASS", name, flush=True) + + +def execute(repo, work, dry_run): + need(not work.exists(), "refusing an existing replay workspace") + need(not work.is_relative_to(PACKAGE), "replay outside published package") + need(sys.flags.optimize == 0, "inherited source requires enabled assertions") + need(os.name == "posix", "full replay process-group cleanup requires POSIX") + for entry in read(PACKAGE / "VENDOR.json"): + need(digest(PACKAGE / entry["path"]) == entry["sha256"], "frozen vendor input") + work.mkdir(parents=True) + source, run = work / "pr3015", work / "run" + export(repo, source) + fill_path = work / "COMPOSED-FILL.json.gz" + fill_hash = fill_from_journal(source, fill_path) + env = dict(os.environ, PYTHONDONTWRITEBYTECODE="1", + PYTHONPYCACHEPREFIX=str(work / "bytecode"), + OPENBLAS_NUM_THREADS="1", OMP_NUM_THREADS="1", PYTHONINTMAXSTRDIGITS="0") + for key in ("PYTHONPATH", "PYTHONOPTIMIZE", "WITNESS_SPEC", "WITNESS_RECORD", "WITNESS_DISCOVER"): + env.pop(key, None) + py = [sys.executable, "-B"] + stages = [] + run_stage("source-preflight", py + [source / "reproduce.py", "--repo", repo, + "--work", run, "--jobs", "1", "--dry-run"], work, env, stages, 120) + recipe = read(run / "PREFLIGHT.json")["commands"] + need([name for name, _ in recipe] == RECIPE_NAMES, "complete source recipe") + changes = [] + for name, command in recipe: + if name == "complete-admission": + position = command.index("--fill") + 1 + need(command[position] == str(source / "allocation/FILL.json.gz"), "source fill preimage") + changes.append(dict(stage=name, argument="--fill", old=command[position], new=str(fill_path))) + command[position] = str(fill_path) + need(len(changes) == 1, "exactly one recipe argument changes") + save(work / "RECIPE.json", dict(commands=recipe, changes=changes, fill_sha256=fill_hash)) + if dry_run: + return {"status": "PREFLIGHT_ONLY_NOT_A_RELEASE", "fill_sha256": fill_hash} + for name, command in recipe: + run_stage(name, command, work, env, stages, 1800) + return check_release(work, source, fill_hash, stages) + + +def check_release(work, source, fill_hash, stages): + candidate = work / "run/candidate" + need(digest(work / "COMPOSED-FILL.json.gz") == fill_hash, "unchanged admitted fill bytes") + admission = read(candidate / "RESULT.json") + release = read(candidate / "release/RELEASE-RECEIPT.json") + need(admission["status"] == "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", "complete admission") + need(release["status"] == "PASS_RELEASE", "outer release") + need(admission["fill_sha256"] == fill_hash, "new literal fill admission binding") + need({int(k): v for k, v in admission["profile"].items()} == EXPECTED, + "exact complete composed profile") + need(admission["source_manifest_sha256"] == read(source / "CLAIM.json")["source_manifest_sha256"], + "unchanged PR3015 edited source") + need(Fraction(admission["kappa"]) == Fraction(release["kappa_decimal"]), "same released endpoint") + need(Fraction(admission["kappa"]) > Fraction(read(source / "CLAIM.json")["kappa"]), + "strict improvement over PR3015") + need(admission["release_receipt_sha256"] == digest(candidate / "release/RELEASE-RECEIPT.json"), + "admission authenticates release") + need(admission["package_manifest_sha256"] == release["manifest_sha256"], "same admitted package") + check_source_chain(work, source, admission, stages) + return dict(status="PASS_RESTORE_PACKING_COMPLETE_RELEASE", kappa=admission["kappa"], + comparison_kappa=read(source / "CLAIM.json")["kappa"], + gain=str(Fraction(admission["kappa"]) - Fraction(read(source / "CLAIM.json")["kappa"])), + fill_sha256=fill_hash, fresh_retained_bootstrap=True, + fill_payload_sha256=hashlib.sha256((json.dumps( + read(work / "COMPOSED-FILL.json.gz"), sort_keys=True, + separators=(",", ":")) + "\n").encode()).hexdigest(), + admission_result_sha256=digest(candidate / "RESULT.json"), + release_receipt_sha256=digest(candidate / "release/RELEASE-RECEIPT.json"), + stages=stages, scope="Conditional finite release; inherited theorem hypotheses remain.") + + +def check_source_chain(work, source, admission, stages): + run = work / "run" + need([s["stage"] for s in stages] == ["source-preflight", *RECIPE_NAMES], "all fresh stages") + need(all(s["exit_code"] == 0 for s in stages), "successful source stages") + edited = run / "source-edits" + need(digest(edited / "MANIFEST.json") == admission["source_manifest_sha256"], "actual edited source") + authenticate_tree(edited) + native_path = run / "native/NATIVE-RECEIPT.json" + native = read(native_path) + need(digest(native_path) == admission["native_receipt_sha256"], "fresh native binding") + need(native["manifest_sha256"] == admission["source_manifest_sha256"], "native source") + need(native["fresh_current_provider_count"] == 2, "two fresh current providers") + need(native["status"] == "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE", + "complete native receipt") + for tag in ("base", "extra"): + actual = edited / ("new/borrow/words/BORROW-WORD-43" + tag + ".json.gz") + expected = source / ("edits/FINAL-WORD-" + tag + ".json.gz") + need(read(actual) == read(expected), "exact edited provider word") + need(native["providers"][tag]["word_sha256"] == digest(actual), "native provider word") + need(digest(source / "MANIFEST.json") == digest(PACKAGE / "vendor/pr3015/MANIFEST.json"), + "unchanged pinned PR3015 manifest") + authenticate_tree(source) + for name, expected in DEPENDENCY_MANIFESTS.items(): + need(digest(run / name / "MANIFEST.json") == expected, "pinned predecessor " + name) + authenticate_tree(run / name) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--repo", type=Path, required=True) + parser.add_argument("--work", type=Path, required=True) + parser.add_argument("--dry-run", action="store_true") + args = parser.parse_args() + result = execute(args.repo.resolve(), args.work.resolve(), args.dry_run) + save(args.work / "RESULT.json", result) + print(result["status"], result.get("kappa", ""), flush=True) + + +if __name__ == "__main__": + main() diff --git a/research/rank7-t148-restore-release/verify.py b/research/rank7-t148-restore-release/verify.py new file mode 100644 index 0000000000..64eccfb08b --- /dev/null +++ b/research/rank7-t148-restore-release/verify.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Compose the literal T148 journal with R1 and certify its complete invoice. + +Geometry and directed moment kernels are retained, not independent new checks. +Python allocation is bounded by 1332 calls, 543456 roles and 298368 bins. +""" + +import argparse +import gzip +import hashlib +import json +import types +from collections import Counter +from fractions import Fraction +from pathlib import Path + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +SOURCE = ROOT / "research/rank7-joint-endframes/allocation" +DELTA = {1: 4, 3: 4, 5: -4, 14: -2, 32: 1} +BASELINE = {1: 1644352, 2: 470862, 3: 159472, 4: 71928, + 5: 13710, 8: 5328, 14: 1, 48: 28190} +EXPECTED = {1: 3288708, 2: 941724, 3: 318948, 4: 143856, + 5: 27416, 8: 10656, 32: 1, 48: 56380} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def digest(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + raw = path.read_bytes() + need(len(raw) <= 20_000_000, "compressed input bound") + if path.suffix == ".gz": + raw = gzip.decompress(raw) + need(len(raw) <= 60_000_000, "decoded input bound") + return json.loads(raw) + + +def canonical(value): + return (json.dumps(value, sort_keys=True, separators=(",", ":")) + "\n").encode() + + +def authenticate(root=ROOT, package=PACKAGE): + rows = [(root, row) for row in read(package / "SOURCES.json")["files"] + if row["usage"] == "input"] + rows += [(package, row) for row in read(package / "VENDOR.json")] + need(1 <= len(rows) <= 32, "input count") + for base, row in rows: + name = Path(row["path"]) + need(not name.is_absolute() and ".." not in name.parts, "input path") + need(digest(base / name) == row["sha256"], "source drift: " + str(name)) + + +def retained(name): + authenticate() + need(name in ("geometry", "moment", "release_driver"), "retained module name") + path = PACKAGE / "vendor" / (name + ".py") + module = types.ModuleType("t148_" + name) + module.__file__ = str(path) + exec(compile(path.read_bytes(), str(path), "exec"), module.__dict__) + return module + + +def apply(fill, journal, count): + rows = list(fill["rows"]) + edits, seen = journal["edits"], set() + need(type(edits) is list and len(edits) == count <= 128, "exact journal count") + for index, before, after in edits: + need(type(index) is int and 0 <= index < len(rows), "journal index") + need(index not in seen and rows[index] == before, "literal journal preimage") + need(len(before) == len(after) == 6 and before[:2] == after[:2], "role identity") + seen.add(index) + rows[index] = after + return {**fill, "rows": rows} + + +def allocation(): + authenticate() + order = read(SOURCE / "ORDER.json") + dispatch = read(SOURCE / "DISPATCH.json") + fill = apply(read(SOURCE / "FILL.json.gz"), + read(PACKAGE / "vendor/PR3018-EXCHANGE.json"), 103) + need(len(order) == len(dispatch) == 666 and len(fill["rows"]) == 271728, + "T74 input counts") + need(not fill.get("dispatch_overrides"), "no implicit dispatch overrides") + order2 = [[stage, owner + 74 * copy] for stage, owner in order for copy in range(2)] + dispatch2 = [[stage, owner + 74 * copy, provider] + for stage, owner, provider in dispatch for copy in range(2)] + rows = [[2 * time + copy, helper, owner + 74 * copy, child, port, offset] + for time, helper, owner, child, port, offset in fill["rows"] for copy in range(2)] + parent = {**fill, "rows": rows} + candidate = apply(parent, read(PACKAGE / "vendor/PR3022-EXCHANGE.json"), 86) + return order, fill, dispatch, order2, parent, candidate, dispatch2 + + +def root(profile, replicas, moment): + need(replicas in (74, 148), "replica domain") + need(sum(r * n for r, n in profile.items()) == 65088 * replicas, "complete rank mass") + threshold = 73 * 896 * replicas * moment.SCALE + low, high = 0, moment.GRID // 100 + need(moment.moment_numerator(profile, Fraction(0))[1] < threshold, "lower root sign") + need(moment.moment_numerator(profile, Fraction(1, 100))[0] > threshold, "upper root sign") + for _ in range(moment.GRID.bit_length()): + if high - low == 1: + return Fraction(low, moment.GRID), Fraction(high, moment.GRID) + middle = (low + high) // 2 + lower, upper = moment.moment_numerator(profile, Fraction(middle, moment.GRID)) + if upper < threshold: + low = middle + elif lower > threshold: + high = middle + else: + raise ValueError("interval precision exhausted") + raise ValueError("bisection bound exhausted") + + +def stock(replicas): + need(replicas in (74, 148), "stock replica domain") + group = 2**1296 + for j in range(1, 37): + group *= 2**(2 * j) - 1 + physical = 896 * replicas + 408 + 8 + 91 + 2 + bits = (group * physical).bit_length() + l2 = (bits + 1) // 2 + reserve = 128 + 37 + 18 + l2 + 1 + 4 + need(physical <= 2**20 and l2 <= 1330 and reserve < 2048, "full stock/prefix budget") + return dict(physical=physical, physical_stock_bits=bits, stock_l2_bits=l2, + required_reserve_bits=reserve, retained_payload_bits=2048, + active_depth=18, calls=9 * replicas, bridges=9 * replicas) + + +def check_invoice(invoice, finite): + need(invoice["status"] == "PASS_INDEPENDENT_MIXED_ASYNC_SCALAR_PREFIX_AND_FINITE_INVOICE", + "actual complete prefix invoice") + expected = finite["stock148"] + need(invoice["physical"] == expected["physical"] and invoice["live"] == 132608, + "actual complete physical stock") + need(invoice["private_zero_buffers"] == 91 and invoice["helpers"] == 408 and + invoice["centres"] == 8, "all private work charged") + need(invoice["complete_invocation_sweeps"] == invoice["bridge_sweeps"] == 1332, + "all doubled sweeps charged") + bn = invoice["blocknorm"] + need(bn["status"] == "PASS_TENSOR_BLOCK_NORM_CERTIFICATE" and bn["replicas"] == 148, + "actual block certificate") + for key in ("physical_stock_bits", "stock_l2_bits", "required_reserve_bits", "retained_payload_bits"): + need(bn[key] == expected[key], "actual T-dependent bound: " + key) + need(bn["physical_families"] == expected["physical"] and bn["max_active_depth"] == 18, + "physical schedule and completed-event depth") + local = bn["local_actual_prefix_bits"] + need(local <= 128 and invoice["charged_prefix_bits"] == 2048, "actual native prefix reserve") + need(invoice["global_prefix_bits"] == bn["actual_prefix_bits"] == + local + 37 + 18 + bn["stock_l2_bits"] + 1 + 4, "actual charged prefix sum") + + +def general_ceiling(moment, actual_local): + certificate = read(PACKAGE / "GENERAL-CEILING.json") + need(certificate["local_profile"] == actual_local, "generic cap actual paid profile") + local = {int(r): n for r, n in actual_local.items()} + idle_mass = 65088 - 9 * sum(r * n for r, n in local.items()) + need(idle_mass > 0 and 2 * 51**2 < 73**2, "generic coverage/halving model") + # Scale the fractional rank-51 relaxation by 51, leaving integer counts. + profile = {r: 51 * 9 * n for r, n in local.items()} + profile[51] = idle_mass + threshold = 73 * 896 * 51 * moment.SCALE + low, high = map(Fraction, certificate["primitive_saving_cap"]) + need(moment.moment_numerator(profile, low)[1] < threshold, "generic cap lower sign") + need(moment.moment_numerator(profile, high)[0] > threshold, "generic cap upper sign") + return low, high + + +def run(): + geometry, moment = retained("geometry"), retained("moment") + order, fill, dispatch, order2, parent, candidate, dispatch2 = allocation() + plan, template = read(SOURCE / "vendor/PLAN.json.gz"), read(SOURCE / "vendor/TEMPLATE.json.gz") + providers = read(PACKAGE / "vendor/pr3015/PROVIDERS.json") + data = [(order, fill, dispatch), (order2, parent, dispatch2), (order2, candidate, dispatch2)] + invoices = [] + for calls, roles, routes in data: + mapping = {(stage, owner): name for stage, owner, name in routes} + need(len(mapping) == len(calls), "unique dispatch") + invoices.append(geometry.check(calls, roles, mapping, plan, template, providers)) + need(invoices[0]["profile"] == BASELINE, "PR3021 baseline with edited providers") + need(invoices[1]["profile"] == {r: 2 * n for r, n in BASELINE.items()}, "exact double") + need(invoices[2]["profile"] == EXPECTED, "complete T148 edited invoice") + difference = Counter(EXPECTED) + difference.subtract(invoices[1]["profile"]) + need({r: n for r, n in difference.items() if n} == DELTA, "complete journal delta") + old, new = root(BASELINE, 74, moment), root(EXPECTED, 148, moment) + need(old[1] < new[0], "strict complete moment gain") + previous = Fraction(read(PACKAGE / "vendor/PR3021-RESULT.json")["kappa"]) + need(previous < old[0], "published PR3021 comparator below its root") + cap = read(PACKAGE / "vendor/pr3015/RELAX-CAP.json") + for tag in ("base", "extra"): + word = read(PACKAGE / ("vendor/pr3015/FINAL-WORD-" + tag + ".json.gz")) + need(word["report"]["local_profile"] == cap["local_per_call"] and + word["report"]["width_inventory"] == cap["inventory_per_call"], "cap source profile") + cap_low, cap_high = Fraction(cap["cap_lower"]), Fraction(cap["cap_upper"]) + need(new[1] < cap_low < cap_high, "below inherited fixed-inventory packing cap") + generic = general_ceiling(moment, cap["local_per_call"]) + need(cap_high < generic[0], "capacity-specific cap is tighter") + return dict(status="PASS_T148_R1_FINITE", profile=EXPECTED, delta=DELTA, + general_packing_cap=list(map(str, generic)), + realized_fraction_of_general_cap=str(new[0] / generic[1]), + inherited_packing_cap=[str(cap_low), str(cap_high)], + realized_fraction_of_cap=str(new[0] / cap_high), + gap_to_cap=[str(cap_low - new[1]), str(cap_high - new[0])], + baseline_root=list(map(str, old)), new_root=list(map(str, new)), + root_gain=[str(new[0] - old[1]), str(new[1] - old[0])], + comparison_kappa=str(previous), roles=543456, private_buffers=91, + stock74=stock(74), stock148=stock(148), + fill_payload_sha256=hashlib.sha256(canonical(candidate)).hexdigest(), + order_sha256=hashlib.sha256(canonical(order2)).hexdigest(), + dispatch_sha256=hashlib.sha256(canonical(dispatch2)).hexdigest()) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path) + args = parser.parse_args() + result = run() + payload = json.dumps(result, indent=2, sort_keys=True) + "\n" + if args.output: + args.output.write_text(payload) + print(payload, end="") + + +if __name__ == "__main__": + main() diff --git a/research/rank7-t148-restore-release/verify_release.py b/research/rank7-t148-restore-release/verify_release.py new file mode 100644 index 0000000000..cd004de6e9 --- /dev/null +++ b/research/rank7-t148-restore-release/verify_release.py @@ -0,0 +1,99 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Recheck finite construction and published full-release relations, not a new cold replay.""" + +import copy +import gzip +import hashlib +import json +from fractions import Fraction + +import verify + +EVIDENCE = verify.PACKAGE / "evidence" + + +def validate(full, admission, release, native, finite, bindings, invoice): + need = verify.need + need(full["status"] == "PASS_T148_R1_COMPLETE_RELEASE", "T148 complete release") + need(admission["status"] == "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", "admission") + need(release["status"] == "PASS_RELEASE", "release") + need(full["replicas"] == admission["replicas"] == 148, "actual doubled replica count") + need(full["fresh_retained_bootstrap"] is True, "fresh retained bootstrap") + need(full["admission_result_sha256"] == bindings["admission"], "admission receipt") + need(full["release_receipt_sha256"] == admission["release_receipt_sha256"] == bindings["release"], + "release receipt") + need(full["native_receipt_sha256"] == admission["native_receipt_sha256"] == bindings["native"], + "native receipt") + for key in ("fill_sha256", "order_sha256", "dispatch_sha256"): + need(full[key] == admission[key], "admission input: " + key) + need(full["fill_payload_sha256"] == finite["fill_payload_sha256"], "canonical fill") + need(full["order_sha256"] == finite["order_sha256"] and + full["dispatch_sha256"] == finite["dispatch_sha256"], "literal chronology and dispatch") + need({int(k): n for k, n in admission["profile"].items()} == verify.EXPECTED, + "complete paid profile") + need(full["stock"] == finite["stock148"], "complete physical/prefix ledger") + need(full["invoice_payload_sha256"] == bindings["invoice"], "actual complete invoice bytes") + verify.check_invoice(invoice, finite) + need(admission["package_manifest_sha256"] == release["manifest_sha256"], "admitted package") + expected_source = verify.read(verify.PACKAGE / "vendor/pr3015/CLAIM.json")["source_manifest_sha256"] + need(admission["source_manifest_sha256"] == native["manifest_sha256"] == expected_source, + "exact R1 source") + need(native["fresh_current_provider_count"] == 2 and native["status"] == + "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE", "two fresh native providers") + endpoint, previous = Fraction(full["kappa"]), Fraction(finite["comparison_kappa"]) + need(previous < endpoint < Fraction(finite["new_root"][0]), "strict valid gain over PR3021") + need(endpoint == Fraction(admission["kappa"]) == Fraction(release["kappa_decimal"]), "same endpoint") + need(Fraction(full["comparison_kappa"]) == previous and + Fraction(full["gain"]) == endpoint - previous, "exact comparator/gain") + names = ["source-preflight", *verify.retained("release_driver").RECIPE_NAMES] + need([s["stage"] for s in full["stages"]] == names and + all(s["exit_code"] == 0 for s in full["stages"]), "all successful fresh stages") + + +def run(): + finite = verify.run() + verify.need(json.loads(json.dumps(finite)) == verify.read(EVIDENCE / "FINITE.json"), + "replayed finite receipt") + names = ["RESULT.json", "ADMISSION-RESULT.json", "RELEASE-RECEIPT.json", "NATIVE-RECEIPT.json"] + records = [verify.read(EVIDENCE / name) for name in names] + bindings = dict(zip(("admission", "release", "native"), + (verify.digest(EVIDENCE / name) for name in names[1:]), strict=True)) + invoice_bytes = gzip.decompress((EVIDENCE / "PREFIX-AND-INVOICE.json.gz").read_bytes()) + verify.need(len(invoice_bytes) <= 2_000_000, "published invoice bound") + invoice = json.loads(invoice_bytes) + bindings["invoice"] = hashlib.sha256(invoice_bytes).hexdigest() + validate(*records, finite, bindings, invoice) + for stage in records[0]["stages"]: + name = stage["stage"] + verify.need(len(name) <= 64 and name.replace("-", "").isalnum(), "log filename") + verify.need(verify.digest(EVIDENCE / "logs" / (name + ".log.txt")) == stage["log_sha256"], + "full stage log") + controls = [(1, "replicas", 74), (1, "profile", {"1": 3288704}), + (1, "fill_sha256", "0" * 64), (2, "kappa_decimal", "1/100"), + (3, "fresh_current_provider_count", 0), (0, "stock", {"physical": 132608})] + for index, field, wrong in controls: + changed = copy.deepcopy(records) + changed[index][field] = wrong + try: + validate(*changed, finite, bindings, invoice) + except ValueError: + continue + raise ValueError("accepted receipt control: " + field) + for field, wrong in [("stock_l2_bits", 1322), ("physical_stock_bits", 2644), + ("required_reserve_bits", 1510), ("max_active_depth", 17)]: + changed = copy.deepcopy(invoice) + changed["blocknorm"][field] = wrong + try: + validate(*records, finite, bindings, changed) + except ValueError: + continue + raise ValueError("accepted actual-invoice control: " + field) + return dict(status="PASS_T148_STORED_RELEASE_BINDINGS", rejected_controls=len(controls) + 4, + receipt_controls=len(controls), actual_invoice_controls=4, + kappa=records[0]["kappa"], gain=records[0]["gain"], + scope="Recomputed finite invoice and stored relations; no fresh cold replay.") + + +if __name__ == "__main__": + print(json.dumps(run(), indent=2, sort_keys=True)) From 78e77d820393c6b8648b47af219e991edfcc54e6 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Fri, 16 Oct 2026 20:17:50 +0100 Subject: [PATCH 2/5] feat(research): release the T740 R1 cap composition --- research/rank7-t740-release/.gitattributes | 3 + research/rank7-t740-release/ENGINEERING.md | 45 + research/rank7-t740-release/GIT-SOURCES.json | 38 + research/rank7-t740-release/PINS.json | 29 + research/rank7-t740-release/README.md | 195 ++++ research/rank7-t740-release/SOURCES.json | 84 ++ research/rank7-t740-release/TASK.json | 127 +++ research/rank7-t740-release/VENDOR.json | 114 +++ research/rank7-t740-release/VERIFY.json | 61 ++ research/rank7-t740-release/decisions.tsv | 10 + .../evidence/ADAPTER-DERIVATION.json | 147 +++ .../evidence/ADMISSION-RESULT.json | 382 ++++++++ .../evidence/ADMISSION-STAGES.json | 113 +++ .../rank7-t740-release/evidence/BINDINGS.json | 7 + .../evidence/BINDINGS.log.txt | 7 + .../evidence/COMPOSITION-RESULT.json | 92 ++ .../evidence/DISCOVERY-AUDIT.json | 104 +++ .../evidence/DISCOVERY-INVOICE.json.gz | Bin 0 -> 56988 bytes .../evidence/DISCOVERY-RESULT.json | 261 ++++++ .../evidence/DISCOVERY-STAGES.json | 44 + .../evidence/ENVIRONMENT.json | 10 + .../rank7-t740-release/evidence/FINITE.json | 94 ++ .../INITIAL-BOOTSTRAP-FAILURE.log.txt | 4 + .../evidence/INVOICE-PAYLOAD.json | 6 + .../evidence/MATERIALIZED.json | 7 + .../evidence/NATIVE-ENVIRONMENT.json | 13 + .../evidence/NATIVE-RECEIPT.json | 113 +++ .../evidence/OUTER-CLAIM.json | 13 + .../evidence/OWNERS-RESULT.json | 1 + .../rank7-t740-release/evidence/RECIPE.json | 238 +++++ .../evidence/RELEASE-RECEIPT.json | 7 + .../rank7-t740-release/evidence/STAGES.json | 80 ++ .../evidence/logs/complete-admission.log.txt | 8 + .../evidence/logs/declared-edit-stage.log.txt | 1 + .../logs/derive-closed-adapters.log.txt | 1 + .../evidence/logs/export-pr2833.log.txt | 1 + .../evidence/logs/export-pr2894.log.txt | 1 + .../evidence/logs/four-kernel-stage.log.txt | 1 + .../logs/fresh-current-native.log.txt | 3 + .../logs/fresh-retained-bootstrap.log.txt | 6 + .../logs/paired-extension-stage.log.txt | 1 + .../evidence/logs/parent-paired-stage.log.txt | 1 + .../evidence/logs/preload-stage.log.txt | 1 + .../evidence/logs/rank7-overlay-stage.log.txt | 1 + .../evidence/logs/source-preflight.log.txt | 1 + .../evidence/optimized_tests.log.txt | 13 + .../evidence/registered.log.txt | 25 + .../evidence/registered_finite.log.txt | 17 + .../rank7-t740-release/evidence/tests.log.txt | 13 + research/rank7-t740-release/materialize.py | 119 +++ research/rank7-t740-release/reproduce.py | 259 ++++++ research/rank7-t740-release/test_verify.py | 123 +++ .../vendor/PR3021-RESULT.json | 92 ++ .../vendor/pr3015/CLAIM.json | 229 +++++ .../vendor/pr3015/CREDITS.md | 17 + .../vendor/pr3015/MANIFEST.json | 156 ++++ .../rank7-t740-release/vendor/pr3015/NOTICE | 28 + .../vendor/pr3015/allocation/PROVIDERS.json | 842 ++++++++++++++++++ .../vendor/pr3015/edits/EDITS.json | 216 +++++ .../pr3015/edits/FINAL-WORD-base.json.gz | Bin 0 -> 71434 bytes .../pr3015/edits/FINAL-WORD-extra.json.gz | Bin 0 -> 71430 bytes .../vendor/pr3018/EXCHANGE.json | 126 +++ .../vendor/pr3021-FINITE.json | 89 ++ .../vendor/pr3021/reproduce.py | 260 ++++++ .../vendor/pr3021/verify.py | 267 ++++++ .../vendor/pr3024/EXCHANGE.json | 559 ++++++++++++ .../vendor/pr3024/cap_proof.py | 257 ++++++ .../rank7-t740-release/vendor/pr3024/lift.py | 152 ++++ research/rank7-t740-release/verify.py | 108 +++ research/rank7-t740-release/verify_release.py | 105 +++ 70 files changed, 6548 insertions(+) create mode 100644 research/rank7-t740-release/.gitattributes create mode 100644 research/rank7-t740-release/ENGINEERING.md create mode 100644 research/rank7-t740-release/GIT-SOURCES.json create mode 100644 research/rank7-t740-release/PINS.json create mode 100644 research/rank7-t740-release/README.md create mode 100644 research/rank7-t740-release/SOURCES.json create mode 100644 research/rank7-t740-release/TASK.json create mode 100644 research/rank7-t740-release/VENDOR.json create mode 100644 research/rank7-t740-release/VERIFY.json create mode 100644 research/rank7-t740-release/decisions.tsv create mode 100644 research/rank7-t740-release/evidence/ADAPTER-DERIVATION.json create mode 100644 research/rank7-t740-release/evidence/ADMISSION-RESULT.json create mode 100644 research/rank7-t740-release/evidence/ADMISSION-STAGES.json create mode 100644 research/rank7-t740-release/evidence/BINDINGS.json create mode 100644 research/rank7-t740-release/evidence/BINDINGS.log.txt create mode 100644 research/rank7-t740-release/evidence/COMPOSITION-RESULT.json create mode 100644 research/rank7-t740-release/evidence/DISCOVERY-AUDIT.json create mode 100644 research/rank7-t740-release/evidence/DISCOVERY-INVOICE.json.gz create mode 100644 research/rank7-t740-release/evidence/DISCOVERY-RESULT.json create mode 100644 research/rank7-t740-release/evidence/DISCOVERY-STAGES.json create mode 100644 research/rank7-t740-release/evidence/ENVIRONMENT.json create mode 100644 research/rank7-t740-release/evidence/FINITE.json create mode 100644 research/rank7-t740-release/evidence/INITIAL-BOOTSTRAP-FAILURE.log.txt create mode 100644 research/rank7-t740-release/evidence/INVOICE-PAYLOAD.json create mode 100644 research/rank7-t740-release/evidence/MATERIALIZED.json create mode 100644 research/rank7-t740-release/evidence/NATIVE-ENVIRONMENT.json create mode 100644 research/rank7-t740-release/evidence/NATIVE-RECEIPT.json create mode 100644 research/rank7-t740-release/evidence/OUTER-CLAIM.json create mode 100644 research/rank7-t740-release/evidence/OWNERS-RESULT.json create mode 100644 research/rank7-t740-release/evidence/RECIPE.json create mode 100644 research/rank7-t740-release/evidence/RELEASE-RECEIPT.json create mode 100644 research/rank7-t740-release/evidence/STAGES.json create mode 100644 research/rank7-t740-release/evidence/logs/complete-admission.log.txt create mode 100644 research/rank7-t740-release/evidence/logs/declared-edit-stage.log.txt create mode 100644 research/rank7-t740-release/evidence/logs/derive-closed-adapters.log.txt create mode 100644 research/rank7-t740-release/evidence/logs/export-pr2833.log.txt create mode 100644 research/rank7-t740-release/evidence/logs/export-pr2894.log.txt create mode 100644 research/rank7-t740-release/evidence/logs/four-kernel-stage.log.txt create mode 100644 research/rank7-t740-release/evidence/logs/fresh-current-native.log.txt create mode 100644 research/rank7-t740-release/evidence/logs/fresh-retained-bootstrap.log.txt create mode 100644 research/rank7-t740-release/evidence/logs/paired-extension-stage.log.txt create mode 100644 research/rank7-t740-release/evidence/logs/parent-paired-stage.log.txt create mode 100644 research/rank7-t740-release/evidence/logs/preload-stage.log.txt create mode 100644 research/rank7-t740-release/evidence/logs/rank7-overlay-stage.log.txt create mode 100644 research/rank7-t740-release/evidence/logs/source-preflight.log.txt create mode 100644 research/rank7-t740-release/evidence/optimized_tests.log.txt create mode 100644 research/rank7-t740-release/evidence/registered.log.txt create mode 100644 research/rank7-t740-release/evidence/registered_finite.log.txt create mode 100644 research/rank7-t740-release/evidence/tests.log.txt create mode 100755 research/rank7-t740-release/materialize.py create mode 100755 research/rank7-t740-release/reproduce.py create mode 100644 research/rank7-t740-release/test_verify.py create mode 100644 research/rank7-t740-release/vendor/PR3021-RESULT.json create mode 100644 research/rank7-t740-release/vendor/pr3015/CLAIM.json create mode 100644 research/rank7-t740-release/vendor/pr3015/CREDITS.md create mode 100644 research/rank7-t740-release/vendor/pr3015/MANIFEST.json create mode 100644 research/rank7-t740-release/vendor/pr3015/NOTICE create mode 100644 research/rank7-t740-release/vendor/pr3015/allocation/PROVIDERS.json create mode 100644 research/rank7-t740-release/vendor/pr3015/edits/EDITS.json create mode 100644 research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-base.json.gz create mode 100644 research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-extra.json.gz create mode 100644 research/rank7-t740-release/vendor/pr3018/EXCHANGE.json create mode 100644 research/rank7-t740-release/vendor/pr3021-FINITE.json create mode 100644 research/rank7-t740-release/vendor/pr3021/reproduce.py create mode 100644 research/rank7-t740-release/vendor/pr3021/verify.py create mode 100644 research/rank7-t740-release/vendor/pr3024/EXCHANGE.json create mode 100644 research/rank7-t740-release/vendor/pr3024/cap_proof.py create mode 100644 research/rank7-t740-release/vendor/pr3024/lift.py create mode 100755 research/rank7-t740-release/verify.py create mode 100755 research/rank7-t740-release/verify_release.py diff --git a/research/rank7-t740-release/.gitattributes b/research/rank7-t740-release/.gitattributes new file mode 100644 index 0000000000..009a4747f7 --- /dev/null +++ b/research/rank7-t740-release/.gitattributes @@ -0,0 +1,3 @@ +# Retain exact predecessor and execution-receipt bytes. +vendor/** -text -whitespace +evidence/** -text -whitespace diff --git a/research/rank7-t740-release/ENGINEERING.md b/research/rank7-t740-release/ENGINEERING.md new file mode 100644 index 0000000000..f92fb02449 --- /dev/null +++ b/research/rank7-t740-release/ENGINEERING.md @@ -0,0 +1,45 @@ +# Engineering bounds and retained-source exceptions + +Build the Lever shaped the contribution into an executable streaming +materializer and source-bound release wrapper. Prove It Works requires the +actual literal-owner recount and a fresh source/native/admission/outer chain, +rather than a moment comparison alone. + +New code has structured control flow and no recursion. Explicit domains are +740 replicas, 6,660 calls, 408 helpers per call, 2,717,280 streamed rows, +550 journal records, 36 group factors, 2 providers, 13 source stages and at +most 100 pinned inputs. Retained native subprocess stages have 1,800-second +timeouts; source export has a 60-second timeout. Process groups are terminated +on every stage exit. Files use scoped context managers. Workspaces must be +fresh and external to the package. Source and output failures propagate. + +Rule 3, fixed memory: Python and the retained numerical libraries allocate +managed objects during execution. Materialization streams rows and gzip output; +the finite owner engine has bounded dictionaries for 1,491,840 bins, plus +6,660 helper/family masks. Input decoding is limited to 150 MB in the new +finite checker. Full admission retains its existing resource model and finite +input domains. The package does not claim allocation-free execution or a +measured peak-memory bound. Follow-up is a bounded streaming replacement only +if actual replay memory becomes a blocker. + +Rule 8, source compilation: one explicit `exec(compile(...))` executes an +exactly SHA256-authenticated Python source from PINS.json. This avoids stale +bytecode replacing the pinned source. Only fixed call sites select the retained +lift, R1 checker, owner, cap and interval modules. The narrowly annotated S102 +diagnostic records that required exception. Source drift controls reject before +execution. Follow-up is a source-loading API that preserves the same bytecode +isolation if the project supplies one. + +Rules 2, 4 and 10 for retained engines: the original files are frozen and +byte-identical, including their existing loop/function conventions and +assertions. They are not refactored as part of this isolated mathematical +composition. The full wrapper refuses optimization because inherited native +validators use assertions; new finite invariants use explicit exceptions and +remain enabled under optimization. Functions changed here remain below the +rough 60-line review limit. Ruff, warnings-as-errors, optimized finite replay, +behavioral controls and registered source-pin checks cover the new files. +No TypeScript or JavaScript is changed. + +The original PR3021 process-group runner and exact-tree export are adapted +with attribution. Their retained source is included for line-by-line review. +Read-only internal review is distinguished from independent human review. diff --git a/research/rank7-t740-release/GIT-SOURCES.json b/research/rank7-t740-release/GIT-SOURCES.json new file mode 100644 index 0000000000..c0df1d757c --- /dev/null +++ b/research/rank7-t740-release/GIT-SOURCES.json @@ -0,0 +1,38 @@ +[ + { + "head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "path": "research/rank7-joint-endframes-restore-edit" + }, + { + "head": "51309592971e3b5be935599eed2a95404dc7781e", + "path": "research/two-sided-helper-extraction" + }, + { + "head": "224bd5e56041c40078ff6b5fa7393733a215de5c", + "path": "research/paired-helper-extension" + }, + { + "head": "a027b0f6fdb0ab2b42ba10fc31b53960166bf2bf", + "path": "research/paired-extension-normal45" + }, + { + "head": "b74b25f3ccc84c16e1a801d73b2f47e5ea764c78", + "path": "research/paired-extension-cap-fill-swaps" + }, + { + "head": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "path": "research/paired-extension-normal45-rewrites" + }, + { + "head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "path": "research/paired-swap-normal45" + }, + { + "head": "18d03c447886895ef9abf888398178e0428533ca", + "path": "research/shared-kernel-packing" + }, + { + "head": "e9307b48d7d1b690939935ecef0f8e524e6d92f4", + "path": "research/gmx-t74-borrow43-handoff" + } +] diff --git a/research/rank7-t740-release/PINS.json b/research/rank7-t740-release/PINS.json new file mode 100644 index 0000000000..61098b716f --- /dev/null +++ b/research/rank7-t740-release/PINS.json @@ -0,0 +1,29 @@ +{ + "research/rank7-joint-endframes/allocation/DISPATCH.json": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c", + "research/rank7-joint-endframes/allocation/FILL.json.gz": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "research/rank7-joint-endframes/allocation/ORDER.json": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1", + "research/rank7-joint-endframes/allocation/PROVIDERS.json": "f2edb7922f3029a5d607437e737775ff3371bca49ebab62e5e2495d16d3bf573", + "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "research/rank7-joint-endframes/allocation/vendor/independent_owners.py": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461", + "research/rank7-joint-endframes/certificates/RELAX-CAP.json": "b272680de5842f7fd5f442cd0aeadfd317fe6af266ddee1a1e0738a919ba856e", + "research/rank7-joint-endframes/data/WORD-base.json.gz": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "research/rank7-joint-endframes/data/WORD-extra.json.gz": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7", + "research/rank7-joint-endframes/tools/root.py": "55f5aca39b5ee2fe4687ac8863e6c24569010f27a332883c069b8e14b8fe09e3", + "research/rank7-t740-release/vendor/PR3021-RESULT.json": "cdc4874dcb17714fbe10f003a4a4516b80a9ddccfc7199278a53baa13c5d3a04", + "research/rank7-t740-release/vendor/pr3015/CLAIM.json": "f9b9fbaaac794c0ce279c238a33a2f34f8c91a34d97ccdeb5ec98b7b8ba56d73", + "research/rank7-t740-release/vendor/pr3015/CREDITS.md": "bd4b09fcd2861933883cbce6ecf0e30743d5d3b4cb0cc38e258530c370c121b9", + "research/rank7-t740-release/vendor/pr3015/MANIFEST.json": "5e113822c0c36ee7dd9366578fbaf5daa108b8c51e37f4d10eda25dd6ed52cae", + "research/rank7-t740-release/vendor/pr3015/NOTICE": "ffcc3de2243815db0e9fb8d820b4ca511fce3c7673c966e14b486f05d30ac11a", + "research/rank7-t740-release/vendor/pr3015/allocation/PROVIDERS.json": "f52d926752eac5d847092dd58bfb9f3f3c6ac36adf39cd6a3c4d4a3b2d1fce15", + "research/rank7-t740-release/vendor/pr3015/edits/EDITS.json": "c9c68660d07bfd12ed20fd8cbfe3d36301ceb2d7bb9b4ea11350cc399b19e0b1", + "research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-base.json.gz": "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5", + "research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-extra.json.gz": "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea", + "research/rank7-t740-release/vendor/pr3018/EXCHANGE.json": "8a103f643ad12d8074972f41e4359d9487eb8b96fc6849e1a178adb61b36578b", + "research/rank7-t740-release/vendor/pr3021-FINITE.json": "f7f6aca1e2596d7049ff2bc69c523013324f568f86fd31b1f29899b96b2617eb", + "research/rank7-t740-release/vendor/pr3021/reproduce.py": "8dffca928c1ad1a36423b18a33a3f591af0e46bb3482e0e1cf127ddb613ef11b", + "research/rank7-t740-release/vendor/pr3021/verify.py": "dac43246695dfc618ffc49866c1c2e1ba08bc7fd7d2deec2b6aa6b9c292d9cf3", + "research/rank7-t740-release/vendor/pr3024/EXCHANGE.json": "18b3af92dab108945fa7033a2476a8521416b403415a31cdbbe2d1315bb1c827", + "research/rank7-t740-release/vendor/pr3024/cap_proof.py": "7c5f362ed21dbbdbd6a0632aebef424213a37c47c86151a0520d097e8f4e321f", + "research/rank7-t740-release/vendor/pr3024/lift.py": "ae6c1fee78fbdec26976ca74ca89f6aab2528d763c596f6573132cb54d57cd3c" +} diff --git a/research/rank7-t740-release/README.md b/research/rank7-t740-release/README.md new file mode 100644 index 0000000000..458c859085 --- /dev/null +++ b/research/rank7-t740-release/README.md @@ -0,0 +1,195 @@ +# T740 cap allocation composed with the R1 restore edit + +The exact T740 allocation in Nick Petalas's [PR3024][3024] composes with +Jeremy Kothe's literal R1 words in [PR3015][3015]. The complete conditional +complex moment root lies in + +```text +[0.0017291527560043309345350, 0.0017291527560043309345351]. +``` + +Compared with the already composed T74 construction in [PR3021][3021], the +gain is in `[1.5520213124915363e-9, 1.5520213124915365e-9]`. +Every local child, idle remainder and all 91 private buffers remain charged. +The unchanged 2,551-pattern relaxation is recertified at the R1 root, so this +allocation also attains the exact fixed-inventory cap for the R1 words in that +model. The selected frontier is unchanged. + +A fresh complete source/native/admission/modern-outer release passes and +certifies + +```text +kappa = 0.001729152756004330934535 - 10^-46 - 10^-70. +``` + +Its exact gain over PR3021's released kappa is +`1552021312491537/10^24`. The earlier interval compares the two complex moment +roots; released nominations use the source's 24-digit grid and strict margins. +The recorded stages total 1,751.78 seconds locally. This is a conditional finite +release, not a complete multiplication theorem or selected-frontier update. + +## Construction and proof + +The scientific base is canonical main +`d8e0f83f00191df62174b641e9fff055c357f641`, priority revision 6. Exact predecessor +heads and original paths are in [VENDOR.json](VENDOR.json); main inputs are in +[SOURCES.json](SOURCES.json). Retained sources are byte-identical. This closes +PR3024's released completion handoff. Concurrent [PR3028][3028], at +`9d10633660a3dff5469f4e7a0a009a6c9994c0d7`, now reports a T148+R1 release at +`0.001729152337142958365650 - 10^-46 - 10^-70`. That report is not independently +validated here. T740 has a larger charged physical stock and reaches the exact +fixed-inventory cap; its released endpoint exceeds the reported T148 endpoint +by about `4.18861372569e-10`. The constructions and their receipts are separate. +The [canonical investigation][discussion] records scope and live overlap. + +R1 changes only `restore`, its derived `cleanup`, and the reported local paid +profile. The exact three-register rational action is unchanged. The retained +PR3021 checker verifies the literal edit and inverse cleanup in both providers. +A/B, warps, source cut, helper endpoints and every ordered helper width remain +unchanged. Each call has local-profile delta `-2 H1 + H2`. + +Apply PR3018's preimage-bound 103-row journal to the original T74 fill. For +each resulting row `(t,h,o,c,p,z)` and copy `j` in `0..9`, use + +```text +row index = j*271728 + original row index +row = (10*t+j, h, o+74*j, c, p, z) +call = (original stage, original replica+74*j). +``` + +Apply PR3024's exact 550-row journal, preserving each call/helper identity. +The source intervals lift to `(10*lo+j,10*hi+j]`, preserving `lo=-1`. +The actual T740 order interleaves copies, while the fill serializes rows in +copy-major order. Call time is explicit in every row. The retained independent +owner checker accepts that representation and checks every role, source +window, family exclusion, capacity, disjoint mask and compact pending prefix. + +There are 6,660 calls and 2,717,280 roles. Their complete R1 profile is + +```text +{1:16443540, 2:4708620, 3:1594737, 4:719280, + 5:137085, 8:53280, 48:281903}. +``` + +Its rank mass is `48,165,120 = 740*65,088`. Its idle profile is +`{1:173160, 3:49617, 5:17205, 48:281903}`. Physical stock is +`663040 + 408 + 8 + 91 + 2 = 663549`. The old owner checker's `live+490` +diagnostic omits 19 buffers; the new receipt explicitly charges `live+509`. + +Write `Hr(b)=r*(73/r)^b`. Subtracting ten copies of PR3021's complete bill gives + +```text +20 H1 + 17 H3 - 15 H5 - 10 H14 + 3 H48 < 0, + for every 0 < b <= 1/100. +``` + +The unchanged R1 per-call charge cancels in this comparison. PR3024's retained +rational derivative proof certifies the strict sign over the whole interval; +the verifier reruns it. The moment denominator scales by ten, so this gives a +strict root improvement. The authenticated rational logarithm/Taylor engine +separately certifies both endpoints and the stated gain interval. + +The width inventory, capacity counts and feasible patterns are unchanged. +The verifier substitutes the actual R1 local profile and new root bracket into +the retained cap certificate. It rechecks the complete primal basis and all +2,551 reduced costs over that bracket, with 12 identically tight patterns and +2,539 strictly positive ones. Its primal idle counts times 740 equal the +literal idle histogram. This is exact cap attainment for the fixed additive +bin model, without a new search or an optimality claim for other contracts. + +## Physical and prefix bounds + +The source admission derives `T` from the actual order. The wrapper changes +exactly its `--fill`, `--order` and `--dispatch` arguments. It preserves all +source/native, reconstruction, parent-lift, rebind and outer acceptance gates. +Reusing the old T74 order or release receipt would not certify this construction. + +The T740 namespaces are centers `[663040,663048)`, helper tableau +`[663048,663456)`, private buffers `[663456,663547)`, and coefficient work +`[663547,663549)`. For the retained `Sp(72,2)` factor, + +```text +G = 2^1296 * product(j=1..36, 2^(2*j)-1) +bit_length(G * 663549) = 2647 +stock_l2_bits = 1324 +reserve = 128 + 37 + 18 + 1324 + 1 + 4 = 1512 <= 2048. +``` + +The 18 active-call/bridge layers are per replica. They do not grow to 18T. +The retained candidate guards `physical<=2^20` and `stock_l2_bits<=1330` hold. +The arbitrary-T parent requires 93 dedicated bank groups and its own rebuilt +invoice; its physical stock is not substituted into the candidate's guard. +Fresh source-bound discovery also passes the emitted-program audit, invoice, +assembly and independent check. Its actual local prefix is 93 bits and its +global prefix is 1,477 bits; the charged payload remains 2,048 bits. The +[discovery invoice](evidence/DISCOVERY-INVOICE.json.gz) records these measurements +and all physical/native charges. The complete release reruns the program audit, +admission controls and independent outer checks. Its [receipt](evidence/RELEASE-RECEIPT.json) is bound to the exact +new allocation, source and endpoint. + +## Reproduce and evidence limits + +Python 3.12 and its standard library suffice for the registered finite check: + +```sh +uv run --python 3.12 --no-project python -B scripts/research_package.py \ + --package research/rank7-t740-release +``` + +The full replay additionally needs NumPy, SciPy, SymPy and mpmath, a native C++ +compiler, and the pinned Git source commits. gmpy2 and psutil are optional. +[ENVIRONMENT.json](evidence/ENVIRONMENT.json) records the actual local versions. +Fetch the exact source objects listed in [GIT-SOURCES.json](GIT-SOURCES.json) +into a full repository before the network-free recipe: + +```sh +python3 -c 'import json, subprocess; subprocess.run(["git", "fetch", "origin", *[r["head"] for r in json.load(open("research/rank7-t740-release/GIT-SOURCES.json"))]], check=True)' +python3.12 -B research/rank7-t740-release/reproduce.py \ + --repo . --work /tmp/t740-r1-fresh +``` + +Use a fresh, external work path. The materializer streams canonical JSON and +records compressed and decompressed payload hashes. Receipts bind the exact +new allocation, order, dispatch, words, source manifest and released endpoint. +The registered check replays the finite proof, eight behavioral groups and +rematerialized-input/stored-release bindings, including six rejecting receipt +mutants. The separate full command reruns the source/native/admission/outer chain. +An initial standard-library-only full replay failed at missing NumPy; its +failure is recorded rather than presented as mathematical rejection. + +The checker reuses explicitly credited source arithmetic and geometry. It is +not an independent implementation of those engines. A separate internal +read-only review checks the T-dependent formulas and source compatibility; +there is no independent human or formal-kernel review claim. Inherited +all-size/compiler, arbitrary-dirty/native realization, physical backing and +movement, precision/tape, caller, analytic-transfer and universal block-energy +hypotheses remain. No selected-result file or frozen predecessor is changed. + +## Open next questions + +Independently replay the exact T740 composition before considering adoption. +Start with the pinned source/native recipe and compare the canonical fill +payload, every complete profile and the modern outer receipt. The larger +replica count makes old T74 receipts insufficient. Scientific dependencies and +the inherited theorem hypotheses remain separate review obligations. No further +packing search inside this attained fixed-inventory cap is justified here. + +## Credit and engineering + +Nick Petalas. Apache-2.0. Substantial automated assistance was used; no +independent human or formal-kernel review is claimed. + +Credit Jeremy Kothe for R1, Nick Petalas for the PR3018/3024 allocation and +PR3021 composition, Marius-Paul Dumitrean for PR2979, and Mason Hale, Jeremy +Diviney, Yiyang Lu, Tekalign, Ross Richardson, Dugongue, icekylinx, +themilkman216 and the retained geometry/native/owner lineage. Original +[CREDITS.md](vendor/pr3015/CREDITS.md) and [NOTICE](vendor/pr3015/NOTICE) remain. +[ENGINEERING.md](ENGINEERING.md) records the bounded-runtime and source-loading +deviations; [decisions.tsv](decisions.tsv) records the session decisions. + +[3015]: https://github.com/CrocSwap/integer-mult-bounds/pull/3015 +[3021]: https://github.com/CrocSwap/integer-mult-bounds/pull/3021 +[3024]: https://github.com/CrocSwap/integer-mult-bounds/pull/3024 +[discussion]: https://github.com/CrocSwap/integer-mult-bounds/discussions/2612#discussioncomment-18980805 + +[3028]: https://github.com/CrocSwap/integer-mult-bounds/pull/3028 diff --git a/research/rank7-t740-release/SOURCES.json b/research/rank7-t740-release/SOURCES.json new file mode 100644 index 0000000000..c21259dcb9 --- /dev/null +++ b/research/rank7-t740-release/SOURCES.json @@ -0,0 +1,84 @@ +{ + "schema_version": 1, + "base_commit": "d8e0f83f00191df62174b641e9fff055c357f641", + "files": [ + { + "path": "research/rank7-joint-endframes/allocation/DISPATCH.json", + "usage": "input", + "git_blob": "9544fee4e6ee1f202cee22bfaeaf229ee3b2515e", + "sha256": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c" + }, + { + "path": "research/rank7-joint-endframes/allocation/FILL.json.gz", + "usage": "input", + "git_blob": "8d4fd644d60ba2c98106dc770803b647afdf0963", + "sha256": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39" + }, + { + "path": "research/rank7-joint-endframes/allocation/ORDER.json", + "usage": "input", + "git_blob": "7409c4df1092241729739596c7648bda504e6aad", + "sha256": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1" + }, + { + "path": "research/rank7-joint-endframes/allocation/PROVIDERS.json", + "usage": "input", + "git_blob": "e1d99e12cfa3ac8375984d85c0b040dc36ea1312", + "sha256": "f2edb7922f3029a5d607437e737775ff3371bca49ebab62e5e2495d16d3bf573" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/independent_owners.py", + "usage": "input", + "git_blob": "16013201b19054f7e45398ecf10af74c9c6a9114", + "sha256": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461" + }, + { + "path": "research/rank7-joint-endframes/certificates/RELAX-CAP.json", + "usage": "input", + "git_blob": "14de38f85eedf4a96500173576184a439348328c", + "sha256": "b272680de5842f7fd5f442cd0aeadfd317fe6af266ddee1a1e0738a919ba856e" + }, + { + "path": "research/rank7-joint-endframes/data/WORD-base.json.gz", + "usage": "input", + "git_blob": "d9aa96a93fea5f7395e7783aef0bc117c0a0ae89", + "sha256": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d" + }, + { + "path": "research/rank7-joint-endframes/data/WORD-extra.json.gz", + "usage": "input", + "git_blob": "74f6cb64595c21f7726ae77e69437868620bdcee", + "sha256": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7" + }, + { + "path": "research/rank7-joint-endframes/tools/root.py", + "usage": "input", + "git_blob": "bd6dc2eb4e5013625d17cc08461b67622bcfed69", + "sha256": "55f5aca39b5ee2fe4687ac8863e6c24569010f27a332883c069b8e14b8fe09e3" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + } + ] +} diff --git a/research/rank7-t740-release/TASK.json b/research/rank7-t740-release/TASK.json new file mode 100644 index 0000000000..b2005d587f --- /dev/null +++ b/research/rank7-t740-release/TASK.json @@ -0,0 +1,127 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 6, + "base_commit": "d8e0f83f00191df62174b641e9fff055c357f641", + "original_card": { + "id": "independent-moment", + "question": "Does one changed supplier or assembly claim lack a source-bound independent check of a specific new implication?", + "starting_points": [ + "certificates/selected-result.json", + "research/rank7-joint-endframes/README.md", + "docs/research/research-family-status.md" + ], + "methods": [ + "Independently reconstruct a coordinated frame/circuit change and its single-change control, then derive the complete rank and physical ledger.", + "Implement certified moment inequalities through a different exact enclosure method." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2979 joint rank-7 end-frame proposal and the revision-6 evidence status. Its claimed kappa is not selected. Compare coordinated changes with the losing single-change controls and locate the complete physical ledger; an aggregate moment alone does not validate the mechanism.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Prioritize a bounded independent audit of #2979: reconstruct one joint group and its single-lowering control, check the declared frames/chronology, then trace changed children, idle widths and cleanup buffers into the complete invoice and both supplier caps. Choose one still-missing implication after checking existing audits. Stop with exact unresolved dependencies if full admission exceeds the session; do not launch a new lowering census on an unvalidated premise or substitute extra root digits for mechanism checking.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Promoting #2979 from merged source archive to validated supplier solely from author PASS receipts or aggregate pricing." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering" + ] + }, + "scope_status": "changed", + "actual_scope": "Materialize PR3024 T740 owners and compose PR3015 R1 through a fresh source/native/admission/modern-outer release, rederiving every T-dependent physical/prefix cost.", + "scope_change_reason": "The released PR3024 handoff requests T740 construction completion; the donor requests a mathematical gain. The active T148 admission handoff is explicitly excluded. The old independent-moment audit card is changed to a source-bound constructive successor.", + "bottleneck_link": "The composed complete moment strictly improves the binding complex conditional endpoint, with the larger literal T740 physical stock and all local, idle, prefix and consumer costs charged.", + "budget_minutes": 60, + "stop_rule": "One composition and one full source recipe. Stop on failed compatibility/semantic/admission gate or at session cap. Do not expand lowering or packing searches.", + "outcome": "completed", + "evidence": "Fresh retained bootstrap, all source overlays, both edited native providers, literal owners/parent, strict discovery, independent arithmetic and complete modern-outer release pass. Recorded stages total1751.78s. Released kappa=0.001729152756004330934535-10^-46-10^-70; exact gain overPR3021=1552021312491537/1000000000000000000000000. All2717280 roles,663549 candidate physical families,1085402 parent physical families,91 private buffers and charged2048-bit prefix remain accounted. Eight behavioral groups and all2551 pattern inequalities pass; six rejecting stored-receipt mutants and complete registered replay pass. Publication-byte checks are recorded separately.", + "author": "Nick Petalas", + "ai_assistance": "Substantial automated assistance; no independent human or formal-kernel review claimed.", + "open_questions": [ + { + "question": "Can an independent replay validate this exact T740 composition before adoption?", + "why_it_matters": "The larger physical stock requires its own source-bound supplier/outer evidence.", + "first_step": "Run reproduce.py from the pinned source commits in a fresh workspace, compare canonical fill payload and complete profile.", + "blocked_by": "An independent full replay needs the scientific/native dependencies and about30 minutes on the recorded host; inherited all-size/compiler, physical, precision/tape and universal block-energy premises remain." + } + ], + "coordination_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2612#discussioncomment-18980805", + "predecessors": [ + { + "pr": 3024, + "head": "315df10c07cf8b8ee9af9b2122750635bb2582ae", + "author": "Nick Petalas", + "delta": "exact T740 cap-attaining allocation and journal" + }, + { + "pr": 3021, + "head": "217edac2ebfa6250536bd6df153de14901a69395", + "author": "Nick Petalas", + "delta": "R1 + improving T74 packing composition and release recipe" + }, + { + "pr": 3015, + "head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "author": "Jeremy Kothe", + "delta": "literal R1 words, native/release source recipe" + } + ], + "family_decision": "Complete only the released T740 source/consumer contract. No new packing or word search; exact finite costs and optimistic prefix allowance are known. Stop on a failed admission gate. Selected frontier is unchanged.", + "overlap_check": { + "checked_at": "2026-10-16T19:16:42Z", + "coverage": { + "open_prs": { + "fetched_at": "2026-10-16T19:15:47.195620+00:00", + "complete_pagination": true, + "records": 271 + }, + "discussions": { + "fetched_at": "2026-10-16T19:16:17.176687+00:00", + "complete_pagination": true, + "records": 1754 + }, + "closed_prs": { + "fetched_at": "2026-10-16T19:16:42.312838+00:00", + "complete_pagination": true, + "records": 2440 + } + }, + "nearest": "PR3024 supplies T740; PR3021 is the released baseline. Concurrent PR3028 now reports completion of the separately claimed T148 release, head9d10633660a3dff5469f4e7a0a009a6c9994c0d7. No other T740 completion found.", + "limitations": "Snapshots are non-atomic; titles/bodies/comments/local notes, not arbitrary code diffs or unpublished work." + }, + "upstream_checkpoint": { + "commit": "d8e0f83f00191df62174b641e9fff055c357f641", + "priority_revision": 6, + "checked_at": "2026-10-16T19:14:57Z", + "guidance_and_selected_record_changed": false + }, + "attempts": 1, + "metric": "Strictly increase the complete released conditional kappa above PR3021, with exact interval comparisons and the source10^-24 nomination grid.", + "rejected_hypotheses": [], + "concurrent_result": { + "pr": 3028, + "head": "9d10633660a3dff5469f4e7a0a009a6c9994c0d7", + "evidence_status": "reported conditional release, not independently validated here", + "reported_kappa": "0.001729152337142958365650 - 10^-46 - 10^-70", + "difference_to_reported_endpoint": "83772274513777/200000000000000000000000", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/3028" + } +} diff --git a/research/rank7-t740-release/VENDOR.json b/research/rank7-t740-release/VENDOR.json new file mode 100644 index 0000000000..65bf1d7f93 --- /dev/null +++ b/research/rank7-t740-release/VENDOR.json @@ -0,0 +1,114 @@ +[ + { + "path": "vendor/PR3021-RESULT.json", + "sha256": "cdc4874dcb17714fbe10f003a4a4516b80a9ddccfc7199278a53baa13c5d3a04", + "source_head": "217edac2ebfa6250536bd6df153de14901a69395", + "source_path": "research/rank7-restore-packing-composition/evidence/COMPOSITION-RESULT.json", + "git_blob": "399bcc26f0684cced978e3a4c90f834551f62dd7" + }, + { + "path": "vendor/pr3015/CLAIM.json", + "sha256": "f9b9fbaaac794c0ce279c238a33a2f34f8c91a34d97ccdeb5ec98b7b8ba56d73", + "source_head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "source_path": "research/rank7-joint-endframes-restore-edit/CLAIM.json", + "git_blob": "70813f559e2878f0c5403c0b859eefe602f70abc" + }, + { + "path": "vendor/pr3015/CREDITS.md", + "sha256": "bd4b09fcd2861933883cbce6ecf0e30743d5d3b4cb0cc38e258530c370c121b9", + "source_head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "source_path": "research/rank7-joint-endframes-restore-edit/CREDITS.md", + "git_blob": "3b6022cd64d7753e65e1c710d91a69596e389042" + }, + { + "path": "vendor/pr3015/MANIFEST.json", + "sha256": "5e113822c0c36ee7dd9366578fbaf5daa108b8c51e37f4d10eda25dd6ed52cae", + "source_head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "source_path": "research/rank7-joint-endframes-restore-edit/MANIFEST.json", + "git_blob": "a331a50f94b698f02092d4647c8be5385d9dd57c" + }, + { + "path": "vendor/pr3015/NOTICE", + "sha256": "ffcc3de2243815db0e9fb8d820b4ca511fce3c7673c966e14b486f05d30ac11a", + "source_head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "source_path": "research/rank7-joint-endframes-restore-edit/NOTICE", + "git_blob": "70a09b472e3c2d82b3e805d82ef898d3ad48e758" + }, + { + "path": "vendor/pr3015/allocation/PROVIDERS.json", + "sha256": "f52d926752eac5d847092dd58bfb9f3f3c6ac36adf39cd6a3c4d4a3b2d1fce15", + "source_head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "source_path": "research/rank7-joint-endframes-restore-edit/allocation/PROVIDERS.json", + "git_blob": "cac6220d3dcb1d323e083d6ff04bc7bc0f00eba9" + }, + { + "path": "vendor/pr3015/edits/EDITS.json", + "sha256": "c9c68660d07bfd12ed20fd8cbfe3d36301ceb2d7bb9b4ea11350cc399b19e0b1", + "source_head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "source_path": "research/rank7-joint-endframes-restore-edit/edits/EDITS.json", + "git_blob": "90894fc6592951eaa3b4e25467d3a85c36b2d988" + }, + { + "path": "vendor/pr3015/edits/FINAL-WORD-base.json.gz", + "sha256": "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5", + "source_head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "source_path": "research/rank7-joint-endframes-restore-edit/edits/FINAL-WORD-base.json.gz", + "git_blob": "4f0483657396a7f735873e1b252482c53dfb2eb6" + }, + { + "path": "vendor/pr3015/edits/FINAL-WORD-extra.json.gz", + "sha256": "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea", + "source_head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "source_path": "research/rank7-joint-endframes-restore-edit/edits/FINAL-WORD-extra.json.gz", + "git_blob": "81f95e21ede115e8bdb6bd522c641b37b740bdf7" + }, + { + "path": "vendor/pr3018/EXCHANGE.json", + "sha256": "8a103f643ad12d8074972f41e4359d9487eb8b96fc6849e1a178adb61b36578b", + "source_head": "ca7113157d7c959fdfa9d7cd17ef92d3877070d0", + "source_path": "research/rank7-integrality-exchange/EXCHANGE.json", + "git_blob": "1260c8d95f573a574e007038263adf883b5ecbd2" + }, + { + "path": "vendor/pr3021/reproduce.py", + "sha256": "8dffca928c1ad1a36423b18a33a3f591af0e46bb3482e0e1cf127ddb613ef11b", + "source_head": "217edac2ebfa6250536bd6df153de14901a69395", + "source_path": "research/rank7-restore-packing-composition/reproduce.py", + "git_blob": "f8f295f6cf377559ae59c6e40972b635b5ce2f21" + }, + { + "path": "vendor/pr3021/verify.py", + "sha256": "dac43246695dfc618ffc49866c1c2e1ba08bc7fd7d2deec2b6aa6b9c292d9cf3", + "source_head": "217edac2ebfa6250536bd6df153de14901a69395", + "source_path": "research/rank7-restore-packing-composition/verify.py", + "git_blob": "84902a90d268579f4110cbb298375365d8121021" + }, + { + "path": "vendor/pr3021-FINITE.json", + "sha256": "f7f6aca1e2596d7049ff2bc69c523013324f568f86fd31b1f29899b96b2617eb", + "source_head": "217edac2ebfa6250536bd6df153de14901a69395", + "source_path": "research/rank7-restore-packing-composition/evidence/FINITE.json", + "git_blob": "6f73992ff764a3d527d4fd551057dc6fa254127e" + }, + { + "path": "vendor/pr3024/EXCHANGE.json", + "sha256": "18b3af92dab108945fa7033a2476a8521416b403415a31cdbbe2d1315bb1c827", + "source_head": "315df10c07cf8b8ee9af9b2122750635bb2582ae", + "source_path": "research/rank7-cap740/EXCHANGE.json", + "git_blob": "1b1a904ff05e848bfb2793597b9613cc997c3367" + }, + { + "path": "vendor/pr3024/cap_proof.py", + "sha256": "7c5f362ed21dbbdbd6a0632aebef424213a37c47c86151a0520d097e8f4e321f", + "source_head": "315df10c07cf8b8ee9af9b2122750635bb2582ae", + "source_path": "research/rank7-cap740/cap_proof.py", + "git_blob": "28f0995a69fbb003238f5ee8d1acf407bb1b37be" + }, + { + "path": "vendor/pr3024/lift.py", + "sha256": "ae6c1fee78fbdec26976ca74ca89f6aab2528d763c596f6573132cb54d57cd3c", + "source_head": "315df10c07cf8b8ee9af9b2122750635bb2582ae", + "source_path": "research/rank7-cap740/lift.py", + "git_blob": "717067dfce61c530205e8dad7ab3e76376f2c179" + } +] diff --git a/research/rank7-t740-release/VERIFY.json b/research/rank7-t740-release/VERIFY.json new file mode 100644 index 0000000000..2558ffdd17 --- /dev/null +++ b/research/rank7-t740-release/VERIFY.json @@ -0,0 +1,61 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/rank7-joint-endframes/allocation/DISPATCH.json", + "research/rank7-joint-endframes/allocation/FILL.json.gz", + "research/rank7-joint-endframes/allocation/ORDER.json", + "research/rank7-joint-endframes/allocation/PROVIDERS.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/certificates/RELAX-CAP.json", + "research/rank7-joint-endframes/data/WORD-base.json.gz", + "research/rank7-joint-endframes/data/WORD-extra.json.gz", + "research/rank7-joint-endframes/tools/root.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "-W", + "error", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Exact R1 word/cleanup compatibility; all2717280 roles, ordered widths, source windows, family collisions, compact prefixes, paid profile,91 buffers and physical/prefix bound; exact R1 root and2551-pattern cap recertification." + }, + { + "argv": [ + "{python}", + "-B", + "-W", + "error", + "-m", + "unittest", + "discover", + "-s", + "{package}", + "-p", + "test_*.py", + "-v" + ], + "timeout_seconds": 120, + "checks": "Eight behavioral groups: all three admission inputs, T740 chronology/dispatch, materialized capacity fault, stock/buffers/prefix, source drift before compile, truncated output, unpaid child, R1 scalar and dirty cleanup mutants." + }, + { + "argv": [ + "{python}", + "-B", + "-W", + "error", + "{package}/verify_release.py" + ], + "timeout_seconds": 120, + "checks": "Rematerialize exact T740 fill,order and dispatch; authenticate stored fresh native/admission/outer/stage-log bindings and strict released gain, with six rejecting receipt mutants. Does not rerun the full native chain." + } + ] +} diff --git a/research/rank7-t740-release/decisions.tsv b/research/rank7-t740-release/decisions.tsv new file mode 100644 index 0000000000..95ce556d35 --- /dev/null +++ b/research/rank7-t740-release/decisions.tsv @@ -0,0 +1,10 @@ +timestamp phase decision reason evidence result +2026-10-16T18:44:00Z selection take T740 release handoff user requests mathematical improvement PR3024 and live discussion2612 T148 work excluded; exact sources frozen +2026-10-16T18:49:00Z finite retain composed T740 R1 profile all roles and full stock pass; strict root gain evidence/FINITE.json cap recertified at changed R1 root +2026-10-16T18:49:00Z environment restart failed bootstrap in existing scientific environment bare3.12 lacked numpy initial missing-NumPy log retained in runtime workspace four native bootstrap providers now pass; no mathematical rejection +2026-10-16T18:51:00Z source continue one full T740 admission fresh retained bootstrap and all source overlays pass /tmp/imb-t740-release-final/STAGES.json R1 source manifest92153122 and91-buffer adapters rederived +2026-10-16T18:51:00Z verification canonicalize finite JSON keys before receipt comparison JSON converts integer histogram keys to strings registered CLI detected receipt mismatch mathematical fields unchanged; rerun actual CLI after regeneration +2026-10-16T18:51:00Z native proceed to T740 complete admission both edited native providers pass and source manifests match /tmp/imb-t740-release-final/fresh-current-native.log final owner/parent/consumer invoices rebuilding +2026-10-16T19:01:50Z admission retain literal emitted T740 program strict audit, invoice, assembly and freeze passed /tmp/imb-t740-release-final/run/candidate/discovery/STAGES.json remaining admission controls and outer release pending +2026-10-16T19:14:32Z release accept complete conditional T740 R1 release all13 fresh stages pass; exact gain overPR3021 evidence/COMPOSITION-RESULT.json and RELEASE-RECEIPT.json kappa0.001729152756004330934535 minus strict margins; selected frontier unchanged +2026-10-16T19:16:49Z publication bind modern outer headline and compact invoice supplier-only CLAIM is a different scoped endpoint evidence/OUTER-CLAIM.json; INVOICE-PAYLOAD.json modern headline equals release; compressed invoice retains exact decompressed bytes diff --git a/research/rank7-t740-release/evidence/ADAPTER-DERIVATION.json b/research/rank7-t740-release/evidence/ADAPTER-DERIVATION.json new file mode 100644 index 0000000000..b86fa9595c --- /dev/null +++ b/research/rank7-t740-release/evidence/ADAPTER-DERIVATION.json @@ -0,0 +1,147 @@ +{ + "status": "PASS_CHECKED_91_BUFFER_ADAPTER_DERIVATION_R13", + "parent_head": "51309592971e3b5be935599eed2a95404dc7781e", + "parent_manifest_sha256": "9dba3fe371602ec023a54e26c0fd66f69eb7a74be86aab89923529083c14b36f", + "source_commit": "rank7-joint-endframes-pr2917", + "source_profile": "rank7-joint-endframes", + "upstream_head": "224bd5e56041c40078ff6b5fa7393733a215de5c", + "source_manifest_sha256": "9215312229c431078ba61daf106edb8caf20b33f48317d46438a341552cf153f", + "source_files": 642, + "comparisons": { + "pr2908": { + "pr": 2908, + "head": "51309592971e3b5be935599eed2a95404dc7781e", + "sha256": "2406680a07b43a69b0f12f8462cc43f3616f3c8cb0a46bc767541b45945cd2bf" + }, + "pr2917": { + "pr": 2917, + "head": "224bd5e56041c40078ff6b5fa7393733a215de5c", + "sha256": "e6c836c0178661a53a69cd91f29d83585e876f2511ff40c6b6204cd270fbdeac" + }, + "pr2966": { + "pr": 2966, + "head": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "sha256": "4d4c4800bf3bcb36d09021313b2712aebd4aa0830c74dda30991daf6851c220a" + }, + "pr2969": { + "pr": 2969, + "head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "sha256": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77" + } + }, + "retained_receipt_sha256": "ba991831771331653d9187516540089809254b18144a8c1800ce39f7a840f896", + "buffer_count": 91, + "physical_overhead": 509, + "width_classes": { + "gauge44": 6, + "extra": 6 + }, + "admission_controls": 139, + "changes": { + "prepare_extension_native.py": { + "source": "/private/tmp/imb-t740-release-final/run/pr2908/tools/prepare_channel_native.py", + "before_sha256": "4d207b9bbe3e0b8a86d10ad5d5f329a81da0cf56dce6c03e6fdd5b78e581ce91", + "after_sha256": "9e6424b70efff445b31e2b35c0d462a786207072919a67410a645cef12dd4a55", + "replacements": [ + { + "old": "SOURCE_SHA='56cf455752722051d598a7da1e5ee700637fbaef09189f534413dbe6e0525a83'", + "new": "SOURCE_SHA='9215312229c431078ba61daf106edb8caf20b33f48317d46438a341552cf153f'" + }, + { + "old": "SOURCE_FILES=610", + "new": "SOURCE_FILES=642" + }, + { + "old": "SOURCE_COMMIT='two-sided-helper408-pr2894'", + "new": "SOURCE_COMMIT='rank7-joint-endframes-pr2917'" + }, + { + "old": "OLD_RECEIPT_SHA='dd36443f2789ffa6deca7210c76ada781e2b9b7e622a546b366f51a475faff3e'", + "new": "OLD_RECEIPT_SHA='ba991831771331653d9187516540089809254b18144a8c1800ce39f7a840f896'" + }, + { + "old": "len(can['zero_buffers'])==73", + "new": "len(can['zero_buffers'])==91" + } + ] + }, + "admit_extension.py": { + "source": "/private/tmp/imb-t740-release-final/run/pr2908/tools/admit_channel408.py", + "before_sha256": "a62c21eac4e0df502cbfb78c88b19a763fd351cde3c11c0588874f84db6992bf", + "after_sha256": "e0250e81477b2f623ef4330319bdfffbdd1efaba298430f816149bf669ba0b54", + "replacements": [ + { + "old": " 'channel408': dict(commit='two-sided-helper408-pr2894',manifest='56cf455752722051d598a7da1e5ee700637fbaef09189f534413dbe6e0525a83',helpers=408,source_file_count=610,upstream_head='18d03c447886895ef9abf888398178e0428533ca'),", + "new": " 'rank7-joint-endframes': dict(commit='rank7-joint-endframes-pr2917',manifest='9215312229c431078ba61daf106edb8caf20b33f48317d46438a341552cf153f',helpers=408,source_file_count=642,upstream_head='224bd5e56041c40078ff6b5fa7393733a215de5c')," + }, + { + "old": "COMPARISONS = {", + "new": "COMPARISONS = {\n 'pr2908': dict(pr=2908,head='51309592971e3b5be935599eed2a95404dc7781e',sha256='2406680a07b43a69b0f12f8462cc43f3616f3c8cb0a46bc767541b45945cd2bf',field='kappa'),\n 'pr2917': dict(pr=2917,head='224bd5e56041c40078ff6b5fa7393733a215de5c',sha256='e6c836c0178661a53a69cd91f29d83585e876f2511ff40c6b6204cd270fbdeac',field='kappa'),\n 'pr2966': dict(pr=2966,head='e62d3eb9005117d82a9babcfa937ecc53237c490',sha256='4d4c4800bf3bcb36d09021313b2712aebd4aa0830c74dda30991daf6851c220a',field='kappa'),\n 'pr2969': dict(pr=2969,head='e2ca469b08385d3d5e29a918d66dbefaf889e9f3',sha256='656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77',field='kappa')," + }, + { + "old": "ap.add_argument('--source-profile', choices=['channel408'], default='channel408')", + "new": "ap.add_argument('--source-profile', choices=['rank7-joint-endframes'], default='rank7-joint-endframes')" + }, + { + "old": "ap.add_argument('--comparison-profile', choices=['pr2894'], default='pr2894')", + "new": "ap.add_argument('--comparison-profile', choices=['pr2908','pr2917','pr2966','pr2969'], default='pr2908')" + }, + { + "old": "zero_buffers_allocated_and_cleared=73", + "new": "zero_buffers_allocated_and_cleared=91" + }, + { + "old": "len(c.get('zero_buffers',[]))==73, 'helper408 physical ABI including all 73 private buffers'", + "new": "len(c.get('zero_buffers',[]))==91, 'paired extension physical ABI including all 91 private buffers'" + }, + { + "old": "896*T+expected_helpers+8+73+2, 'complete physical cost including all actual helpers and 73 buffers'", + "new": "896*T+expected_helpers+8+91+2, 'complete physical cost including all actual helpers and 91 buffers'" + }, + { + "old": "\"len(rd(work/'ADMISSION-CONTROLS.json')['rejected_controls'])==119\")", + "new": "\"len(rd(work/'ADMISSION-CONTROLS.json')['rejected_controls'])==139\")" + }, + { + "old": "\"controls=dict(admission=119,", + "new": "\"controls=dict(admission=139," + } + ] + }, + "extension_blocknorm.py": { + "source": "/private/tmp/imb-t740-release-final/run/pr2908/tools/channel_blocknorm.py", + "before_sha256": "b53ebd53e3948f658c6da4f487a9ea10c9cb0a6acf2435750a32d6efeb9869c0", + "after_sha256": "6e6b8683cc87a84e5410c399b1128eb68694f852a3927cb124067f503ed7d7c7", + "replacements": [ + { + "old": "len(allocated)==73, 'all73 private zero buffers released'", + "new": "len(allocated)==91, 'all91 private zero buffers released'" + }, + { + "old": "'zero_buffers_allocated_and_cleared':73", + "new": "'zero_buffers_allocated_and_cleared':91" + }, + { + "old": "r['zero_buffers_returned_to_zero']==73", + "new": "r['zero_buffers_returned_to_zero']==91" + }, + { + "old": "physical==live+8+408+73+2", + "new": "physical==live+8+408+91+2" + }, + { + "old": "'zero_buffers':[live+416,live+489], 'coefficient':[live+489,live+491]", + "new": "'zero_buffers':[live+416,live+507], 'coefficient':[live+507,live+509]" + }, + { + "old": "len(mp)==73 and set(mp.values())==set(range(*ns['zero_buffers'])), '73distinct private Z slots'", + "new": "len(mp)==91 and set(mp.values())==set(range(*ns['zero_buffers'])), '91distinct private Z slots'" + }, + { + "old": "T=len(order)//9; live=896*T; physical=live+490", + "new": "T=len(order)//9; live=896*T; physical=live+509" + } + ] + } + } +} diff --git a/research/rank7-t740-release/evidence/ADMISSION-RESULT.json b/research/rank7-t740-release/evidence/ADMISSION-RESULT.json new file mode 100644 index 0000000000..196cdb8101 --- /dev/null +++ b/research/rank7-t740-release/evidence/ADMISSION-RESULT.json @@ -0,0 +1,382 @@ +{ + "actual_expected_helpers": 408, + "comparison_claim_sha256": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77", + "comparison_head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "comparison_kappa": "17240352247481048785499999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "comparison_pr": 2969, + "complex_lower": "345830551200866186907/200000000000000000000000", + "dispatch_sha256": "90edc935320dd6264e98dc735d868df3c95f5901c70d7d96171001fcb295cce0", + "external_input_sha256": { + "/private/tmp/imb-t740-release-final/COMPOSED-FILL.json.gz": "0608f8cc5f5b2d67de84924540c6166ef109c77af6690c95ef4d9b72f86dad2c", + "/private/tmp/imb-t740-release-final/DISPATCH.json": "90edc935320dd6264e98dc735d868df3c95f5901c70d7d96171001fcb295cce0", + "/private/tmp/imb-t740-release-final/ORDER.json": "927226d702bf3cada076f4c459da9063c0df7e7154a62955cf75c40cf30215b9", + "/private/tmp/imb-t740-release-final/run/adapters/extension_blocknorm.py": "6e6b8683cc87a84e5410c399b1128eb68694f852a3927cb124067f503ed7d7c7", + "/private/tmp/imb-t740-release-final/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839/lift_parent.py": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "/private/tmp/imb-t740-release-final/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839/reconstruct_replica.py": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "/private/tmp/imb-t740-release-final/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839/replica_parent.py": "48bdbf28f59d80edb266803ec61bf5e22e8fb5e5a0e2b88004b6039147589bd4", + "/private/tmp/imb-t740-release-final/run/pr2969/CLAIM.json": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77" + }, + "fill_sha256": "0608f8cc5f5b2d67de84924540c6166ef109c77af6690c95ef4d9b72f86dad2c", + "gain": "1023506251245211197/200000000000000000000000", + "kappa": "17291527560043309345349999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017291527560043309345349999999999999999999998999999999999999999999999", + "native_receipt_sha256": "c80cb6e9283e746c5d24aa2590e3a22f566929cd16ac7b00431dae2b1da6c859", + "order_sha256": "927226d702bf3cada076f4c459da9063c0df7e7154a62955cf75c40cf30215b9", + "package_manifest_sha256": "117119098284f63bb3e18b9a4e88f424385775512f8220268b0a43a3a517d8f7", + "patches": [ + { + "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "path": "new/rebind.py", + "replacements": [ + [ + "physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))" + ] + ] + }, + { + "after_sha256": "99bef04f24a99088e5c0c9b8f6bbc8386669d8315b8f572d6bbfb932c5d51145", + "before_sha256": "7edb4732b34e5814b27650a55c938626cb50d68f06397744dd4fe451437e90e0", + "path": "geometry_controls.py", + "replacements": [ + [ + " i['complete_invocation_sweeps']=i['bridge_sweeps']=333", + " i['complete_invocation_sweeps']-=1;i['bridge_sweeps']-=1" + ], + [ + " o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);oh=digest(o);i['owner_audit_sha256']=oh", + " o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);assert (o,i)!=(owner,invoice), 'geometry mutant must change actual receipts';oh=digest(o);i['owner_audit_sha256']=oh" + ] + ] + }, + { + "after_sha256": "6cfefe80c02a6c0f243f50ca9e146e1ab1440b84a033d8a71d42be5a5fa27f6b", + "before_sha256": "c43680a2da390f79925547a5ee1919d8a76637cccf98e2c8164b6f667fbc3183", + "path": "verify_release.py", + "replacements": [ + [ + "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)", + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))" + ], + [ + "epsilon=1-(1025/1024)e-3080", + "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}" + ], + [ + "at the one 3000-digit rejection call", + "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call" + ] + ] + }, + { + "after_sha256": "1dd56009986eb14dd6603c9193c7ad71dd45c7d005bf71c9cd3f916e66f54d98", + "before_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "path": "outer/check_ledger.py", + "replacements": [ + [ + "assert (m,W)==(73,66304)", + "T=spec['geometry']['replicas']\nassert type(T) is int and T>0\nassert m==73 and W==896*T and W==BJ['live']" + ] + ] + }, + { + "after_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "before_sha256": "08ca58abff11bdfba721dc56ab8acf06ec1b7c48a8699a0955cf35324680aca7", + "path": "code/witness.py", + "replacements": [ + [ + " with open(os.environ['WITNESS_RECORD'],'a')as f:f.write(json.dumps([key,got],default=str)+chr(10))", + " import time as _wr_time\n _wr_path=Path(os.environ['WITNESS_RECORD'])\n _wr_lock=_wr_path.with_name(_wr_path.name+'.append.lock')\n _wr_deadline=_wr_time.monotonic()+60\n _wr_fd=None\n while _wr_fd is None:\n try:_wr_fd=os.open(_wr_lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY)\n except FileExistsError:\n if _wr_time.monotonic()>=_wr_deadline:raise TimeoutError('discovery record lock timeout; existing lock preserved')\n _wr_time.sleep(.005)\n try:\n with _wr_path.open('a',encoding='utf-8',newline='\\n')as _wr_out:\n _wr_out.write(json.dumps([key,got],default=str)+chr(10))\n _wr_out.flush()\n finally:\n os.close(_wr_fd)\n _wr_lock.unlink()" + ] + ] + }, + { + "after_sha256": "2964ea185a64061d72e4a6c648a48cd0ddbfc7ea8174ecb39be2a2eee52a3be8", + "before_sha256": "8dee5aa1663a70edcf1099a30b72166d89c29fa29ba2025fb5707fdbcc237f83", + "path": "verify.py", + "replacements": [ + [ + "run('lift-parent',P/'lift_parent.py','--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')", + "run('lift-parent',P/'lift_parent.py','--package',P,'--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')" + ] + ] + }, + { + "after_sha256": "0d8cc021d2401d047aaec79060ec2ea28ba06f12eca8dbf4c60c78bb31975c4e", + "before_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "path": "code/witness.py", + "replacements": [ + [ + "PAYLOAD==1<<(192+(GEO['dimension']+1)//2+2*CALLS+4).bit_length()", + "PAYLOAD==1<<(128+(GEO['dimension']+1)//2+18+1330+1+4).bit_length()" + ] + ] + }, + { + "after_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "before_sha256": "bb213d0af12218ff7c9c572717e522d8bbeeb2856b87a253f4a7f44e0fd71f15", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " required_prefix=localbits+input_l2_bits+call_count+bridge_sweeps+4", + " from blocknorm_certificate import certify\n blocknorm=certify(template, {pid:base/'providers'/pid for pid in template['local_providers']})\n assert blocknorm['status'] == 'PASS_TENSOR_BLOCK_NORM_CERTIFICATE'\n assert localbits <= 128, 'actual native scalar/Horner prefix exceeds charged local reserve'\n required_prefix=localbits+input_l2_bits+blocknorm['max_active_depth']+blocknorm['stock_l2_bits']+1+4" + ] + ] + }, + { + "after_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "before_sha256": "02502a217fe8c9e10229075b50745518beac512c48db20e64c3e06514a4da5b5", + "path": "independent_core.py", + "replacements": [ + [ + " payload = 1 << (192 + (M+1)//2 + 2*len(c['order']) + 4).bit_length()", + " require(localbits <= 128, 'measured native prefix exceeds local reserve')\n payload = 1 << (128 + (M+1)//2 + 18 + 1330 + 1 + 4).bit_length()" + ] + ] + }, + { + "after_sha256": "d598a2ac1e2e8eaee14a8c285e0277a7ae44ca6a15bd2b5cfc67fb40844fb387", + "before_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,", + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,blocknorm=blocknorm," + ], + [ + " primitive_arithmetic_margin_bits=4,controller_audit_sha256=", + " tensor_block_norm=blocknorm,partial_cover_margin_bits=1,physical_stock_l2_bits=blocknorm['stock_l2_bits'],primitive_arithmetic_margin_bits=4,controller_audit_sha256=" + ], + [ + "Sum every actual invocation and bridge sweep and take the maximum local scalar/Horner prefix over both orientations of the fixed provider.", + "All invocations and bridge sweeps remain charged. Bound completed-boundary energy by at most eighteen active steps per owner replica, using exact tensor-isomorphic whole-family helper unitaries. Add the full group-indexed physical-stock sup-to-l2 factor and one partial-cover margin, then the maximum local scalar/Horner prefix." + ] + ] + }, + { + "after_sha256": "e051aaa166e01263780d5ae03699690670b597fed6593af4c37a7e978825eb85", + "before_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "path": "independent_core.py", + "replacements": [ + [ + " prefix = localbits + (M + 1) // 2 + len(c['order']) + c['bridges'] + 4", + " bn=c['blocknorm']\n require(bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['max_active_depth']==18 and bn['stock_l2_bits']<=1330, 'independent tensor block certificate')\n prefix = localbits + (M + 1) // 2 + bn['max_active_depth'] + bn['stock_l2_bits'] + 1 + 4" + ], + [ + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], margin=4)", + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], active_block_depth=18,stock_l2=bn['stock_l2_bits'],partial_cover=1,margin=4),blocknorm=bn" + ] + ] + }, + { + "after_sha256": "393323f150d0bb686419804d51cf43d0f58450d2a1e7929725acdd26fdbb3640", + "before_sha256": "2286f00e462ff28abbb3f396095463482a1e063213b9526a7225275980c77eaf", + "path": "audit_mixed.py", + "replacements": [ + [ + "pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)", + "import blocknorm_certificate as BN;ctx['blocknorm']=BN.certify_context(ctx,roles,dirs,source_parent=parent);pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)" + ] + ] + }, + { + "after_sha256": "0542dde915af8902324db2f59136da078d5256bfaa8f1510f3e59336be7e2680", + "before_sha256": "f25e1e870df5d5a16a1e367b3df8843cb01644ab4b75895d7939af81e4fcb833", + "path": "code/assemble.py", + "replacements": [ + [ + " assert invoice['global_prefix_bits']==max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())+37+CALLS+CALLS+4", + " bn=invoice['blocknorm']\n assert bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['replicas']==REPLICAS\n assert bn['max_active_depth']==bn['boundary_depth_bits']==18 and bn['active_calls_per_block']==bn['bridges_per_block']==9\n assert bn['block_width_families']==896 and bn['physical_families']==invoice['physical'] and bn['live_families']==invoice['live']\n assert bn['partial_cover_bits']==1 and bn['input_l2_bits']==37 and bn['local_reserve_bits']==128 and bn['retained_payload_bits']==PAYLOAD\n localbits=max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())\n assert bn['local_actual_prefix_bits']==localbits and localbits<=128\n assert invoice['global_prefix_bits']==bn['actual_prefix_bits']==localbits+37+18+bn['stock_l2_bits']+1+4\n assert bn['required_reserve_bits']==128+37+18+bn['stock_l2_bits']+1+48Xfa5doe~LL>dTqgr3 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 literal 0 HcmV?d00001 diff --git a/research/rank7-t740-release/evidence/DISCOVERY-RESULT.json b/research/rank7-t740-release/evidence/DISCOVERY-RESULT.json new file mode 100644 index 0000000000..00fbf5d926 --- /dev/null +++ b/research/rank7-t740-release/evidence/DISCOVERY-RESULT.json @@ -0,0 +1,261 @@ +{ + "status": "DISCOVERY", + "kappa": "107885496746239/62500000000000000", + "kappa_decimal": "0.001726167947939824", + "steps": [ + { + "name": "bind", + "seconds": 7.123191082995618, + "exit_code": 0, + "log_sha256": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a" + }, + { + "name": "emit", + "seconds": 102.62566216700361, + "exit_code": 0, + "log_sha256": "93a265d78a2aaa19f88042b7d7dccaa292ae83450e11539060c1efd931bb4b14" + }, + { + "name": "audit", + "seconds": 435.70251566698425, + "exit_code": 0, + "log_sha256": "32c4d27226099f5d9e0b809f87d122f841b0f2a8d830f533e232491bf2dc622f" + }, + { + "name": "invoice", + "seconds": 9.936585415998707, + "exit_code": 0, + "log_sha256": "5e2031203af4c50de455eaaa7c8d69e99665f1ff612f96aaef502399a5b3fb59" + }, + { + "name": "assembly", + "seconds": 0.36290320797706954, + "exit_code": 0, + "log_sha256": "712d9130165c5aea9fa31eadaa74971fc47a4a9b072f16c9f25483c4dbd01af7" + }, + { + "name": "freeze", + "seconds": 0.08724591598729603, + "exit_code": 0, + "log_sha256": "d37c284382b497bd1730433d6b26ace70c94c4757eca6df9c271b158793ad8b3" + }, + { + "name": "independent", + "seconds": 13.087569833005546, + "exit_code": 0, + "log_sha256": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe" + } + ], + "independent": { + "status": "PASS_INDEPENDENT_VARIABLE_T_LITERAL_WINDOWS_CHARTS_PREFIX_ROW", + "roles": 2717280, + "calls": 6660, + "source_events_per_replica": 30, + "expanded_replica_events": 22200, + "bridge_events": 6660, + "literal_windows": 13320, + "checked_whole_helper_widths": 2717280, + "checked_busy_family_windows": 2717280, + "orthogonal_port_bases": 112, + "actual_73_axis_charts": 8675, + "checked_slice_prefixes": 1491840, + "local_profiles": { + "gauge44": { + "1": 2443, + "2": 707, + "3": 232, + "4": 108, + "8": 8, + "5": 18 + }, + "extra": { + "1": 2443, + "2": 707, + "3": 232, + "4": 108, + "8": 8, + "5": 18 + } + }, + "width_inventories": { + "gauge44": { + "9": 213, + "8": 99, + "7": 52, + "4": 26, + "6": 16, + "5": 2 + }, + "extra": { + "9": 213, + "8": 99, + "7": 52, + "4": 26, + "6": 16, + "5": 2 + } + }, + "idle": { + "1": 173160, + "3": 49617, + "5": 17205, + "48": 281903 + }, + "profile": { + "1": 16443540, + "2": 4708620, + "3": 1594737, + "4": 719280, + "5": 137085, + "8": 53280, + "48": 281903 + }, + "live": 663040, + "physical": 663549, + "rank_mass": 48165120, + "deficit": 236800, + "namespace": { + "data": [ + 0, + 663040 + ], + "centres": [ + 663040, + 663048 + ], + "tableau": [ + 663048, + 663456 + ], + "zero_buffers": [ + 663456, + 663547 + ], + "coefficient": [ + 663547, + 663549 + ] + }, + "local_prefix_bits": 93, + "local_prefix_from_native_receipt": true, + "local_profile_recounted": true, + "prefix_formula": { + "local_scalar": 93, + "input_l2": 37, + "invocations": 6660, + "bridges": 6660, + "active_block_depth": 18, + "stock_l2": 1324, + "partial_cover": 1, + "margin": 4 + }, + "blocknorm": { + "status": "PASS_TENSOR_BLOCK_NORM_CERTIFICATE", + "replicas": 740, + "physical_families": 663549, + "live_families": 663040, + "max_active_depth": 18, + "boundary_depth_bits": 18, + "stock_l2_bits": 1324, + "stocknorm_bits": 1324, + "physical_stock_bits": 2647, + "partial_cover_bits": 1, + "local_actual_prefix_bits": 93, + "local_reserve_bits": 128, + "input_l2_bits": 37, + "actual_prefix_bits": 1477, + "required_reserve_bits": 1512, + "retained_payload_bits": 2048, + "foreign_helper_roles_checked": 2513525, + "endpoint_replay": { + "gauge44": { + "forward": { + "all_arbitrary_columns": 632, + "helper_to_data_response_zero": true, + "centres_first_clear_and_terminal_zero": 8, + "zero_buffers_allocated_and_cleared": 91, + "coefficient_work_contract": "unchanged audited clear-before-and-after Horner macro" + }, + "backward": { + "all_arbitrary_columns": 632, + "helper_to_data_response_zero": true, + "centres_first_clear_and_terminal_zero": 8, + "zero_buffers_allocated_and_cleared": 91, + "coefficient_work_contract": "unchanged audited clear-before-and-after Horner macro" + } + }, + "extra": { + "forward": { + "all_arbitrary_columns": 632, + "helper_to_data_response_zero": true, + "centres_first_clear_and_terminal_zero": 8, + "zero_buffers_allocated_and_cleared": 91, + "coefficient_work_contract": "unchanged audited clear-before-and-after Horner macro" + }, + "backward": { + "all_arbitrary_columns": 632, + "helper_to_data_response_zero": true, + "centres_first_clear_and_terminal_zero": 8, + "zero_buffers_allocated_and_cleared": 91, + "coefficient_work_contract": "unchanged audited clear-before-and-after Horner macro" + } + } + }, + "scope": "Pre-emission finite premises only. Caller must retain exact source projection, actual phase/primitive audits, check_roles windows/charts and complete release." + }, + "prefix_bits": 1477, + "charged_prefix_bits": 2048, + "physical_stock_bits": 2647, + "physical_row_coefficient": 19551, + "row_limit": 20161, + "scope": "Finite role/window/chart and inherited prefix/row obligations. Requires separately admitted local supplier and emitted controller, complete finite invoice, exact moments and outer assembly; no all-size theorem is asserted.", + "controls_rejected": [ + { + "name": "private_namespace_collision", + "reason": "private-namespace collision" + }, + { + "name": "copy_replica_alias", + "reason": "role invocation time" + }, + { + "name": "missing_whole_helper", + "reason": "complete helper role count" + }, + { + "name": "split_whole_helper", + "reason": "complete helper role count" + }, + { + "name": "truncated_helper_width", + "reason": "whole-helper residual width" + }, + { + "name": "cross_idle_boundary", + "reason": "strict bridge-aware idle window" + }, + { + "name": "cross_child_pending_axis_alias", + "reason": "overlapping pending children on one family" + }, + { + "name": "wrong_provider_at_changed_call", + "reason": "whole-helper residual width" + } + ], + "disjoint_pending_child_axis_checks": 2016, + "provider_counts": { + "extra": 4160, + "gauge44": 2500 + }, + "input_sha256": { + "/private/tmp/imb-t740-release-final/run/candidate/layout/packing74/candidate/PLAN.json": "194d2314bc1d980232d6b81300df1a0cba31d838738e2d1175d5b104276501cf", + "/private/tmp/imb-t740-release-final/run/candidate/layout/packing74/candidate/DISPATCH.json": "a13039c054df03e0d13a2fbf1c8bfc201b11bb878dfbc1cfbc00307609f2ddd0", + "/private/tmp/imb-t740-release-final/run/candidate/layout/packing74/candidate/OWNERS.json.gz": "222ac1c3ee0f9b82b9e57d5fa6b98f6f667ca5943935f4a046225ff10178d4ca", + "/private/tmp/imb-t740-release-final/run/candidate/layout/demotions1148-round43/baseline-replay/parent/t16/global8/base/split-centres/GLOBAL-TEMPLATE.json.gz": "ab8448de2036a23d9b55a196a8846512dc24fdf09855c1e0f0caa5b7a6965f7b", + "/private/tmp/imb-t740-release-final/run/native/native-cache/77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5/local/CANONICAL-WORD.json.gz": "11e4ccf43f23103bb53b66fe44d4d2c8d13ac37731ddafcf2b24a3d68a6919a6", + "/private/tmp/imb-t740-release-final/run/candidate/layout/packing74/native-extra/local/CANONICAL-WORD.json.gz": "49bdedd78e5630d0e24b0a7e649aa4bf0643e99fb9a01da458c63a6260b51a61" + } + }, + "scope": "Conditional finite construction only; unchanged exact-head PR1297 native providers explicitly reused; all inherited theorem obligations retained." +} \ No newline at end of file diff --git a/research/rank7-t740-release/evidence/DISCOVERY-STAGES.json b/research/rank7-t740-release/evidence/DISCOVERY-STAGES.json new file mode 100644 index 0000000000..2e21be9285 --- /dev/null +++ b/research/rank7-t740-release/evidence/DISCOVERY-STAGES.json @@ -0,0 +1,44 @@ +[ + { + "name": "bind", + "seconds": 7.123191082995618, + "exit_code": 0, + "log_sha256": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a" + }, + { + "name": "emit", + "seconds": 102.62566216700361, + "exit_code": 0, + "log_sha256": "93a265d78a2aaa19f88042b7d7dccaa292ae83450e11539060c1efd931bb4b14" + }, + { + "name": "audit", + "seconds": 435.70251566698425, + "exit_code": 0, + "log_sha256": "32c4d27226099f5d9e0b809f87d122f841b0f2a8d830f533e232491bf2dc622f" + }, + { + "name": "invoice", + "seconds": 9.936585415998707, + "exit_code": 0, + "log_sha256": "5e2031203af4c50de455eaaa7c8d69e99665f1ff612f96aaef502399a5b3fb59" + }, + { + "name": "assembly", + "seconds": 0.36290320797706954, + "exit_code": 0, + "log_sha256": "712d9130165c5aea9fa31eadaa74971fc47a4a9b072f16c9f25483c4dbd01af7" + }, + { + "name": "freeze", + "seconds": 0.08724591598729603, + "exit_code": 0, + "log_sha256": "d37c284382b497bd1730433d6b26ace70c94c4757eca6df9c271b158793ad8b3" + }, + { + "name": "independent", + "seconds": 13.087569833005546, + "exit_code": 0, + "log_sha256": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe" + } +] \ No newline at end of file diff --git a/research/rank7-t740-release/evidence/ENVIRONMENT.json b/research/rank7-t740-release/evidence/ENVIRONMENT.json new file mode 100644 index 0000000000..20aa647f51 --- /dev/null +++ b/research/rank7-t740-release/evidence/ENVIRONMENT.json @@ -0,0 +1,10 @@ +{ + "python": "3.12.15 (main, Oct 14 2026, 00:55:37) [Clang 23.1.3 ]", + "platform": "macOS-27.0.1-arm64-arm-64bit", + "numpy": "2.5.4", + "scipy": "1.18.1", + "sympy": "1.14.0", + "mpmath": "1.3.0", + "gmpy2": "unavailable; optional", + "psutil": "unavailable; optional" +} diff --git a/research/rank7-t740-release/evidence/FINITE.json b/research/rank7-t740-release/evidence/FINITE.json new file mode 100644 index 0000000000..0ddf2aba46 --- /dev/null +++ b/research/rank7-t740-release/evidence/FINITE.json @@ -0,0 +1,94 @@ +{ + "calls": 6660, + "idle": { + "1": 173160, + "3": 49617, + "48": 281903, + "5": 17205 + }, + "live": 663040, + "moment": { + "exchange_sign": { + "delta": { + "1": 20, + "14": -10, + "3": 17, + "48": 3, + "5": -15 + }, + "factored_f_derivative_upper": "-9740691/100000", + "saving_interval": "0 < b <= 1/100" + }, + "gain_over_previous_root": [ + "15520213124915363/10000000000000000000000000", + "3104042624983073/2000000000000000000000000" + ], + "previous_released_kappa": "17291512039830184429979999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "r1_cap": { + "cap_lower": "345830551200866186907/200000000000000000000000", + "cap_upper": "17291527560043309345351/10000000000000000000000000", + "idle_per_replica": { + "1": "234", + "3": "1341/20", + "48": "7619/20", + "5": "93/4" + }, + "invariant": { + "cap_requires_T_multiple_of": 20, + "first_multiple_of_74": 740, + "identity": "20*N_[9,9,9,9,9]@48 = 1341*T", + "scope": "Pattern integrality; chronological sufficiency is not asserted." + }, + "minimum_slack_lower": "330765675305227204675371142393288108400151493175513616739741339618653761718041326298111057624781171125553985546713931380045589238715164684519680158082564740064663626585139779201278666945976271879210312552348945421842669479860034347625742282914882395550466970485099678801067095436401756055414599223858358045300620622572136335593899309576755132023072924000625232706202289892486468856482758190936016483225256005340027972594846416378903928488242877276718725872416334489569899876284894464567074525397636741615414416512178272514355557374077726632979830127341350785520875007989552785927437863408466173223802409362040928161903300682009368388022327606117750186058531177130486222532353473629990336123001666673453285550918689932752488873889800407408618663032684827164043100388063145568074124864004671327888352440148634170348081682763216459720440600473567758633447479756936881069232841299315182009213270746341095947229872623984953305659320971822234633628503084874050627189372339056880769747466281694324513868890186542568399493669814325528063369943581616724732903252851537556934617596147852096403830386971101932076078846509096157094005135661650016075760947032213965707873129939184689263987243478656040906464411334211690007822733347623898160446742448648210266592497727349409694316897300189398121201087445724945334874140855821854415515276641951455907807350241364838774433095096175333305053290637933525897282705413481161097167181637390050045065310941579633986151479433320996941088323147696390012023269/81041342522688389710889387537294203079509119498590816677390723091620647310394495647029073126180702147730052952998589633954567841435821298786820185301991996265365431464176659884385965729599723770208940372607986728020752670720000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "patterns": 2551, + "strict_patterns": 2539, + "tight_patterns": 12 + }, + "root": [ + "345830551200866186907/200000000000000000000000", + "17291527560043309345351/10000000000000000000000000" + ] + }, + "physical": 663549, + "profile": { + "1": 16443540, + "2": 4708620, + "3": 1594737, + "4": 719280, + "48": 281903, + "5": 137085, + "8": 53280 + }, + "rank_mass": 48165120, + "replicas": 740, + "roles": 2717280, + "scope": "Finite composed allocation and moment; fresh release is separate.", + "status": "PASS_T740_R1_FINITE", + "stock": { + "buffers": 91, + "group_order_times_physical_bit_length": 2647, + "live": 663040, + "namespaces": { + "centers": [ + 663040, + 663048 + ], + "coefficients": [ + 663547, + 663549 + ], + "tableau": [ + 663048, + 663456 + ], + "zero_buffers": [ + 663456, + 663547 + ] + }, + "payload": 2048, + "physical": 663549, + "reserve": 1512, + "stock_l2_bits": 1324 + } +} diff --git a/research/rank7-t740-release/evidence/INITIAL-BOOTSTRAP-FAILURE.log.txt b/research/rank7-t740-release/evidence/INITIAL-BOOTSTRAP-FAILURE.log.txt new file mode 100644 index 0000000000..507d21fe45 --- /dev/null +++ b/research/rank7-t740-release/evidence/INITIAL-BOOTSTRAP-FAILURE.log.txt @@ -0,0 +1,4 @@ +Traceback (most recent call last): + File "/private/tmp/imb-t740-native-release/run/retained/fast-base/source/native/new/code/borrow/bw_audit_local.py", line 12, in + import numpy as np +ModuleNotFoundError: No module named 'numpy' diff --git a/research/rank7-t740-release/evidence/INVOICE-PAYLOAD.json b/research/rank7-t740-release/evidence/INVOICE-PAYLOAD.json new file mode 100644 index 0000000000..a69e33a9d0 --- /dev/null +++ b/research/rank7-t740-release/evidence/INVOICE-PAYLOAD.json @@ -0,0 +1,6 @@ +{ + "source": "run/candidate/discovery/global/audit/PREFIX-AND-INVOICE.json", + "decompressed_sha256": "901aafc2f1186a91303f597cf48f82b2bfd4fbe91eef623aa3b1fa46f2dbfabb", + "uncompressed_bytes": 3080683, + "scope": "Byte-identical fresh discovery invoice; gzip container bytes are not the mathematical equality criterion." +} diff --git a/research/rank7-t740-release/evidence/MATERIALIZED.json b/research/rank7-t740-release/evidence/MATERIALIZED.json new file mode 100644 index 0000000000..f45ffdf067 --- /dev/null +++ b/research/rank7-t740-release/evidence/MATERIALIZED.json @@ -0,0 +1,7 @@ +{ + "dispatch_sha256": "90edc935320dd6264e98dc735d868df3c95f5901c70d7d96171001fcb295cce0", + "order_sha256": "927226d702bf3cada076f4c459da9063c0df7e7154a62955cf75c40cf30215b9", + "payload_sha256": "57350da6442b107f374eda092a2fe51ea2b5e33a8a60bbd1a471f282cff3e506", + "rows": 2717280, + "sha256": "0608f8cc5f5b2d67de84924540c6166ef109c77af6690c95ef4d9b72f86dad2c" +} diff --git a/research/rank7-t740-release/evidence/NATIVE-ENVIRONMENT.json b/research/rank7-t740-release/evidence/NATIVE-ENVIRONMENT.json new file mode 100644 index 0000000000..dbd8236ea7 --- /dev/null +++ b/research/rank7-t740-release/evidence/NATIVE-ENVIRONMENT.json @@ -0,0 +1,13 @@ +{ + "assertions_enabled": true, + "dependency_versions": { + "gmpy2": null, + "mpmath": "1.3.0", + "numpy": "2.5.4", + "psutil": null, + "scipy": "1.18.1", + "sympy": "1.14.0" + }, + "executable": "/Users/nick/git/integer-mult-bounds/.venv/bin/python", + "python": "3.12.15" +} diff --git a/research/rank7-t740-release/evidence/NATIVE-RECEIPT.json b/research/rank7-t740-release/evidence/NATIVE-RECEIPT.json new file mode 100644 index 0000000000..b19ee78194 --- /dev/null +++ b/research/rank7-t740-release/evidence/NATIVE-RECEIPT.json @@ -0,0 +1,113 @@ +{ + "cache_files": { + "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea/CACHE.json": "b2b125989bbf3b29f7274bbea866b5236db5f069509c39851a456aa10fe039e1", + "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea/STEPS.json": "d893e8b738ed1cbdfc776d18cb0c08ffcf2ce08e0c7be23d3aaee1e6bf7149ff", + "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea/local/CANONICAL-WORD.json.gz": "49bdedd78e5630d0e24b0a7e649aa4bf0643e99fb9a01da458c63a6260b51a61", + "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea/local/CLIFFORD-RECIPES.json": "fc315f2affdf4294a6490c949585d144627957cb0d0527a30bce1b0da8b1e2f9", + "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea/local/CLIFFORD-REVIEW.json": "54341ebffcba56ab61f74258de68a9933400ea308b476e85d760cfd3b4a8da7a", + "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea/local/FULL-WORD.json.gz": "6a87b696f62d7bebc1b5cde53e18a1b3e60d0ae990690fedb7f7de435a620dd3", + "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea/local/INDEPENDENT-LOCAL-REPLAY.json": "d07a2d5b45c6201cdd15c7e4310254f98f1ad3654327ac7c9fe5a4d91fd892d8", + "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea/local/LOCAL-CHECKS.json": "d62b79b9b69d7ccac1256dc2bf249d335806c5234ee345e8f0327d2d0287aca1", + "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea/local/LOCAL-PROGRAMS.json.gz": "b39de2a64d8f4e7086a882e908ab1ab14c2ab44e62fea9388ab79838a38e68bc", + "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea/local/RESIDUAL-ADAPTERS.json": "cc366668c225431a1e5d0f856dbe7ba079c8e2fa1dc3ad0ceeecb9f0796aff77", + "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea/local/SCALAR-FRAME-AUDIT.json": "431f3585cd076914758bea3630a568872acee1312ed79a9e1f79388f864c5a36", + "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea/local/WARP-RECIPE-CHECKS.json": "3143bf29a8025b8f72ae714b3c2058502186244197b651c414978bf69caee85c", + "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea/local/WRAPPER-CHECKS.json": "d6adbd967e5f6f4a6ddea06a096b28129f2715b29f06f0e4a4c92d3b8ba7eef4", + "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5/CACHE.json": "66331b66a284311568ae377b3481b28b986ba9145f52bbc71ac6dd2117a998cc", + "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5/STEPS.json": "e80f7aa9bdb46493470204638abb42983c85d51f36c38efcd7ad7666501d8bb3", + "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5/local/CANONICAL-WORD.json.gz": "11e4ccf43f23103bb53b66fe44d4d2c8d13ac37731ddafcf2b24a3d68a6919a6", + "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5/local/CLIFFORD-RECIPES.json": "0367d988b83dd8cad6953980295895e038665e7b4be177fdb2552e2f4e1aa7ba", + "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5/local/CLIFFORD-REVIEW.json": "5098b243a78274e8781d38ed1fe84d2debd6f9aea590f5f61428f838bb0ce338", + "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5/local/FULL-WORD.json.gz": "3b33485492cca12cdf71fd6886d1bc49b2c8a0ac853956772a0b589a9c0aba35", + "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5/local/INDEPENDENT-LOCAL-REPLAY.json": "9a7cc98be3ad696c505eee35774d45496b3b5bf9ac5bf31fc071f73c4d0ad9f5", + "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5/local/LOCAL-CHECKS.json": "d62b79b9b69d7ccac1256dc2bf249d335806c5234ee345e8f0327d2d0287aca1", + "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5/local/LOCAL-PROGRAMS.json.gz": "b39de2a64d8f4e7086a882e908ab1ab14c2ab44e62fea9388ab79838a38e68bc", + "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5/local/RESIDUAL-ADAPTERS.json": "e1befeb697875416d93ff291ec931b6267bf7961cbb5afb2d96786c9d05e028a", + "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5/local/SCALAR-FRAME-AUDIT.json": "dd3d2737f73090cab2ae5dac51d88deae1dc6204b350473702e22a65e61df89d", + "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5/local/WARP-RECIPE-CHECKS.json": "9b00d684b6282b209cd1555743ee645edddad7a33aa733435103b99c29485286", + "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5/local/WRAPPER-CHECKS.json": "d6adbd967e5f6f4a6ddea06a096b28129f2715b29f06f0e4a4c92d3b8ba7eef4", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/CACHE.json": "d699b7d233b2604a27111312e3666e54ffdc65e0207c203b2b534c9c4681b3cb", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/STEPS.json": "bd2ef9ec20092082c83153ad8e3beda7cb5b03546cf43fd1248a175b0e955397", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CANONICAL-WORD.json.gz": "e38e2136e5a4a75bb843735a59158543eff04bd06384d73752b220d6938af73d", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-RECIPES.json": "cf410b60c9e3d9e7f99d94b5b28c4e3ae61c4b32892df4e03257b60fe5a37b02", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-REVIEW.json": "77607d99153dbe3e2a58396cad36d466037f7109ed0e41a0fb855e15e8a3b98b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/FULL-WORD.json.gz": "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/INDEPENDENT-LOCAL-REPLAY.json": "39874d664110d1ee85da901e2cd56e7cd0f27e0153813d4608c98122a90815da", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-CHECKS.json": "ef01cb5b6d1779518282c69a20d1dbcdbf57cb89ba616e2101bb209b37d80286", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-PROGRAMS.json.gz": "26c2fd119125bfca1ae655bb8a57df064da250370e60a85e1e8e8c4649e6a904", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/RESIDUAL-ADAPTERS.json": "0102fa3b62b095c14a34d5af95cc321db38e5f5e03a4f226828e8ebf6fdbe20b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/SCALAR-FRAME-AUDIT.json": "bbe606aaea8fd2d3054d0df7262eaa9791567da0da7d7630071e14ba431ca1c4", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/WRAPPER-CHECKS.json": "84a5bc26df5fb70dc12852a868962bcdfad3b85d85408edfd1f343e898a78c0e", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/native.log": "19355df4f2bd2f5fe415de1ac6ed47cf9ea302daef5c950a22ae213ef832764e", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/phases.log": "093ba7e5870381dfe9549d4b11c1a070b3628c17605b4fef1327fe5457a61ec4", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RECEIPT.json": "d3be092033b522645077796504dada9bd41797ee15c395918d63469befe78193", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RESULT.json": "ec08b0b74ffeaef455a0c245ea7258422084329d6d3ec625b3d607b0b471a473", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/STAGES.json": "35273f17b3b7045e480c6e76daafea163a9c63ae5bb8f86a9a68a99ef8d1208d", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/CACHE.json": "8e57208f59803e468017c1f1fb06aa8c804412d48903939264909ee28c547fc7", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/STEPS.json": "fa17aee4f19f9998e33e0464745be8065c860fcd1fe4162ead9412579a7f21ee", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CANONICAL-WORD.json.gz": "f69c0ca2c217eab87a231b67e548cd6491286314b1215e19f0b1d7463afd5e91", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-RECIPES.json": "f1b5a509e39293f5d7ffea7b269fd9e5443e625a9286a022caa1fd4b62af8063", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-REVIEW.json": "c63a70cf96717036b2f4d4e03c0bb338c82d7aadf93e75b7c543f7233b22c840", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/FULL-WORD.json.gz": "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/INDEPENDENT-LOCAL-REPLAY.json": "70b4b787a5a4529452a58e9ac48826e848748a35b95a9b20c5358f4355705058", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-CHECKS.json": "e52e7feece9cb22e83c1d687c0f98731f8d50b7e8c863732ec662c89453fbcd4", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-PROGRAMS.json.gz": "81d4aefacaa27f2f215e7d35559d5a079ca521f4ca2eb9a9c6a6bd7062179bff", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/RESIDUAL-ADAPTERS.json": "89e5779ba4fcc1b1a76bed05c9b36600bc1dc3c6efd7e623865692ec715c30c5", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/SCALAR-FRAME-AUDIT.json": "31f4da0ea668e40ab9fa59778dcff8e9d38cf233d728a63cb5d90f9d3e35e7e0", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/WRAPPER-CHECKS.json": "fc7e24778302326fdacfd08dd3d5e63483cf4539cd5022a6c77f016752fac1a3", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/native.log": "1f88ef6a94917c149ec65de26d7b78157dbcacdcb86bab2d87bb9d8716c8f46e", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/phases.log": "dff5dde60610bff9099abc63e72beca9ff524df9f4b6d5f108279e0902fc2796", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5" + }, + "fresh_current_provider_count": 2, + "fresh_retained_native_count": 0, + "fresh_retained_parent": false, + "manifest_sha256": "9215312229c431078ba61daf106edb8caf20b33f48317d46438a341552cf153f", + "providers": { + "base": { + "complete_native_files": { + "STEPS.json": "e80f7aa9bdb46493470204638abb42983c85d51f36c38efcd7ad7666501d8bb3", + "local/CANONICAL-WORD.json.gz": "11e4ccf43f23103bb53b66fe44d4d2c8d13ac37731ddafcf2b24a3d68a6919a6", + "local/CLIFFORD-RECIPES.json": "0367d988b83dd8cad6953980295895e038665e7b4be177fdb2552e2f4e1aa7ba", + "local/CLIFFORD-REVIEW.json": "5098b243a78274e8781d38ed1fe84d2debd6f9aea590f5f61428f838bb0ce338", + "local/FULL-WORD.json.gz": "3b33485492cca12cdf71fd6886d1bc49b2c8a0ac853956772a0b589a9c0aba35", + "local/INDEPENDENT-LOCAL-REPLAY.json": "9a7cc98be3ad696c505eee35774d45496b3b5bf9ac5bf31fc071f73c4d0ad9f5", + "local/LOCAL-CHECKS.json": "d62b79b9b69d7ccac1256dc2bf249d335806c5234ee345e8f0327d2d0287aca1", + "local/LOCAL-PROGRAMS.json.gz": "b39de2a64d8f4e7086a882e908ab1ab14c2ab44e62fea9388ab79838a38e68bc", + "local/RESIDUAL-ADAPTERS.json": "e1befeb697875416d93ff291ec931b6267bf7961cbb5afb2d96786c9d05e028a", + "local/SCALAR-FRAME-AUDIT.json": "dd3d2737f73090cab2ae5dac51d88deae1dc6204b350473702e22a65e61df89d", + "local/WARP-RECIPE-CHECKS.json": "9b00d684b6282b209cd1555743ee645edddad7a33aa733435103b99c29485286", + "local/WRAPPER-CHECKS.json": "d6adbd967e5f6f4a6ddea06a096b28129f2715b29f06f0e4a4c92d3b8ba7eef4" + }, + "word_sha256": "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5" + }, + "extra": { + "complete_native_files": { + "STEPS.json": "d893e8b738ed1cbdfc776d18cb0c08ffcf2ce08e0c7be23d3aaee1e6bf7149ff", + "local/CANONICAL-WORD.json.gz": "49bdedd78e5630d0e24b0a7e649aa4bf0643e99fb9a01da458c63a6260b51a61", + "local/CLIFFORD-RECIPES.json": "fc315f2affdf4294a6490c949585d144627957cb0d0527a30bce1b0da8b1e2f9", + "local/CLIFFORD-REVIEW.json": "54341ebffcba56ab61f74258de68a9933400ea308b476e85d760cfd3b4a8da7a", + "local/FULL-WORD.json.gz": "6a87b696f62d7bebc1b5cde53e18a1b3e60d0ae990690fedb7f7de435a620dd3", + "local/INDEPENDENT-LOCAL-REPLAY.json": "d07a2d5b45c6201cdd15c7e4310254f98f1ad3654327ac7c9fe5a4d91fd892d8", + "local/LOCAL-CHECKS.json": "d62b79b9b69d7ccac1256dc2bf249d335806c5234ee345e8f0327d2d0287aca1", + "local/LOCAL-PROGRAMS.json.gz": "b39de2a64d8f4e7086a882e908ab1ab14c2ab44e62fea9388ab79838a38e68bc", + "local/RESIDUAL-ADAPTERS.json": "cc366668c225431a1e5d0f856dbe7ba079c8e2fa1dc3ad0ceeecb9f0796aff77", + "local/SCALAR-FRAME-AUDIT.json": "431f3585cd076914758bea3630a568872acee1312ed79a9e1f79388f864c5a36", + "local/WARP-RECIPE-CHECKS.json": "3143bf29a8025b8f72ae714b3c2058502186244197b651c414978bf69caee85c", + "local/WRAPPER-CHECKS.json": "d6adbd967e5f6f4a6ddea06a096b28129f2715b29f06f0e4a4c92d3b8ba7eef4" + }, + "word_sha256": "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea" + } + }, + "retained_parent_receipt_sha256": "d3be092033b522645077796504dada9bd41797ee15c395918d63469befe78193", + "retained_reuse_receipt_sha256": "ba991831771331653d9187516540089809254b18144a8c1800ce39f7a840f896", + "reused_retained_native_count": 2, + "reused_retained_parent": true, + "source_commit": "rank7-joint-endframes-pr2917", + "status": "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE" +} diff --git a/research/rank7-t740-release/evidence/OUTER-CLAIM.json b/research/rank7-t740-release/evidence/OUTER-CLAIM.json new file mode 100644 index 0000000000..5c8a5340af --- /dev/null +++ b/research/rank7-t740-release/evidence/OUTER-CLAIM.json @@ -0,0 +1,13 @@ +{ + "b": "certified complex_lower - 1e-104 (outer/B.json)", + "baseline_head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "baseline_kappa": "17240352247481048785499999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "branch": "fine source-prime padding (PR1786, chafreaky; Trudgian's prime theorem; vendor/pr1786) with the gauge-free interiors (PR1758), the radix-distributed union schedule with per-visit tag work and the explicit Strassen boundary (tau=45/16); epsilon=1-1.0009765625e-3080 is a free parameter (outer/FINE-PADDING-COMPOSITION.md): kappa = C - 1/F - B, the fixed-grid maximum (epsilon q is 1.70e-3083 below q); the structured boundary of the previous package is not used; omega_C<=9/4 not used; recertified endpoint: the supplier native endpoint is certified to 1e-3000 (accept at the endpoint, reject at endpoint + 1e-3000, repaired fine engines in integer fixed point), and all free slacks are 1e-3080 or below", + "fixed_grid_maximum": "kappa=C-10^-70-10^-46 exactly; same fixed-grid-maximum proof at precision24.", + "gain": "1023506251245211197/200000000000000000000000", + "kappa": "0.0017291527560043309345349999999999999999999998999999999999999999999999", + "kappa_rational": "17291527560043309345349999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "outer": "PR1673 capped phase-cell fusion (Vlado Vojdanovski)", + "retuned_slacks": "Endpoint precision24; free gaps follow outer/check_ledger.py from the frozen SPEC.", + "supplier": "PR1661 T74 pivot-566 stack with PR2226 anticipatory dirty borrowing, the PR2312 width exchange, frame refit and kernels, the PR2322 handoffs, the PR2435/PR2447 entrance raise, the PR2436 lifted-target aliases, and the PR2530 (zxv) eight source-partner aliases with an owner fill evacuated by the PR2559 (philippeVV) method; this package: six pre-life hostings (cold hosts 273, 275, 289, 291, 305, 321 host helpers 482, 483, 494, 495, 507, 519), a one-gate frame refit with the retired-lender alias 653<-563, and a new exact owner fill" +} diff --git a/research/rank7-t740-release/evidence/OWNERS-RESULT.json b/research/rank7-t740-release/evidence/OWNERS-RESULT.json new file mode 100644 index 0000000000..c8dc460799 --- /dev/null +++ b/research/rank7-t740-release/evidence/OWNERS-RESULT.json @@ -0,0 +1 @@ +{"dispatch":{"extra":4160,"gauge44":2500},"helpers_per_call":408,"idle":{"1":173160,"3":49617,"5":17205,"48":281903},"roles":2717280,"scope":"Literal strict windows, bin capacities, per-call helper widths and distinct physical families verified for the shipped fill; local programs are the borrow words; full parent binding, finite invoice and global admission run separately.","status":"PASS_EXACT_BORROW_WORD_REPLICA_OWNER_FILL"} \ No newline at end of file diff --git a/research/rank7-t740-release/evidence/RECIPE.json b/research/rank7-t740-release/evidence/RECIPE.json new file mode 100644 index 0000000000..8137787ff5 --- /dev/null +++ b/research/rank7-t740-release/evidence/RECIPE.json @@ -0,0 +1,238 @@ +{ + "changes": [ + { + "argument": "--fill", + "new": "/private/tmp/imb-t740-release-final/COMPOSED-FILL.json.gz", + "old": "/private/tmp/imb-t740-release-final/pr3015/allocation/FILL.json.gz", + "stage": "complete-admission" + }, + { + "argument": "--order", + "new": "/private/tmp/imb-t740-release-final/ORDER.json", + "old": "/private/tmp/imb-t740-release-final/pr3015/allocation/ORDER.json", + "stage": "complete-admission" + }, + { + "argument": "--dispatch", + "new": "/private/tmp/imb-t740-release-final/DISPATCH.json", + "old": "/private/tmp/imb-t740-release-final/pr3015/allocation/DISPATCH.json", + "stage": "complete-admission" + } + ], + "commands": [ + [ + "export-pr2894", + [ + "/Users/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/private/tmp/imb-t740-release-final/run/pr2908/reproduce.py", + "--repo", + "/Users/nick/git/integer-mult-bounds", + "--work", + "/private/tmp/imb-t740-release-final/run/parent-export", + "--dry-run" + ] + ], + [ + "export-pr2833", + [ + "/Users/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/private/tmp/imb-t740-release-final/run/parent-export/pr2894/tools/materialize_source.py", + "--repo", + "/Users/nick/git/integer-mult-bounds", + "--out", + "/private/tmp/imb-t740-release-final/run/pr2833" + ] + ], + [ + "fresh-retained-bootstrap", + [ + "/Users/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/private/tmp/imb-t740-release-final/run/parent-export/pr2894/tools/prepare_retained.py", + "--source", + "/private/tmp/imb-t740-release-final/run/pr2833", + "--out", + "/private/tmp/imb-t740-release-final/run/retained", + "--jobs", + "1" + ] + ], + [ + "four-kernel-stage", + [ + "/Users/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/private/tmp/imb-t740-release-final/run/parent-export/pr2894/vendor/pr2857/build_overlay.py", + "--source", + "/private/tmp/imb-t740-release-final/run/pr2833", + "--generator", + "/private/tmp/imb-t740-release-final/run/parent-export/pr2894/vendor/pr2857/shared_kernel.py", + "--review", + "/private/tmp/imb-t740-release-final/run/parent-export/pr2894/vendor/pr2857/review_four_groups.py", + "--candidate-dir", + "/private/tmp/imb-t740-release-final/run/parent-export/pr2894/vendor/pr2857/words", + "--out", + "/private/tmp/imb-t740-release-final/run/source4" + ] + ], + [ + "preload-stage", + [ + "/Users/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/private/tmp/imb-t740-release-final/run/parent-export/pr2894/vendor/pm/build_pm_overlay.py", + "--overlay", + "/private/tmp/imb-t740-release-final/run/source4", + "--pm-dir", + "/private/tmp/imb-t740-release-final/run/parent-export/pr2894/vendor/pm", + "--out", + "/private/tmp/imb-t740-release-final/run/source-pm" + ] + ], + [ + "parent-paired-stage", + [ + "/Users/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/private/tmp/imb-t740-release-final/run/pr2908/tools/build_channel_overlay.py", + "--source", + "/private/tmp/imb-t740-release-final/run/source-pm", + "--local-package", + "/private/tmp/imb-t740-release-final/run/pr2908", + "--out", + "/private/tmp/imb-t740-release-final/run/source2908" + ] + ], + [ + "paired-extension-stage", + [ + "/Users/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/private/tmp/imb-t740-release-final/run/pr2917/tools/build_extension.py", + "--source", + "/private/tmp/imb-t740-release-final/run/source2908", + "--local-package", + "/private/tmp/imb-t740-release-final/run/pr2917", + "--out", + "/private/tmp/imb-t740-release-final/run/source" + ] + ], + [ + "rank7-overlay-stage", + [ + "/Users/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/private/tmp/imb-t740-release-final/pr3015/tools/build_overlay.py", + "--source", + "/private/tmp/imb-t740-release-final/run/source", + "--candidate-dir", + "/private/tmp/imb-t740-release-final/run/candidate-words", + "--out", + "/private/tmp/imb-t740-release-final/run/source-rank7", + "--stage-name", + "rank7-joint-endframes" + ] + ], + [ + "declared-edit-stage", + [ + "/Users/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/private/tmp/imb-t740-release-final/pr3015/tools/build_edits.py", + "--source", + "/private/tmp/imb-t740-release-final/run/source-rank7", + "--local-package", + "/private/tmp/imb-t740-release-final/pr3015", + "--out", + "/private/tmp/imb-t740-release-final/run/source-edits" + ] + ], + [ + "derive-closed-adapters", + [ + "/Users/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/private/tmp/imb-t740-release-final/pr3015/tools/derive_adapters.py", + "--parent-package", + "/private/tmp/imb-t740-release-final/run/pr2908", + "--source", + "/private/tmp/imb-t740-release-final/run/source-edits", + "--retained-receipt", + "/private/tmp/imb-t740-release-final/run/retained/NATIVE-RECEIPT.json", + "--out", + "/private/tmp/imb-t740-release-final/run/adapters", + "--buffers", + "91", + "--source-commit", + "rank7-joint-endframes-pr2917", + "--source-profile", + "rank7-joint-endframes", + "--upstream-head", + "224bd5e56041c40078ff6b5fa7393733a215de5c", + "--comparison", + "pr2917=/private/tmp/imb-t740-release-final/run/pr2917/CLAIM.json", + "--comparison", + "pr2966=/private/tmp/imb-t740-release-final/run/pr2966/CLAIM.json", + "--comparison", + "pr2969=/private/tmp/imb-t740-release-final/run/pr2969/CLAIM.json" + ] + ], + [ + "fresh-current-native", + [ + "/Users/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/private/tmp/imb-t740-release-final/run/adapters/prepare_extension_native.py", + "--source", + "/private/tmp/imb-t740-release-final/run/source-edits", + "--retained-cache", + "/private/tmp/imb-t740-release-final/run/retained/native-cache", + "--retained-receipt", + "/private/tmp/imb-t740-release-final/run/retained/NATIVE-RECEIPT.json", + "--out", + "/private/tmp/imb-t740-release-final/run/native", + "--jobs", + "1" + ] + ], + [ + "complete-admission", + [ + "/Users/nick/git/integer-mult-bounds/.venv/bin/python", + "-B", + "/private/tmp/imb-t740-release-final/run/adapters/admit_extension.py", + "--source", + "/private/tmp/imb-t740-release-final/run/source-edits", + "--fill", + "/private/tmp/imb-t740-release-final/COMPOSED-FILL.json.gz", + "--order", + "/private/tmp/imb-t740-release-final/ORDER.json", + "--dispatch", + "/private/tmp/imb-t740-release-final/DISPATCH.json", + "--native-cache", + "/private/tmp/imb-t740-release-final/run/native/native-cache", + "--native-receipt", + "/private/tmp/imb-t740-release-final/run/native/NATIVE-RECEIPT.json", + "--work", + "/private/tmp/imb-t740-release-final/run/candidate", + "--replica-helper-dir", + "/private/tmp/imb-t740-release-final/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839", + "--reconstructor", + "/private/tmp/imb-t740-release-final/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839/reconstruct_replica.py", + "--blocknorm-checker", + "/private/tmp/imb-t740-release-final/run/adapters/extension_blocknorm.py", + "--comparison-claim", + "/private/tmp/imb-t740-release-final/run/pr2969/CLAIM.json", + "--source-profile", + "rank7-joint-endframes", + "--comparison-profile", + "pr2969", + "--jobs", + "1" + ] + ] + ], + "fill_sha256": "0608f8cc5f5b2d67de84924540c6166ef109c77af6690c95ef4d9b72f86dad2c" +} diff --git a/research/rank7-t740-release/evidence/RELEASE-RECEIPT.json b/research/rank7-t740-release/evidence/RELEASE-RECEIPT.json new file mode 100644 index 0000000000..8677dd63e0 --- /dev/null +++ b/research/rank7-t740-release/evidence/RELEASE-RECEIPT.json @@ -0,0 +1,7 @@ +{ + "status": "PASS_RELEASE", + "kappa_decimal": "0.0017291527560043309345349999999999999999999998999999999999999999999999", + "manifest_sha256": "117119098284f63bb3e18b9a4e88f424385775512f8220268b0a43a3a517d8f7", + "proof": "Supplier: the package's own unchanged `verify.py` (retained PR1297 provider and parent admission, owner reconstruction, parent lift, strict T74 admission, geometry controls): `PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION`, native reuse {'base': 'e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e', 'extra': '7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905'}; its complex endpoint 345830551200866186907/20000000... brackets the ledger's b = 172915275600433093453499999999999999999999999999999999999999999999999999999999999999999999999999999999/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000. Outer (PR1673 capped phase-cell fusion): regenerated exact ledger (63 strict inequalities: the 62 retained rows plus the explicit main-binding row gaussian_above_main, the fixed-grid maximum kappa = C - 1/F - B asserted, 17 rejecting controls incl. the old g-factor union row, the old linear and old-theta chirp guards, the old 2*beta tag test, epsilon at 1 or at the r0 slack and beta outside its window, larger endpoint rejected by the native moment), independent balance derivation, the exact union-schedule simulation, the (retained, not used for kappa) structured-boundary displacement-rank check, the gauge-free identity/symbol/circuit checks, PR1786's finite prime/underflow controls and 19 exact evidence replays all pass. Conditional kappa 0.0017291527560043309345349999999999999999999998999999999999999999999999 (union schedule outer/UNION-SCHEDULE.md; explicit Strassen boundary tau=45/16 (the structured boundary of outer/STRUCTURED-BOUNDARY.md is not used); gauge-free interiors outer/GAUGEFREE-INTERIORS.md; fine source-prime padding PR1786 at the free point epsilon=1-(1025/1024)e-104, outer/FINE-PADDING-COMPOSITION.md; fixed-grid maximum of PR2180/PR2161 (dataisfire), outer/PROOF-GRID-MAX.md; exact-integer coarse exponential PR2168/PR2184 (dataisfire) at the one 24-digit rejection call).", + "seconds": 748.86 +} diff --git a/research/rank7-t740-release/evidence/STAGES.json b/research/rank7-t740-release/evidence/STAGES.json new file mode 100644 index 0000000000..0d3973f832 --- /dev/null +++ b/research/rank7-t740-release/evidence/STAGES.json @@ -0,0 +1,80 @@ +[ + { + "exit_code": 0, + "log_sha256": "33398f425eb773647292f653df20b6bec51ab4a6ea56e9a3ee71a47978deef98", + "seconds": 0.679011708998587, + "stage": "source-preflight" + }, + { + "exit_code": 0, + "log_sha256": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "seconds": 0.24282949999906123, + "stage": "export-pr2894" + }, + { + "exit_code": 0, + "log_sha256": "50be5082e2ceba2d668fb61d17451e0f7e0d98a6bd2dd20f778eb7c48c9c0e18", + "seconds": 0.34354983299272135, + "stage": "export-pr2833" + }, + { + "exit_code": 0, + "log_sha256": "4a1625fdd9a947187583e67492c492f309e28669082f2e6f2aa97b5da345ea29", + "seconds": 275.43257712500053, + "stage": "fresh-retained-bootstrap" + }, + { + "exit_code": 0, + "log_sha256": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "seconds": 0.5446279580064584, + "stage": "four-kernel-stage" + }, + { + "exit_code": 0, + "log_sha256": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "seconds": 0.5530662090168335, + "stage": "preload-stage" + }, + { + "exit_code": 0, + "log_sha256": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "seconds": 0.38549504199181683, + "stage": "parent-paired-stage" + }, + { + "exit_code": 0, + "log_sha256": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "seconds": 0.37884112499887124, + "stage": "paired-extension-stage" + }, + { + "exit_code": 0, + "log_sha256": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "seconds": 0.6730030839971732, + "stage": "rank7-overlay-stage" + }, + { + "exit_code": 0, + "log_sha256": "3ad47363c45012cd4f09aee995e551a314b89da7fb70310cabc437cf78957097", + "seconds": 0.4410717920109164, + "stage": "declared-edit-stage" + }, + { + "exit_code": 0, + "log_sha256": "4752f54354db20b74d96ba359666482d69747e61ea9e6284566d38def65b91cf", + "seconds": 0.14910658399458043, + "stage": "derive-closed-adapters" + }, + { + "exit_code": 0, + "log_sha256": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "seconds": 49.593563124974025, + "stage": "fresh-current-native" + }, + { + "exit_code": 0, + "log_sha256": "241b0a8de2593e66706e8fb6b7881e9abbe884c1bbf1386efc0ccc95a84399e1", + "seconds": 1422.3631923749927, + "stage": "complete-admission" + } +] diff --git a/research/rank7-t740-release/evidence/logs/complete-admission.log.txt b/research/rank7-t740-release/evidence/logs/complete-admission.log.txt new file mode 100644 index 0000000000..eed96ada8a --- /dev/null +++ b/research/rank7-t740-release/evidence/logs/complete-admission.log.txt @@ -0,0 +1,8 @@ +PASS owners +PASS parent-lift +PASS rebind +PASS discovery +PASS outer-check_ledger.py +PASS outer-independent_check.py +PASS release +PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE 0.0017291527560043309345349999999999999999999998999999999999999999999999 diff --git a/research/rank7-t740-release/evidence/logs/declared-edit-stage.log.txt b/research/rank7-t740-release/evidence/logs/declared-edit-stage.log.txt new file mode 100644 index 0000000000..99ee5533b2 --- /dev/null +++ b/research/rank7-t740-release/evidence/logs/declared-edit-stage.log.txt @@ -0,0 +1 @@ +PASS_SOURCE_BOUND_DECLARED_EDIT_OVERLAY 9215312229c431078ba61daf106edb8caf20b33f48317d46438a341552cf153f 642 diff --git a/research/rank7-t740-release/evidence/logs/derive-closed-adapters.log.txt b/research/rank7-t740-release/evidence/logs/derive-closed-adapters.log.txt new file mode 100644 index 0000000000..6c33d73563 --- /dev/null +++ b/research/rank7-t740-release/evidence/logs/derive-closed-adapters.log.txt @@ -0,0 +1 @@ +PASS_CHECKED_91_BUFFER_ADAPTER_DERIVATION_R13 9215312229c431078ba61daf106edb8caf20b33f48317d46438a341552cf153f 642 {'prepare_extension_native.py': '9e6424b70efff445', 'admit_extension.py': 'e0250e81477b2f62', 'extension_blocknorm.py': '6e6b8683cc87a84e'} diff --git a/research/rank7-t740-release/evidence/logs/export-pr2833.log.txt b/research/rank7-t740-release/evidence/logs/export-pr2833.log.txt new file mode 100644 index 0000000000..a7aef07d0c --- /dev/null +++ b/research/rank7-t740-release/evidence/logs/export-pr2833.log.txt @@ -0,0 +1 @@ +{"head": "e9307b48d7d1b690939935ecef0f8e524e6d92f4", "manifest_entries": 541, "manifest_sha256": "c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f", "network_fetch": false, "source": "/private/tmp/imb-t740-release-final/run/pr2833", "status": "PASS_EXACT_PR2833_SOURCE_EXPORT"} diff --git a/research/rank7-t740-release/evidence/logs/export-pr2894.log.txt b/research/rank7-t740-release/evidence/logs/export-pr2894.log.txt new file mode 100644 index 0000000000..2bed900376 --- /dev/null +++ b/research/rank7-t740-release/evidence/logs/export-pr2894.log.txt @@ -0,0 +1 @@ +PASS_PINNED_PR2894_EXPORT_RECIPE_ONLY diff --git a/research/rank7-t740-release/evidence/logs/four-kernel-stage.log.txt b/research/rank7-t740-release/evidence/logs/four-kernel-stage.log.txt new file mode 100644 index 0000000000..257be58c74 --- /dev/null +++ b/research/rank7-t740-release/evidence/logs/four-kernel-stage.log.txt @@ -0,0 +1 @@ +{"derived_manifest_sha256": "54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869", "source_file_count": 547, "status": "PASS_SOURCE_BOUND_FOUR_KERNEL_OVERLAY_DERIVATION"} diff --git a/research/rank7-t740-release/evidence/logs/fresh-current-native.log.txt b/research/rank7-t740-release/evidence/logs/fresh-current-native.log.txt new file mode 100644 index 0000000000..820460ef57 --- /dev/null +++ b/research/rank7-t740-release/evidence/logs/fresh-current-native.log.txt @@ -0,0 +1,3 @@ +PASS fresh-current-base +PASS fresh-current-extra +PASS_TWO_FRESH_SHARED_KERNEL_NATIVE_CHAINS_AUTHENTICATED_PARENT_REUSE diff --git a/research/rank7-t740-release/evidence/logs/fresh-retained-bootstrap.log.txt b/research/rank7-t740-release/evidence/logs/fresh-retained-bootstrap.log.txt new file mode 100644 index 0000000000..9308a84963 --- /dev/null +++ b/research/rank7-t740-release/evidence/logs/fresh-retained-bootstrap.log.txt @@ -0,0 +1,6 @@ +PASS native-base +PASS native-extra +PASS native-retained-base +PASS native-retained-extra +PASS retained-parent +PASS_PR2833_FRESH_NATIVE_PREPARATION diff --git a/research/rank7-t740-release/evidence/logs/paired-extension-stage.log.txt b/research/rank7-t740-release/evidence/logs/paired-extension-stage.log.txt new file mode 100644 index 0000000000..9ca3a42521 --- /dev/null +++ b/research/rank7-t740-release/evidence/logs/paired-extension-stage.log.txt @@ -0,0 +1 @@ +PASS_SOURCE_BOUND_PAIRED_EXTENSION_OVERLAY 98d57c82a1c7318be3c330c3b66897844d57232f0aaeaea88fb4bebd0a1bedf1 632 diff --git a/research/rank7-t740-release/evidence/logs/parent-paired-stage.log.txt b/research/rank7-t740-release/evidence/logs/parent-paired-stage.log.txt new file mode 100644 index 0000000000..de80347a90 --- /dev/null +++ b/research/rank7-t740-release/evidence/logs/parent-paired-stage.log.txt @@ -0,0 +1 @@ +PASS_SOURCE_BOUND_TWO_SIDED_HELPER408_OVERLAY 56cf455752722051d598a7da1e5ee700637fbaef09189f534413dbe6e0525a83 610 diff --git a/research/rank7-t740-release/evidence/logs/preload-stage.log.txt b/research/rank7-t740-release/evidence/logs/preload-stage.log.txt new file mode 100644 index 0000000000..4fa79b5e48 --- /dev/null +++ b/research/rank7-t740-release/evidence/logs/preload-stage.log.txt @@ -0,0 +1 @@ +{"derived_manifest_sha256": "4da246899e2c509dd8c6e5af34905c6124ca17671b188e11ac37e36adf449504", "source_file_count": 553, "status": "PASS_SOURCE_BOUND_PRELOAD_MOVE_OVERLAY_DERIVATION"} diff --git a/research/rank7-t740-release/evidence/logs/rank7-overlay-stage.log.txt b/research/rank7-t740-release/evidence/logs/rank7-overlay-stage.log.txt new file mode 100644 index 0000000000..d058b55c96 --- /dev/null +++ b/research/rank7-t740-release/evidence/logs/rank7-overlay-stage.log.txt @@ -0,0 +1 @@ +{"buffers": 91, "derived_manifest_sha256": "751b46364742cbb947f7db07c130ff09085b38b52c520d3b47f2dadc1e21ba80", "source_file_count": 637, "status": "PASS_SOURCE_BOUND_WORDEDIT_OVERLAY_DERIVATION"} diff --git a/research/rank7-t740-release/evidence/logs/source-preflight.log.txt b/research/rank7-t740-release/evidence/logs/source-preflight.log.txt new file mode 100644 index 0000000000..fbfbb199ad --- /dev/null +++ b/research/rank7-t740-release/evidence/logs/source-preflight.log.txt @@ -0,0 +1 @@ +PASS_PINNED_PR2908_PR2917_PR2942_PR2957_PR2966_PR2969_EXPORT_RECIPE_ONLY diff --git a/research/rank7-t740-release/evidence/optimized_tests.log.txt b/research/rank7-t740-release/evidence/optimized_tests.log.txt new file mode 100644 index 0000000000..bf9b5a7203 --- /dev/null +++ b/research/rank7-t740-release/evidence/optimized_tests.log.txt @@ -0,0 +1,13 @@ +test_full_stock_and_missing_private_buffers (test_verify.BoundaryTests.test_full_stock_and_missing_private_buffers) ... ok +test_lifted_order_and_dispatch_reach_the_owner_checker (test_verify.BoundaryTests.test_lifted_order_and_dispatch_reach_the_owner_checker) ... ok +test_literal_materialized_capacity_fault_rejects (test_verify.BoundaryTests.test_literal_materialized_capacity_fault_rejects) ... ok +test_literal_release_recipe_changes_all_three_inputs (test_verify.BoundaryTests.test_literal_release_recipe_changes_all_three_inputs) ... ok +test_r1_scalar_and_dirty_cleanup_controls (test_verify.BoundaryTests.test_r1_scalar_and_dirty_cleanup_controls) ... ok +test_root_rejects_unpaid_child (test_verify.BoundaryTests.test_root_rejects_unpaid_child) ... ok +test_source_drift_rejects_before_execution (test_verify.BoundaryTests.test_source_drift_rejects_before_execution) ... ok +test_streaming_writer_rejects_omitted_roles (test_verify.BoundaryTests.test_streaming_writer_rejects_omitted_roles) ... ok + +---------------------------------------------------------------------- +Ran 8 tests in 1.227s + +OK diff --git a/research/rank7-t740-release/evidence/registered.log.txt b/research/rank7-t740-release/evidence/registered.log.txt new file mode 100644 index 0000000000..008d6d48c9 --- /dev/null +++ b/research/rank7-t740-release/evidence/registered.log.txt @@ -0,0 +1,25 @@ +CHECK Exact R1 word/cleanup compatibility; all2717280 roles, ordered widths, source windows, family collisions, compact prefixes, paid profile,91 buffers and physical/prefix bound; exact R1 root and2551-pattern cap recertification. +PASS_T740_R1_FINITE roles=2717280 physical=663549 +CHECK Eight behavioral groups: all three admission inputs, T740 chronology/dispatch, materialized capacity fault, stock/buffers/prefix, source drift before compile, truncated output, unpaid child, R1 scalar and dirty cleanup mutants. +test_full_stock_and_missing_private_buffers (test_verify.BoundaryTests.test_full_stock_and_missing_private_buffers) ... ok +test_lifted_order_and_dispatch_reach_the_owner_checker (test_verify.BoundaryTests.test_lifted_order_and_dispatch_reach_the_owner_checker) ... ok +test_literal_materialized_capacity_fault_rejects (test_verify.BoundaryTests.test_literal_materialized_capacity_fault_rejects) ... ok +test_literal_release_recipe_changes_all_three_inputs (test_verify.BoundaryTests.test_literal_release_recipe_changes_all_three_inputs) ... ok +test_r1_scalar_and_dirty_cleanup_controls (test_verify.BoundaryTests.test_r1_scalar_and_dirty_cleanup_controls) ... ok +test_root_rejects_unpaid_child (test_verify.BoundaryTests.test_root_rejects_unpaid_child) ... ok +test_source_drift_rejects_before_execution (test_verify.BoundaryTests.test_source_drift_rejects_before_execution) ... ok +test_streaming_writer_rejects_omitted_roles (test_verify.BoundaryTests.test_streaming_writer_rejects_omitted_roles) ... ok + +---------------------------------------------------------------------- +Ran 8 tests in 1.215s + +OK +CHECK Rematerialize exact T740 fill,order and dispatch; authenticate stored fresh native/admission/outer/stage-log bindings and strict released gain, with six rejecting receipt mutants. Does not rerun the full native chain. +{ + "gain_over_pr3021": "1552021312491537/1000000000000000000000000", + "kappa": "17291527560043309345349999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "rejected_controls": 6, + "scope": "Rematerialized inputs and stored full-release relations; no new native replay.", + "status": "PASS_PUBLISHED_T740_RELEASE_BINDINGS" +} +PASS_REGISTERED_RESEARCH_PACKAGE research/rank7-t740-release outcome=completed diff --git a/research/rank7-t740-release/evidence/registered_finite.log.txt b/research/rank7-t740-release/evidence/registered_finite.log.txt new file mode 100644 index 0000000000..1962971fb5 --- /dev/null +++ b/research/rank7-t740-release/evidence/registered_finite.log.txt @@ -0,0 +1,17 @@ +CHECK Exact R1 word/cleanup compatibility; all2717280 roles, ordered widths, source windows, family collisions, compact prefixes, paid profile,91 buffers and physical/prefix bound; exact R1 root and2551-pattern cap recertification. +PASS_T740_R1_FINITE roles=2717280 physical=663549 +CHECK Eight behavioral groups: all three admission inputs, T740 chronology/dispatch, materialized capacity fault, stock/buffers/prefix, source drift before compile, truncated output, unpaid child, R1 scalar and dirty cleanup mutants. +test_full_stock_and_missing_private_buffers (test_verify.BoundaryTests.test_full_stock_and_missing_private_buffers) ... ok +test_lifted_order_and_dispatch_reach_the_owner_checker (test_verify.BoundaryTests.test_lifted_order_and_dispatch_reach_the_owner_checker) ... ok +test_literal_materialized_capacity_fault_rejects (test_verify.BoundaryTests.test_literal_materialized_capacity_fault_rejects) ... ok +test_literal_release_recipe_changes_all_three_inputs (test_verify.BoundaryTests.test_literal_release_recipe_changes_all_three_inputs) ... ok +test_r1_scalar_and_dirty_cleanup_controls (test_verify.BoundaryTests.test_r1_scalar_and_dirty_cleanup_controls) ... ok +test_root_rejects_unpaid_child (test_verify.BoundaryTests.test_root_rejects_unpaid_child) ... ok +test_source_drift_rejects_before_execution (test_verify.BoundaryTests.test_source_drift_rejects_before_execution) ... ok +test_streaming_writer_rejects_omitted_roles (test_verify.BoundaryTests.test_streaming_writer_rejects_omitted_roles) ... ok + +---------------------------------------------------------------------- +Ran 8 tests in 1.246s + +OK +PASS_REGISTERED_RESEARCH_PACKAGE research/rank7-t740-release outcome=partial diff --git a/research/rank7-t740-release/evidence/tests.log.txt b/research/rank7-t740-release/evidence/tests.log.txt new file mode 100644 index 0000000000..164ca8e92b --- /dev/null +++ b/research/rank7-t740-release/evidence/tests.log.txt @@ -0,0 +1,13 @@ +test_full_stock_and_missing_private_buffers (test_verify.BoundaryTests.test_full_stock_and_missing_private_buffers) ... ok +test_lifted_order_and_dispatch_reach_the_owner_checker (test_verify.BoundaryTests.test_lifted_order_and_dispatch_reach_the_owner_checker) ... ok +test_literal_materialized_capacity_fault_rejects (test_verify.BoundaryTests.test_literal_materialized_capacity_fault_rejects) ... ok +test_literal_release_recipe_changes_all_three_inputs (test_verify.BoundaryTests.test_literal_release_recipe_changes_all_three_inputs) ... ok +test_r1_scalar_and_dirty_cleanup_controls (test_verify.BoundaryTests.test_r1_scalar_and_dirty_cleanup_controls) ... ok +test_root_rejects_unpaid_child (test_verify.BoundaryTests.test_root_rejects_unpaid_child) ... ok +test_source_drift_rejects_before_execution (test_verify.BoundaryTests.test_source_drift_rejects_before_execution) ... ok +test_streaming_writer_rejects_omitted_roles (test_verify.BoundaryTests.test_streaming_writer_rejects_omitted_roles) ... ok + +---------------------------------------------------------------------- +Ran 8 tests in 1.211s + +OK diff --git a/research/rank7-t740-release/materialize.py b/research/rank7-t740-release/materialize.py new file mode 100755 index 0000000000..e2a4980bf2 --- /dev/null +++ b/research/rank7-t740-release/materialize.py @@ -0,0 +1,119 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Materialize PR3024's streaming T740 witness for the actual admission CLI. + +The lift and journals are Nick Petalas's retained PR3024/3018 sources. +PR3015's R1 words are Jeremy Kothe's; their compatibility checker is retained +from PR3021. No allocation or scalar-program search occurs here. +""" + +import gzip +import hashlib +import json +import types +from pathlib import Path + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +MAIN = ROOT / "research/rank7-joint-endframes" +PROFILE = {1: 16443540, 2: 4708620, 3: 1594737, 4: 719280, + 5: 137085, 8: 53280, 48: 281903} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def read(path): + raw = path.read_bytes() + need(len(raw) <= 20_000_000, "compressed input bound") + raw = gzip.decompress(raw) if path.suffix == ".gz" else raw + need(len(raw) <= 150_000_000, "decoded input bound") + return json.loads(raw) + + +def digest(path): + with path.open("rb") as stream: + return hashlib.file_digest(stream, "sha256").hexdigest() + + +def authenticate(): + pins = read(PACKAGE / "PINS.json") + need(1 <= len(pins) <= 100, "input count") + for relative, expected in pins.items(): + path = Path(relative) + need(not path.is_absolute() and ".." not in path.parts, "input path") + need(digest(ROOT / path) == expected, "source digest: " + relative) + + +def load(relative, name): + """Compile authenticated source bytes, bypassing bytecode caches.""" + return load_path(PACKAGE / relative, name) + + +def load_path(path, name): + module = types.ModuleType(name) + pins = read(PACKAGE / "PINS.json") + expected = pins[path.relative_to(ROOT).as_posix()] + need(digest(path) == expected, "module source digest") + module.__file__ = str(path) + # Exact source compilation avoids preexisting bytecode. See ENGINEERING.md. + exec(compile(path.read_bytes(), str(path), "exec"), module.__dict__) # noqa: S102 + return module + + +def witness(): + authenticate() + lift = load("vendor/pr3024/lift.py", "retained_lift740") + check = load("vendor/pr3021/verify.py", "retained_r1_check") + check.PACKAGE, check.ROOT, check.MAIN = PACKAGE, ROOT, MAIN + original = read(MAIN / "allocation/FILL.json.gz") + base = check.apply_exchange(original, read(PACKAGE / "vendor/pr3018/EXCHANGE.json")) + edits = lift.patch(base["rows"], read(PACKAGE / "vendor/pr3024/EXCHANGE.json")) + order = read(MAIN / "allocation/ORDER.json") + dispatch = {(s, r): p for s, r, p in read(MAIN / "allocation/DISPATCH.json")} + order, dispatch = lift.chronology(order, dispatch) + need(len(order) == len(dispatch) == 6660, "complete T740 calls") + providers = read(PACKAGE / "vendor/pr3015/allocation/PROVIDERS.json") + check.check_providers(providers) + declared = read(PACKAGE / "vendor/pr3015/edits/EDITS.json")["edits"] + for tag in ("base", "extra"): + check.check_word(read(MAIN / f"data/WORD-{tag}.json.gz"), + read(PACKAGE / f"vendor/pr3015/edits/FINAL-WORD-{tag}.json.gz"), + declared[tag]) + return lift.Rows(base["rows"], edits), order, dispatch, providers + + +def write_fill(path, rows): + """Write canonical JSON through bounded streaming compression.""" + need(len(rows) == 2717280, "complete materialized role count") + header = {"columns": ["time", "helper", "owner_replica", "child", "port", "offset"], + "dispatch_overrides": []} + prefix = json.dumps(header, sort_keys=True, separators=(",", ":"))[:-1] + ',"rows":[' + count, payload = 0, hashlib.sha256() + with path.open("wb") as raw, gzip.GzipFile( + filename="", mode="wb", fileobj=raw, compresslevel=1, mtime=0 + ) as out: + data = prefix.encode() + out.write(data) + payload.update(data) + for count, row in enumerate(rows, 1): + need(count <= 2717280, "materialization iteration bound") + data = (("," if count > 1 else "") + json.dumps(row, separators=(",", ":"))).encode() + out.write(data) + payload.update(data) + out.write(b"]}\n") + payload.update(b"]}\n") + need(count == 2717280, "no omitted materialized role") + return {"sha256": digest(path), "payload_sha256": payload.hexdigest(), "rows": count} + + +def build(directory): + rows, order, dispatch, _ = witness() + fill = write_fill(directory / "COMPOSED-FILL.json.gz", rows) + for name, value in (("ORDER.json", order), + ("DISPATCH.json", [[s, r, dispatch[s, r]] for s, r in order])): + (directory / name).write_text(json.dumps(value, separators=(",", ":")) + "\n") + return {**fill, "order_sha256": digest(directory / "ORDER.json"), + "dispatch_sha256": digest(directory / "DISPATCH.json")} diff --git a/research/rank7-t740-release/reproduce.py b/research/rank7-t740-release/reproduce.py new file mode 100755 index 0000000000..d86cfc77c9 --- /dev/null +++ b/research/rank7-t740-release/reproduce.py @@ -0,0 +1,259 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Compose PR3024's T740 allocation and R1 through a fresh finite release. + +The source recipes and all their mathematical checks remain unchanged. Only +the complete-admission fill, order and dispatch arguments change. The source +admission rederives physical and prefix bounds; verify.py checks them separately. +Source credit: Jeremy Kothe, Marius-Paul Dumitrean and the retained lineage. +""" + +import argparse +import gzip +import hashlib +import io +import json +import os +import signal +import subprocess +import sys +import tarfile +import time +from fractions import Fraction +from pathlib import Path, PurePosixPath + +import materialize + +PACKAGE = Path(__file__).resolve().parent +HEAD = "e244296debb45fe6f4da84d29e4d64fbab55fda0" +PREFIX = "research/rank7-joint-endframes-restore-edit" +EXPECTED = materialize.PROFILE +RECIPE_NAMES = ["export-pr2894", "export-pr2833", "fresh-retained-bootstrap", + "four-kernel-stage", "preload-stage", "parent-paired-stage", + "paired-extension-stage", "rank7-overlay-stage", "declared-edit-stage", + "derive-closed-adapters", "fresh-current-native", "complete-admission"] +DEPENDENCY_MANIFESTS = { + "pr2908": "9dba3fe371602ec023a54e26c0fd66f69eb7a74be86aab89923529083c14b36f", + "pr2917": "55c46ddf2e3edc87dfe1ba3320947466d36980d457eb37f6cd6fba341dae0192", + "pr2942": "23bd270f440c4c7ad0d106990ae391e1af799a61ef3601d00e27f1824ae8ba69", + "pr2957": "9cd226a2bf7391e7fbf4a23741bb1934afafbd596aef06f2999a935cd6e44e28", + "pr2966": "9e410c244efb370e20a5f9dc366550e11bcb14ebcecf8f2cb850512e82573914", + "pr2969": "797c55c560dec5b5a657296f49d918fc5db708b7bed3eba046b3358b1666e55b", +} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def digest(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == ".gz" else raw) + + +def save(path, value): + path.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n") + + +def authenticate_tree(directory): + manifest = read(directory / "MANIFEST.json") + paths = list(directory.rglob("*")) + need(len(paths) <= 10000 and len(manifest) <= 5000, "source tree bound") + need(not any(p.is_symlink() for p in paths), "regular source tree") + actual = {p.relative_to(directory).as_posix(): digest(p) for p in paths + if p.is_file() and p != directory / "MANIFEST.json"} + need(actual == manifest, "complete source inventory: " + str(directory)) + + +def export(repo, out): + """Export only bounded regular files, then authenticate the whole package.""" + raw = subprocess.run( + ["git", "-C", str(repo), "archive", HEAD, PREFIX], + check=True, capture_output=True, timeout=60, + ).stdout + need(len(raw) < 10_000_000, "bounded source archive") + out.mkdir() + with tarfile.open(fileobj=io.BytesIO(raw)) as archive: + members = archive.getmembers() + need(len(members) <= 256, "source file bound") + for member in members: + name = PurePosixPath(member.name) + need(not name.is_absolute() and ".." not in name.parts, "archive path") + need(member.isfile() or member.isdir(), "regular source entries") + if member.isdir(): + continue + need(name.is_relative_to(PurePosixPath(PREFIX)), "source prefix") + target = out / name.relative_to(PurePosixPath(PREFIX)) + target.parent.mkdir(parents=True, exist_ok=True) + stream = archive.extractfile(member) + need(stream is not None, "source file stream") + with stream: + target.write_bytes(stream.read()) + manifest = out / "MANIFEST.json" + need(digest(manifest) == digest(PACKAGE / "vendor/pr3015/MANIFEST.json"), + "exact PR3015 source manifest") + authenticate_tree(out) + + +def run_stage(name, command, work, env, stages, timeout): + log = work / (name + ".log") + started = time.monotonic() + with log.open("w") as stream: + process = subprocess.Popen( + list(map(str, command)), cwd=work, env=env, stdin=subprocess.DEVNULL, + stdout=stream, stderr=subprocess.STDOUT, start_new_session=True, + ) + try: + code = process.wait(timeout=timeout) + finally: + try: + os.killpg(process.pid, signal.SIGTERM) + except ProcessLookupError: + pass + try: + process.wait(timeout=5) + except subprocess.TimeoutExpired: + os.killpg(process.pid, signal.SIGKILL) + process.wait(timeout=5) + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + stages.append({"stage": name, "exit_code": code, + "seconds": time.monotonic() - started, "log_sha256": digest(log)}) + save(work / "STAGES.json", stages) + need(code == 0, "failed " + name + "; see " + str(log)) + print("PASS", name, flush=True) + + +def execute(repo, work, dry_run): + need(not work.exists(), "refusing an existing replay workspace") + need(not work.is_relative_to(PACKAGE), "replay outside published package") + need(sys.flags.optimize == 0, "inherited source requires enabled assertions") + need(os.name == "posix", "full replay process-group cleanup requires POSIX") + materialize.authenticate() + for entry in read(PACKAGE / "VENDOR.json"): + need(digest(PACKAGE / entry["path"]) == entry["sha256"], "frozen vendor input") + work.mkdir(parents=True) + source, run = work / "pr3015", work / "run" + export(repo, source) + materialized = materialize.build(work) + fill_hash = materialized["sha256"] + save(work / "MATERIALIZED.json", materialized) + env = dict(os.environ, PYTHONDONTWRITEBYTECODE="1", + PYTHONPYCACHEPREFIX=str(work / "bytecode"), + OPENBLAS_NUM_THREADS="1", OMP_NUM_THREADS="1", PYTHONINTMAXSTRDIGITS="0") + for key in ("PYTHONPATH", "PYTHONOPTIMIZE", "WITNESS_SPEC", "WITNESS_RECORD", "WITNESS_DISCOVER"): + env.pop(key, None) + py = [sys.executable, "-B"] + stages = [] + run_stage("source-preflight", py + [source / "reproduce.py", "--repo", repo, + "--work", run, "--jobs", "1", "--dry-run"], work, env, stages, 120) + recipe = read(run / "PREFLIGHT.json")["commands"] + need([name for name, _ in recipe] == RECIPE_NAMES, "complete source recipe") + changes = replace_allocation(recipe, source, work) + save(work / "RECIPE.json", {"commands": recipe, "changes": changes, "fill_sha256": fill_hash}) + if dry_run: + return {"status": "PREFLIGHT_ONLY_NOT_A_RELEASE", "fill_sha256": fill_hash} + for name, command in recipe: + run_stage(name, command, work, env, stages, 1800) + return check_release(work, source, fill_hash, stages) + + +def replace_allocation(recipe, source, work): + changes = [] + for name, command in recipe: + if name == "complete-admission": + for flag, old_name, new_name in ( + ("--fill", "FILL.json.gz", "COMPOSED-FILL.json.gz"), + ("--order", "ORDER.json", "ORDER.json"), + ("--dispatch", "DISPATCH.json", "DISPATCH.json"), + ): + position = command.index(flag) + 1 + need(command[position] == str(source / "allocation" / old_name), "recipe preimage") + changes.append({"stage": name, "argument": flag, "old": command[position], "new": str(work / new_name)}) + command[position] = str(work / new_name) + need(len(changes) == 3, "exactly three allocation arguments change") + return changes + + +def check_release(work, source, fill_hash, stages): + candidate = work / "run/candidate" + need(digest(work / "COMPOSED-FILL.json.gz") == fill_hash, "unchanged admitted fill bytes") + admission = read(candidate / "RESULT.json") + release = read(candidate / "release/RELEASE-RECEIPT.json") + need(admission["status"] == "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", "complete admission") + need(release["status"] == "PASS_RELEASE", "outer release") + need(admission["fill_sha256"] == fill_hash, "new literal fill admission binding") + need({int(k): v for k, v in admission["profile"].items()} == EXPECTED, + "exact complete composed profile") + need(admission["order_sha256"] == digest(work / "ORDER.json"), "T740 order binding") + need(admission["dispatch_sha256"] == digest(work / "DISPATCH.json"), "T740 dispatch binding") + need(Fraction(admission["kappa"]) > Fraction(read(PACKAGE / "vendor/PR3021-RESULT.json")["kappa"]), + "strict improvement over composed PR3021") + need(admission["source_manifest_sha256"] == read(source / "CLAIM.json")["source_manifest_sha256"], + "unchanged PR3015 edited source") + need(Fraction(admission["kappa"]) == Fraction(release["kappa_decimal"]), "same released endpoint") + need(Fraction(admission["kappa"]) > Fraction(read(source / "CLAIM.json")["kappa"]), + "strict improvement over PR3015") + need(admission["release_receipt_sha256"] == digest(candidate / "release/RELEASE-RECEIPT.json"), + "admission authenticates release") + need(admission["package_manifest_sha256"] == release["manifest_sha256"], "same admitted package") + check_source_chain(work, source, admission, stages) + return {"status": "PASS_T740_R1_COMPLETE_RELEASE", "kappa": admission["kappa"], + "comparison_kappa": read(source / "CLAIM.json")["kappa"], + "gain": str(Fraction(admission["kappa"]) - Fraction(read(source / "CLAIM.json")["kappa"])), + "fill_sha256": fill_hash, "fresh_retained_bootstrap": True, + "fill_payload_sha256": hashlib.sha256((json.dumps( + read(work / "COMPOSED-FILL.json.gz"), sort_keys=True, + separators=(",", ":")) + "\n").encode()).hexdigest(), + "admission_result_sha256": digest(candidate / "RESULT.json"), + "release_receipt_sha256": digest(candidate / "release/RELEASE-RECEIPT.json"), + "stages": stages, "scope": "Conditional finite release; inherited theorem hypotheses remain."} + + +def check_source_chain(work, source, admission, stages): + run = work / "run" + need([s["stage"] for s in stages] == ["source-preflight", *RECIPE_NAMES], "all fresh stages") + need(all(s["exit_code"] == 0 for s in stages), "successful source stages") + edited = run / "source-edits" + need(digest(edited / "MANIFEST.json") == admission["source_manifest_sha256"], "actual edited source") + authenticate_tree(edited) + native_path = run / "native/NATIVE-RECEIPT.json" + native = read(native_path) + need(digest(native_path) == admission["native_receipt_sha256"], "fresh native binding") + need(native["manifest_sha256"] == admission["source_manifest_sha256"], "native source") + need(native["fresh_current_provider_count"] == 2, "two fresh current providers") + need(native["status"] == "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE", + "complete native receipt") + for tag in ("base", "extra"): + actual = edited / ("new/borrow/words/BORROW-WORD-43" + tag + ".json.gz") + expected = source / ("edits/FINAL-WORD-" + tag + ".json.gz") + need(read(actual) == read(expected), "exact edited provider word") + need(native["providers"][tag]["word_sha256"] == digest(actual), "native provider word") + need(digest(source / "MANIFEST.json") == digest(PACKAGE / "vendor/pr3015/MANIFEST.json"), + "unchanged pinned PR3015 manifest") + authenticate_tree(source) + for name, expected in DEPENDENCY_MANIFESTS.items(): + need(digest(run / name / "MANIFEST.json") == expected, "pinned predecessor " + name) + authenticate_tree(run / name) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--repo", type=Path, required=True) + parser.add_argument("--work", type=Path, required=True) + parser.add_argument("--dry-run", action="store_true") + args = parser.parse_args() + result = execute(args.repo.resolve(), args.work.resolve(), args.dry_run) + save(args.work / "RESULT.json", result) + print(result["status"], result.get("kappa", ""), flush=True) + + +if __name__ == "__main__": + main() diff --git a/research/rank7-t740-release/test_verify.py b/research/rank7-t740-release/test_verify.py new file mode 100644 index 0000000000..4f36714b08 --- /dev/null +++ b/research/rank7-t740-release/test_verify.py @@ -0,0 +1,123 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Behavioral controls for the new materialization and admission boundary.""" + +import copy +import json +import tempfile +import unittest +from pathlib import Path +from unittest.mock import patch + +import materialize as m +import reproduce +import verify + + +class BoundaryTests(unittest.TestCase): + def test_literal_release_recipe_changes_all_three_inputs(self): + source, work = Path("/source"), Path("/work") + recipe = [["native", ["python", "native.py"]], ["complete-admission", [ + "python", "admit.py", "--fill", "/source/allocation/FILL.json.gz", + "--order", "/source/allocation/ORDER.json", "--dispatch", + "/source/allocation/DISPATCH.json", "--jobs", "1"]]] + original = copy.deepcopy(recipe) + native = copy.deepcopy(recipe[0]) + changes = reproduce.replace_allocation(recipe, source, work) + self.assertEqual(recipe[0], native) + self.assertEqual(recipe[1][1], ["python", "admit.py", "--fill", + "/work/COMPOSED-FILL.json.gz", "--order", "/work/ORDER.json", + "--dispatch", "/work/DISPATCH.json", "--jobs", "1"]) + self.assertEqual([c["argument"] for c in changes], ["--fill", "--order", "--dispatch"]) + recipe = original + recipe[1][1][5] = "/stale/ORDER.json" + with self.assertRaisesRegex(ValueError, "recipe preimage"): + reproduce.replace_allocation(recipe, source, work) + + def test_full_stock_and_missing_private_buffers(self): + result = verify.physical_bound() + self.assertEqual((result["physical"], result["stock_l2_bits"], result["reserve"]), + (663549, 1324, 1512)) + with self.assertRaisesRegex(ValueError, "all 91 private buffers"): + verify.physical_bound(buffers=72) + with self.assertRaisesRegex(ValueError, "paid prefix payload"): + verify.physical_bound(payload=1511) + with self.assertRaisesRegex(ValueError, "T740 physical contract"): + verify.physical_bound(replicas=74) + + def test_source_drift_rejects_before_execution(self): + with tempfile.TemporaryDirectory() as temporary: + root = Path(temporary) + (root / "input.py").write_text("raise RuntimeError('must not execute')\n") + (root / "PINS.json").write_text(json.dumps({"input.py": "0" * 64})) + with patch.object(m, "ROOT", root), patch.object(m, "PACKAGE", root): + with self.assertRaisesRegex(ValueError, "source digest"): + m.authenticate() + with self.assertRaisesRegex(ValueError, "module source digest"): + m.load_path(root / "input.py", "must_not_execute") + + def test_streaming_writer_rejects_omitted_roles(self): + class TruncatedRows: + def __len__(self): + return 2717280 + + def __iter__(self): + return iter([[0, 0, 0, 0, 0, 0]]) + + with ( + tempfile.TemporaryDirectory() as temporary, + self.assertRaisesRegex(ValueError, "no omitted materialized role"), + ): + m.write_fill(Path(temporary) / "fill.gz", TruncatedRows()) + + def test_root_rejects_unpaid_child(self): + wrong = dict(m.PROFILE) + wrong[48] -= 1 + with self.assertRaisesRegex(ValueError, "rank-mass identity"): + verify.moment(wrong) + + def test_r1_scalar_and_dirty_cleanup_controls(self): + m.authenticate() + check = m.load("vendor/pr3021/verify.py", "retained_controls") + old = m.read(m.MAIN / "data/WORD-base.json.gz") + new = m.read(m.PACKAGE / "vendor/pr3015/edits/FINAL-WORD-base.json.gz") + edits = m.read(m.PACKAGE / "vendor/pr3015/edits/EDITS.json")["edits"]["base"] + self.assertEqual(check.check_word(old, new, edits)["private_buffers"], 91) + bad = copy.deepcopy(edits) + bad[0]["new"][0][3] += 1 + with self.assertRaisesRegex(ValueError, "R1 scalar identity"): + check.check_word(old, new, bad) + new["cleanup"].pop() + with self.assertRaisesRegex(ValueError, "inverse cleanup"): + check.check_word(old, new, edits) + + def test_lifted_order_and_dispatch_reach_the_owner_checker(self): + rows, order, dispatch, providers = m.witness() + wrong_order = copy.deepcopy(order) + second = wrong_order.index([1, 0]) + wrong_order[0], wrong_order[second] = wrong_order[second], wrong_order[0] + with self.assertRaisesRegex(ValueError, "order chronology"): + verify.owners(rows, wrong_order, dispatch, providers) + wrong_dispatch = dict(dispatch) + del wrong_dispatch[0, 0] + with self.assertRaisesRegex(ValueError, "provider dispatch coverage"): + verify.owners(rows, order, wrong_dispatch, providers) + + def test_literal_materialized_capacity_fault_rejects(self): + rows, order, dispatch, providers = m.witness() + + class FaultyRows: + def __len__(self): + return len(rows) + + def __iter__(self): + for index, row in enumerate(rows): + if index == 0: + row = [*row[:5], 1000] + yield row + + with self.assertRaisesRegex(ValueError, "bin capacity"): + verify.owners(FaultyRows(), order, dispatch, providers) + + +if __name__ == "__main__": + unittest.main() diff --git a/research/rank7-t740-release/vendor/PR3021-RESULT.json b/research/rank7-t740-release/vendor/PR3021-RESULT.json new file mode 100644 index 0000000000..399bcc26f0 --- /dev/null +++ b/research/rank7-t740-release/vendor/PR3021-RESULT.json @@ -0,0 +1,92 @@ +{ + "admission_result_sha256": "4c03eeb067b33eb79dcbce1dce1c0dc41185b3185292ecda3ed6d37d2617713f", + "comparison_kappa": "17291509735342244286949999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "fill_payload_sha256": "070cbce2f7d609986afb2ecd8439ca9b3280e7d1d7c9eb7389a65f7dc8caa28f", + "fill_sha256": "15328dd296152417f9d207479fbdd15da05ddb7b499ea7491ce3cae91cc9b27b", + "fresh_retained_bootstrap": true, + "gain": "230448794014303/1000000000000000000000000", + "kappa": "17291512039830184429979999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "release_receipt_sha256": "247d9f03b9cd15b9dc0f49c7bf52d0ca1b2f027186b9b62e7f22020cfbb0f90e", + "scope": "Conditional finite release; inherited theorem hypotheses remain.", + "stages": [ + { + "exit_code": 0, + "log_sha256": "33398f425eb773647292f653df20b6bec51ab4a6ea56e9a3ee71a47978deef98", + "seconds": 1.024184999987483, + "stage": "source-preflight" + }, + { + "exit_code": 0, + "log_sha256": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "seconds": 0.281794958980754, + "stage": "export-pr2894" + }, + { + "exit_code": 0, + "log_sha256": "27c4924f28ac159cf7f0db82313f5007db8729ec1b3ba2815176e7675228cece", + "seconds": 0.5389136250014417, + "stage": "export-pr2833" + }, + { + "exit_code": 0, + "log_sha256": "4a1625fdd9a947187583e67492c492f309e28669082f2e6f2aa97b5da345ea29", + "seconds": 296.06436333298916, + "stage": "fresh-retained-bootstrap" + }, + { + "exit_code": 0, + "log_sha256": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "seconds": 0.517102874990087, + "stage": "four-kernel-stage" + }, + { + "exit_code": 0, + "log_sha256": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "seconds": 0.5696059170004446, + "stage": "preload-stage" + }, + { + "exit_code": 0, + "log_sha256": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "seconds": 0.3528053330082912, + "stage": "parent-paired-stage" + }, + { + "exit_code": 0, + "log_sha256": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "seconds": 0.40792808300466277, + "stage": "paired-extension-stage" + }, + { + "exit_code": 0, + "log_sha256": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "seconds": 0.676031208015047, + "stage": "rank7-overlay-stage" + }, + { + "exit_code": 0, + "log_sha256": "3ad47363c45012cd4f09aee995e551a314b89da7fb70310cabc437cf78957097", + "seconds": 0.3996767089993227, + "stage": "declared-edit-stage" + }, + { + "exit_code": 0, + "log_sha256": "8340209b638d921852def42e529ef2a6cf04eef138ab1235fb6ce4a7101290b9", + "seconds": 0.1875800830021035, + "stage": "derive-closed-adapters" + }, + { + "exit_code": 0, + "log_sha256": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "seconds": 52.94589850000921, + "stage": "fresh-current-native" + }, + { + "exit_code": 0, + "log_sha256": "2b1aeaaf0367d9665773d8646eeac7b4af3a2a89e4848f621bf2e13efcdaab14", + "seconds": 294.33291362499585, + "stage": "complete-admission" + } + ], + "status": "PASS_RESTORE_PACKING_COMPLETE_RELEASE" +} diff --git a/research/rank7-t740-release/vendor/pr3015/CLAIM.json b/research/rank7-t740-release/vendor/pr3015/CLAIM.json new file mode 100644 index 0000000000..70813f559e --- /dev/null +++ b/research/rank7-t740-release/vendor/pr3015/CLAIM.json @@ -0,0 +1,229 @@ +{ + "admitted_package_manifest_sha256": "75a1536a7eaafa59c553d62c0ec8ce9a0b68f7365ecadea590ab85c7a78e0c1b", + "baseline_head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "baseline_kappa": "17240352247481048785499999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "baseline_pr": 2969, + "baseline_status": "FINITE_NATIVE_OWNER_AND_MOMENT_CANDIDATE_OUTER_PENDING", + "calls": 666, + "complex_lower": "345830194706844885739/200000000000000000000000", + "declared_edits": { + "count": 1, + "edits_sha256": "c9c68660d07bfd12ed20fd8cbfe3d36301ceb2d7bb9b4ea11350cc399b19e0b1", + "previous_kappa": "0.0017290339826465135177169999999999999999999998999999999999999999999999", + "previous_pr": 2979 + }, + "fill_sha256": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "fixed_inventory_cap": { + "cap_lower": "345830551200866186907/200000000000000000000000", + "cap_upper": "17291527560043309345351/10000000000000000000000000", + "realized": "below the fractional optimum by the recorded gap (check_cap.py); the cap basis is fractional at T74" + }, + "gain": "1023149757223910029/200000000000000000000000", + "helpers": 408, + "independent_inputs": 632, + "kappa": "17291509735342244286949999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017291509735342244286949999999999999999999998999999999999999999999999", + "live_families": 66304, + "local_profile": { + "1": 2443, + "2": 707, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "native_receipt_sha256": "bc03c643a2209ec74f6efe9f74c29d7a1836b1be4b6bfe6e9ee5f3d82c01d19c", + "physical_families": 66813, + "previous_claims": { + "pr2942": { + "claim_file": "comparators/PR2942-CLAIM.json", + "gain": "6334653671010100699/1000000000000000000000000", + "head": "a027b0f6fdb0ab2b42ba10fc31b53960166bf2bf", + "kappa": "17228163198632143279959999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2942 + }, + "pr2957": { + "claim_file": "comparators/PR2957-CLAIM.json", + "gain": "1358389615871564431/250000000000000000000000", + "head": "b74b25f3ccc84c16e1a801d73b2f47e5ea764c78", + "kappa": "17237174150707381709709999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2957 + }, + "pr2966": { + "claim_file": "comparators/PR2966-CLAIM.json", + "gain": "5116701010772251283/1000000000000000000000000", + "head": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "kappa": "17240342725234521774119999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2966 + }, + "pr2969": { + "claim_file": "allocation/baseline/CLAIM.json", + "gain": "1023149757223910029/200000000000000000000000", + "head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "kappa": "17240352247481048785499999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2969 + }, + "pr2979": { + "claim_file": "comparators/PR2979-CLAIM.json", + "gain": "58495443855455489/500000000000000000000000", + "head": "be191346391661f4d35fc0d1508d0a6029572576", + "kappa": "17290339826465135177169999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2979 + } + }, + "profile": { + "1": 1644348, + "2": 470862, + "3": 159468, + "4": 71928, + "48": 28190, + "5": 13716, + "8": 5328 + }, + "release_receipt_sha256": "f6ddfdbbdd343cfd0a11e1d7b00cb9a8a6fbc9c7a64159b0d5abaf7de88cecf2", + "replicas": 74, + "scope": "Conditional finite supplier/outer certificate for PR2979's words (mdumitrean: joint rank-7 end frames, five further paired extractions, fourteen PR2957 rewrites) with one declared literal restore edit (R1, Stack2979 / Jeremy Kothe) and PR2979's literal T74 allocation unchanged (paid profile re-derived). Inherited all-size/compiler/theorem hypotheses remain. No selected-frontier change or independent-human-review claim.", + "source_manifest_sha256": "9215312229c431078ba61daf106edb8caf20b33f48317d46438a341552cf153f", + "stages": { + "stage1": { + "frame_edits": 139, + "groups": { + "A": { + "W": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "helpers": [ + 331, + 450, + 451, + 508, + 509 + ] + }, + "B": { + "W": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "helpers": [ + 299, + 448, + 449, + 484, + 485 + ] + }, + "C": { + "W": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "helpers": [ + 452, + 453, + 532, + 533 + ] + }, + "D": { + "W": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "helpers": [ + 454, + 455, + 556, + 557 + ] + }, + "V45": { + "W": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "helpers": [ + 249, + 251, + 265, + 267 + ] + } + }, + "kind": "joint codimension-2 end-frame lowering (frame-only)", + "record_sha256": "5fbfce004330ebc1fbac8de264614fe295f1a074811b478db4892c3bc3852cd3" + }, + "stage2": { + "extractions": [ + { + "helper": 226, + "normal": 42, + "step": 1 + }, + { + "helper": 228, + "normal": 42, + "step": 2 + }, + { + "helper": 230, + "normal": 42, + "step": 3 + }, + { + "helper": 363, + "normal": 7, + "step": 4 + }, + { + "helper": 395, + "normal": 7, + "step": 5 + } + ], + "kind": "rank-8 paired input/output extractions" + }, + "stage3": { + "applier_sha256": "2509f1335e47543f8814b42d6bf83032b30c5899b4f7cc62a6adc03f5138ae13", + "count": 14, + "kind": "declared exactness-preserving gate rewrites (Jeremy Kothe, PR2957), re-addressed", + "rewrites_sha256": "a37ade675876e4f5b00b33066c84f495fccd264863b7eb5d813837b1d01c3e7d" + } + }, + "status": "CONDITIONAL_CANDIDATE_COMPLETE_FINITE_RELEASE", + "width_inventory": { + "4": 26, + "5": 2, + "6": 16, + "7": 52, + "8": 99, + "9": 213 + }, + "zero_buffers": 91 +} diff --git a/research/rank7-t740-release/vendor/pr3015/CREDITS.md b/research/rank7-t740-release/vendor/pr3015/CREDITS.md new file mode 100644 index 0000000000..3b6022cd64 --- /dev/null +++ b/research/rank7-t740-release/vendor/pr3015/CREDITS.md @@ -0,0 +1,17 @@ +# Credits + +- **PR #2908, Jeremy Diviney**: the paired input/output extraction, its compensation rule `C*S`, the exact two-sided certificate (`structure.py`, vendored unchanged) and the closed-adapter admission chain. +- **PR #2917, Mason Hale**: the nine paired extractions and 82-endpoint words under PR2942, the refit/compose producer model that stage 2 follows, the T74 chronology (ORDER/DISPATCH), the allocation checker, moment auditor, extension stage and adapter derivation reused here. +- **PR #2957 / #2948 / #2966, Jeremy Kothe (jeremykothe2)**: the fourteen declared exactness-preserving gate rewrites in five classes (R-retime, A3779-cut-start-read, PM-carrier-lender-entry, B-carrier-retime, A-commuting-swap) and their pure applier (`vendor/declared_rewrites.py`, vendored unchanged); stage 3 composes exactly these rewrites onto this package's stage-2 word (`data/REWRITES-2957.json`, re-addressed with exact preimages). PR2966 composed the same rewrites onto our PR2942 words. +- **PR #2969, Dugongue**: the PR2942 + PR2957 composition at T370 and its cap-level headline nomination, this package's comparator and moment baseline (`allocation/baseline/`). Our stage 3 composes the same fourteen rewrites, here onto the stage-2 word. +- **PR #2918 (research/helper408-rank7-pairing), RossRichardson**: the fixed-cut rank-seven obstruction for helper408; this package's census of fresh rank-7 extractions reproduces it exactly and is consistent with it. +- **PR #2894 / #2833, Jeremy Kothe**: the preload re-synthesis supplier, the frame accounting and inverse-reverse cleanup (`vendor/preload_move.py`), the source materializer and the inherited supplier lineage. +- **PR #2857 / #2848, Yiyang Lu (Lyy-iiis)**: the shared-kernel words, the staged native/overlay tooling and the chronological flow model and realization (edge colouring) used to construct the allocation; PR2843 (Marius-Paul Dumitrean) is that flow model's starting point. +- **PR #2863 / #2839, Dugongue**: the packing lineage and the PR2839 owner engine. +- **Tekalign**: the independent owner/chronology checker (`allocation/vendor/independent_owners.py`) and admission tooling. +- **icekylinx**: the exact free-operator auditor retained as `vendor/audit_local.py` (PR2833). +- **themilkman216**: the observation that a cap-level allocation of these inventories needs a T whose basic counts are integral, which the allocation's degenerate-face step builds on. +- **Gareth Davidson (bitplane), PR #1995 / #2013**: the fixed-word terminal-subspace bounds that frame stage 1's scope; earlier rank-seven helper ends on other words are in `research/complex-rank7-end-pair`, `research/k8-rank7-composition` and the PR1090/PR1104 lineage (credited there). +- **PR #2930 / #2942, Marius-Paul Dumitrean**: the cap allocation of PR2917's words, the four normal-45 extractions under these words, the relaxation tools and the overlay/producer conventions reused here. +- **New here (Marius-Paul Dumitrean, with substantial AI assistance from Anthropic Claude via Claude Code)**: the codimension-2 census on paired-extraction words, the joint end-frame lowering of 22 restored helpers in five groups (stage 1), the five further extractions it makes profitable (stage 2), the exact composition with PR2957's rewrites (stage 3), the producer and local verification for all three stages, the overlay stage `rank7-joint-endframes` with its rebuild guards, the adapter generalization to six width classes, the literal T74 allocation of the changed inventory, its relaxation certificates and recorded gap, and the complete fresh replay. +- **New here (Jeremy Kothe (jeremykothe2), with AI assistance; edit found by our Stack2979 search)**: the declared literal edit stage (`edits/`, `tools/build_edits.py`) with its independent review, the edit R1 on PR #2979's restore section, the re-derived paid profile and cap certificate. PR #2979 (mdumitrean) is the base and is credited first for everything else. diff --git a/research/rank7-t740-release/vendor/pr3015/MANIFEST.json b/research/rank7-t740-release/vendor/pr3015/MANIFEST.json new file mode 100644 index 0000000000..a331a50f94 --- /dev/null +++ b/research/rank7-t740-release/vendor/pr3015/MANIFEST.json @@ -0,0 +1,156 @@ +{ + ".gitattributes": "056f4f66161e333f3a8d4c20de323ca05599a7deac1aa02d47ba6f6b96335573", + "allocation/baseline/CLAIM.json": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77", + "allocation/baseline/ORDER.json": "d559a1dcb83707724afc0310f6ef8e3a36ad6cda0a895ca6abae9d6f39a0fc76", + "allocation/baseline/PROFILE.json": "6de8ac1fd628cdd2afa5a43872da69c7dab9d7219bdc318f9db55fd8ccdb5eb2", + "allocation/DISPATCH.json": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c", + "allocation/FILL.json.gz": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "allocation/ORDER.json": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1", + "allocation/PROFILE.json": "5626c44edd6d5b209cd4e2d2a824e07bfba696e0856f3964b81fcb01c78eaad8", + "allocation/PROVIDERS.json": "f52d926752eac5d847092dd58bfb9f3f3c6ac36adf39cd6a3c4d4a3b2d1fce15", + "allocation/SEARCH.json": "2ceb1f825cb68e44d17d4251f74c3975ae5122c845391c1ca8de2e564ac4246a", + "allocation/vendor/independent_owners.py": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461", + "allocation/vendor/PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "allocation/vendor/TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "ALLOCATION-PINS.json": "5ea15a726c5fd3960ae2042ee21e7b3ad56aa46b65619233d5da117ae6349a92", + "certificates/RELAX-CAP.json": "6380d23931bfcdf4bd2684dd19bb60db543f570bc88873f5effd53387beb28b0", + "certificates/RELAX-STAGES.json": "0e5ec700a191b668ba3d4b6d675f5c047d264b9a5109fc55fa92961b3fcb7d68", + "check_allocation.py": "64b2bacd98728a25195d80e5be6c0374e24fba1400290edaafb895dcc5d54368", + "check_cap.py": "3f7901f4c1849074478df3c08ea98b792ae7325fd700948f01d80c11c9106893", + "CLAIM.json": "f9b9fbaaac794c0ce279c238a33a2f34f8c91a34d97ccdeb5ec98b7b8ba56d73", + "comparators/PR2942-CLAIM.json": "011aaac80ad79f7f29dc429a672441bb6b3c21a68bbcb34c7a0d5f943c3c3c2e", + "comparators/PR2957-CLAIM.json": "a93e6c9e94bc9bf5664b5e23506dda9647fad1930e1eede66d5ba9f3718b598a", + "comparators/PR2966-CLAIM.json": "4d4c4800bf3bcb36d09021313b2712aebd4aa0830c74dda30991daf6851c220a", + "comparators/PR2979-CLAIM.json": "436e0d297cbdf195445d3697d496ac675e95210b79e70ce602a6a6667a4c6ce9", + "construction/allocation/assemble.py": "57fcc8dd6f08b5557add7f34c0deb993574f71b3e565d6668085f1f65df5eccd", + "construction/allocation/controls.py": "9e10e5c21fab8ea2fdaf07ce92a141c4e6d63a7ef02d9de25bc9022ad1ae7998", + "construction/allocation/diag_lp.py": "59bfeb9586820f7b653370e20619760e23a4b170e4b7e14dc4e2abad9f5d9c61", + "construction/allocation/double.py": "8a89fafcd69cacb0a5a8d19a90d76f8740cf8f12585dc83796fcd8bc428dd94f", + "construction/allocation/fill17.py": "933be460381d65ea04a6e7f288f977ba22a7e4068b69494d65c38ccd7e5f4dbf", + "construction/allocation/providers_from_words.py": "8cf55c2859a626d86f21b447460321c19db92fec8e1f893b3cd37267f3b145fd", + "construction/allocation/round_mix.py": "0d0a423817b30fda9cceaa61b9bcc90e07710f9829e65098c9a31ed1734341bd", + "construction/allocation/T37-FACE-MIX.json": "10598b7ea2e26fbd49db2b4d2f08122415fd6673b87fb7b458019d503ae60744", + "construction/allocation/T37-FLOW.json.gz": "765c6b774ca207f715dd5f579995700f4787c1f4eb92a7855bfc1424f683eca4", + "construction/allocation/T37-MODEL.json": "74849384ad2160f0402f6577e9d3ea849c21704abcf839af50f3353e141a4355", + "construction/allocation/T37-PATTERNS.json": "df09e4581d7ed73fa22253909197ceb26ced59333f50c008c822894a4082f0e4", + "construction/allocation/T37-SOLVER.json": "f56caa18e9638c568c57e699a8576fa6dcbdfe6ba54ae2da3fc8bc626168d863", + "construction/allocation/T74-CONTROLS.json": "0de2d067d957bbca2580566576030d4f10508b7827a0d83a0bd8c05f19b23bbf", + "construction/allocation/T74-OWNER-CHECK.json": "996234db3632983effc279a93cb5599a945688a3ea476fc9f88e3a714fb330be", + "construction/records/derive_stage2.py": "f2518333cea351376ee094e8212b71ad753710d4038c55937a9e3bb212249f9e", + "construction/records/make_data.py": "b9528bcb26bc3c1a8e582032fa3899c79dc4cb463814dc6fea617fd83a5b4858", + "construction/records/make_prices.py": "5fcf593b5672b4f66cabd9d2bd5b4e843453248186d95794386331d801280b78", + "construction/search/codim2.py": "1dd77f4ceb0c4cf82ee5f3f4c04123724db09ebb0e7b9f856c4bd000d4e57531", + "construction/search/combine.py": "d06e041082f120b903937a8c7fdf2189eb42411330af625492ff5a24109b49d0", + "construction/search/deliver_l22.py": "b5f0a6ee2eaf1cbef95f0447efb08b75937e7e03c6d27d0b73d5c884c24a91b5", + "construction/search/final_l27.py": "e964d48e7b7705cc64a57bd42d81eb990d69606689349240e5a18155d08f7350", + "construction/search/lowerA.py": "1aba1edb5397701151b2c95afaf23cd8e675ddc48b5ccca1738bc0c5370e9a6c", + "construction/search/lowerA_joint.py": "eb0efbe0c40d063a606dc370362a8d3fe3f4f57877e2e79f63be940fe06ce41b", + "construction/search/realize.py": "6d524f4a1ce0a4bf77f8e5a859e46922334956688c9268dbea3004e3aea6898e", + "construction/search/vlower.py": "3052c96b4f00239fe679f460bbbad2b7271089b5aa73665cb92c052755143ec4", + "construction/STAGE-PRICES.json": "dfb7d06724bf95367f3fdb398f4828fc70f803d23030bc0eee0b00541457f546", + "CREDITS.md": "bd4b09fcd2861933883cbce6ecf0e30743d5d3b4cb0cc38e258530c370c121b9", + "data/PARENT-base.json.gz": "54ca34c749e3228d7e2df3d8dbf7aa1568c2872490166997c5962f12fd03da35", + "data/PARENT-extra.json.gz": "eded756dfe8f411c3d1f80a3ac16516f0ea5dd6f9866728b2179b157630fa7b6", + "data/REWRITES-2957.json": "a37ade675876e4f5b00b33066c84f495fccd264863b7eb5d813837b1d01c3e7d", + "data/STAGE1-FRAME-EDITS.json": "5fbfce004330ebc1fbac8de264614fe295f1a074811b478db4892c3bc3852cd3", + "data/TRANSFORM-226.json": "1732a39728c068f9d663111c7876b4e0b96088f3dd3b8e6ff824551b5a711338", + "data/TRANSFORM-228.json": "82346e6a5173c4822e16b2dad06ca232111b6795a340079f9aceabe0098797c0", + "data/TRANSFORM-230.json": "8ad70d545695b5d2246fb9e09d46abcc1e42926c1161884f69b77f978a28f46d", + "data/TRANSFORM-363.json": "84d2a609739eb30d4d9356fb6f04b2ff32c8823a978d7a51db1ace1d6d2352cc", + "data/TRANSFORM-395.json": "065aa5d7713683942bc2156b543681857e33c6e2f30f32cba47e2cbb9d1bef69", + "data/WORD-base.json.gz": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "data/WORD-extra.json.gz": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7", + "EDIT-PINS.json": "0cd0ae761bdb53ef1aedefac2f82e0ecb83ce555e422e326c55412d637118dcd", + "edits/declared_edits.py": "d3e49b844e9522808a439d505487839addbd957c7d1055bb57fa00e32cbba7b8", + "edits/EDITS.json": "c9c68660d07bfd12ed20fd8cbfe3d36301ceb2d7bb9b4ea11350cc399b19e0b1", + "edits/edits_review.py": "41734b21dfef4fe9c0917e6afcfb2d0652a4a55583f9cbc300af0ffc275af28c", + "edits/FINAL-WORD-base.json.gz": "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5", + "edits/FINAL-WORD-extra.json.gz": "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea", + "evidence/ADAPTER-DERIVATION.json": "2f09d2bcaa32ed2c65dc4549b7bdc98da1616fe99bad25056be53cb6b9811c6a", + "evidence/ADMISSION-RESULT.json": "f65b098a5cad1402f2badfe08f0e32ed9cdf93c7b4b5acc6be1c189ebff27f85", + "evidence/ADMISSION-STAGES.json": "ebbea57281a5effb1048e3585cea620cd07fe576121d564c417379ed160e18f5", + "evidence/EDITS-DERIVATION.json": "a69cf29822525b02a9e01317ff9e4fd12d7d70dcb24bc068ae24b2de65cbbf36", + "evidence/EDITS-REVIEW.json": "b7a485d2c5a3ec8bbe56182af355360dad584bc8efd63891b817e9856a1bfa07", + "evidence/ENVIRONMENT.json": "7d3ec720e565ce8461b95b28162f25ffe1b1dfbd7576eab70c0b6ff84fbf792d", + "evidence/FULL-NATIVE-RECEIPT.json": "bc03c643a2209ec74f6efe9f74c29d7a1836b1be4b6bfe6e9ee5f3d82c01d19c", + "evidence/FULL-NATIVE-RESULT.json": "ebcb0d2a6750dbd6f99252b9cc4ff8a0348e29f6e3150c8c2896a2f2e1ced528", + "evidence/FULL-REPLAY-RESULT.json": "f2686e9ad61b717e3bf917286bdbe8ebf21d1e14e64856e868a077db8d72929e", + "evidence/FULL-REPLAY-STAGES.json": "0d982174d950fff6c1ae168b51902c47e03b38ca47012216c511900f7cc106f3", + "evidence/logs/admission-discovery.log.txt": "1d520540cb875d2dc90db71fcbead647852d1e2b02ae01ba1c265f7aa51a4c57", + "evidence/logs/admission-outer-check_ledger.py.log.txt": "972a55790dc93979669a700deb02d02a3be936e93ac724a470a2b04a974e5461", + "evidence/logs/admission-outer-independent_check.py.log.txt": "714d3541e97dbcbc11080cee25dee15ca56f5e2b7b3769b29f5038dbc1420340", + "evidence/logs/admission-owners.log.txt": "869df7d6f2381446c933a28bdf53340e11b447ba1e90d620d017195a1a7410da", + "evidence/logs/admission-parent-lift.log.txt": "2389e2ae8c710f1a6ee0b25cccf0b4fef3a87812dc1cbe83a41c14ae32087487", + "evidence/logs/admission-rebind.log.txt": "18bc354417c5a6ceac79a96b0f88c3234f0309e9122c6e6c51affa49198e82f2", + "evidence/logs/admission-release.log.txt": "28e3fde8609d83a6eeb9f31cb5e3256cd939ccf5d220e63bcc9f108325006e31", + "evidence/logs/complete-admission.log.txt": "9681b993ad0c728a013435176a820a007e793104aa84ff5368437ecaac054ee4", + "evidence/logs/declared-edit-stage.log.txt": "70b401477abb6e419570f236f7ccb648101b90794bec5feac3f1d1cccd1ce956", + "evidence/logs/derive-closed-adapters.log.txt": "d79bd114c998f3fd6fd463c401ffd28b5cfbb760c5d4232e169f8c7eed34b509", + "evidence/logs/export-pr2833.log.txt": "f552acd4dabe475385662550ad1c15852259e2da3aeecb9b13cab04c5aefa1ba", + "evidence/logs/export-pr2894.log.txt": "cd3a45db2c9d74f2bd2e05a740e03a2a399209de4a0cbacbd5e527436bb6af76", + "evidence/logs/four-kernel-stage.log.txt": "eaa688738314d328fdd78cdd4ebac700fa044ebe672de6f6b15a3608ba7e9a18", + "evidence/logs/fresh-current-native.log.txt": "23a07eea566458947dadad21fa194ecf8dac8ebe9142d829bbfef66538a8cc53", + "evidence/logs/paired-extension-stage.log.txt": "d0eacd00db46fbaf4cc97af7b94eea3a9ad27f76dd3bc75632e2014a5eab5334", + "evidence/logs/parent-paired-stage.log.txt": "4ef095c17a64356df1155566be29f284d924df678691ef89b79548b95b1565df", + "evidence/logs/preload-stage.log.txt": "e94aa478b278850cc7eb29dd2347cd71c35d52ae220d64624da8d06e53063912", + "evidence/logs/rank7-overlay-stage.log.txt": "0d7805b2d8480a959ef4afd284a80bbe53df3f783a322cbe7c3b135aba50247a", + "evidence/OVERLAY-DERIVATION.json": "145a9491cca7b22f0d04cccb66795a7b6914a1ee415ecfc65e1db7b586573826", + "evidence/pr2979/ADAPTER-DERIVATION.json": "abfe60c965953c567392b587cbcc4703f2f80fc60e267539251a1eac0f9db2f3", + "evidence/pr2979/ADMISSION-RESULT.json": "be9652312a88fd670eb09a4303679b4e875516d02a008ce90ccbca8a92e6b2ac", + "evidence/pr2979/ADMISSION-STAGES.json": "bf2fcb3012c65d861ccc4ba5950e5b97cbff31f603268afdb7e9ae2a0ac9696f", + "evidence/pr2979/ENVIRONMENT.json": "c6faaaa9b538ddbf0ea3c624bbe2f1c7e4074f8cb504d4bee0f3353f1e7f32a1", + "evidence/pr2979/FULL-NATIVE-RECEIPT.json": "6d27c89d5e3a2c7f28387e4b20c462b0dff6c9fa92aacdde715d4b29cc286d41", + "evidence/pr2979/FULL-NATIVE-RESULT.json": "ee10e7b8f2196b3bd28f5389b9be3372c216f3cfe67e00c7a2bcd130746ac364", + "evidence/pr2979/FULL-REPLAY-RESULT.json": "0293261edd3696408e1067df358644a7f43fd05f6c7b78e255aeac3f4a2530a2", + "evidence/pr2979/FULL-REPLAY-STAGES.json": "d8764bbbc029b13e20dc881783c44b74c689064d9ddf8286fc18371f2ec0d503", + "evidence/pr2979/logs/admission-discovery.log.txt": "68845b7e19574ee2040677640848f0f7aaf71854250dfe0470dfae3ff09210b3", + "evidence/pr2979/logs/admission-outer-check_ledger.py.log.txt": "c56f8e0232d749e0ff33b76a8f9de18d28a7bb3abcd736ba69a4b167f2b5a824", + "evidence/pr2979/logs/admission-outer-independent_check.py.log.txt": "7eab2e50c0b03f058ae320c4791a0ea5a0ae3eae3393d29971663428ca79547a", + "evidence/pr2979/logs/admission-owners.log.txt": "dc4840d279e447e42af2ece9437cb92ab13c7f631440911ca5e8a676e3fa418c", + "evidence/pr2979/logs/admission-parent-lift.log.txt": "7b6249a123ca39fae7b7a6339dd9e8ae8777b081f4336418f2cc101704b70644", + "evidence/pr2979/logs/admission-rebind.log.txt": "6126af0a7935a1605ddad6074978494d462ed67cbd54be809ce13fcb32469d67", + "evidence/pr2979/logs/admission-release.log.txt": "d1e575ccd284596605baf38e5ed5b751cd5f506572ef9cfc578bd88d917b46a0", + "evidence/pr2979/logs/complete-admission.log.txt": "37584a0aed98b08f491b676ba0e4914518027f556495b1ae4e8a9a123d360b4f", + "evidence/pr2979/logs/derive-closed-adapters.log.txt": "d11d75855720cfa75a26f667a61467b5122a7b7ae5521030509bf1cbdd00a496", + "evidence/pr2979/logs/export-pr2833.log.txt": "0fa7e0c6a0f0e31c60aadd0fe2afa6841d046d3272a02d3dc873f999b8508654", + "evidence/pr2979/logs/export-pr2894.log.txt": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "evidence/pr2979/logs/four-kernel-stage.log.txt": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "evidence/pr2979/logs/fresh-current-native.log.txt": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "evidence/pr2979/logs/fresh-retained-bootstrap.log.txt": "4a1625fdd9a947187583e67492c492f309e28669082f2e6f2aa97b5da345ea29", + "evidence/pr2979/logs/paired-extension-stage.log.txt": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "evidence/pr2979/logs/parent-paired-stage.log.txt": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "evidence/pr2979/logs/preload-stage.log.txt": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "evidence/pr2979/logs/rank7-overlay-stage.log.txt": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "evidence/pr2979/OVERLAY-DERIVATION.json": "145a9491cca7b22f0d04cccb66795a7b6914a1ee415ecfc65e1db7b586573826", + "evidence/pr2979/RELEASE-RECEIPT.json": "473a5f8e048e45d7e83747077a18985ef87d58da370ca3f2fe5748a057ffdb2d", + "evidence/pr2979/RETAINED-BOOTSTRAP-RECEIPT.json": "ba9ef5709319ceb54928aed10cb250f3d018b3f654a2902c53df27d9e2e1157f", + "evidence/pr2979/RUNTIME-PATCHES.json": "6e4fe608caae2cdc28abc0ab772514d03ede2a4a50b06e9ede2853ab6889f218", + "evidence/README.md": "5b4d6054ee8410f01405bb8adb2b28f4f4a6f293b35426b4f7d32f0a73bd4695", + "evidence/RELEASE-RECEIPT.json": "f6ddfdbbdd343cfd0a11e1d7b00cb9a8a6fbc9c7a64159b0d5abaf7de88cecf2", + "evidence/RUNTIME-PATCHES.json": "25a75bcbc9535bce28c14fbe2fdff6ab42ed7a8193da6d473258ebd53901315c", + "NOTICE": "ffcc3de2243815db0e9fb8d820b4ca511fce3c7673c966e14b486f05d30ac11a", + "PINS.json": "2bd63d7767c5e2c2caa337b32b7c8c3c4adb65ce9d7b79997340865a536fe759", + "producer.py": "d4577cee26314b36b59723cc68df9b8895b22449cc15807c95f325f555c4da3a", + "README.md": "186a01ff053630b6451464ed61b779e3747602d85805f5f0ad0dca8c3b9407f0", + "RELEASE.json": "e6bbe07c74ca07adb4b37c955aa7485e474ff83133a2715cea9a291fdf33fa8d", + "reproduce.py": "ec9cbbf3d11377804e419745bc43ae5ad35c3b6f5fcde41df5f61f482f36e595", + "run_registered.py": "3439d214a163223c2ca7b50562bfb24b284551d5c8a36f4cc74791f890d4dd4a", + "SOURCES.json": "d5f3f498d4d34125bcaed14dafaceaff342223d511d1099993d5b217a147019c", + "structure.py": "83f63b6d9a1a543ecfa2c98d479dbe4e7a1c3caf6fd1c3566123308efbc32e96", + "TASK.json": "b1f2b3c1eb570009689fd6fd408c011e5a851c3ab1e407ba4ed0cdd60a4474b1", + "tools/audit_allocation_moment.py": "c632527ecf092f013862660dbd7f52b599a50b321a8aa88ddc45af0547e79cb5", + "tools/build_edits.py": "7292e18bbbcd2fabc87ed423e3d5d648d03709d0a061563087786ad0d57fb832", + "tools/build_overlay.py": "9d98ace9bffb37aeebd05b93ed386f73e6eee169d960e4956cf14a66e6852140", + "tools/derive_adapters.py": "5c06828151cd230add3e328b42dda72c4a2ed1075bd2902f38ee28727870bc84", + "tools/relax.py": "0fed1c56b50a2e6d44deeeb6db0f1c7e1f71b86d1747130e1a9202216249a728", + "tools/relax_exact.py": "baf1855d6095c951a90d19a0d8094bd33290519940b732e2b758c5647830f044", + "tools/root.py": "55f5aca39b5ee2fe4687ac8863e6c24569010f27a332883c069b8e14b8fe09e3", + "tools/wordedit.py": "cae8ae0f5d7fb3387ec6922fe966068aae05e3a6d3586830d4361b650cfb3617", + "vendor/audit_local.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "vendor/declared_rewrites.py": "2509f1335e47543f8814b42d6bf83032b30c5899b4f7cc62a6adc03f5138ae13", + "vendor/preload_move.py": "c8fda4674644fcd5cbf39b6645ce148a21daa90a998b678cbe51f970b78b0044", + "VERIFY.json": "620001c99145f78fbb639218e97620a956e87fe0a11b541e22b3ccb68fa29ffb", + "verify.py": "5c6bdd35c81d9a2b3a12e020874a5d32e8b0783a3c35bff7a28d070586003401", + "verify_manifest.py": "723d726dbbe5b65a49caecae0f1aab664a1413fb639abfd3e826a5a538e14e5b", + "verify_release.py": "a74e909c70869186bddb8952f049c09fc444800999123d2fac53c7ecda075581" +} diff --git a/research/rank7-t740-release/vendor/pr3015/NOTICE b/research/rank7-t740-release/vendor/pr3015/NOTICE new file mode 100644 index 0000000000..70a09b472e --- /dev/null +++ b/research/rank7-t740-release/vendor/pr3015/NOTICE @@ -0,0 +1,28 @@ +research/rank7-joint-endframes +Copyright 2026 Marius-Paul Dumitrean. Licensed under the Apache License, Version 2.0. +Prepared with substantial AI assistance (Anthropic Claude, via Claude Code). + +This package retains, byte-identical, Apache-2.0 files from: PR #2942 (Marius-Paul Dumitrean, head +a027b0f6fdb0ab2b42ba10fc31b53960166bf2bf, research/paired-extension-normal45): data/PARENT-base.json.gz and +data/PARENT-extra.json.gz (its data/WORD-*.json.gz), comparators/PR2942-CLAIM.json and tools/wordedit.py; PR #2917 +(Mason Hale, head 224bd5e56041c40078ff6b5fa7393733a215de5c, research/paired-helper-extension): structure.py (Jeremy +Diviney's PR2908 two-sided certificate checker), vendor/audit_local.py (PR2833's independent exact auditor, icekylinx +attribution), vendor/preload_move.py (Jeremy Kothe's PR2894 frame accounting and cleanup), allocation/ORDER.json, +allocation/DISPATCH.json and allocation/vendor/ (independent_owners.py: Tekalign's independent owner checker as vendored +by PR2839/PR2917; PLAN.json.gz, TEMPLATE.json.gz); PR #2957 (Jeremy Kothe, head b74b25f3ccc84c16e1a801d73b2f47e5ea764c78, +research/paired-extension-cap-fill-swaps): vendor/declared_rewrites.py (the pure applier of the fourteen declared +rewrites) and comparators/PR2957-CLAIM.json; PR #2966 (Jeremy Kothe, head e62d3eb9005117d82a9babcfa937ecc53237c490, +research/paired-extension-normal45-rewrites): comparators/PR2966-CLAIM.json; PR #2969 (Dugongue, head +e2ca469b08385d3d5e29a918d66dbefaf889e9f3, research/paired-swap-normal45): allocation/baseline/ (its CLAIM.json and its +allocation ORDER.json and PROFILE.json); and PR #2930 (head 81f3b5d12977eba09e06fbff729167d59faabe90): tools/relax.py, +tools/root.py, tools/relax_exact.py. +data/REWRITES-2957.json is Jeremy Kothe's PR2957 rewrite list, re-addressed to this package's stage-2 word with exact +preimages (every entry keeps a credit field). producer.py follows PR2917's producer.py (Mason Hale) for its paired steps; +verify.py, check_allocation.py, check_cap.py, run_registered.py and reproduce.py adapt our PR2942 versions of PR2917's and +PR2930's; tools/audit_allocation_moment.py is PR2917's exact moment auditor with only its authenticated baseline changed (to +the PR2969 headline); tools/derive_adapters.py generalizes PR2917's adapter derivation (PR2908, Jeremy Diviney); +tools/build_overlay.py follows the overlay conventions of PR2908's and PR2917's builders. construction/allocation/ retains +the flow model of PR2857/PR2843 (Yiyang Lu, Marius-Paul Dumitrean) as adapted for this allocation. All original notices of +the exported predecessor packages remain in force. + +Derived work (Apache-2.0): this package is PR #2979's (Marius-Paul Dumitrean, head be191346, research/rank7-joint-endframes) package, retained byte-identical except for the files named in README.md, plus a declared literal edit stage by Jeremy Kothe (jeremykothe2), with AI assistance: edits/ (declared_edits.py, edits_review.py, EDITS.json, FINAL-WORD-*.json.gz), tools/build_edits.py, EDIT-PINS.json, comparators/PR2979-CLAIM.json, and the edits to reproduce.py, run_registered.py, check_allocation.py, check_cap.py, allocation/PROFILE.json, allocation/PROVIDERS.json, certificates/RELAX-CAP.json, CLAIM.json, PINS.json and the release contract files (RELEASE.json, verify_release.py, verify_manifest.py). PR #2979's own evidence is kept under evidence/pr2979/. diff --git a/research/rank7-t740-release/vendor/pr3015/allocation/PROVIDERS.json b/research/rank7-t740-release/vendor/pr3015/allocation/PROVIDERS.json new file mode 100644 index 0000000000..cac6220d3d --- /dev/null +++ b/research/rank7-t740-release/vendor/pr3015/allocation/PROVIDERS.json @@ -0,0 +1,842 @@ +{ + "extra": { + "actual_paid_profile": { + "1": 2443, + "2": 707, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "widths": [ + 9, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 9, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 6, + 6, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 6, + 6, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 6, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 6, + 6, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 5, + 5, + 8, + 8, + 8, + 8 + ] + }, + "gauge44": { + "actual_paid_profile": { + "1": 2443, + "2": 707, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "widths": [ + 9, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 9, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 6, + 6, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 6, + 6, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 6, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 6, + 6, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 5, + 5, + 8, + 8, + 8, + 8 + ] + } +} \ No newline at end of file diff --git a/research/rank7-t740-release/vendor/pr3015/edits/EDITS.json b/research/rank7-t740-release/vendor/pr3015/edits/EDITS.json new file mode 100644 index 0000000000..90894fc659 --- /dev/null +++ b/research/rank7-t740-release/vendor/pr3015/edits/EDITS.json @@ -0,0 +1,216 @@ +{ + "declared": { + "local_profile": { + "1": 2443, + "2": 707, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "width_inventory": { + "4": 26, + "5": 2, + "6": 16, + "7": 52, + "8": 99, + "9": 213 + } + }, + "edits": { + "base": [ + { + "id": "R1", + "new": [ + [ + "add", + 61, + 63, + 1, + 1, + [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + ], + [ + "add", + 22, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 61, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + ], + "old": [ + [ + "add", + 22, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ] + ], + "section": "restore", + "start": 178, + "stop": 180 + } + ], + "extra": [ + { + "id": "R1", + "new": [ + [ + "add", + 61, + 63, + 1, + 1, + [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + ], + [ + "add", + 22, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 61, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + ], + "old": [ + [ + "add", + 22, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ] + ], + "section": "restore", + "start": 178, + "stop": 180 + } + ] + } +} \ No newline at end of file diff --git a/research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-base.json.gz b/research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-base.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..4f0483657396a7f735873e1b252482c53dfb2eb6 GIT binary patch literal 71434 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 literal 0 HcmV?d00001 diff --git a/research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-extra.json.gz b/research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-extra.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..81f95e21ede115e8bdb6bd522c641b37b740bdf7 GIT binary patch literal 71430 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 literal 0 HcmV?d00001 diff --git a/research/rank7-t740-release/vendor/pr3018/EXCHANGE.json b/research/rank7-t740-release/vendor/pr3018/EXCHANGE.json new file mode 100644 index 0000000000..1260c8d95f --- /dev/null +++ b/research/rank7-t740-release/vendor/pr3018/EXCHANGE.json @@ -0,0 +1,126 @@ +{ + "schema_version": 1, + "source_pr": 2979, + "source_head": "be191346391661f4d35fc0d1508d0a6029572576", + "edits": [ + [0,[0,0,13,0,41,0],[0,0,32,6,95,0]], + [816,[2,0,32,6,95,0],[2,0,32,6,95,9]], + [16336,[40,16,3,4,0,9],[40,16,32,6,94,9]], + [20453,[50,53,26,6,5,0],[50,53,3,4,4,9]], + [20458,[50,58,26,6,4,0],[50,58,3,4,3,9]], + [20469,[50,69,26,6,3,0],[50,69,3,4,2,18]], + [20474,[50,74,26,6,2,0],[50,74,3,4,1,18]], + [26450,[64,338,3,4,4,9],[64,338,3,4,4,13]], + [26452,[64,340,3,4,3,9],[64,340,3,4,3,13]], + [29401,[72,25,28,4,0,0],[72,25,3,4,0,9]], + [30439,[74,247,3,4,4,18],[74,247,3,4,4,22]], + [30447,[74,255,3,4,3,18],[74,255,3,4,3,22]], + [30449,[74,257,3,4,2,18],[74,257,3,4,2,22]], + [30456,[74,264,3,4,1,18],[74,264,3,4,1,22]], + [30457,[74,265,3,4,0,18],[74,265,32,6,93,9]], + [30847,[75,247,40,4,4,18],[75,247,32,6,92,9]], + [31281,[76,273,2,5,31,0],[76,273,3,4,0,16]], + [33559,[82,103,12,1,9,0],[82,103,13,0,41,0]], + [33595,[82,139,12,1,8,0],[82,139,3,4,0,24]], + [33967,[83,103,49,1,9,0],[83,103,13,0,41,8]], + [35384,[86,296,13,0,41,9],[86,296,28,4,0,0]], + [44066,[108,2,5,5,98,0],[108,2,2,5,31,0]], + [49778,[122,2,11,4,7,24],[122,2,49,1,9,0]], + [49915,[122,139,11,4,0,24],[122,139,12,1,9,0]], + [50323,[123,139,48,4,0,24],[123,139,12,1,8,0]], + [52434,[128,210,26,6,5,4],[128,210,26,6,5,0]], + [52435,[128,211,26,6,4,4],[128,211,26,6,4,0]], + [52436,[128,212,26,6,3,4],[128,212,26,6,3,0]], + [52437,[128,213,26,6,2,4],[128,213,26,6,2,0]], + [58754,[144,2,18,1,98,0],[144,2,5,5,98,0]], + [66098,[162,2,28,6,13,0],[162,2,11,4,0,24]], + [66100,[162,4,17,6,88,9],[162,4,11,4,7,24]], + [66506,[163,2,65,6,13,0],[163,2,48,4,0,24]], + [67768,[166,40,28,6,13,8],[166,40,28,6,13,0]], + [68176,[167,40,65,6,13,8],[167,40,65,6,13,0]], + [78338,[192,2,19,6,3,0],[192,2,17,6,88,9]], + [78340,[192,4,19,6,2,0],[192,4,18,1,98,0]], + [84180,[206,132,19,6,3,8],[206,132,19,6,3,0]], + [84182,[206,134,19,6,2,8],[206,134,19,6,2,0]], + [86594,[212,98,19,6,3,17],[212,98,19,6,3,9]], + [86596,[212,100,19,6,2,17],[212,100,19,6,2,9]], + [107848,[264,136,26,6,5,13],[264,136,26,6,5,9]], + [107849,[264,137,26,6,4,13],[264,137,26,6,4,9]], + [107852,[264,140,26,6,3,13],[264,140,26,6,3,9]], + [107853,[264,141,26,6,2,13],[264,141,26,6,2,9]], + [109346,[268,2,36,4,1,6],[268,2,19,6,3,18]], + [109348,[268,4,36,4,0,6],[268,4,19,6,2,18]], + [133061,[326,53,23,13,111,9],[326,53,26,6,5,18]], + [133469,[327,53,60,13,111,9],[327,53,26,6,4,18]], + [134760,[330,120,36,4,1,14],[330,120,36,4,1,6]], + [134761,[330,121,36,4,0,14],[330,121,36,4,0,6]], + [144485,[354,53,19,15,58,0],[354,53,26,6,3,18]], + [144490,[354,58,19,15,57,0],[354,58,26,6,2,18]], + [161079,[394,327,28,6,13,17],[394,327,28,6,13,9]], + [161487,[395,327,65,6,13,17],[395,327,65,6,13,9]], + [161961,[396,393,21,14,39,0],[396,393,28,6,13,15]], + [161962,[396,394,21,14,38,0],[396,394,65,6,13,15]], + [161963,[396,395,21,14,37,0],[396,395,36,4,1,15]], + [161964,[396,396,21,14,36,0],[396,396,36,4,0,15]], + [165872,[406,224,32,6,95,9],[406,224,32,6,95,18]], + [165873,[406,225,32,6,94,9],[406,225,32,6,94,18]], + [165874,[406,226,32,6,93,9],[406,226,32,6,93,18]], + [165875,[406,227,32,6,92,9],[406,227,32,6,92,18]], + [167396,[410,116,21,14,39,8],[410,116,21,14,39,0]], + [167398,[410,118,21,14,38,8],[410,118,21,14,38,0]], + [167399,[410,119,21,14,37,8],[410,119,21,14,37,0]], + [167400,[410,120,21,14,36,8],[410,120,21,14,36,0]], + [172176,[422,0,32,6,95,15],[422,0,23,13,111,9]], + [172177,[422,1,32,6,94,15],[422,1,60,13,111,9]], + [172179,[422,3,32,6,93,15],[422,3,26,13,111,9]], + [172181,[422,5,32,6,92,15],[422,5,63,13,111,9]], + [175513,[430,73,19,15,58,4],[430,73,19,15,58,0]], + [175516,[430,76,19,15,57,4],[430,76,19,15,57,0]], + [189539,[464,227,21,14,39,17],[464,227,21,14,39,9]], + [189540,[464,228,21,14,38,17],[464,228,21,14,38,9]], + [189541,[464,229,21,14,37,17],[464,229,21,14,37,9]], + [189542,[464,230,21,14,36,17],[464,230,21,14,36,9]], + [204318,[500,318,19,15,58,13],[500,318,19,15,58,9]], + [204319,[500,319,19,15,57,13],[500,319,19,15,57,9]], + [218754,[536,66,26,13,111,9],[536,66,26,13,111,18]], + [219162,[537,66,63,13,111,9],[537,66,63,13,111,18]], + [219721,[538,217,19,15,58,22],[538,217,19,15,58,18]], + [219722,[538,218,19,15,57,22],[538,218,19,15,57,18]], + [226106,[554,74,26,13,111,18],[554,74,19,15,58,27]], + [226514,[555,74,63,13,111,18],[555,74,19,15,57,27]], + [229431,[562,135,21,14,39,23],[562,135,21,14,39,15]], + [229432,[562,136,21,14,38,23],[562,136,21,14,38,15]], + [229433,[562,137,21,14,37,23],[562,137,21,14,37,15]], + [229436,[562,140,21,14,36,23],[562,140,21,14,36,15]], + [232084,[568,340,26,13,111,22],[568,340,26,13,111,27]], + [232492,[569,340,63,13,111,22],[569,340,63,13,111,27]], + [233782,[572,406,26,13,111,31],[572,406,21,14,38,24]], + [233783,[572,407,23,13,111,13],[572,407,21,14,39,24]], + [234190,[573,406,63,13,111,31],[573,406,21,14,36,24]], + [234191,[573,407,60,13,111,13],[573,407,21,14,37,24]], + [237796,[582,340,23,13,111,21],[582,340,23,13,111,18]], + [238204,[583,340,60,13,111,21],[583,340,60,13,111,18]], + [240720,[590,0,26,13,111,39],[590,0,26,13,111,36]], + [241128,[591,0,63,13,111,39],[591,0,63,13,111,36]], + [243508,[596,340,23,13,111,30],[596,340,23,13,111,27]], + [243916,[597,340,60,13,111,30],[597,340,60,13,111,27]], + [245140,[600,340,23,13,111,39],[600,340,23,13,111,36]], + [245548,[601,340,60,13,111,39],[601,340,60,13,111,36]] + ], + "routes": [ + [[20453,[3,4,4]],[133061,[26,6,5]]], + [[20458,[3,4,3]],[133469,[26,6,4]]], + [[20469,[3,4,2]],[144485,[26,6,3]],[226106,[19,15,58]]], + [[20474,[3,4,1]],[144490,[26,6,2]],[226514,[19,15,57]]], + [[29401,[3,4,0]],[35384,[28,4,0]]], + [[33559,[13,0,41]],[49915,[12,1,9]],[66098,[11,4,0]],[161961,[28,6,13]],[233783,[21,14,39]]], + [[33595,[3,4,0]],[50323,[12,1,8]],[66506,[48,4,0]],[161962,[65,6,13]],[233782,[21,14,38]]], + [[33967,[13,0,41]],[49778,[49,1,9]],[66100,[11,4,7]],[78338,[17,6,88]],[109346,[19,6,3]],[161963,[36,4,1]],[234191,[21,14,37]]], + [[31281,[3,4,0]],[44066,[2,5,31]],[58754,[5,5,98]],[78340,[18,1,98]],[109348,[19,6,2]],[161964,[36,4,0]],[234190,[21,14,36]]], + [[172176,[23,13,111]],[0,[32,6,95]]], + [[172177,[60,13,111]],[16336,[32,6,94]]], + [[172179,[26,13,111]],[30457,[32,6,93]]], + [[172181,[63,13,111]],[30847,[32,6,92]]] + ], + "changed_pattern_bins": [[23,13,111],[60,13,111],[26,13,111],[63,13,111],[3,4,4],[3,4,3],[3,4,2],[3,4,1],[3,4,0],[40,4,4],[13,0,41]] +} diff --git a/research/rank7-t740-release/vendor/pr3021-FINITE.json b/research/rank7-t740-release/vendor/pr3021-FINITE.json new file mode 100644 index 0000000000..6f73992ff7 --- /dev/null +++ b/research/rank7-t740-release/vendor/pr3021-FINITE.json @@ -0,0 +1,89 @@ +{ + "baseline_root": [ + "2161438716917780535869/1250000000000000000000000", + "17291509735342244286953/10000000000000000000000000" + ], + "calls": 666, + "gain": [ + "2304487940143033/10000000000000000000000000", + "460897588028607/2000000000000000000000000" + ], + "idle": { + "1": 17314, + "3": 4960, + "5": 1722, + "14": 1, + "48": 28190 + }, + "journal_edits": 103, + "live": 66304, + "new_root": [ + "8645756019915092214993/5000000000000000000000000", + "17291512039830184429987/10000000000000000000000000" + ], + "packing_delta": { + "1": 4, + "3": 4, + "5": -6, + "14": 1 + }, + "physical": 66813, + "private_buffers": 91, + "profile": { + "1": 1644352, + "2": 470862, + "3": 159472, + "4": 71928, + "5": 13710, + "8": 5328, + "14": 1, + "48": 28190 + }, + "rank_mass": 4816512, + "replicas": 74, + "retained_checkers": "PR3018 geometry.py and moment.py, authenticated unchanged", + "roles": 271728, + "scope": "Finite allocation and conditional moment; supplier/outer admission not checked.", + "sign_certificate": { + "derivative_upper": "-60509/125000", + "saving_interval": "0 < b <= 1/100" + }, + "source_sha256": { + "research/rank7-joint-endframes/allocation/DISPATCH.json": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c", + "research/rank7-joint-endframes/allocation/FILL.json.gz": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "research/rank7-joint-endframes/allocation/ORDER.json": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1", + "research/rank7-joint-endframes/allocation/PROVIDERS.json": "f2edb7922f3029a5d607437e737775ff3371bca49ebab62e5e2495d16d3bf573", + "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "research/rank7-joint-endframes/data/WORD-base.json.gz": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "research/rank7-joint-endframes/data/WORD-extra.json.gz": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7", + "vendor/pr3015/CLAIM.json": "f9b9fbaaac794c0ce279c238a33a2f34f8c91a34d97ccdeb5ec98b7b8ba56d73", + "vendor/pr3015/CREDITS.md": "bd4b09fcd2861933883cbce6ecf0e30743d5d3b4cb0cc38e258530c370c121b9", + "vendor/pr3015/MANIFEST.json": "5e113822c0c36ee7dd9366578fbaf5daa108b8c51e37f4d10eda25dd6ed52cae", + "vendor/pr3015/NOTICE": "ffcc3de2243815db0e9fb8d820b4ca511fce3c7673c966e14b486f05d30ac11a", + "vendor/pr3015/allocation/PROVIDERS.json": "f52d926752eac5d847092dd58bfb9f3f3c6ac36adf39cd6a3c4d4a3b2d1fce15", + "vendor/pr3015/edits/EDITS.json": "c9c68660d07bfd12ed20fd8cbfe3d36301ceb2d7bb9b4ea11350cc399b19e0b1", + "vendor/pr3015/edits/FINAL-WORD-base.json.gz": "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5", + "vendor/pr3015/edits/FINAL-WORD-extra.json.gz": "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea", + "vendor/pr3015/edits/declared_edits.py": "d3e49b844e9522808a439d505487839addbd957c7d1055bb57fa00e32cbba7b8", + "vendor/pr3015/reproduce.py": "ec9cbbf3d11377804e419745bc43ae5ad35c3b6f5fcde41df5f61f482f36e595", + "vendor/pr3018/EXCHANGE.json": "8a103f643ad12d8074972f41e4359d9487eb8b96fc6849e1a178adb61b36578b", + "vendor/pr3018/README.md": "2d9a53877e1b94dcea81ce8230be57d63507b710463915182dcf593e4a6e1fad", + "vendor/pr3018/RESULT.json": "a9191f711b50476312c222a47f33d7b72a4ac26fdd190ec58b38889986f39b24", + "vendor/pr3018/geometry.py": "4581b2fbfc782437b1d011508e5f1d89482e69e99cbf92536a01f8f802e93ed6", + "vendor/pr3018/moment.py": "339b52eb637add91264347797d4b49cef1a412fd3843bf736cc5bb74c6bdce7c" + }, + "status": "PASS_RESTORE_PACKING_COMPOSITION_FINITE", + "words": { + "base": { + "edit": "R1", + "private_buffers": 91, + "scalar_identity": "exact 3x3 rational" + }, + "extra": { + "edit": "R1", + "private_buffers": 91, + "scalar_identity": "exact 3x3 rational" + } + } +} diff --git a/research/rank7-t740-release/vendor/pr3021/reproduce.py b/research/rank7-t740-release/vendor/pr3021/reproduce.py new file mode 100644 index 0000000000..f8f295f6cf --- /dev/null +++ b/research/rank7-t740-release/vendor/pr3021/reproduce.py @@ -0,0 +1,260 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Compose two exact sources and run PR3015's fresh finite release recipe. + +The source recipes and all their mathematical checks remain unchanged. Only +the complete-admission --fill argument is replaced by the journal-derived fill. +Source credit: Jeremy Kothe, Marius-Paul Dumitrean and the retained lineage. +""" + +import argparse +import gzip +import hashlib +import io +import json +import os +import signal +import subprocess +import sys +import tarfile +import time +from fractions import Fraction +from pathlib import Path, PurePosixPath + +PACKAGE = Path(__file__).resolve().parent +HEAD = "e244296debb45fe6f4da84d29e4d64fbab55fda0" +PREFIX = "research/rank7-joint-endframes-restore-edit" +EXPECTED = {1: 1644352, 2: 470862, 3: 159472, 4: 71928, + 5: 13710, 8: 5328, 14: 1, 48: 28190} +RECIPE_NAMES = ["export-pr2894", "export-pr2833", "fresh-retained-bootstrap", + "four-kernel-stage", "preload-stage", "parent-paired-stage", + "paired-extension-stage", "rank7-overlay-stage", "declared-edit-stage", + "derive-closed-adapters", "fresh-current-native", "complete-admission"] +DEPENDENCY_MANIFESTS = { + "pr2908": "9dba3fe371602ec023a54e26c0fd66f69eb7a74be86aab89923529083c14b36f", + "pr2917": "55c46ddf2e3edc87dfe1ba3320947466d36980d457eb37f6cd6fba341dae0192", + "pr2942": "23bd270f440c4c7ad0d106990ae391e1af799a61ef3601d00e27f1824ae8ba69", + "pr2957": "9cd226a2bf7391e7fbf4a23741bb1934afafbd596aef06f2999a935cd6e44e28", + "pr2966": "9e410c244efb370e20a5f9dc366550e11bcb14ebcecf8f2cb850512e82573914", + "pr2969": "797c55c560dec5b5a657296f49d918fc5db708b7bed3eba046b3358b1666e55b", +} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def digest(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == ".gz" else raw) + + +def save(path, value): + path.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n") + + +def authenticate_tree(directory): + manifest = read(directory / "MANIFEST.json") + paths = list(directory.rglob("*")) + need(len(paths) <= 10000 and len(manifest) <= 5000, "source tree bound") + need(not any(p.is_symlink() for p in paths), "regular source tree") + actual = {p.relative_to(directory).as_posix(): digest(p) for p in paths + if p.is_file() and p != directory / "MANIFEST.json"} + need(actual == manifest, "complete source inventory: " + str(directory)) + + +def export(repo, out): + """Export only bounded regular files, then authenticate the whole package.""" + raw = subprocess.run( + ["git", "-C", str(repo), "archive", HEAD, PREFIX], + check=True, capture_output=True, timeout=60, + ).stdout + need(len(raw) < 10_000_000, "bounded source archive") + out.mkdir() + with tarfile.open(fileobj=io.BytesIO(raw)) as archive: + members = archive.getmembers() + need(len(members) <= 256, "source file bound") + for member in members: + name = PurePosixPath(member.name) + need(not name.is_absolute() and ".." not in name.parts, "archive path") + need(member.isfile() or member.isdir(), "regular source entries") + if member.isdir(): + continue + need(name.is_relative_to(PurePosixPath(PREFIX)), "source prefix") + target = out / name.relative_to(PurePosixPath(PREFIX)) + target.parent.mkdir(parents=True, exist_ok=True) + stream = archive.extractfile(member) + need(stream is not None, "source file stream") + with stream: + target.write_bytes(stream.read()) + manifest = out / "MANIFEST.json" + need(digest(manifest) == digest(PACKAGE / "vendor/pr3015/MANIFEST.json"), + "exact PR3015 source manifest") + authenticate_tree(out) + + +def fill_from_journal(source, target): + fill = read(source / "allocation/FILL.json.gz") + need(digest(source / "allocation/FILL.json.gz") == read(source / "CLAIM.json")["fill_sha256"], + "PR3015 literal baseline fill") + journal = read(PACKAGE / "vendor/pr3018/EXCHANGE.json") + need(len(journal["edits"]) == 103, "exact 103-row journal") + rows, seen = list(fill["rows"]), set() + for index, old, new in journal["edits"]: + need(type(index) is int and 0 <= index < len(rows), "journal index") + need(index not in seen and rows[index] == old, "unique literal preimage") + need(len(new) == 6 and old[:2] == new[:2], "same call and helper") + seen.add(index) + rows[index] = new + candidate = {**fill, "rows": rows} + raw = (json.dumps(candidate, sort_keys=True, separators=(",", ":")) + "\n").encode() + target.write_bytes(gzip.compress(raw, compresslevel=1, mtime=0)) + return digest(target) + + +def run_stage(name, command, work, env, stages, timeout): + log = work / (name + ".log") + started = time.monotonic() + with log.open("w") as stream: + process = subprocess.Popen( + list(map(str, command)), cwd=work, env=env, stdin=subprocess.DEVNULL, + stdout=stream, stderr=subprocess.STDOUT, start_new_session=True, + ) + try: + code = process.wait(timeout=timeout) + finally: + try: + os.killpg(process.pid, signal.SIGTERM) + except ProcessLookupError: + pass + try: + process.wait(timeout=5) + except subprocess.TimeoutExpired: + os.killpg(process.pid, signal.SIGKILL) + process.wait(timeout=5) + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + stages.append(dict(stage=name, exit_code=code, + seconds=time.monotonic() - started, log_sha256=digest(log))) + save(work / "STAGES.json", stages) + need(code == 0, "failed " + name + "; see " + str(log)) + print("PASS", name, flush=True) + + +def execute(repo, work, dry_run): + need(not work.exists(), "refusing an existing replay workspace") + need(not work.is_relative_to(PACKAGE), "replay outside published package") + need(sys.flags.optimize == 0, "inherited source requires enabled assertions") + need(os.name == "posix", "full replay process-group cleanup requires POSIX") + for entry in read(PACKAGE / "VENDOR.json"): + need(digest(PACKAGE / entry["path"]) == entry["sha256"], "frozen vendor input") + work.mkdir(parents=True) + source, run = work / "pr3015", work / "run" + export(repo, source) + fill_path = work / "COMPOSED-FILL.json.gz" + fill_hash = fill_from_journal(source, fill_path) + env = dict(os.environ, PYTHONDONTWRITEBYTECODE="1", + PYTHONPYCACHEPREFIX=str(work / "bytecode"), + OPENBLAS_NUM_THREADS="1", OMP_NUM_THREADS="1", PYTHONINTMAXSTRDIGITS="0") + for key in ("PYTHONPATH", "PYTHONOPTIMIZE", "WITNESS_SPEC", "WITNESS_RECORD", "WITNESS_DISCOVER"): + env.pop(key, None) + py = [sys.executable, "-B"] + stages = [] + run_stage("source-preflight", py + [source / "reproduce.py", "--repo", repo, + "--work", run, "--jobs", "1", "--dry-run"], work, env, stages, 120) + recipe = read(run / "PREFLIGHT.json")["commands"] + need([name for name, _ in recipe] == RECIPE_NAMES, "complete source recipe") + changes = [] + for name, command in recipe: + if name == "complete-admission": + position = command.index("--fill") + 1 + need(command[position] == str(source / "allocation/FILL.json.gz"), "source fill preimage") + changes.append(dict(stage=name, argument="--fill", old=command[position], new=str(fill_path))) + command[position] = str(fill_path) + need(len(changes) == 1, "exactly one recipe argument changes") + save(work / "RECIPE.json", dict(commands=recipe, changes=changes, fill_sha256=fill_hash)) + if dry_run: + return {"status": "PREFLIGHT_ONLY_NOT_A_RELEASE", "fill_sha256": fill_hash} + for name, command in recipe: + run_stage(name, command, work, env, stages, 1800) + return check_release(work, source, fill_hash, stages) + + +def check_release(work, source, fill_hash, stages): + candidate = work / "run/candidate" + need(digest(work / "COMPOSED-FILL.json.gz") == fill_hash, "unchanged admitted fill bytes") + admission = read(candidate / "RESULT.json") + release = read(candidate / "release/RELEASE-RECEIPT.json") + need(admission["status"] == "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", "complete admission") + need(release["status"] == "PASS_RELEASE", "outer release") + need(admission["fill_sha256"] == fill_hash, "new literal fill admission binding") + need({int(k): v for k, v in admission["profile"].items()} == EXPECTED, + "exact complete composed profile") + need(admission["source_manifest_sha256"] == read(source / "CLAIM.json")["source_manifest_sha256"], + "unchanged PR3015 edited source") + need(Fraction(admission["kappa"]) == Fraction(release["kappa_decimal"]), "same released endpoint") + need(Fraction(admission["kappa"]) > Fraction(read(source / "CLAIM.json")["kappa"]), + "strict improvement over PR3015") + need(admission["release_receipt_sha256"] == digest(candidate / "release/RELEASE-RECEIPT.json"), + "admission authenticates release") + need(admission["package_manifest_sha256"] == release["manifest_sha256"], "same admitted package") + check_source_chain(work, source, admission, stages) + return dict(status="PASS_RESTORE_PACKING_COMPLETE_RELEASE", kappa=admission["kappa"], + comparison_kappa=read(source / "CLAIM.json")["kappa"], + gain=str(Fraction(admission["kappa"]) - Fraction(read(source / "CLAIM.json")["kappa"])), + fill_sha256=fill_hash, fresh_retained_bootstrap=True, + fill_payload_sha256=hashlib.sha256((json.dumps( + read(work / "COMPOSED-FILL.json.gz"), sort_keys=True, + separators=(",", ":")) + "\n").encode()).hexdigest(), + admission_result_sha256=digest(candidate / "RESULT.json"), + release_receipt_sha256=digest(candidate / "release/RELEASE-RECEIPT.json"), + stages=stages, scope="Conditional finite release; inherited theorem hypotheses remain.") + + +def check_source_chain(work, source, admission, stages): + run = work / "run" + need([s["stage"] for s in stages] == ["source-preflight", *RECIPE_NAMES], "all fresh stages") + need(all(s["exit_code"] == 0 for s in stages), "successful source stages") + edited = run / "source-edits" + need(digest(edited / "MANIFEST.json") == admission["source_manifest_sha256"], "actual edited source") + authenticate_tree(edited) + native_path = run / "native/NATIVE-RECEIPT.json" + native = read(native_path) + need(digest(native_path) == admission["native_receipt_sha256"], "fresh native binding") + need(native["manifest_sha256"] == admission["source_manifest_sha256"], "native source") + need(native["fresh_current_provider_count"] == 2, "two fresh current providers") + need(native["status"] == "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE", + "complete native receipt") + for tag in ("base", "extra"): + actual = edited / ("new/borrow/words/BORROW-WORD-43" + tag + ".json.gz") + expected = source / ("edits/FINAL-WORD-" + tag + ".json.gz") + need(read(actual) == read(expected), "exact edited provider word") + need(native["providers"][tag]["word_sha256"] == digest(actual), "native provider word") + need(digest(source / "MANIFEST.json") == digest(PACKAGE / "vendor/pr3015/MANIFEST.json"), + "unchanged pinned PR3015 manifest") + authenticate_tree(source) + for name, expected in DEPENDENCY_MANIFESTS.items(): + need(digest(run / name / "MANIFEST.json") == expected, "pinned predecessor " + name) + authenticate_tree(run / name) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--repo", type=Path, required=True) + parser.add_argument("--work", type=Path, required=True) + parser.add_argument("--dry-run", action="store_true") + args = parser.parse_args() + result = execute(args.repo.resolve(), args.work.resolve(), args.dry_run) + save(args.work / "RESULT.json", result) + print(result["status"], result.get("kappa", ""), flush=True) + + +if __name__ == "__main__": + main() diff --git a/research/rank7-t740-release/vendor/pr3021/verify.py b/research/rank7-t740-release/vendor/pr3021/verify.py new file mode 100644 index 0000000000..84902a90d2 --- /dev/null +++ b/research/rank7-t740-release/vendor/pr3021/verify.py @@ -0,0 +1,267 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Bounded composition checks; retains PR3018 geometry and interval checkers. + +This is a finite allocation and moment receipt, not supplier/outer admission. +Managed Python storage is bounded by 666 calls, 271728 roles, 103 journal edits, +and two pinned words with fewer than 20000 gates each. +""" + +import argparse +import copy +import gzip +import hashlib +import importlib.util +import json +import sys +from collections import Counter +from fractions import Fraction +from pathlib import Path + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +MAIN = ROOT / "research/rank7-joint-endframes" +EXPECTED = {1: 1644352, 2: 470862, 3: 159472, 4: 71928, + 5: 13710, 8: 5328, 14: 1, 48: 28190} +DELTA = {1: 4, 3: 4, 5: -6, 14: 1} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def read(path): + path = Path(path) + data = path.read_bytes() + need(len(data) <= 20_000_000, "compressed input limit") + if path.suffix == ".gz": + data = gzip.decompress(data) + need(len(data) <= 40_000_000, "decoded input limit") + return json.loads(data) + + +def authenticate(root=ROOT, package=PACKAGE): + """Authenticate live inputs and all vendor bytes before retained imports. + + Historical provenance rows belong to the registered package runner's check. + """ + pins = [(root, row) for row in read(package / "SOURCES.json")["files"] + if row.get("usage") == "input"] + pins += [(package, row) for row in read(package / "VENDOR.json")] + need(1 <= len(pins) <= 100, "source pin count") + result = {} + for base, row in pins: + relative = Path(row["path"]) + need(not relative.is_absolute() and ".." not in relative.parts, "source path") + actual = hashlib.sha256((base / relative).read_bytes()).hexdigest() + need(actual == row["sha256"], "source drift: " + str(relative)) + result[str(relative)] = actual + return result + + +def retained_checkers(): + authenticate() + modules = [] + for name in ("geometry", "moment"): + path = PACKAGE / "vendor/pr3018" / (name + ".py") + spec = importlib.util.spec_from_file_location("composition_" + name, path) + need(spec is not None and spec.loader is not None, "checker import") + module = importlib.util.module_from_spec(spec) + previous = sys.dont_write_bytecode + try: + sys.dont_write_bytecode = True + spec.loader.exec_module(module) + finally: + sys.dont_write_bytecode = previous + modules.append(module) + return tuple(modules) + + +def apply_exchange(fill, journal): + need(type(fill) is dict and type(fill.get("rows")) is list, "fill shape") + need(len(fill["rows"]) == 271728, "complete role count") + edits = journal.get("edits") + need(type(edits) is list and len(edits) == 103, "103 journal edits") + result, seen = copy.deepcopy(fill), set() + for edit in edits: + need(type(edit) is list and len(edit) == 3, "journal edit shape") + index, old, new = edit + need(type(index) is int and 0 <= index < 271728, "journal index") + need(index not in seen, "duplicate journal edit") + need(type(old) is list and type(new) is list, "journal row shape") + need(len(old) == len(new) == 6, "journal row shape") + need(all(type(x) is int for x in old + new), "integer journal row") + need(fill["rows"][index] == old, "journal preimage") + need(old[:2] == new[:2] and old != new, "journal helper identity") + result["rows"][index] = new.copy() + seen.add(index) + need(sum(a != b for a, b in zip(fill["rows"], result["rows"], strict=True)) == 103, + "literal changed row count") + return result + + +def composed_fill(): + authenticate() + return apply_exchange(read(MAIN / "allocation/FILL.json.gz"), + read(PACKAGE / "vendor/pr3018/EXCHANGE.json")) + + +def scalar_action(gates): + """Exact three-register linear action, ignoring frame annotations only.""" + registers = {22: 0, 61: 1, 63: 2} + matrix = [[Fraction(i == j) for j in range(3)] for i in range(3)] + need(type(gates) is list and 1 <= len(gates) <= 3, "R1 gate count") + for gate in gates: + need(type(gate) is list and len(gate) == 6 and gate[0] == "add", "R1 add") + _, target, source, numerator, denominator, _ = gate + need(target in registers and source in registers, "R1 register") + need(type(numerator) is int and type(denominator) is int and denominator != 0, + "R1 rational scalar") + target, source = registers[target], registers[source] + scale = Fraction(numerator, denominator) + matrix[target] = [a + scale * b for a, b in zip(matrix[target], matrix[source], strict=True)] + return matrix + + +def cleanup(word): + """Derive inverse-reverse cleanup, with one private slot per restored helper.""" + need(len(word["A"]) + len(word["B"]) + len(word["restore"]) < 20000, + "word gate limit") + restored = set(map(int, word["helper_final"])) + need(len(restored) == 91, "91 private buffers") + offset = 2 * word["report"]["v"] + word["report"]["R"] + full = [1 << i for i in range(word["report"]["h"] - 1, -1, -1)] + warps = {} + for number, record in enumerate(word["warps"], 1): + warps.setdefault(record[0], []).append(["warp", record[1], number]) + forward = word["A"][word["prelude_events"]:].copy() + for position in range(len(word["B"]) + 1): + forward.extend(warps.get(position, [])) + if position < len(word["B"]): + forward.append(word["B"][position]) + forward.extend(word["restore"]) + result = [] + for gate in reversed(forward): + if gate[0] != "warp" and 112 <= gate[1] < 224: + continue + target = gate[1] + offset if gate[1] in restored else gate[1] + if gate[0] == "warp": + result.append(["warp", target, -gate[2], full]) + elif gate[0] == "add": + source = gate[2] + offset if gate[2] in restored else gate[2] + result.append(["add", target, source, -gate[3], gate[4], full]) + else: + need(gate[0] == "scale", "cleanup gate kind") + result.append(["scale", target, gate[3], gate[2], full]) + return result + + +def check_word(old, new, edits): + need(set(old) == set(new), "word keys") + need(type(edits) is list and len(edits) == 1, "one R1 edit") + edit = edits[0] + need((edit["id"], edit["section"], edit["start"], edit["stop"]) == + ("R1", "restore", 178, 180), "R1 address") + need(old["restore"][178:180] == edit["old"], "R1 preimage") + need(scalar_action(edit["old"]) == scalar_action(edit["new"]), "R1 scalar identity") + need(new["restore"] == old["restore"][:178] + edit["new"] + old["restore"][180:], + "literal R1 restore sequence") + need({key for key in old if old[key] != new[key]} == {"restore", "report", "cleanup"}, + "only declared word fields change") + before, after = old["report"], new["report"] + need(before["width_inventory"] == after["width_inventory"], "width inventory") + need(before.keys() == after.keys(), "report fields") + need(all(before[k] == after[k] for k in before if k != "local_profile"), + "report invariant") + delta = Counter({int(k): v for k, v in after["local_profile"].items()}) + delta.subtract({int(k): v for k, v in before["local_profile"].items()}) + need({k: v for k, v in delta.items() if v} == {1: -2, 2: 1}, "R1 profile delta") + need(cleanup(old) == old["cleanup"] and cleanup(new) == new["cleanup"], + "literal inverse cleanup with all private buffers") + return {"edit": "R1", "private_buffers": 91, "scalar_identity": "exact 3x3 rational"} + + +def inputs(): + dispatch_rows = read(MAIN / "allocation/DISPATCH.json") + need(type(dispatch_rows) is list and len(dispatch_rows) == 666, "dispatch rows") + dispatch = {(s, o): p for s, o, p in dispatch_rows} + need(len(dispatch) == 666, "duplicate dispatch") + return (read(MAIN / "allocation/ORDER.json"), dispatch, + read(MAIN / "allocation/vendor/PLAN.json.gz"), + read(MAIN / "allocation/vendor/TEMPLATE.json.gz"), + read(PACKAGE / "vendor/pr3015/allocation/PROVIDERS.json")) + + +def check_allocation(geometry, fill, data, buffers=91, claimed=EXPECTED): + need(type(buffers) is int and buffers == 91, "91 private buffers") + order, dispatch, plan, template, providers = data + result = geometry.check(order, fill, dispatch, plan, template, providers, buffers) + need(result["profile"] == claimed, "literal complete profile") + need(result["physical"] == 66813 and result["rank_mass"] == 4816512, + "complete physical and rank accounting") + return result + + +def check_providers(providers): + before = read(MAIN / "allocation/PROVIDERS.json") + need(set(before) == set(providers) == {"extra", "gauge44"}, "provider identities") + declared = read(PACKAGE / "vendor/pr3015/edits/EDITS.json")["declared"] + for name in providers: + need(providers[name]["widths"] == before[name]["widths"], "ordered helper widths") + need(Counter(map(str, providers[name]["widths"])) == + Counter(declared["width_inventory"]), "literal width inventory") + need(providers[name]["actual_paid_profile"] == declared["local_profile"], + "provider profile agrees with word") + + +def moment_receipt(moment, baseline, profile): + old_interval, new_interval = moment.root(baseline), moment.root(profile) + gain = new_interval[0] - old_interval[1], new_interval[1] - old_interval[0] + need(gain[0] > 0, "strict complete moment improvement") + return {"baseline_root": list(map(str, old_interval)), + "new_root": list(map(str, new_interval)), "gain": list(map(str, gain)), + "sign_certificate": moment.sign_certificate()} + + +def run(): + pins = authenticate() + geometry, moment = retained_checkers() + data = inputs() + check_providers(data[-1]) + edits = read(PACKAGE / "vendor/pr3015/edits/EDITS.json")["edits"] + words = {} + for variant in ("base", "extra"): + words[variant] = check_word(read(MAIN / ("data/WORD-" + variant + ".json.gz")), + read(PACKAGE / ("vendor/pr3015/edits/FINAL-WORD-" + variant + ".json.gz")), + edits[variant]) + baseline = read(PACKAGE / "vendor/pr3015/CLAIM.json") + baseline = {int(k): v for k, v in baseline["profile"].items()} + original = read(MAIN / "allocation/FILL.json.gz") + check_allocation(geometry, original, data, claimed=baseline) + result = check_allocation(geometry, composed_fill(), data) + delta = {rank: EXPECTED.get(rank, 0) - baseline.get(rank, 0) + for rank in EXPECTED.keys() | baseline.keys()} + need({k: v for k, v in delta.items() if v} == DELTA, "packing profile delta") + result.pop("bin_pattern_histogram") + result.update(moment_receipt(moment, baseline, EXPECTED)) + result.update({"status": "PASS_RESTORE_PACKING_COMPOSITION_FINITE", + "journal_edits": 103, "packing_delta": DELTA, "words": words, + "source_sha256": pins, + "retained_checkers": "PR3018 geometry.py and moment.py, authenticated unchanged", + "scope": "Finite allocation and conditional moment; supplier/outer admission not checked."}) + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path) + args = parser.parse_args() + payload = json.dumps(run(), sort_keys=True, indent=2) + "\n" + if args.output: + args.output.write_text(payload, encoding="utf-8") + print(payload, end="") + + +if __name__ == "__main__": + main() diff --git a/research/rank7-t740-release/vendor/pr3024/EXCHANGE.json b/research/rank7-t740-release/vendor/pr3024/EXCHANGE.json new file mode 100644 index 0000000000..1b1a904ff0 --- /dev/null +++ b/research/rank7-t740-release/vendor/pr3024/EXCHANGE.json @@ -0,0 +1,559 @@ +{ + "schema_version": 1, + "source_pr": 3018, + "source_head": "ca7113157d7c959fdfa9d7cd17ef92d3877070d0", + "copies": 10, + "indexing": "copy * 271728 + base_index; lifted time = 10 * base_time + copy; owner = base_owner + 74 * copy", + "edits": [ + [447,[10,39,40,4,4,0],[10,39,410,4,4,0]], + [26858,[650,338,40,4,4,9],[650,338,410,4,4,18]], + [34068,[830,204,49,1,3,0],[830,204,262,4,4,0]], + [34097,[830,233,49,1,2,0],[830,233,188,4,4,8]], + [34098,[830,234,49,1,1,0],[830,234,114,4,4,16]], + [34100,[830,236,49,1,0,0],[830,236,40,4,4,24]], + [109754,[2690,2,73,4,1,6],[2690,2,654,1,3,0]], + [109756,[2690,4,73,4,0,6],[2690,4,654,1,2,0]], + [199512,[4890,0,72,13,111,0],[4890,0,35,13,111,9]], + [201552,[4940,0,35,13,111,9],[4940,0,35,13,111,18]], + [201960,[4950,0,72,13,111,9],[4950,0,72,13,111,18]], + [208286,[5100,206,26,14,0,0],[5100,206,627,13,111,0]], + [208694,[5110,206,63,14,0,0],[5110,206,627,13,111,9]], + [210540,[5160,12,26,14,0,9],[5160,12,627,13,111,18]], + [210948,[5170,12,63,14,0,9],[5170,12,627,13,111,27]], + [211362,[5180,18,31,14,0,0],[5180,18,31,14,0,14]], + [211770,[5190,18,68,14,0,0],[5190,18,68,14,0,14]], + [216240,[5300,0,26,14,0,18],[5300,0,627,13,111,36]], + [216648,[5310,0,63,14,0,18],[5310,0,26,14,0,22]], + [219504,[5380,0,35,13,111,18],[5380,0,35,13,111,27]], + [219912,[5390,0,72,13,111,18],[5390,0,72,13,111,27]], + [227666,[5580,2,31,14,0,9],[5580,2,650,14,35,6]], + [228074,[5590,2,68,14,0,9],[5590,2,650,14,34,6]], + [244322,[5980,338,31,14,0,17],[5980,338,31,14,0,23]], + [244730,[5990,338,68,14,0,17],[5990,338,68,14,0,23]], + [244965,[6000,165,35,13,111,27],[6000,165,26,14,0,0]], + [245373,[6010,165,72,13,111,27],[6010,165,63,14,0,0]], + [254593,[6240,1,35,13,111,31],[6240,1,35,13,111,36]], + [255001,[6250,1,72,13,111,31],[6250,1,72,13,111,36]], + [263953,[6460,385,35,13,111,40],[6460,385,734,14,0,6]], + [264361,[6470,385,72,13,111,40],[6470,385,697,14,0,6]], + [265527,[6500,327,31,14,0,26],[6500,327,31,14,0,0]], + [265935,[6510,327,68,14,0,26],[6510,327,68,14,0,0]], + [272175,[11,39,114,4,4,0],[11,39,410,4,4,9]], + [298586,[651,338,114,4,4,9],[651,338,484,4,4,9]], + [305796,[831,204,123,1,3,0],[831,204,336,4,4,0]], + [305825,[831,233,123,1,2,0],[831,233,262,4,4,8]], + [305826,[831,234,123,1,1,0],[831,234,188,4,4,16]], + [305828,[831,236,123,1,0,0],[831,236,114,4,4,24]], + [381482,[2691,2,147,4,1,6],[2691,2,654,1,1,0]], + [381484,[2691,4,147,4,0,6],[2691,4,654,1,0,0]], + [470832,[4881,0,109,13,111,0],[4881,0,72,13,111,0]], + [471240,[4891,0,146,13,111,0],[4891,0,109,13,111,0]], + [473280,[4941,0,109,13,111,9],[4941,0,72,13,111,9]], + [473688,[4951,0,146,13,111,9],[4951,0,109,13,111,9]], + [480014,[5101,206,100,14,0,0],[5101,206,26,14,0,4]], + [480422,[5111,206,137,14,0,0],[5111,206,63,14,0,4]], + [482268,[5161,12,100,14,0,9],[5161,12,26,14,0,13]], + [482676,[5171,12,137,14,0,9],[5171,12,63,14,0,13]], + [483090,[5181,18,105,14,0,0],[5181,18,105,14,0,14]], + [483498,[5191,18,142,14,0,0],[5191,18,142,14,0,14]], + [487968,[5301,0,100,14,0,18],[5301,0,63,14,0,22]], + [488376,[5311,0,137,14,0,18],[5311,0,100,14,0,22]], + [491640,[5391,0,146,13,111,18],[5391,0,109,13,111,27]], + [499394,[5581,2,105,14,0,9],[5581,2,650,14,33,6]], + [499802,[5591,2,142,14,0,9],[5591,2,650,14,32,6]], + [516050,[5981,338,105,14,0,17],[5981,338,105,14,0,23]], + [516458,[5991,338,142,14,0,17],[5991,338,142,14,0,23]], + [516693,[6001,165,109,13,111,27],[6001,165,100,14,0,0]], + [517101,[6011,165,146,13,111,27],[6011,165,137,14,0,0]], + [526321,[6241,1,109,13,111,31],[6241,1,109,13,111,36]], + [526729,[6251,1,146,13,111,31],[6251,1,146,13,111,36]], + [535681,[6461,385,109,13,111,40],[6461,385,660,14,0,6]], + [536089,[6471,385,146,13,111,40],[6471,385,623,14,0,6]], + [537255,[6501,327,105,14,0,26],[6501,327,105,14,0,0]], + [537663,[6511,327,142,14,0,26],[6511,327,142,14,0,0]], + [543903,[12,39,188,4,4,0],[12,39,484,4,4,0]], + [570314,[652,338,188,4,4,9],[652,338,484,4,4,18]], + [577553,[832,233,197,1,2,0],[832,233,336,4,4,8]], + [577554,[832,234,197,1,1,0],[832,234,262,4,4,16]], + [577556,[832,236,197,1,0,0],[832,236,188,4,4,24]], + [653210,[2692,2,221,4,1,6],[2692,2,728,1,15,0]], + [653212,[2692,4,221,4,0,6],[2692,4,728,1,14,0]], + [742560,[4882,0,183,13,111,0],[4882,0,146,13,111,0]], + [742968,[4892,0,220,13,111,0],[4892,0,183,13,111,9]], + [745008,[4942,0,183,13,111,9],[4942,0,146,13,111,9]], + [745416,[4952,0,220,13,111,9],[4952,0,183,13,111,18]], + [751742,[5102,206,174,14,0,0],[5102,206,100,14,0,4]], + [752150,[5112,206,211,14,0,0],[5112,206,137,14,0,4]], + [753996,[5162,12,174,14,0,9],[5162,12,100,14,0,13]], + [754404,[5172,12,211,14,0,9],[5172,12,137,14,0,13]], + [754818,[5182,18,179,14,0,0],[5182,18,179,14,0,14]], + [755226,[5192,18,216,14,0,0],[5192,18,216,14,0,14]], + [759696,[5302,0,174,14,0,18],[5302,0,137,14,0,22]], + [760104,[5312,0,211,14,0,18],[5312,0,174,14,0,22]], + [762960,[5382,0,183,13,111,18],[5382,0,146,13,111,18]], + [763368,[5392,0,220,13,111,18],[5392,0,183,13,111,27]], + [771122,[5582,2,179,14,0,9],[5582,2,650,14,19,6]], + [771530,[5592,2,216,14,0,9],[5592,2,650,14,18,6]], + [787778,[5982,338,179,14,0,17],[5982,338,179,14,0,23]], + [788186,[5992,338,216,14,0,17],[5992,338,216,14,0,23]], + [788421,[6002,165,183,13,111,27],[6002,165,174,14,0,0]], + [788829,[6012,165,220,13,111,27],[6012,165,211,14,0,0]], + [798049,[6242,1,183,13,111,31],[6242,1,146,13,111,27]], + [798457,[6252,1,220,13,111,31],[6252,1,183,13,111,36]], + [807409,[6462,385,183,13,111,40],[6462,385,586,14,0,6]], + [807817,[6472,385,220,13,111,40],[6472,385,549,14,0,6]], + [808983,[6502,327,179,14,0,26],[6502,327,179,14,0,0]], + [809391,[6512,327,216,14,0,26],[6512,327,216,14,0,0]], + [815631,[13,39,262,4,4,0],[13,39,558,4,4,0]], + [842042,[653,338,262,4,4,9],[653,338,558,4,4,18]], + [849282,[833,234,271,1,1,0],[833,234,336,4,4,16]], + [849284,[833,236,271,1,0,0],[833,236,262,4,4,24]], + [924938,[2693,2,295,4,1,6],[2693,2,728,1,13,0]], + [924940,[2693,4,295,4,0,6],[2693,4,728,1,12,0]], + [1014288,[4883,0,257,13,111,0],[4883,0,183,13,111,0]], + [1014696,[4893,0,294,13,111,0],[4893,0,220,13,111,0]], + [1016736,[4943,0,257,13,111,9],[4943,0,220,13,111,9]], + [1017144,[4953,0,294,13,111,9],[4953,0,220,13,111,18]], + [1023470,[5103,206,248,14,0,0],[5103,206,174,14,0,4]], + [1023878,[5113,206,285,14,0,0],[5113,206,211,14,0,4]], + [1025724,[5163,12,248,14,0,9],[5163,12,174,14,0,13]], + [1026132,[5173,12,285,14,0,9],[5173,12,211,14,0,13]], + [1026546,[5183,18,253,14,0,0],[5183,18,253,14,0,14]], + [1026954,[5193,18,290,14,0,0],[5193,18,290,14,0,14]], + [1031424,[5303,0,248,14,0,18],[5303,0,211,14,0,22]], + [1031832,[5313,0,285,14,0,18],[5313,0,248,14,0,22]], + [1034688,[5383,0,257,13,111,18],[5383,0,220,13,111,27]], + [1035096,[5393,0,294,13,111,18],[5393,0,257,13,111,27]], + [1042850,[5583,2,253,14,0,9],[5583,2,650,14,17,6]], + [1043258,[5593,2,290,14,0,9],[5593,2,650,14,16,6]], + [1059506,[5983,338,253,14,0,17],[5983,338,253,14,0,23]], + [1059914,[5993,338,290,14,0,17],[5993,338,290,14,0,23]], + [1060149,[6003,165,257,13,111,27],[6003,165,248,14,0,0]], + [1060557,[6013,165,294,13,111,27],[6013,165,285,14,0,0]], + [1069777,[6243,1,257,13,111,31],[6243,1,220,13,111,36]], + [1070185,[6253,1,294,13,111,31],[6253,1,257,13,111,36]], + [1079137,[6463,385,257,13,111,40],[6463,385,512,14,0,6]], + [1079545,[6473,385,294,13,111,40],[6473,385,475,14,0,6]], + [1080711,[6503,327,253,14,0,26],[6503,327,253,14,0,0]], + [1081119,[6513,327,290,14,0,26],[6513,327,290,14,0,0]], + [1087359,[14,39,336,4,4,0],[14,39,558,4,4,9]], + [1113770,[654,338,336,4,4,9],[654,338,632,4,4,9]], + [1121012,[834,236,345,1,0,0],[834,236,336,4,4,24]], + [1196666,[2694,2,369,4,1,6],[2694,2,728,1,11,0]], + [1196668,[2694,4,369,4,0,6],[2694,4,728,1,10,0]], + [1286016,[4884,0,331,13,111,0],[4884,0,257,13,111,0]], + [1286424,[4894,0,368,13,111,0],[4894,0,294,13,111,0]], + [1288464,[4944,0,331,13,111,9],[4944,0,257,13,111,9]], + [1288872,[4954,0,368,13,111,9],[4954,0,294,13,111,9]], + [1295198,[5104,206,322,14,0,0],[5104,206,248,14,0,4]], + [1295606,[5114,206,359,14,0,0],[5114,206,285,14,0,4]], + [1297452,[5164,12,322,14,0,9],[5164,12,248,14,0,13]], + [1297860,[5174,12,359,14,0,9],[5174,12,285,14,0,13]], + [1298274,[5184,18,327,14,0,0],[5184,18,327,14,0,14]], + [1298682,[5194,18,364,14,0,0],[5194,18,364,14,0,14]], + [1303152,[5304,0,322,14,0,18],[5304,0,285,14,0,22]], + [1303560,[5314,0,359,14,0,18],[5314,0,322,14,0,22]], + [1306416,[5384,0,331,13,111,18],[5384,0,257,13,111,18]], + [1306824,[5394,0,368,13,111,18],[5394,0,294,13,111,18]], + [1314578,[5584,2,327,14,0,9],[5584,2,724,14,39,6]], + [1314986,[5594,2,364,14,0,9],[5594,2,724,14,38,6]], + [1331234,[5984,338,327,14,0,17],[5984,338,327,14,0,23]], + [1331642,[5994,338,364,14,0,17],[5994,338,364,14,0,23]], + [1331877,[6004,165,331,13,111,27],[6004,165,322,14,0,0]], + [1332285,[6014,165,368,13,111,27],[6014,165,359,14,0,0]], + [1341505,[6244,1,331,13,111,31],[6244,1,294,13,111,27]], + [1341913,[6254,1,368,13,111,31],[6254,1,294,13,111,36]], + [1350865,[6464,385,331,13,111,40],[6464,385,438,14,0,6]], + [1351273,[6474,385,368,13,111,40],[6474,385,401,14,0,6]], + [1352439,[6504,327,327,14,0,26],[6504,327,327,14,0,0]], + [1352847,[6514,327,364,14,0,26],[6514,327,364,14,0,0]], + [1359087,[15,39,410,4,4,0],[15,39,632,4,4,0]], + [1385498,[655,338,410,4,4,9],[655,338,632,4,4,18]], + [1468394,[2695,2,443,4,1,6],[2695,2,728,1,9,0]], + [1468396,[2695,4,443,4,0,6],[2695,4,728,1,8,0]], + [1557744,[4885,0,405,13,111,0],[4885,0,331,13,111,0]], + [1558152,[4895,0,442,13,111,0],[4895,0,331,13,111,9]], + [1560192,[4945,0,405,13,111,9],[4945,0,331,13,111,18]], + [1560600,[4955,0,442,13,111,9],[4955,0,368,13,111,18]], + [1566926,[5105,206,396,14,0,0],[5105,206,322,14,0,4]], + [1567334,[5115,206,433,14,0,0],[5115,206,359,14,0,4]], + [1569180,[5165,12,396,14,0,9],[5165,12,322,14,0,13]], + [1569588,[5175,12,433,14,0,9],[5175,12,359,14,0,13]], + [1570002,[5185,18,401,14,0,0],[5185,18,401,14,0,14]], + [1570410,[5195,18,438,14,0,0],[5195,18,438,14,0,14]], + [1574880,[5305,0,396,14,0,18],[5305,0,359,14,0,22]], + [1575288,[5315,0,433,14,0,18],[5315,0,396,14,0,22]], + [1578144,[5385,0,405,13,111,18],[5385,0,331,13,111,27]], + [1578552,[5395,0,442,13,111,18],[5395,0,368,13,111,27]], + [1586306,[5585,2,401,14,0,9],[5585,2,724,14,37,6]], + [1586714,[5595,2,438,14,0,9],[5595,2,724,14,36,6]], + [1602962,[5985,338,401,14,0,17],[5985,338,401,14,0,23]], + [1603370,[5995,338,438,14,0,17],[5995,338,438,14,0,23]], + [1603605,[6005,165,405,13,111,27],[6005,165,396,14,0,0]], + [1604013,[6015,165,442,13,111,27],[6015,165,433,14,0,0]], + [1613233,[6245,1,405,13,111,31],[6245,1,331,13,111,36]], + [1613641,[6255,1,442,13,111,31],[6255,1,368,13,111,36]], + [1622593,[6465,385,405,13,111,40],[6465,385,364,14,0,6]], + [1623001,[6475,385,442,13,111,40],[6475,385,327,14,0,6]], + [1624167,[6505,327,401,14,0,26],[6505,327,401,14,0,0]], + [1624575,[6515,327,438,14,0,26],[6515,327,438,14,0,0]], + [1630815,[16,39,484,4,4,0],[16,39,706,4,4,0]], + [1657226,[656,338,484,4,4,9],[656,338,706,4,4,18]], + [1740122,[2696,2,517,4,1,6],[2696,2,728,1,7,0]], + [1740124,[2696,4,517,4,0,6],[2696,4,728,1,6,0]], + [1829472,[4886,0,479,13,111,0],[4886,0,368,13,111,0]], + [1829880,[4896,0,516,13,111,0],[4896,0,405,13,111,0]], + [1831920,[4946,0,479,13,111,9],[4946,0,368,13,111,9]], + [1832328,[4956,0,516,13,111,9],[4956,0,405,13,111,9]], + [1838654,[5106,206,470,14,0,0],[5106,206,396,14,0,4]], + [1839062,[5116,206,507,14,0,0],[5116,206,433,14,0,4]], + [1840908,[5166,12,470,14,0,9],[5166,12,396,14,0,13]], + [1841316,[5176,12,507,14,0,9],[5176,12,433,14,0,13]], + [1841730,[5186,18,475,14,0,0],[5186,18,475,14,0,14]], + [1842138,[5196,18,512,14,0,0],[5196,18,512,14,0,14]], + [1846608,[5306,0,470,14,0,18],[5306,0,433,14,0,22]], + [1847016,[5316,0,507,14,0,18],[5316,0,470,14,0,22]], + [1849872,[5386,0,479,13,111,18],[5386,0,405,13,111,18]], + [1850280,[5396,0,516,13,111,18],[5396,0,405,13,111,27]], + [1858034,[5586,2,475,14,0,9],[5586,2,724,14,35,6]], + [1858442,[5596,2,512,14,0,9],[5596,2,724,14,34,6]], + [1874690,[5986,338,475,14,0,17],[5986,338,475,14,0,23]], + [1875098,[5996,338,512,14,0,17],[5996,338,512,14,0,23]], + [1875333,[6006,165,479,13,111,27],[6006,165,470,14,0,0]], + [1875741,[6016,165,516,13,111,27],[6016,165,507,14,0,0]], + [1884961,[6246,1,479,13,111,31],[6246,1,405,13,111,36]], + [1885369,[6256,1,516,13,111,31],[6256,1,442,13,111,36]], + [1894321,[6466,385,479,13,111,40],[6466,385,290,14,0,6]], + [1894729,[6476,385,516,13,111,40],[6476,385,253,14,0,6]], + [1895895,[6506,327,475,14,0,26],[6506,327,475,14,0,0]], + [1896303,[6516,327,512,14,0,26],[6516,327,512,14,0,0]], + [1902543,[17,39,558,4,4,0],[17,39,706,4,4,9]], + [1928954,[657,338,558,4,4,9],[657,338,737,4,0,5]], + [1935788,[827,236,530,1,0,0],[827,236,40,4,4,0]], + [1935961,[837,1,566,4,6,0],[837,1,566,4,6,14]], + [1935963,[837,3,566,4,5,0],[837,3,566,4,5,14]], + [1935965,[837,5,566,4,4,0],[837,5,566,4,4,14]], + [1935967,[837,7,566,4,3,0],[837,7,566,4,3,14]], + [1935968,[837,8,566,4,2,0],[837,8,566,4,2,14]], + [1935969,[837,9,566,4,1,0],[837,9,566,4,1,14]], + [1937831,[877,239,566,4,6,9],[877,239,566,4,6,23]], + [1937832,[877,240,566,4,5,9],[877,240,566,4,5,23]], + [1937833,[877,241,566,4,4,9],[877,241,566,4,4,23]], + [1937834,[877,242,566,4,3,9],[877,242,566,4,3,23]], + [1937835,[877,243,566,4,2,9],[877,243,566,4,2,23]], + [1937836,[877,244,566,4,1,9],[877,244,566,4,1,23]], + [1943583,[1017,279,566,4,6,18],[1017,279,566,4,6,0]], + [1943584,[1017,280,566,4,5,18],[1017,280,566,4,5,0]], + [1943606,[1017,302,566,4,4,18],[1017,302,566,4,4,0]], + [1943607,[1017,303,566,4,3,18],[1017,303,566,4,3,0]], + [1943630,[1017,326,566,4,2,18],[1017,326,566,4,2,0]], + [1943631,[1017,327,566,4,1,18],[1017,327,566,4,1,0]], + [1952284,[1237,4,566,4,6,24],[1237,4,123,1,3,0]], + [1952286,[1237,6,566,4,5,24],[1237,6,197,1,2,0]], + [1952360,[1237,80,566,4,4,24],[1237,80,271,1,1,0]], + [1952367,[1237,87,566,4,3,24],[1237,87,345,1,0,0]], + [1952376,[1237,96,566,4,2,24],[1237,96,49,1,3,0]], + [1952383,[1237,103,566,4,1,24],[1237,103,123,1,2,0]], + [2011850,[2697,2,591,4,1,6],[2697,2,728,1,5,0]], + [2011852,[2697,4,591,4,0,6],[2697,4,728,1,4,0]], + [2101200,[4887,0,553,13,111,0],[4887,0,442,13,111,0]], + [2101608,[4897,0,590,13,111,0],[4897,0,479,13,111,9]], + [2103648,[4947,0,553,13,111,9],[4947,0,442,13,111,9]], + [2104056,[4957,0,590,13,111,9],[4957,0,479,13,111,18]], + [2110382,[5107,206,544,14,0,0],[5107,206,470,14,0,4]], + [2110790,[5117,206,581,14,0,0],[5117,206,507,14,0,4]], + [2112636,[5167,12,544,14,0,9],[5167,12,470,14,0,13]], + [2113044,[5177,12,581,14,0,9],[5177,12,507,14,0,13]], + [2113458,[5187,18,549,14,0,0],[5187,18,549,14,0,14]], + [2113866,[5197,18,586,14,0,0],[5197,18,586,14,0,14]], + [2118336,[5307,0,544,14,0,18],[5307,0,507,14,0,22]], + [2118744,[5317,0,581,14,0,18],[5317,0,544,14,0,22]], + [2121600,[5387,0,553,13,111,18],[5387,0,442,13,111,18]], + [2122008,[5397,0,590,13,111,18],[5397,0,479,13,111,27]], + [2129762,[5587,2,549,14,0,9],[5587,2,724,14,33,6]], + [2130170,[5597,2,586,14,0,9],[5597,2,724,14,32,6]], + [2146418,[5987,338,549,14,0,17],[5987,338,549,14,0,23]], + [2146826,[5997,338,586,14,0,17],[5997,338,586,14,0,23]], + [2147061,[6007,165,553,13,111,27],[6007,165,544,14,0,0]], + [2147469,[6017,165,590,13,111,27],[6017,165,581,14,0,0]], + [2156689,[6247,1,553,13,111,31],[6247,1,442,13,111,27]], + [2157097,[6257,1,590,13,111,31],[6257,1,479,13,111,36]], + [2166049,[6467,385,553,13,111,40],[6467,385,216,14,0,6]], + [2166457,[6477,385,590,13,111,40],[6477,385,179,14,0,6]], + [2167623,[6507,327,549,14,0,26],[6507,327,549,14,0,0]], + [2168031,[6517,327,586,14,0,26],[6517,327,586,14,0,0]], + [2174271,[18,39,632,4,4,0],[18,39,700,4,0,5]], + [2200682,[658,338,632,4,4,9],[658,338,737,4,1,5]], + [2202055,[698,79,646,6,37,0],[698,79,646,6,37,14]], + [2202057,[698,81,646,6,36,0],[698,81,646,6,36,14]], + [2202058,[698,82,646,6,35,0],[698,82,646,6,35,14]], + [2202060,[698,84,646,6,34,0],[698,84,646,6,34,14]], + [2207514,[828,234,604,1,1,0],[828,234,114,4,4,0]], + [2207516,[828,236,604,1,0,0],[828,236,40,4,4,8]], + [2207688,[838,0,640,4,7,0],[838,0,640,4,7,14]], + [2207689,[838,1,640,4,6,0],[838,1,640,4,6,14]], + [2207691,[838,3,640,4,5,0],[838,3,640,4,5,14]], + [2207693,[838,5,640,4,4,0],[838,5,640,4,4,14]], + [2207695,[838,7,640,4,3,0],[838,7,640,4,3,14]], + [2207696,[838,8,640,4,2,0],[838,8,640,4,2,14]], + [2207697,[838,9,640,4,1,0],[838,9,640,4,1,14]], + [2209557,[878,237,640,4,7,9],[878,237,640,4,7,23]], + [2209559,[878,239,640,4,6,9],[878,239,640,4,6,23]], + [2209560,[878,240,640,4,5,9],[878,240,640,4,5,23]], + [2209561,[878,241,640,4,4,9],[878,241,640,4,4,23]], + [2209562,[878,242,640,4,3,9],[878,242,640,4,3,23]], + [2209563,[878,243,640,4,2,9],[878,243,640,4,2,23]], + [2209564,[878,244,640,4,1,9],[878,244,640,4,1,23]], + [2215291,[1018,259,640,4,7,18],[1018,259,640,4,7,0]], + [2215311,[1018,279,640,4,6,18],[1018,279,640,4,6,0]], + [2215312,[1018,280,640,4,5,18],[1018,280,640,4,5,0]], + [2215334,[1018,302,640,4,4,18],[1018,302,640,4,4,0]], + [2215335,[1018,303,640,4,3,18],[1018,303,640,4,3,0]], + [2215358,[1018,326,640,4,2,18],[1018,326,640,4,2,0]], + [2215359,[1018,327,640,4,1,18],[1018,327,640,4,1,0]], + [2224010,[1238,2,640,4,7,24],[1238,2,197,1,1,0]], + [2224012,[1238,4,640,4,6,24],[1238,4,271,1,0,0]], + [2224014,[1238,6,640,4,5,24],[1238,6,678,1,2,0]], + [2224088,[1238,80,640,4,4,24],[1238,80,49,1,2,0]], + [2224095,[1238,87,640,4,3,24],[1238,87,123,1,1,0]], + [2224104,[1238,96,640,4,2,24],[1238,96,197,1,0,0]], + [2224111,[1238,103,640,4,1,24],[1238,103,604,1,1,0]], + [2240561,[1638,233,646,6,37,9],[1638,233,566,4,6,6]], + [2240562,[1638,234,646,6,36,9],[1638,234,566,4,5,6]], + [2240564,[1638,236,646,6,35,9],[1638,236,566,4,4,6]], + [2240566,[1638,238,646,6,34,9],[1638,238,566,4,3,6]], + [2266719,[2278,279,646,6,37,17],[2278,279,646,6,37,0]], + [2266720,[2278,280,646,6,36,17],[2278,280,646,6,36,0]], + [2266742,[2278,302,646,6,35,17],[2278,302,646,6,35,0]], + [2266743,[2278,303,646,6,34,17],[2278,303,646,6,34,0]], + [2274188,[2458,404,654,1,3,0],[2458,404,646,6,37,6]], + [2274189,[2458,405,654,1,2,0],[2458,405,646,6,36,6]], + [2274190,[2458,406,654,1,1,0],[2458,406,646,6,35,6]], + [2274191,[2458,407,654,1,0,0],[2458,407,646,6,34,6]], + [2283578,[2698,2,665,4,1,6],[2698,2,728,1,3,0]], + [2283580,[2698,4,665,4,0,6],[2698,4,728,1,2,0]], + [2336197,[3978,397,650,14,35,0],[3978,397,73,4,1,6]], + [2336198,[3978,398,650,14,34,0],[3978,398,73,4,0,6]], + [2336199,[3978,399,650,14,33,0],[3978,399,147,4,1,6]], + [2336200,[3978,400,650,14,32,0],[3978,400,147,4,0,6]], + [2336201,[3978,401,650,14,19,0],[3978,401,221,4,1,6]], + [2336204,[3978,404,650,14,18,0],[3978,404,221,4,0,6]], + [2336205,[3978,405,650,14,17,0],[3978,405,295,4,1,6]], + [2336206,[3978,406,650,14,16,0],[3978,406,295,4,0,6]], + [2341633,[4118,121,650,14,35,8],[4118,121,650,14,35,14]], + [2341635,[4118,123,650,14,34,8],[4118,123,650,14,34,14]], + [2341636,[4118,124,650,14,33,8],[4118,124,650,14,33,14]], + [2341637,[4118,125,650,14,32,8],[4118,125,650,14,32,14]], + [2341814,[4118,302,650,14,19,8],[4118,302,650,14,19,0]], + [2341815,[4118,303,650,14,18,8],[4118,303,650,14,18,0]], + [2341838,[4118,326,650,14,17,8],[4118,326,650,14,17,0]], + [2341839,[4118,327,650,14,16,8],[4118,327,650,14,16,0]], + [2363775,[4658,231,650,14,35,17],[4658,231,650,14,35,0]], + [2363802,[4658,258,650,14,34,17],[4658,258,650,14,34,0]], + [2363803,[4658,259,650,14,33,17],[4658,259,650,14,33,0]], + [2363823,[4658,279,650,14,32,17],[4658,279,650,14,32,0]], + [2372928,[4888,0,627,13,111,0],[4888,0,479,13,111,0]], + [2373336,[4898,0,664,13,111,0],[4898,0,516,13,111,0]], + [2375376,[4948,0,627,13,111,9],[4948,0,516,13,111,9]], + [2375784,[4958,0,664,13,111,9],[4958,0,516,13,111,18]], + [2382110,[5108,206,618,14,0,0],[5108,206,544,14,0,4]], + [2382518,[5118,206,655,14,0,0],[5118,206,581,14,0,4]], + [2384364,[5168,12,618,14,0,9],[5168,12,544,14,0,13]], + [2384772,[5178,12,655,14,0,9],[5178,12,581,14,0,13]], + [2385186,[5188,18,623,14,0,0],[5188,18,623,14,0,14]], + [2385594,[5198,18,660,14,0,0],[5198,18,660,14,0,14]], + [2390064,[5308,0,618,14,0,18],[5308,0,581,14,0,22]], + [2390472,[5318,0,655,14,0,18],[5318,0,618,14,0,22]], + [2393328,[5388,0,627,13,111,18],[5388,0,516,13,111,27]], + [2393736,[5398,0,664,13,111,18],[5398,0,553,13,111,27]], + [2401490,[5588,2,623,14,0,9],[5588,2,724,14,19,6]], + [2401898,[5598,2,660,14,0,9],[5598,2,724,14,18,6]], + [2418146,[5988,338,623,14,0,17],[5988,338,623,14,0,23]], + [2418554,[5998,338,660,14,0,17],[5998,338,660,14,0,23]], + [2418789,[6008,165,627,13,111,27],[6008,165,618,14,0,0]], + [2419197,[6018,165,664,13,111,27],[6018,165,655,14,0,0]], + [2428417,[6248,1,627,13,111,31],[6248,1,516,13,111,36]], + [2428825,[6258,1,664,13,111,31],[6258,1,553,13,111,36]], + [2437777,[6468,385,627,13,111,40],[6468,385,142,14,0,6]], + [2438185,[6478,385,664,13,111,40],[6478,385,105,14,0,6]], + [2439351,[6508,327,623,14,0,26],[6508,327,623,14,0,0]], + [2439759,[6518,327,660,14,0,26],[6518,327,660,14,0,0]], + [2445999,[19,39,706,4,4,0],[19,39,700,4,1,5]], + [2472410,[659,338,706,4,4,9],[659,338,739,4,98,4]], + [2473723,[699,19,720,6,88,0],[699,19,720,6,88,14]], + [2473724,[699,20,720,6,87,0],[699,20,720,6,87,14]], + [2473770,[699,66,720,6,47,0],[699,66,720,6,47,14]], + [2473771,[699,67,720,6,46,0],[699,67,720,6,46,14]], + [2473772,[699,68,720,6,45,0],[699,68,720,6,45,14]], + [2473774,[699,70,720,6,44,0],[699,70,720,6,44,14]], + [2473775,[699,71,720,6,43,0],[699,71,720,6,43,14]], + [2473776,[699,72,720,6,42,0],[699,72,720,6,42,14]], + [2473777,[699,73,720,6,41,0],[699,73,720,6,41,14]], + [2473780,[699,76,720,6,40,0],[699,76,720,6,40,14]], + [2473781,[699,77,720,6,39,0],[699,77,720,6,39,14]], + [2473782,[699,78,720,6,38,0],[699,78,720,6,38,14]], + [2473783,[699,79,720,6,37,0],[699,79,720,6,37,14]], + [2473785,[699,81,720,6,36,0],[699,81,720,6,36,14]], + [2473786,[699,82,720,6,35,0],[699,82,720,6,35,14]], + [2473788,[699,84,720,6,34,0],[699,84,720,6,34,14]], + [2474967,[729,39,700,4,1,0],[729,39,700,4,1,14]], + [2474968,[729,40,700,4,0,0],[729,40,700,4,0,14]], + [2475375,[739,39,737,4,1,0],[739,39,737,4,1,14]], + [2475376,[739,40,737,4,0,0],[739,40,737,4,0,14]], + [2479241,[829,233,678,1,2,0],[829,233,188,4,4,0]], + [2479242,[829,234,678,1,1,0],[829,234,114,4,4,8]], + [2479244,[829,236,678,1,0,0],[829,236,40,4,4,16]], + [2479416,[839,0,714,4,7,0],[839,0,714,4,7,14]], + [2479417,[839,1,714,4,6,0],[839,1,714,4,6,14]], + [2479419,[839,3,714,4,5,0],[839,3,714,4,5,14]], + [2479421,[839,5,714,4,4,0],[839,5,714,4,4,14]], + [2479423,[839,7,714,4,3,0],[839,7,714,4,3,14]], + [2479424,[839,8,714,4,2,0],[839,8,714,4,2,14]], + [2479425,[839,9,714,4,1,0],[839,9,714,4,1,14]], + [2481285,[879,237,714,4,7,9],[879,237,714,4,7,23]], + [2481287,[879,239,714,4,6,9],[879,239,714,4,6,23]], + [2481288,[879,240,714,4,5,9],[879,240,714,4,5,23]], + [2481289,[879,241,714,4,4,9],[879,241,714,4,4,23]], + [2481290,[879,242,714,4,3,9],[879,242,714,4,3,23]], + [2481291,[879,243,714,4,2,9],[879,243,714,4,2,23]], + [2481292,[879,244,714,4,1,9],[879,244,714,4,1,23]], + [2483124,[929,36,700,4,1,9],[929,36,700,4,1,23]], + [2483125,[929,37,700,4,0,9],[929,37,700,4,0,23]], + [2483532,[939,36,737,4,1,9],[939,36,737,4,1,23]], + [2483533,[939,37,737,4,0,9],[939,37,737,4,0,23]], + [2487019,[1019,259,714,4,7,18],[1019,259,714,4,7,0]], + [2487039,[1019,279,714,4,6,18],[1019,279,714,4,6,0]], + [2487040,[1019,280,714,4,5,18],[1019,280,714,4,5,0]], + [2487062,[1019,302,714,4,4,18],[1019,302,714,4,4,0]], + [2487063,[1019,303,714,4,3,18],[1019,303,714,4,3,0]], + [2487086,[1019,326,714,4,2,18],[1019,326,714,4,2,0]], + [2487087,[1019,327,714,4,1,18],[1019,327,714,4,1,0]], + [2495738,[1239,2,714,4,7,24],[1239,2,678,1,1,0]], + [2495740,[1239,4,714,4,6,24],[1239,4,49,1,1,0]], + [2495742,[1239,6,714,4,5,24],[1239,6,123,1,0,0]], + [2495816,[1239,80,714,4,4,24],[1239,80,530,1,0,0]], + [2495823,[1239,87,714,4,3,24],[1239,87,604,1,0,0]], + [2495832,[1239,96,714,4,2,24],[1239,96,678,1,0,0]], + [2495839,[1239,103,714,4,1,24],[1239,103,49,1,0,0]], + [2512060,[1639,4,720,6,88,9],[1639,4,566,4,2,6]], + [2512062,[1639,6,720,6,87,9],[1639,6,566,4,1,6]], + [2512136,[1639,80,720,6,47,9],[1639,80,640,4,7,6]], + [2512143,[1639,87,720,6,46,9],[1639,87,640,4,6,6]], + [2512152,[1639,96,720,6,45,9],[1639,96,640,4,5,6]], + [2512159,[1639,103,720,6,44,9],[1639,103,640,4,4,6]], + [2512195,[1639,139,720,6,43,9],[1639,139,640,4,3,6]], + [2512227,[1639,171,720,6,42,9],[1639,171,640,4,2,6]], + [2512240,[1639,184,720,6,41,9],[1639,184,640,4,1,6]], + [2512244,[1639,188,720,6,40,9],[1639,188,714,4,7,6]], + [2512256,[1639,200,720,6,39,9],[1639,200,714,4,6,6]], + [2512260,[1639,204,720,6,38,9],[1639,204,714,4,5,6]], + [2512289,[1639,233,720,6,37,9],[1639,233,714,4,4,6]], + [2512290,[1639,234,720,6,36,9],[1639,234,714,4,3,6]], + [2512292,[1639,236,720,6,35,9],[1639,236,714,4,2,6]], + [2512294,[1639,238,720,6,34,9],[1639,238,714,4,1,6]], + [2525438,[1959,326,720,6,88,17],[1959,326,720,6,88,0]], + [2525439,[1959,327,720,6,87,17],[1959,327,720,6,87,0]], + [2538392,[2279,224,720,6,47,17],[2279,224,720,6,47,0]], + [2538393,[2279,225,720,6,46,17],[2279,225,720,6,46,0]], + [2538394,[2279,226,720,6,45,17],[2279,226,720,6,45,0]], + [2538395,[2279,227,720,6,44,17],[2279,227,720,6,44,0]], + [2538396,[2279,228,720,6,43,17],[2279,228,720,6,43,0]], + [2538397,[2279,229,720,6,42,17],[2279,229,720,6,42,0]], + [2538398,[2279,230,720,6,41,17],[2279,230,720,6,41,0]], + [2538399,[2279,231,720,6,40,17],[2279,231,720,6,40,0]], + [2538426,[2279,258,720,6,39,17],[2279,258,720,6,39,0]], + [2538427,[2279,259,720,6,38,17],[2279,259,720,6,38,0]], + [2538447,[2279,279,720,6,37,17],[2279,279,720,6,37,0]], + [2538448,[2279,280,720,6,36,17],[2279,280,720,6,36,0]], + [2538470,[2279,302,720,6,35,17],[2279,302,720,6,35,0]], + [2538471,[2279,303,720,6,34,17],[2279,303,720,6,34,0]], + [2544858,[2439,162,739,4,98,0],[2439,162,739,4,98,13]], + [2545902,[2459,390,728,1,15,0],[2459,390,720,6,88,6]], + [2545903,[2459,391,728,1,14,0],[2459,391,720,6,87,6]], + [2545904,[2459,392,728,1,13,0],[2459,392,720,6,47,6]], + [2545905,[2459,393,728,1,12,0],[2459,393,720,6,46,6]], + [2545906,[2459,394,728,1,11,0],[2459,394,720,6,45,6]], + [2545907,[2459,395,728,1,10,0],[2459,395,720,6,44,6]], + [2545908,[2459,396,728,1,9,0],[2459,396,720,6,43,6]], + [2545909,[2459,397,728,1,8,0],[2459,397,720,6,42,6]], + [2545910,[2459,398,728,1,7,0],[2459,398,720,6,41,6]], + [2545911,[2459,399,728,1,6,0],[2459,399,720,6,40,6]], + [2545912,[2459,400,728,1,5,0],[2459,400,720,6,39,6]], + [2545913,[2459,401,728,1,4,0],[2459,401,720,6,38,6]], + [2545916,[2459,404,728,1,3,0],[2459,404,720,6,37,6]], + [2545917,[2459,405,728,1,2,0],[2459,405,720,6,36,6]], + [2545918,[2459,406,728,1,1,0],[2459,406,720,6,35,6]], + [2545919,[2459,407,728,1,0,0],[2459,407,720,6,34,6]], + [2555306,[2699,2,739,4,1,6],[2699,2,728,1,1,0]], + [2555308,[2699,4,739,4,0,6],[2699,4,728,1,0,0]], + [2607921,[3979,393,724,14,39,0],[3979,393,369,4,1,6]], + [2607922,[3979,394,724,14,38,0],[3979,394,369,4,0,6]], + [2607923,[3979,395,724,14,37,0],[3979,395,443,4,1,6]], + [2607924,[3979,396,724,14,36,0],[3979,396,443,4,0,6]], + [2607925,[3979,397,724,14,35,0],[3979,397,517,4,1,6]], + [2607926,[3979,398,724,14,34,0],[3979,398,517,4,0,6]], + [2607927,[3979,399,724,14,33,0],[3979,399,591,4,1,6]], + [2607928,[3979,400,724,14,32,0],[3979,400,591,4,0,6]], + [2607929,[3979,401,724,14,19,0],[3979,401,665,4,1,6]], + [2607932,[3979,404,724,14,18,0],[3979,404,665,4,0,6]], + [2607933,[3979,405,724,14,17,0],[3979,405,739,4,1,6]], + [2607934,[3979,406,724,14,16,0],[3979,406,739,4,0,6]], + [2613356,[4119,116,724,14,39,8],[4119,116,724,14,39,14]], + [2613358,[4119,118,724,14,38,8],[4119,118,724,14,38,14]], + [2613359,[4119,119,724,14,37,8],[4119,119,724,14,37,14]], + [2613360,[4119,120,724,14,36,8],[4119,120,724,14,36,14]], + [2613361,[4119,121,724,14,35,8],[4119,121,724,14,35,14]], + [2613363,[4119,123,724,14,34,8],[4119,123,724,14,34,14]], + [2613364,[4119,124,724,14,33,8],[4119,124,724,14,33,14]], + [2613365,[4119,125,724,14,32,8],[4119,125,724,14,32,14]], + [2613542,[4119,302,724,14,19,8],[4119,302,724,14,19,0]], + [2613543,[4119,303,724,14,18,8],[4119,303,724,14,18,0]], + [2613566,[4119,326,724,14,17,8],[4119,326,724,14,17,0]], + [2613567,[4119,327,724,14,16,8],[4119,327,724,14,16,0]], + [2632109,[4579,101,739,4,98,9],[4579,101,739,4,98,0]], + [2633802,[4619,162,739,4,98,13],[4619,162,739,4,98,22]], + [2635499,[4659,227,724,14,39,17],[4659,227,724,14,39,0]], + [2635500,[4659,228,724,14,38,17],[4659,228,724,14,38,0]], + [2635501,[4659,229,724,14,37,17],[4659,229,724,14,37,0]], + [2635502,[4659,230,724,14,36,17],[4659,230,724,14,36,0]], + [2635503,[4659,231,724,14,35,17],[4659,231,724,14,35,0]], + [2635530,[4659,258,724,14,34,17],[4659,258,724,14,34,0]], + [2635531,[4659,259,724,14,33,17],[4659,259,724,14,33,0]], + [2635551,[4659,279,724,14,32,17],[4659,279,724,14,32,0]], + [2642778,[4839,162,739,4,98,22],[4839,162,729,14,0,4]], + [2644656,[4889,0,701,13,111,0],[4889,0,553,13,111,0]], + [2645064,[4899,0,738,13,111,0],[4899,0,590,13,111,0]], + [2646332,[4929,44,700,4,1,18],[4929,44,729,14,0,13]], + [2646333,[4929,45,700,4,0,18],[4929,45,692,14,0,4]], + [2646740,[4939,44,737,4,1,18],[4939,44,729,14,0,22]], + [2646741,[4939,45,737,4,0,18],[4939,45,692,14,0,13]], + [2647104,[4949,0,701,13,111,9],[4949,0,553,13,111,9]], + [2647506,[4949,402,700,4,1,27],[4949,402,700,4,1,0]], + [2647507,[4949,403,700,4,0,27],[4949,403,700,4,0,0]], + [2647512,[4959,0,738,13,111,9],[4959,0,590,13,111,9]], + [2647914,[4959,402,737,4,1,27],[4959,402,737,4,1,0]], + [2647915,[4959,403,737,4,0,27],[4959,403,737,4,0,0]], + [2653838,[5109,206,692,14,0,0],[5109,206,618,14,0,4]], + [2654246,[5119,206,729,14,0,0],[5119,206,655,14,0,4]], + [2656092,[5169,12,692,14,0,9],[5169,12,618,14,0,13]], + [2656500,[5179,12,729,14,0,9],[5179,12,655,14,0,13]], + [2656914,[5189,18,697,14,0,0],[5189,18,697,14,0,14]], + [2657322,[5199,18,734,14,0,0],[5199,18,734,14,0,14]], + [2661792,[5309,0,692,14,0,18],[5309,0,655,14,0,22]], + [2662200,[5319,0,729,14,0,18],[5319,0,692,14,0,22]], + [2665056,[5389,0,701,13,111,18],[5389,0,553,13,111,18]], + [2665464,[5399,0,738,13,111,18],[5399,0,590,13,111,18]], + [2673218,[5589,2,697,14,0,9],[5589,2,724,14,17,6]], + [2673626,[5599,2,734,14,0,9],[5599,2,724,14,16,6]], + [2689874,[5989,338,697,14,0,17],[5989,338,697,14,0,23]], + [2690282,[5999,338,734,14,0,17],[5999,338,734,14,0,23]], + [2690517,[6009,165,701,13,111,27],[6009,165,692,14,0,0]], + [2690925,[6019,165,738,13,111,27],[6019,165,729,14,0,0]], + [2700145,[6249,1,701,13,111,31],[6249,1,590,13,111,27]], + [2700553,[6259,1,738,13,111,31],[6259,1,590,13,111,36]], + [2709505,[6469,385,701,13,111,40],[6469,385,68,14,0,6]], + [2709913,[6479,385,738,13,111,40],[6479,385,31,14,0,6]], + [2711079,[6509,327,697,14,0,26],[6509,327,697,14,0,0]], + [2711487,[6519,327,734,14,0,26],[6519,327,734,14,0,0]] + ] +} diff --git a/research/rank7-t740-release/vendor/pr3024/cap_proof.py b/research/rank7-t740-release/vendor/pr3024/cap_proof.py new file mode 100644 index 0000000000..28f0995a69 --- /dev/null +++ b/research/rank7-t740-release/vendor/pr3024/cap_proof.py @@ -0,0 +1,257 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Exact fixed-inventory cap and replica-divisibility certificate. + +The caller must authenticate the root arithmetic module and bind `certificate` +to the words' actual local profile and width inventory. This module checks the +fixed chronology-free pattern relaxation. It does not prove chronological +feasibility or any scalar/native/physical/outer admission obligation. +""" + +from fractions import Fraction +from itertools import product +from math import gcd + +Q = Fraction +WIDTHS = (4, 5, 6, 7, 8, 9) +CAPS = (8, 16, 32, 48) +BINS = (672, 448, 448, 448) +INVENTORY = (26, 2, 16, 52, 99, 213) +LOCAL = {1: 2445, 2: 706, 3: 232, 4: 108, 5: 18, 8: 8} +Q_ROW = (-3, -6, -12, 0, 0, 0, 1, 2, 3, 4) +TIGHT = ( + (8, (8,)), + (16, (8, 8)), + (16, (7, 9)), + (32, (9, 9, 9)), + (32, (8, 8, 8, 8)), + (32, (7, 8, 8, 9)), + (32, (7, 7, 9, 9)), + (32, (6, 8, 9, 9)), + (32, (5, 9, 9, 9)), + (32, (4, 9, 9, 9)), + (48, ()), + (48, (9, 9, 9, 9, 9)), +) + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def patterns(): + """All 2,551 capacity-feasible count vectors; loops have fixed finite bounds.""" + result = [] + for capacity in CAPS: + for counts in product(*(range(capacity // width + 1) for width in WIDTHS)): + idle = capacity - sum(w * n for w, n in zip(WIDTHS, counts, strict=True)) + if idle >= 0: + result.append((capacity, counts, idle)) + need(len(result) == 2551, "changed pattern domain") + return result + + +def column(pattern): + capacity, counts, _ = pattern + return tuple(int(capacity == cap) for cap in CAPS) + counts + + +def inverse(matrix): + """Gauss-Jordan inversion over Q, explicitly restricted to the 10-row model.""" + need(len(matrix) == 10 and all(len(row) == 10 for row in matrix), "matrix shape") + rows = [ + [Q(value) for value in row] + [Q(i == j) for j in range(10)] + for i, row in enumerate(matrix) + ] + for col in range(10): + pivot = next((r for r in range(col, 10) if rows[r][col]), None) + need(pivot is not None, "singular basis") + rows[col], rows[pivot] = rows[pivot], rows[col] + divisor = rows[col][col] + rows[col] = [value / divisor for value in rows[col]] + for r in range(10): + if r != col: + multiple = rows[r][col] + rows[r] = [ + a - multiple * b for a, b in zip(rows[r], rows[col], strict=True) + ] + return [row[10:] for row in rows] + + +def basis_data(certificate, catalogue): + need( + set(certificate["inventory_per_call"]) == set(map(str, WIDTHS)), + "inventory keys", + ) + need( + tuple(Q(certificate["inventory_per_call"][str(w)]) for w in WIDTHS) + == INVENTORY, + "wrong inventory", + ) + need( + {int(r): Q(n) for r, n in certificate["local_per_call"].items()} == LOCAL, + "wrong local profile", + ) + entries = certificate["basis_patterns"] + need(len(entries) == 10, "wrong basis size") + basis, amounts = [], [] + for entry in entries: + widths = entry["widths"] + need(len(widths) <= 12 and all(w in WIDTHS for w in widths), "basis widths") + pattern = ( + entry["capacity"], + tuple(widths.count(w) for w in WIDTHS), + entry["capacity"] - sum(widths), + ) + need(pattern in catalogue, "infeasible basis pattern") + basis.append(pattern) + amounts.append(Q(entry["count_per_replica"])) + need(len(set(basis)) == 10 and all(x >= 0 for x in amounts), "basis feasibility") + columns = [column(p) for p in basis] + matrix = [[columns[k][r] for k in range(10)] for r in range(10)] + rhs = BINS + tuple(9 * n for n in INVENTORY) + need( + all( + sum(matrix[r][k] * amounts[k] for k in range(10)) == rhs[r] + for r in range(10) + ), + "basis does not supply complete counts", + ) + return basis, amounts, inverse(matrix), rhs + + +def reduced_cost(pattern, basis, basis_inverse): + """Exact coefficients of H_r in c_p - a_p^T B^-T c_B.""" + coefficients = {pattern[2]: Q(1)} if pattern[2] else {} + a = column(pattern) + for k, basic in enumerate(basis): + if basic[2]: + amount = -sum(a[j] * basis_inverse[k][j] for j in range(10)) + coefficients[basic[2]] = coefficients.get(basic[2], Q(0)) + amount + return {rank: value for rank, value in coefficients.items() if value} + + +def check_invariant(tight, rhs, amounts): + """A residue identity isolates the only idle-rank-3 tight pattern.""" + for pattern in tight: + value = sum(a * b for a, b in zip(Q_ROW, column(pattern), strict=True)) + is_five_nines = pattern[0] == 48 and pattern[1] == (0, 0, 0, 0, 0, 5) + need(value == 20 * is_five_nines, "tight-pattern invariant failed") + coefficient = sum(a * b for a, b in zip(Q_ROW, rhs, strict=True)) + need(coefficient == 1341 and gcd(coefficient, 20) == 1, "residue coefficient") + need( + all((20 * x).denominator == 1 for x in amounts), + "20 replicas do not integralize the displayed basis", + ) + return { + "identity": "20*N_[9,9,9,9,9]@48 = 1341*T", + "cap_requires_T_multiple_of": 20, + "first_multiple_of_74": 74 * 20 // gcd(74, 20), + "scope": "Pattern integrality; chronological sufficiency is not asserted.", + } + + +def verify_cap(certificate, root_tools): + """Recertify the complete relaxation and strictness on the entire root bracket.""" + catalogue = patterns() + basis, amounts, basis_inverse, rhs = basis_data(certificate, catalogue) + lower, upper = Q(certificate["cap_lower"]), Q(certificate["cap_upper"]) + need( + 0 < lower < upper <= Q(1, 100) and upper - lower <= Q(1, 10**25), "cap bracket" + ) + profile = {rank: Q(9 * amount) for rank, amount in LOCAL.items()} + idle = {} + for pattern, amount in zip(basis, amounts, strict=True): + if pattern[2]: + profile[pattern[2]] = profile.get(pattern[2], Q(0)) + amount + idle[pattern[2]] = idle.get(pattern[2], Q(0)) + amount + need( + {int(r): Q(n) for r, n in certificate["idle_per_replica"].items()} == idle, + "stored idle differs from primal basis", + ) + need(sum(r * n for r, n in profile.items()) == 65088, "rank mass") + need( + root_tools.moment(profile, lower, 896)[1] + < 1 + < root_tools.moment(profile, upper, 896)[0], + "unproved cap root bracket", + ) + intervals = { + rank: (root_tools.H(rank, lower)[0], root_tools.H(rank, upper)[1]) + for rank in range(1, 49) + } + tight, slacks = [], [] + for pattern in catalogue: + coefficients = reduced_cost(pattern, basis, basis_inverse) + if not coefficients: + tight.append(pattern) + else: + slack = sum( + v * intervals[r][0 if v > 0 else 1] for r, v in coefficients.items() + ) + need(slack > 0, "reduced cost is not strictly positive on cap bracket") + slacks.append(slack) + named = { + (cap, tuple(w for w, n in zip(WIDTHS, counts, strict=True) for _ in range(n))) + for cap, counts, _ in tight + } + need(named == set(TIGHT) and len(slacks) == 2539, "tight domain differs") + invariant = check_invariant(tight, rhs, amounts) + return { + "idle_per_replica": {str(r): str(n) for r, n in sorted(idle.items())}, + "patterns": len(catalogue), + "strict_patterns": len(slacks), + "tight_patterns": len(tight), + "minimum_slack_lower": str(min(slacks)), + "cap_lower": str(lower), + "cap_upper": str(upper), + "invariant": invariant, + } + + +def unit_log_interval(y): + """Three atanh terms and a geometric tail for 1 <= y <= 2.""" + need(Q(1) <= y <= Q(2), "unit log argument") + z = (y - 1) / (y + 1) + lower = 2 * sum(z ** (2 * j + 1) / (2 * j + 1) for j in range(3)) + return lower, lower + 2 * z**7 / (7 * (1 - z * z)) + + +def prove_exchange_sign(): + """For 0 < b <= 1/100, 20H1+17H3-15H5-10H14+3H48 < 0.""" + l2, u2 = unit_log_interval(Q(2)) + a3, b3 = unit_log_interval(Q(3, 2)) + a5, b5 = unit_log_interval(Q(5, 4)) + a14, b14 = unit_log_interval(Q(7, 4)) + logs = { + 2: (l2, u2), + 3: (l2 + a3, u2 + b3), + 5: (2 * l2 + a5, 2 * u2 + b5), + 14: (3 * l2 + a14, 3 * u2 + b14), + } + limits = { + 2: (Q(69, 100), Q(7, 10)), + 3: (Q(109, 100), Q(11, 10)), + 5: (Q(0), Q(161, 100)), + 14: (Q(0), Q(66, 25)), + } + for rank, (lower, upper) in logs.items(): + need(limits[rank][0] < lower <= upper < limits[rank][1], "log bound") + need( + 4 * logs[2][0] + logs[3][0] > Q(77, 20) + and 4 * logs[2][1] + logs[3][1] < Q(39, 10), + "log48 bounds", + ) + need(20 + 51 - 75 - 140 + 144 == 0, "f(0) differs") + derivative_upper = ( + 75 * Q(161, 100) + + 140 * Q(66, 25) + - 51 * Q(109, 100) * Q(989, 1000) + - 144 * Q(77, 20) * Q(961, 1000) + ) + need(derivative_upper == Q(-9740691, 100000) < 0, "derivative sign") + return { + "delta": {1: 20, 3: 17, 5: -15, 14: -10, 48: 3}, + "saving_interval": "0 < b <= 1/100", + "factored_f_derivative_upper": str(derivative_upper), + } diff --git a/research/rank7-t740-release/vendor/pr3024/lift.py b/research/rank7-t740-release/vendor/pr3024/lift.py new file mode 100644 index 0000000000..717067dfce --- /dev/null +++ b/research/rank7-t740-release/vendor/pr3024/lift.py @@ -0,0 +1,152 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Ten interleaved copies and a sparse, preimage-bound allocation journal.""" + +from collections import Counter, defaultdict + +COPIES = 10 +BASE_T = 74 +HELPERS = 408 +BASE_ROLES = 9 * BASE_T * HELPERS +MAX_EDITS = 2000 + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def row_at(base, index): + need(type(index) is int and 0 <= index < COPIES * BASE_ROLES, "lift row index") + copy, original = divmod(index, BASE_ROLES) + time, helper, owner, child, port, offset = base[original] + return [COPIES * time + copy, helper, owner + BASE_T * copy, child, port, offset] + + +def patch(base, journal): + need(len(base) == BASE_ROLES, "base role count") + need(journal.get("copies") == COPIES, "journal lift multiplicity") + edits = journal.get("edits") + need(type(edits) is list and 0 < len(edits) <= MAX_EDITS, "journal size") + result = {} + for entry in edits: + need(type(entry) is list and len(entry) == 3, "edit shape") + index, before, after = entry + need(type(index) is int, "journal integer index") + need(index not in result, "duplicate journal index") + need(before == row_at(base, index), "journal preimage") + need(type(after) is list and len(after) == 6, "replacement row shape") + need(all(type(x) is int for x in after), "replacement integers") + need(after[:2] == before[:2], "fixed call/helper identity") + result[index] = after + return result + + +class Rows: + """Bounded streaming literal witness, in copy-major source-row order.""" + + def __init__(self, base, edits): + need(len(base) == BASE_ROLES, "stream base count") + self.base, self.edits = base, edits + + def __len__(self): + return COPIES * BASE_ROLES + + def __iter__(self): + for index in range(len(self)): + yield self.edits[index] if index in self.edits else row_at(self.base, index) + + +def chronology(order, dispatch): + need(len(order) == len(dispatch) == 9 * BASE_T, "base chronology size") + lifted_order, lifted_dispatch = [], {} + for stage, owner in order: + for copy in range(COPIES): + call = (stage, owner + BASE_T * copy) + lifted_order.append(list(call)) + lifted_dispatch[call] = dispatch[stage, owner] + return lifted_order, lifted_dispatch + + +def destination_window(key, windows): + owner, child, port = key + need(0 <= owner < COPIES * BASE_T and 0 <= port < 112, "destination bounds") + copy, original = divmod(owner, BASE_T) + need((original, child) in windows, "destination child") + capacity, lower, upper = windows[original, child] + lower = -1 if lower == -1 else COPIES * lower + copy + return capacity, lower, COPIES * upper + copy + + +def bin_members(base, index, key, edits): + copy, owner = divmod(key[0], BASE_T) + members = {} + for original in index.get((owner, key[1], key[2]), []): + global_index = copy * BASE_ROLES + original + if global_index not in edits: + members[global_index] = row_at(base, global_index) + for global_index, row in edits.items(): + if tuple(row[2:5]) == key: + members[global_index] = row + return members + + +def check_bin(key, members, widths, windows): + capacity, lower, upper = destination_window(key, windows) + mask, pattern = 0, [] + for row in members.values(): + time, helper, _, _, _, offset = row + need(lower < time <= upper, "changed source window") + width = widths[time // COPIES][helper] + need(0 <= offset and offset + width <= capacity, "changed capacity") + bits = ((1 << width) - 1) << offset + need(mask & bits == 0, "changed bin overlap") + mask |= bits + pattern.append(width) + used = mask.bit_count() + need(mask == (1 << used) - 1, "changed compact prefix") + return capacity - used, (capacity, tuple(sorted(pattern))) + + +def affected_calls(base, edits, families): + times = {row[0] for row in edits.values()} + need(len(times) <= MAX_EDITS, "affected call count") + for time in times: + original, copy = divmod(time, COPIES) + occupied = set() + for helper in range(HELPERS): + index = copy * BASE_ROLES + original * HELPERS + helper + row = edits[index] if index in edits else row_at(base, index) + family = row[2], families[row[3]], row[4] + need(family not in occupied, "changed same-call physical family") + occupied.add(family) + return len(times) + + +def differential(base, edits, widths, windows, families): + index = defaultdict(list) + for original, row in enumerate(base): + need(row[:2] == [original // HELPERS, original % HELPERS], "base row ordering") + index[tuple(row[2:5])].append(original) + keys = {tuple(row_at(base, i)[2:5]) for i in edits} + keys.update(tuple(row[2:5]) for row in edits.values()) + need(len(keys) <= 2 * MAX_EDITS, "affected bin count") + delta, pattern_delta = Counter(), Counter() + for key in sorted(keys): + before = bin_members(base, index, key, {}) + after = bin_members(base, index, key, edits) + old_idle, old_pattern = check_bin(key, before, widths, windows) + new_idle, new_pattern = check_bin(key, after, widths, windows) + if old_idle: + delta[old_idle] -= 1 + if new_idle: + delta[new_idle] += 1 + pattern_delta[old_pattern] -= 1 + pattern_delta[new_pattern] += 1 + return { + "affected_bins": len(keys), + "affected_calls": affected_calls(base, edits, families), + "idle_delta": {rank: count for rank, count in sorted(delta.items()) if count}, + "pattern_delta": [ + [cap, list(ws), n] for (cap, ws), n in sorted(pattern_delta.items()) if n + ], + } diff --git a/research/rank7-t740-release/verify.py b/research/rank7-t740-release/verify.py new file mode 100755 index 0000000000..af625bca18 --- /dev/null +++ b/research/rank7-t740-release/verify.py @@ -0,0 +1,108 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Recount the composed T740 witness and certify its complete moment.""" + +import argparse +import json +from fractions import Fraction + +import materialize as m + + +def physical_bound(replicas=740, buffers=91, payload=2048): + m.need(type(replicas) is int and replicas == 740, "T740 physical contract") + m.need(type(buffers) is int and buffers == 91, "all 91 private buffers") + physical = 896 * replicas + 408 + 8 + buffers + 2 + group = 2 ** 1296 + for j in range(1, 37): + group *= 2 ** (2 * j) - 1 + stock_bits = (group * physical).bit_length() + stock_l2_bits = (stock_bits + 1) // 2 + reserve = 128 + 37 + 18 + stock_l2_bits + 1 + 4 + m.need(physical <= 2 ** 20 and stock_l2_bits <= 1330, "retained full-stock bound") + m.need(type(payload) is int and reserve <= payload, "paid prefix payload") + return {"live": 896 * replicas, "physical": physical, "buffers": buffers, + "group_order_times_physical_bit_length": stock_bits, + "stock_l2_bits": stock_l2_bits, "reserve": reserve, "payload": payload, + "namespaces": {"centers": [663040, 663048], + "tableau": [663048, 663456], + "zero_buffers": [663456, 663547], + "coefficients": [663547, 663549]}} + + +def owners(rows, order, dispatch, providers, claimed=m.PROFILE): + path = m.MAIN / "allocation/vendor/independent_owners.py" + module = m.load_path(path, "authenticated_owner740") + normalized = {name: {**value, "actual_paid_profile": { + int(k): v for k, v in value["actual_paid_profile"].items()}} + for name, value in providers.items()} + fill = {"columns": ["time", "helper", "owner_replica", "child", "port", "offset"], + "rows": rows, "dispatch_overrides": []} + result, _, _ = module.check(740, order, fill, dispatch, claimed, + m.read(m.MAIN / "allocation/vendor/PLAN.json.gz"), + m.read(m.MAIN / "allocation/vendor/TEMPLATE.json.gz"), normalized) + m.need(result["roles"] == 2717280 and result["rank_mass"] == 48165120, + "complete T740 roles and paid mass") + # The retained diagnostic uses 72 buffers; charge the actual 91. + m.need(result["physical"] == result["live"] + 490, "known retained diagnostic") + result["physical"] = result["live"] + 509 + return result + + +def moment(profile): + path = m.MAIN / "tools/root.py" + root = m.load_path(path, "authenticated_root740") + lower, upper = root.kappa_from_profile(profile, 740) + old = m.read(m.PACKAGE / "vendor/PR3021-RESULT.json") + previous = Fraction(old["kappa"]) + m.need(lower > previous, "strict improvement over PR3021 released kappa") + baseline = m.read(m.PACKAGE / "vendor/pr3021-FINITE.json") + previous_upper = Fraction(baseline["new_root"][1]) + m.need(lower > previous_upper, "strict complete moment improvement") + cap = m.load("vendor/pr3024/cap_proof.py", "retained_cap_r1") + providers = m.read(m.PACKAGE / "vendor/pr3015/allocation/PROVIDERS.json") + local = {int(r): n for r, n in providers["gauge44"]["actual_paid_profile"].items()} + m.need(local == {int(r): n for r, n in providers["extra"]["actual_paid_profile"].items()}, + "common actual R1 local profile") + certificate = m.read(m.MAIN / "certificates/RELAX-CAP.json") + cap.LOCAL = local + certificate.update(local_per_call={str(r): n for r, n in local.items()}, + cap_lower=str(lower), cap_upper=str(upper)) + recertified = cap.verify_cap(certificate, root) + m.need(all(Fraction(profile.get(int(r), 0)) == + 9 * 740 * local.get(int(r), 0) + 740 * Fraction(n) + for r, n in recertified["idle_per_replica"].items()), "attained R1 cap idle counts") + return {"root": [str(lower), str(upper)], "r1_cap": recertified, + "exchange_sign": cap.prove_exchange_sign(), + "previous_released_kappa": str(previous), + "gain_over_previous_root": [str(lower - previous_upper), + str(upper - Fraction(baseline["new_root"][0]))]} + + +def run(): + rows, order, dispatch, providers = m.witness() + result = owners(rows, order, dispatch, providers) + stock = physical_bound() + m.need(result["physical"] == stock["physical"] == 663549, "full physical stock") + m.need(result["idle"] == {1: 173160, 3: 49617, 5: 17205, 48: 281903}, + "exact cap-attaining idle bill") + return dict(status="PASS_T740_R1_FINITE", **result, stock=stock, + moment=moment(m.PROFILE), + scope="Finite composed allocation and moment; fresh release is separate.") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=str) + args = parser.parse_args() + result = json.loads(json.dumps(run(), sort_keys=True)) + if args.output: + from pathlib import Path + Path(args.output).write_text(json.dumps(result, sort_keys=True, indent=2) + "\n") + else: + m.need(result == m.read(m.PACKAGE / "evidence/FINITE.json"), "published finite receipt") + print(result["status"], "roles=2717280", "physical=663549", flush=True) + + +if __name__ == "__main__": + main() diff --git a/research/rank7-t740-release/verify_release.py b/research/rank7-t740-release/verify_release.py new file mode 100755 index 0000000000..c81d940c04 --- /dev/null +++ b/research/rank7-t740-release/verify_release.py @@ -0,0 +1,105 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Authenticate stored full-release relations and rematerialize its inputs. + +This adapts PR3021's receipt audit. It does not run the full native/source chain. +""" + +import copy +import gzip +import hashlib +import json +import tempfile +from fractions import Fraction +from pathlib import Path + +import materialize as m +import reproduce + +EVIDENCE = m.PACKAGE / "evidence" + + +def validate(records, finite, bindings, materialized): + full, admission, release, native = records + m.need(full["status"] == "PASS_T740_R1_COMPLETE_RELEASE", "composition release") + m.need(admission["status"] == "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", "admission") + m.need(release["status"] == "PASS_RELEASE", "outer release") + m.need(full["fresh_retained_bootstrap"] is True, "fresh retained bootstrap") + m.need(full["admission_result_sha256"] == bindings["admission"], "admission binding") + m.need(full["release_receipt_sha256"] == admission["release_receipt_sha256"] == + bindings["release"], "release binding") + m.need(admission["native_receipt_sha256"] == bindings["native"], "native binding") + m.need(full["fill_sha256"] == admission["fill_sha256"], "full-run fill binding") + m.need(full["fill_payload_sha256"] == materialized["payload_sha256"], "literal fill payload") + m.need(admission["order_sha256"] == materialized["order_sha256"], "actual T740 order") + m.need(admission["dispatch_sha256"] == materialized["dispatch_sha256"], "actual T740 dispatch") + expected_source = m.read(m.PACKAGE / "vendor/pr3015/CLAIM.json")["source_manifest_sha256"] + m.need(admission["source_manifest_sha256"] == native["manifest_sha256"] == expected_source, + "exact R1 native source") + m.need(native["status"] == "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE" + and native["fresh_current_provider_count"] == 2, "two fresh native providers") + m.need(admission["replicas"] == 740, "admitted T740") + m.need({int(k): v for k, v in admission["profile"].items()} == m.PROFILE, + "complete composed invoice") + m.need(admission["package_manifest_sha256"] == release["manifest_sha256"], "released package") + endpoint = Fraction(full["kappa"]) + m.need(endpoint == Fraction(admission["kappa"]) == Fraction(release["kappa_decimal"]), + "same released endpoint") + outer = m.read(EVIDENCE / "OUTER-CLAIM.json") + m.need(endpoint == Fraction(outer["kappa_rational"]) == Fraction(outer["kappa"]), + "modern outer headline, separate from supplier-only claim") + previous = Fraction(m.read(m.PACKAGE / "vendor/PR3021-RESULT.json")["kappa"]) + m.need(previous < endpoint < Fraction(finite["moment"]["root"][0]), "strict valid gain") + baseline = Fraction(m.read(m.PACKAGE / "vendor/pr3015/CLAIM.json")["kappa"]) + m.need(Fraction(full["comparison_kappa"]) == baseline and + Fraction(full["gain"]) == endpoint - baseline, "exact source comparison") + stages = full["stages"] + m.need([s["stage"] for s in stages] == ["source-preflight", *reproduce.RECIPE_NAMES], + "complete fresh source recipe") + m.need(all(s["exit_code"] == 0 for s in stages), "successful source stages") + m.need(finite["physical"] == 663549 and finite["stock"]["buffers"] == 91, "physical bill") + + +def run(): + m.authenticate() + raw_invoice = gzip.decompress((EVIDENCE / "DISCOVERY-INVOICE.json.gz").read_bytes()) + m.need(hashlib.sha256(raw_invoice).hexdigest() == + m.read(EVIDENCE / "INVOICE-PAYLOAD.json")["decompressed_sha256"], "invoice payload") + invoice = json.loads(raw_invoice) + m.need((invoice["physical"], invoice["global_prefix_bits"], invoice["charged_prefix_bits"]) + == (663549, 1477, 2048), "actual complete prefix/physical invoice") + names = ["COMPOSITION-RESULT.json", "ADMISSION-RESULT.json", + "RELEASE-RECEIPT.json", "NATIVE-RECEIPT.json"] + records = [m.read(EVIDENCE / name) for name in names] + finite = m.read(EVIDENCE / "FINITE.json") + bindings = {"admission": m.digest(EVIDENCE / names[1]), + "release": m.digest(EVIDENCE / names[2]), + "native": m.digest(EVIDENCE / names[3])} + with tempfile.TemporaryDirectory(prefix="t740-input-audit-") as temporary: + materialized = m.build(Path(temporary)) + validate(records, finite, bindings, materialized) + for stage in records[0]["stages"]: + name = stage["stage"] + m.need(len(name) <= 64 and name.replace("-", "").isalnum(), "stage log name") + m.need(m.digest(EVIDENCE / "logs" / (name + ".log.txt")) == stage["log_sha256"], + "exact fresh stage log") + controls = [(1, "profile", {"1": 1}), (1, "order_sha256", "0" * 64), + (1, "dispatch_sha256", "0" * 64), (1, "fill_sha256", "0" * 64), + (2, "kappa_decimal", "1/100"), (3, "fresh_current_provider_count", 0)] + for index, field, wrong in controls: + changed = copy.deepcopy(records) + changed[index][field] = wrong + try: + validate(changed, finite, bindings, materialized) + except ValueError: + continue + raise ValueError("stored receipt mutant accepted: " + field) + previous = Fraction(m.read(m.PACKAGE / "vendor/PR3021-RESULT.json")["kappa"]) + return {"status": "PASS_PUBLISHED_T740_RELEASE_BINDINGS", "rejected_controls": 6, + "kappa": records[0]["kappa"], + "gain_over_pr3021": str(Fraction(records[0]["kappa"]) - previous), + "scope": "Rematerialized inputs and stored full-release relations; no new native replay."} + + +if __name__ == "__main__": + print(json.dumps(run(), indent=2, sort_keys=True)) From daac79539fd6b3b61083c38ad13475dd8d7e5605 Mon Sep 17 00:00:00 2001 From: dataisfire <340375426+dataisfire@users.noreply.github.com> Date: Fri, 16 Oct 2026 21:25:50 +0000 Subject: [PATCH 3/5] Prepare fully gated T148 carrier composition for complete CI replay --- .../workflows/t148-carrier-full-release.yml | 58 + research/t148-carrier-skips/.gitattributes | 2 + research/t148-carrier-skips/GIT-SOURCES.json | 50 + research/t148-carrier-skips/README.md | 107 + research/t148-carrier-skips/SOURCES.json | 846 +++++ research/t148-carrier-skips/TASK.json | 66 + research/t148-carrier-skips/VENDOR.json | 50 + research/t148-carrier-skips/VERIFY.json | 159 + research/t148-carrier-skips/ci_full.py | 56 + research/t148-carrier-skips/finalize.py | 31 + research/t148-carrier-skips/reproduce.py | 139 + research/t148-carrier-skips/seal.py | 86 + research/t148-carrier-skips/vendor/CREDITS.md | 18 + research/t148-carrier-skips/vendor/EDITS.json | 2984 +++++++++++++++++ research/t148-carrier-skips/vendor/NOTICE | 28 + .../vendor/PR3042-CLAIM.json | 229 ++ .../vendor/PR3042-MANIFEST.json | 156 + .../t148-carrier-skips/vendor/PROVIDERS.json | 842 +++++ .../vendor/WORD-base.json.gz | Bin 0 -> 72539 bytes .../vendor/WORD-extra.json.gz | Bin 0 -> 72538 bytes research/t148-carrier-skips/verify.py | 180 + 21 files changed, 6087 insertions(+) create mode 100644 .github/workflows/t148-carrier-full-release.yml create mode 100644 research/t148-carrier-skips/.gitattributes create mode 100644 research/t148-carrier-skips/GIT-SOURCES.json create mode 100644 research/t148-carrier-skips/README.md create mode 100644 research/t148-carrier-skips/SOURCES.json create mode 100644 research/t148-carrier-skips/TASK.json create mode 100644 research/t148-carrier-skips/VENDOR.json create mode 100644 research/t148-carrier-skips/VERIFY.json create mode 100644 research/t148-carrier-skips/ci_full.py create mode 100644 research/t148-carrier-skips/finalize.py create mode 100644 research/t148-carrier-skips/reproduce.py create mode 100644 research/t148-carrier-skips/seal.py create mode 100644 research/t148-carrier-skips/vendor/CREDITS.md create mode 100644 research/t148-carrier-skips/vendor/EDITS.json create mode 100644 research/t148-carrier-skips/vendor/NOTICE create mode 100644 research/t148-carrier-skips/vendor/PR3042-CLAIM.json create mode 100644 research/t148-carrier-skips/vendor/PR3042-MANIFEST.json create mode 100644 research/t148-carrier-skips/vendor/PROVIDERS.json create mode 100644 research/t148-carrier-skips/vendor/WORD-base.json.gz create mode 100644 research/t148-carrier-skips/vendor/WORD-extra.json.gz create mode 100644 research/t148-carrier-skips/verify.py diff --git a/.github/workflows/t148-carrier-full-release.yml b/.github/workflows/t148-carrier-full-release.yml new file mode 100644 index 0000000000..611900afe4 --- /dev/null +++ b/.github/workflows/t148-carrier-full-release.yml @@ -0,0 +1,58 @@ +name: T148 carrier complete verification +on: + push: + branches: [ci-t148-carrier-20261016] + paths: [.github/workflows/t148-carrier-full-release.yml] + workflow_dispatch: +permissions: + contents: read +jobs: + complete-release: + if: github.repository == 'dataisfire/integer-mult-bounds' + runs-on: ubuntu-24.04 + timeout-minutes: 150 + env: + PYTHONDONTWRITEBYTECODE: '1' + PYTHONINTMAXSTRDIGITS: '0' + OPENBLAS_NUM_THREADS: '1' + OMP_NUM_THREADS: '1' + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + fetch-depth: 0 + persist-credentials: false + sparse-checkout: | + .github + scripts + docs + certificates + research/rank7-joint-endframes + research/rank7-t740-release + research/rank7-t148-restore-release + research/two-sided-helper-extraction + research/t148-carrier-skips + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.12' + - name: Install exact scientific dependencies + run: python -m pip install numpy==1.26.4 scipy==1.15.3 sympy==1.14.0 mpmath==1.3.0 gmpy2==2.3.2 + - name: Fetch exact public source commits + run: | + python - <<'PY' + import json, re, subprocess + rows = json.load(open('research/t148-carrier-skips/GIT-SOURCES.json')) + heads = sorted({r['head'] for r in rows}) + assert all(re.fullmatch('[0-9a-f]{40}', h) for h in heads) + subprocess.run(['git','fetch','--no-tags','https://github.com/CrocSwap/integer-mult-bounds.git',*heads],check=True) + PY + - name: Run both complete releases without weakening any scientific check + run: python -B research/t148-carrier-skips/ci_full.py --work "$RUNNER_TEMP/t148-complete-verification" + - name: Registered finite replay after both completed releases + run: python -B scripts/research_package.py --package research/t148-carrier-skips + - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 + with: + name: verified-t148-carrier-package + path: research/t148-carrier-skips/ + retention-days: 7 + if-no-files-found: error + include-hidden-files: true diff --git a/research/t148-carrier-skips/.gitattributes b/research/t148-carrier-skips/.gitattributes new file mode 100644 index 0000000000..ae3dba0713 --- /dev/null +++ b/research/t148-carrier-skips/.gitattributes @@ -0,0 +1,2 @@ +** -text +** whitespace=cr-at-eol diff --git a/research/t148-carrier-skips/GIT-SOURCES.json b/research/t148-carrier-skips/GIT-SOURCES.json new file mode 100644 index 0000000000..23583426b6 --- /dev/null +++ b/research/t148-carrier-skips/GIT-SOURCES.json @@ -0,0 +1,50 @@ +[ + { + "head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "path": "research/rank7-joint-endframes-restore-edit" + }, + { + "head": "51309592971e3b5be935599eed2a95404dc7781e", + "path": "research/two-sided-helper-extraction" + }, + { + "head": "224bd5e56041c40078ff6b5fa7393733a215de5c", + "path": "research/paired-helper-extension" + }, + { + "head": "a027b0f6fdb0ab2b42ba10fc31b53960166bf2bf", + "path": "research/paired-extension-normal45" + }, + { + "head": "b74b25f3ccc84c16e1a801d73b2f47e5ea764c78", + "path": "research/paired-extension-cap-fill-swaps" + }, + { + "head": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "path": "research/paired-extension-normal45-rewrites" + }, + { + "head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "path": "research/paired-swap-normal45" + }, + { + "head": "18d03c447886895ef9abf888398178e0428533ca", + "path": "research/shared-kernel-packing" + }, + { + "head": "e9307b48d7d1b690939935ecef0f8e524e6d92f4", + "path": "research/gmx-t74-borrow43-handoff" + }, + { + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "path": "research/rank7-restore-carrier-skips" + }, + { + "head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "path": "research/rank7-t740-release" + }, + { + "head": "9d10633660a3dff5469f4e7a0a009a6c9994c0d7", + "path": "research/rank7-t148-restore-release" + } +] diff --git a/research/t148-carrier-skips/README.md b/research/t148-carrier-skips/README.md new file mode 100644 index 0000000000..9636c1d914 --- /dev/null +++ b/research/t148-carrier-skips/README.md @@ -0,0 +1,107 @@ +# T148 packing composed with PR3042 carrier skips + +**Full release pending.** The exact complete-moment nomination is + +```text +kappa = 0.001729737530919309734204 - 10^-46 - 10^-70. +``` + +Its exact gain over the full released point reported in +[PR3042](https://github.com/CrocSwap/integer-mult-bounds/pull/3042) is +`1364531393747392/10^24`, about `1.364531393747392e-9`. +This is a composition of credited constructions, not a new native-word +mechanism or selected-frontier update. No completed release is claimed yet. + +## Construction and complete bill + +Use Nick Petalas's released [PR3028](https://github.com/CrocSwap/integer-mult-bounds/pull/3028) +T148 allocation: the authenticated PR3018 journal, two interleaved T74 copies, +then the exact 86-row PR3022 journal. Keep every time, helper, owner, child, +port, offset, source window and dispatch. Its one rank-32 remainder is paid. + +Replace only the local word by dcharb78's PR3042 six carrier/pivot skips, head +`84cc406ad91ec53fff329a11a445d7effe564a77`. Both providers retain exactly the +same ordered helper widths, entrance/end frames, other scalar sections and +91 private buffers. An independently implemented rational replay checks the +complete restore map on all 704 columns. The unchanged inherited frame counter +and inverse-cleanup derivation check the literal new words and tariffs. + +Each call changes the R1 profile by `-10 H1 + 5 H2`. There are 1,332 calls and +543,456 actual helper roles. The complete profile is + +```text +{1:3275388, 2:948384, 3:318948, 4:143856, + 5:27416, 8:10656, 32:1, 48:56380}. +``` + +Its rank mass is `9,633,024`, deficit `47,360`, live stock `132,608` and complete +physical stock `133,117 = 132608 + 408 + 8 + 91 + 2`. The full emitted invoice +must independently rederive that stock and the prefix/row limits. The candidate +is below the source's fixed-inventory fractional cap; cap attainment is not +claimed. Choosing T148 gives one fifth of the T740 role count, with a smaller +verified nomination and the same categories of complete release checks. + +## Verification and source binding + +Every live source input and vendored word is pinned in `SOURCES.json` and +`VENDOR.json`. The finite verifier checks every literal owner role using the +unchanged published T148 geometry engine, the exact root and cap gap, actual +frame tariffs, all inverse cleanup and rejecting sign/price/endpoint controls. +It retains the arithmetic and geometry authors' credit; it is not a new +independent implementation of their engines. + +The full recipe requires a completed PR3030 baseline, rederives its completed +release and authenticates all stage logs before continuing. It then exports +the exact PR3042 package and runs its original source/native recipe. Only +complete-admission's `--fill`, `--order` and `--dispatch` arguments change. +Every original native, dirty-state, owner, physical, prefix, invoice, control +and modern-outer predicate remains unchanged. Both changed native providers +must run freshly. The unchanged retained bootstrap is explicitly authenticated +and reused. Both completed terminal receipts are mandatory for registered PASS. + +Python 3.12, standard library only, for registered finite verification after +the full release has been sealed: + +```sh +python3.12 -B scripts/research_package.py --package research/t148-carrier-skips +``` + +The full replay requires NumPy, SciPy, SymPy, mpmath and a native compiler, as +documented by the pinned predecessor recipes. Fetch the exact commits in +`GIT-SOURCES.json` into a full repository, then use fresh external workspaces: + +```sh +python3.12 -B research/rank7-t740-release/reproduce.py \ + --repo . --work /tmp/t740-baseline +python3.12 -B research/t148-carrier-skips/reproduce.py \ + --repo . --baseline-work /tmp/t740-baseline --work /tmp/t148-carrier-skips +``` + +`--math-only` on this package's verifier checks the finite construction but +explicitly does not certify a complete release. Raw local logs remain outside +the contribution. Publication evidence contains unchanged terminal receipts +and exact mathematical fields without personal paths, usernames or host data. + +## Credit and remaining hypotheses + +dataisfire, with substantial OpenAI Codex assistance. Apache-2.0. Credit +dcharb78/PR3042 for the six restore skips; Nick Petalas/PR3018/3022/3028 for the +T148 allocation and release machinery; Jeremy Kothe/PR3015 for R1 and the +declared-edit tooling; Marius-Paul Dumitrean/PR2979 for the joint rank-seven +words; and Mason Hale, Jeremy Diviney, Yiyang Lu, Tekalign, Ross Richardson, +Dugongue, icekylinx, themilkman216 and the retained native/owner/outer lineage. +Original notices are retained. No independent human or formal-kernel review +is claimed. + +Inherited all-size/compiler, arbitrary-dirty/native realization, physical +backing and movement, precision/tape, caller, analytic-transfer and universal +block-energy hypotheses remain. A finite release is not a complete +multiplication theorem. + +## Open next questions + +The larger T740 allocation has a better moment nomination but requires more +stock and substantially larger owner audits. A separately budgeted composition +must rederive its whole physical invoice and complete release; this T148 +receipt cannot certify it. Further native-word changes require their own +fully priced restoration and consumer contracts. See `TASK.json`. diff --git a/research/t148-carrier-skips/SOURCES.json b/research/t148-carrier-skips/SOURCES.json new file mode 100644 index 0000000000..98d488956b --- /dev/null +++ b/research/t148-carrier-skips/SOURCES.json @@ -0,0 +1,846 @@ +{ + "base_commit": "43f2f05fc9a610ad6b76b3d3f60441448f5e212b", + "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": "9544fee4e6ee1f202cee22bfaeaf229ee3b2515e", + "path": "research/rank7-joint-endframes/allocation/DISPATCH.json", + "sha256": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c", + "usage": "input" + }, + { + "git_blob": "8d4fd644d60ba2c98106dc770803b647afdf0963", + "path": "research/rank7-joint-endframes/allocation/FILL.json.gz", + "sha256": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "usage": "input" + }, + { + "git_blob": "7409c4df1092241729739596c7648bda504e6aad", + "path": "research/rank7-joint-endframes/allocation/ORDER.json", + "sha256": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1", + "usage": "input" + }, + { + "git_blob": "e1d99e12cfa3ac8375984d85c0b040dc36ea1312", + "path": "research/rank7-joint-endframes/allocation/PROVIDERS.json", + "sha256": "f2edb7922f3029a5d607437e737775ff3371bca49ebab62e5e2495d16d3bf573", + "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": "14de38f85eedf4a96500173576184a439348328c", + "path": "research/rank7-joint-endframes/certificates/RELAX-CAP.json", + "sha256": "b272680de5842f7fd5f442cd0aeadfd317fe6af266ddee1a1e0738a919ba856e", + "usage": "input" + }, + { + "git_blob": "d9aa96a93fea5f7395e7783aef0bc117c0a0ae89", + "path": "research/rank7-joint-endframes/data/WORD-base.json.gz", + "sha256": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "usage": "input" + }, + { + "git_blob": "74f6cb64595c21f7726ae77e69437868620bdcee", + "path": "research/rank7-joint-endframes/data/WORD-extra.json.gz", + "sha256": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7", + "usage": "input" + }, + { + "git_blob": "bd6dc2eb4e5013625d17cc08461b67622bcfed69", + "path": "research/rank7-joint-endframes/tools/root.py", + "sha256": "55f5aca39b5ee2fe4687ac8863e6c24569010f27a332883c069b8e14b8fe09e3", + "usage": "input" + }, + { + "git_blob": "8224873d0497cf0b4c202f31b145fa273553d978", + "path": "research/rank7-joint-endframes/vendor/audit_local.py", + "sha256": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "usage": "input" + }, + { + "git_blob": "55b435035bbc439a9d55e8abd125993208cef8d9", + "path": "research/rank7-joint-endframes/vendor/preload_move.py", + "sha256": "c8fda4674644fcd5cbf39b6645ce148a21daa90a998b678cbe51f970b78b0044", + "usage": "input" + }, + { + "git_blob": "fa1385d99a319b43c06f5309d1aae9fdd3adea46", + "path": "research/rank7-t148-restore-release/.gitattributes", + "sha256": "705fd4d6451a31d36b3df7de96f83f30ac976c9b4a6d1e51671d8e2f33e2d0da", + "usage": "input" + }, + { + "git_blob": "085fd64744eb3a79b263e247e4c08873d805f5f1", + "path": "research/rank7-t148-restore-release/GENERAL-CEILING.json", + "sha256": "9087580e41fa6c521bdda83b386c557b1ac460d652cff767c6d1531297f855fb", + "usage": "input" + }, + { + "git_blob": "8af566fde224df986d7207910d56f842c4a1c8f8", + "path": "research/rank7-t148-restore-release/README.md", + "sha256": "6e78aae177c65ef8d0ce7eb469ab97e4fc9f7d4248e7733d7508f05ec085693a", + "usage": "input" + }, + { + "git_blob": "bf3d015a381a8b15fed1cb945841a2f8bd2562e8", + "path": "research/rank7-t148-restore-release/SOURCES.json", + "sha256": "9cc50d0eb226f860de00847dd4e1dd43ea24c95b1e3a0ad1fd9784b849e37902", + "usage": "input" + }, + { + "git_blob": "855f4a31909755b3c391d640b4ead88cee390941", + "path": "research/rank7-t148-restore-release/TASK.json", + "sha256": "243c44d722428ecd69b425a03687abe643f5f013dadd7a40f4023340d3afe387", + "usage": "input" + }, + { + "git_blob": "00cec56e9caec49f30cee91ce6ee180ee6360657", + "path": "research/rank7-t148-restore-release/VENDOR.json", + "sha256": "a7b8b34e684575f013cda73e47d06f0da84b4f8cd70bae0195a1a4c9710ffe96", + "usage": "input" + }, + { + "git_blob": "1dea96c592f9139aa55033269b82a39421ad7d8a", + "path": "research/rank7-t148-restore-release/VERIFY.json", + "sha256": "fb462db7a76e3de545eadc0faf9f1ecf2a754921d7b566d4d51d21abe8ebf919", + "usage": "input" + }, + { + "git_blob": "6f006d0f51ed976ff858924057b17d8005fcc21a", + "path": "research/rank7-t148-restore-release/evidence/ADAPTER-DERIVATION.json", + "sha256": "1a8f041e55699aa53fb81c9af7988d92248fc7df97be8c62ec018d935c09a37f", + "usage": "input" + }, + { + "git_blob": "e859168f5cd0ad39d301a8c8896a52b17e07e7e3", + "path": "research/rank7-t148-restore-release/evidence/ADMISSION-RESULT.json", + "sha256": "c0c4273e72f439cd61c8b9a17f40f0183433b19e6984c8ac82c7efbddbe65d03", + "usage": "input" + }, + { + "git_blob": "3afb93074dcd111eb5abc5ece993dd12ec7bffad", + "path": "research/rank7-t148-restore-release/evidence/ADMISSION-STAGES.json", + "sha256": "8e5ae9d19388b51d8c042158611677f808fa8dd92679ae9b20488cb4dd80ff7e", + "usage": "input" + }, + { + "git_blob": "cdf8792aed1c556263b1ec076e6ed9d9efe01888", + "path": "research/rank7-t148-restore-release/evidence/ENVIRONMENT.json", + "sha256": "9b1636ecff86f202a2f3212061be30f197954e94115f5edb27dde4656b322832", + "usage": "input" + }, + { + "git_blob": "7b9ff88af5778fe5cde29e7c10ba21d0372204e0", + "path": "research/rank7-t148-restore-release/evidence/FINITE.json", + "sha256": "d0e8b8a335ae103a1f2c1e7bd0396758b87b9d4501954cb65a46da487717a604", + "usage": "input" + }, + { + "git_blob": "7dc77328098bf1e4873fc086ff33fbf8ab1f5461", + "path": "research/rank7-t148-restore-release/evidence/NATIVE-RECEIPT.json", + "sha256": "9f053b09b3184b952450c5a9a61077ef0732c7c180be60a7fde82eeaec0c1bab", + "usage": "input" + }, + { + "git_blob": "0a04b9a83d64209a7876faa2720632a213f25eb2", + "path": "research/rank7-t148-restore-release/evidence/OUTER-CLAIM.json", + "sha256": "70c6efb0230cac0166a263b6e3084c9a284de118001fca9cfb04ca9bc98c514e", + "usage": "input" + }, + { + "git_blob": "d3343deefb88419bdf73c6a14f785c5651bcca5a", + "path": "research/rank7-t148-restore-release/evidence/PREFIX-AND-INVOICE.json.gz", + "sha256": "fae5a805cdea557727de1045987bd02507994dc75fd362dbc14d5e37a8eafbcd", + "usage": "input" + }, + { + "git_blob": "c51562f820cdf761c464eddff85be68d69606ff2", + "path": "research/rank7-t148-restore-release/evidence/RECIPE.json", + "sha256": "1104f92d41e2ac8ac4104ea02792093b40acfd96a9bab65a477ae9b468d78b49", + "usage": "input" + }, + { + "git_blob": "f5ead542ad7c65ca67736f1caae644b5fe42e6d6", + "path": "research/rank7-t148-restore-release/evidence/RELEASE-RECEIPT.json", + "sha256": "279bcccd3644b08ce13ee9f5ae8040ad836a5765c23a4898b42b0a6bcec2255a", + "usage": "input" + }, + { + "git_blob": "e9b5bbe2514cab014333d0be80d1ce65731befed", + "path": "research/rank7-t148-restore-release/evidence/RESULT.json", + "sha256": "9e4af50ce76114851a967a151d4bad2a7099b55a2e69dd7ebf0ef141ce6c9904", + "usage": "input" + }, + { + "git_blob": "654a1223b42a9b5d6e4b8447be8b5bb73f46ab18", + "path": "research/rank7-t148-restore-release/evidence/VALIDATION.json", + "sha256": "c401c9cfa501cbd1d34ca959166b144d4a777b03a5ccc8543180ca8a42019cac", + "usage": "input" + }, + { + "git_blob": "3720b63d0dad54fd525c784f7c892156eb300d48", + "path": "research/rank7-t148-restore-release/evidence/VERIFY-RESULT.json", + "sha256": "b07789990699da47600f0a10884bc9efb74d37d0d85db944a9bd43eb1f3fe668", + "usage": "input" + }, + { + "git_blob": "ebb06169b430ee39c6b80406fa77a458c96bdca2", + "path": "research/rank7-t148-restore-release/evidence/VERIFY-STAGES.json", + "sha256": "12c7f0cb1d94683a41bb5097434bde7d5aac10eba07a31d1c49a5ce8a6449df4", + "usage": "input" + }, + { + "git_blob": "4dd4be5938bcd61c0377b34236950bb00698268b", + "path": "research/rank7-t148-restore-release/evidence/logs/complete-admission.log.txt", + "sha256": "284191bb321ec8a14e2fd25d0d522e76957828ec50313ff374dba636ce65f762", + "usage": "input" + }, + { + "git_blob": "99ee5533b2c53b56764b0c0f994cbb580266d571", + "path": "research/rank7-t148-restore-release/evidence/logs/declared-edit-stage.log.txt", + "sha256": "3ad47363c45012cd4f09aee995e551a314b89da7fb70310cabc437cf78957097", + "usage": "input" + }, + { + "git_blob": "09cdb8c2913704282e4c8fbbf23f88afb9edb134", + "path": "research/rank7-t148-restore-release/evidence/logs/derive-closed-adapters.log.txt", + "sha256": "ee4dbc4d3602d2f45ebca2ffadae889ff0bb2497e2a576530126858f6eca4bd2", + "usage": "input" + }, + { + "git_blob": "c2ff3dfb960cfe16a627e1b2b9c70e9e90180634", + "path": "research/rank7-t148-restore-release/evidence/logs/export-pr2833.log.txt", + "sha256": "8d8ca31360aaba9440d9555bcd2f69293f186d3e2e505bf3af35b67a29046fd5", + "usage": "input" + }, + { + "git_blob": "2bed900376db47d928ffe64835940c728d3e4094", + "path": "research/rank7-t148-restore-release/evidence/logs/export-pr2894.log.txt", + "sha256": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "usage": "input" + }, + { + "git_blob": "257be58c74eb0f54ee80f34af65e64e9f201935a", + "path": "research/rank7-t148-restore-release/evidence/logs/four-kernel-stage.log.txt", + "sha256": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "usage": "input" + }, + { + "git_blob": "820460ef57351ee8e921a122c460254594e0c05c", + "path": "research/rank7-t148-restore-release/evidence/logs/fresh-current-native.log.txt", + "sha256": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "usage": "input" + }, + { + "git_blob": "9308a84963a6bf0ebcf3e0343c2bc92655d8e3c0", + "path": "research/rank7-t148-restore-release/evidence/logs/fresh-retained-bootstrap.log.txt", + "sha256": "4a1625fdd9a947187583e67492c492f309e28669082f2e6f2aa97b5da345ea29", + "usage": "input" + }, + { + "git_blob": "9ca3a425215401648870f3f65397a683c028abfb", + "path": "research/rank7-t148-restore-release/evidence/logs/paired-extension-stage.log.txt", + "sha256": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "usage": "input" + }, + { + "git_blob": "de80347a9094a0741e644d36c1f75487fa664424", + "path": "research/rank7-t148-restore-release/evidence/logs/parent-paired-stage.log.txt", + "sha256": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "usage": "input" + }, + { + "git_blob": "4fa79b5e482d644cbe1d2c882dbc3296d367db9b", + "path": "research/rank7-t148-restore-release/evidence/logs/preload-stage.log.txt", + "sha256": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "usage": "input" + }, + { + "git_blob": "d058b55c96bf06d7e9f888559ef27df5417f354d", + "path": "research/rank7-t148-restore-release/evidence/logs/rank7-overlay-stage.log.txt", + "sha256": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "usage": "input" + }, + { + "git_blob": "fbfbb199ad9e24fd5586d200dec7689393a1d7a9", + "path": "research/rank7-t148-restore-release/evidence/logs/source-preflight.log.txt", + "sha256": "33398f425eb773647292f653df20b6bec51ab4a6ea56e9a3ee71a47978deef98", + "usage": "input" + }, + { + "git_blob": "bbe567e6497f3369c6fd37d927be47cb63df82bc", + "path": "research/rank7-t148-restore-release/reproduce.py", + "sha256": "dc234b5f5e7af0e11f88d3836346e6d33dad2f1b3021c89b9a311e3511df9ba0", + "usage": "input" + }, + { + "git_blob": "8ee89e667a2498fac5c96e91d8e1bc814d0e91c3", + "path": "research/rank7-t148-restore-release/test_verify.py", + "sha256": "7145eb8716a831b36552222fb0a85fe1791fa896963f0417cc27bced41bbd14d", + "usage": "input" + }, + { + "git_blob": "1260c8d95f573a574e007038263adf883b5ecbd2", + "path": "research/rank7-t148-restore-release/vendor/PR3018-EXCHANGE.json", + "sha256": "8a103f643ad12d8074972f41e4359d9487eb8b96fc6849e1a178adb61b36578b", + "usage": "input" + }, + { + "git_blob": "399bcc26f0684cced978e3a4c90f834551f62dd7", + "path": "research/rank7-t148-restore-release/vendor/PR3021-RESULT.json", + "sha256": "cdc4874dcb17714fbe10f003a4a4516b80a9ddccfc7199278a53baa13c5d3a04", + "usage": "input" + }, + { + "git_blob": "5370296a7c5b0966e40e461f37f7e4eadd94e4b4", + "path": "research/rank7-t148-restore-release/vendor/PR3022-EXCHANGE.json", + "sha256": "8f6e53068fe91885ab3121da1eeaf8ff49a5c918dcea61e07457d33701fe7ed3", + "usage": "input" + }, + { + "git_blob": "59c0e6cc7771152961fac29acf7b79851b1f068b", + "path": "research/rank7-t148-restore-release/vendor/PR3022-RESULT.json", + "sha256": "77780197928a9b52a6c0abce023011974692ce5cd96eca3360f9cddc16c0b2e9", + "usage": "input" + }, + { + "git_blob": "c1f1771327703a307f7681c28ad02192406c7837", + "path": "research/rank7-t148-restore-release/vendor/geometry.py", + "sha256": "fddefb9d4555d1b0d89766d29e6a320ccb38ba0b2a24a7df0f34a9a4545ab8f2", + "usage": "input" + }, + { + "git_blob": "939427c5158efe99c91455a3204d62dc33ee2b2b", + "path": "research/rank7-t148-restore-release/vendor/moment.py", + "sha256": "339b52eb637add91264347797d4b49cef1a412fd3843bf736cc5bb74c6bdce7c", + "usage": "input" + }, + { + "git_blob": "70813f559e2878f0c5403c0b859eefe602f70abc", + "path": "research/rank7-t148-restore-release/vendor/pr3015/CLAIM.json", + "sha256": "f9b9fbaaac794c0ce279c238a33a2f34f8c91a34d97ccdeb5ec98b7b8ba56d73", + "usage": "input" + }, + { + "git_blob": "3b6022cd64d7753e65e1c710d91a69596e389042", + "path": "research/rank7-t148-restore-release/vendor/pr3015/CREDITS.md", + "sha256": "bd4b09fcd2861933883cbce6ecf0e30743d5d3b4cb0cc38e258530c370c121b9", + "usage": "input" + }, + { + "git_blob": "4f0483657396a7f735873e1b252482c53dfb2eb6", + "path": "research/rank7-t148-restore-release/vendor/pr3015/FINAL-WORD-base.json.gz", + "sha256": "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5", + "usage": "input" + }, + { + "git_blob": "81f95e21ede115e8bdb6bd522c641b37b740bdf7", + "path": "research/rank7-t148-restore-release/vendor/pr3015/FINAL-WORD-extra.json.gz", + "sha256": "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea", + "usage": "input" + }, + { + "git_blob": "a331a50f94b698f02092d4647c8be5385d9dd57c", + "path": "research/rank7-t148-restore-release/vendor/pr3015/MANIFEST.json", + "sha256": "5e113822c0c36ee7dd9366578fbaf5daa108b8c51e37f4d10eda25dd6ed52cae", + "usage": "input" + }, + { + "git_blob": "70a09b472e3c2d82b3e805d82ef898d3ad48e758", + "path": "research/rank7-t148-restore-release/vendor/pr3015/NOTICE", + "sha256": "ffcc3de2243815db0e9fb8d820b4ca511fce3c7673c966e14b486f05d30ac11a", + "usage": "input" + }, + { + "git_blob": "cac6220d3dcb1d323e083d6ff04bc7bc0f00eba9", + "path": "research/rank7-t148-restore-release/vendor/pr3015/PROVIDERS.json", + "sha256": "f52d926752eac5d847092dd58bfb9f3f3c6ac36adf39cd6a3c4d4a3b2d1fce15", + "usage": "input" + }, + { + "git_blob": "41ec3a5f037dd64daade435a4c02468ecbdae524", + "path": "research/rank7-t148-restore-release/vendor/pr3015/RELAX-CAP.json", + "sha256": "6380d23931bfcdf4bd2684dd19bb60db543f570bc88873f5effd53387beb28b0", + "usage": "input" + }, + { + "git_blob": "f8f295f6cf377559ae59c6e40972b635b5ce2f21", + "path": "research/rank7-t148-restore-release/vendor/release_driver.py", + "sha256": "8dffca928c1ad1a36423b18a33a3f591af0e46bb3482e0e1cf127ddb613ef11b", + "usage": "input" + }, + { + "git_blob": "64eccfb08ba13f49984a2c936934c14ea0763744", + "path": "research/rank7-t148-restore-release/verify.py", + "sha256": "5b28450721edc925d274a88bb597bdf5814f1ae7e2c009106fccc2daa91b7ccc", + "usage": "input" + }, + { + "git_blob": "cd004de6e92600ab45e259a9ec51960bf7074df5", + "path": "research/rank7-t148-restore-release/verify_release.py", + "sha256": "e1454b3e03cf1f09ea386e75a9913b5d8906b9e50e7c8938e2db9eae5b126994", + "usage": "input" + }, + { + "git_blob": "009a4747f717b71c88321b786027a5766cf51c76", + "path": "research/rank7-t740-release/.gitattributes", + "sha256": "5bf0e0ffcadbc7665285c27a72de32b52771116703f061e57fff3a3fb28fe998", + "usage": "input" + }, + { + "git_blob": "f92fb024492e6114e6414923869717c19bb16cd4", + "path": "research/rank7-t740-release/ENGINEERING.md", + "sha256": "47403048fa91deb652a2213dab09498b397c154e49ebbb6f244aeb6126759532", + "usage": "input" + }, + { + "git_blob": "c0df1d757ca28eb8a1bc1ec863d0acdf64863095", + "path": "research/rank7-t740-release/GIT-SOURCES.json", + "sha256": "b4180ba7d5300093160538c0854227de19260035902f696d0e8fbe51b91488be", + "usage": "input" + }, + { + "git_blob": "61098b716fb46429130c19163d59acc5b67d2250", + "path": "research/rank7-t740-release/PINS.json", + "sha256": "a8b34c437e301e7220fbf56582a785b0f0afc52976ba37e6da29e635631653fc", + "usage": "input" + }, + { + "git_blob": "458c85908505c1531166510b4cae4b9245605eea", + "path": "research/rank7-t740-release/README.md", + "sha256": "7fa460b1b63ab60cd430a1dfd44a4703c5153a077e31af7bd258d60f381bc338", + "usage": "input" + }, + { + "git_blob": "c21259dcb9ad285b4e2c9e02b3a04b92c15c78c2", + "path": "research/rank7-t740-release/SOURCES.json", + "sha256": "94c941a2e067e83253b15c5e0bea7b5d4316e97dd1766108a05af174614b8551", + "usage": "input" + }, + { + "git_blob": "b2005d587f3cbef4603850af158d59d01b40963b", + "path": "research/rank7-t740-release/TASK.json", + "sha256": "d4287d1512908ceb87b5eb5920ef4f93d7b39e1f04e7d4872c8d43245f40cfdf", + "usage": "input" + }, + { + "git_blob": "65bf1d7f9344ef9710716071d6845c0be39a9154", + "path": "research/rank7-t740-release/VENDOR.json", + "sha256": "a75ab6e08a4901b8ea1060d38fbeef9e3670cb3ffe9515ed449cbf313572f181", + "usage": "input" + }, + { + "git_blob": "2558ffdd17340b3d390d3a66c10d728eb3129cca", + "path": "research/rank7-t740-release/VERIFY.json", + "sha256": "c7a94bcfa7b8af930c85227aa41824d9cdca012e555d9c971fdb994b6419a2de", + "usage": "input" + }, + { + "git_blob": "95ce556d35083e3bcec224ad384edc47cc46dcc8", + "path": "research/rank7-t740-release/decisions.tsv", + "sha256": "15ee79b282e4d6127c8d3a9166adb7dd9d595ecb776b1bef9ee2887730003d44", + "usage": "input" + }, + { + "git_blob": "b86fa9595c751d5ffc686bbacc71f77bd0cbab44", + "path": "research/rank7-t740-release/evidence/ADAPTER-DERIVATION.json", + "sha256": "3a42ab1a4d16917ab3945edcdaec89a8643678cb02524fc73a5001f6b6d9a565", + "usage": "input" + }, + { + "git_blob": "196cdb8101fcd450559e058077e67f8d380f2774", + "path": "research/rank7-t740-release/evidence/ADMISSION-RESULT.json", + "sha256": "ec0f1803321a6f52447945f3bb951f3a484b6e8bc5b36f5e03bcd2d9452ac18f", + "usage": "input" + }, + { + "git_blob": "41d1793d20890ef24ee03630a08dc20ba9d685ae", + "path": "research/rank7-t740-release/evidence/ADMISSION-STAGES.json", + "sha256": "b63f9dcd1af53de9fad5f456498b206dfeda104a45e32c370e36a1c723141b91", + "usage": "input" + }, + { + "git_blob": "f64b47abe023f54b68c59900d76ef728aff4f442", + "path": "research/rank7-t740-release/evidence/BINDINGS.json", + "sha256": "9d1c47ca4943e3bbd01fee2a671311361b932bf51e9b9e8013301581f090fa3c", + "usage": "input" + }, + { + "git_blob": "f64b47abe023f54b68c59900d76ef728aff4f442", + "path": "research/rank7-t740-release/evidence/BINDINGS.log.txt", + "sha256": "9d1c47ca4943e3bbd01fee2a671311361b932bf51e9b9e8013301581f090fa3c", + "usage": "input" + }, + { + "git_blob": "f07e56219afa4a08f433c3d0a722b3913bab42e4", + "path": "research/rank7-t740-release/evidence/COMPOSITION-RESULT.json", + "sha256": "0761f6ab97897ed83595281226660a4effab9a2e01992048d09917551ee6ec85", + "usage": "input" + }, + { + "git_blob": "359123f5d0576d0ec45bdf52e0586482ff186ddd", + "path": "research/rank7-t740-release/evidence/DISCOVERY-AUDIT.json", + "sha256": "32c4d27226099f5d9e0b809f87d122f841b0f2a8d830f533e232491bf2dc622f", + "usage": "input" + }, + { + "git_blob": "d8c6364feea0fc4476ef5fda47619a182030675e", + "path": "research/rank7-t740-release/evidence/DISCOVERY-INVOICE.json.gz", + "sha256": "d65530abcd7c8a8837d26b2a418293981b7b308c7f20c29e7aaa65e106299250", + "usage": "input" + }, + { + "git_blob": "00fbf5d926823e05768873dd2f705dc2018c6552", + "path": "research/rank7-t740-release/evidence/DISCOVERY-RESULT.json", + "sha256": "62ac236ae2938a6c59e9f1c860b6cc10cd6bfdb51c747d3406caa1dbb1f03da5", + "usage": "input" + }, + { + "git_blob": "2e21be92855ade485dccbbc476f1e34ccce2b4f5", + "path": "research/rank7-t740-release/evidence/DISCOVERY-STAGES.json", + "sha256": "7c20492627fc5489a23eb25fbc6a4299823705cb94c44295325cb64e5d24494e", + "usage": "input" + }, + { + "git_blob": "20aa647f515595ef7edc514cf121e80fb4b56f23", + "path": "research/rank7-t740-release/evidence/ENVIRONMENT.json", + "sha256": "179fe4e422f4556702c37a19f4ef23f75dc069aafb0cdd22369ce6ecdd4a0b1b", + "usage": "input" + }, + { + "git_blob": "0ddf2aba4629c09810b336ce92e4dbfc35fca9fa", + "path": "research/rank7-t740-release/evidence/FINITE.json", + "sha256": "00ee90400fa3f35b19a12b89e4d2a2754a02832d4800351657970dc18042b406", + "usage": "input" + }, + { + "git_blob": "507d21fe45f8ce29f2485850d5e6be4067f10e5a", + "path": "research/rank7-t740-release/evidence/INITIAL-BOOTSTRAP-FAILURE.log.txt", + "sha256": "1ff9392125d4b103fac45685cdf927d4050abc925f282aabbaffdf5569183c8f", + "usage": "input" + }, + { + "git_blob": "a69e33a9d0e1a3e6305599b9bb441d9e86e29003", + "path": "research/rank7-t740-release/evidence/INVOICE-PAYLOAD.json", + "sha256": "379b7c810943a9a31dbfb4b4b93b6be405d843fb02f226d21f2946ac501d301e", + "usage": "input" + }, + { + "git_blob": "f45ffdf06751c07651ae44c530aed9158e0050d6", + "path": "research/rank7-t740-release/evidence/MATERIALIZED.json", + "sha256": "b6269af21561e4dd0827c9fb6ee4dbda1734857c12d1a16421c6e1bf76c38c5f", + "usage": "input" + }, + { + "git_blob": "dbd8236ea7ff610d090c5be220d011ecfe3ae880", + "path": "research/rank7-t740-release/evidence/NATIVE-ENVIRONMENT.json", + "sha256": "897135d7418de2f14ee3c39c59b1f8dbec78dddb988b0f8803e98e77554cb63b", + "usage": "input" + }, + { + "git_blob": "b19ee781949d7f4f33a7c3f9160d2e4850bb0a89", + "path": "research/rank7-t740-release/evidence/NATIVE-RECEIPT.json", + "sha256": "c80cb6e9283e746c5d24aa2590e3a22f566929cd16ac7b00431dae2b1da6c859", + "usage": "input" + }, + { + "git_blob": "5c8a5340af831d99c7b1fe67e0bbf4d3427cc170", + "path": "research/rank7-t740-release/evidence/OUTER-CLAIM.json", + "sha256": "f670e3efe5d99954c1e033dce3921630620b31c536a9c7ea17066dc53b20680d", + "usage": "input" + }, + { + "git_blob": "c8dc460799ee260d3d4430c3e8079702206e7f97", + "path": "research/rank7-t740-release/evidence/OWNERS-RESULT.json", + "sha256": "fd17af9e625b75390771e73b96eea0179601c7ddcc0a2dd347cfed80dec0f0f3", + "usage": "input" + }, + { + "git_blob": "8137787ff5c375626ed2e8245e9a4e0447d91a23", + "path": "research/rank7-t740-release/evidence/RECIPE.json", + "sha256": "5cc831fcbbafdddfdaa5f70816bc97364c81d948f4564b557cb6758aa812e638", + "usage": "input" + }, + { + "git_blob": "8677dd63e0168e62a57995379436cf8b4d170f20", + "path": "research/rank7-t740-release/evidence/RELEASE-RECEIPT.json", + "sha256": "63a9834db9a0bcc5b6f6303e167d6806b1ed9633d0aa21c98313c9dad48dcbe5", + "usage": "input" + }, + { + "git_blob": "0d3973f83203a3f3244f2336726eafa0b304726d", + "path": "research/rank7-t740-release/evidence/STAGES.json", + "sha256": "4ca1f6cc9932e561c4a85dbbece979841c7c775b834b4c27f5f2a853d4b26b1f", + "usage": "input" + }, + { + "git_blob": "eed96ada8aebe86216f0be412abd2ff39e7a542b", + "path": "research/rank7-t740-release/evidence/logs/complete-admission.log.txt", + "sha256": "241b0a8de2593e66706e8fb6b7881e9abbe884c1bbf1386efc0ccc95a84399e1", + "usage": "input" + }, + { + "git_blob": "99ee5533b2c53b56764b0c0f994cbb580266d571", + "path": "research/rank7-t740-release/evidence/logs/declared-edit-stage.log.txt", + "sha256": "3ad47363c45012cd4f09aee995e551a314b89da7fb70310cabc437cf78957097", + "usage": "input" + }, + { + "git_blob": "6c33d73563169ce887efb6ee1f60083f2fdb13a5", + "path": "research/rank7-t740-release/evidence/logs/derive-closed-adapters.log.txt", + "sha256": "4752f54354db20b74d96ba359666482d69747e61ea9e6284566d38def65b91cf", + "usage": "input" + }, + { + "git_blob": "a7aef07d0c7fd1b3e1374ff32e9e2e7f8fccf76d", + "path": "research/rank7-t740-release/evidence/logs/export-pr2833.log.txt", + "sha256": "50be5082e2ceba2d668fb61d17451e0f7e0d98a6bd2dd20f778eb7c48c9c0e18", + "usage": "input" + }, + { + "git_blob": "2bed900376db47d928ffe64835940c728d3e4094", + "path": "research/rank7-t740-release/evidence/logs/export-pr2894.log.txt", + "sha256": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "usage": "input" + }, + { + "git_blob": "257be58c74eb0f54ee80f34af65e64e9f201935a", + "path": "research/rank7-t740-release/evidence/logs/four-kernel-stage.log.txt", + "sha256": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "usage": "input" + }, + { + "git_blob": "820460ef57351ee8e921a122c460254594e0c05c", + "path": "research/rank7-t740-release/evidence/logs/fresh-current-native.log.txt", + "sha256": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "usage": "input" + }, + { + "git_blob": "9308a84963a6bf0ebcf3e0343c2bc92655d8e3c0", + "path": "research/rank7-t740-release/evidence/logs/fresh-retained-bootstrap.log.txt", + "sha256": "4a1625fdd9a947187583e67492c492f309e28669082f2e6f2aa97b5da345ea29", + "usage": "input" + }, + { + "git_blob": "9ca3a425215401648870f3f65397a683c028abfb", + "path": "research/rank7-t740-release/evidence/logs/paired-extension-stage.log.txt", + "sha256": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "usage": "input" + }, + { + "git_blob": "de80347a9094a0741e644d36c1f75487fa664424", + "path": "research/rank7-t740-release/evidence/logs/parent-paired-stage.log.txt", + "sha256": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "usage": "input" + }, + { + "git_blob": "4fa79b5e482d644cbe1d2c882dbc3296d367db9b", + "path": "research/rank7-t740-release/evidence/logs/preload-stage.log.txt", + "sha256": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "usage": "input" + }, + { + "git_blob": "d058b55c96bf06d7e9f888559ef27df5417f354d", + "path": "research/rank7-t740-release/evidence/logs/rank7-overlay-stage.log.txt", + "sha256": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "usage": "input" + }, + { + "git_blob": "fbfbb199ad9e24fd5586d200dec7689393a1d7a9", + "path": "research/rank7-t740-release/evidence/logs/source-preflight.log.txt", + "sha256": "33398f425eb773647292f653df20b6bec51ab4a6ea56e9a3ee71a47978deef98", + "usage": "input" + }, + { + "git_blob": "bf9b5a72036bf1b0b19b7d8c019b2dea97f5ddec", + "path": "research/rank7-t740-release/evidence/optimized_tests.log.txt", + "sha256": "11f1a60a1843440af7db37bcae6b03b8cff8bb6160584def92c4c3e45adda342", + "usage": "input" + }, + { + "git_blob": "008d6d48c94888441f416def01aadeb2a90d2bdf", + "path": "research/rank7-t740-release/evidence/registered.log.txt", + "sha256": "32a1bd9512f2c38c6323a10414d4e5c6ef140f03d639b05fc0a98037380ae603", + "usage": "input" + }, + { + "git_blob": "1962971fb55d54e4853263f9fd0c0479d3f9307a", + "path": "research/rank7-t740-release/evidence/registered_finite.log.txt", + "sha256": "11e81db5ca33c7cb5607b11fbff57f5266080421da2f523cbfcc388b12554c21", + "usage": "input" + }, + { + "git_blob": "164ca8e92bface70a582bb9007957636508c8ce5", + "path": "research/rank7-t740-release/evidence/tests.log.txt", + "sha256": "bababdbf75e924260f9e3bddc462d6970ce7614694c5e4f0c4fac450a140da0c", + "usage": "input" + }, + { + "git_blob": "e2a4980bf24d996ea4ba4a323b5038bce77721f8", + "path": "research/rank7-t740-release/materialize.py", + "sha256": "eaa2413c45b9f48d1c0a581ff7e3ceca839ad8f6ac1c51be908da4911200d2c6", + "usage": "input" + }, + { + "git_blob": "d86cfc77c9c129e82d61d1253c5a537a39fe0dbe", + "path": "research/rank7-t740-release/reproduce.py", + "sha256": "c4014e75e518e992d18b8d8fc1d3d40f65164c93847a259da0b1c110dc6d0e6b", + "usage": "input" + }, + { + "git_blob": "4f36714b085f96040f8e648d6344a1f16d48702d", + "path": "research/rank7-t740-release/test_verify.py", + "sha256": "9589cae04c06b9bf1e92facadec6615a93e115f1f29fd309df4a9bad892fafd4", + "usage": "input" + }, + { + "git_blob": "399bcc26f0684cced978e3a4c90f834551f62dd7", + "path": "research/rank7-t740-release/vendor/PR3021-RESULT.json", + "sha256": "cdc4874dcb17714fbe10f003a4a4516b80a9ddccfc7199278a53baa13c5d3a04", + "usage": "input" + }, + { + "git_blob": "70813f559e2878f0c5403c0b859eefe602f70abc", + "path": "research/rank7-t740-release/vendor/pr3015/CLAIM.json", + "sha256": "f9b9fbaaac794c0ce279c238a33a2f34f8c91a34d97ccdeb5ec98b7b8ba56d73", + "usage": "input" + }, + { + "git_blob": "3b6022cd64d7753e65e1c710d91a69596e389042", + "path": "research/rank7-t740-release/vendor/pr3015/CREDITS.md", + "sha256": "bd4b09fcd2861933883cbce6ecf0e30743d5d3b4cb0cc38e258530c370c121b9", + "usage": "input" + }, + { + "git_blob": "a331a50f94b698f02092d4647c8be5385d9dd57c", + "path": "research/rank7-t740-release/vendor/pr3015/MANIFEST.json", + "sha256": "5e113822c0c36ee7dd9366578fbaf5daa108b8c51e37f4d10eda25dd6ed52cae", + "usage": "input" + }, + { + "git_blob": "70a09b472e3c2d82b3e805d82ef898d3ad48e758", + "path": "research/rank7-t740-release/vendor/pr3015/NOTICE", + "sha256": "ffcc3de2243815db0e9fb8d820b4ca511fce3c7673c966e14b486f05d30ac11a", + "usage": "input" + }, + { + "git_blob": "cac6220d3dcb1d323e083d6ff04bc7bc0f00eba9", + "path": "research/rank7-t740-release/vendor/pr3015/allocation/PROVIDERS.json", + "sha256": "f52d926752eac5d847092dd58bfb9f3f3c6ac36adf39cd6a3c4d4a3b2d1fce15", + "usage": "input" + }, + { + "git_blob": "90894fc6592951eaa3b4e25467d3a85c36b2d988", + "path": "research/rank7-t740-release/vendor/pr3015/edits/EDITS.json", + "sha256": "c9c68660d07bfd12ed20fd8cbfe3d36301ceb2d7bb9b4ea11350cc399b19e0b1", + "usage": "input" + }, + { + "git_blob": "4f0483657396a7f735873e1b252482c53dfb2eb6", + "path": "research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-base.json.gz", + "sha256": "77d9be7ac47347894e034d8b67bf07ff8a5e1c317923ed5dd9257c492187dcf5", + "usage": "input" + }, + { + "git_blob": "81f95e21ede115e8bdb6bd522c641b37b740bdf7", + "path": "research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-extra.json.gz", + "sha256": "18d9c448ce892aa19f162e214760d0bd4ecb09f814b9b859dbf11f3ca637e9ea", + "usage": "input" + }, + { + "git_blob": "1260c8d95f573a574e007038263adf883b5ecbd2", + "path": "research/rank7-t740-release/vendor/pr3018/EXCHANGE.json", + "sha256": "8a103f643ad12d8074972f41e4359d9487eb8b96fc6849e1a178adb61b36578b", + "usage": "input" + }, + { + "git_blob": "6f73992ff764a3d527d4fd551057dc6fa254127e", + "path": "research/rank7-t740-release/vendor/pr3021-FINITE.json", + "sha256": "f7f6aca1e2596d7049ff2bc69c523013324f568f86fd31b1f29899b96b2617eb", + "usage": "input" + }, + { + "git_blob": "f8f295f6cf377559ae59c6e40972b635b5ce2f21", + "path": "research/rank7-t740-release/vendor/pr3021/reproduce.py", + "sha256": "8dffca928c1ad1a36423b18a33a3f591af0e46bb3482e0e1cf127ddb613ef11b", + "usage": "input" + }, + { + "git_blob": "84902a90d268579f4110cbb298375365d8121021", + "path": "research/rank7-t740-release/vendor/pr3021/verify.py", + "sha256": "dac43246695dfc618ffc49866c1c2e1ba08bc7fd7d2deec2b6aa6b9c292d9cf3", + "usage": "input" + }, + { + "git_blob": "1b1a904ff05e848bfb2793597b9613cc997c3367", + "path": "research/rank7-t740-release/vendor/pr3024/EXCHANGE.json", + "sha256": "18b3af92dab108945fa7033a2476a8521416b403415a31cdbbe2d1315bb1c827", + "usage": "input" + }, + { + "git_blob": "28f0995a69fbb003238f5ee8d1acf407bb1b37be", + "path": "research/rank7-t740-release/vendor/pr3024/cap_proof.py", + "sha256": "7c5f362ed21dbbdbd6a0632aebef424213a37c47c86151a0520d097e8f4e321f", + "usage": "input" + }, + { + "git_blob": "717067dfce61c530205e8dad7ab3e76376f2c179", + "path": "research/rank7-t740-release/vendor/pr3024/lift.py", + "sha256": "ae6c1fee78fbdec26976ca74ca89f6aab2528d763c596f6573132cb54d57cd3c", + "usage": "input" + }, + { + "git_blob": "af625bca18a00a0fbacf76ff15ac2ae6b7563e32", + "path": "research/rank7-t740-release/verify.py", + "sha256": "6cbbcf1aa90f22baeb1b71cb3ad387c58755d80090e2aef5a748f84365320916", + "usage": "input" + }, + { + "git_blob": "c81d940c04e87f9fc6cdca0f0ddaeef6e42410c9", + "path": "research/rank7-t740-release/verify_release.py", + "sha256": "58a546b8ddc444247f0c4326b93cff652a1d1317edf6a1e34d68531b07cf945a", + "usage": "input" + }, + { + "git_blob": "dbc974a289a2060dc1f28bcd31414af7a2631d3c", + "path": "research/two-sided-helper-extraction/tools/admit_channel408.py", + "sha256": "a62c21eac4e0df502cbfb78c88b19a763fd351cde3c11c0588874f84db6992bf", + "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/t148-carrier-skips/TASK.json b/research/t148-carrier-skips/TASK.json new file mode 100644 index 0000000000..24dc059e98 --- /dev/null +++ b/research/t148-carrier-skips/TASK.json @@ -0,0 +1,66 @@ +{ + "actual_scope": "Compose the published T148 packing with PR3042 six carrier skips; keep the completed PR3030 baseline gate and every original full source/native/admission/outer check.", + "ai_assistance": "Substantial OpenAI Codex assistance; no independent human or formal-kernel review claimed.", + "author": "dataisfire", + "base_commit": "43f2f05fc9a610ad6b76b3d3f60441448f5e212b", + "bottleneck_link": "The source has unchanged packing patterns but its T74 fill is below its exact fractional cap. The released T148 literal fill strictly improves the T74 fill while retaining a positive gap to that cap with every larger-stock and prefix cost charged.", + "budget_minutes": 150, + "evidence": "704-column restore equality and exact moment candidate; full owner and release verification pending.", + "open_questions": [ + { + "blocked_by": "All inherited all-size/compiler, physical, precision/tape, caller and analytic obligations remain.", + "first_step": "Change one explicit native restoration contract and price the complete replacement.", + "question": "Can a further changed word improve the paid inventory?", + "why_it_matters": "The fixed-inventory cap is attained by this composition." + } + ], + "original_card": { + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "first_experiment": "Prioritize a bounded independent audit of #2979: reconstruct one joint group and its single-lowering control, check the declared frames/chronology, then trace changed children, idle widths and cleanup buffers into the complete invoice and both supplier caps. Choose one still-missing implication after checking existing audits. Stop with exact unresolved dependencies if full admission exceeds the session; do not launch a new lowering census on an unvalidated premise or substitute extra root digits for mechanism checking.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2979 joint rank-7 end-frame proposal and the revision-6 evidence status. Its claimed kappa is not selected. Compare coordinated changes with the losing single-change controls and locate the complete physical ledger; an aggregate moment alone does not validate the mechanism.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "id": "independent-moment", + "methods": [ + "Independently reconstruct a coordinated frame/circuit change and its single-change control, then derive the complete rank and physical ledger.", + "Implement certified moment inequalities through a different exact enclosure method." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering" + ], + "question": "Does one changed supplier or assembly claim lack a source-bound independent check of a specific new implication?", + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Promoting #2979 from merged source archive to validated supplier solely from author PASS receipts or aggregate pricing." + ], + "starting_points": [ + "certificates/selected-result.json", + "research/rank7-joint-endframes/README.md", + "docs/research/research-family-status.md" + ] + }, + "outcome": "in-progress", + "priority_revision": 6, + "schema_version": 1, + "scope_change_reason": "Explicit user priority is a verified kappa gain quickly. T148 has one fifth of T740 roles and fits available memory while still improving the latest word at a strictly larger fully paid point.", + "scope_status": "changed", + "stop_rule": "One smaller-stock composition. No source predicate is weakened and no release is claimed before the completed baseline plus the complete new release.", + "task_id": "independent-moment" +} diff --git a/research/t148-carrier-skips/VENDOR.json b/research/t148-carrier-skips/VENDOR.json new file mode 100644 index 0000000000..68543c625d --- /dev/null +++ b/research/t148-carrier-skips/VENDOR.json @@ -0,0 +1,50 @@ +[ + { + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "original_path": "research/rank7-restore-carrier-skips/CLAIM.json", + "path": "vendor/PR3042-CLAIM.json", + "sha256": "adb2efbaa7c16bf66aede2ac739e445e6fa974d5defbff8b70324f4f10632aa3" + }, + { + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "original_path": "research/rank7-restore-carrier-skips/MANIFEST.json", + "path": "vendor/PR3042-MANIFEST.json", + "sha256": "da2b0fbe030ed5981ea105720042f5be8f56803c141e0be326776eb08e379406" + }, + { + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "original_path": "research/rank7-restore-carrier-skips/edits/EDITS.json", + "path": "vendor/EDITS.json", + "sha256": "ebffcc1e57e59439b9678ff8d9be518c457af22ce77235c2fdb46540ab9b9b79" + }, + { + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "original_path": "research/rank7-restore-carrier-skips/edits/FINAL-WORD-base.json.gz", + "path": "vendor/WORD-base.json.gz", + "sha256": "7e98f6f2a6c9ce9e7e04b515bd8ce4a4a533ff05f01ea265be2a1a994695260e" + }, + { + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "original_path": "research/rank7-restore-carrier-skips/edits/FINAL-WORD-extra.json.gz", + "path": "vendor/WORD-extra.json.gz", + "sha256": "1396410de482883416fc7f534062ab005b484056b035fdcfa3b5cc065536ba35" + }, + { + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "original_path": "research/rank7-restore-carrier-skips/allocation/PROVIDERS.json", + "path": "vendor/PROVIDERS.json", + "sha256": "04c9f2620178322010f7bafb30c669cad0be1426a905275d28a398398b596cd0" + }, + { + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "original_path": "research/rank7-restore-carrier-skips/CREDITS.md", + "path": "vendor/CREDITS.md", + "sha256": "8475f5e7c090e05196cfd6c2894516cbbedd5876f54193fea575d8064e23574e" + }, + { + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "original_path": "research/rank7-restore-carrier-skips/NOTICE", + "path": "vendor/NOTICE", + "sha256": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661" + } +] diff --git a/research/t148-carrier-skips/VERIFY.json b/research/t148-carrier-skips/VERIFY.json new file mode 100644 index 0000000000..38b867a91d --- /dev/null +++ b/research/t148-carrier-skips/VERIFY.json @@ -0,0 +1,159 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-B", + "-W", + "error", + "{package}/verify.py" + ], + "checks": "Actual T148 construction: all543456 roles,paid rank32 child,word/frame/cleanup tariffs,exact moment,packing-cap gap,and both mandatory completed-release receipts.", + "timeout_seconds": 600 + } + ], + "inputs": [ + "research/rank7-joint-endframes/allocation/DISPATCH.json", + "research/rank7-joint-endframes/allocation/FILL.json.gz", + "research/rank7-joint-endframes/allocation/ORDER.json", + "research/rank7-joint-endframes/allocation/PROVIDERS.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/certificates/RELAX-CAP.json", + "research/rank7-joint-endframes/data/WORD-base.json.gz", + "research/rank7-joint-endframes/data/WORD-extra.json.gz", + "research/rank7-joint-endframes/tools/root.py", + "research/rank7-joint-endframes/vendor/audit_local.py", + "research/rank7-joint-endframes/vendor/preload_move.py", + "research/rank7-t148-restore-release/.gitattributes", + "research/rank7-t148-restore-release/GENERAL-CEILING.json", + "research/rank7-t148-restore-release/README.md", + "research/rank7-t148-restore-release/SOURCES.json", + "research/rank7-t148-restore-release/TASK.json", + "research/rank7-t148-restore-release/VENDOR.json", + "research/rank7-t148-restore-release/VERIFY.json", + "research/rank7-t148-restore-release/evidence/ADAPTER-DERIVATION.json", + "research/rank7-t148-restore-release/evidence/ADMISSION-RESULT.json", + "research/rank7-t148-restore-release/evidence/ADMISSION-STAGES.json", + "research/rank7-t148-restore-release/evidence/ENVIRONMENT.json", + "research/rank7-t148-restore-release/evidence/FINITE.json", + "research/rank7-t148-restore-release/evidence/NATIVE-RECEIPT.json", + "research/rank7-t148-restore-release/evidence/OUTER-CLAIM.json", + "research/rank7-t148-restore-release/evidence/PREFIX-AND-INVOICE.json.gz", + "research/rank7-t148-restore-release/evidence/RECIPE.json", + "research/rank7-t148-restore-release/evidence/RELEASE-RECEIPT.json", + "research/rank7-t148-restore-release/evidence/RESULT.json", + "research/rank7-t148-restore-release/evidence/VALIDATION.json", + "research/rank7-t148-restore-release/evidence/VERIFY-RESULT.json", + "research/rank7-t148-restore-release/evidence/VERIFY-STAGES.json", + "research/rank7-t148-restore-release/evidence/logs/complete-admission.log.txt", + "research/rank7-t148-restore-release/evidence/logs/declared-edit-stage.log.txt", + "research/rank7-t148-restore-release/evidence/logs/derive-closed-adapters.log.txt", + "research/rank7-t148-restore-release/evidence/logs/export-pr2833.log.txt", + "research/rank7-t148-restore-release/evidence/logs/export-pr2894.log.txt", + "research/rank7-t148-restore-release/evidence/logs/four-kernel-stage.log.txt", + "research/rank7-t148-restore-release/evidence/logs/fresh-current-native.log.txt", + "research/rank7-t148-restore-release/evidence/logs/fresh-retained-bootstrap.log.txt", + "research/rank7-t148-restore-release/evidence/logs/paired-extension-stage.log.txt", + "research/rank7-t148-restore-release/evidence/logs/parent-paired-stage.log.txt", + "research/rank7-t148-restore-release/evidence/logs/preload-stage.log.txt", + "research/rank7-t148-restore-release/evidence/logs/rank7-overlay-stage.log.txt", + "research/rank7-t148-restore-release/evidence/logs/source-preflight.log.txt", + "research/rank7-t148-restore-release/reproduce.py", + "research/rank7-t148-restore-release/test_verify.py", + "research/rank7-t148-restore-release/vendor/PR3018-EXCHANGE.json", + "research/rank7-t148-restore-release/vendor/PR3021-RESULT.json", + "research/rank7-t148-restore-release/vendor/PR3022-EXCHANGE.json", + "research/rank7-t148-restore-release/vendor/PR3022-RESULT.json", + "research/rank7-t148-restore-release/vendor/geometry.py", + "research/rank7-t148-restore-release/vendor/moment.py", + "research/rank7-t148-restore-release/vendor/pr3015/CLAIM.json", + "research/rank7-t148-restore-release/vendor/pr3015/CREDITS.md", + "research/rank7-t148-restore-release/vendor/pr3015/FINAL-WORD-base.json.gz", + "research/rank7-t148-restore-release/vendor/pr3015/FINAL-WORD-extra.json.gz", + "research/rank7-t148-restore-release/vendor/pr3015/MANIFEST.json", + "research/rank7-t148-restore-release/vendor/pr3015/NOTICE", + "research/rank7-t148-restore-release/vendor/pr3015/PROVIDERS.json", + "research/rank7-t148-restore-release/vendor/pr3015/RELAX-CAP.json", + "research/rank7-t148-restore-release/vendor/release_driver.py", + "research/rank7-t148-restore-release/verify.py", + "research/rank7-t148-restore-release/verify_release.py", + "research/rank7-t740-release/.gitattributes", + "research/rank7-t740-release/ENGINEERING.md", + "research/rank7-t740-release/GIT-SOURCES.json", + "research/rank7-t740-release/PINS.json", + "research/rank7-t740-release/README.md", + "research/rank7-t740-release/SOURCES.json", + "research/rank7-t740-release/TASK.json", + "research/rank7-t740-release/VENDOR.json", + "research/rank7-t740-release/VERIFY.json", + "research/rank7-t740-release/decisions.tsv", + "research/rank7-t740-release/evidence/ADAPTER-DERIVATION.json", + "research/rank7-t740-release/evidence/ADMISSION-RESULT.json", + "research/rank7-t740-release/evidence/ADMISSION-STAGES.json", + "research/rank7-t740-release/evidence/BINDINGS.json", + "research/rank7-t740-release/evidence/BINDINGS.log.txt", + "research/rank7-t740-release/evidence/COMPOSITION-RESULT.json", + "research/rank7-t740-release/evidence/DISCOVERY-AUDIT.json", + "research/rank7-t740-release/evidence/DISCOVERY-INVOICE.json.gz", + "research/rank7-t740-release/evidence/DISCOVERY-RESULT.json", + "research/rank7-t740-release/evidence/DISCOVERY-STAGES.json", + "research/rank7-t740-release/evidence/ENVIRONMENT.json", + "research/rank7-t740-release/evidence/FINITE.json", + "research/rank7-t740-release/evidence/INITIAL-BOOTSTRAP-FAILURE.log.txt", + "research/rank7-t740-release/evidence/INVOICE-PAYLOAD.json", + "research/rank7-t740-release/evidence/MATERIALIZED.json", + "research/rank7-t740-release/evidence/NATIVE-ENVIRONMENT.json", + "research/rank7-t740-release/evidence/NATIVE-RECEIPT.json", + "research/rank7-t740-release/evidence/OUTER-CLAIM.json", + "research/rank7-t740-release/evidence/OWNERS-RESULT.json", + "research/rank7-t740-release/evidence/RECIPE.json", + "research/rank7-t740-release/evidence/RELEASE-RECEIPT.json", + "research/rank7-t740-release/evidence/STAGES.json", + "research/rank7-t740-release/evidence/logs/complete-admission.log.txt", + "research/rank7-t740-release/evidence/logs/declared-edit-stage.log.txt", + "research/rank7-t740-release/evidence/logs/derive-closed-adapters.log.txt", + "research/rank7-t740-release/evidence/logs/export-pr2833.log.txt", + "research/rank7-t740-release/evidence/logs/export-pr2894.log.txt", + "research/rank7-t740-release/evidence/logs/four-kernel-stage.log.txt", + "research/rank7-t740-release/evidence/logs/fresh-current-native.log.txt", + "research/rank7-t740-release/evidence/logs/fresh-retained-bootstrap.log.txt", + "research/rank7-t740-release/evidence/logs/paired-extension-stage.log.txt", + "research/rank7-t740-release/evidence/logs/parent-paired-stage.log.txt", + "research/rank7-t740-release/evidence/logs/preload-stage.log.txt", + "research/rank7-t740-release/evidence/logs/rank7-overlay-stage.log.txt", + "research/rank7-t740-release/evidence/logs/source-preflight.log.txt", + "research/rank7-t740-release/evidence/optimized_tests.log.txt", + "research/rank7-t740-release/evidence/registered.log.txt", + "research/rank7-t740-release/evidence/registered_finite.log.txt", + "research/rank7-t740-release/evidence/tests.log.txt", + "research/rank7-t740-release/materialize.py", + "research/rank7-t740-release/reproduce.py", + "research/rank7-t740-release/test_verify.py", + "research/rank7-t740-release/vendor/PR3021-RESULT.json", + "research/rank7-t740-release/vendor/pr3015/CLAIM.json", + "research/rank7-t740-release/vendor/pr3015/CREDITS.md", + "research/rank7-t740-release/vendor/pr3015/MANIFEST.json", + "research/rank7-t740-release/vendor/pr3015/NOTICE", + "research/rank7-t740-release/vendor/pr3015/allocation/PROVIDERS.json", + "research/rank7-t740-release/vendor/pr3015/edits/EDITS.json", + "research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-base.json.gz", + "research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-extra.json.gz", + "research/rank7-t740-release/vendor/pr3018/EXCHANGE.json", + "research/rank7-t740-release/vendor/pr3021-FINITE.json", + "research/rank7-t740-release/vendor/pr3021/reproduce.py", + "research/rank7-t740-release/vendor/pr3021/verify.py", + "research/rank7-t740-release/vendor/pr3024/EXCHANGE.json", + "research/rank7-t740-release/vendor/pr3024/cap_proof.py", + "research/rank7-t740-release/vendor/pr3024/lift.py", + "research/rank7-t740-release/verify.py", + "research/rank7-t740-release/verify_release.py", + "research/two-sided-helper-extraction/tools/admit_channel408.py", + "research/two-sided-helper-extraction/tools/audit_moment.py" + ], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/t148-carrier-skips/ci_full.py b/research/t148-carrier-skips/ci_full.py new file mode 100644 index 0000000000..adb0162a6c --- /dev/null +++ b/research/t148-carrier-skips/ci_full.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Sequential cold baseline and composition, with unchanged scientific checks. + +Only process time budgets are larger than the predecessor convenience wrapper. +Every source command and the original final baseline checker remain unchanged. +""" +import argparse +import importlib.util +import os +import subprocess +import sys +from pathlib import Path + +import verify as v + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--work', type=Path, required=True) + args = parser.parse_args() + work = args.work.resolve() + v.need(not work.exists(), 'fresh CI work root') + work.mkdir() + v.authenticate() + v.baseline_modules() + path = v.ROOT / 'research/rank7-t740-release/reproduce.py' + spec = importlib.util.spec_from_file_location('original_baseline_harness', path) + original = importlib.util.module_from_spec(spec) + spec.loader.exec_module(original) + baseline = work / 'baseline' + prepared = original.execute(v.ROOT, baseline, True) + v.need(prepared['status'] == 'PREFLIGHT_ONLY_NOT_A_RELEASE', 'original baseline preflight') + recipe = v.read(baseline / 'RECIPE.json')['commands'] + v.need([name for name, _ in recipe] == original.RECIPE_NAMES, 'every original source command') + stages = v.read(baseline / 'STAGES.json') + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONINTMAXSTRDIGITS='0', + OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1') + for name in ['PYTHONOPTIMIZE', 'PYTHONPATH', 'WITNESS_SPEC', 'WITNESS_RECORD', 'WITNESS_DISCOVER']: + env.pop(name, None) + for name, command in recipe: + original.run_stage(name, command, baseline, env, stages, 7200) + result = original.check_release(baseline, baseline / 'pr3015', prepared['fill_sha256'], stages) + original.save(baseline / 'RESULT.json', result) + v.need(result['status'] == 'PASS_T740_R1_COMPLETE_RELEASE', 'completed original baseline gate') + print('PASS_COMPLETE_COLD_BASELINE', flush=True) + composition = work / 'composition' + subprocess.run([sys.executable, '-B', str(v.P / 'reproduce.py'), '--repo', str(v.ROOT), + '--baseline-work', str(baseline), '--work', str(composition)], check=True, env=env) + subprocess.run([sys.executable, '-B', str(v.P / 'seal.py'), '--baseline', str(baseline), + '--composition', str(composition)], check=True, env=env) + subprocess.run([sys.executable, '-B', str(v.P / 'finalize.py')], check=True, env=env) + + +if __name__ == '__main__': + main() diff --git a/research/t148-carrier-skips/finalize.py b/research/t148-carrier-skips/finalize.py new file mode 100644 index 0000000000..4d4b3ef16f --- /dev/null +++ b/research/t148-carrier-skips/finalize.py @@ -0,0 +1,31 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Mark completion only after both real release receipts and finite checks pass.""" +import json + +import verify as v + + +def main(): + v.run() + task = v.read(v.P / 'TASK.json') + claim = v.read(v.P / 'CLAIM.json') + task.update(outcome='completed', evidence='Both mandatory complete releases passed. The composition includes two freshly verified changed native providers, all543456 owner roles,133117 physical families,91 buffers and the paid rank32 child. All139 admission,12 bit,25 actual controller,8 independent-owner and6 geometry controls reject;63 strict outer rows and17 outer rejecting cases pass. Exact kappa gain=' + claim['gain'] + '. No selected-frontier or complete-theorem claim.') + task['open_questions'] = [dict(question='Can the larger T740 composition be fully released within a separate resource budget?', + why_it_matters='T148 has a positive gap below the unchanged fixed-inventory cap.', + first_step='Use the exact larger allocation, rederive all stock/prefix constants and run every full release gate.', + blocked_by='A larger audit needs more memory and compute; this smaller release cannot certify it.')] + (v.P / 'TASK.json').write_text(json.dumps(task, sort_keys=True, indent=2) + '\n', encoding='utf-8', newline='\n') + path = v.P / 'README.md' + text = path.read_text() + text = text.replace('**Full release pending.**', '**Both mandatory complete releases passed.**') + text = text.replace('No completed release is claimed yet.', 'The native, supplier and modern outer checks passed; hosted finite replay is recorded separately.') + path.write_text(text, encoding='utf-8', newline='\n') + manifest = {p.relative_to(v.P).as_posix(): v.sha(p) for p in sorted(v.P.rglob('*')) + if p.is_file() and p != v.P / 'MANIFEST.json' and '__pycache__' not in p.parts} + (v.P / 'MANIFEST.json').write_text(json.dumps(manifest, sort_keys=True, indent=2) + '\n', encoding='utf-8', newline='\n') + print('FINALIZED_ONLY_AFTER_BOTH_COMPLETE_RELEASES', flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/t148-carrier-skips/reproduce.py b/research/t148-carrier-skips/reproduce.py new file mode 100644 index 0000000000..5fba4da50c --- /dev/null +++ b/research/t148-carrier-skips/reproduce.py @@ -0,0 +1,139 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Full PR3042 source/native release with only three allocation arguments changed. + +Requires the completed PR3030 baseline. All predecessor scripts and predicates +remain unchanged. Credit dcharb78, Nick Petalas and the retained source lineage. +""" +import argparse +import importlib.util +import io +import os +import subprocess +import sys +import tarfile +from fractions import Fraction as Q +from pathlib import Path, PurePosixPath + +import verify as v + +PREFIX = 'research/rank7-restore-carrier-skips' + + +def export(repo, destination): + raw = subprocess.run(['git', '-C', str(repo), 'archive', v.HEAD, PREFIX], + check=True, capture_output=True, timeout=120).stdout + v.need(len(raw) < 50_000_000, 'bounded exact source archive') + destination.mkdir() + with tarfile.open(fileobj=io.BytesIO(raw)) as archive: + items = archive.getmembers() + v.need(len(items) <= 512, 'bounded source entries') + for item in items: + name = PurePosixPath(item.name) + v.need(not name.is_absolute() and '..' not in name.parts and + (item.isfile() or item.isdir()), 'regular bounded source path') + if item.isdir(): + continue + v.need(name.is_relative_to(PurePosixPath(PREFIX)), 'exact source prefix') + target = destination / name.relative_to(PurePosixPath(PREFIX)) + target.parent.mkdir(parents=True, exist_ok=True) + stream = archive.extractfile(item) + v.need(stream is not None, 'source stream') + with stream: + target.write_bytes(stream.read()) + v.need(v.sha(destination / 'MANIFEST.json') == v.sha(v.P / 'vendor/PR3042-MANIFEST.json'), + 'exact published PR3042 manifest') + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--repo', type=Path, required=True) + parser.add_argument('--baseline-work', type=Path, required=True) + parser.add_argument('--work', type=Path, required=True) + args = parser.parse_args() + repo, baseline, work = args.repo.resolve(), args.baseline_work.resolve(), args.work.resolve() + v.need(os.name == 'posix' and not sys.flags.optimize, 'POSIX and enabled assertions required') + v.need(not work.exists() and not work.is_relative_to(v.P), 'fresh external work required') + v.authenticate() + v.baseline_modules() + path = v.ROOT / 'research/rank7-t740-release/reproduce.py' + spec = importlib.util.spec_from_file_location('original_baseline_harness', path) + harness = importlib.util.module_from_spec(spec) + spec.loader.exec_module(harness) + previous = v.read(baseline / 'RESULT.json') + v.need(previous['status'] == 'PASS_T740_R1_COMPLETE_RELEASE', 'completed PR3030 baseline release gate') + previous_stages = v.read(baseline / 'STAGES.json') + for stage in previous_stages: + v.need(stage['exit_code'] == 0 and v.sha(baseline / (stage['stage'] + '.log')) == stage['log_sha256'], + 'every completed baseline stage/log binding') + v.need(harness.check_release(baseline, baseline / 'pr3015', previous['fill_sha256'], previous_stages) + == previous, 'entire completed baseline rederived') + work.mkdir() + source = work / 'pr3042' + export(repo, source) + harness.authenticate_tree(source) + producer = v.load(v.ROOT / 'research/rank7-t148-restore-release/verify.py', 'credited_t148_allocation') + _, _, _, order, _, fill, dispatch = producer.allocation() + import gzip + for name, value in [('COMPOSED-FILL.json.gz', fill), ('ORDER.json', order), ('DISPATCH.json', dispatch)]: + raw = producer.canonical(value) + (work / name).write_bytes(gzip.compress(raw, compresslevel=1, mtime=0) if name.endswith('.gz') else raw) + materialized = dict(fill_sha256=v.sha(work / 'COMPOSED-FILL.json.gz'), roles=543456, replicas=148) + harness.save(work / 'MATERIALIZED.json', materialized) + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONINTMAXSTRDIGITS='0', + OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1') + for key in ['PYTHONOPTIMIZE', 'PYTHONPATH', 'WITNESS_SPEC', 'WITNESS_RECORD', 'WITNESS_DISCOVER']: + env.pop(key, None) + stages = [] + command = [sys.executable, '-B', str(source / 'reproduce.py'), '--repo', str(repo), + '--work', str(work / 'run'), '--retained', str(baseline / 'run/retained'), + '--jobs', '1', '--dry-run'] + harness.run_stage('source-preflight', command, work, env, stages, 300) + recipe = v.read(work / 'run/PREFLIGHT.json')['commands'] + expected = [name for name in harness.RECIPE_NAMES if name != 'fresh-retained-bootstrap'] + v.need([name for name, _ in recipe] == expected, 'complete original retained-cache recipe') + edits = [] + for name, command in recipe: + if name == 'complete-admission': + for flag, old, new in [('--fill', 'FILL.json.gz', 'COMPOSED-FILL.json.gz'), + ('--order', 'ORDER.json', 'ORDER.json'), + ('--dispatch', 'DISPATCH.json', 'DISPATCH.json')]: + i = command.index(flag) + 1 + v.need(command[i] == str(source / 'allocation' / old), 'exact allocation argument preimage') + edits.append(dict(argument=flag, old=command[i], new=str(work / new))) + command[i] = str(work / new) + v.need(len(edits) == 3, 'only three allocation arguments changed') + harness.save(work / 'RECIPE.json', dict(commands=recipe, allocation_changes=edits)) + for name, command in recipe: + harness.run_stage(name, command, work, env, stages, 7200) + admission = v.read(work / 'run/candidate/RESULT.json') + receipt = v.read(work / 'run/candidate/release/RELEASE-RECEIPT.json') + v.need(admission['status'] == 'PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE' and + receipt['status'] == 'PASS_RELEASE', 'completed supplier and modern outer release') + v.need(admission['source_manifest_sha256'] == v.SOURCE_SHA, 'exact new-word source') + v.need({int(r): n for r, n in admission['profile'].items()} == v.PROFILE, 'complete actual composed profile') + arithmetic = v.calculate(include_owners=False) + v.need(Q(admission['kappa']) == Q(receipt['kappa_decimal']) == arithmetic['kappa'], 'exact composed endpoint') + v.need(Q(admission['kappa']) > Q(v.read(source / 'CLAIM.json')['kappa']), 'strict improvement over PR3042') + v.need(admission['fill_sha256'] == v.sha(work / 'COMPOSED-FILL.json.gz'), 'actual admitted T148 fill') + v.need(admission['release_receipt_sha256'] == v.sha(work / 'run/candidate/release/RELEASE-RECEIPT.json'), + 'terminal release receipt bound by admission') + native = v.read(work / 'run/native/NATIVE-RECEIPT.json') + v.need(native['fresh_current_provider_count'] == 2 and native['manifest_sha256'] == v.SOURCE_SHA, + 'both changed native providers freshly verified') + harness.authenticate_tree(source) + harness.authenticate_tree(work / 'run/source-edits') + result = dict(status='PASS_T148_CARRIER_SKIPS_COMPLETE_RELEASE', + **{k: str(arithmetic[k]) for k in ['kappa', 'complex_lower', 'previous', 'gain']}, + source_manifest_sha256=v.SOURCE_SHA, profile=admission['profile'], + fill_sha256=admission['fill_sha256'], native_receipt_sha256=admission['native_receipt_sha256'], + release_sha256=admission['release_receipt_sha256'], + baseline_result_sha256=v.sha(baseline / 'RESULT.json'), + package_manifest_sha256=receipt['manifest_sha256'], stages=stages, + native_scope='Two fresh changed providers; unchanged retained bootstrap explicitly authenticated and reused.') + harness.save(work / 'RESULT.json', result) + print(result['status'], result['kappa'], flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/t148-carrier-skips/seal.py b/research/t148-carrier-skips/seal.py new file mode 100644 index 0000000000..68657898e6 --- /dev/null +++ b/research/t148-carrier-skips/seal.py @@ -0,0 +1,86 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Seal only actual completed baseline and composition releases.""" +import argparse +import json +from fractions import Fraction as Q +from pathlib import Path + +import verify as v + + +def save(path, value): + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n', encoding='utf-8', newline='\n') + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--baseline', type=Path, required=True) + parser.add_argument('--composition', type=Path, required=True) + args = parser.parse_args() + baseline, work = args.baseline.resolve(), args.composition.resolve() + old = v.read(baseline / 'RESULT.json') + result = v.read(work / 'RESULT.json') + v.need(old['status'] == 'PASS_T740_R1_COMPLETE_RELEASE', 'completed baseline gate') + v.need(result['status'] == 'PASS_T148_CARRIER_SKIPS_COMPLETE_RELEASE', 'completed composition gate') + arithmetic = v.calculate(include_owners=False) + for key in ['kappa', 'complex_lower', 'previous', 'gain']: + v.need(Q(result[key]) == arithmetic[key], 'actual exact result: ' + key) + inner = work / 'run/candidate' + admission = v.read(inner / 'RESULT.json') + v.need(admission['status'] == 'PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE', 'complete original admission') + v.need(admission['source_manifest_sha256'] == v.SOURCE_SHA and + {int(k): n for k, n in admission['profile'].items()} == v.PROFILE, 'actual new-word composed source/profile') + strict = inner / 'release/verify/strict' + counts = dict(admission=len(v.read(strict / 'ADMISSION-CONTROLS.json')['rejected_controls']), + bit=len(v.read(strict / 'BIT-CONTROLS.json')['rejected_controls']), + controller=len(v.read(strict / 'global/audit/ASYNC-AUDIT.json')['mutations_rejected']), + independent_owner=len(v.read(strict / 'INDEPENDENT.json')['controls_rejected']), + geometry=len(v.read(inner / 'release/verify/GEOMETRY-CONTROLS.json')['rejected'])) + v.need(counts == dict(admission=139, bit=12, controller=25, independent_owner=8, geometry=6), 'every actual rejecting control') + invoice = v.read(strict / 'global/audit/PREFIX-AND-INVOICE.json') + v.need(invoice['physical'] == 133117 and invoice['private_zero_buffers'] == 91 and + invoice['global_prefix_bits'] < invoice['charged_prefix_bits'] == 2048, 'full charged physical/prefix invoice') + ledger_path = inner / 'package/outer/LEDGER.json' + ledger = v.read(ledger_path) + row = ledger['rows']['struct_boundary_radix_union'] + v.need(Q(row['kappa']['rational']) == arithmetic['kappa'] and len(row['strict_checks']) == 63 and + all(Q(value['rational']) > 0 for value in row['strict_checks'].values()), 'all63 strict outer margins') + v.need(len(ledger['rejecting_controls']['struct_boundary_radix_union']) == 17, 'all17 outer rejecting cases') + hashes = {} + for source, name, field in [ + (baseline / 'run/candidate/release/RELEASE-RECEIPT.json', 'BASELINE-RELEASE-RECEIPT.json', 'baseline_release_sha256'), + (inner / 'release/RELEASE-RECEIPT.json', 'RELEASE-RECEIPT.json', 'release_sha256'), + (ledger_path, 'OUTER-LEDGER.json', 'outer_ledger_sha256')]: + raw = source.read_bytes() + v.need(not any(marker in raw.lower() for marker in + [b'/mnt/c/', b'c:\\users\\', b'c:/users/', b'/home/', b'/users/']), 'no machine paths in published receipt') + (v.P / 'evidence' / name).write_bytes(raw) + hashes[field] = v.sha(source) + native = v.read(work / 'run/native/NATIVE-RECEIPT.json') + v.need(native['fresh_current_provider_count'] == 2 and native['manifest_sha256'] == v.SOURCE_SHA, + 'both changed native providers fresh and source-bound') + for tag in ['base', 'extra']: + v.need(native['providers'][tag]['word_sha256'] == v.sha(v.P / ('vendor/WORD-' + tag + '.json.gz')), + 'exact freshly compiled provider word') + claim = dict(status=result['status'], source_head=v.HEAD, source_manifest_sha256=v.SOURCE_SHA, + profile={str(r): n for r, n in v.PROFILE.items()}, replicas=148, calls=1332, + roles=543456, physical=133117, private_buffers=91, + **{key: str(arithmetic[key]) for key in ['kappa', 'complex_lower', 'previous', 'gain']}) + save(v.P / 'CLAIM.json', claim) + evidence = dict(status=result['status'], baseline_complete_release=True, composition_complete_release=True, + controls=counts, fresh_current_native_providers=2, + retained_native_scope='Explicitly authenticated unchanged cache from the completed cold baseline.', + baseline_result_sha256=v.sha(baseline / 'RESULT.json'), + composition_result_sha256=v.sha(work / 'RESULT.json'), + admission_result_sha256=v.sha(inner / 'RESULT.json'), + native_receipt_sha256=v.sha(work / 'run/native/NATIVE-RECEIPT.json'), + outer_strict_rows=63, outer_rejecting_cases=17, + global_prefix_bits=invoice['global_prefix_bits'], charged_prefix_bits=2048, + physical=133117, private_zero_buffers=91, **hashes) + save(v.P / 'evidence/VALIDATION.json', evidence) + print(claim['status'], claim['gain'], flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/t148-carrier-skips/vendor/CREDITS.md b/research/t148-carrier-skips/vendor/CREDITS.md new file mode 100644 index 0000000000..85b68ae52e --- /dev/null +++ b/research/t148-carrier-skips/vendor/CREDITS.md @@ -0,0 +1,18 @@ +# Credits + +- **PR #2908, Jeremy Diviney**: the paired input/output extraction, its compensation rule `C*S`, the exact two-sided certificate (`structure.py`, vendored unchanged) and the closed-adapter admission chain. +- **PR #2917, Mason Hale**: the nine paired extractions and 82-endpoint words under PR2942, the refit/compose producer model that stage 2 follows, the T74 chronology (ORDER/DISPATCH), the allocation checker, moment auditor, extension stage and adapter derivation reused here. +- **PR #2957 / #2948 / #2966, Jeremy Kothe (jeremykothe2)**: the fourteen declared exactness-preserving gate rewrites in five classes (R-retime, A3779-cut-start-read, PM-carrier-lender-entry, B-carrier-retime, A-commuting-swap) and their pure applier (`vendor/declared_rewrites.py`, vendored unchanged); stage 3 composes exactly these rewrites onto this package's stage-2 word (`data/REWRITES-2957.json`, re-addressed with exact preimages). PR2966 composed the same rewrites onto our PR2942 words. +- **PR #2969, Dugongue**: the PR2942 + PR2957 composition at T370 and its cap-level headline nomination, this package's comparator and moment baseline (`allocation/baseline/`). Our stage 3 composes the same fourteen rewrites, here onto the stage-2 word. +- **PR #2918 (research/helper408-rank7-pairing), RossRichardson**: the fixed-cut rank-seven obstruction for helper408; this package's census of fresh rank-7 extractions reproduces it exactly and is consistent with it. +- **PR #2894 / #2833, Jeremy Kothe**: the preload re-synthesis supplier, the frame accounting and inverse-reverse cleanup (`vendor/preload_move.py`), the source materializer and the inherited supplier lineage. +- **PR #2857 / #2848, Yiyang Lu (Lyy-iiis)**: the shared-kernel words, the staged native/overlay tooling and the chronological flow model and realization (edge colouring) used to construct the allocation; PR2843 (Marius-Paul Dumitrean) is that flow model's starting point. +- **PR #2863 / #2839, Dugongue**: the packing lineage and the PR2839 owner engine. +- **Tekalign**: the independent owner/chronology checker (`allocation/vendor/independent_owners.py`) and admission tooling. +- **icekylinx**: the exact free-operator auditor retained as `vendor/audit_local.py` (PR2833). +- **themilkman216**: the observation that a cap-level allocation of these inventories needs a T whose basic counts are integral, which the allocation's degenerate-face step builds on. +- **Gareth Davidson (bitplane), PR #1995 / #2013**: the fixed-word terminal-subspace bounds that frame stage 1's scope; earlier rank-seven helper ends on other words are in `research/complex-rank7-end-pair`, `research/k8-rank7-composition` and the PR1090/PR1104 lineage (credited there). +- **PR #2930 / #2942, Marius-Paul Dumitrean**: the cap allocation of PR2917's words, the four normal-45 extractions under these words, the relaxation tools and the overlay/producer conventions reused here. +- **New here (Marius-Paul Dumitrean, with substantial AI assistance from Anthropic Claude via Claude Code)**: the codimension-2 census on paired-extraction words, the joint end-frame lowering of 22 restored helpers in five groups (stage 1), the five further extractions it makes profitable (stage 2), the exact composition with PR2957's rewrites (stage 3), the producer and local verification for all three stages, the overlay stage `rank7-joint-endframes` with its rebuild guards, the adapter generalization to six width classes, the literal T74 allocation of the changed inventory, its relaxation certificates and recorded gap, and the complete fresh replay. +- **PR #3015, Jeremy Kothe (jeremykothe2)**: the declared literal edit stage (`edits/`, `tools/build_edits.py`) with its independent review (`edits/edits_review.py`), and edit R1 on PR #2979's restore section (carrier 61 for register 63). +- **New here (dcharb78, with AI assistance)**: the six restore carrier/pivot hyperplane skips across two declared edit blocks (`R1_E42` at `restore[162:188]` for registers `63, 54, 40` via carriers `369, 450` and `R2_E7` at `restore[190:203]` for registers `22, 73, 5` via carrier `19` and pivot `363` as self-carrier), the 11-control per-word edit review, and the re-derived paid profile, cap certificate, and complete fresh-native admission and release receipts. PR #2979 (mdumitrean) and PR #3015 (jeremykothe2) are the base and are credited first. diff --git a/research/t148-carrier-skips/vendor/EDITS.json b/research/t148-carrier-skips/vendor/EDITS.json new file mode 100644 index 0000000000..c2042a37bd --- /dev/null +++ b/research/t148-carrier-skips/vendor/EDITS.json @@ -0,0 +1,2984 @@ +{ + "declared": { + "local_profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "width_inventory": { + "4": 26, + "5": 2, + "6": 16, + "7": 52, + "8": 99, + "9": 213 + } + }, + "edits": { + "base": [ + { + "id": "R1_E42", + "new": [ + [ + "add", + 40, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 40, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 226, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 40, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 18, + 226, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 18, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 226, + 18, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 34, + -2, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 228, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 228, + 108, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 228, + 1, + 4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 108, + 228, + -4, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 45, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 40, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 18, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 40, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 40, + 54, + 2, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 61, + 63, + 1, + 1, + [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + ], + [ + "add", + 230, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 61, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 230, + 92, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 103, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 108, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 230, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ] + ], + "old": [ + [ + "add", + 18, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 18, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 226, + 18, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 34, + -2, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 108, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 22, + 1, + 4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 228, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 108, + 228, + -4, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 45, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 92, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 103, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 108, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 22, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ] + ], + "section": "restore", + "start": 162, + "stop": 188 + }, + { + "id": "R2_E7", + "new": [ + [ + "add", + 363, + 73, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 59, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 363, + 59, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 73, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 395, + 5, + 1, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 96, + 1, + 4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 395, + 96, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + ], + "old": [ + [ + "add", + 59, + 73, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 59, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 363, + 59, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 5, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 395, + 5, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -4, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ] + ], + "section": "restore", + "start": 190, + "stop": 203 + } + ], + "extra": [ + { + "id": "R1_E42", + "new": [ + [ + "add", + 40, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 40, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 226, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 40, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 18, + 226, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 18, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 226, + 18, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 34, + -2, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 228, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 228, + 108, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 228, + 1, + 4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 108, + 228, + -4, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 45, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 40, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 18, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 40, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 40, + 54, + 2, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 61, + 63, + 1, + 1, + [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + ], + [ + "add", + 230, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 61, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 230, + 92, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 103, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 108, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 230, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ] + ], + "old": [ + [ + "add", + 18, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 18, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 226, + 18, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 34, + -2, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 108, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 22, + 1, + 4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 228, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 108, + 228, + -4, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 45, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 92, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 103, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 108, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 22, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ] + ], + "section": "restore", + "start": 162, + "stop": 188 + }, + { + "id": "R2_E7", + "new": [ + [ + "add", + 363, + 73, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 59, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 363, + 59, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 73, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 395, + 5, + 1, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 96, + 1, + 4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 395, + 96, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + ], + "old": [ + [ + "add", + 59, + 73, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 59, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 363, + 59, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 5, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 395, + 5, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -4, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ] + ], + "section": "restore", + "start": 190, + "stop": 203 + } + ] + } +} \ No newline at end of file diff --git a/research/t148-carrier-skips/vendor/NOTICE b/research/t148-carrier-skips/vendor/NOTICE new file mode 100644 index 0000000000..89c20926ea --- /dev/null +++ b/research/t148-carrier-skips/vendor/NOTICE @@ -0,0 +1,28 @@ +research/rank7-joint-endframes +Copyright 2026 Marius-Paul Dumitrean. Licensed under the Apache License, Version 2.0. +Prepared with substantial AI assistance (Anthropic Claude, via Claude Code). + +This package retains, byte-identical, Apache-2.0 files from: PR #2942 (Marius-Paul Dumitrean, head +a027b0f6fdb0ab2b42ba10fc31b53960166bf2bf, research/paired-extension-normal45): data/PARENT-base.json.gz and +data/PARENT-extra.json.gz (its data/WORD-*.json.gz), comparators/PR2942-CLAIM.json and tools/wordedit.py; PR #2917 +(Mason Hale, head 224bd5e56041c40078ff6b5fa7393733a215de5c, research/paired-helper-extension): structure.py (Jeremy +Diviney's PR2908 two-sided certificate checker), vendor/audit_local.py (PR2833's independent exact auditor, icekylinx +attribution), vendor/preload_move.py (Jeremy Kothe's PR2894 frame accounting and cleanup), allocation/ORDER.json, +allocation/DISPATCH.json and allocation/vendor/ (independent_owners.py: Tekalign's independent owner checker as vendored +by PR2839/PR2917; PLAN.json.gz, TEMPLATE.json.gz); PR #2957 (Jeremy Kothe, head b74b25f3ccc84c16e1a801d73b2f47e5ea764c78, +research/paired-extension-cap-fill-swaps): vendor/declared_rewrites.py (the pure applier of the fourteen declared +rewrites) and comparators/PR2957-CLAIM.json; PR #2966 (Jeremy Kothe, head e62d3eb9005117d82a9babcfa937ecc53237c490, +research/paired-extension-normal45-rewrites): comparators/PR2966-CLAIM.json; PR #2969 (Dugongue, head +e2ca469b08385d3d5e29a918d66dbefaf889e9f3, research/paired-swap-normal45): allocation/baseline/ (its CLAIM.json and its +allocation ORDER.json and PROFILE.json); and PR #2930 (head 81f3b5d12977eba09e06fbff729167d59faabe90): tools/relax.py, +tools/root.py, tools/relax_exact.py. +data/REWRITES-2957.json is Jeremy Kothe's PR2957 rewrite list, re-addressed to this package's stage-2 word with exact +preimages (every entry keeps a credit field). producer.py follows PR2917's producer.py (Mason Hale) for its paired steps; +verify.py, check_allocation.py, check_cap.py, run_registered.py and reproduce.py adapt our PR2942 versions of PR2917's and +PR2930's; tools/audit_allocation_moment.py is PR2917's exact moment auditor with only its authenticated baseline changed (to +the PR2969 headline); tools/derive_adapters.py generalizes PR2917's adapter derivation (PR2908, Jeremy Diviney); +tools/build_overlay.py follows the overlay conventions of PR2908's and PR2917's builders. construction/allocation/ retains +the flow model of PR2857/PR2843 (Yiyang Lu, Marius-Paul Dumitrean) as adapted for this allocation. All original notices of +the exported predecessor packages remain in force. + +Derived work (Apache-2.0): this package (`research/rank7-restore-carrier-skips`) builds on PR #2979 (Marius-Paul Dumitrean, head be191346, research/rank7-joint-endframes) and PR #3015 (Jeremy Kothe, jeremykothe2, research/rank7-joint-endframes-restore-edit), retained byte-identical except for the files named in README.md, plus two declared restore edit blocks (`R1_E42` and `R2_E7` in `edits/EDITS.json` and `edits/FINAL-WORD-*.json.gz`) and their re-derived certificates and complete fresh-native admission and release receipts by dcharb78, with AI assistance. PR #2979's own evidence is kept under evidence/pr2979/. diff --git a/research/t148-carrier-skips/vendor/PR3042-CLAIM.json b/research/t148-carrier-skips/vendor/PR3042-CLAIM.json new file mode 100644 index 0000000000..47a55a7f68 --- /dev/null +++ b/research/t148-carrier-skips/vendor/PR3042-CLAIM.json @@ -0,0 +1,229 @@ +{ + "admitted_package_manifest_sha256": "2c367a7afa966a7952303364fbccd6332730e2d3ad48d2ef04a524f35daddb03", + "baseline_head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "baseline_kappa": "17240352247481048785499999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "baseline_pr": 2969, + "baseline_status": "FINITE_NATIVE_OWNER_AND_MOMENT_CANDIDATE_OUTER_PENDING", + "calls": 666, + "complex_lower": "432434041596978996703/250000000000000000000000", + "declared_edits": { + "count": 2, + "edits_sha256": "ebffcc1e57e59439b9678ff8d9be518c457af22ce77235c2fdb46540ab9b9b79", + "previous_kappa": "0.0017290339826465135177169999999999999999999998999999999999999999999999", + "previous_pr": 2979 + }, + "fill_sha256": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "fixed_inventory_cap": { + "cap_lower": "4324344875160696378107/2500000000000000000000000", + "cap_upper": "17297379500642785512429/10000000000000000000000000", + "realized": "below the fractional optimum by the recorded gap (check_cap.py); the cap basis is fractional at T74" + }, + "gain": "2850470819905554131/500000000000000000000000", + "helpers": 408, + "independent_inputs": 632, + "kappa": "17297361663879159868119999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017297361663879159868119999999999999999999998999999999999999999999999", + "live_families": 66304, + "local_profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "native_receipt_sha256": "7e982591b1362efe5e8d03fd98f67ff4ef676dd8a5fa3ca765c8ef1370be7019", + "physical_families": 66813, + "previous_claims": { + "pr2942": { + "claim_file": "comparators/PR2942-CLAIM.json", + "gain": "108122601948463419/15625000000000000000000", + "head": "a027b0f6fdb0ab2b42ba10fc31b53960166bf2bf", + "kappa": "17228163198632143279959999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2942 + }, + "pr2957": { + "claim_file": "comparators/PR2957-CLAIM.json", + "gain": "6018751317177815841/1000000000000000000000000", + "head": "b74b25f3ccc84c16e1a801d73b2f47e5ea764c78", + "kappa": "17237174150707381709709999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2957 + }, + "pr2966": { + "claim_file": "comparators/PR2966-CLAIM.json", + "gain": "28509469322319047/5000000000000000000000", + "head": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "kappa": "17240342725234521774119999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2966 + }, + "pr2969": { + "claim_file": "allocation/baseline/CLAIM.json", + "gain": "2850470819905554131/500000000000000000000000", + "head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "kappa": "17240352247481048785499999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2969 + }, + "pr2979": { + "claim_file": "comparators/PR2979-CLAIM.json", + "gain": "140436748280493819/200000000000000000000000", + "head": "be191346391661f4d35fc0d1508d0a6029572576", + "kappa": "17290339826465135177169999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2979 + } + }, + "profile": { + "1": 1637688, + "2": 474192, + "3": 159468, + "4": 71928, + "48": 28190, + "5": 13716, + "8": 5328 + }, + "release_receipt_sha256": "906d15db82f7b5b8938d1b760f54d9229dc7b6f2dbe84cc9286f2d1015e36743", + "replicas": 74, + "scope": "Conditional finite supplier/outer certificate for PR2979's words (mdumitrean: joint rank-7 end frames, five further paired extractions, fourteen PR2957 rewrites) with one declared literal restore edit (R1, Stack2979 / Jeremy Kothe) and PR2979's literal T74 allocation unchanged (paid profile re-derived). Inherited all-size/compiler/theorem hypotheses remain. No selected-frontier change or independent-human-review claim.", + "source_manifest_sha256": "130650ad8833f6df88528c560e4d1cfbae084f4b15a64788a332ddcaff472a17", + "stages": { + "stage1": { + "frame_edits": 139, + "groups": { + "A": { + "W": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "helpers": [ + 331, + 450, + 451, + 508, + 509 + ] + }, + "B": { + "W": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "helpers": [ + 299, + 448, + 449, + 484, + 485 + ] + }, + "C": { + "W": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "helpers": [ + 452, + 453, + 532, + 533 + ] + }, + "D": { + "W": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "helpers": [ + 454, + 455, + 556, + 557 + ] + }, + "V45": { + "W": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "helpers": [ + 249, + 251, + 265, + 267 + ] + } + }, + "kind": "joint codimension-2 end-frame lowering (frame-only)", + "record_sha256": "5fbfce004330ebc1fbac8de264614fe295f1a074811b478db4892c3bc3852cd3" + }, + "stage2": { + "extractions": [ + { + "helper": 226, + "normal": 42, + "step": 1 + }, + { + "helper": 228, + "normal": 42, + "step": 2 + }, + { + "helper": 230, + "normal": 42, + "step": 3 + }, + { + "helper": 363, + "normal": 7, + "step": 4 + }, + { + "helper": 395, + "normal": 7, + "step": 5 + } + ], + "kind": "rank-8 paired input/output extractions" + }, + "stage3": { + "applier_sha256": "2509f1335e47543f8814b42d6bf83032b30c5899b4f7cc62a6adc03f5138ae13", + "count": 14, + "kind": "declared exactness-preserving gate rewrites (Jeremy Kothe, PR2957), re-addressed", + "rewrites_sha256": "a37ade675876e4f5b00b33066c84f495fccd264863b7eb5d813837b1d01c3e7d" + } + }, + "status": "CONDITIONAL_CANDIDATE_COMPLETE_FINITE_RELEASE", + "width_inventory": { + "4": 26, + "5": 2, + "6": 16, + "7": 52, + "8": 99, + "9": 213 + }, + "zero_buffers": 91 +} diff --git a/research/t148-carrier-skips/vendor/PR3042-MANIFEST.json b/research/t148-carrier-skips/vendor/PR3042-MANIFEST.json new file mode 100644 index 0000000000..7018d721f5 --- /dev/null +++ b/research/t148-carrier-skips/vendor/PR3042-MANIFEST.json @@ -0,0 +1,156 @@ +{ + ".gitattributes": "056f4f66161e333f3a8d4c20de323ca05599a7deac1aa02d47ba6f6b96335573", + "ALLOCATION-PINS.json": "7bb1494f220d2d5588e8563d1492f22678de8367ea981f1c2a4cc22d87a1cce0", + "CLAIM.json": "adb2efbaa7c16bf66aede2ac739e445e6fa974d5defbff8b70324f4f10632aa3", + "CREDITS.md": "8475f5e7c090e05196cfd6c2894516cbbedd5876f54193fea575d8064e23574e", + "EDIT-PINS.json": "11e15f1fd1f5ac263261c7834dcb2938da178b5c28070cc63b2fa7764ea0182a", + "NOTICE": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661", + "PINS.json": "79a82e455ef97c038169dd305fde230d935e007226083473b84413f74e49fdfe", + "README.md": "a7f24ba0b020afc394197ed2866f9958cfe6628c8b42bf84b09c98da0f681c85", + "RELEASE.json": "59e2e377b62aa785787f418b2bc196d48bc5824c5c4294af1387358642646bf5", + "SOURCES.json": "d5f3f498d4d34125bcaed14dafaceaff342223d511d1099993d5b217a147019c", + "TASK.json": "32c30a45ec317a55548c4f8d459d30ef9940c7787052e6a8b7b8ca2e31c18634", + "VERIFY.json": "5a07ba5f486929903fb736e96c3e1de562b2882876e64f9a32f5d657aae2b7f4", + "allocation/DISPATCH.json": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c", + "allocation/FILL.json.gz": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "allocation/ORDER.json": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1", + "allocation/PROFILE.json": "3245979197e965850eec803879f355a49738a60158cd7043fdc574e9fa810052", + "allocation/PROVIDERS.json": "04c9f2620178322010f7bafb30c669cad0be1426a905275d28a398398b596cd0", + "allocation/SEARCH.json": "2ceb1f825cb68e44d17d4251f74c3975ae5122c845391c1ca8de2e564ac4246a", + "allocation/baseline/CLAIM.json": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77", + "allocation/baseline/ORDER.json": "d559a1dcb83707724afc0310f6ef8e3a36ad6cda0a895ca6abae9d6f39a0fc76", + "allocation/baseline/PROFILE.json": "6de8ac1fd628cdd2afa5a43872da69c7dab9d7219bdc318f9db55fd8ccdb5eb2", + "allocation/vendor/PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "allocation/vendor/TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "allocation/vendor/independent_owners.py": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461", + "certificates/RELAX-CAP.json": "ef10b3d6481155eb3cd6f4ce3c82a6919fc5b5bce285d26cef39621989f22d9f", + "certificates/RELAX-STAGES.json": "0e5ec700a191b668ba3d4b6d675f5c047d264b9a5109fc55fa92961b3fcb7d68", + "check_allocation.py": "64b2bacd98728a25195d80e5be6c0374e24fba1400290edaafb895dcc5d54368", + "check_cap.py": "3f7901f4c1849074478df3c08ea98b792ae7325fd700948f01d80c11c9106893", + "comparators/PR2942-CLAIM.json": "011aaac80ad79f7f29dc429a672441bb6b3c21a68bbcb34c7a0d5f943c3c3c2e", + "comparators/PR2957-CLAIM.json": "a93e6c9e94bc9bf5664b5e23506dda9647fad1930e1eede66d5ba9f3718b598a", + "comparators/PR2966-CLAIM.json": "4d4c4800bf3bcb36d09021313b2712aebd4aa0830c74dda30991daf6851c220a", + "comparators/PR2979-CLAIM.json": "436e0d297cbdf195445d3697d496ac675e95210b79e70ce602a6a6667a4c6ce9", + "construction/STAGE-PRICES.json": "dfb7d06724bf95367f3fdb398f4828fc70f803d23030bc0eee0b00541457f546", + "construction/allocation/T37-FACE-MIX.json": "10598b7ea2e26fbd49db2b4d2f08122415fd6673b87fb7b458019d503ae60744", + "construction/allocation/T37-FLOW.json.gz": "765c6b774ca207f715dd5f579995700f4787c1f4eb92a7855bfc1424f683eca4", + "construction/allocation/T37-MODEL.json": "74849384ad2160f0402f6577e9d3ea849c21704abcf839af50f3353e141a4355", + "construction/allocation/T37-PATTERNS.json": "df09e4581d7ed73fa22253909197ceb26ced59333f50c008c822894a4082f0e4", + "construction/allocation/T37-SOLVER.json": "f56caa18e9638c568c57e699a8576fa6dcbdfe6ba54ae2da3fc8bc626168d863", + "construction/allocation/T74-CONTROLS.json": "0de2d067d957bbca2580566576030d4f10508b7827a0d83a0bd8c05f19b23bbf", + "construction/allocation/T74-OWNER-CHECK.json": "996234db3632983effc279a93cb5599a945688a3ea476fc9f88e3a714fb330be", + "construction/allocation/assemble.py": "57fcc8dd6f08b5557add7f34c0deb993574f71b3e565d6668085f1f65df5eccd", + "construction/allocation/controls.py": "9e10e5c21fab8ea2fdaf07ce92a141c4e6d63a7ef02d9de25bc9022ad1ae7998", + "construction/allocation/diag_lp.py": "59bfeb9586820f7b653370e20619760e23a4b170e4b7e14dc4e2abad9f5d9c61", + "construction/allocation/double.py": "8a89fafcd69cacb0a5a8d19a90d76f8740cf8f12585dc83796fcd8bc428dd94f", + "construction/allocation/fill17.py": "933be460381d65ea04a6e7f288f977ba22a7e4068b69494d65c38ccd7e5f4dbf", + "construction/allocation/providers_from_words.py": "8cf55c2859a626d86f21b447460321c19db92fec8e1f893b3cd37267f3b145fd", + "construction/allocation/round_mix.py": "0d0a423817b30fda9cceaa61b9bcc90e07710f9829e65098c9a31ed1734341bd", + "construction/records/derive_stage2.py": "f2518333cea351376ee094e8212b71ad753710d4038c55937a9e3bb212249f9e", + "construction/records/make_data.py": "b9528bcb26bc3c1a8e582032fa3899c79dc4cb463814dc6fea617fd83a5b4858", + "construction/records/make_prices.py": "5fcf593b5672b4f66cabd9d2bd5b4e843453248186d95794386331d801280b78", + "construction/search/codim2.py": "1dd77f4ceb0c4cf82ee5f3f4c04123724db09ebb0e7b9f856c4bd000d4e57531", + "construction/search/combine.py": "d06e041082f120b903937a8c7fdf2189eb42411330af625492ff5a24109b49d0", + "construction/search/deliver_l22.py": "b5f0a6ee2eaf1cbef95f0447efb08b75937e7e03c6d27d0b73d5c884c24a91b5", + "construction/search/final_l27.py": "e964d48e7b7705cc64a57bd42d81eb990d69606689349240e5a18155d08f7350", + "construction/search/lowerA.py": "1aba1edb5397701151b2c95afaf23cd8e675ddc48b5ccca1738bc0c5370e9a6c", + "construction/search/lowerA_joint.py": "eb0efbe0c40d063a606dc370362a8d3fe3f4f57877e2e79f63be940fe06ce41b", + "construction/search/realize.py": "6d524f4a1ce0a4bf77f8e5a859e46922334956688c9268dbea3004e3aea6898e", + "construction/search/vlower.py": "3052c96b4f00239fe679f460bbbad2b7271089b5aa73665cb92c052755143ec4", + "data/PARENT-base.json.gz": "54ca34c749e3228d7e2df3d8dbf7aa1568c2872490166997c5962f12fd03da35", + "data/PARENT-extra.json.gz": "eded756dfe8f411c3d1f80a3ac16516f0ea5dd6f9866728b2179b157630fa7b6", + "data/REWRITES-2957.json": "a37ade675876e4f5b00b33066c84f495fccd264863b7eb5d813837b1d01c3e7d", + "data/STAGE1-FRAME-EDITS.json": "5fbfce004330ebc1fbac8de264614fe295f1a074811b478db4892c3bc3852cd3", + "data/TRANSFORM-226.json": "1732a39728c068f9d663111c7876b4e0b96088f3dd3b8e6ff824551b5a711338", + "data/TRANSFORM-228.json": "82346e6a5173c4822e16b2dad06ca232111b6795a340079f9aceabe0098797c0", + "data/TRANSFORM-230.json": "8ad70d545695b5d2246fb9e09d46abcc1e42926c1161884f69b77f978a28f46d", + "data/TRANSFORM-363.json": "84d2a609739eb30d4d9356fb6f04b2ff32c8823a978d7a51db1ace1d6d2352cc", + "data/TRANSFORM-395.json": "065aa5d7713683942bc2156b543681857e33c6e2f30f32cba47e2cbb9d1bef69", + "data/WORD-base.json.gz": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "data/WORD-extra.json.gz": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7", + "edits/EDITS.json": "ebffcc1e57e59439b9678ff8d9be518c457af22ce77235c2fdb46540ab9b9b79", + "edits/FINAL-WORD-base.json.gz": "7e98f6f2a6c9ce9e7e04b515bd8ce4a4a533ff05f01ea265be2a1a994695260e", + "edits/FINAL-WORD-extra.json.gz": "1396410de482883416fc7f534062ab005b484056b035fdcfa3b5cc065536ba35", + "edits/declared_edits.py": "d3e49b844e9522808a439d505487839addbd957c7d1055bb57fa00e32cbba7b8", + "edits/edits_review.py": "41734b21dfef4fe9c0917e6afcfb2d0652a4a55583f9cbc300af0ffc275af28c", + "evidence/ADAPTER-DERIVATION.json": "a6c42ad0c10713baecc65853108bd4ba8c2295ef7fd85ad03a80d23a6561485a", + "evidence/ADMISSION-RESULT.json": "7f4f43db039b6d0e1dad7ed6549e0c77a97450f3e347db7ee4b60924c61b1187", + "evidence/ADMISSION-STAGES.json": "7ff279bbae26a36e917cf8d29646a436a470c9c6f535e3af4d7d8443767bbe52", + "evidence/EDITS-DERIVATION.json": "f4244fcbf21f41c54c053fb0719c1afaadafe0a5305f061fac6baa04d6da26b7", + "evidence/EDITS-REVIEW.json": "5e45e0108ad21b47d534c607e4da9200ea4f76a103b0c854542d006b711cadbe", + "evidence/ENVIRONMENT.json": "23f2e3174612fd8ad04b5af4bab5b840d50c0c93d68d1eccc4d66a2f9df36896", + "evidence/FULL-NATIVE-RECEIPT.json": "7e982591b1362efe5e8d03fd98f67ff4ef676dd8a5fa3ca765c8ef1370be7019", + "evidence/FULL-NATIVE-RESULT.json": "13990ed299092d7c1b1e963e83bbff11d0c5a68650284e5bba997e13009905a4", + "evidence/FULL-REPLAY-RESULT.json": "9bd72aa02d4665f7f24a356fdd03d8da767234d0b1f4e773000b5cf1a874b070", + "evidence/FULL-REPLAY-STAGES.json": "06b4071f46edb76550d3dd9a1c62cdb879effa305f80156ca89d9fa699b01679", + "evidence/OVERLAY-DERIVATION.json": "145a9491cca7b22f0d04cccb66795a7b6914a1ee415ecfc65e1db7b586573826", + "evidence/README.md": "2b6f99fc0d15d8575f30cff368aed0c2170da54135d7142641bdeceecb7ecdd5", + "evidence/RELEASE-RECEIPT.json": "906d15db82f7b5b8938d1b760f54d9229dc7b6f2dbe84cc9286f2d1015e36743", + "evidence/RUNTIME-PATCHES.json": "25a75bcbc9535bce28c14fbe2fdff6ab42ed7a8193da6d473258ebd53901315c", + "evidence/logs/admission-discovery.log.txt": "7323585286381c3a740f743bd8d34fbac261063475591750f2f6105da2b52b43", + "evidence/logs/admission-outer-check_ledger.py.log.txt": "c3a7a6c9d72696e898ec0e7ebb5327d4bcbb3796296c802fdd3cc52d4ea0ed76", + "evidence/logs/admission-outer-independent_check.py.log.txt": "f49a96248d35bbb371283a8e0f079783974a904c9f59f94b19eba156346cb87b", + "evidence/logs/admission-owners.log.txt": "748837990aea82c6fe4e65a6c342d29db8074c9f31fe59c24dbc0988c2e053eb", + "evidence/logs/admission-parent-lift.log.txt": "7b6249a123ca39fae7b7a6339dd9e8ae8777b081f4336418f2cc101704b70644", + "evidence/logs/admission-rebind.log.txt": "6fcad10d5896199b8a4b3d55e749a3c0d68c0ab709f55e54085de8326a04e7cf", + "evidence/logs/admission-release.log.txt": "805fce9a345ccdda3f35d6a902150f9c79e8156187999fb1e2adeaebd0d3b778", + "evidence/logs/complete-admission.log.txt": "f49b7c5a423df905b7639d736f092df2119f76c472c9e62d6a082ad5caf51752", + "evidence/logs/declared-edit-stage.log.txt": "e0d0595445e237ed99b78764aeb387fea1e7d4e1c5316fc78e49b2ebfc773de5", + "evidence/logs/derive-closed-adapters.log.txt": "e2e9b59cca255f95b2239ff3c9c0b7d5ec32308b7322cef7535ba4c399527bec", + "evidence/logs/export-pr2833.log.txt": "9064165a51df3c763c3ede7e4bb55ce4757e218eca0597fae78c2f9e7fd30030", + "evidence/logs/export-pr2894.log.txt": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "evidence/logs/four-kernel-stage.log.txt": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "evidence/logs/fresh-current-native.log.txt": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "evidence/logs/paired-extension-stage.log.txt": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "evidence/logs/parent-paired-stage.log.txt": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "evidence/logs/preload-stage.log.txt": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "evidence/logs/rank7-overlay-stage.log.txt": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "evidence/pr2979/ADAPTER-DERIVATION.json": "abfe60c965953c567392b587cbcc4703f2f80fc60e267539251a1eac0f9db2f3", + "evidence/pr2979/ADMISSION-RESULT.json": "be9652312a88fd670eb09a4303679b4e875516d02a008ce90ccbca8a92e6b2ac", + "evidence/pr2979/ADMISSION-STAGES.json": "bf2fcb3012c65d861ccc4ba5950e5b97cbff31f603268afdb7e9ae2a0ac9696f", + "evidence/pr2979/ENVIRONMENT.json": "c6faaaa9b538ddbf0ea3c624bbe2f1c7e4074f8cb504d4bee0f3353f1e7f32a1", + "evidence/pr2979/FULL-NATIVE-RECEIPT.json": "6d27c89d5e3a2c7f28387e4b20c462b0dff6c9fa92aacdde715d4b29cc286d41", + "evidence/pr2979/FULL-NATIVE-RESULT.json": "ee10e7b8f2196b3bd28f5389b9be3372c216f3cfe67e00c7a2bcd130746ac364", + "evidence/pr2979/FULL-REPLAY-RESULT.json": "0293261edd3696408e1067df358644a7f43fd05f6c7b78e255aeac3f4a2530a2", + "evidence/pr2979/FULL-REPLAY-STAGES.json": "d8764bbbc029b13e20dc881783c44b74c689064d9ddf8286fc18371f2ec0d503", + "evidence/pr2979/OVERLAY-DERIVATION.json": "145a9491cca7b22f0d04cccb66795a7b6914a1ee415ecfc65e1db7b586573826", + "evidence/pr2979/RELEASE-RECEIPT.json": "473a5f8e048e45d7e83747077a18985ef87d58da370ca3f2fe5748a057ffdb2d", + "evidence/pr2979/RETAINED-BOOTSTRAP-RECEIPT.json": "ba9ef5709319ceb54928aed10cb250f3d018b3f654a2902c53df27d9e2e1157f", + "evidence/pr2979/RUNTIME-PATCHES.json": "6e4fe608caae2cdc28abc0ab772514d03ede2a4a50b06e9ede2853ab6889f218", + "evidence/pr2979/logs/admission-discovery.log.txt": "68845b7e19574ee2040677640848f0f7aaf71854250dfe0470dfae3ff09210b3", + "evidence/pr2979/logs/admission-outer-check_ledger.py.log.txt": "c56f8e0232d749e0ff33b76a8f9de18d28a7bb3abcd736ba69a4b167f2b5a824", + "evidence/pr2979/logs/admission-outer-independent_check.py.log.txt": "7eab2e50c0b03f058ae320c4791a0ea5a0ae3eae3393d29971663428ca79547a", + "evidence/pr2979/logs/admission-owners.log.txt": "dc4840d279e447e42af2ece9437cb92ab13c7f631440911ca5e8a676e3fa418c", + "evidence/pr2979/logs/admission-parent-lift.log.txt": "7b6249a123ca39fae7b7a6339dd9e8ae8777b081f4336418f2cc101704b70644", + "evidence/pr2979/logs/admission-rebind.log.txt": "6126af0a7935a1605ddad6074978494d462ed67cbd54be809ce13fcb32469d67", + "evidence/pr2979/logs/admission-release.log.txt": "d1e575ccd284596605baf38e5ed5b751cd5f506572ef9cfc578bd88d917b46a0", + "evidence/pr2979/logs/complete-admission.log.txt": "37584a0aed98b08f491b676ba0e4914518027f556495b1ae4e8a9a123d360b4f", + "evidence/pr2979/logs/derive-closed-adapters.log.txt": "d11d75855720cfa75a26f667a61467b5122a7b7ae5521030509bf1cbdd00a496", + "evidence/pr2979/logs/export-pr2833.log.txt": "0fa7e0c6a0f0e31c60aadd0fe2afa6841d046d3272a02d3dc873f999b8508654", + "evidence/pr2979/logs/export-pr2894.log.txt": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "evidence/pr2979/logs/four-kernel-stage.log.txt": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "evidence/pr2979/logs/fresh-current-native.log.txt": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "evidence/pr2979/logs/fresh-retained-bootstrap.log.txt": "4a1625fdd9a947187583e67492c492f309e28669082f2e6f2aa97b5da345ea29", + "evidence/pr2979/logs/paired-extension-stage.log.txt": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "evidence/pr2979/logs/parent-paired-stage.log.txt": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "evidence/pr2979/logs/preload-stage.log.txt": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "evidence/pr2979/logs/rank7-overlay-stage.log.txt": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "producer.py": "d4577cee26314b36b59723cc68df9b8895b22449cc15807c95f325f555c4da3a", + "reproduce.py": "576152d744078d5cb66cded265c189691403f73b277ce2ed0e80708d77629eda", + "run_registered.py": "3439d214a163223c2ca7b50562bfb24b284551d5c8a36f4cc74791f890d4dd4a", + "structure.py": "83f63b6d9a1a543ecfa2c98d479dbe4e7a1c3caf6fd1c3566123308efbc32e96", + "tools/audit_allocation_moment.py": "c632527ecf092f013862660dbd7f52b599a50b321a8aa88ddc45af0547e79cb5", + "tools/build_edits.py": "7292e18bbbcd2fabc87ed423e3d5d648d03709d0a061563087786ad0d57fb832", + "tools/build_overlay.py": "9d98ace9bffb37aeebd05b93ed386f73e6eee169d960e4956cf14a66e6852140", + "tools/derive_adapters.py": "5c06828151cd230add3e328b42dda72c4a2ed1075bd2902f38ee28727870bc84", + "tools/relax.py": "0fed1c56b50a2e6d44deeeb6db0f1c7e1f71b86d1747130e1a9202216249a728", + "tools/relax_exact.py": "baf1855d6095c951a90d19a0d8094bd33290519940b732e2b758c5647830f044", + "tools/root.py": "55f5aca39b5ee2fe4687ac8863e6c24569010f27a332883c069b8e14b8fe09e3", + "tools/wordedit.py": "cae8ae0f5d7fb3387ec6922fe966068aae05e3a6d3586830d4361b650cfb3617", + "vendor/audit_local.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "vendor/declared_rewrites.py": "2509f1335e47543f8814b42d6bf83032b30c5899b4f7cc62a6adc03f5138ae13", + "vendor/preload_move.py": "c8fda4674644fcd5cbf39b6645ce148a21daa90a998b678cbe51f970b78b0044", + "verify.py": "5c6bdd35c81d9a2b3a12e020874a5d32e8b0783a3c35bff7a28d070586003401", + "verify_manifest.py": "723d726dbbe5b65a49caecae0f1aab664a1413fb639abfd3e826a5a538e14e5b", + "verify_release.py": "812c963df6434a370d1e8031af8d8d8e8acd1ae4ab36124edbbd8e3106ae86cf" +} diff --git a/research/t148-carrier-skips/vendor/PROVIDERS.json b/research/t148-carrier-skips/vendor/PROVIDERS.json new file mode 100644 index 0000000000..c0575e3903 --- /dev/null +++ b/research/t148-carrier-skips/vendor/PROVIDERS.json @@ -0,0 +1,842 @@ +{ + "extra": { + "actual_paid_profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "widths": [ + 9, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 9, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 6, + 6, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 6, + 6, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 6, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 6, + 6, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 5, + 5, + 8, + 8, + 8, + 8 + ] + }, + "gauge44": { + "actual_paid_profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "widths": [ + 9, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 9, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 6, + 6, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 6, + 6, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 6, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 6, + 6, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 5, + 5, + 8, + 8, + 8, + 8 + ] + } +} diff --git a/research/t148-carrier-skips/vendor/WORD-base.json.gz b/research/t148-carrier-skips/vendor/WORD-base.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..2ee02e318c98281a71445b954feccd55c153827c GIT binary patch literal 72539 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
o75;v46&M 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%0D*NJD#Jg6u+odl15SK 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 a;;3qwuG+a_gG#k&!%Od_;o?KvH~b%}O)h}| literal 0 HcmV?d00001 diff --git a/research/t148-carrier-skips/verify.py b/research/t148-carrier-skips/verify.py new file mode 100644 index 0000000000..4194901f65 --- /dev/null +++ b/research/t148-carrier-skips/verify.py @@ -0,0 +1,180 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact composition checks; complete releases remain mandatory for PASS. + +Geometry, frame accounting, cleanup and interval engines retain predecessor +credit. New here is their source-bound T148/PR3042 composition and its checks. +""" +import argparse +import copy +import gzip +import hashlib +import json +import sys +import types +from fractions import Fraction as Q +from pathlib import Path + +P = Path(__file__).resolve().parent +ROOT = P.parents[1] +PROFILE = {1: 3275388, 2: 948384, 3: 318948, 4: 143856, + 5: 27416, 8: 10656, 32: 1, 48: 56380} +LOCAL = {1: 2433, 2: 712, 3: 232, 4: 108, 5: 18, 8: 8} +HEAD = '84cc406ad91ec53fff329a11a445d7effe564a77' +SOURCE_SHA = '130650ad8833f6df88528c560e4d1cfbae084f4b15a64788a332ddcaff472a17' + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + + +def authenticate(): + for row in read(P / 'SOURCES.json')['files']: + if row.get('usage') == 'input': + need(sha(ROOT / row['path']) == row['sha256'], 'input drift: ' + row['path']) + for row in read(P / 'VENDOR.json'): + need(row['head'] == HEAD and sha(P / row['path']) == row['sha256'], 'exact PR3042 input') + + +def load(path, name): + module = types.ModuleType(name) + module.__file__ = str(path) + exec(compile(path.read_bytes(), str(path), 'exec'), module.__dict__) + return module + + +def baseline_modules(): + directory = ROOT / 'research/rank7-t740-release' + sys.path.insert(0, str(directory)) + materializer = load(directory / 'materialize.py', 'credited_materializer') + geometry = load(directory / 'verify.py', 'credited_geometry') + return materializer, geometry + + +def restore_action(gates): + rows = [{r: Q(1)} for r in range(704)] + for gate in gates: + if gate[0] == 'add': + _, target, source, n, d, _ = gate + scale = Q(n, d) + for key, value in list(rows[source].items()): + result = rows[target].get(key, Q(0)) + scale * value + if result: + rows[target][key] = result + else: + rows[target].pop(key, None) + else: + need(gate[0] == 'scale', 'restore primitive') + rows[gate[1]] = {k: Q(gate[2], gate[3]) * v for k, v in rows[gate[1]].items()} + return rows + + +def check_word(old, new, frames): + need(set(old) == set(new) and {k for k in old if old[k] != new[k]} <= + {'restore', 'report', 'cleanup'}, 'declared restore-only source change') + need(len(new['helper_final']) == 91 and new['helper_final'] == old['helper_final'] and + new['start_extra'] == old['start_extra'], 'same ordered native endpoint/entrance widths and91 buffers') + need(restore_action(old['restore']) == restore_action(new['restore']), 'exact704-column restore equality') + paid, inventory = frames.frame_report(new) + need(paid == new['report']['local_profile'] == {str(k): n for k, n in LOCAL.items()}, 'actual complete local tariff') + need(inventory == old['report']['width_inventory'] == new['report']['width_inventory'], 'unchanged inventory') + trimmed = copy.deepcopy(new) + trimmed['A'] = trimmed['A'][trimmed['prelude_events']:] + need(frames.derive_cleanup(trimmed, set(map(int, new['helper_final']))) == new['cleanup'], 'actual inverse cleanup') + + +def calculate(include_owners=True): + authenticate() + materializer, geometry = baseline_modules() + frames = load(ROOT / 'research/rank7-joint-endframes/vendor/preload_move.py', 'credited_frames') + controls = 0 + for tag in ['base', 'extra']: + old = read(ROOT / ('research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-' + tag + '.json.gz')) + new = read(P / ('vendor/WORD-' + tag + '.json.gz')) + check_word(old, new, frames) + for kind in ['sign', 'price']: + bad = copy.deepcopy(new) + if kind == 'sign': + index = next(i for i, g in enumerate(bad['restore']) if g[0] == 'add' and g[3]) + bad['restore'][index][3] *= -1 + else: + bad['report']['local_profile']['1'] -= 1 + try: + check_word(old, bad, frames) + except ValueError: + controls += 1 + else: + raise ValueError('word corruption accepted') + claim = read(P / 'vendor/PR3042-CLAIM.json') + providers = read(P / 'vendor/PROVIDERS.json') + old_providers = read(ROOT / 'research/rank7-t740-release/vendor/pr3015/allocation/PROVIDERS.json') + for name, provider in providers.items(): + need(provider['widths'] == old_providers[name]['widths'], 'every ordered helper width unchanged') + need({int(k): n for k, n in provider['actual_paid_profile'].items()} == LOCAL, 'provider actual tariff') + if include_owners: + producer = load(ROOT / 'research/rank7-t148-restore-release/verify.py', 'credited_t148_producer') + _, _, _, order, _, fill, dispatch = producer.allocation() + checker = producer.retained('geometry') + owner = checker.check(order, fill, {(s,r):p for s,r,p in dispatch}, + producer.read(producer.SOURCE / 'vendor/PLAN.json.gz'), + producer.read(producer.SOURCE / 'vendor/TEMPLATE.json.gz'), providers) + need(owner['profile'] == PROFILE and owner['roles'] == 543456, 'all actual T148 roles and paid children') + need(producer.stock(148)['physical'] == 133117, 'every physical family and91 buffers') + root = load(ROOT / 'research/rank7-joint-endframes/tools/root.py', 'credited_exact_root') + lower, upper = root.kappa_from_profile(PROFILE, 148) + C = Q((lower * 10**24).__floor__(), 10**24) + kappa = C - Q(1, 10**46) - Q(1, 10**70) + prior = Q(claim['kappa']) + need(kappa > prior and kappa < C <= lower < upper, 'strict exact gain over full PR3042 point') + need(root.moment(PROFILE, C + Q(1, 10**24), 132608)[0] > 1, 'larger endpoint rejected') + wrong = dict(PROFILE) + wrong[48] += 1 + need(root.moment(wrong, C, 132608)[0] > 1, 'unpaid rank48 charge rejected') + cap = materializer.load('vendor/pr3024/cap_proof.py', 'credited_cap') + cap.LOCAL = LOCAL + certificate = read(ROOT / 'research/rank7-joint-endframes/certificates/RELAX-CAP.json') + cap_lower, cap_upper = map(Q, [claim['fixed_inventory_cap']['cap_lower'], claim['fixed_inventory_cap']['cap_upper']]) + certificate.update(local_per_call={str(r): n for r, n in LOCAL.items()}, cap_lower=str(cap_lower), cap_upper=str(cap_upper)) + cap.verify_cap(certificate, root) + need(upper < cap_lower < cap_upper, 'honest positive gap below the fixed-inventory cap') + return dict(kappa=kappa, complex_lower=C, previous=prior, gain=kappa-prior, + root_lower=lower, root_upper=upper, word_controls=controls) + + +def run(math_only=False): + arithmetic = calculate() + if math_only: + print('PASS_FINITE_T148_CARRIER_COMPOSITION_NOT_A_RELEASE', str(arithmetic['gain'])) + return + claim = read(P / 'CLAIM.json') + need(claim['status'] == 'PASS_T148_CARRIER_SKIPS_COMPLETE_RELEASE', 'completed composition release') + for key in ['kappa', 'complex_lower', 'previous', 'gain']: + need(Q(claim[key]) == arithmetic[key], 'exact claim field: ' + key) + evidence = read(P / 'evidence/VALIDATION.json') + need(evidence['baseline_complete_release'] is True and evidence['composition_complete_release'] is True, + 'both complete release gates') + for filename, point, field in [('BASELINE-RELEASE-RECEIPT.json', + Q('0.001729152756004330934535')-Q(1,10**46)-Q(1,10**70), 'baseline_release_sha256'), + ('RELEASE-RECEIPT.json', arithmetic['kappa'], 'release_sha256')]: + receipt = read(P / 'evidence' / filename) + need(sha(P / 'evidence' / filename) == evidence[field] and receipt['status'] == 'PASS_RELEASE' + and Q(receipt['kappa_decimal']) == point, 'complete terminal release binding') + need(evidence['controls'] == dict(admission=139, bit=12, controller=25, independent_owner=8, geometry=6), + 'all actual rejecting controls') + print('PASS_T148_CARRIER_SKIPS', str(arithmetic['kappa']), 'gain=' + str(arithmetic['gain'])) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--math-only', action='store_true') + run(parser.parse_args().math_only) From a15dae275e2b2e26628c27972aad55c52d4a6b96 Mon Sep 17 00:00:00 2001 From: dataisfire <340375426+dataisfire@users.noreply.github.com> Date: Fri, 16 Oct 2026 21:29:53 +0000 Subject: [PATCH 4/5] Expose full verification through an existing manual CI entry point --- .github/workflows/prime-power-cyclic-inverse.yml | 5 +++++ .github/workflows/t148-carrier-full-release.yml | 1 + 2 files changed, 6 insertions(+) diff --git a/.github/workflows/prime-power-cyclic-inverse.yml b/.github/workflows/prime-power-cyclic-inverse.yml index 3f41b633a8..964cfd56ef 100644 --- a/.github/workflows/prime-power-cyclic-inverse.yml +++ b/.github/workflows/prime-power-cyclic-inverse.yml @@ -14,6 +14,11 @@ permissions: contents: read jobs: + t148-complete-verification: + if: github.repository == 'dataisfire/integer-mult-bounds' && github.ref_name == 'ci-t148-carrier-20261016' + uses: ./.github/workflows/t148-carrier-full-release.yml + permissions: + contents: read verify: runs-on: ubuntu-latest strategy: diff --git a/.github/workflows/t148-carrier-full-release.yml b/.github/workflows/t148-carrier-full-release.yml index 611900afe4..0223aeb0ce 100644 --- a/.github/workflows/t148-carrier-full-release.yml +++ b/.github/workflows/t148-carrier-full-release.yml @@ -4,6 +4,7 @@ on: branches: [ci-t148-carrier-20261016] paths: [.github/workflows/t148-carrier-full-release.yml] workflow_dispatch: + workflow_call: permissions: contents: read jobs: From 239447f19b9365194bca2583014c947db5de8ea4 Mon Sep 17 00:00:00 2001 From: dataisfire <340375426+dataisfire@users.noreply.github.com> Date: Fri, 16 Oct 2026 21:34:57 +0000 Subject: [PATCH 5/5] Clarify pending full release and scope verification workflow --- .github/workflows/prime-power-cyclic-inverse.yml | 5 ----- research/t148-carrier-skips/TASK.json | 4 ++-- 2 files changed, 2 insertions(+), 7 deletions(-) diff --git a/.github/workflows/prime-power-cyclic-inverse.yml b/.github/workflows/prime-power-cyclic-inverse.yml index 964cfd56ef..3f41b633a8 100644 --- a/.github/workflows/prime-power-cyclic-inverse.yml +++ b/.github/workflows/prime-power-cyclic-inverse.yml @@ -14,11 +14,6 @@ permissions: contents: read jobs: - t148-complete-verification: - if: github.repository == 'dataisfire/integer-mult-bounds' && github.ref_name == 'ci-t148-carrier-20261016' - uses: ./.github/workflows/t148-carrier-full-release.yml - permissions: - contents: read verify: runs-on: ubuntu-latest strategy: diff --git a/research/t148-carrier-skips/TASK.json b/research/t148-carrier-skips/TASK.json index 24dc059e98..f362e45aca 100644 --- a/research/t148-carrier-skips/TASK.json +++ b/research/t148-carrier-skips/TASK.json @@ -5,13 +5,13 @@ "base_commit": "43f2f05fc9a610ad6b76b3d3f60441448f5e212b", "bottleneck_link": "The source has unchanged packing patterns but its T74 fill is below its exact fractional cap. The released T148 literal fill strictly improves the T74 fill while retaining a positive gap to that cap with every larger-stock and prefix cost charged.", "budget_minutes": 150, - "evidence": "704-column restore equality and exact moment candidate; full owner and release verification pending.", + "evidence": "704-column restore equality, exact moment and full finite-owner verification passed; complete baseline and release verification pending.", "open_questions": [ { "blocked_by": "All inherited all-size/compiler, physical, precision/tape, caller and analytic obligations remain.", "first_step": "Change one explicit native restoration contract and price the complete replacement.", "question": "Can a further changed word improve the paid inventory?", - "why_it_matters": "The fixed-inventory cap is attained by this composition." + "why_it_matters": "This composition retains a positive gap to the fixed-inventory cap." } ], "original_card": {