diff --git a/.github/workflows/p112-common-slice.yml b/.github/workflows/p112-common-slice.yml index 37f99ca573..1b393f8b73 100644 --- a/.github/workflows/p112-common-slice.yml +++ b/.github/workflows/p112-common-slice.yml @@ -15,8 +15,6 @@ jobs: if: github.repository == 'CrocSwap/integer-mult-bounds' runs-on: ubuntu-24.04 timeout-minutes: 20 - env: - TMPDIR: ${{ runner.temp }}/p112-common-slice steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 with: @@ -25,11 +23,14 @@ jobs: - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 with: python-version: '3.12' + - name: Configure runner temporary directory + run: | + mkdir -p "$RUNNER_TEMP/p112-common-slice" + printf 'TMPDIR=%s/p112-common-slice\n' "$RUNNER_TEMP" >> "$GITHUB_ENV" - name: Install native checker dependencies run: | sudo apt-get update -qq sudo apt-get install -y --no-install-recommends g++ libboost-dev - mkdir -p "$TMPDIR" g++ --version python --version - name: Replay the complete slice diff --git a/research/staged-release-retiming-t530/.gitattributes b/research/staged-release-retiming-t530/.gitattributes new file mode 100644 index 0000000000..d8af14b17d --- /dev/null +++ b/research/staged-release-retiming-t530/.gitattributes @@ -0,0 +1,2 @@ +# Preserve exact bytes of hash-pinned scientific sources and receipts. +* -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol diff --git a/research/staged-release-retiming-t530/CREDITS.md b/research/staged-release-retiming-t530/CREDITS.md new file mode 100644 index 0000000000..17eebfae27 --- /dev/null +++ b/research/staged-release-retiming-t530/CREDITS.md @@ -0,0 +1,11 @@ +# Credit and provenance + +The new contribution is the two commuting release retimings, their independent local proof, changed complete bill, source-bound T530 integration, and the public reproduction package. This work was prepared for GitHub user `roger-sato` with substantial OpenAI Codex assistance, including separate circuit, owner/packing and exact-math review agents. Those agent checks are not independent human peer review. No personal priority over inherited mathematical work is asserted. + +- Ross Richardson's [PR3605](https://github.com/CrocSwap/integer-mult-bounds/pull/3605), head `3efbb5de06a49ffeea6684482f2d3fe48cdca3fb`, supplies the staged helpers and both original words. Its lineage includes dcharb78's PR3133 and Jeremy Diviney's PR3148 work. +- hexapode's [PR3626](https://github.com/CrocSwap/integer-mult-bounds/pull/3626), head `659fd5e7064d9466b668d7188cbb013b333a415a`, supplies the actual T530 allocation, deterministic reconstruction, independent owner audit and complete release machinery. Its manifest and source notices are preserved in the relevant components. +- Ross Richardson's [PR3630](https://github.com/CrocSwap/integer-mult-bounds/pull/3630), head `bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608`, supplies the fixed-inventory basis/dual argument; PR3531 at `550a660a97308d3aeb3620ee1f4218f77e2c2742` supplies the retained positive-binomial interval engine. +- [PR3633](https://github.com/CrocSwap/integer-mult-bounds/pull/3633), head `46c5aaca40117a4ca90a3316771ae52cf9a6801e`, is relevant parallel work attaining the old fixed-inventory ceiling. Its allocation is a comparison and possible future composition, not an input to our achieved endpoint. +- Canonical main at `20ecf2891d80b5acf18d980b2164fb44ea7faa90` supplies the native, owner, outer and release infrastructure. The independent free-operator auditor is preserved from the rank7-coupled-586-588-carrier-fold lineage; its notice credits icekylinx with OpenAI GPT-6 Astra assistance. + +All retained notices, licenses and contributor lists remain in their component source trees. The original repository and this derivative package use Apache-2.0. Exact source bytes are retained where pinned; publication adapters are identified by original/public SHA256 provenance maps. Retained computational summaries are distinguished from fresh replay and from general mathematical assumptions. diff --git a/research/staged-release-retiming-t530/PROOF.md b/research/staged-release-retiming-t530/PROOF.md new file mode 100644 index 0000000000..54ec7d1ab7 --- /dev/null +++ b/research/staged-release-retiming-t530/PROOF.md @@ -0,0 +1,115 @@ +# Proof of the retiming improvement and its conditional transfer + +## 1. Claim and dependency boundary + +Under the same inherited theorem/implementation hypotheses as the pinned PR3626 release, replacing its two PR3605 staged suppliers by the words in `local-audit/words/` yields + +``` +κ = 0.001730394391813963415120 - 10^-46 - 10^-70 + = 17303943918139634151199999999999999999999998999999999999999999999999 + / 10000000000000000000000000000000000000000000000000000000000000000000000. +``` + +The proof has three distinct parts: an exact algebraic/frame change; a finite complete owner/invoice construction; and a conditional transfer using the inherited compiler and outer assumptions. The last part is not asserted unconditionally. All source pins, original proofs and executable obligations are in the sibling components and their notices. + +## 2. Exact word change + +Use zero-based B indices. In **both** base and extra words, at indices 591 and 592 replace + +``` +640 += 2*644 at P +496 -= 2*644 at P +``` + +by + +``` +496 -= 2*644 at P +640 += 2*644 at Q1. +``` + +At indices 641 and 642 replace + +``` +656 -= 660 at P +520 -= 2*660 at P +``` + +by + +``` +520 -= 2*660 at P +656 -= 660 at Q2. +``` + +Here `L = span(30)`, `P = span(429,30)`, `Q1 = span(423,65,20,10)` and `Q2 = span(427,96,24,6)` are the native GF(2) frame subspaces. Their dimensions are 1, 2, 4 and 4, with `L ⊂ P ⊂ Qi` in each case. These inclusions are checked by exact binary elimination, not numerical rank. + +For distinct registers t,u,s, elementary shears `I+c E_ts` and `I+d E_us` commute: both cross products of the two matrix units are zero because neither target is the shared source. This holds over the exact rational scalar model for arbitrary register inputs. Each displayed pair has that form. No warp is crossed and the involved registers have no warp. Moving the first gate after the second therefore preserves the exact operator. + +The delayed donor's original frame itinerary is `L → P → Qi`. Inspection of the complete intervening event sequence shows no intermediate contact, and `Qi` is already the next frame used by donor and pivot. The new itinerary is `L → Qi`, while the pivot still pays its existing `P → Qi` transition. Thus there is no frame decrease, uncharged new pivot transition, lost input or changed boundary frame. The independent minimal checker explicitly verifies these conditions and rejects frame, coefficient and interface mutations. + +Cleanup is regenerated by the required canonical inverse-reverse order at FULL. Only B, cleanup and the reported local profile change; A, cut, restore, warps, helper identities, entrance/final frames and all external interfaces remain identical. The old cleanup order is itself algebraically equivalent because its inverse shears commute; rejecting it is a canonical-format control, not evidence that its operator is wrong. + +## 3. Local recursive bill and exact operator coverage + +A frame jump by d dimensions contributes `H_d`. Each direct jump replaces `H1+H2` by `H3`; the two pairs produce + +``` +ΔH = -2H1 -2H2 +2H3 +old = {1:2439,2:726,3:224,4:102,5:20,8:8} +new = {1:2437,2:724,3:226,4:102,5:20,8:8}. +``` + +Rank mass remains 5,135, since `-2*1-2*2+2*3=0`. The width inventory remains `{4:26,5:2,6:18,7:52,8:97,9:213}` (408 helpers), and all 91 private zero buffers remain private and zero at exit. For `0 1. +``` + +They enclose the root between these adjacent exact decimal rationals without floating-point decisions. The lower endpoint with the two inherited strict margins is the stated κ. The source-bound modern outer arithmetic checks 63 strict inequalities and 17 rejection controls plus an independent balance derivation. The complete derivative release binds the changed providers, actual T530 ownership, physical invoice and modern endpoint; its outer gate independently replays 19 exact obligations. An inherited supplier-only intermediate endpoint is not substituted for this final modern endpoint. + +The seven scientific stages all completed with exit code 0 and terminal `PASS_RELEASE`. They operated on source-manifest SHA256 `fb47533a401d1d13719be8b9aab91fe5313931ca62d40dba336eab6a96275aa0`. Both the original scientific driver and the subsequently executed public full wrapper reproduced that source identity and completed all seven admission stages. The later wrapper run, at publication commit `abc12f62e4fe9bfcb2e33c84703253c918668351`, is separately recorded in [PUBLIC-FULL-REPLAY.json](PUBLIC-FULL-REPLAY.json). It freshly ran both changed native providers and regenerated the literal ownership construction, while authenticating and reusing the unchanged retained parent and two retained native chains. It adds end-to-end reproduction evidence without changing the algebraic argument, paid profile, endpoint or inherited assumptions. See the README for the limits of normalized recorded-evidence checks, including the omitted runtime archive bytes. + +## 6. Conditionality and what remains unproved + +This finite result retains the predecessor's all-size dispatcher/compiler assumptions; common-label/mutable-source realization and whole-call hosting; SCALAR/COPY/CLEAR and zero-allocation contracts; uniform coefficient and stock bounds; recursive rounded-precision arguments; bootstrap; tape/recovery; and analytic/BIT H1–H5 premises. Checking finite native instances, exact owner rows and inequalities does not itself prove those general assumptions. No independent human review or formal proof-assistant kernel certification is claimed. + +The additional packing certificate checks all 2551 patterns of the stated fixed helper inventory, with 2539 strictly positive reduced costs and 12 symbolic zeros. It bounds that relaxation's root by `0.001730418899766071163805`; it neither supplies a better achieved construction nor excludes improvements that alter the word, inventory or model. Combining this retiming with PR3633 remains an untested next question. diff --git a/research/staged-release-retiming-t530/PUBLIC-FULL-REPLAY.json b/research/staged-release-retiming-t530/PUBLIC-FULL-REPLAY.json new file mode 100644 index 0000000000..8a1199c574 --- /dev/null +++ b/research/staged-release-retiming-t530/PUBLIC-FULL-REPLAY.json @@ -0,0 +1,130 @@ +{ + "schema": "public-full-replay-summary/1", + "status": "PASS_PUBLIC_FULL_WRAPPER_END_TO_END", + "executed_publication_commit": "abc12f62e4fe9bfcb2e33c84703253c918668351", + "executed_wrapper_sha256": "9ec43247d2b3af6e4fce61173a4e59aa13b845792776289995cb108285f8aede", + "started_at": "2026-10-18T12:37:09.414302+00:00", + "finished_at": "2026-10-18T12:58:21.088357+00:00", + "wall_seconds": 1271.6689796670107, + "exit_code": 0, + "package_files_unchanged": true, + "environment": { + "python": "3.12.14", + "implementation": "CPython", + "platform": "macOS-27.0-arm64-arm-64bit", + "machine": "arm64", + "packages": { + "numpy": "2.5.4", + "scipy": "1.18.1", + "sympy": "1.14.0", + "mpmath": "1.3.0", + "gmpy2": "2.3.2", + "psutil": "7.2.2" + } + }, + "reproduction_command": "python3.12 -B research/staged-release-retiming-t530/full-admission/reproduce.py --repo . --work /tmp/fresh-retiming-full", + "external_allocation_supplied": false, + "wrapper_code_modified_for_this_run": false, + "source_manifest_sha256": "fb47533a401d1d13719be8b9aab91fe5313931ca62d40dba336eab6a96275aa0", + "source_files": 654, + "kappa": "17303943918139634151199999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "wrapper_status": "PASS_RETIMER_T530_COMPLETE_CONDITIONAL_RELEASE", + "admission_status": "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", + "release_status": "PASS_RELEASE", + "wrapper_stages": [ + { + "name": "original-materialization", + "exit_code": 0, + "seconds": 0.8973857500241138 + }, + { + "name": "retiming-source", + "exit_code": 0, + "seconds": 0.5103864170378074 + }, + { + "name": "preserved-staged-review", + "exit_code": 0, + "seconds": 0.22735691699199378 + }, + { + "name": "new-retiming-review", + "exit_code": 0, + "seconds": 0.6307750410051085 + }, + { + "name": "fresh-native", + "exit_code": 0, + "seconds": 51.058896915987134 + }, + { + "name": "literal-owners", + "exit_code": 0, + "seconds": 17.447704249992967 + }, + { + "name": "full-admission", + "exit_code": 0, + "seconds": 1195.7171897080261 + } + ], + "admission_stages": [ + { + "name": "owners", + "exit_code": 0, + "seconds": 22.98314816597849 + }, + { + "name": "parent-lift", + "exit_code": 0, + "seconds": 45.674995207984466 + }, + { + "name": "rebind", + "exit_code": 0, + "seconds": 4.468241333030164 + }, + { + "name": "discovery", + "exit_code": 0, + "seconds": 446.7887197919772 + }, + { + "name": "outer-check_ledger.py", + "exit_code": 0, + "seconds": 0.1444164999993518 + }, + { + "name": "outer-independent_check.py", + "exit_code": 0, + "seconds": 0.0577197500388138 + }, + { + "name": "release", + "exit_code": 0, + "seconds": 674.106729666004 + } + ], + "fresh_current_native_providers": 2, + "reused_retained_native_chains": 2, + "fresh_retained_parent": false, + "reused_retained_parent": true, + "literal_roles": 1946160, + "calls": 4770, + "replicas": 530, + "profile": { + "1": 11747920, + "2": 3453480, + "3": 1112042, + "4": 486540, + "48": 202828, + "5": 103690, + "8": 38160 + }, + "runtime_manifest_sha256": "9173c368581deec5a97b8be25608289fd9c50627c2041087386d58010b729081", + "original_release_receipt_sha256": "cfeb33c43399f1c89c477945e77d6e2b8562ac8341f13ff395381149edcfb173", + "fresh_receipts": "full-admission/fresh-replay/", + "fresh_evidence_sha256": "a79042409a73bd696bb3ef48655f9c4995de4fe5ef72eeb2b2e6fffbd0bdabaa", + "evidence_checker_sha256": "ec3f3d2e2fe6ae8d77399d6e2fa7f3cd834d9cb2e01871f89dbcedb24d260de7", + "scope": "A fresh local POSIX execution of the public wrapper from its published commit and a new external work directory, using the existing pinned environment. Both changed providers and the allocation were regenerated; retained native/parent chains were authenticated reuse. New compact receipts are separate from prior scientific and bounded-run records. The public evidence check validates recorded references, not omitted archives or a new scientific run. General inherited theorem assumptions and independent human review remain open." +} diff --git a/research/staged-release-retiming-t530/PUBLIC-OWNER-CONTROLS.json b/research/staged-release-retiming-t530/PUBLIC-OWNER-CONTROLS.json new file mode 100644 index 0000000000..952d7df281 --- /dev/null +++ b/research/staged-release-retiming-t530/PUBLIC-OWNER-CONTROLS.json @@ -0,0 +1,68 @@ +{ + "bounded_result": { + "kappa": "17303943918139634151199999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "owner_gate_disable_sensitivity_controls": 5, + "owner_semantic_gate_controls": 5, + "package_files_unchanged": true, + "profile": { + "1": 11747920, + "2": 3453480, + "3": 1112042, + "4": 486540, + "48": 202828, + "5": 103690, + "8": 38160 + }, + "rejected_recorded_cache_controls": [ + "empty cache inventory", + "empty provider cache subset" + ], + "scope": "Fresh finite local/operator, regenerated ownership/invoice, exact arithmetic and scoped packing checks; full native/controller/outer admission is retained evidence only in this command. Inherited general assumptions remain.", + "stages": [ + { + "exit_code": 0, + "seconds": 2.133318333013449, + "stage": "local" + }, + { + "exit_code": 0, + "seconds": 19.608519667002838, + "stage": "owner" + }, + { + "exit_code": 0, + "seconds": 0.29930454201530665, + "stage": "numerics" + }, + { + "exit_code": 0, + "seconds": 1.729215707979165, + "stage": "packing" + }, + { + "exit_code": 0, + "seconds": 0.06904937495710328, + "stage": "recorded-summary" + } + ], + "status": "PASS_STAGED_RELEASE_RETIMING_T530_BOUNDED_CHECKS" + }, + "date": "2026-10-19", + "finding": "https://github.com/CrocSwap/integer-mult-bounds/pull/3694", + "frozen_auditors_and_full_admission_unchanged": true, + "platform": "macOS-27.0-arm64-arm-64bit", + "prior_head": "044d24f12e74f228dd462c07ae2d7f3ea35e2be9", + "python": "3.12.14 (main, Aug 25 2026, 13:50:33) [Clang 22.1.3 ]", + "registered_commands_passed": 3, + "scope": "Fresh bounded registered package replay including all 1946160 owner rows, five actual production-gate semantic mutations and five gate-disable sensitivities. Old false-expression lambdas are not counted. No new kappa and no new full scientific replay; old complete replay stays separately dated.", + "semantic_gate_receipt_sha256": "fafd011475ad59b14d192c03cec3d02c0e46f213602b09352d869585b86e5f2e", + "source_sha256": { + "VERIFY.json": "2f127bf8cb39b56de040c1353bb462bc16ce5a20c7facd691c5b704822018777", + "owner-audit/DERIVATION.json": "a78896e12209bd8bcdb378ba69889f3e63d98ee27e598fbd01c1619f0946828b", + "owner-audit/independent_literal.py": "b51c36ad1ae0999547edc4726d698df369fef60daaaac4f5bbea471648c9f628", + "owner-audit/run.py": "c1afe53caf696d4f19ae4e515007dd497f85b46cd14aa224be8f32032635cfad", + "owner-audit/semantic_gate_controls.py": "5638f9eb05c19be43b6579aa82ab9c01e5648bfeb3d8963042ef6a463dc6e335", + "verify.py": "3a77186565cfee7f7b9e3c0bd02072e03c0b133bb9ca43f9e2418af6a17a5fd1" + }, + "status": "PASS_OWNER_SEMANTIC_CONTROL_CORRECTION" +} diff --git a/research/staged-release-retiming-t530/PUBLIC-VALIDATION-FOLLOWUP.json b/research/staged-release-retiming-t530/PUBLIC-VALIDATION-FOLLOWUP.json new file mode 100644 index 0000000000..194c6259ab --- /dev/null +++ b/research/staged-release-retiming-t530/PUBLIC-VALIDATION-FOLLOWUP.json @@ -0,0 +1,54 @@ +{ + "status": "PASS_STAGED_RELEASE_RETIMING_T530_BOUNDED_CHECKS", + "kappa": "17303943918139634151199999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "profile": { + "1": 11747920, + "2": 3453480, + "3": 1112042, + "4": 486540, + "5": 103690, + "8": 38160, + "48": 202828 + }, + "stages": [ + { + "stage": "local", + "exit_code": 0, + "seconds": 2.399136708001606 + }, + { + "stage": "owner", + "exit_code": 0, + "seconds": 20.673399958002847 + }, + { + "stage": "numerics", + "exit_code": 0, + "seconds": 0.3085460420115851 + }, + { + "stage": "packing", + "exit_code": 0, + "seconds": 1.8915963330073282 + }, + { + "stage": "recorded-summary", + "exit_code": 0, + "seconds": 0.07189666701015085 + } + ], + "package_files_unchanged": true, + "rejected_recorded_cache_controls": [ + "empty cache inventory", + "empty provider cache subset" + ], + "scope": "Fresh finite local/operator, regenerated ownership/invoice, exact arithmetic and scoped packing checks; full native/controller/outer admission is retained evidence only in this command. Inherited general assumptions remain.", + "environment": { + "python": "3.12.14", + "numpy": "2.5.4" + }, + "registered_package_status": "PASS_REGISTERED_RESEARCH_PACKAGE", + "additional_recorded_evidence_status": "PASS_RECORDED_FRESH_WRAPPER_CHAIN", + "additional_semantic_controls_status": "PASS_FOUR_FRESH_EVIDENCE_REJECTION_CONTROLS", + "note": "Separate follow-up bounded verification after adding the completed full-wrapper record; PUBLIC-VALIDATION.json remains the original publication check." +} diff --git a/research/staged-release-retiming-t530/PUBLIC-VALIDATION.json b/research/staged-release-retiming-t530/PUBLIC-VALIDATION.json new file mode 100644 index 0000000000..e5be56653c --- /dev/null +++ b/research/staged-release-retiming-t530/PUBLIC-VALIDATION.json @@ -0,0 +1,48 @@ +{ + "status": "PASS_STAGED_RELEASE_RETIMING_T530_BOUNDED_CHECKS", + "kappa": "17303943918139634151199999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "profile": { + "1": 11747920, + "2": 3453480, + "3": 1112042, + "4": 486540, + "5": 103690, + "8": 38160, + "48": 202828 + }, + "stages": [ + { + "stage": "local", + "exit_code": 0, + "seconds": 2.23428725003032 + }, + { + "stage": "owner", + "exit_code": 0, + "seconds": 19.858183250005823 + }, + { + "stage": "numerics", + "exit_code": 0, + "seconds": 0.3183805840089917 + }, + { + "stage": "packing", + "exit_code": 0, + "seconds": 1.709134666947648 + }, + { + "stage": "recorded-summary", + "exit_code": 0, + "seconds": 0.06325900001684204 + } + ], + "package_files_unchanged": true, + "scope": "Fresh finite local/operator, regenerated ownership/invoice, exact arithmetic and scoped packing checks; full native/controller/outer admission is retained evidence only in this command. Inherited general assumptions remain.", + "environment": { + "python": "3.12.14", + "numpy": "2.5.4" + }, + "registered_runner_status": "PASS_REGISTERED_RESEARCH_PACKAGE", + "metadata_status": "PASS_PACKAGE_METADATA_AND_PINS" +} diff --git a/research/staged-release-retiming-t530/README.md b/research/staged-release-retiming-t530/README.md new file mode 100644 index 0000000000..225d848dba --- /dev/null +++ b/research/staged-release-retiming-t530/README.md @@ -0,0 +1,83 @@ +# Two commuting release retimings: a conditional T530 improvement + +The two staged suppliers from [PR3605](https://github.com/CrocSwap/integer-mult-bounds/pull/3605) admit an exact change of gate order and frame itinerary. In each invocation it replaces `2H1 + 2H2` by `2H3`, while preserving the operator, helper identities, entrance/final frames and width inventory. Applying that change to the actual 4,770-call allocation of [PR3626](https://github.com/CrocSwap/integer-mult-bounds/pull/3626) gives + +```text +κ = 0.001730394391813963415120 − 10^-46 − 10^-70 +``` + +The improvement over that pinned direct predecessor is **0.00000032252710818353258**, or about **0.0186424%**. This is an achieved *conditional finite construction and transfer certificate*, subject to the inherited hypotheses below. It is not an unconditional multiplication theorem, an independently reviewed result, or a global-best/priority claim. This package does not update the selected frontier. + +[PROOF.md](PROOF.md) gives the exact edits, commuting argument, legal nested frames, complete paid profile, rational root enclosure and transfer dependency chain. [CREDITS.md](CREDITS.md) identifies inherited and parallel work. + +## Source and scope + +| Source | Exact pin | Role | +| --- | --- | --- | +| Canonical main | `20ecf2891d80b5acf18d980b2164fb44ea7faa90` | Native, allocation and admission infrastructure | +| PR3605 | `3efbb5de06a49ffeea6684482f2d3fe48cdca3fb` | Both original staged suppliers | +| PR3626 | `659fd5e7064d9466b668d7188cbb013b333a415a` | T530 allocation and complete release driver | +| PR3633 | `46c5aaca40117a4ca90a3316771ae52cf9a6801e` | Comparison only; its T488 allocation is not used | + +The direct predecessor endpoint is `0.001730071864705779882540 − 10^-46 − 10^-70`. PR3633 subsequently attained the old fixed-inventory ceiling at `0.001730096363528623534230 − 10^-46 − 10^-70`. Our result changes the local bill underlying that ceiling; no untested composition with PR3633 contributes to the claimed value. The larger difference from selected main's `0.001672660197076918` includes inherited improvements and is not attributed to this work. + +This was user-directed research. `TASK.json` retrospectively classifies it under the nearest `scalar-to-moment` card, with refined scope; it is not a claim that the task picker assigned this experiment. An overlap refresh on 2026-10-18 covered 348 open PRs and 2,454 discussions, plus local records; this search does not certify novelty. + +## Reproduce the bounded public checks + +From the repository root, with Python 3.12 and NumPy 2.5.4 installed: + +```sh +python3 -B scripts/research_package.py --package research/staged-release-retiming-t530 --check-only +python3 -B scripts/research_package.py --package research/staged-release-retiming-t530 +``` + +The original publication run passed all five stages in about 24.2 seconds, with no package writes; see [PUBLIC-VALIDATION.json](PUBLIC-VALIDATION.json). The follow-up bounded run also passed the added full-wrapper index, receipt-chain and rejection checks; see [PUBLIC-VALIDATION-FOLLOWUP.json](PUBLIC-VALIDATION-FOLLOWUP.json). These are bounded local checks, separate from hosted CI and the full scientific replay. + +The second command invokes `verify.py`, which creates a fresh temporary output directory outside the package and performs the following checks. It also checks the separate full-replay index and rejects incomplete recorded cache inventories. The registered verification then checks the new full-wrapper receipt chain and its four semantic rejection controls. Each component can also be run separately using its README. + +| Component | Freshly checked by the bounded command | Retained evidence / limit | +| --- | --- | --- | +| [local-audit](local-audit/README.md) | Minimal commuting/frame proof, both complete free-operator words, 632 arbitrary input columns, both orientations, 91 zero buffers and negative controls | Complete native receipts are authenticated, not rerun here | +| [owner-audit](owner-audit/README.md) | Reconstruct 1,946,160 literal roles; independently check ownership, windows, families, chronological prefixes, capacities and full invoice; five production-gate mutation tests and five gate-disable sensitivity tests | Native frame tables are authenticated inputs; mutation tests execute isolated production predicates, not whole corrupted journals | +| [numerics](numerics/README.md) | Two rational root engines; 63 strict transfer inequalities, 17 rejection controls and independent balance derivation | Arithmetic alone does not prove the physical circuit | +| [packing-cap](packing-cap/README.md) | All 2,551 fixed-inventory patterns, exact dual and ceiling interval | A scoped relaxation bound, not a higher achieved κ | +| [full-admission](full-admission/README.md) | Public-file integrity and cross-bound recorded-summary checks | Does not rerun or reauthenticate the omitted complete runtime archive | + +The registered dependency closure includes the 13 pinned main files actually used by the bounded owner replay. Self-contained components authenticate their vendored inputs. The longer full replay has a separately pinned closure in `full-admission/MAIN-INPUTS.json`; it is not the bounded CI command. + +### Owner-control correction following PR3694 + +[Sagar Thakrar's PR3694](https://github.com/CrocSwap/integer-mult-bounds/pull/3694) identified a test-coverage defect in the inherited owner auditor. Its five old rejection lambdas evaluate constructed false expressions without calling the real validation gates. We independently reproduced the defect: disabling all five corresponding production predicates still leaves those old controls passing. The earlier descriptions of them as five effective rejection controls were incorrect. The normal ownership and invoice checks remain present; this finding does not itself change the profile or κ. + +The bounded owner replay now executes an owned companion against the regenerated data. It extracts the five actual unconditional validation statements from the authenticated auditor, rejects changed helper identity, strict-window endpoint, same-call family, pending prefix and histogram inputs, and verifies that disabling each respective gate makes its negative test fail. These are explicitly gate-level semantic tests. The frozen upstream and derived auditors, old receipts and full-admission source manifest retain their original bytes. The separate seven-stage full-admission owner check uses a different retained auditor; its earlier run is not relabelled as a fresh replay by this correction. + +All three registered commands passed locally on 2026-10-19 with Python 3.12.14 / NumPy 2.5.4. The five fresh bounded stages took 23.84 seconds, including complete owner reconstruction and audit in 19.61 seconds; package files remained unchanged. [PUBLIC-OWNER-CONTROLS.json](PUBLIC-OWNER-CONTROLS.json) binds the changed code and this run, and [the semantic-control receipt](owner-audit/evidence/SEMANTIC-CONTROLS-FOLLOWUP.json) records each mutation, production predicate and sensitivity result. This is a new bounded validation record, separate from the earlier complete scientific replay. + +## Full scientific replay and recorded results + +The original scientific run freshly checked both changed native providers and completed all seven admission stages with exit code 0. Terminal statuses were `PASS_RELEASE` and `PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE`. The stages took approximately 23.31, 47.11, 4.60, 483.59, 0.11, 0.02 and 661.05 seconds (about 20.3 minutes total, excluding the earlier native checks). Two unchanged native chains and the retained parent chain were authenticated and reused. The newly checked native results were reused within the admission run through authenticated caches. + +The complete run checks 4,770 calls, 1,946,160 roles, 474,880 live registers and 475,389 physical registers. Its global prefix bound is 1,479 bits; 1,512 reserve bits are required, within the 2,048-bit paid payload. The outer release independently replays 19 exact obligations. The release also reports 139 admission, 12 BIT, 15 controller, 8 independent-owner, 6 geometry and 8 reconstruction rejection controls. See the component receipts for their exact scope rather than interpreting every PASS as independent proof of the whole theorem. + +The public reproduction wrapper reconstructs the same **654-file source manifest**: + +```text +fb47533a401d1d13719be8b9aab91fe5313931ca62d40dba336eab6a96275aa0 +``` + +The published all-in-one wrapper at commit `abc12f62e4fe9bfcb2e33c84703253c918668351` subsequently completed end to end in a fresh external work directory, without a supplied allocation or a wrapper code fix. It freshly ran both changed native providers, regenerated all 1,946,160 literal owner roles and completed all seven admission stages. Its seven wrapper stages all exited 0, ending in `PASS_RETIMER_T530_COMPLETE_CONDITIONAL_RELEASE` and terminal `PASS_RELEASE` with the same source manifest and exact κ. All 295 tracked package files remained unchanged during the run. + +This separate replay took **1,271.668979667 seconds (21 minutes 11.67 seconds)** on local macOS 27.0 arm64 with Python 3.12.14, from 2026-10-18 12:37:09.414302 to 12:58:21.088357 UTC. [PUBLIC-FULL-REPLAY.json](PUBLIC-FULL-REPLAY.json) records its environment and evidence separately from the earlier bounded and scientific runs. The unchanged retained parent and two retained native chains were authenticated and reused; no fresh retained bootstrap or independent external reproduction is claimed. [full-admission/README.md](full-admission/README.md) gives exact complete replay and recorded-evidence check commands. The full replay remains a long command outside generic CI, with enough RAM and disk needed for regenerated runtime files. + +To keep the public contribution small, it omits regenerated source/runtime/cache archives and the large generated literal fill. Actual non-main dependencies needed for reconstruction are vendored with pins and notices. Public command metadata replaces this session's private execution prefix with `$RESEARCH_WORKSPACE`; original-to-public SHA256 maps make those adapters explicit. The original full release receipt SHA256 was `80e1f422359d7c553493c1e0f2a1b4c4de230f8eb74690e1471a14d65169d110`. A normalized public summary is a publication derivative, not that original byte-level receipt chain. The subsequent public-wrapper replay has a separate receipt/provenance record and does not overwrite that historical evidence or `PUBLIC-VALIDATION.json`. Reproduction regenerates the full chain; the quick recorded-evidence checkers make only their stated narrower claims. + +## Remaining assumptions + +All inherited all-size dispatch/compiler and recursive rounding arguments remain hypotheses. So do common-label and mutable-source realization, whole-call hosting, SCALAR/COPY/CLEAR and zero-allocation contracts, uniform coefficient/stock bounds, bootstrap, precision, tape/recovery, and the analytic/BIT H1–H5 premises. The finite symbolic and integer checks certify their stated finite instances and implications; they do not discharge those general premises. No formal-kernel proof or independent human review is claimed. The supplier-only endpoint `0.001727405299371541` in an inherited intermediate receipt is a different layer; the final source-bound modern outer certificate uses the κ displayed above. + +## Open next questions + +1. **Compose the retimed suppliers with PR3633's T488 allocation.** This may close some of the remaining fixed-inventory gap. First bind these exact words into its pinned release, regenerate all ownership/invoice artifacts, and rerun native/controller/outer admission. Blocker: this composition has not been tested; do not quote its predicted endpoint as achieved. +2. **Find another legal operator/order or helper-inventory change.** The present fixed-inventory relaxed root lies in `(0.001730418899766071163804, 0.001730418899766071163805)`, only about `2.4507952e-8` above the actual T530 root. First enumerate further adjacent commuting opportunities and derive their complete frame itineraries. Blocker: scalar savings alone do not change the paid profile. +3. **Discharge an inherited all-size obligation.** An improved finite certificate remains conditional. First isolate one compiler/common-label or rounded-precision implication and provide an independently checkable general proof. Blocker: current finite native and arithmetic checks are not that general proof. diff --git a/research/staged-release-retiming-t530/SOURCES.json b/research/staged-release-retiming-t530/SOURCES.json new file mode 100644 index 0000000000..e7ac22c3cc --- /dev/null +++ b/research/staged-release-retiming-t530/SOURCES.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "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/coupled-carrier-cap740/cap_check.py", + "usage": "input", + "git_blob": "8e06e8fadd03e943564322f2a75196d9007b5b47", + "sha256": "c2a2ea7df9ef2f7c7ae2739435f4ac44f2c912d8e18fc9278c717958f258ee38" + }, + { + "path": "research/coupled-carrier-cap740/common.py", + "usage": "input", + "git_blob": "deb060b34f6bd0e7a41d02cef6e01b13b99444a1", + "sha256": "8786495cbf808d950be1c42e42d0198e950e44167af80063d25fd186aafea534" + }, + { + "path": "research/coupled-carrier-cap740/vendor/PR3133-CAP.json", + "usage": "input", + "git_blob": "804edbf26529d259e473ec5c79b7755370001cdc", + "sha256": "e32f3ecd5e6594935583f80f643cf1930e8bc017e3c541025c335395a15cf19c" + }, + { + "path": "research/coupled-carrier-cap740/vendor/PR3133-CREDITS.md", + "usage": "input", + "git_blob": "24f00912d4ec829c3c8d2a8d086aa135664a124c", + "sha256": "1d9d8f56d8899f55878e4cb2c4e052b22506444016a51c2e678773505f5189e6" + }, + { + "path": "research/coupled-carrier-cap740/vendor/PR3133-FILL.json.gz", + "usage": "input", + "git_blob": "92b49b42b8f381d686a9fb8057e74e4b7548cd5c", + "sha256": "68b8bae90144248774b1920cd27f9519caa3dc427704d8a9da6d4c491d912fc4" + }, + { + "path": "research/coupled-carrier-cap740/vendor/PR3133-NOTICE", + "usage": "input", + "git_blob": "89c20926ea7f803718f751d95989d5a269908efd", + "sha256": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661" + }, + { + "path": "research/coupled-carrier-cap740/vendor/PR3133-PROVIDERS.json", + "usage": "input", + "git_blob": "0b2343675099d0a9fe90da6e1f1e53f50235567e", + "sha256": "52eb0d85caa7b2d4a93acdf5011f52b793f61ddca86235fb03cd9a09397ad4cd" + }, + { + "path": "research/coupled-carrier-cap740/vendor/lift.py", + "usage": "input", + "git_blob": "717067dfce61c530205e8dad7ab3e76376f2c179", + "sha256": "ae6c1fee78fbdec26976ca74ca89f6aab2528d763c596f6573132cb54d57cd3c" + }, + { + "path": "research/rank7-joint-endframes/allocation/DISPATCH.json", + "usage": "input", + "git_blob": "9544fee4e6ee1f202cee22bfaeaf229ee3b2515e", + "sha256": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c" + }, + { + "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/rank7-joint-endframes/allocation/vendor/independent_owners.py", + "usage": "input", + "git_blob": "16013201b19054f7e45398ecf10af74c9c6a9114", + "sha256": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461" + } + ] +} diff --git a/research/staged-release-retiming-t530/TASK.json b/research/staged-release-retiming-t530/TASK.json new file mode 100644 index 0000000000..ea140071e1 --- /dev/null +++ b/research/staged-release-retiming-t530/TASK.json @@ -0,0 +1,71 @@ +{ + "schema_version": 1, + "task_id": "scalar-to-moment", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "original_card": { + "id": "scalar-to-moment", + "question": "Can one known scalar simplification be converted into an actual paid-profile improvement?", + "starting_points": [ + "research/r439-bsection-stars-seed01/README.md", + "certificates/selected-result.json" + ], + "methods": [ + "Derive the changed legal frame itinerary and exact child histogram.", + "Prove a scoped obstruction showing why that scalar gain cannot change the paid contract." + ], + "acceptance_gate": "An unchanged histogram is not a kappa gain; record any separate runtime or proof benefit explicitly.", + "first_step": { + "command": [ + "python3", + "-B", + "research/r439-bsection-stars-seed01/verify.py" + ], + "expected": "PASS_R439_BSECTION_STARS", + "inspect": "Observe that the positive control improves scalar counts while retaining the paid histogram.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Choose one simplification and derive the complete changed frame itinerary, or prove why it cannot change the histogram.", + "bottleneck_link": "A legal change to the histogram, not addition count alone, is the bridge to an exponent gain.", + "allowed_variations": [ + "One existing scalar simplification and one proposed frame-path change." + ], + "scope_change_triggers": [ + "Submitting only another scalar count as completion of a paid-profile task." + ], + "overlap_terms": [ + "scalar simplification", + "paid profile", + "R439" + ] + }, + "scope_status": "refined", + "actual_scope": "Retiming two commuting release pairs in both PR3605 suppliers, deriving the changed complete T530 paid profile and conditional outer endpoint, and publishing reproducible evidence.", + "scope_change_reason": "Retrospective nearest-card classification of explicit user-directed research, not a task-picker assignment. The known staged suppliers replace the card example; the actual bottleneck is a legal frame-itinerary change rather than scalar-count reduction.", + "bottleneck_link": "The direct 1-to-4 frame jumps replace two H1+H2 pairs by two H3 children, strictly lowering the moment while preserving allocation interfaces.", + "stop_rule": "Stop this scoped contribution after exact local proof, full source-bound T530 release, independent arithmetic/owner checks, reproducible publication and explicit unresolved assumptions; do not infer untested compositions.", + "outcome": "completed", + "evidence": "PROOF.md; local-audit/; owner-audit/; numerics/; packing-cap/; full-admission/. The published full wrapper also completed end to end at abc12f62e4fe9bfcb2e33c84703253c918668351; PUBLIC-FULL-REPLAY.json records this separate local run with fresh changed native providers and regenerated literal ownership, while the unchanged retained parent and two retained native chains were authenticated and reused. The finite conditional construction is complete; all-size premises, external reproduction and independent review remain open.", + "author": "roger-sato", + "ai_assistance": "Substantial OpenAI Codex assistance for search, exact proof, code, independent agent cross-checks, integration and documentation; no independent human review claimed.", + "open_questions": [ + { + "question": "Compose with PR3633 T488 ownership.", + "why_it_matters": "May close the remaining fixed-inventory gap.", + "first_step": "Bind these exact words into its pinned source and regenerate full admission.", + "blocked_by": "Composition and complete release have not been tested." + }, + { + "question": "Find another legal word/order or inventory change.", + "why_it_matters": "The current fixed-inventory relaxation leaves only about 2.45e-8 root headroom.", + "first_step": "Derive complete frame itineraries for further commuting candidates.", + "blocked_by": "Scalar savings alone do not establish a paid-profile gain." + }, + { + "question": "Discharge an inherited all-size obligation.", + "why_it_matters": "The achieved finite certificate remains conditional.", + "first_step": "Isolate and prove a compiler/common-label or precision implication.", + "blocked_by": "Finite replays do not constitute a general proof." + } + ] +} diff --git a/research/staged-release-retiming-t530/VERIFY.json b/research/staged-release-retiming-t530/VERIFY.json new file mode 100644 index 0000000000..aabd0c28a8 --- /dev/null +++ b/research/staged-release-retiming-t530/VERIFY.json @@ -0,0 +1,58 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [ + "numpy==2.5.4" + ], + "inputs": [ + "research/coupled-carrier-cap740/cap_check.py", + "research/coupled-carrier-cap740/common.py", + "research/coupled-carrier-cap740/vendor/PR3133-CAP.json", + "research/coupled-carrier-cap740/vendor/PR3133-CREDITS.md", + "research/coupled-carrier-cap740/vendor/PR3133-FILL.json.gz", + "research/coupled-carrier-cap740/vendor/PR3133-NOTICE", + "research/coupled-carrier-cap740/vendor/PR3133-PROVIDERS.json", + "research/coupled-carrier-cap740/vendor/lift.py", + "research/rank7-joint-endframes/allocation/DISPATCH.json", + "research/rank7-joint-endframes/allocation/ORDER.json", + "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "research/rank7-joint-endframes/allocation/vendor/independent_owners.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Fresh local operator/frame proof and controls, literal owner reconstruction/audit with five actual-gate semantic mutations and five gate-disable sensitivity tests, two exact moment engines and transfer, all2551 packing patterns, plus narrow recorded-summary consistency; not a full native/admission replay." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/full-admission/fresh_replay_evidence.py", + "check", + "--root", + "{package}/full-admission/fresh-replay" + ], + "timeout_seconds": 30, + "checks": "Check the separately recorded completed public-wrapper receipt chain." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/full-admission/fresh_replay_evidence.py", + "controls", + "--root", + "{package}/full-admission/fresh-replay" + ], + "timeout_seconds": 30, + "checks": "Reject unfinished attempt, external allocation, missing nested gate and stale terminal receipt at semantic predicates." + } + ] +} diff --git a/research/staged-release-retiming-t530/full-admission/ARCHIVE-OMISSIONS.json b/research/staged-release-retiming-t530/full-admission/ARCHIVE-OMISSIONS.json new file mode 100644 index 0000000000..86a5b83189 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/ARCHIVE-OMISSIONS.json @@ -0,0 +1,17 @@ +{ + "archives": { + "admitted-package.tar.gz": { + "bytes": 80312588, + "original_sha256": "f241147afc11ddb69b35ca331b473490d73d99ff5f32b24e2bcc64a19e0faa9a" + }, + "derived-source.tar.gz": { + "bytes": 30592850, + "original_sha256": "bb0c77c2b31412affe09217636188d11741a8470692517b01a9cca0200dab8fc" + }, + "native-cache.tar.gz": { + "bytes": 1833263, + "original_sha256": "33a48e1004ee2376920e9f28db14fe3b26afb296a2226667f7b992fa8fefd8a4" + } + }, + "scope": "Original generated archives intentionally omitted from this public derivative; hashes are historical provenance, not proof of public payload availability. All scientific gates remain in the separate full replay recipe." +} diff --git a/research/staged-release-retiming-t530/full-admission/LICENSE b/research/staged-release-retiming-t530/full-admission/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/staged-release-retiming-t530/full-admission/MAIN-INPUTS.json b/research/staged-release-retiming-t530/full-admission/MAIN-INPUTS.json new file mode 100644 index 0000000000..688aa927f7 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/MAIN-INPUTS.json @@ -0,0 +1,546 @@ +{ + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "scope": "Frozen ancestor bytes exported explicitly by reproduce.py; no unmerged PR Git objects or network access required.", + "sha256": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "research/adaptive-kernel-demotion/inputs/PR589-EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "research/adaptive-kernel-demotion/local/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "research/anticipatory-dirty-borrowing/NOTICE.md": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422", + "research/anticipatory-dirty-borrowing/operators.py": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988", + "research/anticipatory-dirty-borrowing/replay.py": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7", + "research/aphase-residue-composition/.gitattributes": "705fd4d6451a31d36b3df7de96f83f30ac976c9b4a6d1e51671d8e2f33e2d0da", + "research/aphase-residue-composition/data/DISPATCH.json": "2d178ebfbf3147d1f844897c779d151e04a0b9f480cbf57b76add4a24b8858ee", + "research/aphase-residue-composition/data/ORDER.json": "30856f042860e5b5c613357b236ff643f107d7d70e2c64eb5fcaaa09bf81a90d", + "research/aphase-residue-composition/evidence/full/candidate/release/verify/GEOMETRY-CONTROLS.json": "13a50b2f2448931ca302a55e5839c082f651331f20402448fe6ff29d1eb2f481", + "research/aphase-residue-composition/evidence/full/native/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7", + "research/aphase-residue-composition/evidence/full/native/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a", + "research/aphase-residue-composition/evidence/full/native/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CANONICAL-WORD.json.gz": "e38e2136e5a4a75bb843735a59158543eff04bd06384d73752b220d6938af73d", + "research/aphase-residue-composition/evidence/full/native/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-RECIPES.json": "cf410b60c9e3d9e7f99d94b5b28c4e3ae61c4b32892df4e03257b60fe5a37b02", + "research/aphase-residue-composition/evidence/full/native/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/FULL-WORD.json.gz": "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905", + "research/aphase-residue-composition/evidence/full/native/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/INDEPENDENT-LOCAL-REPLAY.json": "39874d664110d1ee85da901e2cd56e7cd0f27e0153813d4608c98122a90815da", + "research/aphase-residue-composition/evidence/full/native/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-CHECKS.json": "ef01cb5b6d1779518282c69a20d1dbcdbf57cb89ba616e2101bb209b37d80286", + "research/aphase-residue-composition/evidence/full/native/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-PROGRAMS.json.gz": "26c2fd119125bfca1ae655bb8a57df064da250370e60a85e1e8e8c4649e6a904", + "research/aphase-residue-composition/evidence/full/native/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/RESIDUAL-ADAPTERS.json": "0102fa3b62b095c14a34d5af95cc321db38e5f5e03a4f226828e8ebf6fdbe20b", + "research/aphase-residue-composition/evidence/full/native/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/WRAPPER-CHECKS.json": "84a5bc26df5fb70dc12852a868962bcdfad3b85d85408edfd1f343e898a78c0e", + "research/aphase-residue-composition/evidence/full/native/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5", + "research/aphase-residue-composition/evidence/full/native/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CANONICAL-WORD.json.gz": "f69c0ca2c217eab87a231b67e548cd6491286314b1215e19f0b1d7463afd5e91", + "research/aphase-residue-composition/evidence/full/native/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-RECIPES.json": "f1b5a509e39293f5d7ffea7b269fd9e5443e625a9286a022caa1fd4b62af8063", + "research/aphase-residue-composition/evidence/full/native/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/FULL-WORD.json.gz": "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "research/aphase-residue-composition/evidence/full/native/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/INDEPENDENT-LOCAL-REPLAY.json": "70b4b787a5a4529452a58e9ac48826e848748a35b95a9b20c5358f4355705058", + "research/aphase-residue-composition/evidence/full/native/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-CHECKS.json": "e52e7feece9cb22e83c1d687c0f98731f8d50b7e8c863732ec662c89453fbcd4", + "research/aphase-residue-composition/evidence/full/native/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-PROGRAMS.json.gz": "81d4aefacaa27f2f215e7d35559d5a079ca521f4ca2eb9a9c6a6bd7062179bff", + "research/aphase-residue-composition/evidence/full/native/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/RESIDUAL-ADAPTERS.json": "89e5779ba4fcc1b1a76bed05c9b36600bc1dc3c6efd7e623865692ec715c30c5", + "research/aphase-residue-composition/evidence/full/native/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/WRAPPER-CHECKS.json": "fc7e24778302326fdacfd08dd3d5e63483cf4539cd5022a6c77f016752fac1a3", + "research/aphase-residue-composition/independent/provider/GLOBAL-TEMPLATE.json.gz": "1d31424c4e27e26a35a9932ca778e43f1f3577589275422cc642aa68b31112db", + "research/aphase-residue-composition/independent/source/PR2827-SOURCE-NOTICE": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420", + "research/aphase-residue-composition/independent/source/PR2833-NOTICE": "a91b93a731f116ae55b3644c88232b4d996e58bb810e2559dec013f9788f5e4b", + "research/atlas-frontier-applications/vendor/pr2848/sources/PR2833-DISPATCH.json": "fd8132ec8957b908ee6d871216848f18bafc6bd9304acd6185519ee26d97b1ca", + "research/atlas-frontier-applications/vendor/pr2848/sources/PR2833-FILL.json.gz": "0cb7522e071ff064ada2efec169e23a2fe7d3daf928eec6ba752b166cffb3468", + "research/atlas-frontier-applications/vendor/pr2848/sources/PR2833-ORDER.json": "aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667", + "research/atlas-frontier-applications/vendor/pr2848/sources/PR2833-OUTER-CLAIM.json": "6f2c4195f0226c5a7f9ba604bc038cfd4100ba3caeeac8ed2defb6fb00632b70", + "research/atlas-frontier-applications/vendor/pr2848/sources/PR2833-PLAN.json": "163431bf8d3bc0d9b894994b1a3cfa7947367b2243b3c0b3a97d740195a1cb08", + "research/atlas-frontier-applications/vendor/pr2848/sources/PR2833-T37-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "research/atlas-frontier-applications/vendor/pr2848/sources/PR2833-WORD-base.json.gz": "dda9878455b3a3bec64ca16b1ac7789bbf5ffb603d5713b8df8644485e85b1b7", + "research/atlas-frontier-applications/vendor/pr2848/sources/PR2833-WORD-extra.json.gz": "bbe6bcba59e45e827a8e932ee4b23650d56ed4a0b8e0875c14f23c36b9e47eac", + "research/atlas-frontier-applications/vendor/pr2848/vendor/pr2839/lift_parent.py": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "research/atlas-frontier-applications/vendor/pr2848/vendor/pr2839/reconstruct_replica.py": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "research/atlas-frontier-applications/vendor/pr2848/vendor/pr2839/replica_parent.py": "48bdbf28f59d80edb266803ec61bf5e22e8fb5e5a0e2b88004b6039147589bd4", + "research/audit-helper-endpoint-indices/inputs/BASE-WORD.json.gz": "eeb6a236ed0ea8873b8800947d0cd19c36a6fcfdf857fc42913cb45cd984f219", + "research/audit-helper-endpoint-indices/inputs/EXTRA-WORD.json.gz": "cd417b904408c221d9840d08faff8af040cc4207f9804284f2f5375d21298a62", + "research/capped-fusion-t74-k554/ADMISSION-DERIVATION.patch": "7021000d75635fc5806af821640c02f9d7cbbbe1cf314dacfcc743fc6875fdd8", + "research/capped-fusion-t74-k554/CONSTRUCTION.json": "1cdadc74fef4cddeb2bae5e32fff7bc27456740150440ae8fda8822f569c2492", + "research/capped-fusion-t74-k554/NOTICE": "3918a42010a435782de0fe8c38fab8f7df5d48a375ecf603c2bad1b818a16d6f", + "research/capped-fusion-t74-k554/PRICE.json": "c5ec535fd9edbdec7b64edd5a8b862edb1a7f173d411dacb279172659573e16a", + "research/capped-fusion-t74-k554/SOURCE-PIN-REFINEMENT.json": "8c0bad79978decd6f8aba0932c0a94c7f61c64bf9ce5a19a36f67cc1390bf74f", + "research/capped-fusion-t74-k554/SOURCE-PIN.json": "66faac1fd4e79bb6d9fc774fd8ba63522ad3309456be1c81405794b284c55c83", + "research/capped-fusion-t74-k554/audit_fast.py": "26950da76589b13cd9c452fdee1b0c354806977f881299bd94073f00e4646fcd", + "research/capped-fusion-t74-k554/audit_mixed.py": "7466461cc15cbb12135d94f2d904d4e90e78cbf4755d0293ab9bd55e3568d4b0", + "research/capped-fusion-t74-k554/code/bind_providers_portable.py": "1d39bcc7b63ac158e021454beaae897d123e174360573762aecade3cd43193f6", + "research/capped-fusion-t74-k554/code/bit_supplier_controls.py": "e6d33fb61a570c3f50669412acc467a3fd06ef0b806da6a75bc296c6ba2142a5", + "research/capped-fusion-t74-k554/code/exact_coarse.py": "5fd03ee160a8bb02a00927cb144359fbcf8b0ec323ae0662778dd1f655b4a216", + "research/capped-fusion-t74-k554/code/fine_cache.py": "89282a83ab102893a4fc1e663ad2137d891d81e843b1c9ea140d13e58b7c7dbd", + "research/capped-fusion-t74-k554/code/freeze_spec.py": "e9132a9d195c66123f2747a17f7ef404b4d1e3ef6263ab4c28c983a052cf10bd", + "research/capped-fusion-t74-k554/code/generated_identity.py": "c8af22719c0f3097a991a3f6ccac8f090afd2faba554745733d9ea88f2c25708", + "research/capped-fusion-t74-k554/code/oracle_check.py": "4836046db4bec939515a5a272559f92192b56612b98f635910fd81ea754ce2e1", + "research/capped-fusion-t74-k554/code/prepare_global.py": "8c0dae301a8f34b77a5a462f840952d08ed120576212adf5051bc09bcad874dc", + "research/capped-fusion-t74-k554/code/restore_parent.py": "69b7b25ff85e9b8160e233c1d415cc6a0272019e5c486dcec14cb6c349e7024d", + "research/capped-fusion-t74-k554/code/witness.py": "08ca58abff11bdfba721dc56ab8acf06ec1b7c48a8699a0955cf35324680aca7", + "research/capped-fusion-t74-k554/construction/leaver/PIVOT-SWAP-k8.json": "3ef7acf0cf67442a532f25b53d5fbeda76d3a84524118df8e003ca69b5cac0bb", + "research/capped-fusion-t74-k554/evidence/ADMISSION-CONTROLS.json": "5cdefeff2516a67c4dd60e609019b3e2e38eb3d43142df2d3c7ed9a6822d5050", + "research/capped-fusion-t74-k554/evidence/ASSEMBLY.json": "5d9eb1ce551386024b5b6894836f81ed03a83d2e0c0bd0e02e3f6410a596bb2c", + "research/capped-fusion-t74-k554/evidence/BIT-CONTROLS.json": "d74d9d2ba363c3709e9a3b33abf6d14abd6b9c68d950b35b7669d8e6edefa59e", + "research/capped-fusion-t74-k554/evidence/FULL-ADMISSION.json": "cda48de718d060b8ca329f1254f4f999a5a5bade5cecabb265f0a9bef1135089", + "research/capped-fusion-t74-k554/evidence/OUTER-DISCOVERY.json": "413ef3e9eb1c3ff680cff1e600dc7160afda228e0b6b021c1a4e4a37ee486cc1", + "research/capped-fusion-t74-k554/evidence/REGRESSION37-CONTROLS.json": "0196ae228d583f2bac3c42d3576a8d378fe622592e377c4c1921b5ae81351854", + "research/capped-fusion-t74-k554/evidence/pr1377/CLAIM.json": "cd089b08077e0151b9ed917a5c33aa7aa6b0de790bd9567442531b48729da8d3", + "research/capped-fusion-t74-k554/evidence/pr1377/PROOF-NOTE.md": "dafd8286b1c9224ed6f50bf71bc34b77918323b936ea7427a4b71c3b644b2264", + "research/capped-fusion-t74-k554/evidence/pr1377/RELEASE.json": "a4fa2ca0f79a11dcdc3227ad16a408d4d22d83b7401c894cb0e31eb2c9c5f7df", + "research/capped-fusion-t74-k554/freeze_spec.py": "0f5c8ad43180a633a2cbbd11f7832729039402c68f593679552c43a1693d69fa", + "research/capped-fusion-t74-k554/geometry_controls.py": "7edb4732b34e5814b27650a55c938626cb50d68f06397744dd4fe451437e90e0", + "research/capped-fusion-t74-k554/inputs/DISPATCH.json": "b7b971df9dce435556145df307e2bb5138d87e5aa933f1fe61fcc5b5163301c4", + "research/capped-fusion-t74-k554/inputs/OWNERS.json.gz": "3a56f578b2db5647cf6cb811bc6263c7a802ae3e31e9e672596d43185e4e5c9f", + "research/capped-fusion-t74-k554/inputs/SPEC.json": "2daedf579c8abf30ceed79fe739bdd7659fce4c514de3894a028933143265d98", + "research/capped-fusion-t74-k554/new/CHAIN.json": "f18804a71bef7005e892b0b7baac818d5362fff685fe5b5aadfe8de6e442446d", + "research/capped-fusion-t74-k554/new/EDITS-1.json": "dffa640c04d71111d3e4bdd7f5a991450ba07049a1d434edeef84791c0cc2d05", + "research/capped-fusion-t74-k554/new/EDITS.json": "d5f9a0444dddcccd35c0217f60dbd6863486241629a747c3bbe4140b3d55eea1", + "research/capped-fusion-t74-k554/new/pivotcheck.py": "6eb1752f077df108c908974413fc71abc751356b07c6e650e75d2075f1a51391", + "research/capped-fusion-t74-k554/new/rebuild.py": "7391a7228d6b5afc2f88afd5d5a987565d78a100386c1f03b8696bcde2e8ef3e", + "research/capped-fusion-t74-k554/new/rebuild_chain.py": "3a5739f94f0fea1aa267e7d12e1c986210e483c841a8855e11020128a017510f", + "research/capped-fusion-t74-k554/new/steps/0/extra.json.gz": "17cc6c177c89eb264514e1efb3685ab9a621f3952a8f393a6a5eb28cf77e2884", + "research/capped-fusion-t74-k554/new/steps/0/gauge44.json.gz": "0740b6f33927b9e60c9a7f35e7fcb2fd9ac6e2d3982112428b302a6966a18c73", + "research/capped-fusion-t74-k554/outer/RECT-BOUNDARY.md": "17ece1cc1eb4a02df4d8433e3612231768633e6674d315acbcf880f36e30bdc7", + "research/capped-fusion-t74-k554/outer/check_fine_padding.py": "a0ae691251cc50ba20b7f23f89fffaed802d62f9192a441131476914a5bdfae8", + "research/capped-fusion-t74-k554/outer/independent_check.py": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "research/capped-fusion-t74-k554/outer/replay_evidence.py": "d3bdcfc8ce29865b3a76d64d99b5177e73fe994a2eb915f35fa233c5ab81df65", + "research/capped-fusion-t74-k554/outer/sched_review.py": "f440a57f1f46119ee8c2934c8f0d618ca1c85c73cda8cfb8453c2aa1b9fc40fb", + "research/capped-fusion-t74-k554/outer/sched_test.py": "f96d09b5990931e3df8cea291520bf17c424215748cd9ec068214c58309a21c8", + "research/capped-fusion-t74-k554/replay.py": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "research/capped-fusion-t74-k554/vendor/build_parent.py": "82e274d0c7a94f9bf0468dd37f0505d0c42017559ebb4ba8c079a1f4e403d91e", + "research/capped-fusion-t74-k554/vendor/pr1297/CLAIM.json": "bc9e90a475333b957a8c4eae8b950988caea89e20e9b44a919e83415fb76b1b8", + "research/capped-fusion-t74-k554/vendor/pr1297/COMPOSITION.json": "6fb74e73fd298b356402eb2fbcd625463b2fa540a6be4ef2d6335ddfa31d70f6", + "research/capped-fusion-t74-k554/vendor/pr1297/CONSTRUCTION.json": "fb5f74f59c89b93c63ec47e32e2c9264658e115d1f21eed3eceefec7dc7a0cde", + "research/capped-fusion-t74-k554/vendor/pr1297/CONTROL-SITES-base.json": "b41361f5a2f6ab3d223c146269c8027a0537f1a6e3c963f28cf1ebbe05c5d7e2", + "research/capped-fusion-t74-k554/vendor/pr1297/CONTROL-SITES-extra.json": "f1aada769389ec410b41bc9e2082826bb916b8332c915ee9e07045135c30393b", + "research/capped-fusion-t74-k554/vendor/pr1297/DEPENDENCIES.json": "9c9fff3ac059da4d4e2f13e655afb9e42ada1a57987f5b47b68dda4b64797966", + "research/capped-fusion-t74-k554/vendor/pr1297/EXACT-RELATIONS.json": "6864f378d917d0ecfd8cd53cc26303217ebb48f47f2987bbc01cf1e2c9a28093", + "research/capped-fusion-t74-k554/vendor/pr1297/INDEPENDENT-DERIVATION.patch": "6b3af098ec1c9e2360a366933eb7fbf0e16ebb37d43809d26b275e66fb5ee779", + "research/capped-fusion-t74-k554/vendor/pr1297/KERNEL-CONTROLS-base.json": "cbe755333f469a1f01258b65f2b273763212dba6642edabfb58f7490f326abda", + "research/capped-fusion-t74-k554/vendor/pr1297/KERNEL-CONTROLS-extra.json": "cf255deb866ecaefca4b6ecb72f105d6b08dc8ea907a8381d45aedc39b2022cf", + "research/capped-fusion-t74-k554/vendor/pr1297/MANIFEST.json": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "research/capped-fusion-t74-k554/vendor/pr1297/MAPPED-RECIPE.json": "09aca649da97a37116262827cbd3ebe0addcd2b1a33c08e8347f3daf3394176a", + "research/capped-fusion-t74-k554/vendor/pr1297/NATIVE-VALIDATION.json": "755b7087e0ae964c538e9378311e07dba2867c16b568d1bf6ae9051657f9f5cb", + "research/capped-fusion-t74-k554/vendor/pr1297/NOTICE": "b352129a07fc8693f57c77cbb0ea92230b2fa77439f86c9f35b828213f9c42db", + "research/capped-fusion-t74-k554/vendor/pr1297/PRICE.json": "e19f9f9e70e4fda2bc4a39fae93ea44555945cdaea59728864c5a44dcc5522e6", + "research/capped-fusion-t74-k554/vendor/pr1297/PROFILE.json": "d9bbe0d73ba005749615915a2d884819a6b141e3402d9e7f87f4592a2d27af99", + "research/capped-fusion-t74-k554/vendor/pr1297/README.md": "102ac7f080c1799aaedd5345ffb3631845215e8ab770e2af34750c25f667686d", + "research/capped-fusion-t74-k554/vendor/pr1297/RECIPE-base.json.gz": "0f2db2c658e9732fdd1aeb7bbbb5c786d6045de8a2575b7654b9e6fddc71b03d", + "research/capped-fusion-t74-k554/vendor/pr1297/RECIPE-extra.json.gz": "9e6f58570b0a8f9e8271bfbc73a339fce42f1cf28bf14d4db93f246b8f63a3c9", + "research/capped-fusion-t74-k554/vendor/pr1297/SEARCH-RESULT.json": "7cdacadcbbf83b81f9f91668fcc707f8a238c6025f35a8bdc36758619c2591c4", + "research/capped-fusion-t74-k554/vendor/pr1297/SOURCE-PIN.json": "e93f303f4de383757e50d612ada5e379533d46737a32281aa6879fb4b6138e09", + "research/capped-fusion-t74-k554/vendor/pr1297/UPSTREAM-NOTICE.md": "b97fb4731e84aef736c58a9c126334eb5b8d3a057a8d9d45b4ffff24af65c38b", + "research/capped-fusion-t74-k554/vendor/pr1297/VALIDATION.json": "1008f637a22f954ee774920a8362931ca7cfed63ca146e725768c0f39803c0a5", + "research/capped-fusion-t74-k554/vendor/pr1297/build_word.py": "ff08af2851b4813c113ef63113566cbd79625e9310611292913d51be554b5aa9", + "research/capped-fusion-t74-k554/vendor/pr1297/construct.py": "71aff454291d4a35068c43dbb65c00ff511f48e91ab7cdada462833f04ac73e3", + "research/capped-fusion-t74-k554/vendor/pr1297/controls.py": "935cf39ed6601eb6ac411b7b1a4adf5d4238589cad9fd5969d7dca967ace4c4b", + "research/capped-fusion-t74-k554/vendor/pr1297/independent_core.py": "d1dcd5593a05cf647b485db38891984f829abea5f95c6cc91e37d554bf163d48", + "research/capped-fusion-t74-k554/vendor/pr1297/inputs/base.json.gz": "b87c706d14a7e1972514ee901002a930908073811ef38761def31c8e36351916", + "research/capped-fusion-t74-k554/vendor/pr1297/inputs/extra.json.gz": "ded6903e00deb9e158fa700b03ccc9b8bfaae6c8bad8ca4842f0ad9b963234ab", + "research/capped-fusion-t74-k554/vendor/pr1297/kernel543_controls.py": "ac16d605e773197e3664643d40b36c15a7130a45e95e36bfe7b42d939644367c", + "research/capped-fusion-t74-k554/vendor/pr1297/kernel_controls.py": "436e3f3d9974da7c1968ef99fdde5ad203a61544d8195493e3150eb25869f4dc", + "research/capped-fusion-t74-k554/vendor/pr1297/premise/inputs/CODED-CELLS-k8.json": "7347f814850a838bd617bc7a55c307cec2b72becde2f12ea3e2e1af344b43563", + "research/capped-fusion-t74-k554/vendor/pr1297/premise/inputs/TRI-LEAVER-k8.json": "b22e6ecf76104de66844bd617c4ca80f5546ba0966a50e5e9aa0ffea4976cb30", + "research/capped-fusion-t74-k554/vendor/pr1297/premise/premise_check.py": "28a7f881a988b29b8ed3c927dd142ac3d4ee273dedab3a65bb02c01a64eb2639", + "research/capped-fusion-t74-k554/vendor/pr1297/premise/verify_1049.py": "a1736324c6db161733d8e11f608defd87b7f97cacd611203d22499e4c7de5545", + "research/capped-fusion-t74-k554/vendor/pr1297/replay.py": "d3ea7c2e74ff6df9d14969f994eaa85f825372cee92dafb77bec4767edb242e7", + "research/capped-fusion-t74-k554/vendor/pr1297/search_relations.py": "58f3bd092cb8592a070d7879918ff318a658a6fa02bfad7b5b8f4cb0fe16691c", + "research/capped-fusion-t74-k554/vendor/pr1297/upstream-layout.tar.gz": "a0cc229bb0fc9ab8ee5c14d5de87b3de31d1fcb793e99192c9cdc63781e794a0", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/CLAIM.json": "b9db2fbfb004b505ad535e4763915275dc5908feaefef32e65863fa65de061ff", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/DEPENDENCY-PINS.json": "c9330aa6a4226c804060499429cb450820d7142ab17696eb47408b04b410b5bc", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/MANIFEST.json": "4837d070679d9e70218c7cfa2d3e70d7d742a5b74dc66d224840b1a3a4ac4a31", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/NOTICE.md": "c7a17a0a35dc249f8ebcc550b3791e214aa65872eab8a6458c5167dd7b948e5b", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/PROOF.md": "b2a38120ddb75e90764d0b81913d60b46cddac4d943cb731bd9c7134f1c236d1", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/README.md": "cdcf62624912150ce4e6e05356c27299251eef4cfc130e4f209839cdabc05e08", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/SOURCE-PINS.json": "08eed0d6822a1c17053161929591e7ac36b9f91f8fd61190183a6d975948db85", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/audit.py": "1118d483b6abbe7036390c0a1053bcfec2038dbac273fd1bac92a68f38e6d7da", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/build_word.py": "effb72aecfff9958fe078ee89e0d37b85d601eddb19fec4520d7ee6e936edfae", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/common.py": "274274df31f8ef2a47b801d1f30ec226f94bce674fe15586d814ca754f6b7785", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/construct.py": "3dd333b50f4bd1d86956a6df4a334ed746d75d0a9e03dfadbb6724b4356e0cd6", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/controller.py": "d93ed519a0f2316b87b66f44c5ea615f0768a263dbd800815b536d8b7c86b8b7", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/controls.py": "574c55a01cfc34f5b9688cdec5646160cf22b403decee36d18b11f1b07e71f21", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/data/FLOW.json.gz": "e8e6dfa66e083ff8f3617a8441b5b2d766c3c9d9ac62ddc37d99edc24051f79e", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/data/FOUR-RECIPE.json": "384b32c5b0e9b3baa1c7232db884809596d30fc55553094245f7b739b1a43484", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/data/FOUR-WORD.json.gz": "7d09ee1b8b9881313e5fb1f623c0961d59b0c6352a019bc9164a6cad8c58e27f", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/data/MIX.json": "dd86bbb792a5c9f0d7507d55bd2f8392c66716023934b03b24f48ca737204eea", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/data/ORDER.json": "7757df3b54ca5e84c6dba9563b10bc6215c5e289313392b5a4b493179a245c29", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/data/PLAN.json.gz": "1f1085beb84b516b9a96ceaedc6c3de1c58941fd00b6e70f0d0c686b6546ff79", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/data/SPEC.json": "82b263990afdc5efdc1dfe38ae16d7815004dff8d70f85c28fd8286c31f688bb", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/evidence/ANCESTRY.json": "cd880b2d1c2fb8d9050458bd13f228385c417a95e4d1985607d9f4bb60b5c109", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/evidence/ENTRANCE-CONTROLS.json": "7b101dd97c1025667fb3615930a9d6cd2ec443169d263a3bc1191b80fc712a1f", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/evidence/FLOW-CONTROLS.json": "43fe7e94bd72607d502ed947ac1463405be18728eb0b8faabd7ba63ab1d28ab4", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/evidence/INDEPENDENT-OWNERS.json": "4c295ff53f51631e1720b0dc2ea895c34861435fa92112ee52439e4569de968a", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/evidence/PARENT-CHECK.json": "2b729fd666ffe4e34a355223b57f74ba460fb171b19c84f260378dd109f0b9a0", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/evidence/PRICE.json": "a1dac219b019f8d40d5b434b0e0c25b0d1f097fe5ae13eae45c76869aec4758b", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/evidence/RAW-demote3.json": "02150d4cb1b2f4763b5c5c20ce979c740cbdfc1066e021a8aa5d407de5c4b9d3", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/evidence/RAW-demote4.json": "7adf0070125b2c61e04d46c5f1cbf57af079eb733799bbfcc3fe9b0551d964b1", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/evidence/REPLAY-SOURCE.json": "a5a290aa8c75fffa45c9ad2e3441d5051d3adaf7934f4d0311875fb4d8f023cf", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/evidence/RESULT.json": "62aca8286cbb021d2535d81494f7ba7a3aec20898fd7c40a895a461bbd303ac4", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/evidence/STAGES.json": "0dce559b2a8f371f369a05ae25ca5dd6a48019b5685b0097f001a23bd849429d", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/evidence/WORD-RECIPE.json": "b6750c8123c205b63786fb825da26a819592f71736a82009809ae1cf96173a5c", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/local_controls.py": "fe3d13491fa7523eedb8d24577ffe4bbd6c36a87b4a7d1178e5795d223bed4b8", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/native.py": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/package.py": "cde0b2d66125649ee84440fc0a67f0d91f900fc838fbda069b579422289ea3be", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/prepare.py": "9fe454a5f857ff73c70a5b276bc9e289422b051a4cbbbb51123a91bb2200e6d8", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/price.py": "d45042f4c1fea352349377b43def363cf75a742546a1d5c790ad30da91791803", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/vendor/pr1148/JOINT-WORD.json.gz": "a0622d86259c4163e58cf0677ce575b6039a8ae4c95aa6d8b82a8163cbd42718", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/vendor/pr1148/NOTICE.md": "afbd38d6c8a232ea566c296424a86420f204e6cfaac565c0a147340bda3d3da6", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/vendor/pr1148/PLAN.json.gz": "e963ed64b9970858902b9388bcf1c5f9cc704859ad021ce8bda465a4dcef8310", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/vendor/pr1148/SPEC.json": "55bdb68d5d126c6be0e0acc419bd62301a978afd514f9834ed1e08b1aa4f563e", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-coordinated-owners-NOTICE.md": "442756fc1c5ecfd7b7b7694b53b1ecc70aa525004cd80f7d748ccd7270555189", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-eight-ends-NOTICE.md": "820fa13161f857c221f2c4099dd2985c7ff72249dc7a0221bc00fd0c1b9760e5", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-eight-ends-t16-NOTICE.md": "a9e85b59dde61fbff0b006923b441cbd1419e24fa9802426785bca667437fdc0", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-three-demotions-NOTICE.md": "a0fe85fb2207f0e6831a96deaeefb65afa379c1377a29f0b586f1db4bb4b2137", + "research/capped-fusion-t74-k554/vendor/pr1297/vendor/pr1193/verify.py": "e5c952989344a65b7e63fa112dda4d464979814205644a8ec34e407a0d96be29", + "research/capped-fusion-t74-k554/vendor/pr1297/verify.py": "358ad8dfd967f4fd69a0cc298eae3508ad8b57b1e419ebaa0d621e199f534345", + "research/capped-fusion-t74-k554/vendor/pr1297/x54_controls.py": "82f91b81be9173dca546345dbdaddfc71e6d21e626fb84a8b4d1b4ba0d673814", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/ALGEBRAIC-STABILITY-INDEPENDENT.md": "7873e7d9a99fdc9de3ee224b9925d3e277e9773d7f5f8c2d0f1c19b0e52bc87f", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/BILATERAL-LDU.md": "0d65e66d227464dda1a19f781ae0a0be671cbfd347c41e37ec954f3d629d8a77", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/CAPPED-GAUGE-AUDIT.md": "1030a34922709ab8d3434a4c57a4a58934ae268c237fb598cb415697da411c9f", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/CAPPED-INTERIORS.md": "983c5cab2d2398f2192a8aec07daecb655f2de136e12a37f75672a14d27172ba", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/CAPPED-OUTER-ARITHMETIC.json": "22caac9ec2ecf4d5743b7eb946b633911fbac55a714399556e87e2eae0457dec", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/CAPPED-SIGNOFF.md": "70e9175ebde200f8b016236adc88c4a1c4858945e7c3e5c453a8b6a5f79a263a", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/FINAL-PACKAGE-REVIEW.json": "3457385de52d8e86853d96026a70aef2e8dece516db9eea020d8774e01d076a8", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/FORWARD-SMALL-A-AUDIT.md": "e37aaa30b15671a1dff00676b14572213efaaac99df202dbba5e09f57af487c0", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/HALO-THEOREM.md": "cb9e1da38400b658f9209e465b4e5896fadd17dc66afa862f38bae8d8c1f2058", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/INDEPENDENT-FINAL-REVIEW.json": "6b98e5222aa109a35be8b4fc9ec19669daebcc06d542ecec0a9c820da7930501", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/LOG-A-PHASE-SCHUR-AUDIT.md": "e05d6b8596c80b6e8676569a0ff464a29fa704c3304143f58914f47cdf38b272", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/MANIFEST-UPDATE.json": "32c58bcab8e19ef895660331c13d31b5fae7d0c95f7cda4147870f29d8299f6d", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/MANIFEST.json": "9af581d640e9c69d513256cf69babb0717287642134cfc807cedcd79966c1706", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/MATRIX-COROLLARY-ARITHMETIC.json": "c6efc4d2f6d17159cefebf5c2dd6099a6327fe0911c5dd87623cad96c7d6c56a", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/MATRIX-COROLLARY-REVIEW.json": "5cd5e97f93a9b3e439bfeffb52139d7bb1730de96ad13b59b7e1b20fdca6a3f6", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/MATRIX-COROLLARY.md": "2d7fb1088e58bb86e574277733e082f135362215a69add71d9090213d32c9221", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/MATRIX-LAYOUT-CONTROLS.json": "f8bd8729cb8438188e90fb9149f598b825461c97b4ed290584ca4367f812a48a", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/MATRIX-LAYOUT-SIGNOFF.md": "4c8c62f723232e842dc3bbdcc4defcc8ff1aeb86ba9f694661899dc6783b13c4", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/MATRIX-SOURCE-CONSTRUCTIONS.json": "114c1d8fb70592455a80c73d8a1bc6bfc9aca4e7395a420b6331d5474b4d1917", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/MATRIX-SOURCE-COVERAGE.json": "fdc6849f97999a6cf99cdaa50591d24f78d6fb0bc580315f205452e5906b35cc", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/MATRIX-TRANSFER-MANIFEST.json": "35d98d7579a16dae36530b4e5f4d0b8f925a069daa3f6fe1ea5276916167e0c2", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/NATIVE-RECEIPT-CAPSULE.json": "a04d6bba3d15c11a219536b66a23012797484ae106ec1952ecd7b76f077ddb01", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/OUTER-ARITHMETIC.json": "050c61d90236c593fd0827d7edc297e05604884e4ec093659aee46a9ee336020", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/OUTER-AUDIT.md": "94799bfa2794eb867d6ba68593c3e92988ade083e74d895e8d07ae3b8d0670dc", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/PACKAGE-MANIFEST.json": "298f1eaf79b5d5d57cb96fb3abb422174b78c31c14491a878f6176431d731d04", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/PHASE-LAYOUT-AUDIT.md": "54aafc7afd09fe1a5312e69fad09c87422690543ab75c6ae35f6cbcc26b3eb8a", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/PROOF-AND-COVERAGE.md": "db7509d754bb7fc3381419e0fed2674f22a9d57d34e8420fd5afa3c688fde9aa", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/PUBLICATION-CHECKS.json": "6e2fb68e6768c3aa4224aacb4900263586fc8114815a51df40f3f9fdf6124217", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/PUBLICATION-SOURCES.json": "6082583794168b1c2320187214b86c93a5a6e76fbbddfcb3bdbb8c5bd34c0586", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/README.md": "91af88b8fc53a22e1e968908f0e449cdfe2154c83f0dddb8a504e661c0c6965c", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/REVIEW-RECEIPT.json": "97b20e50d3722fcde3831124a107df6c15c0ffdbb9e057b7867f41aaa2481800", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/ROOT-EXACT-REPLAY.json": "d36114abe9d7a83c327f49f5ea153c6dcada4a7421f5e74a9a5ceb392cecb994", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/ROOT-MATRIX-EXACT-REPLAY.json": "d6bd4fcb8a528655181b4aa3fd1bad7e6647a4ca5aa76ee7f2cdd800b698b225", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/SHALLOW-TOEPLITZ.md": "b384b93f3fb4a8c97da2e617ebc14d55cebb0a739070e7f8dbb66f63e24e9310", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/SOURCES.json": "14ce6fdc7c83e18ccf4fee19ff51062726c960ca44462a45af60dd686167d456", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/SUPPLIER-SUPPORT-AUDIT.md": "bd5b06eca043c5c871227264f6a954473c55cd16ec85bb420ff538fb8ec1d8d6", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/SUPPORT-ADVERSARIAL-AUDIT.md": "b1290f8720bf075ea2ad58d6070f3e1fc95c0155f8e33b165bc13439bbb9222d", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/SUPPORT-ROUTER.md": "6ddb322e11883c1177ba6cd1a77d23a1dac827d7290b32eaf642457b1d762a54", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/TASK.json": "47b82ef23e20991010fae838ad4da9bdac3f947a8fea916a028fd6260f95f5f8", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/TENSOR-COMPILER.md": "4d3b8466598a864a234b978e25976648d4e761840aad9153dd18d73d3dfe4d15", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/VERIFIER-NEGATIVE-CONTROLS.json": "eeb887cdc0c76426c75ddbfc3d4af7ccbbe19d17962c6ad7a1549dafe8dabb5a", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/VERIFY.json": "cb50aa523a0863a457181ca815e69a1b3b4d91ed1006a79263f4a8f18457c669", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/check_capped_outer.py": "b4555c77de7a3ed4abc708a8d93363ef7c9a914be1091f80ab3ddea83f71230a", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/check_matrix_corollary.py": "30db2d8e0f40fcc5c91e25f74cdc54e46aa4a0353c725345f9bcf5744e0b617f", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/BILATERAL-CONTROLS.json": "eb3ba38d18bac4aceaffba39ef48dbb55bd15e6abcb68cdf66920d9d13ec00ab", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/CAPPED-GAUGE-CONTROLS.json": "ae8f0eb121a2f4da5c3f982ee6e7f45dab7b18368cadb5d2060602b0393b7120", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/CYCLIC-SCAN-CONTROLS.json": "4c37249f12b4cb4df847d179df8f378fbf1f42917e9fa703b2d847146f29b95c", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/DYADIC-INTERIOR-CONTROLS.json": "afbaee9f56f6a66fd9421bba7dfa8c3610c12bd447b01d0e9d79f97d1216aa90", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/FORWARD-CELL-CONTROLS.json": "4417a518ba3b6833f06b4f5e33d4f73ea74100b9110cf20e8d1c2070f1833fcc", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOG-A-SCHUR-CONTROLS.json": "046191420a24d8b2c063c190af5e954c85e39357902988c4df79f5abcdf1596d", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOWER-CONTROLS.json": "323cb4acae960a6fa05527df5ede9d48e274883272b8ddb5151ebcee6dd26e52", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOWER-FACTOR.md": "dbc7eff783695e0f50fec57b0f7ca4212d51428eea04fa2ae5e0a9178fa69b30", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/README.md": "8fb5321b514af9260c44e150125205fe564efd073c456214f76bbdb358279cf0", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-DATA-ALGORITHM.md": "46b98b9c013dc5a94c9f17fd85acd7c1896c8e93ad2ee4a7c34f583895f1daf0", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-DATA-CONTROLS.json": "c9e6fd7f338f2cb78a0ed15ee944fde63549ae3d8522ab0874d184f3e252db76", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-LIFTING.md": "69535a48416a5435ea2a5ef4ecfe70fde30c32c4043bfc56f1ae2d7f49cd34bd", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-MERGE-CONTROLS.json": "c5729bdb36237c0691fba56d149019f78d94e996749532d907a84c35ef01319d", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_bilateral.py": "8d5c79bd4f4c96de5c1fa91553b19e3a62419333b414fc84dec894a4b729d5e0", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_capped_gauges.py": "121279bef47dd490bf29fc72ddbce547176cdaf1154af67dc8b96d7baa8cfc6f", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_cyclic_scan.py": "d25156f852cb95f013e0ee74b319fc8c20d6a7a53fa851543244d5af7898ee61", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_dyadic_interiors.py": "a39617147870719a0296eef77101c90df8fbe716841cb9ed823f36b94254c3e1", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_forward_cell.py": "082a0e46c175f6e59fe1f8c168ca56bc444c71a602c9b7318c0834aae1f2de90", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_log_a_schur.py": "a0f1116ce27ecbff18de7089ce1f56714ed7966dfa0105b20419d408feb7ca41", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_lower.py": "027c77d8ce33c3d5e3c436234668f11bafc3de8658b9c3d03d455eb0e4d71f95", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_upper_data.py": "de4f9df64cf31e94adb9a5d04b38d53d823d864f51632c49c7c80c6a46b5224d", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_upper_merge.py": "95c9908134905e3ebdd030375e36a942c886cfc59edde3c6a419f36da6754780", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/EMBEDDING-CONTROLS.json": "d0182e172f16b55ec64a5edfabb10816e416348ef2db15449f3ed4b47f3fec1f", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/HALO-CONTROLS.json": "ae370f7d7421f2f96e101a4b9d8082110507c47211220fd6ead065c2366aa828", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/MANIFEST.json": "37946d7691b90d39906d93581839bdf8ae2cf899d459e5520c39e782766e9327", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/PARAMETER-CHECK.json": "e38cdfc13f1959186d888383458c9030c4bd3c8c3915aea4743d55637d2f8d76", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/RAGGED-CONTROLS.json": "c3688f65565486b585727374abfbe478f7544aa61381bd73cc6ffa168b4221b6", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/RAGGED-PERIODS.md": "c6e4dfe7f58dac7c5a513ffb3a9ab4801ab0717efae5c1e764e570335402ff25", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/README.md": "575a3acfc18a0e05ffe04a8563318a2770ce32cd7bf3a5e6123ce2de39a1cd4c", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/RECTANGULAR-EMBEDDING.md": "e64447bff7e7717802ee049290faaf29e45db3e36a6f7fcec109184478f15f26", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/SPARSE-SHEAR-CONTROLS.json": "d3b9763f7ef6a3a5752c6c11a8a4d5f465646ad75b178a1c1b3363540fcc4871", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_embedding.py": "597cb5304498456575c99d46a7fb503e04db28d5a7f57857b102b50f703b7464", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_halo.py": "0a3257cbb8f37b6cc9bb44019cb114ea2ae9b28738a416bff4bc712d1306e1b7", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_ragged.py": "54b761cfe3404d524af3a2abdf09bcea8dfb5cca6199c0c182cee310e3ca8c78", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_sparse_shear.py": "6e22c989e6bae92c4cd209c9336aad4359956cf370bdbd5f6b70609144598121", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/CORE-SOURCES.json": "2546f47dacc47c2d63dc5bb9cc52ef86c5e02ee159c4fb6e00dfac3f8f34d89c", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/core_review.md": "13f2df4d5b240f9b89ca0ae44bba198c935532098ff4c1161631fcbd86b3e8b1", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/gaussian_layout_review.md": "ebd7188970f55b5979b1b1a13f874a31ed0ee6c82bee329e7ad0b2a38c42c430", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/layout_subreview.md": "637e4698a9fb02978ebc4032d8939ce0db9528e89e908c94d63b9f0d2a41f64a", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/union_subreview.md": "738b35a04d6871cd73b14b4165ae69a1feb3a103eb46e064a64a22c4c7426856", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/CIRCUIT-REPLAY.json": "2ce5cf9ef9461e5897374ad389c26af66aeee85e8f514a9da4ed3bb2028cb1da", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/EXACT-ALGEBRA.json": "694898bfb1afcb3b8b8ef951634ac8919decdde0904350b355d254601ae3dc12", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/MANIFEST.json": "3b018dc660c6add775c12f75b9e8f5281825aeebc3888a508833ce6106c1229b", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/READING-COVERAGE.json": "756e52726b161eea27e27f1d519b05d4fb0ebf67ef9a67b33947194d5d02b709", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SOURCES.json": "fb3771f66771250aa9f4406ae9e7eb176f9cdef03976cbc9558440c674a4a94a", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SUPPLIER-AUDIT-SOURCES.json": "d0c274d6edd6193b09d28e45e7cbfe9236fb35474d35ea3af0664ba36f9e006a", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SUPPLIER-CAPACITY-CONTROLS.json": "6922b7d7a936d53846569ad3be53fe4f3c63d6cfe794f9279fdc6a1fe411ef0c", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/TENSOR-COMPILER-CONTROLS.json": "db8a5c0dc2be956d83bc7667177252a4968e0ffaee8352e6a5dba5ab983d7ada", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_circuits.py": "06d1861bfe8af543908e26557ffda7e451ff176bceb9bacfaf0f04f234b336d5", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_exact_algebra.py": "5ff7f25c55b370a1d0cda6c84ab9cdf2c7b0de3266d3f2e7a43280a6491074ab", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_supplier_capacity.py": "035ed96b39414eadec46e8de4bf3811b785862fd313deb044f42e17cf2ad3f78", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_tensor_compiler.py": "dc4b1f1884489215a2c2d0e8978a241e99e6c8c9f1d2fa2460c73d2c7d4ba30a", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/check_source_constructions.py": "9d387098403c0355be8e93158df02bae5a435b2366bd28efdf0b127e470c8c1c", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/README.md": "17c393075292b364899cb7c451cebbc9b20834f9fac934ce3740aba360c27246", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/check_outer.py": "6a0c5f8956323615df8bc4b12996832471c0ae607d05429c9d70ad1b50568f10", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/CAPPED-LAYOUT-CONTROLS.json": "e6951790238b4998c632c95aa329ee2cd2527a5d74a2f28bd15249fec6d2419a", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/MANIFEST.json": "c98559147bb498ac78af998eed63ab6661af934fa1a0df6844176b1811753fb9", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/PARAMETERS.json": "9f72cfffa34844764ca65a6b4431cc5c779141751df746019db9d3ad8f1dee92", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/Q-EMBEDDING-CONTROLS.json": "24ead3534482397c00c23ad3dbbd4e930e02290e00c97765353d8783c6575c7d", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/README.md": "0ec721f76dfa943e808afd3c2cc39ee69f1a6e5f4f77ba3c7c1373ad60db25af", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/UNION-CONTROLS.json": "6c5262144215cc603bbc3bee93a9a6d9d2318d0177a59115fe560762998498f9", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/check_capped_layout.py": "267d93ab5114ec160f88a6e65fd34c9f0696a686c36ba2dd194d6b70fa32a6bd", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/check_q_embedding.py": "ac858a14bbaf37e0e412a7ada282cd1586632f52b8a979733e775f50130969b6", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/check_union.py": "74608380d72567edcd4470c8d226b15848f9d3a4e5d77d652bdd8963480ab9ce", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/CONTROLS.json": "12d9207e887fda73159a9e2e4776003ca6f905fc3dc45d77ced588a1c9f80cb2", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/ERASURE-ROUNDING-CONTROL.json": "cceb2ade8ce5e18be3871f771955e38258f5eb4e39790c016aab96d8cf0488ef", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/FIXED-A-LDU-CONTROLS.json": "d6bda457fff01e04b6565d84c7bdbac870569a2ba7ef18a1fc8db11b738faf38", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/FIXED-A-PERIODIC-NORM-AUDIT.md": "21027a569588922c491b2c5b4f31e01ddb784f1f20cdf48b7d482d0e85b66bdb", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/HOLES-AND-Q-LDU.md": "c6a032ed495325806ddf491c5c85bc822a7fdd613aff906a7be553960d0f85a3", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/HOLES-CONTROLS.json": "3f7e98ce524d5fb2ba2f911a350081340215e806ae945abf15a2fa07988ca2f8", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/LEDGER.json": "87eab0eb334ddc16e50cedbcab56320d2ff056c3dc87d7a5191171bb5a4c206e", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/NEAREST-NEIGHBOR-CONTROLS.json": "b85eca6098847e7b2f77b49a6c8c35e33cf790bc5dd01b95e1334daef9af47f4", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/NEAREST-NEIGHBOR-NORM.md": "7955383d50fc59b5c4c4d839c7e4d630add6208a3a233d7372a80309085ac6b2", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/PARTIAL-FUSION.md": "811a3a0c88a90708add5b12fb0a05c25623f0af155010d5dcacd56021c55cba5", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/POSITIVE-TREE-CONTROLS.json": "7b31811402ddda4668fe8375f6c90a6047511d50836dbb7cfc7ffcf24fe19a11", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/Q-LDU-CONTROLS.json": "370a07aa1a56c656ec1f44d7651dfbe999ad0c19dede9036257cc2f29dc39452", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/README.md": "4d65ea3c8b6a0d5faef819a58c8b8277681d11bed54686e9a7f78de29736e68e", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/REFINED-PHASE-FUSION.md": "b4367eac012624f803b3d2e3a72339e050a0071bbec37e6d33b2cf322bd70bc5", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/STABLE-POSITIVE-TREE.md": "ec2f8a1c4273b81217545d2710bcffdd09b5c9ba9349e887b5f7bf6f5bddfdc7", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/SYLVESTER-CONTROLS.json": "198af9f58c2950f17d8b1861ba4566bb2f6a0108a889a56db328fe67f8faa1a2", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/TASK.md": "5eef77fb23f26f5bfb5dc8e376ed25e769924f2b6420ebfc8671e3b2a2f1f611", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_constructions.py": "91387c9bd763a5c55c22a9907947bd07b6002f739aa6feedf6d3a02adea1e316", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_erasure_rounding.py": "486efd4692665a548b94b79877abb76ad13157268f05c270c4e75d8f97700795", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_fixed_a_ldu.py": "15134147317a7d789c9ea0ebd71db5ff11e59a20ef140f681d87478977734cd0", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_holes.py": "99c5dc4601ea88b553f52e235d36fba0aeb867e7fcd54130cdb3eb115a9bb0d8", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_ledger.py": "254342c05949e5cefe4f507a35487e0a1ffb7137a60d2b97831d5ad55d7d7ce5", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_nearest_neighbor.py": "21bf2be683cefa7a760bf1e1bdaa647f57bf47ab86b13fd7a74e8d650f492913", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_positive_tree.py": "46db2ce9122ff57bb4eeaa723db1f351891e671a7eaa7bf4fb61f85dafee9e37", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_q_ldu.py": "ec2589ca9abe71d674ba9ccf81f289b1526f56f3001c48d22977accb1be3e4dc", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_sylvester_factor.py": "60b21fda4ff451582087d30222a072eb1a214d531277e92883eaf28221aafced", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/frontier_fusion/FRONTIER-FUSION-ARITHMETIC.json": "82656563e7c8725f95c4aea7e273805a3d3faf34c495a330f1c91a036765414a", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/frontier_fusion/INDEPENDENT-SUBSTITUTION-RECEIPT.json": "49a8450289f1c1730c7d11d7c1506ad4af26fe9a1f76341f808a3025123e9519", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/frontier_fusion/INDEPENDENT-SUBSTITUTION-REVIEW.md": "b48d3e14083829db81336b639a6cfc698ac0dccc76fa2606d11b4be7a968ddeb", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/frontier_fusion/NATIVE-ADMISSION-BINDING.json": "ec4e89e0513958c1d553736cd06eedbc5f2aca61b40f92aeade3eb882bf588bc", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/frontier_fusion/REPRODUCE.txt": "76808b685f1623813658f5b596a4b8191a07e7c0810550f6fada7fb4a4992913", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/frontier_fusion/T74-APPENDIX.tex": "d053a6b69de2ff4005ee52eb3b673de606326aa0f0e290354675f9f08f915b99", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/frontier_fusion/bind_native_admission.py": "166541ca2b7f3066f4c2421e5a9f1886d58e1fdd7677904976261ab2c82b32cb", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/frontier_fusion/check_frontier_fusion.py": "02f7f9ebf29487331171954c7ceb37ff5315e2f28a9d56096ebbf9fb865c70ab", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/frontier_fusion/independent_substitution_check.py": "579bbde41e90792818c2726b38dcab26cf5a2695d3348731e814175146b0a737", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/gaussian_fixed_width_note.tex": "6f3edb7b238f2b6af4f3e2d98dee90fe6f4ba063a5ccd120422e45c941712aab", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/make_native_capsule.py": "8f342ca212b8d601a11f704042c577c1b088e0079bda04b3065467c2f3c36ea0", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/phase_fusion_note.tex": "b5957f38c98a68f2584a42cedf91d753180dab438129fdf749b441074f00d4e1", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/target002_upstream/full-1661-verification/RESULT.json": "11c57817a4d43a489010a13af7621d37eeedc398308c036e63a2a97119443861", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/target002_upstream/full-1661-verification/STAGES.json": "c2edb01a61c03e04bf48e605422ff83c1d304e4d586268959d4ea24b743640fb", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/CLAIM.json": "70aacd45f9e6fac8675687cf50da32e0ad4e479d9a5c28f2afd1550311ae8849", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/MANIFEST.json": "d90d49eaa68e48c6992a07972e736ef4b9cd80274361cbbc1ec980d43f29ad7f", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/new/SPEC.json": "d6b6a2140f3a61ae8cfdd8b51a1131934d63d2dd8573c1b13eb2b9528f3c3db8", + "research/capped-fusion-t74-k554/vendor/pr1673/capped-phase-fusion/verify.py": "93ef0f46e132485da6194587199b8f039e25b1b9f099f93bbdaeac5c0d66de7f", + "research/capped-fusion-t74-k554/vendor/pr1786/FINE-PRIME-PADDING.md": "47d1b1b4df28aadda3cd6bdeb1fbc47290595e9208cd09c1a1f338520d33fdce", + "research/capped-fusion-t74-k554/vendor/pr1786/NOTICE.md": "dcc1adb2461aa93ca62b6a912dbd8b215599e6af8053dfbacb7423b544dd659a", + "research/capped-fusion-t74-k554/verify_manifest.py": "723d726dbbe5b65a49caecae0f1aab664a1413fb639abfd3e826a5a538e14e5b", + "research/clifford-state-performance/fast_state.py": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5", + "research/complex-routing-leaf-fusion/vendor/pr2751/inputs/WORD-base.json.gz": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "research/complex-routing-leaf-fusion/vendor/pr2751/inputs/WORD-extra.json.gz": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "research/complex-t37-ends7-owners/vendor/pr1107/research/gauge44-ends7-t16/construction/ends7/fastpath/NOTICE.md": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2", + "research/complex-t37-ends7-owners/vendor/pr1107/research/gauge44-ends7-t16/construction/ends7/fastpath/PROOF.md": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053", + "research/complex-t37-ends7-owners/vendor/pr1107/research/gauge44-ends7-t16/construction/ends7/fastpath/sparse_state.py": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37", + "research/coupled-cap-independent/vendor/PROVIDERS.json": "52eb0d85caa7b2d4a93acdf5011f52b793f61ddca86235fb03cd9a09397ad4cd", + "research/coupled-carrier-cap740/cap_check.py": "c2a2ea7df9ef2f7c7ae2739435f4ac44f2c912d8e18fc9278c717958f258ee38", + "research/coupled-carrier-cap740/common.py": "8786495cbf808d950be1c42e42d0198e950e44167af80063d25fd186aafea534", + "research/coupled-carrier-cap740/vendor/PR3133-CAP.json": "e32f3ecd5e6594935583f80f643cf1930e8bc017e3c541025c335395a15cf19c", + "research/coupled-carrier-cap740/vendor/PR3133-CREDITS.md": "1d9d8f56d8899f55878e4cb2c4e052b22506444016a51c2e678773505f5189e6", + "research/coupled-carrier-cap740/vendor/PR3133-FILL.json.gz": "68b8bae90144248774b1920cd27f9519caa3dc427704d8a9da6d4c491d912fc4", + "research/coupled-carrier-cap740/vendor/PR3133-NOTICE": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661", + "research/coupled-carrier-cap740/vendor/PR3133-PROVIDERS.json": "52eb0d85caa7b2d4a93acdf5011f52b793f61ddca86235fb03cd9a09397ad4cd", + "research/coupled-carrier-cap740/vendor/lift.py": "ae6c1fee78fbdec26976ca74ca89f6aab2528d763c596f6573132cb54d57cd3c", + "research/coupled-carrier-cap740/words/base.json.gz": "300a9b8ad1d554f0e6f84f43f3f5fd870a5b4e5f81ad856900b6e8999684892e", + "research/coupled-carrier-cap740/words/extra.json.gz": "495d030f1e03b90e954dad3043994f03293d41b9ed220a3beaef849df435d3f0", + "research/coupled-carrier-independent-audit/inputs/EDITS.json": "47831d52490e3a3b8ed0569ff644582ea23f60e2ef900c2301d04c60bd73f5d4", + "research/coupled-carrier-independent-audit/inputs/PARENT-base.json.gz": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "research/coupled-carrier-independent-audit/inputs/PARENT-extra.json.gz": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7", + "research/gmx-t74-borrow43-gridmax/EXACT-ARITHMETIC-DERIVATION.json": "c0d40deaa495a7365e91aa5d9e6a846f91e0cb6daff98bb3b7f2acef84d64ec4", + "research/gmx-t74-borrow43-gridmax/code/fine_mercator.py": "6cf29658b5c1618de4aae8bd49d6d890be06d57ead1ad0f2d41bc8d25cc578d3", + "research/gmx-t74-borrow43-gridmax/code/fine_moment.py": "bdfc492be6a663b219d76beff444db14bd67bb53c7c8ec4086ab0f56e48323c0", + "research/gmx-t74-borrow43-gridmax/code/lemmag_checks.py": "cc753c5953e58f5900ce580ece8f814a352d672bcee6d4566c7dd52647912393", + "research/gmx-t74-borrow43-gridmax/lift_parent.py": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "research/gmx-t74-borrow43-gridmax/new/borrow/audit_local.diff": "202f6f2032552eba069b9ec7e33b729d4af2ffc20974a9e82e444d906d7137b4", + "research/gmx-t74-borrow43-gridmax/new/borrow/borrow_controls.py": "07fbbf8e2f06df063dc9d88e5e4f721222a9fcf30b983bf9127cd5aa4b611627", + "research/gmx-t74-borrow43-gridmax/new/borrow/inputs/blocks.json": "ddfac1dae1fe7cc0a91e7c7205c6d9d0c07c682880aa34eed83bf4ad7384da9f", + "research/gmx-t74-borrow43-gridmax/new/borrow/inputs/extra.canonical.json.gz": "d7e48dcbafa236a2e1e41f7958244211506f7c7630fe6a2d43d2bdf17b7ae015", + "research/gmx-t74-borrow43-gridmax/new/borrow/inputs/gauge44.canonical.json.gz": "65c6d17ffee2eacf27bff438f37fc549c9ed0c909cbc7a52976cc75cf2d15b91", + "research/gmx-t74-borrow43-gridmax/new/code/borrow/bw_adapters.py": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce", + "research/gmx-t74-borrow43-gridmax/new/code/borrow/bw_audit_local.py": "6bc8a07942a027a52ede46521f6b5dab755643eb693efc7dcb829496050fde09", + "research/gmx-t74-borrow43-gridmax/new/code/borrow/bw_check_recipes.py": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19", + "research/gmx-t74-borrow43-gridmax/new/code/borrow/bw_emit.py": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76", + "research/gmx-t74-borrow43-gridmax/new/code/borrow/bw_gauss.py": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb", + "research/gmx-t74-borrow43-gridmax/new/code/borrow/bw_phases.py": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e", + "research/gmx-t74-borrow43-gridmax/new/code/borrow/bw_tamper.py": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9", + "research/gmx-t74-borrow43-gridmax/new/rebind.py": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "research/gmx-t74-borrow43-gridmax/new/run_native_borrow.py": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "research/gmx-t74-borrow43-gridmax/new/unpin_spec.py": "03901dbb881fa608b6540a0541b26311dd4bab23bd8768e9ed48b8b355e1b36b", + "research/gmx-t74-borrow43-gridmax/outer/PROOF-GRID-MAX.md": "19dc50ad398993d156f9366fc752321a88a7337dc016c00b0d5a53eceff93cf6", + "research/gmx-t74-borrow43-gridmax/outer/RETUNED-SLACKS.md": "d87beb3869fb60143c2c3872d7c427ee16174aa51b5e6f42689312fbd40d3d42", + "research/gmx-t74-borrow43-handoff/PARENT-LIFT-RECEIPT.json": "787db0b6f847cb03ff9b71246aba6e702ad3ab8e2fbbcb7dff9f51b8a8a783e8", + "research/gmx-t74-borrow43-handoff/SPEC.json": "81676590c26018aa95082e3252f394ac99c61c0c4e5578f59501401700e38033", + "research/gmx-t74-borrow43-handoff/audit_mixed.py": "2286f00e462ff28abbb3f396095463482a1e063213b9526a7225275980c77eaf", + "research/gmx-t74-borrow43-handoff/code/assemble.py": "f25e1e870df5d5a16a1e367b3df8843cb01644ab4b75895d7939af81e4fcb833", + "research/gmx-t74-borrow43-handoff/code/assembly_controls.py": "d7675ff0b0994b29541d37eaa3010c5f39bb1447700c9f8e750522bf8c951f56", + "research/gmx-t74-borrow43-handoff/code/audit_allcold.py": "fa3488b62efdf8a0c37de0ca0caba587b4b036c5f068e002eb04c71c12b9e9b4", + "research/gmx-t74-borrow43-handoff/code/emit_allcold.py": "549603ca6d28b163a43b2dfaaaa788161c73d7952ab9190289407caca5418c71", + "research/gmx-t74-borrow43-handoff/code/invoice_allcold.py": "bb213d0af12218ff7c9c572717e522d8bbeeb2856b87a253f4a7f44e0fd71f15", + "research/gmx-t74-borrow43-handoff/code/lemmag_stage.py": "5158e1e95e46b3119de9f4add7d849c8ad2d2dd92b17a79b0f93b86e7d4e6049", + "research/gmx-t74-borrow43-handoff/code/pyc_guard.py": "1def35bd093a7b3893c1cf410301d875435a2a7a096b42f49ecb060ed2a61f0e", + "research/gmx-t74-borrow43-handoff/evidence/INDEPENDENT.json": "7150546e840e859268c40c11c2c79ba4fd646fc632fced68e3c19355b292fa61", + "research/gmx-t74-borrow43-handoff/freeze_spec.py": "1d965b7a329b98008fcc67e73d03dcf6e75f0f33c2858a39f1182bb3d0ed0ea1", + "research/gmx-t74-borrow43-handoff/independent_core.py": "02502a217fe8c9e10229075b50745518beac512c48db20e64c3e06514a4da5b5", + "research/gmx-t74-borrow43-handoff/new/borrow-fill/search/agg.py": "267a66287336b72731b897508073dae1a7c85fa72cd86093a7340ddfc12af04c", + "research/gmx-t74-borrow43-handoff/new/borrow-fill/search/base74.py": "acc99c57730fe50f88538e4061e7165a7f278ed7499728c24b0522d479be8b8c", + "research/gmx-t74-borrow43-handoff/new/borrow-fill/search/ceil74.py": "99df541abe458fb6154755d9c67066b2ba0430b06f879a7b5a43e30618f4c1d7", + "research/gmx-t74-borrow43-handoff/new/borrow-fill/search/evac.py": "7c6ce4e8aa9833a9d451c5d4b891bbd1927315bcbf112d3c15845f0ede2d9dc3", + "research/gmx-t74-borrow43-handoff/new/borrow-fill/search/fillbase.py": "4fc6fa920d8703ccec860bee0e1187a0a8b1e37b245789256f7a4d01ae8a2b00", + "research/gmx-t74-borrow43-handoff/new/borrow-fill/search/inv.py": "eec279ea8e8d9d1dccc2733a88129351678c73fb51f06a4604a9c1da1d771387", + "research/gmx-t74-borrow43-handoff/new/borrow-fill/search/lattice.py": "8f2ee194fa4992d1f45394b09b5151ec699b28e4c950b9d40b826f33cbb635ba", + "research/gmx-t74-borrow43-handoff/new/borrow-fill/search/lnstime.py": "3a1ff558f10b0b935389137627359f875ca484717ffa3ced7de8d8b588836755", + "research/gmx-t74-borrow43-handoff/new/borrow/alias1_controls.py": "f4cc82312af891ea48956d9953a061196a8c3b113ef6d81e5848fe95745147b2", + "research/gmx-t74-borrow43-handoff/new/borrow/alias_build.py": "40b97536c8347733eaae24a3c4a13f5d21711e983106454777837be487959f1b", + "research/gmx-t74-borrow43-handoff/new/borrow/alias_enumerate.py": "7324f2569e6b76981d8c964a16ff9a3bc9e770e41b9cc6ec1c9defe8e662c153", + "research/gmx-t74-borrow43-handoff/new/borrow/audit_local.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "research/gmx-t74-borrow43-handoff/new/borrow/build_word.py": "40047409dd9f9c406bb37a2ed0b4c8159797e0e4a114d525a368355418128707", + "research/gmx-t74-borrow43-handoff/new/borrow/emit_word.py": "a057ed0c81fbb07dabf38247e0ce0cec6c5fbfa31d8bf1b38838bd3758e41f87", + "research/gmx-t74-borrow43-handoff/new/borrow/guard_cut_centres.py": "5df204597697756808e6c959f5bba81cf35a2f0e7a0f1f75748dca1814373b72", + "research/gmx-t74-borrow43-handoff/new/borrow/guard_helper_indices.py": "d93aeb2d51d77ca93ecbf9e566d9000bb436c279e2a25b699a867e9697f782fd", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/alias1_43base.json": "2c5b5491da4b3e8a8356fd42a12a8fc8b2c9b4b0b20c4adc4e273ba217230e11", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/alias1_43extra.json": "0a54f41f886bf4f61fa620c65725373be905524ce906e5e95d501890de783179", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/alias8_43base.json": "3b91dd5a0d1b297a48e278b45903e073c5cefb23f22921f6a738bcbbf21e521f", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/alias8_43extra.json": "3ab265a33750a229a9201c2baff45ad91f1bef556879306d2fb743f5290cab31", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/dirtentry_43base.json": "a067f7138f23eed6434286e7bd53548c86a7eef58c654374b778b4f424e9ffef", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/dirtentry_43extra.json": "8280fafb4642389ae91989e870ece7c9f2bffa38c9b52f2424b8abf489ba71f8", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/entrance_43base.json": "1b3c09f9558c50e7f299aa10fb21dcbd1b5ff397794838d8629c80d4c7a565f5", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/entrance_43extra.json": "e57ec67fa0a3fca63bf9e4bb9edf4e6be48db0bd7c9e092cddad29b26b897463", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/handoff_43base.json": "5ae3062bcce666c8c3a3a650e345adf15c22a2800fa0e17d79ad6e8b97208a2f", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/handoff_43extra.json": "4238a7c5093a4347fe69adf4f76e507d2f43c4e727d91b2c4705039e1cbaa06a", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/kernel_43base.json": "7f06b4b08a49192a27e8f4132ad0c93521dad90f97ca985a173944ba02c5442b", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/kernel_43extra.json": "ef95eae03915f0222bcd486959c6dfe307a9a0a856702420fa35491abfae4c84", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/lowfour_43base.json": "a8df0a2acf85e96febb35d24ae047c370d179095b46142bae968f06348bf1c18", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/lowfour_43extra.json": "9dbfb49fb3c04a0652dcae9a962d973489679f5d1ee2baf4e65c58d2e8ef578c", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/prelife_43base.json": "ec43328c198094c0e8b37cf93de0210d2ba0397ed20dcaec1f1d121ffa5cdb69", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/prelife_43extra.json": "a7fc8362edaf33de314bebc400bcda6a6cc345ac6ca86220e1f53ae43cbc8600", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/refit563_43base.json": "4ba6d0fe6f5f03095821f1080f1cceb97204a3189ab0e48092e1cbccb1d7ceae", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/refit_43base.json": "19a97e80b0ee3146e0244e6bc36bd365d89e9c1cd0f885c4e06be4193606a323", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/refit_43extra.json": "1349d54f704847fdcd4a00e323cdc9e1118fac7fedb0c7573e9b2b3f0169a7eb", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/retired7_43base.json": "74daf5826d9191be4613a61447f4dc12789190fb49a3219f6a9df63075cac1e1", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/retired7_43extra.json": "25d9774b512da78f042287ce1de91c79c8658d06488b8fe94e548cbdd036f034", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/twelve_43base.json": "ee268c45a9c768a6a4cecf401cd4446cebb042e67d69e5fb6d078934d5a49498", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/twelve_43extra.json": "4ff1d00714d0dfacf95b89778f6c1abb113877f8c9880c01a06d0f30998756ee", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/witness_43_base.json": "65ee52604e2e49a30c1e978b7ce829482a694a20a8744f37b9bf40dad1ff3a2e", + "research/gmx-t74-borrow43-handoff/new/borrow/inputs/witness_43_extra.json": "19c652db80d5215c958c63b5d6f2de96d9cf34a0e4d56dab5c13e556c57f7467", + "research/gmx-t74-borrow43-handoff/new/borrow/lowfour_controls.py": "b1484a0ab1ad5f87a71b8e48ee8c5ba7604835acfe2b841b6f13cbd12f32e344", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife/results/gap-base.json.gz": "cf596232260cadcc02bf1020c2e138a31e9482140c4ee2bdf6a0a32797a1187c", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife/results/prelo-base.json": "9d6fa7827d991281a647043a4675c001964bf5bfa4045e54ce0e192ab74a19c9", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife/results/tryE-base.json": "aeb3e8e7442ff104806ab39e8fcbe366fdcda95b64909c107d255c379ad579fb", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife/search/chains.py": "588d6cdb2312febfee5f3d576295f2edff53ca74c14d21ed9bffed3312dfa32c", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife/search/edit.py": "8e5eea35d0bb83aa60bd066ae9ddf3f4b0ad46cf9ac9d31d8fc5777f49013713", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife/search/fm.py": "36174e2b7e012726964282af926fdf541332556bcc548af5b41502cdb8b198e2", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife/search/gapbound.py": "a0fa0fbd079a456bf5f9b75352eb68c4b7e2febad0c99e66b7553bdc744772c8", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife/search/mk1.py": "4bab66a4e1514a067572c7854731a4fbd29681300e95a4384fdb68e0eb140575", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife/search/prelife2.py": "db1fc5eea7bd70066188d7c7f52cf4be8991e61b821d3fe4b779ee30c7f3c9eb", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife/search/prelo.py": "157dc45b5fcc421d26507d6d7fca6d4caeff6c73efcd679fd28e906f600ea886", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife/search/propbound.py": "735cd4d1a6a43c96f397eb5ae2972e86ab71c2c232e6d14ac6cbf1eb7f638c1c", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife/search/repair2.py": "410ddd6f9b3e14be6b9247cc5792d1a893175e843a0c21bf667e71a6e3a9710f", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife/search/tryE.py": "130a859c0ad20623943b25800dd2f1d0355cf03b8520fc493ec870baa010b2ae", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife/search/wordmodel.py": "215e678d3f3711b4291f9da5d7937cdbb0b091390bba089e6949b8c42a29f6f4", + "research/gmx-t74-borrow43-handoff/new/borrow/prelife_controls.py": "c24398bdc407aaf6713201100d27ba851233525a9dfd747b641d99e1cde66cba", + "research/gmx-t74-borrow43-handoff/new/borrow/receipts/AUDIT-43base-pinned.json": "8dc6daa8929c1137c1e37fa5a1bf869afafe94c3e65ed2705ea9f41f2dc8cee8", + "research/gmx-t74-borrow43-handoff/new/borrow/receipts/AUDIT-43base-prekernel.json": "fb6f40a1d117bd304cc0757ac21915bd8558e8d3f31b8709129f395033fc534e", + "research/gmx-t74-borrow43-handoff/new/borrow/receipts/AUDIT-43base.json": "07b8a4836fe2659d0d46957ed0973ba3334f6752b5c1235d03b961a107fb95d5", + "research/gmx-t74-borrow43-handoff/new/borrow/receipts/AUDIT-43extra-pinned.json": "4176a6190fb1a224d45797064cde2aa758970bce7c1ed2a009ecb2fc7839d26e", + "research/gmx-t74-borrow43-handoff/new/borrow/receipts/AUDIT-43extra-prekernel.json": "09041e49888a1360b7ddee29d54d82836a875ecb6547c7ad1eb92427e7f3b384", + "research/gmx-t74-borrow43-handoff/new/borrow/receipts/AUDIT-43extra.json": "a01ae6847449ddb88c56fa8e44d10bc0b005f1b24daa283d38ba00089d8f89f2", + "research/gmx-t74-borrow43-handoff/new/borrow/receipts/CONTROLS-43base.json": "02b73bfbf72c63926ebb244bbd6bf87a03201ee1487e2c15292ad52684fb4d69", + "research/gmx-t74-borrow43-handoff/new/borrow/receipts/CONTROLS-43extra.json": "f8b93901ef5b4810bb39a7b5ccdc62497612c2efba67920a8d6119ae8a898126", + "research/gmx-t74-borrow43-handoff/new/borrow/receipts/CONTROLS-KERNEL-43base.json": "2b40a169ede95155b5ffe276589b911d9704ef904cfaac41bf41b24140d40907", + "research/gmx-t74-borrow43-handoff/new/borrow/receipts/CONTROLS-LOWFOUR-43base.json": "e0e3e01afefb69952da0063b3e6daaa032a4d1dd71d1d68cbcb7f3530a6ecb38", + "research/gmx-t74-borrow43-handoff/new/borrow/refit/results/pairs-base.json": "8178d2a34be82601f2361afbc63b37294255a435b243e65295bf7b641edfc4a3", + "research/gmx-t74-borrow43-handoff/new/borrow/refit/results/pairs-extra.json": "3a64b6ace504a5d410a4cfd87ae2fc04576df61883ce56e3f7eb38d4b26df8af", + "research/gmx-t74-borrow43-handoff/new/borrow/refit/search/bounds.py": "690986e69e3125723b12255cc5aa135fceec93894d589eb196ab7fa5da37e9fb", + "research/gmx-t74-borrow43-handoff/new/borrow/refit/search/eval1.py": "0547e606468ad4670512ea83fb3d6e7f39fda9b66537fdf791ad22a3bf4aeeee", + "research/gmx-t74-borrow43-handoff/new/borrow/refit/search/mkcand.py": "c5b437f6a991de674bd781d610d98a43d9f84179beb1187340354e55f42ceaa4", + "research/gmx-t74-borrow43-handoff/new/borrow/refit/search/pairs.py": "7922404bf942eff2dda0125b78ff1234bfdfda5101ff428b11f8a5ed73ce4882", + "research/gmx-t74-borrow43-handoff/new/borrow/refit/search/refit.py": "c036d0d4cc91360e583a7ed01d6c69c17a69f16c5838062c2b9de83a616d2e23", + "research/gmx-t74-borrow43-handoff/new/borrow/refit/search/why.py": "209a95a62a95c06138f0b5af2d1dd1f9c60c403c4da294d39663928c2312425e", + "research/gmx-t74-borrow43-handoff/new/borrow/word_patch.py": "9b3287f189c4f29c1a8bdb1ba01fdcfe14a57d87b50fa4f2f646fb2346ab01ce", + "research/gmx-t74-borrow43-handoff/new/code/borrow/NOTICE-PR2226.md": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a", + "research/gmx-t74-borrow43-handoff/new/code/borrow/bw_transport.py": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "research/gmx-t74-borrow43-handoff/new/fastnative/.gitattributes": "92e5734dbb86fb8958622e6dcea5895601800a24b0722ef86220322449a44ff8", + "research/gmx-t74-borrow43-handoff/new/fastnative/EXPECTED.json": "8d45fba81564631f9f8614e637b9fbe69dc911b4e2f0b77f0a7071f39cfd7ca8", + "research/gmx-t74-borrow43-handoff/new/fastnative/FRESHNESS.json": "92abf8c25be59ff71a90781f38c5db2f9176c623df046a6d0e2327fd0235cb6c", + "research/gmx-t74-borrow43-handoff/new/fastnative/PINS.json": "f619e8e1c163078fb70c6fc3b98a498a671b8c02927b91d6cc253af2a775b6c9", + "research/gmx-t74-borrow43-handoff/new/fastnative/README.md": "6a2026383804606cd7981e087192b3488c674f2d9443ec218dcb2e85d06406dc", + "research/gmx-t74-borrow43-handoff/new/fastnative/SOURCE-PROVENANCE.json": "8daf4fc7c75db99d34641152682208ce6c974f50d509960d0f4fa021f862abee", + "research/gmx-t74-borrow43-handoff/new/fastnative/SOURCES.json": "3599ed28c8d8a9ce096bc13507b066d09e3968587781748b2bc72f634618331b", + "research/gmx-t74-borrow43-handoff/new/fastnative/TASK.json": "8159b49d5c73dd887d432a4680dc947f63e7158a01a66d7736ff7138e8149732", + "research/gmx-t74-borrow43-handoff/new/fastnative/VERIFY.json": "e46542b70296c039b5bea0c0aa9cfd4e95e1df8859e67885ed3403bea9da7b32", + "research/gmx-t74-borrow43-handoff/new/fastnative/benchmark.py": "3e544453c89310281d745a37e861cbd79065b1740d90f1ec883fc200b189a557", + "research/gmx-t74-borrow43-handoff/new/fastnative/common.py": "8f04e08b99a370fa82115fc46fbb3af4ab44f4facd47de07b01e1a2499a94914", + "research/gmx-t74-borrow43-handoff/new/fastnative/compare.py": "ebf877a6f47ef1fd2b797fd6077bd45d132d8cb56ab7553044bae3d86e238e45", + "research/gmx-t74-borrow43-handoff/new/fastnative/controls.py": "03131f4dc6a1830f10e35fb837ada456f060ca510994d250c5c2666a6342c23a", + "research/gmx-t74-borrow43-handoff/new/fastnative/evidence/BENCHMARK.json": "9b192c5697514c7b36b709d0e5506915425ca61f24af0210e2508d7b1bdb295f", + "research/gmx-t74-borrow43-handoff/new/fastnative/evidence/COVERAGE.json": "8bead250cc97614528d9448dfd29529bf08605daa5e8007e701038ab317e00f6", + "research/gmx-t74-borrow43-handoff/new/fastnative/evidence/REGISTERED.log": "78a49def69d0465f4318b9e24613246ba5fb6de19441e54b88fb50dfe823f149", + "research/gmx-t74-borrow43-handoff/new/fastnative/evidence/VALIDATION.json": "d265ce16251effd6b5d3b7429f31f98cd385fe79f659cfa24a2820bc17ac70dd", + "research/gmx-t74-borrow43-handoff/new/fastnative/requirements.txt": "a23aaf94250a9f53031a592980142245a848e2372b6c6c3093e8260b129265b8", + "research/gmx-t74-borrow43-handoff/new/fastnative/run_native.py": "a7bfe110fe5098f6ef8bde3c43ecf15e8d1e06149abf7321a4c945383dcc2627", + "research/gmx-t74-borrow43-handoff/new/fastnative/stage.py": "3cce27dd5a359ebc4dc70d4aab994aee52bc0a12e59db7da3f902257f876cffe", + "research/gmx-t74-borrow43-handoff/new/fastnative/vendor/native/new/code/borrow/bw_audit_local.py": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07", + "research/gmx-t74-borrow43-handoff/new/fastnative/verify.py": "6dbdc56ca6cfde987869e12990a495d7eded78dd1887fb3fdf2d196060220fcc", + "research/gmx-t74-borrow43-handoff/outer/CLASSICAL-BOUNDARY.md": "6647d5a71d9f6c3f628ac71a7be2e63bcb0cac9618cd4fee7493dcc4ef02529a", + "research/gmx-t74-borrow43-handoff/outer/FINE-PADDING-COMPOSITION.md": "d20d8e5f84a9e33cc9996f875be06c24c74ea53874cc76564953785ff29c5c6c", + "research/gmx-t74-borrow43-handoff/outer/GAUGEFREE-INTERIORS.md": "ebeb7fa53dca671e45b3a3dedf4603607d19461bbeb977445bf5e17bbdb25db8", + "research/gmx-t74-borrow43-handoff/outer/STRUCTURED-BOUNDARY.md": "ceef915be6462a8ad81449eefb86bf4d97db6ac41c87660e9dd7cfd2c2bc1efa", + "research/gmx-t74-borrow43-handoff/outer/UNION-SCHEDULE.md": "bc8e9cf7c178bb39b092ab5aafc4eeb523e72b1f69639bfcb9f27d0f74109357", + "research/gmx-t74-borrow43-handoff/outer/check_gaugefree.py": "f8d49739d3f5819a62f9862a624dab7bebb019f3d8ab949524cb9bbf58d3ef66", + "research/gmx-t74-borrow43-handoff/outer/check_ledger.py": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "research/gmx-t74-borrow43-handoff/outer/run_outer.py": "9d5dc0a7ea38973ce52a1cda02d311c235bc7c39c4d20921d5811cab1a57ef8c", + "research/gmx-t74-borrow43-handoff/outer/struct_check.py": "f1df92bb6247034a22e141dcb39c1e8b6b9df6eb9791493be25a3911f7add8d4", + "research/gmx-t74-borrow43-handoff/reconstruct.py": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "research/gmx-t74-borrow43-handoff/requirements.txt": "255a2ee4a60637759d4d5c89448c55849153e81ec1d1383555c6697784d9dc97", + "research/helper408-rank7-pairing/sources/PINS.json": "d67d70971d36ccd8faa4e0edfd65852e0a41888997fc6a3937e725b573ea0e6a", + "research/helper408-rank7-pairing/sources/data/PARENT-base.json.gz": "c20a470aec0f3e61833cb41fe190639eb358f58017143d2336c55c80fba265eb", + "research/helper408-rank7-pairing/sources/data/PARENT-extra.json.gz": "db34e39876241087b581ed9374c53e9cd393e3e86ef6103bfb54f3077c3d2761", + "research/helper408-rank7-pairing/sources/data/TRANSFORM.json": "1d38f0369fce0b892d202ce2e5fd7ea95d9a95d3f80734b672cddd5cb93ce8ca", + "research/helper408-rank7-pairing/sources/data/WORD-base.json.gz": "3657ad53ebe5f156f307a903479e919f2fe812811ce5d5f15e72c3aaf68dfde3", + "research/helper408-rank7-pairing/sources/data/WORD-extra.json.gz": "b975492ff4cbec0d619cdf2da34f55ce3b20c8a541132e4339cc6c8ae3b2e487", + "research/normal45-a-retiming-boundary/vendor/preload_move.py": "c8fda4674644fcd5cbf39b6645ce148a21daa90a998b678cbe51f970b78b0044", + "research/normal45-owner-cost-bridge/inputs/PARENT-base.json.gz": "fec3c120db1a35022944628d34b56a36f2456248c274c2eaba1a325cdc690ce8", + "research/normal45-owner-cost-bridge/inputs/PARENT-extra.json.gz": "e4d0c617df85bf8a824ff68310ca3373dc017c1ebf9ea733056a3ee4a784b36f", + "research/paired-extension-normal45/structure.py": "83f63b6d9a1a543ecfa2c98d479dbe4e7a1c3caf6fd1c3566123308efbc32e96", + "research/paired-helper-extension/PINS.json": "3d49ca62f3242444db52a21b9de10f18293757842f64a2b3189ad8f4e61fad36", + "research/paired-helper-extension/data/TRANSFORM-299.json": "781585f68449c30f63e40ee4bf58d1fa194e4faf8cf4394505437fc15137ba34", + "research/paired-helper-extension/data/TRANSFORM-304.json": "024515c6e47d952dfaf307fcefda9f2106049ccc28875ae620d95241fdec72ed", + "research/paired-helper-extension/data/TRANSFORM-320.json": "0e4c0216221ab21c4bf48a11eab34ff6cc245014d664dc1523cfae9d437dc00d", + "research/paired-helper-extension/data/TRANSFORM-331.json": "355bcfd60ffcb672f66882e66bae1b046d1bfb979f725b411b034f811dfb68bb", + "research/paired-helper-extension/data/TRANSFORM-412.json": "54328a8436d7abed6433da5e4384a36ad95b266070479b496e0e96416a5f5a79", + "research/paired-helper-extension/data/TRANSFORM-424.json": "42747fa1332af1ca0827edebfff7490ee761f84f662527f593e975a502400dbc", + "research/paired-helper-extension/data/TRANSFORM-428.json": "89e8fbd5a5d1d64d386cdc38f257cae18d8e7428e868f618ed1f0be5a22aba3e", + "research/paired-helper-extension/data/TRANSFORM-499.json": "f86eef40cd96b45c67755903eae6a86432e2aeb6d53812621222db7c062d88f6", + "research/paired-helper-extension/data/TRANSFORM-511.json": "48e0749f1c82594841c88923a38b0308ed777639631a4c3f2414500617f2e34b", + "research/paired-helper-extension/producer.py": "c60546ca68a905d237401b2a255ccb60e17285b004211d523b5d8fd57b758f5a", + "research/paired-helper-extension/verify.py": "5fb7984329ce7213294c8f76a3151f06759005456940968b4cc84712933321ee", + "research/paired-swap-normal45/CLAIM.json": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77", + "research/rank7-coupled-586-588-carrier-fold/edits/declared_edits.py": "4871287e859c6451b53adbd602eb209ad62acc7f3c6eb88106be3010044ef82b", + "research/rank7-coupled-586-588-carrier-fold/edits/edits_review.py": "2fca291cc254f61ed3528de2b95e59e54c578d7fbdec0e5c0c330350d4fbda32", + "research/rank7-joint-endframes/allocation/DISPATCH.json": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c", + "research/rank7-joint-endframes/allocation/ORDER.json": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1", + "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/shared-kernel-packing/vendor/pr2857/review_four_groups.py": "5b323e50fb5a10ac088472b3e085b54d7d2ae3a29f8552ff44b788a984eb97d1", + "research/shared-kernel-packing/vendor/pr2857/shared_kernel.py": "b3241527e6c136dc4b54975ef401c49d452bd6159fb99030accaf095c8fbd3ed", + "research/shared-kernel-packing/vendor/pr2857/words/WORD-base.json.gz": "001b14314d8db873d4d80826d4af9c40a3e5a1fecde743e5a26391bdf673f458", + "research/shared-kernel-packing/vendor/pr2857/words/WORD-extra.json.gz": "bc5bfe51178f0c3312d28318412ec490463c896ceed0660b9c443fcb76496546", + "research/t8-rank7-two-swaps/MATERIALIZE.json": "54b4e3d38bf16b81d87827275325dfe0bf0b5cb6f7e4ce7543a1061c6ad89122", + "research/t8-rank7-two-swaps/derived-overlay.tar.gz": "053de667b534bef38f71f0c86f39647c3af501a3f940bb3e3e797d4373ee2144", + "research/t8-rank7-two-swaps/materialize.py": "b2a9e121c18abcf6a07024ef8938c1c461d15bb23756819ed78f28b18a759185", + "research/two-sided-helper-extraction/extract.py": "e9f530fd9a2d72c86a65ae1dea147a61d072969deded314973b5f31de90c91ac", + "research/two-sided-helper-extraction/verify.py": "9cebf9f20ae8d1d66cc066507a92456b719714fd83b7223e5352a507c4b2903f" + } +} diff --git a/research/staged-release-retiming-t530/full-admission/NOTICE b/research/staged-release-retiming-t530/full-admission/NOTICE new file mode 100644 index 0000000000..59d8e0cf31 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/NOTICE @@ -0,0 +1,415 @@ +A sharper exponent for integer multiplication +Copyright 2026 Douglas Colkitt + +This project includes unmodified source files from OpenAI's manuscript +"Integer multiplication below n log n" and its accompanying repository: +https://github.com/openai/math +Commit: adc7f1241b42e322a6451854ab7e4b4c146bf78a + +The original manuscript identifies OpenAI as its author. Its Apache-2.0 +license is retained at upstream/LICENSE. The exact source URLs and hashes +are recorded in upstream/manifest.json. Proposed modifications are supplied +as separate files under patches/; upstream source files remain unchanged. + +The original local research note, scripts, certificates, patches, and +documentation were prepared by Douglas Colkitt with assistance from OpenAI +Codex. The community release incorporates work by the contributors identified +in the notices below; it is not solely Douglas Colkitt's work. +This project is not an official OpenAI release or an OpenAI endorsement. + +Related contributions (not imported in this checkpoint): +Zhihao Chen (jacklightChen), PR #7, supplied an earlier ternary five-subset +motif, finite-alphabet transfer and a different compressed producer: +https://github.com/CrocSwap/integer-mult-bounds/pull/7 +The present checkpoint claims no priority for that motif. Related compressed +complex-network work was submitted by eumemic in PR #3: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +The pending contributions and their stronger bounds require their own review; +this notice does not represent adoption or verification of their claims. + +Additional community work, including parallel and superseded submissions, is +acknowledged in CONTRIBUTORS.md, with pinned submission metadata in +docs/research/contribution-snapshot.json. These acknowledgements do not imply +joint authorship of the checkpoint, incorporation of pending code, or verification +of submitted mathematical claims. Original source-specific notices remain in force. + +Community release (accepted by conditional maintainer audit): +The following original contributor notices apply to the imported PR #39 chain. +The preceding non-import statements describe the preserved 2^-30 checkpoint. + +Ternary five-subset construction and common-four-point resynthesis +Copyright 2026 Zhihao Chen (jacklightChen) + +This is Zhihao Chen's first submission of this specific construction to this +repository. Research, proof development, code and verification were prepared +with substantial assistance from GPT-6 Astra (OpenAI Codex), as identified by +the contributor. This is not independent review or an OpenAI endorsement. +Future research building on this contribution should explicitly acknowledge +Zhihao Chen (jacklightChen), cite the accompanying note and pull request, and +retain the preceding contributors' attribution. This notice records research +provenance; the repository's Apache-2.0 license remains unchanged. + +Dependencies retained from eumemic's Claude-assisted PRs #3 and #5: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +https://github.com/CrocSwap/integer-mult-bounds/pull/5 +PR #5 commit: d3d370c34937503bd3fa63c83d505a05e8e50893 +These include complex_circuit.py, complex_network.py, fast_gaussian.py, +their generators, construction notes and certificates. The Gaussian input +scaling proof is corrected in this derivative; see the modification notice below. +Aligned pairing also appears in Bortlesboat's PR #2. Retained totals and bank +sharing appear in dleen's PR #4 and cheaper retained centers in eumemic's PR #6. +Their results and ideas are credited separately from this new construction. + +Bulk recursion and controlled tensor basis, 8 October 2026 +Copyright 2026 icekylinx + +The new projector batching, controlled simultaneous basis, mixed-width tape +recursions, whole-residual complex recursion, and dependency-path precision +guard in the batched-23 proof package are contributed by icekylinx, developed +with substantial OpenAI GPT-6 Astra assistance. Review corrections and +repository integration were prepared with OpenAI Codex assistance. They build on the retained +PR #7 finite producers and the preceding contributions credited above. +The new package retains the repository's Apache-2.0 license and the original +authors' attribution. It is not an official OpenAI release or endorsement. + +Modification notice, 8 October 2026 (icekylinx): the retained fast Gaussian +proof now bounds shifted approximation error by F=2^ceil(1.14 alpha^2). +The P=34p precision budget and asymptotic exponent are unchanged. New batching +checks are integrated into make verify. Existing attribution and licenses +are retained. + +Partial-swap extension, 8 October 2026 +Copyright 2026 icekylinx + +The partial-swap framing, binary retained-total triple construction, +dependency-preserving positive labels and carrier reuse, unequal (25,23,57) +common basis, improved complex batching, and exact assembly are contributed +by icekylinx with substantial OpenAI GPT-6 Astra and Codex assistance. +This extension directly inherits PR #10, commit +62691e395a0458ce089a1c7b5d89e74291e95e29. The portable producer adapters +modify the retained paired-exclusion and shared-point implementations credited +above. The original licenses, attribution, and Gaussian correction are retained. + +Endpoint-gauge extension, 8 October 2026 +Copyright 2026 icekylinx + +The complementary auxiliary endpoint gauges, (32,30,40) controlled basis, +general nondegenerate binary phase residuals, retained-center complex producer, +updated path guard and exact assembly are contributed by icekylinx with +substantial OpenAI GPT-6 Astra and Codex assistance. This extension inherits +f2ab41aebad47861caf6316282c1793e5513845e and its PR #10 ancestry. New portable +adapters retain the paired-exclusion and shared-point contributions credited +above. Original licenses, notices and the Gaussian correction are retained. + +Structured-basis and semantic-bulk extension, 8 October 2026 +Copyright 2026 icekylinx + +The selected (32,30,36) bit construction, A1/A5 block refinements, fixed +middle-axis I+J profiles with bounded-minor CRT certificates, mixed dyadic +complex centers, complete data-front batching and circuit-specific assembly +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. The immediate parent is ed90fd940279c336ebc45968631bdebfb087b505. + +The semantic/bulk compatibility argument, literal scalar charge, product row +stock and parameterization adapt Zhihao Chen (jacklightChen)'s PR #23, +commit 661ebabc1076c9f525d7ce4967c876b203fa9827. Translated complex endpoints +are adopted from the same contributor's PR #21, +commit 5ba6cf0bfb68f2be8d15610e7972207c50254d6a, following eumemic's source-frame +work and the earlier nested-basis contributions. + +Completed-child semantic precision, arbitrary-coordinate routing, phase-cell +Gaussian inversion and bulk tape transfer are credited to the RaD project +(hipotures), commit 45d9b60355872041f9275f77c057514def0d45bc, exposed through +PR #20 at 4f8d6c8272b5ff307a0da51df545ec3cd96a8b6e. Their selected proof +sources retain their separate CC0 license and original NOTICE under +references/semantic-bulk/rad20. The PR #23 source retains its recorded OpenAI +Codex assistance; RaD retains its recorded Codex and GPT-6.1-Sol Ultra +assistance. These are source attributions, not claims about this session's +runtime model. Related contributions by Rohan Arun and Aurel Prosz remain +acknowledged in the imported notices. No exclusive priority or additional +license condition is asserted. + +Copied retained-center extension, 8 October 2026 +Copyright 2026 icekylinx + +The copied retained-center schedule in both orientations, its complex-phase +transfer, the Wm-N+L rank budget, and the selected (25,23)/(28,28) composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. This extension inherits PR #32 at +0ef3aeb61f55cc0b321ce6a0ef00acee25cefe52 and the preceding PR #10/#18/#24 work. + +The two-stage topology and paid copied-stream endpoint correction are due +to Aurel Prosz (Paureel), c82d09eb4781b68435e3fa3eb6beea72fa900fab, +through Zhihao Chen (jacklightChen)'s PR #29 unequal-axis composition, +9d963275075fa98f1da821e27757b238dafd6b3c. That source also credits Swapnil +Jain's two-stage development at ae405eb474d1486b2d8aef90139869f927f4836a. + +The contiguous corner method, incidence factorization and exact partition +certificates are due to Rohan Arun (PR #31), method commit +02f68f95369c39955c5ffcfddbd75cd83e26b305. The selected (25,23) certificate +specializes Dominik Scholz's parameterization (PR #33), +a499a345c040aa15b68e984a0904eadc485c7a7e. Their source notices and proof +snapshots are preserved in references/copied-centers. Historical OpenAI +Codex, GPT-6 Astra and Anthropic Claude Opus 5.5 assistance is credited to +the respective imported sources. Existing PR #21/#23 and RaD attribution, +licenses and the Gaussian correction remain in force. + +Copied centers with reversed (23,25) data corners, 2026-10-08 +Rohan Arun with substantial OpenAI Codex assistance supplies the composition, +exact dimension23 controls and cost/assembly integration. James Chang's PR34 +supplies the reversed boundary family; icekylinx's PR36 supplies copied retained +centers and the selected complex graph. The balanced assembly remains attributed +to RaD/hipotures and its PR34 specialization. Retain Dominik Scholz PR33, Rohan +Arun PR31, Zhihao Chen PR29/21/23, Paureel/Aurel Prosz, Swapnil Jain, icekylinx, +eumemic, Douglas Colkitt, OpenAI and all earlier notices and hypotheses. +This is not a claim of formal verification, new foundational rank identities, +global optimality or measured runtime speedup. + +Fixed middle basis with copied reversed corners (2026-10-08): +Rohan Arun, with substantial OpenAI Codex assistance. Composition and +simultaneous-basis proof retain icekylinx PR32/36, James Chang PR34, +Dominik Scholz PR35/38, Zhihao Chen, Paureel, Swapnil Jain, RaD/hipotures, +eumemic and all preceding attribution and licenses. See research/copied-fixed-reversed. + +Changed-graph composition with copied centers and fixed bases, 8 October 2026 +Prepared with OpenAI Codex assistance. +The new composition uses icekylinx PR36 copied centers and PR32 fixed-I+J +projectors/profiler, Dominik Scholz PR35 two fixed factors and CRT argument, +Zhihao Chen (jacklightChen) PR29/23 interfaces, Aurel Prosz (Paureel) and +Swapnil Jain's two-stage development, Rohan Arun PR25/31 corner methods, +Dominik Scholz PR33/38 dimension/composition work; James Chang (jamesyc) +PR34 reversed geometry and balanced transfer; Rohan Arun PR37/39/40 +reversed integration, modular data tests and both-fixed baseline; +RaD (hipotures) PR41 changed scalar DAGs, alternating point order and +independent role compiler; RaD balanced routing/bulk interfaces, and all +retained predecessors. +Complete attribution and the conditional proof boundary are recorded in +research/copied-fixed/PROOF.md; imported originals and source pins are retained. +Original Apache-2.0 and CC0 notices remain applicable. + +Community follow-up integration (PRs #49, #45 and #26), 8 October 2026: +Rohan Arun contributes weighted carrier matching and climbed summand/leave-one-out +orders (PRs #44/#47/#49), with Anthropic Claude assistance. The final construction +composes Chafik Boukhalfa's changed-graph checks, exact rational data recovery and +reordered exclusion sums (PRs #43/#46/#48, OpenAI Codex assistance) with RaD / +hipotures's alternating pair order and independent physical role compiler (#41). +All predecessor attribution and conditional proof interfaces remain in force. + +Alejandro Zarzuelo Urdiales contributes Gaussian parity and canonical arithmetic +proofs, finite tensor execution, profile precision accounting and mixed-center +reference checks (#45), with substantial OpenAI Codex assistance. See +research/gaussian-parity-synthesis/PROVENANCE.md for his full attribution. +Ryan S / princezuda contributes historical Lean certificate arithmetic, algebraic +frame/movement/guard lemmas and independent paired-circuit checks (#26). Original +source notices and historical snapshots are preserved. Neither formal package +claims a full formal proof of the multiplication algorithm or a new kappa. + +Joint frame compilation of skip-prefix strips + +The local compiler and exact finite witnesses were prepared by eumemic with +substantial OpenAI Codex assistance. Avi Eisenberg / ikeboy with Anthropic +Claude assistance supplied the unmodified PR #53 skip-prefix producer. +The pinned PR #48 pipeline is Chafik Boukhalfa's contribution, incorporating +Rohan Arun, RaD / hipotures, icekylinx, Dominik Scholz, James Chang, +Zhihao Chen, Aurel Prosz / Paureel, Swapnil Jain, eumemic, Douglas Colkitt, +OpenAI, David Harvey, Joris van der Hoeven and the earlier contributors +credited in the retained sources. See references/frame-compiler/pr48/NOTICE +and references/frame-compiler/pr53/NOTICE for their original attribution. +No authorship or review by those predecessors is claimed for this compiler. + +Joint dual-skip/frame-compiler composition (2026-10-08) +--------------------------------------------------- +Rohan Gupta / gupt1156 with Anthropic Claude assistance: PR55 dual-skip +scalar graph; original LICENSE and NOTICE are retained under +references/frame-compiler/pr55. eumemic with substantial OpenAI Codex +assistance: PR57 joint reversible frame compiler, serialized physical-word +replay and profile reconstruction. Chafik Boukhalfa with OpenAI Codex +assistance: this composition, independent integration and exact certificate. +Avi Eisenberg / ikeboy, Rohan Arun, RaD / hipotures, icekylinx, and all +predecessor authors retain the notices above and in pinned source files. +No original copyright or Apache-2.0 notice is removed. + +Ranked reclamation after the PR58 joint-dual composition (2026-10-08) +---------------------------------------------------------------- +Chafik Boukhalfa with OpenAI Codex assistance: prioritize retired physical +slots by descending current frame rank, retaining slot ID as the tie-breaker; +complete replay, exact profiles, comparison and adversarial controls. +The dedicated joint_dual_reclaim_compiler.py is derived from eumemic's PR57 +compiler. Its original shared compiler remains byte-identical. The PR55 +producer and all preceding attribution remain unchanged. The complete PR58 +comparison certificate and its original source/proof provenance are retained +under references/frame-compiler/pr58. + +Skip-prefix strip producer, 8 October 2026 +By Avi Eisenberg (ikeboy), with Anthropic Claude (Claude Opus 5.5) +assistance. The skip-prefix leave-one-out strip layout in +research/skip-strips/skip_graph.py is new. Everything else reuses Chafik +Boukhalfa's PR #43/#46/#48 research/copied-fixed pipeline, its verification +code, exact data recovery and support-order sorting, together with: +- Rohan Arun's PR #44 weighted carrier matching optimizer; +- RaD (hipotures) PR #41 alternating point order; +- every predecessor credited above. +Complete attribution and the conditional proof boundary are recorded in +research/skip-strips/PROOF.md. Original Apache-2.0 and CC0 notices remain +applicable. + +Local split-pair skip-prefix research continuation (2026-10-08) +Prepared with substantial OpenAI Codex assistance at the user's request. +New contribution: singleton/pair recursive partition refinement, finite summand +order and moment search, and verified composition with inherited paid clones. +Avi Eisenberg/ikeboy with Anthropic Claude assistance: PR53 skip-prefix strips. +Chafik Boukhalfa with OpenAI Codex assistance: PR54 original-envelope clone +specialization and PR43/46/48 checking interfaces. RaD/hipotures: PR51 +whole-chain/source-partition cloning and earlier producer/interfaces. +Rohan Arun: PR44 weighted matching and earlier fixed/reversed work, with all +stated historical AI assistance. All predecessor notices remain applicable. + +Original-envelope whole-chain clones on skip-prefix strips (research/skip-clones): +Chafik Boukhalfa, prepared with OpenAI Codex assistance. The complete-chain +source-partition clone operation is adapted from RaD / hipotures, PR #51, +with original envelopes retained here. The scalar base is Avi Eisenberg's +PR #53 skip-prefix layout, prepared with Anthropic Claude assistance. +All credited PR #43/#46/#48, PR #44 and earlier code/proof notices remain +in force. This extension is provided under the repository's Apache-2.0 terms. + +Community review checkpoint #50–#61, 8 October 2026 +Maintainer integration and independent arithmetic: Douglas Colkitt, with OpenAI Codex. +Avi Eisenberg / ikeboy: skip-prefix strip framework (#53), with Anthropic Claude. +Rohan Gupta / gupt1156: parallel order search (#50, stated Antigravity assistance) +and dual-suffix strips (#55, Anthropic Claude assistance). +Eumemic: equal-frame joint compilation and paid signal reclamation (#57), with Codex. +Chafik Boukhalfa: original-envelope paid clones (#54), composition (#58) and ranked +reclamation (#60), with Codex. Rohan Arun: order search (#52) and positive-frame +composition (#56), with Anthropic Claude and stated Codex validation assistance. +RaD / hipotures: enlarged frames, source partitions and paid whole-chain clones +(#51), with Codex. Rohan Garg / rohangar1: singleton/pair recursion and paid-clone +composition (#59), with Codex. Alejandro Zarzuelo Urdiales: exact parameter +refinement, scoped Lean arithmetic, matrix/parity and search tools (#61), with +his disclosed multi-tool and Codex assistance. +Parallel #50/#52 records are reviewed and credited without replacing the earlier +climbed-48 implementation; their exact commit history is retained. The separate +#51 witness is retained as research; its source-graph/negative-basis data proof +has not received the same full replay as #56's consumed compiler machinery. +See docs/research/community-round2-review.md for precise validation boundaries. +All earlier licenses, contributions and notices remain applicable. + +Interval strips and core-aware pair assembly + +The interval leave-one-out strips and the core-aware group-pair assembly in +research/pair-assembly were prepared by Avi Eisenberg / ikeboy with Anthropic +Claude assistance. They build on PR #53's skip-prefix pipeline and its +inherited PR #48 sources. The stacked witness in research/pair-assembly/frame +uses eumemic's PR #57 joint frame compiler unchanged; its driver and verifier +are adaptations of PR #57's skip_frame_compiler.py, skip_frame_compose.py and +verify_skip_frame.py. Original notices are retained. + +Stopped product-ring extension, 9 October 2026 +Copyright 2026 icekylinx + +The opposite-bank generic projector factorization, componentwise atom-ring +adapters, stopped recurrence and outer ordinary-interchange conversion, +aligned pair-star producer with rational centers, exact denominator-21 +grid and selected (23,23)/(24,24) composition are contributed by icekylinx +with substantial OpenAI GPT-6 Astra and Codex assistance. This extension +builds on merged PR #36, 11817ccacb564bb7f98789c20dc11d3fece207e3, and is +integrated on upstream main 56b66d58297deca1d7dd130247d720e960f77a37. + +The retained ordinary leaf uses the preceding projector, corner and +copied-center proofs. The selected two-stage topology retains Aurel Prosz +(Paureel), Swapnil Jain and Zhihao Chen's credits; the semantic assembly +retains PR #21/#23 and RaD's attribution. Paired producers, carrier matching, +original source notices and each imported license remain unchanged. + +Partial-gauge extension, 9 October 2026 +Copyright 2026 icekylinx + +The pair-first cube assembly, compatible backward frame enlargement, +partial source-gauge schedule and stopped whole-projector composition are +contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance, extending PR #104 at 948ce1510df750f4c18b96bdaef436a86f8bf834. + +The physical deferred bit word, reflected event accounting, fan-order +clarification and signed two-stage endpoint are adopted from Zhihao Chen +(jacklightChen), PR #97, e15350b66e4bf796153a68c240a6cc1b788abe3e, with +Codex assistance. Its deferred readouts, V leaves, lifted frames and frozen +witness originate in Swapnil Jain's 741e7aa078392553815df7926ee17ac5e25a8c38, +with the original Claude disclosure retained. Cyclic interval and core-aware +pair primitives build on Avi Eisenberg (ikeboy), PR #62, +ad0f25ff7b23cff7f08ad237c2254e6ecf74257e, with Anthropic Claude assistance. +Prior two-stage, copied-center, ordinary-leaf, semantic/bulk, routing and +precision credits remain in force. Imported source notices and licenses +are preserved under references/partial-gauge/; see SOURCES.json. + +Three-stage cover extension, 9 October 2026 +Copyright 2026 icekylinx + +The arbitrary-subspace Clifford frame theorem, three-stage Cayley geometry, +weighted q-adic GL cover, unit-lower weighted compiler, charged local-ring +fallback, uniform batching, internal row borrowing and exact composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. This +repository integration uses Codex assistance and extends +PR #115, cf60442983c153a3a0f5272ea4713f99eba13c86. + +The selected local complex DAG and support/label replay are adopted from +Copyright 2026 eumemic, PR #117, cbb05ce504d571546d9b7794c186a613c659c3bf, +with its original Apache-2.0 terms and Claude assistance disclosure. +The unchanged bit physical word retains Zhihao Chen (jacklightChen), +PR #97, and Swapnil Jain's underlying witness and assistance notices. +The prior opposite-bank, stopped ordinary-leaf, copied-center, topology, +semantic/bulk, precision and analytic credits remain applicable. +Original source notices and license bytes are preserved in +references/three-stage-cover/pr117/ and references/partial-gauge/. + +Paired-cube and shared-core extension, 9 October 2026 +Copyright 2026 icekylinx + +The paired-coordinate triple-cube identity, signed overlap channels, +original-source involution, coordinate-star centers, concrete frame/carrier +compiler, chronological source gauges, PR97 gauge-subset selection, +orthogonal cross-stage routing and exact supplier/assembly integration +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. +Repository integration uses Codex assistance and extends PR #130 at +6a9970a530119174507904e23592fd59ede19a5d. + +The substantial completed-core workspace-sharing principle is credited to +an664, PR #128, 530588a019b4a74f09180680c9e3961bf649ec89, with its reported +OpenAI Codex assistance. No source code, partition or serialized witness +from that PR is imported. The new routing and paired-motif integration +are described separately and claim no exclusive priority for broad sharing, +paired-coordinate, Fourier or carrier-matching ideas. + +Selected coarse queries restrict the retained eumemic PR #117 positive DAG; +its original Apache-2.0 and Claude assistance notices remain unchanged. +The bit word and original frames retain Zhihao Chen's PR #97 and Swapnil +Jain's frozen witness, notices and historical assistance disclosures. +Earlier generalized Clifford, three-stage, uniform weighted recursion, +ordinary-leaf, semantic/bulk, precision and analytic credits remain in force. +Source-specific license bytes are preserved under references/. + +October 9 recycled-bit integration: +DaysSky (#150), William Porter/hpst3r (#147), Thomas Marchand/Th0rgal (#146), +Rohan Gupta/gupt1156 (#148), James Chang/jamesyc (#124), SovereignSteak (#122). +The original notices and assistance disclosures are retained under research/, +including research/recycled-bit-integration/NOTICE. Andrew Barnes/Bortlesboat +(#101) repairs shared verifiers using rfu08's #64 counterexample. rfu08's +scoped finite and formal-transfer packages are included separately; they do +not establish the full multiplication theorem. Earlier and parallel credits +remain applicable. Douglas Colkitt integrated these with OpenAI Codex assistance. + +SovereignSteak PR151 independently supplies the matching gauge/recycling +composition and the selected 473/10^6 atom refinement; its original package +and assistance disclosure are retained under research/gauge-recycling/. + +October 9 coordinated-frame and completed-entrance-bank integration: +Dugongue PR186, 166a34d75e853e933855f0f7e940fe77c4bb6b8d, builds on +Chafik Boukhalfa/chafreaky's PR181, 7fb2194801e3a10f54772c7f0d5505035a4fc0ad, +and eumemic's PR168 v4, 4a3c769e5c5430e7114c4d3e099ff34664677f17. +The frozen package and prerequisite archive preserve all author, source-license +and assistance notices, including PR175's compiler optimization. DaysSky's +carrier closure, James Chang's terminal substitution and balanced assembly, +geckods' stopping refinements and all preceding framework credits remain. +Rohan Arun's PR185 bootstrap and chafreaky's PR182 bit refinement are reviewed +parallel contributions; their gains are not added to the selected witness. +Douglas Colkitt integrated the package and supplied the bank scheduling +supplement with OpenAI Codex assistance, under Apache-2.0. The all-size +interfaces remain conditional; finite verification is not full formalization. diff --git a/research/staged-release-retiming-t530/full-admission/PUBLIC-PINS.json b/research/staged-release-retiming-t530/full-admission/PUBLIC-PINS.json new file mode 100644 index 0000000000..052414b656 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/PUBLIC-PINS.json @@ -0,0 +1,203 @@ +{ + "schema": "public-retiming-summary-files/1", + "sha256": { + "ARCHIVE-OMISSIONS.json": "ff8f4c3281ade85526959e43bea647b86e0e4c7d2cf93ac3522ae55df9f37331", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "MAIN-INPUTS.json": "cdf3c11de5b0e43646043330ced860a8c2ae70cb71fd07c7ccb3589415521cda", + "NOTICE": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd", + "PUBLIC-PROVENANCE.json": "a811de5291da8cca961d7b0b2b66c544b9c4f60e269c8c0834be2ae1b5ae141d", + "README.md": "8a7029c0001d1a04e4622570b6eac2eb6ff19393be6760714d8f82b7890f252e", + "check_recorded_summary.py": "a8993e8e84491790edede5f7dc467be59c1192d352b60197e0b26d592e9067d8", + "data/RETIME-AUDIT-base.json": "b3a4fefcb1aa16b16ec4a4481da10afa06f8f2a59c2e77ade8eaa6dd48bc8d0e", + "data/RETIME-AUDIT-extra.json": "ddf5b88b7338202a40cc92851c1e95d8fdc0ad97ffc8bc6f680ba162e913fecb", + "data/RETIMED-RECORD-base.json": "9e224473ea00cc5965f8202d7d9e9f29b1069c7e5dde95ae949bdbaa92949fb4", + "data/RETIMED-RECORD-extra.json": "c7b0eb0663dd5d1f7e78105d32e0c2669fc473fb5e730f5fa0fab31e2c0dd13c", + "data/RETIMED644-660-base.json.gz": "6df3356808e29909776be8bc0faf03df983401a267c2d740d1ac2dbcaa278269", + "data/RETIMED644-660-extra.json.gz": "65624efec36b35934b750c1741ba2ad4e6df3cff86e44536b0c016ebddb0fb55", + "data/STAGED644-660-base.json.gz": "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653", + "data/STAGED644-660-extra.json.gz": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f", + "evidence/ADMISSION-COMMAND.json": "a68b9f12801a87e8da2039966c274a84c7e9882f2e83fde053a965cb80eb772c", + "evidence/ADMISSION-RESULT.json": "51f41f2dc65654492b8fe0c5049a7b81a7a31f56aa3bf7864d90be45b628f231", + "evidence/ADMISSION-STAGES.json": "60441920a466b073f4d1b4ad7a02e7d87bb91f21e3e9136e2a54f46957a40b3e", + "evidence/ASSEMBLY.json": "3ccbf66eab7b067d46da6dc85d4d64dd142cf3598bec5cfe5af209a2528bd7d3", + "evidence/CONTROLLER-AUDIT.json": "50387246e44de8512452460de73ab7ce30bb9391b832e6c6e32751b791e033e8", + "evidence/DERIVATION.json": "d5283f9c59d3a419d29351fa60f9c7514e206a3d9f7ead2ef1c2e7836f87f461", + "evidence/GEOMETRY-CONTROLS.json": "13a50b2f2448931ca302a55e5839c082f651331f20402448fe6ff29d1eb2f481", + "evidence/INHERITED-RUNTIME-PATCHES.json": "35f74730e3f249e5bfc929ef633feaa551fd17d46d682d0125c9cf370580d16b", + "evidence/NATIVE-ENVIRONMENT.json": "8360a3a4beecde7ea72d92248a68c2bd39a7ab91eeaf0282e0f4781348a2b6e8", + "evidence/NATIVE-NATIVE-RECEIPT.json": "2967a2fba90cb9019bcf48092942bb9c7eb1bf0f336e72ca5816c670cd4c3eac", + "evidence/NATIVE-RESULT.json": "d7466460f5d9e53cbc640d8a6b06523ea5337817ca663897c737b0281f9b909f", + "evidence/NATIVE-STAGES.json": "ddbf5a98ad4a61a4aa00d8cc1bef12c82018ed76f8156a373eaee78c8a9246b5", + "evidence/OWNER-AUDIT.json": "14cd76009b3fb862de216aae145ab37656a424a9e180b45e2f8b641ba4772a66", + "evidence/PACKAGE-MANIFEST.json": "6eac9a8c77a4e67c7c0a928117350529b49570fb53f714d591e1d4fe0a90ab94", + "evidence/PARENT-SOURCE-MANIFEST.json": "318ede57c79d10323fb1918f7be4d451d1fcdac01c6456fe9851d51d05d59453", + "evidence/PORTABLE-SOURCE-CHECK.json": "0ed265fc227873b5a7c7e527706d905f4e072b119c8bd09ae5679f9752bcf228", + "evidence/PREFIX-AND-INVOICE.json": "caf49b466dddd0283a017552d5fc8d926ae2cd19db0eb9388cf7e9fd827e4297", + "evidence/PUBLIC-SOURCE-REBUILD-RESULT.json": "fb71b88fb0be33d3467ce6976102313345d11dc4170d1f6f626a8c7249581885", + "evidence/PUBLIC-SUMMARY-CONTROLS.json": "4a31d11b66010d7eabdc63e1327c5884eac7b78f6f2a9aa43984e9328d9e34db", + "evidence/RELEASE-RECEIPT.json": "80e1f422359d7c553493c1e0f2a1b4c4de230f8eb74690e1471a14d65169d110", + "evidence/RETAINED-REUSE-RECEIPT.json": "f90cafe84385533a0eeb96356f385b646f402ff85cd05154c47a81c783023d9d", + "evidence/RETIMING-COMPLETE-RELEASE.json": "346e22c25de55e49ba0bbd8ffef1e9674a630452351ccf2a9166b1ece50f0c7b", + "evidence/SOURCE-MANIFEST.json": "fb47533a401d1d13719be8b9aab91fe5313931ca62d40dba336eab6a96275aa0", + "evidence/STAGE-SCRIPT-BINDINGS.json": "147543c049a083097f75db0923f1994c005a8a47b0e7ff280177fdc62fbbef76", + "evidence/STRICT-STAGES.json": "d4fa62461de5a431fa8485f2bcde5c37fef54b3d2f701271386e7b0c02b50b9d", + "evidence/SUPPLIER-RESULT.json": "9ab7c0a9d457c992c01993f73ebabc4286e692d8184d32a0222eac394fd03bb4", + "evidence/SUPPLIER-STAGES.json": "b3502a6ef790ce02064caaaef863aaa05a132991e293cc85a30e11b9f0c3ad22", + "evidence/logs/discovery.log": "75aa839712643553e5d46922f2aeff7bcebd197910e1098a0c3430010e71fb28", + "evidence/logs/outer-check_ledger.py.log": "dc0e4db2bfa2937532113e1678f8cd5513080c0c691e9ee558085b16682fd115", + "evidence/logs/outer-independent_check.py.log": "7f55339f208e0ed8d7456ae68fa61ba43a79d37f8b0f382405ce05880155f576", + "evidence/logs/owners.log": "48248e5bc879a86b178083e82bf9a6299b1d6a4b73f32177de5f1330509419e6", + "evidence/logs/parent-lift.log": "240f02db618ec1a3a196845cc328eae52361bf838514658d64e744b14d7b986b", + "evidence/logs/rebind.log": "0dc96988ea6182e2d855f17550c8a992cb30b8b97ad7817be23f1033499f9a03", + "evidence/logs/release.log": "fe92fa512cf03cf655b151637520f8bea1774c23967860e532d89587f1486a6a", + "evidence/native-base-RESULT.json": "93667243b4bb7300683f4bb6923f5ed55e7298afdcf10e1dbedca842d77b72bc", + "evidence/native-base.log": "25913a541f8aeb459f5aae9787a235c098422ca492636bf456011cc3d3c8e9a0", + "evidence/native-extra-RESULT.json": "0a575ae9bec7fac0949c9ed2e6727b1364d1d45b77d3f27b839c0b4ee24af4c5", + "evidence/native-extra.log": "e931822e91ee17c7f36855ad033de2f686bf6a55bfd788e3a00958f247159021", + "evidence/native-logs/base/ledgers-bw_emit.py.log": "3c22a15ea4f7a760b7e51d018db25509ecfea353334b14640a348f90cc9dfe8f", + "evidence/native-logs/base/local-replay-bw_audit_local.py.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "evidence/native-logs/base/native-bw_transport.py.log": "bbb99340536118d1192726cd59d9fbced72fb21cbb667c20a3f582f56c61ef69", + "evidence/native-logs/base/phases-bw_check_recipes.py.log": "985f91e7b90482d89b062b43dbe9c3885521fe26e4f8600c3b7757c33d3181ed", + "evidence/native-logs/base/phases-bw_phases.py.log": "69727c9cd4ce5ad938bf1cd7d998a7c4c55e9a9b1c3ab5282cffc9bcb461629c", + "evidence/native-logs/base/wrappers-bw_adapters.py.log": "92065498c6214eb987a9906ad8e018c6459465c91f142268c1fd7cd5d4a13e7d", + "evidence/native-logs/extra/ledgers-bw_emit.py.log": "3c22a15ea4f7a760b7e51d018db25509ecfea353334b14640a348f90cc9dfe8f", + "evidence/native-logs/extra/local-replay-bw_audit_local.py.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "evidence/native-logs/extra/native-bw_transport.py.log": "f5e71dfe851dfad5e1763ac0c1b30f3100d503495ee5e69ad6f1306bd36ed549", + "evidence/native-logs/extra/phases-bw_check_recipes.py.log": "985f91e7b90482d89b062b43dbe9c3885521fe26e4f8600c3b7757c33d3181ed", + "evidence/native-logs/extra/phases-bw_phases.py.log": "2983aede642c67bfb19f1716eda3014e99c78b437b61a73db345df17542e8acf", + "evidence/native-logs/extra/wrappers-bw_adapters.py.log": "92065498c6214eb987a9906ad8e018c6459465c91f142268c1fd7cd5d4a13e7d", + "evidence/native-summary/65624efec36b35934b750c1741ba2ad4e6df3cff86e44536b0c016ebddb0fb55/CACHE.json": "fa872a8bf10ed47da15bc7a383f32ecf1935c49b22ac182b29b578e2f376aa2c", + "evidence/native-summary/65624efec36b35934b750c1741ba2ad4e6df3cff86e44536b0c016ebddb0fb55/STEPS.json": "5a1eed0c759c403b4b69d83abe6ce37787e5f9386a8c1028d816f8126607c6df", + "evidence/native-summary/65624efec36b35934b750c1741ba2ad4e6df3cff86e44536b0c016ebddb0fb55/local/INDEPENDENT-LOCAL-REPLAY.json": "8d9013f5060502270b63cb7a6078ab18bf1242a3bb74af7126e3e5b93e3be037", + "evidence/native-summary/65624efec36b35934b750c1741ba2ad4e6df3cff86e44536b0c016ebddb0fb55/local/LOCAL-CHECKS.json": "11743473efa1822069303b49c62b1853af4236f46ef54b4778a27e2e70d79d06", + "evidence/native-summary/6df3356808e29909776be8bc0faf03df983401a267c2d740d1ac2dbcaa278269/CACHE.json": "1b4d790152a34d2dea86043377b9979a7f9b0dc0989c065b7b4abb84d15b1a9e", + "evidence/native-summary/6df3356808e29909776be8bc0faf03df983401a267c2d740d1ac2dbcaa278269/STEPS.json": "59930bc84ab798dec32c846a79431eff30f36673917261d9049eb6645c50bc39", + "evidence/native-summary/6df3356808e29909776be8bc0faf03df983401a267c2d740d1ac2dbcaa278269/local/INDEPENDENT-LOCAL-REPLAY.json": "f99d4c50632d1cff239ac6f54e4040bc9a7ac66500de9d032c8e9fc5ec42a458", + "evidence/native-summary/6df3356808e29909776be8bc0faf03df983401a267c2d740d1ac2dbcaa278269/local/LOCAL-CHECKS.json": "11743473efa1822069303b49c62b1853af4236f46ef54b4778a27e2e70d79d06", + "evidence/native-summary/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/CACHE.json": "3ed6859152f2594352bea363ce8d297f93dc138a5748b2a55523e89d2eef3776", + "evidence/native-summary/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/STEPS.json": "02a8f2021aa8406277656a086d875a2d50cea569e5179c27d2bcaed92d9826ff", + "evidence/native-summary/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/INDEPENDENT-LOCAL-REPLAY.json": "39874d664110d1ee85da901e2cd56e7cd0f27e0153813d4608c98122a90815da", + "evidence/native-summary/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-CHECKS.json": "ef01cb5b6d1779518282c69a20d1dbcdbf57cb89ba616e2101bb209b37d80286", + "evidence/native-summary/_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RECEIPT.json": "bc1bc13637846b3807119ae55dd006c8076815f355c93e0a1f57c1dce3ebeb3e", + "evidence/native-summary/_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RESULT.json": "845e82a755ac46ea2f62b79700f7af6037616408a8359e615c24d351713c8c12", + "evidence/native-summary/_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/STAGES.json": "b0d0263a87e95da1dc03e552c878ba4da4494184d1560ecc66e4dd93d7129a0b", + "evidence/native-summary/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/CACHE.json": "2ab0c916ce58b97c3bca6b2d0369168f3626f06c7cf566dec0ead919ba7d7940", + "evidence/native-summary/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/STEPS.json": "ae00b2906950db818416e47984cb08ecbf55ba836d68e5fce7bfb94926a91bc5", + "evidence/native-summary/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/INDEPENDENT-LOCAL-REPLAY.json": "70b4b787a5a4529452a58e9ac48826e848748a35b95a9b20c5358f4355705058", + "evidence/native-summary/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-CHECKS.json": "e52e7feece9cb22e83c1d687c0f98731f8d50b7e8c863732ec662c89453fbcd4", + "evidence/portable-STAGES.json": "0ed265fc227873b5a7c7e527706d905f4e072b119c8bd09ae5679f9752bcf228", + "evidence/portable-new-retiming-review.log": "d85d4eb71eb02b45de85515eb424fbc993b3c315083fad2b939bfd66d2de2203", + "evidence/portable-preserved-staged-review.log": "de2fa433a259e21f69f10db63667ba6034e0cd35f102a989208e865d042c31c8", + "evidence/release-logs/outer.log": "670f60ee3ecc7e2d7fc4b23b468d4cdb8cfab9edaf252cd2410c1cabcb0318dc", + "evidence/release-logs/verify.log": "d240f4323dd046a88332536c2100cb9495b12ee01c6f3aa2678ae09b181cb0e1", + "evidence/retained-parent-CLAIM.json": "bc9e90a475333b957a8c4eae8b950988caea89e20e9b44a919e83415fb76b1b8", + "evidence/runtime-summary/CLAIM.json": "2048826e64891fc8e0b4d2f7a70edebacab4b62b31b0609eb8330299f892d014", + "evidence/runtime-summary/new/SPEC.json": "cf8d85cf2c447522cf95afb01fe03a40b6a53567156ab36c485a17ad44f82922", + "evidence/runtime-summary/outer/B.json": "1c28c50d56e4935886eb33ee20ccf7af7b6e1458e09debbf6f1f3d28bea6560d", + "evidence/runtime-summary/outer/LEDGER.json": "14ed690fd607d9e7fc29b1d290593acc5c3961be449c469a2a5db500006e1a6d", + "evidence/runtime-summary/outer/OUTER-CLAIM.json": "512d8c62a12e669040cf849c4b9774af297c585208a0ce0d86e517dc29fc46cd", + "evidence/stage-scripts/discovery.py": "4f5c0926b70edb5aef3af0f8a8d9fa8119fa7af6603df1721c0dc31760b08254", + "evidence/stage-scripts/outer-check_ledger.py.py": "1dd56009986eb14dd6603c9193c7ad71dd45c7d005bf71c9cd3f916e66f54d98", + "evidence/stage-scripts/outer-independent_check.py.py": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "evidence/stage-scripts/owners.py": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "evidence/stage-scripts/parent-lift.py": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "evidence/stage-scripts/rebind.py": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "evidence/stage-scripts/release.py": "6cfefe80c02a6c0f243f50ca9e146e1ab1440b84a033d8a71d42be5a5fa27f6b", + "evidence/strict-logs/admission.log": "1cee8d732e126c670f531018d65955c23828a7cc0af8d6ac4bb0f6672962a540", + "evidence/strict-logs/assembly.log": "8381985bf9120e38a0891e6b3495248a74ac7db3a5c204c6c4b983569dea75cd", + "evidence/strict-logs/audit.log": "50387246e44de8512452460de73ab7ce30bb9391b832e6c6e32751b791e033e8", + "evidence/strict-logs/bind.log": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "evidence/strict-logs/bit.log": "d54d260bf95bd8ae4ab8846314082b93b2e3d8f427eb35376691f2ce543a6b67", + "evidence/strict-logs/emit.log": "62318c4d7144194d8c5f2f52f2cedb7876e68057a3d6967f3d26019a04a6a3e7", + "evidence/strict-logs/independent.log": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "evidence/strict-logs/invoice.log": "f85ae311904331b375004ec8c233d1c963bd82f0f48d33dc312319f9e68c4e67", + "evidence/supplier-logs/audit-local-566-base.log": "7e1ff2fecf2df3cacdd5335b67aa302368be2a736d6d484ddfd56d2c28586ae9", + "evidence/supplier-logs/audit-local-566-extra.log": "823a6d7d6b4b333babdd75c27c342c4ae526d2529e7b6f6d2bb9ef1713a8bb67", + "evidence/supplier-logs/declared-edit-review.log": "9812aa8d08d4251d390eb0cea1e5731dc59d22e09e0c914823c77d3e2e233e13", + "evidence/supplier-logs/fine-engine-oracle.log": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3", + "evidence/supplier-logs/geometry-controls.log": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9", + "evidence/supplier-logs/lemmag-labels.log": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469", + "evidence/supplier-logs/lift-parent.log": "240f02db618ec1a3a196845cc328eae52361bf838514658d64e744b14d7b986b", + "evidence/supplier-logs/paired-extension-review.log": "22f1c329665ba83cc5fc58eb882369f1817b2708ee3391b57341ff0a59a77170", + "evidence/supplier-logs/preload-move-independent-review.log": "c456d3e39c09e960ceebf80251d5e808fa9299991471fd86f4093d9bc4dd3eda", + "evidence/supplier-logs/rebind-566.log": "0dc96988ea6182e2d855f17550c8a992cb30b8b97ad7817be23f1033499f9a03", + "evidence/supplier-logs/rebuild-borrow-words.log": "5b1c1f9e3bcbaab31d134fd7a5a1e3629dc8a225bd67ddf94a664f0a52595363", + "evidence/supplier-logs/rebuild-words-566.log": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f", + "evidence/supplier-logs/reconstruct-owners.log": "48248e5bc879a86b178083e82bf9a6299b1d6a4b73f32177de5f1330509419e6", + "evidence/supplier-logs/shared-kernel-independent-review.log": "3dc6eb8940cf8a4b993f80129c98b6c4846ad346ccf773a78af225cff3339cc3", + "evidence/supplier-logs/staged-release-retime-review.log": "d85d4eb71eb02b45de85515eb424fbc993b3c315083fad2b939bfd66d2de2203", + "evidence/supplier-logs/staged3605-review.log": "de2fa433a259e21f69f10db63667ba6034e0cd35f102a989208e865d042c31c8", + "evidence/supplier-logs/strict-t74.log": "e5efcef5cb683fd3be94fbdb0d25fb65bc805b0b2d1417eadf3495f464b5370d", + "evidence/supplier-logs/two-sided-helper408-review.log": "6b6be35dc5a9105d9f7fbca2b37952b3865b14ccf6ff1fbba75664241c7fafd8", + "fresh-replay/ADMISSION-RESULT.json": "ac6d69b6028dddfbe8c570592aab46d325689e315c814dcfadac23afea07d383", + "fresh-replay/ATTEMPT.json": "e26e82fd2d22255accae1e5a8c5afc9071e248d4232b083a7882326871fd76c2", + "fresh-replay/CHECK-r1.json": "36d1e22ceedd7d6f06bd2f90b48ad58b451a77d0a5d0f7c5487246a348bbf05b", + "fresh-replay/CONTROLS-r1.json": "f6f76707aaf03f88d6b77ce791889d4f69ae5e076df2d0d31b7653892f44fb57", + "fresh-replay/EVIDENCE.json": "a79042409a73bd696bb3ef48655f9c4995de4fe5ef72eeb2b2e6fffbd0bdabaa", + "fresh-replay/NATIVE-RECEIPT.json": "1353cedccb418383565c0cd31da7447cc4ea73a6fd5ad53ab0482edb4833c053", + "fresh-replay/NATIVE-RESULT.json": "4fd193bce3ee011f0a493fe59a2f7be3c9e52442d2570755cd689d935b776774", + "fresh-replay/NATIVE-base-RESULT.json": "6f9667ce2b083f92edbd2222571760ac6773e95e58d22f12acc0d7e0242554bc", + "fresh-replay/NATIVE-extra-RESULT.json": "ab8305d83699f4a00805f7aef9535568bd89c97bdbac4b0b8dd7853ae3acebd6", + "fresh-replay/RELEASE-RECEIPT.json": "cfeb33c43399f1c89c477945e77d6e2b8562ac8341f13ff395381149edcfb173", + "fresh-replay/SOURCE-REBUILD-RESULT.json": "fb71b88fb0be33d3467ce6976102313345d11dc4170d1f6f626a8c7249581885", + "fresh-replay/TESTS-r1.json": "0be0df7b4be5fb7fb783c32be00478a001469e2fbe6b032940835404b422c24f", + "fresh-replay/WRAPPER-RESULT.json": "0b4a4a2a97ce73cb67881cf20f25f0be03e55fd4a4296df4eafa6f861bc88016", + "fresh_replay_evidence.py": "ec3f3d2e2fe6ae8d77399d6e2fa7f3cd834d9cb2e01871f89dbcedb24d260de7", + "reproduce.py": "9ec43247d2b3af6e4fce61173a4e59aa13b845792776289995cb108285f8aede", + "scripts/admit_extension.py": "5934268bdf39b4b84a754c5fafa2d18023610066e511056dcb17cdefa6f82c3e", + "scripts/admit_extension.py.patch": "dc62088611a384d97a2a47d84e307600269c5ec94f7c86fbc046b8af5de8491c", + "scripts/integrate.py": "2129f62e2b78b1a674f78045c3acf0b1d8c8f59812147829e02d60d7913f9926", + "scripts/prepare_extension_native.py": "17830b10181e45cba62678e4344e256d674fe847af978434978ec1fc5249e045", + "scripts/prepare_extension_native.py.patch": "33c13181f980082231260a3f9e80a0287538165ea227042bc77e8ec6a0e8d82d", + "test_recorded_summary.py": "73dc3b2f16991e5fb3dd11b65b20b8c649ec63a6572796dc7274fa273f3b49d6", + "vendor/PR3626-FETCH-PINS.json": "b0c055a4c03038e87ff65b9e6c0ebc7713b841a8692718f1ff725d91cb108d79", + "vendor/PR3626-INPUTS.json": "afb9c990b5020a31da8e43794c876d3c2288b75decb54d52a9382da18317eb39", + "vendor/staged-width-t530/CLAIM.json": "9f27717c3ddbf5eb7b9773e1b2887ff3899d354019139d916c9b8004aee2e097", + "vendor/staged-width-t530/CREDITS.md": "dfca50b8d12ccb9ebf7c574bc9a30c57c4329da259bf171e4530437a747da501", + "vendor/staged-width-t530/EXPECTED.json": "9a3ddab54912652881f1488c3572988a81cc127e8fa1d01bc615842314f737e3", + "vendor/staged-width-t530/FRONTIER.json": "8f2f80438593e7efaa6bb57c881a40cedbd7b5665b4ae12c6cf215d217c98397", + "vendor/staged-width-t530/PROOF.md": "485f4b2adce3761ac664032898c3a90ce83186c423df6f1eef499fe76b5ce768", + "vendor/staged-width-t530/README.md": "c5f6d11e3783d09a60c0cf28996e94fc84e543717873aadcbaa3076720a778cb", + "vendor/staged-width-t530/owners/ARTIFACTS.json": "46dbca32c5b0f4fa565a39b89b6c22a8bcb3a1500a88a39816f286b7fd72b57e", + "vendor/staged-width-t530/owners/CANDIDATE.json": "7755b8e7aed8dbfbe89fe64fdfebee04ad84de3c6c9020b3535eb04fdabccec1", + "vendor/staged-width-t530/owners/DEPENDENCIES.json": "785cebd02d407dc6442cfb0604d9b232d93dd049fd319fc5f0ceacb314715272", + "vendor/staged-width-t530/owners/DISPATCH37.json": "4f78935b2ef1f6c08c9c16433d54015def1eccd767443b496a77ea8823690df6", + "vendor/staged-width-t530/owners/EXPECTED.json": "4fac5fcc90e20405c0ad176d7466cbd52eb947c02fd34fe35fea18eaf372d79a", + "vendor/staged-width-t530/owners/INPUT-PINS.json": "9b4b64a1e7d596f6ca8c4be8c2592544bce15a91dee988a31e89f0acb66cff7e", + "vendor/staged-width-t530/owners/ORDER37.json": "94803d190b2b0506d9645e980b57cdbc3e98221f3b615292df8a94f1b174c984", + "vendor/staged-width-t530/owners/PROVIDERS.json": "d96f2798024ab83edbb8848b62c425992aec182f1f24ef46bb8286dd390618c2", + "vendor/staged-width-t530/owners/README.txt": "7b9e8d85c1d0edfc265dc321a32752d76f1c94fa76dd7a931fff9066f57bd3a6", + "vendor/staged-width-t530/owners/SOURCE-PINS.json": "7dec42af587af3b7ae66d4fdf3d0c6157f9c85eb744edec66fa266f294378e5e", + "vendor/staged-width-t530/owners/T16-DISPATCH.json": "282960b7163bc305675b64d1d0faee9f71b18848748326418a013626944c6488", + "vendor/staged-width-t530/owners/T16-ORDER.json": "9b2106c84aed23a7c3c8b99e21d3e96c66b12f92980a42ab2f6dbbe7831ef7c4", + "vendor/staged-width-t530/owners/T16-PROVENANCE.json": "ebc9d5d23d5a698b795deee783c991910d2027cdb2e2f7561854df4189a63621", + "vendor/staged-width-t530/owners/UPSTREAM-PROOF.md": "11113405347bb8a85a85c6d5b516ff3dcdb15e01d4b16f825ba4eb314a1be5cd", + "vendor/staged-width-t530/owners/UPSTREAM-SOURCE-CREDITS.md": "1d9d8f56d8899f55878e4cb2c4e052b22506444016a51c2e678773505f5189e6", + "vendor/staged-width-t530/owners/UPSTREAM-SOURCE-NOTICE": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661", + "vendor/staged-width-t530/owners/independent_literal.py": "36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4", + "vendor/staged-width-t530/owners/integral_network.py": "97cce7cdaeea2c415b7959d3bdbf34d272e3b541f6e7dc9b87c134a2c2620740", + "vendor/staged-width-t530/owners/portable_expand.py": "3a0ded73b3b8c6e945f28626c65c2160b540df5c3e86db5a48eb5639c5731f4c", + "vendor/staged-width-t530/owners/source_context.py": "9967d6f5c0ca5f8437f76e3130c39aea3ff53e3d1ffa04a54d17db5f44f69f4c", + "vendor/staged-width-t530/owners/test_owner_guards.py": "fecbf1518c4594c64276847f92d5980443c6b5562345e97354305d5c31530bb0", + "vendor/staged-width-t530/owners/verify_candidate.py": "efce5f7b1cbc3f8d0807312da5248209d1b2dd9d6043656a7d2e58b58887214b", + "vendor/staged-width-t530/owners/verify_owner.py": "8d1a3c2a7beb0f18e2beaa3df455a721ea6129343ec52031d18e58fbde5081cb", + "vendor/staged-width-t530/replay.py": "c74d9169279bd795c84a605e375afbba1988abfc78933293b296f59bd70f013f", + "vendor/staged-width-t530/source_builder.py": "0cb5f62d517ac35c44922abc338cd41356b3e08dc7c6d6d9f64a43a9a541378f", + "vendor/staged-width-t530/supplier3605/ARTIFACTS.json": "867bd848d04505518463eb06b1905e70ccc9256bb73312d3cd1dc57623bb319b", + "vendor/staged-width-t530/supplier3605/PROOF.md": "525b010f3a895bdb11313f9938ad1b742df64bcee0b5671399230b1ded541baf", + "vendor/staged-width-t530/supplier3605/README.md": "c1956badbcd92f2f88dcea833facc39eefb7eef8f220fb7b1941b4c552109d89", + "vendor/staged-width-t530/supplier3605/SOURCES.json": "005bf38ae679a9fb3ad1ee94b8c35bdfec58451ef58e0a87b0c7b68ef4fc51d5", + "vendor/staged-width-t530/supplier3605/STAGED-PAIR-RECORD-base.json.gz": "a6ae4188be998990ecb176fef5929e8e1dfce3726e372c0da2a290fe8ea73532", + "vendor/staged-width-t530/supplier3605/STAGED-PAIR-RECORD-extra.json.gz": "33a39d46d4d19bdeb6f0b6abb38cc80c68219e1ae10dd7e1acaccedc14b47236", + "vendor/staged-width-t530/supplier3605/STAGED644-660-base.json.gz": "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653", + "vendor/staged-width-t530/supplier3605/STAGED644-660-extra.json.gz": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f", + "vendor/staged-width-t530/supplier3605/TASK.json": "b85158fedf4734ff028703353ac6e9929ddea6a8e7c845c8341c2428d628717a", + "vendor/staged-width-t530/supplier3605/VALIDATION.json": "fa3803654e230cd50bc9fb874ec80e16dd838adebf13cd0cb174f18bc12fa04a", + "vendor/staged-width-t530/supplier3605/VERIFY.json": "21320da6b638366ccd42824e4b5865608f497cf2ba7323fffedb77f0a368c96a", + "vendor/staged-width-t530/supplier3605/check_residual.py": "e34b06ae725f062d15ad83cbd3ef2f91d3d78c380ccc93c8d2deba1c9e354c70", + "vendor/staged-width-t530/supplier3605/check_scope.py": "f8eefd425a0d570167e14febcacfbb38a6bb29d820d808be426180cf31b5a947", + "vendor/staged-width-t530/supplier3605/staged_pair.py": "25fc9b025dbb90358032013303adea650a5f19937fd3edf30b6c6fd023e2d747", + "vendor/staged-width-t530/supplier3605/verify.py": "0ef49b725fc132cd5fc26a9a81028739896232d938bae22cef132384c7cbab13", + "vendor/staged-width-t530/templates/prepare_extension_native.py": "0cdb4b8b8b565e3dc4a312d4174c86d7d1aebc531430cb726658c8feb0c3bcf4" + } +} diff --git a/research/staged-release-retiming-t530/full-admission/PUBLIC-PROVENANCE.json b/research/staged-release-retiming-t530/full-admission/PUBLIC-PROVENANCE.json new file mode 100644 index 0000000000..24778bf607 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/PUBLIC-PROVENANCE.json @@ -0,0 +1,877 @@ +{ + "files": { + "LICENSE": { + "normalization": "none", + "original_sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "public_sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "NOTICE": { + "normalization": "none", + "original_sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd", + "public_sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd" + }, + "data/RETIME-AUDIT-base.json": { + "normalization": "none", + "original_sha256": "b3a4fefcb1aa16b16ec4a4481da10afa06f8f2a59c2e77ade8eaa6dd48bc8d0e", + "public_sha256": "b3a4fefcb1aa16b16ec4a4481da10afa06f8f2a59c2e77ade8eaa6dd48bc8d0e" + }, + "data/RETIME-AUDIT-extra.json": { + "normalization": "none", + "original_sha256": "ddf5b88b7338202a40cc92851c1e95d8fdc0ad97ffc8bc6f680ba162e913fecb", + "public_sha256": "ddf5b88b7338202a40cc92851c1e95d8fdc0ad97ffc8bc6f680ba162e913fecb" + }, + "data/RETIMED-RECORD-base.json": { + "normalization": "none", + "original_sha256": "9e224473ea00cc5965f8202d7d9e9f29b1069c7e5dde95ae949bdbaa92949fb4", + "public_sha256": "9e224473ea00cc5965f8202d7d9e9f29b1069c7e5dde95ae949bdbaa92949fb4" + }, + "data/RETIMED-RECORD-extra.json": { + "normalization": "none", + "original_sha256": "c7b0eb0663dd5d1f7e78105d32e0c2669fc473fb5e730f5fa0fab31e2c0dd13c", + "public_sha256": "c7b0eb0663dd5d1f7e78105d32e0c2669fc473fb5e730f5fa0fab31e2c0dd13c" + }, + "data/RETIMED644-660-base.json.gz": { + "normalization": "none", + "original_sha256": "6df3356808e29909776be8bc0faf03df983401a267c2d740d1ac2dbcaa278269", + "public_sha256": "6df3356808e29909776be8bc0faf03df983401a267c2d740d1ac2dbcaa278269" + }, + "data/RETIMED644-660-extra.json.gz": { + "normalization": "none", + "original_sha256": "65624efec36b35934b750c1741ba2ad4e6df3cff86e44536b0c016ebddb0fb55", + "public_sha256": "65624efec36b35934b750c1741ba2ad4e6df3cff86e44536b0c016ebddb0fb55" + }, + "data/STAGED644-660-base.json.gz": { + "normalization": "none", + "original_sha256": "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653", + "public_sha256": "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653" + }, + "data/STAGED644-660-extra.json.gz": { + "normalization": "none", + "original_sha256": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f", + "public_sha256": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f" + }, + "evidence/ADMISSION-COMMAND.json": { + "normalization": "workspace-prefix-to-token", + "original_sha256": "e0d861370c5d938e84c99b203647a33c93b804923c8e58763caf1bbf691481ec", + "public_sha256": "a68b9f12801a87e8da2039966c274a84c7e9882f2e83fde053a965cb80eb772c" + }, + "evidence/ADMISSION-RESULT.json": { + "normalization": "workspace-prefix-to-token", + "original_sha256": "9e1b232ad063d26bd097063d0ec12319382a943be9a541fd29a2501d4abf41bd", + "public_sha256": "51f41f2dc65654492b8fe0c5049a7b81a7a31f56aa3bf7864d90be45b628f231" + }, + "evidence/ADMISSION-STAGES.json": { + "normalization": "workspace-prefix-to-token", + "original_sha256": "ffeabb8e70b691d256bec729e1ad6988280debc30599707b208ce7c158838c6b", + "public_sha256": "60441920a466b073f4d1b4ad7a02e7d87bb91f21e3e9136e2a54f46957a40b3e" + }, + "evidence/ASSEMBLY.json": { + "normalization": "none", + "original_sha256": "3ccbf66eab7b067d46da6dc85d4d64dd142cf3598bec5cfe5af209a2528bd7d3", + "public_sha256": "3ccbf66eab7b067d46da6dc85d4d64dd142cf3598bec5cfe5af209a2528bd7d3" + }, + "evidence/CONTROLLER-AUDIT.json": { + "normalization": "none", + "original_sha256": "50387246e44de8512452460de73ab7ce30bb9391b832e6c6e32751b791e033e8", + "public_sha256": "50387246e44de8512452460de73ab7ce30bb9391b832e6c6e32751b791e033e8" + }, + "evidence/DERIVATION.json": { + "normalization": "none", + "original_sha256": "d5283f9c59d3a419d29351fa60f9c7514e206a3d9f7ead2ef1c2e7836f87f461", + "public_sha256": "d5283f9c59d3a419d29351fa60f9c7514e206a3d9f7ead2ef1c2e7836f87f461" + }, + "evidence/GEOMETRY-CONTROLS.json": { + "normalization": "none", + "original_sha256": "13a50b2f2448931ca302a55e5839c082f651331f20402448fe6ff29d1eb2f481", + "public_sha256": "13a50b2f2448931ca302a55e5839c082f651331f20402448fe6ff29d1eb2f481" + }, + "evidence/INHERITED-RUNTIME-PATCHES.json": { + "normalization": "none", + "original_sha256": "35f74730e3f249e5bfc929ef633feaa551fd17d46d682d0125c9cf370580d16b", + "public_sha256": "35f74730e3f249e5bfc929ef633feaa551fd17d46d682d0125c9cf370580d16b" + }, + "evidence/NATIVE-ENVIRONMENT.json": { + "normalization": "workspace-prefix-to-token", + "original_sha256": "e1da43941225174bf36cea80422e47d774cd26ccb80142d9f706822fe7bde783", + "public_sha256": "8360a3a4beecde7ea72d92248a68c2bd39a7ab91eeaf0282e0f4781348a2b6e8" + }, + "evidence/NATIVE-NATIVE-RECEIPT.json": { + "normalization": "none", + "original_sha256": "2967a2fba90cb9019bcf48092942bb9c7eb1bf0f336e72ca5816c670cd4c3eac", + "public_sha256": "2967a2fba90cb9019bcf48092942bb9c7eb1bf0f336e72ca5816c670cd4c3eac" + }, + "evidence/NATIVE-RESULT.json": { + "normalization": "workspace-prefix-to-token", + "original_sha256": "d5fbf10f5647b8862cada4f0368f840655e567c81fbac9d01ef8df798a04f9d5", + "public_sha256": "d7466460f5d9e53cbc640d8a6b06523ea5337817ca663897c737b0281f9b909f" + }, + "evidence/NATIVE-STAGES.json": { + "normalization": "workspace-prefix-to-token", + "original_sha256": "5b27e3a3913a028df2a3941fcbed8aecac5c9228fe47f51da27fced8a29afac1", + "public_sha256": "ddbf5a98ad4a61a4aa00d8cc1bef12c82018ed76f8156a373eaee78c8a9246b5" + }, + "evidence/OWNER-AUDIT.json": { + "normalization": "none", + "original_sha256": "14cd76009b3fb862de216aae145ab37656a424a9e180b45e2f8b641ba4772a66", + "public_sha256": "14cd76009b3fb862de216aae145ab37656a424a9e180b45e2f8b641ba4772a66" + }, + "evidence/PACKAGE-MANIFEST.json": { + "normalization": "none", + "original_sha256": "6eac9a8c77a4e67c7c0a928117350529b49570fb53f714d591e1d4fe0a90ab94", + "public_sha256": "6eac9a8c77a4e67c7c0a928117350529b49570fb53f714d591e1d4fe0a90ab94" + }, + "evidence/PARENT-SOURCE-MANIFEST.json": { + "normalization": "none", + "original_sha256": "318ede57c79d10323fb1918f7be4d451d1fcdac01c6456fe9851d51d05d59453", + "public_sha256": "318ede57c79d10323fb1918f7be4d451d1fcdac01c6456fe9851d51d05d59453" + }, + "evidence/PORTABLE-SOURCE-CHECK.json": { + "normalization": "workspace-prefix-to-token", + "original_sha256": "807ad458b8ab570cc28652b0b957125da059f04b41508f7831a235c83f340dc9", + "public_sha256": "0ed265fc227873b5a7c7e527706d905f4e072b119c8bd09ae5679f9752bcf228" + }, + "evidence/PREFIX-AND-INVOICE.json": { + "normalization": "none", + "original_sha256": "caf49b466dddd0283a017552d5fc8d926ae2cd19db0eb9388cf7e9fd827e4297", + "public_sha256": "caf49b466dddd0283a017552d5fc8d926ae2cd19db0eb9388cf7e9fd827e4297" + }, + "evidence/RELEASE-RECEIPT.json": { + "normalization": "none", + "original_sha256": "80e1f422359d7c553493c1e0f2a1b4c4de230f8eb74690e1471a14d65169d110", + "public_sha256": "80e1f422359d7c553493c1e0f2a1b4c4de230f8eb74690e1471a14d65169d110" + }, + "evidence/RETAINED-REUSE-RECEIPT.json": { + "normalization": "none", + "original_sha256": "f90cafe84385533a0eeb96356f385b646f402ff85cd05154c47a81c783023d9d", + "public_sha256": "f90cafe84385533a0eeb96356f385b646f402ff85cd05154c47a81c783023d9d" + }, + "evidence/RETIMING-COMPLETE-RELEASE.json": { + "normalization": "none", + "original_sha256": "346e22c25de55e49ba0bbd8ffef1e9674a630452351ccf2a9166b1ece50f0c7b", + "public_sha256": "346e22c25de55e49ba0bbd8ffef1e9674a630452351ccf2a9166b1ece50f0c7b" + }, + "evidence/SOURCE-MANIFEST.json": { + "normalization": "none", + "original_sha256": "fb47533a401d1d13719be8b9aab91fe5313931ca62d40dba336eab6a96275aa0", + "public_sha256": "fb47533a401d1d13719be8b9aab91fe5313931ca62d40dba336eab6a96275aa0" + }, + "evidence/STAGE-SCRIPT-BINDINGS.json": { + "normalization": "none", + "original_sha256": "147543c049a083097f75db0923f1994c005a8a47b0e7ff280177fdc62fbbef76", + "public_sha256": "147543c049a083097f75db0923f1994c005a8a47b0e7ff280177fdc62fbbef76" + }, + "evidence/STRICT-STAGES.json": { + "normalization": "none", + "original_sha256": "d4fa62461de5a431fa8485f2bcde5c37fef54b3d2f701271386e7b0c02b50b9d", + "public_sha256": "d4fa62461de5a431fa8485f2bcde5c37fef54b3d2f701271386e7b0c02b50b9d" + }, + "evidence/SUPPLIER-RESULT.json": { + "normalization": "none", + "original_sha256": "9ab7c0a9d457c992c01993f73ebabc4286e692d8184d32a0222eac394fd03bb4", + "public_sha256": "9ab7c0a9d457c992c01993f73ebabc4286e692d8184d32a0222eac394fd03bb4" + }, + "evidence/SUPPLIER-STAGES.json": { + "normalization": "none", + "original_sha256": "b3502a6ef790ce02064caaaef863aaa05a132991e293cc85a30e11b9f0c3ad22", + "public_sha256": "b3502a6ef790ce02064caaaef863aaa05a132991e293cc85a30e11b9f0c3ad22" + }, + "evidence/logs/discovery.log": { + "normalization": "none", + "original_sha256": "75aa839712643553e5d46922f2aeff7bcebd197910e1098a0c3430010e71fb28", + "public_sha256": "75aa839712643553e5d46922f2aeff7bcebd197910e1098a0c3430010e71fb28" + }, + "evidence/logs/outer-check_ledger.py.log": { + "normalization": "none", + "original_sha256": "dc0e4db2bfa2937532113e1678f8cd5513080c0c691e9ee558085b16682fd115", + "public_sha256": "dc0e4db2bfa2937532113e1678f8cd5513080c0c691e9ee558085b16682fd115" + }, + "evidence/logs/outer-independent_check.py.log": { + "normalization": "none", + "original_sha256": "7f55339f208e0ed8d7456ae68fa61ba43a79d37f8b0f382405ce05880155f576", + "public_sha256": "7f55339f208e0ed8d7456ae68fa61ba43a79d37f8b0f382405ce05880155f576" + }, + "evidence/logs/owners.log": { + "normalization": "none", + "original_sha256": "48248e5bc879a86b178083e82bf9a6299b1d6a4b73f32177de5f1330509419e6", + "public_sha256": "48248e5bc879a86b178083e82bf9a6299b1d6a4b73f32177de5f1330509419e6" + }, + "evidence/logs/parent-lift.log": { + "normalization": "none", + "original_sha256": "240f02db618ec1a3a196845cc328eae52361bf838514658d64e744b14d7b986b", + "public_sha256": "240f02db618ec1a3a196845cc328eae52361bf838514658d64e744b14d7b986b" + }, + "evidence/logs/rebind.log": { + "normalization": "none", + "original_sha256": "0dc96988ea6182e2d855f17550c8a992cb30b8b97ad7817be23f1033499f9a03", + "public_sha256": "0dc96988ea6182e2d855f17550c8a992cb30b8b97ad7817be23f1033499f9a03" + }, + "evidence/logs/release.log": { + "normalization": "none", + "original_sha256": "fe92fa512cf03cf655b151637520f8bea1774c23967860e532d89587f1486a6a", + "public_sha256": "fe92fa512cf03cf655b151637520f8bea1774c23967860e532d89587f1486a6a" + }, + "evidence/native-base-RESULT.json": { + "normalization": "none", + "original_sha256": "93667243b4bb7300683f4bb6923f5ed55e7298afdcf10e1dbedca842d77b72bc", + "public_sha256": "93667243b4bb7300683f4bb6923f5ed55e7298afdcf10e1dbedca842d77b72bc" + }, + "evidence/native-base.log": { + "normalization": "none", + "original_sha256": "25913a541f8aeb459f5aae9787a235c098422ca492636bf456011cc3d3c8e9a0", + "public_sha256": "25913a541f8aeb459f5aae9787a235c098422ca492636bf456011cc3d3c8e9a0" + }, + "evidence/native-extra-RESULT.json": { + "normalization": "none", + "original_sha256": "0a575ae9bec7fac0949c9ed2e6727b1364d1d45b77d3f27b839c0b4ee24af4c5", + "public_sha256": "0a575ae9bec7fac0949c9ed2e6727b1364d1d45b77d3f27b839c0b4ee24af4c5" + }, + "evidence/native-extra.log": { + "normalization": "none", + "original_sha256": "e931822e91ee17c7f36855ad033de2f686bf6a55bfd788e3a00958f247159021", + "public_sha256": "e931822e91ee17c7f36855ad033de2f686bf6a55bfd788e3a00958f247159021" + }, + "evidence/native-logs/base/ledgers-bw_emit.py.log": { + "normalization": "none", + "original_sha256": "3c22a15ea4f7a760b7e51d018db25509ecfea353334b14640a348f90cc9dfe8f", + "public_sha256": "3c22a15ea4f7a760b7e51d018db25509ecfea353334b14640a348f90cc9dfe8f" + }, + "evidence/native-logs/base/local-replay-bw_audit_local.py.log": { + "normalization": "none", + "original_sha256": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "public_sha256": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402" + }, + "evidence/native-logs/base/native-bw_transport.py.log": { + "normalization": "none", + "original_sha256": "bbb99340536118d1192726cd59d9fbced72fb21cbb667c20a3f582f56c61ef69", + "public_sha256": "bbb99340536118d1192726cd59d9fbced72fb21cbb667c20a3f582f56c61ef69" + }, + "evidence/native-logs/base/phases-bw_check_recipes.py.log": { + "normalization": "none", + "original_sha256": "985f91e7b90482d89b062b43dbe9c3885521fe26e4f8600c3b7757c33d3181ed", + "public_sha256": "985f91e7b90482d89b062b43dbe9c3885521fe26e4f8600c3b7757c33d3181ed" + }, + "evidence/native-logs/base/phases-bw_phases.py.log": { + "normalization": "none", + "original_sha256": "69727c9cd4ce5ad938bf1cd7d998a7c4c55e9a9b1c3ab5282cffc9bcb461629c", + "public_sha256": "69727c9cd4ce5ad938bf1cd7d998a7c4c55e9a9b1c3ab5282cffc9bcb461629c" + }, + "evidence/native-logs/base/wrappers-bw_adapters.py.log": { + "normalization": "none", + "original_sha256": "92065498c6214eb987a9906ad8e018c6459465c91f142268c1fd7cd5d4a13e7d", + "public_sha256": "92065498c6214eb987a9906ad8e018c6459465c91f142268c1fd7cd5d4a13e7d" + }, + "evidence/native-logs/extra/ledgers-bw_emit.py.log": { + "normalization": "none", + "original_sha256": "3c22a15ea4f7a760b7e51d018db25509ecfea353334b14640a348f90cc9dfe8f", + "public_sha256": "3c22a15ea4f7a760b7e51d018db25509ecfea353334b14640a348f90cc9dfe8f" + }, + "evidence/native-logs/extra/local-replay-bw_audit_local.py.log": { + "normalization": "none", + "original_sha256": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "public_sha256": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402" + }, + "evidence/native-logs/extra/native-bw_transport.py.log": { + "normalization": "none", + "original_sha256": "f5e71dfe851dfad5e1763ac0c1b30f3100d503495ee5e69ad6f1306bd36ed549", + "public_sha256": "f5e71dfe851dfad5e1763ac0c1b30f3100d503495ee5e69ad6f1306bd36ed549" + }, + "evidence/native-logs/extra/phases-bw_check_recipes.py.log": { + "normalization": "none", + "original_sha256": "985f91e7b90482d89b062b43dbe9c3885521fe26e4f8600c3b7757c33d3181ed", + "public_sha256": "985f91e7b90482d89b062b43dbe9c3885521fe26e4f8600c3b7757c33d3181ed" + }, + "evidence/native-logs/extra/phases-bw_phases.py.log": { + "normalization": "none", + "original_sha256": "2983aede642c67bfb19f1716eda3014e99c78b437b61a73db345df17542e8acf", + "public_sha256": "2983aede642c67bfb19f1716eda3014e99c78b437b61a73db345df17542e8acf" + }, + "evidence/native-logs/extra/wrappers-bw_adapters.py.log": { + "normalization": "none", + "original_sha256": "92065498c6214eb987a9906ad8e018c6459465c91f142268c1fd7cd5d4a13e7d", + "public_sha256": "92065498c6214eb987a9906ad8e018c6459465c91f142268c1fd7cd5d4a13e7d" + }, + "evidence/native-summary/65624efec36b35934b750c1741ba2ad4e6df3cff86e44536b0c016ebddb0fb55/CACHE.json": { + "normalization": "none", + "original_sha256": "fa872a8bf10ed47da15bc7a383f32ecf1935c49b22ac182b29b578e2f376aa2c", + "public_sha256": "fa872a8bf10ed47da15bc7a383f32ecf1935c49b22ac182b29b578e2f376aa2c" + }, + "evidence/native-summary/65624efec36b35934b750c1741ba2ad4e6df3cff86e44536b0c016ebddb0fb55/STEPS.json": { + "normalization": "none", + "original_sha256": "5a1eed0c759c403b4b69d83abe6ce37787e5f9386a8c1028d816f8126607c6df", + "public_sha256": "5a1eed0c759c403b4b69d83abe6ce37787e5f9386a8c1028d816f8126607c6df" + }, + "evidence/native-summary/65624efec36b35934b750c1741ba2ad4e6df3cff86e44536b0c016ebddb0fb55/local/INDEPENDENT-LOCAL-REPLAY.json": { + "normalization": "none", + "original_sha256": "8d9013f5060502270b63cb7a6078ab18bf1242a3bb74af7126e3e5b93e3be037", + "public_sha256": "8d9013f5060502270b63cb7a6078ab18bf1242a3bb74af7126e3e5b93e3be037" + }, + "evidence/native-summary/65624efec36b35934b750c1741ba2ad4e6df3cff86e44536b0c016ebddb0fb55/local/LOCAL-CHECKS.json": { + "normalization": "none", + "original_sha256": "11743473efa1822069303b49c62b1853af4236f46ef54b4778a27e2e70d79d06", + "public_sha256": "11743473efa1822069303b49c62b1853af4236f46ef54b4778a27e2e70d79d06" + }, + "evidence/native-summary/6df3356808e29909776be8bc0faf03df983401a267c2d740d1ac2dbcaa278269/CACHE.json": { + "normalization": "none", + "original_sha256": "1b4d790152a34d2dea86043377b9979a7f9b0dc0989c065b7b4abb84d15b1a9e", + "public_sha256": "1b4d790152a34d2dea86043377b9979a7f9b0dc0989c065b7b4abb84d15b1a9e" + }, + "evidence/native-summary/6df3356808e29909776be8bc0faf03df983401a267c2d740d1ac2dbcaa278269/STEPS.json": { + "normalization": "none", + "original_sha256": "59930bc84ab798dec32c846a79431eff30f36673917261d9049eb6645c50bc39", + "public_sha256": "59930bc84ab798dec32c846a79431eff30f36673917261d9049eb6645c50bc39" + }, + "evidence/native-summary/6df3356808e29909776be8bc0faf03df983401a267c2d740d1ac2dbcaa278269/local/INDEPENDENT-LOCAL-REPLAY.json": { + "normalization": "none", + "original_sha256": "f99d4c50632d1cff239ac6f54e4040bc9a7ac66500de9d032c8e9fc5ec42a458", + "public_sha256": "f99d4c50632d1cff239ac6f54e4040bc9a7ac66500de9d032c8e9fc5ec42a458" + }, + "evidence/native-summary/6df3356808e29909776be8bc0faf03df983401a267c2d740d1ac2dbcaa278269/local/LOCAL-CHECKS.json": { + "normalization": "none", + "original_sha256": "11743473efa1822069303b49c62b1853af4236f46ef54b4778a27e2e70d79d06", + "public_sha256": "11743473efa1822069303b49c62b1853af4236f46ef54b4778a27e2e70d79d06" + }, + "evidence/native-summary/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/CACHE.json": { + "normalization": "none", + "original_sha256": "3ed6859152f2594352bea363ce8d297f93dc138a5748b2a55523e89d2eef3776", + "public_sha256": "3ed6859152f2594352bea363ce8d297f93dc138a5748b2a55523e89d2eef3776" + }, + "evidence/native-summary/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/STEPS.json": { + "normalization": "none", + "original_sha256": "02a8f2021aa8406277656a086d875a2d50cea569e5179c27d2bcaed92d9826ff", + "public_sha256": "02a8f2021aa8406277656a086d875a2d50cea569e5179c27d2bcaed92d9826ff" + }, + "evidence/native-summary/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/INDEPENDENT-LOCAL-REPLAY.json": { + "normalization": "none", + "original_sha256": "39874d664110d1ee85da901e2cd56e7cd0f27e0153813d4608c98122a90815da", + "public_sha256": "39874d664110d1ee85da901e2cd56e7cd0f27e0153813d4608c98122a90815da" + }, + "evidence/native-summary/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-CHECKS.json": { + "normalization": "none", + "original_sha256": "ef01cb5b6d1779518282c69a20d1dbcdbf57cb89ba616e2101bb209b37d80286", + "public_sha256": "ef01cb5b6d1779518282c69a20d1dbcdbf57cb89ba616e2101bb209b37d80286" + }, + "evidence/native-summary/_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RECEIPT.json": { + "normalization": "none", + "original_sha256": "bc1bc13637846b3807119ae55dd006c8076815f355c93e0a1f57c1dce3ebeb3e", + "public_sha256": "bc1bc13637846b3807119ae55dd006c8076815f355c93e0a1f57c1dce3ebeb3e" + }, + "evidence/native-summary/_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RESULT.json": { + "normalization": "none", + "original_sha256": "845e82a755ac46ea2f62b79700f7af6037616408a8359e615c24d351713c8c12", + "public_sha256": "845e82a755ac46ea2f62b79700f7af6037616408a8359e615c24d351713c8c12" + }, + "evidence/native-summary/_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/STAGES.json": { + "normalization": "none", + "original_sha256": "b0d0263a87e95da1dc03e552c878ba4da4494184d1560ecc66e4dd93d7129a0b", + "public_sha256": "b0d0263a87e95da1dc03e552c878ba4da4494184d1560ecc66e4dd93d7129a0b" + }, + "evidence/native-summary/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/CACHE.json": { + "normalization": "none", + "original_sha256": "2ab0c916ce58b97c3bca6b2d0369168f3626f06c7cf566dec0ead919ba7d7940", + "public_sha256": "2ab0c916ce58b97c3bca6b2d0369168f3626f06c7cf566dec0ead919ba7d7940" + }, + "evidence/native-summary/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/STEPS.json": { + "normalization": "none", + "original_sha256": "ae00b2906950db818416e47984cb08ecbf55ba836d68e5fce7bfb94926a91bc5", + "public_sha256": "ae00b2906950db818416e47984cb08ecbf55ba836d68e5fce7bfb94926a91bc5" + }, + "evidence/native-summary/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/INDEPENDENT-LOCAL-REPLAY.json": { + "normalization": "none", + "original_sha256": "70b4b787a5a4529452a58e9ac48826e848748a35b95a9b20c5358f4355705058", + "public_sha256": "70b4b787a5a4529452a58e9ac48826e848748a35b95a9b20c5358f4355705058" + }, + "evidence/native-summary/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-CHECKS.json": { + "normalization": "none", + "original_sha256": "e52e7feece9cb22e83c1d687c0f98731f8d50b7e8c863732ec662c89453fbcd4", + "public_sha256": "e52e7feece9cb22e83c1d687c0f98731f8d50b7e8c863732ec662c89453fbcd4" + }, + "evidence/portable-STAGES.json": { + "normalization": "workspace-prefix-to-token", + "original_sha256": "807ad458b8ab570cc28652b0b957125da059f04b41508f7831a235c83f340dc9", + "public_sha256": "0ed265fc227873b5a7c7e527706d905f4e072b119c8bd09ae5679f9752bcf228" + }, + "evidence/portable-new-retiming-review.log": { + "normalization": "none", + "original_sha256": "d85d4eb71eb02b45de85515eb424fbc993b3c315083fad2b939bfd66d2de2203", + "public_sha256": "d85d4eb71eb02b45de85515eb424fbc993b3c315083fad2b939bfd66d2de2203" + }, + "evidence/portable-preserved-staged-review.log": { + "normalization": "none", + "original_sha256": "de2fa433a259e21f69f10db63667ba6034e0cd35f102a989208e865d042c31c8", + "public_sha256": "de2fa433a259e21f69f10db63667ba6034e0cd35f102a989208e865d042c31c8" + }, + "evidence/release-logs/outer.log": { + "normalization": "none", + "original_sha256": "670f60ee3ecc7e2d7fc4b23b468d4cdb8cfab9edaf252cd2410c1cabcb0318dc", + "public_sha256": "670f60ee3ecc7e2d7fc4b23b468d4cdb8cfab9edaf252cd2410c1cabcb0318dc" + }, + "evidence/release-logs/verify.log": { + "normalization": "none", + "original_sha256": "d240f4323dd046a88332536c2100cb9495b12ee01c6f3aa2678ae09b181cb0e1", + "public_sha256": "d240f4323dd046a88332536c2100cb9495b12ee01c6f3aa2678ae09b181cb0e1" + }, + "evidence/retained-parent-CLAIM.json": { + "normalization": "none", + "original_sha256": "bc9e90a475333b957a8c4eae8b950988caea89e20e9b44a919e83415fb76b1b8", + "public_sha256": "bc9e90a475333b957a8c4eae8b950988caea89e20e9b44a919e83415fb76b1b8" + }, + "evidence/runtime-summary/CLAIM.json": { + "normalization": "none", + "original_sha256": "2048826e64891fc8e0b4d2f7a70edebacab4b62b31b0609eb8330299f892d014", + "public_sha256": "2048826e64891fc8e0b4d2f7a70edebacab4b62b31b0609eb8330299f892d014" + }, + "evidence/runtime-summary/new/SPEC.json": { + "normalization": "none", + "original_sha256": "cf8d85cf2c447522cf95afb01fe03a40b6a53567156ab36c485a17ad44f82922", + "public_sha256": "cf8d85cf2c447522cf95afb01fe03a40b6a53567156ab36c485a17ad44f82922" + }, + "evidence/runtime-summary/outer/B.json": { + "normalization": "none", + "original_sha256": "1c28c50d56e4935886eb33ee20ccf7af7b6e1458e09debbf6f1f3d28bea6560d", + "public_sha256": "1c28c50d56e4935886eb33ee20ccf7af7b6e1458e09debbf6f1f3d28bea6560d" + }, + "evidence/runtime-summary/outer/LEDGER.json": { + "normalization": "none", + "original_sha256": "14ed690fd607d9e7fc29b1d290593acc5c3961be449c469a2a5db500006e1a6d", + "public_sha256": "14ed690fd607d9e7fc29b1d290593acc5c3961be449c469a2a5db500006e1a6d" + }, + "evidence/runtime-summary/outer/OUTER-CLAIM.json": { + "normalization": "none", + "original_sha256": "512d8c62a12e669040cf849c4b9774af297c585208a0ce0d86e517dc29fc46cd", + "public_sha256": "512d8c62a12e669040cf849c4b9774af297c585208a0ce0d86e517dc29fc46cd" + }, + "evidence/stage-scripts/discovery.py": { + "normalization": "none", + "original_sha256": "4f5c0926b70edb5aef3af0f8a8d9fa8119fa7af6603df1721c0dc31760b08254", + "public_sha256": "4f5c0926b70edb5aef3af0f8a8d9fa8119fa7af6603df1721c0dc31760b08254" + }, + "evidence/stage-scripts/outer-check_ledger.py.py": { + "normalization": "none", + "original_sha256": "1dd56009986eb14dd6603c9193c7ad71dd45c7d005bf71c9cd3f916e66f54d98", + "public_sha256": "1dd56009986eb14dd6603c9193c7ad71dd45c7d005bf71c9cd3f916e66f54d98" + }, + "evidence/stage-scripts/outer-independent_check.py.py": { + "normalization": "none", + "original_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "public_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7" + }, + "evidence/stage-scripts/owners.py": { + "normalization": "none", + "original_sha256": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "public_sha256": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15" + }, + "evidence/stage-scripts/parent-lift.py": { + "normalization": "none", + "original_sha256": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "public_sha256": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e" + }, + "evidence/stage-scripts/rebind.py": { + "normalization": "none", + "original_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "public_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b" + }, + "evidence/stage-scripts/release.py": { + "normalization": "none", + "original_sha256": "6cfefe80c02a6c0f243f50ca9e146e1ab1440b84a033d8a71d42be5a5fa27f6b", + "public_sha256": "6cfefe80c02a6c0f243f50ca9e146e1ab1440b84a033d8a71d42be5a5fa27f6b" + }, + "evidence/strict-logs/admission.log": { + "normalization": "none", + "original_sha256": "1cee8d732e126c670f531018d65955c23828a7cc0af8d6ac4bb0f6672962a540", + "public_sha256": "1cee8d732e126c670f531018d65955c23828a7cc0af8d6ac4bb0f6672962a540" + }, + "evidence/strict-logs/assembly.log": { + "normalization": "none", + "original_sha256": "8381985bf9120e38a0891e6b3495248a74ac7db3a5c204c6c4b983569dea75cd", + "public_sha256": "8381985bf9120e38a0891e6b3495248a74ac7db3a5c204c6c4b983569dea75cd" + }, + "evidence/strict-logs/audit.log": { + "normalization": "none", + "original_sha256": "50387246e44de8512452460de73ab7ce30bb9391b832e6c6e32751b791e033e8", + "public_sha256": "50387246e44de8512452460de73ab7ce30bb9391b832e6c6e32751b791e033e8" + }, + "evidence/strict-logs/bind.log": { + "normalization": "none", + "original_sha256": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "public_sha256": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a" + }, + "evidence/strict-logs/bit.log": { + "normalization": "none", + "original_sha256": "d54d260bf95bd8ae4ab8846314082b93b2e3d8f427eb35376691f2ce543a6b67", + "public_sha256": "d54d260bf95bd8ae4ab8846314082b93b2e3d8f427eb35376691f2ce543a6b67" + }, + "evidence/strict-logs/emit.log": { + "normalization": "none", + "original_sha256": "62318c4d7144194d8c5f2f52f2cedb7876e68057a3d6967f3d26019a04a6a3e7", + "public_sha256": "62318c4d7144194d8c5f2f52f2cedb7876e68057a3d6967f3d26019a04a6a3e7" + }, + "evidence/strict-logs/independent.log": { + "normalization": "none", + "original_sha256": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "public_sha256": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe" + }, + "evidence/strict-logs/invoice.log": { + "normalization": "none", + "original_sha256": "f85ae311904331b375004ec8c233d1c963bd82f0f48d33dc312319f9e68c4e67", + "public_sha256": "f85ae311904331b375004ec8c233d1c963bd82f0f48d33dc312319f9e68c4e67" + }, + "evidence/supplier-logs/audit-local-566-base.log": { + "normalization": "none", + "original_sha256": "7e1ff2fecf2df3cacdd5335b67aa302368be2a736d6d484ddfd56d2c28586ae9", + "public_sha256": "7e1ff2fecf2df3cacdd5335b67aa302368be2a736d6d484ddfd56d2c28586ae9" + }, + "evidence/supplier-logs/audit-local-566-extra.log": { + "normalization": "none", + "original_sha256": "823a6d7d6b4b333babdd75c27c342c4ae526d2529e7b6f6d2bb9ef1713a8bb67", + "public_sha256": "823a6d7d6b4b333babdd75c27c342c4ae526d2529e7b6f6d2bb9ef1713a8bb67" + }, + "evidence/supplier-logs/declared-edit-review.log": { + "normalization": "none", + "original_sha256": "9812aa8d08d4251d390eb0cea1e5731dc59d22e09e0c914823c77d3e2e233e13", + "public_sha256": "9812aa8d08d4251d390eb0cea1e5731dc59d22e09e0c914823c77d3e2e233e13" + }, + "evidence/supplier-logs/fine-engine-oracle.log": { + "normalization": "none", + "original_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3", + "public_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3" + }, + "evidence/supplier-logs/geometry-controls.log": { + "normalization": "none", + "original_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9", + "public_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9" + }, + "evidence/supplier-logs/lemmag-labels.log": { + "normalization": "none", + "original_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469", + "public_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469" + }, + "evidence/supplier-logs/lift-parent.log": { + "normalization": "none", + "original_sha256": "240f02db618ec1a3a196845cc328eae52361bf838514658d64e744b14d7b986b", + "public_sha256": "240f02db618ec1a3a196845cc328eae52361bf838514658d64e744b14d7b986b" + }, + "evidence/supplier-logs/paired-extension-review.log": { + "normalization": "none", + "original_sha256": "22f1c329665ba83cc5fc58eb882369f1817b2708ee3391b57341ff0a59a77170", + "public_sha256": "22f1c329665ba83cc5fc58eb882369f1817b2708ee3391b57341ff0a59a77170" + }, + "evidence/supplier-logs/preload-move-independent-review.log": { + "normalization": "none", + "original_sha256": "c456d3e39c09e960ceebf80251d5e808fa9299991471fd86f4093d9bc4dd3eda", + "public_sha256": "c456d3e39c09e960ceebf80251d5e808fa9299991471fd86f4093d9bc4dd3eda" + }, + "evidence/supplier-logs/rebind-566.log": { + "normalization": "none", + "original_sha256": "0dc96988ea6182e2d855f17550c8a992cb30b8b97ad7817be23f1033499f9a03", + "public_sha256": "0dc96988ea6182e2d855f17550c8a992cb30b8b97ad7817be23f1033499f9a03" + }, + "evidence/supplier-logs/rebuild-borrow-words.log": { + "normalization": "workspace-prefix-to-token", + "original_sha256": "fa5a01866b83b3b3741b23761f6818eac15ae0341421b91cd07544497c9b8a8b", + "public_sha256": "5b1c1f9e3bcbaab31d134fd7a5a1e3629dc8a225bd67ddf94a664f0a52595363" + }, + "evidence/supplier-logs/rebuild-words-566.log": { + "normalization": "none", + "original_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f", + "public_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f" + }, + "evidence/supplier-logs/reconstruct-owners.log": { + "normalization": "none", + "original_sha256": "48248e5bc879a86b178083e82bf9a6299b1d6a4b73f32177de5f1330509419e6", + "public_sha256": "48248e5bc879a86b178083e82bf9a6299b1d6a4b73f32177de5f1330509419e6" + }, + "evidence/supplier-logs/shared-kernel-independent-review.log": { + "normalization": "none", + "original_sha256": "3dc6eb8940cf8a4b993f80129c98b6c4846ad346ccf773a78af225cff3339cc3", + "public_sha256": "3dc6eb8940cf8a4b993f80129c98b6c4846ad346ccf773a78af225cff3339cc3" + }, + "evidence/supplier-logs/staged-release-retime-review.log": { + "normalization": "none", + "original_sha256": "d85d4eb71eb02b45de85515eb424fbc993b3c315083fad2b939bfd66d2de2203", + "public_sha256": "d85d4eb71eb02b45de85515eb424fbc993b3c315083fad2b939bfd66d2de2203" + }, + "evidence/supplier-logs/staged3605-review.log": { + "normalization": "none", + "original_sha256": "de2fa433a259e21f69f10db63667ba6034e0cd35f102a989208e865d042c31c8", + "public_sha256": "de2fa433a259e21f69f10db63667ba6034e0cd35f102a989208e865d042c31c8" + }, + "evidence/supplier-logs/strict-t74.log": { + "normalization": "none", + "original_sha256": "e5efcef5cb683fd3be94fbdb0d25fb65bc805b0b2d1417eadf3495f464b5370d", + "public_sha256": "e5efcef5cb683fd3be94fbdb0d25fb65bc805b0b2d1417eadf3495f464b5370d" + }, + "evidence/supplier-logs/two-sided-helper408-review.log": { + "normalization": "none", + "original_sha256": "6b6be35dc5a9105d9f7fbca2b37952b3865b14ccf6ff1fbba75664241c7fafd8", + "public_sha256": "6b6be35dc5a9105d9f7fbca2b37952b3865b14ccf6ff1fbba75664241c7fafd8" + }, + "scripts/admit_extension.py": { + "normalization": "none", + "original_sha256": "5934268bdf39b4b84a754c5fafa2d18023610066e511056dcb17cdefa6f82c3e", + "public_sha256": "5934268bdf39b4b84a754c5fafa2d18023610066e511056dcb17cdefa6f82c3e" + }, + "scripts/admit_extension.py.patch": { + "normalization": "none", + "original_sha256": "dc62088611a384d97a2a47d84e307600269c5ec94f7c86fbc046b8af5de8491c", + "public_sha256": "dc62088611a384d97a2a47d84e307600269c5ec94f7c86fbc046b8af5de8491c" + }, + "scripts/integrate.py": { + "normalization": "none", + "original_sha256": "2129f62e2b78b1a674f78045c3acf0b1d8c8f59812147829e02d60d7913f9926", + "public_sha256": "2129f62e2b78b1a674f78045c3acf0b1d8c8f59812147829e02d60d7913f9926" + }, + "scripts/prepare_extension_native.py": { + "normalization": "none", + "original_sha256": "17830b10181e45cba62678e4344e256d674fe847af978434978ec1fc5249e045", + "public_sha256": "17830b10181e45cba62678e4344e256d674fe847af978434978ec1fc5249e045" + }, + "scripts/prepare_extension_native.py.patch": { + "normalization": "none", + "original_sha256": "33c13181f980082231260a3f9e80a0287538165ea227042bc77e8ec6a0e8d82d", + "public_sha256": "33c13181f980082231260a3f9e80a0287538165ea227042bc77e8ec6a0e8d82d" + }, + "vendor/PR3626-FETCH-PINS.json": { + "normalization": "none", + "original_sha256": "b0c055a4c03038e87ff65b9e6c0ebc7713b841a8692718f1ff725d91cb108d79", + "public_sha256": "b0c055a4c03038e87ff65b9e6c0ebc7713b841a8692718f1ff725d91cb108d79" + }, + "vendor/staged-width-t530/CLAIM.json": { + "normalization": "none", + "original_sha256": "9f27717c3ddbf5eb7b9773e1b2887ff3899d354019139d916c9b8004aee2e097", + "public_sha256": "9f27717c3ddbf5eb7b9773e1b2887ff3899d354019139d916c9b8004aee2e097" + }, + "vendor/staged-width-t530/CREDITS.md": { + "normalization": "none", + "original_sha256": "dfca50b8d12ccb9ebf7c574bc9a30c57c4329da259bf171e4530437a747da501", + "public_sha256": "dfca50b8d12ccb9ebf7c574bc9a30c57c4329da259bf171e4530437a747da501" + }, + "vendor/staged-width-t530/EXPECTED.json": { + "normalization": "none", + "original_sha256": "9a3ddab54912652881f1488c3572988a81cc127e8fa1d01bc615842314f737e3", + "public_sha256": "9a3ddab54912652881f1488c3572988a81cc127e8fa1d01bc615842314f737e3" + }, + "vendor/staged-width-t530/FRONTIER.json": { + "normalization": "none", + "original_sha256": "8f2f80438593e7efaa6bb57c881a40cedbd7b5665b4ae12c6cf215d217c98397", + "public_sha256": "8f2f80438593e7efaa6bb57c881a40cedbd7b5665b4ae12c6cf215d217c98397" + }, + "vendor/staged-width-t530/PROOF.md": { + "normalization": "none", + "original_sha256": "485f4b2adce3761ac664032898c3a90ce83186c423df6f1eef499fe76b5ce768", + "public_sha256": "485f4b2adce3761ac664032898c3a90ce83186c423df6f1eef499fe76b5ce768" + }, + "vendor/staged-width-t530/README.md": { + "normalization": "none", + "original_sha256": "c5f6d11e3783d09a60c0cf28996e94fc84e543717873aadcbaa3076720a778cb", + "public_sha256": "c5f6d11e3783d09a60c0cf28996e94fc84e543717873aadcbaa3076720a778cb" + }, + "vendor/staged-width-t530/owners/ARTIFACTS.json": { + "normalization": "none", + "original_sha256": "46dbca32c5b0f4fa565a39b89b6c22a8bcb3a1500a88a39816f286b7fd72b57e", + "public_sha256": "46dbca32c5b0f4fa565a39b89b6c22a8bcb3a1500a88a39816f286b7fd72b57e" + }, + "vendor/staged-width-t530/owners/CANDIDATE.json": { + "normalization": "none", + "original_sha256": "7755b8e7aed8dbfbe89fe64fdfebee04ad84de3c6c9020b3535eb04fdabccec1", + "public_sha256": "7755b8e7aed8dbfbe89fe64fdfebee04ad84de3c6c9020b3535eb04fdabccec1" + }, + "vendor/staged-width-t530/owners/DEPENDENCIES.json": { + "normalization": "none", + "original_sha256": "785cebd02d407dc6442cfb0604d9b232d93dd049fd319fc5f0ceacb314715272", + "public_sha256": "785cebd02d407dc6442cfb0604d9b232d93dd049fd319fc5f0ceacb314715272" + }, + "vendor/staged-width-t530/owners/DISPATCH37.json": { + "normalization": "none", + "original_sha256": "4f78935b2ef1f6c08c9c16433d54015def1eccd767443b496a77ea8823690df6", + "public_sha256": "4f78935b2ef1f6c08c9c16433d54015def1eccd767443b496a77ea8823690df6" + }, + "vendor/staged-width-t530/owners/EXPECTED.json": { + "normalization": "none", + "original_sha256": "4fac5fcc90e20405c0ad176d7466cbd52eb947c02fd34fe35fea18eaf372d79a", + "public_sha256": "4fac5fcc90e20405c0ad176d7466cbd52eb947c02fd34fe35fea18eaf372d79a" + }, + "vendor/staged-width-t530/owners/INPUT-PINS.json": { + "normalization": "none", + "original_sha256": "9b4b64a1e7d596f6ca8c4be8c2592544bce15a91dee988a31e89f0acb66cff7e", + "public_sha256": "9b4b64a1e7d596f6ca8c4be8c2592544bce15a91dee988a31e89f0acb66cff7e" + }, + "vendor/staged-width-t530/owners/ORDER37.json": { + "normalization": "none", + "original_sha256": "94803d190b2b0506d9645e980b57cdbc3e98221f3b615292df8a94f1b174c984", + "public_sha256": "94803d190b2b0506d9645e980b57cdbc3e98221f3b615292df8a94f1b174c984" + }, + "vendor/staged-width-t530/owners/PROVIDERS.json": { + "normalization": "none", + "original_sha256": "d96f2798024ab83edbb8848b62c425992aec182f1f24ef46bb8286dd390618c2", + "public_sha256": "d96f2798024ab83edbb8848b62c425992aec182f1f24ef46bb8286dd390618c2" + }, + "vendor/staged-width-t530/owners/README.txt": { + "normalization": "none", + "original_sha256": "7b9e8d85c1d0edfc265dc321a32752d76f1c94fa76dd7a931fff9066f57bd3a6", + "public_sha256": "7b9e8d85c1d0edfc265dc321a32752d76f1c94fa76dd7a931fff9066f57bd3a6" + }, + "vendor/staged-width-t530/owners/SOURCE-PINS.json": { + "normalization": "none", + "original_sha256": "7dec42af587af3b7ae66d4fdf3d0c6157f9c85eb744edec66fa266f294378e5e", + "public_sha256": "7dec42af587af3b7ae66d4fdf3d0c6157f9c85eb744edec66fa266f294378e5e" + }, + "vendor/staged-width-t530/owners/T16-DISPATCH.json": { + "normalization": "none", + "original_sha256": "282960b7163bc305675b64d1d0faee9f71b18848748326418a013626944c6488", + "public_sha256": "282960b7163bc305675b64d1d0faee9f71b18848748326418a013626944c6488" + }, + "vendor/staged-width-t530/owners/T16-ORDER.json": { + "normalization": "none", + "original_sha256": "9b2106c84aed23a7c3c8b99e21d3e96c66b12f92980a42ab2f6dbbe7831ef7c4", + "public_sha256": "9b2106c84aed23a7c3c8b99e21d3e96c66b12f92980a42ab2f6dbbe7831ef7c4" + }, + "vendor/staged-width-t530/owners/T16-PROVENANCE.json": { + "normalization": "none", + "original_sha256": "ebc9d5d23d5a698b795deee783c991910d2027cdb2e2f7561854df4189a63621", + "public_sha256": "ebc9d5d23d5a698b795deee783c991910d2027cdb2e2f7561854df4189a63621" + }, + "vendor/staged-width-t530/owners/UPSTREAM-PROOF.md": { + "normalization": "none", + "original_sha256": "11113405347bb8a85a85c6d5b516ff3dcdb15e01d4b16f825ba4eb314a1be5cd", + "public_sha256": "11113405347bb8a85a85c6d5b516ff3dcdb15e01d4b16f825ba4eb314a1be5cd" + }, + "vendor/staged-width-t530/owners/UPSTREAM-SOURCE-CREDITS.md": { + "normalization": "none", + "original_sha256": "1d9d8f56d8899f55878e4cb2c4e052b22506444016a51c2e678773505f5189e6", + "public_sha256": "1d9d8f56d8899f55878e4cb2c4e052b22506444016a51c2e678773505f5189e6" + }, + "vendor/staged-width-t530/owners/UPSTREAM-SOURCE-NOTICE": { + "normalization": "none", + "original_sha256": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661", + "public_sha256": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661" + }, + "vendor/staged-width-t530/owners/independent_literal.py": { + "normalization": "none", + "original_sha256": "36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4", + "public_sha256": "36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4" + }, + "vendor/staged-width-t530/owners/integral_network.py": { + "normalization": "none", + "original_sha256": "97cce7cdaeea2c415b7959d3bdbf34d272e3b541f6e7dc9b87c134a2c2620740", + "public_sha256": "97cce7cdaeea2c415b7959d3bdbf34d272e3b541f6e7dc9b87c134a2c2620740" + }, + "vendor/staged-width-t530/owners/portable_expand.py": { + "normalization": "none", + "original_sha256": "3a0ded73b3b8c6e945f28626c65c2160b540df5c3e86db5a48eb5639c5731f4c", + "public_sha256": "3a0ded73b3b8c6e945f28626c65c2160b540df5c3e86db5a48eb5639c5731f4c" + }, + "vendor/staged-width-t530/owners/source_context.py": { + "normalization": "none", + "original_sha256": "9967d6f5c0ca5f8437f76e3130c39aea3ff53e3d1ffa04a54d17db5f44f69f4c", + "public_sha256": "9967d6f5c0ca5f8437f76e3130c39aea3ff53e3d1ffa04a54d17db5f44f69f4c" + }, + "vendor/staged-width-t530/owners/test_owner_guards.py": { + "normalization": "none", + "original_sha256": "fecbf1518c4594c64276847f92d5980443c6b5562345e97354305d5c31530bb0", + "public_sha256": "fecbf1518c4594c64276847f92d5980443c6b5562345e97354305d5c31530bb0" + }, + "vendor/staged-width-t530/owners/verify_candidate.py": { + "normalization": "none", + "original_sha256": "efce5f7b1cbc3f8d0807312da5248209d1b2dd9d6043656a7d2e58b58887214b", + "public_sha256": "efce5f7b1cbc3f8d0807312da5248209d1b2dd9d6043656a7d2e58b58887214b" + }, + "vendor/staged-width-t530/owners/verify_owner.py": { + "normalization": "none", + "original_sha256": "8d1a3c2a7beb0f18e2beaa3df455a721ea6129343ec52031d18e58fbde5081cb", + "public_sha256": "8d1a3c2a7beb0f18e2beaa3df455a721ea6129343ec52031d18e58fbde5081cb" + }, + "vendor/staged-width-t530/replay.py": { + "normalization": "none", + "original_sha256": "c74d9169279bd795c84a605e375afbba1988abfc78933293b296f59bd70f013f", + "public_sha256": "c74d9169279bd795c84a605e375afbba1988abfc78933293b296f59bd70f013f" + }, + "vendor/staged-width-t530/source_builder.py": { + "normalization": "none", + "original_sha256": "0cb5f62d517ac35c44922abc338cd41356b3e08dc7c6d6d9f64a43a9a541378f", + "public_sha256": "0cb5f62d517ac35c44922abc338cd41356b3e08dc7c6d6d9f64a43a9a541378f" + }, + "vendor/staged-width-t530/supplier3605/ARTIFACTS.json": { + "normalization": "none", + "original_sha256": "867bd848d04505518463eb06b1905e70ccc9256bb73312d3cd1dc57623bb319b", + "public_sha256": "867bd848d04505518463eb06b1905e70ccc9256bb73312d3cd1dc57623bb319b" + }, + "vendor/staged-width-t530/supplier3605/PROOF.md": { + "normalization": "none", + "original_sha256": "525b010f3a895bdb11313f9938ad1b742df64bcee0b5671399230b1ded541baf", + "public_sha256": "525b010f3a895bdb11313f9938ad1b742df64bcee0b5671399230b1ded541baf" + }, + "vendor/staged-width-t530/supplier3605/README.md": { + "normalization": "none", + "original_sha256": "c1956badbcd92f2f88dcea833facc39eefb7eef8f220fb7b1941b4c552109d89", + "public_sha256": "c1956badbcd92f2f88dcea833facc39eefb7eef8f220fb7b1941b4c552109d89" + }, + "vendor/staged-width-t530/supplier3605/SOURCES.json": { + "normalization": "none", + "original_sha256": "005bf38ae679a9fb3ad1ee94b8c35bdfec58451ef58e0a87b0c7b68ef4fc51d5", + "public_sha256": "005bf38ae679a9fb3ad1ee94b8c35bdfec58451ef58e0a87b0c7b68ef4fc51d5" + }, + "vendor/staged-width-t530/supplier3605/STAGED-PAIR-RECORD-base.json.gz": { + "normalization": "none", + "original_sha256": "a6ae4188be998990ecb176fef5929e8e1dfce3726e372c0da2a290fe8ea73532", + "public_sha256": "a6ae4188be998990ecb176fef5929e8e1dfce3726e372c0da2a290fe8ea73532" + }, + "vendor/staged-width-t530/supplier3605/STAGED-PAIR-RECORD-extra.json.gz": { + "normalization": "none", + "original_sha256": "33a39d46d4d19bdeb6f0b6abb38cc80c68219e1ae10dd7e1acaccedc14b47236", + "public_sha256": "33a39d46d4d19bdeb6f0b6abb38cc80c68219e1ae10dd7e1acaccedc14b47236" + }, + "vendor/staged-width-t530/supplier3605/STAGED644-660-base.json.gz": { + "normalization": "none", + "original_sha256": "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653", + "public_sha256": "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653" + }, + "vendor/staged-width-t530/supplier3605/STAGED644-660-extra.json.gz": { + "normalization": "none", + "original_sha256": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f", + "public_sha256": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f" + }, + "vendor/staged-width-t530/supplier3605/TASK.json": { + "normalization": "none", + "original_sha256": "b85158fedf4734ff028703353ac6e9929ddea6a8e7c845c8341c2428d628717a", + "public_sha256": "b85158fedf4734ff028703353ac6e9929ddea6a8e7c845c8341c2428d628717a" + }, + "vendor/staged-width-t530/supplier3605/VALIDATION.json": { + "normalization": "none", + "original_sha256": "fa3803654e230cd50bc9fb874ec80e16dd838adebf13cd0cb174f18bc12fa04a", + "public_sha256": "fa3803654e230cd50bc9fb874ec80e16dd838adebf13cd0cb174f18bc12fa04a" + }, + "vendor/staged-width-t530/supplier3605/VERIFY.json": { + "normalization": "none", + "original_sha256": "21320da6b638366ccd42824e4b5865608f497cf2ba7323fffedb77f0a368c96a", + "public_sha256": "21320da6b638366ccd42824e4b5865608f497cf2ba7323fffedb77f0a368c96a" + }, + "vendor/staged-width-t530/supplier3605/check_residual.py": { + "normalization": "none", + "original_sha256": "e34b06ae725f062d15ad83cbd3ef2f91d3d78c380ccc93c8d2deba1c9e354c70", + "public_sha256": "e34b06ae725f062d15ad83cbd3ef2f91d3d78c380ccc93c8d2deba1c9e354c70" + }, + "vendor/staged-width-t530/supplier3605/check_scope.py": { + "normalization": "none", + "original_sha256": "f8eefd425a0d570167e14febcacfbb38a6bb29d820d808be426180cf31b5a947", + "public_sha256": "f8eefd425a0d570167e14febcacfbb38a6bb29d820d808be426180cf31b5a947" + }, + "vendor/staged-width-t530/supplier3605/staged_pair.py": { + "normalization": "none", + "original_sha256": "25fc9b025dbb90358032013303adea650a5f19937fd3edf30b6c6fd023e2d747", + "public_sha256": "25fc9b025dbb90358032013303adea650a5f19937fd3edf30b6c6fd023e2d747" + }, + "vendor/staged-width-t530/supplier3605/verify.py": { + "normalization": "none", + "original_sha256": "0ef49b725fc132cd5fc26a9a81028739896232d938bae22cef132384c7cbab13", + "public_sha256": "0ef49b725fc132cd5fc26a9a81028739896232d938bae22cef132384c7cbab13" + }, + "vendor/staged-width-t530/templates/prepare_extension_native.py": { + "normalization": "none", + "original_sha256": "0cdb4b8b8b565e3dc4a312d4174c86d7d1aebc531430cb726658c8feb0c3bcf4", + "public_sha256": "0cdb4b8b8b565e3dc4a312d4174c86d7d1aebc531430cb726658c8feb0c3bcf4" + } + }, + "original_prefix_sha256": "6f277c0e8378adc3906f83130da63c731e4c4e0045b891dbfba8968da7971d7f", + "rule": "Only this session workspace absolute prefix is replaced with $RESEARCH_WORKSPACE in execution metadata. Upstream source bytes, source manifests, changed words and mathematical fields are unchanged. Original hashes are historical claims from the retained local capsule; this public derivative does not supply all original bytes or the complete runtime/native archives.", + "schema": "public-normalized-recorded-summary/1" +} diff --git a/research/staged-release-retiming-t530/full-admission/README.md b/research/staged-release-retiming-t530/full-admission/README.md new file mode 100644 index 0000000000..0873261cab --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/README.md @@ -0,0 +1,142 @@ +# Source reconstruction, full replay and recorded evidence + +The original local run completed fresh native replay for both changed providers +and all seven source-bound admission stages. The terminal statuses were +`PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE` and `PASS_RELEASE`. +The conditional modern outer value was exactly +`0.001730394391813963415120 - 10^-46 - 10^-70`. +The inherited all-size assumptions remain; see the package's main proof. +The published full wrapper has subsequently completed end to end as a separate +local run, described below; its receipts do not replace the original evidence. + +This is a lean public derivative of that evidence. It deliberately omits the +complete generated source, runtime and native-cache archives. Their original +hashes and sizes are recorded in `ARCHIVE-OMISSIONS.json`. Source and runtime +manifests, selected native/runtime metadata, all seven stage summaries and +relevant logs are retained. No archive payload is authenticated by the public +summary check. + +## Public summary check + +```sh +python3 -B research/staged-release-retiming-t530/full-admission/check_recorded_summary.py +``` + +This standard-library check verifies public file hashes and internal recorded +status, exact κ/profile, native-versus-retained-reuse, seven-stage, physical and +prefix references. It returns `PASS_PUBLIC_RECORDED_SUMMARY_BINDINGS`. It is +not the private capsule's complete archive checker and does not rerun native, +owner, controller or outer computations. + +`python3 -B research/staged-release-retiming-t530/full-admission/test_recorded_summary.py` +checks four repinned malformed summaries: missing fresh native stages, missing +providers, empty finite-invoice predicates and a changed certified endpoint. +Each is rejected at its corresponding content predicate. + +Our workspace prefix in execution metadata is replaced with +`$RESEARCH_WORKSPACE`. `PUBLIC-PROVENANCE.json` records original SHA256, public +SHA256 and the normalization rule for each retained evidence file. Original hash +references are compared as recorded historical metadata, never falsely to the +normalized bytes. The original unnormalized bytes are not all supplied here. +Upstream source bytes, source manifests, words and mathematical fields are +unchanged. The original local capsule was left untouched. + +`evidence/DERIVATION.json` preserves the historical PREPARED construction status. +It predates the completed native and full admission receipts. The older +supplier-only κ `0.001727405299371541` is a different layer: the original final +release binds the modern outer κ to the same supplier complex endpoint/profile. + +## Fresh source reconstruction + +From a full Git checkout containing canonical main +`20ecf2891d80b5acf18d980b2164fb44ea7faa90`: + +```sh +python3.12 -B research/staged-release-retiming-t530/full-admission/reproduce.py \ + --repo . --work /tmp/fresh-retiming-source --materialize-only +``` + +This path was actually run from the public layout. It exports exactly the 540 +ancestor paths in `MAIN-INPUTS.json`, checks every SHA256, materializes the +predecessor with its unchanged authenticated materializer, appends the retiming +stage and runs the old and new reconstruction reviews. It reproduces all 654 +source files and source manifest +`fb47533a401d1d13719be8b9aab91fe5313931ca62d40dba336eab6a96275aa0`. +`evidence/PUBLIC-SOURCE-REBUILD-RESULT.json` records that fresh check. +The checkout HEAD may be newer than the ancestor. No network or unmerged PR +Git objects are needed: the required PR3626 bytes at +`659fd5e7064d9466b668d7188cbb013b333a415a` are vendored with exact input pins. +Only its consumed source/owner closure is retained, with contributor notices. + +## Complete scientific replay + +From the repository root, run the full wrapper without `--materialize-only` +or an imported `--allocation`: + +```sh +python3.12 -B research/staged-release-retiming-t530/full-admission/reproduce.py \ + --repo . --work /tmp/fresh-retiming-full +``` + +This runs fresh changed native providers, reconstructs all 1,946,160 literal +owner roles and executes the complete original admission. Use Python 3.12 with +numpy 2.5.4, scipy 1.18.1, sympy 1.14.0, mpmath 1.3.0, +gmpy2 2.3.2 and psutil 7.2.2. Assertions must be enabled. All output goes to a +fresh external work directory. The original scientific driver took about 20.3 +minutes, plus native generation. The unchanged retained parent and two retained native +chains are authenticated and reused; this is not a fresh retained bootstrap. + +The complete scientific driver ran successfully before publication, using this +same 654-file source. The published wrapper has now also run end to end at +commit `abc12f62e4fe9bfcb2e33c84703253c918668351`, in a fresh external work +directory with a regenerated allocation and no wrapper code fix. All seven +wrapper stages and all seven nested admission stages exited 0. It reproduced +the same source manifest and exact κ, ending in +`PASS_RETIMER_T530_COMPLETE_CONDITIONAL_RELEASE` and `PASS_RELEASE`. +All 295 tracked package files remained unchanged during the run. + +The full-wrapper run took **1,271.668979667 seconds (21 minutes 11.67 seconds)** +on local macOS 27.0 arm64, Python 3.12.14 and the dependency versions above, +from 2026-10-18 12:37:09.414302 to 12:58:21.088357 UTC. This was a new work +directory in an already provisioned local environment, not an independent +external or clean-environment reproduction. Both changed native providers were +freshly replayed; the retained parent and two unchanged native chains remained +authenticated reuse. Runtime source patches and exact native/admission driver +copies are retained for inspection; no scientific gate was removed. + +## Separate public full-replay evidence + +[PUBLIC-FULL-REPLAY.json](../PUBLIC-FULL-REPLAY.json) indexes the new run. +Its selected records and original-to-public normalization hashes are in +`fresh-replay/`; the original scientific receipts, source-only reconstruction +receipt and bounded `PUBLIC-VALIDATION.json` remain unchanged. Check the new +recorded evidence and its rejection controls from the repository root: + +```sh +python3 -B research/staged-release-retiming-t530/full-admission/fresh_replay_evidence.py check \ + --root research/staged-release-retiming-t530/full-admission/fresh-replay +python3 -B research/staged-release-retiming-t530/full-admission/fresh_replay_evidence.py controls \ + --root research/staged-release-retiming-t530/full-admission/fresh-replay +``` + +These are recorded-evidence checks; they do not rerun the scientific pipeline +or authenticate omitted archive payloads. Use `reproduce.py` above for a fresh +full computation. The original public summary checker retains its narrower +historical scope. + +## Open next questions + +- Reproduce the public full wrapper independently in another clean environment + or platform. Its complete path has now passed locally; an external run would + test dependency and platform portability. First provision the stated + dependencies, run the full command in a fresh directory, and compare the + mathematical payloads, source manifest and endpoint. This remains separate + from the inherited general theorem assumptions. +- Evaluate the retiming with another chronological allocation only after its + full owner/controller/prefix invoice is available. Start by comparing helper + interfaces and exact local profiles; no untested composition is claimed. + +The source and credit lineage includes Ross Richardson/PR3605, +hexapode/PR3626, dcharb78/PR3133, Jeremy Diviney/PR3148, +Marius-Paul Dumitrean/PR2979 and all retained notices. The new retiming and +integration used substantial OpenAI Codex assistance. Apache-2.0 applies. diff --git a/research/staged-release-retiming-t530/full-admission/check_recorded_summary.py b/research/staged-release-retiming-t530/full-admission/check_recorded_summary.py new file mode 100644 index 0000000000..b3a6ed0b43 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/check_recorded_summary.py @@ -0,0 +1,211 @@ +#!/usr/bin/env python3 +"""Check the PUBLIC NORMALIZED RECORDED SUMMARY with standard-library code. + +This intentionally has a narrower scope than the private archive checker. It +checks public-file integrity, declared original/public normalization hashes and +internal recorded status/profile/receipt references. The original full source, +runtime and native archives are not supplied or authenticated by this check. +Original hashes are historical metadata, NOT hashes of the normalized bytes. +Run reproduce.py --materialize-only for fresh source reconstruction; omit that +flag for the separate complete scientific replay with inherited assumptions. +""" +from pathlib import Path, PurePosixPath +from fractions import Fraction as Q +import argparse +import hashlib +import json + +SOURCE = 'fb47533a401d1d13719be8b9aab91fe5313931ca62d40dba336eab6a96275aa0' +PROFILE = {'1':11747920,'2':3453480,'3':1112042,'4':486540,'5':103690,'8':38160,'48':202828} +LOCAL = {'1':2437,'2':724,'3':226,'4':102,'5':20,'8':8} +C = Q('0.001730394391813963415120') +K = C-Q(1,10**46)-Q(1,10**70) +STAGES = ['owners','parent-lift','rebind','discovery','outer-check_ledger.py','outer-independent_check.py','release'] +PARENT = 'e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' +RETAINED = {'base':'e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e','extra':'7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905'} +NATIVE_STAGES = ['native','ledgers','local-replay','wrappers','phases'] +WORDS = {'base':'6df3356808e29909776be8bc0faf03df983401a267c2d740d1ac2dbcaa278269','extra':'65624efec36b35934b750c1741ba2ad4e6df3cff86e44536b0c016ebddb0fb55'} + +def need(value, label): + if not value: + raise ValueError(label) + +def digest(data): + return hashlib.sha256(data).hexdigest() + +def file_sha(path): + h=hashlib.sha256() + with path.open('rb') as f: + for b in iter(lambda:f.read(1024*1024),b''): + h.update(b) + return h.hexdigest() + +def jread(path): + return json.loads(path.read_text()) + +def check(root): + pins=jread(root/'PUBLIC-PINS.json') + need(pins['schema']=='public-retiming-summary-files/1','public pin schema') + actual={p.relative_to(root).as_posix() for p in root.rglob('*') if p.is_file() and p.name not in {'PUBLIC-PINS.json','PUBLIC-CHECK-RESULT.json'}} + need(set(pins['sha256'])==actual,'complete public summary file inventory') + for name,h in pins['sha256'].items(): + p=PurePosixPath(name) + need(not p.is_absolute() and '..' not in p.parts,'unsafe evidence path') + need(file_sha(root/name)==h,'recorded file hash: '+name) + provenance=jread(root/'PUBLIC-PROVENANCE.json') + need(provenance['schema']=='public-normalized-recorded-summary/1','normalization provenance schema') + for name,record in provenance['files'].items(): + need(file_sha(root/name)==record['public_sha256'],'public normalization digest '+name) + need(record['normalization'] in ('none','workspace-prefix-to-token'),'documented normalization rule') + if record['normalization']=='none': + need(record['original_sha256']==record['public_sha256'],'unchanged bytes really unchanged') + def recorded_sha(path): + # This is an ORIGINAL HASH DECLARATION. It does not authenticate unavailable raw bytes. + name=path.relative_to(root).as_posix() + return provenance['files'][name]['original_sha256'] if name in provenance['files'] else file_sha(path) + def metadata(prefix,expected,names): + data={} + for name in names: + path=root/'evidence'/prefix/name + need(recorded_sha(path)==expected[name],'selected original metadata digest '+name) + data[name]=path.read_bytes() + return data + ev=root/'evidence' + rebuilt=jread(ev/'PUBLIC-SOURCE-REBUILD-RESULT.json') + need(rebuilt['status']=='PASS_PUBLIC_SOURCE_REBUILD_654_FILES' and rebuilt['source_manifest_sha256']==SOURCE and rebuilt['source_files']==654,'recorded public source rebuild') + need(rebuilt['main_commit']=='20ecf2891d80b5acf18d980b2164fb44ea7faa90' and rebuilt['exported_inputs']==540,'recorded pinned main export') + need([s['name'] for s in rebuilt['stages']]==['original-materialization','retiming-source','preserved-staged-review','new-retiming-review'] and all(s['exit_code']==0 for s in rebuilt['stages']),'recorded public source rebuild gates') + manifest=jread(ev/'SOURCE-MANIFEST.json') + need(recorded_sha(ev/'SOURCE-MANIFEST.json')==SOURCE and len(manifest)==654,'frozen source manifest') + need(recorded_sha(ev/'retained-parent-CLAIM.json')==manifest['vendor/pr1297/CLAIM.json'],'selected retained source claim') + source={'vendor/pr1297/CLAIM.json':(ev/'retained-parent-CLAIM.json').read_bytes()} + nr=jread(ev/'NATIVE-NATIVE-RECEIPT.json') + need(nr['status']=='PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE','native receipt status') + need(set(nr['providers'])=={'base','extra'},'exact fresh provider set') + need(nr['manifest_sha256']==SOURCE and nr['fresh_current_provider_count']==2,'two fresh changed providers') + need(nr['reused_retained_native_count']==2 and nr['reused_retained_parent'] is True and nr['fresh_retained_parent'] is False,'explicit retained reuse') + nr_result=jread(ev/'NATIVE-RESULT.json') + need(nr_result['status']=='PASS_TWO_FRESH_SHARED_KERNEL_NATIVE_CHAINS_AUTHENTICATED_PARENT_REUSE','native preparation completion') + need(nr_result['native_receipt_sha256']==recorded_sha(ev/'NATIVE-NATIVE-RECEIPT.json'),'native receipt chain') + need(nr_result['source_manifest_sha256']==SOURCE,'native source chain') + need(nr_result['environment_sha256']==recorded_sha(ev/'NATIVE-ENVIRONMENT.json'),'native environment chain') + need(nr_result['preparer_sha256']==recorded_sha(root/'scripts/prepare_extension_native.py'),'actual native preparer binding') + need(nr_result['stages']==jread(ev/'NATIVE-STAGES.json'),'native stage identity') + need([s['name'] for s in nr_result['stages']]==['fresh-current-base','fresh-current-extra'],'exact two fresh native stages') + old_receipt=jread(ev/'RETAINED-REUSE-RECEIPT.json') + need(nr['retained_reuse_receipt_sha256']==recorded_sha(ev/'RETAINED-REUSE-RECEIPT.json'),'actual retained reuse receipt') + parent_dir='_receipts/'+PARENT+'/' + names=[parent_dir+n for n in ['RECEIPT.json','RESULT.json','STAGES.json']] + for word in RETAINED.values(): + names.extend([word+'/STEPS.json',word+'/CACHE.json']) + for kind,word in WORDS.items(): + need(nr['providers'][kind]['word_sha256']==word,'changed word binding') + names.extend([word+'/STEPS.json',word+'/local/LOCAL-CHECKS.json',word+'/local/INDEPENDENT-LOCAL-REPLAY.json']) + native=metadata('native-summary',nr['cache_files'],names) + pr=json.loads(native[parent_dir+'RECEIPT.json']) + need(digest(native[parent_dir+'RECEIPT.json'])==nr['retained_parent_receipt_sha256']==old_receipt['retained_parent_receipt_sha256'],'retained parent receipt chain') + need(pr['schema']=='parent-receipt/1' and pr['vendor_manifest_sha256']==PARENT==manifest['vendor/pr1297/MANIFEST.json'],'retained parent manifest') + need(pr['claim_sha256']==manifest['vendor/pr1297/CLAIM.json'] and pr['words']==RETAINED,'retained parent claim and words') + need(set(pr['files'])=={'RESULT.json','STAGES.json'},'retained parent receipt file set') + for name,h in pr['files'].items(): + need(digest(native[parent_dir+name])==h,'retained parent result file binding') + parent_result=json.loads(native[parent_dir+'RESULT.json']) + parent_stages=json.loads(native[parent_dir+'STAGES.json']) + need(parent_result['status']=='PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION','retained parent complete status') + need(parent_result['base_native_reuse'] is True and parent_result['extra_native_reuse'] is True,'retained parent reuse explicit') + need(parent_result['kappa']==json.loads(source['vendor/pr1297/CLAIM.json'])['kappa'],'retained parent exact kappa') + need(parent_result['stages']==parent_stages and len(parent_stages)==16 and all(s['exit_code']==0 for s in parent_stages),'retained parent sixteen stages') + for kind,word in RETAINED.items(): + need(word==manifest['vendor/pr1297/'+('gauge44-word.json.gz' if kind=='base' else 'extra-word.json.gz')],'retained literal word source') + st=json.loads(native[word+'/STEPS.json']) + need([x['step'] for x in st]==NATIVE_STAGES and all(x['exit_code']==0 for x in st),'retained native five stages') + cj=json.loads(native[word+'/CACHE.json']) + subset={k.removeprefix(word+'/'):h for k,h in nr['cache_files'].items() if k.startswith(word+'/') and k!=word+'/CACHE.json'} + need(cj['word_sha256']==word and cj['files']==subset,'complete retained native cache') + for name,h in nr['cache_files'].items(): + if name.startswith(parent_dir) or any(name.startswith(w+'/') for w in RETAINED.values()): + need(old_receipt['cache_files'][name]==h,'retained cache exact inherited bytes') + for s in nr_result['stages']: + need(s['exit_code']==0,'fresh native exit status') + kind=s['name'].split('-')[-1] + need(s['log_sha256']==recorded_sha(ev/('native-'+kind+'.log')),'fresh native log chain') + need(s['result_sha256']==recorded_sha(ev/('native-'+kind+'-RESULT.json')),'fresh native result chain') + need(s['script_sha256']==manifest['new/fastnative/run_native.py'],'fresh native actual script source') + fresh=jread(ev/('native-'+kind+'-RESULT.json')) + need(fresh['status']=='PASS_COMPLETE_T74_NATIVE_REPLAY' and fresh['word_sha256']==WORDS[kind],'fresh native status and word') + need([q['step'] for q in fresh['steps']]==NATIVE_STAGES and all(q['exit_code']==0 for q in fresh['steps']),'fresh native full five-stage receipt') + for kind,word in WORDS.items(): + need(nr['providers'][kind]['complete_native_files']=={k.removeprefix(word+'/'):h for k,h in nr['cache_files'].items() if k.startswith(word+'/') and k!=word+'/CACHE.json'},'complete fresh provider cache binding') + st=json.loads(native[word+'/STEPS.json']) + need([x['step'] for x in st]==NATIVE_STAGES and all(x['exit_code']==0 for x in st),'five native gates') + checks=json.loads(native[word+'/local/LOCAL-CHECKS.json']) + for orientation in ['forward','backward']: + row=checks[orientation] + need(row['paid_profile']==LOCAL and row['all_columns']==632 and row['zero_buffers_returned_to_zero']==91,'native profile/columns/buffers') + result=jread(ev/'ADMISSION-RESULT.json') + need(result['status']=='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE','complete admission status') + need(result['source_manifest_sha256']==SOURCE and result['source_file_count']==654,'admission source binding') + need(result['native_receipt_sha256']==recorded_sha(ev/'NATIVE-NATIVE-RECEIPT.json'),'admission native binding') + need(result['profile']==PROFILE and result['replicas']==530 and result['actual_expected_helpers']==408,'admission profile/dimensions') + need(Q(result['complex_lower'])==C and Q(result['kappa'])==Q(result['kappa_decimal'])==K,'exact certified endpoint') + need(K>Q('0.001730071864705779882540'),'strict improvement over PR3626 before its margins') + stages=jread(ev/'ADMISSION-STAGES.json') + need(stages==result['stages'] and [x['name'] for x in stages]==STAGES,'seven-stage receipt chain') + bindings=jread(ev/'STAGE-SCRIPT-BINDINGS.json') + for s in stages: + need(s['exit_code']==0,'admission stage exit status') + need(s['log_sha256']==recorded_sha(ev/'logs'/(s['name']+'.log')),'admission log binding '+s['name']) + need(s['script_sha256']==recorded_sha(root/bindings[s['name']]),'admission script binding '+s['name']) + package_manifest=jread(ev/'PACKAGE-MANIFEST.json') + package_hash=recorded_sha(ev/'PACKAGE-MANIFEST.json') + need(result['package_manifest_sha256']==package_hash,'final package manifest chain') + stage_sources={'owners':'reconstruct.py','parent-lift':'lift_parent.py','rebind':'new/rebind.py','discovery':'replay.py','outer-check_ledger.py':'outer/check_ledger.py','outer-independent_check.py':'outer/independent_check.py','release':'verify_release.py'} + for stage in stages: + need(stage['script_sha256']==package_manifest[stage_sources[stage['name']]],'execution script in admitted package') + selected=['CLAIM.json','outer/LEDGER.json','outer/B.json','outer/OUTER-CLAIM.json','new/SPEC.json'] + packed=metadata('runtime-summary',package_manifest,selected) + spec=json.loads(packed['new/SPEC.json']) + need(spec['expected']['global_profile']==PROFILE and Q(spec['expected']['complex_lower'])==C,'frozen final specification') + ledger=json.loads(packed['outer/LEDGER.json']) + need(Q(ledger['rows']['struct_boundary_radix_union']['kappa']['rational'])==K,'modern ledger headline chain') + outer_claim=json.loads(packed['outer/OUTER-CLAIM.json']) + b=json.loads(packed['outer/B.json']) + need(Q(outer_claim['kappa'])==Q(outer_claim['kappa_rational'])==K,'outer claim headline') + need(b['profile']==PROFILE and b['live']==474880 and Q(b['b'])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": "770d23cb1ac78b485ccc1a26f5d3e2fed7345940f77011579ae90ada4f5cacb1", + "before_sha256": "4b44d5e72e9d677076edc2d20569cdd30f0e21849afd88874d74dfa7d1c767e0", + "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+40\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": "770d23cb1ac78b485ccc1a26f5d3e2fed7345940f77011579ae90ada4f5cacb1", + "before_sha256": "4b44d5e72e9d677076edc2d20569cdd30f0e21849afd88874d74dfa7d1c767e0", + "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. +DIG=spec['outer_refinement']['endpoint_digits'] # the supplier endpoint is certified to 10^-DIG (accept at the endpoint, reject at endpoint + 10^-DIG); every slack sits 10 digits below +# Fixed-grid maximum (PR2180 / PR2161, dataisfire; proof PROOF-GRID-MAX.md): the free gaps shrink together to R0 = 10^-(DIG+80); grid, backoff and certified endpoint are unchanged. +R0=Q(1,10**(DIG+80)); ZETA=R0/100; SLACK=R0; GAP=R0; STOP=R0/10**6 +FLOOR=10**(DIG+46); BACKOFF=Q(1,10**(DIG+22)); B_GAP=R0 +# Fine prime padding: theta is between 1/(4p^2) and 1/(2p^2-1). +# Online chirp guard beta+2*xi-2<1; coefficient setup uses O(p^2 log p) bits. +# epsilon = 1 - DELTA_E is a FREE parameter (outer/FINE-PADDING-COMPOSITION.md sec. 2): every row is strictly satisfied for every DELTA_E > r0 = 10^-(DIG+80); beta = 1 - 3 DELTA_E lies in the admissible window +# [1 - DELTA_E (1 + 1/q), 1 - 2 DELTA_E). DELTA_E = (1025/1024) r0 keeps the gamma spare power 1-eps-r0 = r0/1024 > 0 and puts C - eps*q below 1/FLOOR (PROOF-GRID-MAX.md). +DELTA_E=Q(1025,1024)*R0 +EPS=1-DELTA_E +BETA=1-3*DELTA_E +THETA_POWER=Q(2) +HALO_POWER=48 +CORE_POWER=128 +STRASSEN_TAU=Q(45,16) +KAPPA_1828=Q('0.0016797549561255445213356709939207025769983114385025802954603275201627999999999999999999999999979966404900867489109573286580121585') # exact kappa of rohanarun's PR1828 (slack refinement of PR1800 at 1e-96), from its body +KAPPA_1839=Q('0.0016797549561255445213356709939207025769983114385025802954603275201628645482603256388263049999999997996640490086748910957328658012158594') # exact kappa of PR1839 (previous package: 1e-90 endpoint) +KAPPA_1875=Q('0.0016797549561255445213356709939207025769983114385025802954603275201628645482603256388263056561328446322744513169085862209720704481201654121427713006366929567157349625273906229277148454180995537563371124755588139767841405530386745578819565618798006892541712197674874836946756930569827889227573192555649999999997996640490086748910957328658012158594') # exact kappa of rohanarun's PR1875 (1e-300 endpoint), from its body +KAPPA_1876=Q('0.001679754956125544521335670993920702576998311438502580295460327520162864548260325638826305656132844632274451316908586220972070448120165412142771300636692956715734962527390622927714845418099553756337112475558813976784140553038674557881956561879800689254171219767487483694675693056982788922757319255565606685566411725238449650999339827075715283714270157705762309226038611771955655377501414652136546310799999999999999999997996640490086748910957328658012158594846') # exact kappa of rohanarun's PR1876 (1e-400 endpoint), from its body +KAPPA_1897=Q('0.001679754956125544521335670993920702576998311438502580295460327520162864548260325638826305656132844632274451316908586220972070448120165412142771300636692956715734962527390622927714845418099553756337112475558813976784140553038674557881956561879800689254171219767487483694675693056982788922757319255565606685566411725238449650999339827075715283714270157705762309226038611771955655377501414652136546310881185746917580802513640545967852810801680966856133978576162943792322682482152988532923811998938861379689883167389728443314312230815059559906903773756886872476136837071871203030423643505345473735135533') # exact kappa of M6LI's PR1897 (1e-500 grid), from its body +KAPPA_1786=Q('0.0016797547881500489087805478664999999999999999999999999999999998000000199999') # exact kappa of chafreaky's PR1786 ledger (EXPECTED-BALANCE.json), headline 0.001679754788150048 +KAPPA_PKG5=Q('0.001677992607205282520732088774830808372222877897034109604209719298829805473412451530867883424937597') # previous package (rectangular k=2, tau_eff=2.2500351) +KAPPA_PKG4=Q('0.0016778199023144364336310551358776001013829401215770658599799349282716974076737897457922714197448847') # previous package (radix union schedule, square boundary tau=2.372864) +KAPPA_1712=Q('0.0016776417313433545642517275958639984231708545722735432722117400060454625429077941422798526440584702') # pkg of PR1712 (Le Gall tau=12/5, old union row) +KAPPA_1699=Q('0.001677641731343354564251058287063644749065568493') # exact kappa of PR1699's ledger (Chafik Boukhalfa), same supplier profile +certified_complex=Q(spec['expected']['complex_lower']) +bit=Q('0.001733427039589844234749') +# Keep short independently checkable decimals strictly inside both endpoints. +b=certified_complex-B_GAP # strictly inside the certified supplier endpoint; B.json carries the same exact value +assert b==Q(BJ['b']) +q=b-GAP +a=(q+b)/2 +online=Q(spec['expected']['kappa']) +old=Q('0.001673360105405778') +assert b0 +assert m==73 and W==896*T and W==BJ['live'] +EXPECTED_PROFILE={int(k):v for k,v in BJ['profile'].items()} +assert profile==EXPECTED_PROFILE + +GB=int((DIG+130)*3.3220)+16 # enclosure grid 2^-GB, about 50 digits below the slacks +ONE=1<=2:x/=2;k+=1 + lo,hi=unit_log(x) + return down(lo+k*ln2[0]),up(hi+k*ln2[1]) +def exp(x): + assert 0<=x>GB)//j;th=_cd(-((-th*xu)>>GB),j);sl+=tl;sh+=th + tn=_cd(-((-th*xu)>>GB),EN) # x^EN/EN! (rounded up); the tail is at most twice this + return Q(int(sl),ONE),Q(int(sh+2*tn+2),ONE) +def moment(endpoint): + lo=hi=Q(0) + for r,n in profile.items(): + l,h=log(Q(m,r)); weight=Q(n*r,m*W) + lo+=weight*exp(endpoint*l)[0] + hi+=weight*exp(endpoint*h)[1] + return down(lo),up(hi) + +native=moment(b) +assert native[1]<1 +b_up=Q(BJ['b_above_endpoint']) +assert b_up>certified_complex and moment(b_up)[0]>1 # a larger test endpoint is rejected + +def ledger(kind, *, q_=q, zeta=ZETA, slack=SLACK, + old_scan=False, full_gauge=False, full_key=False, old_union=False, old_theta=False, old_linear=False, old_tag=False, + eps_=EPS, beta_=BETA, tau_eff=STRASSEN_TAU, halo_power=HALO_POWER, core_power=CORE_POWER): + r=R0; stop=STOP + # Existing explicit Strassen format, 7^16<2^45; c=3/32. + # Union: radix-distributed schedule (outer/UNION-SCHEDULE.md, new in this package): row exponent eps+1/2-xi. The boundary row binds with main; the Gaussian row has slack at this explicit point. + c=(3-tau_eff)/2 + eps=eps_; beta=beta_ + xi=eps*(1+q_)-c+slack + saving=eps*q_ + # Deliberate strict gap (BACKOFF) after decimal truncation to the FLOOR grid. + kappa=Q((saving*FLOOR).__floor__(),FLOOR)-BACKOFF + # kappa is derived, not silently asserted to equal an expected decimal. + tau=1-a; sigma=1-b + internal=tau+(1-stop)*max(sigma-tau,Q(0)) + leaf=sigma+stop*(1-sigma) + lam=1-(q_+a)/2 + key=beta+1-eps + margins={ + 'main_transform':saving, + 'global_coordinate_router':a, + 'fused_gaussian':1-eps+q_*beta, + 'group_bit_router':1-eps+a*beta, + 'group_scans':1-eps+beta, + 'boundary_algebraic_matrix':c+xi-eps, + 'sparse_union_movement':xi+Q(1,2)-eps, + 'polynomial_products':eps, + 'microbox_face_corrections':1-(eps+beta+halo_power-core_power+2), + } + if old_union:margins['old_g_factor_union_row']=1-eps-beta-Q(1,2)+xi + if old_scan:margins['old_per_axis_scan']=1-eps + if full_key:margins['unnecessary_full_key_sort']=margins['sparse_union_movement']-key + checks={ + 'actual_bit_above_effective':bit-a, + 'complex_above_effective':b-a, + 'q_positive':q_, 'complex_endpoint':b-q_, + 'q_below_effective':a-q_, 'stop_positive':stop, + 'stop_below_one':1-stop, + 'leaf_saving_above_effective':(1-stop)*b-a, + 'q_below_internal':1-internal-q_, 'q_below_leaf':1-leaf-q_, + 'lambda_above_tau':lam-tau, 'lambda_above_sigma':lam-sigma, + 'lambda_above_internal':lam-internal, + 'lambda_prime_above_lambda':1-q_-lam, + 'lambda_prime_above_leaf':1-q_-leaf, + 'epsilon_positive':eps,'epsilon_below_one':1-eps, + 'cap_above_band':xi-Q(1,2),'cap_below_cell':eps-xi, + 'group_positive':beta,'group_below_dimension':eps-beta, + 'support_router_span':1-beta, + 'group_gauge_power_slack':1-(2*xi-THETA_POWER)-r-beta, + 'actual_logarithmic_group_guard':1-(2*xi-THETA_POWER)-beta, + 'global_gamma_power_slack':1-eps-r, + 'actual_logarithmic_gamma_guard':1-eps, + 'alpha_logarithm_absorption':r, + 'group_key_fits_record':1-key, + 'membership_arithmetic_fits_record':1-beta-2*(1-eps), + 'microbox_halo_volume':core_power-halo_power-beta, + 'positive_layout_slack':slack, + 'short_record_fallback':eps-a, + 'improvement_over_online_final':kappa-online, + 'improvement_over_previous_local_final':kappa-old, + 'complex_below_one_over_32':Q(1,32)-b, + } + checks['strassen_integer_power_gap']=Q(2**tau_eff.numerator-7**tau_eff.denominator) + checks['theta_positive_polynomial_power']=THETA_POWER + checks['cap_below_phase_cell_power']=THETA_POWER-xi + checks['halo_covers_generic_inverse_radius']=Q(halo_power-43) + checks['union_tag_work_per_visit_fits_record']=1-beta + checks['union_header_fits_record']=1-beta + checks['source_axis_superpolynomial']=1-eps + checks['improvement_over_pr1786']=kappa-KAPPA_1786 + checks['improvement_over_pr1828']=kappa-KAPPA_1828 + checks['improvement_over_pr1839']=kappa-KAPPA_1839 + checks['improvement_over_pr1875']=kappa-KAPPA_1875 + checks['improvement_over_pr1876']=kappa-KAPPA_1876 + checks['improvement_over_pr1897']=kappa-KAPPA_1897 + checks['improvement_over_pr1758']=kappa-Q('0.001679745508802299051546533685199973672313473419790800679752457380932784242972585600630181672224983') + checks['improvement_over_pr1699']=kappa-KAPPA_1699 + checks['improvement_over_pr1712']=kappa-KAPPA_1712 + checks['improvement_over_previous_package']=kappa-KAPPA_PKG4 + checks['improvement_over_pkg_k2']=kappa-KAPPA_PKG5 + if full_gauge:checks['unrecentered_group_gauge']=1-THETA_POWER-r-beta + if old_theta:checks['old_theta_chirp_guard']=1-(2*xi-eps)-r-beta + if old_linear:checks['old_linear_guard']=1-xi-r-beta + if old_tag:checks['old_union_tag_2beta']=1-2*beta + # Main-binding family invariant (PR2180): the Gaussian saving stays above the main saving. The fixed kappa grid (FLOOR) is coarser than the free gaps, + # so the *_above_kappa rows alone would no longer exclude a beta outside the main-binding window; this row is delta*(1-2q) > 0. + checks['gaussian_above_main']=margins['fused_gaussian']-saving + checks.update({n+'_above_kappa':v-kappa for n,v in margins.items()}) + assert margins['boundary_algebraic_matrix']==saving+slack + assert margins['sparse_union_movement']==saving+slack+(tau_eff-2)/2 + return {'kind':kind,'kappa':kappa,'epsilon':eps,'xi':xi,'beta':beta, + 'q':q_,'a':a,'r0':r,'zeta':zeta,'slack':slack, + 'margins':margins,'strict_checks':checks} + +def encode(x): + if isinstance(x,Q): + with localcontext() as c: + c.prec=DIG+200 + return {'rational':str(x),'decimal':str(Decimal(x.numerator)/Decimal(x.denominator))} + if isinstance(x,dict):return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)):return [encode(v) for v in x] + return x + +rows={};controls={} +for kind in ['struct_boundary_radix_union']: + row=ledger(kind) + assert all(v>0 for v in row['strict_checks'].values()) + assert min(row['margins'].values())==row['margins']['main_transform'] + # fixed-grid maximum: C*FLOOR is an integer and 0 < C - eps*q < 1/FLOOR, so floor(FLOOR*eps*q)/FLOOR = C - 1/FLOOR exactly and kappa attains the grid/backoff ceiling + assert (certified_complex*FLOOR).denominator==1 and 0= 1/(4 p^THETA_POWER)), an exponential factor <= p^2 eventually, +# alpha^5 polylogarithmic; a further half power is allowed for the polylogarithmic and bounded-constant factors of the augmented matrices. The umbrella must exceed that budget. +UMBRELLA_POWER=10 +def umbrella_margin(theta_power):return UMBRELLA_POWER-(2*theta_power+2+Q(1,2)) +assert umbrella_margin(THETA_POWER)>0 and umbrella_margin(Q(15,4))<=0 # control: the umbrella would fail silently for THETA_POWER >= 3.75 +HALO_UMBRELLA={'umbrella_power':UMBRELLA_POWER,'theta_power':THETA_POWER,'exponent_budget':2*THETA_POWER+2+Q(1,2),'margin':umbrella_margin(THETA_POWER),'fails_from_theta_power':Q(15,4)} +out={'status':'PASS_FINE_PRIME_PADDING_EXACT_ARITHMETIC', + 'scope':'Conditional fine-prime padding composition. Fresh native admission is required by verify.py. The cited prime theorem, written gauge-free theorem and inherited all-size interfaces are not proved by this arithmetic. No independent human review is claimed.', + 'geometry_changes':{'theta_power':THETA_POWER,'halo_power':HALO_POWER,'core_power':CORE_POWER,'matrix_exponent':STRASSEN_TAU}, + 'halo_umbrella':HALO_UMBRELLA,'complex_lower_short':b,'complex_lower_pinned':certified_complex, + 'native_moment':native,'profile':profile,'m':m,'W':W, + 'online_final_kappa':online,'rows':rows,'rejecting_controls':controls, + 'pr1673_kappa':Q('0.001677160151714381'),'improvement_over_pr1673':rows['struct_boundary_radix_union']['kappa']-Q('0.001677160151714381'), + 'source_sha256':{p.relative_to(WORK).as_posix():hashlib.sha256(p.read_bytes()).hexdigest() for p in [SPEC,CLAIM]}} +(HERE/'LEDGER.json').write_text(json.dumps(encode(out),indent=2)+'\n') +print(out['status']) +for name,row in rows.items(): + print(name,'FINAL KAPPA',encode(row['kappa'])['decimal'], + 'positive checks',len(row['strict_checks']), + 'gain over online',encode(row['kappa']-online)['decimal']) diff --git a/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/outer-independent_check.py.py b/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/outer-independent_check.py.py new file mode 100644 index 0000000000..b838c430ef --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/outer-independent_check.py.py @@ -0,0 +1,60 @@ +"""Independent balance-equation check (PR1673, adapted: this package's supplier b and SPEC), not an execution of the ledger in check_ledger.py.""" +from fractions import Fraction as F +from pathlib import Path +from decimal import Decimal,localcontext +import json,hashlib,sys +sys.set_int_max_str_digits(0) +D=Path(__file__).resolve().parent;W=D.parent +src=W/'new/SPEC.json' +BJ=json.loads((D/'B.json').read_text()) +spec=json.loads(src.read_text());pinned=F(spec['expected']['complex_lower']) +DIG=spec['outer_refinement']['endpoint_digits'];T=10**(DIG+80) # all free slacks are 10^-(DIG+80) or below (fixed-grid-maximum point, PR2180 / PR2161 dataisfire) +b=F(BJ['b']);q=b-F(1,T);eff=(q+b)/2;actual_bit=F('0.001733427039589844234749') +r=F(1,T);z=F(1,T*100);s=F(1,T) +assert 0eff +rows={} +# FINE-PRIME PADDING (outer/FINE-PADDING-COMPOSITION.md): explicit point epsilon=1-delta, beta=1-3 delta, delta=(1025/1024)*10^-(DIG+80), Strassen boundary tau=45/16 (7^16<2^45), c=3/32, +# theta in (1/(4p^2),1/(2p^2-1)], chirp guard beta+2xi-2<1, halo power 48, core power 128. Derived here WITHOUT the ledger code; the structured boundary is not used. +delta=F(1025,1024*T);E=1-delta;B=1-3*delta +assert 7**16<2**45;tau=F(45,16);c=(3-tau)/2;assert c==F(3,32) +nu=2;halo=48;core=128 +X=E+E*q+s-c # boundary saving c+X-E = E q + s +assert c+X-E==E*q+s +# the Gaussian row has slack: 1-E+qB-Eq = delta(1-2q) +assert 1-E+q*B-E*q==delta*(1-2*q)>0 +# admissible beta window for this epsilon: Gaussian row needs beta >= 1-delta(1+1/q); membership needs beta < 1-2 delta +assert 1-delta*(1+1/q)<=B<1-2*delta +assert F(1,2)z>0 and 1-E-r>0 and core-halo-B>0 and halo>43 +assert 1-B>0 and 1-B-2*(1-E)==delta>0 +costs={'transform':1-E*q,'global_router':1-eff,'gaussian':E-q*B,'group_router':E-eff*B,'group_scans':E-B,'boundary':E-X+(tau-1)/2,'sparse_union':E+F(1,2)-X,'polynomials':1-E,'microfaces':E+B+halo-core+2} +K=F((E*q*10**(DIG+46)).__floor__(),10**(DIG+46))-F(1,10**(DIG+22)) +assert max(costs.values())==costs['transform'] and all(v<1-K for v in costs.values()) +# earlier packages' guards fail at this point (they are rejecting controls in the ledger): linear guard 1-X-r-B<0, old theta chirp guard 1-(2X-E)-r-B<0, 2B<1 test fails +assert 1-X-r-B<0 and 1-(2*X-E)-r-B<0 and 1-2*B<0 +assert K>F('0.0016797547881500489087805478664999999999999999999999999999999998000000199999') # PR1786 exact kappa +assert K>F('0.0016797549561255445213356709939207025769983114385025802954603275201627999999999999999999999999979966404900867489109573286580121585') # PR1828 exact kappa +assert K>F('0.0016797549561255445213356709939207025769983114385025802954603275201628645482603256388263049999999997996640490086748910957328658012158594') # PR1839 exact kappa +assert K>F('0.0016797549561255445213356709939207025769983114385025802954603275201628645482603256388263056561328446322744513169085862209720704481201654121427713006366929567157349625273906229277148454180995537563371124755588139767841405530386745578819565618798006892541712197674874836946756930569827889227573192555649999999997996640490086748910957328658012158594') # PR1875 exact kappa +assert K>F('0.001679754956125544521335670993920702576998311438502580295460327520162864548260325638826305656132844632274451316908586220972070448120165412142771300636692956715734962527390622927714845418099553756337112475558813976784140553038674557881956561879800689254171219767487483694675693056982788922757319255565606685566411725238449650999339827075715283714270157705762309226038611771955655377501414652136546310799999999999999999997996640490086748910957328658012158594846') # PR1876 exact kappa +assert K>F('0.001679754956125544521335670993920702576998311438502580295460327520162864548260325638826305656132844632274451316908586220972070448120165412142771300636692956715734962527390622927714845418099553756337112475558813976784140553038674557881956561879800689254171219767487483694675693056982788922757319255565606685566411725238449650999339827075715283714270157705762309226038611771955655377501414652136546310881185746917580802513640545967852810801680966856133978576162943792322682482152988532923811998938861379689883167389728443314312230815059559906903773756886872476136837071871203030423643505345473735135533') # PR1897 exact kappa +assert K>F('0.001679745508802299051546533685199973672313473419790800679752457380932784242972585600630181672224983') # PR1758 +assert K r0 (beta = 1-3 delta); only kappa moves, kappa = (1-delta) q - O(1e-76) +# fixed-grid maximum: saving < C and C*FLOOR integral give K <= C-1/FLOOR-BACKOFF; this point attains it (0 < C-E*q < 1/FLOOR) +FL=10**(DIG+46);assert (pinned*FL).denominator==1 and 00 and 1-dd*(1+1/q)<=Bd<1-2*dd and 1-Ed+q*Bd-Ed*q>0 and Ed-Bd>0 and 1-Bd-2*(1-Ed)>0 + assert F(1,2)0 and core-halo-Bd>0 + assert 1-Ed+eff*Bd>Ed*q and eff>Ed*q and 1-Ed+Bd>Ed*q and Ed>Ed*q and 1-(Ed+Bd+halo-core+2)>Ed*q + sweep.append((str(dd),str(float(q-Ed*q)))) +assert 1-F(1,T)<=1-r # delta=r0 itself is rejected by 1-eps-r0>0 +assert not (1-(1-r)-r>0) +rows['struct_boundary_radix_union']={'epsilon':str(E),'cap':str(X),'beta':str(B),'kappa':str(K),'margin_above_kappa':str(E*q-K),'checked_cost_powers':len(costs),'gap_to_q':str(q-K),'epsilon_free_sweep_delta_gap_to_q':sweep} +report={'status':'PASS_INDEPENDENT_BALANCE_DERIVATION','source_sha256':hashlib.sha256(src.read_bytes()).hexdigest(),'b':str(b),'rows':rows,'scope':'Independent balance derivation and margin comparisons for this package\'s supplier endpoint; the supplier native admission is bound by verify_release.py; inherited all-size assumptions remain.'} +(D/'INDEPENDENT.json').write_text(json.dumps(report,indent=2)+'\n') +print(json.dumps(report,indent=2)) diff --git a/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/owners.py b/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/owners.py new file mode 100644 index 0000000000..f00410bb45 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/owners.py @@ -0,0 +1,66 @@ +# SPDX-License-Identifier: Apache-2.0 +# Derived from Jeremy Kothe / Philippe Van Velzen / Tekalign owner verifier. +# Parameter extension with substantial OpenAI Codex assistance. +"""Borrow-word owner witness: literal verification of the shipped exact fill (new/borrow-fill/FILL.json.gz) and emission of +OWNERS/ORDER/DISPATCH/PROFILE/RESULT for lift_parent.py. The helper count per call is R' = 480-k and the per-call widths come from +new/BORROW-PROVIDERS.json; the same windows, bins and distinct-family rules as the pinned PR1297 owner construction are checked +literally (no window, bin, helper or family rule is relaxed). Idle remainders are whatever the exact bins leave (ranks priced +exactly by the profile). The fill itself is found offline by new/borrow-fill/solve_fill.py (not rerun here) and only verified. +""" +import argparse,collections,gzip,importlib.util,json +from pathlib import Path +assert __debug__, 'Assertions are required' +F=Path(__file__).resolve().parent +ap=argparse.ArgumentParser();ap.add_argument('--out',type=Path,required=True);args=ap.parse_args();P=args.out.resolve();P.mkdir(parents=True,exist_ok=False) +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def dump(p,x): + b=json.dumps(x,sort_keys=True,separators=(',',':')).encode();z=bytearray(gzip.compress(b,mtime=0));z[9]=255;p.write_bytes(bytes(z) if p.suffix=='.gz' else b) +plan=read(F/'inputs/PLAN.json');parent=read(F/'inputs/GLOBAL-TEMPLATE.json.gz');T=plan['T'] +OF=F/'new/borrow-fill/ORDER.json' +assert OF.exists(), 'explicit candidate order required' +if OF.exists(): # a free complete invocation order (666 calls; windows are recomputed from it below) with its explicit dispatch + order=read(OF);dispatch={(s,r):pid for s,r,pid in read(F/'new/borrow-fill/DISPATCH.json')} + Tnew=1+max(r for s,r in order) + assert type(Tnew) is int and Tnew>0 + assert len(order)==9*Tnew and sorted(map(tuple,order))==[(s,r) for s in range(9) for r in range(Tnew)],'order must cover every actual source replica and stage exactly once' + assert set(dispatch)==set(map(tuple,order)),'complete provider dispatch' +else: + order=[[s,r+T*g] for s,r in plan['order'] for g in range(2)] + dispatch={(s,r+T*g):pid for s,r,pid in read(F/'inputs/DISPATCH.json') for g in range(2)} +source=F/'vendor/build_parent.py';sp=importlib.util.spec_from_file_location('windows',source);mod=importlib.util.module_from_spec(sp);sp.loader.exec_module(mod);windows,schedule=mod.actual_windows(parent,order) +prov=read(F/'new/BORROW-PROVIDERS.json');widths={p:d['widths'] for p,d in prov.items()};paid={p:{int(k):v for k,v in d['actual_paid_profile'].items()} for p,d in prov.items()} +R=len(next(iter(widths.values())));assert all(len(w)==R for w in widths.values()) and set(widths)==set(dispatch.values()) +fill=read(F/'new/borrow-fill/FILL.json.gz');assert fill['columns']==['time','helper','owner_replica','child','port','offset'] +for s_,r_,p_ in fill['dispatch_overrides']:dispatch[s_,r_]=p_ # the single gauge44->extra provider upgrade of the pinned fill +pairs,sides=plan['pairs'],plan['sides'] +at={tuple(x):i for i,x in enumerate(order)} +roles=[] +for time,helper,rep,child,port,offset in fill['rows']: + stage,replica=order[time];w=widths[dispatch[stage,replica]][helper] + roles.append(dict(stage=stage,replica=replica,time=time,helper=helper,width=w,owner_replica=rep,child=child,port=port,offset=offset,copy=112*rep+port,family=rep*896+(2*pairs[str(child)]+sides[str(child)])*112+port)) +assert len(roles)==len(order)*R,(len(roles),len(order)*R) +helpers=collections.defaultdict(set);fams=collections.defaultdict(set);used=collections.defaultdict(set) +for z in roles: + call=(z['stage'],z['replica']);rep,child,port=z['owner_replica'],z['child'],z['port'] + cap,allowed=windows[f'{rep},{child}'] + assert z['time'] in allowed and 0<=port<112 and 0<=z['helper']=0 and z['offset']+z['width']<=cap and not used[rep,child,port]&cells + used[rep,child,port]|=cells +assert set(helpers)==set(map(tuple,order)) and all(s==set(range(R)) for s in helpers.values()) +idle=collections.Counter() +for key,(cap,times) in windows.items(): + r,ch=map(int,key.split(',')) + for port in range(112): + c=used[r,ch,port];assert c==set(range(len(c))),'gap in pending prefix' + if cap-len(c):idle[cap-len(c)]+=1 +H=collections.Counter(idle) +for sr in order: + for r,n in paid[dispatch[tuple(sr)]].items():H[int(r)]+=n +assert 73*(896*Tnew)-sum(r*n for r,n in H.items())==320*Tnew,'rank-mass deficit' +roles.sort(key=lambda r:(r['time'],r['helper'])) +dump(P/'OWNERS.json.gz',roles);dump(P/'ORDER.json',order);dump(P/'DISPATCH.json',[[s,r,dispatch[s,r]] for s,r in order]);dump(P/'PROFILE.json',dict(sorted(H.items()))) +dump(P/'RESULT.json',dict(status='PASS_EXACT_BORROW_WORD_REPLICA_OWNER_FILL',roles=len(roles),helpers_per_call=R,dispatch=dict(collections.Counter(dispatch.values())),idle=dict(sorted(idle.items())),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.')) +print('PASS_OWNER_VERIFY',dict(idle),dict(sorted(H.items())),flush=True) diff --git a/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/parent-lift.py b/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/parent-lift.py new file mode 100644 index 0000000000..fc0375d424 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/parent-lift.py @@ -0,0 +1,96 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Construct a literal arbitrary-T source parent, PLAN and SPEC from exact owners. + +CLI: --package IMMUTABLE_SOURCE --owners RECONSTRUCTOR_OUTPUT --out FRESH_DIR. +Source lineage and arbitrary-group argument are in replica_parent.py / PARENT-LIFT.md. +This adapter mutates neither the source package nor owner input directory. +""" +import argparse, ast, collections, copy, importlib.util, json, sys +from pathlib import Path +sys.dont_write_bytecode=True +import replica_parent as P +assert __debug__, 'Assertions required' + +def main(): + ap=argparse.ArgumentParser(description=__doc__) + ap.add_argument('--package',type=Path,required=True);ap.add_argument('--owners',type=Path,required=True);ap.add_argument('--out',type=Path,required=True) + a=ap.parse_args();base=a.package.resolve();owners=a.owners.resolve();out=a.out.resolve() + P.require(not out.exists(),'fresh output required') + source_names=['inputs/PLAN.json','inputs/SPEC.json','inputs/GLOBAL-TEMPLATE.json.gz','new/BORROW-PROVIDERS.json','vendor/build_parent.py'] + input_names=['ORDER.json','OWNERS.json.gz','DISPATCH.json','PROFILE.json','RESULT.json'] + input_hash={str(base/n):P.sha(base/n)for n in source_names}|{str(owners/n):P.sha(owners/n)for n in input_names} + P.SOURCE=base/'inputs/GLOBAL-TEMPLATE.json.gz' + plan=P.read(base/'inputs/PLAN.json');spec=P.read(base/'inputs/SPEC.json');providers=P.read(base/'new/BORROW-PROVIDERS.json') + order=P.read(owners/'ORDER.json');dispatch_rows=P.read(owners/'DISPATCH.json');roles=P.read(owners/'OWNERS.json.gz');profile=P.read(owners/'PROFILE.json') + T=1+max(r for st,r in order);P.require(T>0,'positive T');P.require(len(order)==9*T,'complete new invocation count') + parent=P.build(T);geometry=P.check(parent,parent['replica_lift']['groups']) + sp=importlib.util.spec_from_file_location('retained_physical_source_windows',base/'vendor/build_parent.py');mod=importlib.util.module_from_spec(sp);sp.loader.exec_module(mod) + windows,schedule=mod.actual_windows(parent,order) + independent=P.expand_schedule(parent,order);P.require(schedule==independent,'independent literal source-event expansion') + dispatch={(s,r):pid for s,r,pid in dispatch_rows} + P.require(len(dispatch_rows)==len(order) and set(dispatch)==set(map(tuple,order)),'dispatch bijection') + P.require(set(dispatch.values())<=set(providers),'known provider') + for pid,d in providers.items(): + P.require(pid in plan['provider_registry'],'provider in retained registry') + plan['provider_registry'][pid].update(widths=d['widths'],actual_paid_profile={str(k):v for k,v in sorted({int(k):v for k,v in d['actual_paid_profile'].items()}.items())}) + widths={pid:d['widths']for pid,d in providers.items()};R=len(next(iter(widths.values()))) + P.require(all(len(w)==R for w in widths.values()),'same helper count') + pairs,sides=plan['pairs'],plan['sides'];helper_seen=collections.defaultdict(set);family_seen=collections.defaultdict(set);used=collections.defaultdict(set) + for z in roles: + tm=z['time'];P.require(0<=tmlen(cells):idle[cap-len(cells)]+=1 + paid=collections.Counter(idle) + for st,r in order:paid.update({int(k):v for k,v in providers[dispatch[st,r]]['actual_paid_profile'].items()}) + P.require(dict(paid)=={int(k):v for k,v in profile.items()},'entire actual paid profile') + P.require(73*896*T-sum(k*v for k,v in paid.items())==320*T,'full rank mass and deficit') + stage_template={c['stage']:c for c in plan['provider_calls']} + plan['provider_calls']=[];plan['per_call_widths']=[] + for tm,(st,r)in enumerate(order): + pid=dispatch[st,r];desc=plan['provider_registry'][pid];z=copy.deepcopy(stage_template[st]);orientation='forward'if st%2==0 else'backward' + P.require(z['orientation']==orientation,'source stage orientation') + z.update(replica=r,time=tm,provider=pid,local_program_sha256=desc['orientation_program_sha256'][orientation]);plan['provider_calls'].append(z) + plan['per_call_widths'].append(dict(stage=st,replica=r,time=tm,widths=desc['widths'])) + plan.update(T=T,live=896*T,deficit=320*T,order=order,windows=windows,profile=profile,assignment_sha256=P.sha(owners/'OWNERS.json.gz'),assignment_content_sha256=P.identity(roles),status=f'EXPLICIT_T{T}_STRICT_WINDOW_OWNER_FILL',mode=f'mixed-t{T}-exact-fill',solver_status='Literal fixed owner witness independently rechecked; no solver runs in adapter') + plan['replica_lift']=dict(replicas=T,parent_template_content_sha256=P.identity(parent),owners_file_sha256=P.sha(owners/'OWNERS.json.gz'),schedule_content_sha256=P.identity(schedule),source_replicas=37,groups=parent['replica_lift']['groups'],phase_recipe_unchanged=True) + # Discovery computes geometry/numerical expectations, but the descriptive + # reporting denominator is source metadata and must survive the reset. + preserved_expected={'gain_baseline_kappa':spec['expected']['gain_baseline_kappa']} + spec.update(name=f'mixed-t{T}-exact-fill',call_order=order,dispatch=dispatch_rows,providers={},expected=preserved_expected) + assembly_ast=ast.parse((base/'code/assemble.py').read_text(encoding='utf-8')) + read_expected={node.slice.value for node in ast.walk(assembly_ast) if isinstance(node,ast.Subscript) and isinstance(node.value,ast.Name) and node.value.id=='X' and isinstance(node.slice,ast.Constant) and isinstance(node.slice.value,str)} + discovery_computed={'complex_lower','conservative_complex_lower'} + P.require(read_expected-discovery_computed<=set(preserved_expected),'all noncomputed assembly X metadata retained') + # Fresh discovery/freezing and outer admission supply all expected values. + spec['geometry']=dict(replicas=T,stages=plan['L'],pairs=plan['K'],dimension=plan['M'],charged_prefix_bits=1<<(128+37+18+1330+1+4).bit_length(),parent_live=parent['live'],parent_physical=parent['physical'],parent_idle=geometry['parent_idle'],parent_helpers=504) + out.mkdir(parents=True) + for name,obj in [('GLOBAL-TEMPLATE.json.gz',parent),('OWNERS.json.gz',roles),('DISPATCH.json',dispatch_rows),('PROFILE.json',profile),('ORDER.json',order),('CONSTRUCTION.json',P.read(owners/'RESULT.json'))]:P.write_new(out/name,obj) + # Bind canonical output owner serialization while preserving exact role semantics. + output_owner=out/'OWNERS.json.gz' + P.require(P.read(output_owner)==roles,'serialized owner semantics') + # Canonical gzip may differ from emitter gzip. Bind the actual output file everywhere. + plan['assignment_sha256']=P.sha(output_owner);plan['replica_lift']['owners_file_sha256']=P.sha(output_owner) + P.write_new(out/'PLAN.json',plan) + spec['data']={'plan_sha256':P.sha(out/'PLAN.json'),'owners_sha256':P.sha(output_owner)} + P.write_new(out/'SPEC.json',spec) + receipt=dict(status='PASS_LITERAL_GENERAL_T_PARENT_PLAN_SPEC',geometry=spec['geometry'],groups=parent['replica_lift']['groups'],input_sha256=input_hash,template_content_sha256=P.identity(parent),new_sha256=P.sha(out/'GLOBAL-TEMPLATE.json.gz'),source_sha256=P.SOURCE_SHA,roles=len(roles),helpers_per_call=R,source_events_per_replica=30,global_tail=[30,31],schedule_content_sha256=P.identity(schedule),profile=dict(sorted(paid.items())),idle=dict(sorted(idle.items())),private_work_shared=514,source_programs_phase_recipes_unchanged=True,discovery_X_metadata=sorted(read_expected-discovery_computed),discovery_computed_X_keys=sorted(read_expected&discovery_computed),phase_scope='Reuses root fresh hash-bound native/phase admission; this adapter checks literal source geometry and complete paid owner profile.',scripts={Path(__file__).name:P.sha(__file__),Path(P.__file__).name:P.sha(P.__file__)}) + P.write_new(out/'PARENT-LIFT-RECEIPT.json',receipt) + for path,h in input_hash.items():P.require(P.sha(path)==h,'input unchanged after lift') + print('PASS_LITERAL_GENERAL_T_PARENT_PLAN_SPEC',json.dumps(spec['geometry'],sort_keys=True),flush=True) +if __name__=='__main__':main() diff --git a/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/rebind.py b/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/rebind.py new file mode 100644 index 0000000000..b0d04e911d --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/rebind.py @@ -0,0 +1,59 @@ +"""rebind.py: rebind PR1319's T74 data (PLAN/SPEC) to new native provider directories with UNCHANGED interfaces (ports, +centres, widths), for discovery -> unpin -> freeze -> strict replay. Updates only provider-derived fields: +provider_registry..{actual_paid_profile, artifact_semantic_sha256, artifact_sha256, orientation_program_sha256}, +provider_calls[*].local_program_sha256, PLAN.profile (recomputed from the dispatch and the new local paid profiles plus the +unchanged idle remainder), and SPEC.data.plan_sha256 / SPEC.expected.global_profile. +usage: rebind.py PR1319_PKG_DIR GAUGE44_LOCAL EXTRA_LOCAL OUT_DATA_DIR (also writes PROFILE.json with the new global profile)""" +import collections, gzip, hashlib, json, shutil, sys +from pathlib import Path +pkg, loc_g, loc_e, out = map(Path, sys.argv[1:5]); sys.path.insert(0, str(pkg / 'code')) +from generated_identity import artifact_identities +def rd(p): return json.loads(gzip.decompress(p.read_bytes()) if p.suffix == '.gz' else p.read_bytes()) +def sha(p): return hashlib.sha256(p.read_bytes()).hexdigest() +out.mkdir(parents=True, exist_ok=False) +for n in ['PLAN.json', 'PROFILE.json', 'OWNERS.json.gz', 'DISPATCH.json', 'CONSTRUCTION.json', 'GLOBAL-TEMPLATE.json.gz']: shutil.copy2(pkg / n, out / n) +plan = rd(pkg / 'PLAN.json'); spec = rd(pkg / 'new/SPEC.json'); old_profile = dict(plan['profile']) # SPEC base = the frozen outer-refinement new/SPEC.json (rebound fields only are rewritten) +locs = {'gauge44': loc_g, 'extra': loc_e}; counts = collections.Counter(c['provider'] for c in plan['provider_calls']); changes = {} +for pid, d in locs.items(): + desc = plan['provider_registry'][pid]; word = rd(d / 'CANONICAL-WORD.json.gz'); checks = rd(d / 'LOCAL-CHECKS.json') + assert word['ports'] == desc['ports'] and word['centers'] == desc['centers'], pid + widths = [len(word['frames'][word['final'][r]]) - len(word['frames'][word['start'][r]]) for r in range(2 * 112, 2 * 112 + word['R'])] + if widths != desc['widths']: # width-changing rebind (borrowed words): helper count/widths come from the native word + assert len(widths) == word['R'], pid + desc['widths'] = widths + for c in plan['per_call_widths']: + if plan['provider_calls'][c['time']]['provider'] == pid: c['widths'] = widths + new = dict(actual_paid_profile={str(k): v for k, v in sorted({int(k): v for k, v in checks['forward']['paid_profile'].items()}.items())}, + artifact_semantic_sha256=artifact_identities(d), + artifact_sha256={name: sha(d / name) for name in desc['artifact_sha256']}, + orientation_program_sha256={o: checks[o]['sha256'] for o in ('backward', 'forward')}) + changes[pid] = {k: (desc.get(k), v) for k, v in new.items() if desc.get(k) != v} + desc.update(new) + for c in plan['provider_calls']: + if c['provider'] == pid: c['local_program_sha256'] = checks[c['orientation']]['sha256'] +prof = collections.Counter() +for pid, n in counts.items(): + for r, v in plan['provider_registry'][pid]['actual_paid_profile'].items(): prof[int(r)] += n * v +idle = {int(r): v for r, v in rd(pkg / 'CONSTRUCTION.json')['idle'].items()} # exact idle ranks of the shipped owner fill +for r, v in idle.items(): prof[r] += v +new_profile = {str(k): v for k, v in sorted(prof.items())} +# sanity: the recomputation reproduces the OLD profile from the OLD local profiles +oldp = collections.Counter() +for pid, n in counts.items(): + for r, v in rd(pkg / 'PLAN.json')['provider_registry'][pid]['actual_paid_profile'].items(): oldp[int(r)] += n * v +for r, v in idle.items(): oldp[r] += v +assert {str(k): v for k, v in oldp.items()} == {k: v for k, v in old_profile.items()}, 'profile recomputation rule mismatch' +plan['profile'] = new_profile +(out / 'PROFILE.json').write_text(json.dumps(new_profile, separators=(',', ':')) + '\n') +(out / 'PLAN.json').write_text(json.dumps(plan, indent=2) + '\n') +spec['data']['plan_sha256'] = sha(out / 'PLAN.json'); spec['data']['owners_sha256'] = sha(pkg / 'OWNERS.json.gz'); spec['expected']['global_profile'] = new_profile +roles = rd(pkg / 'OWNERS.json.gz'); R = len(next(iter(plan['provider_registry'].values()))['widths']) +spec['expected'].update(idle_remainder_profile={str(k): v for k, v in sorted(idle.items())}, idle_remainders=sum(idle.values()), hosted_residuals=len(roles), + cross_replica_helper_roles=sum(z['replica'] != z['owner_replica'] for z in roles), physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values())) +for pid, desc in plan['provider_registry'].items(): spec['providers'].setdefault(pid, {})['inventory'] = {str(k): v for k, v in sorted(collections.Counter(desc['widths']).items())} +piv = {x['pivot'] for x in rd(pkg / spec['pivot_swap']['recipe'])['swaps']} # same expectation as code/witness.py spot_widths() +assert all(desc['widths'][h] == (9 if 2 * 112 + h in piv else 8) for desc in plan['provider_registry'].values() for h in spec['width_spot_helpers']), 'spot helper width pins' +(out / 'SPEC.json').write_text(json.dumps(spec, indent=2) + '\n') +json.dump(dict(provider_counts=counts, old_profile=old_profile, new_profile=new_profile, changed_fields={p: sorted(c) for p, c in changes.items()}, + new_paid={p: plan['provider_registry'][p]['actual_paid_profile'] for p in locs}), open(out / 'REBIND.json', 'w'), indent=1, sort_keys=True) +print('provider counts', dict(counts), '| new profile', new_profile, '| changed', {p: sorted(c) for p, c in changes.items()}) diff --git a/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/release.py b/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/release.py new file mode 100644 index 0000000000..19403b539c --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/stage-scripts/release.py @@ -0,0 +1,203 @@ +"""Release proof: PR1673 capped phase-cell fusion outer on this package's T74 supplier (PR1661 stack + pivot-554 kernel). + +Runs (1) the supplier's own unchanged verify.py (native replays reused from --native-cache when present), concurrently with +(2) outer/check_ledger.py + outer/independent_check.py (the 45-inequality ledger, 5 rejecting controls, endpoint rejection and the +independent balance derivation, regenerated in a temporary copy and compared byte-for-byte with the committed LEDGER.json / +INDEPENDENT.json) and outer/replay_evidence.py (PR1673's 19 supplier-independent exact evidence replays); +then binds the supplier's strict ASSEMBLY (complex endpoint, bit endpoint, profile) to the ledger inputs. +The receipt kappa is the ledger's kappa with the radix-distributed sparse-union schedule (new in pkg4, outer/UNION-SCHEDULE.md) and structured boundary solves (new in this package, outer/STRUCTURED-BOUNDARY.md: displacement-rank generator representations of the boundary blocks, O(r W log W) per right-hand-side column, tau_eff = 2 + 1e-64 in that earlier package; not used here); the unproven omega_C <= 9/4 premise is not used. +""" +import argparse, hashlib, json, os, shutil, subprocess, sys, tempfile, time +from fractions import Fraction +from pathlib import Path + +PACKAGE = Path(__file__).resolve().parent +os.environ['PYTHONINTMAXSTRDIGITS'] = '0' # the pinned endpoints, kappas and ledger values are decimal/rational strings of thousands of digits +sys.set_int_max_str_digits(0) + + +def digest(p): + return hashlib.sha256(p.read_bytes()).hexdigest() + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--main', type=Path, required=True) + ap.add_argument('--work', type=Path, required=True) + ap.add_argument('--native-cache', type=Path) + ap.add_argument('--jobs', type=int, default=4) + a = ap.parse_args() + if sys.flags.optimize: + raise SystemExit('Full proof requires assertions enabled') + work = a.work.resolve() + work.mkdir(parents=True, exist_ok=False) + msha = digest(PACKAGE / 'MANIFEST.json') + t = time.monotonic() + opts = ['--audit-shards', str(max(1, a.jobs))] + (['--native-cache', str(a.native_cache.resolve())] if a.native_cache else []) + reused = {} + if a.native_cache: + for key, name in (('base', 'gauge44-word'), ('extra', 'extra-word')): + entry = a.native_cache.resolve() / digest(PACKAGE / 'vendor/pr1297' / (name + '.json.gz')) + if (entry / 'CACHE.json').is_file() and (entry / 'local/FULL-WORD.json.gz').is_file() and (entry / 'STEPS.json').is_file(): + opts += ['--%s-native-from' % key, str(entry)] + reused[key] = entry.name + if len(reused) == 2: + opts += ['--parent-receipt-cache', str(a.native_cache.resolve() / '_receipts')] + # Stale-bytecode isolation (PR2788, jeremydiviney): no .pyc/__pycache__ may exist in the package, and every child interpreter uses a fresh pycache prefix. + sys.path.insert(0, str(PACKAGE / 'code')) + import pyc_guard + pyc_guard.guard(PACKAGE) + pyc_guard.selftest() + os.environ['PYTHONPYCACHEPREFIX'] = str(work / 'pycache-prefix') + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1') + outer_log = (work / 'outer.log').open('w', encoding='utf-8') + outer_proc = subprocess.Popen([sys.executable, '-B', str(PACKAGE / 'outer/run_outer.py'), str(work / 'outer-tmp')], + stdin=subprocess.DEVNULL, stdout=outer_log, stderr=subprocess.STDOUT, env=env) + with (work / 'verify.log').open('w', encoding='utf-8') as out: + r = subprocess.run([sys.executable, '-B', str(PACKAGE / 'verify.py'), '--work', str(work / 'verify')] + opts, + stdin=subprocess.DEVNULL, stdout=out, stderr=subprocess.STDOUT) + if outer_proc.wait(): + raise SystemExit('outer checks failed: ' + (work / 'outer.log').read_text(encoding='utf-8', errors='replace')[-1500:]) + if r.returncode: + lines = (work / 'verify.log').read_text(encoding='utf-8', errors='replace').strip().splitlines() + raise SystemExit(f'verify failed rc={r.returncode}: {lines[-1] if lines else ""}') + res = json.loads((work / 'verify/RESULT.json').read_text(encoding='utf-8')) + claim = json.loads((PACKAGE / 'CLAIM.json').read_text(encoding='utf-8')) + if not res['status'].startswith('PASS_'): + raise SystemExit('package verify status ' + res['status']) + if Fraction(res['kappa_decimal']) != Fraction(claim['kappa_decimal']): + raise SystemExit(f"verified kappa {res['kappa_decimal']} != CLAIM {claim['kappa_decimal']}") + # ---- bind the supplier admission to the outer ledger inputs + asm = json.loads((work / 'verify/strict/ASSEMBLY.json').read_text(encoding='utf-8')) + spec = json.loads((PACKAGE / 'new/SPEC.json').read_text(encoding='utf-8')) + ledger = json.loads((PACKAGE / 'outer/LEDGER.json').read_text(encoding='utf-8')) + bj = json.loads((PACKAGE / 'outer/B.json').read_text(encoding='utf-8')) + if asm['status'] != 'PASS_GAUGE44_NATIVE_EXACT_GLOBAL_ASSEMBLY' or len(asm['outer']) != 47: + raise SystemExit('supplier strict assembly did not pass') + if Fraction(asm['complex_lower']) != Fraction(spec['expected']['complex_lower']) or not Fraction(bj['b']) < Fraction(asm['complex_lower']) < Fraction(bj['b_above_endpoint']): + raise SystemExit('ledger endpoint b is not bracketed by the admitted supplier complex endpoint') + if {int(k): v for k, v in asm['complex_profile'].items()} != {int(k): v for k, v in bj['profile'].items()} or Fraction(asm['bit_lower']) != Fraction('0.001733427039589844234749'): + raise SystemExit('ledger profile / bit endpoint differ from the admitted supplier assembly') + kappa_decimal = ledger['rows']['struct_boundary_radix_union']['kappa']['decimal'] + if Fraction(kappa_decimal) != Fraction(ledger['rows']['struct_boundary_radix_union']['kappa']['rational']) or Fraction(kappa_decimal) != Fraction(json.loads((PACKAGE / 'outer/OUTER-CLAIM.json').read_text(encoding='utf-8'))['kappa']): + raise SystemExit('ledger kappa != OUTER-CLAIM') + if Fraction(kappa_decimal) <= Fraction('0.001677160151714381'): + raise SystemExit('ledger kappa does not exceed PR1673') + if Fraction(kappa_decimal) <= Fraction('0.001677641731343354564251058287063644749065568493'): + raise SystemExit('ledger kappa does not exceed PR1699') + if Fraction(kappa_decimal) <= Fraction('0.0016783441717365385237811729563143950958709031230206606381509868512618172844657807114390339553440364'): + raise SystemExit('ledger kappa does not exceed the previous package (structured boundary, linear guard)') + if Fraction(kappa_decimal) <= Fraction('0.0016797547881500489087805478664999999999999999999999999999999998000000199999'): + raise SystemExit('ledger kappa does not exceed PR1786') + if Fraction(kappa_decimal) <= Fraction('0.0016797549561255445213356709939207025769983114385025802954603275201627999999999999999999999999979966404900867489109573286580121585'): + raise SystemExit('ledger kappa does not exceed PR1828') + if Fraction(kappa_decimal) <= Fraction('0.0016797549561255445213356709939207025769983114385025802954603275201628645482603256388263049999999997996640490086748910957328658012158594'): + raise SystemExit('ledger kappa does not exceed PR1839') + if Fraction(kappa_decimal) <= Fraction('0.0016797549561255445213356709939207025769983114385025802954603275201628645482603256388263056561328446322744513169085862209720704481201654121427713006366929567157349625273906229277148454180995537563371124755588139767841405530386745578819565618798006892541712197674874836946756930569827889227573192555649999999997996640490086748910957328658012158594'): + raise SystemExit('ledger kappa does not exceed PR1875') + if Fraction(kappa_decimal) <= Fraction('0.001679754956125544521335670993920702576998311438502580295460327520162864548260325638826305656132844632274451316908586220972070448120165412142771300636692956715734962527390622927714845418099553756337112475558813976784140553038674557881956561879800689254171219767487483694675693056982788922757319255565606685566411725238449650999339827075715283714270157705762309226038611771955655377501414652136546310799999999999999999997996640490086748910957328658012158594846'): + raise SystemExit('ledger kappa does not exceed PR1876') + if Fraction(kappa_decimal) <= Fraction('0.001679754956125544521335670993920702576998311438502580295460327520162864548260325638826305656132844632274451316908586220972070448120165412142771300636692956715734962527390622927714845418099553756337112475558813976784140553038674557881956561879800689254171219767487483694675693056982788922757319255565606685566411725238449650999339827075715283714270157705762309226038611771955655377501414652136546310881185746917580802513640545967852810801680966856133978576162943792322682482152988532923811998938861379689883167389728443314312230815059559906903773756886872476136837071871203030423643505345473735135533'): + raise SystemExit('ledger kappa does not exceed PR1897') + if Fraction(kappa_decimal) <= Fraction('0.001679745508802299051546533685199973672313473419790800679752457380932784242972585600630181672224983'): + raise SystemExit('ledger kappa does not exceed the previous package (gauge-free interiors, PR1758)') + if Fraction(kappa_decimal) <= Fraction('0.0016781238306335473083421558390362687182218966358657650331660405387910568682486186577879457360762643'): + raise SystemExit('ledger kappa does not exceed the previous package (rectangular k=5)') + if Fraction(kappa_decimal) <= Fraction('0.001677992607205282520732088774830808372222877897034109604209719298829805473412451530867883424937597'): + raise SystemExit('ledger kappa does not exceed the previous package (rectangular k=2)') + if Fraction(kappa_decimal) <= Fraction('0.0016778199023144364336310551358776001013829401215770658599799349282716974076737897457922714197448847'): + raise SystemExit('ledger kappa does not exceed the previous package (square boundary tau=2.372864)') + if Fraction(kappa_decimal) <= Fraction('0.0016776417313433545642517275958639984231708545722735432722117400060454625429077941422798526440584702'): + raise SystemExit('ledger kappa does not exceed the previous package (old union row)') + # PR2269 (this package's own 90-digit-endpoint predecessor): exact outer kappa + if Fraction(kappa_decimal) <= Fraction('0.0016962471390584742207696225394800943861284603706821716607210815258272261945561178592716719999999997996607505720883051558460754921039811'): + raise SystemExit('ledger kappa does not exceed PR2269') + # PR2265: its published 43-digit kappa + if Fraction(kappa_decimal) <= Fraction('0.0016834125885426074623303197403999369605037'): + raise SystemExit('ledger kappa does not exceed PR2265') + # the previous 1e-3000 fixed-grid-maximum package without the frame refit + if Fraction(kappa_decimal) <= Fraction('0.0016962471390584742207696225394800943861284603706821716607210815258272261945561178592716725376787146850319387830720495673160906619586385985253004200974538949035715460651846040948044242351804037917972203668759131442974306926788095523055348682603080830926543046109524019284266202449358819248039824128659652256009597225750921338791772522346327260842638280758491285261012177101751247814588199922615754428296427117543521452060897258700168878706575252152477061988688277049228862038051831802155042557172623266376692067754074066018861739445031053058532975745010650260626662153102779311231323276136828410015626012654950781671416272174286060026260461657234237896123847927833525865765270919579650629143257756554312491072906153370276441896408260328764564124330642285119147808930086141569295621851854218252564733837316294676373092948766021104018820867623171046683661092297248291577095250274060655173297958878033621645679452722665435213096247941313869533587196421382302143322934628990123191000788388609573672644835019755994246318060035281060223322645388928947169626138581457300875151159820924963147410503862327253442337658663568159699004958107894981576832335403664692406006933059590031689949815905089106171767594599700984735621368930563780702038882727505392721719386114334646038558353670081177427424360521812807826505397161210251724237709062744724805616548559632816270489581394531990712494078787486793971491473790864233960278289765655920963414849196322659136809511659945219008433168014265025447420166561704034530316921458618874915620099025502502618035097461895895223764605753492664274479247941026938492542179778796317704962018292021909919861292918602366755911657954379368017800183443534262330089328250652960096418423703035464940084343778512813829329581029347226356616738501436617600538369671094908540693286250261760877248005905559065855049093770979808303937056962048941085753495270703319891930887209058318724823718437728926974429367073432624131997567987115993164528269149849858078521203142762866174513268973487116932558183863464998283664642818679918224691979365372184748788493010550047368581279373073912036778334443492857927577286206252250817438195734298252518895370754124356495069959100552751704357607410115438146261739773032451457910141843649185347442684032256783823682283095281962476486777479624246578178585460914644633119591516245821764820377869654594359836428035991519960602392276985209925181526794428648224235182876264483709972370910406024724235806573365230168960701547640481777654852632561016384940077669718531691663918817962517445077811778410121692781099290921788135421040816814884933097268321380716162541362023853790195929790454122099814729604396862433157569138302781321102658775072569805525878616035680869031990224830742282562628026822259745461025473632267405693042132745262647696903701549047243949928334048586480294363233950866830966312211937319379776455575978516623582930772197819418024026409253019530180915180162077226543806380451730024060862435857727097812643685954248405246979875007274554000293999879999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed the previous package without the frame refit') + # the frame-refit package (PR2288) without the pivot-518 and 506 kernel(s) + if Fraction(kappa_decimal) <= Fraction('0.0016963109504150503355459722948928372280921721968724561762220421147644145761482885984967571578775454795315558417113412813231694622783490900348662681729592231903560853351255426786420763663178655003281505857286229869637466044243361588921779343716397967014438707898921127328975611256954437224641356898964339750713275612215896309041743033060768412139515368921536567057807207970466805003234862027817806690888390640784312394449662495210379111189000631731969913840405376781346897986214021741117422083725271871234401300183440304871341727820180574990353647279025142496867177789206624424997571530449519473352459498702658190828360923979498460128294798369917738404595397076263670723799359146613908833280073309651683729500428984791690934381229160893705326133037686127780198339018446754315723841737409963499522556148454109950498516960459062732145158464860520078222748772968666075308688060102095614219976567632142437588956251046223730866088862642016182480104196556736296484779283894121049643477734969019861544809837984636249407062760727016150066849286523322382074826026591803191556133160894153871744448522032246500691186272893727169459533826781329045410280180988227028953413948959627749435199294031602259974218679241756389094310293571776392665275440060128416069298336060934137683594749721875539100961984531705428740926745070478347051156564464735857576131568055392439349070688880983269683785203701743772494006377580873498989793098269416860245163673122355107078009192943296623200063923837978979726391155585227314506166287746919098802987376988749553428565117960680127117162859295585227836619358244831230559141562987941014958985682702824249440221289383909203561727045338247733043391763320670727494268068194378574627275095092953256732444212010516159194168180734821980726368427670070083408548719514533875518211958369469443610189017971552955689302325989684135168369391344574216178885288117746332765863840834323243319512183818941784295388396142410597918436552038064272557102280593496223131576927738593912346466653541945307822699814228743982825778594943895299684477718445989153104502257728995186791911138506213294032637402557360080474323425209358316182406158317687799224345569293433266156429509667100484719547899661170517984309861756776927699226774589333862417619615368800621280904731717007166601114931265538945746290456987826198646807505442125838746726438952084536942026710073899593382686159240597649780928138606355205051150505411617909421597379489564148134928926452171026914761461651993691541524538533834516264821822447885276530775319313163077520187620131998416989866100917322207904174653603539624514404731819512306251114049648504295075390277206769978284985627399920781440314570024036501328001706131508141398741768215146098232034243920786833682457710615638883903735636031855214906341242985023985190321962818946356673366984195534290058577773793515114601500926048296812708989110472867763853176364841468154926700424141264878832861923854082418142072303154196136904410704478768982906491915123250789901966397050583475894251697949999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed PR2288') + # PR2309 (Dugongue), the leader when this package was produced: exact outer kappa from its OUTER-CLAIM.json + if Fraction(kappa_decimal) <= Fraction('0.00169651512427273361603599999999979966069697504545327679280000000004'): + raise SystemExit('ledger kappa does not exceed PR2309') + # the previous package of this series (PR2302: same borrowed words without the width exchange) + if Fraction(kappa_decimal) <= Fraction('0.0016963957667360813401512017553615279117657068999363362106179646359054125313327703641011221779442459539871339461089219553691969977981401822760624794359560302229082314375995113942636590530620500782018194470671677119219839790494868307385847339452290887998700500411938799170674858093003286928048347274196039389000026290158196870872057257166500256835682013163283959997146169413950711966027087759767643419344712853576886783980615153279853404871016920071981553436279223622600525528471894700346011238233160868742145859860232058840791090764650133979481731323862930667518610044720573929298900532647950009058229587419786329958635690641780883137293844634272967192129687625408058060979531066936687993586039456039983556398478876965232482500625906736777109730724363281837955848614134083855809276505907144514733003845909331244045116980160376226985173142007628755093785143804942105479013303454321654201006831063585897430195472621578837899364607899809076894338902922137189579253839575904800502610823779130735405603222473104747840629391300795787215163295589140558844477425029302996689344654557359518706574870692938432544394742080506599997481540301232455817253619818598089752894860335888890891880609355298270585656725967316985275280947993338075572101492385630908482865327189235020782479107222108858033635848484476216327745019864086458153496328944574382125376897016725855331581938687114469271253756940030142844034371034587111817349355531104318277478257775334736701581945229498694136616722992028634631701247483684781250376596144385321278165606853375118819053849117338897262268427648262083455985839725633062313154695107759038550706454041941335604443412998733314092411840156288419954892739877843363834586046209819538672727213101410080383088045149018402130819728297511733105868594243532422336753902918788806466274681744246646231919140342567931214862038137091588934018251621114223684759626831339521740017781252613474170420781940878405217534505039416191481935402640036986540158535291068418753431261769460339726043941330310230377899497156447379116998376192778609260328368073641708331187025338628941230659019886492604497357183156893789943392609707575190186729444486788239744694366996859954082129202977358652316001835628949595287583151561304797052473367226958069794800493678276862560358912337464359182323531306401167100839378883760333513912116046596297577086537173884239225402145910324209403865332661419916572372514397914176245034825502665354589686225181030312038801291955465396008078308395064856427920952835111772605746736316974495455631547761742048841271657420320301289128193817983624681549963224888472167699611833879336569131555833595853052201499353493629265799166715221065545501398338697081697219199223693278872441290995511120223269123632695643837629348428447025464796370314880913595117416482942440311412104992815244674930680260974933325676734432766624185506445208555388434881647973303483680217436986110622497014745484207497834185076498923378325028164419862694022665993974610131397860814963409376069481211236799567291945371869999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed the previous package without the width exchange') + # PR2530 (zxv): exact kappa from its CLAIM.json kappa_decimal + if Fraction(kappa_decimal) <= Fraction('0.0017137379215475043467519999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed PR2530') + # our previous package (PR2530 words with the evacuated fill, no swap): exact kappa + if Fraction(kappa_decimal) <= Fraction('0.0017138793200090178277393159658224882741850018276313377388777989344499779848036755735428839404883345081602076596915372935445163549257843677134573070543785050332601116981993891257639919589050864224223081575002103470378121326336831573484387001971572673042430972264354343382445827018882480440150722134038654543514447040832086957753875948539795365986241603529249689022001469858539534077287984416852359032562142401296793489217750140041453361184825029008761489635682924036629010469046401692181463930065388198942359871821152988851590217230520445064090958372121169090974065699524460063735965152873157133691147904439546166602128335035227799311591048209869927896976392833606241651343837175036609754247898480938989923023026340729844763056096052891175627877787262609452046399579466119092866313036535335682776806467648155922323786896091802483647985050566213804836809233317388799083677377866787383160162429778257908983024618109489694227409456421456553821912409696075009897306969145639343554354294862224440345868807439480436522182454940263568552784110654861453895664733986933358400123432858311482018590531702871810773114656503043158537780455279474868026048789004691174934486731419756746078311076528526320047247891238854597833295812499048350762168712006615674155474538738266039000865183914404795542264510066849653250910062386485914981385408502826475933413003183371865127611213925081091620176820895595774203463534988723189732383296420699228344003259363802319950945737703013570881767452324590219600387226386787048764627579542456462764844609489763920522188359153280015992268875949796304927401654770271220367238478108613075320623080494495855320771028930323871101017186861279132677049043646070329989481696629395030949354561093038394667780737914876393297052666585239534669737633956610661828075015769008377319021277895520032135021829427065947060170567563924839546050173598426499186711026203297983373628996988586527888359978799700950685830527637466469741991953945143829950743519568663923237325147079615749220203441333884492689989831739159556848913207186854641193990869836716532585341620797475557979337046510007188184034485707803071651275961652448954489297978320254470661983316896742078889495926093977121191215505667552123475407376054942432134130965183580749237595795249612033007995019964320077937956267567317383001969322296889609589300659039114771172708530832143967950515442779669349644619739545138073128324507431264059303279325718069826798637589643803270292223723298849691999630063205858147500767567267152827749768037494607466986996767341068595192611238975735415563540363309761253620740101360043545213109647086260932301614471027335524945466703881224630958399194747296073610167994149180303313893618957485405280582230721498163633952081089076890135405434297265673746101998657294284004782174978381087995631064709016813402351965928946324429653664710622253413105177832288302918850616410129494149251215937071973528625923760868330603512797460185151283124933050024548482871563020543139117414365613534429413233278250150299395695308669999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed the previous package (no swap)') + # PR2571 (rohanarun): exact kappa_decimal from its research/source-partner-repack/CLAIM.json + if Fraction(kappa_decimal) <= Fraction('0.0017137844912361143131449999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed PR2571') + # PR2436 (tekuuu): exact kappa + if Fraction(kappa_decimal) <= Fraction('0.001699160892139825160028'): + raise SystemExit('ledger kappa does not exceed PR2436') + # PR2435 (our previous package): exact kappa + if Fraction(kappa_decimal) <= Fraction('0.0016985113436976293290517338141877446308055110967045933112789142962230829468162898341951791806612097103089373234971683843352747786930041151727362819565230218349121075974166971824969591011217978263772357971645637990906671947907264145608572312831884027994294129916401260085150019209771313354764916248453595083165495324143523894449450691307086112491644144865158608055855884464187565801019555715970196050475190435909515154211111746650599567224499059795061082684332558375704345494867609328212726505329205932635761431749934820741127389044354860113766948092316247723704125119645275990197876854879992017397555143192287544724913630217464784503656948990786068598407873145289054550742625443908707733418270092545559085087575922813686919128943056715534713410017028659255187727620917187403119881890253391323975990386407713427526885644658486243444047073202627454384564726751561652433479720829616046376359016291378111084223539218953623912571977915965711868344311448096041639498896249066806011480337926979336386922535296303752711889978569232419801794934322834391758343224495751526935421536033765421920712479882326684183343175192506299338548272335365486251925033343467210567293885905433780822999898604806238618868381030618734960564543625151176983437948634467084422228827374831795369936288472513373544493094900054747070753455699633326414320913460348479500983823174310013199097862135411812726539849723398231855832967776337718672217880238071981788235029509052279747189188681017572483164064571080246530954181586740864619167589362678617045511756037366397896287535580824234872210152899236988326941025506999808922548377766309470729712387648163405540888355093150391393147762868679282467450248868441271263534493578828020033697285447763448133926166569487422405222986476700516751666801177807240657564339291923875269516741832922888995392021815208206000349549288250522070993210698907902608614026748746226358646184865889780191165888384651919903384475762221811266201306458084323514041511509641989786115752760407119009860442439632421403230395972475348378156789079511896489813648834249547691849265251849667444226323872984574855719511144598417008957627888727054559888291831917098918028329850588422718093434809471730512569958638862082155535047678827813738782160371366678147328051204025977598523823201157893310362964269992621082595013887883317116160638083051854550265075133554450400672096216801889893843542349827136660836690734577713840538485494706157608832285361332402523141110775007848457158586364555932568759681602669482751949814440768908964969207479429539605772323917098643373158579016561519795798882730005614360958024497845667634552553552983588304002856198810822137614346744361151657633282342263919735927514970826742259413534781096542529517187951831272379701715213763298528196318890985268220654521387901862300533678359917037097369847001136323652610917811136723698294245291973870628779153244079459318485933533570876673919779617623307381536963771175021281784418966086504076951993546379032710653964402197313385999437909265508362772441799999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed PR2435') + # PR2374 (our previous package): exact kappa + if Fraction(kappa_decimal) <= Fraction('0.0016971949509017704265940818773095411997829254474375229705809997635438062942204765954562383974077821671831369565342135210662806080984189437744311691170166878200706637656120224415299737717701337307539464110268836203281111987753159498203954701705205852698182995035958027658044607115822574508666985181699711923175134847560718669920281030992600965545441954035328408493723703194682661214225479411060097662633754661550995525106462258180812881394912204830656550720788554855150041136725936752258040654282493873524814048951275613529361946942930756606941674074477881485086387253593916040344556969145236818327248309098647296974311830069674219033678569504586581135358848081070141238752991674150396577553602390245098256623610206219873018910702970683481898704791312128544927797796263798965928185946464208453538038074130191248384897942236565804073051820886237792115045300205866675310844866731650898744658240052151403474629612369248407339925817250755774230849162429893816537967019801563891871154347775301101452039034203590012030571830828102063480584807251100111533885801953898940545829732671930912393072557857172603412452229175719796953206694288737814097206799032728139418329449617047277996553941167768501692770450270903073953001977679531560526318261641545560089674289210949739800895987320710205405144779108114410801410863004777930712359085672774857562943038447218083992439662882844810916772482599422378373397511127617771820574570321893388248531869294501515231655597646378900151261952601403678797872447106754637862547429677096069631147251860052756420659326128494026586838106695013238864030608401406156607559989211808454412638637175211030555454020488650023294167520672980980396370514923547443975614840890626840642981934129785156305249800680496635934963165026962087272991982852425076410102938295280642112519009725151518793502417899440161288959425552435156339988887994241563680501591034798080807680420907177078719219475936443453591733013776785983706296335551856437598080747432920929336409488151175919768679340727810125057537659035408133643666970582481765189938136267947101008867469846414911701653627941553461882443557617407944704412052768481182211920226323727462445103056307935153715081554046115943894672966439801441223675986168815297036589266986545180924888304377614106150893981516595103244696808698485755403663575692962132048959618919396672463657258697165154476184606747977244468238112487890243300215295911516769877096033023277755679579119616362363771146906851312883551325577910752948791145027867851031285296278290624616792326245346316955108929449453650392187829083153563766593182662271262370655984316122305681275693367071550045835867673591141005622801963302635483892372821569656326071183032535073704098039743172546777387752768217496897183134894138727088377616522650102507208838965437331059647644187138589104298496147389776807118532428525203523839384398259710922706840602678791436521874179119410390463568320091540786380546514858693482059552649347514416855482639636114585292794893763151788378014165475136659461413021709999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed PR2374') + # PR2363 (mason-hale): exact claimed kappa + if Fraction(kappa_decimal) <= Fraction('0.001697147064845350'): + raise SystemExit('ledger kappa does not exceed PR2363') + # PR2322 (Vlado Vojdanovski): stated kappa 0.001697060296258836 (1697060296258836/10^18) and the upper bracket of its native endpoint + if Fraction(kappa_decimal) <= Fraction('0.0016970602962588368950279736213908681183'): + raise SystemExit('ledger kappa does not exceed PR2322') + # PR2588: exact kappa + if Fraction(kappa_decimal) <= Fraction('0.0017142520392602451425351562259099656664344954373283308057225381981747562918061584999947561271124347686149558922108259494962534008930178575454133344862965601444172448331817152909766535112350708396928034441496871589713722575642506593412194794093575215326475625862439862175485535192485846059948632157105700869610795316500696247041824549885043526850412669441427740223730510517106191036541515810277226760681285811597004525917025031294007539732680314931686823171332211823282945239145205539721434651612050340581904232072561787095451293647899747540565463039808817184375271124592995766320237487820150010351277952099669162323267814619484819200315019911819091959999102657515505743819070010860672786565869109554832488031261334627499859493067849719077384885683033508260673984426700487660141214070225024894125232965845799661985539549847752461342172075646358338997453999288053000870497362760554381696697559133522856331801156646764525400539905340083758377929219827625380610057781487820821153448475385456799775382491514332736278655517522245329247263904596950776220980841805647952361535073719003157669640166693563466336815584519569810166511233264775205298632073076591451322372399999932369033904582035223410891524967205366234071383787219133164546315393239183818212307692995348435520398110005153430241887453343698646683271418734060091347040390456896142756143404386772216380704460366762755346337789906988466769974334711756339583937072621281296515518137951279458035968043755162367096330489177199370336093741395702690118092853200339791089791539032324817414888688781047182611324584582279916507607603683633460063962260109142936483039472011289743848580404445260351106444824458226423661897715297239393027939493242320955426198133601143645144070064073639933353974680604733068250031880911548549706199846207296069928696737309533371014168058754951811832295923513035374099881688243096526277292236890002388720709719158033023774073285846627771534726540103118668507295515605586205236016558176536393654414873191837922077367280957373153021556794154858562911961622539935196645728280666794496793070971823976465041173986748576532128413546720628060291475675470318602031900109561615265527973645747625798002311701903276616609332536708138849321371734306833508405333500117302670393361198251737269272732630795992200554211220244271419343563457390640311082668614170624080072295459234096049682185671202285453274140611688611730629671522699192434380356216674162550908702958080720859592831370976796243013789725750621736728357882717905941026190676496976765717982858759328564664729815198515864807758674700087456768561551484526092627733646122071138836057111007614820893117430832928217406368343840328483713773591907538062309195075401781133054022005465946906253474970706352348849924590842041842207238838697575396324108643421972631975393020597662234530109461046990303616133913438500827840442653674795648233352671879634300064195664716077491094816328554594096949401066084188934653885251272157233742246081515816462277045893076727873354607812239505000220820255049999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed PR2588') + # PR2575: exact kappa + if Fraction(kappa_decimal) <= Fraction('0.0017138793200090178277393159658224882741850018276313377388777989344499779848036755735428839404883345081602076596915372935445163549257843677134573070543785050332601116981993891257639919589050864224223081575002103470378121326336831573484387001971572673042430972264354343382445827018882480440150722134038654543514447040832086957753875948539795365986241603529249689022001469858539534077287984416852359032562142401296793489217750140041453361184825029008761489635682924036629010469046401692181463930065388198942359871821152988851590217230520445064090958372121169090974065699524460063735965152873157133691147904439546166602128335035227799311591048209869927896976392833606241651343837175036609754247898480938989923023026340729844763056096052891175627877787262609452046399579466119092866313036535335682776806467648155922323786896091802483647985050566213804836809233317388799083677377866787383160162429778257908983024618109489694227409456421456553821912409696075009897306969145639343554354294862224440345868807439480436522182454940263568552784110654861453895664733986933358400123432858311482018590531702871810773114656503043158537780455279474868026048789004691174934486731419756746078311076528526320047247891238854597833295812499048350762168712006615674155474538738266039000865183914404795542264510066849653250910062386485914981385408502826475933413003183371865127611213925081091620176820895595774203463534988723189732383296420699228344003259363802319950945737703013570881767452324590219600387226386787048764627579542456462764844609489763920522188359153280015992268875949796304927401654770271220367238478108613075320623080494495855320771028930323871101017186861279132677049043646070329989481696629395030949354561093038394667780737914876393297052666585239534669737633956610661828075015769008377319021277895520032135021829427065947060170567563924839546050173598426499186711026203297983373628996988586527888359978799700950685830527637466469741991953945143829950743519568663923237325147079615749220203441333884492689989831739159556848913207186854641193990869836716532585341620797475557979337046510007188184034485707803071651275961652448954489297978320254470661983316896742078889495926093977121191215505667552123475407376054942432134130965183580749237595795249612033007995019964320077937956267567317383001969322296889609589300659039114771172708530832143967950515442779669349644619739545138073128324507431264059303279325718069826798637589643803270292223723298849691999630063205858147500767567267152827749768037494607466986996767341068595192611238975735415563540363309761253620740101360043545213109647086260932301614471027335524945466703881224630958399194747296073610167994149180303313893618957485405280582230721498163633952081089076890135405434297265673746101998657294284004782174978381087995631064709016813402351965928946324429653664710622253413105177832288302918850616410129494149251215937071973528625923760868330603512797460185151283124933050024548482871563020543139117414365613534429413233278250150299395695308669999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed PR2575') + # PR2751: exact kappa_decimal from its claim + if Fraction(kappa_decimal) <= Fraction('0.0017171415863484263381089999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed PR2751') + # PR2766: exact kappa_decimal from its claim + if Fraction(kappa_decimal) <= Fraction('0.0017172569734670023082699999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed PR2766') + # PR2767: exact kappa_decimal from its claim + if Fraction(kappa_decimal) <= Fraction('0.0017172569734670023082709447969069152126118769780965028281008777096022519916744024507755781541393565107541777345616367652506197068005633337706659261256966375316821124413350346601705176280553912235149970753181426298001293678362122690855686275720239412792316093597276141944155457489339446224311536862711549926054504931270560356314999015644110485022254405640527426463064952462185589768355732358008424134781124147412002557999341130922954560743011637806547436549181955782473753496979703362588896807515818466546937711049279980942794048991491326287505803399514341852820837943067785939680385921588672688420201433278727269345703864690376991542653902864701881652568311532870078191785893592410790571289085509481502003170258982906991486560315611931860697467696290292055253082068400551006212099824229936930413663128901131121759917302246165771388714185911541104549988804338712295071202096399100335791126922173037775327463059771433440926266880163896249389966745756271553563709591781001439768394342152913377499665536820868707787226505884376108228421715755450623096661691184454221995927505823408578749208545463740410015863275806178269842001719301762674785169518465683571440572993799589490631487105886295095493149586094319859314875095378861401422556789940186941047005736880403188010645106677026296918442629431903843644855362525736842630354486796094857852734997386028457768569824115555112581868166739336167277381787859006062432028767244521059628397246359398320786429319939420672411083838467729316208932075333803830898035322664949004091568509869438186415465161733566756555736356233923851918780823353640473134174987172652099048421354257100239255942629158502164301318171598492065833037847549681946684768605491450323194076412999983215955509460578326463064191168457600338240713840193411472575547950797115245206022145794895788468041089449169787357317266308048623204566140235628233017090878916323527128156264726328354041412616033952419944700431126936863322584716859502347695311920748466005526768515925854102406706307520896865670601578650767111842955685088409462542848610347972939615154323284480230135034841876444061631325858729157683020840589884429004551623552818746676680914576485067803186939296066606405395766033283905684054983159064863223300983125666776604195695852034071159764621179219686754472092896427897404874394357914200560727383691925322278679456774883229095577135736844500900384756502718708923562610023580899942766723533449198010932258174758894762374984951419979309148647906675840732792544402297243181446952503231023897790927353688424025440209475595384587082902426402767980019136142593982138839226181846487690619361976037727824614860473865262796331567734540250992369604076843182445798287538318092729802017130103545991079143478304625081199840311512857747798081094366427632011938791580334466991754850298586038018016640436196908298039209188887977906075656186932051633274060946735331678245512576959516444591775914847982031747835727960828045213036341689251316473265483110696205040246018249882524641792097396874190897482609999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed PR2767') + # PR2802: exact kappa_decimal from its claim + if Fraction(kappa_decimal) <= Fraction('0.0017177949841186346638269999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed PR2802') + # PR2818: exact kappa_decimal from its claim + if Fraction(kappa_decimal) <= Fraction('0.0017177949841186346638272299184281789040885843854623122009009272567619811451693128959233927619586069928722704582863584186086707310535394138626926710629820889033848049602292064935012319711733257433358230465812920895415475031660711346220961679911613825710704958000867504103971494992119087046562042876559213675515203237127088112088427885595141419686934510191208342840674573423182801330783403919437936058720919920108906265959816656455048496316720030774333519468932548694829399230373287537901102420346759524477101633385635510471780962236695200107186884715759473934852366750305844187213730888432237688884656783638517088815127041335422566053263046139117681735490283197323428036941873466898492867640174140203754253880380259133474587978567954061014535280911008076768807932789614315183546684808185874225108148730976091221047166772451654879788745793565162071625194022849877585436190136375921694139193740542335276060128357375558021449083900197016043788433227393073509549863324724556568148945510979578864605531361362729378133297430330915121749734288536944575539972520172159321070805847754311668480251773562441089008186316121880554425502110019758570839986239397554065839346381095524688851679911464103650074950984202579105230295548942225016711755740249390145623141818375010326796806534460989476041815626555830186783586397114318234459795840553998725845598598978382204059158067583964913964319658478679381552684575892831928104465845573357348966658397831187818481438394060569135266969917549451866054730281756994407408227206605351959243923844123308865651371682863192475317598176868811945604104660414533095486319889696688286612291332068492568471207782946972113284118690391186110032262967227248040037701209405392407896239329317407783117646126175897625603072767796314981489983368571140491137098030268691445121838711653887757337262240831742275738818465378080971065296829519361544581075154111402963174974941320886809257462198157026865873404637363591400136805811943866860507723438884239219572763817004492760951420675536206600179461818149841610014254585066042148880756169807599598879187009536438634900647877351551166768977025347563607013874015470790684615655514936424824255857694225231305352973328782500843387842037123324908784232857216083686795953816640969656805552868895140417028319084583621515426004154642617336021199242329428213161651612282007325789961367126884210336939174936137086973193085518026673436544345546381318884153511592449392486335079136623514220762610196754287420133726755777914823957170518604805139157563099172723331320942628842675870487772293883797094764987398989876042310158848431983084786115690815673186904154155972472570165803789288603236223277216867991331902648275745106999611914327707526655658766726312099222797771523435376183565614807764068904026405037419957025998847632186742539714637437306587086296371308889655921863155787187634483878254934950732428117907330107260791871692212963442401733062211167387870358203867505050996702552158757356247175280572779093767235204928189098610970605273560236102506430609999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed PR2818') + # PR2824: exact kappa_decimal from its claim + if Fraction(kappa_decimal) <= Fraction('0.0017177951600320121074069999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed PR2824') + # PR2696: exact kappa_decimal from its claim + if Fraction(kappa_decimal) <= Fraction('0.001715599770234969498857'): + raise SystemExit('ledger kappa does not exceed PR2696') + # PR2733: exact kappa_decimal from its claim + if Fraction(kappa_decimal) <= Fraction('0.0017161404259974415161889999999999999999999998999999999999999999999999'): + raise SystemExit('ledger kappa does not exceed PR2733') + _c = Fraction(spec['expected']['complex_lower']) + if Fraction(kappa_decimal) != _c - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22)): + raise SystemExit('ledger kappa is not the fixed-grid maximum C - 1/F - B') + if digest(PACKAGE / 'MANIFEST.json') != msha: + raise SystemExit('Package manifest changed during verification') + proof = ("Supplier: the package's own unchanged `verify.py` (retained PR1297 provider and parent admission, owner reconstruction, " + "parent lift, strict T74 admission, geometry controls): " + f"`{res['status']}`, native reuse {reused or 'none (fresh replays)'}; its complex endpoint " + f"{asm['complex_lower'][:30]}... brackets the ledger's b = {bj['b']}. 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. " + f"Conditional kappa {kappa_decimal} (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-{spec['outer_refinement']['endpoint_digits']+80}, 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 {spec['outer_refinement']['endpoint_digits']}-digit rejection call).") + (work / 'RELEASE-RECEIPT.json').write_text(json.dumps(dict( + status='PASS_RELEASE', kappa_decimal=kappa_decimal, manifest_sha256=msha, proof=proof, + seconds=round(time.monotonic() - t, 2)), indent=2) + '\n', encoding='utf-8') + print('PASS_RELEASE', kappa_decimal, flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/admission.log b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/admission.log new file mode 100644 index 0000000000..050ce02918 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/admission.log @@ -0,0 +1 @@ +PASS_EXACT_MIXED_048_ALLCOLD_NATIVE_ASSEMBLY_ADMISSION_NEGATIVE_CONTROLS 139 diff --git a/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/assembly.log b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/assembly.log new file mode 100644 index 0000000000..e9602b3333 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/assembly.log @@ -0,0 +1 @@ +PASS_GAUGE44_NATIVE_EXACT_GLOBAL_ASSEMBLY 0.001727405299371541 diff --git a/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/audit.log b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/audit.log new file mode 100644 index 0000000000..dcdb880deb --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/audit.log @@ -0,0 +1,104 @@ +{ + "status": "PASS_INDEPENDENT_ASYNC_WHOLE_OWNER_CONTROLLER_PHASES_AND_SPECTATORS", + "template_sha256": "6182ee1ccf2232c9cb4cad3a5b101a576de02c7e8d68289f166d786d962c8cc5", + "complex_template_sha256": "6182ee1ccf2232c9cb4cad3a5b101a576de02c7e8d68289f166d786d962c8cc5", + "complex_live": 474880, + "complex_profile": { + "1": 11747920, + "2": 3453480, + "3": 1112042, + "4": 486540, + "5": 103690, + "8": 38160, + "48": 202828 + }, + "complex_hosted_residuals": 1946160, + "physical": 475389, + "rank_mass": 34496640, + "deficit": 169600, + "entering_helper_roles": 930150, + "cross_replica_helper_roles": 1921602, + "one_owner_per_complete_invocation": true, + "helper_busy_family_window_checks": 1946160, + "complete_invocations": 4770, + "actual_orthogonal_73column_maps": 8735, + "actual_sigma_stream_sha256": "bb7c0bd44c6bad0f40217963c7095402865e3b5c7dc3aabf6cab610449de15fd", + "all_actual_residual_and_spectator_charts": true, + "idle_remainders": 368570, + "mutations_rejected": [ + "alias two whole owners", + "helper on active data family", + "owner in private namespace", + "wrong residual width", + "wrong spectator coordinate", + "omit idle remainder", + "omit private zero buffers", + "private buffer aliases data", + "pooled slots exchange invocation time (equal widths)", + "pooled slot time shifted", + "understate physical reserve", + "extra: wrong provider at its invocation", + "extra: stale per-call local program hash", + "extra: stale serialized provider program", + "extra: unbound residual adapter hash", + "extra: wrong per-call residual width", + "extra: wrong sweep provider", + "extra: entering helper width silently restored to nine", + "gauge44: wrong provider at its invocation", + "gauge44: stale per-call local program hash", + "gauge44: stale serialized provider program", + "gauge44: unbound residual adapter hash", + "gauge44: wrong per-call residual width", + "gauge44: wrong sweep provider", + "gauge44: entering helper width silently restored to nine" + ], + "mutation_controls_run": true, + "provider_phase_semantic_sha256": { + "extra": "098348d85c8edc579110244f887a7d79af48c4a11bfd4eeacd71993492b7e03a", + "gauge44": "13e8df8b34f2821967845d6d4a383d9b05186df693af0fe09df1410685a7429c" + }, + "provider_artifact_semantic_sha256": { + "extra": { + "CANONICAL-WORD.json.gz": "1a0bf1ab1ba8c04a403b4adc4e6ad8600f7a694ae6cb8e80a44b70dd00cfb7b8", + "LOCAL-PROGRAMS.json.gz": "3a56a06b63794f96904168d00792521c9475a6155e88bf5228bea35256d547e3", + "LOCAL-CHECKS.json": "f8c9fc2e524c404ed6bd33a51c571f72ce6ba0a40a2d8957f6197b1b952b653c", + "INDEPENDENT-LOCAL-REPLAY.json": "6461afcce77f511a1435e4cddae859f4a04967f9b8d8e56d0aeaa6b6b6ffcc97", + "CLIFFORD-RECIPES.json": "c406b59021d2560f5405da13fd58e31620445ec3c89c221cc428a98260ccb47c", + "CLIFFORD-REVIEW.json": "098348d85c8edc579110244f887a7d79af48c4a11bfd4eeacd71993492b7e03a", + "RESIDUAL-ADAPTERS.json": "efd0ef1043c1766e1a6c3bc21772b0dd6fab86dbeda0cb1bf90a9bc4716a2433" + }, + "gauge44": { + "CANONICAL-WORD.json.gz": "73e81ff9dfc99013f8c74600fbbc30028566446cc4ab801d16dcafa1686286cd", + "LOCAL-PROGRAMS.json.gz": "3a56a06b63794f96904168d00792521c9475a6155e88bf5228bea35256d547e3", + "LOCAL-CHECKS.json": "f8c9fc2e524c404ed6bd33a51c571f72ce6ba0a40a2d8957f6197b1b952b653c", + "INDEPENDENT-LOCAL-REPLAY.json": "866c6cc9231da41f9663a1a60da05b014cc0a974da1b036b4a3db1eb15c47956", + "CLIFFORD-RECIPES.json": "2bfff13b291f8112d6e0dd1129db57849da11aba9fc01de5f070fb80bd77857b", + "CLIFFORD-REVIEW.json": "13e8df8b34f2821967845d6d4a383d9b05186df693af0fe09df1410685a7429c", + "RESIDUAL-ADAPTERS.json": "376f0c06dec209fdbe66c3261c36f9ebde2a6dc2735637573ccae03e104c06a9" + } + }, + "widths_by_provider": { + "extra": { + "4": 26, + "5": 2, + "6": 18, + "7": 52, + "8": 97, + "9": 213 + }, + "gauge44": { + "4": 26, + "5": 2, + "6": 18, + "7": 52, + "8": 97, + "9": 213 + } + }, + "provider_counts": { + "extra": 2090, + "gauge44": 2680 + }, + "all_provider_program_phase_and_wrapper_bindings": true, + "scope": "Independent exact asynchronous chronology, per-replica phase projection, owner/chart/paid-profile audit. Uses per-invocation local providers bound by exact scalar, phase and residual-wrapper receipts; all-size compilation and complete coefficient invoice are separate inherited obligations." +} diff --git a/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/bind.log b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/bind.log new file mode 100644 index 0000000000..a964929571 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/bind.log @@ -0,0 +1 @@ +PASS_FROZEN_048_ALLCOLD_DISPATCH_FRESH_PROVIDER_BINDING diff --git a/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/bit.log b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/bit.log new file mode 100644 index 0000000000..434ec86a59 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/bit.log @@ -0,0 +1 @@ +PASS_PR589_BIT_SUPPLIER_DERIVED_DEFICIT_NEGATIVE_CONTROLS 12 diff --git a/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/emit.log b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/emit.log new file mode 100644 index 0000000000..3ffa92edef --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/emit.log @@ -0,0 +1,58 @@ +{ + "status": "EMITTED_MIXED_PROVIDER_ASYNCHRONOUS_WHOLE_OWNER_COMPLEX_TEMPLATE", + "template_sha256": "6182ee1ccf2232c9cb4cad3a5b101a576de02c7e8d68289f166d786d962c8cc5", + "parent_template_sha256": "7027694928df0a4490d6ddc768c268924809f16d0ef91e961071d95a0b18806e", + "live": 474880, + "physical": 475389, + "global_profile": { + "1": 11747920, + "2": 3453480, + "3": 1112042, + "4": 486540, + "5": 103690, + "8": 38160, + "48": 202828 + }, + "rank_mass": 34496640, + "deficit": 169600, + "maxchild": 48, + "hosted_residuals": 1946160, + "banks_per_stage": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "entering_helper_roles": 930150, + "unique_actual_73column_sigmas": 8735, + "sigma_stream_sha256": "bb7c0bd44c6bad0f40217963c7095402865e3b5c7dc3aabf6cab610449de15fd", + "cross_replica_helper_roles": 1921602, + "asynchronous_order_sha256": "a264fb429d0a6740aa12ec71aed0abfdbeb74be3d02035db87f66223001da1f0", + "source_artifacts": { + "work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "providers/extra/CANONICAL-WORD.json.gz": "f30605f35030460f18b053dbd6031e862bf3c6661141d481d54ffdc1e8d1ad01", + "providers/extra/LOCAL-PROGRAMS.json.gz": "1d67fa36c04eaaa6458ef87752d6312a3c58a2b41cedc7b5a32c2e36ae24db61", + "providers/extra/LOCAL-CHECKS.json": "11743473efa1822069303b49c62b1853af4236f46ef54b4778a27e2e70d79d06", + "providers/extra/INDEPENDENT-LOCAL-REPLAY.json": "8d9013f5060502270b63cb7a6078ab18bf1242a3bb74af7126e3e5b93e3be037", + "providers/extra/RESIDUAL-ADAPTERS.json": "c4ddd4db13db5ed6b3672f8ddd0dc3a2bfff50068779b51489c6f002972f6163", + "providers/extra/CLIFFORD-RECIPES.json": "c406b59021d2560f5405da13fd58e31620445ec3c89c221cc428a98260ccb47c", + "providers/extra/CLIFFORD-REVIEW.json": "47c9e73a4ed4924bed7485039e7e081e7d64fd601dba2b505079eea347713303", + "providers/gauge44/CANONICAL-WORD.json.gz": "ba1e3767f52c849c49d7d3852b879d9562265f1f51d15ca40421c51cae0aae6a", + "providers/gauge44/LOCAL-PROGRAMS.json.gz": "1d67fa36c04eaaa6458ef87752d6312a3c58a2b41cedc7b5a32c2e36ae24db61", + "providers/gauge44/LOCAL-CHECKS.json": "11743473efa1822069303b49c62b1853af4236f46ef54b4778a27e2e70d79d06", + "providers/gauge44/INDEPENDENT-LOCAL-REPLAY.json": "f99d4c50632d1cff239ac6f54e4040bc9a7ac66500de9d032c8e9fc5ec42a458", + "providers/gauge44/RESIDUAL-ADAPTERS.json": "a19e744f741bf917a72d63aab09cf7e10f5566091458568747b97f7bf0ea945a", + "providers/gauge44/CLIFFORD-RECIPES.json": "2bfff13b291f8112d6e0dd1129db57849da11aba9fc01de5f070fb80bd77857b", + "providers/gauge44/CLIFFORD-REVIEW.json": "e57e200c991adc30002c8f9829e3594f2b11b9f7481909d55746412e4b048a85" + }, + "provider_counts": { + "extra": 2090, + "gauge44": 2680 + }, + "scope": "Two actual verified plain/width-seven providers dispatched per complete invocation; independent controller/spectator/normalization and complete finite invoice admission required." +} diff --git a/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/independent.log b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/independent.log new file mode 100644 index 0000000000..17d16f0b71 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/independent.log @@ -0,0 +1 @@ +PASS_INDEPENDENT_MIXED_OWNER 8 diff --git a/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/invoice.log b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/invoice.log new file mode 100644 index 0000000000..e8957fab70 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/strict-logs/invoice.log @@ -0,0 +1,36 @@ +{ + "status": "PASS_INDEPENDENT_MIXED_ASYNC_SCALAR_PREFIX_AND_FINITE_INVOICE", + "provider_counts": { + "extra": 2090, + "gauge44": 2680 + }, + "selected_real_component_primitives": 756184920, + "selected_coefficient_work_primitive_count": 369781000, + "global_prefix_bits": 1479, + "finite": { + "physical_stock_bits": 2647, + "router_bits": 8002, + "literal_bits": 35294, + "physical_row_coefficient": 19551, + "retained_row_coefficient": 20161, + "required_C0_bits": 200012, + "halving_integer_inequality": [ + 5329, + 4608 + ], + "G_exponent": 30000, + "E_exponent": 100000, + "C0_exponent": 210000 + }, + "strict_checks": { + "local_primitive_bound": true, + "logical": true, + "router": true, + "literal": true, + "mass": true, + "precision": true, + "tape": true, + "row": true, + "halving": true + } +} diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/audit-local-566-base.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/audit-local-566-base.log new file mode 100644 index 0000000000..fb768c8fac --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/audit-local-566-base.log @@ -0,0 +1,139 @@ +endpoint forward PASS +endpoint dual PASS +{ + "status": "PASS_INDEPENDENT_EXACT_FORWARD_AND_DUAL_ENDPOINT_FRAMES_ENTRANCES_CONES", + "input_file": "gauge44-word-566.json.gz", + "content_sha256": "ba9ee703e656b998ee9389309321a18ae6838a8f8eb77ccc402a345096df2112", + "compressed_sha256": "eeb6a236ed0ea8873b8800947d0cd19c36a6fcfdf857fc42913cb45cd984f219", + "parent_center_interface": { + "parent_path": "research/community-k492-audit/pr622/replay/baseline558/complex-global/base/split-centres/CANONICAL-WORD.json.gz", + "parent_file_sha256": "66d3c3c70983224650643a0a05a21ac6c6959f84d0f4528650601016f5a76844", + "transport_tau": 43, + "ordered_frame_bases_match": true, + "all_ports_match": true, + "transported_centers": [ + 92, + 57, + 81, + 224, + 11, + 240, + 9, + 256 + ], + "source_centers": [ + 92, + 57, + 81, + 11, + 9 + ], + "ordered_frame_bases": [ + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + [ + 256, + 128, + 64, + 32, + 17, + 9, + 4, + 2 + ], + [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + [ + 256, + 128, + 66, + 32, + 18, + 8, + 4, + 1 + ], + [ + 256, + 128, + 65, + 33, + 17, + 9, + 5, + 3 + ], + [ + 256, + 128, + 65, + 33, + 16, + 8, + 4, + 2 + ], + [ + 256, + 128, + 68, + 32, + 16, + 12, + 2, + 1 + ] + ] + }, + "v": 112, + "h": 9, + "R": 480, + "entering": 192, + "lowends": 78, + "coldends": 48, + "compensation_gates": 7208, + "local_profile": { + "1": 2348, + "2": 500, + "3": 416, + "4": 130, + "5": 82, + "8": 8 + }, + "width_inventory": { + "4": 44, + "5": 44, + "7": 38, + "8": 114, + "9": 240 + }, + "checked_columns": 704, + "elapsed_seconds": 0.4200849999906495, + "scope": "Exact rational full scalar map in both orientations; all literal native frame chains, center levels, dyadic units, entrance-zero response, wrapper exclusion and final helper row/column cones. No global owner admission or exponent repricing." +} diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/audit-local-566-extra.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/audit-local-566-extra.log new file mode 100644 index 0000000000..0e6f78a757 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/audit-local-566-extra.log @@ -0,0 +1,139 @@ +endpoint forward PASS +endpoint dual PASS +{ + "status": "PASS_INDEPENDENT_EXACT_FORWARD_AND_DUAL_ENDPOINT_FRAMES_ENTRANCES_CONES", + "input_file": "extra-word-566.json.gz", + "content_sha256": "848815627392ea8995577fb2023077f461405231fcaf934aad6b9e5a8a0da4eb", + "compressed_sha256": "cd417b904408c221d9840d08faff8af040cc4207f9804284f2f5375d21298a62", + "parent_center_interface": { + "parent_path": "research/community-k492-audit/pr622/replay/baseline558/complex-global/base/split-centres/CANONICAL-WORD.json.gz", + "parent_file_sha256": "66d3c3c70983224650643a0a05a21ac6c6959f84d0f4528650601016f5a76844", + "transport_tau": 43, + "ordered_frame_bases_match": true, + "all_ports_match": true, + "transported_centers": [ + 92, + 57, + 81, + 224, + 11, + 240, + 9, + 256 + ], + "source_centers": [ + 92, + 57, + 81, + 11, + 9 + ], + "ordered_frame_bases": [ + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + [ + 256, + 128, + 64, + 32, + 17, + 9, + 4, + 2 + ], + [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + [ + 256, + 128, + 66, + 32, + 18, + 8, + 4, + 1 + ], + [ + 256, + 128, + 65, + 33, + 17, + 9, + 5, + 3 + ], + [ + 256, + 128, + 65, + 33, + 16, + 8, + 4, + 2 + ], + [ + 256, + 128, + 68, + 32, + 16, + 12, + 2, + 1 + ] + ] + }, + "v": 112, + "h": 9, + "R": 480, + "entering": 192, + "lowends": 78, + "coldends": 48, + "compensation_gates": 7208, + "local_profile": { + "1": 2340, + "2": 508, + "3": 420, + "4": 126, + "5": 82, + "8": 8 + }, + "width_inventory": { + "4": 40, + "5": 48, + "7": 38, + "8": 114, + "9": 240 + }, + "checked_columns": 704, + "elapsed_seconds": 0.4299599169753492, + "scope": "Exact rational full scalar map in both orientations; all literal native frame chains, center levels, dyadic units, entrance-zero response, wrapper exclusion and final helper row/column cones. No global owner admission or exponent repricing." +} diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/declared-edit-review.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/declared-edit-review.log new file mode 100644 index 0000000000..8165a02a2e --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/declared-edit-review.log @@ -0,0 +1 @@ +PASS_INDEPENDENT_EDIT_REVIEW {'base': 21, 'extra': 21} diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/fine-engine-oracle.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/fine-engine-oracle.log new file mode 100644 index 0000000000..2382f2e57a --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/fine-engine-oracle.log @@ -0,0 +1 @@ +PASS_FINE_ENGINE_LOG_ORACLE inputs=76 enclosures=152 diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/geometry-controls.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/geometry-controls.log new file mode 100644 index 0000000000..64497d9505 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/geometry-controls.log @@ -0,0 +1 @@ +PASS_GEOMETRY_CONTROLS 6 diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/lemmag-labels.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/lemmag-labels.log new file mode 100644 index 0000000000..700d3f05e7 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/lemmag-labels.log @@ -0,0 +1 @@ +PASS_LEMMAG_LABELS dirs=4 mutants_rejected=12 borrow_mutants_rejected=14 diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/lift-parent.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/lift-parent.log new file mode 100644 index 0000000000..eb77de6c68 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/lift-parent.log @@ -0,0 +1 @@ +PASS_LITERAL_GENERAL_T_PARENT_PLAN_SPEC {"charged_prefix_bits": 2048, "dimension": 73, "pairs": 4, "parent_helpers": 504, "parent_idle": 1068480, "parent_live": 778792, "parent_physical": 779306, "replicas": 530, "stages": 9} diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/paired-extension-review.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/paired-extension-review.log new file mode 100644 index 0000000000..17541315b5 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/paired-extension-review.log @@ -0,0 +1,161 @@ +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 632 independent inputs +free-algebra dual PASS 632 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "WORD-base.json.gz", + "content_sha256": "a602bc8494a336e8fbc9fac5e22d71e7394e86ca762f92083496c8ba448f5d94", + "compressed_sha256": "fec3c120db1a35022944628d34b56a36f2456248c274c2eaba1a325cdc690ce8", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 72, + "independent_inputs": 632, + "warps": 72, + "corrections": 36, + "restored_cold": 82, + "zero_buffers": 82, + "entering": 134, + "local_profile": { + "1": 2416, + "2": 640, + "3": 280, + "4": 110, + "5": 26, + "8": 8 + }, + "local_mass": 5170, + "width_inventory": { + "4": 26, + "5": 2, + "7": 62, + "8": 96, + "9": 222 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 632, + "elapsed_seconds": 0.3913867920055054, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 632 independent inputs +free-algebra dual PASS 632 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "WORD-extra.json.gz", + "content_sha256": "a3aeb900e97822b1aaf39a0c274b2dc5ec840f5d1f0e5cf14aae19b9d32ad39b", + "compressed_sha256": "e4d0c617df85bf8a824ff68310ca3373dc017c1ebf9ea733056a3ee4a784b36f", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 72, + "independent_inputs": 632, + "warps": 72, + "corrections": 36, + "restored_cold": 82, + "zero_buffers": 82, + "entering": 134, + "local_profile": { + "1": 2416, + "2": 640, + "3": 280, + "4": 110, + "5": 26, + "8": 8 + }, + "local_mass": 5170, + "width_inventory": { + "4": 26, + "5": 2, + "7": 62, + "8": 96, + "9": 222 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 632, + "elapsed_seconds": 0.3832818329683505, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +PASS_NINE_ADDITIONAL_PAIRED_EXTRACTIONS diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/preload-move-independent-review.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/preload-move-independent-review.log new file mode 100644 index 0000000000..c2e61ca85e --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/preload-move-independent-review.log @@ -0,0 +1,111 @@ +{ + "status": "PASS_INDEPENDENT_PRELOAD_MOVE_REVIEW", + "variants": { + "base": { + "inserted_A_gates": 14, + "controls": [ + [ + "dropped_quartet_helper_entry", + "RuntimeError: paid profile mismatch {1: 2402, 2: 643, 3: 262, 4: 128, 5: 26, 8: 8}" + ], + [ + "dropped_entry_delivery", + "RuntimeError: paid profile mismatch {1: 2403, 2: 642, 3: 261, 4: 129, 5: 26, 8: 8}" + ], + [ + "flipped_sign", + "RuntimeError: target map failed 24" + ], + [ + "flipped_partner_sign", + "RuntimeError: target map failed 24" + ], + [ + "missing_carrier_raise", + "RuntimeError: frame not monotone (499, (42,), (415, 84, 44))" + ], + [ + "missing_carrier_raise_second", + "RuntimeError: frame not monotone (510, (42,), (276, 138, 85))" + ], + [ + "preload_gate_moved_back", + "RuntimeError: frame not monotone (457, (42,), ())" + ], + [ + "preload_gate_moved_back_second", + "RuntimeError: frame not monotone (458, (42,), ())" + ], + [ + "preload_undo_removed", + "RuntimeError: target map failed 24" + ], + [ + "wrong_start_extra", + "RuntimeError: frame not monotone (457, (75,), (42,))" + ], + [ + "wrong_compensation_sign", + "RuntimeError: target map failed 22" + ], + [ + "stale_cleanup", + "RuntimeError: explicit cleanup differs from derived inverse-reverse at FULL" + ] + ] + }, + "extra": { + "inserted_A_gates": 14, + "controls": [ + [ + "dropped_quartet_helper_entry", + "RuntimeError: paid profile mismatch {1: 2402, 2: 643, 3: 262, 4: 128, 5: 26, 8: 8}" + ], + [ + "dropped_entry_delivery", + "RuntimeError: paid profile mismatch {1: 2403, 2: 642, 3: 261, 4: 129, 5: 26, 8: 8}" + ], + [ + "flipped_sign", + "RuntimeError: target map failed 24" + ], + [ + "flipped_partner_sign", + "RuntimeError: target map failed 24" + ], + [ + "missing_carrier_raise", + "RuntimeError: frame not monotone (499, (42,), (415, 84, 44))" + ], + [ + "missing_carrier_raise_second", + "RuntimeError: frame not monotone (510, (42,), (276, 138, 85))" + ], + [ + "preload_gate_moved_back", + "RuntimeError: frame not monotone (457, (42,), ())" + ], + [ + "preload_gate_moved_back_second", + "RuntimeError: frame not monotone (458, (42,), ())" + ], + [ + "preload_undo_removed", + "RuntimeError: target map failed 24" + ], + [ + "wrong_start_extra", + "RuntimeError: frame not monotone (457, (75,), (42,))" + ], + [ + "wrong_compensation_sign", + "RuntimeError: target map failed 22" + ], + [ + "stale_cleanup", + "RuntimeError: explicit cleanup differs from derived inverse-reverse at FULL" + ] + ] + } + } +} diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/rebind-566.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/rebind-566.log new file mode 100644 index 0000000000..2353b22176 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/rebind-566.log @@ -0,0 +1 @@ +provider counts {'extra': 2090, 'gauge44': 2680} | new profile {'1': 11747920, '2': 3453480, '3': 1112042, '4': 486540, '5': 103690, '8': 38160, '48': 202828} | changed {'gauge44': ['artifact_semantic_sha256', 'artifact_sha256', 'orientation_program_sha256'], 'extra': ['artifact_semantic_sha256', 'artifact_sha256', 'orientation_program_sha256']} diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/rebuild-borrow-words.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/rebuild-borrow-words.log new file mode 100644 index 0000000000..0c391921a3 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/rebuild-borrow-words.log @@ -0,0 +1,19 @@ +wrote $RESEARCH_WORKSPACE/work/joint-analysis/full-derivative/admission/release/verify/tmp/tmpjw97iepl/w.json.gz 1901 4504 42 78 +TARGET-OFFSETS base declared by patch input 12 missing/extra/changed rejected True True True +TWELVE-CONTROLS base {'twelve_gate_sign_flipped_rejected': True, 'twelve_gate_coefficient_doubled_rejected': True, 'twelve_gate_dropped_rejected': True, 'twelve_warp_dropped_rejected': True, 'twelve_target_frame_changed_rejected': True} +RETIRED7-CONTROLS base {'retired7_gate_sign_flipped_rejected': True, 'retired7_gate_coefficient_doubled_rejected': True, 'retired7_gate_dropped_rejected': True, 'retired7_warp_dropped_rejected': True, 'retired7_target_frame_changed_rejected': True} +DIRTENTRY-CONTROLS base {'dirtentry_injection_dropped_rejected': True, 'dirtentry_injection_sign_flipped_rejected': True, 'dirtentry_injection_wrong_time_rejected': True, 'dirtentry_removal_missing_rejected': True} +CUT-CENTRE-GUARD base cut gates 176 violations 0 negative control rejected True +HELPER-INDEX-GUARD base helper_final keys 91 violations 0 negative control (key -1) rejected True +ENTRANCE-WIDTH-BINDING base raised 26 bound True dim1 tamper rejected True +gauge44 {'rebuild_plus_patches_equals_shipped': True, 'patches': ['refit', 'kernel', 'handoff', 'entrance', 'lowfour', 'alias8', 'prelife', 'refit563', 'alias1', 'twelve', 'retired7', 'dirtentry', 'shared-four-kernel', 'preload-move', 'two-sided-helper408', 'nine-additional-paired-extractions', 'rank7-joint-endframes', 'declared-edit-list', 'staged3605', 'staged-release-retime'], 'kernel_edit_exact': True, 'prior_state_audit_rc': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'audit_rc': 0, 'target_offsets_declared': True, 'target_offset_missing_rejected': True, 'target_offset_extra_rejected': True, 'target_offset_changed_rejected': True, 'controls_rc': 0, 'lowfour_controls_rc': 0, 'prelife_controls_ok': True, 'refit563_undone_rejected_by_warp_frame_mismatch': True, 'alias1_controls_rc': 0, 'twelve_gate_sign_flipped_rejected': True, 'twelve_gate_coefficient_doubled_rejected': True, 'twelve_gate_dropped_rejected': True, 'twelve_warp_dropped_rejected': True, 'twelve_target_frame_changed_rejected': True, 'retired7_gate_sign_flipped_rejected': True, 'retired7_gate_coefficient_doubled_rejected': True, 'retired7_gate_dropped_rejected': True, 'retired7_warp_dropped_rejected': True, 'retired7_target_frame_changed_rejected': True, 'dirtentry_injection_dropped_rejected': True, 'dirtentry_injection_sign_flipped_rejected': True, 'dirtentry_injection_wrong_time_rejected': True, 'dirtentry_removal_missing_rejected': True, 'kernel_controls_rejected': {'kernel_sign_flipped': True, 'kernel_read_dropped': True, 'kernel_coefficient_doubled': True, 'kernel_read_moved_to_neighbour_register': True, 'alias8_sign_flipped': True, 'alias8_coefficient_doubled': True, 'alias8_warp_dropped': True, 'entrance_start_frame_dropped': True, 'entrance_start_frame_widened': True, 'handoff_sign_flipped': True, 'handoff_coefficient_doubled': True}, 'refit_tamper_rejected': True, 'cut_centre_guard_violations': 0, 'cut_centre_guard_negative_control_rejected': True, 'helper_index_guard_violations': 0, 'helper_index_guard_negative_control_rejected': True, 'entrance_widths_bound_to_providers': True, 'dim1_delivery_rejected': True, 'raised_buffers': 26} +wrote $RESEARCH_WORKSPACE/work/joint-analysis/full-derivative/admission/release/verify/tmp/tmpq_u635rq/w.json.gz 1901 4504 42 78 +TARGET-OFFSETS extra declared by patch input 12 missing/extra/changed rejected True True True +TWELVE-CONTROLS extra {'twelve_gate_sign_flipped_rejected': True, 'twelve_gate_coefficient_doubled_rejected': True, 'twelve_gate_dropped_rejected': True, 'twelve_warp_dropped_rejected': True, 'twelve_target_frame_changed_rejected': True} +RETIRED7-CONTROLS extra {'retired7_gate_sign_flipped_rejected': True, 'retired7_gate_coefficient_doubled_rejected': True, 'retired7_gate_dropped_rejected': True, 'retired7_warp_dropped_rejected': True, 'retired7_target_frame_changed_rejected': True} +DIRTENTRY-CONTROLS extra {'dirtentry_injection_dropped_rejected': True, 'dirtentry_injection_sign_flipped_rejected': True, 'dirtentry_injection_wrong_time_rejected': True, 'dirtentry_removal_missing_rejected': True} +CUT-CENTRE-GUARD extra cut gates 176 violations 0 negative control rejected True +HELPER-INDEX-GUARD extra helper_final keys 91 violations 0 negative control (key -1) rejected True +ENTRANCE-WIDTH-BINDING extra raised 26 bound True dim1 tamper rejected True +extra {'rebuild_plus_patches_equals_shipped': True, 'patches': ['refit', 'kernel', 'handoff', 'entrance', 'lowfour', 'alias8', 'prelife', 'refit563', 'alias1', 'twelve', 'retired7', 'dirtentry', 'shared-four-kernel', 'preload-move', 'two-sided-helper408', 'nine-additional-paired-extractions', 'rank7-joint-endframes', 'declared-edit-list', 'staged3605', 'staged-release-retime'], 'kernel_edit_exact': True, 'prior_state_audit_rc': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'audit_rc': 0, 'target_offsets_declared': True, 'target_offset_missing_rejected': True, 'target_offset_extra_rejected': True, 'target_offset_changed_rejected': True, 'controls_rc': 0, 'lowfour_controls_rc': 0, 'prelife_controls_ok': True, 'refit563_undone_rejected_by_warp_frame_mismatch': True, 'alias1_controls_rc': 0, 'twelve_gate_sign_flipped_rejected': True, 'twelve_gate_coefficient_doubled_rejected': True, 'twelve_gate_dropped_rejected': True, 'twelve_warp_dropped_rejected': True, 'twelve_target_frame_changed_rejected': True, 'retired7_gate_sign_flipped_rejected': True, 'retired7_gate_coefficient_doubled_rejected': True, 'retired7_gate_dropped_rejected': True, 'retired7_warp_dropped_rejected': True, 'retired7_target_frame_changed_rejected': True, 'dirtentry_injection_dropped_rejected': True, 'dirtentry_injection_sign_flipped_rejected': True, 'dirtentry_injection_wrong_time_rejected': True, 'dirtentry_removal_missing_rejected': True, 'kernel_controls_rejected': {'kernel_sign_flipped': True, 'kernel_read_dropped': True, 'kernel_coefficient_doubled': True, 'kernel_read_moved_to_neighbour_register': True, 'alias8_sign_flipped': True, 'alias8_coefficient_doubled': True, 'alias8_warp_dropped': True, 'entrance_start_frame_dropped': True, 'entrance_start_frame_widened': True, 'handoff_sign_flipped': True, 'handoff_coefficient_doubled': True}, 'refit_tamper_rejected': True, 'cut_centre_guard_violations': 0, 'cut_centre_guard_negative_control_rejected': True, 'helper_index_guard_violations': 0, 'helper_index_guard_negative_control_rejected': True, 'entrance_widths_bound_to_providers': True, 'dim1_delivery_rejected': True, 'raised_buffers': 26} +PASS_REBUILD_BORROW diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/rebuild-words-566.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/rebuild-words-566.log new file mode 100644 index 0000000000..c8d49c118f --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/rebuild-words-566.log @@ -0,0 +1,4 @@ +step 0 gauge44 PASS {'scalar_program_matches': True, 'interfaces_identical': True, 'b_tail_map_rows': 522, 'b_tail_map_rows_differing': 0, 'remaining_cleanup_identical': True, 'pivot': 566, 'pivot_writes': [872, 1935], 'inserted_reads_where_pivot_is_initial': True, 'exact': True, 'inserted_read_signs': {'0': 1, '1': 1, '2': 1, '3': 1, '51': 1, '229': 1, '526': 1, '1936': 1}, 'inserted_reads_see_signed_identity': True, 'inserted_read_q_rows': {'0': {'566': '1'}, '1': {'566': '1'}, '2': {'566': '1'}, '3': {'566': '1'}, '51': {'566': '1'}, '229': {'566': '1'}, '526': {'566': '1'}, '1936': {'566': '1'}}, 'inserted_read_effective_coefficients': {'0': '1', '1': '-1', '2': '-1', '3': '-2', '51': '1', '229': '2', '526': '-1', '1936': '1'}, 'pass': True, 'tamper_controls_all_fail': True, 'tamper_controls': {'all_new_gates_sign_flipped': True, 'tail_gates_sign_flipped': True, 'gate0_coefficient_x2': True, 'gate1_coefficient_x2': True, 'gate2_coefficient_x2': True, 'gate3_coefficient_x2': True, 'gate4_coefficient_x2': True, 'gate5_coefficient_x2': True, 'gate6_coefficient_x2': True, 'gate7_coefficient_x2': True}} +step 0 extra PASS {'scalar_program_matches': True, 'interfaces_identical': True, 'b_tail_map_rows': 522, 'b_tail_map_rows_differing': 0, 'remaining_cleanup_identical': True, 'pivot': 566, 'pivot_writes': [872, 1935], 'inserted_reads_where_pivot_is_initial': True, 'exact': True, 'inserted_read_signs': {'0': 1, '1': 1, '2': 1, '3': 1, '51': 1, '229': 1, '526': 1, '1936': 1}, 'inserted_reads_see_signed_identity': True, 'inserted_read_q_rows': {'0': {'566': '1'}, '1': {'566': '1'}, '2': {'566': '1'}, '3': {'566': '1'}, '51': {'566': '1'}, '229': {'566': '1'}, '526': {'566': '1'}, '1936': {'566': '1'}}, 'inserted_read_effective_coefficients': {'0': '1', '1': '-1', '2': '-1', '3': '-2', '51': '1', '229': '2', '526': '-1', '1936': '1'}, 'pass': True, 'tamper_controls_all_fail': True, 'tamper_controls': {'all_new_gates_sign_flipped': True, 'tail_gates_sign_flipped': True, 'gate0_coefficient_x2': True, 'gate1_coefficient_x2': True, 'gate2_coefficient_x2': True, 'gate3_coefficient_x2': True, 'gate4_coefficient_x2': True, 'gate5_coefficient_x2': True, 'gate6_coefficient_x2': True, 'gate7_coefficient_x2': True}} +step 1 gauge44 PASS {'scalar_program_matches': True, 'interfaces_identical': True, 'b_tail_map_rows': 522, 'b_tail_map_rows_differing': 0, 'remaining_cleanup_identical': True, 'pivot': 554, 'pivot_writes': [857, 1935, 1936], 'inserted_reads_where_pivot_is_initial': False, 'exact': True, 'inserted_read_signs': {'1': 1, '2': 1, '519': 1, '1937': -1}, 'inserted_reads_see_signed_identity': True, 'inserted_read_q_rows': {'1': {'554': '1'}, '2': {'554': '1'}, '519': {'554': '1'}, '1937': {'554': '-1'}}, 'inserted_read_effective_coefficients': {'1': '1', '2': '-1', '519': '-1', '1937': '1'}, 'pass': True, 'tamper_controls_all_fail': True, 'tamper_controls': {'all_new_gates_sign_flipped': True, 'tail_gates_sign_flipped': True, 'gate0_coefficient_x2': True, 'gate1_coefficient_x2': True, 'gate2_coefficient_x2': True, 'gate3_coefficient_x2': True, 'gate4_coefficient_x2': True}} +step 1 extra PASS {'scalar_program_matches': True, 'interfaces_identical': True, 'b_tail_map_rows': 522, 'b_tail_map_rows_differing': 0, 'remaining_cleanup_identical': True, 'pivot': 554, 'pivot_writes': [857, 1935, 1936], 'inserted_reads_where_pivot_is_initial': False, 'exact': True, 'inserted_read_signs': {'1': 1, '2': 1, '519': 1, '1937': -1}, 'inserted_reads_see_signed_identity': True, 'inserted_read_q_rows': {'1': {'554': '1'}, '2': {'554': '1'}, '519': {'554': '1'}, '1937': {'554': '-1'}}, 'inserted_read_effective_coefficients': {'1': '1', '2': '-1', '519': '-1', '1937': '1'}, 'pass': True, 'tamper_controls_all_fail': True, 'tamper_controls': {'all_new_gates_sign_flipped': True, 'tail_gates_sign_flipped': True, 'gate0_coefficient_x2': True, 'gate1_coefficient_x2': True, 'gate2_coefficient_x2': True, 'gate3_coefficient_x2': True, 'gate4_coefficient_x2': True}} diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/reconstruct-owners.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/reconstruct-owners.log new file mode 100644 index 0000000000..1d705970dc --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/reconstruct-owners.log @@ -0,0 +1 @@ +PASS_OWNER_VERIFY {1: 123430, 5: 8290, 48: 202828, 3: 34022} {1: 11747920, 2: 3453480, 3: 1112042, 4: 486540, 5: 103690, 8: 38160, 48: 202828} diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/shared-kernel-independent-review.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/shared-kernel-independent-review.log new file mode 100644 index 0000000000..17f3b684a4 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/shared-kernel-independent-review.log @@ -0,0 +1,131 @@ +{ + "status": "PASS_INDEPENDENT_FOUR_GROUP_REVIEW", + "variants": { + "base": { + "inserted_A_gates": 20, + "compensation_removed": 28, + "compensation_added": 28, + "controls": [ + { + "name": "wrong_kernel_sign", + "cleanup_rederived": true, + "expected_failure_kind": "endpoint", + "frames_profile_pass": true, + "rejected_for": "RuntimeError: target map failed 3" + }, + { + "name": "drop_primary_A_injection", + "cleanup_rederived": true, + "expected_failure_kind": "endpoint", + "frames_profile_pass": true, + "rejected_for": "RuntimeError: target map failed 14" + }, + { + "name": "missing_raw_dirt_reconstruction", + "cleanup_rederived": true, + "expected_failure_kind": "endpoint", + "frames_profile_pass": true, + "rejected_for": "RuntimeError: target map failed 14" + }, + { + "name": "missing_compensation_regeneration", + "cleanup_rederived": true, + "expected_failure_kind": "endpoint", + "frames_profile_pass": true, + "rejected_for": "RuntimeError: target map failed 3" + }, + { + "name": "wrong_compensation_sign", + "cleanup_rederived": true, + "expected_failure_kind": "endpoint", + "frames_profile_pass": true, + "rejected_for": "RuntimeError: target map failed 14" + }, + { + "name": "wrong_start_extra", + "cleanup_rederived": true, + "expected_failure_kind": "frame", + "frames_profile_pass": false, + "rejected_for": "RuntimeError: frame not monotone (478, (75,), (25,))" + }, + { + "name": "suppressed_compensation_without_transport", + "cleanup_rederived": true, + "expected_failure_kind": "endpoint", + "frames_profile_pass": true, + "rejected_for": "RuntimeError: target map failed 3" + }, + { + "name": "stale_cleanup", + "cleanup_rederived": false, + "expected_failure_kind": "cleanup", + "frames_profile_pass": false, + "rejected_for": "RuntimeError: explicit cleanup differs from derived inverse-reverse at FULL" + } + ] + }, + "extra": { + "inserted_A_gates": 20, + "compensation_removed": 28, + "compensation_added": 28, + "controls": [ + { + "name": "wrong_kernel_sign", + "cleanup_rederived": true, + "expected_failure_kind": "endpoint", + "frames_profile_pass": true, + "rejected_for": "RuntimeError: target map failed 3" + }, + { + "name": "drop_primary_A_injection", + "cleanup_rederived": true, + "expected_failure_kind": "endpoint", + "frames_profile_pass": true, + "rejected_for": "RuntimeError: target map failed 14" + }, + { + "name": "missing_raw_dirt_reconstruction", + "cleanup_rederived": true, + "expected_failure_kind": "endpoint", + "frames_profile_pass": true, + "rejected_for": "RuntimeError: target map failed 14" + }, + { + "name": "missing_compensation_regeneration", + "cleanup_rederived": true, + "expected_failure_kind": "endpoint", + "frames_profile_pass": true, + "rejected_for": "RuntimeError: target map failed 3" + }, + { + "name": "wrong_compensation_sign", + "cleanup_rederived": true, + "expected_failure_kind": "endpoint", + "frames_profile_pass": true, + "rejected_for": "RuntimeError: target map failed 14" + }, + { + "name": "wrong_start_extra", + "cleanup_rederived": true, + "expected_failure_kind": "frame", + "frames_profile_pass": false, + "rejected_for": "RuntimeError: frame not monotone (478, (75,), (25,))" + }, + { + "name": "suppressed_compensation_without_transport", + "cleanup_rederived": true, + "expected_failure_kind": "endpoint", + "frames_profile_pass": true, + "rejected_for": "RuntimeError: target map failed 3" + }, + { + "name": "stale_cleanup", + "cleanup_rederived": false, + "expected_failure_kind": "cleanup", + "frames_profile_pass": false, + "rejected_for": "RuntimeError: explicit cleanup differs from derived inverse-reverse at FULL" + } + ] + } + } +} diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/staged-release-retime-review.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/staged-release-retime-review.log new file mode 100644 index 0000000000..fee9c15366 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/staged-release-retime-review.log @@ -0,0 +1 @@ +PASS_RELEASE_RETIME_RECONSTRUCTION_EIGHT_CONTROLS diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/staged3605-review.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/staged3605-review.log new file mode 100644 index 0000000000..53377eefde --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/staged3605-review.log @@ -0,0 +1 @@ +PASS_STAGED3605_RECONSTRUCTION_AND_CONTROL diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/strict-t74.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/strict-t74.log new file mode 100644 index 0000000000..672cf5f9da --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/strict-t74.log @@ -0,0 +1,9 @@ +PASS bind +PASS emit +PASS audit +PASS invoice +PASS assembly +PASS admission +PASS bit +PASS independent +PASS_STRICT_MIXED_T74_EXACT_FILL 0.001727405299371541 diff --git a/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/two-sided-helper408-review.log b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/two-sided-helper408-review.log new file mode 100644 index 0000000000..2ab6795863 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/evidence/supplier-logs/two-sided-helper408-review.log @@ -0,0 +1,183 @@ +warps 72 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 632 independent inputs +free-algebra dual PASS 632 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "PARENT-base.json.gz", + "content_sha256": "ec3577859eee4b99ec5b3b382307444201094dd6151898b45d1adb35ad965f35", + "compressed_sha256": "c20a470aec0f3e61833cb41fe190639eb358f58017143d2336c55c80fba265eb", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 72, + "independent_inputs": 632, + "warps": 72, + "corrections": 36, + "restored_cold": 72, + "zero_buffers": 72, + "entering": 134, + "local_profile": { + "1": 2404, + "2": 642, + "3": 262, + "4": 128, + "5": 26, + "8": 8 + }, + "local_mass": 5180, + "width_inventory": { + "4": 26, + "5": 2, + "7": 62, + "8": 86, + "9": 232 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 632, + "elapsed_seconds": 0.42587362497579306, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +warps 72 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 632 independent inputs +free-algebra dual PASS 632 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "WORD-base.json.gz", + "content_sha256": "8d7f24d329db696be203e84c459f220f8de061fcc8681b5ab74a7a902d01bcd3", + "compressed_sha256": "3657ad53ebe5f156f307a903479e919f2fe812811ce5d5f15e72c3aaf68dfde3", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 72, + "independent_inputs": 632, + "warps": 72, + "corrections": 36, + "restored_cold": 73, + "zero_buffers": 73, + "entering": 134, + "local_profile": { + "1": 2407, + "2": 640, + "3": 262, + "4": 128, + "5": 26, + "8": 8 + }, + "local_mass": 5179, + "width_inventory": { + "4": 26, + "5": 2, + "7": 62, + "8": 87, + "9": 231 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 632, + "elapsed_seconds": 0.3932563749840483, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +warps 72 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 632 independent inputs +free-algebra dual PASS 632 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "PARENT-extra.json.gz", + "content_sha256": "c47e5c1444190bea1eea4821365e0ac70e74d74c558152a37e89632d36310937", + "compressed_sha256": "db34e39876241087b581ed9374c53e9cd393e3e86ef6103bfb54f3077c3d2761", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 72, + "independent_inputs": 632, + "warps": 72, + "corrections": 36, + "restored_cold": 72, + "zero_buffers": 72, + "entering": 134, + "local_profile": { + "1": 2404, + "2": 642, + "3": 262, + "4": 128, + "5": 26, + "8": 8 + }, + "local_mass": 5180, + "width_inventory": { + "4": 26, + "5": 2, + "7": 62, + "8": 86, + "9": 232 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 632, + "elapsed_seconds": 0.34683650004444644, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +warps 72 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 632 independent inputs +free-algebra dual PASS 632 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "WORD-extra.json.gz", + "content_sha256": "97ac8c367548702f2510b450c251248944bb2c81e0e74b10cca250d3f2e957c1", + "compressed_sha256": "b975492ff4cbec0d619cdf2da34f55ce3b20c8a541132e4339cc6c8ae3b2e487", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 72, + "independent_inputs": 632, + "warps": 72, + "corrections": 36, + "restored_cold": 73, + "zero_buffers": 73, + "entering": 134, + "local_profile": { + "1": 2407, + "2": 640, + "3": 262, + "4": 128, + "5": 26, + "8": 8 + }, + "local_mass": 5179, + "width_inventory": { + "4": 26, + "5": 2, + "7": 62, + "8": 87, + "9": 231 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 632, + "elapsed_seconds": 0.36775654199300334, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +frames/profile PASS +warps 72 PASS static K_G checks +warps 72 PASS static K_G checks +PASS_TWO_SIDED_HELPER408_LOCAL_CONSTRUCTION {"wrong_input_scale": "target map failed 3", "wrong_output_cancellation": "restored cold input still read by 408", "stale_compensation": "pre-wrapper touch of residual helper", "omit_new_private_buffer": "explicit cleanup differs from derived inverse-reverse at FULL"} diff --git a/research/staged-release-retiming-t530/full-admission/fresh-replay/ADMISSION-RESULT.json b/research/staged-release-retiming-t530/full-admission/fresh-replay/ADMISSION-RESULT.json new file mode 100644 index 0000000000..9585b62431 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/fresh-replay/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": "21629929897674542689/12500000000000000000000", + "dispatch_sha256": "a758a59b001f3bdda07e6a1a98bc8bd0339461dee5ec6b1909925030a043eddb", + "external_input_sha256": { + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/public-full-replay-3642-r1/FILL-legacy.json.gz": "e36d064df51ea93c4ca265e3e330aa71148ea3827bdf5a55144fc20e657a48cb", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/public-full-replay-3642-r1/allocation/DISPATCH.json": "a758a59b001f3bdda07e6a1a98bc8bd0339461dee5ec6b1909925030a043eddb", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/public-full-replay-3642-r1/allocation/ORDER.json": "599fb079a23b403f9de9e334d7c463f0cad28f9d69d1f99fcbf93abb72e935eb", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/public-full-replay-3642-r1/prepared/predecessor/PR2969-CLAIM.json": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/public-full-replay-3642-r1/prepared/predecessor/adapters/extension_blocknorm.py": "6e6b8683cc87a84e5410c399b1128eb68694f852a3927cb124067f503ed7d7c7", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/public-full-replay-3642-r1/prepared/predecessor/helpers/lift_parent.py": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/public-full-replay-3642-r1/prepared/predecessor/helpers/reconstruct_replica.py": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/public-full-replay-3642-r1/prepared/predecessor/helpers/replica_parent.py": "48bdbf28f59d80edb266803ec61bf5e22e8fb5e5a0e2b88004b6039147589bd4" + }, + "fill_sha256": "e36d064df51ea93c4ca265e3e330aa71148ea3827bdf5a55144fc20e657a48cb", + "gain": "635916706585853657/100000000000000000000000", + "kappa": "17303943918139634151199999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017303943918139634151199999999999999999999998999999999999999999999999", + "native_receipt_sha256": "1353cedccb418383565c0cd31da7447cc4ea73a6fd5ad53ab0482edb4833c053", + "order_sha256": "599fb079a23b403f9de9e334d7c463f0cad28f9d69d1f99fcbf93abb72e935eb", + "package_manifest_sha256": "9173c368581deec5a97b8be25608289fd9c50627c2041087386d58010b729081", + "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": "770d23cb1ac78b485ccc1a26f5d3e2fed7345940f77011579ae90ada4f5cacb1", + "before_sha256": "4b44d5e72e9d677076edc2d20569cdd30f0e21849afd88874d74dfa7d1c767e0", + "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 for s in rows), label+' completed exits') + need(all(s['command'][1] == '-B' for s in rows), label+' normal interpreter invocation') + +def validate(records, evidence): + """Semantic checks shared by raw collection, public check and rejection controls.""" + a = records['ATTEMPT.json'] + need(a['schema'] == 'public-end-to-end-attempt/1', 'attempt schema') + need(a.get('exit_code') == 0 and a.get('finished_at'), 'completed exit-zero attempt required') + start, finish = [datetime.fromisoformat(a[k]) for k in ('started_at','finished_at')] + need(finish >= start and a['seconds'] >= 0, 'completed time interval') + need(a['package_files_unchanged'] is True, 'publication inputs unchanged during replay') + need(a['publication_commit'] == COMMIT and a['wrapper_sha256'] == WRAPPER, 'executed commit and wrapper') + command = a['command'] + need(len(command) == 7 and command[1] == '-B' and command[3] == '--repo' and command[5] == '--work', 'full wrapper argv without external allocation or materialize-only') + need(command[2].endswith('/full-admission/reproduce.py'), 'public wrapper entry point') + repo, work = command[4].rstrip('/'), command[6].rstrip('/') + pub = repo+'/research/staged-release-retiming-t530/full-admission' + need(command[2] == pub+'/reproduce.py', 'wrapper within recorded repo') + need(a['package_before']['research/staged-release-retiming-t530/full-admission/reproduce.py'] == WRAPPER, 'before-run wrapper binding') + top = records['WRAPPER-RESULT.json'] + need(top['status'] == 'PASS_RETIMER_T530_COMPLETE_CONDITIONAL_RELEASE', 'complete wrapper result') + need(top['source_manifest_sha256'] == SOURCE and Q(top['kappa']) == K, 'wrapper source and modern kappa') + stages(top['stages'], TOP, 'wrapper') + scripts = [pub+'/vendor/staged-width-t530/replay.py', pub+'/scripts/integrate.py', + work+'/retimed/source/new/borrow/review_staged3605.py', + work+'/retimed/source/new/borrow/review_release_retime.py', + work+'/retimed/prepare_extension_native.py', + pub+'/vendor/staged-width-t530/owners/portable_expand.py', + work+'/retimed/admit_extension.py'] + need([s['command'][2] for s in top['stages']] == scripts, 'wrapper stage script identities') + need(top['stages'][5]['command'][3:] == ['--out',work+'/allocation'], 'fresh internal literal allocation') + argv = top['stages'][6]['command'] + for flag, path in {'--source':'retimed/source','--fill':'FILL-legacy.json.gz','--order':'allocation/ORDER.json','--dispatch':'allocation/DISPATCH.json','--native-cache':'retimed/native/native-cache','--native-receipt':'retimed/native/NATIVE-RECEIPT.json','--work':'retimed/admission'}.items(): + need(argv.count(flag) == 1 and argv[argv.index(flag)+1] == work+'/'+path, 'internal admission input '+flag) + rebuilt = records['SOURCE-REBUILD-RESULT.json'] + need(rebuilt['status'] == 'PASS_PUBLIC_SOURCE_REBUILD_654_FILES' and rebuilt['source_manifest_sha256'] == SOURCE and rebuilt['source_files'] == 654, 'fresh source reconstruction') + need(rebuilt['main_commit'] == MAIN and rebuilt['exported_inputs'] == 540, 'pinned main reconstruction') + need(rebuilt['stages'] == [{k:s[k] for k in ['name','exit_code','log_sha256']} for s in top['stages'][:4]], 'source reconstruction stage chain') + native, nr = records['NATIVE-RESULT.json'], records['NATIVE-RECEIPT.json'] + original = lambda name:evidence['files'][name]['original_sha256'] + need(native['status'] == 'PASS_TWO_FRESH_SHARED_KERNEL_NATIVE_CHAINS_AUTHENTICATED_PARENT_REUSE' and native['source_manifest_sha256'] == SOURCE, 'fresh native completion') + need(native['native_receipt_sha256'] == original('NATIVE-RECEIPT.json'), 'native receipt hash chain') + need(nr['status'] == 'PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE' and nr['manifest_sha256'] == SOURCE, 'native receipt source') + need(nr['fresh_current_provider_count'] == 2 and nr['fresh_retained_native_count'] == 0 and nr['fresh_retained_parent'] is False and nr['reused_retained_native_count'] == 2 and nr['reused_retained_parent'] is True, 'fresh changed providers and explicit retained reuse') + need(set(nr['providers']) == set(WORDS), 'exact native providers') + stages(native['stages'], ['fresh-current-base','fresh-current-extra'], 'native') + for row, (kind, word) in zip(native['stages'], WORDS.items()): + fresh = records['NATIVE-'+kind+'-RESULT.json'] + need(row['result_sha256'] == original('NATIVE-'+kind+'-RESULT.json'), 'fresh provider result binding') + need(nr['providers'][kind]['word_sha256'] == fresh['word_sha256'] == word and fresh['status'] == 'PASS_COMPLETE_T74_NATIVE_REPLAY', 'fresh provider word and status') + need([s['step'] for s in fresh['steps']] == NATIVE and all(s['exit_code'] == 0 for s in fresh['steps']), 'five fresh native gates') + admission, release = records['ADMISSION-RESULT.json'], records['RELEASE-RECEIPT.json'] + need(admission['status'] == 'PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE', 'complete nested admission') + need(admission['native_receipt_sha256'] == original('NATIVE-RECEIPT.json') and admission['source_manifest_sha256'] == SOURCE and admission['source_file_count'] == 654, 'nested admission source/native binding') + need(admission['profile'] == PROFILE and admission['replicas'] == 530 and admission['actual_expected_helpers'] == 408, 'nested profile and dimensions') + need(Q(admission['complex_lower']) == C and Q(admission['kappa']) == Q(admission['kappa_decimal']) == K, 'exact modern endpoint') + stages(admission['stages'], INNER, 'admission') + inner_scripts = [work+'/retimed/admission/'+('layout/packing74/replay.py' if name == 'discovery' else 'package/'+path) for name,path in INNER.items()] + need([s['command'][2] for s in admission['stages']] == inner_scripts, 'nested script identities') + need(admission['release_receipt_sha256'] == original('RELEASE-RECEIPT.json'), 'terminal receipt hash chain') + need(release['status'] == 'PASS_RELEASE' and Q(release['kappa_decimal']) == K and release['manifest_sha256'] == admission['package_manifest_sha256'], 'terminal release and runtime manifest') + observed = evidence['local_byte_checks'] + need(observed['source_manifest_sha256'] == SOURCE and observed['source_file_count'] == 654 and observed['main_export_count'] == 540, 'recorded local source checks') + need(observed['package_manifest_sha256'] == admission['package_manifest_sha256'], 'recorded runtime manifest check') + need(observed['literal_rows'] == 1946160 and observed['literal_payload_sha256'] == '9f82e7d4abfcb52cd6d969e37e07415516856d7af85192010f3fc142dbaad246', 'recorded full literal allocation check') + for key, rows in [('top_stages',top['stages']),('admission_stages',admission['stages']),('native_stages',native['stages'])]: + bindings = observed[key] + need([b['name'] for b in bindings] == [s['name'] for s in rows], 'recorded local stage set '+key) + for b, s in zip(bindings, rows): + need(b['log_sha256'] == s['log_sha256'], 'recorded local stage log '+s['name']) + if 'script_sha256' in s: + need(b['script_sha256'] == s['script_sha256'], 'recorded local executed script '+s['name']) + return {'status':'PASS_RECORDED_FRESH_WRAPPER_CHAIN','top_stages':7,'admission_stages':7,'fresh_current_providers':2,'kappa':str(K),'executed_commit':COMMIT,'wrapper_sha256':WRAPPER,'scope':SCOPE} + +def collect(work, attempt, package, log, out): + need(not out.exists(), 'fresh evidence output directory required') + a = read(attempt) + need(a.get('exit_code') == 0 and a.get('finished_at'), 'completed exit-zero attempt required') + need(Path(a['command'][6]).resolve() == work and Path(a['command'][2]).resolve() == package/'reproduce.py', 'requested local run identity') + repo = Path(a['command'][4]).resolve() + need(sha(package/'reproduce.py') == WRAPPER == a['wrapper_sha256'], 'unchanged actual executed wrapper') + need(sha(log) == a['stdout_sha256'], 'actual complete wrapper stdout') + # Check all pre-run public files, without including new documentation/evidence. + for name, expected in a['package_before'].items(): + need(sha(safe(repo,name)) == expected, 'unchanged original publication file '+name) + source = work/'retimed/source' + manifest = read(source/'MANIFEST.json') + need(sha(source/'MANIFEST.json') == SOURCE and len(manifest) == 654, 'actual frozen source manifest') + for name, expected in manifest.items(): + need(sha(safe(source,name)) == expected, 'actual source file '+name) + main = read(package/'MAIN-INPUTS.json') + need(main['base_commit'] == MAIN and len(main['sha256']) == 540, 'actual main export pins') + for name, expected in main['sha256'].items(): + need(sha(safe(work/'main-files',name)) == expected, 'actual main export '+name) + paths = {'ATTEMPT.json':attempt, **{name:work/rel for name,rel in PATHS.items()}} + raw = {name:p.read_bytes() for name,p in paths.items()} + records = {name:json.loads(data) for name,data in raw.items()} + admission = work/'retimed/admission' + native = work/'retimed/native' + runtime = admission/'package' + runtime_manifest = read(runtime/'MANIFEST.json') + runtime_hash = sha(runtime/'MANIFEST.json') + for name, expected in runtime_manifest.items(): + need(sha(safe(runtime,name)) == expected, 'actual admitted runtime '+name) + def bind(rows, base): + need(rows == read(base/'STAGES.json'), 'actual separate stage file identity') + bindings = [] + for s in rows: + script = Path(s['command'][2]); script_hash = sha(script) + log_name = 'native-'+s['name'].removeprefix('fresh-current-') if base == native else s['name'] + log_path = base/(log_name+'.log') + need(sha(log_path) == s['log_sha256'], 'actual stage log '+s['name']) + if 'script_sha256' in s: + need(script_hash == s['script_sha256'], 'actual executed script '+s['name']) + if base == admission: + need(runtime_manifest[INNER[s['name']]] == script_hash, 'executed script in admitted runtime') + bindings.append({'name':s['name'],'script_sha256':script_hash,'log_sha256':s['log_sha256']}) + return bindings + top_bindings = bind(records['WRAPPER-RESULT.json']['stages'],work) + inner_bindings = bind(records['ADMISSION-RESULT.json']['stages'],admission) + native_bindings = bind(records['NATIVE-RESULT.json']['stages'],native) + nr = records['NATIVE-RECEIPT.json'] + need(sha(work/'prepared/predecessor/NATIVE-RECEIPT.json') == nr['retained_reuse_receipt_sha256'], 'actual retained native reuse receipt') + for name, expected in nr['cache_files'].items(): + need(sha(safe(native/'native-cache',name)) == expected, 'actual native cache '+name) + need(sha(native/'ENVIRONMENT.json') == records['NATIVE-RESULT.json']['environment_sha256'], 'actual native environment') + need(sha(work/'retimed/prepare_extension_native.py') == records['NATIVE-RESULT.json']['preparer_sha256'], 'actual native preparer') + with gzip.open(work/'allocation/FILL.json.gz','rb') as f: + fill_bytes = f.read() + fill = json.loads(fill_bytes) + need(fill['columns'] == ['time','helper','owner_replica','child','port','offset'] and not fill.get('dispatch_overrides',[]), 'literal allocation shape') + fill['dispatch_overrides'] = [] + expected_legacy = digest(json.dumps(fill,separators=(',',':')).encode()) + legacy_hash = hashlib.sha256() + with gzip.open(work/'FILL-legacy.json.gz','rb') as f: + for block in iter(lambda:f.read(1024*1024), b''): + legacy_hash.update(block) + need(expected_legacy == legacy_hash.hexdigest(), 'internal legacy fill preserves complete allocation') + ar = records['ADMISSION-RESULT.json'] + for field, rel in [('fill','FILL-legacy.json.gz'),('order','allocation/ORDER.json'),('dispatch','allocation/DISPATCH.json')]: + need(sha(work/rel) == ar[field+'_sha256'], 'admitted literal input '+field) + public = {name:normalized(body) for name,body in raw.items()} + evidence = {'schema':'fresh-public-wrapper-evidence/1','scope':SCOPE, + 'normalization':'Only the local home-directory prefix is replaced by $RESEARCH_WORKSPACE in selected metadata; hashes refer to original raw files unless explicitly public_sha256.', + 'files':{name:{'original_sha256':digest(raw[name]),'public_sha256':digest(body),'normalization':'none' if body == raw[name] else 'workspace-prefix-to-token'} for name,body in public.items()}, + 'local_byte_checks':{'source_manifest_sha256':SOURCE,'source_file_count':654,'main_export_count':540,'package_manifest_sha256':runtime_hash,'runtime_file_count':len(runtime_manifest),'native_cache_files':len(nr['cache_files']),'literal_rows':len(fill['rows']),'literal_payload_sha256':digest(fill_bytes),'top_stages':top_bindings,'admission_stages':inner_bindings,'native_stages':native_bindings}} + validate(records,evidence) + # Nothing is published until every raw-byte and semantic predicate succeeds. + out.mkdir(parents=True) + for name, body in public.items(): + (out/name).write_bytes(body) + (out/'EVIDENCE.json').write_text(json.dumps(evidence,sort_keys=True,indent=2)+'\n') + return check(out) + +def load(root): + evidence = read(root/'EVIDENCE.json') + need(evidence['schema'] == 'fresh-public-wrapper-evidence/1', 'evidence schema') + need(set(evidence['files']) == {'ATTEMPT.json',*PATHS}, 'exact selected receipt set') + records = {} + for name, pin in evidence['files'].items(): + raw = safe(root,name).read_bytes() + need(digest(raw) == pin['public_sha256'], 'public receipt bytes '+name) + need(pin['normalization'] in ('none','workspace-prefix-to-token'), 'normalization rule') + need(b'/Users/' not in raw, 'no original macOS home-directory prefix') + if pin['normalization'] == 'none': + need(pin['original_sha256'] == pin['public_sha256'], 'unchanged receipt hash') + records[name] = json.loads(raw) + return records,evidence + +def check(root): + return validate(*load(root)) + +def controls(root): + records,evidence = load(root) + validate(records,evidence) + mutations = { + 'incomplete_attempt':lambda r,e:r['ATTEMPT.json'].pop('finished_at'), + 'external_allocation':lambda r,e:r['ATTEMPT.json']['command'].extend(['--allocation','/external/allocation']), + 'missing_nested_gate':lambda r,e:r['ADMISSION-RESULT.json']['stages'].pop(4), + 'stale_terminal_receipt':lambda r,e:r['ADMISSION-RESULT.json'].__setitem__('release_receipt_sha256','0'*64), + } + rejected = {} + for name, mutate in mutations.items(): + r,e = copy.deepcopy(records),copy.deepcopy(evidence) + mutate(r,e) + try: + validate(r,e) + except ValueError as exc: + rejected[name] = str(exc) + else: + raise ValueError('control accepted: '+name) + return {'status':'PASS_FOUR_FRESH_EVIDENCE_REJECTION_CONTROLS','controls':rejected,'scope':'Semantic controls bypass public-file hash checks; no scientific replay.'} + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + sub = ap.add_subparsers(dest='action',required=True) + c = sub.add_parser('collect') + for name in ('work','attempt','package','log','out'): + c.add_argument('--'+name,type=Path,required=True) + for name in ('check','controls'): + sub.add_parser(name).add_argument('--root',type=Path,required=True) + args = ap.parse_args() + if args.action == 'collect': + result = collect(*(getattr(args,n).resolve() for n in ('work','attempt','package','log','out'))) + else: + result = (check if args.action == 'check' else controls)(args.root.resolve()) + print(json.dumps(result,sort_keys=True,indent=2)) + +if __name__ == '__main__': + main() diff --git a/research/staged-release-retiming-t530/full-admission/reproduce.py b/research/staged-release-retiming-t530/full-admission/reproduce.py new file mode 100644 index 0000000000..634a3e10dc --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/reproduce.py @@ -0,0 +1,78 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Source-bound retiming derivative; substantial OpenAI Codex assistance. +"""Rebuild exact sources, or run the separate complete scientific replay. + +This separate replay is not the registered bounded summary check. Pass +--materialize-only for fresh source reconstruction alone. The complete replay +retains all original scientific gates and reuses authenticated parent evidence. +""" +import argparse,gzip,hashlib,io,json,os,subprocess,sys,tarfile,time +from pathlib import Path,PurePosixPath +from fractions import Fraction as Q +H=Path(__file__).resolve().parent +MAIN='20ecf2891d80b5acf18d980b2164fb44ea7faa90' +MANIFEST='fb47533a401d1d13719be8b9aab91fe5313931ca62d40dba336eab6a96275aa0' +def need(ok,message): + if not ok:raise ValueError(message) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p):return json.loads(gzip.decompress(p.read_bytes()) if p.suffix=='.gz' else p.read_bytes()) +def export_main(repo,out): + pins=read(H/'MAIN-INPUTS.json');need(pins['base_commit']==MAIN,'frozen main commit') + env=dict(os.environ,GIT_NO_REPLACE_OBJECTS='1') + subprocess.run(['git','-C',str(repo),'cat-file','-e',MAIN+'^{commit}'],env=env,check=True,stdout=subprocess.DEVNULL) + names=sorted(pins['sha256']);raw=subprocess.run(['git','-C',str(repo),'archive','--format=tar',MAIN,'--',*names],env=env,check=True,capture_output=True).stdout + out.mkdir();seen=set() + with tarfile.open(fileobj=io.BytesIO(raw),mode='r:') as tar: + for m in tar: + p=PurePosixPath(m.name) + need(not p.is_absolute() and '..' not in p.parts and '\\' not in m.name,'unsafe Git archive path') + if m.isdir():continue + need(m.isfile() and m.name in pins['sha256'] and m.name not in seen,'exact regular-file export set') + stream=tar.extractfile(m);need(stream is not None,'export bytes');body=stream.read() + need(hashlib.sha256(body).hexdigest()==pins['sha256'][m.name],'frozen input hash '+m.name) + q=out/m.name;q.parent.mkdir(parents=True,exist_ok=True);q.write_bytes(body);seen.add(m.name) + need(seen==set(names),'complete pinned main export') + return len(seen) +def main(): + a=argparse.ArgumentParser(description=__doc__);a.add_argument('--repo',type=Path,default=H.parents[2]);a.add_argument('--work',type=Path,required=True);a.add_argument('--allocation',type=Path);a.add_argument('--materialize-only',action='store_true');x=a.parse_args() + need(__debug__ and not sys.flags.optimize,'assertions must be enabled for inherited scientific code') + repo=x.repo.resolve();work=x.work.resolve();need(not work.exists() and not work.is_relative_to(H),'fresh external work directory');work.mkdir(parents=True) + pins=read(H/'vendor/PR3626-INPUTS.json');need(pins['head']=='659fd5e7064d9466b668d7188cbb013b333a415a','PR3626 exact source head') + original=read(H/'vendor/PR3626-FETCH-PINS.json');need(original['head']==pins['head'],'original fetch provenance') + for path,digest in pins['sha256'].items(): + need(original['sha256'][path]==digest,'published dependency hash') + local=H/'vendor/staged-width-t530'/Path(path).relative_to('research/staged-width-t530');need(sha(local)==digest,'PR3626 input '+path) + frozen=work/'main-files';exported=export_main(repo,frozen) + t530=H/'vendor/staged-width-t530';t8=frozen/'research/t8-rank7-two-swaps';stages=[] + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',PYTHONPYCACHEPREFIX=str(work/'pycache'),PYTHONINTMAXSTRDIGITS='0',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1') + for key in ['PYTHONPATH','PYTHONOPTIMIZE','WITNESS_SPEC','WITNESS_RECORD','WITNESS_DISCOVER']:env.pop(key,None) + def run(label,args,extra_env=None): + start=time.monotonic();cmd=[sys.executable,'-B',*map(str,args)] + with (work/(label+'.log')).open('w') as f:r=subprocess.run(cmd,env=env if extra_env is None else dict(env,**extra_env),stdout=f,stderr=subprocess.STDOUT) + stages.append({'name':label,'command':cmd,'exit_code':r.returncode,'seconds':time.monotonic()-start,'log_sha256':sha(work/(label+'.log'))});(work/'STAGES.json').write_text(json.dumps(stages,indent=2));need(r.returncode==0,label+': inspect its work log') + print('PASS',label,flush=True) + prepared=work/'prepared';retimed=work/'retimed' + run('original-materialization',[t530/'replay.py','--t8-package',t8,'--main-files',frozen,'--work',prepared,'--materialize-only']) + run('retiming-source',[H/'scripts/integrate.py','--parent',prepared/'changed','--out',retimed]) + need(sha(retimed/'source/MANIFEST.json')==MANIFEST,'same frozen654 source') + manifest=read(retimed/'source/MANIFEST.json');need(len(manifest)==654 and all(sha(retimed/'source'/p)==h for p,h in manifest.items()),'complete source payload hashes') + run('preserved-staged-review',[retimed/'source/new/borrow/review_staged3605.py']) + run('new-retiming-review',[retimed/'source/new/borrow/review_release_retime.py']) + summary={'status':'PASS_PUBLIC_SOURCE_REBUILD_654_FILES','source_manifest_sha256':MANIFEST,'source_files':654,'main_commit':MAIN,'exported_inputs':exported,'stages':[{'name':s['name'],'exit_code':s['exit_code'],'log_sha256':s['log_sha256']} for s in stages],'scope':'Fresh exact source reconstruction and reconstruction controls only; no fresh native/controller/outer admission.'} + (work/'SOURCE-REBUILD-RESULT.json').write_text(json.dumps(summary,sort_keys=True,indent=2)+'\n') + if x.materialize_only:print('PASS_PUBLIC_SOURCE_REBUILD_654_FILES');return + old=prepared/'predecessor' + run('fresh-native',[retimed/'prepare_extension_native.py','--source',retimed/'source','--retained-cache',old/'native-cache','--retained-receipt',old/'NATIVE-RECEIPT.json','--out',retimed/'native','--jobs','1']) + allocation=x.allocation.resolve() if x.allocation else work/'allocation' + if x.allocation is None:run('literal-owners',[t530/'owners/portable_expand.py','--out',allocation],{'OWNER_SOURCE_REPO':str(frozen)}) + fill=read(allocation/'FILL.json.gz');need(fill['columns']==['time','helper','owner_replica','child','port','offset'] and len(fill['rows'])==1946160,'complete literal allocation') + need(not fill.get('dispatch_overrides',[]),'no dispatch override');fill['dispatch_overrides']=[];legacy=work/'FILL-legacy.json.gz';legacy.write_bytes(gzip.compress(json.dumps(fill,separators=(',',':')).encode(),mtime=0)) + cmd=[retimed/'admit_extension.py'];vals={'source':retimed/'source','fill':legacy,'order':allocation/'ORDER.json','dispatch':allocation/'DISPATCH.json','native-cache':retimed/'native/native-cache','native-receipt':retimed/'native/NATIVE-RECEIPT.json','work':retimed/'admission','replica-helper-dir':old/'helpers','reconstructor':old/'helpers/reconstruct_replica.py','comparison-claim':old/'PR2969-CLAIM.json','blocknorm-checker':old/'adapters/extension_blocknorm.py'} + for k,v in vals.items():cmd+=['--'+k,v] + cmd+=['--source-profile','staged3605','--comparison-profile','pr2969','--jobs','1'];run('full-admission',cmd) + r=read(retimed/'admission/RESULT.json');need(r['status']=='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE','complete scientific release') + need(Q(r['kappa'])==Q('.001730394391813963415120')-Q(1,10**46)-Q(1,10**70),'exact conditional modern headline') + need(Q(r['kappa'])>Q('.001730071864705779882540')-Q(1,10**46)-Q(1,10**70),'strict improvement over PR3626') + (work/'RESULT.json').write_text(json.dumps({'status':'PASS_RETIMER_T530_COMPLETE_CONDITIONAL_RELEASE','kappa':r['kappa'],'source_manifest_sha256':MANIFEST,'stages':stages},indent=2));print('PASS_RETIMER_T530_COMPLETE_CONDITIONAL_RELEASE',r['kappa']) +if __name__=='__main__':main() diff --git a/research/staged-release-retiming-t530/full-admission/scripts/admit_extension.py b/research/staged-release-retiming-t530/full-admission/scripts/admit_extension.py new file mode 100644 index 0000000000..281bd42f88 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/scripts/admit_extension.py @@ -0,0 +1,419 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Prepare and fully admit a changed-replica literal order/fill derivative. + +PR2833 extension by Yiyang Lu with OpenAI Codex assistance: add the exact +immutable dirt-entry source profile and exact full outer-claim comparisons to +PR2833 and the newer PR2843 T124 allocation. All +inherited native, owner, invoice, block-norm, controls and release checks retained. + +Research runtime only: native providers must already have passed freshly and +are authenticated by --native-receipt. --prepare-only stops before discovery. +Default complete admission preserves the original verify.py and release stages. +Source inputs and the native cache are read-only; all output uses fresh --work. +""" +import argparse +from fractions import Fraction as Q +import gzip +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tarfile +import time + +SOURCE_COMMIT = 'local-joint12-refit393' +SOURCE_MANIFEST = '1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb' +PARENT_MANIFEST = 'e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' +PRECISION = dict(endpoint_digits=24, grid_digits=18, margin_digits=28, bootstrap_steps=12) +COMPARISON_SHA = '252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3' +COMPARISON_HEAD = 'e8b771ba132fe632796b28c1742a8d096c04519f' +NATIVE_STAGES = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases'] +# Supported immutable source versions; CLI selection never accepts arbitrary hashes. +SOURCE_PROFILES = { + 'staged3605': dict(commit='local-staged644-660-two-release-retimings',manifest='fb47533a401d1d13719be8b9aab91fe5313931ca62d40dba336eab6a96275aa0',helpers=408,source_file_count=654,upstream_head='ac92a027c78b0c9bb0ada739b26959afda489d0e'), + 'shared-four': dict(commit='shared-four-kernel-pr2833', manifest='54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869', helpers=408, source_file_count=547, upstream_head='e9307b48d7d1b690939935ecef0f8e524e6d92f4'), + 'preload-move': dict(commit='preload-move-pr2857', manifest='4da246899e2c509dd8c6e5af34905c6124ca17671b188e11ac37e36adf449504', helpers=408, source_file_count=553, upstream_head='e9307b48d7d1b690939935ecef0f8e524e6d92f4'), + 'pr2833': dict(commit='pr2833-dirtentry', manifest='c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f', helpers=408, source_file_count=541, upstream_head='e9307b48d7d1b690939935ecef0f8e524e6d92f4'), + 'pr2766': dict(commit='local-joint12-refit393', manifest='1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb', helpers=415, source_file_count=491, upstream_head='e6df920cd0110e4b629e2ad84eddcb539001e174'), + 'pr2802': dict(commit='local-joint12-pr2733', manifest='9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451', helpers=408, source_file_count=506, upstream_head='17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd'), +} +COMPARISONS = { + 'pr2908': dict(pr=2908,head='51309592971e3b5be935599eed2a95404dc7781e',sha256='2406680a07b43a69b0f12f8462cc43f3616f3c8cb0a46bc767541b45945cd2bf',field='kappa'), + 'pr2917': dict(pr=2917,head='224bd5e56041c40078ff6b5fa7393733a215de5c',sha256='e6c836c0178661a53a69cd91f29d83585e876f2511ff40c6b6204cd270fbdeac',field='kappa'), + 'pr2966': dict(pr=2966,head='e62d3eb9005117d82a9babcfa937ecc53237c490',sha256='4d4c4800bf3bcb36d09021313b2712aebd4aa0830c74dda30991daf6851c220a',field='kappa'), + 'pr2969': dict(pr=2969,head='e2ca469b08385d3d5e29a918d66dbefaf889e9f3',sha256='656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77',field='kappa'), + 'pr2894': dict(pr=2894,head='18d03c447886895ef9abf888398178e0428533ca',sha256='29cd4aa92059a561437d7670b574c51ae4e1cfeaaf6feb6cc318d915869e6d30',field='kappa'), + 'pr2857': dict(pr=2857, head='0b2e2537b368a0cade07ce3f71452ea018ebe394', sha256='c2a04b639c86f462caef654a29817545c57b8e5ba809e37d4d476d3577f5cd6f', field='kappa'), + 'pr2848': dict(pr=2848, head='c50d12e4720cd1fef2b5a65e337e37de9731879a', sha256='aceb1394b3e8f3abcc9b1a0dc82756ab937ffbefc2f37305a229a00ccc5137e9', field='kappa'), + 'pr2843': dict(pr=2843, head='47a7227c044cd0cabb1432a06c61dd5d60c07f5a', sha256='0adc0edfade0260c65e79867b6c8b96f58dfe29d38aa30cfb8f3d5e9c7e828d9', field='kappa'), + 'pr2833': dict(pr=2833, head='e9307b48d7d1b690939935ecef0f8e524e6d92f4', sha256='6f2c4195f0226c5a7f9ba604bc038cfd4100ba3caeeac8ed2defb6fb00632b70', field='kappa_rational'), + 'pr2767': dict(pr=2767, head='e8b771ba132fe632796b28c1742a8d096c04519f', sha256='252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3', field='kappa_rational'), + 'pr2802': dict(pr=2802, head='17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd', sha256='a2fcbc8a3ad3095ecbd310a26c02e9d11c28e4d105669a08bbdfb39d7704db51', field='kappa'), +} + + + +# Discovery records are shared by parallel mutation-audit processes on Windows. +# Only discovery bookkeeping changes; strict pin comparison below it is untouched. +DISCOVERY_APPEND_OLD = " with open(os.environ['WITNESS_RECORD'],'a')as f:f.write(json.dumps([key,got],default=str)+chr(10))" +DISCOVERY_APPEND_NEW = r''' import time as _wr_time + _wr_path=Path(os.environ['WITNESS_RECORD']) + _wr_lock=_wr_path.with_name(_wr_path.name+'.append.lock') + _wr_deadline=_wr_time.monotonic()+60 + _wr_fd=None + while _wr_fd is None: + try:_wr_fd=os.open(_wr_lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY) + except FileExistsError: + if _wr_time.monotonic()>=_wr_deadline:raise TimeoutError('discovery record lock timeout; existing lock preserved') + _wr_time.sleep(.005) + try: + with _wr_path.open('a',encoding='utf-8',newline='\n')as _wr_out: + _wr_out.write(json.dumps([key,got],default=str)+chr(10)) + _wr_out.flush() + finally: + os.close(_wr_fd) + _wr_lock.unlink()''' + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + body = path.read_bytes() + return json.loads(gzip.decompress(body) if path.suffix == '.gz' else body) + + +def write(path, value): + # All output targets belong to this fresh work tree; never unlink an open lock. + lock = path.with_name(path.name + '.lock') + descriptor = os.open(lock, os.O_CREAT | os.O_EXCL | os.O_WRONLY) + try: + os.write(descriptor, str(os.getpid()).encode()) + os.close(descriptor) + descriptor = None + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n', encoding='utf-8', newline='\n') + finally: + if descriptor is not None: + os.close(descriptor) + lock.unlink() + + +def tree(root, exclude=()): + result = {} + for path in sorted(root.rglob('*')): + need(not path.is_symlink(), 'unbound symlink: ' + str(path)) + name = path.relative_to(root).as_posix() + if path.is_file() and name not in exclude: + result[name] = sha(path) + return result + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + for name in ('source', 'fill', 'order', 'dispatch', 'native-cache', 'native-receipt', 'work', 'replica-helper-dir', 'reconstructor', 'comparison-claim', 'blocknorm-checker'): + ap.add_argument('--' + name, type=Path, required=True) + ap.add_argument('--jobs', type=int, default=4) + ap.add_argument('--prepare-only', action='store_true') + ap.add_argument('--source-profile', choices=['staged3605'], default='staged3605') + ap.add_argument('--comparison-profile', choices=['pr2908','pr2917','pr2966','pr2969'], default='pr2908') + a = ap.parse_args() + global SOURCE_COMMIT, SOURCE_MANIFEST, COMPARISON_SHA, COMPARISON_HEAD + source_profile = SOURCE_PROFILES[a.source_profile] + comparison = COMPARISONS[a.comparison_profile] + SOURCE_COMMIT, SOURCE_MANIFEST = source_profile['commit'], source_profile['manifest'] + COMPARISON_SHA, COMPARISON_HEAD = comparison['sha256'], comparison['head'] + expected_helpers, comparison_pr = source_profile['helpers'], comparison['pr'] + need(not sys.flags.optimize and a.jobs > 0, 'enabled assertions and positive jobs required') + source, cache, work = a.source.resolve(), a.native_cache.resolve(), a.work.resolve() + need(not work.exists() and not work.is_relative_to(source) and not work.is_relative_to(cache), + 'fresh external work required') + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST, 'COMPOSED manifest pin') + source_files = read(source / 'MANIFEST.json') + need(len(source_files) == source_profile['source_file_count'] and tree(source, ('MANIFEST.json',)) == source_files, + 'complete COMPOSED source inventory and hashes') + helper_dir = a.replica_helper_dir.resolve() + helper_paths = [helper_dir / n for n in ('lift_parent.py', 'replica_parent.py')] + [a.reconstructor.resolve()] + external_hashes = {str(p): sha(p) for p in helper_paths + [a.fill.resolve(), a.order.resolve(), a.dispatch.resolve(), a.comparison_claim.resolve(), a.blocknorm_checker.resolve()]} + need(sha(a.comparison_claim) == COMPARISON_SHA, 'exact pinned frontier headline comparison') + comparison_claim = read(a.comparison_claim) + need('headline_kappa_source' not in comparison_claim and comparison['field'] in comparison_claim, + 'comparison must be full headline outer claim, not supplier-only CLAIM') + previous = Q(comparison_claim[comparison['field']]) + need(previous == Q(comparison_claim['kappa']), 'comparison rational/decimal equality') + order_input = read(a.order) + need(order_input and all(isinstance(x,list) and len(x)==2 and all(type(v)is int for v in x) for x in order_input), 'literal integer call order') + T = 1 + max(r for st,r in order_input) + need(T > 0 and len(order_input)==9*T and set(map(tuple,order_input))=={(st,r) for st in range(9) for r in range(T)}, 'complete new replica coverage') + need(all([st for st,r in order_input if r==rep]==list(range(9)) for rep in range(T)), 'source stage projection') + dispatch_input = read(a.dispatch) + need(len(dispatch_input)==9*T and {(st,r) for st,r,pid in dispatch_input}==set(map(tuple,order_input)), 'complete explicit dispatch') + native_receipt = read(a.native_receipt) + need(native_receipt['status'] == 'PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE' + and native_receipt['source_commit'] == SOURCE_COMMIT + and native_receipt['manifest_sha256'] == SOURCE_MANIFEST, 'native receipt source binding') + need(tree(cache) == native_receipt['cache_files'], 'complete native/parent cache hashes') + old = source / 'vendor/pr1297' + need(sha(old / 'MANIFEST.json') == PARENT_MANIFEST, 'retained parent pin') + parent_receipt = cache / '_receipts' / PARENT_MANIFEST / 'RECEIPT.json' + need(sha(parent_receipt) == native_receipt['retained_parent_receipt_sha256'], 'parent receipt pin') + pr = read(parent_receipt) + need(pr['vendor_manifest_sha256'] == PARENT_MANIFEST and pr['claim_sha256'] == sha(old / 'CLAIM.json'), + 'parent receipt claim binding') + for name, digest in pr['files'].items(): + need(sha(parent_receipt.parent / name) == digest, 'parent receipt file') + parent_result = read(parent_receipt.parent / 'RESULT.json') + need(parent_result['status'] == 'PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' + and parent_result['kappa'] == read(old / 'CLAIM.json')['kappa'], 'retained parent completed admission') + natives = {} + for tag in ('base', 'extra'): + word = source / ('new/borrow/words/BORROW-WORD-43' + tag + '.json.gz') + entry = cache / sha(word) + binding = native_receipt['providers'][tag] + need(binding['word_sha256'] == sha(word) + and tree(entry, ('CACHE.json',)) == binding['complete_native_files'], 'native full-tree binding') + need(read(entry / 'local/FULL-WORD.json.gz') == read(word), 'native complete word') + stages = read(entry / 'STEPS.json') + need([s['step'] for s in stages] == NATIVE_STAGES and all(s['exit_code'] == 0 for s in stages), + 'native five-stage coverage') + checks = read(entry / 'local/LOCAL-CHECKS.json') + need(all(checks[o]['paid_profile'] == read(word)['report']['local_profile'] for o in ('forward', 'backward')), + 'native actual paid profiles') + natives[tag] = entry + work.mkdir(parents=True) + package = work / 'package' + shutil.copytree(source, package) + # Only the fresh external clone changes. Immutable source/cache inventories remain pinned. + for hp in helper_paths[:2]: + shutil.copy2(hp, package / hp.name) + need(sha(package / hp.name)==external_hashes[str(hp)], 'helper copy hash') + shutil.copy2(a.blocknorm_checker, package / 'blocknorm_certificate.py') + shutil.copy2(a.blocknorm_checker, package / 'code/blocknorm_certificate.py') + need(sha(package / 'blocknorm_certificate.py') == external_hashes[str(a.blocknorm_checker.resolve())], 'block-norm checker exact source binding') + shutil.copy2(a.reconstructor, package / 'reconstruct.py') + need(sha(package / 'reconstruct.py')==external_hashes[str(a.reconstructor.resolve())], 'reconstructor copy hash') + # The original subprocesses also write generated hash-bound source. Windows + # callers use a process-scoped LF adapter; no system configuration is changed. + lf_probe = work / '.lf-preflight.txt' + lf_probe.write_text('LF\n', encoding='utf-8') + need(lf_probe.read_bytes()==b'LF\n', 'process-scoped LF output required on Windows') + lf_probe.unlink() + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONUTF8='1', PYTHONINTMAXSTRDIGITS='0', + OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1', AUDIT_FAST_SHARDS=str(a.jobs)) + for name in ('PYTHONOPTIMIZE', 'WITNESS_SPEC', 'WITNESS_DISCOVER', 'WITNESS_RECORD'): + env.pop(name, None) + stages, patches = [], [] + + def run(name, script, *args): + start = time.monotonic() + command = [sys.executable, '-B', str(script), *map(str, args)] + log = work / (name + '.log') + with log.open('w') as output: + result = subprocess.run(command, env=env, cwd=work, stdin=subprocess.DEVNULL, + stdout=output, stderr=subprocess.STDOUT) + stages.append(dict(name=name, exit_code=result.returncode, seconds=time.monotonic() - start, + script_sha256=sha(script), log_sha256=sha(log), command=command)) + write(work / 'STAGES.json', stages) + need(result.returncode == 0, 'failed ' + name + '; see ' + str(log)) + print('PASS', name, flush=True) + + def patch(name, replacements): + path = package / name + before = sha(path) + body = path.read_text() + for old_text, new_text in replacements: + need(body.count(old_text) == 1, 'exact patch preimage: ' + name + ': ' + old_text[:80]) + body = body.replace(old_text, new_text) + path.write_text(body) + patches.append(dict(path=name, before_sha256=before, after_sha256=sha(path), replacements=replacements)) + + # PR2530's already checked correction: restored zero buffers occupy physical + # rows. COMPOSED's shipped SPEC includes them; its rebound SPEC omitted them. + patch('new/rebind.py', [ + ("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()))")]) + # At T37 the historical fixed333 mutant is a no-op. Preserve the + # undercharge test by subtracting one from both actual charges, and + # require every geometry mutant to differ before the unchanged assembly. + patch('geometry_controls.py', [ + (" 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")]) + # Preserve the exact fixed-grid-maximum equality while deriving precision + # from the same SPEC read by both independent outer arithmetic checkers. + patch('verify_release.py', [ + ('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")]) + # Keep the native dimension and paid moment ledger fixed; bind replica + # width to both the checked source geometry and the independent B invoice. + patch('outer/check_ledger.py', [ + ('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']")]) + patch('code/witness.py', [(DISCOVERY_APPEND_OLD, DISCOVERY_APPEND_NEW)]) + patch('verify.py', [ + ("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')")]) + # A sharper local reserve is certified against actual scalar/Horner + # prefixes of BOTH orientations and BOTH providers. All sweep and physical + # row charges remain unchanged; this never omits an invocation or bridge. + patch('code/witness.py', [ + ("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()")]) + patch('code/invoice_allcold.py', [ + (" 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")]) + patch('independent_core.py', [ + (" 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()")]) + patch('code/invoice_allcold.py', [ + (" 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.")]) + patch('independent_core.py', [ + (" 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")]) + patch('audit_mixed.py', [ + ("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)")]) + patch('code/assemble.py', [ + (" 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 previous, + 'candidate must strictly improve full exact pinned frontier headline before full release') + outer_claim = read(source / 'outer/OUTER-CLAIM.json') + outer_claim.update(kappa=row['decimal'], kappa_rational=row['rational'], + baseline_head=COMPARISON_HEAD, baseline_kappa=str(previous), gain=str(kappa-previous), + b='certified complex_lower - 1e-104 (outer/B.json)', + retuned_slacks='Endpoint precision24; free gaps follow outer/check_ledger.py from the frozen SPEC.', + fixed_grid_maximum='kappa=C-10^-70-10^-46 exactly; same fixed-grid-maximum proof at precision24.') + write(package / 'outer/OUTER-CLAIM.json', outer_claim) + (package / 'provenance').mkdir(exist_ok=True) + shutil.copy2(a.comparison_claim, package / ('provenance/PR' + str(comparison_pr) + '-HEADLINE-CLAIM.json')) + write(package / 'MANIFEST.json', tree(package, ('MANIFEST.json',))) + run('release', package / 'verify_release.py', '--main', source.parents[1], '--work', work / 'release', + '--native-cache', cache, '--jobs', a.jobs) + receipt = read(work / 'release/RELEASE-RECEIPT.json') + need(receipt['status'] == 'PASS_RELEASE' and Q(receipt['kappa_decimal']) == kappa + and receipt['manifest_sha256'] == sha(package / 'MANIFEST.json'), 'complete release binding') + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST + and tree(source, ('MANIFEST.json',)) == source_files and tree(cache) == native_receipt['cache_files'], + 'read-only source/cache inputs changed') + need(all(sha(Path(p))==h for p,h in external_hashes.items()), 'external candidate/helper inputs changed during admission') + result.update(status='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE', + complex_lower=str(C), kappa=str(kappa), kappa_decimal=row['decimal'], + gain=str(kappa-previous), release_receipt_sha256=sha(work / 'release/RELEASE-RECEIPT.json'), + package_manifest_sha256=sha(package / 'MANIFEST.json'), stages=stages, + scope='Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.') + write(work / 'RESULT.json', result) + print(result['status'], row['decimal'], flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/staged-release-retiming-t530/full-admission/scripts/admit_extension.py.patch b/research/staged-release-retiming-t530/full-admission/scripts/admit_extension.py.patch new file mode 100644 index 0000000000..7cca891119 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/scripts/admit_extension.py.patch @@ -0,0 +1,11 @@ +--- PR3626/admit_extension.py ++++ retimed/admit_extension.py +@@ -35,7 +35,7 @@ + NATIVE_STAGES = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases'] + # Supported immutable source versions; CLI selection never accepts arbitrary hashes. + SOURCE_PROFILES = { +- 'staged3605': dict(commit='pr3605-ac92a027c78b0c9bb0ada739b26959afda489d0e',manifest='318ede57c79d10323fb1918f7be4d451d1fcdac01c6456fe9851d51d05d59453',helpers=408,source_file_count=648,upstream_head='ac92a027c78b0c9bb0ada739b26959afda489d0e'), ++ 'staged3605': dict(commit='local-staged644-660-two-release-retimings',manifest='fb47533a401d1d13719be8b9aab91fe5313931ca62d40dba336eab6a96275aa0',helpers=408,source_file_count=654,upstream_head='ac92a027c78b0c9bb0ada739b26959afda489d0e'), + 'shared-four': dict(commit='shared-four-kernel-pr2833', manifest='54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869', helpers=408, source_file_count=547, upstream_head='e9307b48d7d1b690939935ecef0f8e524e6d92f4'), + 'preload-move': dict(commit='preload-move-pr2857', manifest='4da246899e2c509dd8c6e5af34905c6124ca17671b188e11ac37e36adf449504', helpers=408, source_file_count=553, upstream_head='e9307b48d7d1b690939935ecef0f8e524e6d92f4'), + 'pr2833': dict(commit='pr2833-dirtentry', manifest='c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f', helpers=408, source_file_count=541, upstream_head='e9307b48d7d1b690939935ecef0f8e524e6d92f4'), diff --git a/research/staged-release-retiming-t530/full-admission/scripts/integrate.py b/research/staged-release-retiming-t530/full-admission/scripts/integrate.py new file mode 100644 index 0000000000..4a29f851a7 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/scripts/integrate.py @@ -0,0 +1,87 @@ +import copy,gzip,hashlib,json,shutil,sys +from pathlib import Path +import argparse +ap=argparse.ArgumentParser();ap.add_argument('--parent',type=Path,required=True);ap.add_argument('--out',type=Path,required=True);ap.add_argument('--data',type=Path,default=Path(__file__).resolve().parents[1]/'data');a=ap.parse_args() +H=a.data.resolve();P=a.parent.resolve();OUT=a.out.resolve();OUT.mkdir(exist_ok=False) +S=OUT/'source';shutil.copytree(P/'source',S);D=S/'new/borrow' +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def rd(p):return json.loads(gzip.decompress(p.read_bytes()) if p.suffix=='.gz' else p.read_bytes()) +def save(p,x):p.write_text(json.dumps(x,sort_keys=True,indent=2)+'\n') +def tree(p):return {f.relative_to(p).as_posix():sha(f) for f in sorted(p.rglob('*')) if f.is_file() and f!=p/'MANIFEST.json'} +def rep(s,a,b):assert s.count(a)==1,(a,s.count(a));return s.replace(a,b) +oldmanifest=sha(P/'source/MANIFEST.json');assert oldmanifest=='318ede57c79d10323fb1918f7be4d451d1fcdac01c6456fe9851d51d05d59453';assert tree(P/'source')==rd(P/'source/MANIFEST.json') +(D/'release-retime').mkdir() +code='''# SPDX-License-Identifier: Apache-2.0 +# New staged release retiming with substantial OpenAI Codex assistance. +# Builds on Ross Richardson PR3605 and all retained supplier attribution. +import copy,hashlib,json +import preload_move as pm + +def canon(w):return hashlib.sha256(json.dumps(w,sort_keys=True,separators=(',',':')).encode()).hexdigest() +def apply(parent,record): + if canon(parent)!=record['source_canonical_sha256']:raise ValueError('retime source canonical hash') + x=copy.deepcopy(parent) + if [e['index'] for e in record['edits']]!=[591,641]:raise ValueError('exact retiming addresses') + for e in record['edits']: + i=e['index'];old=e['old'];new=e['new'] + if x['B'][i:i+2]!=old:raise ValueError('retime source gate preimage') + if old[0][0]!=old[1][0]!='add':raise ValueError('ADD release') + if old[0][1]==old[1][1] or old[0][2]!=old[1][2]:raise ValueError('commuting distinct targets common source') + if new[0]!=old[1] or new[1][:-1]!=old[0][:-1]:raise ValueError('literal commuting permutation') + if any(i= D_g-(R-1)n_g` follows from the same inequality. A bin of degree R +delivers one unit, all other bins deliver at most one, and each width delivers +exactly I_w. Integral capacities and lower bounds give an integral feasible +flow after the standard circulation reduction. The implemented augmenting-path +algorithm produces this integral flow directly. Removing its selected roles +preserves all three invariants with R replaced by R-1. Repeating constructs S +actual calls, each with every required width count, at most one role from a bin, +and at most n_g roles from each group. + +This argument is an all-parameter written realization lemma under its stated +integer-flow and pattern-size hypotheses. Feasibility of this particular +aggregate witness is finite computation, not an all-parameter packing theorem. + +## Physical owners and endpoint availability + +For a group, the physical stock is exactly S copies of its n_g source bins. +A bin containing any role at macro-time hi requires an owner-copy index at +least the largest call-copy index among those endpoint roles. Other bins have +no lower requirement on their owner-copy index. + +For each j, the number of bins requiring owner index greater than j is at most +the number of endpoint roles assigned to actual call-copy indices greater than +j. The preceding decomposition bounds that number by `(S-1-j)n_g`, exactly the +number of physical bins in those owner copies. These nested Hall inequalities +justify sorting bins by decreasing requirement and assigning the physical +owner copies in decreasing order, with n_g bins per owner copy. The construction +checks every resulting requirement separately. Original owner, child and port +labels are retained when allocating each copy's n_g bins. + +The literal chronology is +`(stage,r) at macro-time t -> (stage,r+37*j) at time S*t+j`. +Provider dispatch is copied along that embedding. If a source window has +noninitial lower endpoint lo, every admitted macro-time satisfies t>=lo+1; +therefore `S*t+j > S*lo+k` for every owner-copy k. For an upper endpoint, +t 33` gates skipping `{22, 40, 54, 63}`, and `R2_E7` at `restore[190:203]`, `13 -> 15` gates skipping `{5, 73}`) on PR #2979's words that serve as the direct starting words for `B_586_438` and `B_588_440`. +- **New here (dcharb78, with AI assistance)**: the two coupled `B` + `restore` dying-helper carrier folds (`B_586_438` and `B_588_440`, `6` hunks / `6 -> 5` gates each) and `helper_final` lowerings on entering helpers `586` ($E_{30} \to V_{30,76,82}$) and `588` ($E_{30} \to V_{30,97,127}$) shifting the helper width inventory from `{4:26, 5:2, 6:16, 7:52, 8:99, 9:213}` to `{4:26, 5:2, 6:18, 7:50, 8:99, 9:213}` (`+665` net profit per helper, `+1,330` joint), the literal `T74_optimal_idle39` allocation (`allocation/FILL.json.gz`), the 21-control per-word edit review (`edits/edits_review.py`) and 100-control four-stage replay (`verify.py`), and the re-derived paid profile, cap certificate (`certificates/RELAX-CAP.json`), and complete fresh-native admission and release receipts. PR #2979 (mdumitrean), PR #3015 (jeremykothe2), and PR #3042 (dcharb78) are credited first. diff --git a/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/UPSTREAM-SOURCE-NOTICE b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/UPSTREAM-SOURCE-NOTICE new file mode 100644 index 0000000000..89c20926ea --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/UPSTREAM-SOURCE-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/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/independent_literal.py b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/independent_literal.py new file mode 100644 index 0000000000..32755776c1 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/independent_literal.py @@ -0,0 +1,128 @@ +# SPDX-License-Identifier: Apache-2.0 +# Adapted from PR3605; retained attribution in UPSTREAM-SOURCE-CREDITS.md. +import sys +if not __debug__ or sys.flags.optimize: + raise RuntimeError("Enabled assertions required before owner replay") +"""Path-adapted copy of the parent independent owner audit. +Original SHA256 1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e. +Filesystem/source authentication and output paths adapted; mathematical predicates retained. +""" +"""Independent vectorized audit of the literal staged-pair owner journal. + +No optimizer, producer, inherited owner checker or reconstructor is imported. +Uses the source execution template and the actual checked native frame tables. +""" +from pathlib import Path +from collections import Counter +import gzip,hashlib,json,os,sys +import numpy as np +R=Path(__file__).resolve().parent +if not __debug__:raise SystemExit('unoptimized Python required') +for _key in ('OWNER_SOURCE_REPO','OWNER_LITERAL_DIR','OWNER_NATIVE_DIR','OWNER_AUDIT_OUTPUT'): + if not os.environ.get(_key):raise SystemExit('missing '+_key) +A=Path(os.environ['OWNER_LITERAL_DIR']).resolve() +NATIVE=Path(os.environ['OWNER_NATIVE_DIR']).resolve() +S=Path(os.environ['OWNER_SOURCE_REPO']).resolve()/'research/rank7-joint-endframes/allocation/vendor' +def need(v,m): + if not v:raise ValueError(m) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def rank(v): + piv={} + for q in v: + while q: + h=q.bit_length() + if h in piv:q^=piv[h] + else:piv[h]=q;break + return len(piv) +for rel,digest in read(R/'ARTIFACTS.json').items(): + f=R/rel;need(f.is_file() and not f.is_symlink() and sha(f)==digest,'frozen audit artifact '+rel) +paths=[A/n for n in ('FILL.json.gz','ORDER.json','DISPATCH.json','PROFILE.json')]+[S/'PLAN.json.gz',S/'TEMPLATE.json.gz'] +paths += [NATIVE/f'checked-{p}/CANONICAL-WORD.json.gz' for p in ('base','extra')] +source_pins=read(R/'SOURCE-PINS.json') +repo=Path(os.environ['OWNER_SOURCE_REPO']).resolve() +for rel,digest in source_pins['repo_files'].items():need(sha(repo/rel)==digest,'retained source pin '+rel) +for tag in ('base','extra'):need(sha(NATIVE/f'checked-{tag}/CANONICAL-WORD.json.gz')==source_pins['native_canonical'][tag]['canonical_sha256'],'actual native canonical pin') +pins={str(p):sha(p) for p in paths} +expected=read(R/'EXPECTED.json');need(hashlib.sha256(gzip.decompress(paths[0].read_bytes())).hexdigest()==expected['payload_sha256'],'freshT530payload') +baseorder=read(R/'ORDER37.json')+[[s,r+37]for s,r in read(R/'T16-ORDER.json')] +need(read(paths[1])==[[s,r+53*cp]for s,r in baseorder for cp in range(10)],'exactmixedsourceclock') +basedispatch={(s,r):p for s,r,p in read(R/'DISPATCH37.json')};basedispatch.update({(s,r+37):p for s,r,p in read(R/'T16-DISPATCH.json')}) +need(read(paths[2])==[[s,r+53*cp,basedispatch[s,r]]for s,r in baseorder for cp in range(10)],'exactsourceproviderdispatch') +order=read(paths[1]);dispatch=read(paths[2]);profile={int(k):v for k,v in read(paths[3]).items()};plan=read(paths[4]);template=read(paths[5]) +T=530;N=9*T +need(len(order)==N and len(set(map(tuple,order)))==N,'call coverage') +clock={tuple(call):t for t,call in enumerate(order)} +need(set(clock)=={(s,r) for s in range(9) for r in range(T)},'exact source calls') +need(all([clock[s,r] for s in range(9)]==sorted(clock[s,r] for s in range(9)) for r in range(T)),'per-replica order') +D={(s,r):p for s,r,p in dispatch};need(len(dispatch)==N and set(D)==set(clock),'dispatch coverage') +need(Counter(D.values())=={'extra': 2090, 'gauge44': 2680},'provider count') +# Reconstruct source windows per replica from the actual source event sequence. +children={x['child']:x['rank'] for x in template['idle_children']};K=max(children)+1 +cap=np.zeros((T,K),dtype=np.int64);lo=np.full((T,K),N,dtype=np.int64);hi=np.full((T,K),-2,dtype=np.int64) +local_pair={x['stage']:x['pair'] for x in template['recipe'] if x['kind']=='local'} +for r in range(T): + touched={};t=None + for ev in template['execution_schedule']: + kind=ev['kind'] + if kind in ('bank_padding_cover_sweep','translate_every_live_family'):continue + if kind=='local_cover_sweep': + t=clock[ev['stage'],r];touched[local_pair[ev['stage']]]=t + elif kind=='bridge': + need(t is not None,'bridge source');touched[ev['src']]=t;touched[ev['dst']]=t + elif kind=='idle_cover_sweep': + need(t is not None,'idle source') + for c in ev['child_indices']: + if c in children: + need(cap[r,c]==0,'unique source child');cap[r,c]=children[c];lo[r,c]=touched.get(ev['pair'],-1);hi[r,c]=t + else:need(kind in ('terminal_Y_translations','terminal'),'known source event') +need(np.all(cap[:,list(children)]>0),'all source windows') +fam=np.full(K,-1,np.int64) +for c in children:fam[c]=2*plan['pairs'][str(c)]+plan['sides'][str(c)] +widths={};L=None +for tag,pid in [('base','gauge44'),('extra','extra')]: + w=read(NATIVE/f'checked-{tag}/CANONICAL-WORD.json.gz') + need(w['R']==408 and len(w['zero_buffers'])==91,'native helper stock') + widths[pid]=np.array([rank(w['frames'][w['final'][224+h]])-rank(w['frames'][w['start'][224+h]]) for h in range(408)],dtype=np.int64) + need(Counter(widths[pid])=={4:26,5:2,6:18,7:52,8:97,9:213},'actual native widths') + loc={int(k):v for k,v in w['local_profile'].items()} + need(L is None or L==loc,'common actual native bill');L=loc +need(L=={1:2439,2:726,3:224,4:102,5:20,8:8},'new local bill') +bycall=np.stack([widths[D[tuple(call)]] for call in order]) +j=read(A/'FILL.json.gz');need(j['columns']==['time','helper','owner_replica','child','port','offset'] and j['dispatch_overrides']==[],'journal schema') +need(all(len(row)==6 and all(type(v) is int for v in row) for row in j['rows']),'literal integer roles') +rows=np.array(j['rows'],dtype=np.int64);del j +need(rows.shape==(N*408,6),'literal role shape') +need(np.array_equal(rows[:,0],np.repeat(np.arange(N),408)) and np.array_equal(rows[:,1],np.tile(np.arange(408),N)),'complete literal ordered helper identities') +t,h,o,c,p,z=rows.T +need(np.all((o>=0)&(o=0)&(c=0)&(p<112)),'owner bounds') +need(np.all(cap[o,c]>0),'declared source child') +need(np.all((lo[o,c]=0)&(z+w<=cap[o,c])),'actual widths and capacity') +binid=(o*K+c)*112+p +idx=np.lexsort((t,binid));bins=binid[idx];ws=w[idx];starts=np.r_[True,bins[1:]!=bins[:-1]] +cs=np.cumsum(ws,dtype=np.int64)-ws;baseline=np.maximum.accumulate(np.where(starts,cs,0));expected=cs-baseline +need(np.array_equal(z[idx],expected),'every chronological pending mask is a compact prefix') +used=np.zeros(T*K*112,np.int64);np.add.at(used,binid,w) +allcap=np.repeat(cap.reshape(-1),112);valid=allcap>0 +need(np.all(used[~valid]==0) and np.all(used<=allcap),'full used-bin mass') +idle=Counter(map(int,(allcap-used)[valid]));idle.pop(0,None) +H=Counter({r:n*N for r,n in L.items()});H.update(idle) +need(dict(H)==profile and sum(r*n for r,n in H.items())==65088*T,'independent complete histogram') +# Small semantic predicates test each independent gate on actual changed inputs. +controls=[] +def reject(name,test): + need(not test(), 'control accepted '+name);controls.append(name) +reject('duplicate helper',lambda: np.array_equal(np.r_[rows[0,1],rows[:-1,1]],np.tile(np.arange(408),N))) +reject('strict lower endpoint used as available',lambda: bool(lo[o[0],c[0]]=0 + i=len(self.to);self.to.extend((v,u));self.cap.extend((int(capacity),0));self.adj[u].append(i);self.adj[v].append(i+1);return i + def maxflow(self,s,t,limit): + total=0;n=len(self.adj) + while total0:net.add(ss,n,b);target+=b + elif b<0:net.add(n,tt,-b) + got=net.maxflow(ss,tt,target) + assert got==target,('copy circulation',copy,got,target,dict(dg),dict(db)) + selected=[];wc=Counter();gc=Counter();bc=set() + for key,e in handles.items(): + n=net.cap[e^1] + assert n in (0,1) + if n: + b,w=key;i=bucket[key].pop();selected.append(i);wc[w]+=1;g=int(bin_group[b]);gc[g]+=1 + assert b not in bc;bc.add(b);db[b]-=1;dg[g]-=1;copies[i]=copy + assert len(selected)==408 and wc==Counter(dict(zip(W,INV))) + assert all(n<=group_n[g] for g,n in gc.items()) + assert max(db.values(),default=0)<=R-1 and all(n<=(R-1)*group_n[g] for g,n in dg.items()) + stats['flows']+=1;stats['max_nodes']=max(stats['max_nodes'],tt+1);stats['max_edges']=max(stats['max_edges'],len(net.to)//2) + return copies,stats diff --git a/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/portable_expand.py b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/portable_expand.py new file mode 100644 index 0000000000..431654fe59 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/portable_expand.py @@ -0,0 +1,126 @@ +# SPDX-License-Identifier: Apache-2.0 +# Adapted from PR3605; retained attribution in UPSTREAM-SOURCE-CREDITS.md. +import sys +if not __debug__ or sys.flags.optimize: + raise RuntimeError("Enabled assertions required before owner replay") +"""Reconstruct the S10 mixedT53 literal owners by deterministic integral networks. +No optimization is run. Requires explicit OWNER_SOURCE_REPO. Expected payload is the fresh independently audited T530 output, never a predecessor owner receipt. +This optional reconstruction takes several minutes and does not run admission. +""" +from pathlib import Path +from array import array +from collections import Counter,defaultdict +import argparse,gzip,hashlib,json,time +import importlib.util +def module(name,file): + spec=importlib.util.spec_from_file_location(name,Path(__file__).resolve().parent/file);m=importlib.util.module_from_spec(spec);spec.loader.exec_module(m);return m +_candidate=module('t530_candidate','verify_candidate.py');candidate_check=_candidate.check;v=_candidate.v +common=v.common;HERE=Path(__file__).resolve().parent;W=v.W;INV=v.INV;LOCAL=v.LOCAL;P=v.P +def check(cert):return candidate_check(cert,'concatenated') +copy_colors=module('t530_network','integral_network.py').copy_colors + +def authenticate(): + pins=common.read(HERE/'INPUT-PINS.json') + for rel,digest in pins.items(): + if common.sha(HERE/rel)!=digest:raise ValueError('changedbuilderinput '+rel) + return pins + +class Rows: + def __init__(self,calls,task_width,task_bin,owner,child,port,order,dispatch,providers): + self.calls,self.width,self.bin,self.owner,self.child,self.port=calls,task_width,task_bin,owner,child,port + self.order,self.dispatch,self.providers=order,dispatch,providers + def __len__(self):return len(self.calls)*408 + def __iter__(self): + offset=array('B',[0])*len(self.owner) + for t,tasks in enumerate(self.calls): + pool=defaultdict(list);pid=self.dispatch[tuple(self.order[t])] + for h,w in enumerate(self.providers[pid]['widths']):pool[w].append(h) + call=[] + for i in sorted(tasks,key=lambda i:(self.width[i],i)): + w=self.width[i];h=pool[w].pop();b=self.bin[i];call.append((h,b,w)) + assert not any(pool.values()) + for h,b,w in sorted(call): + z=offset[b];offset[b]+=w + yield [t,h,self.owner[b],self.child[b],self.port[b],z] + +def write_fill(path,rows): + payload=hashlib.sha256();prefix=json.dumps({'columns':['time','helper','owner_replica','child','port','offset'],'dispatch_overrides':[]},sort_keys=True,separators=(',',':'))[:-1]+',"rows":[' + 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 j,row in enumerate(rows): + data=((',' if j else '')+json.dumps(row,separators=(',',':'))).encode();out.write(data);payload.update(data) + data=b']}\n';out.write(data);payload.update(data) + return dict(rows=len(rows),sha256=common.sha(path),payload_sha256=payload.hexdigest()) + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--out',type=Path,required=True);ap.add_argument('--owner-check',action='store_true');a=ap.parse_args() + pins=authenticate();cert=common.read(HERE/'CANDIDATE.json');primal=check(cert);S=cert['S'];G=cert['groups'];T=53*S + assert T<65536 and S<=128 and len(G)<65536 and 477*S*408<2**32 + c=common.context();order45=cert['order'];win=c.owner.windows(c.template,order45,53);groups=defaultdict(list) + for (o,ch),(cap,lo,hi) in win.items(): + for p in range(112):groups[cap,lo,hi].append((o,ch,p)) + groupkeys=sorted(groups);assert [[*g,len(groups[g])] for g in groupkeys]==G + # Source child windows sharing a physical family are pairwise disjoint. + fw=defaultdict(list) + for (o,ch),(cap,lo,hi) in win.items():fw[o,c.families[ch]].append((lo,hi)) + for intervals in fw.values(): + for j,(lo,hi) in enumerate(intervals):assert all(max(lo,l)>=min(hi,h) for l,h in intervals[j+1:]) + xg=defaultdict(list);zg=defaultdict(list) + for gi,q,n in cert['x']:xg[gi].append((q,n)) + for gi,t,w,n in cert['z']:zg[gi].append((t,w,n)) + task_width=array('B');task_bin=array('I');bin_group=array('H');required=array('b');macro=[array('I') for _ in range(477)];bin_ranges=[] + for gi,g in enumerate(G): + bstart=len(bin_group);available=defaultdict(lambda:array('I')) + for q,n in sorted(xg[gi]): + widths=[w for w,k in zip(W,q) for _ in range(k)] + for _ in range(n): + b=len(bin_group);bin_group.append(gi);required.append(-1) + for w in widths: + i=len(task_width);task_width.append(w);task_bin.append(b);available[w].append(i) + cursor=Counter() + for t,w,n in sorted(zg[gi]): + ids=available[w][cursor[w]:cursor[w]+n];assert len(ids)==n;macro[t].extend(ids);cursor[w]+=n + assert all(cursor[w]==len(ids) for w,ids in available.items()) + assert len(bin_group)-bstart==g[3]*S;bin_ranges.append((bstart,len(bin_group))) + assert len(task_width)==477*S*408 + actual=[array('I') for _ in range(477*S)];group_n={gi:g[3] for gi,g in enumerate(G)};stats=Counter();t0=time.monotonic() + for t,indices in enumerate(macro): + colors,stat=copy_colors(sorted(indices),task_bin,task_width,bin_group,group_n,S) + for i,cp in colors.items(): + actual[S*t+cp].append(i);b=task_bin[i];gi=bin_group[b] + if t==G[gi][2]:required[b]=max(required[b],cp) + stats['flows']+=stat['flows'];stats['max_nodes']=max(stats['max_nodes'],stat['max_nodes']);stats['max_edges']=max(stats['max_edges'],stat['max_edges']) + if t%40==0:print('PORTABLE_CALL_DECOMPOSITION',t,'seconds',round(time.monotonic()-t0,2),flush=True) + assert all(len(call)==408 for call in actual) + owners=array('H',[0])*len(bin_group);children=array('H',[0])*len(bin_group);ports=array('B',[0])*len(bin_group) + for gi,(lo,hi) in enumerate(bin_ranges): + base=groups[groupkeys[gi]];m=len(base) + for j,b in enumerate(sorted(range(lo,hi),key=lambda b:(required[b],b),reverse=True)): + cp=S-1-j//m;o,ch,p=base[j%m];assert cp>=required[b] + owners[b]=o+53*cp;children[b]=ch;ports[b]=p + order=[[s,r+53*cp] for s,r in order45 for cp in range(S)];t8dispatch={(s,r):pid for s,r,pid in common.read(HERE/'T16-DISPATCH.json')};dispatch={(s,r+53*cp):(c.dispatch[s,r] if r<37 else t8dispatch[s,r-37]) for s,r in order45 for cp in range(S)} + providers=common.read(HERE/'PROVIDERS.json') + for provider in providers.values():provider['actual_paid_profile']={int(k):v for k,v in provider['actual_paid_profile'].items()} + for pid,provider in providers.items(): + assert provider['widths']==[w-int(h in (389,397)) for h,w in enumerate(c.providers[pid]['widths'])] + assert provider['actual_paid_profile']==LOCAL + a.out.mkdir(parents=True,exist_ok=False) + for name,obj in [('ORDER.json',order),('DISPATCH.json',[[s,r,dispatch[s,r]] for s,r in order]),('PROFILE.json',cert['profile']),('PROVIDERS.json',common.read(HERE/'PROVIDERS.json'))]: + # The source profile file uses indented sorted-rank formatting. + if name=='PROFILE.json':data=json.dumps({int(k):v for k,v in sorted(cert['profile'].items(),key=lambda kv:int(kv[0]))},indent=2)+'\n' + else:data=json.dumps(obj,separators=(',',':'))+'\n' + (a.out/name).write_text(data) + assert common.sha(a.out/name)==common.read(HERE/'EXPECTED.json')['literal_files'][name],('changedliteralinput',name) + rows=Rows(actual,task_width,task_bin,owners,children,ports,order,dispatch,providers);made=write_fill(a.out/'FILL.json.gz',rows) + expected=common.read(HERE/'EXPECTED.json') + # Container bytes are provenance only: zlib streams may vary across runtimes. + assert made['rows']==477*S*408==expected['rows'] and made['payload_sha256']==expected['payload_sha256'] + assert primal['profile']=={int(k):v for k,v in cert['profile'].items()} + report=dict(status='PASS_STANDARD_LIBRARY_SEMANTIC_LITERAL_REPLAY',replicas=T,calls=477*S,roles=len(rows),physical=896*T+509,materialized=made,decomposition=dict(stats),primal=primal,fresh_retained_owner_check=False,scope='Fresh mixedT53S10 exact integer networks and literal generation. No predecessor owner receipt is reused as candidate proof. Fresh independent literal audit and full release required.') + if a.owner_check: + fill={'columns':['time','helper','owner_replica','child','port','offset'],'dispatch_overrides':[],'rows':rows} + result,_,_=c.owner.check(T,order,fill,dispatch,cert['profile'],c.plan,c.template,providers);report['fresh_retained_owner_check']=True;report['owner_check']=result + (a.out/'PORTABLE-REPLAY.json').write_text(json.dumps(report,indent=2,sort_keys=True)+'\n') + print('PORTABLE_REPLAY_PASS',json.dumps(made),flush=True) + +if __name__=='__main__':main() diff --git a/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/source_context.py b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/source_context.py new file mode 100644 index 0000000000..9731888ac7 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/source_context.py @@ -0,0 +1,32 @@ +# SPDX-License-Identifier: Apache-2.0 +# Adapted from PR3605; retained attribution in UPSTREAM-SOURCE-CREDITS.md. +import sys +if not __debug__ or sys.flags.optimize: + raise RuntimeError("Enabled assertions required before owner replay") +"""Solver-independent integer primal check of the new aggregate owner flow. + +Standard library only. Source geometry is read from the attributed frozen source +template through its retained window routine; literal copied owners are checked +separately. This certifies one finite primal, not LP optimality. +""" +from pathlib import Path +from collections import Counter,defaultdict +import sys,json,gzip,hashlib,os +if not __debug__: + raise SystemExit('unoptimized Python required by retained owner engines') +HERE=Path(__file__).resolve().parent +if not os.environ.get('OWNER_SOURCE_REPO'): + raise SystemExit('OWNER_SOURCE_REPO must identify the declared source checkout or export') +ROOT=Path(os.environ['OWNER_SOURCE_REPO']).resolve() +P=ROOT/'research/coupled-carrier-cap740' +# Authenticate every imported predecessor before executing any of its code. +_pins=json.loads((HERE/'SOURCE-PINS.json').read_text()) +for _rel,_digest in _pins['repo_files'].items(): + _path=ROOT/_rel + if not _path.is_file() or _path.is_symlink() or hashlib.sha256(_path.read_bytes()).hexdigest()!=_digest: + raise ValueError('stale retained source '+_rel) +import types +common=types.ModuleType('staged_owner_retained_common');common.__file__=str(P/'common.py') +exec(compile((P/'common.py').read_bytes(),common.__file__,'exec'),common.__dict__) +W=(4,5,6,7,8,9);INV=Counter(dict(zip(W,(26,2,18,52,97,213)))) +LOCAL={1:2439,2:726,3:224,4:102,5:20,8:8} diff --git a/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/test_owner_guards.py b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/test_owner_guards.py new file mode 100644 index 0000000000..fbe816a2ac --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/test_owner_guards.py @@ -0,0 +1,22 @@ +# SPDX-License-Identifier: Apache-2.0 +import pathlib,json,copy,subprocess,sys,tempfile,shutil,importlib.util +P=pathlib.Path(__file__).resolve().parent +def need(x,m): + if not x:raise ValueError(m) +def main(): + count=0 + with tempfile.TemporaryDirectory()as t: + d=pathlib.Path(t);out=d/'must-not-exist' + for name in ('verify_owner.py','verify_candidate.py','portable_expand.py','independent_literal.py','integral_network.py','source_context.py'): + r=subprocess.run([sys.executable,'-I','-O','-B',str(P/name),'--out',str(out)],capture_output=True,text=True) + need(r.returncode and 'Enabled assertions required'in r.stderr and not out.exists(),'optimized gate '+name);count+=1 + q=d/'corrupt';shutil.copytree(P,q);(q/'CANDIDATE.json').write_bytes((q/'CANDIDATE.json').read_bytes()+b'x') + r=subprocess.run([sys.executable,'-I','-B',str(q/'verify_owner.py')],capture_output=True,text=True);need(r.returncode and 'frozen owner artifact'in r.stderr,'certificate corruption');count+=1 + spec=importlib.util.spec_from_file_location('check_controls',P/'verify_candidate.py');v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v);x=json.loads((P/'CANDIDATE.json').read_text());v.check(x,'concatenated') + for field,value in [('order',x['order'][::-1]),('groups',[]),('inventory',{}),('profile',{})]: + d=copy.deepcopy(x);d[field]=value + try:v.check(d,'concatenated') + except ValueError:count+=1 + else:raise ValueError('accepted semantic corruption '+field) + print('PASS_OWNER_GUARDS',count) +if __name__=='__main__':main() diff --git a/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/verify_candidate.py b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/verify_candidate.py new file mode 100644 index 0000000000..ac74cbc4b8 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/verify_candidate.py @@ -0,0 +1,45 @@ +import sys +if not __debug__ or sys.flags.optimize:raise RuntimeError('Enabled assertions required before owner replay') +from pathlib import Path +from collections import Counter,defaultdict +import json,os,importlib.util,hashlib,argparse +P=Path(__file__).resolve().parent +if not os.environ.get('OWNER_SOURCE_REPO'):raise ValueError('explicitOWNER_SOURCE_REPOrequired') +s=importlib.util.spec_from_file_location('actual_owner',P/'source_context.py');v=importlib.util.module_from_spec(s);s.loader.exec_module(v) +def need(x,m): + if not x:raise ValueError(m) +def check(d,kind): + # Regenerate expectedclock from authenticated actualinputstreams, not candidate fields. + import gzip + pins=json.loads((P/'INPUT-PINS.json').read_text()) + for rel,sha in pins.items():need(hashlib.sha256((P/rel).read_bytes()).hexdigest()==sha,'inputpin') + a=json.loads((P/'ORDER37.json').read_text());b=[[i,j+37]for i,j in json.loads((P/'T16-ORDER.json').read_text())] + if kind=='concatenated':order=a+b + else: + from fractions import Fraction as F + order=[z[2]for z in sorted([(F(2*i+1,666),0,z)for i,z in enumerate(a)]+[(F(2*i+1,288),1,z)for i,z in enumerate(b)])] + need(d['order']==order,'actualsourceclock'); + providers=json.loads((P/'PROVIDERS.json').read_text());pins=json.loads((P/'ARTIFACTS.json').read_text());need(hashlib.sha256((P/'PROVIDERS.json').read_bytes()).hexdigest()==pins['PROVIDERS.json'],'providerpin') + for provider in providers.values(): + need(Counter(provider['widths'])==v.INV,'providerwidths');need({int(k):n for k,n in provider['actual_paid_profile'].items()}==v.LOCAL,'providerlocal') + c=v.common.context();win=c.owner.windows(c.template,order,53);g=Counter();fw=defaultdict(list) + for (o,ch),(cap,lo,hi)in win.items():g[cap,lo,hi]+=112;fw[o,c.families[ch]].append((lo,hi)) + need(all(all(max(lo,l)>=min(hi,h)for l,h in rows[i+1:])for rows in fw.values()for i,(lo,hi)in enumerate(rows)),'disjointfamilywindows') + G=[[*k,n]for k,n in sorted(g.items())];need(d['groups']==G,'actualgroups');S=d['S'];need(type(S)is int and S>0,'positiveintegralS');need(d['widths']==list(v.W),'widths');need({int(k):n for k,n in d['inventory'].items()}==dict(v.INV),'actualinventory') + xb=Counter();xw=Counter();idle=Counter();seen=set() + for gi,q,n in d['x']: + need(type(gi)is int and 0<=gi=0 for z in q)and type(n)is int and n>0,'patternintegers');need((gi,tuple(q))not in seen,'duplicatepattern');seen.add((gi,tuple(q))) + used=sum(w*z for w,z in zip(v.W,q));need(used<=G[gi][0]and sum(q)<=S,'patterncapacity');xb[gi]+=n + for w,z in zip(v.W,q):xw[gi,w]+=z*n + if used0,'flowintegers');need((gi,t,w)not in seen,'duplicateflow');seen.add((gi,t,w));need(G[gi][1]FRONTIER,'must beat published T450, not merely inherited2969 comparison' + (work/'RESULT.json').write_text(json.dumps({'status':'PASS_STAGED_WIDTH_T530_COMPLETE_RELEASE','kappa':result['kappa'],'baselineT450':str(FRONTIER),'gainT450':str(Fraction(result['kappa'])-FRONTIER),'release_receipt_sha256':sha(work/'admission/release/RELEASE-RECEIPT.json'),'stages':stages},indent=2)+'\n');print('PASS_STAGED_WIDTH_T530_COMPLETE_RELEASE') +if __name__=='__main__':main() diff --git a/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/source_builder.py b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/source_builder.py new file mode 100644 index 0000000000..664fc66d18 --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/source_builder.py @@ -0,0 +1,90 @@ +# SPDX-License-Identifier: Apache-2.0 +# Source derivation with substantial OpenAI Codex assistance; inherited authors retained. +"""Private source derivation and strict driver binding. Never runs heavy admission. +Appends PR3605 to authenticated PR3133 source; preserves inherited validators. +""" +import argparse,json,gzip,hashlib,shutil,sys,importlib.util +from pathlib import Path +if not __debug__ or sys.flags.optimize: + raise RuntimeError('Assertions must be enabled for scientific replay') +P=Path(__file__).parent +OLD='fa3e2d855ac5298ecc849e596d79dcef7a72668a276b6524585bc0cd616ce474' +COMMIT='pr3605-ac92a027c78b0c9bb0ada739b26959afda489d0e' +DRIVER_PINS={'prepare_extension_native.py': '0cdb4b8b8b565e3dc4a312d4174c86d7d1aebc531430cb726658c8feb0c3bcf4', 'admit_extension.py': '6ddd449abfc2910e4c91f4ed93e14d65b84e6c1d2a082f3c089ad06f64d1d6ce'} +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p):return json.loads(gzip.decompress(p.read_bytes())if p.suffix=='.gz'else p.read_bytes()) +def save(p,x):p.write_text(json.dumps(x,sort_keys=True,indent=2)+'\n') +def tree(p): + assert not any(x.is_symlink()for x in p.rglob('*')) + return {x.relative_to(p).as_posix():sha(x)for x in sorted(p.rglob('*'))if x.is_file()and x!=p/'MANIFEST.json'} +def replace(s,a,b):assert s.count(a)==1,(a,s.count(a));return s.replace(a,b) +def rank(rows): + piv={} + for x in rows: + assert type(x)is int and x>=0 + while x: + k=x.bit_length()-1 + if k not in piv:piv[k]=x;break + x^=piv[k] + return len(piv) +def main(out,src,pkg,drivers,retained_cache,retained_receipt): + global PKG + PKG=pkg + assert all(sha(drivers/n)==h for n,h in DRIVER_PINS.items()),"driver source pin" + assert not out.exists();assert sha(src/'MANIFEST.json')==OLD and tree(src)==read(src/'MANIFEST.json') + # Frozen package artifacts are independently pinned in upstream ARTIFACTS. + assert sha(PKG/'ARTIFACTS.json')=='867bd848d04505518463eb06b1905e70ccc9256bb73312d3cd1dc57623bb319b', 'frozen supplier artifact index' + assert sha(PKG/'staged_pair.py')=='25fc9b025dbb90358032013303adea650a5f19937fd3edf30b6c6fd023e2d747', 'supplier code before import' + for name,h in read(PKG/'ARTIFACTS.json').items():assert sha(PKG/name)==h + out.mkdir();dst=out/'source';shutil.copytree(src,dst);d=dst/'new/borrow';(d/'staged3605').mkdir() + shutil.copy2(PKG/'staged_pair.py',d/'staged_pair.py') + spec=importlib.util.spec_from_file_location('staged3605',PKG/'staged_pair.py');m=importlib.util.module_from_spec(spec);spec.loader.exec_module(m) + providers=read(dst/'new/BORROW-PROVIDERS.json') + for tag,pid in [('base','gauge44'),('extra','extra')]: + q=d/f'words/BORROW-WORD-43{tag}.json.gz';parent=read(q);record=read(PKG/f'STAGED-PAIR-RECORD-{tag}.json.gz');word=read(PKG/f'STAGED644-660-{tag}.json.gz') + assert m.apply(parent,record)==word + shutil.copy2(q,d/f'inputs/PRE3605-{tag}.json.gz');shutil.copy2(PKG/f'STAGED-PAIR-RECORD-{tag}.json.gz',d/f'staged3605/RECORD-{tag}.json.gz');shutil.copy2(PKG/f'STAGED644-660-{tag}.json.gz',q) + providers[pid]['widths']=[rank(word['helper_final'].get(str(h),[1<index:warp[0]-=1 + else:wrong['B'][index][3]*=-1 + wrong['cleanup']=producer.cleanup(wrong);bad,buffers=endpoint(wrong,audit) + require(any(112<=r<224 for r in bad),'semantic target defect was not rejected') + require(not buffers,'control must retain literal clean-buffer restoration') + controls.append({'helper':helper,'defect':kind,'bad_targets':[r for r in bad if 112<=r<224]}) + out=scratch/'native' + run('transport',NATIVE/'bw_transport.py',word_path,out) + run('residual-adapters',NATIVE/'bw_adapters.py',out/'CANONICAL-WORD.json.gz',out/'RESIDUAL-ADAPTERS.json',out/'LEMMA-A.json') + for name in ('bw_emit.py','bw_audit_local.py','bw_phases.py','bw_check_recipes.py'):run(name,NATIVE/name,out) + residual=json.loads(run('changed-width-phase-controls',HERE/'check_residual.py',NATIVE)) + require(residual['status']=='PASS_EXACT_PAIRED_ENTRANCE_FULL_WIDTH7_RESIDUAL','residual controls');authenticate() + print(json.dumps({'status':'PASS_STAGED_PAIR_LOCAL_CONSTRUCTION','provider':tag,'word_sha256':sha(word_path), + 'local_profile':word['report']['local_profile'],'inventory':word['report']['width_inventory'], + 'independent_inputs':632,'private_buffers':91,'orientations':['forward','dual'], + 'controls':controls+residual['controls'],'stages':stages,'elapsed_seconds':time.monotonic()-started, + 'scope':'Finite exact local word, frame invoice and full native chain; no owner allocation or kappa claim.'},sort_keys=True)) +if __name__=='__main__':main() diff --git a/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/templates/prepare_extension_native.py b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/templates/prepare_extension_native.py new file mode 100644 index 0000000000..ae11fa01cc --- /dev/null +++ b/research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/templates/prepare_extension_native.py @@ -0,0 +1,76 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Two fresh changed-word native chains; explicit authenticated parent reuse. +Yiyang (@Lyy-iiis), with substantial OpenAI Codex assistance. +Derived from the PR2839/PR2848 native preparation lineage, retaining validators. +""" +from pathlib import Path +from concurrent.futures import ThreadPoolExecutor +from importlib import metadata +import argparse,hashlib,json,gzip,os,platform,shutil,subprocess,sys,time +sys.dont_write_bytecode=True +SOURCE_SHA='fa3e2d855ac5298ecc849e596d79dcef7a72668a276b6524585bc0cd616ce474' +SOURCE_FILES=642 +SOURCE_COMMIT='rank7-joint-endframes-pr2917' +PARENT_SHA='e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' +OLD_RECEIPT_SHA='f90cafe84385533a0eeb96356f385b646f402ff85cd05154c47a81c783023d9d' +def need(ok,why): + if not ok:raise ValueError(why) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b)if p.suffix=='.gz'else b) +def write(p,v):p.write_text(json.dumps(v,sort_keys=True,indent=2)+'\n') +def tree(p,exclude=()): + out={} + for f in sorted(p.rglob('*')): + need(not f.is_symlink(),'no cache/source symlinks') + if f.is_file()and f.relative_to(p).as_posix()not in exclude:out[f.relative_to(p).as_posix()]=sha(f) + return out + +def main(): + ap=argparse.ArgumentParser() + for n in ['source','retained-cache','retained-receipt','out']:ap.add_argument('--'+n,type=Path,required=True) + ap.add_argument('--jobs',type=int,default=2);a=ap.parse_args();source=a.source.resolve();out=a.out.resolve();oldcache=a.retained_cache.resolve() + need(not sys.flags.optimize and 1<=a.jobs<=2,'assertions enabled and max2 jobs') + need(sha(source/'MANIFEST.json')==SOURCE_SHA and len(read(source/'MANIFEST.json'))==SOURCE_FILES and tree(source,('MANIFEST.json',))==read(source/'MANIFEST.json'),'complete immutable derived source') + need(not list(source.rglob('__pycache__'))and not list(source.rglob('*.pyc')),'source free of bytecode and cache folders') + before=tree(source);oldreceipt=read(a.retained_receipt) + need(sha(a.retained_receipt)==OLD_RECEIPT_SHA and tree(oldcache)==oldreceipt['cache_files'],'complete PR2848 retained native/cache evidence') + old=source/'vendor/pr1297';need(sha(old/'MANIFEST.json')==PARENT_SHA and tree(old,('MANIFEST.json',))==read(old/'MANIFEST.json'),'unchanged retained source') + prdir=oldcache/'_receipts'/PARENT_SHA;need(sha(prdir/'RECEIPT.json')==oldreceipt['retained_parent_receipt_sha256'],'retained parent receipt identity');pr=read(prdir/'RECEIPT.json') + need(pr['vendor_manifest_sha256']==PARENT_SHA and pr['claim_sha256']==sha(old/'CLAIM.json'),'retained parent source claim') + for name,h in pr['files'].items():need(sha(prdir/name)==h,'retained parent result binding') + need(read(prdir/'RESULT.json')['status']=='PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' and read(prdir/'RESULT.json')['kappa']==read(old/'CLAIM.json')['kappa'],'retained full parent admission') + pstages=read(prdir/'STAGES.json');need(len(pstages)==16 and all(s['exit_code']==0 for s in pstages),'all16 retained parent stages') + need(not out.exists()and not out.is_relative_to(source)and not out.is_relative_to(oldcache),'fresh external native work');out.mkdir(parents=True);cache=out/'native-cache';cache.mkdir() + steps=['native','ledgers','local-replay','wrappers','phases'] + for tag,name in [('base','gauge44-word.json.gz'),('extra','extra-word.json.gz')]: + word=old/name;key=sha(word);need(pr['words'][tag]==key,'retained word hash');entry=oldcache/key + need(read(entry/'local/FULL-WORD.json.gz')==read(word),'retained complete literal word');st=read(entry/'STEPS.json');need([s['step']for s in st]==steps and all(s['exit_code']==0 for s in st),'retained native five stages') + cj=read(entry/'CACHE.json');need(cj['word_sha256']==key and cj['files']==tree(entry,('CACHE.json',)),'retained full native files') + shutil.copytree(entry,cache/key) + shutil.copytree(prdir,cache/'_receipts'/PARENT_SHA) + versions={} + for name in ['numpy','scipy','sympy','mpmath','psutil','gmpy2']: + try:versions[name]=metadata.version(name) + except metadata.PackageNotFoundError:versions[name]=None + write(out/'ENVIRONMENT.json',dict(python=platform.python_version(),executable=sys.executable,dependency_versions=versions,assertions_enabled=True)) + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',PYTHONUTF8='1',PYTHONINTMAXSTRDIGITS='0',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1') + for k in ['PYTHONOPTIMIZE','WITNESS_SPEC','WITNESS_DISCOVER','WITNESS_RECORD']:env.pop(k,None) + driver=source/'new/fastnative/run_native.py';start=time.monotonic();stages=[];words={t:source/('new/borrow/words/BORROW-WORD-43'+t+'.json.gz')for t in ['base','extra']} + def fresh(tag): + word=words[tag];work=out/('fresh-'+tag);cmd=[sys.executable,'-B',str(driver),str(word),str(work)];log=out/('native-'+tag+'.log');begin=time.monotonic() + with log.open('w')as f:r=subprocess.run(cmd,cwd=out,env=env,stdin=subprocess.DEVNULL,stdout=f,stderr=subprocess.STDOUT) + need(r.returncode==0,'fresh native '+tag+' failed; '+str(log));res=read(work/'RESULT.json');need(res['status']=='PASS_COMPLETE_T74_NATIVE_REPLAY'and res['word_sha256']==sha(word),'fresh native result') + entry=cache/sha(word);shutil.copytree(work/'native',entry);need(read(entry/'local/FULL-WORD.json.gz')==read(word),'fresh complete literal word') + st=read(entry/'STEPS.json');need([s['step']for s in st]==steps and all(s['exit_code']==0 for s in st),'fresh native five stages') + checks=read(entry/'local/LOCAL-CHECKS.json');can=read(entry/'local/CANONICAL-WORD.json.gz') + need(can['R']==408 and len(can['centers'])==8 and len(can['zero_buffers'])==91,'complete physical ABI') + for orientation in ['forward','backward']:need(checks[orientation]['all_columns']==632 and checks[orientation]['paid_profile']==read(word)['report']['local_profile'],'actual all-column native profile') + write(entry/'CACHE.json',dict(word_sha256=sha(word),files=tree(entry))) + rec=dict(name='fresh-current-'+tag,exit_code=0,command=cmd,script_sha256=sha(driver),log_sha256=sha(log),result_sha256=sha(work/'RESULT.json'),seconds=time.monotonic()-begin);print('PASS',rec['name'],flush=True);return rec + with ThreadPoolExecutor(max_workers=a.jobs)as pool:stages=list(pool.map(fresh,['base','extra'])) + need(tree(source)==before and tree(oldcache)==oldreceipt['cache_files']and sha(a.retained_receipt)==OLD_RECEIPT_SHA,'read-only input drift') + rec=dict(status='PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE',source_commit=SOURCE_COMMIT,manifest_sha256=SOURCE_SHA,providers={t:dict(word_sha256=sha(w),complete_native_files=tree(cache/sha(w),('CACHE.json',)))for t,w in words.items()},retained_parent_receipt_sha256=sha(cache/'_receipts'/PARENT_SHA/'RECEIPT.json'),cache_files=tree(cache),fresh_current_provider_count=2,fresh_retained_native_count=0,reused_retained_native_count=2,fresh_retained_parent=False,reused_retained_parent=True,retained_reuse_receipt_sha256=OLD_RECEIPT_SHA) + write(out/'NATIVE-RECEIPT.json',rec);write(out/'STAGES.json',stages);write(out/'RESULT.json',dict(status='PASS_TWO_FRESH_SHARED_KERNEL_NATIVE_CHAINS_AUTHENTICATED_PARENT_REUSE',source_manifest_sha256=SOURCE_SHA,native_receipt_sha256=sha(out/'NATIVE-RECEIPT.json'),preparer_sha256=sha(Path(__file__)),environment_sha256=sha(out/'ENVIRONMENT.json'),stages=stages,seconds=time.monotonic()-start,scope='Fresh changed base/extra native chains; two unchanged retained native chains and16-stage parent admission explicitly reused by exact full-tree receipts. No owner/controller/outer admission yet.')) + print('PASS_TWO_FRESH_SHARED_KERNEL_NATIVE_CHAINS_AUTHENTICATED_PARENT_REUSE',flush=True) +if __name__=='__main__':main() diff --git a/research/staged-release-retiming-t530/local-audit/LICENSE b/research/staged-release-retiming-t530/local-audit/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/staged-release-retiming-t530/local-audit/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/staged-release-retiming-t530/local-audit/MANIFEST.json b/research/staged-release-retiming-t530/local-audit/MANIFEST.json new file mode 100644 index 0000000000..81e579131c --- /dev/null +++ b/research/staged-release-retiming-t530/local-audit/MANIFEST.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "sha256": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NATIVE-LINEAGE-NOTICE": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420", + "PUBLIC-INPUTS.json": "e0fae1c1a7aa365acd4b1815f74bd6d588d7829a385f62136cf99ba3dbb9c412", + "README.md": "5882a6746c61aecbd6ad65dc216082506b86465f3a0c3a036ba48aba2f05d1f5", + "SOURCE-PINS.json": "782e6600e68efdb8b753e965f9e0ed87b7ac213b674ce09db14d7f6437edc3ca", + "check_retiming_independent.py": "1d57113431ec7615fc7e3e876b11ea97ee29af21402f9081d44feeb1dff5d541", + "check_retiming_negative.py": "f1d8737aba2fa0ca2fe21eb5454c8e065aa77023826df54d7397bcb83c4e758d", + "receipts/native-base/COMMANDS.json": "f50dabd902fc59059482c7c5ebd7931e8ec1e35137b070ac85f5a3df813fcdef", + "receipts/native-base/RESULT.json": "24a078ef87248b8c590cc9a64d00956d8275098f7109ea70e4952028e15ff5e7", + "receipts/native-base/native/local/INDEPENDENT-LOCAL-REPLAY.json": "f99d4c50632d1cff239ac6f54e4040bc9a7ac66500de9d032c8e9fc5ec42a458", + "receipts/native-base/native/local/LOCAL-CHECKS.json": "11743473efa1822069303b49c62b1853af4236f46ef54b4778a27e2e70d79d06", + "receipts/native-base/native/local/SCALAR-FRAME-AUDIT.json": "21ce6befe785a2143146121457fe394c0d7a1140118b600e6508d2b7ae0ec192", + "receipts/native-base/native/local/WARP-RECIPE-CHECKS.json": "8a0b738edc8ef4c428346e55d74bca08313df104a61b21dbbfcf9dd82c863079", + "receipts/native-base/native/local/WRAPPER-CHECKS.json": "2b8981d41893a2bbbed38ca78fcca7a0f613e50b062861c8f329bd47fa4d3485", + "receipts/native-extra/COMMANDS.json": "087c701235d3fd702b4d928f43240ca7e792473609cb2cf4e0a8c46223624b47", + "receipts/native-extra/RESULT.json": "d5f100c155e13d8360e016c32efd66df0bfadd0fa52bcb3a1f2b1f9cf9e22b9c", + "receipts/native-extra/native/local/INDEPENDENT-LOCAL-REPLAY.json": "8d9013f5060502270b63cb7a6078ab18bf1242a3bb74af7126e3e5b93e3be037", + "receipts/native-extra/native/local/LOCAL-CHECKS.json": "11743473efa1822069303b49c62b1853af4236f46ef54b4778a27e2e70d79d06", + "receipts/native-extra/native/local/SCALAR-FRAME-AUDIT.json": "60fb2027dffde335e62c1fb6fe8d51a9432b70478224fcbbfa0bfe3b7ade4b69", + "receipts/native-extra/native/local/WARP-RECIPE-CHECKS.json": "cb7e8b1d35dc677737ee514f39b96d7d25e0d5d2b0c1d6a6bcafb4c23c91902d", + "receipts/native-extra/native/local/WRAPPER-CHECKS.json": "2b8981d41893a2bbbed38ca78fcca7a0f613e50b062861c8f329bd47fa4d3485", + "vendor/SOURCE-CREDITS.md": "1d9d8f56d8899f55878e4cb2c4e052b22506444016a51c2e678773505f5189e6", + "vendor/SOURCE-NOTICE": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661", + "vendor/audit_local.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "verify.py": "8ed59af3f942cbe2e469434954f74b0d6fedd7b99f09efc2b60e64c2e5a030a7", + "words/RETIMED644-660-base.json.gz": "6df3356808e29909776be8bc0faf03df983401a267c2d740d1ac2dbcaa278269", + "words/RETIMED644-660-extra.json.gz": "65624efec36b35934b750c1741ba2ad4e6df3cff86e44536b0c016ebddb0fb55", + "words/STAGED644-660-base.json.gz": "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653", + "words/STAGED644-660-extra.json.gz": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f" + } +} diff --git a/research/staged-release-retiming-t530/local-audit/NATIVE-LINEAGE-NOTICE b/research/staged-release-retiming-t530/local-audit/NATIVE-LINEAGE-NOTICE new file mode 100644 index 0000000000..380e979f0e --- /dev/null +++ b/research/staged-release-retiming-t530/local-audit/NATIVE-LINEAGE-NOTICE @@ -0,0 +1,14 @@ +Anticipatory dirty borrowing: PR2226 (Cinna Davis / 1337isnot1337, with substantial OpenAI Codex assistance) is credited first. Its alias rule, changed-reference K_G handoffs, initial compensation and exact free-operator replay (vendored under new/code/borrow/vendor, see new/code/borrow/NOTICE-PR2226.md) are applied here to the T74 pivot-566+554 words; the native lowering, window-exact owner fill and independent audit of the borrow words are new in this package. Bootstrap carried-cutoff repair: PR1956 (Josie Elliston); Lemma G label/adapter checks and X/Y/Z mutants: PR1964 (thakrarsagar), extended here with borrow warp/zero-buffer controls. + +New research prepared by Rohan Arun with substantial OpenAI Codex assistance. Apache-2.0. Parent words and build recipe method derive from Jeremy Kothe PR1274 and Rohan Arun PR1218, with lineage credited in README.md. All inherited mathematical qualifications are retained. +Additional pivot555 and567 composition by Rohan Arun with substantial OpenAI Codex assistance. + +T74 exact-fill owner construction by Rohan Arun with substantial OpenAI Codex assistance. + +PR1377 grid refinement credited to Jeremy Kothe. Outer witness refinement by Rohan Arun with OpenAI Codex assistance; construction unchanged. + +Pivot-566 kernel, words, edits, rebuild.py and rebind.py: PR1625 (mdumitrean). Endpoint/outer-witness stacking, fine_cache.py and oracle stage by jeremykothe2 with oh-my-pi assistance. + +The preceding paragraphs are inherited source notices, not attribution of this derivative. +This joint twelve-source construction, generator, independent replay, hosting composition and package: Tekalign (@tekuuu), with substantial OpenAI Codex assistance. No independent human review claimed. +Credits: Cinna Davis/PR2226 anticipatory dirty borrowing; Tekalign/PR2436 four lifted targets; Jeremy Kothe/PR2462,2588,2673 source pipeline, source-label swap and order/fill; zxv/PR2530 eight aliases; Mason Hale/PR2696 concentrated source-partner assignment and independent local interpreter; Philippe Van Velzen/PR2559,2679 evacuation, six pre-life hosts and refit/alias; themilkman216/PR2621 priority order; Marius-Paul Dumitrean/PR2733 independent concentrated/pre-life composition; Vlado Vojdanovski/PR2322 generator utilities. PR2720's fixed-old-path cut obstruction motivates the changed premise. The retained owner/native/bit/modern outer lineage and their notices remain in the pinned source. New work Apache-2.0. diff --git a/research/staged-release-retiming-t530/local-audit/PUBLIC-INPUTS.json b/research/staged-release-retiming-t530/local-audit/PUBLIC-INPUTS.json new file mode 100644 index 0000000000..6b5c686577 --- /dev/null +++ b/research/staged-release-retiming-t530/local-audit/PUBLIC-INPUTS.json @@ -0,0 +1,5 @@ +{ + "schema_version": 1, + "repository_inputs": [], + "dependency_scope": "Self-contained package-local exact scientific inputs and retained source copies. Python standard library only. No network or external repository bytes are read by the registered direct verifier." +} diff --git a/research/staged-release-retiming-t530/local-audit/PUBLICATION-PROVENANCE.json b/research/staged-release-retiming-t530/local-audit/PUBLICATION-PROVENANCE.json new file mode 100644 index 0000000000..a2105b48d3 --- /dev/null +++ b/research/staged-release-retiming-t530/local-audit/PUBLICATION-PROVENANCE.json @@ -0,0 +1,54 @@ +{ + "schema_version": 1, + "source_capsule": "kappa-release-retiming/local-audit", + "scope": "Explicit publication adapter. Original frozen research capsule left unchanged. Original SHA256 identify private original bytes; public SHA256 identify the adapted files and do not assert original-byte identity. No full native/controller/outer scientific pipeline rerun is implied by publication.", + "path_alias": "$RESEARCH_WORKSPACE replaces this session's private task-workspace or user-root prefix in historical command metadata. It is an informational alias, not an executable path.", + "byte_identical_copied_file_count": 22, + "changed_files": [ + { + "path": "MANIFEST.json", + "original_sha256": "58c75d3dff037b3c70e338f142e306aedfd9657f3eb7172af0a937771b76fe3f", + "public_sha256": "8b39c1608513db2811ea25fecdfc24e7b593c5a4a37ab0e52b70d2af3c009917", + "transformation": "Output routing, documentation or publication integrity metadata adaptation; mathematical input unchanged." + }, + { + "path": "README.md", + "original_sha256": "fddb1d3172961310785e25afed89fea80fe55f7b7bf7cbe92086d5d81e5816de", + "public_sha256": "5882a6746c61aecbd6ad65dc216082506b86465f3a0c3a036ba48aba2f05d1f5", + "transformation": "Output routing, documentation or publication integrity metadata adaptation; mathematical input unchanged." + }, + { + "path": "check_retiming_independent.py", + "original_sha256": "8cbcf940d4bad813a372244c22391b1a3d562db7a923e40767cb2070a1458a42", + "public_sha256": "1d57113431ec7615fc7e3e876b11ea97ee29af21402f9081d44feeb1dff5d541", + "transformation": "Output routing, documentation or publication integrity metadata adaptation; mathematical input unchanged." + }, + { + "path": "check_retiming_negative.py", + "original_sha256": "60a51e2e99e567ab5a9e5a19d7d5f965c68760b348ebf5c3b4257cf31dcb68d8", + "public_sha256": "f1d8737aba2fa0ca2fe21eb5454c8e065aa77023826df54d7397bcb83c4e758d", + "transformation": "Output routing, documentation or publication integrity metadata adaptation; mathematical input unchanged." + }, + { + "path": "receipts/native-base/COMMANDS.json", + "original_sha256": "23e51cd91cb01db7e8913ed001bf8225d2aac2c378311e183941289243403c5e", + "public_sha256": "f50dabd902fc59059482c7c5ebd7931e8ec1e35137b070ac85f5a3df813fcdef", + "transformation": "Only private user/workspace path prefixes replaced with $RESEARCH_WORKSPACE. Original execution command bytes are preserved in the non-public capsule; this file is an explicitly normalized publication derivative." + }, + { + "path": "receipts/native-extra/COMMANDS.json", + "original_sha256": "7b9954b5004d62d564274e5ca3e1cbc22bab53416cca60da7edce62c6052757a", + "public_sha256": "087c701235d3fd702b4d928f43240ca7e792473609cb2cf4e0a8c46223624b47", + "transformation": "Only private user/workspace path prefixes replaced with $RESEARCH_WORKSPACE. Original execution command bytes are preserved in the non-public capsule; this file is an explicitly normalized publication derivative." + }, + { + "path": "verify.py", + "original_sha256": "e91ccf3218e0656aba5890aea009b353c191a101d4628a28fdb30c680880eb43", + "public_sha256": "8ed59af3f942cbe2e469434954f74b0d6fedd7b99f09efc2b60e64c2e5a030a7", + "transformation": "Output routing, documentation or publication integrity metadata adaptation; mathematical input unchanged." + } + ], + "omitted_generated_material": [ + "results/: regenerable local proof receipts, negative-control words and logs; generated afresh outside the package by verify.py" + ] +} diff --git a/research/staged-release-retiming-t530/local-audit/README.md b/research/staged-release-retiming-t530/local-audit/README.md new file mode 100644 index 0000000000..797e3186bc --- /dev/null +++ b/research/staged-release-retiming-t530/local-audit/README.md @@ -0,0 +1,73 @@ +# Independent local audit of the two release retimings + +Run from this directory, or invoke `verify.py` by its absolute path from anywhere: + +```sh +python3 -B verify.py +``` + +Python 3.10 or later and the standard library suffice. No network, repository checkout or third-party packages are needed. All input paths are relative to `__file__`; output is written to a fresh temporary directory, or the external directory supplied with `--out /fresh/output`. The expected final line is `PASS_PORTABLE_LOCAL_RETIMING_AUDIT`. + +The verifier authenticates all packaged inputs, runs the separately written minimal scalar/frame proof, freshly replays both complete free-operator words on all 632 arbitrary input columns in both orientations, checks all 91 private zero buffers, and exercises four semantic rejection controls. It also authenticates retained receipts of two complete native replays performed during this research session. The full native implementation is not bundled or rerun by this command. + +## Exact change and proof + +Parent words: [PR3605](https://github.com/CrocSwap/integer-mult-bounds/pull/3605), pinned at `3efbb5de06a49ffeea6684482f2d3fe48cdca3fb`. In both variants, only B, cleanup and `report.local_profile` change. + +At zero-based B indices 591–592, replace + +```text +640 += 2 * 644 at P +496 -= 2 * 644 at P +``` + +with + +```text +496 -= 2 * 644 at P +640 += 2 * 644 at Q +``` + +Here `P = span(429,30)` and `Q = span(423,65,20,10)`. At indices 641–642, similarly exchange `656 -= 660` and `520 -= 2*660`, raising the delayed first gate to `Q' = span(427,96,24,6)`. + +Each pair contains two rational elementary shears with the same source and different targets. The shears commute exactly. No warp intervenes, and none of the six involved registers has a warp. The delayed donor originally traverses the nested frames `span(30) < P < Q`, of dimensions 1, 2, 4; Q is already the next frame used by donor and pivot. Retiming allows a direct donor jump from dimension 1 to dimension 4. The same argument applies to Q'. Cleanup follows canonical inverse-reverse order at FULL. + +Each block replaces `H₁ + H₂` with `H₃`. The total delta is `−2H₁ − 2H₂ + 2H₃`, yielding profile `{1:2437,2:724,3:226,4:102,5:20,8:8}`. For every `0 < a < 1`, `3^(1−a) < 2^(1−a) + 1`, so the recursive moment strictly decreases. This is a structural improvement, rather than decimal rounding. Rank mass remains 5135. Helper identities, entrance/final frames, interfaces, 408 live helpers, 91 private zero buffers and width inventory `{4:26,5:2,6:18,7:52,8:97,9:213}` all remain unchanged. + +## Native evidence and scope + +`receipts/native-{base,extra}/RESULT.json` records two fresh successful five-stage native runs: native, ledgers, local replay, wrappers and phases, including the separate warp-recipe checker. Their independent replay reports cover all 632 live columns, all 91 zero buffers and all 512 warp columns in both orientations. Exact local prefix bounds are: + +| Orientation | Bound | Bits | +| --- | --- | ---: | +| Forward | `202390250292205836324211411723 / 512` | 89 | +| Backward | `4091250694836343058381993950001 / 128` | 95 | + +Both lie below the inherited 128-bit local reserve and 192-bit charged payload. Native events decrease from 22768 to 22766; scalar macros and primitive counts remain unchanged. Public `COMMANDS.json` files replace this session's private user/workspace prefixes with `$RESEARCH_WORKSPACE`. They are publication derivatives, not the original command bytes. `PUBLICATION-PROVENANCE.json` records the original and public SHA256 for every changed copied file. Scientific native result, source and local replay receipts remain byte-identical. The portable verifier does not execute historical commands. + +To rerun the full native implementation, obtain repository commit `20ecf2891d80b5acf18d980b2164fb44ea7faa90`, use Python 3.12 with NumPy, and substitute actual checkout/capsule paths below. Each destination must not already exist: + +```sh +python3 -B /path/to/repository/research/t74-native-fast/run_native.py /path/to/local-audit/words/RETIMED644-660-base.json.gz /path/to/fresh-native-base +python3 -B /path/to/repository/research/t74-native-fast/run_native.py /path/to/local-audit/words/RETIMED644-660-extra.json.gz /path/to/fresh-native-extra +``` + +The driver SHA is in `SOURCE-PINS.json`; each native result retains its full native source manifest. These independent local native runs used Python 3.12.14 and NumPy 2.3.5. The separate integrated admission used Python 3.12.14 and NumPy 2.5.4. + +This capsule proves the local replacement and its strict moment reduction. It does not rerun the global owner/controller/physical/outer release or establish an unconditional integer-multiplication bound. A higher κ still requires source-bound assembly and transfer checks and the source's declared theorem hypotheses. Pending source claims are not promoted here to the repository's selected reviewed baseline. + +## Negative controls + +The inherited checker rejects: (1) raising the first gate while retaining old order, at frame monotonicity; (2) omitting the frame jump while claiming the new invoice, at paid profile; (3) coefficient 2 to 3 with a consistent inverse, at target map; (4) old literal cleanup, at canonical inverse-reverse ordering. The fourth is structural: the old inverse shears also commute, so their old order remains operator-equivalent. + +Mutation words, logs and JSON results are generated under `/negative/`. The minimal proof additionally rejects coefficient, frame and interface mutations. + +## Provenance and license + +The staged suppliers are Ross Richardson's PR3605 contribution, based on dcharb78's PR3133 lineage. The commuting retiming was found by the joint-circuit agent in this session; the minimal proof and packaging were written separately by the fresh-math review agent. No priority is claimed over predecessor suppliers or their mathematics. + +`vendor/audit_local.py` is an unchanged SHA-pinned copy of `research/rank7-coupled-586-588-carrier-fold/vendor/audit_local.py` at the repository commit above; its notice credits icekylinx with OpenAI GPT-6 Astra assistance. The reused native implementation is credited in `NATIVE-LINEAGE-NOTICE`. Inherited notices and credits remain in `vendor/SOURCE-NOTICE` and `vendor/SOURCE-CREDITS.md`. The retained source and this derivative capsule are Apache-2.0 licensed; see `LICENSE`. + +## Publication adapter + +This directory is a public derivative of the preserved local capsule. Only execution-path metadata, output routing and publication documentation were adapted; source words and inherited checkers remain unchanged. No full native replay was repeated by this adapter. The default command writes outside the package; an explicit `--out` must name a new directory outside it. There are no external repository inputs; see `PUBLIC-INPUTS.json`. diff --git a/research/staged-release-retiming-t530/local-audit/SOURCE-PINS.json b/research/staged-release-retiming-t530/local-audit/SOURCE-PINS.json new file mode 100644 index 0000000000..6a5b0d0219 --- /dev/null +++ b/research/staged-release-retiming-t530/local-audit/SOURCE-PINS.json @@ -0,0 +1,15 @@ +{ + "repository": "https://github.com/CrocSwap/integer-mult-bounds", + "main_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "staged_supplier_pr": 3605, + "staged_supplier_commit": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "independent_checker": { + "path": "research/rank7-coupled-586-588-carrier-fold/vendor/audit_local.py", + "sha256": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90" + }, + "native_driver": { + "path": "research/t74-native-fast/run_native.py", + "sha256": "a7bfe110fe5098f6ef8bde3c43ecf15e8d1e06149abf7321a4c945383dcc2627" + }, + "description": "Local research derivative of the pinned staged suppliers: two commuting scalar-release retimings. Pending source claims and inherited theorem hypotheses remain conditional." +} diff --git a/research/staged-release-retiming-t530/local-audit/check_retiming_independent.py b/research/staged-release-retiming-t530/local-audit/check_retiming_independent.py new file mode 100644 index 0000000000..9016f3aa14 --- /dev/null +++ b/research/staged-release-retiming-t530/local-audit/check_retiming_independent.py @@ -0,0 +1,140 @@ +#!/usr/bin/env python3 +"""Independent minimal-delta check for the two release reorderings. + +Standard library only. Does not import the search, builder or frame optimizer. +The native receipts are separately freshly produced by the unchanged credited +t74-native-fast verifier; this script binds their exact input and outputs. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction +from pathlib import Path +import argparse +import tempfile +import gzip +import hashlib +import json + +HERE=Path(__file__).resolve().parent +WORDS=HERE/'words' +SOURCE={ + 'base':'735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653', + 'extra':'886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f'} +FULL=[256,128,64,32,16,8,4,2,1] + +def need(ok,why): + if not ok:raise ValueError(why) + +def sha(path):return hashlib.sha256(path.read_bytes()).hexdigest() + +def read(path):return json.loads(gzip.decompress(path.read_bytes()) if path.suffix=='.gz' else path.read_bytes()) + +def span(vectors): + out={0} + for v in vectors:out|={u^v for u in out} + return out + +def gate_product(gates, registers): + rows={r:{r:Fraction(1)} for r in registers} + for g in gates: + need(g[0]=='add' and g[1]!=g[2],'not an elementary shear') + target,source=g[1:3] + for k,v in list(rows[source].items()): + rows[target][k]=rows[target].get(k,Fraction(0))+Fraction(g[3],g[4])*v + if rows[target][k]==0:del rows[target][k] + return rows + +def local_check(old,new): + need(set(old)==set(new),'top-level schema changed') + need([k for k in old if old[k]!=new[k]]==['B','cleanup','report'],'unexpected changed fields') + expected=deepcopy(old) + blocks=[] + for index,donor,pivot,other,frame in ( + (591,640,644,496,[423,65,20,10]), + (641,656,660,520,[427,96,24,6])): + before=old['B'][index:index+2] + after=new['B'][index:index+2] + need(before[0][1:3]==[donor,pivot] and before[1][1:3]==[other,pivot],'wrong source shears') + need(before[0][-1]==before[1][-1]==[429,30],'wrong source frames') + need(after==[before[1],before[0][:-1]+[frame]],'not the literal commuting reordering') + need(all(rec[0]!=index+1 for rec in old['warps']),'warp crossed between shears') + need(not any(rec[1] in (donor,pivot,other) for rec in old['warps']),'changed-register warp') + need(gate_product(before,[donor,pivot,other])==gate_product(after,[donor,pivot,other]),'operator mismatch') + need(span([30]) 33` gates skipping `{22, 40, 54, 63}`, and `R2_E7` at `restore[190:203]`, `13 -> 15` gates skipping `{5, 73}`) on PR #2979's words that serve as the direct starting words for `B_586_438` and `B_588_440`. +- **New here (dcharb78, with AI assistance)**: the two coupled `B` + `restore` dying-helper carrier folds (`B_586_438` and `B_588_440`, `6` hunks / `6 -> 5` gates each) and `helper_final` lowerings on entering helpers `586` ($E_{30} \to V_{30,76,82}$) and `588` ($E_{30} \to V_{30,97,127}$) shifting the helper width inventory from `{4:26, 5:2, 6:16, 7:52, 8:99, 9:213}` to `{4:26, 5:2, 6:18, 7:50, 8:99, 9:213}` (`+665` net profit per helper, `+1,330` joint), the literal `T74_optimal_idle39` allocation (`allocation/FILL.json.gz`), the 21-control per-word edit review (`edits/edits_review.py`) and 100-control four-stage replay (`verify.py`), and the re-derived paid profile, cap certificate (`certificates/RELAX-CAP.json`), and complete fresh-native admission and release receipts. PR #2979 (mdumitrean), PR #3015 (jeremykothe2), and PR #3042 (dcharb78) are credited first. diff --git a/research/staged-release-retiming-t530/local-audit/vendor/SOURCE-NOTICE b/research/staged-release-retiming-t530/local-audit/vendor/SOURCE-NOTICE new file mode 100644 index 0000000000..89c20926ea --- /dev/null +++ b/research/staged-release-retiming-t530/local-audit/vendor/SOURCE-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/staged-release-retiming-t530/local-audit/vendor/audit_local.py b/research/staged-release-retiming-t530/local-audit/vendor/audit_local.py new file mode 100644 index 0000000000..8224873d04 --- /dev/null +++ b/research/staged-release-retiming-t530/local-audit/vendor/audit_local.py @@ -0,0 +1,501 @@ +"""Independent exact scalar/frame audit of the changed forward supplier. + +This does not import a generator, builder, stored compensation, or price. +All claimed endpoint matrices are derived from the input word's gates. +Optional --main checks the transported boundary against the pinned parent. +Prepared for icekylinx with OpenAI GPT-6 Astra assistance. Apache-2.0. +""" +import argparse,gzip,json,hashlib,time +from pathlib import Path +from fractions import Fraction as F +from collections import Counter + +def require(x,label): + if not x:raise RuntimeError(label) + +def basis(vs): + piv={} + for a in vs: + while a: + bit=a.bit_length()-1 + if bit in piv:a^=piv[bit] + else: + piv[bit]=a;break + for k in sorted(piv): + for j in piv: + if j>k and piv[j]>>k&1:piv[j]^=piv[k] + return tuple(piv[k] for k in sorted(piv,reverse=True)) + +def contained(a,b):return basis(a+b)==b + +def registers(e):return e[1:3] if e[0]=='add' else e[1:2] + +def apply(e,rows,dual=False): + if e[0]=='add': + t,s=e[1:3];q=F(e[3],e[4]);require(t!=s,'self add') + if dual:t,s,q=s,t,-q + dst=rows[t] + for k,x in list(rows[s].items()): + a=dst.get(k,F(0))+q*x + if a:dst[k]=a + else:dst.pop(k,None) + elif e[0]=='scale': + t=e[1];q=F(e[2],e[3]);require(q!=0,'zero scale') + if dual:q=1/q + rows[t]={k:q*x for k,x in rows[t].items()} + else:raise RuntimeError('unknown scalar primitive') + +def invert(e): + r=list(e) + if r[0]=='add':r[3]=-r[3] + else:r[2],r[3]=r[3],r[2] + return r + +def check_parent_interface(word,main): + # Read only the retained boundary data. No builder or local checker is imported. + relative="research/community-k492-audit/pr622/replay/baseline558/complex-global/base/split-centres/CANONICAL-WORD.json.gz" + path=main/relative;raw=path.read_bytes() + require(hashlib.sha256(raw).hexdigest()=="66d3c3c70983224650643a0a05a21ac6c6959f84d0f4528650601016f5a76844",'parent canonical input pin') + parent=json.loads(gzip.decompress(raw)) + tau=lambda x:x^(43 if (x&43).bit_count()%2 else 0) + ports=parent['ports'];v=word['report']['v'] + require(len(ports)==len(set(ports))==v,'parent port count') + require(set(map(tau,word['ports']))==set(ports),'transported source/target ports') + moved={i:ports.index(tau(p)) for i,p in enumerate(word['ports'])} + centers=[moved.get(r,r) for r in word['centers']] + actual=[list(basis([tau(x) for x in frame])) for frame in word['center_frames']] + expected=[parent['frames'][f] for f in parent['center_frames']] + require(len(centers)==len(set(centers))==len(actual)==8,'eight distinct centre carriers') + require(actual==expected and all(len(f)==8 for f in actual),'ordered centre frame interface') + return dict(parent_path=relative,parent_file_sha256=hashlib.sha256(raw).hexdigest(), + transport_tau=43,ordered_frame_bases_match=True,all_ports_match=True, + transported_centers=centers,source_centers=[r for r in centers if r=2*v} + for e in w['precondition']:apply(e,dirt) + compensation=[['add',y,k,-a.numerator,a.denominator,[]] for y in range(v,2*v) for k,a in sorted(dirt[y].items())] + entering=set(map(int,w.get('start_extra',{})));lowends=set(map(int,w.get('helper_final',{}))) + coldends=lowends-entering + require(not any(e[2] in entering for e in compensation),'nonzero entrance response') + require(not any(r in entering|coldends for e in w['precondition']+compensation for r in registers(e)), 'pre-wrapper touch of residual helper') + require(all(e[-1]==[] for e in w['precondition']+compensation),'nonzero frame precondition') + early=w.get('early_cleanup',[]);earlyids={i for i,U in early} + require(len(earlyids)==len(early),'duplicate early cleanup gate') + tail=[w['cleanup'][i][:-1]+[U] for i,U in early] + cleanup=[e for i,e in enumerate(w['cleanup']) if i not in earlyids] + prefix=w['precondition']+compensation+main + program=prefix+tail+cleanup + for dual in (False,True): + actual=ident() + for e in program:apply(e,actual,dual) + expected=ident() + for t in range(v):expected[t if dual else v+t][v+t if dual else t]=F(-1 if dual else 1) + bad=[i for i in range(n) if actual[i]!=expected[i]] + require(not bad,'all-column endpoint failure '+str((dual,bad[:8]))) + print('endpoint', 'dual' if dual else 'forward','PASS',flush=True) + full=basis([1<>=1;i+=1 + return y + +def ginv(cols,h): + # inverse columns over F2 (None if singular), Gauss-Jordan on (G | I) column-wise + piv={}; + for i in range(h): + a=cols[i];b=1<>s&1:a^=piv[s][0];b^=piv[s][1] + if a:return None + pre.append(b) + return pre # pre[t] = G^{-1}(e_t) + +def gtrans(cols,h): + # transpose: column j of G^T = row j of G + return [sum(((cols[i]>>j)&1)< E (used for B-phase warps and for A-phase prelude warps)""" + inv=ginv(cols,h);require(inv is not None,'G not invertible') + require(all(gmul(cols,inv[t])==1<(Gx, (G+G^-T)x + G^-T z) + GiT=gtrans(inv,h) # G^{-T}: columns j = row j of G^{-1} + # G^{-T}(z): via columns GiT + def M(vec): + x=vec&((1<>h + gx=gmul(cols,x);S=gx^gmul(GiT,x) # (G + G^{-T}) x + return gx|((S^gmul(GiT,z))<>h)|((vec&((1<0)-(op<0))*(abs(op)+dsym)) + walg_add(rows[src],row,-c) + return + if e[0]=='warp': + op=e[2];s=(op>0)-(op<0) + if dual:op=s*(abs(op)+dsym) # dual orientation: K_G^{-T} is a distinct free symbol + rows[e[1]]=walg_warp(rows[e[1]],op);return + if e[0]=='add': + t,s=e[1:3];q=F(e[3],e[4]);require(t!=s,'self add') + if dual:t,s,q=s,t,-q + walg_add(rows[t],rows[s],q) + else: + t=e[1];q=F(e[2],e[3]);require(q!=0,'zero scale') + if dual:q=1/q + rows[t]={k:q*x for k,x in rows[t].items()} + +def invert_item(e,full): + if e[0]=='warp':return ['warp',e[1],-e[2]] + r=list(e) + if r[0]=='add':r[3]=-r[3] + else:r[2],r[3]=r[3],r[2] + return r + +def run_borrow(path,out,main,base,w,data,begin): + v,h,R=w['report']['v'],w['report']['h'],w['report']['R'];n=2*v+R + require((v,h)==(112,9),'wrong source geometry') + require(main is None,'--main parent interface is not available for coordinate-changed BORROW-WORD; use --base') + full=basis([1<=2*v,'correction source must be a remaining helper') + require(s not in entering,'correction source has nonzero entrance frame') + require(len(word)>=1 and all(1<=abs(o)<=K for o in word),'correction operator word') + require(c!=0 and c.denominator&(c.denominator-1)==0,'correction coefficient') + # the source is the lender of the operator it is read through + require(all(warps[abs(o)-1][1]==s for o in word),'correction source is not the lender of its operator') + # --- 4. frames: literal chain, monotone, paid profile --------------------------------------- + end=[full]*v+[basis([x for x in range(1,1<0 else list(to_),list(to_) if op_>0 else list(fr_),h) + require(cur[r_]==basis(fr_),'prelude warp frame mismatch '+str((r_,op_))) + cur[r_]=basis(to_) + else: + for q in registers(e):climb(q,e[-1]) + for e in Aord: + for q in registers(e):climb(q,e[-1]) + lev={int(t):basis(U) for t,U in w.get('target_levels',{}).items()} + require(all(cur[v+t]==lev.get(t,()) for t in range(v)),'target centre levels') + for q,U in zip(w['centers'],w['center_frames']): + U=basis(U);require(cur[q]==U,'center frame') + served={lev.get(e[1]-v,()) for e in w['cut'] if e[2]==q} + for T in sorted(served,key=lambda x:-len(x)): + require(contained(T,U),'center path not nested') + if T!=U:paid[len(U)-len(T)]+=1 + U=T + byposition={} + for op,rec in enumerate(warps,1):byposition.setdefault(rec[0],[]).append(op) + B=w['B'];forward=[] # chronological program of the (recorded) non-target word + for e in Aord:forward.append(e) + for p in range(len(B)+1): + for op in byposition.get(p,[]): + _,lender,cols,U,E=warps[op-1] + require(cur[lender]==basis(U),'warp frame mismatch '+str((op,lender,cur[lender],basis(U)))) + cur[lender]=basis(E);forward.append(['warp',lender,op]) + if p 0. +DIG=spec['outer_refinement']['endpoint_digits'] # the supplier endpoint is certified to 10^-DIG (accept at the endpoint, reject at endpoint + 10^-DIG); every slack sits 10 digits below +# Fixed-grid maximum (PR2180 / PR2161, dataisfire; proof PROOF-GRID-MAX.md): the free gaps shrink together to R0 = 10^-(DIG+80); grid, backoff and certified endpoint are unchanged. +R0=Q(1,10**(DIG+80)); ZETA=R0/100; SLACK=R0; GAP=R0; STOP=R0/10**6 +FLOOR=10**(DIG+46); BACKOFF=Q(1,10**(DIG+22)); B_GAP=R0 +# Fine prime padding: theta is between 1/(4p^2) and 1/(2p^2-1). +# Online chirp guard beta+2*xi-2<1; coefficient setup uses O(p^2 log p) bits. +# epsilon = 1 - DELTA_E is a FREE parameter (outer/FINE-PADDING-COMPOSITION.md sec. 2): every row is strictly satisfied for every DELTA_E > r0 = 10^-(DIG+80); beta = 1 - 3 DELTA_E lies in the admissible window +# [1 - DELTA_E (1 + 1/q), 1 - 2 DELTA_E). DELTA_E = (1025/1024) r0 keeps the gamma spare power 1-eps-r0 = r0/1024 > 0 and puts C - eps*q below 1/FLOOR (PROOF-GRID-MAX.md). +DELTA_E=Q(1025,1024)*R0 +EPS=1-DELTA_E +BETA=1-3*DELTA_E +THETA_POWER=Q(2) +HALO_POWER=48 +CORE_POWER=128 +STRASSEN_TAU=Q(45,16) +KAPPA_1828=Q('0.0016797549561255445213356709939207025769983114385025802954603275201627999999999999999999999999979966404900867489109573286580121585') # exact kappa of rohanarun's PR1828 (slack refinement of PR1800 at 1e-96), from its body +KAPPA_1839=Q('0.0016797549561255445213356709939207025769983114385025802954603275201628645482603256388263049999999997996640490086748910957328658012158594') # exact kappa of PR1839 (previous package: 1e-90 endpoint) +KAPPA_1875=Q('0.0016797549561255445213356709939207025769983114385025802954603275201628645482603256388263056561328446322744513169085862209720704481201654121427713006366929567157349625273906229277148454180995537563371124755588139767841405530386745578819565618798006892541712197674874836946756930569827889227573192555649999999997996640490086748910957328658012158594') # exact kappa of rohanarun's PR1875 (1e-300 endpoint), from its body +KAPPA_1876=Q('0.001679754956125544521335670993920702576998311438502580295460327520162864548260325638826305656132844632274451316908586220972070448120165412142771300636692956715734962527390622927714845418099553756337112475558813976784140553038674557881956561879800689254171219767487483694675693056982788922757319255565606685566411725238449650999339827075715283714270157705762309226038611771955655377501414652136546310799999999999999999997996640490086748910957328658012158594846') # exact kappa of rohanarun's PR1876 (1e-400 endpoint), from its body +KAPPA_1897=Q('0.001679754956125544521335670993920702576998311438502580295460327520162864548260325638826305656132844632274451316908586220972070448120165412142771300636692956715734962527390622927714845418099553756337112475558813976784140553038674557881956561879800689254171219767487483694675693056982788922757319255565606685566411725238449650999339827075715283714270157705762309226038611771955655377501414652136546310881185746917580802513640545967852810801680966856133978576162943792322682482152988532923811998938861379689883167389728443314312230815059559906903773756886872476136837071871203030423643505345473735135533') # exact kappa of M6LI's PR1897 (1e-500 grid), from its body +KAPPA_1786=Q('0.0016797547881500489087805478664999999999999999999999999999999998000000199999') # exact kappa of chafreaky's PR1786 ledger (EXPECTED-BALANCE.json), headline 0.001679754788150048 +KAPPA_PKG5=Q('0.001677992607205282520732088774830808372222877897034109604209719298829805473412451530867883424937597') # previous package (rectangular k=2, tau_eff=2.2500351) +KAPPA_PKG4=Q('0.0016778199023144364336310551358776001013829401215770658599799349282716974076737897457922714197448847') # previous package (radix union schedule, square boundary tau=2.372864) +KAPPA_1712=Q('0.0016776417313433545642517275958639984231708545722735432722117400060454625429077941422798526440584702') # pkg of PR1712 (Le Gall tau=12/5, old union row) +KAPPA_1699=Q('0.001677641731343354564251058287063644749065568493') # exact kappa of PR1699's ledger (Chafik Boukhalfa), same supplier profile +certified_complex=Q(spec['expected']['complex_lower']) +bit=Q('0.001733427039589844234749') +# Keep short independently checkable decimals strictly inside both endpoints. +b=certified_complex-B_GAP # strictly inside the certified supplier endpoint; B.json carries the same exact value +assert b==Q(BJ['b']) +q=b-GAP +a=(q+b)/2 +online=Q(spec['expected']['kappa']) +old=Q('0.001673360105405778') +assert b0 +assert m==73 and W==896*T and W==BJ['live'] +EXPECTED_PROFILE={int(k):v for k,v in BJ['profile'].items()} +assert profile==EXPECTED_PROFILE + +GB=int((DIG+130)*3.3220)+16 # enclosure grid 2^-GB, about 50 digits below the slacks +ONE=1<=2:x/=2;k+=1 + lo,hi=unit_log(x) + return down(lo+k*ln2[0]),up(hi+k*ln2[1]) +def exp(x): + assert 0<=x>GB)//j;th=_cd(-((-th*xu)>>GB),j);sl+=tl;sh+=th + tn=_cd(-((-th*xu)>>GB),EN) # x^EN/EN! (rounded up); the tail is at most twice this + return Q(int(sl),ONE),Q(int(sh+2*tn+2),ONE) +def moment(endpoint): + lo=hi=Q(0) + for r,n in profile.items(): + l,h=log(Q(m,r)); weight=Q(n*r,m*W) + lo+=weight*exp(endpoint*l)[0] + hi+=weight*exp(endpoint*h)[1] + return down(lo),up(hi) + +native=moment(b) +assert native[1]<1 +b_up=Q(BJ['b_above_endpoint']) +assert b_up>certified_complex and moment(b_up)[0]>1 # a larger test endpoint is rejected + +def ledger(kind, *, q_=q, zeta=ZETA, slack=SLACK, + old_scan=False, full_gauge=False, full_key=False, old_union=False, old_theta=False, old_linear=False, old_tag=False, + eps_=EPS, beta_=BETA, tau_eff=STRASSEN_TAU, halo_power=HALO_POWER, core_power=CORE_POWER): + r=R0; stop=STOP + # Existing explicit Strassen format, 7^16<2^45; c=3/32. + # Union: radix-distributed schedule (outer/UNION-SCHEDULE.md, new in this package): row exponent eps+1/2-xi. The boundary row binds with main; the Gaussian row has slack at this explicit point. + c=(3-tau_eff)/2 + eps=eps_; beta=beta_ + xi=eps*(1+q_)-c+slack + saving=eps*q_ + # Deliberate strict gap (BACKOFF) after decimal truncation to the FLOOR grid. + kappa=Q((saving*FLOOR).__floor__(),FLOOR)-BACKOFF + # kappa is derived, not silently asserted to equal an expected decimal. + tau=1-a; sigma=1-b + internal=tau+(1-stop)*max(sigma-tau,Q(0)) + leaf=sigma+stop*(1-sigma) + lam=1-(q_+a)/2 + key=beta+1-eps + margins={ + 'main_transform':saving, + 'global_coordinate_router':a, + 'fused_gaussian':1-eps+q_*beta, + 'group_bit_router':1-eps+a*beta, + 'group_scans':1-eps+beta, + 'boundary_algebraic_matrix':c+xi-eps, + 'sparse_union_movement':xi+Q(1,2)-eps, + 'polynomial_products':eps, + 'microbox_face_corrections':1-(eps+beta+halo_power-core_power+2), + } + if old_union:margins['old_g_factor_union_row']=1-eps-beta-Q(1,2)+xi + if old_scan:margins['old_per_axis_scan']=1-eps + if full_key:margins['unnecessary_full_key_sort']=margins['sparse_union_movement']-key + checks={ + 'actual_bit_above_effective':bit-a, + 'complex_above_effective':b-a, + 'q_positive':q_, 'complex_endpoint':b-q_, + 'q_below_effective':a-q_, 'stop_positive':stop, + 'stop_below_one':1-stop, + 'leaf_saving_above_effective':(1-stop)*b-a, + 'q_below_internal':1-internal-q_, 'q_below_leaf':1-leaf-q_, + 'lambda_above_tau':lam-tau, 'lambda_above_sigma':lam-sigma, + 'lambda_above_internal':lam-internal, + 'lambda_prime_above_lambda':1-q_-lam, + 'lambda_prime_above_leaf':1-q_-leaf, + 'epsilon_positive':eps,'epsilon_below_one':1-eps, + 'cap_above_band':xi-Q(1,2),'cap_below_cell':eps-xi, + 'group_positive':beta,'group_below_dimension':eps-beta, + 'support_router_span':1-beta, + 'group_gauge_power_slack':1-(2*xi-THETA_POWER)-r-beta, + 'actual_logarithmic_group_guard':1-(2*xi-THETA_POWER)-beta, + 'global_gamma_power_slack':1-eps-r, + 'actual_logarithmic_gamma_guard':1-eps, + 'alpha_logarithm_absorption':r, + 'group_key_fits_record':1-key, + 'membership_arithmetic_fits_record':1-beta-2*(1-eps), + 'microbox_halo_volume':core_power-halo_power-beta, + 'positive_layout_slack':slack, + 'short_record_fallback':eps-a, + 'improvement_over_online_final':kappa-online, + 'improvement_over_previous_local_final':kappa-old, + 'complex_below_one_over_32':Q(1,32)-b, + } + checks['strassen_integer_power_gap']=Q(2**tau_eff.numerator-7**tau_eff.denominator) + checks['theta_positive_polynomial_power']=THETA_POWER + checks['cap_below_phase_cell_power']=THETA_POWER-xi + checks['halo_covers_generic_inverse_radius']=Q(halo_power-43) + checks['union_tag_work_per_visit_fits_record']=1-beta + checks['union_header_fits_record']=1-beta + checks['source_axis_superpolynomial']=1-eps + checks['improvement_over_pr1786']=kappa-KAPPA_1786 + checks['improvement_over_pr1828']=kappa-KAPPA_1828 + checks['improvement_over_pr1839']=kappa-KAPPA_1839 + checks['improvement_over_pr1875']=kappa-KAPPA_1875 + checks['improvement_over_pr1876']=kappa-KAPPA_1876 + checks['improvement_over_pr1897']=kappa-KAPPA_1897 + checks['improvement_over_pr1758']=kappa-Q('0.001679745508802299051546533685199973672313473419790800679752457380932784242972585600630181672224983') + checks['improvement_over_pr1699']=kappa-KAPPA_1699 + checks['improvement_over_pr1712']=kappa-KAPPA_1712 + checks['improvement_over_previous_package']=kappa-KAPPA_PKG4 + checks['improvement_over_pkg_k2']=kappa-KAPPA_PKG5 + if full_gauge:checks['unrecentered_group_gauge']=1-THETA_POWER-r-beta + if old_theta:checks['old_theta_chirp_guard']=1-(2*xi-eps)-r-beta + if old_linear:checks['old_linear_guard']=1-xi-r-beta + if old_tag:checks['old_union_tag_2beta']=1-2*beta + # Main-binding family invariant (PR2180): the Gaussian saving stays above the main saving. The fixed kappa grid (FLOOR) is coarser than the free gaps, + # so the *_above_kappa rows alone would no longer exclude a beta outside the main-binding window; this row is delta*(1-2q) > 0. + checks['gaussian_above_main']=margins['fused_gaussian']-saving + checks.update({n+'_above_kappa':v-kappa for n,v in margins.items()}) + assert margins['boundary_algebraic_matrix']==saving+slack + assert margins['sparse_union_movement']==saving+slack+(tau_eff-2)/2 + return {'kind':kind,'kappa':kappa,'epsilon':eps,'xi':xi,'beta':beta, + 'q':q_,'a':a,'r0':r,'zeta':zeta,'slack':slack, + 'margins':margins,'strict_checks':checks} + +def encode(x): + if isinstance(x,Q): + with localcontext() as c: + c.prec=DIG+200 + return {'rational':str(x),'decimal':str(Decimal(x.numerator)/Decimal(x.denominator))} + if isinstance(x,dict):return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)):return [encode(v) for v in x] + return x + +rows={};controls={} +for kind in ['struct_boundary_radix_union']: + row=ledger(kind) + assert all(v>0 for v in row['strict_checks'].values()) + assert min(row['margins'].values())==row['margins']['main_transform'] + # fixed-grid maximum: C*FLOOR is an integer and 0 < C - eps*q < 1/FLOOR, so floor(FLOOR*eps*q)/FLOOR = C - 1/FLOOR exactly and kappa attains the grid/backoff ceiling + assert (certified_complex*FLOOR).denominator==1 and 0= 1/(4 p^THETA_POWER)), an exponential factor <= p^2 eventually, +# alpha^5 polylogarithmic; a further half power is allowed for the polylogarithmic and bounded-constant factors of the augmented matrices. The umbrella must exceed that budget. +UMBRELLA_POWER=10 +def umbrella_margin(theta_power):return UMBRELLA_POWER-(2*theta_power+2+Q(1,2)) +assert umbrella_margin(THETA_POWER)>0 and umbrella_margin(Q(15,4))<=0 # control: the umbrella would fail silently for THETA_POWER >= 3.75 +HALO_UMBRELLA={'umbrella_power':UMBRELLA_POWER,'theta_power':THETA_POWER,'exponent_budget':2*THETA_POWER+2+Q(1,2),'margin':umbrella_margin(THETA_POWER),'fails_from_theta_power':Q(15,4)} +out={'status':'PASS_FINE_PRIME_PADDING_EXACT_ARITHMETIC', + 'scope':'Conditional fine-prime padding composition. Fresh native admission is required by verify.py. The cited prime theorem, written gauge-free theorem and inherited all-size interfaces are not proved by this arithmetic. No independent human review is claimed.', + 'geometry_changes':{'theta_power':THETA_POWER,'halo_power':HALO_POWER,'core_power':CORE_POWER,'matrix_exponent':STRASSEN_TAU}, + 'halo_umbrella':HALO_UMBRELLA,'complex_lower_short':b,'complex_lower_pinned':certified_complex, + 'native_moment':native,'profile':profile,'m':m,'W':W, + 'online_final_kappa':online,'rows':rows,'rejecting_controls':controls, + 'pr1673_kappa':Q('0.001677160151714381'),'improvement_over_pr1673':rows['struct_boundary_radix_union']['kappa']-Q('0.001677160151714381'), + 'source_sha256':{p.relative_to(WORK).as_posix():hashlib.sha256(p.read_bytes()).hexdigest() for p in [SPEC,CLAIM]}} +(HERE/'LEDGER.json').write_text(json.dumps(encode(out),indent=2)+'\n') +print(out['status']) +for name,row in rows.items(): + print(name,'FINAL KAPPA',encode(row['kappa'])['decimal'], + 'positive checks',len(row['strict_checks']), + 'gain over online',encode(row['kappa']-online)['decimal']) diff --git a/research/staged-release-retiming-t530/numerics/recorded/outer/outer/independent_check.py b/research/staged-release-retiming-t530/numerics/recorded/outer/outer/independent_check.py new file mode 100644 index 0000000000..b838c430ef --- /dev/null +++ b/research/staged-release-retiming-t530/numerics/recorded/outer/outer/independent_check.py @@ -0,0 +1,60 @@ +"""Independent balance-equation check (PR1673, adapted: this package's supplier b and SPEC), not an execution of the ledger in check_ledger.py.""" +from fractions import Fraction as F +from pathlib import Path +from decimal import Decimal,localcontext +import json,hashlib,sys +sys.set_int_max_str_digits(0) +D=Path(__file__).resolve().parent;W=D.parent +src=W/'new/SPEC.json' +BJ=json.loads((D/'B.json').read_text()) +spec=json.loads(src.read_text());pinned=F(spec['expected']['complex_lower']) +DIG=spec['outer_refinement']['endpoint_digits'];T=10**(DIG+80) # all free slacks are 10^-(DIG+80) or below (fixed-grid-maximum point, PR2180 / PR2161 dataisfire) +b=F(BJ['b']);q=b-F(1,T);eff=(q+b)/2;actual_bit=F('0.001733427039589844234749') +r=F(1,T);z=F(1,T*100);s=F(1,T) +assert 0eff +rows={} +# FINE-PRIME PADDING (outer/FINE-PADDING-COMPOSITION.md): explicit point epsilon=1-delta, beta=1-3 delta, delta=(1025/1024)*10^-(DIG+80), Strassen boundary tau=45/16 (7^16<2^45), c=3/32, +# theta in (1/(4p^2),1/(2p^2-1)], chirp guard beta+2xi-2<1, halo power 48, core power 128. Derived here WITHOUT the ledger code; the structured boundary is not used. +delta=F(1025,1024*T);E=1-delta;B=1-3*delta +assert 7**16<2**45;tau=F(45,16);c=(3-tau)/2;assert c==F(3,32) +nu=2;halo=48;core=128 +X=E+E*q+s-c # boundary saving c+X-E = E q + s +assert c+X-E==E*q+s +# the Gaussian row has slack: 1-E+qB-Eq = delta(1-2q) +assert 1-E+q*B-E*q==delta*(1-2*q)>0 +# admissible beta window for this epsilon: Gaussian row needs beta >= 1-delta(1+1/q); membership needs beta < 1-2 delta +assert 1-delta*(1+1/q)<=B<1-2*delta +assert F(1,2)z>0 and 1-E-r>0 and core-halo-B>0 and halo>43 +assert 1-B>0 and 1-B-2*(1-E)==delta>0 +costs={'transform':1-E*q,'global_router':1-eff,'gaussian':E-q*B,'group_router':E-eff*B,'group_scans':E-B,'boundary':E-X+(tau-1)/2,'sparse_union':E+F(1,2)-X,'polynomials':1-E,'microfaces':E+B+halo-core+2} +K=F((E*q*10**(DIG+46)).__floor__(),10**(DIG+46))-F(1,10**(DIG+22)) +assert max(costs.values())==costs['transform'] and all(v<1-K for v in costs.values()) +# earlier packages' guards fail at this point (they are rejecting controls in the ledger): linear guard 1-X-r-B<0, old theta chirp guard 1-(2X-E)-r-B<0, 2B<1 test fails +assert 1-X-r-B<0 and 1-(2*X-E)-r-B<0 and 1-2*B<0 +assert K>F('0.0016797547881500489087805478664999999999999999999999999999999998000000199999') # PR1786 exact kappa +assert K>F('0.0016797549561255445213356709939207025769983114385025802954603275201627999999999999999999999999979966404900867489109573286580121585') # PR1828 exact kappa +assert K>F('0.0016797549561255445213356709939207025769983114385025802954603275201628645482603256388263049999999997996640490086748910957328658012158594') # PR1839 exact kappa +assert K>F('0.0016797549561255445213356709939207025769983114385025802954603275201628645482603256388263056561328446322744513169085862209720704481201654121427713006366929567157349625273906229277148454180995537563371124755588139767841405530386745578819565618798006892541712197674874836946756930569827889227573192555649999999997996640490086748910957328658012158594') # PR1875 exact kappa +assert K>F('0.001679754956125544521335670993920702576998311438502580295460327520162864548260325638826305656132844632274451316908586220972070448120165412142771300636692956715734962527390622927714845418099553756337112475558813976784140553038674557881956561879800689254171219767487483694675693056982788922757319255565606685566411725238449650999339827075715283714270157705762309226038611771955655377501414652136546310799999999999999999997996640490086748910957328658012158594846') # PR1876 exact kappa +assert K>F('0.001679754956125544521335670993920702576998311438502580295460327520162864548260325638826305656132844632274451316908586220972070448120165412142771300636692956715734962527390622927714845418099553756337112475558813976784140553038674557881956561879800689254171219767487483694675693056982788922757319255565606685566411725238449650999339827075715283714270157705762309226038611771955655377501414652136546310881185746917580802513640545967852810801680966856133978576162943792322682482152988532923811998938861379689883167389728443314312230815059559906903773756886872476136837071871203030423643505345473735135533') # PR1897 exact kappa +assert K>F('0.001679745508802299051546533685199973672313473419790800679752457380932784242972585600630181672224983') # PR1758 +assert K r0 (beta = 1-3 delta); only kappa moves, kappa = (1-delta) q - O(1e-76) +# fixed-grid maximum: saving < C and C*FLOOR integral give K <= C-1/FLOOR-BACKOFF; this point attains it (0 < C-E*q < 1/FLOOR) +FL=10**(DIG+46);assert (pinned*FL).denominator==1 and 00 and 1-dd*(1+1/q)<=Bd<1-2*dd and 1-Ed+q*Bd-Ed*q>0 and Ed-Bd>0 and 1-Bd-2*(1-Ed)>0 + assert F(1,2)0 and core-halo-Bd>0 + assert 1-Ed+eff*Bd>Ed*q and eff>Ed*q and 1-Ed+Bd>Ed*q and Ed>Ed*q and 1-(Ed+Bd+halo-core+2)>Ed*q + sweep.append((str(dd),str(float(q-Ed*q)))) +assert 1-F(1,T)<=1-r # delta=r0 itself is rejected by 1-eps-r0>0 +assert not (1-(1-r)-r>0) +rows['struct_boundary_radix_union']={'epsilon':str(E),'cap':str(X),'beta':str(B),'kappa':str(K),'margin_above_kappa':str(E*q-K),'checked_cost_powers':len(costs),'gap_to_q':str(q-K),'epsilon_free_sweep_delta_gap_to_q':sweep} +report={'status':'PASS_INDEPENDENT_BALANCE_DERIVATION','source_sha256':hashlib.sha256(src.read_bytes()).hexdigest(),'b':str(b),'rows':rows,'scope':'Independent balance derivation and margin comparisons for this package\'s supplier endpoint; the supplier native admission is bound by verify_release.py; inherited all-size assumptions remain.'} +(D/'INDEPENDENT.json').write_text(json.dumps(report,indent=2)+'\n') +print(json.dumps(report,indent=2)) diff --git a/research/staged-release-retiming-t530/numerics/run.py b/research/staged-release-retiming-t530/numerics/run.py new file mode 100644 index 0000000000..38b0664cba --- /dev/null +++ b/research/staged-release-retiming-t530/numerics/run.py @@ -0,0 +1,16 @@ +#!/usr/bin/env python3 +"""Offline exact moment and transfer check; Python standard library only.""" +from pathlib import Path +import argparse, hashlib, json, subprocess, sys, tempfile +D=Path(__file__).resolve().parent +p=argparse.ArgumentParser();p.add_argument('--out',type=Path);a=p.parse_args() +for name,digest in json.loads((D/'INPUT-SHA256.json').read_text()).items(): + if hashlib.sha256((D/name).read_bytes()).hexdigest()!=digest:raise ValueError('changed capsule input '+name) +out=a.out.resolve() if a.out else Path(tempfile.mkdtemp(prefix='retimed-numerics-')) +if out==D or D in out.parents:raise ValueError('output must be outside package') +if a.out and out.exists():raise ValueError('choose a fresh output directory') +out.mkdir(parents=True,exist_ok=True) +if (out/'MOMENT.json').exists() or (out/'outer').exists():raise ValueError('choose a fresh output directory') +subprocess.run([sys.executable,'-B',str(D/'verify_moment.py'),'--repo',str(D/'vendor-repo'),'--t530',str(D/'t530'),'--words',str(D/'words'),'--out',str(out/'MOMENT.json')],check=True) +subprocess.run([sys.executable,'-B',str(D/'verify_outer.py'),'--repo',str(D/'vendor-repo'),'--t530',str(D/'t530'),'--moment',str(out/'MOMENT.json'),'--out',str(out/'outer')],check=True) +print('Fresh exact arithmetic evidence:',out) diff --git a/research/staged-release-retiming-t530/numerics/t530/CREDITS.md b/research/staged-release-retiming-t530/numerics/t530/CREDITS.md new file mode 100644 index 0000000000..37f2ab02a1 --- /dev/null +++ b/research/staged-release-retiming-t530/numerics/t530/CREDITS.md @@ -0,0 +1,7 @@ +# Credits and provenance + +Ross Richardson’s PR3605 supplies the staged-width operators, T37 lineage and integral-network allocation machinery. Our published T450 contribution PR3624 is the comparison baseline; its T8 chronology is not reused by this candidate. + +The retained T16 chronology originates in PR3413 and is preserved in our PR3457/3465 provider-composition lineage. T16-PROVENANCE.json pins the actual PLAN and reconstruction source. This contribution supplies the combined chronology and newly solved allocation; it does not claim the constituent chronologies or count their prior gains twice. + +Retained machinery preserves its upstream contributor notices and exact sources, including the earlier rank-seven compiler/controller and conditional-release chain. Private optimizer tools are excluded. New material is Apache-2.0, prepared for hexapode with substantial OpenAI Codex assistance. No independent human or formal-kernel acceptance is claimed. diff --git a/research/staged-release-retiming-t530/numerics/t530/EXPECTED.json b/research/staged-release-retiming-t530/numerics/t530/EXPECTED.json new file mode 100644 index 0000000000..0f6d39dbfa --- /dev/null +++ b/research/staged-release-retiming-t530/numerics/t530/EXPECTED.json @@ -0,0 +1,24 @@ +{ + "replicas": 530, + "calls": 4770, + "roles": 1946160, + "physical": 475389, + "profile": { + "1": 11757460, + "2": 3463020, + "3": 1102502, + "4": 486540, + "5": 103690, + "8": 38160, + "48": 202828 + }, + "root_interval": [ + "0.001730071864705779882540", + "0.001730071864705779882541" + ], + "candidate_endpoint": "17300718647057798825399999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "frontier_pr": 3624, + "frontier_head": "515a7c4490aa32ac3ca5014feb6f7da0d6952863", + "frontier_sha256": "8f2f80438593e7efaa6bb57c881a40cedbd7b5665b4ae12c6cf215d217c98397", + "scope": "Finite profile expectation; complete admission checked separately." +} diff --git a/research/staged-release-retiming-t530/numerics/t530/PROOF.md b/research/staged-release-retiming-t530/numerics/t530/PROOF.md new file mode 100644 index 0000000000..395fe84ea4 --- /dev/null +++ b/research/staged-release-retiming-t530/numerics/t530/PROOF.md @@ -0,0 +1,13 @@ +# T530 construction argument and completed conditional admission + +The two staged-width suppliers and their source-bound native programs are unchanged from PR3605 and our admitted T450 contribution. Concatenate T37 and T16 orders, renumber replicas, preserve each constituent dispatch, and derive windows from the actual source geometry. Initial lower bounds remain globally −1. T16 chronology provenance is pinned to PLAN-3413.json and its reconstruction source; older numerical gains are not added again. + +The aggregate certificate has ten copies, 4,770 calls and 408 roles per call. Integer pattern counts and time flows satisfy every actual window, group count, width quota and group/time degree. Maximum pattern degree six is at most the ten copies. The retained integral lower-bound flow decomposition and copy-color induction therefore apply. A grouped time represents ten successive physical calls. Literal reconstruction and an independent native-frame audit check all 1,946,160 assignments, source-family uniqueness and rank offsets, including five rejection controls. + +The full paid profile is `11757460 H1 + 3463020 H2 + 1102502 H3 + 486540 H4 + 103690 H5 + 38160 H8 + 202828 H48`, where `Hr=r^(1-kappa)`. Its rank mass is `65088*530`. Normalizing by `896*530*73^(1-kappa)` gives a strictly increasing function, since all occupied ranks are less than 73. Exact rational sign enclosures certify the root interval in EXPECTED.json. + +The exact comparison against PR3624 normalizes different replica counts using `450*profile_T530 - 530*profile_T450`. The resulting signed profile is recorded by verify_price.py, has zero rank mass and has strictly negative cost at the predecessor upper root endpoint. The proposed conditional endpoint is the lower root bound minus the inherited margins `10^-46 + 10^-70`; it is checked against the completed source-bound admission in the stored evidence. + +Physical stock is `896*530 + 408 + 8 + 91 + 2 = 475389`, within the original sufficient ceiling. Stock norm exponent 1324 gives reserve `128+37+18+1324+1+4=1512<2048`. Expected actual prefix is 1479. The stored terminal evidence authenticates execution of the physical, arbitrary-dirty endpoint, cleanup, precision and outer ledgers; all passed with these values. The registered evidence check is separate from a fresh full replay. + +All inherited all-size, compiler, uniform-cost, hosting, bootstrap-time, rounding, tape/recovery, analytic and BIT endpoint assumptions remain. Independent agents in one session are not independent human review or formal-kernel verification. Future construction and theoretical questions are listed in README.md. diff --git a/research/staged-release-retiming-t530/numerics/t530/evidence/RESULT.json b/research/staged-release-retiming-t530/numerics/t530/evidence/RESULT.json new file mode 100644 index 0000000000..ef1167f25d --- /dev/null +++ b/research/staged-release-retiming-t530/numerics/t530/evidence/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": "86503593235288994127/50000000000000000000000", + "dispatch_sha256": "a758a59b001f3bdda07e6a1a98bc8bd0339461dee5ec6b1909925030a043eddb", + "external_input_sha256": { + "/private/tmp/integer-mult-experiments/adversarial/cap740-preflight/run/adapters/extension_blocknorm.py": "6e6b8683cc87a84e5410c399b1128eb68694f852a3927cb124067f503ed7d7c7", + "/private/tmp/integer-mult-experiments/adversarial/cap740-preflight/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839/lift_parent.py": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "/private/tmp/integer-mult-experiments/adversarial/cap740-preflight/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839/reconstruct_replica.py": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "/private/tmp/integer-mult-experiments/adversarial/cap740-preflight/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839/replica_parent.py": "48bdbf28f59d80edb266803ec61bf5e22e8fb5e5a0e2b88004b6039147589bd4", + "/private/tmp/integer-mult-experiments/adversarial/cap740-preflight/run/pr2969/CLAIM.json": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77", + "/private/tmp/integer-mult-experiments/overlap-pr3605-latest/T530-literal/DISPATCH.json": "a758a59b001f3bdda07e6a1a98bc8bd0339461dee5ec6b1909925030a043eddb", + "/private/tmp/integer-mult-experiments/overlap-pr3605-latest/T530-literal/FILL.json.gz": "d1cc162ad8ddfaee30643248af2997d6b8b4cc34e141a785f439b1c79fb9484c", + "/private/tmp/integer-mult-experiments/overlap-pr3605-latest/T530-literal/ORDER.json": "599fb079a23b403f9de9e334d7c463f0cad28f9d69d1f99fcbf93abb72e935eb" + }, + "fill_sha256": "d1cc162ad8ddfaee30643248af2997d6b8b4cc34e141a785f439b1c79fb9484c", + "gain": "603663995767500399/100000000000000000000000", + "kappa": "17300718647057798825399999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017300718647057798825399999999999999999999998999999999999999999999999", + "native_receipt_sha256": "411b6fc1ac480263a90d36eca58c109687307e9a2d204af3ed4d002f9f8ff629", + "order_sha256": "599fb079a23b403f9de9e334d7c463f0cad28f9d69d1f99fcbf93abb72e935eb", + "package_manifest_sha256": "3e67c387b084f95d6c7bc239981a9c9b4cb3d57666a787e18033f058d70b97b3", + "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": "0bc39b4bc037bde6b1644cc53bcf9394e585e0d8245c48b2cfdb79365e216ffc", + "before_sha256": "8e1c5b5c4291637aa0ed4366792106df3cd7110bdfcc117a3d5da30a8f209862", + "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 else hi) + upper += count * (hi if count >= 0 else lo) + return lower, upper + + +def compact(bounds): + # Report outward intervals at 60 decimal places, retaining rational signs. + lo, hi = bounds + scale = 10**60 + low = (lo.numerator*scale)//lo.denominator + high = -((-hi.numerator*scale)//hi.denominator) + return {'lower': str(Q(low, scale)), 'upper': str(Q(high, scale))} diff --git a/research/staged-release-retiming-t530/numerics/t530/supplier3605/STAGED644-660-base.json.gz b/research/staged-release-retiming-t530/numerics/t530/supplier3605/STAGED644-660-base.json.gz new file mode 100644 index 0000000000..dc6d321b1e Binary files /dev/null and b/research/staged-release-retiming-t530/numerics/t530/supplier3605/STAGED644-660-base.json.gz differ diff --git a/research/staged-release-retiming-t530/numerics/t530/supplier3605/STAGED644-660-extra.json.gz b/research/staged-release-retiming-t530/numerics/t530/supplier3605/STAGED644-660-extra.json.gz new file mode 100644 index 0000000000..78e7b2bb06 Binary files /dev/null and b/research/staged-release-retiming-t530/numerics/t530/supplier3605/STAGED644-660-extra.json.gz differ diff --git a/research/staged-release-retiming-t530/numerics/vendor-repo/research/gmx-t74-borrow43-handoff/outer/check_ledger.py b/research/staged-release-retiming-t530/numerics/vendor-repo/research/gmx-t74-borrow43-handoff/outer/check_ledger.py new file mode 100644 index 0000000000..b64077b84b --- /dev/null +++ b/research/staged-release-retiming-t530/numerics/vendor-repo/research/gmx-t74-borrow43-handoff/outer/check_ledger.py @@ -0,0 +1,258 @@ +#!/usr/bin/env python3 +"""Exact ledger for fine-prime padding (PR1786, chafreaky / Chafik Boukhalfa, with Tim Trudgian's prime theorem) at the free point epsilon = 1 - (1025/1024)*10^-(DIG+80), explicit Strassen boundary, retuned to the fixed-grid maximum kappa = C - 1/FLOOR - BACKOFF. + +Adapted from PR1786's ledger, itself adapted from PR1731's cost ledger, credited to Jeremy Kothe et al. and +Vlado Vojdanovski (PR1673); uses PR1758's gauge-free chirp and per-visit tag +accounting. New source-prime, coefficient-setup and halo lemmas are in +FINE-PRIME-PADDING.md. Finite arithmetic does not prove the all-size theorem. +""" +from fractions import Fraction as Q +from decimal import Decimal, localcontext +from pathlib import Path +from math import factorial +import hashlib, json, sys +sys.set_int_max_str_digits(0) + +if not __debug__: raise RuntimeError('Assertions must be enabled') +HERE=Path(__file__).resolve().parent +WORK=HERE.parent +SPEC=WORK/'new/SPEC.json' +CLAIM=WORK/'CLAIM.json' +BJ=json.loads((HERE/'B.json').read_text()) +spec=json.loads(SPEC.read_text()) +# Free strict slacks of the PR1673 proof (retuned in this package, see RETUNED-SLACKS.md); every one only needs to be > 0. +DIG=spec['outer_refinement']['endpoint_digits'] # the supplier endpoint is certified to 10^-DIG (accept at the endpoint, reject at endpoint + 10^-DIG); every slack sits 10 digits below +# Fixed-grid maximum (PR2180 / PR2161, dataisfire; proof PROOF-GRID-MAX.md): the free gaps shrink together to R0 = 10^-(DIG+80); grid, backoff and certified endpoint are unchanged. +R0=Q(1,10**(DIG+80)); ZETA=R0/100; SLACK=R0; GAP=R0; STOP=R0/10**6 +FLOOR=10**(DIG+46); BACKOFF=Q(1,10**(DIG+22)); B_GAP=R0 +# Fine prime padding: theta is between 1/(4p^2) and 1/(2p^2-1). +# Online chirp guard beta+2*xi-2<1; coefficient setup uses O(p^2 log p) bits. +# epsilon = 1 - DELTA_E is a FREE parameter (outer/FINE-PADDING-COMPOSITION.md sec. 2): every row is strictly satisfied for every DELTA_E > r0 = 10^-(DIG+80); beta = 1 - 3 DELTA_E lies in the admissible window +# [1 - DELTA_E (1 + 1/q), 1 - 2 DELTA_E). DELTA_E = (1025/1024) r0 keeps the gamma spare power 1-eps-r0 = r0/1024 > 0 and puts C - eps*q below 1/FLOOR (PROOF-GRID-MAX.md). +DELTA_E=Q(1025,1024)*R0 +EPS=1-DELTA_E +BETA=1-3*DELTA_E +THETA_POWER=Q(2) +HALO_POWER=48 +CORE_POWER=128 +STRASSEN_TAU=Q(45,16) +KAPPA_1828=Q('0.0016797549561255445213356709939207025769983114385025802954603275201627999999999999999999999999979966404900867489109573286580121585') # exact kappa of rohanarun's PR1828 (slack refinement of PR1800 at 1e-96), from its body +KAPPA_1839=Q('0.0016797549561255445213356709939207025769983114385025802954603275201628645482603256388263049999999997996640490086748910957328658012158594') # exact kappa of PR1839 (previous package: 1e-90 endpoint) +KAPPA_1875=Q('0.0016797549561255445213356709939207025769983114385025802954603275201628645482603256388263056561328446322744513169085862209720704481201654121427713006366929567157349625273906229277148454180995537563371124755588139767841405530386745578819565618798006892541712197674874836946756930569827889227573192555649999999997996640490086748910957328658012158594') # exact kappa of rohanarun's PR1875 (1e-300 endpoint), from its body +KAPPA_1876=Q('0.001679754956125544521335670993920702576998311438502580295460327520162864548260325638826305656132844632274451316908586220972070448120165412142771300636692956715734962527390622927714845418099553756337112475558813976784140553038674557881956561879800689254171219767487483694675693056982788922757319255565606685566411725238449650999339827075715283714270157705762309226038611771955655377501414652136546310799999999999999999997996640490086748910957328658012158594846') # exact kappa of rohanarun's PR1876 (1e-400 endpoint), from its body +KAPPA_1897=Q('0.001679754956125544521335670993920702576998311438502580295460327520162864548260325638826305656132844632274451316908586220972070448120165412142771300636692956715734962527390622927714845418099553756337112475558813976784140553038674557881956561879800689254171219767487483694675693056982788922757319255565606685566411725238449650999339827075715283714270157705762309226038611771955655377501414652136546310881185746917580802513640545967852810801680966856133978576162943792322682482152988532923811998938861379689883167389728443314312230815059559906903773756886872476136837071871203030423643505345473735135533') # exact kappa of M6LI's PR1897 (1e-500 grid), from its body +KAPPA_1786=Q('0.0016797547881500489087805478664999999999999999999999999999999998000000199999') # exact kappa of chafreaky's PR1786 ledger (EXPECTED-BALANCE.json), headline 0.001679754788150048 +KAPPA_PKG5=Q('0.001677992607205282520732088774830808372222877897034109604209719298829805473412451530867883424937597') # previous package (rectangular k=2, tau_eff=2.2500351) +KAPPA_PKG4=Q('0.0016778199023144364336310551358776001013829401215770658599799349282716974076737897457922714197448847') # previous package (radix union schedule, square boundary tau=2.372864) +KAPPA_1712=Q('0.0016776417313433545642517275958639984231708545722735432722117400060454625429077941422798526440584702') # pkg of PR1712 (Le Gall tau=12/5, old union row) +KAPPA_1699=Q('0.001677641731343354564251058287063644749065568493') # exact kappa of PR1699's ledger (Chafik Boukhalfa), same supplier profile +certified_complex=Q(spec['expected']['complex_lower']) +bit=Q('0.001733427039589844234749') +# Keep short independently checkable decimals strictly inside both endpoints. +b=certified_complex-B_GAP # strictly inside the certified supplier endpoint; B.json carries the same exact value +assert b==Q(BJ['b']) +q=b-GAP +a=(q+b)/2 +online=Q(spec['expected']['kappa']) +old=Q('0.001673360105405778') +assert b=2:x/=2;k+=1 + lo,hi=unit_log(x) + return down(lo+k*ln2[0]),up(hi+k*ln2[1]) +def exp(x): + assert 0<=x>GB)//j;th=_cd(-((-th*xu)>>GB),j);sl+=tl;sh+=th + tn=_cd(-((-th*xu)>>GB),EN) # x^EN/EN! (rounded up); the tail is at most twice this + return Q(int(sl),ONE),Q(int(sh+2*tn+2),ONE) +def moment(endpoint): + lo=hi=Q(0) + for r,n in profile.items(): + l,h=log(Q(m,r)); weight=Q(n*r,m*W) + lo+=weight*exp(endpoint*l)[0] + hi+=weight*exp(endpoint*h)[1] + return down(lo),up(hi) + +native=moment(b) +assert native[1]<1 +b_up=Q(BJ['b_above_endpoint']) +assert b_up>certified_complex and moment(b_up)[0]>1 # a larger test endpoint is rejected + +def ledger(kind, *, q_=q, zeta=ZETA, slack=SLACK, + old_scan=False, full_gauge=False, full_key=False, old_union=False, old_theta=False, old_linear=False, old_tag=False, + eps_=EPS, beta_=BETA, tau_eff=STRASSEN_TAU, halo_power=HALO_POWER, core_power=CORE_POWER): + r=R0; stop=STOP + # Existing explicit Strassen format, 7^16<2^45; c=3/32. + # Union: radix-distributed schedule (outer/UNION-SCHEDULE.md, new in this package): row exponent eps+1/2-xi. The boundary row binds with main; the Gaussian row has slack at this explicit point. + c=(3-tau_eff)/2 + eps=eps_; beta=beta_ + xi=eps*(1+q_)-c+slack + saving=eps*q_ + # Deliberate strict gap (BACKOFF) after decimal truncation to the FLOOR grid. + kappa=Q((saving*FLOOR).__floor__(),FLOOR)-BACKOFF + # kappa is derived, not silently asserted to equal an expected decimal. + tau=1-a; sigma=1-b + internal=tau+(1-stop)*max(sigma-tau,Q(0)) + leaf=sigma+stop*(1-sigma) + lam=1-(q_+a)/2 + key=beta+1-eps + margins={ + 'main_transform':saving, + 'global_coordinate_router':a, + 'fused_gaussian':1-eps+q_*beta, + 'group_bit_router':1-eps+a*beta, + 'group_scans':1-eps+beta, + 'boundary_algebraic_matrix':c+xi-eps, + 'sparse_union_movement':xi+Q(1,2)-eps, + 'polynomial_products':eps, + 'microbox_face_corrections':1-(eps+beta+halo_power-core_power+2), + } + if old_union:margins['old_g_factor_union_row']=1-eps-beta-Q(1,2)+xi + if old_scan:margins['old_per_axis_scan']=1-eps + if full_key:margins['unnecessary_full_key_sort']=margins['sparse_union_movement']-key + checks={ + 'actual_bit_above_effective':bit-a, + 'complex_above_effective':b-a, + 'q_positive':q_, 'complex_endpoint':b-q_, + 'q_below_effective':a-q_, 'stop_positive':stop, + 'stop_below_one':1-stop, + 'leaf_saving_above_effective':(1-stop)*b-a, + 'q_below_internal':1-internal-q_, 'q_below_leaf':1-leaf-q_, + 'lambda_above_tau':lam-tau, 'lambda_above_sigma':lam-sigma, + 'lambda_above_internal':lam-internal, + 'lambda_prime_above_lambda':1-q_-lam, + 'lambda_prime_above_leaf':1-q_-leaf, + 'epsilon_positive':eps,'epsilon_below_one':1-eps, + 'cap_above_band':xi-Q(1,2),'cap_below_cell':eps-xi, + 'group_positive':beta,'group_below_dimension':eps-beta, + 'support_router_span':1-beta, + 'group_gauge_power_slack':1-(2*xi-THETA_POWER)-r-beta, + 'actual_logarithmic_group_guard':1-(2*xi-THETA_POWER)-beta, + 'global_gamma_power_slack':1-eps-r, + 'actual_logarithmic_gamma_guard':1-eps, + 'alpha_logarithm_absorption':r, + 'group_key_fits_record':1-key, + 'membership_arithmetic_fits_record':1-beta-2*(1-eps), + 'microbox_halo_volume':core_power-halo_power-beta, + 'positive_layout_slack':slack, + 'short_record_fallback':eps-a, + 'improvement_over_online_final':kappa-online, + 'improvement_over_previous_local_final':kappa-old, + 'complex_below_one_over_32':Q(1,32)-b, + } + checks['strassen_integer_power_gap']=Q(2**tau_eff.numerator-7**tau_eff.denominator) + checks['theta_positive_polynomial_power']=THETA_POWER + checks['cap_below_phase_cell_power']=THETA_POWER-xi + checks['halo_covers_generic_inverse_radius']=Q(halo_power-43) + checks['union_tag_work_per_visit_fits_record']=1-beta + checks['union_header_fits_record']=1-beta + checks['source_axis_superpolynomial']=1-eps + checks['improvement_over_pr1786']=kappa-KAPPA_1786 + checks['improvement_over_pr1828']=kappa-KAPPA_1828 + checks['improvement_over_pr1839']=kappa-KAPPA_1839 + checks['improvement_over_pr1875']=kappa-KAPPA_1875 + checks['improvement_over_pr1876']=kappa-KAPPA_1876 + checks['improvement_over_pr1897']=kappa-KAPPA_1897 + checks['improvement_over_pr1758']=kappa-Q('0.001679745508802299051546533685199973672313473419790800679752457380932784242972585600630181672224983') + checks['improvement_over_pr1699']=kappa-KAPPA_1699 + checks['improvement_over_pr1712']=kappa-KAPPA_1712 + checks['improvement_over_previous_package']=kappa-KAPPA_PKG4 + checks['improvement_over_pkg_k2']=kappa-KAPPA_PKG5 + if full_gauge:checks['unrecentered_group_gauge']=1-THETA_POWER-r-beta + if old_theta:checks['old_theta_chirp_guard']=1-(2*xi-eps)-r-beta + if old_linear:checks['old_linear_guard']=1-xi-r-beta + if old_tag:checks['old_union_tag_2beta']=1-2*beta + # Main-binding family invariant (PR2180): the Gaussian saving stays above the main saving. The fixed kappa grid (FLOOR) is coarser than the free gaps, + # so the *_above_kappa rows alone would no longer exclude a beta outside the main-binding window; this row is delta*(1-2q) > 0. + checks['gaussian_above_main']=margins['fused_gaussian']-saving + checks.update({n+'_above_kappa':v-kappa for n,v in margins.items()}) + assert margins['boundary_algebraic_matrix']==saving+slack + assert margins['sparse_union_movement']==saving+slack+(tau_eff-2)/2 + return {'kind':kind,'kappa':kappa,'epsilon':eps,'xi':xi,'beta':beta, + 'q':q_,'a':a,'r0':r,'zeta':zeta,'slack':slack, + 'margins':margins,'strict_checks':checks} + +def encode(x): + if isinstance(x,Q): + with localcontext() as c: + c.prec=DIG+200 + return {'rational':str(x),'decimal':str(Decimal(x.numerator)/Decimal(x.denominator))} + if isinstance(x,dict):return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)):return [encode(v) for v in x] + return x + +rows={};controls={} +for kind in ['struct_boundary_radix_union']: + row=ledger(kind) + assert all(v>0 for v in row['strict_checks'].values()) + assert min(row['margins'].values())==row['margins']['main_transform'] + # fixed-grid maximum: C*FLOOR is an integer and 0 < C - eps*q < 1/FLOOR, so floor(FLOOR*eps*q)/FLOOR = C - 1/FLOOR exactly and kappa attains the grid/backoff ceiling + assert (certified_complex*FLOOR).denominator==1 and 0= 1/(4 p^THETA_POWER)), an exponential factor <= p^2 eventually, +# alpha^5 polylogarithmic; a further half power is allowed for the polylogarithmic and bounded-constant factors of the augmented matrices. The umbrella must exceed that budget. +UMBRELLA_POWER=10 +def umbrella_margin(theta_power):return UMBRELLA_POWER-(2*theta_power+2+Q(1,2)) +assert umbrella_margin(THETA_POWER)>0 and umbrella_margin(Q(15,4))<=0 # control: the umbrella would fail silently for THETA_POWER >= 3.75 +HALO_UMBRELLA={'umbrella_power':UMBRELLA_POWER,'theta_power':THETA_POWER,'exponent_budget':2*THETA_POWER+2+Q(1,2),'margin':umbrella_margin(THETA_POWER),'fails_from_theta_power':Q(15,4)} +out={'status':'PASS_FINE_PRIME_PADDING_EXACT_ARITHMETIC', + 'scope':'Conditional fine-prime padding composition. Fresh native admission is required by verify.py. The cited prime theorem, written gauge-free theorem and inherited all-size interfaces are not proved by this arithmetic. No independent human review is claimed.', + 'geometry_changes':{'theta_power':THETA_POWER,'halo_power':HALO_POWER,'core_power':CORE_POWER,'matrix_exponent':STRASSEN_TAU}, + 'halo_umbrella':HALO_UMBRELLA,'complex_lower_short':b,'complex_lower_pinned':certified_complex, + 'native_moment':native,'profile':profile,'m':m,'W':W, + 'online_final_kappa':online,'rows':rows,'rejecting_controls':controls, + 'pr1673_kappa':Q('0.001677160151714381'),'improvement_over_pr1673':rows['struct_boundary_radix_union']['kappa']-Q('0.001677160151714381'), + 'source_sha256':{p.relative_to(WORK).as_posix():hashlib.sha256(p.read_bytes()).hexdigest() for p in [SPEC,CLAIM]}} +(HERE/'LEDGER.json').write_text(json.dumps(encode(out),indent=2)+'\n') +print(out['status']) +for name,row in rows.items(): + print(name,'FINAL KAPPA',encode(row['kappa'])['decimal'], + 'positive checks',len(row['strict_checks']), + 'gain over online',encode(row['kappa']-online)['decimal']) diff --git a/research/staged-release-retiming-t530/numerics/vendor-repo/research/gmx-t74-borrow43-handoff/outer/independent_check.py b/research/staged-release-retiming-t530/numerics/vendor-repo/research/gmx-t74-borrow43-handoff/outer/independent_check.py new file mode 100644 index 0000000000..b838c430ef --- /dev/null +++ b/research/staged-release-retiming-t530/numerics/vendor-repo/research/gmx-t74-borrow43-handoff/outer/independent_check.py @@ -0,0 +1,60 @@ +"""Independent balance-equation check (PR1673, adapted: this package's supplier b and SPEC), not an execution of the ledger in check_ledger.py.""" +from fractions import Fraction as F +from pathlib import Path +from decimal import Decimal,localcontext +import json,hashlib,sys +sys.set_int_max_str_digits(0) +D=Path(__file__).resolve().parent;W=D.parent +src=W/'new/SPEC.json' +BJ=json.loads((D/'B.json').read_text()) +spec=json.loads(src.read_text());pinned=F(spec['expected']['complex_lower']) +DIG=spec['outer_refinement']['endpoint_digits'];T=10**(DIG+80) # all free slacks are 10^-(DIG+80) or below (fixed-grid-maximum point, PR2180 / PR2161 dataisfire) +b=F(BJ['b']);q=b-F(1,T);eff=(q+b)/2;actual_bit=F('0.001733427039589844234749') +r=F(1,T);z=F(1,T*100);s=F(1,T) +assert 0eff +rows={} +# FINE-PRIME PADDING (outer/FINE-PADDING-COMPOSITION.md): explicit point epsilon=1-delta, beta=1-3 delta, delta=(1025/1024)*10^-(DIG+80), Strassen boundary tau=45/16 (7^16<2^45), c=3/32, +# theta in (1/(4p^2),1/(2p^2-1)], chirp guard beta+2xi-2<1, halo power 48, core power 128. Derived here WITHOUT the ledger code; the structured boundary is not used. +delta=F(1025,1024*T);E=1-delta;B=1-3*delta +assert 7**16<2**45;tau=F(45,16);c=(3-tau)/2;assert c==F(3,32) +nu=2;halo=48;core=128 +X=E+E*q+s-c # boundary saving c+X-E = E q + s +assert c+X-E==E*q+s +# the Gaussian row has slack: 1-E+qB-Eq = delta(1-2q) +assert 1-E+q*B-E*q==delta*(1-2*q)>0 +# admissible beta window for this epsilon: Gaussian row needs beta >= 1-delta(1+1/q); membership needs beta < 1-2 delta +assert 1-delta*(1+1/q)<=B<1-2*delta +assert F(1,2)z>0 and 1-E-r>0 and core-halo-B>0 and halo>43 +assert 1-B>0 and 1-B-2*(1-E)==delta>0 +costs={'transform':1-E*q,'global_router':1-eff,'gaussian':E-q*B,'group_router':E-eff*B,'group_scans':E-B,'boundary':E-X+(tau-1)/2,'sparse_union':E+F(1,2)-X,'polynomials':1-E,'microfaces':E+B+halo-core+2} +K=F((E*q*10**(DIG+46)).__floor__(),10**(DIG+46))-F(1,10**(DIG+22)) +assert max(costs.values())==costs['transform'] and all(v<1-K for v in costs.values()) +# earlier packages' guards fail at this point (they are rejecting controls in the ledger): linear guard 1-X-r-B<0, old theta chirp guard 1-(2X-E)-r-B<0, 2B<1 test fails +assert 1-X-r-B<0 and 1-(2*X-E)-r-B<0 and 1-2*B<0 +assert K>F('0.0016797547881500489087805478664999999999999999999999999999999998000000199999') # PR1786 exact kappa +assert K>F('0.0016797549561255445213356709939207025769983114385025802954603275201627999999999999999999999999979966404900867489109573286580121585') # PR1828 exact kappa +assert K>F('0.0016797549561255445213356709939207025769983114385025802954603275201628645482603256388263049999999997996640490086748910957328658012158594') # PR1839 exact kappa +assert K>F('0.0016797549561255445213356709939207025769983114385025802954603275201628645482603256388263056561328446322744513169085862209720704481201654121427713006366929567157349625273906229277148454180995537563371124755588139767841405530386745578819565618798006892541712197674874836946756930569827889227573192555649999999997996640490086748910957328658012158594') # PR1875 exact kappa +assert K>F('0.001679754956125544521335670993920702576998311438502580295460327520162864548260325638826305656132844632274451316908586220972070448120165412142771300636692956715734962527390622927714845418099553756337112475558813976784140553038674557881956561879800689254171219767487483694675693056982788922757319255565606685566411725238449650999339827075715283714270157705762309226038611771955655377501414652136546310799999999999999999997996640490086748910957328658012158594846') # PR1876 exact kappa +assert K>F('0.001679754956125544521335670993920702576998311438502580295460327520162864548260325638826305656132844632274451316908586220972070448120165412142771300636692956715734962527390622927714845418099553756337112475558813976784140553038674557881956561879800689254171219767487483694675693056982788922757319255565606685566411725238449650999339827075715283714270157705762309226038611771955655377501414652136546310881185746917580802513640545967852810801680966856133978576162943792322682482152988532923811998938861379689883167389728443314312230815059559906903773756886872476136837071871203030423643505345473735135533') # PR1897 exact kappa +assert K>F('0.001679745508802299051546533685199973672313473419790800679752457380932784242972585600630181672224983') # PR1758 +assert K r0 (beta = 1-3 delta); only kappa moves, kappa = (1-delta) q - O(1e-76) +# fixed-grid maximum: saving < C and C*FLOOR integral give K <= C-1/FLOOR-BACKOFF; this point attains it (0 < C-E*q < 1/FLOOR) +FL=10**(DIG+46);assert (pinned*FL).denominator==1 and 00 and 1-dd*(1+1/q)<=Bd<1-2*dd and 1-Ed+q*Bd-Ed*q>0 and Ed-Bd>0 and 1-Bd-2*(1-Ed)>0 + assert F(1,2)0 and core-halo-Bd>0 + assert 1-Ed+eff*Bd>Ed*q and eff>Ed*q and 1-Ed+Bd>Ed*q and Ed>Ed*q and 1-(Ed+Bd+halo-core+2)>Ed*q + sweep.append((str(dd),str(float(q-Ed*q)))) +assert 1-F(1,T)<=1-r # delta=r0 itself is rejected by 1-eps-r0>0 +assert not (1-(1-r)-r>0) +rows['struct_boundary_radix_union']={'epsilon':str(E),'cap':str(X),'beta':str(B),'kappa':str(K),'margin_above_kappa':str(E*q-K),'checked_cost_powers':len(costs),'gap_to_q':str(q-K),'epsilon_free_sweep_delta_gap_to_q':sweep} +report={'status':'PASS_INDEPENDENT_BALANCE_DERIVATION','source_sha256':hashlib.sha256(src.read_bytes()).hexdigest(),'b':str(b),'rows':rows,'scope':'Independent balance derivation and margin comparisons for this package\'s supplier endpoint; the supplier native admission is bound by verify_release.py; inherited all-size assumptions remain.'} +(D/'INDEPENDENT.json').write_text(json.dumps(report,indent=2)+'\n') +print(json.dumps(report,indent=2)) diff --git a/research/staged-release-retiming-t530/numerics/vendor-repo/research/pending-claims-independent-pricing/arith.py b/research/staged-release-retiming-t530/numerics/vendor-repo/research/pending-claims-independent-pricing/arith.py new file mode 100644 index 0000000000..b9e3014443 --- /dev/null +++ b/research/staged-release-retiming-t530/numerics/vendor-repo/research/pending-claims-independent-pricing/arith.py @@ -0,0 +1,133 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Code-disjoint exact interval arithmetic for complex-moment endpoints and the kappa reduction. + +Imports nothing from the retained engines (moment.py, base_two_moment.py, outer.py). +Extends the arithmetic of research/t37-endpoints-independent (PR1051) to every prime: + ln 2 = 2 atanh(1/3), ln p = ln(p-1) + 2 atanh(1/(2p-1)) for odd primes p, +since p/(p-1) = (1+t)/(1-t) with t = 1/(2p-1) <= 1/5. atanh tails use the geometric bound +t^(2K+1) / ((2K+1)(1-t^2)); exp uses a Taylor polynomial with remainder 2 y^(K+1)/(K+1)!; +all intervals are exact rationals rounded outward to multiples of 2^-PREC. +""" +from fractions import Fraction as Q +from functools import lru_cache + +PREC = 320 +TERMS = 120 +TAYLOR = 16 + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def down(x): + return Q((x.numerator << PREC) // x.denominator, 1 << PREC) + + +def up(x): + return -down(-x) + + +class I: + __slots__ = ('lo', 'hi') + + def __init__(self, lo, hi=None): + hi = lo if hi is None else hi + require(lo <= hi, 'interval order') + self.lo, self.hi = down(Q(lo)), up(Q(hi)) + + def __add__(self, o): + o = o if isinstance(o, I) else I(o) + return I(self.lo + o.lo, self.hi + o.hi) + + def __sub__(self, o): + o = o if isinstance(o, I) else I(o) + return I(self.lo - o.hi, self.hi - o.lo) + + def __mul__(self, o): + o = o if isinstance(o, I) else I(o) + p = (self.lo * o.lo, self.lo * o.hi, self.hi * o.lo, self.hi * o.hi) + return I(min(p), max(p)) + + __radd__ = __add__ + __rmul__ = __mul__ + + +def atanh(t): + t = Q(t) + require(0 < t <= Q(1, 3), 'atanh argument') + s, power = Q(0), t + for k in range(TERMS): + s += power / (2 * k + 1) + power *= t * t + return I(s, s + power / ((2 * TERMS + 1) * (1 - t * t))) + + +def is_prime(p): + return p >= 2 and all(p % d for d in range(2, int(p ** 0.5) + 1)) + + +@lru_cache(None) +def ln_prime(p): + require(is_prime(p), 'not a prime') + if p == 2: + return 2 * atanh(Q(1, 3)) + return ln_int(p - 1) + 2 * atanh(Q(1, 2 * p - 1)) + + +@lru_cache(None) +def ln_int(k): + require(k >= 1, 'positive integer') + out, d = I(0), 2 + while k > 1: + while k % d == 0: + out = out + ln_prime(d) + k //= d + d += 1 + return out + + +def exp_small(y): + require(0 <= y.lo and y.hi < Q(1, 100), 'exp range') + lo = hi = tlo = thi = Q(1) + for k in range(1, TAYLOR + 1): + tlo = down(tlo * y.lo / k) + thi = up(thi * y.hi / k) + lo += tlo + hi += thi + return I(lo, hi + thi * y.hi / (TAYLOR + 1) * 2) + + +def moment(H, m, W, z, surcharge=False): + total = I(0) + lm = ln_int(m) + for r, n in H.items(): + require(0 < r < m, 'child rank range') + total = total + I(Q(r * n, m * W)) * exp_small((lm - ln_int(r)) * I(z)) + if surcharge: + total = total + I(Q(32 * m * sum(H.values()), 10 ** 16 * W)) * exp_small(lm * I(z)) + return total + + +def certify(H, m, W, b, grid=Q(1, 10 ** 24), surcharge=False): + at, nxt = moment(H, m, W, b, surcharge), moment(H, m, W, b + grid, surcharge) + require(at.hi < 1, 'moment not below one at the endpoint') + require(nxt.lo > 1, 'moment not above one at the next grid point') + return (float(at.hi - 1), float(nxt.lo - 1)) + + +def kappa_from(b, c, grid=Q(1, 10 ** 18)): + """Selected T37 reduction: s = min(c, (1-beta) b) - 10^-27, seven bootstrap steps from 384599/10^10, + q = a7 (1 - 2 eta), kappa = largest grid point strictly below (1 - eta) q / (1 + q); eta = beta = 10^-24.""" + eta = beta = Q(1, 10 ** 24) + s = min(c, (1 - beta) * b) - Q(1, 10 ** 27) + a = Q(384599, 10 ** 10) + for _ in range(7): + a = (1 - s) * s + s * a + q = a * (1 - 2 * eta) + margin = (1 - eta) * q / (1 + q) + t = margin / grid + k = (-((-t.numerator) // t.denominator) - 1) * grid + require(k < margin <= k + grid, 'grid reduction') + return k, margin, ('bit' if c <= (1 - beta) * b else 'complex') diff --git a/research/staged-release-retiming-t530/numerics/verify_moment.py b/research/staged-release-retiming-t530/numerics/verify_moment.py new file mode 100644 index 0000000000..6f36c0baf1 --- /dev/null +++ b/research/staged-release-retiming-t530/numerics/verify_moment.py @@ -0,0 +1,53 @@ +#!/usr/bin/env python3 +"""Exact cost certification for the two commuting-release changes. +No global supplier/physical controller admission is inferred from arithmetic. +""" +import argparse,gzip,hashlib,importlib.util,json,sys +from fractions import Fraction as Q +from pathlib import Path + +def need(x,m): + if not x:raise ValueError(m) +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def load(name,p): + sp=importlib.util.spec_from_file_location(name,p);x=importlib.util.module_from_spec(sp);sp.loader.exec_module(x);return x +def dec(x): + from decimal import Decimal,localcontext + with localcontext() as c: + c.prec=80;return str(Decimal(x.numerator)/Decimal(x.denominator)) +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--repo',type=Path,required=True);ap.add_argument('--t530',type=Path,required=True);ap.add_argument('--words',type=Path,required=True);ap.add_argument('--out',type=Path,required=True);a=ap.parse_args() + price=load('exactprice',a.t530/'price.py') + ind=load('independent_price',a.repo/'research/pending-claims-independent-pricing/arith.py') + exp=read(a.t530/'EXPECTED.json');N=exp['replicas']*9;W=exp['replicas']*896 + need(N==4770 and W==474880,'actual T530 normalization') + old={int(k):v for k,v in exp['profile'].items()} + delta=None;pins={} + for tag in ('base','extra'): + s=a.t530/f'supplier3605/STAGED644-660-{tag}.json.gz';t=a.words/f'RETIMED644-660-{tag}.json.gz' + before,after=read(s),read(t);pins[str(s)]=hashlib.sha256(s.read_bytes()).hexdigest();pins[str(t)]=hashlib.sha256(t.read_bytes()).hexdigest() + for key in ('start_extra','helper_final','removed','warps','center_frames','cut','restore','A'): + need(before.get(key)==after.get(key),'preserved '+key) + x={int(k):v for k,v in before['report']['local_profile'].items()};y={int(k):v for k,v in after['report']['local_profile'].items()} + d={r:y.get(r,0)-x.get(r,0) for r in x.keys()|y.keys()};d={r:n for r,n in d.items() if n} + need(d=={1:-2,2:-2,3:2},'exact per-call profile delta') + need(before['report']['width_inventory']==after['report']['width_inventory'],'width inventory') + if delta is None:delta=d + else:need(delta==d,'providers share delta') + profile={r:old.get(r,0)+N*delta.get(r,0) for r in old.keys()|delta.keys()} + need(sum(r*n for r,n in old.items())==sum(r*n for r,n in profile.items()),'rank mass') + need(73*W-sum(r*n for r,n in profile.items())==W-64*N,'coverage law') + lo=Q('0.001730394391813963415120');hi=lo+Q(1,10**24) + signed={**profile,73:-W} + l,h=price.interval(signed,lo),price.interval(signed,hi) + need(l[1]<00 for x in row['strict_checks'].values()),'63 positive inequalities') + need(len(controls)==17 and all(x and all(Q(v['rational'])<=0 for v in x.values()) for x in controls.values()),'17 controls') + independent=read(a.out/'outer/INDEPENDENT.json');need(Q(independent['rows']['struct_boundary_radix_union']['kappa'])==K,'independent derivation') + result=dict(status='PASS_RETIMED_MODERN_OUTER_ARITHMETIC',kappa=str(K),strict_inequalities=63,rejected_controls=17,independent=independent['status'],ledger_sha256=sha(a.out/'outer/LEDGER.json'),checker_sha256=sha(a.out/'outer/check_ledger.py'),independent_checker_sha256=sha(inp),scope='Fresh source-bound exact arithmetic. Global changed-word controller/invoice release not inferred; inherited supplier and all-size premises remain.') + save(a.out/'RESULT.json',result);print(result['status']) +if __name__=='__main__':main() diff --git a/research/staged-release-retiming-t530/numerics/words/RETIMED644-660-base.json.gz b/research/staged-release-retiming-t530/numerics/words/RETIMED644-660-base.json.gz new file mode 100644 index 0000000000..d69125e0c7 Binary files /dev/null and b/research/staged-release-retiming-t530/numerics/words/RETIMED644-660-base.json.gz differ diff --git a/research/staged-release-retiming-t530/numerics/words/RETIMED644-660-extra.json.gz b/research/staged-release-retiming-t530/numerics/words/RETIMED644-660-extra.json.gz new file mode 100644 index 0000000000..f3c580b065 Binary files /dev/null and b/research/staged-release-retiming-t530/numerics/words/RETIMED644-660-extra.json.gz differ diff --git a/research/staged-release-retiming-t530/owner-audit/DERIVATION.json b/research/staged-release-retiming-t530/owner-audit/DERIVATION.json new file mode 100644 index 0000000000..d7e287e2d6 --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/DERIVATION.json @@ -0,0 +1,14 @@ +{ + "predecessor_script_sha256": "36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4", + "derived_script_sha256": "b51c36ad1ae0999547edc4726d698df369fef60daaaac4f5bbea471648c9f628", + "native_pins": { + "base": "ba1e3767f52c849c49d7d3852b879d9562265f1f51d15ca40421c51cae0aae6a", + "extra": "f30605f35030460f18b053dbd6031e862bf3c6661141d481d54ffdc1e8d1ad01" + }, + "changes": [ + "upstream directory explicit", + "actual fresh native canonical pins", + "local profile -2H1-2H2+2H3" + ], + "predicates": "All source, window, family, capacity, chronological-prefix, inventory and rejection checks retained" +} diff --git a/research/staged-release-retiming-t530/owner-audit/PUBLIC-INPUTS.json b/research/staged-release-retiming-t530/owner-audit/PUBLIC-INPUTS.json new file mode 100644 index 0000000000..31a7c228a0 --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/PUBLIC-INPUTS.json @@ -0,0 +1,43 @@ +{ + "derived_auditor_sha256": "b51c36ad1ae0999547edc4726d698df369fef60daaaac4f5bbea471648c9f628", + "literal_payload_sha256": "9f82e7d4abfcb52cd6d969e37e07415516856d7af85192010f3fc142dbaad246", + "main_base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "native_canonical_sha256": { + "base": "ba1e3767f52c849c49d7d3852b879d9562265f1f51d15ca40421c51cae0aae6a", + "extra": "f30605f35030460f18b053dbd6031e862bf3c6661141d481d54ffdc1e8d1ad01" + }, + "pending_predecessor": { + "head": "659fd5e7064d9466b668d7188cbb013b333a415a", + "owners_artifacts_git_blob": "01694a31e732d9f0a357ce3466cb2aa9f81a5855", + "pr": 3626 + }, + "python": "3.12 recommended; retained common.py requires >=3.11", + "regenerated_not_committed": [ + "literal/FILL.json.gz", + "literal/ORDER.json", + "literal/DISPATCH.json", + "literal/PROFILE.json", + "literal/PROVIDERS.json" + ], + "repo_files": { + "research/coupled-carrier-cap740/cap_check.py": "c2a2ea7df9ef2f7c7ae2739435f4ac44f2c912d8e18fc9278c717958f258ee38", + "research/coupled-carrier-cap740/common.py": "8786495cbf808d950be1c42e42d0198e950e44167af80063d25fd186aafea534", + "research/coupled-carrier-cap740/vendor/PR3133-CAP.json": "e32f3ecd5e6594935583f80f643cf1930e8bc017e3c541025c335395a15cf19c", + "research/coupled-carrier-cap740/vendor/PR3133-CREDITS.md": "1d9d8f56d8899f55878e4cb2c4e052b22506444016a51c2e678773505f5189e6", + "research/coupled-carrier-cap740/vendor/PR3133-FILL.json.gz": "68b8bae90144248774b1920cd27f9519caa3dc427704d8a9da6d4c491d912fc4", + "research/coupled-carrier-cap740/vendor/PR3133-NOTICE": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661", + "research/coupled-carrier-cap740/vendor/PR3133-PROVIDERS.json": "52eb0d85caa7b2d4a93acdf5011f52b793f61ddca86235fb03cd9a09397ad4cd", + "research/coupled-carrier-cap740/vendor/lift.py": "ae6c1fee78fbdec26976ca74ca89f6aab2528d763c596f6573132cb54d57cd3c", + "research/rank7-joint-endframes/allocation/DISPATCH.json": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c", + "research/rank7-joint-endframes/allocation/ORDER.json": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1", + "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" + }, + "runtime_dependencies": [ + "numpy" + ], + "schema": "staged-retiming-owner-public-inputs-v1", + "scope": "No network and no optimizer; unchanged exact integer-network reconstruction followed by preserved independent literal audit. Actual native canonical words are authenticated data, whose operator proofs are separate.", + "upstream_artifacts_manifest": "upstream/ARTIFACTS.json" +} diff --git a/research/staged-release-retiming-t530/owner-audit/PUBLIC-PROVENANCE.json b/research/staged-release-retiming-t530/owner-audit/PUBLIC-PROVENANCE.json new file mode 100644 index 0000000000..25786d7274 --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/PUBLIC-PROVENANCE.json @@ -0,0 +1,23 @@ +{ + "schema": "execution-metadata-publication-v1", + "files": [ + { + "file": "RESULT.json", + "original_sha256": "518fe7f8e07434000dcefc9ef6af568502626e24276881b046f7983a4fb67c19", + "public_sha256": "2c42518600f9e2bc9e868591aa25ab9ad012611fe528723a27214f03d3000b0d", + "change": "Only the local home-directory prefix replaced by $RESEARCH_WORKSPACE in execution metadata; all scientific values and input content hashes unchanged." + }, + { + "file": "evidence/FRESH-RESULT.json", + "original_sha256": "6227a002e7cc4b5cfe7d92c81c218928347cd5419c3de8faf3ab9e1a9f5462a4", + "public_sha256": "174ed7ec57441191ed025ca1c398771adced4a11388a0e16d80fc67ed593e5c8", + "change": "Only local home-directory prefix replaced by $RESEARCH_WORKSPACE, if present; all scientific values and input content hashes unchanged." + }, + { + "file": "evidence/FRESH-RUN.json", + "original_sha256": "7ea5abd27853ad3357feb8bcb596017a893c8415bb6fc0d242a6ee148c8596a1", + "public_sha256": "7ea5abd27853ad3357feb8bcb596017a893c8415bb6fc0d242a6ee148c8596a1", + "change": "Only local home-directory prefix replaced by $RESEARCH_WORKSPACE, if present; all scientific values and input content hashes unchanged." + } + ] +} diff --git a/research/staged-release-retiming-t530/owner-audit/README.md b/research/staged-release-retiming-t530/owner-audit/README.md new file mode 100644 index 0000000000..db09c0d799 --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/README.md @@ -0,0 +1,54 @@ +# Lean T530 ownership replay for the two release swaps + +This is a fresh, finite owner and invoice check. It regenerates all 1,946,160 literal helper-role rows without an optimizer, then independently verifies the actual source windows, physical families, chronological compact prefixes, capacities and complete histogram against the fresh canonical words. It does not rerun the canonical words' scalar/operator or native proofs, and does not establish an unconditional multiplication theorem. + +From the repository root: + +```sh +python3 -B research/staged-release-retiming-t530/owner-audit/run.py --out /tmp/staged-release-owner-check +``` + +The output directory must not exist and must be outside this package. Python 3.12 is recommended, and NumPy is required. The pinned predecessor uses `hashlib.file_digest`, so Python 3.11 is the minimum. The runner rejects optimized Python because the preserved predecessor assertions must remain enabled. `--repo /path/to/checkout` can select another checkout with exactly the same 13 source file hashes. The default derives the repository root from the runner's location; no working-directory assumption or network is required. + +## Fresh checks and retained records + +The new runner was executed from this public package with Python 3.12.14 and NumPy 2.5.4. The full literal reconstruction and independent owner audit passed in 19.23 seconds, and its before/after snapshot verified that no package file was written. The fresh output was outside the package. `evidence/FRESH-RUN.json` and `evidence/FRESH-RESULT.json` preserve that executed receipt, distinct from the earlier retained `RESULT.json`. + +A rerun performs all of the following: + +1. Authenticate the 13 existing-main dependencies and all 22 frozen PR3626 owner artifacts. +2. Execute the unchanged `upstream/portable_expand.py`, including its exact primal and deterministic integral-network checks, into a fresh output directory. This generates the full T530 literal journal and binds its decompressed payload to SHA256 `9f82e7d4abfcb52cd6d969e37e07415516856d7af85192010f3fc142dbaad246`. +3. Bind both actual retimed canonical words and read their local profile. Keep the literal ownership rows unchanged, replacing only the generated full profile by `H_new = H_old + 4770*(-2H1-2H2+2H3)`. +4. Execute `semantic_gate_controls.py`, which runs the exact preserved derived `independent_literal.py` once against the regenerated journal, changed profile and actual canonical words. Check all 1,946,160 rows, 4,770 calls and 530 replicas, then test five actual production gate statements on changed in-memory semantic inputs. Compare the positive receipt fields and verify that every package file remains unchanged. The historical five `reject()` lambdas are retained as provenance and are not counted as negative coverage. + +### Correction to the inherited negative-control claim + +[PR3694](https://github.com/CrocSwap/integer-mult-bounds/pull/3694) identified that the five inherited `reject()` lambdas do not invoke their corresponding production gates. A separate scratch reproduction confirmed that disabling all five named gates still leaves those historical controls reporting success. This is a test-coverage defect; the positive owner, window, family, prefix and invoice predicates remain genuine checks on the literal journal. Earlier receipts and their `controls` fields are preserved unchanged as historical records, not evidence of five genuine mutation tests. + +The owned companion now extracts the exact five unconditional `need(...)` AST statements from the authenticated derived auditor and checks that they match the frozen predecessor. It first executes the complete positive auditor, including source authentication, once. It then tests duplicate helper identity, time equal to an actual nonnegative strict lower endpoint, reuse of a same-call physical family, a chronological offset hole, and one unpaid rank-1 invoice child. The family case also executes the production key-computation statements. Each changed input must raise the exact expected gate error; the original input must pass before and after. Replacing that gate predicate by `True` must make its mutation test fail. + +`SEMANTIC-GATES.json` binds these five rejection results and five gate-disable sensitivity results to the preserved auditor, the new checker and the unchanged positive `RESULT.json`. These are isolated semantic gate tests on real journal data. They do not claim five complete corrupted-file replays through the artifact hash checks, or new native/controller/outer admission. The preserved auditor, upstream files, old receipts and full-admission source manifests are unchanged. + +The resulting complete profile is: + +```text +{1:11747920,2:3453480,3:1112042,4:486540,5:103690,8:38160,48:202828} +``` + +Physical stock is 475,389. The fresh independent audit derives idle counts `{1:123430,3:34022,5:8290,48:202828}`. The authenticated canonical words supply 408 helper roles and 91 zero buffers, each with width inventory `{4:26,5:2,6:18,7:52,8:97,9:213}` and local profile `{1:2437,2:724,3:226,4:102,5:20,8:8}`. + +The generated `PROVIDERS.json` is unchanged predecessor materialization metadata. This owner audit obtains the retimed bill and widths from the two authenticated canonical words instead. That generated predecessor provider metadata is not a retimed full-admission input. + +## Inputs, unchanged sources and provenance + +`PUBLIC-INPUTS.json` lists the exact 13 repository paths and SHA256 values, pending PR3626 head `659fd5e7064d9466b668d7188cbb013b333a415a`, the source base `20ecf2891d80b5acf18d980b2164fb44ea7faa90`, and the native and semantic payload pins. Every repository dependency was already present on that base. No main source is copied again and no 11 MB generated fill is committed. + +`upstream/` retains all 22 files authenticated by its unchanged `ARTIFACTS.json`. The PR3626 manifest Git blob `01694a31e732d9f0a357ce3466cb2aa9f81a5855` was checked against the exact pending head. Its original producers, source context, primal, expectations, independent auditor, proof, credits and notices retain their original bytes and hashes. + +`independent_literal.py` is the already-derived auditor, copied without predicate changes. `DERIVATION.json` documents the three preceding adaptations: explicit upstream directory, actual fresh native canonical pins, and the local bill `-2H1-2H2+2H3`. The original auditor remains at `upstream/independent_literal.py`. The runner authenticates both scripts before execution. Their positive checks are not replaced by stored PASS receipts. The owned companion supplies the additional semantic mutation coverage without editing either preserved script. + +Only this session's local home-directory prefix in public execution metadata is represented by `$RESEARCH_WORKSPACE`. `PUBLIC-PROVENANCE.json` records original and public SHA256 values; scientific fields and content hashes are unchanged. Frozen upstream sources are not normalized or rewritten. + +The independent owner check imports neither the producer nor a solver or inherited owner checker. The separate materialization subprocess does execute the frozen deterministic constructor; the subsequent auditor checks its complete literal output independently. Canonical native frame tables are authenticated inputs; the separate complete operator and native proofs must bind those exact words. + +Source credit and Apache-2.0 notices are retained in `upstream/UPSTREAM-SOURCE-CREDITS.md` and `upstream/UPSTREAM-SOURCE-NOTICE`, including PR3605's staged entering helpers, PR3626's T530 construction, PR3133/PR3148 and their named predecessors. The new release retiming, integration and package wrapper had substantial OpenAI Codex assistance. No independent human or formal-kernel review is claimed. diff --git a/research/staged-release-retiming-t530/owner-audit/RESULT.json b/research/staged-release-retiming-t530/owner-audit/RESULT.json new file mode 100644 index 0000000000..9ef094d014 --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/RESULT.json @@ -0,0 +1,41 @@ +{ + "calls": 4770, + "controls": [ + "duplicate helper", + "strict lower endpoint used as available", + "same-call family reused", + "unpaid chronological hole", + "one unpaid rank1 child" + ], + "idle": { + "1": 123430, + "3": 34022, + "5": 8290, + "48": 202828 + }, + "input_sha256": { + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/integer-mult-bounds/research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/integer-mult-bounds/research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/retimed-literal/DISPATCH.json": "a758a59b001f3bdda07e6a1a98bc8bd0339461dee5ec6b1909925030a043eddb", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/retimed-literal/FILL.json.gz": "d1cc162ad8ddfaee30643248af2997d6b8b4cc34e141a785f439b1c79fb9484c", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/retimed-literal/ORDER.json": "599fb079a23b403f9de9e334d7c463f0cad28f9d69d1f99fcbf93abb72e935eb", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/retimed-literal/PROFILE.json": "32c51c89f66339fd2bb778a06be68851d62c946dd7a3ff77573fb2416b8335cb", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/retimed-owner-audit/native/checked-base/CANONICAL-WORD.json.gz": "ba1e3767f52c849c49d7d3852b879d9562265f1f51d15ca40421c51cae0aae6a", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/retimed-owner-audit/native/checked-extra/CANONICAL-WORD.json.gz": "f30605f35030460f18b053dbd6031e862bf3c6661141d481d54ffdc1e8d1ad01" + }, + "physical": 475389, + "profile": { + "1": 11747920, + "2": 3453480, + "3": 1112042, + "4": 486540, + "5": 103690, + "8": 38160, + "48": 202828 + }, + "replicas": 530, + "roles": 1946160, + "scope": "Independent finite vectorized audit; no producer, solver, retained owner checker or reconstructor imports. Actual native frames are authenticated input data; their separate full operator proofs are required.", + "script_sha256": "b51c36ad1ae0999547edc4726d698df369fef60daaaac4f5bbea471648c9f628", + "status": "PASS_INDEPENDENT_LITERAL_OWNER_WINDOWS_FAMILIES_PREFIXES_AND_INVOICE" +} diff --git a/research/staged-release-retiming-t530/owner-audit/evidence/FRESH-RESULT.json b/research/staged-release-retiming-t530/owner-audit/evidence/FRESH-RESULT.json new file mode 100644 index 0000000000..b018387103 --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/evidence/FRESH-RESULT.json @@ -0,0 +1,41 @@ +{ + "calls": 4770, + "controls": [ + "duplicate helper", + "strict lower endpoint used as available", + "same-call family reused", + "unpaid chronological hole", + "one unpaid rank1 child" + ], + "idle": { + "1": 123430, + "3": 34022, + "5": 8290, + "48": 202828 + }, + "input_sha256": { + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/integer-mult-bounds-pr/research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/integer-mult-bounds-pr/research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/integer-mult-bounds-pr/research/staged-release-retiming-t530/owner-audit/native/checked-base/CANONICAL-WORD.json.gz": "ba1e3767f52c849c49d7d3852b879d9562265f1f51d15ca40421c51cae0aae6a", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/integer-mult-bounds-pr/research/staged-release-retiming-t530/owner-audit/native/checked-extra/CANONICAL-WORD.json.gz": "f30605f35030460f18b053dbd6031e862bf3c6661141d481d54ffdc1e8d1ad01", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/lean-owner-public-check/literal/DISPATCH.json": "a758a59b001f3bdda07e6a1a98bc8bd0339461dee5ec6b1909925030a043eddb", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/lean-owner-public-check/literal/FILL.json.gz": "d1cc162ad8ddfaee30643248af2997d6b8b4cc34e141a785f439b1c79fb9484c", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/lean-owner-public-check/literal/ORDER.json": "599fb079a23b403f9de9e334d7c463f0cad28f9d69d1f99fcbf93abb72e935eb", + "$RESEARCH_WORKSPACE/Documents/Codex/2026-10-18/https-github-com-crocswap-integer-mult-2/work/lean-owner-public-check/literal/PROFILE.json": "e021f99b1d33c2b751b22151a41ec3ba47b94d05707ceacc6526987f9b49894a" + }, + "physical": 475389, + "profile": { + "1": 11747920, + "2": 3453480, + "3": 1112042, + "4": 486540, + "5": 103690, + "8": 38160, + "48": 202828 + }, + "replicas": 530, + "roles": 1946160, + "scope": "Independent finite vectorized audit; no producer, solver, retained owner checker or reconstructor imports. Actual native frames are authenticated input data; their separate full operator proofs are required.", + "script_sha256": "b51c36ad1ae0999547edc4726d698df369fef60daaaac4f5bbea471648c9f628", + "status": "PASS_INDEPENDENT_LITERAL_OWNER_WINDOWS_FAMILIES_PREFIXES_AND_INVOICE" +} diff --git a/research/staged-release-retiming-t530/owner-audit/evidence/FRESH-RUN.json b/research/staged-release-retiming-t530/owner-audit/evidence/FRESH-RUN.json new file mode 100644 index 0000000000..1a2f562dc7 --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/evidence/FRESH-RUN.json @@ -0,0 +1,21 @@ +{ + "derived_profile": { + "1": 11747920, + "2": 3453480, + "3": 1112042, + "4": 486540, + "5": 103690, + "8": 38160, + "48": 202828 + }, + "fresh_independent_owner_audit": true, + "fresh_literal_reconstruction": true, + "numpy": "2.5.4", + "package_files_unchanged": true, + "python": "3.12.14 (main, Aug 25 2026, 13:50:33) [Clang 22.1.3 ]", + "scope": "Fresh finite reconstruction and independent ownership/invoice checks; canonical native frame tables are authenticated inputs, not operator proofs rerun by this command.", + "seconds": 19.2313930420205, + "source_files": 13, + "status": "PASS_LEAN_REGENERATED_OWNER_AUDIT", + "upstream_artifacts": 22 +} diff --git a/research/staged-release-retiming-t530/owner-audit/evidence/SEMANTIC-CONTROLS-FOLLOWUP.json b/research/staged-release-retiming-t530/owner-audit/evidence/SEMANTIC-CONTROLS-FOLLOWUP.json new file mode 100644 index 0000000000..baeb17be61 --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/evidence/SEMANTIC-CONTROLS-FOLLOWUP.json @@ -0,0 +1,99 @@ +{ + "checker_sha256": "5638f9eb05c19be43b6579aa82ab9c01e5648bfeb3d8963042ef6a463dc6e335", + "gate_disable_sensitivities": 5, + "historical_reject_lambdas_counted": false, + "positive_receipt_sha256": "c30b8dda1833b436c2d07a517c413f24ce1f15c31eeb1b628101711020fd7874", + "predecessor_source_sha256": "36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4", + "roles": 1946160, + "scope": "Fresh authenticated complete positive owner audit followed by five isolated production AST gate tests on changed in-memory inputs, each sensitive to disabling its gate. Not five end-to-end corrupted-artifact replays. Frozen auditor and source manifests are unchanged; historical reject lambdas provide no negative coverage.", + "seconds": 1.8133439169614576, + "semantic_mutants_rejected": 5, + "source_sha256": "b51c36ad1ae0999547edc4726d698df369fef60daaaac4f5bbea471648c9f628", + "status": "PASS_FIVE_EXACT_PRODUCTION_GATE_MUTATIONS_AND_FIVE_DISABLE_SENSITIVITIES", + "tests": [ + { + "baseline_passed": true, + "disabling_gate_makes_control_fail": true, + "gate": "helper_identity", + "message": "complete literal ordered helper identities", + "mutant_rejected_at_expected_gate": true, + "mutation": { + "column": "helper", + "new": 0, + "old": 1, + "row": 1 + }, + "predicate_sha256": "7c75c732719e03df7e9f327aee1de48a432ad301f43fa8de9279279ed719c835", + "restored_baseline_passed": true, + "source_line": 98 + }, + { + "baseline_passed": true, + "disabling_gate_makes_control_fail": true, + "gate": "window", + "message": "strict/closed actual source windows", + "mutant_rejected_at_expected_gate": true, + "mutation": { + "column": "time", + "meaning": "exact strict lower endpoint", + "new": 70, + "old": 100, + "row": 40802 + }, + "predicate_sha256": "2a72a2fb1b76cc872b93e0df6fc15672432e6c4d8abd33bdc567754c74e433f7", + "restored_baseline_passed": true, + "source_line": 102 + }, + { + "baseline_passed": true, + "disabling_gate_makes_control_fail": true, + "gate": "family", + "message": "same-call physical family uniqueness", + "mutant_rejected_at_expected_gate": true, + "mutation": { + "columns": [ + "owner_replica", + "child", + "port" + ], + "copied_from_row": 0, + "meaning": "two helpers of the same call share a physical family", + "row": 1 + }, + "predicate_sha256": "ef57448e3ed1769ad515690ab2805325ed8670b29a6d996cc9d66160a0414837", + "restored_baseline_passed": true, + "source_line": 105 + }, + { + "baseline_passed": true, + "disabling_gate_makes_control_fail": true, + "gate": "prefix", + "message": "every chronological pending mask is a compact prefix", + "mutant_rejected_at_expected_gate": true, + "mutation": { + "column": "offset", + "new": 1, + "old": 0, + "row": 2006 + }, + "predicate_sha256": "f8cacaf9b9a853b3d6270a118224710e89bebd9a242881bd492d11b1a35b6149", + "restored_baseline_passed": true, + "source_line": 110 + }, + { + "baseline_passed": true, + "disabling_gate_makes_control_fail": true, + "gate": "histogram", + "message": "independent complete histogram", + "mutant_rejected_at_expected_gate": true, + "mutation": { + "new": 11747921, + "old": 11747920, + "rank": 1 + }, + "predicate_sha256": "eb01bc2b4f1aadbdb5fcd993f794679db1f50bd81d1d15ce2e8c79a88ba5114d", + "restored_baseline_passed": true, + "source_line": 116 + } + ] +} diff --git a/research/staged-release-retiming-t530/owner-audit/independent_literal.py b/research/staged-release-retiming-t530/owner-audit/independent_literal.py new file mode 100644 index 0000000000..86dc50768f --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/independent_literal.py @@ -0,0 +1,129 @@ +# SPDX-License-Identifier: Apache-2.0 +# Adapted from PR3605; retained attribution in UPSTREAM-SOURCE-CREDITS.md. +import sys +if not __debug__ or sys.flags.optimize: + raise RuntimeError("Enabled assertions required before owner replay") +"""Path-adapted copy of the parent independent owner audit. +Original SHA256 1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e. +Filesystem/source authentication and output paths adapted; mathematical predicates retained. +""" +"""Independent vectorized audit of the literal staged-pair owner journal. + +No optimizer, producer, inherited owner checker or reconstructor is imported. +Uses the source execution template and the actual checked native frame tables. +""" +from pathlib import Path +from collections import Counter +import gzip,hashlib,json,os,sys +import numpy as np +R=Path(os.environ["OWNER_UPSTREAM_DIR"]).resolve() +DERIVED_NATIVE_PINS={'base': 'ba1e3767f52c849c49d7d3852b879d9562265f1f51d15ca40421c51cae0aae6a', 'extra': 'f30605f35030460f18b053dbd6031e862bf3c6661141d481d54ffdc1e8d1ad01'} +if not __debug__:raise SystemExit('unoptimized Python required') +for _key in ('OWNER_SOURCE_REPO','OWNER_LITERAL_DIR','OWNER_NATIVE_DIR','OWNER_AUDIT_OUTPUT'): + if not os.environ.get(_key):raise SystemExit('missing '+_key) +A=Path(os.environ['OWNER_LITERAL_DIR']).resolve() +NATIVE=Path(os.environ['OWNER_NATIVE_DIR']).resolve() +S=Path(os.environ['OWNER_SOURCE_REPO']).resolve()/'research/rank7-joint-endframes/allocation/vendor' +def need(v,m): + if not v:raise ValueError(m) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def rank(v): + piv={} + for q in v: + while q: + h=q.bit_length() + if h in piv:q^=piv[h] + else:piv[h]=q;break + return len(piv) +for rel,digest in read(R/'ARTIFACTS.json').items(): + f=R/rel;need(f.is_file() and not f.is_symlink() and sha(f)==digest,'frozen audit artifact '+rel) +paths=[A/n for n in ('FILL.json.gz','ORDER.json','DISPATCH.json','PROFILE.json')]+[S/'PLAN.json.gz',S/'TEMPLATE.json.gz'] +paths += [NATIVE/f'checked-{p}/CANONICAL-WORD.json.gz' for p in ('base','extra')] +source_pins=read(R/'SOURCE-PINS.json') +repo=Path(os.environ['OWNER_SOURCE_REPO']).resolve() +for rel,digest in source_pins['repo_files'].items():need(sha(repo/rel)==digest,'retained source pin '+rel) +for tag in ('base','extra'):need(sha(NATIVE/f'checked-{tag}/CANONICAL-WORD.json.gz')==DERIVED_NATIVE_PINS[tag],'actual native canonical pin') +pins={str(p):sha(p) for p in paths} +expected=read(R/'EXPECTED.json');need(hashlib.sha256(gzip.decompress(paths[0].read_bytes())).hexdigest()==expected['payload_sha256'],'freshT530payload') +baseorder=read(R/'ORDER37.json')+[[s,r+37]for s,r in read(R/'T16-ORDER.json')] +need(read(paths[1])==[[s,r+53*cp]for s,r in baseorder for cp in range(10)],'exactmixedsourceclock') +basedispatch={(s,r):p for s,r,p in read(R/'DISPATCH37.json')};basedispatch.update({(s,r+37):p for s,r,p in read(R/'T16-DISPATCH.json')}) +need(read(paths[2])==[[s,r+53*cp,basedispatch[s,r]]for s,r in baseorder for cp in range(10)],'exactsourceproviderdispatch') +order=read(paths[1]);dispatch=read(paths[2]);profile={int(k):v for k,v in read(paths[3]).items()};plan=read(paths[4]);template=read(paths[5]) +T=530;N=9*T +need(len(order)==N and len(set(map(tuple,order)))==N,'call coverage') +clock={tuple(call):t for t,call in enumerate(order)} +need(set(clock)=={(s,r) for s in range(9) for r in range(T)},'exact source calls') +need(all([clock[s,r] for s in range(9)]==sorted(clock[s,r] for s in range(9)) for r in range(T)),'per-replica order') +D={(s,r):p for s,r,p in dispatch};need(len(dispatch)==N and set(D)==set(clock),'dispatch coverage') +need(Counter(D.values())=={'extra': 2090, 'gauge44': 2680},'provider count') +# Reconstruct source windows per replica from the actual source event sequence. +children={x['child']:x['rank'] for x in template['idle_children']};K=max(children)+1 +cap=np.zeros((T,K),dtype=np.int64);lo=np.full((T,K),N,dtype=np.int64);hi=np.full((T,K),-2,dtype=np.int64) +local_pair={x['stage']:x['pair'] for x in template['recipe'] if x['kind']=='local'} +for r in range(T): + touched={};t=None + for ev in template['execution_schedule']: + kind=ev['kind'] + if kind in ('bank_padding_cover_sweep','translate_every_live_family'):continue + if kind=='local_cover_sweep': + t=clock[ev['stage'],r];touched[local_pair[ev['stage']]]=t + elif kind=='bridge': + need(t is not None,'bridge source');touched[ev['src']]=t;touched[ev['dst']]=t + elif kind=='idle_cover_sweep': + need(t is not None,'idle source') + for c in ev['child_indices']: + if c in children: + need(cap[r,c]==0,'unique source child');cap[r,c]=children[c];lo[r,c]=touched.get(ev['pair'],-1);hi[r,c]=t + else:need(kind in ('terminal_Y_translations','terminal'),'known source event') +need(np.all(cap[:,list(children)]>0),'all source windows') +fam=np.full(K,-1,np.int64) +for c in children:fam[c]=2*plan['pairs'][str(c)]+plan['sides'][str(c)] +widths={};L=None +for tag,pid in [('base','gauge44'),('extra','extra')]: + w=read(NATIVE/f'checked-{tag}/CANONICAL-WORD.json.gz') + need(w['R']==408 and len(w['zero_buffers'])==91,'native helper stock') + widths[pid]=np.array([rank(w['frames'][w['final'][224+h]])-rank(w['frames'][w['start'][224+h]]) for h in range(408)],dtype=np.int64) + need(Counter(widths[pid])=={4:26,5:2,6:18,7:52,8:97,9:213},'actual native widths') + loc={int(k):v for k,v in w['local_profile'].items()} + need(L is None or L==loc,'common actual native bill');L=loc +need(L=={1:2437,2:724,3:226,4:102,5:20,8:8},'two commuting release swaps local bill') +bycall=np.stack([widths[D[tuple(call)]] for call in order]) +j=read(A/'FILL.json.gz');need(j['columns']==['time','helper','owner_replica','child','port','offset'] and j['dispatch_overrides']==[],'journal schema') +need(all(len(row)==6 and all(type(v) is int for v in row) for row in j['rows']),'literal integer roles') +rows=np.array(j['rows'],dtype=np.int64);del j +need(rows.shape==(N*408,6),'literal role shape') +need(np.array_equal(rows[:,0],np.repeat(np.arange(N),408)) and np.array_equal(rows[:,1],np.tile(np.arange(408),N)),'complete literal ordered helper identities') +t,h,o,c,p,z=rows.T +need(np.all((o>=0)&(o=0)&(c=0)&(p<112)),'owner bounds') +need(np.all(cap[o,c]>0),'declared source child') +need(np.all((lo[o,c]=0)&(z+w<=cap[o,c])),'actual widths and capacity') +binid=(o*K+c)*112+p +idx=np.lexsort((t,binid));bins=binid[idx];ws=w[idx];starts=np.r_[True,bins[1:]!=bins[:-1]] +cs=np.cumsum(ws,dtype=np.int64)-ws;baseline=np.maximum.accumulate(np.where(starts,cs,0));expected=cs-baseline +need(np.array_equal(z[idx],expected),'every chronological pending mask is a compact prefix') +used=np.zeros(T*K*112,np.int64);np.add.at(used,binid,w) +allcap=np.repeat(cap.reshape(-1),112);valid=allcap>0 +need(np.all(used[~valid]==0) and np.all(used<=allcap),'full used-bin mass') +idle=Counter(map(int,(allcap-used)[valid]));idle.pop(0,None) +H=Counter({r:n*N for r,n in L.items()});H.update(idle) +need(dict(H)==profile and sum(r*n for r,n in H.items())==65088*T,'independent complete histogram') +# Small semantic predicates test each independent gate on actual changed inputs. +controls=[] +def reject(name,test): + need(not test(), 'control accepted '+name);controls.append(name) +reject('duplicate helper',lambda: np.array_equal(np.r_[rows[0,1],rows[:-1,1]],np.tile(np.arange(408),N))) +reject('strict lower endpoint used as available',lambda: bool(lo[o[0],c[0]]0 for v in total.values()),'Positive paid histogram') + profile_text=json.dumps(dict(sorted(total.items())),indent=2)+'\n' + (literal/'PROFILE.json').write_text(profile_text) + need(total==Counter({int(k):v for k,v in read(HERE/'RESULT.json')['profile'].items()}),'New full invoice matches retained receipt') + env.update({'OWNER_UPSTREAM_DIR':str(HERE/'upstream'),'OWNER_LITERAL_DIR':str(literal),'OWNER_NATIVE_DIR':str(HERE/'native'),'OWNER_AUDIT_OUTPUT':str(out/'RESULT.json')}) + subprocess.run([sys.executable,'-B',str(HERE/'semantic_gate_controls.py')],env=env,check=True) + semantic=read(out/'SEMANTIC-GATES.json') + need(semantic['status']=='PASS_FIVE_EXACT_PRODUCTION_GATE_MUTATIONS_AND_FIVE_DISABLE_SENSITIVITIES' + and semantic['semantic_mutants_rejected']==semantic['gate_disable_sensitivities']==5 + and semantic['historical_reject_lambdas_counted'] is False,'Fresh semantic gate controls') + need(semantic['source_sha256']==derivation['derived_script_sha256'] + and semantic['checker_sha256']==sha(HERE/'semantic_gate_controls.py') + and semantic['positive_receipt_sha256']==sha(out/'RESULT.json'),'Semantic gate receipt binding') + retained=read(HERE/'RESULT.json');actual=read(out/'RESULT.json') + for key in ('status','replicas','calls','roles','physical','idle','profile','script_sha256','controls','scope'): + need(actual[key]==retained[key],'Independent receipt mismatch: '+key) + need(snapshot()==before,'Package changed during replay') + receipt={'status':'PASS_LEAN_REGENERATED_OWNER_AUDIT','seconds':time.monotonic()-start,'python':sys.version,'numpy':numpy.__version__,'fresh_literal_reconstruction':True,'fresh_independent_owner_audit':True,'fresh_semantic_gate_mutations':5,'gate_disable_sensitivities':5,'historical_reject_lambdas_counted':False,'semantic_gate_receipt_sha256':sha(out/'SEMANTIC-GATES.json'),'package_files_unchanged':True,'source_files':len(inputs['repo_files']),'upstream_artifacts':len(read(HERE/'upstream/ARTIFACTS.json')),'derived_profile':dict(sorted(total.items())),'scope':'Fresh finite reconstruction and independent ownership/invoice checks; canonical native frame tables are authenticated inputs, not operator proofs rerun by this command.'} + (out/'RUN.json').write_text(json.dumps(receipt,indent=2,sort_keys=True)+'\n');print(json.dumps(receipt,indent=2)) + +if __name__=='__main__':main() diff --git a/research/staged-release-retiming-t530/owner-audit/semantic_gate_controls.py b/research/staged-release-retiming-t530/owner-audit/semantic_gate_controls.py new file mode 100644 index 0000000000..e94fd5a117 --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/semantic_gate_controls.py @@ -0,0 +1,190 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Run the preserved auditor and test its exact production semantic gate nodes. + +The auditor and frozen inputs remain byte-identical. These are five isolated +in-memory gate tests, not five end-to-end corrupted-artifact replays. Historical +reject() lambdas in the preserved auditor are not counted as negative coverage. +Prepared with substantial OpenAI Codex assistance. +""" +import ast +import copy +import hashlib +import json +import os +from pathlib import Path +import runpy +import sys +import time + +HERE = Path(__file__).resolve().parent +SOURCE = HERE / 'independent_literal.py' +GATES = { + 'helper_identity': 'complete literal ordered helper identities', + 'window': 'strict/closed actual source windows', + 'family': 'same-call physical family uniqueness', + 'prefix': 'every chronological pending mask is a compact prefix', + 'histogram': 'independent complete histogram', +} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def inventory(path): + """Select unconditional production statements, failing closed on ambiguity.""" + found = {} + assignments = {} + for statement in ast.parse(path.read_text()).body: + if isinstance(statement, ast.Assign) and len(statement.targets) == 1: + target = statement.targets[0] + if isinstance(target, ast.Name) and target.id in ('family', 'key', 'sort'): + need(target.id not in assignments, 'Repeated family computation') + assignments[target.id] = statement + if not isinstance(statement, ast.Expr) or not isinstance(statement.value, ast.Call): + continue + call = statement.value + if (isinstance(call.func, ast.Name) and call.func.id == 'need' + and len(call.args) == 2 and isinstance(call.args[1], ast.Constant) + and call.args[1].value in GATES.values()): + message = call.args[1].value + need(message not in found, 'Repeated production gate: ' + message) + found[message] = statement + need(set(found) == set(GATES.values()), 'Exact five unconditional production gates') + need(set(assignments) == {'family', 'key', 'sort'}, 'Exact family recomputation') + computation = [assignments[name] for name in ('family', 'key', 'sort')] + need([node.lineno for node in computation] == sorted(node.lineno for node in computation) + and computation[-1].lineno <= found[GATES['family']].lineno, + 'Family computation precedes its production gate') + return found, computation + + +def execute(nodes, context): + module = ast.Module(body=copy.deepcopy(nodes), type_ignores=[]) + exec(compile(module, str(SOURCE), 'exec'), context) + + +def rejected(node, context, message): + try: + execute([node], context) + except ValueError as error: + need(str(error) == message, 'Rejected at an unintended condition: ' + str(error)) + return True + return False + + +def mutation(label, context, family_computation): + # Namespace copies retain baseline storage; only modified arrays are copied. + changed = dict(context) + np = context['np'] + if label == 'helper_identity': + changed['rows'] = context['rows'].copy() + changed['rows'][1, 1] = changed['rows'][0, 1] + details = {'row': 1, 'column': 'helper', 'old': int(context['rows'][1, 1]), + 'new': int(changed['rows'][1, 1])} + elif label == 'window': + candidates = np.flatnonzero(context['lo'][context['o'], context['c']] >= 0) + need(len(candidates) > 0, 'Nonnegative strict endpoint fixture exists') + row = int(candidates[0]) + changed['t'] = context['t'].copy() + changed['t'][row] = context['lo'][context['o'][row], context['c'][row]] + details = {'row': row, 'column': 'time', 'old': int(context['t'][row]), + 'new': int(changed['t'][row]), 'meaning': 'exact strict lower endpoint'} + elif label == 'family': + need(context['t'][0] == context['t'][1], 'Same-call family fixture') + for name in ('o', 'c', 'p'): + changed[name] = context[name].copy() + changed[name][1] = changed[name][0] + # Recompute the family keys with the production assignments, not a + # duplicated implementation of the uniqueness predicate or key formula. + execute(family_computation, changed) + details = {'row': 1, 'columns': ['owner_replica', 'child', 'port'], + 'copied_from_row': 0, + 'meaning': 'two helpers of the same call share a physical family'} + elif label == 'prefix': + row = int(context['idx'][0]) + changed['z'] = context['z'].copy() + changed['z'][row] += 1 + details = {'row': row, 'column': 'offset', 'old': int(context['z'][row]), + 'new': int(changed['z'][row])} + elif label == 'histogram': + changed['profile'] = dict(context['profile']) + changed['profile'][1] += 1 + details = {'rank': 1, 'old': context['profile'][1], 'new': changed['profile'][1]} + else: + raise ValueError('Unknown semantic mutation: ' + label) + return changed, details + + +def main(): + need(__debug__ and not sys.flags.optimize, 'Assertions-enabled Python is required') + started = time.monotonic() + derivation = json.loads((HERE / 'DERIVATION.json').read_text()) + source_pin = derivation['derived_script_sha256'] + need(sha(SOURCE) == source_pin, 'Authenticated preserved auditor') + output = Path(os.environ['OWNER_AUDIT_OUTPUT']).resolve() + semantic_output = output.with_name('SEMANTIC-GATES.json') + need(not semantic_output.exists(), 'Fresh semantic-gate receipt') + # Authentication, the complete positive audit, and its original RESULT.json + # execute once. No producer or validator predicate is replaced or bypassed. + context = runpy.run_path(str(SOURCE), run_name='__main__') + gates, family_computation = inventory(SOURCE) + inherited = HERE / 'upstream/independent_literal.py' + need(sha(inherited) == derivation['predecessor_script_sha256'], 'Frozen predecessor auditor') + inherited_gates, inherited_family = inventory(inherited) + for message in GATES.values(): + need(ast.dump(gates[message], include_attributes=False) + == ast.dump(inherited_gates[message], include_attributes=False), + 'Same inherited production gate: ' + message) + need([ast.dump(node, include_attributes=False) for node in family_computation] + == [ast.dump(node, include_attributes=False) for node in inherited_family], + 'Same inherited family computation') + baseline_rows = hashlib.sha256(context['rows']).hexdigest() + baseline_profile = dict(context['profile']) + tests = [] + for label, message in GATES.items(): + node = gates[message] + execute([node], dict(context)) + bad, details = mutation(label, context, family_computation) + need(rejected(node, bad, message), 'Semantic mutation accepted: ' + label) + disabled = copy.deepcopy(node) + disabled.value.args[0] = ast.copy_location(ast.Constant(True), disabled.value.args[0]) + ast.fix_missing_locations(disabled) + need(not rejected(disabled, bad, message), + 'Disabling the gate did not break the negative test: ' + label) + execute([node], dict(context)) + tests.append({'gate': label, 'source_line': node.lineno, 'message': message, + 'predicate_sha256': hashlib.sha256( + ast.dump(node, include_attributes=False).encode()).hexdigest(), + 'baseline_passed': True, 'mutation': details, + 'mutant_rejected_at_expected_gate': True, + 'disabling_gate_makes_control_fail': True, + 'restored_baseline_passed': True}) + del bad + need(hashlib.sha256(context['rows']).hexdigest() == baseline_rows + and context['profile'] == baseline_profile, 'Baseline semantic inputs unchanged') + need(sha(SOURCE) == source_pin, 'Preserved auditor unchanged') + receipt = { + 'status': 'PASS_FIVE_EXACT_PRODUCTION_GATE_MUTATIONS_AND_FIVE_DISABLE_SENSITIVITIES', + 'source_sha256': source_pin, 'predecessor_source_sha256': sha(inherited), + 'checker_sha256': sha(Path(__file__)), 'positive_receipt_sha256': sha(output), + 'roles': len(context['rows']), 'tests': tests, 'seconds': time.monotonic() - started, + 'semantic_mutants_rejected': len(tests), 'gate_disable_sensitivities': len(tests), + 'historical_reject_lambdas_counted': False, + 'scope': 'Fresh authenticated complete positive owner audit followed by five isolated ' + 'production AST gate tests on changed in-memory inputs, each sensitive to disabling ' + 'its gate. Not five end-to-end corrupted-artifact replays. Frozen auditor and ' + 'source manifests are unchanged; historical reject lambdas provide no negative coverage.'} + semantic_output.write_text(json.dumps(receipt, indent=2, sort_keys=True) + '\n') + print(json.dumps({'status': receipt['status'], 'semantic_mutants_rejected': len(tests), + 'gate_disable_sensitivities': len(tests)}, indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/staged-release-retiming-t530/owner-audit/upstream/ARTIFACTS.json b/research/staged-release-retiming-t530/owner-audit/upstream/ARTIFACTS.json new file mode 100644 index 0000000000..01694a31e7 --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/upstream/ARTIFACTS.json @@ -0,0 +1,24 @@ +{ + "ORDER37.json": "94803d190b2b0506d9645e980b57cdbc3e98221f3b615292df8a94f1b174c984", + "T16-DISPATCH.json": "282960b7163bc305675b64d1d0faee9f71b18848748326418a013626944c6488", + "DEPENDENCIES.json": "785cebd02d407dc6442cfb0604d9b232d93dd049fd319fc5f0ceacb314715272", + "integral_network.py": "97cce7cdaeea2c415b7959d3bdbf34d272e3b541f6e7dc9b87c134a2c2620740", + "EXPECTED.json": "4fac5fcc90e20405c0ad176d7466cbd52eb947c02fd34fe35fea18eaf372d79a", + "SOURCE-PINS.json": "7dec42af587af3b7ae66d4fdf3d0c6157f9c85eb744edec66fa266f294378e5e", + "UPSTREAM-PROOF.md": "11113405347bb8a85a85c6d5b516ff3dcdb15e01d4b16f825ba4eb314a1be5cd", + "CANDIDATE.json": "7755b8e7aed8dbfbe89fe64fdfebee04ad84de3c6c9020b3535eb04fdabccec1", + "UPSTREAM-SOURCE-NOTICE": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661", + "PROVIDERS.json": "d96f2798024ab83edbb8848b62c425992aec182f1f24ef46bb8286dd390618c2", + "T16-PROVENANCE.json": "ebc9d5d23d5a698b795deee783c991910d2027cdb2e2f7561854df4189a63621", + "test_owner_guards.py": "fecbf1518c4594c64276847f92d5980443c6b5562345e97354305d5c31530bb0", + "verify_candidate.py": "efce5f7b1cbc3f8d0807312da5248209d1b2dd9d6043656a7d2e58b58887214b", + "portable_expand.py": "3a0ded73b3b8c6e945f28626c65c2160b540df5c3e86db5a48eb5639c5731f4c", + "source_context.py": "9967d6f5c0ca5f8437f76e3130c39aea3ff53e3d1ffa04a54d17db5f44f69f4c", + "README.txt": "7b9e8d85c1d0edfc265dc321a32752d76f1c94fa76dd7a931fff9066f57bd3a6", + "INPUT-PINS.json": "9b4b64a1e7d596f6ca8c4be8c2592544bce15a91dee988a31e89f0acb66cff7e", + "T16-ORDER.json": "9b2106c84aed23a7c3c8b99e21d3e96c66b12f92980a42ab2f6dbbe7831ef7c4", + "UPSTREAM-SOURCE-CREDITS.md": "1d9d8f56d8899f55878e4cb2c4e052b22506444016a51c2e678773505f5189e6", + "DISPATCH37.json": "4f78935b2ef1f6c08c9c16433d54015def1eccd767443b496a77ea8823690df6", + "verify_owner.py": "8d1a3c2a7beb0f18e2beaa3df455a721ea6129343ec52031d18e58fbde5081cb", + "independent_literal.py": "36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4" +} diff --git a/research/staged-release-retiming-t530/owner-audit/upstream/CANDIDATE.json b/research/staged-release-retiming-t530/owner-audit/upstream/CANDIDATE.json new file mode 100644 index 0000000000..0cc7c249dd --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/upstream/CANDIDATE.json @@ -0,0 +1,34257 @@ +{ + "schema": "mixed-chronology-aggregate-input-v1", + "baseT": 53, + "S": 10, + "order": [ + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 0, + 4 + ], + [ + 1, + 0 + ], + [ + 0, + 5 + ], + [ + 1, + 1 + ], + [ + 0, + 6 + ], + [ + 1, + 2 + ], + [ + 0, + 7 + ], + [ + 1, + 3 + ], + [ + 0, + 8 + ], + [ + 1, + 4 + ], + [ + 0, + 9 + ], + [ + 2, + 0 + ], + [ + 1, + 5 + ], + [ + 0, + 10 + ], + [ + 2, + 1 + ], + [ + 1, + 6 + ], + [ + 0, + 11 + ], + [ + 2, + 2 + ], + [ + 1, + 7 + ], + [ + 0, + 12 + ], + [ + 2, + 3 + ], + [ + 1, + 8 + ], + [ + 0, + 13 + ], + [ + 2, + 4 + ], + [ + 1, + 9 + ], + [ + 3, + 0 + ], + [ + 0, + 14 + ], + [ + 2, + 5 + ], + [ + 1, + 10 + ], + [ + 3, + 1 + ], + [ + 0, + 15 + ], + [ + 2, + 6 + ], + [ + 1, + 11 + ], + [ + 3, + 2 + ], + [ + 0, + 16 + ], + [ + 2, + 7 + ], + [ + 1, + 12 + ], + [ + 3, + 3 + ], + [ + 0, + 17 + ], + [ + 2, + 8 + ], + [ + 1, + 13 + ], + [ + 3, + 4 + ], + [ + 0, + 18 + ], + [ + 2, + 9 + ], + [ + 4, + 0 + ], + [ + 1, + 14 + ], + [ + 3, + 5 + ], + [ + 0, + 19 + ], + [ + 2, + 10 + ], + [ + 4, + 1 + ], + [ + 1, + 15 + ], + [ + 3, + 6 + ], + [ + 0, + 20 + ], + [ + 2, + 11 + ], + [ + 4, + 2 + ], + [ + 1, + 16 + ], + [ + 3, + 7 + ], + [ + 0, + 21 + ], + [ + 2, + 12 + ], + [ + 4, + 3 + ], + [ + 1, + 17 + ], + [ + 3, + 8 + ], + [ + 0, + 22 + ], + [ + 2, + 13 + ], + [ + 4, + 4 + ], + [ + 1, + 18 + ], + [ + 3, + 9 + ], + [ + 0, + 23 + ], + [ + 5, + 0 + ], + [ + 2, + 14 + ], + [ + 4, + 5 + ], + [ + 1, + 19 + ], + [ + 3, + 10 + ], + [ + 0, + 24 + ], + [ + 5, + 1 + ], + [ + 2, + 15 + ], + [ + 4, + 6 + ], + [ + 1, + 20 + ], + [ + 3, + 11 + ], + [ + 0, + 25 + ], + [ + 5, + 2 + ], + [ + 2, + 16 + ], + [ + 4, + 7 + ], + [ + 1, + 21 + ], + [ + 3, + 12 + ], + [ + 0, + 26 + ], + [ + 5, + 3 + ], + [ + 2, + 17 + ], + [ + 4, + 8 + ], + [ + 1, + 22 + ], + [ + 3, + 13 + ], + [ + 0, + 27 + ], + [ + 5, + 4 + ], + [ + 2, + 18 + ], + [ + 4, + 9 + ], + [ + 1, + 23 + ], + [ + 6, + 0 + ], + [ + 3, + 14 + ], + [ + 0, + 28 + ], + [ + 5, + 5 + ], + [ + 2, + 19 + ], + [ + 4, + 10 + ], + [ + 1, + 24 + ], + [ + 6, + 1 + ], + [ + 3, + 15 + ], + [ + 0, + 29 + ], + [ + 5, + 6 + ], + [ + 2, + 20 + ], + [ + 4, + 11 + ], + [ + 1, + 25 + ], + [ + 6, + 2 + ], + [ + 3, + 16 + ], + [ + 0, + 30 + ], + [ + 5, + 7 + ], + [ + 2, + 21 + ], + [ + 4, + 12 + ], + [ + 1, + 26 + ], + [ + 6, + 3 + ], + [ + 3, + 17 + ], + [ + 0, + 31 + ], + [ + 5, + 8 + ], + [ + 2, + 22 + ], + [ + 4, + 13 + ], + [ + 1, + 27 + ], + [ + 6, + 4 + ], + [ + 3, + 18 + ], + [ + 0, + 32 + ], + [ + 5, + 9 + ], + [ + 2, + 23 + ], + [ + 7, + 0 + ], + [ + 4, + 14 + ], + [ + 1, + 28 + ], + [ + 6, + 5 + ], + [ + 3, + 19 + ], + [ + 0, + 33 + ], + [ + 5, + 10 + ], + [ + 2, + 24 + ], + [ + 7, + 1 + ], + [ + 4, + 15 + ], + [ + 1, + 29 + ], + [ + 6, + 6 + ], + [ + 3, + 20 + ], + [ + 0, + 34 + ], + [ + 5, + 11 + ], + [ + 2, + 25 + ], + [ + 7, + 2 + ], + [ + 4, + 16 + ], + [ + 1, + 30 + ], + [ + 6, + 7 + ], + [ + 3, + 21 + ], + [ + 0, + 35 + ], + [ + 5, + 12 + ], + [ + 2, + 26 + ], + [ + 7, + 3 + ], + [ + 4, + 17 + ], + [ + 1, + 31 + ], + [ + 6, + 8 + ], + [ + 3, + 22 + ], + [ + 0, + 36 + ], + [ + 5, + 13 + ], + [ + 2, + 27 + ], + [ + 7, + 4 + ], + [ + 4, + 18 + ], + [ + 1, + 32 + ], + [ + 6, + 9 + ], + [ + 3, + 23 + ], + [ + 8, + 0 + ], + [ + 5, + 14 + ], + [ + 2, + 28 + ], + [ + 7, + 5 + ], + [ + 4, + 19 + ], + [ + 1, + 33 + ], + [ + 6, + 10 + ], + [ + 3, + 24 + ], + [ + 8, + 1 + ], + [ + 5, + 15 + ], + [ + 2, + 29 + ], + [ + 7, + 6 + ], + [ + 4, + 20 + ], + [ + 1, + 34 + ], + [ + 6, + 11 + ], + [ + 3, + 25 + ], + [ + 8, + 2 + ], + [ + 5, + 16 + ], + [ + 2, + 30 + ], + [ + 7, + 7 + ], + [ + 4, + 21 + ], + [ + 1, + 35 + ], + [ + 6, + 12 + ], + [ + 3, + 26 + ], + [ + 8, + 3 + ], + [ + 5, + 17 + ], + [ + 2, + 31 + ], + [ + 7, + 8 + ], + [ + 4, + 22 + ], + [ + 1, + 36 + ], + [ + 6, + 13 + ], + [ + 3, + 27 + ], + [ + 8, + 4 + ], + [ + 5, + 18 + ], + [ + 2, + 32 + ], + [ + 7, + 9 + ], + [ + 4, + 23 + ], + [ + 6, + 14 + ], + [ + 3, + 28 + ], + [ + 8, + 5 + ], + [ + 5, + 19 + ], + [ + 2, + 33 + ], + [ + 7, + 10 + ], + [ + 4, + 24 + ], + [ + 6, + 15 + ], + [ + 3, + 29 + ], + [ + 8, + 6 + ], + [ + 5, + 20 + ], + [ + 2, + 34 + ], + [ + 7, + 11 + ], + [ + 4, + 25 + ], + [ + 6, + 16 + ], + [ + 3, + 30 + ], + [ + 8, + 7 + ], + [ + 5, + 21 + ], + [ + 2, + 35 + ], + [ + 7, + 12 + ], + [ + 4, + 26 + ], + [ + 6, + 17 + ], + [ + 3, + 31 + ], + [ + 8, + 8 + ], + [ + 5, + 22 + ], + [ + 2, + 36 + ], + [ + 7, + 13 + ], + [ + 4, + 27 + ], + [ + 6, + 18 + ], + [ + 3, + 32 + ], + [ + 8, + 9 + ], + [ + 5, + 23 + ], + [ + 7, + 14 + ], + [ + 4, + 28 + ], + [ + 6, + 19 + ], + [ + 3, + 33 + ], + [ + 8, + 10 + ], + [ + 5, + 24 + ], + [ + 7, + 15 + ], + [ + 4, + 29 + ], + [ + 6, + 20 + ], + [ + 3, + 34 + ], + [ + 8, + 11 + ], + [ + 5, + 25 + ], + [ + 7, + 16 + ], + [ + 4, + 30 + ], + [ + 6, + 21 + ], + [ + 3, + 35 + ], + [ + 8, + 12 + ], + [ + 5, + 26 + ], + [ + 7, + 17 + ], + [ + 4, + 31 + ], + [ + 6, + 22 + ], + [ + 3, + 36 + ], + [ + 8, + 13 + ], + [ + 5, + 27 + ], + [ + 7, + 18 + ], + [ + 4, + 32 + ], + [ + 6, + 23 + ], + [ + 8, + 14 + ], + [ + 5, + 28 + ], + [ + 7, + 19 + ], + [ + 4, + 33 + ], + [ + 6, + 24 + ], + [ + 8, + 15 + ], + [ + 5, + 29 + ], + [ + 7, + 20 + ], + [ + 4, + 34 + ], + [ + 6, + 25 + ], + [ + 8, + 16 + ], + [ + 5, + 30 + ], + [ + 7, + 21 + ], + [ + 4, + 35 + ], + [ + 6, + 26 + ], + [ + 8, + 17 + ], + [ + 5, + 31 + ], + [ + 7, + 22 + ], + [ + 4, + 36 + ], + [ + 6, + 27 + ], + [ + 8, + 18 + ], + [ + 5, + 32 + ], + [ + 7, + 23 + ], + [ + 6, + 28 + ], + [ + 8, + 19 + ], + [ + 5, + 33 + ], + [ + 7, + 24 + ], + [ + 6, + 29 + ], + [ + 8, + 20 + ], + [ + 5, + 34 + ], + [ + 7, + 25 + ], + [ + 6, + 30 + ], + [ + 8, + 21 + ], + [ + 5, + 35 + ], + [ + 7, + 26 + ], + [ + 6, + 31 + ], + [ + 8, + 22 + ], + [ + 5, + 36 + ], + [ + 7, + 27 + ], + [ + 6, + 32 + ], + [ + 8, + 23 + ], + [ + 7, + 28 + ], + [ + 6, + 33 + ], + [ + 8, + 24 + ], + [ + 7, + 29 + ], + [ + 6, + 34 + ], + [ + 8, + 25 + ], + [ + 7, + 30 + ], + [ + 6, + 35 + ], + [ + 8, + 26 + ], + [ + 7, + 31 + ], + [ + 6, + 36 + ], + [ + 8, + 27 + ], + [ + 7, + 32 + ], + [ + 8, + 28 + ], + [ + 7, + 33 + ], + [ + 8, + 29 + ], + [ + 7, + 34 + ], + [ + 8, + 30 + ], + [ + 7, + 35 + ], + [ + 8, + 31 + ], + [ + 7, + 36 + ], + [ + 8, + 32 + ], + [ + 8, + 33 + ], + [ + 8, + 34 + ], + [ + 8, + 35 + ], + [ + 8, + 36 + ], + [ + 0, + 37 + ], + [ + 0, + 45 + ], + [ + 0, + 38 + ], + [ + 0, + 46 + ], + [ + 1, + 37 + ], + [ + 1, + 45 + ], + [ + 0, + 39 + ], + [ + 0, + 47 + ], + [ + 1, + 38 + ], + [ + 1, + 46 + ], + [ + 2, + 37 + ], + [ + 2, + 45 + ], + [ + 0, + 40 + ], + [ + 0, + 48 + ], + [ + 1, + 39 + ], + [ + 1, + 47 + ], + [ + 2, + 38 + ], + [ + 2, + 46 + ], + [ + 3, + 37 + ], + [ + 3, + 45 + ], + [ + 0, + 41 + ], + [ + 0, + 49 + ], + [ + 1, + 40 + ], + [ + 1, + 48 + ], + [ + 2, + 39 + ], + [ + 2, + 47 + ], + [ + 3, + 38 + ], + [ + 3, + 46 + ], + [ + 4, + 37 + ], + [ + 4, + 45 + ], + [ + 0, + 42 + ], + [ + 0, + 50 + ], + [ + 1, + 41 + ], + [ + 1, + 49 + ], + [ + 2, + 40 + ], + [ + 2, + 48 + ], + [ + 3, + 39 + ], + [ + 3, + 47 + ], + [ + 4, + 38 + ], + [ + 4, + 46 + ], + [ + 5, + 37 + ], + [ + 5, + 45 + ], + [ + 0, + 43 + ], + [ + 0, + 51 + ], + [ + 1, + 42 + ], + [ + 1, + 50 + ], + [ + 2, + 41 + ], + [ + 2, + 49 + ], + [ + 3, + 40 + ], + [ + 3, + 48 + ], + [ + 4, + 39 + ], + [ + 4, + 47 + ], + [ + 5, + 38 + ], + [ + 5, + 46 + ], + [ + 0, + 44 + ], + [ + 0, + 52 + ], + [ + 6, + 37 + ], + [ + 6, + 45 + ], + [ + 1, + 43 + ], + [ + 1, + 51 + ], + [ + 2, + 42 + ], + [ + 2, + 50 + ], + [ + 3, + 41 + ], + [ + 3, + 49 + ], + [ + 4, + 40 + ], + [ + 4, + 48 + ], + [ + 5, + 39 + ], + [ + 5, + 47 + ], + [ + 6, + 38 + ], + [ + 6, + 46 + ], + [ + 1, + 44 + ], + [ + 1, + 52 + ], + [ + 7, + 37 + ], + [ + 7, + 45 + ], + [ + 2, + 43 + ], + [ + 2, + 51 + ], + [ + 3, + 42 + ], + [ + 3, + 50 + ], + [ + 4, + 41 + ], + [ + 4, + 49 + ], + [ + 5, + 40 + ], + [ + 5, + 48 + ], + [ + 6, + 39 + ], + [ + 6, + 47 + ], + [ + 7, + 38 + ], + [ + 7, + 46 + ], + [ + 2, + 44 + ], + [ + 2, + 52 + ], + [ + 8, + 37 + ], + [ + 8, + 45 + ], + [ + 3, + 43 + ], + [ + 3, + 51 + ], + [ + 4, + 42 + ], + [ + 4, + 50 + ], + [ + 5, + 41 + ], + [ + 5, + 49 + ], + [ + 6, + 40 + ], + [ + 6, + 48 + ], + [ + 7, + 39 + ], + [ + 7, + 47 + ], + [ + 8, + 38 + ], + [ + 8, + 46 + ], + [ + 3, + 44 + ], + [ + 3, + 52 + ], + [ + 4, + 43 + ], + [ + 4, + 51 + ], + [ + 5, + 42 + ], + [ + 5, + 50 + ], + [ + 6, + 41 + ], + [ + 6, + 49 + ], + [ + 7, + 40 + ], + [ + 7, + 48 + ], + [ + 8, + 39 + ], + [ + 8, + 47 + ], + [ + 4, + 44 + ], + [ + 4, + 52 + ], + [ + 5, + 43 + ], + [ + 5, + 51 + ], + [ + 6, + 42 + ], + [ + 6, + 50 + ], + [ + 7, + 41 + ], + [ + 7, + 49 + ], + [ + 8, + 40 + ], + [ + 8, + 48 + ], + [ + 5, + 44 + ], + [ + 5, + 52 + ], + [ + 6, + 43 + ], + [ + 6, + 51 + ], + [ + 7, + 42 + ], + [ + 7, + 50 + ], + [ + 8, + 41 + ], + [ + 8, + 49 + ], + [ + 6, + 44 + ], + [ + 6, + 52 + ], + [ + 7, + 43 + ], + [ + 7, + 51 + ], + [ + 8, + 42 + ], + [ + 8, + 50 + ], + [ + 7, + 44 + ], + [ + 7, + 52 + ], + [ + 8, + 43 + ], + [ + 8, + 51 + ], + [ + 8, + 44 + ], + [ + 8, + 52 + ] + ], + "groups": [ + [ + 8, + 5, + 15, + 224 + ], + [ + 8, + 7, + 18, + 224 + ], + [ + 8, + 9, + 21, + 224 + ], + [ + 8, + 11, + 24, + 224 + ], + [ + 8, + 13, + 27, + 224 + ], + [ + 8, + 16, + 31, + 224 + ], + [ + 8, + 19, + 35, + 224 + ], + [ + 8, + 22, + 39, + 224 + ], + [ + 8, + 25, + 43, + 224 + ], + [ + 8, + 28, + 47, + 224 + ], + [ + 8, + 29, + 48, + 224 + ], + [ + 8, + 32, + 52, + 224 + ], + [ + 8, + 33, + 53, + 224 + ], + [ + 8, + 36, + 57, + 224 + ], + [ + 8, + 37, + 58, + 224 + ], + [ + 8, + 40, + 62, + 224 + ], + [ + 8, + 41, + 63, + 224 + ], + [ + 8, + 44, + 67, + 224 + ], + [ + 8, + 45, + 68, + 224 + ], + [ + 8, + 49, + 73, + 224 + ], + [ + 8, + 50, + 74, + 224 + ], + [ + 8, + 54, + 79, + 224 + ], + [ + 8, + 55, + 80, + 224 + ], + [ + 8, + 59, + 85, + 224 + ], + [ + 8, + 60, + 86, + 224 + ], + [ + 8, + 64, + 91, + 224 + ], + [ + 8, + 65, + 92, + 224 + ], + [ + 8, + 69, + 97, + 224 + ], + [ + 8, + 70, + 98, + 224 + ], + [ + 8, + 72, + 100, + 224 + ], + [ + 8, + 75, + 104, + 224 + ], + [ + 8, + 76, + 105, + 224 + ], + [ + 8, + 78, + 107, + 224 + ], + [ + 8, + 81, + 111, + 224 + ], + [ + 8, + 82, + 112, + 224 + ], + [ + 8, + 84, + 114, + 224 + ], + [ + 8, + 87, + 118, + 224 + ], + [ + 8, + 88, + 119, + 224 + ], + [ + 8, + 90, + 121, + 224 + ], + [ + 8, + 93, + 125, + 224 + ], + [ + 8, + 94, + 126, + 224 + ], + [ + 8, + 96, + 128, + 224 + ], + [ + 8, + 99, + 132, + 224 + ], + [ + 8, + 101, + 134, + 224 + ], + [ + 8, + 103, + 136, + 224 + ], + [ + 8, + 106, + 140, + 224 + ], + [ + 8, + 108, + 142, + 224 + ], + [ + 8, + 110, + 144, + 224 + ], + [ + 8, + 113, + 148, + 224 + ], + [ + 8, + 115, + 150, + 224 + ], + [ + 8, + 117, + 152, + 224 + ], + [ + 8, + 120, + 156, + 224 + ], + [ + 8, + 122, + 158, + 224 + ], + [ + 8, + 124, + 160, + 224 + ], + [ + 8, + 127, + 164, + 224 + ], + [ + 8, + 129, + 166, + 224 + ], + [ + 8, + 131, + 168, + 224 + ], + [ + 8, + 135, + 172, + 224 + ], + [ + 8, + 137, + 174, + 224 + ], + [ + 8, + 139, + 176, + 224 + ], + [ + 8, + 143, + 180, + 224 + ], + [ + 8, + 145, + 182, + 224 + ], + [ + 8, + 147, + 184, + 224 + ], + [ + 8, + 151, + 188, + 224 + ], + [ + 8, + 153, + 190, + 224 + ], + [ + 8, + 155, + 192, + 224 + ], + [ + 8, + 159, + 196, + 224 + ], + [ + 8, + 161, + 198, + 224 + ], + [ + 8, + 163, + 200, + 224 + ], + [ + 8, + 167, + 204, + 224 + ], + [ + 8, + 169, + 206, + 224 + ], + [ + 8, + 171, + 207, + 224 + ], + [ + 8, + 175, + 211, + 224 + ], + [ + 8, + 177, + 213, + 224 + ], + [ + 8, + 179, + 214, + 224 + ], + [ + 8, + 183, + 218, + 224 + ], + [ + 8, + 185, + 220, + 224 + ], + [ + 8, + 187, + 221, + 224 + ], + [ + 8, + 191, + 225, + 224 + ], + [ + 8, + 193, + 227, + 224 + ], + [ + 8, + 195, + 228, + 224 + ], + [ + 8, + 199, + 232, + 224 + ], + [ + 8, + 201, + 234, + 224 + ], + [ + 8, + 203, + 235, + 224 + ], + [ + 8, + 208, + 240, + 224 + ], + [ + 8, + 210, + 241, + 224 + ], + [ + 8, + 215, + 246, + 224 + ], + [ + 8, + 217, + 247, + 224 + ], + [ + 8, + 222, + 252, + 224 + ], + [ + 8, + 224, + 253, + 224 + ], + [ + 8, + 229, + 258, + 224 + ], + [ + 8, + 231, + 259, + 224 + ], + [ + 8, + 236, + 264, + 224 + ], + [ + 8, + 238, + 265, + 224 + ], + [ + 8, + 242, + 269, + 224 + ], + [ + 8, + 244, + 270, + 224 + ], + [ + 8, + 248, + 274, + 224 + ], + [ + 8, + 250, + 275, + 224 + ], + [ + 8, + 254, + 279, + 224 + ], + [ + 8, + 256, + 280, + 224 + ], + [ + 8, + 260, + 284, + 224 + ], + [ + 8, + 262, + 285, + 224 + ], + [ + 8, + 267, + 289, + 224 + ], + [ + 8, + 272, + 293, + 224 + ], + [ + 8, + 277, + 297, + 224 + ], + [ + 8, + 282, + 301, + 224 + ], + [ + 8, + 287, + 305, + 224 + ], + [ + 8, + 291, + 308, + 224 + ], + [ + 8, + 295, + 311, + 224 + ], + [ + 8, + 299, + 314, + 224 + ], + [ + 8, + 303, + 317, + 224 + ], + [ + 8, + 337, + 343, + 224 + ], + [ + 8, + 338, + 344, + 224 + ], + [ + 8, + 341, + 349, + 224 + ], + [ + 8, + 342, + 350, + 224 + ], + [ + 8, + 347, + 357, + 224 + ], + [ + 8, + 348, + 358, + 224 + ], + [ + 8, + 351, + 361, + 224 + ], + [ + 8, + 352, + 362, + 224 + ], + [ + 8, + 355, + 367, + 224 + ], + [ + 8, + 356, + 368, + 224 + ], + [ + 8, + 359, + 371, + 224 + ], + [ + 8, + 360, + 372, + 224 + ], + [ + 8, + 365, + 379, + 224 + ], + [ + 8, + 366, + 380, + 224 + ], + [ + 8, + 369, + 383, + 224 + ], + [ + 8, + 370, + 384, + 224 + ], + [ + 8, + 373, + 389, + 224 + ], + [ + 8, + 374, + 390, + 224 + ], + [ + 8, + 377, + 393, + 224 + ], + [ + 8, + 378, + 394, + 224 + ], + [ + 8, + 381, + 397, + 224 + ], + [ + 8, + 382, + 398, + 224 + ], + [ + 8, + 385, + 401, + 224 + ], + [ + 8, + 386, + 402, + 224 + ], + [ + 8, + 391, + 407, + 224 + ], + [ + 8, + 392, + 408, + 224 + ], + [ + 8, + 395, + 411, + 224 + ], + [ + 8, + 396, + 412, + 224 + ], + [ + 8, + 399, + 415, + 224 + ], + [ + 8, + 400, + 416, + 224 + ], + [ + 8, + 403, + 419, + 224 + ], + [ + 8, + 404, + 420, + 224 + ], + [ + 8, + 409, + 425, + 224 + ], + [ + 8, + 410, + 426, + 224 + ], + [ + 8, + 413, + 429, + 224 + ], + [ + 8, + 414, + 430, + 224 + ], + [ + 8, + 423, + 437, + 224 + ], + [ + 8, + 424, + 438, + 224 + ], + [ + 8, + 427, + 441, + 224 + ], + [ + 8, + 428, + 442, + 224 + ], + [ + 8, + 435, + 447, + 224 + ], + [ + 8, + 436, + 448, + 224 + ], + [ + 8, + 439, + 451, + 224 + ], + [ + 8, + 440, + 452, + 224 + ], + [ + 8, + 449, + 459, + 224 + ], + [ + 8, + 450, + 460, + 224 + ], + [ + 8, + 457, + 465, + 224 + ], + [ + 8, + 458, + 466, + 224 + ], + [ + 16, + -1, + 5, + 224 + ], + [ + 16, + -1, + 7, + 224 + ], + [ + 16, + -1, + 9, + 224 + ], + [ + 16, + -1, + 11, + 224 + ], + [ + 16, + -1, + 13, + 224 + ], + [ + 16, + -1, + 16, + 224 + ], + [ + 16, + -1, + 19, + 224 + ], + [ + 16, + -1, + 22, + 224 + ], + [ + 16, + -1, + 25, + 224 + ], + [ + 16, + -1, + 28, + 224 + ], + [ + 16, + -1, + 32, + 224 + ], + [ + 16, + -1, + 36, + 224 + ], + [ + 16, + -1, + 40, + 224 + ], + [ + 16, + -1, + 44, + 224 + ], + [ + 16, + -1, + 49, + 224 + ], + [ + 16, + -1, + 54, + 224 + ], + [ + 16, + -1, + 59, + 224 + ], + [ + 16, + -1, + 64, + 224 + ], + [ + 16, + -1, + 69, + 224 + ], + [ + 16, + -1, + 75, + 224 + ], + [ + 16, + -1, + 81, + 224 + ], + [ + 16, + -1, + 87, + 224 + ], + [ + 16, + -1, + 93, + 224 + ], + [ + 16, + -1, + 99, + 224 + ], + [ + 16, + -1, + 106, + 224 + ], + [ + 16, + -1, + 113, + 224 + ], + [ + 16, + -1, + 120, + 224 + ], + [ + 16, + -1, + 127, + 224 + ], + [ + 16, + -1, + 135, + 224 + ], + [ + 16, + -1, + 143, + 224 + ], + [ + 16, + -1, + 151, + 224 + ], + [ + 16, + -1, + 159, + 224 + ], + [ + 16, + -1, + 167, + 224 + ], + [ + 16, + -1, + 175, + 224 + ], + [ + 16, + -1, + 183, + 224 + ], + [ + 16, + -1, + 191, + 224 + ], + [ + 16, + -1, + 199, + 224 + ], + [ + 16, + -1, + 337, + 224 + ], + [ + 16, + -1, + 338, + 224 + ], + [ + 16, + -1, + 341, + 224 + ], + [ + 16, + -1, + 342, + 224 + ], + [ + 16, + -1, + 347, + 224 + ], + [ + 16, + -1, + 348, + 224 + ], + [ + 16, + -1, + 355, + 224 + ], + [ + 16, + -1, + 356, + 224 + ], + [ + 16, + -1, + 365, + 224 + ], + [ + 16, + -1, + 366, + 224 + ], + [ + 16, + -1, + 377, + 224 + ], + [ + 16, + -1, + 378, + 224 + ], + [ + 16, + -1, + 391, + 224 + ], + [ + 16, + -1, + 392, + 224 + ], + [ + 16, + -1, + 403, + 224 + ], + [ + 16, + -1, + 404, + 224 + ], + [ + 16, + 100, + 170, + 224 + ], + [ + 16, + 107, + 178, + 224 + ], + [ + 16, + 114, + 186, + 224 + ], + [ + 16, + 121, + 194, + 224 + ], + [ + 16, + 128, + 202, + 224 + ], + [ + 16, + 136, + 209, + 224 + ], + [ + 16, + 144, + 216, + 224 + ], + [ + 16, + 152, + 223, + 224 + ], + [ + 16, + 160, + 230, + 224 + ], + [ + 16, + 168, + 237, + 224 + ], + [ + 16, + 176, + 243, + 224 + ], + [ + 16, + 184, + 249, + 224 + ], + [ + 16, + 192, + 255, + 224 + ], + [ + 16, + 200, + 261, + 224 + ], + [ + 16, + 207, + 266, + 224 + ], + [ + 16, + 214, + 271, + 224 + ], + [ + 16, + 221, + 276, + 224 + ], + [ + 16, + 228, + 281, + 224 + ], + [ + 16, + 235, + 286, + 224 + ], + [ + 16, + 241, + 290, + 224 + ], + [ + 16, + 247, + 294, + 224 + ], + [ + 16, + 253, + 298, + 224 + ], + [ + 16, + 259, + 302, + 224 + ], + [ + 16, + 265, + 306, + 224 + ], + [ + 16, + 270, + 309, + 224 + ], + [ + 16, + 275, + 312, + 224 + ], + [ + 16, + 280, + 315, + 224 + ], + [ + 16, + 285, + 318, + 224 + ], + [ + 16, + 289, + 320, + 224 + ], + [ + 16, + 293, + 322, + 224 + ], + [ + 16, + 297, + 324, + 224 + ], + [ + 16, + 301, + 326, + 224 + ], + [ + 16, + 305, + 328, + 224 + ], + [ + 16, + 308, + 329, + 224 + ], + [ + 16, + 311, + 330, + 224 + ], + [ + 16, + 314, + 331, + 224 + ], + [ + 16, + 317, + 332, + 224 + ], + [ + 16, + 389, + 421, + 224 + ], + [ + 16, + 390, + 422, + 224 + ], + [ + 16, + 401, + 433, + 224 + ], + [ + 16, + 402, + 434, + 224 + ], + [ + 16, + 415, + 445, + 224 + ], + [ + 16, + 416, + 446, + 224 + ], + [ + 16, + 429, + 455, + 224 + ], + [ + 16, + 430, + 456, + 224 + ], + [ + 16, + 441, + 463, + 224 + ], + [ + 16, + 442, + 464, + 224 + ], + [ + 16, + 451, + 469, + 224 + ], + [ + 16, + 452, + 470, + 224 + ], + [ + 16, + 459, + 473, + 224 + ], + [ + 16, + 460, + 474, + 224 + ], + [ + 16, + 465, + 475, + 224 + ], + [ + 16, + 466, + 476, + 224 + ], + [ + 32, + -1, + 29, + 224 + ], + [ + 32, + -1, + 33, + 224 + ], + [ + 32, + -1, + 37, + 224 + ], + [ + 32, + -1, + 41, + 224 + ], + [ + 32, + -1, + 45, + 224 + ], + [ + 32, + -1, + 50, + 224 + ], + [ + 32, + -1, + 55, + 224 + ], + [ + 32, + -1, + 60, + 224 + ], + [ + 32, + -1, + 65, + 224 + ], + [ + 32, + -1, + 70, + 224 + ], + [ + 32, + -1, + 76, + 224 + ], + [ + 32, + -1, + 82, + 224 + ], + [ + 32, + -1, + 88, + 224 + ], + [ + 32, + -1, + 94, + 224 + ], + [ + 32, + -1, + 101, + 224 + ], + [ + 32, + -1, + 108, + 224 + ], + [ + 32, + -1, + 115, + 224 + ], + [ + 32, + -1, + 122, + 224 + ], + [ + 32, + -1, + 129, + 224 + ], + [ + 32, + -1, + 137, + 224 + ], + [ + 32, + -1, + 145, + 224 + ], + [ + 32, + -1, + 153, + 224 + ], + [ + 32, + -1, + 161, + 224 + ], + [ + 32, + -1, + 169, + 224 + ], + [ + 32, + -1, + 177, + 224 + ], + [ + 32, + -1, + 185, + 224 + ], + [ + 32, + -1, + 193, + 224 + ], + [ + 32, + -1, + 201, + 224 + ], + [ + 32, + -1, + 208, + 224 + ], + [ + 32, + -1, + 215, + 224 + ], + [ + 32, + -1, + 222, + 224 + ], + [ + 32, + -1, + 229, + 224 + ], + [ + 32, + -1, + 236, + 224 + ], + [ + 32, + -1, + 242, + 224 + ], + [ + 32, + -1, + 248, + 224 + ], + [ + 32, + -1, + 254, + 224 + ], + [ + 32, + -1, + 260, + 224 + ], + [ + 32, + -1, + 351, + 224 + ], + [ + 32, + -1, + 352, + 224 + ], + [ + 32, + -1, + 359, + 224 + ], + [ + 32, + -1, + 360, + 224 + ], + [ + 32, + -1, + 369, + 224 + ], + [ + 32, + -1, + 370, + 224 + ], + [ + 32, + -1, + 381, + 224 + ], + [ + 32, + -1, + 382, + 224 + ], + [ + 32, + -1, + 395, + 224 + ], + [ + 32, + -1, + 396, + 224 + ], + [ + 32, + -1, + 409, + 224 + ], + [ + 32, + -1, + 410, + 224 + ], + [ + 32, + -1, + 423, + 224 + ], + [ + 32, + -1, + 424, + 224 + ], + [ + 32, + -1, + 435, + 224 + ], + [ + 32, + -1, + 436, + 224 + ], + [ + 32, + 48, + 170, + 224 + ], + [ + 32, + 53, + 178, + 224 + ], + [ + 32, + 58, + 186, + 224 + ], + [ + 32, + 63, + 194, + 224 + ], + [ + 32, + 68, + 202, + 224 + ], + [ + 32, + 74, + 209, + 224 + ], + [ + 32, + 80, + 216, + 224 + ], + [ + 32, + 86, + 223, + 224 + ], + [ + 32, + 92, + 230, + 224 + ], + [ + 32, + 98, + 237, + 224 + ], + [ + 32, + 105, + 243, + 224 + ], + [ + 32, + 112, + 249, + 224 + ], + [ + 32, + 119, + 255, + 224 + ], + [ + 32, + 126, + 261, + 224 + ], + [ + 32, + 134, + 266, + 224 + ], + [ + 32, + 142, + 271, + 224 + ], + [ + 32, + 150, + 276, + 224 + ], + [ + 32, + 158, + 281, + 224 + ], + [ + 32, + 166, + 286, + 224 + ], + [ + 32, + 174, + 290, + 224 + ], + [ + 32, + 182, + 294, + 224 + ], + [ + 32, + 190, + 298, + 224 + ], + [ + 32, + 198, + 302, + 224 + ], + [ + 32, + 206, + 306, + 224 + ], + [ + 32, + 213, + 309, + 224 + ], + [ + 32, + 220, + 312, + 224 + ], + [ + 32, + 227, + 315, + 224 + ], + [ + 32, + 234, + 318, + 224 + ], + [ + 32, + 240, + 320, + 224 + ], + [ + 32, + 246, + 322, + 224 + ], + [ + 32, + 252, + 324, + 224 + ], + [ + 32, + 258, + 326, + 224 + ], + [ + 32, + 264, + 328, + 224 + ], + [ + 32, + 269, + 329, + 224 + ], + [ + 32, + 274, + 330, + 224 + ], + [ + 32, + 279, + 331, + 224 + ], + [ + 32, + 284, + 332, + 224 + ], + [ + 32, + 361, + 421, + 224 + ], + [ + 32, + 362, + 422, + 224 + ], + [ + 32, + 371, + 433, + 224 + ], + [ + 32, + 372, + 434, + 224 + ], + [ + 32, + 383, + 445, + 224 + ], + [ + 32, + 384, + 446, + 224 + ], + [ + 32, + 397, + 455, + 224 + ], + [ + 32, + 398, + 456, + 224 + ], + [ + 32, + 411, + 463, + 224 + ], + [ + 32, + 412, + 464, + 224 + ], + [ + 32, + 425, + 469, + 224 + ], + [ + 32, + 426, + 470, + 224 + ], + [ + 32, + 437, + 473, + 224 + ], + [ + 32, + 438, + 474, + 224 + ], + [ + 32, + 447, + 475, + 224 + ], + [ + 32, + 448, + 476, + 224 + ], + [ + 48, + -1, + 72, + 224 + ], + [ + 48, + -1, + 78, + 224 + ], + [ + 48, + -1, + 84, + 224 + ], + [ + 48, + -1, + 90, + 224 + ], + [ + 48, + -1, + 96, + 224 + ], + [ + 48, + -1, + 103, + 224 + ], + [ + 48, + -1, + 110, + 224 + ], + [ + 48, + -1, + 117, + 224 + ], + [ + 48, + -1, + 124, + 224 + ], + [ + 48, + -1, + 131, + 224 + ], + [ + 48, + -1, + 139, + 224 + ], + [ + 48, + -1, + 147, + 224 + ], + [ + 48, + -1, + 155, + 224 + ], + [ + 48, + -1, + 163, + 224 + ], + [ + 48, + -1, + 171, + 224 + ], + [ + 48, + -1, + 179, + 224 + ], + [ + 48, + -1, + 187, + 224 + ], + [ + 48, + -1, + 195, + 224 + ], + [ + 48, + -1, + 203, + 224 + ], + [ + 48, + -1, + 210, + 224 + ], + [ + 48, + -1, + 217, + 224 + ], + [ + 48, + -1, + 224, + 224 + ], + [ + 48, + -1, + 231, + 224 + ], + [ + 48, + -1, + 238, + 224 + ], + [ + 48, + -1, + 244, + 224 + ], + [ + 48, + -1, + 250, + 224 + ], + [ + 48, + -1, + 256, + 224 + ], + [ + 48, + -1, + 262, + 224 + ], + [ + 48, + -1, + 267, + 224 + ], + [ + 48, + -1, + 272, + 224 + ], + [ + 48, + -1, + 277, + 224 + ], + [ + 48, + -1, + 282, + 224 + ], + [ + 48, + -1, + 287, + 224 + ], + [ + 48, + -1, + 291, + 224 + ], + [ + 48, + -1, + 295, + 224 + ], + [ + 48, + -1, + 299, + 224 + ], + [ + 48, + -1, + 303, + 224 + ], + [ + 48, + -1, + 373, + 224 + ], + [ + 48, + -1, + 374, + 224 + ], + [ + 48, + -1, + 385, + 224 + ], + [ + 48, + -1, + 386, + 224 + ], + [ + 48, + -1, + 399, + 224 + ], + [ + 48, + -1, + 400, + 224 + ], + [ + 48, + -1, + 413, + 224 + ], + [ + 48, + -1, + 414, + 224 + ], + [ + 48, + -1, + 427, + 224 + ], + [ + 48, + -1, + 428, + 224 + ], + [ + 48, + -1, + 439, + 224 + ], + [ + 48, + -1, + 440, + 224 + ], + [ + 48, + -1, + 449, + 224 + ], + [ + 48, + -1, + 450, + 224 + ], + [ + 48, + -1, + 457, + 224 + ], + [ + 48, + -1, + 458, + 224 + ], + [ + 48, + 15, + 170, + 224 + ], + [ + 48, + 18, + 178, + 224 + ], + [ + 48, + 21, + 186, + 224 + ], + [ + 48, + 24, + 194, + 224 + ], + [ + 48, + 27, + 202, + 224 + ], + [ + 48, + 31, + 209, + 224 + ], + [ + 48, + 35, + 216, + 224 + ], + [ + 48, + 39, + 223, + 224 + ], + [ + 48, + 43, + 230, + 224 + ], + [ + 48, + 47, + 237, + 224 + ], + [ + 48, + 52, + 243, + 224 + ], + [ + 48, + 57, + 249, + 224 + ], + [ + 48, + 62, + 255, + 224 + ], + [ + 48, + 67, + 261, + 224 + ], + [ + 48, + 73, + 266, + 224 + ], + [ + 48, + 79, + 271, + 224 + ], + [ + 48, + 85, + 276, + 224 + ], + [ + 48, + 91, + 281, + 224 + ], + [ + 48, + 97, + 286, + 224 + ], + [ + 48, + 104, + 290, + 224 + ], + [ + 48, + 111, + 294, + 224 + ], + [ + 48, + 118, + 298, + 224 + ], + [ + 48, + 125, + 302, + 224 + ], + [ + 48, + 132, + 306, + 224 + ], + [ + 48, + 140, + 309, + 224 + ], + [ + 48, + 148, + 312, + 224 + ], + [ + 48, + 156, + 315, + 224 + ], + [ + 48, + 164, + 318, + 224 + ], + [ + 48, + 172, + 320, + 224 + ], + [ + 48, + 180, + 322, + 224 + ], + [ + 48, + 188, + 324, + 224 + ], + [ + 48, + 196, + 326, + 224 + ], + [ + 48, + 204, + 328, + 224 + ], + [ + 48, + 211, + 329, + 224 + ], + [ + 48, + 218, + 330, + 224 + ], + [ + 48, + 225, + 331, + 224 + ], + [ + 48, + 232, + 332, + 224 + ], + [ + 48, + 343, + 421, + 224 + ], + [ + 48, + 344, + 422, + 224 + ], + [ + 48, + 349, + 433, + 224 + ], + [ + 48, + 350, + 434, + 224 + ], + [ + 48, + 357, + 445, + 224 + ], + [ + 48, + 358, + 446, + 224 + ], + [ + 48, + 367, + 455, + 224 + ], + [ + 48, + 368, + 456, + 224 + ], + [ + 48, + 379, + 463, + 224 + ], + [ + 48, + 380, + 464, + 224 + ], + [ + 48, + 393, + 469, + 224 + ], + [ + 48, + 394, + 470, + 224 + ], + [ + 48, + 407, + 473, + 224 + ], + [ + 48, + 408, + 474, + 224 + ], + [ + 48, + 419, + 475, + 224 + ], + [ + 48, + 420, + 476, + 224 + ] + ], + "widths": [ + 4, + 5, + 6, + 7, + 8, + 9 + ], + "inventory": { + "4": 26, + "5": 2, + "6": 18, + "7": 52, + "8": 97, + "9": 213 + }, + "local_profile": { + "1": 2439, + "2": 726, + "3": 224, + "4": 102, + "5": 20, + "8": 8 + }, + "physical_bins": 106848, + "capacity_rank_mass": 2564352, + "constraints": "x patterncounts pergroup sum=S*bins; z withinlo= D_g-(R-1)n_g` follows from the same inequality. A bin of degree R +delivers one unit, all other bins deliver at most one, and each width delivers +exactly I_w. Integral capacities and lower bounds give an integral feasible +flow after the standard circulation reduction. The implemented augmenting-path +algorithm produces this integral flow directly. Removing its selected roles +preserves all three invariants with R replaced by R-1. Repeating constructs S +actual calls, each with every required width count, at most one role from a bin, +and at most n_g roles from each group. + +This argument is an all-parameter written realization lemma under its stated +integer-flow and pattern-size hypotheses. Feasibility of this particular +aggregate witness is finite computation, not an all-parameter packing theorem. + +## Physical owners and endpoint availability + +For a group, the physical stock is exactly S copies of its n_g source bins. +A bin containing any role at macro-time hi requires an owner-copy index at +least the largest call-copy index among those endpoint roles. Other bins have +no lower requirement on their owner-copy index. + +For each j, the number of bins requiring owner index greater than j is at most +the number of endpoint roles assigned to actual call-copy indices greater than +j. The preceding decomposition bounds that number by `(S-1-j)n_g`, exactly the +number of physical bins in those owner copies. These nested Hall inequalities +justify sorting bins by decreasing requirement and assigning the physical +owner copies in decreasing order, with n_g bins per owner copy. The construction +checks every resulting requirement separately. Original owner, child and port +labels are retained when allocating each copy's n_g bins. + +The literal chronology is +`(stage,r) at macro-time t -> (stage,r+37*j) at time S*t+j`. +Provider dispatch is copied along that embedding. If a source window has +noninitial lower endpoint lo, every admitted macro-time satisfies t>=lo+1; +therefore `S*t+j > S*lo+k` for every owner-copy k. For an upper endpoint, +t 33` gates skipping `{22, 40, 54, 63}`, and `R2_E7` at `restore[190:203]`, `13 -> 15` gates skipping `{5, 73}`) on PR #2979's words that serve as the direct starting words for `B_586_438` and `B_588_440`. +- **New here (dcharb78, with AI assistance)**: the two coupled `B` + `restore` dying-helper carrier folds (`B_586_438` and `B_588_440`, `6` hunks / `6 -> 5` gates each) and `helper_final` lowerings on entering helpers `586` ($E_{30} \to V_{30,76,82}$) and `588` ($E_{30} \to V_{30,97,127}$) shifting the helper width inventory from `{4:26, 5:2, 6:16, 7:52, 8:99, 9:213}` to `{4:26, 5:2, 6:18, 7:50, 8:99, 9:213}` (`+665` net profit per helper, `+1,330` joint), the literal `T74_optimal_idle39` allocation (`allocation/FILL.json.gz`), the 21-control per-word edit review (`edits/edits_review.py`) and 100-control four-stage replay (`verify.py`), and the re-derived paid profile, cap certificate (`certificates/RELAX-CAP.json`), and complete fresh-native admission and release receipts. PR #2979 (mdumitrean), PR #3015 (jeremykothe2), and PR #3042 (dcharb78) are credited first. diff --git a/research/staged-release-retiming-t530/owner-audit/upstream/UPSTREAM-SOURCE-NOTICE b/research/staged-release-retiming-t530/owner-audit/upstream/UPSTREAM-SOURCE-NOTICE new file mode 100644 index 0000000000..89c20926ea --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/upstream/UPSTREAM-SOURCE-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/staged-release-retiming-t530/owner-audit/upstream/independent_literal.py b/research/staged-release-retiming-t530/owner-audit/upstream/independent_literal.py new file mode 100644 index 0000000000..32755776c1 --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/upstream/independent_literal.py @@ -0,0 +1,128 @@ +# SPDX-License-Identifier: Apache-2.0 +# Adapted from PR3605; retained attribution in UPSTREAM-SOURCE-CREDITS.md. +import sys +if not __debug__ or sys.flags.optimize: + raise RuntimeError("Enabled assertions required before owner replay") +"""Path-adapted copy of the parent independent owner audit. +Original SHA256 1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e. +Filesystem/source authentication and output paths adapted; mathematical predicates retained. +""" +"""Independent vectorized audit of the literal staged-pair owner journal. + +No optimizer, producer, inherited owner checker or reconstructor is imported. +Uses the source execution template and the actual checked native frame tables. +""" +from pathlib import Path +from collections import Counter +import gzip,hashlib,json,os,sys +import numpy as np +R=Path(__file__).resolve().parent +if not __debug__:raise SystemExit('unoptimized Python required') +for _key in ('OWNER_SOURCE_REPO','OWNER_LITERAL_DIR','OWNER_NATIVE_DIR','OWNER_AUDIT_OUTPUT'): + if not os.environ.get(_key):raise SystemExit('missing '+_key) +A=Path(os.environ['OWNER_LITERAL_DIR']).resolve() +NATIVE=Path(os.environ['OWNER_NATIVE_DIR']).resolve() +S=Path(os.environ['OWNER_SOURCE_REPO']).resolve()/'research/rank7-joint-endframes/allocation/vendor' +def need(v,m): + if not v:raise ValueError(m) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def rank(v): + piv={} + for q in v: + while q: + h=q.bit_length() + if h in piv:q^=piv[h] + else:piv[h]=q;break + return len(piv) +for rel,digest in read(R/'ARTIFACTS.json').items(): + f=R/rel;need(f.is_file() and not f.is_symlink() and sha(f)==digest,'frozen audit artifact '+rel) +paths=[A/n for n in ('FILL.json.gz','ORDER.json','DISPATCH.json','PROFILE.json')]+[S/'PLAN.json.gz',S/'TEMPLATE.json.gz'] +paths += [NATIVE/f'checked-{p}/CANONICAL-WORD.json.gz' for p in ('base','extra')] +source_pins=read(R/'SOURCE-PINS.json') +repo=Path(os.environ['OWNER_SOURCE_REPO']).resolve() +for rel,digest in source_pins['repo_files'].items():need(sha(repo/rel)==digest,'retained source pin '+rel) +for tag in ('base','extra'):need(sha(NATIVE/f'checked-{tag}/CANONICAL-WORD.json.gz')==source_pins['native_canonical'][tag]['canonical_sha256'],'actual native canonical pin') +pins={str(p):sha(p) for p in paths} +expected=read(R/'EXPECTED.json');need(hashlib.sha256(gzip.decompress(paths[0].read_bytes())).hexdigest()==expected['payload_sha256'],'freshT530payload') +baseorder=read(R/'ORDER37.json')+[[s,r+37]for s,r in read(R/'T16-ORDER.json')] +need(read(paths[1])==[[s,r+53*cp]for s,r in baseorder for cp in range(10)],'exactmixedsourceclock') +basedispatch={(s,r):p for s,r,p in read(R/'DISPATCH37.json')};basedispatch.update({(s,r+37):p for s,r,p in read(R/'T16-DISPATCH.json')}) +need(read(paths[2])==[[s,r+53*cp,basedispatch[s,r]]for s,r in baseorder for cp in range(10)],'exactsourceproviderdispatch') +order=read(paths[1]);dispatch=read(paths[2]);profile={int(k):v for k,v in read(paths[3]).items()};plan=read(paths[4]);template=read(paths[5]) +T=530;N=9*T +need(len(order)==N and len(set(map(tuple,order)))==N,'call coverage') +clock={tuple(call):t for t,call in enumerate(order)} +need(set(clock)=={(s,r) for s in range(9) for r in range(T)},'exact source calls') +need(all([clock[s,r] for s in range(9)]==sorted(clock[s,r] for s in range(9)) for r in range(T)),'per-replica order') +D={(s,r):p for s,r,p in dispatch};need(len(dispatch)==N and set(D)==set(clock),'dispatch coverage') +need(Counter(D.values())=={'extra': 2090, 'gauge44': 2680},'provider count') +# Reconstruct source windows per replica from the actual source event sequence. +children={x['child']:x['rank'] for x in template['idle_children']};K=max(children)+1 +cap=np.zeros((T,K),dtype=np.int64);lo=np.full((T,K),N,dtype=np.int64);hi=np.full((T,K),-2,dtype=np.int64) +local_pair={x['stage']:x['pair'] for x in template['recipe'] if x['kind']=='local'} +for r in range(T): + touched={};t=None + for ev in template['execution_schedule']: + kind=ev['kind'] + if kind in ('bank_padding_cover_sweep','translate_every_live_family'):continue + if kind=='local_cover_sweep': + t=clock[ev['stage'],r];touched[local_pair[ev['stage']]]=t + elif kind=='bridge': + need(t is not None,'bridge source');touched[ev['src']]=t;touched[ev['dst']]=t + elif kind=='idle_cover_sweep': + need(t is not None,'idle source') + for c in ev['child_indices']: + if c in children: + need(cap[r,c]==0,'unique source child');cap[r,c]=children[c];lo[r,c]=touched.get(ev['pair'],-1);hi[r,c]=t + else:need(kind in ('terminal_Y_translations','terminal'),'known source event') +need(np.all(cap[:,list(children)]>0),'all source windows') +fam=np.full(K,-1,np.int64) +for c in children:fam[c]=2*plan['pairs'][str(c)]+plan['sides'][str(c)] +widths={};L=None +for tag,pid in [('base','gauge44'),('extra','extra')]: + w=read(NATIVE/f'checked-{tag}/CANONICAL-WORD.json.gz') + need(w['R']==408 and len(w['zero_buffers'])==91,'native helper stock') + widths[pid]=np.array([rank(w['frames'][w['final'][224+h]])-rank(w['frames'][w['start'][224+h]]) for h in range(408)],dtype=np.int64) + need(Counter(widths[pid])=={4:26,5:2,6:18,7:52,8:97,9:213},'actual native widths') + loc={int(k):v for k,v in w['local_profile'].items()} + need(L is None or L==loc,'common actual native bill');L=loc +need(L=={1:2439,2:726,3:224,4:102,5:20,8:8},'new local bill') +bycall=np.stack([widths[D[tuple(call)]] for call in order]) +j=read(A/'FILL.json.gz');need(j['columns']==['time','helper','owner_replica','child','port','offset'] and j['dispatch_overrides']==[],'journal schema') +need(all(len(row)==6 and all(type(v) is int for v in row) for row in j['rows']),'literal integer roles') +rows=np.array(j['rows'],dtype=np.int64);del j +need(rows.shape==(N*408,6),'literal role shape') +need(np.array_equal(rows[:,0],np.repeat(np.arange(N),408)) and np.array_equal(rows[:,1],np.tile(np.arange(408),N)),'complete literal ordered helper identities') +t,h,o,c,p,z=rows.T +need(np.all((o>=0)&(o=0)&(c=0)&(p<112)),'owner bounds') +need(np.all(cap[o,c]>0),'declared source child') +need(np.all((lo[o,c]=0)&(z+w<=cap[o,c])),'actual widths and capacity') +binid=(o*K+c)*112+p +idx=np.lexsort((t,binid));bins=binid[idx];ws=w[idx];starts=np.r_[True,bins[1:]!=bins[:-1]] +cs=np.cumsum(ws,dtype=np.int64)-ws;baseline=np.maximum.accumulate(np.where(starts,cs,0));expected=cs-baseline +need(np.array_equal(z[idx],expected),'every chronological pending mask is a compact prefix') +used=np.zeros(T*K*112,np.int64);np.add.at(used,binid,w) +allcap=np.repeat(cap.reshape(-1),112);valid=allcap>0 +need(np.all(used[~valid]==0) and np.all(used<=allcap),'full used-bin mass') +idle=Counter(map(int,(allcap-used)[valid]));idle.pop(0,None) +H=Counter({r:n*N for r,n in L.items()});H.update(idle) +need(dict(H)==profile and sum(r*n for r,n in H.items())==65088*T,'independent complete histogram') +# Small semantic predicates test each independent gate on actual changed inputs. +controls=[] +def reject(name,test): + need(not test(), 'control accepted '+name);controls.append(name) +reject('duplicate helper',lambda: np.array_equal(np.r_[rows[0,1],rows[:-1,1]],np.tile(np.arange(408),N))) +reject('strict lower endpoint used as available',lambda: bool(lo[o[0],c[0]]=0 + i=len(self.to);self.to.extend((v,u));self.cap.extend((int(capacity),0));self.adj[u].append(i);self.adj[v].append(i+1);return i + def maxflow(self,s,t,limit): + total=0;n=len(self.adj) + while total0:net.add(ss,n,b);target+=b + elif b<0:net.add(n,tt,-b) + got=net.maxflow(ss,tt,target) + assert got==target,('copy circulation',copy,got,target,dict(dg),dict(db)) + selected=[];wc=Counter();gc=Counter();bc=set() + for key,e in handles.items(): + n=net.cap[e^1] + assert n in (0,1) + if n: + b,w=key;i=bucket[key].pop();selected.append(i);wc[w]+=1;g=int(bin_group[b]);gc[g]+=1 + assert b not in bc;bc.add(b);db[b]-=1;dg[g]-=1;copies[i]=copy + assert len(selected)==408 and wc==Counter(dict(zip(W,INV))) + assert all(n<=group_n[g] for g,n in gc.items()) + assert max(db.values(),default=0)<=R-1 and all(n<=(R-1)*group_n[g] for g,n in dg.items()) + stats['flows']+=1;stats['max_nodes']=max(stats['max_nodes'],tt+1);stats['max_edges']=max(stats['max_edges'],len(net.to)//2) + return copies,stats diff --git a/research/staged-release-retiming-t530/owner-audit/upstream/portable_expand.py b/research/staged-release-retiming-t530/owner-audit/upstream/portable_expand.py new file mode 100644 index 0000000000..431654fe59 --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/upstream/portable_expand.py @@ -0,0 +1,126 @@ +# SPDX-License-Identifier: Apache-2.0 +# Adapted from PR3605; retained attribution in UPSTREAM-SOURCE-CREDITS.md. +import sys +if not __debug__ or sys.flags.optimize: + raise RuntimeError("Enabled assertions required before owner replay") +"""Reconstruct the S10 mixedT53 literal owners by deterministic integral networks. +No optimization is run. Requires explicit OWNER_SOURCE_REPO. Expected payload is the fresh independently audited T530 output, never a predecessor owner receipt. +This optional reconstruction takes several minutes and does not run admission. +""" +from pathlib import Path +from array import array +from collections import Counter,defaultdict +import argparse,gzip,hashlib,json,time +import importlib.util +def module(name,file): + spec=importlib.util.spec_from_file_location(name,Path(__file__).resolve().parent/file);m=importlib.util.module_from_spec(spec);spec.loader.exec_module(m);return m +_candidate=module('t530_candidate','verify_candidate.py');candidate_check=_candidate.check;v=_candidate.v +common=v.common;HERE=Path(__file__).resolve().parent;W=v.W;INV=v.INV;LOCAL=v.LOCAL;P=v.P +def check(cert):return candidate_check(cert,'concatenated') +copy_colors=module('t530_network','integral_network.py').copy_colors + +def authenticate(): + pins=common.read(HERE/'INPUT-PINS.json') + for rel,digest in pins.items(): + if common.sha(HERE/rel)!=digest:raise ValueError('changedbuilderinput '+rel) + return pins + +class Rows: + def __init__(self,calls,task_width,task_bin,owner,child,port,order,dispatch,providers): + self.calls,self.width,self.bin,self.owner,self.child,self.port=calls,task_width,task_bin,owner,child,port + self.order,self.dispatch,self.providers=order,dispatch,providers + def __len__(self):return len(self.calls)*408 + def __iter__(self): + offset=array('B',[0])*len(self.owner) + for t,tasks in enumerate(self.calls): + pool=defaultdict(list);pid=self.dispatch[tuple(self.order[t])] + for h,w in enumerate(self.providers[pid]['widths']):pool[w].append(h) + call=[] + for i in sorted(tasks,key=lambda i:(self.width[i],i)): + w=self.width[i];h=pool[w].pop();b=self.bin[i];call.append((h,b,w)) + assert not any(pool.values()) + for h,b,w in sorted(call): + z=offset[b];offset[b]+=w + yield [t,h,self.owner[b],self.child[b],self.port[b],z] + +def write_fill(path,rows): + payload=hashlib.sha256();prefix=json.dumps({'columns':['time','helper','owner_replica','child','port','offset'],'dispatch_overrides':[]},sort_keys=True,separators=(',',':'))[:-1]+',"rows":[' + 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 j,row in enumerate(rows): + data=((',' if j else '')+json.dumps(row,separators=(',',':'))).encode();out.write(data);payload.update(data) + data=b']}\n';out.write(data);payload.update(data) + return dict(rows=len(rows),sha256=common.sha(path),payload_sha256=payload.hexdigest()) + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--out',type=Path,required=True);ap.add_argument('--owner-check',action='store_true');a=ap.parse_args() + pins=authenticate();cert=common.read(HERE/'CANDIDATE.json');primal=check(cert);S=cert['S'];G=cert['groups'];T=53*S + assert T<65536 and S<=128 and len(G)<65536 and 477*S*408<2**32 + c=common.context();order45=cert['order'];win=c.owner.windows(c.template,order45,53);groups=defaultdict(list) + for (o,ch),(cap,lo,hi) in win.items(): + for p in range(112):groups[cap,lo,hi].append((o,ch,p)) + groupkeys=sorted(groups);assert [[*g,len(groups[g])] for g in groupkeys]==G + # Source child windows sharing a physical family are pairwise disjoint. + fw=defaultdict(list) + for (o,ch),(cap,lo,hi) in win.items():fw[o,c.families[ch]].append((lo,hi)) + for intervals in fw.values(): + for j,(lo,hi) in enumerate(intervals):assert all(max(lo,l)>=min(hi,h) for l,h in intervals[j+1:]) + xg=defaultdict(list);zg=defaultdict(list) + for gi,q,n in cert['x']:xg[gi].append((q,n)) + for gi,t,w,n in cert['z']:zg[gi].append((t,w,n)) + task_width=array('B');task_bin=array('I');bin_group=array('H');required=array('b');macro=[array('I') for _ in range(477)];bin_ranges=[] + for gi,g in enumerate(G): + bstart=len(bin_group);available=defaultdict(lambda:array('I')) + for q,n in sorted(xg[gi]): + widths=[w for w,k in zip(W,q) for _ in range(k)] + for _ in range(n): + b=len(bin_group);bin_group.append(gi);required.append(-1) + for w in widths: + i=len(task_width);task_width.append(w);task_bin.append(b);available[w].append(i) + cursor=Counter() + for t,w,n in sorted(zg[gi]): + ids=available[w][cursor[w]:cursor[w]+n];assert len(ids)==n;macro[t].extend(ids);cursor[w]+=n + assert all(cursor[w]==len(ids) for w,ids in available.items()) + assert len(bin_group)-bstart==g[3]*S;bin_ranges.append((bstart,len(bin_group))) + assert len(task_width)==477*S*408 + actual=[array('I') for _ in range(477*S)];group_n={gi:g[3] for gi,g in enumerate(G)};stats=Counter();t0=time.monotonic() + for t,indices in enumerate(macro): + colors,stat=copy_colors(sorted(indices),task_bin,task_width,bin_group,group_n,S) + for i,cp in colors.items(): + actual[S*t+cp].append(i);b=task_bin[i];gi=bin_group[b] + if t==G[gi][2]:required[b]=max(required[b],cp) + stats['flows']+=stat['flows'];stats['max_nodes']=max(stats['max_nodes'],stat['max_nodes']);stats['max_edges']=max(stats['max_edges'],stat['max_edges']) + if t%40==0:print('PORTABLE_CALL_DECOMPOSITION',t,'seconds',round(time.monotonic()-t0,2),flush=True) + assert all(len(call)==408 for call in actual) + owners=array('H',[0])*len(bin_group);children=array('H',[0])*len(bin_group);ports=array('B',[0])*len(bin_group) + for gi,(lo,hi) in enumerate(bin_ranges): + base=groups[groupkeys[gi]];m=len(base) + for j,b in enumerate(sorted(range(lo,hi),key=lambda b:(required[b],b),reverse=True)): + cp=S-1-j//m;o,ch,p=base[j%m];assert cp>=required[b] + owners[b]=o+53*cp;children[b]=ch;ports[b]=p + order=[[s,r+53*cp] for s,r in order45 for cp in range(S)];t8dispatch={(s,r):pid for s,r,pid in common.read(HERE/'T16-DISPATCH.json')};dispatch={(s,r+53*cp):(c.dispatch[s,r] if r<37 else t8dispatch[s,r-37]) for s,r in order45 for cp in range(S)} + providers=common.read(HERE/'PROVIDERS.json') + for provider in providers.values():provider['actual_paid_profile']={int(k):v for k,v in provider['actual_paid_profile'].items()} + for pid,provider in providers.items(): + assert provider['widths']==[w-int(h in (389,397)) for h,w in enumerate(c.providers[pid]['widths'])] + assert provider['actual_paid_profile']==LOCAL + a.out.mkdir(parents=True,exist_ok=False) + for name,obj in [('ORDER.json',order),('DISPATCH.json',[[s,r,dispatch[s,r]] for s,r in order]),('PROFILE.json',cert['profile']),('PROVIDERS.json',common.read(HERE/'PROVIDERS.json'))]: + # The source profile file uses indented sorted-rank formatting. + if name=='PROFILE.json':data=json.dumps({int(k):v for k,v in sorted(cert['profile'].items(),key=lambda kv:int(kv[0]))},indent=2)+'\n' + else:data=json.dumps(obj,separators=(',',':'))+'\n' + (a.out/name).write_text(data) + assert common.sha(a.out/name)==common.read(HERE/'EXPECTED.json')['literal_files'][name],('changedliteralinput',name) + rows=Rows(actual,task_width,task_bin,owners,children,ports,order,dispatch,providers);made=write_fill(a.out/'FILL.json.gz',rows) + expected=common.read(HERE/'EXPECTED.json') + # Container bytes are provenance only: zlib streams may vary across runtimes. + assert made['rows']==477*S*408==expected['rows'] and made['payload_sha256']==expected['payload_sha256'] + assert primal['profile']=={int(k):v for k,v in cert['profile'].items()} + report=dict(status='PASS_STANDARD_LIBRARY_SEMANTIC_LITERAL_REPLAY',replicas=T,calls=477*S,roles=len(rows),physical=896*T+509,materialized=made,decomposition=dict(stats),primal=primal,fresh_retained_owner_check=False,scope='Fresh mixedT53S10 exact integer networks and literal generation. No predecessor owner receipt is reused as candidate proof. Fresh independent literal audit and full release required.') + if a.owner_check: + fill={'columns':['time','helper','owner_replica','child','port','offset'],'dispatch_overrides':[],'rows':rows} + result,_,_=c.owner.check(T,order,fill,dispatch,cert['profile'],c.plan,c.template,providers);report['fresh_retained_owner_check']=True;report['owner_check']=result + (a.out/'PORTABLE-REPLAY.json').write_text(json.dumps(report,indent=2,sort_keys=True)+'\n') + print('PORTABLE_REPLAY_PASS',json.dumps(made),flush=True) + +if __name__=='__main__':main() diff --git a/research/staged-release-retiming-t530/owner-audit/upstream/source_context.py b/research/staged-release-retiming-t530/owner-audit/upstream/source_context.py new file mode 100644 index 0000000000..9731888ac7 --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/upstream/source_context.py @@ -0,0 +1,32 @@ +# SPDX-License-Identifier: Apache-2.0 +# Adapted from PR3605; retained attribution in UPSTREAM-SOURCE-CREDITS.md. +import sys +if not __debug__ or sys.flags.optimize: + raise RuntimeError("Enabled assertions required before owner replay") +"""Solver-independent integer primal check of the new aggregate owner flow. + +Standard library only. Source geometry is read from the attributed frozen source +template through its retained window routine; literal copied owners are checked +separately. This certifies one finite primal, not LP optimality. +""" +from pathlib import Path +from collections import Counter,defaultdict +import sys,json,gzip,hashlib,os +if not __debug__: + raise SystemExit('unoptimized Python required by retained owner engines') +HERE=Path(__file__).resolve().parent +if not os.environ.get('OWNER_SOURCE_REPO'): + raise SystemExit('OWNER_SOURCE_REPO must identify the declared source checkout or export') +ROOT=Path(os.environ['OWNER_SOURCE_REPO']).resolve() +P=ROOT/'research/coupled-carrier-cap740' +# Authenticate every imported predecessor before executing any of its code. +_pins=json.loads((HERE/'SOURCE-PINS.json').read_text()) +for _rel,_digest in _pins['repo_files'].items(): + _path=ROOT/_rel + if not _path.is_file() or _path.is_symlink() or hashlib.sha256(_path.read_bytes()).hexdigest()!=_digest: + raise ValueError('stale retained source '+_rel) +import types +common=types.ModuleType('staged_owner_retained_common');common.__file__=str(P/'common.py') +exec(compile((P/'common.py').read_bytes(),common.__file__,'exec'),common.__dict__) +W=(4,5,6,7,8,9);INV=Counter(dict(zip(W,(26,2,18,52,97,213)))) +LOCAL={1:2439,2:726,3:224,4:102,5:20,8:8} diff --git a/research/staged-release-retiming-t530/owner-audit/upstream/test_owner_guards.py b/research/staged-release-retiming-t530/owner-audit/upstream/test_owner_guards.py new file mode 100644 index 0000000000..fbe816a2ac --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/upstream/test_owner_guards.py @@ -0,0 +1,22 @@ +# SPDX-License-Identifier: Apache-2.0 +import pathlib,json,copy,subprocess,sys,tempfile,shutil,importlib.util +P=pathlib.Path(__file__).resolve().parent +def need(x,m): + if not x:raise ValueError(m) +def main(): + count=0 + with tempfile.TemporaryDirectory()as t: + d=pathlib.Path(t);out=d/'must-not-exist' + for name in ('verify_owner.py','verify_candidate.py','portable_expand.py','independent_literal.py','integral_network.py','source_context.py'): + r=subprocess.run([sys.executable,'-I','-O','-B',str(P/name),'--out',str(out)],capture_output=True,text=True) + need(r.returncode and 'Enabled assertions required'in r.stderr and not out.exists(),'optimized gate '+name);count+=1 + q=d/'corrupt';shutil.copytree(P,q);(q/'CANDIDATE.json').write_bytes((q/'CANDIDATE.json').read_bytes()+b'x') + r=subprocess.run([sys.executable,'-I','-B',str(q/'verify_owner.py')],capture_output=True,text=True);need(r.returncode and 'frozen owner artifact'in r.stderr,'certificate corruption');count+=1 + spec=importlib.util.spec_from_file_location('check_controls',P/'verify_candidate.py');v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v);x=json.loads((P/'CANDIDATE.json').read_text());v.check(x,'concatenated') + for field,value in [('order',x['order'][::-1]),('groups',[]),('inventory',{}),('profile',{})]: + d=copy.deepcopy(x);d[field]=value + try:v.check(d,'concatenated') + except ValueError:count+=1 + else:raise ValueError('accepted semantic corruption '+field) + print('PASS_OWNER_GUARDS',count) +if __name__=='__main__':main() diff --git a/research/staged-release-retiming-t530/owner-audit/upstream/verify_candidate.py b/research/staged-release-retiming-t530/owner-audit/upstream/verify_candidate.py new file mode 100644 index 0000000000..ac74cbc4b8 --- /dev/null +++ b/research/staged-release-retiming-t530/owner-audit/upstream/verify_candidate.py @@ -0,0 +1,45 @@ +import sys +if not __debug__ or sys.flags.optimize:raise RuntimeError('Enabled assertions required before owner replay') +from pathlib import Path +from collections import Counter,defaultdict +import json,os,importlib.util,hashlib,argparse +P=Path(__file__).resolve().parent +if not os.environ.get('OWNER_SOURCE_REPO'):raise ValueError('explicitOWNER_SOURCE_REPOrequired') +s=importlib.util.spec_from_file_location('actual_owner',P/'source_context.py');v=importlib.util.module_from_spec(s);s.loader.exec_module(v) +def need(x,m): + if not x:raise ValueError(m) +def check(d,kind): + # Regenerate expectedclock from authenticated actualinputstreams, not candidate fields. + import gzip + pins=json.loads((P/'INPUT-PINS.json').read_text()) + for rel,sha in pins.items():need(hashlib.sha256((P/rel).read_bytes()).hexdigest()==sha,'inputpin') + a=json.loads((P/'ORDER37.json').read_text());b=[[i,j+37]for i,j in json.loads((P/'T16-ORDER.json').read_text())] + if kind=='concatenated':order=a+b + else: + from fractions import Fraction as F + order=[z[2]for z in sorted([(F(2*i+1,666),0,z)for i,z in enumerate(a)]+[(F(2*i+1,288),1,z)for i,z in enumerate(b)])] + need(d['order']==order,'actualsourceclock'); + providers=json.loads((P/'PROVIDERS.json').read_text());pins=json.loads((P/'ARTIFACTS.json').read_text());need(hashlib.sha256((P/'PROVIDERS.json').read_bytes()).hexdigest()==pins['PROVIDERS.json'],'providerpin') + for provider in providers.values(): + need(Counter(provider['widths'])==v.INV,'providerwidths');need({int(k):n for k,n in provider['actual_paid_profile'].items()}==v.LOCAL,'providerlocal') + c=v.common.context();win=c.owner.windows(c.template,order,53);g=Counter();fw=defaultdict(list) + for (o,ch),(cap,lo,hi)in win.items():g[cap,lo,hi]+=112;fw[o,c.families[ch]].append((lo,hi)) + need(all(all(max(lo,l)>=min(hi,h)for l,h in rows[i+1:])for rows in fw.values()for i,(lo,hi)in enumerate(rows)),'disjointfamilywindows') + G=[[*k,n]for k,n in sorted(g.items())];need(d['groups']==G,'actualgroups');S=d['S'];need(type(S)is int and S>0,'positiveintegralS');need(d['widths']==list(v.W),'widths');need({int(k):n for k,n in d['inventory'].items()}==dict(v.INV),'actualinventory') + xb=Counter();xw=Counter();idle=Counter();seen=set() + for gi,q,n in d['x']: + need(type(gi)is int and 0<=gi=0 for z in q)and type(n)is int and n>0,'patternintegers');need((gi,tuple(q))not in seen,'duplicatepattern');seen.add((gi,tuple(q))) + used=sum(w*z for w,z in zip(v.W,q));need(used<=G[gi][0]and sum(q)<=S,'patterncapacity');xb[gi]+=n + for w,z in zip(v.W,q):xw[gi,w]+=z*n + if used0,'flowintegers');need((gi,t,w)not in seen,'duplicateflow');seen.add((gi,t,w));need(G[gi][1]=1,'power domain');k=0 + while y>2:y/=2;k+=1 + a=unit(y,b);two=unit(Q(2),b) + for _ in range(k):a=mul(a,two) + return a +def moment(profile,b,W): + need(type(W)is int and W>0 and 0<=b<1,'moment domain') + lo=hi=0 + for r,n in profile.items(): + need(type(r)is int and type(n)is int and 00,'paid child') + a,z=power(Q(73,r),b);lo+=n*r*a;hi+=n*r*z + return Q(lo,S*73*W),Q(hi,S*73*W) diff --git a/research/staged-release-retiming-t530/packing-cap/cap-source/pr3630-check_budget.py b/research/staged-release-retiming-t530/packing-cap/cap-source/pr3630-check_budget.py new file mode 100644 index 0000000000..a1de88c5f7 --- /dev/null +++ b/research/staged-release-retiming-t530/packing-cap/cap-source/pr3630-check_budget.py @@ -0,0 +1,121 @@ +"""Re-enumerate every pattern and certify the fixed-inventory dual. + +Derived from the separate review_budget.py by Ross Richardson with substantial +OpenAI Codex assistance; see ADAPTATIONS.json. No optimizer or cached PASS input. +The source-bound positive-binomial engine is credited to PR3531. +""" +from collections import Counter +from fractions import Fraction as Q +from itertools import product +from pathlib import Path +import argparse, hashlib, json, types +ap = argparse.ArgumentParser(description=__doc__) +ap.add_argument('--predecessor', type=Path, required=True) +ap.add_argument('--out', type=Path, required=True) +a = ap.parse_args() +binomial_source = (a.predecessor / 'vendor/pr3531/binomial.py').read_bytes() +if hashlib.sha256(binomial_source).hexdigest() != '03eebf2be23cab07e5f9e978980fee7b17e10847da5720c3e4e0adb243e8e4fa': + raise ValueError('source-bound binomial engine') +B = types.ModuleType('positive_binomial_dual') +exec(compile(binomial_source, 'PR3531/binomial.py', 'exec'), B.__dict__) +M, T, W = (73, 740, 663040) +CAPS = (8, 16, 32, 48) +WIDTHS = (4, 5, 6, 7, 8, 9) +CAP_TOTAL = (672, 448, 448, 448) +INVENTORY = (26, 2, 18, 52, 97, 213) +H0 = {1: 16417896, 2: 4835160, 3: 1540174, 4: 679321, 5: 143992, 6: 3, 8: 53280, 48: 283185} +HA = {1: 16417892, 2: 4835160, 3: 1540174, 4: 679320, 5: 143993, 7: 3, 8: 53280, 48: 283185} +DELTA = {1: -4, 4: -1, 5: 1, 6: -3, 7: 3} +L = {1: 2439, 2: 726, 3: 224, 4: 102, 5: 20, 8: 8} +C0 = Q('0.001730006549538841847005') +CA = Q('0.001730006690311348872326') +LO = Q('0.001730096363528623534230') +HI = LO + Q(1, 10 ** 24) + +def solve(a, b): + n = len(a) + z = [[Q(v) for v in row] + [Q(b[i])] for i, row in enumerate(a)] + for j in range(n): + k = next((k for k in range(j, n) if z[k][j])) + z[j], z[k] = (z[k], z[j]) + q = z[j][j] + z[j] = [x / q for x in z[j]] + for k in range(n): + if k != j: + q = z[k][j] + z[k] = [x - q * y for x, y in zip(z[k], z[j])] + return [row[-1] for row in z] +patterns = [] +for capacity in CAPS: + for counts in product(*(range(capacity // width + 1) for width in WIDTHS)): + used = sum((n * w for n, w in zip(counts, WIDTHS))) + if used <= capacity: + patterns.append((capacity, counts, capacity - used)) +if not len(patterns) == len(set(patterns)) == 2551: + raise ValueError('dual condition: len(patterns) == len(set(patterns)) == 2551') +column = lambda p: [Q(p[0] == capacity) for capacity in CAPS] + list(map(Q, p[1])) +specs = [(8, (8,), Q(672)), (16, (7, 9), Q(448)), (32, (9, 9, 9), Q(57, 4)), (32, (7, 8, 8, 9), Q(39, 2)), (32, (7, 7, 9, 9), Q(1, 4)), (32, (6, 8, 9, 9), Q(162)), (32, (5, 9, 9, 9), Q(18)), (32, (4, 9, 9, 9), Q(234)), (48, (), Q(1531, 4)), (48, (9, 9, 9, 9, 9), Q(261, 4))] +basis = [(cap, tuple((ws.count(w) for w in WIDTHS)), cap - sum(ws)) for cap, ws, n in specs] +amount = [n for cap, ws, n in specs] +if not all((p in patterns for p in basis)): + raise ValueError('dual condition: all((p in patterns for p in basis))') +columns = [column(p) for p in basis] +A = list(map(list, zip(*columns))) +rhs = list(map(Q, CAP_TOTAL)) + [Q(9 * n) for n in INVENTORY] +if not [sum((a * n for a, n in zip(row, amount))) for row in A] == rhs: + raise ValueError('dual condition: [sum((a * n for a, n in zip(row, amount))) for row in A] == rhs') +if not (solve(A, rhs) == amount and all((n > 0 for n in amount))): + raise ValueError('dual condition: solve(A, rhs) == amount and all((n > 0 for n in amount))') +ideal_idle = Counter() +for p, n in zip(basis, amount): + if p[2]: + ideal_idle[p[2]] += n * T +ideal = Counter({r: 9 * T * n for r, n in L.items()}) +ideal.update(ideal_idle) +if not all((Q(n).denominator == 1 for n in ideal.values())): + raise ValueError('dual condition: all((Q(n).denominator == 1 for n in ideal.values()))') +ideal = {r: int(n) for r, n in ideal.items()} +if not sum((r * n for r, n in ideal.items())) == sum((r * n for r, n in HA.items())) == 65088 * T: + raise ValueError('dual condition: sum((r * n for r, n in ideal.items())) == sum((r * n for r, n in HA.items())) == 65088 * T') +root_enclosures = {} +for name, profile, lo, hi in [('predecessor', H0, C0, C0 + Q(1, 10 ** 24)), ('candidate_A', HA, CA, CA + Q(1, 10 ** 24)), ('relaxed_ceiling', dict(ideal), LO, HI)]: + below = B.moment(profile, lo, W) + above = B.moment(profile, hi, W) + if not below[1] < 1 < above[0]: + raise ValueError('dual condition: below[1] < 1 < above[0]') + root_enclosures[name] = {'lower': str(lo), 'upper': str(hi), 'moment_at_lower': list(map(str, below)), 'moment_at_upper': list(map(str, above))} +cache = {} + +def f(rank, b): + if rank == 0: + return (Q(0), Q(0)) + if (rank, b) not in cache: + cache[rank, b] = tuple((73 * x for x in B.moment({rank: 1}, b, 1))) + return cache[rank, b] +dual_symbolic = [solve(list(map(list, zip(*A))), [int(i == j) for i in range(10)]) for j in range(10)] + +def coefficients(p): + a = column(p) + out = Counter({p[2]: Q(1)}) if p[2] else Counter() + for j, bp in enumerate(basis): + if bp[2]: + out[bp[2]] -= sum((x * y for x, y in zip(a, dual_symbolic[j]))) + return {r: n for r, n in out.items() if n} +tight = [] +strict = [] +coefficient_hash = hashlib.sha256() +for p in patterns: + coeff = coefficients(p) + coefficient_hash.update(json.dumps([p, sorted(((r, str(n)) for r, n in coeff.items()))], separators=(',', ':')).encode()) + if not coeff: + tight.append(p) + continue + lower = sum((n * f(r, LO if n > 0 else HI)[0 if n > 0 else 1] for r, n in coeff.items())) + if not lower > 0: + raise ValueError('dual condition: lower > 0') + strict.append((lower, p)) +if not (len(tight), len(strict)) == (12, 2539): + raise ValueError('dual condition: (len(tight), len(strict)) == (12, 2539)') +result = dict(status='PASS_ALL_2551_FIXED_INVENTORY_PATTERNS', patterns=len(patterns), strict=len(strict), symbolically_zero=len(tight), coefficient_sha256=coefficient_hash.hexdigest(), root_enclosures=root_enclosures, ideal_profile=ideal, min_reduced_cost_lower=str(min(strict)[0]), scope='Finite exhaustive dual plus written scaling proof for every positive integer T with the same capacities, width inventory, local bill and live stock896T; no chronological attainment or global optimum.') +a.out.write_text(json.dumps(result, sort_keys=True, indent=2) + '\n') +print(result['status']) diff --git a/research/staged-release-retiming-t530/packing-cap/check_retimed_cap.py b/research/staged-release-retiming-t530/packing-cap/check_retimed_cap.py new file mode 100644 index 0000000000..e7a3e5f229 --- /dev/null +++ b/research/staged-release-retiming-t530/packing-cap/check_retimed_cap.py @@ -0,0 +1,107 @@ +"""Exact all-T fixed-capacity packing cap for the local two-release-swap profile. + +Adapted from PR3630 check_budget.py, Ross Richardson / OpenAI Codex assistance, +head bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608. Its pattern basis and exact dual +are retained; local invoice changes by 2H3-2H2-2H1. PR3531's source-bound +positive-binomial engine is retained unchanged. No allocation is constructed. +""" +from collections import Counter +from fractions import Fraction as Q +from itertools import product +from pathlib import Path +import argparse,hashlib,json,tempfile,types,time +def need(ok,msg): + if not ok:raise ValueError(msg) +HERE=Path(__file__).resolve().parent +parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--out',type=Path,help='Fresh external output directory; default: temporary directory.') +args=parser.parse_args() +OUT=args.out.resolve() if args.out else Path(tempfile.mkdtemp(prefix='retiming-cap-')) +need(OUT!=HERE and HERE not in OUT.parents,'output must be outside package') +need(not args.out or not OUT.exists(),'fresh output directory required') +OUT.mkdir(parents=True,exist_ok=True) +raw=(HERE/'cap-source/binomial.py').read_bytes() +need(hashlib.sha256(raw).hexdigest()=='03eebf2be23cab07e5f9e978980fee7b17e10847da5720c3e4e0adb243e8e4fa', "failed: hashlib.sha256(raw).hexdigest()=='03eebf2be23cab07e5f9e978980fee7b17e10847da5720c3e4e0adb243e8e4fa'") +B=types.ModuleType('positive_binomial_dual');exec(compile(raw,'PR3531/binomial.py','exec'),B.__dict__) +CAPS=(8,16,32,48);WIDTHS=(4,5,6,7,8,9);CAP_TOTAL=(672,448,448,448);INVENTORY=(26,2,18,52,97,213) +L={1:2437,2:724,3:226,4:102,5:20,8:8} +PARENT_L={1:2439,2:726,3:224,4:102,5:20,8:8} +T=740;W=896*T +LITERAL_T=530 +LITERAL_BEFORE={1:11757460,2:3463020,3:1102502,4:486540,5:103690,8:38160,48:202828} +LITERAL=dict(LITERAL_BEFORE) +for r,d in {1:-2,2:-2,3:2}.items():LITERAL[r]+=9*LITERAL_T*d +REALIZED=Q('0.001730394391813963415120') + +def solve(a,b): + n=len(a);z=[[Q(v) for v in row]+[Q(b[i])] for i,row in enumerate(a)] + for j in range(n): + k=next(k for k in range(j,n) if z[k][j]);z[j],z[k]=z[k],z[j];q=z[j][j];z[j]=[x/q for x in z[j]] + for k in range(n): + if k!=j: + q=z[k][j];z[k]=[x-q*y for x,y in zip(z[k],z[j])] + return [row[-1] for row in z] + +patterns=[] +for capacity in CAPS: + for counts in product(*(range(capacity//width+1) for width in WIDTHS)): + used=sum(n*w for n,w in zip(counts,WIDTHS)) + if used<=capacity:patterns.append((capacity,counts,capacity-used)) +need(len(patterns)==len(set(patterns))==2551, 'failed: len(patterns)==len(set(patterns))==2551') +column=lambda p:[Q(p[0]==capacity) for capacity in CAPS]+list(map(Q,p[1])) +specs=[(8,(8,),Q(672)),(16,(7,9),Q(448)),(32,(9,9,9),Q(57,4)),(32,(7,8,8,9),Q(39,2)),(32,(7,7,9,9),Q(1,4)),(32,(6,8,9,9),Q(162)),(32,(5,9,9,9),Q(18)),(32,(4,9,9,9),Q(234)),(48,(),Q(1531,4)),(48,(9,9,9,9,9),Q(261,4))] +basis=[(cap,tuple(ws.count(w) for w in WIDTHS),cap-sum(ws)) for cap,ws,n in specs];amount=[n for cap,ws,n in specs] +A=list(map(list,zip(*[column(p) for p in basis])));rhs=list(map(Q,CAP_TOTAL))+[Q(9*n) for n in INVENTORY] +need(all(p in patterns for p in basis), 'failed: all(p in patterns for p in basis)') +need([sum(a*n for a,n in zip(row,amount)) for row in A]==rhs, 'failed: [sum(a*n for a,n in zip(row,amount)) for row in A]==rhs') +need(solve(A,rhs)==amount and all(n>0 for n in amount), 'failed: solve(A,rhs)==amount and all(n>0 for n in amount)') +idle=Counter() +for p,n in zip(basis,amount): + if p[2]:idle[p[2]]+=n*T +ideal=Counter({r:9*T*n for r,n in L.items()});ideal.update(idle) +need(all(Q(n).denominator==1 for n in ideal.values()), 'failed: all(Q(n).denominator==1 for n in ideal.values())');ideal={r:int(n) for r,n in ideal.items()} +need(sum(r*n for r,n in ideal.items())==65088*T, 'failed: sum(r*n for r,n in ideal.items())==65088*T') +need(sum(r*n for r,n in LITERAL.items())==65088*LITERAL_T, 'failed: sum(r*n for r,n in LITERAL.items())==65088*LITERAL_T') + +def bracket(profile,stock,digits=24): + scale=10**digits;a=0;c=scale//100 + need(B.moment(profile,Q(c,scale),stock)[0]>1, 'failed: B.moment(profile,Q(c,scale),stock)[0]>1') + while c-a>1: + m=(a+c)//2;lo,hi=B.moment(profile,Q(m,scale),stock) + if hi<1:a=m + elif lo>1:c=m + else:raise ValueError('interval too wide') + lo=Q(a,scale);hi=Q(c,scale) + ml=B.moment(profile,lo,stock);mh=B.moment(profile,hi,stock) + need(ml[1]<10 else HI)[0 if n>0 else 1] for r,n in co.items()) + need(lower>0, 'failed: lower>0') + strict.append((lower,p)) +need((len(tight),len(strict))==(12,2539), 'failed: (len(tight),len(strict))==(12,2539)') +fraclow=actuallo/HI;frachigh=actualhi/LO +result={'status':'PASS_RETIMED_ALL_2551_FIXED_INVENTORY_PATTERNS','source_heads':{'PR3630':'bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608','PR3531':'550a660a97308d3aeb3620ee1f4218f77e2c2742'},'source_sha256':{'binomial.py':hashlib.sha256(raw).hexdigest(),'pr3630-check_budget.py':hashlib.sha256((HERE/'cap-source/pr3630-check_budget.py').read_bytes()).hexdigest()},'local_per_call':L,'width_inventory_per_call':dict(zip(WIDTHS,INVENTORY)),'capacity_counts_per_replica':dict(zip(CAPS,CAP_TOTAL)),'ideal_idle_per_replica':{r:str(n/T) for r,n in idle.items()},'ideal_profile_at_T740':ideal,'literal_T530_profile':LITERAL,'cap_root':[str(LO),str(HI)],'cap_root_decimal':[format(float(LO),'.25f'),format(float(HI),'.25f')],'literal_root':[str(actuallo),str(actualhi)],'literal_to_cap_ratio':[str(fraclow),str(frachigh)],'literal_to_cap_ratio_float':[float(fraclow),float(frachigh)],'remaining_root_headroom':[str(LO-actualhi),str(HI-actuallo)],'remaining_root_headroom_float':[float(LO-actualhi),float(HI-actuallo)],'patterns':len(patterns),'strict':len(strict),'symbolically_zero':len(tight),'coefficient_sha256':ch.hexdigest(),'min_reduced_cost_lower':str(min(strict)[0]),'moment_at_cap_lower':list(map(str,ml)),'moment_at_cap_upper':list(map(str,mh)),'moment_at_literal_lower':list(map(str,aml)),'moment_at_literal_upper':list(map(str,amh)),'scope':'All positive integer T under same fixed capacities,widths,new local bill,dimension73,live stock896T. Chronology/family attainment unknown. Modern primitive scope uses kappa approximately b; no universal multiplication cap and no new supplier admission.','seconds':time.time()-start} +# Decimal presentation generated exactly, not through float. +def dec(q): + return str(q.numerator//q.denominator)+'.'+str((q.numerator%q.denominator)*10**24//q.denominator).zfill(24) +result['cap_root_decimal']=[dec(LO),dec(HI)];result['literal_root_decimal']=[dec(actuallo),dec(actualhi)] +(OUT/'RETIMED-PACKING-CAP.json').write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') +print(result['status']);print('cap',result['cap_root_decimal']);print('literal',result['literal_root_decimal']);print('fraction',result['literal_to_cap_ratio_float']);print('headroom',result['remaining_root_headroom_float']);print('seconds',result['seconds']) +print('Fresh evidence:',OUT) diff --git a/research/staged-release-retiming-t530/verify.py b/research/staged-release-retiming-t530/verify.py new file mode 100644 index 0000000000..7d59ff0e23 --- /dev/null +++ b/research/staged-release-retiming-t530/verify.py @@ -0,0 +1,176 @@ +#!/usr/bin/env python3 +"""Bounded fresh finite checks plus explicitly scoped recorded-summary checks. + +Full native/controller/outer admission is the separate full-admission replay. +Prepared with substantial OpenAI Codex assistance. SPDX-License-Identifier: Apache-2.0 +""" +from fractions import Fraction +from pathlib import Path +import hashlib +import json +import copy +import os +import subprocess +import sys +import tempfile +import time + +HERE = Path(__file__).resolve().parent +REPO = HERE.parents[1] +PROFILE = {'1':11747920, '2':3453480, '3':1112042, '4':486540, + '5':103690, '8':38160, '48':202828} +LOWER = Fraction('0.001730394391813963415120') +UPPER = Fraction('0.001730394391813963415121') +KAPPA = LOWER - Fraction(1, 10**46) - Fraction(1, 10**70) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def read(path): + return json.loads(path.read_text()) + + +def snapshot(): + return {str(p.relative_to(HERE)): hashlib.sha256(p.read_bytes()).hexdigest() + for p in HERE.rglob('*') if p.is_file()} + + +def check_recorded_cache(evidence, native): + observed = evidence['local_byte_checks'] + require(observed['runtime_file_count'] == 658 + and observed['native_cache_files'] == len(native['cache_files']) == 63, + 'complete recorded runtime/native inventory') + require(set(native['providers']) == {'base', 'extra'}, 'recorded native providers') + for provider in native['providers'].values(): + prefix = provider['word_sha256'] + '/' + subset = {name.removeprefix(prefix): digest + for name, digest in native['cache_files'].items() + if name.startswith(prefix) and name != prefix + 'CACHE.json'} + require(len(subset) == 12 and provider['complete_native_files'] == subset, + 'complete recorded provider cache subset') + + +def main(): + require(__debug__ and not sys.flags.optimize, 'Run with assertions enabled') + before = snapshot() + out = Path(tempfile.mkdtemp(prefix='staged-release-retiming-t530-')) + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1') + env.pop('PYTHONOPTIMIZE', None) + stages = [] + + def run(name, relative, *args): + start = time.monotonic() + command = [sys.executable, '-B', str(HERE / relative), *map(str, args)] + result = subprocess.run(command, cwd=REPO, env=env, + capture_output=True, text=True, timeout=240) + (out / (name + '.log')).write_text(result.stdout + result.stderr) + require(result.returncode == 0, name + ' failed: ' + str(out / (name + '.log'))) + stages.append({'stage':name, 'exit_code':0, 'seconds':time.monotonic()-start}) + print('PASS ' + name, flush=True) + return result.stdout + + run('local', 'local-audit/verify.py', '--out', out / 'local') + run('owner', 'owner-audit/run.py', '--repo', REPO, '--out', out / 'owner') + run('numerics', 'numerics/run.py', '--out', out / 'numerics') + run('packing', 'packing-cap/check_retimed_cap.py', '--out', out / 'packing') + summary = json.loads(run('recorded-summary', 'full-admission/check_recorded_summary.py')) + + local = read(out / 'local/VERIFY.json') + owner = read(out / 'owner/RESULT.json') + owner_run = read(out / 'owner/RUN.json') + owner_controls = read(out / 'owner/SEMANTIC-GATES.json') + moment = read(out / 'numerics/MOMENT.json') + outer = read(out / 'numerics/outer/RESULT.json') + cap = read(out / 'packing/RETIMED-PACKING-CAP.json') + require(local['status'] == 'PASS_PORTABLE_LOCAL_RETIMING_AUDIT', 'local status') + require(owner_run['status'] == 'PASS_LEAN_REGENERATED_OWNER_AUDIT', 'fresh owner status') + require(owner_controls['status'] + == 'PASS_FIVE_EXACT_PRODUCTION_GATE_MUTATIONS_AND_FIVE_DISABLE_SENSITIVITIES', + 'fresh owner semantic controls') + require(owner_controls['source_sha256'] == owner['script_sha256'] + and owner_controls['roles'] == owner['roles'], 'owner control source/data binding') + require({item['gate'] for item in owner_controls['tests']} + == {'helper_identity', 'window', 'family', 'prefix', 'histogram'} + and len(owner_controls['tests']) == 5, 'complete owner gate control coverage') + for item in owner_controls['tests']: + require(all(item[key] is True for key in + ('baseline_passed', 'mutant_rejected_at_expected_gate', + 'disabling_gate_makes_control_fail', 'restored_baseline_passed')), + 'owner mutation and gate-disable sensitivity: ' + item['gate']) + require(owner['profile'] == moment['new_profile'] == cap['literal_T530_profile'] + == summary['profile'] == PROFILE, 'all components bind the same full profile') + require(owner['roles'] == 1946160 and owner['calls'] == moment['calls'] == 4770, + 'complete literal role/call coverage') + require(owner['physical'] == summary['physical'] == 475389, 'physical stock') + require(moment['status'] == 'PASS_TWO_ENGINE_EXACT_MOMENT', 'two-engine moment status') + require(list(map(Fraction, moment['root_interval'])) == [LOWER, UPPER], 'exact root interval') + require(list(map(Fraction, cap['literal_root'])) == [LOWER, UPPER], 'independent literal root') + require(outer['status'] == 'PASS_RETIMED_MODERN_OUTER_ARITHMETIC' + and outer['strict_inequalities'] == 63 and outer['rejected_controls'] == 17, + 'complete bounded outer arithmetic') + require(Fraction(outer['kappa']) == Fraction(summary['kappa']) == KAPPA, 'exact endpoint binding') + require(cap['status'] == 'PASS_RETIMED_ALL_2551_FIXED_INVENTORY_PATTERNS' + and (cap['patterns'], cap['strict'], cap['symbolically_zero']) == (2551, 2539, 12), + 'all fixed-inventory patterns') + require(summary['status'] == 'PASS_PUBLIC_RECORDED_SUMMARY_BINDINGS', 'narrow summary status') + full_run = read(HERE / 'PUBLIC-FULL-REPLAY.json') + fresh_dir = HERE / 'full-admission/fresh-replay' + attempt = read(fresh_dir / 'ATTEMPT.json') + wrapper_result = read(fresh_dir / 'WRAPPER-RESULT.json') + admission_result = read(fresh_dir / 'ADMISSION-RESULT.json') + native_receipt = read(fresh_dir / 'NATIVE-RECEIPT.json') + fresh_evidence = read(fresh_dir / 'EVIDENCE.json') + require(full_run['status'] == 'PASS_PUBLIC_FULL_WRAPPER_END_TO_END' + and Fraction(full_run['kappa']) == KAPPA and full_run['profile'] == PROFILE, + 'separate full-wrapper headline agrees with fresh finite checks') + require(full_run['executed_publication_commit'] == attempt['publication_commit'] + and full_run['executed_wrapper_sha256'] == attempt['wrapper_sha256'] + and full_run['wall_seconds'] == attempt['seconds'] + and full_run['exit_code'] == attempt['exit_code'] == 0 + and full_run['package_files_unchanged'] is attempt['package_files_unchanged'] is True, + 'separate full-wrapper execution identity') + for field in ('started_at', 'finished_at', 'environment'): + require(full_run[field] == attempt[field], 'full-wrapper index ' + field) + require(full_run['source_manifest_sha256'] == wrapper_result['source_manifest_sha256'] + and full_run['runtime_manifest_sha256'] == admission_result['package_manifest_sha256'] + and full_run['original_release_receipt_sha256'] == admission_result['release_receipt_sha256'], + 'full-wrapper source/runtime/terminal index') + for field, result in [('wrapper_stages', wrapper_result), ('admission_stages', admission_result)]: + require(full_run[field] == [{key: row[key] for key in ('name', 'exit_code', 'seconds')} + for row in result['stages']], 'full-wrapper index ' + field) + check_recorded_cache(fresh_evidence, native_receipt) + for field in ('cache_files', 'complete_native_files'): + mutant = copy.deepcopy(native_receipt) + if field == 'cache_files': + mutant[field] = {} + else: + mutant['providers']['base'][field] = {} + try: + check_recorded_cache(fresh_evidence, mutant) + except ValueError: + pass + else: + raise ValueError('incomplete recorded cache accepted: ' + field) + for field, path in [('fresh_evidence_sha256', 'full-admission/fresh-replay/EVIDENCE.json'), + ('evidence_checker_sha256', 'full-admission/fresh_replay_evidence.py')]: + require(full_run[field] == hashlib.sha256((HERE / path).read_bytes()).hexdigest(), + 'separate full-wrapper evidence binding: ' + field) + require(snapshot() == before, 'package files changed during replay') + receipt = { + 'status':'PASS_STAGED_RELEASE_RETIMING_T530_BOUNDED_CHECKS', + 'kappa':str(KAPPA), 'profile':PROFILE, 'stages':stages, + 'package_files_unchanged':True, + 'owner_semantic_gate_controls':5, + 'owner_gate_disable_sensitivity_controls':5, + 'rejected_recorded_cache_controls':['empty cache inventory', 'empty provider cache subset'], + 'scope':'Fresh finite local/operator, regenerated ownership/invoice, exact arithmetic and scoped packing checks; full native/controller/outer admission is retained evidence only in this command. Inherited general assumptions remain.'} + (out / 'RESULT.json').write_text(json.dumps(receipt, indent=2) + '\n') + print(json.dumps(receipt, indent=2)) + print('Fresh evidence: ' + str(out)) + + +if __name__ == '__main__': + main()