diff --git a/.github/workflows/t148-carrier-full-release.yml b/.github/workflows/t148-carrier-full-release.yml new file mode 100644 index 0000000000..0223aeb0ce --- /dev/null +++ b/.github/workflows/t148-carrier-full-release.yml @@ -0,0 +1,59 @@ +name: T148 carrier complete verification +on: + push: + branches: [ci-t148-carrier-20261016] + paths: [.github/workflows/t148-carrier-full-release.yml] + workflow_dispatch: + workflow_call: +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/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+4= 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 0000000000..4f04836573 Binary files /dev/null and b/research/rank7-t148-restore-release/vendor/pr3015/FINAL-WORD-base.json.gz differ 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 0000000000..81f95e21ed Binary files /dev/null and b/research/rank7-t148-restore-release/vendor/pr3015/FINAL-WORD-extra.json.gz differ 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)) 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+4 + 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 0000000000..4f04836573 Binary files /dev/null and b/research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-base.json.gz differ 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 0000000000..81f95e21ed Binary files /dev/null and b/research/rank7-t740-release/vendor/pr3015/edits/FINAL-WORD-extra.json.gz differ 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)) 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..f362e45aca --- /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, 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": "This composition retains a positive gap to the fixed-inventory cap." + } + ], + "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 0000000000..2ee02e318c Binary files /dev/null and b/research/t148-carrier-skips/vendor/WORD-base.json.gz differ diff --git a/research/t148-carrier-skips/vendor/WORD-extra.json.gz b/research/t148-carrier-skips/vendor/WORD-extra.json.gz new file mode 100644 index 0000000000..33ba5f3499 Binary files /dev/null and b/research/t148-carrier-skips/vendor/WORD-extra.json.gz differ 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)