diff --git a/.github/workflows/p112-common-slice.yml b/.github/workflows/p112-common-slice.yml index 37f99ca573..48047f61c4 100644 --- a/.github/workflows/p112-common-slice.yml +++ b/.github/workflows/p112-common-slice.yml @@ -15,9 +15,9 @@ jobs: if: github.repository == 'CrocSwap/integer-mult-bounds' runs-on: ubuntu-24.04 timeout-minutes: 20 - env: - TMPDIR: ${{ runner.temp }}/p112-common-slice steps: + - name: Initialise P112 work directory + run: echo "TMPDIR=$RUNNER_TEMP/p112-common-slice" >> "$GITHUB_ENV" - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 with: fetch-depth: 0 diff --git a/research/t385-r437-copy-audit/.gitattributes b/research/t385-r437-copy-audit/.gitattributes new file mode 100644 index 0000000000..26a0492c93 --- /dev/null +++ b/research/t385-r437-copy-audit/.gitattributes @@ -0,0 +1,3 @@ +# Preserve byte-authenticated predecessor material across checkout platforms. +inputs/** -text -whitespace +R437-* -text -whitespace diff --git a/research/t385-r437-copy-audit/CALLER-BOUNDARY.md b/research/t385-r437-copy-audit/CALLER-BOUNDARY.md new file mode 100644 index 0000000000..e13afb93ab --- /dev/null +++ b/research/t385-r437-copy-audit/CALLER-BOUNDARY.md @@ -0,0 +1,79 @@ +# Where the complete-stream implementation handoff reaches actual code + +This is a source inspection, not execution or independent validation of +PR2809's universal refinement proof. The inspected files are pinned as +provenance at canonical main `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +Jose Manuel / jmbarrancoml supplied the physical lowering of David Arias's +PR2753 caller. Their notices and the selected primitive/parking lineage remain. + +## A concrete wrapper already exists + +In `research/selected-bit-physical-caller/macro_code.py`, `compile_node` +handles a local COPY event by emitting, in order: + +1. Copy the current staged center to the permanent `copy_source` role. +2. Execute one residual on `copy_source`, using that event's request and the + current common low class. +3. Transfer its completed output to the local private role. + +At ERASE it emits a clear of that private role at the original guarded +position. No helper-label projection appears in this wrapper. The source +`LocalState` validates the event lifecycle during compilation; the wrapper +is not a free-standing license to clear arbitrary persistent state. + +`macro_machine.py` implements COPY by committing the source tape to the named +destination. Its `commit` clears the destination, appends the entire source, +and rewinds the destination. It clears the returned source only if that +source is a temporary `Lease`; a staged permanent source role is preserved. +MOVE transfers between fixed roles; CLEAR calls that role's tape clear. +These operations make explicit the complete source clone, owned output and +linear disposal that a cost audit must retain. They do not support charging +an unspecified dirty-input projection as if it were the whole source. + +The source proof, section 3, describes that same source-clone/residual/private +sequence. Section 5 inventories scratch inside atomic blocks, and sections 6–7 +supply the parent parking/return argument. This is an existing proposed +implementation path, not an assertion that nobody has written a caller. + +## What the reduced execution actually covers + +`macro_local_checks.py` observes the copied source before the residual, +compares the copied output against an independent address permutation, and +checks that the original source is unchanged **before** later XOR cancellation. +The published complete GL2(F3) fixture checks 96 COPY endpoints, 192 MOVE and 384 +IDLE residuals on 31,104 bits. Its source proof explicitly says it has no +internal child. A separate GL2(F2) fixture tests recursive control; the selected +junction probe is not a complete selected GL64 payload. + +This session did not rerun those fixtures or independently review the whole +parametric proof. The repository's current physical-contract map also keeps +PR2809's universal refinement pending despite archival incorporation and +later ordinary-backend compositions. Reduced fixtures and source archival +status should not be turned into an R437 implementation/admission certificate. + +## Precise next implication + +The new R437 checker establishes the exact-function endpoint and guards of +R437's actual rank-seven requests. The concrete wrapper above is structurally +compatible with a universal complete-stream residual. The unclosed step is +an exact-source binding and proof that its rank-seven residual/caller: + +- accepts R437's current source/owner/chart data and all arbitrary helper + functions, including the newly occurring input 340; +- preserves its borrowed source and returns the transformed complete output; +- charges source clone, all routing/adapters, child execution, transfer and + complete disposal under the retained volume-normalized tariff; +- restores child scratch and parking state within the actual full reserve; +- satisfies the admitted numerical format, exceptional-class and recovery + conditions on the required all-size domain. + +The available source-level compiler/primitive proof may be the route to those +claims, but this finite application audit does not independently validate it. +No second recursive uncompute is forced by the existing wrapper: it transforms +an owned clone and later clears owned output. Conversely, clear is a real tape +operation and its linear cost and scratch lifetimes remain part of the bill. + +A useful next audit should start with `compile_node`'s COPY branch, +`Machine.commit`/COPY/CLEAR and the bound residual plan, then connect one +actual R437 request to the general primitive and lease/return arguments. +Repeating the GL2 endpoint fixture alone would leave that implication open. diff --git a/research/t385-r437-copy-audit/EVIDENCE.json b/research/t385-r437-copy-audit/EVIDENCE.json new file mode 100644 index 0000000000..92e844af14 --- /dev/null +++ b/research/t385-r437-copy-audit/EVIDENCE.json @@ -0,0 +1,63 @@ +{ + "files": { + "evidence/t385/admission-result.json": "43ff0e5058f242b2783082581b2f29e0b54deae3f2036f3654a0f3c0a198736c", + "evidence/t385/discovery-RESULT.json": "13526e1505efdc599096ac611b9b9a782a670ed98a365d471d8bf997dc2b8e24", + "evidence/t385/discovery-STAGES.json": "cff1d2a1200525a23790716e98e849188577a29e5680b3d5433e02e3501beb08", + "evidence/t385/discovery-assembly.log": "1518262cd2fb428acb41b5e3bb4fbc2a9aac03b3f0f6f3da0f222226bbd6799d", + "evidence/t385/discovery-audit.log": "e7403fd02cfb7a18f5eb1098de1a3d9830c209521ded74b1a4fbf0044349fc79", + "evidence/t385/discovery-bind.log": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "evidence/t385/discovery-emit.log": "cb7715dcffa5a5ec8e15559df8ad80620a6b1d1edd41b1f9ef1572711de318c5", + "evidence/t385/discovery-freeze.log": "dd6da2aa4a2d630e61a2f77138921c578c0c6409d170d58568a29af4ee56d379", + "evidence/t385/discovery-independent.log": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "evidence/t385/discovery-invoice.log": "0fa5bbe81eef6ea6e7824bcb686c9207a748697d9d98348bfd4a05e7511e8945", + "evidence/t385/native-receipt.json": "7ddf3f80b2fa61d1ab12035da9ef1c95d43f76077df819d7683144d7862a3f93", + "evidence/t385/release-RELEASE-RECEIPT.json": "9f49e2e801cff8dd9402121e16c0d63801975740140637c5943f94149b28c803", + "evidence/t385/release-outer.log": "670f60ee3ecc7e2d7fc4b23b468d4cdb8cfab9edaf252cd2410c1cabcb0318dc", + "evidence/t385/release-strict-RESULT.json": "7babd8a958bff810adf89d560c73a01c052d98210d6852dbea106400ccbdf65d", + "evidence/t385/release-strict-STAGES.json": "6a8ae6fd5198ddbb4443060d27917ffcd083ee55bd32bb68314f2fe951c5eee4", + "evidence/t385/release-strict-admission.log": "1cee8d732e126c670f531018d65955c23828a7cc0af8d6ac4bb0f6672962a540", + "evidence/t385/release-strict-assembly.log": "1518262cd2fb428acb41b5e3bb4fbc2a9aac03b3f0f6f3da0f222226bbd6799d", + "evidence/t385/release-strict-audit.log": "e7403fd02cfb7a18f5eb1098de1a3d9830c209521ded74b1a4fbf0044349fc79", + "evidence/t385/release-strict-bind.log": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "evidence/t385/release-strict-bit.log": "d54d260bf95bd8ae4ab8846314082b93b2e3d8f427eb35376691f2ce543a6b67", + "evidence/t385/release-strict-emit.log": "cb7715dcffa5a5ec8e15559df8ad80620a6b1d1edd41b1f9ef1572711de318c5", + "evidence/t385/release-strict-independent.log": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "evidence/t385/release-strict-invoice.log": "0fa5bbe81eef6ea6e7824bcb686c9207a748697d9d98348bfd4a05e7511e8945", + "evidence/t385/release-verify-RESULT.json": "0372a78fcb546538d781ae54d70424b272a3faff632e0a391cb383326f1aa6ba", + "evidence/t385/release-verify-STAGES.json": "8f23bb4af5567f2d8fa2e09d3cf54f6973591cb536bbb35d4daa247a132aa1cb", + "evidence/t385/release-verify-audit-local-566-base.log": "c16c2e894f5bb470a8b16bd478f3e311c2dfa397d4f87f0ab36f46c2ee709f78", + "evidence/t385/release-verify-audit-local-566-extra.log": "0141a0a056a6c1c31dcb88c9ae613dd76c771dc43ef5f3867ad46f984dba8a01", + "evidence/t385/release-verify-declared-edit-review.log": "9812aa8d08d4251d390eb0cea1e5731dc59d22e09e0c914823c77d3e2e233e13", + "evidence/t385/release-verify-delayed-release-independent-review.log": "cc8f2e06baec65ca81cb91674bd23ea14320f6b1ceee9a6cfba251387d77c737", + "evidence/t385/release-verify-fine-engine-oracle.log": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3", + "evidence/t385/release-verify-geometry-controls.log": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9", + "evidence/t385/release-verify-lemmag-labels.log": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469", + "evidence/t385/release-verify-lift-parent.log": "c5102a5a2c10b2a5e08927636187a9c1df2841a094c58f1a61326a2b11274483", + "evidence/t385/release-verify-paired-extension-review.log": "f5928ef4aecde0f00d2bcded7b6cf9577c4bfe756bc190b68a8f7901dc2e1dc7", + "evidence/t385/release-verify-preload-move-independent-review.log": "c456d3e39c09e960ceebf80251d5e808fa9299991471fd86f4093d9bc4dd3eda", + "evidence/t385/release-verify-rebind-566.log": "4efcc424f53c49777d308af3bc568688d2eb0de9c0236aae9af6ab50190974a7", + "evidence/t385/release-verify-rebuild-borrow-words.log": "59dc4ab25e1e91611f2049d9dd9c3f5f210e4fc9b5b394b6a21de60745694f54", + "evidence/t385/release-verify-rebuild-words-566.log": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f", + "evidence/t385/release-verify-reconstruct-owners.log": "239d8562814d1627c19e7e6bf75f06ae2ef219b50c948bb612dcfa0f3f21ef1c", + "evidence/t385/release-verify-shared-kernel-independent-review.log": "3dc6eb8940cf8a4b993f80129c98b6c4846ad346ccf773a78af225cff3339cc3", + "evidence/t385/release-verify-staged3605-review.log": "de2fa433a259e21f69f10db63667ba6034e0cd35f102a989208e865d042c31c8", + "evidence/t385/release-verify-staged544-independent-word-review.log": "2b3e72ac971d0d7eacd8277defcd85ff3d24771285681d1b99fb6fdc4c3cdbf0", + "evidence/t385/release-verify-strict-t74.log": "5e17e55fd26dcde3a43516c4654f55b572a05f61bb8381e8883f876e6a291dcb", + "evidence/t385/release-verify-two-sided-helper408-review.log": "a44341620c98e985c522107cdec7def37b715267c605976b25c33fe8a9f3cefb", + "evidence/t385/release-verify.log": "f8db339ba756aa4054dc9329d8f059ed700f72d273cff73422ea820229f47a24", + "evidence/t385/runtime-patches.json": "def1cdb3a467a9763f283ebbecbbfba979e915012f5f690d4aaab620a2b21498", + "evidence/t385/stage-discovery.log": "0698d7bbe8ffa568e2c0cea6bdd2fea81cb7fe17df8a4ed58e0f10e6bf14a421", + "evidence/t385/stage-outer-check_ledger.py.log": "b66b80965a59ac5aec812a16e8cbcddf6c97c02b3e6dd35b6be8ce02ff9174c4", + "evidence/t385/stage-outer-independent_check.py.log": "639d5cdd1ad11190a6198809aa3c5b00245d905dabf6d7671ccbf1a587202276", + "evidence/t385/stage-owners.log": "239d8562814d1627c19e7e6bf75f06ae2ef219b50c948bb612dcfa0f3f21ef1c", + "evidence/t385/stage-parent-lift.log": "c5102a5a2c10b2a5e08927636187a9c1df2841a094c58f1a61326a2b11274483", + "evidence/t385/stage-rebind.log": "4efcc424f53c49777d308af3bc568688d2eb0de9c0236aae9af6ab50190974a7", + "evidence/t385/stage-release.log": "acdf066ba832393ac990976f6705748d72a1cc0d521b394711516c874e7a4796", + "evidence/t385/supervisor.json": "57443cd242961ee84a72e8ee0e18044923b31727ee8c54b3f9350acd3d3b28c8", + "evidence/t385/timeout-extension.json": "a2a59b018b656929d63f67b7f4d10cfa1b6256a0690a17d9cdb333b38dfa1c88", + "evidence/t385/wrapper-result.json": "70789b05fc62ce1fb8b53332816231dabaa5109a2a8ab24660fe22b79e816dcb", + "evidence/t385/wrapper.log": "8289a527218d2bd3b3f76510e0fcbbd05ddc99ec4342590d791733f4265c0337", + "T385-EXECUTION.json": "3adbbafd78f2b2c7e1ba9dc8f26ecec0eda3508fe2baa12442e6b0b263064914" + }, + "scope": "Authenticate recorded execution evidence; not an execution or mathematical acceptance claim" +} diff --git a/research/t385-r437-copy-audit/OVERLAP.json b/research/t385-r437-copy-audit/OVERLAP.json new file mode 100644 index 0000000000..8a83b1b545 --- /dev/null +++ b/research/t385-r437-copy-audit/OVERLAP.json @@ -0,0 +1,99 @@ +{ + "checked_utc": "2026-10-19 04:59:01 UTC", + "records": 638, + "unique_prs": 638, + "coverage": "All seven open-PR title/body pages including drafts; non-atomic snapshot. Closed history not fully enumerated. Discussion handoff refreshed manually; broader Discussion coverage partial.", + "matches": [ + { + "number": 3883, + "title": "Independent audit of R437 OQ4 transition and staged544 admission replay", + "head": "0ce706e210d133ee36b65144f87f0a74a74bec6d", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3883" + }, + { + "number": 3890, + "title": "Certify the complete staged544 joint width-price region", + "head": "772953c9bda6d41db7b89e4cd6bae3dc05d7636e", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3890" + }, + { + "number": 3880, + "title": "Compile dirty-buffer XOR corrections with explicit space–time bounds", + "head": "eef2760be4ed4b08f9c59b037e3ad2380a8bf958", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3880" + }, + { + "number": 3875, + "title": "Refine the certified staged544 conditional kappa endpoint to 80 digits", + "head": "a65afd67e0a43e02554b58b5593d253581207b04", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3875" + }, + { + "number": 3857, + "title": "Kernel-check the staged supplier moment and refine conditional κ", + "head": "ef4315b8caa605e47a2515004845eb2d2ed71a86", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3857" + }, + { + "number": 3647, + "title": "Improve conditional BIT c to 0.001736646042 with composed R437 and credited slot coalescing", + "head": "a24f9ff95c12fd0b6792e3f710569237efd72db2", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3647" + }, + { + "number": 3802, + "title": "Improve conditional kappa beyond T488 with a T385 combined-clock allocation", + "head": "de2cd5c58009205210e3bf328b0ef5cadf3903af", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3802" + }, + { + "number": 3815, + "title": "Research: certify the staged544 packing ceiling and reach it on PR3734's T360 clock (no new κ; same value as #3802)", + "head": "77ffbf287b6ca198b4a31e3835db3bae60718b93", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3815" + }, + { + "number": 3724, + "title": "Independent verification (no κ): arithmetic layer of PR3562's ordinary-rate theorem holds; line-158 exposition gap, 4283584 stands", + "head": "946d03dd6b9cc794190876fe3f0f89b0ebc01c59", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3724" + }, + { + "number": 3700, + "title": "Independent verification (no κ): PR3647's composed R437 bit word, hosting and price pass an exact audit against single-change controls (c = 0.001736628253427115)", + "head": "aa0bd9fbc8700506b1fafcc55bca9bd32aced7d9", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3700" + }, + { + "number": 3690, + "title": "Research: source-bind R437 ordinary coupling at c=1/576 (no κ claim)", + "head": "03c141ef1fd372cf42951488767537e55675c072", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3690" + }, + { + "number": 3668, + "title": "Add the published R437 histogram and compare its coefficient with the selected kappa", + "head": "a69d1f76cbfbc5441bccf52de01672308d5447e1", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3668" + }, + { + "number": 2745, + "title": "Conditional κ = 0.001716140425997441: #2696's lender assignment with #2679's pre-life hosting and a window-optimal fill", + "head": "4f485de05544884fa0f2edf6063bb9259decad30", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2745" + }, + { + "number": 1724, + "title": "Conditional κ = 0.0016769381110224387711...: stacked pivot 566 + 554 kernels with 600-digit grid and 600-digit endpoints over PR1692", + "head": "d7d89428fe5219d56b115371d5074d5e518fd0c7", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1724" + }, + { + "number": 1692, + "title": "Conditional κ = 0.0016769381110224387711...: stacked pivot 566 + 554 kernels with 470-digit grid and 450-digit endpoints over PR1672", + "head": "c7b46d54328214469c47423a3bcc98699bd01f76", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1692" + } + ], + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19030424" +} diff --git a/research/t385-r437-copy-audit/PROOF.md b/research/t385-r437-copy-audit/PROOF.md new file mode 100644 index 0000000000..ee68834a87 --- /dev/null +++ b/research/t385-r437-copy-audit/PROOF.md @@ -0,0 +1,183 @@ +# R437 complete-stream COPY applicability and its cost boundary + +This is an application audit in the ideal exact-stream model, with a new +source-bound implementation of the checks. The model, gauge argument and +rank-seven correction are credited to alephnan's PR1627 and the earlier +PR540 framework; PR2088 and the selected COPY separation/two-copy physical +audits already distinguish complete operators from their ranks. No new +all-size compiler, supplier admission or unconditional multiplication theorem +is proved here. + +## 1. Exact object and hypotheses + +The R437 input is PR3647 at +`a24f9ff95c12fd0b6792e3f710569237efd72db2`. Both literal local instruction +lists are reconstructed from the retained WORD and compared in full against +the OQ4 hosted template. There are 659 persistent inputs: 111 SOURCE, 111 +TARGET and 437 arbitrary dirty helper functions. The selected PR589 word is +retained only to reconstruct the earlier capture rows and compare dirt. + +Let K have characteristic other than two, let the address domain be +`X = K^64 × K^64`, and let M be the F2 vector space of **all** functions +`X -> F2`. An initial physical input may be any member of M; different +inputs may be correlated. Boolean XOR coefficients and address coefficients +in K are different fields. We do not identify them. + +For a rational symmetric frame projector P, define + + D_P = [[I-P, P], [P, I-P]]. + +The checker reconstructs all 636 projectors from literal root vectors by exact +orthogonalization, checks idempotence and trace, and checks `D_P² = I`. +Every resulting address entry is dyadic. Thus the exact matrix identities +specialize to every such K. The rational characteristic polynomial of a +rank-r idempotent is `t^(8-r)(t-1)^r`; this identity also specializes, and +an idempotent is diagonalizable with eigenvalues 0 and 1. Its rank remains r. +In particular the nine COPY frames have rank seven in every permitted K; +D_P itself is an invertible 16-dimensional address map, not a rank-seven +Boolean matrix. + +The displayed 16-by-16 maps act on the local eight coordinates in each half +and extend by identity on all exterior coordinates. The input functions +remain arbitrary on the **full** address domain. At stage s the inherited +gauges include a common exterior projector E_s. Its factors commute with +local maps and cancel in every relative transport. For reflected calls, +`D_(I-P_a) D_(I-P_b) = D_Pa D_Pb`; the two local full-swap factors also +cancel. Hence both literal orientations use the checked local relative maps. +This is the inherited common-chart realization premise, not a new proof that +a uniform tape compiler implements those charts. + +## 2. Universal function simulation + +An interpreter term `(i,A)` denotes the entire arbitrary initial function +`f_i composed with A`. A row is an XOR of such terms. Actual MOVE transport +right-multiplies every A by its relative address map. Common-frame ADD XORs +the complete rows. No dirty column, exterior coordinate, or frame action is +silently omitted. This is distinct from testing one finite address grid. + +Equivalently, if a physical row is f with gauge Gamma, define its decoded +row to be `c = f composed with Gamma`. MOVE from a to b sends + + f -> f composed with Gamma_a composed with Gamma_b^-1, + +so c is unchanged. Equal-frame ADD adds decoded rows. A fresh COPY into a +blank owned private row at ZERO copies the decoded row by the same relative +transport. For a retained center at frame P, that transport is its actual +D_P, in either orientation. + +ERASE is accepted only if the private row equals the **current** center +transported by that same complete map. This is a chronological equality for +all inputs, not merely equality after eventual cleanup. R437 never writes or +moves the center inside its COPY window and never writes the copied row; +all readers are the designated ZERO-frame targets. Its guard therefore +holds, and the owned private row may be returned to blank. The checker also +verifies every full endpoint, rather than trusting this schematic induction. + +For local source ray S and complementary target K=I-S, the physical endpoint +has source transported by D_K, target transported by D_K plus source +transported by the full local swap, and helpers transported by the full local +swap. This follows from the checked decoded map `x'=x, h'=h, y'=y+x` and +`D_S D_K = D_I`. Both literal directions reproduce the expected operator +rows on all 659 input function symbols. Equal formal operator expressions +remain equal after substituting any correlated functions for those symbols; +independence is a verification device, not a physical freshness assumption. + +## 3. The actual changed dirt and a discriminating weaker contract + +The first, second, third, fifth, eighth and ninth forward captures keep their dirty +support after surviving-register renumbering. The former center 475 loses +old helper 470 and now has 62 rather than 63 dirty columns. Former centers +477 and 478 replace old helper 464 by surviving helper 340; their dirty counts +remain 46 and 43. The complete maps, SOURCE rows, COPY ranks and target +incidences remain fixed. These facts are credited to the original R437 +capture note and PR3700; this checker rederives them and exercises the +physical pullbacks of the current construction. + +There is a small source-bound counterexample to a **weaker**, label-specific +COPY contract. At current center 475/frame 515, take input function340 to be +the constant-one function, with every other initial function zero. The new +complete capture is one. Restricting COPY to the old capture's surviving +named dirty subset omits 340 and returns zero. The transported ERASE guard +then fails. The same issue occurs at center 476/frame 516. This is not a +counterexample to R437's explicitly universal contract, nor an allegation +that an existing implementation performs this projection. It proves why +clean SOURCE rows, dirt counts, or an older named-label audit cannot by +themselves discharge the current complete-stream implication. + +The executable controls also reject dropping all helper dirt, replacing the +map by a full swap, using a different rank-seven map, ignoring MOVE address +actions, aliasing the private family with a dirty persistent family, and +omitting the linear disposal charge. They remain active under `-O`. + +## 4. Physical ownership and scope of composition + +The private owner is family 28416 at the invocation's common cover class d. +Every persistent owner in all 288 call descriptors has family strictly below +28416. Family tags therefore separate the private stream from SOURCE, +TARGET and hosted dirty inputs for every d, regardless of correlated values. +The template reserves nine private families; this word has only one explicit +live copied stream. No new private family is added. + +The checker binds each of 125856 helper owner occurrences to its literal +slot and reconstructs its pending-axis support from the actual idle levels. +Within each invocation, helpers sharing a physical family have distinct +support charts; active data families are disjoint from hosted helpers. +The injectivity argument for those orthogonal charts is the inherited +PR1627 construction. The prior PR3883 transition audit independently checks +the complete chronology and residual suffix geometry; we do not rebrand that +coverage as a new whole-hosting proof. + +Once a complete call returns its private stream blank, sequential invocation +permits reuse at every stage/replica/cover class. This addresses the explicit +copied stream. It does **not** prove that a recursively implemented COPY +child's scratch or parked tape fits in the eight other reserved families. + +## 5. Complete local bill versus an implementation cost theorem + +The literal local bill in each orientation is: + +| Item | Count / charge | +| --- | ---: | +| Persistent arbitrary input functions | 659 | +| MOVE events | 2906 | +| Ordinary scalar ADDs, including dirty compensation and cleanup | 24208 | +| Scatter ADDs, already included above | 527 | +| COPY / ERASE episodes | 9 / 9 | +| Recursive COPY rank mass | 9×7 = 63 | +| Peak explicitly live copied streams | 1 | +| Complete local recursive rank mass | 5113 | +| Cancellation-free positive bound, forward / reverse | 49347 / 1113998 | + +A complete-stream COPY operates on one stream, not separately on each dirty +symbol appearing in its linear description. If a source-preserving rank-r +COPY implementation costs `C_r(V)` and uses child scratch `S_r(V)`, then an +episode with k target reads costs that implementation **plus** k scalar stream +ADDs, complete private-stream disposal, routing/descriptor handling and any +required precision/recovery work. The copied value occupies one owned stream +in addition to `S_r(V)` and control storage. The model does not imply a bound +on C_r or S_r merely because D_P is a known matrix. + +The retained convention charges one rank-seven child for each COPY and +linear complete-private-stream disposal for its paired ERASE. Guarded equality +licenses disposal of the owned copied output; it does not license erasure of +original/helper dirt. An implementation using another recursive transform to +uncompute instead would require another charge. We neither assume that +alternative is necessary nor assume its cost is zero. + +Across 288 local calls, the actual counts are 2592 COPYs, paid COPY rank mass +18144, and 2592 linear disposal episodes. The checker rederives the whole +paid profile from the literal slots and residual suffixes, including all +903456 edges. It retains the existing source/MOVE/COPY J coefficient 2002560, +ordinary ADDs/bridges, high-digit, stock, compiler, route selectors, matrix, +prefix and disposal terms. Prefix/coefficient widths remain 177 bits, charged +192; two-level width 393 is charged 512; ROW 18355 is below 20161. The bad-class +bound 98682 is retained under the131072-per-edge overcharge and bad fraction +10^-16. No further root calculation is needed for this applicability audit. + +Those coefficient formulas and their implementation interpretations are +**inherited bounds**. Recomputing their integers does not derive a new tape, +routing, scratch, precision or volume-normalization theorem. The precise +remaining handoff is to bind C_7(V), S_7(V), owned output and linear disposal +to an actual uniform caller on arbitrary complete streams and then prove +that caller's time, storage and recovery inequalities. Neither finite matrix +identities nor nine reserved family tags supply that missing implementation. diff --git a/research/t385-r437-copy-audit/R437-CAPTURE-SCOPE.txt b/research/t385-r437-copy-audit/R437-CAPTURE-SCOPE.txt new file mode 100644 index 0000000000..b6cf3e21b5 --- /dev/null +++ b/research/t385-r437-copy-audit/R437-CAPTURE-SCOPE.txt @@ -0,0 +1,37 @@ +Capture dirt and the inherited complete-stream interface + +This note responds to Sagar Thakrar's PR3700, open question 1, at head +aa0bd9fbc8700506b1fafcc55bca9bd32aced7d9. It states the exact interface used +by this conditional finite certificate; it does not prove a new all-size +physical implementation of that interface. + +The selected #589 captures are already dirty: the nine retained totals carry +42,44,46,63,66,46,43,62,59 helper columns at COPY. In the helper464 edit, +the captures originally called h477 and h478 replace the deleted helper464 +column with helper340's column, keeping their clean rows and 46/43 dirt +counts. The helper470 edit drops its dirt column at the capture originally +called h475. The public independent audit derives these facts from the word; +this package's full-basis audits check the resulting word and all COPY windows. + +The inherited interface required here is universal in the complete current +stream: for a fixed legal frame/window, COPY applies one paid linear transform +to an arbitrary stream and private-stream discard retains its complete linear +cost. It is not an interface restricted to a prescribed named subset of dirty +helper labels. A fixed linear transform/discard law valid on every independent +input basis column is valid on every linear combination of SOURCE, TARGET and +helper contents. Changing which such columns occur in a total therefore does +not change this interface's width, frame, private lifetime or paid rank. The +record replay checks all 659 input columns in both orientations and closes +every COPY window while restoring the original helper contents. No dirty +column is projected away to obtain the reported identity or price. + +This observation explains why the stated arbitrary-stream interface suffices +for the changed capture contents. It does not establish that an implementation +having a weaker, label-specific contract realizes that interface. The selected +all-size/common-label SOURCE/compiler/field/cover and correlated-hosting +realization obligations remain explicit and conditional. In particular, this +note does not erase arbitrary original/helper dirt for free, reschedule a +SOURCE query, narrow a retained private stream, or prove a new whole exponent. + +Credit: Sagar Thakrar / PR3700 for identifying the capture-column substitution; +the clarification and package integration used substantial OpenAI Codex help. diff --git a/research/t385-r437-copy-audit/R437-LICENSE b/research/t385-r437-copy-audit/R437-LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/t385-r437-copy-audit/R437-LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/t385-r437-copy-audit/R437-UPSTREAM-NOTICE.md b/research/t385-r437-copy-audit/R437-UPSTREAM-NOTICE.md new file mode 100644 index 0000000000..9b519b904d --- /dev/null +++ b/research/t385-r437-copy-audit/R437-UPSTREAM-NOTICE.md @@ -0,0 +1,71 @@ +# Notice + +Apache-2.0 (`LICENSE`, copied from #493's package). Prepared by eumemic with substantial Anthropic Claude +assistance. + +## New in this package + +- `code/gen_p3.py` (the generator of the punctured word: the L3 skeleton of #543 restricted to the live lines, the + pseudo-target totals, the phase-A mini-nodes and extra carriers), `code/pwordl.py` (word builder for a live subset + of the 120 lines; output in the bitE8/1 layout with the `ports_geom` and `punctured` fields introduced by #545), + `data/bitE8mut-p111.json.gz` (the word), `data/punct.json` (its frozen parameters), `discovery/choose.py` and + `discovery/search.py` (the nomination of P and of the parameters; not run by `verify.sh`). +- `code/gen_p3.py` carries `derive`, `ex_part` and `plan_thirds` from #543's `code/gen_l3.py` (eumemic), and + `data/plan-l3.json` is #543's CP-SAT plan, unchanged. `code/nodeopt.py`, `code/planio.py`, `code/mutants.py`, + `code/mutrec_b.py` and `code/provenance.py` are #543's files, unchanged. +- `code/xcheck_p.py`: #543's independent checker `code/xcheck.py` with nine listed edits for v <= 120 live labels + (root-line enumeration of the lattice, frame closure and target frames over the live labels) and a new part T (the + frame and COPY rank of every retained total at the scatter, and whether it is the hyperplane of a punctured line). +- `code/mutants_p.py` (punctured-design controls), `code/adapt9p.py` (#510's nine-stage files parameterised for + v <= 120 and any copy ranks, the way #545's `adapt.py` parameterises #493's eleven-stage files), `code/cited.py`, + `code/receipt_kappa.py`, `code/summary.py`, `verify.sh`, `EXPECTED.json`, `DEPENDS.json`, `requirements.txt`, + `data/complex-b.json`, `data/selection9-p111.json` and `data/hosting11-p111.json` (frozen nominations of #442's + hosting programme, rediscovered by `verify.sh`), `.github/workflows/e8-bit-p111.yml`. + +## Vendored, byte-identical (git blob ids in `SOURCE-pr*.json`, checked by `code/provenance.py`) + +- **PR #510 (DreamingOfClouds, with Claude Opus 5.5 via Claude Code), commit 64edee1** (`vendor/pr510/`): the same 19 + files as #543's package (#510's nine-stage chain with the files it vendors from #463, #443, #442 and #315, and #503's + R480 word). Their notices are listed in #543's NOTICE and in the files. +- **PR #545 (DreamingOfClouds, with Claude Opus 5.5 via Claude Code; draft), commit 376426f** (`vendor/pr545/`): + `code/adapt.py` and `code/punct_cfg.py`, run unchanged on this package's word; `data/bitE8mut-v111-r489.json.gz`, + `data/hosting-v111-r489.json` and `EXPECTED.json` (a control). +- **PR #548 (Dugongue), commit 66dbc2b** (`data/complex/pr548/`): `EXPECTED.json` and `evidence/EXACT-ASSEMBLY.json`. +- **PR #544 (chafreaky, with OpenAI Codex assistance), commit 4858bb3** (`data/complex/pr544/`): `EXPECTED.json` and + the Linux exact-assembly receipt. +- **PR #535 (icekylinx, with GPT-6 Astra assistance), commit 8b758a1** (`data/complex/pr535/`): `EXPECTED.json` and + `evidence/audit/EXACT-ASSEMBLY-PR493.json`. + +## Used from main, unchanged (pinned in `DEPENDS.json`) + +- `research/e8-bit-carrier-skeleton` (PR #493, eumemic): the skeleton modules and D4 partition the generator imports, + #370's checker (run here in #545's v <= 120 form), the official cohort checkers, `gram_frames.py`, the record + exporter, the geometries and the eleven-stage chain that #545's `adapt.py` parameterises, #442's hosting programme, + the R489 word, the control receipts and #315's engines. +- `research/direct-delivery504-global/EXPECTED.json` (PR #531, icekylinx): its complex b and kappa. + +## Cited, not rebuilt + +Complex coarse savings in `data/complex-b.json`, each bound to its PR's receipt by `code/cited.py`: PR #548 (primary; +open), PR #544 and PR #535 (open), PR #531 (merged), and PR #484, #471 and #458 (controls). + +## Ideas used + +- PR #545 (DreamingOfClouds): the punctured-star unit. Nine lines are neither sources nor targets; each retained total + is a pseudo-target that reads what the removed target would read, at frame rank 7, so the decoder constant is 63; + the rank-mass identity with v and the decoder constant as parameters; the parameterisation of the hub chain. +- PR #543 (eumemic): the R420 L3 skeleton with keepers read by targets and rewritten in phase B. +- PR #493 (eumemic), PR #503 and #510 (DreamingOfClouds), PR #425 (Zhihao Chen / jacklightChen), PR #370 (Dylan Crow), + PR #472, #445, #443 (chafreaky), PR #442 (DaysSky), PR #463 and #315 (DreamingOfClouds), PR #386 (Zhihao Chen): the + skeleton, the scalar-interface lemma, the format, and the pricing pipelines. +- PR #523 (icekylinx): the puncture pattern on the complex side, cited by #545. +- Jacob Sussman introduced the E8 unit. + +R437 composition: Ali Romman (@aliromman), with substantial OpenAI Codex assistance, authored the public1043 helper470 source-boundary deletion. Its exact canonical-main package and NOTICE are retained in public1043/. The new contribution here composes that credited deletion with the independently validated helper464 GL, then reconstructs actual owners, full invoice, independent checks and portable replay. + +Sagar Thakrar (thakrarsagar), PR3700 Open question4, proposed the exact +window6 two-leftover coalescing used by this follow-up. No code from that +PR is imported by the author pipeline; root independently replayed its +hosting and price engines. Full owner/template/invoice regeneration and +packaging used substantial OpenAI Codex assistance. All prior credits and +Apache-2.0 notices remain in place. diff --git a/research/t385-r437-copy-audit/README.md b/research/t385-r437-copy-audit/README.md new file mode 100644 index 0000000000..56e2c929b9 --- /dev/null +++ b/research/t385-r437-copy-audit/README.md @@ -0,0 +1,136 @@ +# T385 replay and R437 complete-stream COPY audit + +**Scoped independent execution and applicability audit; no supplier admission +or selected-frontier change.** This follows the donor-assigned next questions +of PR3883. T385 execution evidence is recorded separately from the new R437 +implementation. The selected conditional kappa remains 0.001672660197076918. + +## R437 result + +The new standard-library checker imports no predecessor executable. It +reconstructs both literal R437 programs from the current WORD, compares them +with the OQ4 template, reconstructs all 636 frame projectors, and executes +actual exact address pullbacks for all 659 arbitrary input functions. Both +complete physical endpoints and all nine transported COPY/ERASE guards pass. +No finite address sample or clean-input projection substitutes for a complete +function identity. Both local directions have 24,208 ADDs, 2,906 MOVEs, nine +rank-seven COPYs and nine paired ERASEs. + +The changed captures are rederived against selected PR589. Old helper 470 is +removed from one capture; helper 340 replaces old helper 464 in two others. +At the forward capture at center 475/frame 515, setting only arbitrary dirty input 340 to the +constant-one function separates the complete COPY from a weaker contract +restricted to the predecessor's surviving named dirt. Seven semantic controls +reject. The full informal argument, exact boundary and tariff limitations are +in [PROOF.md](PROOF.md); [RESULT.json](RESULT.json) is freshly recomputed. + +This independently applies the credited exact-stream/gauge framework to +R437's actual changed head. It does not claim to invent the gauge theorem, +rank-seven address maps, capture substitution or OQ4 placement. + +## Cost result and remaining implementation premise + +The finite cost audit binds all 125856 helper owner occurrences and separates +the one copied stream from every persistent family. It reconstructs the paid +profile and retains all 903456 edges, bad-class fallback and historical +coefficient terms. Across 288 calls there are 2592 COPY episodes, rank mass 18144 +for those transforms, and 2,592 separately charged linear disposal episodes. +The existing 177/192-bit prefix and 393/512-bit two-level charges and ROW 18355 +are reproduced. The [concrete caller boundary](CALLER-BOUNDARY.md) traces the +existing source-clone/residual/private/CLEAR path and distinguishes its reduced +fixtures from the still-pending universal implementation proof. + +This is complete **finite accounting under the inherited tariff**, not a new +proof of that tariff. A uniform source-preserving rank-seven child, its +restored scratch, physical tape/routing, volume normalization, precision and +recovery remain conditional. Nine reserved families do not by themselves +prove the child's scratch fits. The ledger charges one recursive transform and linear disposal per episode. +A second recursive uncompute would need its own charge if an implementation +used it. + +## T385 execution + +The longer one-job full wrapper is run at exact PR3802 head +`de2cd5c58009205210e3bf328b0ef5cadf3903af`, with a fresh work directory, +CPython 3.12.3 and numpy 2.2.6/scipy 1.15.3/sympy 1.14.0/mpmath 1.3.0. The declared +initial limit was 2,400 seconds, replacing the earlier 780-second cap. +After measured stage durations, the ceiling was extended to 3,000 and then +3,180 seconds while keeping the scientific wrapper uninterrupted. + +**Completed:** `PASS_T385_COMPLETE_CONDITIONAL_RELEASE`, exit 0. All seven +wrapper stages passed: owners, parent-lift, rebind, discovery, both outer +checks and release. The retained supervisor interval is 2946.086 seconds +(49 minutes 6 seconds, including brief post-exit collection latency). +The final strict release also passed all eight internal stages. +`T385-EXECUTION.json` binds stage logs, exact endpoint, source manifest, native +receipt, environment and timeout extension; `EVIDENCE.json` authenticates the +retained files. Absolute session paths are normalized with original digests +retained. `check_execution.py` passes with three rejection controls. +Unchanged native suppliers and retained ancestry are explicitly reused. This +is a conditional source-bound execution, not an independent native +reimplementation or an unconditional theorem. + +## Reproduce + +From a repository root with this package, standard-library Python 3.12: + +```sh +python3.12 -I -B research/t385-r437-copy-audit/verify.py +python3.12 -I -O -B research/t385-r437-copy-audit/verify.py +python3.12 -B scripts/research_package.py --package research/t385-r437-copy-audit +python3.12 -B scripts/check_research_commit.py --package research/t385-r437-copy-audit --check-source-history +``` + +The bounded hook recomputes the R437 result and semantic controls. It does not +repeat the long T385 execution. Its fourth command authenticates the recorded +T385 result and rejects incomplete-stage, prepared-status and wrong-endpoint controls. Retained scientific inputs are SHA256/Git-blob +bound in `SOURCES.json.retained`, with exact origin heads and paths. The large geometry JSON is retained losslessly in a gzip transport; its +decompressed original bytes carry the source hash. The inputs are +inside this package and do not require foreign pending Git objects at runtime. +`SOURCES.json.files` pins historical catalogue, selected record and credited +proof context at canonical base `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. + +## Coordination and source status + +Canonical main and priority revision 6 were refreshed at entry. The explicitly +assigned task refines `independent-moment`; no task reroll or allocation search +was performed. Seven open-PR pages contained 633 entries at the initial scan; +the final refresh at 04:59 UTC contained 638 unique open PRs across seven +pages. Related #3700/#3802/#3815/#3857/#3875/#3890 were inspected as +overlapping coverage. No new conflicting assignment was found. Discussion coverage is partial. The claim +is [a reply to the released handoff](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19030424), +with PR3883 as the investigation record. The connector denied upstream comment +creation; the authorized claim was posted through Chrome. + +The main baseline source-binding check passes after materializing its sparse +inputs. This is orientation only, not a full selected cold replay. Exact +validation results are retained in `VALIDATION.json` and the registered-hook log. +Publication-byte and source-history checks are run against the GitHub-created commit. + +## Open next questions + +Structured questions are in `TASK.json`. Bind one actual complete-stream +COPY child to its source-preserving caller, owned output, restored scratch, +linear disposal and full time/storage/recovery bill. This can close a real +implementation premise; another digit refinement cannot. T385 now has a complete recorded wrapper replay; fresh native reconstruction +and inherited all-size implementation premises remain separate obligations. + +## Credit and license + +Credit ai-nanachi/PR3647 for R437, Sagar Thakrar/PR3700 for the independent +older-head audit, capture question and OQ4 placement, and Ali Romman/PR1043 +for helper 470. Retain eumemic, DreamingOfClouds, DaysSky, cheesegrader, +chafreaky, Zhihao Chen and the native/compiler/owner/outer lineage in the +unchanged `R437-UPSTREAM-NOTICE.md` and `R437-LICENSE`. + +The exact-stream/gauge and physical owner framework is alephnan/PR1627; +Adam Gall/PR2088, the selected-COPY separation audit and the two-copy physical +audit are prior complete-operator coverage. Ross Richardson/PR1704 and the +live-COPY stabilizer/intertwiner lineage distinguish chronological guards +from eventual cleanup. This new implementation imports none of their code. + +For T385 credit dataisfire/PR3734, hexapode/PR3802, ChaloupeMusic/PR3815, +PR3638 and all native/owner/outer authors retained by those packages. New +implementation, execution and writing by Chris R / Clear1nsight with +substantial OpenAI Codex assistance. Apache-2.0. No independent human review +or formal-kernel verification is claimed. diff --git a/research/t385-r437-copy-audit/RESULT.json b/research/t385-r437-copy-audit/RESULT.json new file mode 100644 index 0000000000..fff5bc4828 --- /dev/null +++ b/research/t385-r437-copy-audit/RESULT.json @@ -0,0 +1,3013 @@ +{ + "capture_changes": [ + { + "COPY_address_map": { + "denominator": 4, + "rows": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 1, + 0, + -1, + 0, + 0, + 1, + 0, + 3, + -1, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 1, + 1, + 0, + -1, + 0, + 0, + 1, + 0, + -1, + 3, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0 + ], + [ + 0, + -1, + -1, + 0, + 1, + 0, + 0, + -1, + 0, + 1, + 1, + 0, + 3, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0 + ], + [ + 0, + 1, + 1, + 0, + -1, + 0, + 0, + 1, + 0, + -1, + -1, + 0, + 1, + 0, + 0, + 3 + ], + [ + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 3, + -1, + 0, + 1, + 0, + 0, + -1, + 0, + 1, + 1, + 0, + -1, + 0, + 0, + 1 + ], + [ + 0, + -1, + 3, + 0, + 1, + 0, + 0, + -1, + 0, + 1, + 1, + 0, + -1, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 1, + 0, + 3, + 0, + 0, + 1, + 0, + -1, + -1, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + -1, + -1, + 0, + 1, + 0, + 0, + 3, + 0, + 1, + 1, + 0, + -1, + 0, + 0, + 1 + ] + ] + }, + "SOURCE_row_hex": "0x7faa33a86730e2ae16b0d6b0ca69", + "added_surviving_labels": [], + "arbitrary_dirty_row_hex": "0x108001001008a2200880a0880880a088000058011114000004410040144500002040041", + "frame": 510, + "new_center": 470, + "new_dirty_count": 42, + "old_center": 472, + "old_dirty_count": 42, + "removed_old_dirty_labels": [], + "removed_surviving_labels": [] + }, + { + "COPY_address_map": { + "denominator": 4, + "rows": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + -1, + 0, + 0, + -1, + 0, + 3, + 1, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + -1, + 1, + 0, + 1, + 0, + 0, + 1, + 0, + 1, + 3, + 0, + -1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0 + ], + [ + 0, + -1, + 1, + 0, + 1, + 0, + 0, + 1, + 0, + 1, + -1, + 0, + 3, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0 + ], + [ + 0, + -1, + 1, + 0, + 1, + 0, + 0, + 1, + 0, + 1, + -1, + 0, + -1, + 0, + 0, + 3 + ], + [ + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 3, + 1, + 0, + 1, + 0, + 0, + 1, + 0, + 1, + -1, + 0, + -1, + 0, + 0, + -1 + ], + [ + 0, + 1, + 3, + 0, + -1, + 0, + 0, + -1, + 0, + -1, + 1, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + 3, + 0, + 0, + -1, + 0, + -1, + 1, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + -1, + 0, + 0, + 3, + 0, + -1, + 1, + 0, + 1, + 0, + 0, + 1 + ] + ] + }, + "SOURCE_row_hex": "0x7fd5cca866cf1d51d6b0e94f0a69", + "added_surviving_labels": [], + "arbitrary_dirty_row_hex": "0x4002038a22220020a080880a082828800a80400012004410044410005001200802", + "frame": 511, + "new_center": 471, + "new_dirty_count": 44, + "old_center": 473, + "old_dirty_count": 44, + "removed_old_dirty_labels": [], + "removed_surviving_labels": [] + }, + { + "COPY_address_map": { + "denominator": 4, + "rows": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0, + -1, + -1, + 0, + 0, + 3, + -1, + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0, + -1, + -1, + 0, + 0, + -1, + 3, + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0 + ], + [ + 0, + -1, + -1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 3, + -1, + 0 + ], + [ + 0, + -1, + -1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + -1, + 3, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4 + ], + [ + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 3, + -1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + -1, + -1, + 0 + ], + [ + 0, + -1, + 3, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + -1, + -1, + 0 + ], + [ + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0, + 3, + -1, + 0, + 0, + -1, + -1, + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0, + -1, + 3, + 0, + 0, + -1, + -1, + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ] + }, + "SOURCE_row_hex": "0x33335532abfce1e470e970e97899", + "added_surviving_labels": [], + "arbitrary_dirty_row_hex": "0x28000100040424080802101104041112c20004a002602801200848012009080118008240", + "frame": 512, + "new_center": 472, + "new_dirty_count": 46, + "old_center": 474, + "old_dirty_count": 46, + "removed_old_dirty_labels": [], + "removed_surviving_labels": [] + }, + { + "COPY_address_map": { + "denominator": 4, + "rows": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + 1, + -1, + 0, + 0, + 3, + 1, + 0, + 0, + -1, + 1, + 0 + ], + [ + 0, + -1, + 1, + 0, + 0, + -1, + 1, + 0, + 0, + 1, + 3, + 0, + 0, + 1, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + 1, + -1, + 0, + 0, + -1, + 1, + 0, + 0, + 3, + 1, + 0 + ], + [ + 0, + -1, + 1, + 0, + 0, + -1, + 1, + 0, + 0, + 1, + -1, + 0, + 0, + 1, + 3, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4 + ], + [ + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 3, + 1, + 0, + 0, + -1, + 1, + 0, + 0, + 1, + -1, + 0, + 0, + 1, + -1, + 0 + ], + [ + 0, + 1, + 3, + 0, + 0, + 1, + -1, + 0, + 0, + -1, + 1, + 0, + 0, + -1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + -1, + 1, + 0, + 0, + 3, + 1, + 0, + 0, + 1, + -1, + 0, + 0, + 1, + -1, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + 1, + 3, + 0, + 0, + -1, + 1, + 0, + 0, + -1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ] + }, + "SOURCE_row_hex": "0x4ccc55ccabff1e1470d6b0d68799", + "added_surviving_labels": [], + "arbitrary_dirty_row_hex": "0x4080104004100084001000000c00000010020400000c008a001806060200290601002aa988002000a1040000812809006210000a20141", + "frame": 513, + "new_center": 473, + "new_dirty_count": 62, + "old_center": 475, + "old_dirty_count": 63, + "removed_old_dirty_labels": [ + 470 + ], + "removed_surviving_labels": [] + }, + { + "COPY_address_map": { + "denominator": 4, + "rows": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 3, + -1, + -1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + -1, + 3, + -1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + -1, + -1, + 3, + -1 + ], + [ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + -1, + -1, + -1, + 3 + ], + [ + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 3, + -1, + -1, + -1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + -1, + 3, + -1, + -1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + -1, + -1, + 3, + -1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + -1, + -1, + -1, + 3, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ] + ] + }, + "SOURCE_row_hex": "0x33666664cccffb4599999999b20f", + "added_surviving_labels": [], + "arbitrary_dirty_row_hex": "0x2080084004080082002000000c08800010020800010401018100824282404142014082824015a30802404002818001004202018200069", + "frame": 514, + "new_center": 474, + "new_dirty_count": 66, + "old_center": 476, + "old_dirty_count": 66, + "removed_old_dirty_labels": [], + "removed_surviving_labels": [] + }, + { + "COPY_address_map": { + "denominator": 4, + "rows": [ + [ + 1, + 1, + -1, + 1, + 0, + 0, + 0, + 0, + 3, + -1, + 1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + -1, + 1, + 0, + 0, + 0, + 0, + -1, + 3, + 1, + -1, + 0, + 0, + 0, + 0 + ], + [ + -1, + -1, + 1, + -1, + 0, + 0, + 0, + 0, + 1, + 1, + 3, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + -1, + 1, + 0, + 0, + 0, + 0, + -1, + -1, + 1, + 3, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4 + ], + [ + 3, + -1, + 1, + -1, + 0, + 0, + 0, + 0, + 1, + 1, + -1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 3, + 1, + -1, + 0, + 0, + 0, + 0, + 1, + 1, + -1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 3, + 1, + 0, + 0, + 0, + 0, + -1, + -1, + 1, + -1, + 0, + 0, + 0, + 0 + ], + [ + -1, + -1, + 1, + 3, + 0, + 0, + 0, + 0, + 1, + 1, + -1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ] + }, + "SOURCE_row_hex": "0x78700f0fe1e257f1c3fc3c03c7f0", + "added_surviving_labels": [ + 340 + ], + "arbitrary_dirty_row_hex": "0x2003250018000011004455004000400086e2009200a86a0028000085008a8a00", + "frame": 515, + "new_center": 475, + "new_dirty_count": 46, + "old_center": 477, + "old_dirty_count": 46, + "removed_old_dirty_labels": [ + 464 + ], + "removed_surviving_labels": [] + }, + { + "COPY_address_map": { + "denominator": 4, + "rows": [ + [ + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 3, + 0, + 0, + -1, + -1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + -1, + 0, + 0, + 3, + -1, + 0, + 0, + -1 + ], + [ + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + -1, + 0, + 0, + -1, + 3, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0 + ], + [ + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + -1, + 0, + 0, + -1, + -1, + 0, + 0, + 3 + ], + [ + 3, + 0, + 0, + -1, + -1, + 0, + 0, + -1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1 + ], + [ + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 3, + -1, + 0, + 0, + -1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1 + ], + [ + -1, + 0, + 0, + -1, + 3, + 0, + 0, + -1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + -1, + -1, + 0, + 0, + 3, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1 + ] + ] + }, + "SOURCE_row_hex": "0x785a3c5878d2b55feab32ab33266", + "added_surviving_labels": [ + 340 + ], + "arbitrary_dirty_row_hex": "0x18000400250000144054021000060140000444044160e880080608000a02020080828", + "frame": 516, + "new_center": 476, + "new_dirty_count": 43, + "old_center": 478, + "old_dirty_count": 43, + "removed_old_dirty_labels": [ + 464 + ], + "removed_surviving_labels": [] + }, + { + "COPY_address_map": { + "denominator": 4, + "rows": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 1, + 0, + 0, + 1, + -1, + 0, + 0, + 3, + -1, + 0, + 0, + -1, + 1 + ], + [ + 0, + 0, + 1, + 1, + 0, + 0, + 1, + -1, + 0, + 0, + -1, + 3, + 0, + 0, + -1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0 + ], + [ + 0, + 0, + 1, + 1, + 0, + 0, + 1, + -1, + 0, + 0, + -1, + -1, + 0, + 0, + 3, + 1 + ], + [ + 0, + 0, + -1, + -1, + 0, + 0, + -1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 3 + ], + [ + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 3, + -1, + 0, + 0, + -1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + -1 + ], + [ + 0, + 0, + -1, + 3, + 0, + 0, + -1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + -1, + -1, + 0, + 0, + 3, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + -1 + ], + [ + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 3, + 0, + 0, + -1, + -1, + 0, + 0, + -1, + 1 + ] + ] + }, + "SOURCE_row_hex": "0x2d25f094b54994c6a97fe6569133", + "added_surviving_labels": [], + "arbitrary_dirty_row_hex": "0x20a002002014004004001020001000820040020040080c0224008118000011002800422242440000280440205960282020844110a04", + "frame": 517, + "new_center": 477, + "new_dirty_count": 62, + "old_center": 479, + "old_dirty_count": 62, + "removed_old_dirty_labels": [], + "removed_surviving_labels": [] + }, + { + "COPY_address_map": { + "denominator": 4, + "rows": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + -1, + 0, + -1, + 0, + -1, + 0, + 3, + 0, + 1, + 0, + 1, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + -1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 3, + 0, + -1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0 + ], + [ + 0, + -1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + -1, + 0, + 3, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0 + ], + [ + 0, + -1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + -1, + 0, + -1, + 0, + 3 + ], + [ + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 3, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + -1, + 0, + -1, + 0, + -1 + ], + [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 3, + 0, + -1, + 0, + -1, + 0, + -1, + 0, + 1, + 0, + 1, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + -1, + 0, + 3, + 0, + -1, + 0, + -1, + 0, + 1, + 0, + 1, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + -1, + 0, + -1, + 0, + 3, + 0, + -1, + 0, + 1, + 0, + 1, + 0, + 1 + ] + ] + }, + "SOURCE_row_hex": "0x1e165a581eb68ad2d9a9697fe955", + "added_surviving_labels": [], + "arbitrary_dirty_row_hex": "0x1001000830010001200000a00040005040048040001010010081002001100200000590104880002400109201088214c101c5420002012", + "frame": 518, + "new_center": 478, + "new_dirty_count": 59, + "old_center": 480, + "old_dirty_count": 59, + "removed_old_dirty_labels": [], + "removed_surviving_labels": [] + } + ], + "controls": [ + { + "control": "project helper dirt away at COPY", + "rejected_by": "ERASE complete transported equality" + }, + { + "control": "rank-eight swap priced seven", + "rejected_by": "ERASE complete transported equality" + }, + { + "control": "different rank-seven map", + "rejected_by": "ERASE complete transported equality" + }, + { + "control": "MOVE labels without address action", + "rejected_by": "physical arbitrary-function endpoint 0" + }, + { + "control": "private family aliases persistent dirty input", + "rejected_by": "private aliases persistent family" + }, + { + "control": "omit private discard cost", + "rejected_by": "linear complete-private-stream discard charge" + }, + { + "control": "predecessor-only dirt contract at changed capture 475", + "rejected_by": "ERASE complete transported equality" + } + ], + "directions": { + "forward": { + "arbitrary_input_functions": 659, + "captures": [ + { + "center": 470, + "dirty_terms": 42, + "frame": 510, + "terms": 98 + }, + { + "center": 471, + "dirty_terms": 44, + "frame": 511, + "terms": 104 + }, + { + "center": 472, + "dirty_terms": 46, + "frame": 512, + "terms": 104 + }, + { + "center": 473, + "dirty_terms": 62, + "frame": 513, + "terms": 120 + }, + { + "center": 474, + "dirty_terms": 66, + "frame": 514, + "terms": 125 + }, + { + "center": 475, + "dirty_terms": 46, + "frame": 515, + "terms": 104 + }, + { + "center": 476, + "dirty_terms": 43, + "frame": 516, + "terms": 102 + }, + { + "center": 477, + "dirty_terms": 62, + "frame": 517, + "terms": 118 + }, + { + "center": 478, + "dirty_terms": 59, + "frame": 518, + "terms": 118 + } + ], + "counts": { + "ADD": 24208, + "COPY": 9, + "ERASE": 9, + "MOVE": 2906 + }, + "endpoint_sha256": "5e98c64e9814694ec989f4fafcd015e667b53110a7cffb06df63433e16c800fa", + "positive_bound": 49347, + "private_streams_peak": 1, + "profile": { + "1": 1320, + "2": 1344, + "3": 77, + "4": 43, + "5": 102, + "6": 11, + "7": 18 + }, + "transported_atoms": 64384 + }, + "reverse": { + "arbitrary_input_functions": 659, + "captures": [ + { + "center": 478, + "dirty_terms": 59, + "frame": 518, + "terms": 118 + }, + { + "center": 477, + "dirty_terms": 62, + "frame": 517, + "terms": 118 + }, + { + "center": 476, + "dirty_terms": 43, + "frame": 516, + "terms": 102 + }, + { + "center": 475, + "dirty_terms": 46, + "frame": 515, + "terms": 104 + }, + { + "center": 474, + "dirty_terms": 66, + "frame": 514, + "terms": 125 + }, + { + "center": 473, + "dirty_terms": 62, + "frame": 513, + "terms": 120 + }, + { + "center": 472, + "dirty_terms": 46, + "frame": 512, + "terms": 104 + }, + { + "center": 471, + "dirty_terms": 44, + "frame": 511, + "terms": 104 + }, + { + "center": 470, + "dirty_terms": 42, + "frame": 510, + "terms": 98 + } + ], + "counts": { + "ADD": 24208, + "COPY": 9, + "ERASE": 9, + "MOVE": 2906 + }, + "endpoint_sha256": "5e98c64e9814694ec989f4fafcd015e667b53110a7cffb06df63433e16c800fa", + "positive_bound": 1113998, + "private_streams_peak": 1, + "profile": { + "1": 1320, + "2": 1344, + "3": 77, + "4": 43, + "5": 102, + "6": 11, + "7": 18 + }, + "transported_atoms": 64171 + } + }, + "domain": "Ideal exact Boolean streams on odd-characteristic address fields; arbitrary complete functions including correlated dirt", + "finite_cost": { + "COPY_episodes": 2592, + "COPY_rank_mass": 18144, + "ERASE_linear_episodes": 2592, + "J": 2002560, + "ROW": 18355, + "bad_fraction": "1/10000000000000000", + "charged_prefix_bits": 192, + "charged_two_level_bits": 512, + "coefficient_bits": 177, + "components": { + "compiler_edges": "242519623335936", + "good_edges": "29611673856", + "linear_private_discard": "2592", + "matrix_test": "4194304", + "one": "1", + "prefix": "118135750078243242693955380695625753717181264196272128", + "selectors": "5654715840", + "source_move_copy_high": "537820618352640", + "source_move_copy_physical": "56922768000", + "unit_ADD": "7035840" + }, + "cost_reuse": "Historical high/physical/compiler/route/prefix/ROW/fallback coefficient bounds are source-bound inputs, not re-proved implementations", + "edges": 903456, + "fallback_exact_per_edge": 98682, + "fallback_overcharge_per_edge": 131072, + "fallback_total_rank_one_weight": 118417784832, + "helper_owner_occurrences": 125856, + "implementation_cost_status": "INHERITED_CONDITIONAL_NOT_A_NEW_COMPILER_BOUND", + "local_calls": 288, + "physical_families": 28425, + "prefix_bits": 177, + "private_family": 28416, + "profile": { + "1": 380160, + "2": 400864, + "3": 22176, + "4": 26592, + "5": 29376, + "6": 17376, + "7": 26496, + "26": 32, + "42": 384 + }, + "reserved_private_families": 9, + "two_level_bits": 393 + }, + "label_specific_counterexample": { + "arbitrary_dirty_input": 340, + "center": 475, + "complete_COPY_value": 1, + "frame": 515, + "input_function": "constant one; every other initial function zero", + "predecessor_surviving_named_dirt_only_COPY_value": 0, + "scope": "Counterexample to a weaker label-specific contract, not to R437's stated universal contract" + }, + "new_compiler_or_supplier_admission": false, + "remaining": [ + "uniform all-size source-preserving COPY child and restored recursive scratch", + "actual tape/routing/volume-normalized cost", + "mutable SOURCE/common field/cover realization", + "precision/recovery/analytic/BIT premises" + ], + "selected_frontier_changed": false, + "status": "PASS_R437_ARBITRARY_STREAM_AND_FINITE_COPY_COST_AUDIT" +} diff --git a/research/t385-r437-copy-audit/SOURCES.json b/research/t385-r437-copy-audit/SOURCES.json new file mode 100644 index 0000000000..ba1c52a5a5 --- /dev/null +++ b/research/t385-r437-copy-audit/SOURCES.json @@ -0,0 +1,140 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/bit-selected-copy-separation/README.md", + "usage": "provenance", + "git_blob": "9978d55bd8e6562a109c2fbd4563241c7a2c7d8a", + "sha256": "898aa7df7d292f3d2205e54043c6b865515dd431350fe57b4c239df6f3ed9ee5" + }, + { + "path": "research/bit-two-copy-physical/README.md", + "usage": "provenance", + "git_blob": "dd6271806fe3b5f15c03a733cd1e91908d63df13", + "sha256": "8fb8fe7a164f86beecaf4e8524e06389988f4bcc5ebeccc3efcd2a10a2c89480" + }, + { + "path": "research/pr589-five-helper-hosting/PROOF.md", + "usage": "provenance", + "git_blob": "bbd3f12b9a32b3ad3cba85a2d5a1b3054214fa02", + "sha256": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647" + }, + { + "path": "docs/research/selected-bit-physical-contract-map.md", + "usage": "provenance", + "git_blob": "bc2810efa90ba8d5a25cc9627ae9ffd4ffa5c5a0", + "sha256": "1311f839e109a16e3f1c093a62b51583ebaf1277ffda6e0df0768ba8e6a09c8e" + }, + { + "path": "research/selected-bit-physical-caller/README.md", + "usage": "provenance", + "git_blob": "abd0edba96101a025609d2840c3dbdf4d3e30aa8", + "sha256": "989ad891ce3f866c920a25e0cdd661815f982c4c854370f8c00668eaa15d770c" + }, + { + "path": "research/selected-bit-physical-caller/PROOF.md", + "usage": "provenance", + "git_blob": "548ecff3ef79a32c14bafc7f2309781181d3c23d", + "sha256": "e5a827e93fe313ba9bf4a2e300bae01b58b28004aa8a8ee119cf6d950edd9f93" + }, + { + "path": "research/selected-bit-physical-caller/macro_code.py", + "usage": "provenance", + "git_blob": "2f5f8ecfac6457171707b1b5ff02b5071954fcb7", + "sha256": "f626b018124747a5f17c1603bea36cd74c00a69a0647fd7b10e9c4e2964caea8" + }, + { + "path": "research/selected-bit-physical-caller/macro_machine.py", + "usage": "provenance", + "git_blob": "5a032e8923f7f8b22bb98f3e39b804beb9906c16", + "sha256": "7bc6e42072a09a08ac961e05c3da01cde012d740d4b4c605f298d994f2ad7c5a" + }, + { + "path": "research/selected-bit-physical-caller/macro_local_checks.py", + "usage": "provenance", + "git_blob": "421f9030f91f3ab309a9873928c09ba8a2ade580", + "sha256": "a9be60378d1282184632066b87cb044a8510b6623acf0df4dbf2f1bcd35cb830" + } + ], + "retained": [ + { + "path": "research/t385-r437-copy-audit/inputs/r437-word.json.gz", + "usage": "input", + "git_blob": "c558a221dd44cbdaa732a401f9876de4c096d4a7", + "sha256": "e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e", + "origin_commit": "a24f9ff95c12fd0b6792e3f710569237efd72db2", + "origin_path": "research/bit-p111-r437-gl464-470-20261018/data/r0042/R437-COMPOSED-WORD.json.gz", + "origin_repository": "CrocSwap/integer-mult-bounds (PR3647)" + }, + { + "path": "research/t385-r437-copy-audit/inputs/selected589-word.json.gz", + "usage": "input", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "origin_commit": "a24f9ff95c12fd0b6792e3f710569237efd72db2", + "origin_path": "research/bit-p111-r437-gl464-470-20261018/data/SELECTED589.json.gz", + "origin_repository": "CrocSwap/integer-mult-bounds (PR3647)" + }, + { + "path": "research/t385-r437-copy-audit/inputs/r437-template.json.gz", + "usage": "input", + "git_blob": "f56efc7ca3648d2070b791d4551a3d77dd7fdde4", + "sha256": "6e03c76f5a4227394ea57e901eb7e93f4d1ee411ccfecd483fd44ea043550494", + "origin_commit": "a24f9ff95c12fd0b6792e3f710569237efd72db2", + "origin_path": "research/bit-p111-r437-gl464-470-20261018/generated/GLOBAL-TEMPLATE.json.gz", + "origin_repository": "CrocSwap/integer-mult-bounds (PR3647)" + }, + { + "path": "research/t385-r437-copy-audit/R437-CAPTURE-SCOPE.txt", + "usage": "input", + "git_blob": "b6cf3e21b53f257d24f48b33a18205d61cb50e25", + "sha256": "26a7a1f57c413790c2537a04bf2d245292edae60dfde1ed9580b44c805f9b6bc", + "origin_commit": "a24f9ff95c12fd0b6792e3f710569237efd72db2", + "origin_path": "research/bit-p111-r437-gl464-470-20261018/proof/R437-CAPTURE-SCOPE.txt", + "origin_repository": "CrocSwap/integer-mult-bounds (PR3647)" + }, + { + "path": "research/t385-r437-copy-audit/R437-UPSTREAM-NOTICE.md", + "usage": "input", + "git_blob": "9b519b904d456b0b5861f7469a66c365e77799a6", + "sha256": "8ed83f2f0bde43a41e44279f44d29efaeae3df44850b86f0e3578edf3ee104e4", + "origin_commit": "a24f9ff95c12fd0b6792e3f710569237efd72db2", + "origin_path": "research/bit-p111-r437-gl464-470-20261018/UPSTREAM-NOTICE.md", + "origin_repository": "CrocSwap/integer-mult-bounds (PR3647)" + }, + { + "path": "research/t385-r437-copy-audit/R437-LICENSE", + "usage": "input", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "origin_commit": "a24f9ff95c12fd0b6792e3f710569237efd72db2", + "origin_path": "research/bit-p111-r437-gl464-470-20261018/LICENSE", + "origin_repository": "CrocSwap/integer-mult-bounds (PR3647)" + }, + { + "path": "research/t385-r437-copy-audit/inputs/r437-geometry.json.gz", + "usage": "input", + "git_blob": "7158a5c55b0001a526dab6e816b7b98f0527a202", + "sha256": "b9ed0e5e0084dcd285f33bfc71aab833ddcfa1062bd80c9c83da8244276d6830", + "origin_commit": "a24f9ff95c12fd0b6792e3f710569237efd72db2", + "origin_path": "research/bit-p111-r437-gl464-470-20261018/data/GEOMETRY.json", + "origin_repository": "CrocSwap/integer-mult-bounds (PR3647)", + "encoding": "gzip-original-utf8-bytes", + "transport_sha256": "edcaebb35d313f403b2db45a2cf808617f921c83cf7a11dd5d74356570ede1a8" + } + ], + "retained_origin_verification": "Bytes obtained with git show at the fetched exact PR head, with Git blob and SHA256 recorded. Runtime authenticates retained bytes; publication history need only contain the base, not the foreign pending PR." +} diff --git a/research/t385-r437-copy-audit/T385-EXECUTION.json b/research/t385-r437-copy-audit/T385-EXECUTION.json new file mode 100644 index 0000000000..fdba037a80 --- /dev/null +++ b/research/t385-r437-copy-audit/T385-EXECUTION.json @@ -0,0 +1,417 @@ +{ + "source_head": "de2cd5c58009205210e3bf328b0ef5cadf3903af", + "classification": "COMPLETE_CONDITIONAL_REPLAY", + "run_exit_code": 0, + "jobs": 1, + "native_and_ancestry_reused": true, + "started_utc": "2026-10-19T04:14:10Z", + "finished_utc": "2026-10-19T05:03:17Z", + "seconds": 2946.085577381, + "budget_seconds": 3180, + "python": "Python 3.12.3", + "dependencies": [ + "mpmath==1.3.0", + "numpy==2.2.6", + "scipy==1.15.3", + "sympy==1.14.0" + ], + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "stages": [ + { + "command": [ + "{SESSION_ROOT}/.venv-t385/bin/python", + "-B", + "{SESSION_ROOT}/t385-fresh-20261019/admission/package/reconstruct.py", + "--out", + "{SESSION_ROOT}/t385-fresh-20261019/admission/owners" + ], + "exit_code": 0, + "log_sha256": "239d8562814d1627c19e7e6bf75f06ae2ef219b50c948bb612dcfa0f3f21ef1c", + "name": "owners", + "script_sha256": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "seconds": 53.10569934900195, + "original_log_sha256": "239d8562814d1627c19e7e6bf75f06ae2ef219b50c948bb612dcfa0f3f21ef1c" + }, + { + "command": [ + "{SESSION_ROOT}/.venv-t385/bin/python", + "-B", + "{SESSION_ROOT}/t385-fresh-20261019/admission/package/lift_parent.py", + "--package", + "{SESSION_ROOT}/t385-fresh-20261019/admission/package", + "--owners", + "{SESSION_ROOT}/t385-fresh-20261019/admission/owners", + "--out", + "{SESSION_ROOT}/t385-fresh-20261019/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "c5102a5a2c10b2a5e08927636187a9c1df2841a094c58f1a61326a2b11274483", + "name": "parent-lift", + "script_sha256": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "seconds": 100.71956423899974, + "original_log_sha256": "c5102a5a2c10b2a5e08927636187a9c1df2841a094c58f1a61326a2b11274483" + }, + { + "command": [ + "{SESSION_ROOT}/.venv-t385/bin/python", + "-B", + "{SESSION_ROOT}/t385-fresh-20261019/admission/package/new/rebind.py", + "{SESSION_ROOT}/t385-fresh-20261019/admission/package", + "{SESSION_ROOT}/t385-fresh-20261019/inputs/native-cache/5ca4be99851f8878cbfe0fd6c454df926b11218f17feefa1664721cf03156699/local", + "{SESSION_ROOT}/t385-fresh-20261019/inputs/native-cache/965268a9be73d3f62e7ef680d18f108cf064bfe1f44b82157baa61443232904e/local", + "{SESSION_ROOT}/t385-fresh-20261019/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "4efcc424f53c49777d308af3bc568688d2eb0de9c0236aae9af6ab50190974a7", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 10.611837894997734, + "original_log_sha256": "4efcc424f53c49777d308af3bc568688d2eb0de9c0236aae9af6ab50190974a7" + }, + { + "command": [ + "{SESSION_ROOT}/.venv-t385/bin/python", + "-B", + "{SESSION_ROOT}/t385-fresh-20261019/admission/layout/packing74/replay.py", + "--data", + "{SESSION_ROOT}/t385-fresh-20261019/admission/layout/packing74/candidate", + "--work", + "{SESSION_ROOT}/t385-fresh-20261019/admission/discovery", + "--local", + "{SESSION_ROOT}/t385-fresh-20261019/inputs/native-cache/5ca4be99851f8878cbfe0fd6c454df926b11218f17feefa1664721cf03156699/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "0698d7bbe8ffa568e2c0cea6bdd2fea81cb7fe17df8a4ed58e0f10e6bf14a421", + "name": "discovery", + "script_sha256": "4f5c0926b70edb5aef3af0f8a8d9fa8119fa7af6603df1721c0dc31760b08254", + "seconds": 1073.6600669010004, + "original_log_sha256": "0698d7bbe8ffa568e2c0cea6bdd2fea81cb7fe17df8a4ed58e0f10e6bf14a421" + }, + { + "command": [ + "{SESSION_ROOT}/.venv-t385/bin/python", + "-B", + "{SESSION_ROOT}/t385-fresh-20261019/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "b66b80965a59ac5aec812a16e8cbcddf6c97c02b3e6dd35b6be8ce02ff9174c4", + "name": "outer-check_ledger.py", + "script_sha256": "1dd56009986eb14dd6603c9193c7ad71dd45c7d005bf71c9cd3f916e66f54d98", + "seconds": 0.09301394399881246, + "original_log_sha256": "b66b80965a59ac5aec812a16e8cbcddf6c97c02b3e6dd35b6be8ce02ff9174c4" + }, + { + "command": [ + "{SESSION_ROOT}/.venv-t385/bin/python", + "-B", + "{SESSION_ROOT}/t385-fresh-20261019/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "639d5cdd1ad11190a6198809aa3c5b00245d905dabf6d7671ccbf1a587202276", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.05943211100020562, + "original_log_sha256": "639d5cdd1ad11190a6198809aa3c5b00245d905dabf6d7671ccbf1a587202276" + }, + { + "command": [ + "{SESSION_ROOT}/.venv-t385/bin/python", + "-B", + "{SESSION_ROOT}/t385-fresh-20261019/admission/package/verify_release.py", + "--main", + "{SESSION_ROOT}/t385-fresh-20261019", + "--work", + "{SESSION_ROOT}/t385-fresh-20261019/admission/release", + "--native-cache", + "{SESSION_ROOT}/t385-fresh-20261019/inputs/native-cache", + "--jobs", + "1" + ], + "exit_code": 0, + "log_sha256": "acdf066ba832393ac990976f6705748d72a1cc0d521b394711516c874e7a4796", + "name": "release", + "script_sha256": "6cfefe80c02a6c0f243f50ca9e146e1ab1440b84a033d8a71d42be5a5fa27f6b", + "seconds": 1685.1761937479969, + "original_log_sha256": "acdf066ba832393ac990976f6705748d72a1cc0d521b394711516c874e7a4796" + } + ], + "source_manifest_sha256": "4c4f7067b1b5404b59213f480e9d91c96ffc79b5458e2736b159f5a522ed2dc3", + "native_receipt_sha256": "7ddf3f80b2fa61d1ab12035da9ef1c95d43f76077df819d7683144d7862a3f93", + "source_files": [ + { + "path": "research/staged544-t385/full_replay.py", + "git_blob": "0afb1d35cf49d79e80e2d48e800feef9c09402bd", + "sha256": "87b3f3c55b695551ae2661efbb9d0a8a2e9283e9ed9130215444fbbc8401aecf" + }, + { + "path": "research/staged544-t385/admit_t385.py", + "git_blob": "7859c9e262754ed56a7ca0091d49a74018d9fae8", + "sha256": "b208716e011b456e4344b6104f7dd43abbb57b9e1b9c273c4449e6e43d96cf8a" + }, + { + "path": "research/staged544-t385/source3734/REPLAY-INPUTS.json", + "git_blob": "1c96d298a534aa98325592a9487fea79aebec596", + "sha256": "727691274be6f91059c763dfa8206f7bca4516c5acf4703da403789a49b5e1e7" + }, + { + "path": "research/staged544-t385/source3734/REPLAY-INPUTS.tar.gz", + "git_blob": "5e45113fdc6eaf8d4a07aa1f7c0f9b3b6991ca1c", + "sha256": "e74d545c18f77b7a9b8f0cc3d4901a87bb686888edaf3e41b30e5b2748751041" + } + ], + "normalization": "Absolute session-root paths replaced by {SESSION_ROOT}; original digests retained. Scientific values unchanged.", + "original_files": { + "supervisor": { + "original_sha256": "124c0c472aa943dd7c023129b377b31e9028ba2581afa99e6ec288979f615a02", + "retained_sha256": "57443cd242961ee84a72e8ee0e18044923b31727ee8c54b3f9350acd3d3b28c8", + "path": "evidence/t385/supervisor.json" + }, + "timeout_extension": { + "original_sha256": "a2a59b018b656929d63f67b7f4d10cfa1b6256a0690a17d9cdb333b38dfa1c88", + "retained_sha256": "a2a59b018b656929d63f67b7f4d10cfa1b6256a0690a17d9cdb333b38dfa1c88", + "path": "evidence/t385/timeout-extension.json" + }, + "wrapper_log": { + "original_sha256": "8289a527218d2bd3b3f76510e0fcbbd05ddc99ec4342590d791733f4265c0337", + "retained_sha256": "8289a527218d2bd3b3f76510e0fcbbd05ddc99ec4342590d791733f4265c0337", + "path": "evidence/t385/wrapper.log" + }, + "admission": { + "original_sha256": "bc9d14986a9ed85b735c5dffbd0f011cc084bd315dd6d09548077bdd486d9e08", + "retained_sha256": "43ff0e5058f242b2783082581b2f29e0b54deae3f2036f3654a0f3c0a198736c", + "path": "evidence/t385/admission-result.json" + }, + "runtime_patches": { + "original_sha256": "def1cdb3a467a9763f283ebbecbbfba979e915012f5f690d4aaab620a2b21498", + "retained_sha256": "def1cdb3a467a9763f283ebbecbbfba979e915012f5f690d4aaab620a2b21498", + "path": "evidence/t385/runtime-patches.json" + }, + "native_receipt": { + "original_sha256": "7ddf3f80b2fa61d1ab12035da9ef1c95d43f76077df819d7683144d7862a3f93", + "retained_sha256": "7ddf3f80b2fa61d1ab12035da9ef1c95d43f76077df819d7683144d7862a3f93", + "path": "evidence/t385/native-receipt.json" + }, + "discovery-STAGES.json": { + "original_sha256": "cff1d2a1200525a23790716e98e849188577a29e5680b3d5433e02e3501beb08", + "retained_sha256": "cff1d2a1200525a23790716e98e849188577a29e5680b3d5433e02e3501beb08", + "path": "evidence/t385/discovery-STAGES.json" + }, + "discovery-RESULT.json": { + "original_sha256": "0dc2a8c8663a00437c90984835d7d08bef956839c5c79183b4eeccb2f9d70de8", + "retained_sha256": "13526e1505efdc599096ac611b9b9a782a670ed98a365d471d8bf997dc2b8e24", + "path": "evidence/t385/discovery-RESULT.json" + }, + "discovery-bind-log": { + "original_sha256": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "retained_sha256": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "path": "evidence/t385/discovery-bind.log" + }, + "discovery-emit-log": { + "original_sha256": "cb7715dcffa5a5ec8e15559df8ad80620a6b1d1edd41b1f9ef1572711de318c5", + "retained_sha256": "cb7715dcffa5a5ec8e15559df8ad80620a6b1d1edd41b1f9ef1572711de318c5", + "path": "evidence/t385/discovery-emit.log" + }, + "discovery-audit-log": { + "original_sha256": "e7403fd02cfb7a18f5eb1098de1a3d9830c209521ded74b1a4fbf0044349fc79", + "retained_sha256": "e7403fd02cfb7a18f5eb1098de1a3d9830c209521ded74b1a4fbf0044349fc79", + "path": "evidence/t385/discovery-audit.log" + }, + "discovery-invoice-log": { + "original_sha256": "0fa5bbe81eef6ea6e7824bcb686c9207a748697d9d98348bfd4a05e7511e8945", + "retained_sha256": "0fa5bbe81eef6ea6e7824bcb686c9207a748697d9d98348bfd4a05e7511e8945", + "path": "evidence/t385/discovery-invoice.log" + }, + "discovery-assembly-log": { + "original_sha256": "1518262cd2fb428acb41b5e3bb4fbc2a9aac03b3f0f6f3da0f222226bbd6799d", + "retained_sha256": "1518262cd2fb428acb41b5e3bb4fbc2a9aac03b3f0f6f3da0f222226bbd6799d", + "path": "evidence/t385/discovery-assembly.log" + }, + "discovery-freeze-log": { + "original_sha256": "dd6da2aa4a2d630e61a2f77138921c578c0c6409d170d58568a29af4ee56d379", + "retained_sha256": "dd6da2aa4a2d630e61a2f77138921c578c0c6409d170d58568a29af4ee56d379", + "path": "evidence/t385/discovery-freeze.log" + }, + "discovery-independent-log": { + "original_sha256": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "retained_sha256": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "path": "evidence/t385/discovery-independent.log" + }, + "release-verify-STAGES.json": { + "original_sha256": "8f23bb4af5567f2d8fa2e09d3cf54f6973591cb536bbb35d4daa247a132aa1cb", + "retained_sha256": "8f23bb4af5567f2d8fa2e09d3cf54f6973591cb536bbb35d4daa247a132aa1cb", + "path": "evidence/t385/release-verify-STAGES.json" + }, + "release-verify-RESULT.json": { + "original_sha256": "0372a78fcb546538d781ae54d70424b272a3faff632e0a391cb383326f1aa6ba", + "retained_sha256": "0372a78fcb546538d781ae54d70424b272a3faff632e0a391cb383326f1aa6ba", + "path": "evidence/t385/release-verify-RESULT.json" + }, + "release-verify-fine-engine-oracle-log": { + "original_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3", + "retained_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3", + "path": "evidence/t385/release-verify-fine-engine-oracle.log" + }, + "release-verify-rebuild-words-566-log": { + "original_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f", + "retained_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f", + "path": "evidence/t385/release-verify-rebuild-words-566.log" + }, + "release-verify-reconstruct-owners-log": { + "original_sha256": "239d8562814d1627c19e7e6bf75f06ae2ef219b50c948bb612dcfa0f3f21ef1c", + "retained_sha256": "239d8562814d1627c19e7e6bf75f06ae2ef219b50c948bb612dcfa0f3f21ef1c", + "path": "evidence/t385/release-verify-reconstruct-owners.log" + }, + "release-verify-lift-parent-log": { + "original_sha256": "c5102a5a2c10b2a5e08927636187a9c1df2841a094c58f1a61326a2b11274483", + "retained_sha256": "c5102a5a2c10b2a5e08927636187a9c1df2841a094c58f1a61326a2b11274483", + "path": "evidence/t385/release-verify-lift-parent.log" + }, + "release-verify-rebuild-borrow-words-log": { + "original_sha256": "442990fb24b5f9088eae06c3f8fa2640dde20606216f884f6342eba2fb988f78", + "retained_sha256": "59dc4ab25e1e91611f2049d9dd9c3f5f210e4fc9b5b394b6a21de60745694f54", + "path": "evidence/t385/release-verify-rebuild-borrow-words.log" + }, + "release-verify-shared-kernel-independent-review-log": { + "original_sha256": "3dc6eb8940cf8a4b993f80129c98b6c4846ad346ccf773a78af225cff3339cc3", + "retained_sha256": "3dc6eb8940cf8a4b993f80129c98b6c4846ad346ccf773a78af225cff3339cc3", + "path": "evidence/t385/release-verify-shared-kernel-independent-review.log" + }, + "release-verify-preload-move-independent-review-log": { + "original_sha256": "c456d3e39c09e960ceebf80251d5e808fa9299991471fd86f4093d9bc4dd3eda", + "retained_sha256": "c456d3e39c09e960ceebf80251d5e808fa9299991471fd86f4093d9bc4dd3eda", + "path": "evidence/t385/release-verify-preload-move-independent-review.log" + }, + "release-verify-two-sided-helper408-review-log": { + "original_sha256": "a44341620c98e985c522107cdec7def37b715267c605976b25c33fe8a9f3cefb", + "retained_sha256": "a44341620c98e985c522107cdec7def37b715267c605976b25c33fe8a9f3cefb", + "path": "evidence/t385/release-verify-two-sided-helper408-review.log" + }, + "release-verify-paired-extension-review-log": { + "original_sha256": "f5928ef4aecde0f00d2bcded7b6cf9577c4bfe756bc190b68a8f7901dc2e1dc7", + "retained_sha256": "f5928ef4aecde0f00d2bcded7b6cf9577c4bfe756bc190b68a8f7901dc2e1dc7", + "path": "evidence/t385/release-verify-paired-extension-review.log" + }, + "release-verify-declared-edit-review-log": { + "original_sha256": "9812aa8d08d4251d390eb0cea1e5731dc59d22e09e0c914823c77d3e2e233e13", + "retained_sha256": "9812aa8d08d4251d390eb0cea1e5731dc59d22e09e0c914823c77d3e2e233e13", + "path": "evidence/t385/release-verify-declared-edit-review.log" + }, + "release-verify-staged3605-review-log": { + "original_sha256": "de2fa433a259e21f69f10db63667ba6034e0cd35f102a989208e865d042c31c8", + "retained_sha256": "de2fa433a259e21f69f10db63667ba6034e0cd35f102a989208e865d042c31c8", + "path": "evidence/t385/release-verify-staged3605-review.log" + }, + "release-verify-delayed-release-independent-review-log": { + "original_sha256": "cc8f2e06baec65ca81cb91674bd23ea14320f6b1ceee9a6cfba251387d77c737", + "retained_sha256": "cc8f2e06baec65ca81cb91674bd23ea14320f6b1ceee9a6cfba251387d77c737", + "path": "evidence/t385/release-verify-delayed-release-independent-review.log" + }, + "release-verify-staged544-independent-word-review-log": { + "original_sha256": "2b3e72ac971d0d7eacd8277defcd85ff3d24771285681d1b99fb6fdc4c3cdbf0", + "retained_sha256": "2b3e72ac971d0d7eacd8277defcd85ff3d24771285681d1b99fb6fdc4c3cdbf0", + "path": "evidence/t385/release-verify-staged544-independent-word-review.log" + }, + "release-verify-audit-local-566-base-log": { + "original_sha256": "c16c2e894f5bb470a8b16bd478f3e311c2dfa397d4f87f0ab36f46c2ee709f78", + "retained_sha256": "c16c2e894f5bb470a8b16bd478f3e311c2dfa397d4f87f0ab36f46c2ee709f78", + "path": "evidence/t385/release-verify-audit-local-566-base.log" + }, + "release-verify-audit-local-566-extra-log": { + "original_sha256": "0141a0a056a6c1c31dcb88c9ae613dd76c771dc43ef5f3867ad46f984dba8a01", + "retained_sha256": "0141a0a056a6c1c31dcb88c9ae613dd76c771dc43ef5f3867ad46f984dba8a01", + "path": "evidence/t385/release-verify-audit-local-566-extra.log" + }, + "release-verify-rebind-566-log": { + "original_sha256": "4efcc424f53c49777d308af3bc568688d2eb0de9c0236aae9af6ab50190974a7", + "retained_sha256": "4efcc424f53c49777d308af3bc568688d2eb0de9c0236aae9af6ab50190974a7", + "path": "evidence/t385/release-verify-rebind-566.log" + }, + "release-verify-lemmag-labels-log": { + "original_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469", + "retained_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469", + "path": "evidence/t385/release-verify-lemmag-labels.log" + }, + "release-verify-strict-t74-log": { + "original_sha256": "5e17e55fd26dcde3a43516c4654f55b572a05f61bb8381e8883f876e6a291dcb", + "retained_sha256": "5e17e55fd26dcde3a43516c4654f55b572a05f61bb8381e8883f876e6a291dcb", + "path": "evidence/t385/release-verify-strict-t74.log" + }, + "release-verify-geometry-controls-log": { + "original_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9", + "retained_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9", + "path": "evidence/t385/release-verify-geometry-controls.log" + }, + "release-strict-STAGES.json": { + "original_sha256": "6a8ae6fd5198ddbb4443060d27917ffcd083ee55bd32bb68314f2fe951c5eee4", + "retained_sha256": "6a8ae6fd5198ddbb4443060d27917ffcd083ee55bd32bb68314f2fe951c5eee4", + "path": "evidence/t385/release-strict-STAGES.json" + }, + "release-strict-RESULT.json": { + "original_sha256": "00dc03767a108af33011de7d6f4b4b6e8b1d8fe054f4edf2caef4ca17a8b3656", + "retained_sha256": "7babd8a958bff810adf89d560c73a01c052d98210d6852dbea106400ccbdf65d", + "path": "evidence/t385/release-strict-RESULT.json" + }, + "release-strict-bind-log": { + "original_sha256": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "retained_sha256": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "path": "evidence/t385/release-strict-bind.log" + }, + "release-strict-emit-log": { + "original_sha256": "cb7715dcffa5a5ec8e15559df8ad80620a6b1d1edd41b1f9ef1572711de318c5", + "retained_sha256": "cb7715dcffa5a5ec8e15559df8ad80620a6b1d1edd41b1f9ef1572711de318c5", + "path": "evidence/t385/release-strict-emit.log" + }, + "release-strict-audit-log": { + "original_sha256": "e7403fd02cfb7a18f5eb1098de1a3d9830c209521ded74b1a4fbf0044349fc79", + "retained_sha256": "e7403fd02cfb7a18f5eb1098de1a3d9830c209521ded74b1a4fbf0044349fc79", + "path": "evidence/t385/release-strict-audit.log" + }, + "release-strict-invoice-log": { + "original_sha256": "0fa5bbe81eef6ea6e7824bcb686c9207a748697d9d98348bfd4a05e7511e8945", + "retained_sha256": "0fa5bbe81eef6ea6e7824bcb686c9207a748697d9d98348bfd4a05e7511e8945", + "path": "evidence/t385/release-strict-invoice.log" + }, + "release-strict-assembly-log": { + "original_sha256": "1518262cd2fb428acb41b5e3bb4fbc2a9aac03b3f0f6f3da0f222226bbd6799d", + "retained_sha256": "1518262cd2fb428acb41b5e3bb4fbc2a9aac03b3f0f6f3da0f222226bbd6799d", + "path": "evidence/t385/release-strict-assembly.log" + }, + "release-strict-admission-log": { + "original_sha256": "1cee8d732e126c670f531018d65955c23828a7cc0af8d6ac4bb0f6672962a540", + "retained_sha256": "1cee8d732e126c670f531018d65955c23828a7cc0af8d6ac4bb0f6672962a540", + "path": "evidence/t385/release-strict-admission.log" + }, + "release-strict-bit-log": { + "original_sha256": "d54d260bf95bd8ae4ab8846314082b93b2e3d8f427eb35376691f2ce543a6b67", + "retained_sha256": "d54d260bf95bd8ae4ab8846314082b93b2e3d8f427eb35376691f2ce543a6b67", + "path": "evidence/t385/release-strict-bit.log" + }, + "release-strict-independent-log": { + "original_sha256": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "retained_sha256": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "path": "evidence/t385/release-strict-independent.log" + }, + "release-RELEASE-RECEIPT.json": { + "original_sha256": "9f49e2e801cff8dd9402121e16c0d63801975740140637c5943f94149b28c803", + "retained_sha256": "9f49e2e801cff8dd9402121e16c0d63801975740140637c5943f94149b28c803", + "path": "evidence/t385/release-RELEASE-RECEIPT.json" + }, + "release-verify.log": { + "original_sha256": "f8db339ba756aa4054dc9329d8f059ed700f72d273cff73422ea820229f47a24", + "retained_sha256": "f8db339ba756aa4054dc9329d8f059ed700f72d273cff73422ea820229f47a24", + "path": "evidence/t385/release-verify.log" + }, + "release-outer.log": { + "original_sha256": "670f60ee3ecc7e2d7fc4b23b468d4cdb8cfab9edaf252cd2410c1cabcb0318dc", + "retained_sha256": "670f60ee3ecc7e2d7fc4b23b468d4cdb8cfab9edaf252cd2410c1cabcb0318dc", + "path": "evidence/t385/release-outer.log" + }, + "wrapper_result": { + "original_sha256": "70789b05fc62ce1fb8b53332816231dabaa5109a2a8ab24660fe22b79e816dcb", + "retained_sha256": "70789b05fc62ce1fb8b53332816231dabaa5109a2a8ab24660fe22b79e816dcb", + "path": "evidence/t385/wrapper-result.json" + } + }, + "recorded_scope": "Fresh wrapper execution with the published source-bound native/ancestry reuse and its declared runtime adaptations. No fresh native rebuild or new all-size theorem." +} diff --git a/research/t385-r437-copy-audit/TASK.json b/research/t385-r437-copy-audit/TASK.json new file mode 100644 index 0000000000..cdf25967da --- /dev/null +++ b/research/t385-r437-copy-audit/TASK.json @@ -0,0 +1,76 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "original_card": { + "id": "independent-moment", + "question": "Does one changed supplier or assembly claim lack a source-bound independent check of a specific new implication?", + "starting_points": [ + "certificates/selected-result.json", + "research/rank7-joint-endframes/README.md", + "docs/research/research-family-status.md" + ], + "methods": [ + "Independently reconstruct a coordinated frame/circuit change and its single-change control, then derive the complete rank and physical ledger.", + "Implement certified moment inequalities through a different exact enclosure method." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2979 joint rank-7 end-frame proposal and the revision-6 evidence status. Its claimed kappa is not selected. Compare coordinated changes with the losing single-change controls and locate the complete physical ledger; an aggregate moment alone does not validate the mechanism.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Prioritize a bounded independent audit of #2979: reconstruct one joint group and its single-lowering control, check the declared frames/chronology, then trace changed children, idle widths and cleanup buffers into the complete invoice and both supplier caps. Choose one still-missing implication after checking existing audits. Stop with exact unresolved dependencies if full admission exceeds the session; do not launch a new lowering census on an unvalidated premise or substitute extra root digits for mechanism checking.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Promoting #2979 from merged source archive to validated supplier solely from author PASS receipts or aggregate pricing." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering" + ] + }, + "scope_status": "refined", + "actual_scope": "Complete T385 at de2cd5c; independently reconstruct R437 physical pullbacks for all arbitrary input functions, test changed dirty captures and retain complete finite COPY costs without asserting a compiler theorem.", + "scope_change_reason": "Explicit donor assignment continues PR3883: fresh complete T385 wrapper and exact R437 arbitrary-stream COPY applicability with an inherited-cost/unknown-premise ledger.", + "bottleneck_link": "An exact finite identity and a price endpoint do not establish the arbitrary-complete-stream implementation contract or its normalization.", + "budget_minutes": 60, + "stop_rule": "Initial one-job T385 budget 2400 seconds, extended to 3000 and then 3180 after observed stage durations. Keep the original scientific wrapper uninterrupted and restore its timeout supervisor after completion or at the absolute 3180-second deadline. Final session work is verification, evidence retention and publication.", + "outcome": "partial", + "evidence": "Fresh T385 full wrapper PASS through all seven stages at de2cd5c, with declared native/ancestry reuse; independent R437 exact physical pullbacks and complete finite accounting pass. Outcome remains partial relative to uniform supplier/theorem admission.", + "author": "Chris R (@Clear1nsight), with substantial OpenAI assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in new implementation, execution and writing; no independent human or formal kernel review.", + "open_questions": [ + { + "question": "Can the inherited complete-stream COPY child be implemented with the declared source preservation, restored scratch and volume-normalized cost?", + "why_it_matters": "Exact pullback identities alone do not supply a uniform tape compiler or restored recursive workspace.", + "first_step": "Bind one rank-seven COPY to a concrete child caller, owned output and paid linear discard, with a full time and storage bound.", + "blocked_by": "General compiler, mutable SOURCE, precision/tape/recovery and physical realization premises remain conditional." + } + ], + "freshness": { + "canonical_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "priority_revision": 6, + "predecessor_audit_live_head": "0ce706e210d133ee36b65144f87f0a74a74bec6d", + "predecessor_scientific_head": "b122e6ceab16bc1c6df818490ea5a21e864e0786", + "predecessor_delta": "Only the unrelated P112 workflow differs; scientific audit bytes unchanged.", + "entry_check_utc_minute": "2026-10-19T04:12Z", + "interface_checkpoint_utc_minute": "2026-10-19T04:29Z", + "handoff_refreshed_utc_minute": "2026-10-19T04:56Z" + } +} diff --git a/research/t385-r437-copy-audit/VALIDATION.json b/research/t385-r437-copy-audit/VALIDATION.json new file mode 100644 index 0000000000..e247d20014 --- /dev/null +++ b/research/t385-r437-copy-audit/VALIDATION.json @@ -0,0 +1,30 @@ +{ + "R437": { + "status": "PASS", + "python": "CPython 3.12.3", + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "commands": [ + "verify.py normal", + "verify.py -O", + "test_package.py actual optimized Git-free CLI" + ], + "semantic_controls": 7, + "export_controls": 4, + "selected_baseline": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "scope": "Exact stream-model application and finite arithmetic under inherited coefficients; no uniform compiler/theorem admission", + "registered_manifest_sha256_before_execution_evidence_command": "3991a0ec9aeaac420ddddea79cdaeb7d7381334c69c975a3056d22bc99a4b024" + }, + "T385": { + "classification": "COMPLETE_CONDITIONAL_REPLAY", + "source_head": "de2cd5c58009205210e3bf328b0ef5cadf3903af", + "exit_code": 0, + "completed_top_level_stages": 7, + "recorded_supervisor_seconds": 2946.085577381, + "summed_top_level_stage_seconds": 2923.4258081869957, + "evidence_command": "python3 -I -O -B research/t385-r437-copy-audit/check_execution.py", + "evidence_controls": 3, + "native_and_ancestry_reused": true, + "scope": "Fresh author wrapper execution with explicit runtime adaptations and native/ancestry reuse; no fresh native rebuild or new theorem." + }, + "registered_manifest_sha256": "1f6c6f1d6738e300cdd7a0871e8a4fc175f6d16889512d727f71d664e9ac3a96" +} diff --git a/research/t385-r437-copy-audit/VERIFY.json b/research/t385-r437-copy-audit/VERIFY.json new file mode 100644 index 0000000000..401ea942b3 --- /dev/null +++ b/research/t385-r437-copy-audit/VERIFY.json @@ -0,0 +1,51 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Reconstruct exact physical address pullbacks on all 659 arbitrary input functions in both R437 programs; changed capture dirt, complete finite invoice arithmetic, owner/private separation and seven semantic controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Repeat exact physical replay and semantic controls with assertions disabled; no author executable imports." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/test_package.py" + ], + "timeout_seconds": 300, + "checks": "Run the actual optimized CLI from an export without Git; reject changed source bytes, missing input, symlinked input and a falsified disposal receipt." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/check_execution.py" + ], + "timeout_seconds": 30, + "checks": "Authenticate the recorded complete T385 conditional replay and reject missing release, prepared admission and altered exact endpoint. Does not rerun the long wrapper." + } + ] +} diff --git a/research/t385-r437-copy-audit/check_execution.py b/research/t385-r437-copy-audit/check_execution.py new file mode 100644 index 0000000000..1926a1cd05 --- /dev/null +++ b/research/t385-r437-copy-audit/check_execution.py @@ -0,0 +1,159 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Authenticate the recorded T385 run and forbid promotion of incomplete evidence. +This does not execute the scientific wrapper or convert author reuse into a new proof. +""" +import copy +from fractions import Fraction +import hashlib +import json +from pathlib import Path + +P = Path(__file__).resolve().parent +STAGES = [ + "owners", + "parent-lift", + "rebind", + "discovery", + "outer-check_ledger.py", + "outer-independent_check.py", + "release", +] +HEAD = "de2cd5c58009205210e3bf328b0ef5cadf3903af" +ENDPOINT = ( + Fraction("0.001730578437266246818740") - Fraction(1, 10**46) - Fraction(1, 10**70) +) + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def read(path): + return json.loads(path.read_bytes()) + + +def classify(evidence, admission, wrapper): + need( + evidence["source_head"] == HEAD and evidence["jobs"] == 1, + "source/config binding", + ) + need(evidence["native_and_ancestry_reused"] is True, "reuse boundary") + stages = evidence["stages"] + names = [stage["name"] for stage in stages] + need( + names == STAGES[: len(names)] and all(s["exit_code"] == 0 for s in stages), + "completed stage prefix", + ) + complete = ( + evidence["run_exit_code"] == 0 + and names == STAGES + and admission["status"] == "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE" + and wrapper is not None + and wrapper["status"] == "PASS_T385_COMPLETE_CONDITIONAL_RELEASE" + ) + if evidence["classification"] == "COMPLETE_CONDITIONAL_REPLAY": + need(complete, "incomplete execution cannot be promoted to complete replay") + need( + Fraction(admission["kappa"]) == Fraction(wrapper["kappa"]) == ENDPOINT, + "exact released endpoint", + ) + need( + wrapper["changed_allocation_and_release_fresh"] is True + and wrapper["native_and_ancestry_reused"] is True, + "fresh/reused classification", + ) + need( + wrapper["admission_result_sha256"] + == evidence["original_files"]["admission"]["original_sha256"], + "wrapper binds the original admission-result bytes", + ) + need( + admission["source_manifest_sha256"] == evidence["source_manifest_sha256"], + "admission source manifest", + ) + need( + admission["native_receipt_sha256"] == evidence["native_receipt_sha256"], + "admission native receipt", + ) + need( + admission["replicas"] == 385 + and admission["actual_expected_helpers"] == 408, + "literal construction size", + ) + need(admission["stages"] == stages, "final stage records") + return "COMPLETE_CONDITIONAL_REPLAY" + need( + evidence["classification"] == "INCOMPLETE_EXECUTION" and not complete, + "execution classification", + ) + need(evidence["run_exit_code"] != 0, "incomplete run has no successful exit") + need(wrapper is None, "partial run has a contradictory full-wrapper result") + return "INCOMPLETE_EXECUTION" + + +def main(): + manifest = read(P / "EVIDENCE.json") + for name, digest in manifest["files"].items(): + path = P / name + need( + not Path(name).is_absolute() and ".." not in Path(name).parts, + "evidence path", + ) + need( + path.is_file() and not path.is_symlink(), "missing/linked evidence: " + name + ) + need( + hashlib.sha256(path.read_bytes()).hexdigest() == digest, + "evidence SHA: " + name, + ) + evidence = read(P / "T385-EXECUTION.json") + admission = read(P / "evidence/t385/admission-result.json") + wrapper_path = P / "evidence/t385/wrapper-result.json" + wrapper = read(wrapper_path) if wrapper_path.exists() else None + result = classify(evidence, admission, wrapper) + for stage in evidence["stages"]: + path = P / "evidence/t385" / ("stage-" + stage["name"] + ".log") + need( + hashlib.sha256(path.read_bytes()).hexdigest() == stage["log_sha256"], + "stage log binding", + ) + mutants = [] + if result == "COMPLETE_CONDITIONAL_REPLAY": + bad = copy.deepcopy(evidence) + bad["stages"] = bad["stages"][:-1] + mutants.append((bad, admission, wrapper)) + bad_admission = copy.deepcopy(admission) + bad_admission["status"] = "PREPARED_REPLICA_SAME_WORD_DERIVATIVE_NOT_ADMITTED" + mutants.append((evidence, bad_admission, wrapper)) + bad_wrapper = copy.deepcopy(wrapper) + bad_wrapper["kappa"] = str(ENDPOINT + Fraction(1, 10**70)) + mutants.append((evidence, admission, bad_wrapper)) + else: + bad = copy.deepcopy(evidence) + bad["classification"] = "COMPLETE_CONDITIONAL_REPLAY" + mutants.append((bad, admission, wrapper)) + bad = copy.deepcopy(evidence) + bad["run_exit_code"] = 0 + mutants.append((bad, admission, wrapper)) + bad = copy.deepcopy(evidence) + bad["native_and_ancestry_reused"] = False + mutants.append((bad, admission, wrapper)) + for mutant in mutants: + try: + classify(*mutant) + except ValueError: + pass + else: + raise ValueError("accepted execution-coverage mutation") + print( + "PASS_T385_RECORDED_EVIDENCE classification=" + + result + + " controls=" + + str(len(mutants)) + ) + + +if __name__ == "__main__": + main() diff --git a/research/t385-r437-copy-audit/evidence/baseline.log b/research/t385-r437-copy-audit/evidence/baseline.log new file mode 100644 index 0000000000..fba406c250 --- /dev/null +++ b/research/t385-r437-copy-audit/evidence/baseline.log @@ -0,0 +1,17 @@ +{ + "status": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "selected_kappa": "836330098538459/500000000000000000", + "review": "docs/research/community-batch1099-review.md", + "certificate": "research/community-frontier1094-audit/ASSEMBLY.json", + "full_replay": "make frontier1094-verify", + "bit_saving": "1733427039589844234749/1000000000000000000000000", + "complex_saving": "67018507072324140917/40000000000000000000000", + "binding_primitive": "complex", + "ideal_balanced_cap": "67018507072324140917/40067018507072324140917", + "target_kappa": "1/100", + "target_primitive_under_retained_transfer": "1/99", + "required_bit_multiplier": 5.827190801985042, + "required_complex_multiplier": 6.028788489788009, + "scope": "Selected source bindings and arithmetic only. The a/(1+a) transfer is a planning model under retained hypotheses, not a universal requirement or supplier verification.", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" +} diff --git a/research/t385-r437-copy-audit/evidence/r437-registered.log b/research/t385-r437-copy-audit/evidence/r437-registered.log new file mode 100644 index 0000000000..d0d31b4a0d --- /dev/null +++ b/research/t385-r437-copy-audit/evidence/r437-registered.log @@ -0,0 +1,7 @@ +CHECK Reconstruct exact physical address pullbacks on all 659 arbitrary input functions in both R437 programs; changed capture dirt, complete finite invoice arithmetic, owner/private separation and seven semantic controls. +PASS_R437_ARBITRARY_STREAM_AND_FINITE_COPY_COST_AUDIT functions=659 directions=2 controls=7 +CHECK Repeat exact physical replay and semantic controls with assertions disabled; no author executable imports. +PASS_R437_ARBITRARY_STREAM_AND_FINITE_COPY_COST_AUDIT functions=659 directions=2 controls=7 +CHECK Run the actual optimized CLI from an export without Git; reject changed source bytes, missing input, symlinked input and a falsified disposal receipt. +PASS_R437_EXPORTED_CLI controls=4 positive=1 Git_free=true optimized=true +PASS_REGISTERED_RESEARCH_PACKAGE research/t385-r437-copy-audit outcome=partial diff --git a/research/t385-r437-copy-audit/evidence/t385/admission-result.json b/research/t385-r437-copy-audit/evidence/t385/admission-result.json new file mode 100644 index 0000000000..adcfee6239 --- /dev/null +++ b/research/t385-r437-copy-audit/evidence/t385/admission-result.json @@ -0,0 +1,389 @@ +{ + "actual_expected_helpers": 408, + "comparison_claim_sha256": "c0d8d1ae7f302ae00feade55470d524401fc464b392bf1bc931cdb7a421e23b4", + "comparison_head": "fa041037a3374eaa08feeca0b26a5d6893194147", + "comparison_kappa": "17304483602076354617399999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "comparison_pr": 3734, + "complex_lower": "86528921863312340937/50000000000000000000000", + "dispatch_sha256": "df0b91fbafad903b532af1396f4c4615a14bca1a0b1bc73a5b8e433fd93feab7", + "external_input_sha256": { + "{SESSION_ROOT}/t385-fresh-20261019/inputs/extension_blocknorm.py": "6e6b8683cc87a84e5410c399b1128eb68694f852a3927cb124067f503ed7d7c7", + "{SESSION_ROOT}/t385-fresh-20261019/inputs/helpers/lift_parent.py": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "{SESSION_ROOT}/t385-fresh-20261019/inputs/helpers/reconstruct_replica.py": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "{SESSION_ROOT}/t385-fresh-20261019/inputs/helpers/replica_parent.py": "48bdbf28f59d80edb266803ec61bf5e22e8fb5e5a0e2b88004b6039147589bd4", + "{SESSION_ROOT}/t385-replay/research/staged544-t385/inputs/DISPATCH.json": "df0b91fbafad903b532af1396f4c4615a14bca1a0b1bc73a5b8e433fd93feab7", + "{SESSION_ROOT}/t385-replay/research/staged544-t385/inputs/FILL.json.gz": "70c5ba97085c1f0a7acb44dda571c2e07c3f17e659396b70b7b433876db28edc", + "{SESSION_ROOT}/t385-replay/research/staged544-t385/inputs/ORDER.json": "8e800fa77c58788d3656323ea01519bbba1945ace7fbe18551a370786d9fab8f", + "{SESSION_ROOT}/t385-replay/research/staged544-t385/source3734/CLAIM.json": "c0d8d1ae7f302ae00feade55470d524401fc464b392bf1bc931cdb7a421e23b4" + }, + "fill_sha256": "70c5ba97085c1f0a7acb44dda571c2e07c3f17e659396b70b7b433876db28edc", + "gain": "130077058611357/1000000000000000000000", + "kappa": "17305784372662468187399999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017305784372662468187399999999999999999999998999999999999999999999999", + "native_receipt_sha256": "7ddf3f80b2fa61d1ab12035da9ef1c95d43f76077df819d7683144d7862a3f93", + "order_sha256": "8e800fa77c58788d3656323ea01519bbba1945ace7fbe18551a370786d9fab8f", + "package_manifest_sha256": "38ca5496382d088ff777015b797eb163f7e428763a4b661c798cd39d48030640", + "patches": [ + { + "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "path": "new/rebind.py", + "replacements": [ + [ + "physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))" + ] + ] + }, + { + "after_sha256": "99bef04f24a99088e5c0c9b8f6bbc8386669d8315b8f572d6bbfb932c5d51145", + "before_sha256": "7edb4732b34e5814b27650a55c938626cb50d68f06397744dd4fe451437e90e0", + "path": "geometry_controls.py", + "replacements": [ + [ + " i['complete_invocation_sweeps']=i['bridge_sweeps']=333", + " i['complete_invocation_sweeps']-=1;i['bridge_sweeps']-=1" + ], + [ + " o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);oh=digest(o);i['owner_audit_sha256']=oh", + " o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);assert (o,i)!=(owner,invoice), 'geometry mutant must change actual receipts';oh=digest(o);i['owner_audit_sha256']=oh" + ] + ] + }, + { + "after_sha256": "6cfefe80c02a6c0f243f50ca9e146e1ab1440b84a033d8a71d42be5a5fa27f6b", + "before_sha256": "c43680a2da390f79925547a5ee1919d8a76637cccf98e2c8164b6f667fbc3183", + "path": "verify_release.py", + "replacements": [ + [ + "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)", + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))" + ], + [ + "epsilon=1-(1025/1024)e-3080", + "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}" + ], + [ + "at the one 3000-digit rejection call", + "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call" + ] + ] + }, + { + "after_sha256": "1dd56009986eb14dd6603c9193c7ad71dd45c7d005bf71c9cd3f916e66f54d98", + "before_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "path": "outer/check_ledger.py", + "replacements": [ + [ + "assert (m,W)==(73,66304)", + "T=spec['geometry']['replicas']\nassert type(T) is int and T>0\nassert m==73 and W==896*T and W==BJ['live']" + ] + ] + }, + { + "after_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "before_sha256": "08ca58abff11bdfba721dc56ab8acf06ec1b7c48a8699a0955cf35324680aca7", + "path": "code/witness.py", + "replacements": [ + [ + " with open(os.environ['WITNESS_RECORD'],'a')as f:f.write(json.dumps([key,got],default=str)+chr(10))", + " import time as _wr_time\n _wr_path=Path(os.environ['WITNESS_RECORD'])\n _wr_lock=_wr_path.with_name(_wr_path.name+'.append.lock')\n _wr_deadline=_wr_time.monotonic()+60\n _wr_fd=None\n while _wr_fd is None:\n try:_wr_fd=os.open(_wr_lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY)\n except FileExistsError:\n if _wr_time.monotonic()>=_wr_deadline:raise TimeoutError('discovery record lock timeout; existing lock preserved')\n _wr_time.sleep(.005)\n try:\n with _wr_path.open('a',encoding='utf-8',newline='\\n')as _wr_out:\n _wr_out.write(json.dumps([key,got],default=str)+chr(10))\n _wr_out.flush()\n finally:\n os.close(_wr_fd)\n _wr_lock.unlink()" + ] + ] + }, + { + "after_sha256": "cc1ba8c83cceeafbe8029823dccc9149dcbc2a2f426b0200ed4309ae2384b4a4", + "before_sha256": "196cf2d1cda601b7d88929cb17cbebbe3d4d06bc66d9e0d4b5edca750861d3ee", + "path": "verify.py", + "replacements": [ + [ + "run('lift-parent',P/'lift_parent.py','--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')", + "run('lift-parent',P/'lift_parent.py','--package',P,'--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')" + ] + ] + }, + { + "after_sha256": "0d8cc021d2401d047aaec79060ec2ea28ba06f12eca8dbf4c60c78bb31975c4e", + "before_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "path": "code/witness.py", + "replacements": [ + [ + "PAYLOAD==1<<(192+(GEO['dimension']+1)//2+2*CALLS+4).bit_length()", + "PAYLOAD==1<<(128+(GEO['dimension']+1)//2+18+1330+1+4).bit_length()" + ] + ] + }, + { + "after_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "before_sha256": "bb213d0af12218ff7c9c572717e522d8bbeeb2856b87a253f4a7f44e0fd71f15", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " required_prefix=localbits+input_l2_bits+call_count+bridge_sweeps+4", + " from blocknorm_certificate import certify\n blocknorm=certify(template, {pid:base/'providers'/pid for pid in template['local_providers']})\n assert blocknorm['status'] == 'PASS_TENSOR_BLOCK_NORM_CERTIFICATE'\n assert localbits <= 128, 'actual native scalar/Horner prefix exceeds charged local reserve'\n required_prefix=localbits+input_l2_bits+blocknorm['max_active_depth']+blocknorm['stock_l2_bits']+1+4" + ] + ] + }, + { + "after_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "before_sha256": "02502a217fe8c9e10229075b50745518beac512c48db20e64c3e06514a4da5b5", + "path": "independent_core.py", + "replacements": [ + [ + " payload = 1 << (192 + (M+1)//2 + 2*len(c['order']) + 4).bit_length()", + " require(localbits <= 128, 'measured native prefix exceeds local reserve')\n payload = 1 << (128 + (M+1)//2 + 18 + 1330 + 1 + 4).bit_length()" + ] + ] + }, + { + "after_sha256": "d598a2ac1e2e8eaee14a8c285e0277a7ae44ca6a15bd2b5cfc67fb40844fb387", + "before_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,", + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,blocknorm=blocknorm," + ], + [ + " primitive_arithmetic_margin_bits=4,controller_audit_sha256=", + " tensor_block_norm=blocknorm,partial_cover_margin_bits=1,physical_stock_l2_bits=blocknorm['stock_l2_bits'],primitive_arithmetic_margin_bits=4,controller_audit_sha256=" + ], + [ + "Sum every actual invocation and bridge sweep and take the maximum local scalar/Horner prefix over both orientations of the fixed provider.", + "All invocations and bridge sweeps remain charged. Bound completed-boundary energy by at most eighteen active steps per owner replica, using exact tensor-isomorphic whole-family helper unitaries. Add the full group-indexed physical-stock sup-to-l2 factor and one partial-cover margin, then the maximum local scalar/Horner prefix." + ] + ] + }, + { + "after_sha256": "e051aaa166e01263780d5ae03699690670b597fed6593af4c37a7e978825eb85", + "before_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "path": "independent_core.py", + "replacements": [ + [ + " prefix = localbits + (M + 1) // 2 + len(c['order']) + c['bridges'] + 4", + " bn=c['blocknorm']\n require(bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['max_active_depth']==18 and bn['stock_l2_bits']<=1330, 'independent tensor block certificate')\n prefix = localbits + (M + 1) // 2 + bn['max_active_depth'] + bn['stock_l2_bits'] + 1 + 4" + ], + [ + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], margin=4)", + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], active_block_depth=18,stock_l2=bn['stock_l2_bits'],partial_cover=1,margin=4),blocknorm=bn" + ] + ] + }, + { + "after_sha256": "393323f150d0bb686419804d51cf43d0f58450d2a1e7929725acdd26fdbb3640", + "before_sha256": "2286f00e462ff28abbb3f396095463482a1e063213b9526a7225275980c77eaf", + "path": "audit_mixed.py", + "replacements": [ + [ + "pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)", + "import blocknorm_certificate as BN;ctx['blocknorm']=BN.certify_context(ctx,roles,dirs,source_parent=parent);pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)" + ] + ] + }, + { + "after_sha256": "0542dde915af8902324db2f59136da078d5256bfaa8f1510f3e59336be7e2680", + "before_sha256": "f25e1e870df5d5a16a1e367b3df8843cb01644ab4b75895d7939af81e4fcb833", + "path": "code/assemble.py", + "replacements": [ + [ + " assert invoice['global_prefix_bits']==max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())+37+CALLS+CALLS+4", + " bn=invoice['blocknorm']\n assert bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['replicas']==REPLICAS\n assert bn['max_active_depth']==bn['boundary_depth_bits']==18 and bn['active_calls_per_block']==bn['bridges_per_block']==9\n assert bn['block_width_families']==896 and bn['physical_families']==invoice['physical'] and bn['live_families']==invoice['live']\n assert bn['partial_cover_bits']==1 and bn['input_l2_bits']==37 and bn['local_reserve_bits']==128 and bn['retained_payload_bits']==PAYLOAD\n localbits=max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())\n assert bn['local_actual_prefix_bits']==localbits and localbits<=128\n assert invoice['global_prefix_bits']==bn['actual_prefix_bits']==localbits+37+18+bn['stock_l2_bits']+1+4\n assert bn['required_reserve_bits']==128+37+18+bn['stock_l2_bits']+1+40\nassert m==73 and W==896*T and W==BJ['live']" + ] + ] + }, + { + "after_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "before_sha256": "08ca58abff11bdfba721dc56ab8acf06ec1b7c48a8699a0955cf35324680aca7", + "path": "code/witness.py", + "replacements": [ + [ + " with open(os.environ['WITNESS_RECORD'],'a')as f:f.write(json.dumps([key,got],default=str)+chr(10))", + " import time as _wr_time\n _wr_path=Path(os.environ['WITNESS_RECORD'])\n _wr_lock=_wr_path.with_name(_wr_path.name+'.append.lock')\n _wr_deadline=_wr_time.monotonic()+60\n _wr_fd=None\n while _wr_fd is None:\n try:_wr_fd=os.open(_wr_lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY)\n except FileExistsError:\n if _wr_time.monotonic()>=_wr_deadline:raise TimeoutError('discovery record lock timeout; existing lock preserved')\n _wr_time.sleep(.005)\n try:\n with _wr_path.open('a',encoding='utf-8',newline='\\n')as _wr_out:\n _wr_out.write(json.dumps([key,got],default=str)+chr(10))\n _wr_out.flush()\n finally:\n os.close(_wr_fd)\n _wr_lock.unlink()" + ] + ] + }, + { + "after_sha256": "cc1ba8c83cceeafbe8029823dccc9149dcbc2a2f426b0200ed4309ae2384b4a4", + "before_sha256": "196cf2d1cda601b7d88929cb17cbebbe3d4d06bc66d9e0d4b5edca750861d3ee", + "path": "verify.py", + "replacements": [ + [ + "run('lift-parent',P/'lift_parent.py','--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')", + "run('lift-parent',P/'lift_parent.py','--package',P,'--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')" + ] + ] + }, + { + "after_sha256": "0d8cc021d2401d047aaec79060ec2ea28ba06f12eca8dbf4c60c78bb31975c4e", + "before_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "path": "code/witness.py", + "replacements": [ + [ + "PAYLOAD==1<<(192+(GEO['dimension']+1)//2+2*CALLS+4).bit_length()", + "PAYLOAD==1<<(128+(GEO['dimension']+1)//2+18+1330+1+4).bit_length()" + ] + ] + }, + { + "after_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "before_sha256": "bb213d0af12218ff7c9c572717e522d8bbeeb2856b87a253f4a7f44e0fd71f15", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " required_prefix=localbits+input_l2_bits+call_count+bridge_sweeps+4", + " from blocknorm_certificate import certify\n blocknorm=certify(template, {pid:base/'providers'/pid for pid in template['local_providers']})\n assert blocknorm['status'] == 'PASS_TENSOR_BLOCK_NORM_CERTIFICATE'\n assert localbits <= 128, 'actual native scalar/Horner prefix exceeds charged local reserve'\n required_prefix=localbits+input_l2_bits+blocknorm['max_active_depth']+blocknorm['stock_l2_bits']+1+4" + ] + ] + }, + { + "after_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "before_sha256": "02502a217fe8c9e10229075b50745518beac512c48db20e64c3e06514a4da5b5", + "path": "independent_core.py", + "replacements": [ + [ + " payload = 1 << (192 + (M+1)//2 + 2*len(c['order']) + 4).bit_length()", + " require(localbits <= 128, 'measured native prefix exceeds local reserve')\n payload = 1 << (128 + (M+1)//2 + 18 + 1330 + 1 + 4).bit_length()" + ] + ] + }, + { + "after_sha256": "d598a2ac1e2e8eaee14a8c285e0277a7ae44ca6a15bd2b5cfc67fb40844fb387", + "before_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,", + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,blocknorm=blocknorm," + ], + [ + " primitive_arithmetic_margin_bits=4,controller_audit_sha256=", + " tensor_block_norm=blocknorm,partial_cover_margin_bits=1,physical_stock_l2_bits=blocknorm['stock_l2_bits'],primitive_arithmetic_margin_bits=4,controller_audit_sha256=" + ], + [ + "Sum every actual invocation and bridge sweep and take the maximum local scalar/Horner prefix over both orientations of the fixed provider.", + "All invocations and bridge sweeps remain charged. Bound completed-boundary energy by at most eighteen active steps per owner replica, using exact tensor-isomorphic whole-family helper unitaries. Add the full group-indexed physical-stock sup-to-l2 factor and one partial-cover margin, then the maximum local scalar/Horner prefix." + ] + ] + }, + { + "after_sha256": "e051aaa166e01263780d5ae03699690670b597fed6593af4c37a7e978825eb85", + "before_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "path": "independent_core.py", + "replacements": [ + [ + " prefix = localbits + (M + 1) // 2 + len(c['order']) + c['bridges'] + 4", + " bn=c['blocknorm']\n require(bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['max_active_depth']==18 and bn['stock_l2_bits']<=1330, 'independent tensor block certificate')\n prefix = localbits + (M + 1) // 2 + bn['max_active_depth'] + bn['stock_l2_bits'] + 1 + 4" + ], + [ + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], margin=4)", + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], active_block_depth=18,stock_l2=bn['stock_l2_bits'],partial_cover=1,margin=4),blocknorm=bn" + ] + ] + }, + { + "after_sha256": "393323f150d0bb686419804d51cf43d0f58450d2a1e7929725acdd26fdbb3640", + "before_sha256": "2286f00e462ff28abbb3f396095463482a1e063213b9526a7225275980c77eaf", + "path": "audit_mixed.py", + "replacements": [ + [ + "pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)", + "import blocknorm_certificate as BN;ctx['blocknorm']=BN.certify_context(ctx,roles,dirs,source_parent=parent);pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)" + ] + ] + }, + { + "after_sha256": "0542dde915af8902324db2f59136da078d5256bfaa8f1510f3e59336be7e2680", + "before_sha256": "f25e1e870df5d5a16a1e367b3df8843cb01644ab4b75895d7939af81e4fcb833", + "path": "code/assemble.py", + "replacements": [ + [ + " assert invoice['global_prefix_bits']==max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())+37+CALLS+CALLS+4", + " bn=invoice['blocknorm']\n assert bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['replicas']==REPLICAS\n assert bn['max_active_depth']==bn['boundary_depth_bits']==18 and bn['active_calls_per_block']==bn['bridges_per_block']==9\n assert bn['block_width_families']==896 and bn['physical_families']==invoice['physical'] and bn['live_families']==invoice['live']\n assert bn['partial_cover_bits']==1 and bn['input_l2_bits']==37 and bn['local_reserve_bits']==128 and bn['retained_payload_bits']==PAYLOAD\n localbits=max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())\n assert bn['local_actual_prefix_bits']==localbits and localbits<=128\n assert invoice['global_prefix_bits']==bn['actual_prefix_bits']==localbits+37+18+bn['stock_l2_bits']+1+4\n assert bn['required_reserve_bits']==128+37+18+bn['stock_l2_bits']+1+4 0 and key[1] & (key[1] - 1) == 0, "non-dyadic address map") + if key not in self.index: + self.index[key] = len(self.values) + self.values.append(key) + return self.index[key] + + def swap(self, p): + a = [ + Q(i % 8 == j % 8) - p[i % 8][j % 8] if i // 8 == j // 8 else p[i % 8][j % 8] + for i in range(16) + for j in range(16) + ] + d = math.lcm(*(x.denominator for x in a)) + return self.put([int(x * d) for x in a], d) + + @lru_cache(None) + def mul(self, l, r): + if l == self.identity: + return r + if r == self.identity: + return l + a, ad = self.values[l] + b, bd = self.values[r] + c = [0] * 256 + for i in range(16): + for k in range(16): + x = a[16 * i + k] + if x: + for j in range(16): + c[16 * i + j] += x * b[16 * k + j] + return self.put(c, ad * bd) + + def pull(self, row, m): + return {(i, self.mul(a, m)) for i, a in row} + + def serial(self, m): + a, d = self.values[m] + return dict( + denominator=d, rows=[list(a[i : i + 16]) for i in range(0, 256, 16)] + ) + + +def geometry(w, a): + dims = [] + maps = [] + for indices in w["frames"]: + p, d = projection(w, indices) + m = a.swap(p) + need(a.mul(m, m) == a.identity, "D_P involution") + dims.append(d) + maps.append(m) + need(len(dims) == 636 and dims[:2] == [0, 8], "frame convention") + return dims, maps + + +def emit(w, dims): + v = w["v"] + n = 2 * v + w["R"] + cur = w["start"][:] + rows = [1 << i for i in range(n)] + out = [] + captures = [] + + def move(r, f): + old = cur[r] + if old != f: + need(set(w["frames"][old]) <= set(w["frames"][f]), "frame descent") + out.append([0, r, old, f, dims[f] - dims[old], 0]) + cur[r] = f + + for sec in ["D", "A", "B", "C"]: + if sec == "B": + for j, r in enumerate(w["ret"]): + f = cur[r] + need(dims[f] == 7, "COPY rank") + targets = [v + t for t, ss in enumerate(w["scatter"]) if j in ss] + captures.append(dict(center=r, frame=f, row=rows[r], targets=targets)) + out.append([2, r, n, f, 0, 7, 0]) + for t in targets: + need(cur[t] == 0, "noncold scatter") + out.append([1, t, n, 1, 0, 0]) + rows[t] ^= rows[r] + out.append([3, r, n, f, 0, 0, 0]) + for f, d, ss in w[sec]: + need(d not in ss and len(ss) == len(set(ss)), "ambiguous grouped ADD") + for r in [d] + ss: + move(r, f) + for s in ss: + out.append([1, d, s, 1, f, 0]) + rows[d] ^= rows[s] + for r, f in enumerate(w["final"]): + move(r, f) + need( + rows + == [(1 << i) ^ ((1 << (i - v)) if v <= i < 2 * v else 0) for i in range(n)], + "scalar arbitrary-dirty endpoint", + ) + return out, captures + + +def inverse(records, dims): + out = [] + for op, d, s, a, b, *tail in reversed(records): + if op == 0: + out.append([0, d, a, s, b, 1]) + elif op == 1: + out.append([1, d, s, -a, b, 1]) + elif op == 3: + out.append([2, d, s, a, b, abs(dims[a] - dims[b]), 1]) + else: + out.append([3, d, s, a, b, tail[0], 1]) + return out + + +def execute( + records, + w, + dims, + swaps, + a, + rev=False, + wrong_copy=None, + omit_dirty=False, + omit_moves=False, + omit_capture_input=None, +): + v = w["v"] + n = 2 * v + w["R"] + initial = w["final"] if rev else w["start"] + final = w["start"] if rev else w["final"] + cur = initial[:] + [-1] + rows = [{(i, a.identity)} for i in range(n)] + [set()] + norm = [1] * n + [0] + live = None + profile = Counter() + counts = Counter() + peak = 1 + atoms = 0 + caps = [] + for op, d, s, x, y, *tail in records: + if op == 0: + need(cur[d] == s and d != live, "MOVE state") + lo, hi = (x, s) if rev else (s, x) + need( + set(w["frames"][lo]) <= set(w["frames"][hi]) + and dims[hi] - dims[lo] == y > 0, + "MOVE containment/rank", + ) + if not omit_moves: + rows[d] = a.pull(rows[d], a.mul(swaps[s], swaps[x])) + atoms += len(rows[d]) + cur[d] = x + profile[y] += 1 + counts["MOVE"] += 1 + elif op == 1: + need(d < n and d != s and d != live, "ADD mutates live center") + need(cur[d] == cur[s] == y, "ADD common native frame") + need(s < n or live is not None, "read closed private") + rows[d] ^= rows[s] + norm[d] += norm[s] + peak = max(peak, norm[d]) + counts["ADD"] += 1 + elif op == 2: + need( + live is None and s == n and not rows[n] and cur[n] == -1, + "COPY nonblank/aliased private", + ) + need(cur[d] == x and y == 0 and tail[0] == dims[x] == 7, "COPY frame/rank") + m = a.mul(swaps[x], swaps[y]) if wrong_copy is None else wrong_copy + rows[n] = a.pull(rows[d], m) + if omit_dirty: + rows[n] = {(i, z) for i, z in rows[n] if i < 2 * v} + if omit_capture_input is not None and d == omit_capture_input[0]: + rows[n] = {(i, z) for i, z in rows[n] if i != omit_capture_input[1]} + cur[n] = y + norm[n] = norm[d] + live = d + profile[7] += 1 + counts["COPY"] += 1 + caps.append( + dict( + center=d, + frame=x, + terms=len(rows[n]), + dirty_terms=sum(i >= 2 * v for i, z in rows[n]), + ) + ) + elif op == 3: + need(live == d and s == n and cur[d] == x and cur[n] == y, "ERASE state") + need( + rows[n] == a.pull(rows[d], a.mul(swaps[x], swaps[y])), + "ERASE complete transported equality", + ) + rows[n] = set() + norm[n] = 0 + cur[n] = -1 + live = None + counts["ERASE"] += 1 + else: + raise ValueError("unknown event") + need( + live is None and not rows[n] and cur[n] == -1 and cur[:n] == final, + "return boundary", + ) + endpoints = [] + for r in range(n): + want = {(r, a.mul(swaps[initial[r]], swaps[final[r]]))} + if v <= r < 2 * v: + want ^= {(r - v, a.mul(swaps[initial[r - v]], swaps[final[r]]))} + need(rows[r] == want, "physical arbitrary-function endpoint " + str(r)) + endpoints.append([(i, a.serial(m)) for i, m in sorted(rows[r])]) + return dict( + counts=dict(sorted(counts.items())), + profile=dict(sorted(profile.items())), + positive_bound=peak, + arbitrary_input_functions=n, + private_streams_peak=1, + transported_atoms=atoms, + captures=caps, + endpoint_sha256=hashlib.sha256(canon(endpoints)).hexdigest(), + ) + + +def reject(fn, label): + try: + fn() + except ValueError as e: + return dict(control=label, rejected_by=str(e)) + raise ValueError("accepted control: " + label) + + +def cost(t, fw, bw, discard_charge=None): + need( + (t["m"], t["live"], t["stages"], t["replicas"]) == (64, 28416, 9, 32), + "host scope", + ) + need( + t["private_centre_reserve"] == 9 and not any(t["banks_per_stage"].values()), + "host/private stock", + ) + wins = {e["idx"]: e for e in t["schedule"] if e["kind"] == "idle"} + occupied = defaultdict(set) + assigned = {} + for i, cp, off, width, stage, h in t["hosting"]["slots"]: + need( + 0 <= cp < 222 + and 0 <= h < 437 + and width == 8 + and 0 <= off + and off + 8 <= wins[i]["rank"], + "slot capacity", + ) + need( + stage in t["hosting"]["windows"][str(i)][2] and (stage, h) not in assigned, + "slot eligibility/uniqueness", + ) + axes = set(range(off, off + 8)) + need(not occupied[i, cp] & axes, "slot overlap") + occupied[i, cp] |= axes + assigned[stage, h] = i, cp, off + need(len(assigned) == 9 * 437, "helper inventory") + idle = Counter() + for i, w in wins.items(): + for cp in range(222): + left = set(range(w["rank"])) - occupied[i, cp] + need( + not left or left == set(range(min(left), w["rank"])), "residual suffix" + ) + if left: + idle[len(left)] += 32 + profile = Counter({r: n * 288 for r, n in fw["profile"].items()}) + profile.update(idle) + need( + dict(profile) + == { + 1: 380160, + 2: 400864, + 3: 22176, + 4: 26592, + 5: 29376, + 6: 17376, + 7: 26496, + 26: 32, + 42: 384, + }, + "whole finite profile", + ) + seen = set() + for call in t["calls"]: + st, rep = call["stage"], call["replica"] + need((st, rep) not in seen, "duplicate call") + seen.add((st, rep)) + owners = call["owners"] + need( + len(owners) == 659 and all(0 <= o[0] < 28416 for o in owners), + "private aliases persistent family", + ) + data_families = {o[0] for o in owners[:222]} + need(len(data_families) == 222, "data family aliases") + physical = set() + for h, (family, desc) in enumerate(owners[222:]): + i, cp, off = assigned[st, h] + w = wins[i] + side, port = divmod(cp, 111) + need( + family not in data_families + and family == rep * 888 + (2 * w["pair"] + side) * 111 + port + and desc == ["hosted", i, off, 8], + "helper owner binding", + ) + start = 1 if w["source_level"] == -1 else 8 + 7 * w["source_level"] + key = family, tuple(range(start + off, start + off + 8)) + need(key not in physical, "identical physical owner chart") + physical.add(key) + need(len(seen) == 288, "complete call inventory") + E = sum(profile.values()) + episodes = len(seen) * fw["counts"]["COPY"] + need( + episodes == len(seen) * fw["counts"]["ERASE"] == 2592, + "COPY/ERASE charge coverage", + ) + if discard_charge is None: + discard_charge = episodes + need(discard_charge == episodes, "linear complete-private-stream discard charge") + J = 8 * 32 * 9 * 659 + 8 * 8 * 111 * 32 + 2 * 9 * 32 * 437 + 2 * episodes + prefix = 2**18 * fw["positive_bound"] ** 5 * bw["positive_bound"] ** 4 + route = read(P / "inputs/r437-geometry.json.gz")["max_route_factors"] + components = dict( + unit_ADD=288 * fw["counts"]["ADD"] + 18 * 111 * 32, + source_move_copy_high=J * 16 * (64**2 + 1) ** 2, + source_move_copy_physical=J * 28425, + good_edges=E * (8 * 64**2 + 8), + compiler_edges=E * 128 * 128**3, + matrix_test=16 * 64**3, + linear_private_discard=discard_charge, + selectors=2 * 9 * 32 * ((28416 - 1) + 437 * 64 * (route + 144 + 2 + 63 + 64)), + prefix=prefix, + one=1, + ) + coefficient = sum(components.values()) + two = (coefficient + 1) ** 2 * (E + 1) ** 2 + need( + (prefix.bit_length(), coefficient.bit_length(), two.bit_length()) + == (177, 177, 393), + "finite precision ledger", + ) + need(sum(r * n for r, n in profile.items()) == 1808352, "rank mass") + need( + 64 * 28416 - 1808352 == 10272 and 2 * max(profile) ** 2 < 64**2, + "deficit/halving guard", + ) + fallback_exact = 6 * 128 * 127 + 3 * 128 + 6 * 127 + need(fallback_exact == 98682 < 32 * 64**2, "bad-class fallback overcharge") + return dict( + local_calls=288, + COPY_episodes=episodes, + COPY_rank_mass=7 * episodes, + ERASE_linear_episodes=episodes, + private_family=28416, + reserved_private_families=9, + physical_families=28425, + helper_owner_occurrences=125856, + profile=dict(sorted(profile.items())), + edges=E, + J=J, + components={k: str(v) for k, v in components.items()}, + prefix_bits=177, + charged_prefix_bits=192, + coefficient_bits=177, + two_level_bits=393, + charged_two_level_bits=512, + ROW=18355, + bad_fraction="1/10000000000000000", + fallback_exact_per_edge=fallback_exact, + fallback_overcharge_per_edge=32 * 64**2, + fallback_total_rank_one_weight=32 * 64**2 * E, + cost_reuse="Historical high/physical/compiler/route/prefix/ROW/fallback coefficient bounds are source-bound inputs, not re-proved implementations", + implementation_cost_status="INHERITED_CONDITIONAL_NOT_A_NEW_COMPILER_BOUND", + ) + + +def calculate(): + authenticate() + w = read(P / "inputs/r437-word.json.gz") + old = read(P / "inputs/selected589-word.json.gz") + t = read(P / "inputs/r437-template.json.gz") + need((w["v"], w["R"], w["h"]) == (111, 437, 8), "word scope") + a = Maps() + dims, swaps = geometry(w, a) + rec, caps = emit(w, dims) + rev = inverse(rec, dims) + need( + rec == t["local_programs"]["forward"] and rev == t["local_programs"]["reverse"], + "literal template programs", + ) + reports = dict( + forward=execute(rec, w, dims, swaps, a), + reverse=execute(rev, w, dims, swaps, a, True), + ) + fw = reports["forward"] + bw = reports["reverse"] + need( + fw["counts"] == bw["counts"] == dict(ADD=24208, COPY=9, ERASE=9, MOVE=2906), + "local event count", + ) + need( + fw["profile"] + == bw["profile"] + == {1: 1320, 2: 1344, 3: 77, 4: 43, 5: 102, 6: 11, 7: 18}, + "local recursive profile", + ) + need( + [fw["positive_bound"], bw["positive_bound"]] == [49347, 1113998], + "positive bounds", + ) + for key in ["lines", "frames", "scatter"]: + need(w[key] == old[key], "selected geometry/scatter") + _, oldcaps = emit(old, dims) + changes = [] + for before, after in zip(oldcaps, caps): + od = {i for i in range(222, 661) if before["row"] >> i & 1} + nd = {i for i in range(222, 659) if after["row"] >> i & 1} + survive = {i - int(i > 464) - int(i > 470) for i in od if i not in [464, 470]} + need( + before["frame"] == after["frame"] + and before["row"] & ((1 << 111) - 1) == after["row"] & ((1 << 111) - 1), + "clean capture boundary", + ) + changes.append( + dict( + old_center=before["center"], + new_center=after["center"], + frame=after["frame"], + old_dirty_count=len(od), + new_dirty_count=len(nd), + removed_old_dirty_labels=sorted(od & {464, 470}), + added_surviving_labels=sorted(nd - survive), + removed_surviving_labels=sorted(survive - nd), + arbitrary_dirty_row_hex=hex(after["row"] >> 222), + SOURCE_row_hex=hex(after["row"] & ((1 << 111) - 1)), + COPY_address_map=a.serial(swaps[after["frame"]]), + ) + ) + controls = [ + reject( + lambda: execute(rec, w, dims, swaps, a, omit_dirty=True), + "project helper dirt away at COPY", + ), + reject( + lambda: execute(rec, w, dims, swaps, a, wrong_copy=swaps[1]), + "rank-eight swap priced seven", + ), + reject( + lambda: execute(rec, w, dims, swaps, a, wrong_copy=swaps[caps[1]["frame"]]), + "different rank-seven map", + ), + reject( + lambda: execute(rec, w, dims, swaps, a, omit_moves=True), + "MOVE labels without address action", + ), + ] + bad = json.loads(json.dumps(t)) + bad["calls"][0]["owners"][222][0] = 28416 + controls.append( + reject( + lambda: cost(bad, fw, bw), "private family aliases persistent dirty input" + ) + ) + controls.append( + reject(lambda: cost(t, fw, bw, discard_charge=0), "omit private discard cost") + ) + controls.append( + reject( + lambda: execute(rec, w, dims, swaps, a, omit_capture_input=(475, 340)), + "predecessor-only dirt contract at changed capture 475", + ) + ) + # An actual changed-label witness: copying only the predecessor's surviving + # named dirt subset omits input 340 in the current center 475. All other + # input functions may be zero and input 340 may be the constant-one function. + changed = changes[5] + need( + changed["new_center"] == 475 and changed["added_surviving_labels"] == [340], + "changed-label witness", + ) + need(caps[5]["row"] >> 340 & 1, "dirty witness missing from complete capture") + return dict( + status="PASS_R437_ARBITRARY_STREAM_AND_FINITE_COPY_COST_AUDIT", + domain="Ideal exact Boolean streams on odd-characteristic address fields; arbitrary complete functions including correlated dirt", + directions=reports, + capture_changes=changes, + label_specific_counterexample=dict( + center=475, + frame=515, + arbitrary_dirty_input=340, + input_function="constant one; every other initial function zero", + complete_COPY_value=1, + predecessor_surviving_named_dirt_only_COPY_value=0, + scope="Counterexample to a weaker label-specific contract, not to R437's stated universal contract", + ), + finite_cost=cost(t, fw, bw), + controls=controls, + new_compiler_or_supplier_admission=False, + selected_frontier_changed=False, + remaining=[ + "uniform all-size source-preserving COPY child and restored recursive scratch", + "actual tape/routing/volume-normalized cost", + "mutable SOURCE/common field/cover realization", + "precision/recovery/analytic/BIT premises", + ], + ) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument("--emit", type=Path) + args = ap.parse_args() + # Histograms use integer ranks internally; JSON object keys are strings. + # Normalize that representation before comparing the complete receipt. + result = json.loads(canon(calculate())) + if args.emit: + with args.emit.open("x") as f: + json.dump(result, f, sort_keys=True, indent=2) + f.write("\n") + else: + need(result == read(P / "RESULT.json"), "recomputed result differs") + print( + result["status"], + "functions=659 directions=2 controls=" + str(len(result["controls"])), + ) + + +if __name__ == "__main__": + main()