From b1eb3cec856e1f56a4ce70c583bce738223be6b2 Mon Sep 17 00:00:00 2001 From: yssite <175725951+yssite@users.noreply.github.com> Date: Tue, 20 Oct 2026 08:27:07 +0000 Subject: [PATCH 1/2] Bind PR4088 four-provider dispatch to inherited admission --- research/mixed-provider-admission/COVERAGE.md | 55 + research/mixed-provider-admission/EVIDENCE.md | 117 ++ .../NATIVE-OUTPUTS.json | 74 ++ research/mixed-provider-admission/README.md | 213 +++ .../mixed-provider-admission/SOURCES.json | 1176 +++++++++++++++++ research/mixed-provider-admission/TASK.json | 96 ++ research/mixed-provider-admission/VERIFY.json | 231 ++++ research/mixed-provider-admission/adapt.py | 154 +++ research/mixed-provider-admission/binding.py | 128 ++ .../mixed-provider-admission/challenge.py | 117 ++ .../independent_ledger.py | 312 +++++ .../native_outputs.py | 56 + research/mixed-provider-admission/replay.py | 250 ++++ research/mixed-provider-admission/sources.py | 21 + .../mixed-provider-admission/test_binding.py | 223 ++++ research/mixed-provider-admission/verify.py | 76 ++ 16 files changed, 3299 insertions(+) create mode 100644 research/mixed-provider-admission/COVERAGE.md create mode 100644 research/mixed-provider-admission/EVIDENCE.md create mode 100644 research/mixed-provider-admission/NATIVE-OUTPUTS.json create mode 100644 research/mixed-provider-admission/README.md create mode 100644 research/mixed-provider-admission/SOURCES.json create mode 100644 research/mixed-provider-admission/TASK.json create mode 100644 research/mixed-provider-admission/VERIFY.json create mode 100644 research/mixed-provider-admission/adapt.py create mode 100644 research/mixed-provider-admission/binding.py create mode 100644 research/mixed-provider-admission/challenge.py create mode 100644 research/mixed-provider-admission/independent_ledger.py create mode 100644 research/mixed-provider-admission/native_outputs.py create mode 100644 research/mixed-provider-admission/replay.py create mode 100644 research/mixed-provider-admission/sources.py create mode 100644 research/mixed-provider-admission/test_binding.py create mode 100644 research/mixed-provider-admission/verify.py diff --git a/research/mixed-provider-admission/COVERAGE.md b/research/mixed-provider-admission/COVERAGE.md new file mode 100644 index 0000000000..12096f4d47 --- /dev/null +++ b/research/mixed-provider-admission/COVERAGE.md @@ -0,0 +1,55 @@ +# Admission coverage and invalidation + +This map describes the exact PR4088 words and literal fill carried through the +retained PR4085 engine. Paths in the caller column are in the reconstructed +source or runtime tree. `adapt.py` records exact preimages and hashes for every +change. A completed discovery run is not strict admission. + +| Obligation | Actual caller and input binding | Evidence or rejection control | +| --- | --- | --- | +| Four local provider definitions, both orientations, shared helper order | Retained PR4088 `verify.py --controls`; `adapt.extend_source`; native full/canonical word identity | Exact source words, widths and profiles; changed word and omitted provider reject | +| Complete native source and execution products | `replay.bind_cache`, `native_outputs.authenticate_native`, then inherited cache/generated-identity checks | Exact compiler closure; `native`, `ledgers`, `local-replay`, `wrappers`, `phases`; eleven fixed scientific products per provider | +| Literal selector and per-call mixed dispatch | Inherited reconstruction and parent lift; `new/rebind.py` calls `mixed_binding.validate_rebind`; provider arguments enter both discovery and strict replay | All 3,240 calls have the exact provider, orientation and program; selector `(109*t) % 324 < 109`; omitted/same-width-wrong-program/coherent-dispatch mutations reject | +| Width, owner capacity and chronology | Retained PR4088 owner/operator gates; independent parent lift; inherited controller audit; `binding.account` | Each of 1,321,920 rows uses the selected width and strict window; compact prefixes, per-call non-aliasing, capacity and physical owner identity; width 7/8 adversarial fixture | +| Recomputed idle and complete paid profile | `validate_rebind` compares its complement accounting to `CONSTRUCTION.json` and `PLAN.json`; downstream invoice consumes rebound plan | Mixed idle `{3:22783,5:1625,48:138492}`, total mass 23,431,680; stale idle and changed complete profile reject | +| Phase and native endpoint evidence | Retained PR4088 `operator_verify.py --controls`; native exact recipe/endpoint checks; inherited local and Lemma-G checks for each provider and orientation | 10,416 all-character identities over 112 ports; exact phase mutant, omitted phase stage and false private-work erasure reject | +| Full stock/reserve/depth cost | Inherited `extension_blocknorm.py`, `blocknorm_certificate.full_stock_l2`, invoice, assembly and `independent_core`; exact rebound native ABI and per-call profile | 632 arbitrary columns, 91 zero buffers, 8 centers; actual local prefix 95 with reserve 128, active boundary depth 18, actual stock l2 1323 with cap 1330; actual global prefix 1478, charged payload 2048, physical inventory 323,069, physical row coefficient 19,549 below 20,161 | +| Discovery and frozen certificates | Inherited `replay.py --discover` runs bind, emit, audit, invoice, assembly, freeze, independent | Records actual mixed certificate; discovery alone is not accepted as release | +| Ordinary strict verification | Inherited `verify.py` and its strict `replay.py`, with four provider directories propagated to both calls | All inherited predicates retained; four-provider control targets: 201 assembly, 43 controller, 12 bit, 8 independent owner and 6 geometry controls | +| Outer admission | Inherited `outer/check_ledger.py`, `outer/independent_check.py`, top-level `verify_release.py` | Rebound complete paid profile and all ordinary prerequisites; reproducing the headline moment root alone is insufficient | +| Uniform all-size mathematics | Outside this finite engine | General generation/lifting, conditioning, fixed-tape realization and analytic transfer remain unresolved here | + +## Two corrected draft reuse gaps + +The separate adversarial context found two failures in early versions of this +successor, before publication. These are not attributed to PR4088 or PR4165. + +First, an existing preflight's successful source reconstruction did not by +itself authenticate the cached admission driver. The final gate requires the +exact inherited engine SHA256 +`e69184d235d8790a3c520977dd44dcfb73a99d56989825485f922ff61059c8b1`, +the exact 676-file source inventory, adapter bindings, three review stages and +all 95 retained engine/helper/native-cache inputs. A changed engine is rejected +before the source adaptation can consume it. + +Second, a native source hash and successful stage flags did not commit the +produced operators. The phase mutation changed a warp's left phase modulo 4 +and refreshed recipe references. The source's exact recipe checker rejected +the resulting operator. The final reuse gate compares every scientific product +to fixed commitments, including when all internal references are coherently +updated. It never derives an expected commitment from the supplied cache. + +The regression includes the latter mutation, missing-stage and endpoint +controls. The clean release records the actual native executions and inherited +controls separately; a regression success is not substituted for those runs. + +## Evidence categories + +* **Original authors' retained evidence:** unchanged THREE native results and + predecessor scientific input packages. +* **Campaign execution:** FOUR native replays, exact source reconstruction, + independent reviews and the extended inherited admission. +* **Separate AI checks:** an independent event/span accounting method and an + adversarial implementation review. These are not independent human review. +* **Not established here:** formal proof, a maintainer-reviewed new frontier, + or the complete integer-multiplication theorem. diff --git a/research/mixed-provider-admission/EVIDENCE.md b/research/mixed-provider-admission/EVIDENCE.md new file mode 100644 index 0000000000..cc001e9087 --- /dev/null +++ b/research/mixed-provider-admission/EVIDENCE.md @@ -0,0 +1,117 @@ +# Executed evidence and limits + +Scientific base: `12fa8c5c844be21bfefb38a19503fbd867a11244`. +Task: `supplier-boundary-audit`, priority revision 7, refined to the exact +PR4088/PR4165 four-provider admission handoff. The assignment and experiments +are deterministic; there was no randomized task lottery. + +## Baseline and bounded evidence + +The inexpensive `python3 -B scripts/research_baseline.py` passed +`PASS_RESEARCH_BASELINE_BINDINGS_ONLY`. This checks source bindings, not +mathematical acceptance. + +The retained PR4085 source preflight was executed freshly, redirecting only its +output location into a private external work directory. Its three independent +terminal, staged-entry and receiver reviews passed. It reconstructed exactly +676 source files, manifest SHA256 +`4116ef61479e509811b60b5fd4e84db8811dae079092f2f83bdcc2c80052c0da`, +and admission engine SHA256 +`e69184d235d8790a3c520977dd44dcfb73a99d56989825485f922ff61059c8b1`. +All 95 non-source archive inputs matched their retained inventory. + +An unmodified inherited owner reconstruction on the real PR4085 THREE control +reproduced its old invoice, including idle +`{3:22842,5:1890,48:138438}`. The independent mixed scan and the new binding +then reproduced the distinct PR4088 invoice in the README. PR4165's existing +five rejection controls also passed; its idle finding is predecessor credit. + +Both FOUR native sources were freshly executed through all five stages: +`native`, `ledgers`, `local-replay`, `wrappers`, `phases`. Initial executions +took 63.145 and 68.423 seconds. These are observed wall times, not a speedup +claim. Unchanged THREE and parent-admission evidence is explicitly authenticated +reuse, not a fresh cold replay of the entire historical ancestry. + +Executed bounded commands: + +```sh +python3 -B scripts/research_package.py --package research/mixed-provider-admission +python3 -O -B research/mixed-provider-admission/independent_ledger.py --controls +python3 -B research/mixed-provider-admission/challenge.py --work REPLAY_WORK --preflight PREFLIGHT +python3 -O -B research/mixed-provider-admission/challenge.py --work REPLAY_WORK --preflight PREFLIGHT +``` + +`REPLAY_WORK` and `PREFLIGHT` above denote the actual external output directories, +not repository dependencies. The registered command passed the 192 live pins, +14 semantic test methods, all 1,321,920 real rows, the optimized unit controls +and the independent event/span checker. The independent checker also passed +separately under `-O`, with an identical result object. + +The public actual-output challenges passed 18 cases in normal and optimized +Python. They include all four providers, changed phase with coherently rebound +references, skipped native stage, equivalent serialization/timing positives, +and a changed predecessor engine with its completion receipt rebound. + +`python3 -O -B research/mixed-provider-admission/replay.py --work NEW_DIRECTORY` +was rejected before creating the directory, with +`inherited admission requires assertions`. An optimized full release is not +reported as passing. + +## Development failures and corrections + +The first mixed wrapper attempt reached the new rebind gate and failed because +the inherited reconstructor serializes dispatch rows chronologically, while the +literal input table has a different row order. The correction compares the +table as a sorted relation while separately requiring a bijection and checking +every chronological call, program, orientation and width. A permutation +positive control and changed-selector negative controls cover this distinction. +No owner or accounting predicate was removed. + +A separate adversarial AI context demonstrated two draft reuse gaps: an +unbound cached admission driver and native output phases authenticated only by +successful flags. The fixed engine commitment and fixed scientific output +commitments close those demonstrated gaps. That context's 17 bounded follow-up +cases passed before the public four-provider challenge script was added. +These were defects in this unpublished draft, not new allegations about +predecessor mathematics. + +A preliminary metadata-only check rejected the draft outcome string +`in-progress`; it was corrected to the schema's `partial` state. The registered +metadata and pin checks then passed. + +## Full release + +The development replay has passed complete discovery, both outer ledger +checks, native/Lemma-G bindings and the ordinary source-review chain. The +strict and final outer release are still running at this development checkpoint. +No final admission is claimed from those intermediate stages. The final +publication gate additionally requires a fresh replay from a committed, +Git-free source export and inspected release receipts. + +## Review and overlap scope + +The 2026-10-20 08:19 UTC refresh still found canonical main at the scientific +base and priority revision 7. The helper covered all 294 open/draft PRs and +2,693 Discussion records with complete pagination and no warnings. The latest +50 updated PRs were also inspected for merged successors. + +PR4170's pooled-ceiling transfer and PR4171's independent moment/paid-power +arithmetic are complementary to this actual caller/ordinary/outer integration. +PR4169 audits a PR4100 CRT repair implication. No equivalent admission +successor or active claim was found in that coverage. This is an overlap check, +not a proof of novelty. Coordination remained local-only. + +## Checks outside this result + +No repository-wide historical suite, selected #1094 cold replay, Lean proof, +reference dense native backend, Windows execution, or hosted CI was run. +The selected construction is not changed. No complete all-size theorem, +independent human review or maintainer acceptance is established. + +The numerical environment is CPython 3.12.14 on Linux, NumPy 2.3.5, +SciPy 1.17.0, SymPy 1.14.0 and mpmath 1.3.0, all already installed. +The full driver checks these dependency versions before running. +The registered regression itself uses the Python standard library. + +Prepared for yssite with substantial OpenAI Codex assistance. Apache-2.0; +all predecessor credits and source-specific notices remain applicable. diff --git a/research/mixed-provider-admission/NATIVE-OUTPUTS.json b/research/mixed-provider-admission/NATIVE-OUTPUTS.json new file mode 100644 index 0000000000..a9d1938dd8 --- /dev/null +++ b/research/mixed-provider-admission/NATIVE-OUTPUTS.json @@ -0,0 +1,74 @@ +{ + "providers": { + "extra": { + "evidence": "retained PR4085 five-stage output", + "products": { + "CANONICAL-WORD.json.gz": "5fb702d44a4c8a785b1ee98e1c544756a9e821d0425d842cf8b882f10d445725", + "CLIFFORD-RECIPES.json": "3d90c6657966224c7b92e85dddec28633ef7fd56af9eafeeb44fef468605ff06", + "CLIFFORD-REVIEW.json": "edeafd04c696d4465d8c415a6bf6484821373b36b3d1b6eaf98509aafb7ae9b0", + "FULL-WORD.json.gz": "ef1ca8b7d40346fc2b3261b93dab740322064e47ea194b7d989bac3650e37255", + "INDEPENDENT-LOCAL-REPLAY.json": "dc28e816c3dfd5541a851a94b7f4cc903c1492c2528dba093a9aaeef111ee931", + "LOCAL-CHECKS.json": "cd992cd4e5705767e703bf21cb0f490b7df69cdd9178410977d1a1b670bb5c21", + "LOCAL-PROGRAMS.json.gz": "6a1adb398b66cc67dcaec8ecca788ca5fcf9e5ee3646a413e8a375f64824c177", + "RESIDUAL-ADAPTERS.json": "ab58505fae0a0c50aeae5dfbfff4d949a7f11625b8d088cf133ca70c69a7ae72", + "SCALAR-FRAME-AUDIT.json": "aa950de74f09508ca1706f7213d9ca45a28ba58318b740a5e00ae1e822c4e945", + "WARP-RECIPE-CHECKS.json": "c389582fc10b1461ad7846bbf20f39fc342cffefc905f5c39139193eec5067eb", + "WRAPPER-CHECKS.json": "63372859a1b3f6c44a61797d5c035ca1ef51d87833ee1e2e8d83d6e8030ac835" + }, + "word_sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + "extra-four": { + "evidence": "fresh five-stage campaign execution", + "products": { + "CANONICAL-WORD.json.gz": "6a3bbd63a229da14c5067fcf11f4abc99940651651e4567d870388dfe725e606", + "CLIFFORD-RECIPES.json": "d259754558d9616665069423644a71535b5c331a565c77211b9719f0a319d29d", + "CLIFFORD-REVIEW.json": "35e44002b64ce70766231eecb425864f746fbca40a797aa78c7f5e9d4a5ecd4c", + "FULL-WORD.json.gz": "c517eed7547e48ddc9f1f561e2fcc436b5999dab4aeb0cc634806c910d5444fc", + "INDEPENDENT-LOCAL-REPLAY.json": "90de0735f66c47134c12d72ff76acdc6f5796947dc581ed8bb626e9ae98551c2", + "LOCAL-CHECKS.json": "8e7857823c377bf9bfb246d8f29b5b79e6bc4547c10ab0901d07ab041103b5ec", + "LOCAL-PROGRAMS.json.gz": "a55f57ff6d2a9680c77930897372d0574c0222e29d9a88cfeadca4b023ee44f6", + "RESIDUAL-ADAPTERS.json": "ab58505fae0a0c50aeae5dfbfff4d949a7f11625b8d088cf133ca70c69a7ae72", + "SCALAR-FRAME-AUDIT.json": "4d3b08fd41116cbd8bb54aa3700dd9ac78dfde7b5ea053ef16f0f0dc64793e51", + "WARP-RECIPE-CHECKS.json": "8fd04798f9e526806d0b9e65ca6e30f042b06121ef5b389e59f4f37ec7aa90f5", + "WRAPPER-CHECKS.json": "63372859a1b3f6c44a61797d5c035ca1ef51d87833ee1e2e8d83d6e8030ac835" + }, + "word_sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a" + }, + "gauge44": { + "evidence": "retained PR4085 five-stage output", + "products": { + "CANONICAL-WORD.json.gz": "c3348706d4bbf01e7909a53efc677e51aa6ebc1286846c1fa72f3d6a85f2e5da", + "CLIFFORD-RECIPES.json": "bf88fc775e883227bbea9532ebf97df9e29576054dc0a893f8dc7fa1dc9744e2", + "CLIFFORD-REVIEW.json": "7cee799b7060f8b30e8415760770e8e73ca04cf6f966b0d008a897d7250b3d36", + "FULL-WORD.json.gz": "960867f94fe43489c5108eaff4cc159714a338a8a056837e5c497ded3d72c283", + "INDEPENDENT-LOCAL-REPLAY.json": "2ae9acb0162b4afedfa51bbfd1d7f6708009d76ad539907383ba10720c4382f7", + "LOCAL-CHECKS.json": "cd992cd4e5705767e703bf21cb0f490b7df69cdd9178410977d1a1b670bb5c21", + "LOCAL-PROGRAMS.json.gz": "6a1adb398b66cc67dcaec8ecca788ca5fcf9e5ee3646a413e8a375f64824c177", + "RESIDUAL-ADAPTERS.json": "f6e5a22cb2ee20196b4bd06510022dc65a63a7991f9bc46d2c27d2f97a2ffbdc", + "SCALAR-FRAME-AUDIT.json": "2d3794f1ad85bbfc1e1bf42d3b17f525d7856fb686557629c973636174b9f900", + "WARP-RECIPE-CHECKS.json": "e08d18d81ef1a425727d57f02046152d9c85dcc171073975d554758c4220658b", + "WRAPPER-CHECKS.json": "63372859a1b3f6c44a61797d5c035ca1ef51d87833ee1e2e8d83d6e8030ac835" + }, + "word_sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + "gauge44-four": { + "evidence": "fresh five-stage campaign execution", + "products": { + "CANONICAL-WORD.json.gz": "6206d8d304264c476738ed9ccfc0d15ca93f25dbb7cfab6e54ba9ca9c5559b84", + "CLIFFORD-RECIPES.json": "f99fef8a175ff4952bc546d4b09c78d45d0bda5540c391eba82d539e477a78ba", + "CLIFFORD-REVIEW.json": "ab86e9840b746ea3cc601d65676337609732b9aecc6e630cd82165231990d75f", + "FULL-WORD.json.gz": "cc8e27b329defb34e5fe89bc18f886a4c9ff0f99a08bd4f686f4298b0eb39e04", + "INDEPENDENT-LOCAL-REPLAY.json": "19789adff8d0550fd3fe6ece9e467302b738cd00f1e08e678511906aadaed3dd", + "LOCAL-CHECKS.json": "8e7857823c377bf9bfb246d8f29b5b79e6bc4547c10ab0901d07ab041103b5ec", + "LOCAL-PROGRAMS.json.gz": "a55f57ff6d2a9680c77930897372d0574c0222e29d9a88cfeadca4b023ee44f6", + "RESIDUAL-ADAPTERS.json": "f6e5a22cb2ee20196b4bd06510022dc65a63a7991f9bc46d2c27d2f97a2ffbdc", + "SCALAR-FRAME-AUDIT.json": "b354613cd4fe79eb2bae8f2aa5b4df9f3112aa1c9d09b5b9bb02273428eecf2e", + "WARP-RECIPE-CHECKS.json": "8175edef5e833dce1071c1360cb631419ee659b97a1f1f3649ec189374cc17be", + "WRAPPER-CHECKS.json": "63372859a1b3f6c44a61797d5c035ca1ef51d87833ee1e2e8d83d6e8030ac835" + }, + "word_sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95" + } + }, + "schema_version": 1, + "scope": "Fixed scientific output commitments for the exact four source words; timings and JSON/gzip serialization are not mathematical evidence. Reproduce via the original five native stages." +} diff --git a/research/mixed-provider-admission/README.md b/research/mixed-provider-admission/README.md new file mode 100644 index 0000000000..29da37eb1b --- /dev/null +++ b/research/mixed-provider-admission/README.md @@ -0,0 +1,213 @@ +# Four-provider ordinary admission for the retained PR4088 construction + +This successor connects the exact retained PR4088 mixed construction to the +PR4085 ordinary/outer admission engine. It extends the provider registry and +actual call dispatch, recomputes the idle invoice from each selected helper +width, and preserves the inherited release checks. It does not construct a new +supplier, change the selected frontier, or prove the all-size multiplication +theorem. + +The question is the revision-7 `supplier-boundary-audit` card's concrete missing +replay. The scientific baseline is +`12fa8c5c844be21bfefb38a19503fbd867a11244`; the exact consumed Git objects and +SHA256 pins are in [SOURCES.json](SOURCES.json). The task is refined to this +specific integration, as recorded in [TASK.json](TASK.json). + +## What changes + +The source adapter makes checked, literal substitutions in a fresh copy of the +inherited engine. Every preimage must match; it records each changed file's +before/after hash and each substitution's count in `ADAPTATION.json`. Frozen +predecessors are read without modification. + +* The registry contains `gauge44`, `extra`, `gauge44-four`, and `extra-four`, + with both orientations. The original literal selector and all 3,240 calls + remain bound to their actual native programs. +* The rebind gate checks all 1,321,920 owner rows against per-call widths and + programs. It requires the exact compact residual prefixes, chronology, + capacity and full provider set; it recomputes idle complements and the + complete paid profile. It does not use an averaged width vector. +* All four native closures enter the inherited provider, emission, audit, + invoice, assembly, independent, strict and outer paths. The coverage map is + [COVERAGE.md](COVERAGE.md). +* Optional reuse authenticates the exact predecessor engine and all 95 retained + non-source inputs, as well as its 676-file source inventory. Native reuse + authenticates the compiler, word, five-stage coverage and 11 scientific + output products per provider against [NATIVE-OUTPUTS.json](NATIVE-OUTPUTS.json). + +## Accounting boundary + +PR4165 already identified the different mixed idle invoice. We credit that +finding and carry it into the actual admission caller rather than claim it as +a new result. Original helper 601 (owner helper index 367, native register 591) +has width 8 for THREE and width 7 for FOUR, in both orientations. + +| Quantity | Exact value | +| --- | --- | +| Calls `(gauge44, extra, gauge44-four, extra-four)` | `(1040, 1110, 528, 562)` | +| Mixed idle profile | `{3: 22783, 5: 1625, 48: 138492}` | +| Complete paid profile | `{1: 8060060, 2: 2310120, 3: 751813, 4: 327210, 5: 66425, 8: 25920, 48: 138492}` | +| Profile mass | `23431680 = 65088 * 360` | +| Complete physical inventory | `896 * 360 + 408 + 8 + 91 + 2 = 323069` | +| Actual global prefix | `95 + 37 + 18 + 1323 + 1 + 4 = 1478` | +| Charged payload and physical row | `2048` bits; coefficient `19549 < 20161` | + +The first distinguishing owner row is index 367. If call zero is coherently +changed from FOUR to THREE, the later shared-owner row 29,389 has offset 7 but +requires 8. This is a useful negative control because counts and local program +metadata can be updated consistently while the real chronology still fails. + +PR4088's already published root enclosure is not a new result of this package. +The selected conditional kappa remains `0.001672660197076918` (#1094). +The actual native local prefix is 95, below the inherited reserve 128. +The stock l2 calculation gives 1323, below its cap 1330. The inherited block-norm +and independent invoice callers recompute these values on this physical +inventory; the caps do not replace the actual measurements. + +## Native evidence and invalidation + +Successful status flags and a source-word hash do not authenticate a native +output. During adversarial review of this draft, changing the first warp's +left phase modulo 4 while rebinding recipe references exposed that gap. The +original exact recipe checker rejects the changed operator; the final reuse +gate also rejects it against a fixed scientific product commitment. A missing +phase stage and a false private-work-erasure claim are rejected separately. + +The commitments canonicalize JSON and decompressed gzip payloads. They omit +only the root elapsed-time `seconds` fields in `SCALAR-FRAME-AUDIT.json` and +`CLIFFORD-REVIEW.json`; those fields must still be finite nonnegative numbers. +References to compressed words/programs and serialized recipes are checked +against the actual referenced bytes before normalization. All other scientific +fields, missing/extra products, compiler changes and word changes invalidate +reuse. Reformatting or recompression with corresponding valid references is +allowed. + +The FOUR products were executed afresh during this campaign. The unchanged +THREE products are authenticated retained PR4085 evidence. A run records +`executed_by_this_driver`, `explicitly_supplied_cache`, or `retained_PR4085` +for each provider. These labels distinguish fresh execution from reuse. + +## Reproduce + +From the repository root, the bounded standard-library regression is: + +```sh +python3 -B scripts/research_package.py --package research/mixed-provider-admission +``` + +Its three registered commands can also be run directly: + +```sh +python3 -B research/mixed-provider-admission/verify.py +python3 -O -B research/mixed-provider-admission/test_binding.py +python3 -B research/mixed-provider-admission/independent_ledger.py --controls +``` + +The first reports `PASS_FOUR_PROVIDER_BINDING_REGRESSION`, including the exact +source pins, semantic controls and all real owner rows. This bounded regression +does not run or claim the full admission. +The last reports `PASS_INDEPENDENT_MIXED_LEDGER`: a separate implementation +enumerates binary spans and reconstructs observation windows from schedule +events without importing the original owner walker or the new binder. + +The full replay requires Python 3.12 and the pinned numerical environment +used by the inherited engine: NumPy 2.3.5, SciPy 1.17.0, SymPy 1.14.0 and +mpmath 1.3.0. The driver installs nothing. Use a new directory outside the +checkout: + +```sh +python3 -B research/mixed-provider-admission/replay.py \ + --work /tmp/mixed-admission-fresh +``` + +The expected final status is +`PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE`. The driver first runs +the three retained PR4088 word/owner/operator gates, reconstructs the exact +PR4085 source through its independent reviews, runs both FOUR native replays, +and invokes the extended inherited engine. The inherited engine requires +assertions; the full driver explicitly rejects optimized Python. + +`--checked-preflight`, `--four-native-base`, and `--four-native-extra` accept +previous outputs only after the binding checks described above. They are useful +for continuing an interrupted replay, not an exemption from those checks. +`--prepare-only` deliberately reports a non-admitted preparation status. + +After a full or prepared run, the actual cache/engine challenges can be run +without repeating expensive admission: + +```sh +python3 -B research/mixed-provider-admission/challenge.py \ + --work /tmp/mixed-admission-fresh +python3 -O -B research/mixed-provider-admission/challenge.py \ + --work /tmp/mixed-admission-fresh +``` + +They report `PASS_ACTUAL_REPLAY_CHALLENGES` for 18 positive/negative cases. +Supply `--preflight PATH` if the replay used an external checked preflight. +Only temporary copies are mutated. The recorded environment is Linux; the driver +cleans its child process groups on POSIX. Windows execution is not claimed. + +Actual executed commands, outcomes, environments and unrun checks are recorded +in [EVIDENCE.md](EVIDENCE.md). Source commitments bind inputs, not proof truth +or authorship. + +## Scope and limitations + +This is author-produced finite verification with separate AI adversarial checks. +A second context used an event-based scanner and explicit small binary spans +to check the mixed owner widths and invoice independently of the original +owner walk. That corroboration is neither independent human review nor formal +verification. + +The inherited native and ordinary/outer predicates remain the acceptance +contract; this package does not replace them with a permissive new checker. +Their successful finite execution does not discharge uniform generation, +arbitrary-size lifting, conditioning/precision, fixed-tape realization, or the +complete analytic transfer theorem. It does not assess PR4100's separately +proposed written all-size argument. Archival source-retention merges and +author receipts are distinct from maintainer scientific review. + +## Open next questions + +1. **Independent scientific review of this finite integration.** A maintainer + can execute the full command on the committed tree, inspect the exact + adaptations and challenge the coverage map before considering selection. + Independent review is required beyond any author replay; this package makes no + selected-frontier change. +2. **One caller-bound all-size implication.** Finite admission leaves the + uniform compiler/precision/fixed-tape transfer question open. The first + feasible step is to consult the current `uniform-transfer-audit` card and + PR4100/PR4169 handoffs, then pin one real caller and quantified proposition. + A general argument, rather than another evaluation of this root, is needed. + +The structured questions and their blockers are also in [TASK.json](TASK.json). + +## Provenance and credit + +* PR4088, Cinna Davis (`1337isnot1337`): + `72d7efc181edb21806a878f174847c96dd410ab0`, the mixed construction, exact + selector, four local words, owner/operator evidence and published profile. +* PR4165, `unpaidmoon`: + `430072ee4130b58c1dd952cb37fd81759675a118`, mixed idle-rebind audit and + concrete admission handoff. +* PR4085, David Ganz (`zxv`): + `c5854c77620723aae6914c32122870519a6f820d`, repaired operator composition + and predecessor release/admission. +* PR4076, Rohan Arun: + `9744f9df268590295a9872b1952c695a678192b9`, triple-entry fill and source + reconstruction; PR3945, Dugongue: + `91f81d131252db704f945891da1ea54e29d46b8b`, predecessor release machinery. +* Tekalign (`tekuuu`), including PR2768's exact sparse native execution and + the retained owner/native checking tools. Their original notices, as well + as the credited Clifford and earlier supplier lineage, remain in the source. + +The retained archive SHA256 is +`e74d545c18f77b7a9b8f0cc3d4901a87bb686888edaf3e41b30e5b2748751041`. +All predecessor notices and licenses remain in their source packages and are +preserved by reconstruction. PR4170's pooled-ceiling transfer audit addresses +a distinct obligation. This does not repeat yssite's PR959, PR1558 or PR2377. + +Prepared for yssite with substantial OpenAI Codex assistance in investigation, +implementation, documentation and two separate AI checking contexts. +New work is Apache-2.0; predecessor attribution and source-specific notices +remain applicable. diff --git a/research/mixed-provider-admission/SOURCES.json b/research/mixed-provider-admission/SOURCES.json new file mode 100644 index 0000000000..163f13ee2d --- /dev/null +++ b/research/mixed-provider-admission/SOURCES.json @@ -0,0 +1,1176 @@ +{ + "schema_version": 1, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "research/kappa-adaptive-continuation/admission/receiver_share.py", + "usage": "input", + "git_blob": "0f1491d8c6df7b59e55ba71230daa2d54447e9b3", + "sha256": "6ef3255e91f42cb78eb194c761c02568e0230a9cfab40387f257d7a4bd38ccc4" + }, + { + "path": "research/kappa-adaptive-continuation/admission/review_receiver_share.py", + "usage": "input", + "git_blob": "dcc11d429ce0aef7aa9700a9c31994c8a77e1dfe", + "sha256": "bbf28e17a657b8d1eaf63f33d811682720afb393ee2ab9a4bb46661fef1ed996" + }, + { + "path": "research/kappa-adaptive-continuation/runtime-repair/FIXTURES.json", + "usage": "input", + "git_blob": "ded4702868432d304851486f602a8db0d57f6fbc", + "sha256": "4f6185125ddb38b7ab02a349829aae434e7707e804ca8c6c4ab8c086cd63635e" + }, + { + "path": "research/kappa-adaptive-continuation/runtime-repair/audit_fast.py", + "usage": "input", + "git_blob": "086fb580b25d533570b50dfd1f806e8309d5e4ea", + "sha256": "30a39a3612efde96a0db189c14053afe5e012e56de1a89863596a078a8b64381" + }, + { + "path": "research/kappa-adaptive-continuation/sources/PR3815/research/staged544-producer-return/REPLAY-INPUTS.tar.gz", + "usage": "input", + "git_blob": "5e45113fdc6eaf8d4a07aa1f7c0f9b3b6991ca1c", + "sha256": "e74d545c18f77b7a9b8f0cc3d4901a87bb686888edaf3e41b30e5b2748751041" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/candidate/BORROW-WORD-43base.json.gz", + "usage": "input", + "git_blob": "137793e275870db2161048405017b83dcc1824ee", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/candidate/BORROW-WORD-43extra.json.gz", + "usage": "input", + "git_blob": "7cce921b20dc0504cea954ab3297c5b55a9468dc", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/candidate/CONSTRUCTION.json", + "usage": "input", + "git_blob": "1614c1c40d4804cf70d3c4a90896d20c261f59a1", + "sha256": "e0a3f13504304147f4049757016a494c15beda82ed751439f05039f88a0dd891" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/RESULT.json", + "usage": "input", + "git_blob": "135cd88e44786e26bcde18f67398a186653293ef", + "sha256": "dc7d4049460e2c754b6319d721efcad9a8bad7249aea130c19eabc8f9193975e" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/STEPS.json", + "usage": "input", + "git_blob": "9d585f31444582f3254f8e10e8f76ba5224b4508", + "sha256": "31896a06049f951fc25db1338888a743c1c73cf1a6c44212dbc21789ceaefeb0" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CANONICAL-WORD.json.gz", + "usage": "input", + "git_blob": "40d74e5638d08ccb0b8270e6c47843cc45762c72", + "sha256": "f07fae1011160b53e2df1f3135465db1277a093319de2a1da52d648f00a39542" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CLIFFORD-RECIPES.json", + "usage": "input", + "git_blob": "9dcdc26825cf00d00ab7420156a747d4279c3bb3", + "sha256": "bf88fc775e883227bbea9532ebf97df9e29576054dc0a893f8dc7fa1dc9744e2" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CLIFFORD-REVIEW.json", + "usage": "input", + "git_blob": "494dd79f94634a84c1bcd7a7ef70ceaa209454db", + "sha256": "9d5316a1465a3eb2c62fac76c291394c0401c34a96fd8b94863d662b16a64552" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/FULL-WORD.json.gz", + "usage": "input", + "git_blob": "137793e275870db2161048405017b83dcc1824ee", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/INDEPENDENT-LOCAL-REPLAY.json", + "usage": "input", + "git_blob": "7f9a60816cdc2717d0c392de4496b28e675d50c4", + "sha256": "1b9167ef68707cddad4b781e37858cfb5205d377670365019b8de26fceeb1891" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/LOCAL-CHECKS.json", + "usage": "input", + "git_blob": "f89b2988e31e510d9e2c6877bd0fb828d8e503d5", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/LOCAL-PROGRAMS.json.gz", + "usage": "input", + "git_blob": "9e67bc42952b2c65ed8e070cf81582bd78a5f550", + "sha256": "67d700388eaa162e008e7d6f588278fb429872cfc5b56b7dcddc9f576316bc72" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/RESIDUAL-ADAPTERS.json", + "usage": "input", + "git_blob": "8eaa8cd45ee42162008586bc72e3ca8164f16be1", + "sha256": "4711da8324861b5ab4d50dbcf1404c7f14c1b20b87bb750959912ff5da1c2e76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/SCALAR-FRAME-AUDIT.json", + "usage": "input", + "git_blob": "04d1e367f4e96770b5bde9b84fd5369633a6f5a1", + "sha256": "23163ff2f94a4920e5fca35fb6f0de108f710e7b09cc13e7c2796ad693a2b497" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/WARP-RECIPE-CHECKS.json", + "usage": "input", + "git_blob": "9e3afae3bc1dff0b5a12a87ba8b13aa003cb1219", + "sha256": "7e3bb0f46320f243cd89c97c60af5b29ac82a79293463afae5a178f8938ebda0" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/WRAPPER-CHECKS.json", + "usage": "input", + "git_blob": "04a12a3f688315ce6c76369223db11b7c5abd198", + "sha256": "c3c925cfe5a3e2e4cb21fba12a60d8ba2b84ab568d27bf26691f92bf48a0d681" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/SPARSE-NOTICE.md", + "usage": "input", + "git_blob": "a3b31e157fcb9f8978040535a98d30a640509424", + "sha256": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/SPARSE-PROOF.md", + "usage": "input", + "git_blob": "bbd59904396b5978c15e38720d0c0ad7a9ac5398", + "sha256": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/sparse_state.py", + "usage": "input", + "git_blob": "ca39f73494e11bf0a860c51b8d711bec48ec0842", + "sha256": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/tables.py", + "usage": "input", + "git_blob": "5d546d8a05f6025d58a5133fa0d67ce134993013", + "sha256": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/NOTICE-PR2226.md", + "usage": "input", + "git_blob": "a14b299ef55c5581166988aa78baba329cebde04", + "sha256": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_adapters.py", + "usage": "input", + "git_blob": "82beaa9c1d13bcd5f79d0a5e10e8a10733eac347", + "sha256": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_audit_local.py", + "usage": "input", + "git_blob": "912a0c447c2ad34eb5ef3270e04ad0a73ca20a55", + "sha256": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_check_recipes.py", + "usage": "input", + "git_blob": "6db8ad50eb2562700432a852501aad720aa34816", + "sha256": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_emit.py", + "usage": "input", + "git_blob": "6d47f63ab7a533941b3881bbfd3ae4dac5f76932", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_gauss.py", + "usage": "input", + "git_blob": "1ff29dfb244e2114de8e586a450ae9fb70308d58", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_phases.py", + "usage": "input", + "git_blob": "99f351785ebca5fbf3336bedcd7b48bac9c255e5", + "sha256": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_tamper.py", + "usage": "input", + "git_blob": "a519863fd890ee1200043ad2ae4e307b95a1634e", + "sha256": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_transport.py", + "usage": "input", + "git_blob": "08248542b18864c94a5ac050c8669f68519838e1", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "usage": "input", + "git_blob": "5ea70357a04d083dba066fbc5c809a5736d8edd6", + "sha256": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/pr2226_operators.py", + "usage": "input", + "git_blob": "5c4fbe8cceedd769a1c367a31cd0beeae2175dc1", + "sha256": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/pr2226_replay.py", + "usage": "input", + "git_blob": "1bbe590206644e68d7654c23f0b46d5a18836e34", + "sha256": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/run_native_borrow.py", + "usage": "input", + "git_blob": "942310947b4d7016ed7a5d23a87e9ae98e0427d6", + "sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/RESULT.json", + "usage": "input", + "git_blob": "9f9d6a9c4116610a76abe8eeb6394317ac9c524c", + "sha256": "e18a62a1019dac507c278fda6342dbb38afabace8f48a8d3c45a8f1e9b2d7bce" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/STEPS.json", + "usage": "input", + "git_blob": "c93596421fdbf2c41e524eb1c0c7660f58cc362d", + "sha256": "0bad75c89a69637a1c9b98824da183243c584e07e0eb76ce986420384a7246c8" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CANONICAL-WORD.json.gz", + "usage": "input", + "git_blob": "2af11b77b0d1f9ed54584fb1ec63f808d08071e6", + "sha256": "882271d70602354cbada8d77f479703ccc6c47e689e8ccd91f9e4c87de0f4379" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CLIFFORD-RECIPES.json", + "usage": "input", + "git_blob": "3a8e83134093221f7e7676ae4d432ef858856885", + "sha256": "3d90c6657966224c7b92e85dddec28633ef7fd56af9eafeeb44fef468605ff06" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CLIFFORD-REVIEW.json", + "usage": "input", + "git_blob": "00a86cdddcad95817b87322c13e22a0dd5faed22", + "sha256": "81c01d4b007bb720311dbdbbc63df673fdaf7baba707b360bbecc4b9cb6ee7b0" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/FULL-WORD.json.gz", + "usage": "input", + "git_blob": "7cce921b20dc0504cea954ab3297c5b55a9468dc", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/INDEPENDENT-LOCAL-REPLAY.json", + "usage": "input", + "git_blob": "0b69f5f67e2e26f531c6685db8da43ee911eb347", + "sha256": "753c950d3273bba4e7ff560000d84aaf928d24448e899e6f75e0166b7989f508" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/LOCAL-CHECKS.json", + "usage": "input", + "git_blob": "f89b2988e31e510d9e2c6877bd0fb828d8e503d5", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/LOCAL-PROGRAMS.json.gz", + "usage": "input", + "git_blob": "9e67bc42952b2c65ed8e070cf81582bd78a5f550", + "sha256": "67d700388eaa162e008e7d6f588278fb429872cfc5b56b7dcddc9f576316bc72" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/RESIDUAL-ADAPTERS.json", + "usage": "input", + "git_blob": "5ecdb02d3da25d5854be7574cdd53bed2d286ac6", + "sha256": "e14450952c98caa3f948527a3dd107555381eed6a08dd041bc859d142aa3522d" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/SCALAR-FRAME-AUDIT.json", + "usage": "input", + "git_blob": "4dde678a2fd312ed567404cb21f757a248217acb", + "sha256": "9100f0387118988d81fa47740d4bd47892b13400c36ea63d43cbe4aeba38a4a1" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/WARP-RECIPE-CHECKS.json", + "usage": "input", + "git_blob": "077da2ebaac823cd7b69568d265652496cf2fbd1", + "sha256": "e037ea86e1e2902d6c03885ae8e332e4afe48d27d6200923b9c71498b12953d3" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/WRAPPER-CHECKS.json", + "usage": "input", + "git_blob": "04a12a3f688315ce6c76369223db11b7c5abd198", + "sha256": "c3c925cfe5a3e2e4cb21fba12a60d8ba2b84ab568d27bf26691f92bf48a0d681" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/SPARSE-NOTICE.md", + "usage": "input", + "git_blob": "a3b31e157fcb9f8978040535a98d30a640509424", + "sha256": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/SPARSE-PROOF.md", + "usage": "input", + "git_blob": "bbd59904396b5978c15e38720d0c0ad7a9ac5398", + "sha256": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/sparse_state.py", + "usage": "input", + "git_blob": "ca39f73494e11bf0a860c51b8d711bec48ec0842", + "sha256": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/tables.py", + "usage": "input", + "git_blob": "5d546d8a05f6025d58a5133fa0d67ce134993013", + "sha256": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/NOTICE-PR2226.md", + "usage": "input", + "git_blob": "a14b299ef55c5581166988aa78baba329cebde04", + "sha256": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_adapters.py", + "usage": "input", + "git_blob": "82beaa9c1d13bcd5f79d0a5e10e8a10733eac347", + "sha256": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_audit_local.py", + "usage": "input", + "git_blob": "912a0c447c2ad34eb5ef3270e04ad0a73ca20a55", + "sha256": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_check_recipes.py", + "usage": "input", + "git_blob": "6db8ad50eb2562700432a852501aad720aa34816", + "sha256": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_emit.py", + "usage": "input", + "git_blob": "6d47f63ab7a533941b3881bbfd3ae4dac5f76932", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_gauss.py", + "usage": "input", + "git_blob": "1ff29dfb244e2114de8e586a450ae9fb70308d58", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_phases.py", + "usage": "input", + "git_blob": "99f351785ebca5fbf3336bedcd7b48bac9c255e5", + "sha256": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_tamper.py", + "usage": "input", + "git_blob": "a519863fd890ee1200043ad2ae4e307b95a1634e", + "sha256": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_transport.py", + "usage": "input", + "git_blob": "08248542b18864c94a5ac050c8669f68519838e1", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "usage": "input", + "git_blob": "5ea70357a04d083dba066fbc5c809a5736d8edd6", + "sha256": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/pr2226_operators.py", + "usage": "input", + "git_blob": "5c4fbe8cceedd769a1c367a31cd0beeae2175dc1", + "sha256": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/pr2226_replay.py", + "usage": "input", + "git_blob": "1bbe590206644e68d7654c23f0b46d5a18836e34", + "sha256": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/run_native_borrow.py", + "usage": "input", + "git_blob": "942310947b4d7016ed7a5d23a87e9ae98e0427d6", + "sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/run_release.py", + "usage": "input", + "git_blob": "a14a26a95e02899b05d61a510e86ee461614e2d5", + "sha256": "262e914eca3d0e97567786fe94cb25fb1698c52e08785fd4a2581020c4af26dc" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/full_replay.py", + "usage": "input", + "git_blob": "492998766fc9aedfa1f1c0c337b2d4abe10ab707", + "sha256": "6f6b5adccb29d29a4b7890c91180a7ecd9f54ee04007cf9e0ea06fbea42b5c0e" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/NEW-base.json.gz", + "usage": "input", + "git_blob": "806784bf99d9d15004d2d227d06268556a0726c8", + "sha256": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/NEW-extra.json.gz", + "usage": "input", + "git_blob": "c531be7383ad3ba941600c7ced14e5e10d6d1c67", + "sha256": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/PR3682-CLAIM.json", + "usage": "input", + "git_blob": "6f05d13347e650467b561f1861e6266ffc9ef15c", + "sha256": "c7455323c62a5b1d5c9ceef07a305a5758df6971ac8f88e2be5223eb5f4c7553" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/PREDECESSOR.json", + "usage": "input", + "git_blob": "1c96d298a534aa98325592a9487fea79aebec596", + "sha256": "727691274be6f91059c763dfa8206f7bca4516c5acf4703da403789a49b5e1e7" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/SOURCE-PATCHES.json", + "usage": "input", + "git_blob": "e45a06597117509656383c7ac3c49c1c0620b93b", + "sha256": "4b6b1ac15742264f1d6d8047d975fd5d05fc63db61358b3bacf1c1c47ee71428" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/SOURCES.json", + "usage": "input", + "git_blob": "fda8edb01adffae448457341f10ea0a73848079c", + "sha256": "8bdda4822009d6e5f1d6bd948a8f89154780a5721dca366c56deb75019bb268b" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/old-NATIVE-base.json.gz", + "usage": "input", + "git_blob": "3424e3b0fb72c12dd244c41ad3ba44b4875ce5a4", + "sha256": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/old-NATIVE-extra.json.gz", + "usage": "input", + "git_blob": "6c1e9149b26394607cca9d4765ab8d3c5fc029bb", + "sha256": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/terminal_applier.py", + "usage": "input", + "git_blob": "ee1f16607ca4b5dc29321483e9a5dc63371085be", + "sha256": "69bbfc0414324593e98112af7a8db6549315badb8aa7adb5ca05419214849c56" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/terminal_review.py", + "usage": "input", + "git_blob": "5ea426d4983e1f70b23f451d7d3f29a93aabcf56", + "sha256": "fff028de30e9fb06d6d75efc6fdd6e94ead6a88823efa07d3e7cd177dcd94acd" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/NEW-base.json.gz", + "usage": "input", + "git_blob": "dcc0374b5c822d544a4ecf19d00635c7117d82c9", + "sha256": "8159c67d29ab58efe546ebc4ce20872421996cc71b5f17737ff8b36cbc76d148" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/NEW-extra.json.gz", + "usage": "input", + "git_blob": "990c54caeeb4fb344de622de98d97e107ec67ed5", + "sha256": "0147e6b30ef328e227e89113323eb0d02d116e125b0e7c99a00ea4f2652dcc80" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/OLD-base.json.gz", + "usage": "input", + "git_blob": "806784bf99d9d15004d2d227d06268556a0726c8", + "sha256": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/OLD-extra.json.gz", + "usage": "input", + "git_blob": "c531be7383ad3ba941600c7ced14e5e10d6d1c67", + "sha256": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/ENTRIES.json", + "usage": "input", + "git_blob": "f67031d3e12f7ca91075ba2b2fdeeb99a3de5873", + "sha256": "00071bc2e54bf5fd05a6aac9292a3861087e72898d86d1f6f7bbda65b07cfbda" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/RECORD-base.json", + "usage": "input", + "git_blob": "64bcb35908f140bec80c73a2f4ba429be14ae225", + "sha256": "6e2f3ef76d90086784db92a7e3b0ac23893dd60750effe79287fa59c48b6bc99" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/RECORD-extra.json", + "usage": "input", + "git_blob": "faf479d61f57b88ced9b434d188a31f6ca5c3f2c", + "sha256": "e92568c62db0f220096870c2a01cd8c313497953bc9cff5f2c087fe9a6875109" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/make_record.py", + "usage": "input", + "git_blob": "7dfaaaa1b084e5971e03ce2586fc5d5ddd21c760", + "sha256": "70030e184e9c3d41169cabf5f6a07d6ec10590ce384ebfeabbeba7253d85404b" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/staged_entries_applier.py", + "usage": "input", + "git_blob": "358ba3dcd984a19799bc9ed47e3ed81d1d111043", + "sha256": "41f889bcdf6ef4e8033ac45bf4d2c0fdb20d7b51dd194806d79bba789e207661" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/staged_entries_review.py", + "usage": "input", + "git_blob": "3ee17a1e5fbdfcdf14a481e35c69ab0a0615e5d9", + "sha256": "dd104d15719ae181fde3d6c93f210b09ddffe0e0ca16b07c85b4ebaf75641d91" + }, + { + "path": "research/staged544-mixed-fourth-entry/.gitattributes", + "usage": "input", + "git_blob": "fc06868c3d5cb57faf9146b154cb3961d5660360", + "sha256": "04e5e0efa0141765d3c58422bbc347caf588ab7e70c3429e63f78d892038a1d7" + }, + { + "path": "research/staged544-mixed-fourth-entry/EXPORTED-SOURCES.json", + "usage": "input", + "git_blob": "5d27e2d4f864e6d4a26be3af2d2131bd3000545a", + "sha256": "59b692adb4ed3c8caed033d380c23e2e2cf2a1547323b88f97b4a4ad7453141b" + }, + { + "path": "research/staged544-mixed-fourth-entry/INPUTS.json", + "usage": "input", + "git_blob": "5898f7e11f827baa4122fa17d4aa251b990efff6", + "sha256": "43ab5cd305ec23dbc63accaffb0dca8bdf201130bff89f5e807d919c5118fc98" + }, + { + "path": "research/staged544-mixed-fourth-entry/MANIFEST.json", + "usage": "input", + "git_blob": "768091ef74f2212027222b3e5af84365694e4780", + "sha256": "f2f52b40e4b0dda45777fdeecf2267679da0d36be69daf467adc1740f4951b9d" + }, + { + "path": "research/staged544-mixed-fourth-entry/NOTICE.md", + "usage": "input", + "git_blob": "56c36d6f5900b2d6cd3169c8996b7b2018649fe9", + "sha256": "1ba00cad41d7a1333da420bd23f078d09e28b7aa17cf5a8a89e54dd207123971" + }, + { + "path": "research/staged544-mixed-fourth-entry/PROOF.md", + "usage": "input", + "git_blob": "9c665b0442774b8c84116f51c3261d50dd5f8d2c", + "sha256": "3aa03a9ba64422474890c137d2b10ef830464712830fd469fe1b0e9538b24ebb" + }, + { + "path": "research/staged544-mixed-fourth-entry/README.md", + "usage": "input", + "git_blob": "29aac74f7ba382aad85189e5e297bf356414e2f9", + "sha256": "98b53ad6e6ee7ef7ba106e68e7a2a77d8f5a9823202cb3725cf101f5901e2d6f" + }, + { + "path": "research/staged544-mixed-fourth-entry/RESULT.json", + "usage": "input", + "git_blob": "1174e25e2ef8f8bc9a0815c43ba5d64c8af08349", + "sha256": "6346ee768637aa9a1891d1d61d800d640235420b320fb7e659d1bf664ec42b3d" + }, + { + "path": "research/staged544-mixed-fourth-entry/SOURCES.json", + "usage": "input", + "git_blob": "a604c6a640acd80f08b7378a00739eff45ac0830", + "sha256": "53211542c4e92eee92458f2b313d0bf6c1706e56dada488c604e93a0760fec43" + }, + { + "path": "research/staged544-mixed-fourth-entry/TASK.json", + "usage": "input", + "git_blob": "77f24f0c846cb00a702cb7aa06c31c02a29198fd", + "sha256": "8c34b11a10f0317dd4a4dc765b036a2231cee55cb44fc0e1e59fb64e11326a13" + }, + { + "path": "research/staged544-mixed-fourth-entry/VERIFY.json", + "usage": "input", + "git_blob": "f8b3c9ab743525816d1a2f35ca437b7d3674d07a", + "sha256": "2814773f90ee84a1c367dfec1ee85ec4f001ed100469f354d0464e7952303e9d" + }, + { + "path": "research/staged544-mixed-fourth-entry/checks/inherited_frames.py", + "usage": "input", + "git_blob": "a87dde507358dd3b60c0d80d6216ef16123c56ca", + "sha256": "25ba8774b1be4f0be27abeac94232eb8db657f02d7830bd93208c53649e65a04" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-CANONICAL-base.json.gz", + "usage": "input", + "git_blob": "77ee265be3cc15d76054c023d825578d9c62fa5c", + "sha256": "bff67890d0d350646d11f45aa1b098d6a415b1850b4982e8a05b4c146d247eda" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-CANONICAL-extra.json.gz", + "usage": "input", + "git_blob": "bc6433bbf5c355d53eec218448fa49c5f4d45346", + "sha256": "e0c473d62127a09cb3cbf451564dbdd19c0c10f1674dab0575e65251aa5e1e3c" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-LOCAL-base.json", + "usage": "input", + "git_blob": "7de151df4cf0639ee782bc7f32ba51f983b814f8", + "sha256": "51713c6bb1909bc90994d54467baac08bafd849945a0e246f0c96dbf3658307b" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-LOCAL-extra.json", + "usage": "input", + "git_blob": "7de151df4cf0639ee782bc7f32ba51f983b814f8", + "sha256": "51713c6bb1909bc90994d54467baac08bafd849945a0e246f0c96dbf3658307b" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-PHASES-base.json", + "usage": "input", + "git_blob": "22fd191b74aadd219bc4095633ac552244b1083b", + "sha256": "e273538de7957b959c40f593c4aad5e8e3d81d83d662fe2895c17770c5fad8bd" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-PHASES-extra.json", + "usage": "input", + "git_blob": "f99019e597d38749594b06c7a47847bb78a40bc8", + "sha256": "c8f744c62670ad7d76faf4dee65e2f708f4036953041e72383929c7d0b32ec38" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-base.json", + "usage": "input", + "git_blob": "f6b24b3310609e9a862e6877a1412ce5d4d23120", + "sha256": "c422d41b5b316fe6823012ca31a13bd3c2c4a4a17c3712c36ce0156f311e5ce9" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-extra.json", + "usage": "input", + "git_blob": "fe667708d7c878e80a6efdb6874496864ca67136", + "sha256": "2b6f90f3d00e7b2723fa12c6bd8e8f0d2881854b3ef625b0fd37ed6f51e2bfa4" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-CANONICAL-base.json.gz", + "usage": "input", + "git_blob": "40d74e5638d08ccb0b8270e6c47843cc45762c72", + "sha256": "f07fae1011160b53e2df1f3135465db1277a093319de2a1da52d648f00a39542" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-CANONICAL-extra.json.gz", + "usage": "input", + "git_blob": "2af11b77b0d1f9ed54584fb1ec63f808d08071e6", + "sha256": "882271d70602354cbada8d77f479703ccc6c47e689e8ccd91f9e4c87de0f4379" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-LOCAL-base.json", + "usage": "input", + "git_blob": "f89b2988e31e510d9e2c6877bd0fb828d8e503d5", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-LOCAL-extra.json", + "usage": "input", + "git_blob": "f89b2988e31e510d9e2c6877bd0fb828d8e503d5", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-NATIVE-base.json", + "usage": "input", + "git_blob": "135cd88e44786e26bcde18f67398a186653293ef", + "sha256": "dc7d4049460e2c754b6319d721efcad9a8bad7249aea130c19eabc8f9193975e" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-NATIVE-extra.json", + "usage": "input", + "git_blob": "9f9d6a9c4116610a76abe8eeb6394317ac9c524c", + "sha256": "e18a62a1019dac507c278fda6342dbb38afabace8f48a8d3c45a8f1e9b2d7bce" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-PHASES-base.json", + "usage": "input", + "git_blob": "494dd79f94634a84c1bcd7a7ef70ceaa209454db", + "sha256": "9d5316a1465a3eb2c62fac76c291394c0401c34a96fd8b94863d662b16a64552" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-PHASES-extra.json", + "usage": "input", + "git_blob": "00a86cdddcad95817b87322c13e22a0dd5faed22", + "sha256": "81c01d4b007bb720311dbdbbc63df673fdaf7baba707b360bbecc4b9cb6ee7b0" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/DATA-PHASES.json", + "usage": "input", + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/FOUR-base.json.gz", + "usage": "input", + "git_blob": "65957e5ca322049d985f23fdc0bd8da07ffa4c2a", + "sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/FOUR-extra.json.gz", + "usage": "input", + "git_blob": "1f3239c30e9343cf4e34b4371fcbeebb94a19011", + "sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/OPERATOR-TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/PR4076-RESULT.json", + "usage": "input", + "git_blob": "4bdbe9682413329415782da9ee9c33ec34bb2a21", + "sha256": "b00f1665c7096ca292079668bac86e25ca7552c57cbe62c8c45ea40aa8708ecf" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/PR4085-CLAIM.json", + "usage": "input", + "git_blob": "a0485940af5330dc64a962937d8f3465074a7224", + "sha256": "a65bcb4624a96204b1d30ec8c82080fbcdda2c1a30349643b60db579f339c75c" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/PR4088-FIRST-RESULT.json", + "usage": "input", + "git_blob": "d110afeaeecc8df7ccf1730eae63a8e124516b65", + "sha256": "817c39b155892ab3ea89b6e2bf04480c45e1ebb9a8f87e2bb9a48c715a7eee9e" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/THREE-base.json.gz", + "usage": "input", + "git_blob": "137793e275870db2161048405017b83dcc1824ee", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/THREE-extra.json.gz", + "usage": "input", + "git_blob": "7cce921b20dc0504cea954ab3297c5b55a9468dc", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/LICENSE", + "usage": "input", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/NATIVE-LINEAGE-NOTICE", + "usage": "input", + "git_blob": "380e979f0e84e00a22bd890615d87cc4684ad740", + "sha256": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/PINS.json", + "usage": "input", + "git_blob": "7c83dc543292205bc65abd332f77215b58feebf7", + "sha256": "f619e8e1c163078fb70c6fc3b98a498a671b8c02927b91d6cc253af2a775b6c9" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/SOURCE-PROVENANCE.json", + "usage": "input", + "git_blob": "07cd8a78808413a4a2e58cd5d43e448ab50ac34b", + "sha256": "8daf4fc7c75db99d34641152682208ce6c974f50d509960d0f4fa021f862abee" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/common.py", + "usage": "input", + "git_blob": "9ed8d88b97bda87a30bcb01cb9fd81339cbc15ab", + "sha256": "8f04e08b99a370fa82115fc46fbb3af4ab44f4facd47de07b01e1a2499a94914" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/run_native.py", + "usage": "input", + "git_blob": "64ef0eb83f214c2a922e446fa079e7d2568f73ef", + "sha256": "a7bfe110fe5098f6ef8bde3c43ecf15e8d1e06149abf7321a4c945383dcc2627" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/stage.py", + "usage": "input", + "git_blob": "9ecc54bca4173b732e3f030fadee0a3b7f54f686", + "sha256": "3cce27dd5a359ebc4dc70d4aab994aee52bc0a12e59db7da3f902257f876cffe" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/SPARSE-NOTICE.md", + "usage": "input", + "git_blob": "a3b31e157fcb9f8978040535a98d30a640509424", + "sha256": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/SPARSE-PROOF.md", + "usage": "input", + "git_blob": "bbd59904396b5978c15e38720d0c0ad7a9ac5398", + "sha256": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/sparse_state.py", + "usage": "input", + "git_blob": "ca39f73494e11bf0a860c51b8d711bec48ec0842", + "sha256": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/tables.py", + "usage": "input", + "git_blob": "5d546d8a05f6025d58a5133fa0d67ce134993013", + "sha256": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/NOTICE-PR2226.md", + "usage": "input", + "git_blob": "a14b299ef55c5581166988aa78baba329cebde04", + "sha256": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_adapters.py", + "usage": "input", + "git_blob": "82beaa9c1d13bcd5f79d0a5e10e8a10733eac347", + "sha256": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_audit_local.py", + "usage": "input", + "git_blob": "912a0c447c2ad34eb5ef3270e04ad0a73ca20a55", + "sha256": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_check_recipes.py", + "usage": "input", + "git_blob": "6db8ad50eb2562700432a852501aad720aa34816", + "sha256": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_emit.py", + "usage": "input", + "git_blob": "6d47f63ab7a533941b3881bbfd3ae4dac5f76932", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_gauss.py", + "usage": "input", + "git_blob": "1ff29dfb244e2114de8e586a450ae9fb70308d58", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_phases.py", + "usage": "input", + "git_blob": "99f351785ebca5fbf3336bedcd7b48bac9c255e5", + "sha256": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_tamper.py", + "usage": "input", + "git_blob": "a519863fd890ee1200043ad2ae4e307b95a1634e", + "sha256": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_transport.py", + "usage": "input", + "git_blob": "08248542b18864c94a5ac050c8669f68519838e1", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "usage": "input", + "git_blob": "5ea70357a04d083dba066fbc5c809a5736d8edd6", + "sha256": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/pr2226_operators.py", + "usage": "input", + "git_blob": "5c4fbe8cceedd769a1c367a31cd0beeae2175dc1", + "sha256": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/pr2226_replay.py", + "usage": "input", + "git_blob": "1bbe590206644e68d7654c23f0b46d5a18836e34", + "sha256": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/run_native_borrow.py", + "usage": "input", + "git_blob": "942310947b4d7016ed7a5d23a87e9ae98e0427d6", + "sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8" + }, + { + "path": "research/staged544-mixed-fourth-entry/operator_verify.py", + "usage": "input", + "git_blob": "60295d1c4622819c1bb2f514b885b952376e52bd", + "sha256": "9f1af2585df3f24ac0862d967cebc71c07c98bbc51506b0b95f82a2ab9ce6564" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/DISPATCH.json", + "usage": "input", + "git_blob": "9e93daeaf8f8a234655f523374528979c561951b", + "sha256": "5d6fa711d704a1b498e5fe066ea821c4fa0217463702e82a7ce5be9da4023e8a" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/FILL.json.gz", + "usage": "input", + "git_blob": "5e67f9bd27a42e38b9bd1a5ffd6f7ba7193578dc", + "sha256": "45f5bce58f2251b784b0ab89ca4657e0920515209810cfabd7e32d9a126e2db1" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/MIXED-DISPATCH.json", + "usage": "input", + "git_blob": "9fbaa36ec2d7706cadd6991028d882714b46af62", + "sha256": "7f3b4a82e556300e5cfa5f873a5b1975f5d1a10b494316289f6662941b8e39f2" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/ORDER.json", + "usage": "input", + "git_blob": "58d4b4c34170788a825d4c4e595fe45e28ef3fd2", + "sha256": "743e74b538432e2b2045e754b0de9c18f36fc5039fdb8eb542177a898ec78e44" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/PR4085-PROFILE.json", + "usage": "input", + "git_blob": "8f342d307e0080f9a927dc129c993fe50b3901e7", + "sha256": "610cd49ed71e684481182ee3c7e5d1686f6a376ef8c6e74e3c3615bbb842d841" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/old-NATIVE-base.json.gz", + "usage": "input", + "git_blob": "3424e3b0fb72c12dd244c41ad3ba44b4875ce5a4", + "sha256": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/old-NATIVE-extra.json.gz", + "usage": "input", + "git_blob": "6c1e9149b26394607cca9d4765ab8d3c5fc029bb", + "sha256": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner_verify.py", + "usage": "input", + "git_blob": "a74d1ee0b5d45feb4c87cc034ae49069d654467c", + "sha256": "7cc34c6cd6092550ca356093823252764f97bde8c3daecfe7d84afffe383ce72" + }, + { + "path": "research/staged544-mixed-fourth-entry/price.py", + "usage": "input", + "git_blob": "5b702b6fd94327f502fd9ef58594e1031dfa9db9", + "sha256": "89b7c623befd880a163baabc52f8ca576281ad0d8b71685e2ee37c9709edb335" + }, + { + "path": "research/staged544-mixed-fourth-entry/recipe/RECORD-base.json", + "usage": "input", + "git_blob": "d1c13c2ea786f790e96d45f18f58ec1ef2be7507", + "sha256": "221b56acc02ceeee35000f26f7098426421c0c90a075d81f9629170284f4aa25" + }, + { + "path": "research/staged544-mixed-fourth-entry/recipe/RECORD-extra.json", + "usage": "input", + "git_blob": "8d5a8d22ddb5450abf414f9ec814077d16033111", + "sha256": "b1963fba45032238f773f3b375412d7db5f6e184edb59dcd05be15f6f70116f2" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/PR4076-NOTICE.md", + "usage": "input", + "git_blob": "9ccffcfb7da1e36b158752ffed293dc95797e68e", + "sha256": "91f7f723bb616aca757812f940f6b893559e64e441d6158c907155a79b3b15a7" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/PR4085-OPERATOR-PROOF.md", + "usage": "input", + "git_blob": "eb65f87966b1b8b61c5f9abad508a3f0cd6d689b", + "sha256": "864b2857f200a37b37f939b78887484f5230be0b68ab7755705713e2e2d45d3e" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/audit_core.py", + "usage": "input", + "git_blob": "8b5e1d5f2a106402f036b63028ecef31a4e4c462", + "sha256": "888679ca8502cdcb100420fe5382a052529a494bf76cb332928b86e62612b951" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/audit_verify.py", + "usage": "input", + "git_blob": "7f9fc1df424ae1d459616e49bda7a5dd17e40491", + "sha256": "99971d3cc143cc894600e08c8cfbad3e8f537a544212f21dfbe4271cfa97354d" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/exact_root.py", + "usage": "input", + "git_blob": "96dab46ab3404adc92c4b004481759db0c71dfdf", + "sha256": "565e0d7de2fcd7587045f11731dfaba202e18f93e3a7a8178374f4933e502fbe" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/full_operator.py", + "usage": "input", + "git_blob": "b2b50c0847c811248031ef14e0b9adc8010d0127", + "sha256": "06f9f5128e19b6ea07756a9a11fcc9a9757a440a8048b5210422d12f183dfac3" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/staged_entries_applier.py", + "usage": "input", + "git_blob": "358ba3dcd984a19799bc9ed47e3ed81d1d111043", + "sha256": "41f889bcdf6ef4e8033ac45bf4d2c0fdb20d7b51dd194806d79bba789e207661" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/staged_pair.py", + "usage": "input", + "git_blob": "ca3e3effb97f46485ab7ac8c15ce4a92e1f93fbe", + "sha256": "25fc9b025dbb90358032013303adea650a5f19937fd3edf30b6c6fd023e2d747" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/t360_admission.py", + "usage": "input", + "git_blob": "266a2e541edc82c77a77e9c403bfe79a7392b950", + "sha256": "d3c3786a54fd4b2e5df98a1b39319628e855f65ffacabe7ab4d0deba8fe13329" + }, + { + "path": "research/staged544-mixed-fourth-entry/verify.py", + "usage": "input", + "git_blob": "816a7786a3570976ac86baf3b19ee798e6098895", + "sha256": "8dcb31e06abe2c92fca29a53d42a67f1b3358512b75b659e5fe2e0ba41e70cc8" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/DISPATCH.json", + "usage": "input", + "git_blob": "9e93daeaf8f8a234655f523374528979c561951b", + "sha256": "5d6fa711d704a1b498e5fe066ea821c4fa0217463702e82a7ce5be9da4023e8a" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/FILL.json.gz", + "usage": "input", + "git_blob": "5e67f9bd27a42e38b9bd1a5ffd6f7ba7193578dc", + "sha256": "45f5bce58f2251b784b0ab89ca4657e0920515209810cfabd7e32d9a126e2db1" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/FOUR-base.json.gz", + "usage": "input", + "git_blob": "65957e5ca322049d985f23fdc0bd8da07ffa4c2a", + "sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/FOUR-extra.json.gz", + "usage": "input", + "git_blob": "1f3239c30e9343cf4e34b4371fcbeebb94a19011", + "sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/MIXED-DISPATCH.json", + "usage": "input", + "git_blob": "9fbaa36ec2d7706cadd6991028d882714b46af62", + "sha256": "7f3b4a82e556300e5cfa5f873a5b1975f5d1a10b494316289f6662941b8e39f2" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/NATIVE-base.json.gz", + "usage": "input", + "git_blob": "3424e3b0fb72c12dd244c41ad3ba44b4875ce5a4", + "sha256": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/NATIVE-extra.json.gz", + "usage": "input", + "git_blob": "6c1e9149b26394607cca9d4765ab8d3c5fc029bb", + "sha256": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/ORDER.json", + "usage": "input", + "git_blob": "58d4b4c34170788a825d4c4e595fe45e28ef3fd2", + "sha256": "743e74b538432e2b2045e754b0de9c18f36fc5039fdb8eb542177a898ec78e44" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/PR4085-PROFILE.json", + "usage": "input", + "git_blob": "8f342d307e0080f9a927dc129c993fe50b3901e7", + "sha256": "610cd49ed71e684481182ee3c7e5d1686f6a376ef8c6e74e3c3615bbb842d841" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/THREE-base.json.gz", + "usage": "input", + "git_blob": "137793e275870db2161048405017b83dcc1824ee", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/THREE-extra.json.gz", + "usage": "input", + "git_blob": "7cce921b20dc0504cea954ab3297c5b55a9468dc", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + { + "path": "research/staged544-mixed-idle-rebind/vendor/rebind.py", + "usage": "provenance", + "git_blob": "a0453d3e956d80c2088b9f69650095dcae800343", + "sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af" + }, + { + "path": "research/staged544-triple-entry-fill/admission/pr3945/PR3682-CLAIM.json", + "usage": "input", + "git_blob": "6f05d13347e650467b561f1861e6266ffc9ef15c", + "sha256": "c7455323c62a5b1d5c9ceef07a305a5758df6971ac8f88e2be5223eb5f4c7553" + } + ] +} diff --git a/research/mixed-provider-admission/TASK.json b/research/mixed-provider-admission/TASK.json new file mode 100644 index 0000000000..bfec423ed5 --- /dev/null +++ b/research/mixed-provider-admission/TASK.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 7, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Can the #4088 four-provider dispatch satisfy the complete ordinary/outer admission contract?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/scatter-boundary-decision/README.md" + ], + "methods": [ + "Trace one hypothesis through the source, checker and complete caller.", + "Construct one semantically invalid but superficially well-formed fixture and test rejection." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4088 Scope and Open next questions: local words, native receipts and literal fill do not include a rerun of the mixed four-provider ordinary/outer engine. #3801 is the newer scatter-boundary decision; do not restart #2977 as if untouched.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Pin the provider registry, four native source closures and dispatch. Make a bounded acceptance coverage map or one registry adapter preserving every inherited admission predicate and rejection control (including an omitted fourth provider). Record remaining ordinary/outer obligations and a resource estimate before heavy execution. Stop at unresolved source/caller dependencies; no selected-result promotion from a local pass.", + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "allowed_variations": [ + "One provider-registry, dispatch, native-closure or admission-predicate obligation; separate branches must name distinct coverage." + ], + "scope_change_triggers": [ + "Reporting the historical timing-only diagnostic as a new current acceptance bug.", + "Calling a malformed mutant a failure of the selected construction, or importing an opt-in repair without testing the exporter boundary.", + "Running another root enclosure instead of validating dispatch or weakening an inherited predicate to make mixed admission pass." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics", + "4088", + "3801", + "staged544-mixed-fourth-entry", + "scatter-boundary-decision" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Carry PR4088 four-provider dispatch through the inherited PR4085 ordinary/outer admission without weakening its predicates; bind native stage products and recompute the complete idle invoice from actual per-call widths.", + "scope_change_reason": "Narrow revision-7 supplier-boundary-audit to the concrete PR4165 four-provider rebind handoff, on the exact retained PR4088 word/order/fill. No parameter search, new supplier or all-size proof claim.", + "bottleneck_link": "docs/research/current-priorities.md revision 7: the mixed four-provider ordinary/outer engine has not been replayed. This successor targets that finite admission boundary, retaining all analytic/theorem obligations.", + "budget_minutes": 180, + "stop_rule": "At most four bounded rounds on this question. Stop after a reviewable result, equivalent live work, two experiments without actionable evidence, or a nonlocal proof/infrastructure blocker; preserve the final quarter for verification/handoff.", + "outcome": "partial", + "evidence": "COVERAGE.md maps caller obligations. replay.py executes exact source reconstruction and inherited admission; verify.py checks source pins, actual call/width/idle bindings and semantic controls. challenge.py exercises actual four-provider products and the cached engine; NATIVE-OUTPUTS.json fixes their scientific commitments.", + "author": "yssite", + "ai_assistance": "Substantial OpenAI Codex assistance in investigation, implementation and documentation. A separate Codex context independently scanned source-event/phase-axis owner rows; another adversarially challenged the implementation and reproduced two corrected reuse-binding gaps. Neither is independent human review or formal verification.", + "open_questions": [ + { + "question": "Does an independently reviewed all-size compiler/precision/fixed-tape transfer justify using the admitted finite supplier in the complete multiplication theorem?", + "why_it_matters": "Finite ordinary/outer arithmetic and native source replay do not establish uniform generation, physical execution, conditioning or the complete machine-cost theorem.", + "first_step": "Use the current uniform-transfer-audit card and live PR4100/PR4169 handoffs to pin one remaining proposition at its actual caller; do not rerun this unchanged moment root.", + "blocked_by": "A general source-bound mathematical argument and independent scientific review, beyond this finite integration." + }, + { + "question": "Can a maintainer independently reproduce and review the four-provider successor before any frontier selection?", + "why_it_matters": "Archived predecessor packages and this author/AI evidence do not themselves select a result.", + "first_step": "Run the full replay command on the exact committed source, then inspect the coverage map and semantic mutation receipts.", + "blocked_by": "Independent maintainer execution/review; this campaign does not promote the selected record." + } + ] +} diff --git a/research/mixed-provider-admission/VERIFY.json b/research/mixed-provider-admission/VERIFY.json new file mode 100644 index 0000000000..187fa849f2 --- /dev/null +++ b/research/mixed-provider-admission/VERIFY.json @@ -0,0 +1,231 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/kappa-adaptive-continuation/admission/receiver_share.py", + "research/kappa-adaptive-continuation/admission/review_receiver_share.py", + "research/kappa-adaptive-continuation/runtime-repair/FIXTURES.json", + "research/kappa-adaptive-continuation/runtime-repair/audit_fast.py", + "research/kappa-adaptive-continuation/sources/PR3815/research/staged544-producer-return/REPLAY-INPUTS.tar.gz", + "research/kappa-operator-repair/late-staged-composition/candidate/BORROW-WORD-43base.json.gz", + "research/kappa-operator-repair/late-staged-composition/candidate/BORROW-WORD-43extra.json.gz", + "research/kappa-operator-repair/late-staged-composition/candidate/CONSTRUCTION.json", + "research/kappa-operator-repair/late-staged-composition/native-base/RESULT.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/STEPS.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CANONICAL-WORD.json.gz", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CLIFFORD-RECIPES.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CLIFFORD-REVIEW.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/FULL-WORD.json.gz", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/INDEPENDENT-LOCAL-REPLAY.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/LOCAL-CHECKS.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/LOCAL-PROGRAMS.json.gz", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/RESIDUAL-ADAPTERS.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/SCALAR-FRAME-AUDIT.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/WARP-RECIPE-CHECKS.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/WRAPPER-CHECKS.json", + "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/SPARSE-NOTICE.md", + "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/SPARSE-PROOF.md", + "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/sparse_state.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/tables.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/NOTICE-PR2226.md", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_adapters.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_audit_local.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_check_recipes.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_emit.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_gauss.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_phases.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_tamper.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_transport.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/pr2226_operators.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/pr2226_replay.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/run_native_borrow.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/RESULT.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/STEPS.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CANONICAL-WORD.json.gz", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CLIFFORD-RECIPES.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CLIFFORD-REVIEW.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/FULL-WORD.json.gz", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/INDEPENDENT-LOCAL-REPLAY.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/LOCAL-CHECKS.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/LOCAL-PROGRAMS.json.gz", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/RESIDUAL-ADAPTERS.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/SCALAR-FRAME-AUDIT.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/WARP-RECIPE-CHECKS.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/WRAPPER-CHECKS.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/SPARSE-NOTICE.md", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/SPARSE-PROOF.md", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/sparse_state.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/tables.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/NOTICE-PR2226.md", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_adapters.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_audit_local.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_check_recipes.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_emit.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_gauss.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_phases.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_tamper.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_transport.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/pr2226_operators.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/pr2226_replay.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/run_native_borrow.py", + "research/kappa-operator-repair/late-staged-composition/run_release.py", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/full_replay.py", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/NEW-base.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/NEW-extra.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/PR3682-CLAIM.json", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/PREDECESSOR.json", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/SOURCE-PATCHES.json", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/SOURCES.json", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/old-NATIVE-base.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/old-NATIVE-extra.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/terminal_applier.py", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/terminal_review.py", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/NEW-base.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/NEW-extra.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/OLD-base.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/OLD-extra.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/ENTRIES.json", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/RECORD-base.json", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/RECORD-extra.json", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/make_record.py", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/staged_entries_applier.py", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/staged_entries_review.py", + "research/staged544-mixed-fourth-entry/.gitattributes", + "research/staged544-mixed-fourth-entry/EXPORTED-SOURCES.json", + "research/staged544-mixed-fourth-entry/INPUTS.json", + "research/staged544-mixed-fourth-entry/MANIFEST.json", + "research/staged544-mixed-fourth-entry/NOTICE.md", + "research/staged544-mixed-fourth-entry/PROOF.md", + "research/staged544-mixed-fourth-entry/README.md", + "research/staged544-mixed-fourth-entry/RESULT.json", + "research/staged544-mixed-fourth-entry/SOURCES.json", + "research/staged544-mixed-fourth-entry/TASK.json", + "research/staged544-mixed-fourth-entry/VERIFY.json", + "research/staged544-mixed-fourth-entry/checks/inherited_frames.py", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-CANONICAL-base.json.gz", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-CANONICAL-extra.json.gz", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-LOCAL-base.json", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-LOCAL-extra.json", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-PHASES-base.json", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-PHASES-extra.json", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-base.json", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-extra.json", + "research/staged544-mixed-fourth-entry/evidence/THREE-CANONICAL-base.json.gz", + "research/staged544-mixed-fourth-entry/evidence/THREE-CANONICAL-extra.json.gz", + "research/staged544-mixed-fourth-entry/evidence/THREE-LOCAL-base.json", + "research/staged544-mixed-fourth-entry/evidence/THREE-LOCAL-extra.json", + "research/staged544-mixed-fourth-entry/evidence/THREE-NATIVE-base.json", + "research/staged544-mixed-fourth-entry/evidence/THREE-NATIVE-extra.json", + "research/staged544-mixed-fourth-entry/evidence/THREE-PHASES-base.json", + "research/staged544-mixed-fourth-entry/evidence/THREE-PHASES-extra.json", + "research/staged544-mixed-fourth-entry/inputs/DATA-PHASES.json", + "research/staged544-mixed-fourth-entry/inputs/FOUR-base.json.gz", + "research/staged544-mixed-fourth-entry/inputs/FOUR-extra.json.gz", + "research/staged544-mixed-fourth-entry/inputs/OPERATOR-TEMPLATE.json.gz", + "research/staged544-mixed-fourth-entry/inputs/PR4076-RESULT.json", + "research/staged544-mixed-fourth-entry/inputs/PR4085-CLAIM.json", + "research/staged544-mixed-fourth-entry/inputs/PR4088-FIRST-RESULT.json", + "research/staged544-mixed-fourth-entry/inputs/THREE-base.json.gz", + "research/staged544-mixed-fourth-entry/inputs/THREE-extra.json.gz", + "research/staged544-mixed-fourth-entry/native/LICENSE", + "research/staged544-mixed-fourth-entry/native/NATIVE-LINEAGE-NOTICE", + "research/staged544-mixed-fourth-entry/native/PINS.json", + "research/staged544-mixed-fourth-entry/native/SOURCE-PROVENANCE.json", + "research/staged544-mixed-fourth-entry/native/common.py", + "research/staged544-mixed-fourth-entry/native/run_native.py", + "research/staged544-mixed-fourth-entry/native/stage.py", + "research/staged544-mixed-fourth-entry/native/vendor/accelerators/SPARSE-NOTICE.md", + "research/staged544-mixed-fourth-entry/native/vendor/accelerators/SPARSE-PROOF.md", + "research/staged544-mixed-fourth-entry/native/vendor/accelerators/sparse_state.py", + "research/staged544-mixed-fourth-entry/native/vendor/accelerators/tables.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/NOTICE-PR2226.md", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_adapters.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_audit_local.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_check_recipes.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_emit.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_gauss.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_phases.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_tamper.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_transport.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/pr2226_operators.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/pr2226_replay.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/run_native_borrow.py", + "research/staged544-mixed-fourth-entry/operator_verify.py", + "research/staged544-mixed-fourth-entry/owner/DISPATCH.json", + "research/staged544-mixed-fourth-entry/owner/FILL.json.gz", + "research/staged544-mixed-fourth-entry/owner/MIXED-DISPATCH.json", + "research/staged544-mixed-fourth-entry/owner/ORDER.json", + "research/staged544-mixed-fourth-entry/owner/PLAN.json.gz", + "research/staged544-mixed-fourth-entry/owner/PR4085-PROFILE.json", + "research/staged544-mixed-fourth-entry/owner/TEMPLATE.json.gz", + "research/staged544-mixed-fourth-entry/owner/old-NATIVE-base.json.gz", + "research/staged544-mixed-fourth-entry/owner/old-NATIVE-extra.json.gz", + "research/staged544-mixed-fourth-entry/owner_verify.py", + "research/staged544-mixed-fourth-entry/price.py", + "research/staged544-mixed-fourth-entry/recipe/RECORD-base.json", + "research/staged544-mixed-fourth-entry/recipe/RECORD-extra.json", + "research/staged544-mixed-fourth-entry/vendor/PR4076-NOTICE.md", + "research/staged544-mixed-fourth-entry/vendor/PR4085-OPERATOR-PROOF.md", + "research/staged544-mixed-fourth-entry/vendor/audit_core.py", + "research/staged544-mixed-fourth-entry/vendor/audit_verify.py", + "research/staged544-mixed-fourth-entry/vendor/exact_root.py", + "research/staged544-mixed-fourth-entry/vendor/full_operator.py", + "research/staged544-mixed-fourth-entry/vendor/staged_entries_applier.py", + "research/staged544-mixed-fourth-entry/vendor/staged_pair.py", + "research/staged544-mixed-fourth-entry/vendor/t360_admission.py", + "research/staged544-mixed-fourth-entry/verify.py", + "research/staged544-mixed-idle-rebind/inputs/DISPATCH.json", + "research/staged544-mixed-idle-rebind/inputs/FILL.json.gz", + "research/staged544-mixed-idle-rebind/inputs/FOUR-base.json.gz", + "research/staged544-mixed-idle-rebind/inputs/FOUR-extra.json.gz", + "research/staged544-mixed-idle-rebind/inputs/MIXED-DISPATCH.json", + "research/staged544-mixed-idle-rebind/inputs/NATIVE-base.json.gz", + "research/staged544-mixed-idle-rebind/inputs/NATIVE-extra.json.gz", + "research/staged544-mixed-idle-rebind/inputs/ORDER.json", + "research/staged544-mixed-idle-rebind/inputs/PLAN.json.gz", + "research/staged544-mixed-idle-rebind/inputs/PR4085-PROFILE.json", + "research/staged544-mixed-idle-rebind/inputs/TEMPLATE.json.gz", + "research/staged544-mixed-idle-rebind/inputs/THREE-base.json.gz", + "research/staged544-mixed-idle-rebind/inputs/THREE-extra.json.gz", + "research/staged544-triple-entry-fill/admission/pr3945/PR3682-CLAIM.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "All declared live source pins; actual four-provider call/width/idle binding on 1,321,920 rows; semantic mutation controls." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/test_binding.py" + ], + "timeout_seconds": 60, + "checks": "The new explicit rejection predicates remain active in optimized Python; the inherited full engine separately rejects optimized execution." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/independent_ledger.py", + "--controls" + ], + "timeout_seconds": 180, + "checks": "Independent exact span enumeration and event-level chronology/capacity/accounting; three semantic mutations reach their specific rejection predicates." + } + ] +} diff --git a/research/mixed-provider-admission/adapt.py b/research/mixed-provider-admission/adapt.py new file mode 100644 index 0000000000..12579636b9 --- /dev/null +++ b/research/mixed-provider-admission/adapt.py @@ -0,0 +1,154 @@ +"""Exact, reviewable extensions of a freshly reconstructed PR4085 source. + +SPDX-License-Identifier: Apache-2.0 +Prepared for yssite with substantial OpenAI Codex assistance. +Predecessor code and notices are retained in the generated external tree. +""" +import json +from pathlib import Path +import shutil + +from binding import need, read, sha + +HERE = Path(__file__).resolve().parent +REPO = HERE.parents[1] +MIXED = REPO / "research/staged544-mixed-fourth-entry" +TAGS = {"gauge44": "base", "extra": "extra", + "gauge44-four": "base-four", "extra-four": "extra-four"} +BASE_MANIFEST = "4116ef61479e509811b60b5fd4e84db8811dae079092f2f83bdcc2c80052c0da" +BASE_ENGINE = "e69184d235d8790a3c520977dd44dcfb73a99d56989825485f922ff61059c8b1" + + +def write(path, value): + path.write_text(json.dumps(value, sort_keys=True, indent=2) + "\n") + + +def tree(path, exclude=()): + result = {} + for p in sorted(path.rglob("*")): + need(not p.is_symlink(), "unbound source symlink") + if p.is_file() and p.relative_to(path).as_posix() not in exclude: + result[p.relative_to(path).as_posix()] = sha(p) + return result + + +class Patches: + def __init__(self, root): + self.root = root + self.rows = [] + + def replace(self, name, old, new, count=1): + p = self.root / name + before = sha(p) + body = p.read_text() + need(body.count(old) == count, "exact patch preimage: " + name + ": " + old[:70]) + p.write_text(body.replace(old, new)) + self.rows.append(dict(path=name, before_sha256=before, after_sha256=sha(p), + old=old, new=new, occurrences=count)) + + +def extend_source(baseline, destination): + source = baseline / "inputs/source" + need(sha(source / "MANIFEST.json") == BASE_MANIFEST, "exact PR4085 source manifest") + need(tree(source, ("MANIFEST.json",)) == read(source / "MANIFEST.json"), + "complete PR4085 source inventory") + shutil.copytree(source, destination) + p = Patches(destination) + registry = read(destination / "new/BORROW-PROVIDERS.json") + contract = {"providers": {}, "dispatch": read(MIXED / "owner/MIXED-DISPATCH.json")} + for pid, tag in TAGS.items(): + base = tag.split("-")[0] + kind = "FOUR" if tag.endswith("-four") else "THREE" + word = MIXED / f"inputs/{kind}-{base}.json.gz" + value = read(word) + native = read(MIXED / f"owner/old-NATIVE-{base}.json.gz") + widths = [len(value["helper_final"].get(str(r), [1 << i for i in range(9)])) + - len(value["start_extra"].get(str(r), [])) for r in native["helper_origin"]] + relative = f"new/borrow/words/BORROW-WORD-43{tag}.json.gz" + if kind == "THREE": + need(sha(destination / relative) == sha(word), "unchanged THREE source") + else: + shutil.copyfile(word, destination / relative) + registry[pid] = {"widths": widths, "actual_paid_profile": value["report"]["local_profile"]} + need(registry[pid]["widths"] == widths + and registry[pid]["actual_paid_profile"] == value["report"]["local_profile"], + "complete native-order registry") + contract["providers"][pid] = dict(word=relative, word_sha256=sha(word), + widths=widths, profile=value["report"]["local_profile"]) + write(destination / "new/BORROW-PROVIDERS.json", registry) + write(destination / "new/MIXED-CONTRACT.json", contract) + shutil.copyfile(HERE / "binding.py", destination / "new/mixed_binding.py") + p.replace("new/rebind.py", + "pkg, loc_g, loc_e, out = map(Path, sys.argv[1:5]);", + "pkg, loc_g, loc_e, loc_g4, loc_e4, out = map(Path, sys.argv[1:7]);") + p.replace("new/rebind.py", "locs = {'gauge44': loc_g, 'extra': loc_e};", + "locs = {'gauge44': loc_g, 'extra': loc_e, 'gauge44-four': loc_g4, 'extra-four': loc_e4};") + p.replace("new/rebind.py", + "idle = {int(r): v for r, v in rd(pkg / 'CONSTRUCTION.json')['idle'].items()} # exact idle ranks of the shipped owner fill", + "from mixed_binding import validate_rebind\nidle = validate_rebind(pkg, plan, locs)") + # Both native entrypoints and both inherited replay call sites receive all providers. + p.replace("verify.py", + "new_words={'base':P/'new/borrow/words/BORROW-WORD-43base.json.gz','extra':P/'new/borrow/words/BORROW-WORD-43extra.json.gz'}", + "new_words={tag:P/'new/borrow/words'/('BORROW-WORD-43'+tag+'.json.gz') for tag in ('base','extra','base-four','extra-four')}") + p.replace("verify.py", "reuse=getattr(a,'new_%s_native_from'%key)", + "reuse=getattr(a,'new_%s_native_from'%key,None)") + p.replace("verify.py", + "P,nat['base']/'local',nat['extra']/'local',work/'data-rebound'", + "P,nat['base']/'local',nat['extra']/'local',nat['base-four']/'local',nat['extra-four']/'local',work/'data-rebound'") + p.replace("verify.py", "nat['base'],nat['extra'],*[p_", + "nat['base'],nat['extra'],nat['base-four'],nat['extra-four'],*[p_") + p.replace("verify.py", "shutil.copytree(nat['extra'],runtime/'native-extra')", + "for pid,tag in [('extra','extra'),('gauge44-four','base-four'),('extra-four','extra-four')]:shutil.copytree(nat[tag],runtime/('native-'+pid))") + p.replace("replay.py", "g=work/'global'", + "provider_dirs={'gauge44':local, **{pid:P/('native-'+pid)/'local' for pid in rd(data/'PLAN.json')['provider_registry'] if pid!='gauge44'}}\n" + "assert set(provider_dirs)==set(rd(data/'PLAN.json')['provider_registry'])\n" + "provider_args=[arg for pid,directory in sorted(provider_dirs.items()) for arg in ('--provider',pid+'='+str(directory))]\n" + "g=work/'global'") + p.replace("replay.py", + "'--provider','gauge44='+str(local),'--provider','extra='+str(P/'native-extra/local')", + "*provider_args", count=2) + after = tree(destination, ("MANIFEST.json",)) + before = read(source / "MANIFEST.json") + patched = {row["path"] for row in p.rows} + for name in sorted(set(before) | set(after)): + if name not in patched and before.get(name) != after.get(name): + p.rows.append(dict(path=name, kind="file_inventory_change", + before_sha256=before.get(name), after_sha256=after.get(name))) + write(destination / "MANIFEST.json", after) + return contract, p.rows + + +def extend_engine(baseline, source, output): + need(sha(baseline / "admit_composed.py") == BASE_ENGINE, "exact inherited admission engine") + shutil.copyfile(baseline / "admit_composed.py", output) + p = Patches(output.parent) + name = output.name + manifest = sha(source / "MANIFEST.json") + p.replace(name, "manifest='" + BASE_MANIFEST + "'", "manifest='" + manifest + "'") + p.replace(name, "helpers=408,source_file_count=676", + f"helpers=408,source_file_count={len(read(source / 'MANIFEST.json'))}") + p.replace(name, "commit='triple-staged-entry-and-receiver-share-20261019'", + "commit='pr4088-four-provider-admission-v1'") + p.replace(name, "for tag in ('base', 'extra'):", + "for tag in ('base', 'extra', 'base-four', 'extra-four'):", count=2) + p.replace(name, + "natives['extra'] / 'local', work / 'rebound'", + "natives['extra'] / 'local', natives['base-four'] / 'local', natives['extra-four'] / 'local', work / 'rebound'") + p.replace(name, "shutil.copytree(natives['extra'], runtime / 'native-extra')", + "for pid, tag in [('extra','extra'),('gauge44-four','base-four'),('extra-four','extra-four')]:\n" + " shutil.copytree(natives[tag], runtime / ('native-'+pid))") + p.replace(name, " write(work / 'RUNTIME-PATCHES.json', patches)", + " patch('verify.py', [(\"controller=15,independent_owner=8,geometry=6\", " + "\"controller=rd(P/'new/SPEC.json')['expected']['mutations_rejected'],independent_owner=8,geometry=6\")])\n" + " write(work / 'RUNTIME-PATCHES.json', patches)") + # New provider IDs inherit the unchanged interface descriptor, never an averaged width. + old = "P.require(pid in plan['provider_registry'],'provider in retained registry')" + new = ("if pid not in plan['provider_registry']:\n" + " P.require(pid.endswith('-four') and pid[:-5] in plan['provider_registry'], 'declared fourth provider')\n" + " plan['provider_registry'][pid]=copy.deepcopy(plan['provider_registry'][pid[:-5]])\n" + " " + old) + helper = output.parent / "helpers" + shutil.copytree(baseline / "inputs/helpers", helper) + hp = Patches(output.parent) + hp.replace("helpers/lift_parent.py", old, new) + return p.rows + hp.rows diff --git a/research/mixed-provider-admission/binding.py b/research/mixed-provider-admission/binding.py new file mode 100644 index 0000000000..14eb67c6e1 --- /dev/null +++ b/research/mixed-provider-admission/binding.py @@ -0,0 +1,128 @@ +"""Strict per-call binding added to the inherited PR4085 rebind. + +SPDX-License-Identifier: Apache-2.0 +Prepared for yssite with substantial OpenAI Codex assistance. +The inherited owner, native, phase, invoice and release checks remain required. +""" +from collections import Counter +import gzip +import hashlib +import json + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == ".gz" else raw) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def account(plan, roles, dispatch): + """Recompute complements from actual rows, never an orientation average.""" + order = [tuple(c) for c in plan["order"]] + need(len(order) == len(set(order)), "duplicate call") + need(len(dispatch) == len(order), "dispatch row coverage") + selected = {(s, r): p for s, r, p in dispatch} + need(len(selected) == len(dispatch) and set(selected) == set(order), + "dispatch bijection") + registry = plan["provider_registry"] + need(set(selected.values()) == set(registry), "complete provider usage") + counts = {len(d["widths"]) for d in registry.values()} + need(len(counts) == 1, "common helper count") + helpers = counts.pop() + need(helpers > 0 and len(roles) == helpers * len(order), "role coverage") + calls, widths = plan["provider_calls"], plan["per_call_widths"] + need(len(calls) == len(widths) == len(order), "call descriptor coverage") + for t, (stage, replica) in enumerate(order): + c, w, pid = calls[t], widths[t], selected[stage, replica] + need((c["stage"], c["replica"], c["time"], c["provider"]) + == (stage, replica, t, pid), "per-call provider binding") + need(c["orientation"] == ("forward" if stage % 2 == 0 else "backward"), + "per-call orientation") + need(c["local_program_sha256"] == + registry[pid]["orientation_program_sha256"][c["orientation"]], + "per-call program binding") + need((w["stage"], w["replica"], w["time"]) == (stage, replica, t) + and w["widths"] == registry[pid]["widths"], "per-call width binding") + windows = {tuple(map(int, k.split(","))): (cap, set(times)) + for k, (cap, times) in plan["windows"].items()} + used = Counter() + families = set() + for j, z in enumerate(roles): + t, h = divmod(j, helpers) + stage, replica = order[t] + pid = selected[stage, replica] + need((z["time"], z["helper"], z["stage"], z["replica"]) + == (t, h, stage, replica), "ordered role identity") + owner, child, port = z["owner_replica"], z["child"], z["port"] + need(all(type(v) is int for v in (owner, child, port, z["offset"], z["width"])), + "integer owner record") + need((owner, child) in windows and 0 <= port < 112, "owner bin") + cap, times = windows[owner, child] + need(t in times, "strict inherited window") + width = registry[pid]["widths"][h] + need(type(width) is int and width > 0 and z["width"] == width, + "actual selected helper width") + stream = 2 * plan["pairs"][str(child)] + plan["sides"][str(child)] + family = 896 * owner + 112 * stream + port + need(z["family"] == family and z["copy"] == 112 * owner + port, + "physical family binding") + if h == 0: + families = set() + need(family not in families, "same-call family alias") + families.add(family) + key = owner, child, port + need(z["offset"] == used[key] and used[key] + width <= cap, + "compact per-call residual prefix") + used[key] += width + idle = Counter() + for (owner, child), (cap, _) in windows.items(): + for port in range(112): + left = cap - used[owner, child, port] + need(left >= 0, "negative idle remainder") + if left: + idle[left] += 1 + total = Counter(idle) + for call in order: + total.update({int(r): n for r, n in + registry[selected[call]]["actual_paid_profile"].items()}) + return dict(sorted(idle.items())), dict(sorted(total.items())) + + +def validate_rebind(pkg, plan, locs): + contract = read(pkg / "new/MIXED-CONTRACT.json") + need(set(locs) == set(plan["provider_registry"]) == set(contract["providers"]), + "complete four-provider binding") + for pid, source in contract["providers"].items(): + word = pkg / source["word"] + need(sha(word) == source["word_sha256"], "provider source changed") + full = read(locs[pid] / "FULL-WORD.json.gz") + need(full == read(word), "native source word") + canonical = read(locs[pid] / "CANONICAL-WORD.json.gz") + widths = [len(canonical["frames"][canonical["final"][r]]) + - len(canonical["frames"][canonical["start"][r]]) + for r in range(224, 224 + canonical["R"])] + desc = plan["provider_registry"][pid] + need(widths == source["widths"] == desc["widths"], "native selected widths") + checks = read(locs[pid] / "LOCAL-CHECKS.json") + need(all(checks[o]["paid_profile"] == source["profile"] + == desc["actual_paid_profile"] for o in ("forward", "backward")), + "both orientation paid profiles") + dispatch = read(pkg / "DISPATCH.json") + # The inherited reconstructor serializes in chronological order; the input + # table's row order is immaterial. account() separately requires a bijection + # and binds every chronological call, width and orientation program. + need(sorted(dispatch) == sorted(contract["dispatch"]), "literal mixed selector") + idle, total = account(plan, read(pkg / "OWNERS.json.gz"), dispatch) + need(idle == {int(k): v for k, v in read(pkg / "CONSTRUCTION.json")["idle"].items()}, + "stale construction idle") + need(total == {int(k): v for k, v in plan["profile"].items()}, + "complete mixed paid profile") + return idle diff --git a/research/mixed-provider-admission/challenge.py b/research/mixed-provider-admission/challenge.py new file mode 100644 index 0000000000..2b27377cfe --- /dev/null +++ b/research/mixed-provider-admission/challenge.py @@ -0,0 +1,117 @@ +#!/usr/bin/env python3 +"""Bounded semantic challenges against an actual prepared or completed replay. + +SPDX-License-Identifier: Apache-2.0 +Prepared for yssite with substantial OpenAI Codex assistance, incorporating +the separate adversarial context's demonstrated cache mutations. +This does not rerun or establish the full release. +""" +import argparse +import gzip +import json +from pathlib import Path +import shutil +import tempfile + +from adapt import TAGS, write +from binding import need, read, sha +from native_outputs import REFERENCES, authenticate_native +from replay import check_preflight + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument("--work", type=Path, required=True, help="existing replay.py output") + ap.add_argument("--preflight", type=Path, help="if the run supplied --checked-preflight") + args = ap.parse_args() + work = args.work.resolve() + baseline = (args.preflight or work / "baseline/release-work/preflight").resolve() + check_preflight(baseline) + results = [{"name": "actual predecessor preflight", "status": "PASS"}] + + def reject(name, call, reason): + try: + call() + except ValueError as exc: + need(reason in str(exc), "unexpected rejection: " + str(exc)) + results.append(dict(name=name, status="REJECTED", reason=str(exc))) + else: + raise ValueError("accepted semantic mutant: " + name) + + for pid, tag in TAGS.items(): + word_sha = sha(work / f"source/new/borrow/words/BORROW-WORD-43{tag}.json.gz") + original = work / "native-cache" / word_sha + # Engine caches add CACHE.json; its transport inventory is checked by + # the engine. The fixed scientific gate consumes only native products. + with tempfile.TemporaryDirectory() as td: + native = Path(td) / "native" + shutil.copytree(original, native, ignore=shutil.ignore_patterns("CACHE.json")) + products = authenticate_native(pid, word_sha, native) + need(len(products) == 11, "all scientific products") + results.append(dict(name=pid + " actual native products", status="PASS")) + + recipe_path = native / "local/CLIFFORD-RECIPES.json" + saved = recipe_path.read_bytes() + recipe = read(recipe_path) + recipe["warps"][0]["left"]["phase"] = (recipe["warps"][0]["left"]["phase"] + 1) % 4 + write(recipe_path, recipe) + for name in ("CLIFFORD-REVIEW.json", "WARP-RECIPE-CHECKS.json"): + path = native / "local" / name + value = read(path) + value["recipe_sha256"] = sha(recipe_path) + write(path, value) + reject(pid + " wrong phase with all recipe references rebound", + lambda: authenticate_native(pid, word_sha, native), + "native scientific output commitment") + recipe_path.write_bytes(saved) + for name in ("CLIFFORD-REVIEW.json", "WARP-RECIPE-CHECKS.json"): + shutil.copyfile(original / "local" / name, native / "local" / name) + + steps_path = native / "STEPS.json" + steps = read(steps_path) + write(steps_path, steps[:-1]) + reject(pid + " skipped phase stage", + lambda: authenticate_native(pid, word_sha, native), + "actual native stage products coverage") + write(steps_path, steps) + + # Positive control: transport and elapsed time may change without + # changing a mathematical product. Rebind actual serialized refs. + for path in (native / "local").iterdir(): + value = read(path) + if path.name in ("CLIFFORD-REVIEW.json", "SCALAR-FRAME-AUDIT.json"): + value["seconds"] += 1 + raw = json.dumps(value, sort_keys=True, indent=1).encode() + path.write_bytes(gzip.compress(raw, mtime=17) if path.suffix == ".gz" else raw) + for path in (native / "local").iterdir(): + value = read(path) + changed = False + for field, target in REFERENCES.items(): + if field in value: + value[field] = sha(native / "local" / target) + changed = True + if changed: + write(path, value) + need(authenticate_native(pid, word_sha, native) == products, + "transport-equivalent products") + results.append(dict(name=pid + " equivalent serialization and timing", status="PASS")) + + with tempfile.TemporaryDirectory() as td: + mutant = Path(td) / "preflight" + shutil.copytree(baseline, mutant) + engine = mutant / "admit_composed.py" + engine.write_bytes(engine.read_bytes() + b"\n# deliberate source mutation\n") + receipt_path = mutant / "PREFLIGHT-RESULT.json" + receipt = read(receipt_path) + receipt["admission_engine_sha256"] = sha(engine) + write(receipt_path, receipt) + reject("changed engine with rebound completion receipt", + lambda: check_preflight(mutant), "preflight admission engine") + + print(json.dumps(dict(status="PASS_ACTUAL_REPLAY_CHALLENGES", cases=results, + scope="Reuse gates only; not full native or ordinary admission."), + sort_keys=True, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/mixed-provider-admission/independent_ledger.py b/research/mixed-provider-admission/independent_ledger.py new file mode 100644 index 0000000000..396640e75d --- /dev/null +++ b/research/mixed-provider-admission/independent_ledger.py @@ -0,0 +1,312 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Independently corroborate PR4088's mixed-provider owner invoice. + +Prepared for the yssite campaign with substantial OpenAI Codex assistance, +2026-10-20. This checker credits Cinna Davis's PR4088 construction and unpaidmoon's +PR4165 idle/rebind finding. It imports no repository code, invokes no subprocesses, +and writes no files. Optional controls change only private in-memory inputs. + +Independence: frame ranks enumerate complete F2 spans; exact observation windows +are reconstructed from the flat execution schedule. The owner walker and lead +admission binding are not imported. Local cost profiles and observer definitions +remain declared source interfaces. This is a finite ledger check, not a native, +scalar-semantics, Z4-operator, all-size, or ordinary/outer release proof. + +Use --repo PATH when this script is outside research/mixed-provider-admission. +Only that installed location permits repository-root inference. All consumed +source paths and byte hashes are emitted in consumed_sources. +""" +import argparse +from collections import Counter, defaultdict +import gzip +import hashlib +import json +from pathlib import Path + +PACKAGE = Path('research/staged544-mixed-fourth-entry') +PREDECESSOR = Path('research/staged544-mixed-idle-rebind') + + +class LedgerError(ValueError): + def __init__(self, code, detail=''): + self.code = code + self.detail = detail + super().__init__(code + (': ' + detail if detail else '')) + + +def require(condition, code, detail=''): + if not condition: + raise LedgerError(code, detail) + + +def rank(vectors): + """Enumerate at most 512 span elements, without a shared basis routine.""" + span = {0} + for vector in vectors: + require(type(vector) is int and 0 <= vector < 512, 'frame-vector') + span |= {value ^ vector for value in tuple(span)} + return len(span).bit_length() - 1 + + +def repo_path(argument): + if argument is not None: + return Path(argument).resolve() + here = Path(__file__).resolve().parent + require(here.name == 'mixed-provider-admission' and here.parent.name == 'research', + 'explicit-repo-required', 'use --repo PATH outside research/mixed-provider-admission') + return here.parent.parent + + +class Sources: + def __init__(self, repo): + self.repo = repo + self.consumed = {} + self.declared = {} + for name in ('MANIFEST.json', 'EXPORTED-SOURCES.json'): + manifest = self.read(PACKAGE / name, authenticate=False) + for relative, entry in manifest.items(): + digest = entry['sha256'] if isinstance(entry, dict) else entry + path = (PACKAGE / relative).as_posix() + require(path not in self.declared or self.declared[path] == digest, + 'conflicting-source-pin', path) + self.declared[path] = digest + + def raw(self, path, authenticate=True): + name = path.as_posix() + raw = (self.repo / path).read_bytes() + digest = hashlib.sha256(raw).hexdigest() + if authenticate: + require(name in self.declared, 'undeclared-source', name) + require(digest == self.declared[name], 'source-pin', name) + self.consumed[name] = digest + return raw + + def read(self, path, authenticate=True): + raw = self.raw(path, authenticate) + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + + +def exact_windows(order, template, plan, phases): + clock = {tuple(call): time for time, call in enumerate(order)} + require(len(order) == len(clock) == 3240, 'order-uniqueness') + require(set(clock) == {(s, r) for s in range(9) for r in range(360)}, 'order-domain') + require(all(clock[s, r] < clock[s + 1, r] for r in range(360) for s in range(8)), + 'stage-chronology') + positive = {entry['child'] for entry in template['idle_children']} + require(len(positive) == 18 and len(phases['recipes']) == 112, 'bin-dimensions') + stage_pairs = {e['stage']: e['pair'] for e in template['recipe'] if e['kind'] == 'local'} + observations = defaultdict(list) + windows = {} + stage = None + index = -1 + for event in template['execution_schedule']: + kind = event['kind'] + if kind in ('bank_padding_cover_sweep', 'translate_every_live_family'): + continue + if kind == 'local_cover_sweep': + stage, index = event['stage'], 0 + else: + index += 1 + require(stage is not None, 'event-before-local-stage') + if kind == 'idle_cover_sweep': + for side, child in enumerate(event['child_indices']): + stream = 2 * event['pair'] + side + if child in positive: + require(stream == 2 * plan['pairs'][str(child)] + plan['sides'][str(child)], + 'stream-route') + for owner in range(360): + endpoint = (clock[stage, owner], index) + prior = observations[owner, stream][-1] if observations[owner, stream] else (-1, -1) + require((owner, child) not in windows, 'duplicate-window') + windows[owner, child] = prior, endpoint, stream + if kind == 'local_cover_sweep': + touched = (2 * stage_pairs[stage], 2 * stage_pairs[stage] + 1) + elif kind == 'bridge': + touched = [2 * pair + side for pair in (event['src'], event['dst']) for side in (0, 1)] + elif kind == 'terminal': + touched = range(8) + else: + require(kind in ('idle_cover_sweep', 'terminal_Y_translations'), 'unrecognized-event') + touched = () + for owner in range(360): + for stream in touched: + observations[owner, stream].append((clock[stage, owner], index)) + shared = defaultdict(list) + for (owner, child), (low, high, stream) in windows.items(): + if child in positive: + shared[owner, stream].append((low, high)) + for intervals in shared.values(): + intervals.sort() + require(all(left[1] <= right[0] for left, right in zip(intervals, intervals[1:])), + 'overlapping-stream-windows') + return clock, windows, stage_pairs + + +def scan(rows, order, dispatch, windows, stage_pairs, phases, widths, first_row_override=None): + require(len(rows) == 1321920, 'role-count') + used = defaultdict(int) + same_call = set() + hosted_mass = 0 + first = {} + for index, original in enumerate(rows): + row = first_row_override if index == 0 and first_row_override is not None else original + require(len(row) == 6 and all(type(value) is int for value in row), 'row-types') + time, helper, owner, child, port, offset = row + require((time, helper) == divmod(index, 408), 'row-identity') + if helper == 0: + same_call = set() + require((owner, child) in windows and 0 <= port < 112, 'owner-identity') + low, high, stream = windows[owner, child] + require(low < (time, -1) < high, 'strict-observation-window') + key = owner, child, port + physical = owner, stream, port + require(physical not in same_call, 'same-call-alias') + same_call.add(physical) + stage, replica = order[time] + require(4 * owner + stream // 2 != 4 * replica + stage_pairs[stage], 'productive-alias') + record = phases['recipes'][port]['idle_children'][child] + axes = record['orthogonal_axes'] + require(len(axes) == len(set(axes)) == record['rank'], 'axis-identity') + provider = dispatch[stage, replica] + width = widths[provider][helper] + require(offset == used[key], 'compact-prefix', + f'row {index}: expected {used[key]}, got {offset}') + require(offset + width <= len(axes), 'axis-capacity', f'row {index}') + used[key] += width + hosted_mass += width + if helper == 367 and provider not in first: + first[provider] = dict(row_index=index, row=row, call=order[time], width=width, + window=[low, high], stream=stream, axis_capacity=len(axes)) + idle = Counter() + axis_mass = positive_bins = 0 + for owner in range(360): + for port, recipe in enumerate(phases['recipes']): + for child, record in enumerate(recipe['idle_children']): + capacity = len(record['orthogonal_axes']) + axis_mass += capacity + positive_bins += bool(capacity) + left = capacity - used[owner, child, port] + require(left >= 0, 'negative-complement') + if left: + idle[left] += 1 + require(hosted_mass + sum(r * n for r, n in idle.items()) == axis_mass, 'axis-mass') + return dict(idle=idle, first=first, hosted_axis_mass=hosted_mass, total_axis_mass=axis_mass, + positive_bins=positive_bins, occupied_positive_bins=sum(bool(v) for v in used.values())) + + +def invoice(counts, profiles, idle, expected): + profile = Counter(idle) + for provider, count in counts.items(): + for r, n in profiles[provider].items(): + profile[r] += count * n + require(dict(profile) == {int(r): n for r, n in expected['profile'].items()}, 'complete-profile') + require(dict(idle) == {int(r): n for r, n in expected['idle'].items()}, 'idle-profile') + require(sum(r * n for r, n in profile.items()) == 65088 * 360, 'paid-rank-mass') + return dict(sorted(profile.items())) + + +def reject(label, expected_code, expected_detail, action): + try: + action() + except LedgerError as error: + require(error.code == expected_code and expected_detail in error.detail, + 'wrong-control-rejection', f'{label}: {error}') + return dict(control=label, rejection=error.code, detail=error.detail) + raise LedgerError('accepted-control', label) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--repo', type=Path, help='repository root') + parser.add_argument('--controls', action='store_true', help='run three bounded in-memory rejection controls') + args = parser.parse_args() + sources = Sources(repo_path(args.repo)) + read = sources.read + pairs = [('owner/' + n, 'inputs/' + n) for n in + ('ORDER.json', 'DISPATCH.json', 'MIXED-DISPATCH.json', 'FILL.json.gz', + 'PLAN.json.gz', 'TEMPLATE.json.gz', 'PR4085-PROFILE.json')] + pairs += [('owner/old-NATIVE-' + s + '.json.gz', 'inputs/NATIVE-' + s + '.json.gz') + for s in ('base', 'extra')] + pairs += [('inputs/' + k + '-' + s + '.json.gz', 'inputs/' + k + '-' + s + '.json.gz') + for k in ('THREE', 'FOUR') for s in ('base', 'extra')] + for left, right in pairs: + raw = sources.raw(PACKAGE / left) + # PR4165's duplicate input is authenticated by exact equality to the pinned PR4088 bytes. + other = sources.raw(PREDECESSOR / right, authenticate=False) + require(raw == other, 'cross-package-source', left) + order = read(PACKAGE / 'owner/ORDER.json') + template = read(PACKAGE / 'owner/TEMPLATE.json.gz') + plan = read(PACKAGE / 'owner/PLAN.json.gz') + phases = read(PACKAGE / 'inputs/DATA-PHASES.json') + require(template['exact_data_phase_recipe_sha256'] == sources.consumed[(PACKAGE / 'inputs/DATA-PHASES.json').as_posix()], + 'phase-pin') + clock, windows, stage_pairs = exact_windows(order, template, plan, phases) + old = read(PACKAGE / 'owner/DISPATCH.json') + new = read(PACKAGE / 'owner/MIXED-DISPATCH.json') + require(len(old) == len(new) == 3240, 'dispatch-row-count') + predecessor = {(s, r): provider for s, r, provider in old} + dispatch = {(s, r): provider for s, r, provider in new} + require(len(predecessor) == len(dispatch) == 3240 and set(dispatch) == set(clock) == set(predecessor), + 'dispatch-identity') + require(new == [[s, r, provider + ('-four' if 109 * clock[s, r] % 324 < 109 else '')] + for s, r, provider in old], 'literal-selector') + counts = Counter(dispatch.values()) + require(counts == Counter({'gauge44': 1040, 'gauge44-four': 528, 'extra': 1110, 'extra-four': 562}), + 'provider-counts') + origin = read(PACKAGE / 'owner/old-NATIVE-base.json.gz')['helper_origin'] + require(origin == read(PACKAGE / 'owner/old-NATIVE-extra.json.gz')['helper_origin'], 'orientation-origin') + widths, profiles, inventories = {}, {}, {} + for tag, provider in (('base', 'gauge44'), ('extra', 'extra')): + for kind, suffix in (('THREE', ''), ('FOUR', '-four')): + word = read(PACKAGE / f'inputs/{kind}-{tag}.json.gz') + name = provider + suffix + require(origin == sorted(set(range(224, 704)) - set(word['removed'])), 'helper-origin') + widths[name] = [rank(word['helper_final'].get(str(h), [1 << i for i in range(9)])) + - rank(word['start_extra'].get(str(h), [])) for h in origin] + profiles[name] = {int(r): n for r, n in word['report']['local_profile'].items()} + inventories[name] = dict(sorted(Counter(widths[name]).items())) + native_kind = 'THREE-CANONICAL' if kind == 'THREE' else 'NATIVE-CANONICAL' + canonical = read(PACKAGE / f'evidence/{native_kind}-{tag}.json.gz') + require(canonical['helper_origin'] == origin, 'native-helper-map') + native_widths = [rank(canonical['frames'][canonical['final'][r]]) + - rank(canonical['frames'][canonical['start'][r]]) for r in range(224, 632)] + require(native_widths == widths[name], 'native-candidate-widths') + for provider in ('gauge44', 'extra'): + changes = [(h, origin[h], a, b) for h, (a, b) in + enumerate(zip(widths[provider], widths[provider + '-four'])) if a != b] + require(changes == [(367, 601, 8, 7)], 'width-changes') + fill = read(PACKAGE / 'owner/FILL.json.gz') + require(fill['columns'] == ['time', 'helper', 'owner_replica', 'child', 'port', 'offset'] + and fill['dispatch_overrides'] == [], 'fill-schema') + rows = fill['rows'] + result = read(PACKAGE / 'RESULT.json') + def walk(chosen_dispatch=dispatch, first_row_override=None): + return scan(rows, order, chosen_dispatch, windows, stage_pairs, phases, widths, first_row_override) + scanned = walk() + profile = invoice(counts, profiles, scanned['idle'], result) + controls = [] + if args.controls: + changed_dispatch = dict(dispatch) + require(dispatch[tuple(order[0])] == 'extra-four', 'control-t0-provider') + changed_dispatch[tuple(order[0])] = 'extra' + controls.append(reject('stamp-three-t0', 'compact-prefix', 'row 29389: expected 8, got 7', + lambda: walk(changed_dispatch))) + bad_row = list(rows[0]) + bad_row[-1] += 1 + controls.append(reject('offset-hole', 'compact-prefix', 'row 0: expected 0, got 1', + lambda: walk(first_row_override=bad_row))) + bad_profiles = {provider: dict(values) for provider, values in profiles.items()} + bad_profiles['extra-four'][1] += 1 + controls.append(reject('extra-rank-one', 'complete-profile', '', + lambda: invoice(counts, bad_profiles, scanned['idle'], result))) + output = dict(status='PASS_INDEPENDENT_MIXED_LEDGER', provider_counts=dict(counts), + width_histograms=inventories, first_helper601_per_provider=scanned.pop('first'), + profile=profile, rows=len(rows), exact_windows_including_zero_slots=len(windows), + paid_rank_mass=sum(r * n for r, n in profile.items()), controls=controls, + consumed_sources=dict(sorted(sources.consumed.items())), **scanned) + print(json.dumps(output, sort_keys=True, indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/mixed-provider-admission/native_outputs.py b/research/mixed-provider-admission/native_outputs.py new file mode 100644 index 0000000000..4b7e6b217b --- /dev/null +++ b/research/mixed-provider-admission/native_outputs.py @@ -0,0 +1,56 @@ +"""Authenticate the scientific products of all five native stages. + +SPDX-License-Identifier: Apache-2.0 +Completion flags are not output commitments. This closure is fixed by recorded +honest executions, not regenerated from a caller's cache during verification. +Only two root elapsed-time fields and gzip transport bytes are normalized. +""" +import hashlib +import json +import math +from pathlib import Path + +from binding import need, read, sha + +HERE = Path(__file__).resolve().parent +STAGES = ("native", "ledgers", "local-replay", "wrappers", "phases") +REFERENCES = {"canonical_word_sha256": "CANONICAL-WORD.json.gz", + "local_programs_sha256": "LOCAL-PROGRAMS.json.gz", + "recipe_sha256": "CLIFFORD-RECIPES.json"} + + +def digest(value): + return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":"), + allow_nan=False).encode()).hexdigest() + + +def scientific_products(native): + steps = read(native / "STEPS.json") + need([s["step"] for s in steps] == list(STAGES) + and all(type(s["exit_code"]) is int and s["exit_code"] == 0 for s in steps), + "actual native stage products coverage") + local = native / "local" + products = {} + for path in sorted(local.iterdir()): + need(path.is_file() and not path.is_symlink(), "ordinary native product") + value = read(path) + if path.name in ("SCALAR-FRAME-AUDIT.json", "CLIFFORD-REVIEW.json"): + seconds = value.pop("seconds") + need(type(seconds) in (int, float) and math.isfinite(seconds) and seconds >= 0, + "finite nonnegative native timing") + for field, target in REFERENCES.items(): + if field in value: + need(value[field] == sha(local / target), "stale native reference: " + path.name) + value[field] = digest(read(local / target)) + products[path.name] = digest(value) + need({p.relative_to(native).as_posix() for p in native.rglob("*") if p.is_file()} + == {"STEPS.json"} | {"local/" + n for n in products}, "native output file closure") + return products + + +def authenticate_native(pid, word_sha256, native): + expected = read(HERE / "NATIVE-OUTPUTS.json")["providers"][pid] + need(expected["word_sha256"] == word_sha256, "native commitment word binding") + actual = scientific_products(native) + need(actual == expected["products"], "native scientific output commitment") + return actual diff --git a/research/mixed-provider-admission/replay.py b/research/mixed-provider-admission/replay.py new file mode 100644 index 0000000000..fe8ac09fd0 --- /dev/null +++ b/research/mixed-provider-admission/replay.py @@ -0,0 +1,250 @@ +#!/usr/bin/env python3 +"""Run the source-bound four-provider extension in a fresh external directory. + +SPDX-License-Identifier: Apache-2.0 +Prepared for yssite with substantial OpenAI Codex assistance. +No frontier record is modified. Finite release is not an all-size proof. +""" +import argparse +from importlib.metadata import version +import importlib.util +import os +from pathlib import Path +import shutil +import signal +import subprocess +import sys +import time + +from adapt import BASE_ENGINE, BASE_MANIFEST, HERE, MIXED, REPO, TAGS, extend_engine, extend_source, tree, write +from binding import need, read, sha +from native_outputs import authenticate_native +from sources import authenticate_sources + +PREDECESSOR = REPO / "research/kappa-operator-repair/late-staged-composition" +STAGES = ["native", "ledgers", "local-replay", "wrappers", "phases"] +DEPENDENCIES = {"numpy": "2.3.5", "scipy": "1.17.0", "sympy": "1.14.0", "mpmath": "1.3.0"} + + +def baseline_preflight(output): + """Redirect output placement only; the predecessor's exact pins still apply.""" + output.mkdir() + shutil.copytree(PREDECESSOR / "candidate", output / "candidate") + path = PREDECESSOR / "run_release.py" + spec = importlib.util.spec_from_file_location("pr4085_preflight", path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + module.HERE = output + saved = sys.argv + sys.argv = [str(path), "--work", str(output / "release-work/preflight"), "--preflight-only"] + try: + module.main() + finally: + sys.argv = saved + return output / "release-work/preflight" + + +def check_preflight(baseline): + result = read(baseline / "PREFLIGHT-RESULT.json") + need(result["status"] == "PASS_ALL_THREE_WORD_REVIEWS_SOURCE_READY_NOT_ADMITTED", + "completed predecessor preflight") + need(result["runner_sha256"] == sha(PREDECESSOR / "run_release.py"), + "preflight runner binding") + need(result["source_manifest_sha256"] == BASE_MANIFEST + == sha(baseline / "inputs/source/MANIFEST.json"), "preflight source pin") + need(result["source_files"] == 676, "preflight source count") + need(result["candidate_gzip_sha256"] == + {tag: sha(MIXED / f"inputs/THREE-{tag}.json.gz") for tag in ("base", "extra")}, + "preflight candidate bindings") + need(result["admission_engine_sha256"] == BASE_ENGINE + == sha(baseline / "admit_composed.py"), "preflight admission engine") + for field, name in (("source_adaptation_sha256", "SOURCE-ADAPTATION.json"), + ("admission_adapter_receipt_sha256", "COMPOSED-ADMISSION-ADAPTER.json")): + need(result[field] == sha(baseline / name), "preflight adaptation binding") + need(read(baseline / "COMPOSED-ADMISSION-ADAPTER.json")["adapted_sha256"] == BASE_ENGINE, + "preflight effective engine") + need(tree(baseline / "inputs/source", ("MANIFEST.json",)) + == read(baseline / "inputs/source/MANIFEST.json"), "preflight source inventory") + expected = ["independent-terminal-word", "independent-staged-word", "independent-receiver-word"] + need(read(baseline / "STAGES.json") == result["completed_reviews"], + "preflight stage receipt equality") + need([s["name"] for s in result["completed_reviews"]] == expected, + "predecessor review coverage") + for s in result["completed_reviews"]: + need(s["exit_code"] == 0 and sha(baseline / (s["name"] + ".log")) == s["log_sha256"], + "completed predecessor review log") + inventory = read(PREDECESSOR.parent / "sources/PR4076/research/" + "staged544-triple-entry-fill/admission/pr3945/PREDECESSOR.json")["files"] + retained = {n: h for n, h in inventory.items() if not n.startswith("source/")} + actual = {n: h for n, h in tree(baseline / "inputs").items() if not n.startswith("source/")} + need(actual == retained, "all 95 retained engine/helper/native-cache input bindings") + + +def bind_cache(baseline, source, output, native_dirs, fresh_tags=()): + cache = output / "native-cache" + shutil.copytree(baseline / "inputs/native-cache", cache) + receipt = read(baseline / "inputs/NATIVE-RECEIPT.json") + need(tree(cache) == receipt["cache_files"], "retained parent cache") + compiler = tree(source / "new/fastnative/vendor") + bindings = {} + for pid, tag in TAGS.items(): + origin = native_dirs[tag] + result = read(origin / "RESULT.json") + word = source / f"new/borrow/words/BORROW-WORD-43{tag}.json.gz" + need(result["status"] == "PASS_COMPLETE_T74_NATIVE_REPLAY" + and result["word_sha256"] == sha(word), "native source input") + need(result["source_sha256"] == compiler == tree(origin / "source"), + "exact native compiler closure") + need([r["step"] for r in result["steps"]] == STAGES + and all(r["exit_code"] == 0 for r in result["steps"]), "native five-stage coverage") + native = origin / "native" + need(read(native / "local/FULL-WORD.json.gz") == read(word), "native full word") + products = authenticate_native(pid, sha(word), native) + evidence = "NATIVE" if tag.endswith("-four") else "THREE" + base = tag.split("-")[0] + need(read(native / "local/CANONICAL-WORD.json.gz") + == read(MIXED / f"evidence/{evidence}-CANONICAL-{base}.json.gz"), + "retained canonical native identity") + entry = cache / sha(word) + need(not entry.exists(), "fresh candidate cache entry") + shutil.copytree(native, entry) + write(entry / "CACHE.json", dict(word_sha256=sha(word), files=tree(entry))) + receipt["providers"][tag] = dict(word_sha256=sha(word), + complete_native_files=tree(entry, ("CACHE.json",))) + bindings[pid] = dict(word_sha256=sha(word), compiler=compiler, + native_result_sha256=sha(origin / "RESULT.json"), + canonical_sha256=sha(entry / "local/CANONICAL-WORD.json.gz"), + scientific_products=products, + execution=("executed_by_this_driver" if tag in fresh_tags else + "explicitly_supplied_cache" if tag.endswith("-four") else + "retained_PR4085")) + receipt.update(source_commit="pr4088-four-provider-admission-v1", + manifest_sha256=sha(source / "MANIFEST.json"), cache_files=tree(cache)) + write(output / "NATIVE-RECEIPT.json", receipt) + write(output / "PROVIDER-BINDINGS.json", bindings) + return cache + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument("--work", type=Path, required=True) + ap.add_argument("--checked-preflight", type=Path) + ap.add_argument("--four-native-base", type=Path) + ap.add_argument("--four-native-extra", type=Path) + ap.add_argument("--prepare-only", action="store_true") + args = ap.parse_args() + need(__debug__, "inherited admission requires assertions") + authenticate_sources() + need(sys.version_info[:2] == (3, 12), "full replay requires Python 3.12") + need({name: version(name) for name in DEPENDENCIES} == DEPENDENCIES, + "full replay dependency pins") + if os.name == "posix": + # Let the stage's finally block clean its process group on termination. + signal.signal(signal.SIGTERM, lambda *_: sys.exit(128 + signal.SIGTERM)) + work = args.work.resolve() + need(not work.exists() and not work.is_relative_to(REPO), "fresh external work") + work.mkdir(parents=True) + # Research subprocesses do not inherit account credentials or network configuration. + env = dict(PATH=os.environ["PATH"], PYTHONDONTWRITEBYTECODE="1", PYTHONUTF8="1", + PYTHONINTMAXSTRDIGITS="0", OPENBLAS_NUM_THREADS="1", OMP_NUM_THREADS="1", + AUDIT_RUNTIME_CONTROLS="fork" if hasattr(os, "fork") else "pickle") + stages = [] + + def run(name, command, timeout=1800): + started = time.monotonic() + log = work / (name + ".log") + with log.open("w") as stream: + process = subprocess.Popen(command, env=env, stdin=subprocess.DEVNULL, + stdout=stream, stderr=subprocess.STDOUT, + start_new_session=(os.name == "posix")) + try: + code = process.wait(timeout=timeout) + finally: + # A bounded replay must also stop descendants after failure or + # interruption. Proof-relevant children must finish before success. + if os.name == "posix": + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + elif process.poll() is None: + process.kill() + process.wait() + stages.append(dict(name=name, exit_code=code, seconds=time.monotonic()-started, + log_sha256=sha(log))) + write(work / "STAGES.json", stages) + need(code == 0, "failed " + name + "; inspect its log") + print("PASS", name, flush=True) + + # These source-specific word and all-character gates supplement the inherited release. + for name in ("verify.py", "owner_verify.py", "operator_verify.py"): + run("pr4088-" + name[:-3], [sys.executable, "-B", str(MIXED / name), "--controls"], 300) + if args.checked_preflight: + baseline = args.checked_preflight.resolve() + else: + # The source reconstruction also runs in the credential-free child + # environment, rather than importing predecessor code in the caller. + run("predecessor-preflight", + [sys.executable, "-B", "-c", + "import sys; from pathlib import Path; sys.path.insert(0, sys.argv[1]); " + "from replay import baseline_preflight; baseline_preflight(Path(sys.argv[2]))", + str(HERE), str(work / "baseline")], 300) + baseline = work / "baseline/release-work/preflight" + check_preflight(baseline) + source = work / "source" + _, changes = extend_source(baseline, source) + changes += extend_engine(baseline, source, work / "admit_mixed.py") + write(work / "ADAPTATION.json", changes) + natives = {tag: PREDECESSOR / ("native-" + tag) for tag in ("base", "extra")} + fresh_tags = set() + for tag in ("base", "extra"): + supplied = getattr(args, "four_native_" + tag) + if supplied: + natives[tag + "-four"] = supplied.resolve() + else: + natives[tag + "-four"] = work / ("native-four-" + tag) + run("native-four-" + tag, [sys.executable, "-B", str(MIXED / "native/run_native.py"), + str(MIXED / f"inputs/FOUR-{tag}.json.gz"), + str(natives[tag + "-four"])], 900) + fresh_tags.add(tag + "-four") + cache = bind_cache(baseline, source, work, natives, fresh_tags) + source_before = tree(source) + cache_before = tree(cache) + original = baseline / "inputs" + arguments = { + "source": source, "fill": MIXED / "owner/FILL.json.gz", + "order": MIXED / "owner/ORDER.json", "dispatch": MIXED / "owner/MIXED-DISPATCH.json", + "native-cache": cache, "native-receipt": work / "NATIVE-RECEIPT.json", + "work": work / "admission", "replica-helper-dir": work / "helpers", + "reconstructor": work / "helpers/reconstruct_replica.py", + "comparison-claim": REPO / "research/staged544-triple-entry-fill/admission/pr3945/PR3682-CLAIM.json", + "blocknorm-checker": original / "extension_blocknorm.py", + } + command = [sys.executable, "-B", str(work / "admit_mixed.py")] + for key, value in arguments.items(): + command += ["--" + key, str(value)] + command += ["--source-profile", "staged544", "--comparison-profile", "pr3682", "--jobs", "1"] + if args.prepare_only: + command.append("--prepare-only") + run("inherited-admission", command, 2400) + need(tree(source) == source_before and tree(cache) == cache_before, + "immutable source/cache after admission") + result = read(work / "admission/RESULT.json") + need(result["profile"] == read(MIXED / "RESULT.json")["profile"], "complete profile") + if args.prepare_only: + need(result["status"] == "PREPARED_REPLICA_SAME_WORD_DERIVATIVE_NOT_ADMITTED", + "preparation is not admission") + else: + need(result["status"] == "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", + "complete inherited release") + write(work / "RESULT.json", dict(status=result["status"], stages=stages, + admission_result_sha256=sha(work / "admission/RESULT.json"), + source_manifest_sha256=sha(source / "MANIFEST.json"), + runtime=dict(python=sys.version.split()[0], + dependencies=DEPENDENCIES, platform=sys.platform), + selected_frontier_changed=False)) + print(result["status"], flush=True) + + +if __name__ == "__main__": + main() diff --git a/research/mixed-provider-admission/sources.py b/research/mixed-provider-admission/sources.py new file mode 100644 index 0000000000..d5a8460242 --- /dev/null +++ b/research/mixed-provider-admission/sources.py @@ -0,0 +1,21 @@ +"""Live-input authentication for direct commands as well as registered replay. + +SPDX-License-Identifier: Apache-2.0 +Git provenance is separately checked by the repository package validator. +""" +from pathlib import Path + +from binding import need, read, sha + +HERE = Path(__file__).resolve().parent +REPO = HERE.parents[1] + + +def authenticate_sources(root=REPO): + rows = [r for r in read(HERE / "SOURCES.json")["files"] if r["usage"] == "input"] + for row in rows: + path = root / row["path"] + need(path.resolve().is_relative_to(root.resolve()) and not path.is_symlink(), + "ordinary in-tree source input") + need(sha(path) == row["sha256"], "changed live source: " + row["path"]) + return len(rows) diff --git a/research/mixed-provider-admission/test_binding.py b/research/mixed-provider-admission/test_binding.py new file mode 100644 index 0000000000..03b3f8b831 --- /dev/null +++ b/research/mixed-provider-admission/test_binding.py @@ -0,0 +1,223 @@ +"""Semantic controls for the new binding, independent of source-hash failures. + +SPDX-License-Identifier: Apache-2.0 +Prepared for yssite with substantial OpenAI Codex assistance. +""" +import json +from pathlib import Path +import shutil +import tempfile +import unittest + +from binding import account, sha, validate_rebind +from native_outputs import authenticate_native +from replay import PREDECESSOR + + +def fixture(): + """Four real provider kinds, reduced to the shared 7/8-width boundary.""" + pids = ["extra-four", "extra", "gauge44", "gauge44-four"] + registry = { + p: {"widths": [7 if p.endswith("-four") else 8], + "actual_paid_profile": {"1": 2 if p.endswith("-four") else 1}, + "orientation_program_sha256": {o: p + ":" + o for o in ("forward", "backward")}} + for p in pids + } + plan = dict(order=[[s, 0] for s in range(4)], provider_registry=registry, + pairs={"0": 0}, sides={"0": 0}, + windows={"0,0": [16, [0, 1]], "1,0": [16, [2, 3]]}, + provider_calls=[], per_call_widths=[]) + roles, dispatch = [], [] + for t, pid in enumerate(pids): + ori = "forward" if t % 2 == 0 else "backward" + plan["provider_calls"].append(dict(stage=t, replica=0, time=t, provider=pid, + orientation=ori, local_program_sha256=pid + ":" + ori)) + plan["per_call_widths"].append(dict(stage=t, replica=0, time=t, + widths=registry[pid]["widths"][:])) + roles.append(dict(time=t, helper=0, stage=t, replica=0, owner_replica=t // 2, + child=0, port=107, family=896 * (t // 2) + 107, + copy=112 * (t // 2) + 107, offset=[0, 7, 0, 8][t], + width=registry[pid]["widths"][0])) + dispatch.append([t, 0, pid]) + return plan, roles, dispatch + + +class CallBindingTests(unittest.TestCase): + def test_positive_complements_and_row_order(self): + p, r, d = fixture() + idle, total = account(p, r, d) + self.assertEqual(idle, {1: 2, 16: 222}) + self.assertEqual(total, {1: 8, 16: 222}) + self.assertEqual(account(p, r, list(reversed(d))), (idle, total)) + + def test_wrong_dispatch_with_coherent_call_metadata(self): + p, r, d = fixture() + # Keep counts, programs, per-call widths and row widths coherent, but + # exchange which call uses FOUR. The old second offset is now illegal. + d[0][2], d[1][2] = d[1][2], d[0][2] + for t in (0, 1): + pid = d[t][2] + c = p["provider_calls"][t] + c["provider"] = pid + c["local_program_sha256"] = pid + ":" + c["orientation"] + p["per_call_widths"][t]["widths"] = p["provider_registry"][pid]["widths"][:] + r[t]["width"] = p["provider_registry"][pid]["widths"][0] + with self.assertRaisesRegex(ValueError, "compact per-call residual prefix"): + account(p, r, d) + + def test_omitted_provider(self): + p, r, d = fixture() + del p["provider_registry"]["gauge44-four"] + with self.assertRaisesRegex(ValueError, "complete provider usage"): + account(p, r, d) + + def test_program_binding_even_when_widths_agree(self): + p, r, d = fixture() + p["provider_calls"][2]["local_program_sha256"] = "extra:forward" + with self.assertRaisesRegex(ValueError, "per-call program binding"): + account(p, r, d) + + def test_averaged_width_or_wrong_orientation(self): + for field, value, reason in ( + ("width", 8, "actual selected helper width"), + ("orientation", "backward", "per-call orientation"), + ): + p, r, d = fixture() + if field == "width": + r[0][field] = value + else: + p["provider_calls"][0][field] = value + with self.assertRaisesRegex(ValueError, reason): + account(p, r, d) + + def test_capacity_window_hole_and_duplicate(self): + mutations = [ + (lambda p, r, d: r[0].__setitem__("offset", 1), "compact per-call residual prefix"), + (lambda p, r, d: p["windows"]["0,0"].__setitem__(0, 14), "compact per-call residual prefix"), + (lambda p, r, d: p["windows"]["0,0"].__setitem__(1, [1]), "strict inherited window"), + (lambda p, r, d: d.__setitem__(1, d[0][:]), "dispatch bijection"), + ] + for mutate, reason in mutations: + with self.subTest(reason=reason): + p, r, d = fixture() + mutate(p, r, d) + with self.assertRaisesRegex(ValueError, reason): + account(p, r, d) + + +class RebindContractTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.addCleanup(self.temp.cleanup) + self.pkg = Path(self.temp.name) + (self.pkg / "new").mkdir() + self.plan, roles, dispatch = fixture() + idle, total = account(self.plan, roles, dispatch) + self.plan["profile"] = {str(r): n for r, n in total.items()} + self.contract = {"providers": {}, "dispatch": list(reversed(dispatch))} + self.locs = {} + + def put(path, value): + path.write_text(json.dumps(value)) + self.put = put + # This reduced fixture tests the binder contract, not native semantics; + # NativeProductTests uses the real source-bound native products. + for pid, desc in self.plan["provider_registry"].items(): + word = self.pkg / (pid + ".json") + value = {"provider": pid} + put(word, value) + local = self.pkg / pid + local.mkdir() + put(local / "FULL-WORD.json", value) + import gzip + (local / "FULL-WORD.json.gz").write_bytes(gzip.compress(json.dumps(value).encode())) + width = desc["widths"][0] + canonical = {"R": 1, "frames": [[], [1 << i for i in range(width)]], + "start": [0] * 225, "final": [0] * 224 + [1]} + (local / "CANONICAL-WORD.json.gz").write_bytes(gzip.compress(json.dumps(canonical).encode())) + put(local / "LOCAL-CHECKS.json", + {o: {"paid_profile": desc["actual_paid_profile"]} for o in ("forward", "backward")}) + self.contract["providers"][pid] = dict(word=word.name, word_sha256=sha(word), + widths=desc["widths"], profile=desc["actual_paid_profile"]) + self.locs[pid] = local + put(self.pkg / "new/MIXED-CONTRACT.json", self.contract) + put(self.pkg / "DISPATCH.json", dispatch) + import gzip + (self.pkg / "OWNERS.json.gz").write_bytes(gzip.compress(json.dumps(roles).encode())) + put(self.pkg / "CONSTRUCTION.json", {"idle": idle}) + + def test_positive_rebind_with_different_table_order(self): + self.assertEqual(validate_rebind(self.pkg, self.plan, self.locs), {1: 2, 16: 222}) + + def test_stale_idle(self): + self.put(self.pkg / "CONSTRUCTION.json", {"idle": {1: 1, 16: 222}}) + with self.assertRaisesRegex(ValueError, "stale construction idle"): + validate_rebind(self.pkg, self.plan, self.locs) + + def test_source_change(self): + (self.pkg / "gauge44-four.json").write_text('{"provider":"different"}') + with self.assertRaisesRegex(ValueError, "provider source changed"): + validate_rebind(self.pkg, self.plan, self.locs) + + def test_missing_provider_and_changed_selector(self): + locs = dict(self.locs) + del locs["gauge44-four"] + with self.assertRaisesRegex(ValueError, "complete four-provider binding"): + validate_rebind(self.pkg, self.plan, locs) + dispatch = json.loads((self.pkg / "DISPATCH.json").read_text()) + dispatch[0][2], dispatch[1][2] = dispatch[1][2], dispatch[0][2] + self.put(self.pkg / "DISPATCH.json", dispatch) + with self.assertRaisesRegex(ValueError, "literal mixed selector"): + validate_rebind(self.pkg, self.plan, self.locs) + + +class NativeProductTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.source = PREDECESSOR / "native-base/native" + cls.word_sha = json.loads((PREDECESSOR / "native-base/RESULT.json").read_text())["word_sha256"] + + def test_real_retained_positive_control(self): + self.assertEqual(len(authenticate_native("gauge44", self.word_sha, self.source)), 11) + + def test_phase_change_with_rebound_receipts(self): + with tempfile.TemporaryDirectory() as td: + out = Path(td) / "native" + shutil.copytree(self.source, out) + path = out / "local/CLIFFORD-RECIPES.json" + recipe = json.loads(path.read_text()) + recipe["warps"][0]["left"]["phase"] = (recipe["warps"][0]["left"]["phase"] + 1) % 4 + path.write_text(json.dumps(recipe)) + # Rebind both receipt references, so rejection cannot be attributed + # to a stale raw hash or the intentionally unchanged success flags. + for name in ("CLIFFORD-REVIEW.json", "WARP-RECIPE-CHECKS.json"): + receipt = out / "local" / name + value = json.loads(receipt.read_text()) + value["recipe_sha256"] = sha(path) + receipt.write_text(json.dumps(value)) + with self.assertRaisesRegex(ValueError, "native scientific output commitment"): + authenticate_native("gauge44", self.word_sha, out) + + def test_missing_phase_stage(self): + with tempfile.TemporaryDirectory() as td: + out = Path(td) / "native" + shutil.copytree(self.source, out) + path = out / "STEPS.json" + path.write_text(json.dumps(json.loads(path.read_text())[:-1])) + with self.assertRaisesRegex(ValueError, "actual native stage products coverage"): + authenticate_native("gauge44", self.word_sha, out) + + def test_uncovered_endpoint_claim(self): + with tempfile.TemporaryDirectory() as td: + out = Path(td) / "native" + shutil.copytree(self.source, out) + path = out / "local/INDEPENDENT-LOCAL-REPLAY.json" + value = json.loads(path.read_text()) + value["local"]["backward"]["private_work_erased"] = False + path.write_text(json.dumps(value)) + with self.assertRaisesRegex(ValueError, "native scientific output commitment"): + authenticate_native("gauge44", self.word_sha, out) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/research/mixed-provider-admission/verify.py b/research/mixed-provider-admission/verify.py new file mode 100644 index 0000000000..7cb49ffd62 --- /dev/null +++ b/research/mixed-provider-admission/verify.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python3 +"""Bounded binding regression; full inherited release uses replay.py separately. + +SPDX-License-Identifier: Apache-2.0 +Prepared for yssite with substantial OpenAI Codex assistance. +""" +import json +import sys +import unittest + +from adapt import MIXED, TAGS +from binding import account, need, read +from sources import authenticate_sources + + +def real_call_binding(): + # Reuse PR4088's declared source-window interpretation, not its walk(). + # The separate campaign scanner also challenged this interpretation from + # exact event positions and actual phase-axis lists. + sys.path.insert(0, str(MIXED)) + from owner_verify import context + order, selected, windows, family, widths, profiles = context() + original = read(MIXED / "owner/PLAN.json.gz") + registry = {} + for pid, tag in TAGS.items(): + kind = "NATIVE" if tag.endswith("-four") else "THREE" + checks = read(MIXED / f"evidence/{kind}-LOCAL-{tag.split('-')[0]}.json") + registry[pid] = dict(widths=widths[pid], actual_paid_profile=profiles[pid], + orientation_program_sha256={o: checks[o]["sha256"] + for o in ("forward", "backward")}) + calls, per_call = [], [] + for time, (stage, replica) in enumerate(order): + pid = selected[stage, replica] + orientation = "forward" if stage % 2 == 0 else "backward" + calls.append(dict(stage=stage, replica=replica, time=time, provider=pid, orientation=orientation, + local_program_sha256=registry[pid]["orientation_program_sha256"][orientation])) + per_call.append(dict(stage=stage, replica=replica, time=time, widths=widths[pid])) + plan = dict(order=order, provider_registry=registry, provider_calls=calls, per_call_widths=per_call, + pairs=original["pairs"], sides=original["sides"], + windows={f"{o},{c}": (cap, range(lo + 1, hi + 1)) + for (o, c), (cap, lo, hi) in windows.items()}) + rows = read(MIXED / "owner/FILL.json.gz")["rows"] + + class Roles: + def __len__(self): + return len(rows) + + def __iter__(self): + for time, helper, owner, child, port, offset in rows: + stage, replica = order[time] + yield dict(time=time, helper=helper, stage=stage, replica=replica, + owner_replica=owner, child=child, port=port, offset=offset, + family=896 * owner + 112 * family[child] + port, + copy=112 * owner + port, width=widths[selected[stage, replica]][helper]) + + idle, total = account(plan, Roles(), read(MIXED / "owner/MIXED-DISPATCH.json")) + expected = read(MIXED / "RESULT.json") + need(idle == {int(k): v for k, v in expected["idle"].items()}, "actual idle") + need(total == {int(k): v for k, v in expected["profile"].items()}, "actual complete profile") + return dict(rows=len(rows), calls=len(order), providers=len(registry), idle=idle, profile=total) + + +def main(): + inputs = authenticate_sources() + suite = unittest.defaultTestLoader.loadTestsFromName("test_binding") + result = unittest.TextTestRunner(verbosity=1).run(suite) + need(result.wasSuccessful(), "binding controls") + finite = real_call_binding() + print(json.dumps(dict(status="PASS_FOUR_PROVIDER_BINDING_REGRESSION", live_inputs=inputs, + tests=result.testsRun, finite=finite, + scope="Binding and negative controls only; full release is a separate command."), + sort_keys=True)) + + +if __name__ == "__main__": + main() From 15a4153e734a8d1d485c6d3bea9b1a8201328a4c Mon Sep 17 00:00:00 2001 From: yssite <175725951+yssite@users.noreply.github.com> Date: Tue, 20 Oct 2026 09:07:18 +0000 Subject: [PATCH 2/2] Record clean four-provider admission evidence --- .../mixed-provider-admission/EVIDENCE.json | 648 ++++++++++++++++++ research/mixed-provider-admission/EVIDENCE.md | 97 ++- research/mixed-provider-admission/README.md | 14 +- research/mixed-provider-admission/REPLAY.log | 84 +++ research/mixed-provider-admission/TASK.json | 4 +- 5 files changed, 831 insertions(+), 16 deletions(-) create mode 100644 research/mixed-provider-admission/EVIDENCE.json create mode 100644 research/mixed-provider-admission/REPLAY.log diff --git a/research/mixed-provider-admission/EVIDENCE.json b/research/mixed-provider-admission/EVIDENCE.json new file mode 100644 index 0000000000..0e230402e3 --- /dev/null +++ b/research/mixed-provider-admission/EVIDENCE.json @@ -0,0 +1,648 @@ +{ + "actual_inherited_controls": { + "admission": 201, + "bit": 12, + "controller": 43, + "geometry": 6, + "independent_owner": 8 + }, + "actual_output_challenges": [ + { + "name": "actual predecessor preflight", + "status": "PASS" + }, + { + "name": "gauge44 actual native products", + "status": "PASS" + }, + { + "name": "gauge44 wrong phase with all recipe references rebound", + "reason": "native scientific output commitment", + "status": "REJECTED" + }, + { + "name": "gauge44 skipped phase stage", + "reason": "actual native stage products coverage", + "status": "REJECTED" + }, + { + "name": "gauge44 equivalent serialization and timing", + "status": "PASS" + }, + { + "name": "extra actual native products", + "status": "PASS" + }, + { + "name": "extra wrong phase with all recipe references rebound", + "reason": "native scientific output commitment", + "status": "REJECTED" + }, + { + "name": "extra skipped phase stage", + "reason": "actual native stage products coverage", + "status": "REJECTED" + }, + { + "name": "extra equivalent serialization and timing", + "status": "PASS" + }, + { + "name": "gauge44-four actual native products", + "status": "PASS" + }, + { + "name": "gauge44-four wrong phase with all recipe references rebound", + "reason": "native scientific output commitment", + "status": "REJECTED" + }, + { + "name": "gauge44-four skipped phase stage", + "reason": "actual native stage products coverage", + "status": "REJECTED" + }, + { + "name": "gauge44-four equivalent serialization and timing", + "status": "PASS" + }, + { + "name": "extra-four actual native products", + "status": "PASS" + }, + { + "name": "extra-four wrong phase with all recipe references rebound", + "reason": "native scientific output commitment", + "status": "REJECTED" + }, + { + "name": "extra-four skipped phase stage", + "reason": "actual native stage products coverage", + "status": "REJECTED" + }, + { + "name": "extra-four equivalent serialization and timing", + "status": "PASS" + }, + { + "name": "changed engine with rebound completion receipt", + "reason": "preflight admission engine", + "status": "REJECTED" + } + ], + "claim": "The exact retained PR4088 four-provider construction passes the extended inherited finite ordinary/outer release with source-bound per-call widths and a recomputed complete idle invoice.", + "development_release": { + "inherited_seconds": 1780.780658912, + "status": "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE" + }, + "discovery_stages": [ + { + "exit_code": 0, + "log_sha256": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "name": "bind", + "seconds": 5.425385736999942 + }, + { + "exit_code": 0, + "log_sha256": "b8f4202fcfa93e19069e726c949b8eefee864eb8a22338dc60e9edce5f7997ba", + "name": "emit", + "seconds": 139.54207018600027 + }, + { + "exit_code": 0, + "log_sha256": "644a2e44045b134104bc7bb45fbda8642347168a8cf32f54fc7af79d5ac8e5a0", + "name": "audit", + "seconds": 396.46721273 + }, + { + "exit_code": 0, + "log_sha256": "a5319a1c6c21f33f7e7f3c4ba3c8b44edd00795f95bf2f457c1e9c13c2445968", + "name": "invoice", + "seconds": 17.163060288999986 + }, + { + "exit_code": 0, + "log_sha256": "7358a8a7e6ee53cd295162c695895ce04ea910655b119c7b64381ffd9395ce39", + "name": "assembly", + "seconds": 0.5220512509995388 + }, + { + "exit_code": 0, + "log_sha256": "fe7a44e785ab2226b2f52945f27fd0362c02f9e0d02c26e4e10f24ff96ddafd1", + "name": "freeze", + "seconds": 0.05886043000009522 + }, + { + "exit_code": 0, + "log_sha256": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "name": "independent", + "seconds": 25.74216463099947 + } + ], + "driver_stages": [ + { + "exit_code": 0, + "log_sha256": "e2b3ca9377e03e9b25cfb7b5086dac5833f75526298c476409bc69f570594886", + "name": "owners", + "script_sha256": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "seconds": 36.32757500799971 + }, + { + "exit_code": 0, + "log_sha256": "2d738a7322c4303d36deb694e6d79b6b51bfe098642bf5cda8abc319f03d66ab", + "name": "parent-lift", + "script_sha256": "66ed2b2287add939b30af2b9bac22570b93d0a74d902afb5de5fa65cba9d3cac", + "seconds": 71.65258922000021 + }, + { + "exit_code": 0, + "log_sha256": "d68f6853059855ffaa204aaf3d3132d04d69480db5fc7e955b06ac77171ae920", + "name": "rebind", + "script_sha256": "c00f769b29fa49e8b559a26287fbc815a25c51727410ca809f0d12532b07d095", + "seconds": 14.366808935000336 + }, + { + "exit_code": 0, + "log_sha256": "472ea53bfbf046f4844e9e95c460ad97370b660382040f0010b207075c72424c", + "name": "discovery", + "script_sha256": "fd11521257936734d8ac2a2c2c418a1e6b9c629b4d559a93f0ff5be5e0bf2705", + "seconds": 587.2045944200004 + }, + { + "exit_code": 0, + "log_sha256": "dc92e09c5b9dedab975e871b942bdc7ce997909d3c9bbb77c47f10951a11e78d", + "name": "outer-check_ledger.py", + "script_sha256": "1dd56009986eb14dd6603c9193c7ad71dd45c7d005bf71c9cd3f916e66f54d98", + "seconds": 0.04120386999966286 + }, + { + "exit_code": 0, + "log_sha256": "c27d3d0ba2a63a7f8db5da3c3820e3fc4b293b23f8cf8e171dd2940c85c83d62", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.03291257700038841 + }, + { + "exit_code": 0, + "log_sha256": "797cff0086ccefbb0c9bfc92136e5415892f0b43c5b8e4d605be3a585d2c7dba", + "name": "release", + "script_sha256": "6cfefe80c02a6c0f243f50ca9e146e1ab1440b84a033d8a71d42be5a5fa27f6b", + "seconds": 1118.443671162 + } + ], + "finite": { + "calls": 3240, + "charged_prefix_bits": 2048, + "idle": { + "3": 22783, + "48": 138492, + "5": 1625 + }, + "local_prefix_bits": 95, + "physical": 323069, + "physical_row_coefficient": 19549, + "physical_stock_bits": 2646, + "prefix_bits": 1478, + "prefix_formula": { + "active_block_depth": 18, + "bridges": 3240, + "input_l2": 37, + "invocations": 3240, + "local_scalar": 95, + "margin": 4, + "partial_cover": 1, + "stock_l2": 1323 + }, + "profile": { + "1": 8060060, + "2": 2310120, + "3": 751813, + "4": 327210, + "48": 138492, + "5": 66425, + "8": 25920 + }, + "provider_counts": { + "extra": 1110, + "extra-four": 562, + "gauge44": 1040, + "gauge44-four": 528 + }, + "roles": 1321920, + "row_limit": 20161 + }, + "fixed_inputs": { + "NATIVE-OUTPUTS.json": "7a231d9782297d36c5666860003e9b29a8260312c257820b488c8abd17780fc5", + "SOURCES.json": "dc14323136206ceee2bbe56b848effd7cffcae07ab680055beb09ed10bef5113" + }, + "implementation_commit": "b1eb3cec856e1f56a4ce70c583bce738223be6b2", + "independent_ledger_controls": [ + { + "control": "stamp-three-t0", + "detail": "row 29389: expected 8, got 7", + "rejection": "compact-prefix" + }, + { + "control": "offset-hole", + "detail": "row 0: expected 0, got 1", + "rejection": "compact-prefix" + }, + { + "control": "extra-rank-one", + "detail": "", + "rejection": "complete-profile" + } + ], + "isolated_export_files": 208, + "isolated_export_unchanged_after_replay": true, + "limitations": [ + "Finite source-bound admission, not an all-size or formal proof.", + "Author-produced evidence and separate AI checking; no independent human or maintainer review.", + "Unchanged THREE native and retained ancestry receipts authenticated and reused, not rebuilt cold.", + "Selected frontier unchanged; no new kappa claimed.", + "No hosted CI, Windows execution, dense backend or selected-frontier cold replay claimed." + ], + "native_execution": { + "base": { + "engine": "sparse", + "seconds": 74.37671391999993, + "stages": [ + { + "exit_code": 0, + "seconds": 1.0676890469999307, + "step": "native" + }, + { + "exit_code": 0, + "seconds": 1.2444967950000319, + "step": "ledgers" + }, + { + "exit_code": 0, + "seconds": 33.2658251339999, + "step": "local-replay" + }, + { + "exit_code": 0, + "seconds": 1.7386096579998593, + "step": "wrappers" + }, + { + "exit_code": 0, + "seconds": 37.05364620699993, + "step": "phases" + } + ], + "status": "PASS_COMPLETE_T74_NATIVE_REPLAY", + "word_sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95" + }, + "extra": { + "engine": "sparse", + "seconds": 65.27442802099995, + "stages": [ + { + "exit_code": 0, + "seconds": 1.0079365389997292, + "step": "native" + }, + { + "exit_code": 0, + "seconds": 1.2680895930002407, + "step": "ledgers" + }, + { + "exit_code": 0, + "seconds": 28.34220983100022, + "step": "local-replay" + }, + { + "exit_code": 0, + "seconds": 1.7045661110000765, + "step": "wrappers" + }, + { + "exit_code": 0, + "seconds": 32.946490324000024, + "step": "phases" + } + ], + "status": "PASS_COMPLETE_T74_NATIVE_REPLAY", + "word_sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a" + } + }, + "ordinary_stages": [ + { + "exit_code": 0, + "log_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3", + "name": "fine-engine-oracle", + "seconds": 2.7065371510007026 + }, + { + "exit_code": 0, + "name": "retained-provider-and-parent-admission", + "reused_receipt": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "seconds": 0.38355172199953813 + }, + { + "exit_code": 0, + "log_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f", + "name": "rebuild-words-566", + "seconds": 3.0525175610000588 + }, + { + "exit_code": 0, + "log_sha256": "e2b3ca9377e03e9b25cfb7b5086dac5833f75526298c476409bc69f570594886", + "name": "reconstruct-owners", + "seconds": 40.22737005399995 + }, + { + "exit_code": 0, + "log_sha256": "2d738a7322c4303d36deb694e6d79b6b51bfe098642bf5cda8abc319f03d66ab", + "name": "lift-parent", + "seconds": 74.72428813200077 + }, + { + "exit_code": 0, + "log_sha256": "8db780424ae2b9a2cfe8b8ed2d6fb76b3db3580348b7b3dbbc6fd2e3fe168072", + "name": "rebuild-borrow-words", + "seconds": 261.0704355709995 + }, + { + "exit_code": 0, + "log_sha256": "3dc6eb8940cf8a4b993f80129c98b6c4846ad346ccf773a78af225cff3339cc3", + "name": "shared-kernel-independent-review", + "seconds": 14.209026573000301 + }, + { + "exit_code": 0, + "log_sha256": "c456d3e39c09e960ceebf80251d5e808fa9299991471fd86f4093d9bc4dd3eda", + "name": "preload-move-independent-review", + "seconds": 18.142910587999722 + }, + { + "exit_code": 0, + "log_sha256": "a580354334d31376297292b4cb3c4edb0b53496a27700dbce15079305dac7457", + "name": "two-sided-helper408-review", + "seconds": 6.344389111000055 + }, + { + "exit_code": 0, + "log_sha256": "675cf2d9e49433fd6345462a4eacff74f6c37fd5fa0c167bbd8135822ab2562c", + "name": "paired-extension-review", + "seconds": 37.63992583500021 + }, + { + "exit_code": 0, + "log_sha256": "9812aa8d08d4251d390eb0cea1e5731dc59d22e09e0c914823c77d3e2e233e13", + "name": "declared-edit-review", + "seconds": 25.923998927000866 + }, + { + "exit_code": 0, + "log_sha256": "de2fa433a259e21f69f10db63667ba6034e0cd35f102a989208e865d042c31c8", + "name": "staged3605-review", + "seconds": 0.5407488490000105 + }, + { + "exit_code": 0, + "log_sha256": "145c88b1dff898d6b482558ca13a21f539c7f81b5bd5f2e6857156473692c9c4", + "name": "delayed-release-independent-review", + "seconds": 15.87705145200016 + }, + { + "exit_code": 0, + "log_sha256": "2b3e72ac971d0d7eacd8277defcd85ff3d24771285681d1b99fb6fdc4c3cdbf0", + "name": "staged544-independent-word-review", + "seconds": 5.402585488000113 + }, + { + "exit_code": 0, + "log_sha256": "be24d67b25305edbd7007e3d66204ea332b0589d2e68e8dc9c3ea7b6bf0afe16", + "name": "terminal-width5-independent-word-review", + "seconds": 4.287232639000649 + }, + { + "exit_code": 0, + "log_sha256": "6b584a0cb534d19f4683dde3a32ccc826ba405344ef267b2a91507b6ae49d513", + "name": "staged-entries-independent-word-review", + "seconds": 12.144086363000497 + }, + { + "exit_code": 0, + "log_sha256": "4598a833dda6247b7f0f2ac377a4e584254615ac8677745b0cc9e68385c1facf", + "name": "receiver-sharing-independent-word-review", + "seconds": 4.907475904999956 + }, + { + "exit_code": 0, + "log_sha256": "11d2f7b0418ead7e3a3991c0aa3a6776ebd4e4eb9aff5a226129c5a12685f6a6", + "name": "audit-local-566-base", + "seconds": 1.1379442690003998 + }, + { + "exit_code": 0, + "log_sha256": "e78a2eb0b7e2772691ba95c5bd139f817956ac52f52220c6b249bf2078b2b7bc", + "name": "audit-local-566-extra", + "seconds": 1.2681380249996437 + }, + { + "exit_code": 0, + "log_sha256": "d68f6853059855ffaa204aaf3d3132d04d69480db5fc7e955b06ac77171ae920", + "name": "rebind-566", + "seconds": 16.021649397000147 + }, + { + "exit_code": 0, + "log_sha256": "6e9516482c37bb844030d73d01af22e27ccd2a105aebc3ddd8846a7ab45e8e63", + "name": "lemmag-labels", + "seconds": 69.08023641800082 + }, + { + "exit_code": 0, + "log_sha256": "9f9c864207f4f1f98139419bf73c72fa6e5ce8dc07b70d3835e5cdd0c4b5202e", + "name": "strict-t74", + "seconds": 612.8734909570003 + }, + { + "exit_code": 0, + "log_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9", + "name": "geometry-controls", + "seconds": 0.7877863670000806 + } + ], + "outer": { + "exact_evidence_replays": 19, + "independent_status": "PASS_INDEPENDENT_BALANCE_DERIVATION", + "ledger_status": "PASS_FINE_PRIME_PADDING_EXACT_ARITHMETIC", + "rejecting_controls": [ + "endpoint_equality", + "zero_layout_slack", + "old_per_axis_scan", + "full_cell_gauge", + "full_key_sort", + "old_g_factor_union_row", + "old_theta_chirp_guard", + "old_linear_guard", + "old_union_tag_2beta", + "matrix_below_strassen", + "halo_too_short", + "core_too_small", + "group_equals_dimension", + "epsilon_equals_one", + "epsilon_not_above_r0_slack", + "beta_below_gaussian_window", + "beta_above_membership_window" + ], + "status": "PASS_RELEASE", + "strict_positive_inequalities": 63 + }, + "providers": { + "extra": { + "execution": "retained_PR4085", + "native_result_sha256": "e18a62a1019dac507c278fda6342dbb38afabace8f48a8d3c45a8f1e9b2d7bce", + "word_sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + "extra-four": { + "execution": "executed_by_this_driver", + "native_result_sha256": "849bc74cdcf9d47a8b30376daab54002223a780c541e5bd0decb3cb26c4c0d18", + "word_sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a" + }, + "gauge44": { + "execution": "retained_PR4085", + "native_result_sha256": "dc7d4049460e2c754b6319d721efcad9a8bad7249aea130c19eabc8f9193975e", + "word_sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + "gauge44-four": { + "execution": "executed_by_this_driver", + "native_result_sha256": "f4461bf354c92f672010d28b06540f36def41c88bd0c607c2db51e97d3e37055", + "word_sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95" + } + }, + "runtime": { + "dependencies": { + "mpmath": "1.3.0", + "numpy": "2.3.5", + "scipy": "1.17.0", + "sympy": "1.14.0" + }, + "platform": "linux", + "python": "3.12.14" + }, + "schema_version": 1, + "scientific_base": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "source_bound_receipt_hashes": { + "RESULT.json": "9d3c65bac0cd3ec566804dbd0afe988f087e99e750a78940184abc9daf9338a1", + "admission/RESULT.json": "ab509448ce5eb88035739fa9836b0eb33a8da6ebe79aa77c51f0617c47473835", + "admission/release/RELEASE-RECEIPT.json": "228dca1ce9cef5da86d4116e13f4782768a9828c033a16d1dd14d4928c32e0b9", + "admission/release/outer-tmp/outer/LEDGER.json": "73a236e238023f2d2216c44b19ad2765ee2ce45f46133967b40d1767fe9ba077", + "admission/release/verify/RESULT.json": "f76ad4dad609bfc4ce2259a0bbac201747c9957078a1f01081e76a8e3a5f4af1", + "admission/release/verify/strict/INDEPENDENT.json": "3032c25bb909fbfefcdbd6ef7b75776d22c91182668e6a6ba2a9469bad704fe4" + }, + "source_files": 680, + "source_manifest_sha256": "633c49d337b2053d294c2ef257b2e46f1ca2b4712ad5536747da05ddbcb71e73", + "status": "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", + "strict_stages": [ + { + "exit_code": 0, + "log_sha256": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "name": "bind", + "seconds": 5.3001343500000075 + }, + { + "exit_code": 0, + "log_sha256": "b8f4202fcfa93e19069e726c949b8eefee864eb8a22338dc60e9edce5f7997ba", + "name": "emit", + "seconds": 132.40401873000064 + }, + { + "exit_code": 0, + "log_sha256": "9a3e11fe30dbf47c5e0a54ef462b4b08a2fcafc52111f3082aa0ef5ba38d48e0", + "name": "audit", + "seconds": 414.7160506050004 + }, + { + "exit_code": 0, + "log_sha256": "a5319a1c6c21f33f7e7f3c4ba3c8b44edd00795f95bf2f457c1e9c13c2445968", + "name": "invoice", + "seconds": 19.95038905399997 + }, + { + "exit_code": 0, + "log_sha256": "7358a8a7e6ee53cd295162c695895ce04ea910655b119c7b64381ffd9395ce39", + "name": "assembly", + "seconds": 0.5276581799998894 + }, + { + "exit_code": 0, + "log_sha256": "90e2d631eb82a5edf69c7672e79cf6e261a5d4f4592b5dc09986f1aa6748611b", + "name": "admission", + "seconds": 7.6581824559998495 + }, + { + "exit_code": 0, + "log_sha256": "d54d260bf95bd8ae4ab8846314082b93b2e3d8f427eb35376691f2ce543a6b67", + "name": "bit", + "seconds": 1.3034140260006097 + }, + { + "exit_code": 0, + "log_sha256": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "name": "independent", + "seconds": 28.85628553600054 + } + ], + "tested_python_sources": { + "adapt.py": "3739cbeb4f0e75a475cf95f47ccfca5aee2f0a55abfcd2d0e502e411fad96a1d", + "binding.py": "5a63b937ffc6533a2b8d858d441c210a35a33895242881c5d996459bb2210977", + "challenge.py": "99d3f2c2b628e3eec0fc9fd0397f2ab822ef7230f37c42944e915fe38cd8f9fb", + "independent_ledger.py": "4262571439a845ad93bc4dc119adfe0b1fe8654992653cc56f4c4e3232ce13c3", + "native_outputs.py": "dfc9ae9f651dbf3e248896ee328d0968ee868fd5532252cb5217f04b0de6a5e3", + "replay.py": "25576ade4839c1c0ece1ecd2e9f70ccedd04ed601a4aa28a715286176b8ef096", + "sources.py": "a0c3a7cdbf0a889d1f47fb124209494fc17209d90992f4c12ce154fb786accd0", + "test_binding.py": "5abfc37a6d256951f11f0ac5dd2f1066390d0bdebac984758afc2bcf7348c966", + "verify.py": "e6cf84816fcfdb3bd1b66510539c7b30a08cc15b8e18e3f1715746d73d1826bc" + }, + "wrapper_stages": [ + { + "exit_code": 0, + "log_sha256": "a6bde715fdaa3bac87dde33c570b772e528df26379ad515588a0ed4d335b4c5b", + "name": "pr4088-verify", + "seconds": 11.456949471000371 + }, + { + "exit_code": 0, + "log_sha256": "b33431cc08d680a861ca0a206dc264980ce46b66f6b27f352c7113ba434ae2a4", + "name": "pr4088-owner_verify", + "seconds": 4.37820875899979 + }, + { + "exit_code": 0, + "log_sha256": "1992e3d6debe5ad7688f1221842b4444a546053429167ba8bbba682b7598be21", + "name": "pr4088-operator_verify", + "seconds": 9.245831447 + }, + { + "exit_code": 0, + "log_sha256": "0a7fcecac4dcd5be8347adf0b221d1d7f1aef00973720fd78cc8a63a06dc676d", + "name": "predecessor-preflight", + "seconds": 26.3588124730004 + }, + { + "exit_code": 0, + "log_sha256": "9043965e7f35767772769856a15d4316f21fdc2a12b762da691a84c413b7c7e6", + "name": "native-four-base", + "seconds": 74.43039581699986 + }, + { + "exit_code": 0, + "log_sha256": "2300d8a9b4d84d3cbb588066528087922fb819d14b034b79eb1e579b2d336915", + "name": "native-four-extra", + "seconds": 65.3754942100004 + }, + { + "exit_code": 0, + "log_sha256": "131825ece051c1e45a30c36537235b943c1c4caf9b4d2c363f1355566249b2dd", + "name": "inherited-admission", + "seconds": 1829.7672280440001 + } + ] +} diff --git a/research/mixed-provider-admission/EVIDENCE.md b/research/mixed-provider-admission/EVIDENCE.md index cc001e9087..61efc22709 100644 --- a/research/mixed-provider-admission/EVIDENCE.md +++ b/research/mixed-provider-admission/EVIDENCE.md @@ -26,6 +26,26 @@ reproduced its old invoice, including idle then reproduced the distinct PR4088 invoice in the README. PR4165's existing five rejection controls also passed; its idle finding is predecessor credit. +The separate THREE baseline copied `PREFLIGHT/inputs/source` to +`BASELINE_CONTROL`, installed the unchanged retained +`PREFLIGHT/inputs/helpers/reconstruct_replica.py` as `reconstruct.py`, and +placed PR4076's `owner/FILL.json.gz` and `owner/inputs/{ORDER,DISPATCH}.json` +in `new/borrow-fill/`. Its executed command was: + +```sh +python3 -B BASELINE_CONTROL/reconstruct.py --out BASELINE_OWNERS +``` + +Those aliases denote fresh external directories. The source package is +`research/staged544-triple-entry-fill` at the scientific base. Its baseline +input hashes are `a8de70d8cc5e15914881dd4849e51014af261bdd215ced7222ceb111cc5baab9` +(fill), `743e74b538432e2b2045e754b0de9c18f36fc5039fdb8eb542177a898ec78e44` +(order), and `5d6fa711d704a1b498e5fe066ea821c4fa0217463702e82a7ce5be9da4023e8a` +(dispatch). The unchanged helper hash is +`5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15`. +This initial experiment used the full canonical checkout; the isolated export +contains the 192 inputs consumed by the successor's documented replay commands. + Both FOUR native sources were freshly executed through all five stages: `native`, `ledgers`, `local-replay`, `wrappers`, `phases`. Initial executions took 63.145 and 68.423 seconds. These are observed wall times, not a speedup @@ -81,24 +101,67 @@ metadata and pin checks then passed. ## Full release -The development replay has passed complete discovery, both outer ledger -checks, native/Lemma-G bindings and the ordinary source-review chain. The -strict and final outer release are still running at this development checkpoint. -No final admission is claimed from those intermediate stages. The final -publication gate additionally requires a fresh replay from a committed, -Git-free source export and inspected release receipts. +The development replay completed the inherited engine in 1,780.781 seconds: + +* `PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE`; +* all seven outer-driver stages, including discovery and final release; +* all 23 ordinary stages, ending in strict replay and geometry controls; +* actual control counts: 201 assembly, 43 controller, 12 bit, + 8 independent owner and 6 geometry; +* `PASS_RELEASE`, 63 strict outer inequalities, 17 rejecting outer controls, + independent balance derivation, union schedule and 19 exact evidence replays. + +The counts above were inspected in the produced ordinary result, strict +receipts and nested outer ledger, rather than inferred from a PR title. +Source and native-cache inventories remained unchanged after admission. + +The implementation commit is +`b1eb3cec856e1f56a4ce70c583bce738223be6b2`. Its 208-file committed export +(16 package files and 192 declared inputs) passed archive integrity and +committed-byte checks. Extracting into a fresh directory without `.git` +passed the direct binding regression and optimized controls. The default full +replay then passed from that export, with fresh source reconstruction and fresh +FOUR native execution. Its seven wrapper stages totalled 2,021.013 seconds, +including 1,829.767 seconds in inherited admission. The fresh FOUR base/extra +native drivers reported 74.377 and 65.274 seconds respectively. These are +single-run wall measurements, not performance comparisons. + +The clean replay reproduced all the statuses and control counts above. +[EVIDENCE.json](EVIDENCE.json) records the actual stage results, receipt hashes, +provider provenance, exact invoice and semantic controls. +[REPLAY.log](REPLAY.log) contains actual executed stdout excerpts, with only +work, source and interpreter paths normalized. Raw receipt hashes identify +this execution; they are not cross-environment deterministic hash claims. +All 208 exported files remained unchanged after execution, and all nine tested +Python files remain byte-identical in the final package. Subsequent changes +only finalize documentation, metadata and these execution receipts. +The registered package check was then rerun on the final tree and returned +`PASS_REGISTERED_RESEARCH_PACKAGE` with outcome `completed`. + +The executed default command, with its external work path abbreviated, was: + +```sh +python3 -B research/mixed-provider-admission/replay.py --work ISOLATED_RELEASE +``` + +The ordinary release ran its 19 exact outer evidence replays. This does not +mean every historical native/parent receipt was rebuilt cold: unchanged THREE +and retained ancestry evidence use the authenticated reuse described above. ## Review and overlap scope -The 2026-10-20 08:19 UTC refresh still found canonical main at the scientific -base and priority revision 7. The helper covered all 294 open/draft PRs and -2,693 Discussion records with complete pagination and no warnings. The latest +The 2026-10-20 08:54 UTC refresh still found canonical main at the scientific +base and priority revision 7. The helper covered all 295 open/draft PRs and +2,695 Discussion records with complete pagination and no warnings. The latest 50 updated PRs were also inspected for merged successors. +A final canonical fetch at 09:06 UTC still returned the same base SHA. PR4170's pooled-ceiling transfer and PR4171's independent moment/paid-power arithmetic are complementary to this actual caller/ordinary/outer integration. -PR4169 audits a PR4100 CRT repair implication. No equivalent admission -successor or active claim was found in that coverage. This is an overlap check, +PR4169 audits a PR4100 CRT repair implication. The new Discussion4173 +claim concerns CRT reservoir placement, and PR4172 concerns QQ16 comparison. +No equivalent admission successor or active claim was found in that coverage. +This is an overlap check, not a proof of novelty. Coordination remained local-only. ## Checks outside this result @@ -108,6 +171,18 @@ reference dense native backend, Windows execution, or hosted CI was run. The selected construction is not changed. No complete all-size theorem, independent human review or maintainer acceptance is established. +The optional `--check-source-history` publication preflight was not run: +this workspace has shallow history and that check requires a full clone. +All declared source pins resolve at the canonical base, which is the +implementation commit's immediate parent; no unreachable PR-head object is +needed. Metadata, Git-blob pins, committed bytes and the Git-free export are +checked separately. A reviewer with full history can additionally run: + +```sh +python3 -B scripts/check_research_commit.py \ + --package research/mixed-provider-admission --check-source-history +``` + The numerical environment is CPython 3.12.14 on Linux, NumPy 2.3.5, SciPy 1.17.0, SymPy 1.14.0 and mpmath 1.3.0, all already installed. The full driver checks these dependency versions before running. diff --git a/research/mixed-provider-admission/README.md b/research/mixed-provider-admission/README.md index 29da37eb1b..16f25a51e5 100644 --- a/research/mixed-provider-admission/README.md +++ b/research/mixed-provider-admission/README.md @@ -7,6 +7,12 @@ width, and preserves the inherited release checks. It does not construct a new supplier, change the selected frontier, or prove the all-size multiplication theorem. +The default full replay passed from an isolated committed export, including +ordinary, strict and outer release. [EVIDENCE.json](EVIDENCE.json) records its +actual receipts and [REPLAY.log](REPLAY.log) preserves the executed stdout +excerpts. These are author-produced finite evidence, pending independent +scientific review. + The question is the revision-7 `supplier-boundary-audit` card's concrete missing replay. The scientific baseline is `12fa8c5c844be21bfefb38a19503fbd867a11244`; the exact consumed Git objects and @@ -177,7 +183,8 @@ author receipts are distinct from maintainer scientific review. 2. **One caller-bound all-size implication.** Finite admission leaves the uniform compiler/precision/fixed-tape transfer question open. The first feasible step is to consult the current `uniform-transfer-audit` card and - PR4100/PR4169 handoffs, then pin one real caller and quantified proposition. + PR4100/PR4169 handoffs and Discussion4173's live CRT reservoir claim, then + pin one unclaimed real caller and quantified proposition. A general argument, rather than another evaluation of this root, is needed. The structured questions and their blockers are also in [TASK.json](TASK.json). @@ -204,8 +211,9 @@ The structured questions and their blockers are also in [TASK.json](TASK.json). The retained archive SHA256 is `e74d545c18f77b7a9b8f0cc3d4901a87bb686888edaf3e41b30e5b2748751041`. All predecessor notices and licenses remain in their source packages and are -preserved by reconstruction. PR4170's pooled-ceiling transfer audit addresses -a distinct obligation. This does not repeat yssite's PR959, PR1558 or PR2377. +preserved by reconstruction. PR4170's pooled-ceiling transfer, PR4171's moment +arithmetic and Discussion4173's CRT reservoir audit address distinct +obligations. This does not repeat yssite's PR959, PR1558 or PR2377. Prepared for yssite with substantial OpenAI Codex assistance in investigation, implementation, documentation and two separate AI checking contexts. diff --git a/research/mixed-provider-admission/REPLAY.log b/research/mixed-provider-admission/REPLAY.log new file mode 100644 index 0000000000..05fa331de1 --- /dev/null +++ b/research/mixed-provider-admission/REPLAY.log @@ -0,0 +1,84 @@ +Executed stdout excerpts from the isolated committed export. +Only work/source/interpreter paths are normalized; these are local logs, not hosted CI or formal proof. + +== default full driver == +PASS pr4088-verify +PASS pr4088-owner_verify +PASS pr4088-operator_verify +PASS predecessor-preflight +PASS native-four-base +PASS native-four-extra +PASS inherited-admission +PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE + +== fresh FOUR base == +PASS native +PASS ledgers +PASS local-replay +PASS wrappers +PASS phases +PASS_COMPLETE_T74_NATIVE_REPLAY sparse 74.377 + +== fresh FOUR extra == +PASS native +PASS ledgers +PASS local-replay +PASS wrappers +PASS phases +PASS_COMPLETE_T74_NATIVE_REPLAY sparse 65.274 + +== inherited admission == +PASS owners +PASS parent-lift +PASS rebind +PASS discovery +PASS outer-check_ledger.py +PASS outer-independent_check.py +PASS release +PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE 0.0017309791156707924727599999999999999999999998999999999999999999999999 + +== ordinary verification == +PASS fine-engine-oracle +PASS retained-provider-and-parent-admission (hash-checked receipt) +PASS rebuild-words-566 +PASS reconstruct-owners +PASS lift-parent +PASS rebuild-borrow-words +PASS shared-kernel-independent-review +PASS preload-move-independent-review +PASS two-sided-helper408-review +PASS paired-extension-review +PASS declared-edit-review +PASS staged3605-review +PASS delayed-release-independent-review +PASS staged544-independent-word-review +PASS terminal-width5-independent-word-review +PASS staged-entries-independent-word-review +PASS receiver-sharing-independent-word-review +PASS audit-local-566-base +PASS audit-local-566-extra +PASS rebind-566 +PASS lemmag-labels +PASS strict-t74 +PASS geometry-controls +PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION 0.001727988004522833 + +== strict replay == +PASS bind +PASS emit +PASS audit +PASS invoice +PASS assembly +PASS admission +PASS bit +PASS independent +PASS_STRICT_MIXED_T74_EXACT_FILL 0.001727988004522833 + +== outer execution == +case g=5 L=7: exact tensor product reproduced; sum|F|=28812 = sum|U_i|; g|U|=74035 (x2.57); moves=336140 <= 950796; rounds=5 +case g=4 L=6: exact tensor product reproduced; sum|F|=1944 = sum|U_i|; g|U|=4416 (x2.27); moves=18360 <= 58320; rounds=4 +case g=6 L=5: exact tensor product reproduced; sum|F|=40625 = sum|U_i|; g|U|=90834 (x2.24); moves=459375 <= 1340625; rounds=6 +case g=3 L=8: exact tensor product reproduced; sum|F|=512 = sum|U_i|; g|U|=1086 (x2.12); moves=5120 <= 15360; rounds=3 +PASS_UNION_SCHEDULE +PASS_EXACT_REPLAY 19 +PASS_OUTER diff --git a/research/mixed-provider-admission/TASK.json b/research/mixed-provider-admission/TASK.json index bfec423ed5..6665979932 100644 --- a/research/mixed-provider-admission/TASK.json +++ b/research/mixed-provider-admission/TASK.json @@ -75,7 +75,7 @@ "bottleneck_link": "docs/research/current-priorities.md revision 7: the mixed four-provider ordinary/outer engine has not been replayed. This successor targets that finite admission boundary, retaining all analytic/theorem obligations.", "budget_minutes": 180, "stop_rule": "At most four bounded rounds on this question. Stop after a reviewable result, equivalent live work, two experiments without actionable evidence, or a nonlocal proof/infrastructure blocker; preserve the final quarter for verification/handoff.", - "outcome": "partial", + "outcome": "completed", "evidence": "COVERAGE.md maps caller obligations. replay.py executes exact source reconstruction and inherited admission; verify.py checks source pins, actual call/width/idle bindings and semantic controls. challenge.py exercises actual four-provider products and the cached engine; NATIVE-OUTPUTS.json fixes their scientific commitments.", "author": "yssite", "ai_assistance": "Substantial OpenAI Codex assistance in investigation, implementation and documentation. A separate Codex context independently scanned source-event/phase-axis owner rows; another adversarially challenged the implementation and reproduced two corrected reuse-binding gaps. Neither is independent human review or formal verification.", @@ -83,7 +83,7 @@ { "question": "Does an independently reviewed all-size compiler/precision/fixed-tape transfer justify using the admitted finite supplier in the complete multiplication theorem?", "why_it_matters": "Finite ordinary/outer arithmetic and native source replay do not establish uniform generation, physical execution, conditioning or the complete machine-cost theorem.", - "first_step": "Use the current uniform-transfer-audit card and live PR4100/PR4169 handoffs to pin one remaining proposition at its actual caller; do not rerun this unchanged moment root.", + "first_step": "Consult the current uniform-transfer-audit card and live PR4100/PR4169/Discussion4173 handoffs, then pin one unclaimed proposition at its actual caller; do not rerun this unchanged moment root or duplicate the live CRT reservoir audit.", "blocked_by": "A general source-bound mathematical argument and independent scientific review, beyond this finite integration." }, {