diff --git a/research/r437-pooled-native-interface/.gitattributes b/research/r437-pooled-native-interface/.gitattributes new file mode 100644 index 0000000000..a154a13b7c --- /dev/null +++ b/research/r437-pooled-native-interface/.gitattributes @@ -0,0 +1 @@ +inputs/** -text -diff diff --git a/research/r437-pooled-native-interface/PROOF.md b/research/r437-pooled-native-interface/PROOF.md new file mode 100644 index 0000000000..24816d8dfb --- /dev/null +++ b/research/r437-pooled-native-interface/PROOF.md @@ -0,0 +1,150 @@ +# Replica-indexed native request boundary for pooled R437 + +## Result and exact dependency + +PR3995 at ae29394a128ba2016919446a7377c7d75ff9c18e binds Rohan Arun's +63 PR3959 moves to the actual retained emitter, and proves the old catalogue's +replica symmetry guard fails. Its emitted-IR and slot-packing results are reused, +not rediscovered. We construct the next interface: a complete replica-indexed +request vocabulary, actual owner charts, source templates and explicit IDLE +selection. This is a source/compiler interface, not a physical caller execution +or supplier admission. PR3980 supplies the dyadic determinant and separation +checker; all actual pooled calls are checked here without replica symmetry. +The local-only follow-up on PR3959 already proves the first helper's permutation +transport and common-plan equality. We do not claim that as new work. + +## Physical objects and request keys + +There are 288 local calls, indexed by (stage, replica), with 659 roles each. +The absolute owner of a role is exactly the pooled template's family and route. +Requests are keyed by (kind, stage, caller replica, position), except IDLE uses +its local copy/role instead of position. The catalogue enumerates all paid +physical request sites, not one replica followed by a multiplicity factor. +Its local order is stage, replica, positive literal MOVE/COPY position; IDLE +order is the retained compiler's child, replica, local-copy order. The lazy +sequence merely constructs that finite table on demand. It does not identify +requests across replicas. In particular, different replicas can own distinct +slots of the same absolute family. + +Local bases, frames, chronology and COPY/ERASE matching come from the authenticated +current unpooled R437 word; the pooled compiler changes only the declared owner +records. The existing canonical adapter verifies that literal word and local +program. For MOVE, the request family and chart come from the actual call role. +For COPY, the target is the existing private common family 28416, while its source +chart comes from the actual role. The canonical Template method retains the +rank/base/preparation construction and appends the native/common tag to a record +that now starts with schema and caller replica. All2592 ERASE guards expand to +(stage,replica,erase-position,capture-position,role,base-key). + +For IDLE, the retained compiler establishes that occupied cells form a compact +prefix of the actual pending-axis list in each (child,absolute-family). The +request base is precisely the remaining suffix, not a suffix inferred from +replica 0. The family is already absolute. `idle_identifiers(child,replica)` +selects that replica's entries exactly once; `idle_family(id,replica)` checks the +request's replica and returns its family with no extra stride. The old `idles` +interface is deliberately unavailable. An existing consumer must replace its +IDLE lookup by this explicit API before it can consume this topology. + +Every request's key is checked back to its exact ordinal and every local ordinal +back to the actual caller's request vector. IDLE enumeration is checked for +coverage and uniqueness. This gives a finite constructive bijection between +paid literal sites and catalogue entries. The cardinality is 903456, consisting +of 836928 MOVE, 2592 COPY and 63936 IDLE requests, with rank mass 1808352. +The profile contains 400877 rank 2 requests and exactly one rank 14 request, so it +cannot be represented by multiplying a canonical profile by 32. + +## Uniform owner separation and right action + +Let D=Z[1/2]. Every actual pooled chart sigma is a 64 by64 matrix over D. +The independent reconstruction agrees with the canonical chart constructor for +all 1235 labels. Exact elimination gives determinant +1 for 236 labels and -1 for 999. +Consequently every chart is invertible modulo every odd prime and every odd +prime power. This is a finite certificate of a uniform algebraic premise, not +enumeration of all primes or GL64 classes. + +For each of the 179802 unordered pairs of different roles sharing a family in +one actual call, the checker exhibits an entry of sigma_a-sigma_b that is a +unit of D. Thus the charts remain different modulo every odd prime. For any +invertible common low d0, the native packet lows are ell_a=d0 sigma_a^-1 and +ell_b=d0 sigma_b^-1; equality would imply sigma_a=sigma_b modulo q, a contradiction. +Different families are separate physical registers; same-family owners use +different low packets. All 288 actual calls are checked; no 32-fold symmetry +extension is used for this pooled source. Sequential calls may reuse these +packets and must observe the latest family state. + +The address action is on the right: rho_sigma(g)=g sigma. Given native low +ell=d0 sigma^-1 modulo q and a high-digit matrix X, let g=ell+qX modulo q^w. +Canonical reduction of g sigma has low d0 and unique high matrix Y. Right +multiplication by the invertible sigma is a bijection of these complete fibres. +Its inverse uses sigma^-1. No invertibility of the high-digit matrix X is +required. Canonical quotient extraction includes carries; a permutation-only +formula cannot replace this for general rational charts. Equality of these +address maps gives equality of their pullbacks pointwise for every Boolean +function, including arbitrary dirty dependence. Correct routing therefore +transports arbitrary complete packets, conditional on the physical route +primitive realizing this specified permutation. This algebra does not execute +or price that primitive. + +In groupoid terms, the objects are the typed family/low fibres and the arrows +are these invertible chart transports. The caller replica is part of the +request object even when arrows happen to use the same family. Collapsing the +objects before selecting their charts is precisely the old interface error. + +## Codebook identity and complete incremental bill + +For fixed q let L=|GL64(F_q)|. The old vocabulary had 28233 requests and source +code limit 2*28233*L. The new one has 903456=32*28233 requests and limit 32 times +larger. Since ceil(log2(32x))=5+ceil(log2 x), the exact fixed source-code width +increases by five bits for every fixed odd prime q. At q=3 this is 6507→6512. +This is code-field width, not a claim that all physical descriptor layouts grow +by only five cells: any layout depending on that width must be recompiled and +charged. The lazy host-side representation gives no free run-time compression. + +A source handle contains schema, source-codebook identity and integer code. +The identity binds q, dimension, request cardinality, code width, the exact retained +low-code codec, the authenticated unpooled request digest and exact pooled move +bytes. Cross-prime handles are rejected as well. The supplied Specifications must be bound to the same catalogue object. +A stale/untyped handle or mismatched Specifications context is rejected before the canonical source +compiler. The new Template record also includes replica and schema; successful +compilation of one integer under a different context cannot be mistaken for +historical source compatibility. Fixed-context integer codes remain internal +to the retained Specifications implementation. Handles are an interface check, +not a new authenticated physical serialization protocol. The fixed codebook +identity can be a static compilation parameter; if serialized dynamically, +its scan/storage cost remains additional and must be charged. + +The exact event multiplicities remain, per low class, 189792 local gathers and +189792 local scatters,63936 IDLE gathers and 63936 IDLE scatters, and 379584 local +routes. With N low classes and completed tariffs G,S,R, the complete owner +transport term is 253728N(G+S)+379584NR. Neither the new table nor the separation +proof removes any route/scan. The request rank profile changes exactly as in +PR3995; COPY reads, paid child transforms, native preparation, private lifetime, +ERASE, dirty restoration, bridges, exchange, parking and full source consumers +remain separately charged. A complete caller bound must also replace each old +source-code width by width+5 in every descriptor, header, history checkpoint, +serialization and scanner where that field is present, re-evaluate alignment, +and sum the actual read/write/rewind rates. In the retained records.py grammar, STEP length is c=Q+2I+90 and +Program length P_h=2I+L+6+h*c; the exact increment is therefore 5h symbols +per Program. Each raw field has length Q+2+4096(L+1), increasing by 5. +With n_f raw fields and a Program with h steps, this contributes exactly +5(n_f+h) extra source-code symbols before checkpoint encoding and repeated +consumption. In the fixed four-symbol parking codec credited to PR3983, a +chronological depth-d Program stack starting at h_0 incurs 20[d*h_0+d(d-1)/2] +extra parked body symbols. Root record lengths are unchanged when I,L are +fixed. Alignment and any changed I,L require separate recomputation. +The count of those occurrences, +primitive tariffs and whole-run visited-cell reserve are unknown here. This is +an exact incremental interface invoice with explicit unknowns, not a complete +numerical physical cost bound. + +## Evidence and limits + +The verifier compiles representative actual q=3 specifications: the relocated +MOVE in common and native form, the unique pooled rank 14 IDLE, and actual COPY. +Their typed records, ranks and replica identities are checked. This is finite +source compilation, not execution on a shortened or production-volume packet. +The all-q statement concerns the chart and owner-separation algebra; the complete +supplier and all its source/child/physical obligations remain conditional. +Negative controls reject omitted replica, wrong IDLE replica, legacy enumeration, +replica-factorized profile, duplicate chart, stale/cross-prime codebook, untyped source and +native COPY. No kappa/frontier change is asserted. diff --git a/research/r437-pooled-native-interface/README.md b/research/r437-pooled-native-interface/README.md new file mode 100644 index 0000000000..6187399f1c --- /dev/null +++ b/research/r437-pooled-native-interface/README.md @@ -0,0 +1,81 @@ +# Pooled R437 replica-indexed native request interface + +This package fills the next source boundary exposed by PR3995: all actual pooled +requests now include the caller replica, actual owner charts and absolute IDLE +families. The new topology has an explicit replica-indexed IDLE API. It does not +execute a physical CALL/RETURN or admit the pooled supplier. + +The complete source audit checks: + +- 903,456 paid request sites: 836,928 MOVE, 2,592 COPY and 63,936 IDLE; exact + pooled rank profile and rank mass 1,808,352. +- Every request key and actual caller identifier, plus exactly-once IDLE coverage. +- All 1,235 actual charts, with dyadic entries and determinant ±1, and all 179,802 + same-family owner pairs in all 288 calls, each with a dyadic-unit separation + witness. This certifies owner separation for every odd prime without assuming + replica symmetry. +- Actual retained q=3 source compilation for the first relocated MOVE in both + native/common forms, the unique rank-14 IDLE, and a COPY. The committed result + reports good/fallback classification; compilation is not fallback execution. +- Exactly five additional source-code bits at every fixed q: q=3 grows from + 6,507 to 6,512. Program histories and raw fields must pay for that expansion. +- Wrong replica, legacy IDLE lookup, stale or cross-prime source-code context, + mismatched Specifications, untyped source, duplicate chart, replica-scaled + profile and invalid native COPY are rejected. + +The ordered request digest is +`29ad864c2a6a31ad15162b0165b4f047cf580d9f2c147aebcfccfd564ccbbc60`. +The first moved helper's MOVE is request 563291; the same literal position in +replica 0 is request 560376. Both use family 209, with distinct charts. This is +why absolute family alone cannot identify the caller's request. + +Run the registered, standard-library replay: + +``` +python3 -B scripts/research_package.py --package research/r437-pooled-native-interface +``` + +No Git, network or predecessor worktree is used by verification. `SOURCES.json` +authenticates retained bytes and the canonical source closure. Pending source +files are retained locally; source-provenance metadata identifies their original +commits. The inherited full compiler file is retained unchanged, but only its +source overlay/slot validator is executed here, not its unused emitter helpers. +The new catalogue intentionally requires an IDLE consumer change; it is not a +silent replacement accepted by the old physical compiler. + +`PROOF.md` states the complete changed contract and uniform algebra, exact +transport multiplicities, code-width invoice and remaining unknowns. Physical +routing, complete residual/source access, prior dirty-state observation, native +preparation, CALL/RETURN, all consumers, source acceptance, chronological history, +parking and global visited-cell/resource coupling remain obligations. There is +no shortened-volume execution passed off as a production result, no new kappa, +and no frontier change. + +Credit Rohan Arun's PR3959/3958/3939 for pooling and its conditional endpoint; +ai-nanachi's PR3647, Ali Romman's PR1043 and Sagar Thakrar's PR3700/2423 for the +R437 word/hosting lineage; PR3995 for absolute-owner emission and the catalogue +counterexample; PR3980 for the dyadic owner checker; PR3983 for complete +chronological parking accounting; Nick Petalas's PR2989 for earlier owner +separation/compiler correspondence. The prior PR3959 local follow-up already +established the first helper's permutation transport and common plan identity. +Canonical physical/source/compiler credit includes zxv, David Arias, Jose Manuel +(jmbarrancoml), ywz65, alephnan, Adam Gall, Ross Richardson and the retained +notices, together with mightyOil, DaysSky, chafreaky, DreamingOfClouds and eumemic. + +New interface, audit and writing: Chris R / Clear1nsight with substantial OpenAI +Codex assistance. Same-session AI cross-review is distinct from human or formal +kernel acceptance. Apache-2.0; inherited notices and byte-exact retained sources +are preserved. + +## Open next questions + +1. Adapt the full physical compiler's IDLE enumeration and bind the first actual + pooled gather/native source/return with its preceding dirty read and every + consumer. Source compilation and owner separation are ready premises; + physical primitive and complete source acceptance are still required. +2. Substitute the widened source-code field into the actual chronological + history, raw fields, checkpoint codec, scans and returns. Count all occurrences + and whole-run reserve before claiming a complete numerical physical bill. +3. Join the actual pooled caller to an admitted child supplier and all-size, + stock, precision and analytic bounds. A successful finite replay alone does + not discharge these remaining supplier obligations. diff --git a/research/r437-pooled-native-interface/RESULT.json b/research/r437-pooled-native-interface/RESULT.json new file mode 100644 index 0000000000..4a03e803bf --- /dev/null +++ b/research/r437-pooled-native-interface/RESULT.json @@ -0,0 +1,101 @@ +{ + "ERASE_guards": 2592, + "chart_count": 1235, + "chart_sha256": "8d8d44ca739b1c87902a19af89c961c76c9081c2a821cee8dcc64cae68153426", + "code_bits_delta": 5, + "compiled_actual_sources": [ + { + "common": true, + "good": true, + "kind": "MOVE", + "rank": 2, + "replica": 1, + "request": 563291 + }, + { + "common": false, + "good": false, + "kind": "MOVE", + "rank": 2, + "replica": 1, + "request": 563291 + }, + { + "common": false, + "good": false, + "kind": "IDLE", + "rank": 14, + "replica": 0, + "request": 896352 + }, + { + "common": true, + "good": false, + "kind": "COPY", + "rank": 7, + "replica": 0, + "request": 1598 + } + ], + "controls": [ + "replica omitted", + "wrong idle replica", + "legacy idle consumer", + "replica factorized profile", + "same-family duplicate chart", + "stale source codebook", + "different prime source codebook", + "mismatched Specifications context", + "untagged integer source", + "native COPY request" + ], + "determinants": { + "-1": 999, + "1": 236 + }, + "family_scans_per_low": 507456, + "first_moved_request": 563291, + "full_physical_caller_executed": false, + "idle_owner_gathers_per_low": 63936, + "local_owner_gathers_per_low": 189792, + "new_q3_code_bits": 6512, + "old_q3_code_bits": 6507, + "per_stage_pairs": { + "0": 6848, + "1": 13920, + "2": 27392, + "3": 27872, + "4": 27872, + "5": 27808, + "6": 27322, + "7": 13920, + "8": 6848 + }, + "profile": { + "1": 380160, + "2": 400877, + "3": 22176, + "4": 26592, + "5": 29376, + "6": 17375, + "7": 26496, + "14": 1, + "42": 403 + }, + "rank_mass": 1808352, + "replica_zero_request": 560376, + "request_count": 903456, + "request_kinds": { + "COPY": 2592, + "IDLE": 63936, + "MOVE": 836928 + }, + "request_sha256": "29ad864c2a6a31ad15162b0165b4f047cf580d9f2c147aebcfccfd564ccbbc60", + "routes_per_low": 379584, + "same_family_pairs": 179802, + "source_identity": "84cc5d15252e334b9bed24c50d6826fd3d765710857e5db04889fc76d62aed1e", + "status": "PASS_POOLED_REPLICA_NATIVE_REQUEST_INTERFACE", + "supplier_admitted": false, + "unique_chart_pair_witnesses": 463, + "witness_sha256": "1818977337134cdda43778d82d79ca4a061a4fc271ad5cb0ec2966659abf2185" +} diff --git a/research/r437-pooled-native-interface/SOURCES.json b/research/r437-pooled-native-interface/SOURCES.json new file mode 100644 index 0000000000..d0987e871a --- /dev/null +++ b/research/r437-pooled-native-interface/SOURCES.json @@ -0,0 +1,900 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz", + "usage": "input", + "sha256": "0357b7cfbd7c29b4983982baf153c8a9f1e1e412690cd7fa9fc3d23d7963b20f", + "git_blob": "9eafb8776cbf78c72124f833534469ddfa5e98ec" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json", + "usage": "input", + "sha256": "0058c491d839142aa99ef86a5ec697ce99857632228531512ea3fa74fb24d734", + "git_blob": "44006542202ca6037533a754f0bcd00549d7e088" + }, + { + "path": "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "usage": "input", + "sha256": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "git_blob": "e293ddc557742637f9f679f083a1a282d87b1b13" + }, + { + "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "usage": "input", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a" + }, + { + "path": "research/pr589-five-helper-hosting/PROOF.md", + "usage": "input", + "sha256": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647", + "git_blob": "bbd3f12b9a32b3ad3cba85a2d5a1b3054214fa02" + }, + { + "path": "research/pr589-five-helper-hosting/verify.py", + "usage": "input", + "sha256": "cf90e19ae9991b0698be03d395a8cc29061ecb307eb7fea19adfb2d23c25a367", + "git_blob": "dbc71f56bb4205ebe378ada1f9f4ea88630d1d39" + }, + { + "path": "research/recursive-parking-boundary/README.md", + "usage": "input", + "sha256": "491aa208391ee4c2936510b1a5c5c018dd5509d9a0e88687c72ab8406cd77b18", + "git_blob": "251f335ebaccc11d69393ee7aeb5a2e84526d0bb" + }, + { + "path": "research/selected-bit-local-ring-sweeps/PROOF.md", + "usage": "input", + "sha256": "846c59440cc99e28bae93ad2af99525bc769de29368080071b8427141215b4f7", + "git_blob": "4330de85dd9862ed15d84ab917887d249753df99" + }, + { + "path": "research/selected-bit-physical-caller/PROOF.md", + "usage": "input", + "sha256": "e5a827e93fe313ba9bf4a2e300bae01b58b28004aa8a8ee119cf6d950edd9f93", + "git_blob": "548ecff3ef79a32c14bafc7f2309781181d3c23d" + }, + { + "path": "research/selected-bit-physical-caller/README.md", + "usage": "input", + "sha256": "989ad891ce3f866c920a25e0cdd661815f982c4c854370f8c00668eaa15d770c", + "git_blob": "abd0edba96101a025609d2840c3dbdf4d3e30aa8" + }, + { + "path": "research/selected-bit-physical-caller/RESULT.json", + "usage": "input", + "sha256": "de6216b9f89f22b9602867776a7fc951ec558c852e6abd4624151e95d868af56", + "git_blob": "44afaf8dca8f76b3c9f5ef58616b6d57ff7ff2f3" + }, + { + "path": "research/selected-bit-physical-caller/SNAPSHOTS.json", + "usage": "input", + "sha256": "c7b3485bdae5ddf43166cd6626bd512816e179617a4234c36584f6c57c34744a", + "git_blob": "034836cfaa3e4f984e900a980eecc986ec405b1d" + }, + { + "path": "research/selected-bit-physical-caller/SOURCES.json", + "usage": "input", + "sha256": "94e1f55094bbd122e4ee73413650fa24072c392d53d257041cd5d38a2269e4fd", + "git_blob": "a27291a91519f9f4e074712afa3262c4d372aaaf" + }, + { + "path": "research/selected-bit-physical-caller/TASK.json", + "usage": "input", + "sha256": "84319cb2f8c7c121927123e8c3271c3ec4ec93fc9be362dcfdf7ee4366cd1a74", + "git_blob": "28b8d5e1cbd29824e702d384937831ddb3876da7" + }, + { + "path": "research/selected-bit-physical-caller/VALIDATION.md", + "usage": "input", + "sha256": "c38eaa31a9cf3489356f2e2a675e2bc6194fa41796589edc9cbd8578b5d71c0f", + "git_blob": "5b1a9221f35cbd637183282489e8eeaa30314ea8" + }, + { + "path": "research/selected-bit-physical-caller/VERIFY.json", + "usage": "input", + "sha256": "5bb3cf67018f35de5b825c9bb4b7a6590296da85f492ba3dbff7a6ce9bdebf8e", + "git_blob": "682809777271adfe08df6e6ba2fae89571420212" + }, + { + "path": "research/selected-bit-physical-caller/continuation_checks.py", + "usage": "input", + "sha256": "c6ef8fa86a7099af0eb6763a3f5bd43f8f94e1e176cfba38c0077b3e0f5fda48", + "git_blob": "f2be8aad16e279c0d1467e21d79d2dd81dcae8d8" + }, + { + "path": "research/selected-bit-physical-caller/frame_checks.py", + "usage": "input", + "sha256": "ced41d9244afcb5275ad5c46dc0f60265afc1e6422d29b277364e945825c4dd8", + "git_blob": "4b992ffcb0a613da54ca24e31d25e61445799e10" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/EVIDENCE.json", + "usage": "input", + "sha256": "77b7cbefa2ca30acf2f77e23d14808ccd27848e9c76e4c5e68a045ef7891a07f", + "git_blob": "c2c347abc2b8c19bb642c4da1aad5b3e8383016f" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/PREDECESSOR.json", + "usage": "input", + "sha256": "e3127475913d62dbdf1b45d9283d2db2e9b689e0f81a703189150c1e5be2bca0", + "git_blob": "56d76c357b51f4fc6856923222bfca47f03334e7" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/PROOF.md", + "usage": "input", + "sha256": "552fa306d5cc228f4d8d8553f8ac5fc6a738ef2b66a2cb765ba0638cd229794d", + "git_blob": "1a08e57eac2a37764066d31baa3ecd3769759158" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/README.md", + "usage": "input", + "sha256": "6ce41fd7e6dfbe5faecc25bd36561f0a65b6ebca6fc69d3fb72569424a405045", + "git_blob": "75461632856f94d6b48ae820cf5d0b2b232305c2" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/RESULT.json", + "usage": "input", + "sha256": "4919655bae2e5cff051e8f2d240a8e4ebb03392a9da2fb5328daa9248fb7e88b", + "git_blob": "75faec7844e18fc7c44543dbab87aba2ecf32b3e" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/SOURCES.json", + "usage": "input", + "sha256": "7c78f539078e1bc3d893b78b5ee24cb22dc090d3763fe554e861b6c3d3e7eaf7", + "git_blob": "ff8c8e36176aa56e319d0f9e584167ac21d67f33" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/TASK.json", + "usage": "input", + "sha256": "ac7d4b38da31b373e665929027fc04afb66c3e9aedaea3296e3783637912d0e8", + "git_blob": "d70ad317275d2a517ab1294ce48ecb1f83dfedbf" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/VALIDATION.md", + "usage": "input", + "sha256": "ac0f2fab0ca810ce0202d31480daa8329cba0897ab015520a2bfd4b689c4086b", + "git_blob": "d91680665a28c12c27c99336b55c3d5341dd0fe4" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/VERIFY.json", + "usage": "input", + "sha256": "6ad0e07f68458afedece927550655b5bc5cd9861a70044fcd95bb10a2179f0a6", + "git_blob": "b6072f66c13a38b5d8dff3ca3bc5f3f3562f1b6e" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/bootstrap.py", + "usage": "input", + "sha256": "eef1c418e8edbdf317d159683e30beaecd971c77cf41d6b09708576405e2141e", + "git_blob": "448c9b3a86eedb84220646ab27ff089a32ad5b9b" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/check_layout.py", + "usage": "input", + "sha256": "454b1587d1ed5ccaea19b621a67e2ceba999d7ede61188125faa41c4dd2ab2b1", + "git_blob": "be59d614d25961f891e1640bf85cf5e2f474a059" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/check_nested_model.py", + "usage": "input", + "sha256": "b1941b882b0659722c3c41994c82f020c1f7ab320dc28c43c2758029ef8a48b7", + "git_blob": "20fed6bd389cb53fc52d0ad8389e9e7704c90265" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/check_recursion.py", + "usage": "input", + "sha256": "dde82badf043e553bc635a34295e2b5505d84d6dfbaf96e0cfccb8a8c3dbb158", + "git_blob": "8f36c88e196cf5afc0d6e227ba8568a10bb23c6a" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/check_runtime.py", + "usage": "input", + "sha256": "9fcf0c9a3c84a17446fafe8da50b63db296ba9465d48ddb6fdeac8742dfc98b1", + "git_blob": "fe355a703475325bca4807b8ffedfa9f6edb74f5" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/check_sign.py", + "usage": "input", + "sha256": "ee4fd34acd49962a18d268aefeb20aa3c2673a10e7a43eee3e51a9bd3cf9106a", + "git_blob": "50669949a1325e8c49aa0ff714c40a50077b5eb8" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/check_sources.py", + "usage": "input", + "sha256": "1c49984ae6ee7f8a44cde16b51e486f0b3ba4ee5c973389ac8d58a82d0a0aa3b", + "git_blob": "5c09a13943070a3bb3c0da06fd19fbc6916d1743" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/consumer.py", + "usage": "input", + "sha256": "2f2a8604c23fb2c81f24320c71ed0142118d98dde3be6086adad28e89954a777", + "git_blob": "a66d9276f829ce2c619871866816649d5f3687fd" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/control_checks.py", + "usage": "input", + "sha256": "c09d33327932b4ffbb8acb26c8a6bb621bcca542157d22f1edf72679a9359981", + "git_blob": "11daa0b2221c5870d19ba2eaf411a6bff3a0398d" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/driver.py", + "usage": "input", + "sha256": "ceaf8f75de9810a05ebf8f65780b6f8bd7599a5768401d5e4386182afe615cdf", + "git_blob": "5b7846a70aada53d87480b337e1c04217118771b" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/evidence/NOTICE.md", + "usage": "input", + "sha256": "fd7c42e89878cda6df86dde8720ece34625a337cf5edd795a421e2d3b42919e9", + "git_blob": "d0318d43ed420e21dc52166a19de703aa87fbb3e" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2688-NOTICE.md", + "usage": "input", + "sha256": "c899fccf7bd32397f0ddd85e4af35a166cefb3e3ae3407ec40edc3ab2051b617", + "git_blob": "f2b49cdef83a4a685fad32c01fba93e12cfcb5a8" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2688-PROOF.md", + "usage": "input", + "sha256": "fa9bec0952468e4acb760a88d45d5be216325650e1a4080cf590e07b90c9f533", + "git_blob": "1395e1941863e40ff6d62dd91c41de2cb56edae9" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2708-README.md", + "usage": "input", + "sha256": "5906f6b7b2c8eea90e441476c4cbd60fe2ef981b690c63357bcfe67e3104aeef", + "git_blob": "79b8742f32b4ffb991f91ddd2d3c6be693084e6d" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2731-README.md", + "usage": "input", + "sha256": "19683df4394de299cbd7e1cce39bf9434ad260b1a37006587cf9aed84c9c0a03", + "git_blob": "ac5b826f9c34e1faadc5d5a02d5d260823112078" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/layout.py", + "usage": "input", + "sha256": "3beef6534b02c3b011b741f957a7d9fb05a9ac0bba1fed53b2c71834e4ea6bc1", + "git_blob": "aa554b14fe0f6b308d9fba0a2afc92e5a28e20cb" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/linear_sign.py", + "usage": "input", + "sha256": "73e895fc701a4145cbe89d60f5775128354e7f08d0a45eacf22f423913f54e67", + "git_blob": "6a6e5c02f299fad8c4f7ab724fc36e14a22ab13c" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/node.py", + "usage": "input", + "sha256": "0bd4f640cafb5c8f070c161d86445910f77578a672bf5886936ed89e7f6bd21b", + "git_blob": "28c98a3573b458f7a055678d70b602b80e6e959e" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/packet_engine.py", + "usage": "input", + "sha256": "c80fc3aa9092f91cc309b2fb2dbc3618bf96bdb9b8498503993ea161f0ae2134", + "git_blob": "72543f684f38fefeacc2ee66d81661f1a2439cf7" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/peel.py", + "usage": "input", + "sha256": "8b20888f74b4cd814a97b42ec72528fbfb6d2e936c5022df726f0785d0d01a2e", + "git_blob": "38502515afc928082c849cd2cda8578d33a5050a" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/NOTICE.md", + "usage": "input", + "sha256": "c446b32b8a621844fb2fbe654810c8122035bdd43fed2132f1137d98cb6f9943", + "git_blob": "ef9f81510db86eaf2f0a7191d85e92a6db30ddc0" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/PROOF.md", + "usage": "input", + "sha256": "88754d57bae35a2089d9de221ff32ba802b7a56b810f96271f3ea36985edfb14", + "git_blob": "a4746d1786f41e45a36fdedf37966b80fbab3562" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/README.md", + "usage": "input", + "sha256": "15631eb826b2d8d54fbee18fb6f70ee035e172d524c2a209b6c467c3f0204f64", + "git_blob": "988ff622029aff49d7e99deb2468684d904bc852" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/RESULT.json", + "usage": "input", + "sha256": "0d94c5e9150f3fbd603526c67ea33168d3ba45e158aaf722e848bf5c316a37a8", + "git_blob": "7b7dfe0eab22a7b511483f268b97a7c707fd8b90" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/SOURCES.json", + "usage": "input", + "sha256": "1b02a5c607a5967948988c3beaf37d9975d650ad501a99fcf74c135dc1f05fdd", + "git_blob": "4fef1a4d6c2d5e2620d3506d6032f9226870ed39" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/TASK.json", + "usage": "input", + "sha256": "a4cd54d4b09ad12a90a5feeb39a127f0f0d5a2a04f9f88554c5fc3ee0cfe77f4", + "git_blob": "eb2ce7cc00df816daf566f101d56a0330852c1d9" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/VERIFY.json", + "usage": "input", + "sha256": "e1dd0ee5f267ffa515bb345054ff8637cfedb0079b0d2da29b90b7848264926e", + "git_blob": "69c7ad75abe494be386f73a5d51359b9053cd9be" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/cardinal_counts.py", + "usage": "input", + "sha256": "59ddeac102a0cc51fa49b15aae6aeb68cd68ed217fa974ce916372a177d2ec8f", + "git_blob": "6a14feac45094ae9156e8c2c982d6727544f180e" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/catalogue.py", + "usage": "input", + "sha256": "83ea88f82d4a83c5f889774bfe3519b7ebaa24b6a0e2a969dafff012107a89bf", + "git_blob": "0efc0575a7623ac41c094d2e8772beda5a9fdc29" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_headers.py", + "usage": "input", + "sha256": "a41dab0c487c341eb32b34a03af74454e15e9e61e7386a1ca426d83f3b68b1ca", + "git_blob": "1c372b19e19b838a89c0e64daeda15ec6b49f079" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_layout.py", + "usage": "input", + "sha256": "8f776a21dc0e31f9738d822cfda38db92f1e3672afb880d4246ec5e084a50a41", + "git_blob": "174d843716a684145f934cb55a612bca85aad725" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_runtime.py", + "usage": "input", + "sha256": "5357e4ff255f17c4209aaf71a3413a4148475f11180c4f829e8f0ebacd2877cb", + "git_blob": "5647693b3a5c1555b65e281c6609f98b92d45542" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_sources.py", + "usage": "input", + "sha256": "6463c2724e04a313181b78e90a17cd62ee42465754902cca3e9a65c6140a15a1", + "git_blob": "9219cdf863d9f060d6e38a4f2f4760fd227af003" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/consumer.py", + "usage": "input", + "sha256": "b28ec97b0873ff2be25aff4bdde268247ffcec0d21279d0ada196de19a0bdc66", + "git_blob": "24b53521fce94d3349072cf47d70e62195f4d541" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/control.py", + "usage": "input", + "sha256": "d3a93e54bb7d333b73917586407d11674d38b5c3fda4fbdc436fb5293ae7786a", + "git_blob": "4f6ac09bffab43dbccc470bd0bde2ffbe969a8b2" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/control_checks.py", + "usage": "input", + "sha256": "5ea6ded8c2508fbb00d93655affdfe7907ffb60916389e0736249c003a7a5148", + "git_blob": "712cfddc4caaad9e788d97b0e1e3f623172c43ed" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/driver.py", + "usage": "input", + "sha256": "ee9e42fe95ab28fdd5e927c2d46fd480305aaad610eb2ca7ae514a5d22d9f0ac", + "git_blob": "0bdee4c9e348259b470a636a98e7657770f97fae" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/fresh_rows.py", + "usage": "input", + "sha256": "e4ae08fbd658add630eb7754ebe0cbcb42c6f39cf4128f9cb92e27fcf5213a7d", + "git_blob": "aa3a327604308d3a5c7a27b65f5e631d430ab093" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/layout.py", + "usage": "input", + "sha256": "7534b0166805f2ae8d11495c811d2bd272cea89c89b6bb5251fd411c89245a20", + "git_blob": "267d5ab98cd013ee82ba75e6d41609f1778af25f" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/model.py", + "usage": "input", + "sha256": "c937ae8e46162f88fc1cd7646d3b22c99273029ad0f0e3131f46ddec230676cb", + "git_blob": "9fb82fa57d29cdf8402f91534dffed8f586ced6c" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/node.py", + "usage": "input", + "sha256": "b88fc9ac0b22d939311ff4f7aff788e8c87a64fd5e866498e59bd27940ee3f28", + "git_blob": "13badda6f059da2132cbe325c071307e5191baa3" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/packet_engine.py", + "usage": "input", + "sha256": "ce7f132a6a69c802406f07c4a2119ef921e8978520ff58d5eeaeedb982c257f2", + "git_blob": "27a0dbf82e78252beede56ff86f5933c93eb55c1" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/peel.py", + "usage": "input", + "sha256": "3de018e68601566c364c7568b110f60c1bf34941b846cdffb94401bb799f85e3", + "git_blob": "2ae1769a9726ab738d3981891d0b76beccac2d99" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/topology.py", + "usage": "input", + "sha256": "384d456ddba76de137a63b50019d5bba2e9f6daa4177c91643e0565d4cf1d44b", + "git_blob": "39a2916c207d04be5efc44750d8606f5da0c2990" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/binding.py", + "usage": "input", + "sha256": "20169a8af6ed2b34069fd353a2bc1c42335ab686c58de8479baef33dd3fb493b", + "git_blob": "21a5a21220a18ab62a19ac403a9944bc3a8665c8" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/bitstream.py", + "usage": "input", + "sha256": "f78bac9641007dbd8824984edcac057274fe016ce78bd9cb512d0c0913274783", + "git_blob": "4d1fd4abb0f2aabe833e5cbc9efb51039739e7ca" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/cardinality.py", + "usage": "input", + "sha256": "505d5e560c5a507e6184edcc19a87cf1fed243eb34a5cb21fbe1e4fe017e7f22", + "git_blob": "b8ba857e32c5903408e1e61ff916300848b4a208" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/check_support.py", + "usage": "input", + "sha256": "d9977e87ddc5acdb836b8e4a4e3942da17a05b04ce67c04547d17b986b518964", + "git_blob": "e1f961df9fa3a441fc5b600d1288a8d038eca51e" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/children.py", + "usage": "input", + "sha256": "a78866939631214c1d1659203b2b5fc062e3c6255e9f11f975c310046b010bd6", + "git_blob": "ce4935f838516e2b08d13bec767cb803786fbc6b" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/controller.py", + "usage": "input", + "sha256": "fa09146991f6c04e6f4b6eb9bf0c8e103e70e90a0e402ff3d69814e6aac8ff8c", + "git_blob": "c631a9e77fbcccf0e8f448adc22978728aed7b60" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/counts.py", + "usage": "input", + "sha256": "00b476dbda0e8cc99886bf794439e1cb9e775f435f599a3557e99321fe084069", + "git_blob": "81b48940ce222290a40d4fb349ce827f4788469d" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/directory.py", + "usage": "input", + "sha256": "4270e370b2bfe38ef73aadcd97d1b3496b56bd582115d74331eb9e5ceb90bec7", + "git_blob": "c74cacf5ce809c0561d374f137a52df0992b4226" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/episode.py", + "usage": "input", + "sha256": "38f79cb2a370548471063952d5f7c74bd795a2a8496fdcf3ce0996d79e3adaff", + "git_blob": "30d11ff4f333813855d36da3eb5a1ab0e154bafe" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/forms.py", + "usage": "input", + "sha256": "1fdf9d31b7eb107c396e33f94dad61c9d3f2c709cae61178268a44ca80dbc0b4", + "git_blob": "6667c0b772a63f0059c7caffec63e0d919a92398" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/low_codes.py", + "usage": "input", + "sha256": "f657e17f6088c840e3f7783e662257630f6d2c1e71c217721ffbca4d6ac93e87", + "git_blob": "737edfc4a10f4b7b3b97a7cef4b40864efd806e6" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/matrices.py", + "usage": "input", + "sha256": "00b687434039b54529ee092e34f9435cfcd66e0816eb3bd2a6688c73f4e01459", + "git_blob": "5d497353efbb9eeaaf4facd96ab40ffb0f3aa20d" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/numeric.py", + "usage": "input", + "sha256": "7327b05c4ec3e0f6d9c352cc7de85bfd4ebe940482553e77c59a773a8c09c514", + "git_blob": "6d4ebca8398008375b8f4762d1a9f1514e8c2611" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/oracle.py", + "usage": "input", + "sha256": "7bd18089e32ce48085b5e3a75159f6a82cdb2649ec682c53db05e399d97aef67", + "git_blob": "244f131466698a3ace10b657242fe1f65c07fd1f" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/packet.py", + "usage": "input", + "sha256": "970e7fe0719e3dfe122b248941e6f21cd90d7dd62089fa6acbd0e5412ce083a5", + "git_blob": "ebc9b616514412b80c56d523776e6ba5d6766453" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/plan.py", + "usage": "input", + "sha256": "d9c8dc93762db4d3a449814aa51e2211460648694469854d89cb48cb04188cf3", + "git_blob": "48255d5454308c07635fae4e7eb4873b0bd2a4f8" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/records.py", + "usage": "input", + "sha256": "0c9c4b23e998597fb877bb1a29da69ac869b68262abe635b162b4dba9c69b372", + "git_blob": "4f00467a0ff580954ad2fd0c7380240c753ddef3" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/residual.py", + "usage": "input", + "sha256": "8fd24747cae498dfb2ba333e7f8a68d7315ae4c2d7530d8ca145aab95ede21df", + "git_blob": "3d070d2539a529f3b14ecb086a92a3db056229fe" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/routes.py", + "usage": "input", + "sha256": "ed7dc3679451696ab1dd841146b215c9515a3eec5e4ff3763f33c315f1696ada", + "git_blob": "35531201dc349a811dfabc6f1f6e64697d665194" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/selection.py", + "usage": "input", + "sha256": "bc8e371fb1fa0b41fb05ef0b34d0f4c317b2396f9833d91f44f95c2b54b4052b", + "git_blob": "2c28f1aaec104a75c4e6c170b3e6a60300ee6700" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/sources.py", + "usage": "input", + "sha256": "f102edc7816d742bd89db8097254c19b843d0ef5cf6758ad42e93bcc0b214c62", + "git_blob": "16d5e7e6a28018f1e2d76d61efe2d54f6a6941d4" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/stream.py", + "usage": "input", + "sha256": "c7dc7da5b00f27016982ada4c0416f8328568b00df16d97012f33d4b372d79b5", + "git_blob": "5e5a4bb0f98971447043e25d4dd6991bfc070389" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/stream_runner.py", + "usage": "input", + "sha256": "751c5023ca0e477369e448583961ace6a76db2723bb6c26f81203def539f1249", + "git_blob": "efff281d4c4be5c1378e31404fbcc634fe4ade59" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/trace.py", + "usage": "input", + "sha256": "c71ba11d793dde2ac6e4cdcf468482872975c34589bf1167f2a460cb8a74e984", + "git_blob": "bb845a90f5bcf006e683e581e385936208f6a1f4" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/words.py", + "usage": "input", + "sha256": "5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9", + "git_blob": "8d4ba37e2778acb35b34e0719df2caf138fbeb50" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/verify.py", + "usage": "input", + "sha256": "cd83797d1f420f7e5de61c1a693110b4ee0c80bac0adae4699599046b7f76f8a", + "git_blob": "121acc1ff15ec85a8011e96eda2eb587608413b9" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/recursive_call.py", + "usage": "input", + "sha256": "157deaa5972557893d43494a81151483bdc46373448ec677cb6a738c9b7e6f1e", + "git_blob": "6d33224145aa04f7fbaf7b6cda7c9c164311a402" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/scheduler.py", + "usage": "input", + "sha256": "0d96f7fbd6f90416167c5a52c0e3de942d1a0cae3d2968831932a9576701699f", + "git_blob": "60c2b6d065eba91dd5e0edb7a77fc087971eca3f" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/stream_runner.py", + "usage": "input", + "sha256": "b255feaf6cc6e40413ae73fe302bf8f290bf4dd89f4128b23a91cc9860601801", + "git_blob": "6ba5df130bb4a0fcb06b6c630830ae3a6922921b" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/trace.py", + "usage": "input", + "sha256": "3a664224c558244f606b603cad816d75e94a17c9b2620a06a1530e893dfceac2", + "git_blob": "4b002201ce54cdecec9acf4e874b7f71cd75fe71" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/verify.py", + "usage": "input", + "sha256": "65126e788eeea10e830fc583cf4afe0bfc4d67495cbf8ac21de3507dbe624d56", + "git_blob": "96be8f5859a3f3799344d46dec1ee68170d96bfa" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/NOTICE.md", + "usage": "input", + "sha256": "8640d1b52fd21e5b20e8109ce9c4957ca1e19a95e26a1c80d019a6e6f4d5f178", + "git_blob": "307c2da733f7f3a76e97c77e71072e811f40df02" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/PROOF.md", + "usage": "input", + "sha256": "fc9e7dcc5b385b6e508d6a6e9524b93059fa3e9fd5fcfb5eedbd85b3a54ba55e", + "git_blob": "7207ce7dec86694f01a3d9c049dcb87cc909e380" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/README.md", + "usage": "input", + "sha256": "6550a466bfafff2ca11740e931ed9fce062eb488f23e74edff7e4bbae8282bb1", + "git_blob": "c96e0d6cec56a9a5579ae159456fc15767315bc3" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/RESULT.json", + "usage": "input", + "sha256": "4406fec9515bb4206c75b681f046b5441319cf1ed39a13b9b0134696b1c192a7", + "git_blob": "b2d1889d77019e06ac0326ac91b1322340cf3866" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/SOURCES.json", + "usage": "input", + "sha256": "a6476b786632c2cbffabbe27eece790e378996c8b03eb17a01f1094f20fc4cdf", + "git_blob": "746393061c55f47412601e3d346e914762683e0c" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/TASK.json", + "usage": "input", + "sha256": "964d3a4fbfb53fd58936840328ac4b770b324c9e78f722861b1db04663110626", + "git_blob": "216dc8f8bcb33fe32d0eaccdadb0fe0383d73848" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/VERIFY.json", + "usage": "input", + "sha256": "f9e252e8ab255b49c3b18d4db76cc09ebd9fb61d599305e0aca8bf295189028d", + "git_blob": "6537be05745836106c753e1388ffc8b1bd23ce4c" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/checks.py", + "usage": "input", + "sha256": "98ffbd58881aa138b8dbae4d5722855ece2a5fdf7585e53978069ae9b064eb09", + "git_blob": "46630a7648b1c93530e9253872a19cce338929ff" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/codec.py", + "usage": "input", + "sha256": "5b9fda8136f7e60bece54e3fcc74f4ea0bec7145fa60e1ae3a4d252741b81fd3", + "git_blob": "9cd54d9417eb685dcd3f8293f01299ef9046ad31" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/vendor/parking_machine.py", + "usage": "input", + "sha256": "68134779debfb795468a1aaecbc2b9d321d7d4e451313ce7dc8fa7092561df4c", + "git_blob": "cafd614a3b7bc87b019361fcdf890ed976f26d19" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/vendor/pr2753_recursive_call.py", + "usage": "input", + "sha256": "157deaa5972557893d43494a81151483bdc46373448ec677cb6a738c9b7e6f1e", + "git_blob": "6d33224145aa04f7fbaf7b6cda7c9c164311a402" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/vendor/words.py", + "usage": "input", + "sha256": "5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9", + "git_blob": "8d4ba37e2778acb35b34e0719df2caf138fbeb50" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/verify.py", + "usage": "input", + "sha256": "37f9e51e6c038a2493b4550e3cf0bd52621b6c20e115f0886406fc9909a82120", + "git_blob": "6be4f94eda9c96f4e7265a294f63e39309dcb0c6" + }, + { + "path": "research/selected-bit-physical-caller/loader.py", + "usage": "input", + "sha256": "4d8647f520b2967a0ca7dcadeb39d6ebabbce44df4193f609fef22911d0ae67b", + "git_blob": "4a0326c9af88626938645f288e559b5b97cb1787" + }, + { + "path": "research/selected-bit-physical-caller/macro_binding.py", + "usage": "input", + "sha256": "9ef31765d03d2c54fad9296f2ff0707a190ce169e44de4f0f45214e3c410c01a", + "git_blob": "c197eb6458be9374cb4684c654bfc99e619dcaf0" + }, + { + "path": "research/selected-bit-physical-caller/macro_checks.py", + "usage": "input", + "sha256": "0631b4d6b547a76d8ea4babd3465908b9efaa058503f8330140bcc8eb22a51cb", + "git_blob": "6a9226a647d095419840fd9d6696ffcef9827b0b" + }, + { + "path": "research/selected-bit-physical-caller/macro_code.py", + "usage": "input", + "sha256": "f626b018124747a5f17c1603bea36cd74c00a69a0647fd7b10e9c4e2964caea8", + "git_blob": "2f5f8ecfac6457171707b1b5ff02b5071954fcb7" + }, + { + "path": "research/selected-bit-physical-caller/macro_controls.py", + "usage": "input", + "sha256": "a5343faffadfdd9ea0e52d4c7c4ef24ba5e8d2dee86c8af27c094ad78944b845", + "git_blob": "b7c1d28dd47ff463df02ea97b5907a041c05bdde" + }, + { + "path": "research/selected-bit-physical-caller/macro_local_checks.py", + "usage": "input", + "sha256": "a9be60378d1282184632066b87cb044a8510b6623acf0df4dbf2f1bcd35cb830", + "git_blob": "421f9030f91f3ab309a9873928c09ba8a2ade580" + }, + { + "path": "research/selected-bit-physical-caller/macro_machine.py", + "usage": "input", + "sha256": "7bc6e42072a09a08ac961e05c3da01cde012d740d4b4c605f298d994f2ad7c5a", + "git_blob": "5a032e8923f7f8b22bb98f3e39b804beb9906c16" + }, + { + "path": "research/selected-bit-physical-caller/macro_selected_checks.py", + "usage": "input", + "sha256": "080e147837a4983a73e598af0cc97333e2cfb1d328f5190c9d4447a8bdbb4668", + "git_blob": "14f224e975fdd1a580088baf26e23ca44091a2f7" + }, + { + "path": "research/selected-bit-physical-caller/nested_bank_checks.py", + "usage": "input", + "sha256": "4c225e7d91c767b4cedcf9f9b5222875be948bf8b4ef03cedc4f46f1d570e9bb", + "git_blob": "c48f87429773e3b80719c209b4ad3f3977e3c41e" + }, + { + "path": "research/selected-bit-physical-caller/numerical_frame.py", + "usage": "input", + "sha256": "3fd62eda5d0b48bf31ea244708a77afdc6d16cf4fc9439d140ef422a38c7406c", + "git_blob": "dc92611dd5f131718806fa96470b8f3494e15e2a" + }, + { + "path": "research/selected-bit-physical-caller/residual_blocks.py", + "usage": "input", + "sha256": "ab7f3df8906decd2efecfb138eac1456c106bb520b2598761f699f80680d8331", + "git_blob": "fba75e7649cf77e352a75324495191bbd7853c22" + }, + { + "path": "research/selected-bit-physical-caller/role_parking.py", + "usage": "input", + "sha256": "1884a3c260d81d5efbc0c33d86a810d6728e55e5764cfcd423f858cc685470f3", + "git_blob": "fc48c244eefdbaa3e320e86c75a7d187cb5765ef" + }, + { + "path": "research/selected-bit-physical-caller/scratch_pool.py", + "usage": "input", + "sha256": "41f1eb93652b7174c3b02f95f70e1a9ce2e2aed0a729e725167c8f226e65d8db", + "git_blob": "0f22807c65d1bca374b905538512bf8c43702070" + }, + { + "path": "research/selected-bit-physical-caller/verify.py", + "usage": "input", + "sha256": "bfba14c842ea4d97bf160588abc061553d3e4eab66cd5f32b903e1a67e661aec", + "git_blob": "fbdc87b9f98dc7722db45a42a742c5569089eeeb" + }, + { + "path": "research/selected-bit-recursive-closure/PROOF.md", + "usage": "input", + "sha256": "74cc8de20f21acb5123fe2d20996fe0925ea6e51b3dec633bd5221fb719b3344", + "git_blob": "6c410cab5713979214a45835091fbeb9ee9b8531" + }, + { + "path": "upstream/build/sections/02-streams.tex", + "usage": "input", + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "git_blob": "088fceea1867abc76271d7efe7532b779fee9039" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5" + }, + { + "path": "research/physical-compiler-correspondence/README.md", + "usage": "input", + "sha256": "bb04d8a05f0fbda2df0dc653118524ecaace3d22dd924179574fc115524df901", + "git_blob": "1b542517f938ef64a25155f96214ba332d8ce623" + }, + { + "path": "research/physical-compiler-correspondence/owners.py", + "usage": "input", + "sha256": "220918b53e45c5992471bb2fd0a95e62f410679048f3517504c851077ee94845", + "git_blob": "3fdf157278aa00308df706e11fc4a9e428b05e66" + } + ], + "retained": [ + { + "path": "adapter.py", + "bytes": 2963, + "sha256": "c1c054e5a2c650cfc267117b32896073e6735b93c5fbfb1defe6e379c4afab9e", + "git_blob": "276a9a0f436ba03e2a0bb1cd95d57ebc3cc3a290", + "origin_commit": "24f680cdbb015dca72b977a99dbec69f24576661", + "origin_path": "research/r437-native-transport/adapter.py" + }, + { + "path": "check_transport.py", + "bytes": 9670, + "sha256": "c1351777d8886754a172ed3f6e90586be5c664a93b66eda5e87fa9580f104ab7", + "git_blob": "5bd3c8a38aed9df3b0d4404d382268aee02dfcb3", + "origin_commit": "24f680cdbb015dca72b977a99dbec69f24576661", + "origin_path": "research/r437-native-transport/check_transport.py" + }, + { + "path": "inputs/EXPECTED.json", + "bytes": 1118, + "sha256": "67d06bcb90d2307a11975d6b25107a695be477f168f2dc289b8484ba0b7e2de0", + "git_blob": "bc2585e1404402395a7c59ba6f6dde58b04e65a2", + "origin_commit": "24f680cdbb015dca72b977a99dbec69f24576661", + "origin_path": "research/r437-native-transport/inputs/EXPECTED.json" + }, + { + "path": "inputs/catalogue.py", + "bytes": 12593, + "sha256": "83ea88f82d4a83c5f889774bfe3519b7ebaa24b6a0e2a969dafff012107a89bf", + "git_blob": "0efc0575a7623ac41c094d2e8772beda5a9fdc29", + "origin_commit": "ae29394a128ba2016919446a7377c7d75ff9c18e", + "origin_path": "research/r437-replica-indexed-emission/inputs/catalogue.py" + }, + { + "path": "inputs/geometry.json.gz", + "bytes": 105558, + "sha256": "edcaebb35d313f403b2db45a2cf808617f921c83cf7a11dd5d74356570ede1a8", + "git_blob": "a01a33c4753955ec4707db9515cee82a567cc1cb", + "origin_commit": "24f680cdbb015dca72b977a99dbec69f24576661", + "origin_path": "research/r437-native-transport/inputs/geometry.json.gz" + }, + { + "path": "inputs/moves.json", + "bytes": 12962, + "sha256": "0a58b239795d213743b5654c59a3e4622a0ddd4a53d8dba3fa30dedef4558dff", + "git_blob": "2cdb414a38cff6f0b872445f0980f2e3bc1895eb", + "origin_commit": "ae29394a128ba2016919446a7377c7d75ff9c18e", + "origin_path": "research/r437-replica-indexed-emission/inputs/moves.json" + }, + { + "path": "inputs/template.json.gz", + "bytes": 797946, + "sha256": "6e03c76f5a4227394ea57e901eb7e93f4d1ee411ccfecd483fd44ea043550494", + "git_blob": "f56efc7ca3648d2070b791d4551a3d77dd7fdde4", + "origin_commit": "24f680cdbb015dca72b977a99dbec69f24576661", + "origin_path": "research/r437-native-transport/inputs/template.json.gz" + }, + { + "path": "inputs/word.json.gz", + "bytes": 42280, + "sha256": "e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e", + "git_blob": "c558a221dd44cbdaa732a401f9876de4c096d4a7", + "origin_commit": "24f680cdbb015dca72b977a99dbec69f24576661", + "origin_path": "research/r437-native-transport/inputs/word.json.gz" + }, + { + "path": "pooled_compiler.py", + "bytes": 6637, + "sha256": "fa1c589e5809ba8223eaf070cfb299bf55d843889d360b4d089824eb675e177c", + "git_blob": "512047d8b99628b097f5a597761e6647b424c92e", + "origin_commit": "ae29394a128ba2016919446a7377c7d75ff9c18e", + "origin_path": "research/r437-replica-indexed-emission/compiler.py" + } + ], + "origin_heads": { + "current_R437": "a24f9ff95c12fd0b6792e3f710569237efd72db2", + "predecessor_adapter": "03c141ef1fd372cf42951488767537e55675c072", + "prior_complete_stream_audit": "125f5afad680ef128e386fa58e76eef5fadaa5d6", + "uniform_local_reduction": "364701494bc3d726806a15d4d1d4b547c1e0f9d5", + "current_adapter": "32af060614fefa9729c86370524c2e72265acd76", + "pooled_IR": "ae29394a128ba2016919446a7377c7d75ff9c18e", + "owner_certificate": "24f680cdbb015dca72b977a99dbec69f24576661" + }, + "retained_provenance": "Nine exact source files retained: four unpooled R437 inputs, canonical-adapted current adapter, dyadic checker, pooled compiler, literal moves and its original catalogue. Each declared foreign origin is checked byte-for-byte before publication. Replay uses only retained bytes and canonical main inputs." +} diff --git a/research/r437-pooled-native-interface/TASK.json b/research/r437-pooled-native-interface/TASK.json new file mode 100644 index 0000000000..31286abc91 --- /dev/null +++ b/research/r437-pooled-native-interface/TASK.json @@ -0,0 +1,96 @@ +{ + "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": "Construct the next replica-indexed native/request catalogue interface for actual pooled R437; all-site binding, owner separation and exact code-width/cost changes.", + "scope_change_reason": "Explicit donor multi-agent continuation; PR3995 exposed this exact remaining boundary. Reuses its emitted-IR/slot proof rather than duplicating it.", + "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": "One60-minute round2026-10-19 08:26 to09:26 UTC, research cutoff09:08, finalquarter verification/publication. Stop at replica request/source contract; retain physical execution and supplier obligations.", + "outcome": "partial", + "evidence": "Full903456-site catalogue and179802 actual same-family owner-pair certificates,1235 chart determinants, representative q3 native/common source compilation, five-bit fixed-code width change.", + "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 complete physical caller consume the explicit replica IDLE API and typed source handles?", + "why_it_matters": "Finite source catalogue and algebra do not execute the production caller.", + "first_step": "Adapt actual compile_node IDLE lookup and bind complete dirty-state gather/return/consumers.", + "blocked_by": "Physical primitive, source acceptance, stock and reserve contracts." + }, + { + "question": "What is the complete physical bill after the five-bit source-code expansion?", + "why_it_matters": "Each chronological record and raw-field source code widens; repeated consumers/checkpoints must pay.", + "first_step": "Count actual field occurrences and substitute the widened codec into history, parking, scan and return bounds.", + "blocked_by": "Whole-run occurrence, tariff and resource coupling bounds." + } + ], + "freshness": { + "canonical_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "priority_revision": 6, + "entry_utc": "2026-10-19T08:26:00Z", + "PR3967_head": "32af060614fefa9729c86370524c2e72265acd76", + "PR3967_CI": "39215291431 allsuccess checked by coordinating parent before dispatch", + "R437_head": "a24f9ff95c12fd0b6792e3f710569237efd72db2", + "overlap_coverage": "Offline find_overlap has no usable remote snapshot; targeted live GitHub PR searches plus coordinating parent discussion/claim checks. No exhaustive novelty claim.", + "claim": "https://github.com/CrocSwap/integer-mult-bounds/pull/3967#issuecomment-6263066320", + "important_overlap": "PR3995 full pooled emitted-IR binding and exact old catalogue guard; PR3959 local-only first-helper permutation transport/common plan; PR3980 alloddq chart certificates and unpooled ownerpairs; PR2989 prior conditional owner/compiler correspondence. New contribution is actual full replica-indexed request/source interface with explicit consumer and code-width changes.", + "PR3995_head": "ae29394a128ba2016919446a7377c7d75ff9c18e", + "PR3995_CI": "39221691337 allsuccess checked by coordinating parent before dispatch", + "submission_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "submission_utc": "2026-10-19T08:46:04Z" + }, + "overlap": { + "claim": "https://github.com/CrocSwap/integer-mult-bounds/pull/3967#issuecomment-6263066320", + "checked": [ + "PR3995 and its comments at ae29394a128ba2016919446a7377c7d75ff9c18e", + "PR3959 comment6262851541 including local source-compilation follow-up", + "Live R437 replica PR query; parent complete live open-body snapshot; offline find_overlap had no usable remote snapshot" + ], + "coverage": "Broader closed/private/Discussion coverage partial; no exhaustive novelty claim" + } +} diff --git a/research/r437-pooled-native-interface/VALIDATION.md b/research/r437-pooled-native-interface/VALIDATION.md new file mode 100644 index 0000000000..ba071214dd --- /dev/null +++ b/research/r437-pooled-native-interface/VALIDATION.md @@ -0,0 +1,51 @@ +# Validation and publication evidence + +Scientific files frozen at GitHub commit +`110e0f270cc083a68b689acbe4774e05d87fa065` on canonical main +`20ecf2891d80b5acf18d980b2164fb44ea7faa90` (priority revision 6). +Subsequent publication commit adds this note only. + +Completed 2026-10-19: + +- Registered normal and optimized replays: `PASS_REGISTERED_RESEARCH_PACKAGE`, + completed 08:53:32UTC. Each command has a 550-second limit; total 1100 seconds. + Both authenticate all 134 canonical runtime input files and 9 retained sources, + reconstruct the exact receipt and reject ten semantic/context mutations. +- GitHub-created scientific commit: `PASS_RESEARCH_COMMIT_BYTES`, all 153 package + and runtime input files match exact publication bytes; source-history check + passes against canonical main. `git diff --check` passes. +- Official committed export and archive check both pass for all 153 files. + Extracted archive contains no `.git`; all files were made read-only. +- Read-only Git-free exported replay: `PASS_POOLED_REPLICA_NATIVE_INTERFACE`, + completed 08:55:35UTC, with `PATH=/nonexistent` and absolute `/usr/bin/python3 -I + -B`. It reproduces the same exact RESULT without network, Git, foreign source + worktrees or shell commands. +- Same-session AI cross-review independently recounted requests, profile and + owner pairs from literal JSON/moves without running this verifier. It checked + all 9 retained files against their original Git objects and found two handle + context omissions (prime/codec context and actual Specifications object). + Both were fixed and have explicit rejection controls in the frozen replay. + This is not independent human or formal-kernel acceptance. + +Frozen scientific SHA256 values: + +| File | SHA256 | +|---|---| +| replica_catalogue.py | d093a5a5421596d82c6c6e9fbc7fbf3f313c803a7ba423d666b98344b1912ff3 | +| check_interface.py | b4f5fab63a262e36b5d585ad9ed6bb9436ecb8183eae233b27c8da9c448128d4 | +| PROOF.md | 695c3416094ee374a6b5d5152c80ce29f18358eda21e3afb7b58c2264a6d879c | +| RESULT.json | 27a20d575cb90c16a186a621d553e167f2bb6fd4e19541fe8d8dfc0208451658 | + +The four source-compilation examples independently choose low I in their stated +native/common contexts. They are valid representative source specifications, +not a paired physical route replay: their good/fallback classifications may +differ. In particular, native MOVE, rank-14 IDLE and COPY select the retained +fallback branch. Fallback execution and cost are not erased by compilation. +The uniform corresponding-low chart identity is a separate algebraic result. + +This evidence proves the stated finite request/source interface and its +source-bound chart certificate. Full physical caller execution, source/child +supplier acceptance, primitive tariffs, all widened-field occurrences, precision, +parking and whole-run visited-cell/resource joins remain open. Hosted CI is +reported on the PR at its exact head; no hosted result is inferred from this +local validation note. No new kappa, merge, admission or frontier change. diff --git a/research/r437-pooled-native-interface/VERIFY.json b/research/r437-pooled-native-interface/VERIFY.json new file mode 100644 index 0000000000..885be18855 --- /dev/null +++ b/research/r437-pooled-native-interface/VERIFY.json @@ -0,0 +1,165 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz", + "research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json", + "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "research/pr589-five-helper-hosting/PROOF.md", + "research/pr589-five-helper-hosting/verify.py", + "research/recursive-parking-boundary/README.md", + "research/selected-bit-local-ring-sweeps/PROOF.md", + "research/selected-bit-physical-caller/PROOF.md", + "research/selected-bit-physical-caller/README.md", + "research/selected-bit-physical-caller/RESULT.json", + "research/selected-bit-physical-caller/SNAPSHOTS.json", + "research/selected-bit-physical-caller/SOURCES.json", + "research/selected-bit-physical-caller/TASK.json", + "research/selected-bit-physical-caller/VALIDATION.md", + "research/selected-bit-physical-caller/VERIFY.json", + "research/selected-bit-physical-caller/continuation_checks.py", + "research/selected-bit-physical-caller/frame_checks.py", + "research/selected-bit-physical-caller/inputs/pr2753/EVIDENCE.json", + "research/selected-bit-physical-caller/inputs/pr2753/PREDECESSOR.json", + "research/selected-bit-physical-caller/inputs/pr2753/PROOF.md", + "research/selected-bit-physical-caller/inputs/pr2753/README.md", + "research/selected-bit-physical-caller/inputs/pr2753/RESULT.json", + "research/selected-bit-physical-caller/inputs/pr2753/SOURCES.json", + "research/selected-bit-physical-caller/inputs/pr2753/TASK.json", + "research/selected-bit-physical-caller/inputs/pr2753/VALIDATION.md", + "research/selected-bit-physical-caller/inputs/pr2753/VERIFY.json", + "research/selected-bit-physical-caller/inputs/pr2753/bootstrap.py", + "research/selected-bit-physical-caller/inputs/pr2753/check_layout.py", + "research/selected-bit-physical-caller/inputs/pr2753/check_nested_model.py", + "research/selected-bit-physical-caller/inputs/pr2753/check_recursion.py", + "research/selected-bit-physical-caller/inputs/pr2753/check_runtime.py", + "research/selected-bit-physical-caller/inputs/pr2753/check_sign.py", + "research/selected-bit-physical-caller/inputs/pr2753/check_sources.py", + "research/selected-bit-physical-caller/inputs/pr2753/consumer.py", + "research/selected-bit-physical-caller/inputs/pr2753/control_checks.py", + "research/selected-bit-physical-caller/inputs/pr2753/driver.py", + "research/selected-bit-physical-caller/inputs/pr2753/evidence/NOTICE.md", + "research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2688-NOTICE.md", + "research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2688-PROOF.md", + "research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2708-README.md", + "research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2731-README.md", + "research/selected-bit-physical-caller/inputs/pr2753/layout.py", + "research/selected-bit-physical-caller/inputs/pr2753/linear_sign.py", + "research/selected-bit-physical-caller/inputs/pr2753/node.py", + "research/selected-bit-physical-caller/inputs/pr2753/packet_engine.py", + "research/selected-bit-physical-caller/inputs/pr2753/peel.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/NOTICE.md", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/PROOF.md", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/README.md", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/RESULT.json", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/SOURCES.json", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/TASK.json", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/VERIFY.json", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/cardinal_counts.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/catalogue.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_headers.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_layout.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_runtime.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_sources.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/consumer.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/control.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/control_checks.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/driver.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/fresh_rows.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/layout.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/model.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/node.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/packet_engine.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/peel.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/topology.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/binding.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/bitstream.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/cardinality.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/check_support.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/children.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/controller.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/counts.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/directory.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/episode.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/forms.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/low_codes.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/matrices.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/numeric.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/oracle.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/packet.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/plan.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/records.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/residual.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/routes.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/selection.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/sources.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/stream.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/stream_runner.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/trace.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/words.py", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/verify.py", + "research/selected-bit-physical-caller/inputs/pr2753/recursive_call.py", + "research/selected-bit-physical-caller/inputs/pr2753/scheduler.py", + "research/selected-bit-physical-caller/inputs/pr2753/stream_runner.py", + "research/selected-bit-physical-caller/inputs/pr2753/trace.py", + "research/selected-bit-physical-caller/inputs/pr2753/verify.py", + "research/selected-bit-physical-caller/inputs/pr2769/NOTICE.md", + "research/selected-bit-physical-caller/inputs/pr2769/PROOF.md", + "research/selected-bit-physical-caller/inputs/pr2769/README.md", + "research/selected-bit-physical-caller/inputs/pr2769/RESULT.json", + "research/selected-bit-physical-caller/inputs/pr2769/SOURCES.json", + "research/selected-bit-physical-caller/inputs/pr2769/TASK.json", + "research/selected-bit-physical-caller/inputs/pr2769/VERIFY.json", + "research/selected-bit-physical-caller/inputs/pr2769/checks.py", + "research/selected-bit-physical-caller/inputs/pr2769/codec.py", + "research/selected-bit-physical-caller/inputs/pr2769/vendor/parking_machine.py", + "research/selected-bit-physical-caller/inputs/pr2769/vendor/pr2753_recursive_call.py", + "research/selected-bit-physical-caller/inputs/pr2769/vendor/words.py", + "research/selected-bit-physical-caller/inputs/pr2769/verify.py", + "research/selected-bit-physical-caller/loader.py", + "research/selected-bit-physical-caller/macro_binding.py", + "research/selected-bit-physical-caller/macro_checks.py", + "research/selected-bit-physical-caller/macro_code.py", + "research/selected-bit-physical-caller/macro_controls.py", + "research/selected-bit-physical-caller/macro_local_checks.py", + "research/selected-bit-physical-caller/macro_machine.py", + "research/selected-bit-physical-caller/macro_selected_checks.py", + "research/selected-bit-physical-caller/nested_bank_checks.py", + "research/selected-bit-physical-caller/numerical_frame.py", + "research/selected-bit-physical-caller/residual_blocks.py", + "research/selected-bit-physical-caller/role_parking.py", + "research/selected-bit-physical-caller/scratch_pool.py", + "research/selected-bit-physical-caller/verify.py", + "research/selected-bit-recursive-closure/PROOF.md", + "upstream/build/sections/02-streams.tex", + "research/physical-compiler-correspondence/README.md", + "research/physical-compiler-correspondence/owners.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 550, + "checks": "Authenticate sources, all903456 replica request mappings, allpooled owner/chart certificates, actualsource compiler andsemantic rejection controls" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 550, + "checks": "Assertions-independent optimized replay of the same exact result" + } + ] +} diff --git a/research/r437-pooled-native-interface/adapter.py b/research/r437-pooled-native-interface/adapter.py new file mode 100644 index 0000000000..276a9a0f43 --- /dev/null +++ b/research/r437-pooled-native-interface/adapter.py @@ -0,0 +1,63 @@ +"""Current OQ4 source binding, derived from zxv/PR3690's adapter. + +Reuse Jose Manuel/David Arias's canonical physical runtime without copying an +unrelated ordinary/T360 archive. Apache-2.0; substantial OpenAI Codex assistance. +""" +import gzip +import hashlib +import json +from pathlib import Path +import sys +import types + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +PHYSICAL = ROOT / 'research/selected-bit-physical-caller' +REQUEST_DIGEST = 'cbfea55f5cd0b74a2a0d4292ad0139d2b5bb73127951127698030bc90c73c532' + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def replacement(source, before, after, count): + require(source.count(before) == count, 'exact adaptation context: ' + before[:65]) + return source.replace(before, after) + + +def load(): + sys.path.insert(0, str(PHYSICAL)) + import loader + loader.activate() + import catalogue, topology + expected = json.loads((HERE / 'inputs/EXPECTED.json').read_bytes()) + paths = {name: HERE / ('inputs/' + name + '.json.gz') + for name in ('word', 'template', 'geometry')} + for name, field in [('word','word_content_sha256'), ('template','template_content_sha256')]: + require(hashlib.sha256(gzip.decompress(paths[name].read_bytes())).hexdigest() + == expected[field], 'current R437 ' + name + ' identity') + require(expected['profile'].get('26') == 32 and '34' not in expected['profile'], + 'current OQ4 profile, not predecessor rank34') + original = Path(catalogue.__file__).read_text() + source = replacement(original, 'private=661', 'private=659', 1) + source = replacement(source, '==661', '==659', 3) + source = replacement(source, 'self.old.WORD,self.old.HOST,self.old.GEO', + "R437_PATHS['word'],R437_PATHS['template'],R437_PATHS['geometry']", 1) + source = replacement(source, 'expected={int(k):v for k,v in self.old.read("research/e8-bit-p111-tuned/tune/EXPECTED.json")["nine"]["profile"].items()}', + 'expected={int(k):v for k,v in R437_EXPECTED["profile"].items()}', 1) + source = replacement(source, '==904896', '==903456', 1) + source = replacement(source, '"f5a4fb124709adc4b56376a3146e3609e91c0f4d3ed1931a61785a5d99bf8ee7"', + 'R437_REQUEST_DIGEST', 1) + module = types.ModuleType('oq4_catalogue') + module.__file__ = str(HERE / 'adapter.py') + module.R437_PATHS, module.R437_EXPECTED = paths, expected + module.R437_REQUEST_DIGEST = REQUEST_DIGEST + sys.modules[module.__name__] = module + exec(compile(source, '', 'exec'), module.__dict__) + value = module.Catalogue(3) + code = replacement(Path(topology.__file__).read_text(), '==661', '==659', 1) + topo = types.ModuleType('oq4_topology') + sys.modules[topo.__name__] = topo + exec(compile(code, '', 'exec'), topo.__dict__) + return value, topo.SelectedTopology(value) diff --git a/research/r437-pooled-native-interface/check_interface.py b/research/r437-pooled-native-interface/check_interface.py new file mode 100644 index 0000000000..d44bcf750f --- /dev/null +++ b/research/r437-pooled-native-interface/check_interface.py @@ -0,0 +1,114 @@ +"""Source-level all-replica audit, no full-volume physical replay.""" +from collections import Counter, defaultdict +from functools import lru_cache +from hashlib import sha256 +import json +from pathlib import Path +import sys +import replica_catalogue as rc +import adapter +from check_transport import determinant,dyadic,dyadic_unit,reconstructed_chart,distinguishing_entry,canonical + +HERE=Path(__file__).resolve().parent +need=rc.need + +def run(): + cat,top=rc.load() + charts=set() + calls=[] + for stage in range(9): + for replica in range(32): + call=top.call(stage,replica); calls.append(call) + charts.update(owner.chart for owner in call.owners) + charts.update(request.chart for request in cat.requests.idles) + charts.update(request.chart for rows in cat.requests.prototypes for request in rows if request.kind=='COPY') + matrices={};dets=Counter();cdigest=sha256() + for chart in sorted(charts,key=lambda c:canonical(c.key)): + m=reconstructed_chart(chart,cat.geometry) + need(m==cat.chart_matrix(chart),'actual pooled chart agrees with independent reconstruction') + need(all(dyadic(x) for row in m for x in row),'dyadic entries') + det=determinant(m);need(dyadic_unit(det),'chart invertible at every odd prime') + matrices[chart]=m;dets[str(det)]+=1 + cdigest.update((canonical([chart.key,str(det)])+'\n').encode()) + @lru_cache(None) + def witness(a,b):return distinguishing_entry(matrices[a],matrices[b]) + pairs=0;wdigest=sha256();stage_pairs=Counter() + for call in calls: + groups=defaultdict(list) + for role,owner in enumerate(call.owners):groups[owner.family].append((role,owner.chart)) + for family,roles in sorted(groups.items()): + for index,(role,a) in enumerate(roles): + for other,b in roles[:index]: + entry=witness(a,b);pairs+=1;stage_pairs[call.stage]+=1 + wdigest.update((canonical([call.stage,call.replica,family,role,other,*entry])+'\n').encode()) + profile=Counter();kinds=Counter();digest=sha256();resolved=0 + for identifier,r in enumerate(cat.requests): + need(cat.requests.identifier(*r.key)==identifier,'full request key round trip') + if r.kind!='IDLE': + call=top.call(r.stage,r.replica) + need(call.requests[r.position]==identifier,'actual caller source identifier') + owner=call.owners[r.role] + need((r.family,r.chart)==(owner.family,owner.chart) if r.kind=='MOVE' + else r.family==28416 and r.source_chart==owner.chart,'typed owner/source chart') + else: + need(top.idle_family(identifier,r.replica)==r.family,'absolute idle family') + resolved+=1;profile[r.base.rank]+=1;kinds[r.kind]+=1 + digest.update((canonical(r.record())+'\n').encode()) + need(profile==cat.profile and resolved==903456,'complete physical profile') + idle_ids=[i for event in top.schedule if event['kind']=='idle' + for replica in range(32) for i in top.idle_identifiers(event['idx'],replica)] + need(len(idle_ids)==63936 and len(set(idle_ids))==63936,'exact once idle enumeration') + need(set(idle_ids)==set(range(cat.requests.starts[-1],len(cat.requests))),'full idle coverage') + controls=[] + def reject(name,action): + try:action() + except (ValueError,TypeError,KeyError,AttributeError):controls.append(name) + else:raise ValueError('accepted control '+name) + reject('replica omitted',lambda:cat.requests.identifier('MOVE',6,19236)) + reject('wrong idle replica',lambda:top.idle_family(idle_ids[0],(cat.requests[idle_ids[0]].replica+1)%32)) + reject('legacy idle consumer',lambda:top.idles) + reject('replica factorized profile',lambda:need(all(n%32==0 for n in profile.values()),'profile is not replica factorized')) + first=cat.requests.identifier('MOVE',6,1,19236) + zero=cat.requests.identifier('MOVE',6,0,19236) + a,b=cat.requests[first],cat.requests[zero] + need(a.role==b.role==643 and a.family==b.family==209 and a.chart!=b.chart,'actual first moved helper witness') + reject('same-family duplicate chart',lambda:distinguishing_entry(matrices[a.chart],matrices[a.chart])) + need(cat.codes.bits-cat.old_code_bits==5,'expanded source-code field is exactly five bits wider') + from catalogue import Specifications + from sources import identity + specs=Specifications(cat); low=tuple(tuple(map(int,row)) for row in identity(64)) + rank14=next(i for i in idle_ids if cat.requests[i].base.rank==14) + copy_id=next(i for i,r in enumerate(cat.requests.prototypes[0]) if r.kind=='COPY') + compiled=[] + for identifier,common in ((first,True),(first,False),(rank14,False),(copy_id,True)): + handle=rc.source_handle(cat,identifier,common,low) + spec=rc.resolve_handle(cat,specs,handle) + r=cat.requests[identifier] + need(spec.template.record[:2]==(rc.VERSION,r.replica),'compiled source retains replica identity') + need(spec.template.rank==r.base.rank,'actual source rank') + compiled.append({'request':identifier,'kind':r.kind,'replica':r.replica,'rank':r.base.rank, + 'common':common,'good':spec.good}) + reject('stale source codebook',lambda:rc.resolve_handle(cat,specs,rc.SourceHandle(rc.VERSION,adapter.REQUEST_DIGEST,handle.code))) + import copy + wrong_context=copy.copy(cat);wrong_context.q=5 + reject('different prime source codebook',lambda:rc.resolve_handle(cat,specs,rc.SourceHandle(rc.VERSION,rc.codebook_identity(wrong_context),handle.code))) + reject('mismatched Specifications context',lambda:rc.resolve_handle(cat,Specifications(wrong_context),handle)) + reject('untagged integer source',lambda:rc.resolve_handle(cat,specs,handle.code)) + reject('native COPY request',lambda:specs.bind(copy_id,False,low)) + return dict(status='PASS_POOLED_REPLICA_NATIVE_REQUEST_INTERFACE',request_count=resolved, + request_kinds=dict(sorted(kinds.items())),profile=dict(sorted(profile.items())), + rank_mass=sum(r*n for r,n in profile.items()),request_sha256=digest.hexdigest(), + chart_count=len(charts),determinants=dict(sorted(dets.items())),chart_sha256=cdigest.hexdigest(), + same_family_pairs=pairs,per_stage_pairs=dict(sorted(stage_pairs.items())), + witness_sha256=wdigest.hexdigest(),unique_chart_pair_witnesses=witness.cache_info().currsize, + old_q3_code_bits=cat.old_code_bits,new_q3_code_bits=cat.codes.bits,code_bits_delta=5, + first_moved_request=first,replica_zero_request=zero, + controls=controls,compiled_actual_sources=compiled,source_identity=cat.source_identity,ERASE_guards=len(cat.erase_guards),local_owner_gathers_per_low=189792,idle_owner_gathers_per_low=63936, + routes_per_low=379584,family_scans_per_low=507456, + full_physical_caller_executed=False,supplier_admitted=False) + +if __name__=='__main__': + value=run() + if '--write' in sys.argv:(HERE/'RESULT.json').write_text(json.dumps(value,sort_keys=True,indent=2)+'\n') + else:need(json.loads((HERE/'RESULT.json').read_bytes())==json.loads(json.dumps(value)),'exact frozen interface receipt') + print(json.dumps(value,sort_keys=True)) diff --git a/research/r437-pooled-native-interface/check_transport.py b/research/r437-pooled-native-interface/check_transport.py new file mode 100644 index 0000000000..5bd3c8a38a --- /dev/null +++ b/research/r437-pooled-native-interface/check_transport.py @@ -0,0 +1,208 @@ +"""Independent dyadic chart and packet separation certificates for R437/OQ4. + +Chris R / Clear1nsight with substantial OpenAI Codex assistance. Apache-2.0. +The source catalogue is reused; exact determinant and separation checks are new. +""" +from collections import Counter, defaultdict +from fractions import Fraction as F +from hashlib import sha256 +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent + +def need(ok, message): + if not ok: + raise ValueError(message) + +def power_two(n): + return n > 0 and n & (n - 1) == 0 + +def dyadic(x): + return power_two(F(x).denominator) + +def dyadic_unit(x): + x = F(x) + return power_two(abs(x.numerator)) and power_two(x.denominator) + +def determinant(matrix): + """Exact elimination independent of predecessor chart/inverse routines.""" + a = [list(map(F, row)) for row in matrix] + n, result = len(a), F(1) + need(all(len(row) == n for row in a), 'square determinant') + for col in range(n): + pivot_row = next((i for i in range(col, n) if a[i][col]), None) + if pivot_row is None: + return F(0) + if pivot_row != col: + a[pivot_row], a[col] = a[col], a[pivot_row] + result = -result + pivot = a[col][col] + result *= pivot + for i in range(col + 1, n): + if not a[i][col]: + continue + factor = a[i][col] / pivot + for j in range(col + 1, n): + if a[col][j]: + a[i][j] -= factor * a[col][j] + a[i][col] = F(0) + return result + +def distinguishing_entry(a, b): + for i, (ra, rb) in enumerate(zip(a, b)): + for j, (x, y) in enumerate(zip(ra, rb)): + if dyadic_unit(x - y): + return i, j, str(x - y) + raise ValueError('no universally nonzero dyadic-unit chart witness') + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')) + +def reconstructed_chart(chart, geometry): + """Sparse coordinate specification; no catalogue matrix/route functions.""" + entries = {(i, i): F(1) for i in range(64)} + if chart.kind == 'data' and chart.stage: + axes = tuple(range(8)) + tuple(range(8 + 7*(chart.stage-1), 8 + 7*chart.stage)) + rho = geometry['ports'][chart.port]['rho15'] + for i, a in enumerate(axes): + for j, b in enumerate(axes): + entries[a,b] = F(rho[i][j]) + elif chart.kind == 'family' or chart.kind == 'host' and chart.port >= 0: + port = geometry['ports'][chart.port] + for i in range(8): + entries[i,0] = F(port['q'][i], 2) + for j in range(1,8): + entries[i,j] = F(port['complement_columns'][i][j-1]) + else: + need(chart.kind in ('identity','host','data'), 'known chart label') + if chart.kind == 'host': + support, native = set(chart.axes), set(range(8)) + need(len(support) == 8, 'eight owner axes') + exchanges = dict() + for a,b in zip(sorted(native-support), sorted(support-native)): + exchanges[a], exchanges[b] = b,a + entries = {(i, exchanges.get(j,j)): x for (i,j),x in entries.items()} + return tuple(tuple(entries.get((i,j),F(0)) for j in range(64)) for i in range(64)) + +def source_certificate(): + import adapter + catalogue, topology = adapter.load() + charts = sorted(catalogue.charts, key=lambda x: canonical(x.key)) + chart_ids = {chart: i for i, chart in enumerate(charts)} + matrices, determinants, chart_rows = {}, Counter(), [] + for chart in charts: + matrix = reconstructed_chart(chart, catalogue.geometry) + need(matrix == catalogue.chart_matrix(chart), 'independent exact chart reconstruction') + need(all(dyadic(x) for row in matrix for x in row), 'dyadic chart entries') + det = determinant(matrix) + need(dyadic_unit(det), 'unit determinant at every odd modulus') + matrices[chart] = matrix + determinants[str(det)] += 1 + chart_rows.append([chart.key, str(det)]) + witnesses, difference_counts, stage_counts = [], Counter(), [] + for stage in range(9): + call = topology.call(stage,0) + groups = defaultdict(list) + for role,owner in enumerate(call.owners): + groups[owner.family].append((role,owner.chart)) + before = len(witnesses) + for family, roles in sorted(groups.items()): + for a, (role_a, chart_a) in enumerate(roles): + for role_b,chart_b in roles[:a]: + entry = distinguishing_entry(matrices[chart_a],matrices[chart_b]) + difference_counts[entry[2]] += 1 + witnesses.append([stage,family,role_a,role_b,chart_ids[chart_a],chart_ids[chart_b],*entry]) + stage_counts.append(len(witnesses)-before) + # Check the precise replica reduction, not only an aggregate histogram. + for replica in range(32): + other = topology.call(stage,replica) + need(len(other.owners)==len(call.owners)==659, 'current complete role inventory') + need(all(o.chart==b.chart and o.family==b.family+888*replica + for o,b in zip(other.owners,call.owners)), 'all actual replica owner labels') + # A source-specific carry control at actual native IDLE27776/chart98. + idle = catalogue.requests[27776] + need(idle.kind == 'IDLE' and idle.base.rank == 26 and idle.chart.port == 98, + 'actual rank26 native chart') + sigma = matrices[idle.chart] + carry_cases = [] + for q,w in ((3,2),(5,3),(7,4)): + modulus = q**w + reduced = tuple(tuple(x.numerator*pow(x.denominator,-1,modulus)%modulus + for x in row) for row in sigma) + low = tuple(tuple(x.numerator*pow(x.denominator,-1,q)%q + for x in row) for row in sigma) + # Raw native identity has zero high digits, but rational chart entries carry. + high = tuple(tuple((x-y)//q for x,y in zip(a,b)) for a,b in zip(reduced,low)) + need(all((x-y)%q == 0 and 0 <= h < q**(w-1) + for a,b,c in zip(reduced,low,high) for x,y,h in zip(a,b,c)), + 'complete canonical raw-to-high quotient') + nonzero = sum(x != 0 for row in high for x in row) + need(nonzero > 0, 'low-only chart retag loses actual native carry') + carry_cases.append({'q':q,'w':w,'nonzero_high_entries':nonzero, + 'raw_identity_high_zero':True}) + receipt = catalogue.receipt() + kinds = receipt['request_kinds'] + local_roles = 9*32*659 + idles = kinds['IDLE']*32 + counts = { + 'local_gathers_per_low_class':local_roles, + 'local_scatters_per_low_class':local_roles, + 'local_routes_per_low_class':2*local_roles, + 'idle_gathers_per_low_class':idles, + 'idle_scatters_per_low_class':idles, + 'all_family_scans_per_low_class':2*(local_roles+idles), + } + need(receipt['binding_sha256']==adapter.REQUEST_DIGEST,'current complete source binding') + need(len(charts)==1235 and len(witnesses)==5619,'frozen chart and pair inventory') + return { + 'status':'PASS_CURRENT_R437_UNIFORM_OWNER_SEPARATION', + 'request_binding_sha256':receipt['binding_sha256'], + 'chart_labels':len(charts),'determinants':dict(sorted(determinants.items())), + 'chart_certificate_sha256':sha256(canonical(chart_rows).encode()).hexdigest(), + 'canonical_same_family_pairs':len(witnesses),'replicated_same_family_pairs':32*len(witnesses), + 'per_stage_pairs':stage_counts,'witness_differences':dict(sorted(difference_counts.items())), + 'witness_sha256':sha256(canonical(witnesses).encode()).hexdigest(), + 'request_kinds':kinds,'complete_transport_counts':counts, + 'actual_native_carry_controls':carry_cases, + 'quantifier':'Every odd prime q, every w>=1, every invertible common low, every high lift; algebraic owner/route interface only.', + 'full_GL64_physical_execution':False,'supplier_admission':False, + } + +def finite_controls(): + identity = ((F(1),F(0)),(F(0),F(1))) + swap = ((F(0),F(1)),(F(1),F(0))) + need(determinant(identity)==1 and determinant(swap)==-1,'determinant positive controls') + rejected = [] + for label, action in [ + ('same_family_duplicate_chart',lambda:distinguishing_entry(identity,identity)), + ('odd_prime_determinant',lambda:need(dyadic_unit(determinant(((3,0),(0,1)))),'odd determinant rejected')), + ('odd_denominator',lambda:need(dyadic(F(1,3)),'odd denominator rejected')), + ('difference_vanishes_mod_3',lambda:distinguishing_entry(identity,((F(4),F(0)),(F(0),F(1))))), + ]: + try: action() + except ValueError: rejected.append(label) + else: raise ValueError('control accepted: '+label) + # Disjoint writes into the latest family compose; stale snapshots lose writes. + original = [0,1,1,0,0,1] + def scatter(state, index, values): + result = state[:];result[2*index:2*index+2] = values;return result + latest = scatter(scatter(original,0,[1,1]),2,[0,0]) + stale = scatter(original,2,[0,0]) + need(latest == [1,1,1,0,0,0] and stale != latest,'stale scatter semantic control') + rejected.append('stale_scatter_snapshot') + return rejected + +def main(): + result = source_certificate() + result['controls'] = finite_controls() + target = HERE/'RESULT.json' + if '--write' in sys.argv: + target.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + else: + need(json.loads(target.read_text())==result,'frozen exact transport receipt') + print(json.dumps(result,sort_keys=True)) + +if __name__ == '__main__': + main() diff --git a/research/r437-pooled-native-interface/inputs/EXPECTED.json b/research/r437-pooled-native-interface/inputs/EXPECTED.json new file mode 100644 index 0000000000..bc2585e140 --- /dev/null +++ b/research/r437-pooled-native-interface/inputs/EXPECTED.json @@ -0,0 +1,34 @@ +{ + "word_gzip_sha256": "e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e", + "word_content_sha256": "da77deaf11368d016622348227657b98404b6afbc7e4f3d6fe9a246baae0dcce", + "records_sha256": "caeb2eb0e417992788c32c1f5812ada60b46d1dfdba9f4ac376299b2dede13cb", + "template_content_sha256": "c425a64739981b3ae3ed6b36d1a2f42c2d35e93f007649e89d4c677d8e158fe5", + "program_sha256": "a777373994bd84681d6c2be75251ba6a04a1521580910f23afe09bb50db632b2", + "profile": { + "1": 380160, + "2": 400864, + "3": 22176, + "4": 26592, + "5": 29376, + "6": 17376, + "7": 26496, + "26": 32, + "42": 384 + }, + "live": 28416, + "physical": 28425, + "rank_mass": 1808352, + "deficit": 10272, + "emitted_events": 7814016, + "hosted_residuals": 125856, + "BIT_c": "1736646042038446578551/1000000000000000000000000", + "BIT_c_decimal": "0.001736646042038446578551", + "next_grid": "217080755254805822319/125000000000000000000000", + "invoice": { + "prefix_bits": 177, + "charged_prefix": 192, + "two_level_bits": 393, + "charged_two_level": 512, + "ROW": 18355 + } +} diff --git a/research/r437-pooled-native-interface/inputs/catalogue.py b/research/r437-pooled-native-interface/inputs/catalogue.py new file mode 100644 index 0000000000..0efc0575a7 --- /dev/null +++ b/research/r437-pooled-native-interface/inputs/catalogue.py @@ -0,0 +1,268 @@ +"""Fixed selected request compilation, adapted from pinned PR2234 provider.py. + +Only q, rational labels and low classes enter these compilation routines. +Runtime precision, high matrices, widths and coefficients remain on tapes. +""" +from collections import Counter, defaultdict +from dataclasses import dataclass +from fractions import Fraction as F +from functools import cached_property, lru_cache +from hashlib import sha256 +import importlib.util +import json + +from binding import split_basis +from low_codes import LowCodes +import oracle +from plan import compile_plan +from sources import ROOT, Template, compile_specification, identity, product +from words import need + + +def canonical(value): + return json.dumps(value,sort_keys=True,separators=(",",":")) + + +@dataclass(frozen=True) +class Base: + kind: str + data: tuple + rank: int + + @cached_property + def key(self): + values=[[str(x) for x in row] for row in self.data] if self.kind=="local" else self.data + return sha256(canonical([self.kind,self.rank,values]).encode()).hexdigest() + + @lru_cache(None) + def matrix(self): + out=[[F(0)]*64 for _ in range(64)] + if self.kind=="local": + for i,row in enumerate(self.data):out[i][:8]=row + else: + need(self.kind=="idle" and len(set(self.data))==self.rank,"fixed idle base") + for i in self.data:out[i][i]=F(1) + return tuple(map(tuple,out)) + + @lru_cache(None) + def basis(self,q): + return split_basis(self.matrix(),self.rank,q) + + +@dataclass(frozen=True) +class Chart: + kind: str + port: int = -1 + stage: int = -1 + axes: tuple = () + + @property + def key(self):return (self.kind,self.port,self.stage,self.axes) + + +@dataclass(frozen=True) +class Request: + kind: str + stage: int + position: int + role: int + family: int + old_frame: int + new_frame: int + base: Base + chart: Chart + header_space: str + source_chart: object = None + + def record(self): + return [self.kind,self.stage,self.position,self.role,self.family, + self.old_frame,self.new_frame,self.base.key,self.base.rank, + self.chart.key,self.header_space,self.source_chart.key if self.source_chart else None] + + +class Catalogue: + dimension=64 + replicas=32 + families=28416 + private=661 + replica_stride=888 + + def __init__(self,q): + self.q=q + path=ROOT/"research/pr589-five-helper-hosting/verify.py" + spec=importlib.util.spec_from_file_location("retained_selected_node_source",path) + self.old=importlib.util.module_from_spec(spec);spec.loader.exec_module(self.old) + self.word,self.template,self.geometry=(self.old.read(p) for p in + (self.old.WORD,self.old.HOST,self.old.GEO)) + rows=[self.old.projection([self.word["lines"][i] for i in frame]) for frame in self.word["frames"]] + self.projectors=[p for p,_ in rows];self.dimensions=[r for _,r in rows] + self.idles={event["idx"]:event for event in self.template["schedule"] if event["kind"]=="idle"} + self.requests=[];self.bases={};self.charts=set();self.erase_guards=[] + self._bind() + self.codes=LowCodes(q,64,len(self.requests)) + self.identifiers={self.semantic_key(request):i for i,request in enumerate(self.requests)} + need(len(self.identifiers)==len(self.requests),"unique full catalogue request identifiers") + + @staticmethod + def semantic_key(request): + return (request.kind,request.stage,request.role if request.kind=="IDLE" else request.position) + + def base(self,a,b): + lo,hi=(a,b) if self.dimensions[a]<=self.dimensions[b] else (b,a) + value=Base("local",self.old.sub(self.projectors[hi],self.projectors[lo]), + self.dimensions[hi]-self.dimensions[lo]) + return self.bases.setdefault(value.key,value) + + def pending(self,child):return tuple(self.old.pending_axes(self.idles[child])) + + def owner_chart(self,call,role): + family,route=call["owners"][role] + if route[0]=="data":return Chart("data",route[2],route[1]) + need(route[0]=="hosted","selected owner route kind") + _,child,offset,width=route + axes=self.pending(child)[offset:offset+width] + need(len(axes)==8,"complete selected helper support") + return Chart("host",family%111 if min(axes)<8 else -1,axes=axes) + + @lru_cache(None) + def chart_matrix(self,chart): + out=identity(64) + if chart.kind=="identity":return tuple(map(tuple,out)) + if chart.kind=="data": + if chart.stage==0:return tuple(map(tuple,out)) + axes=list(range(8))+list(range(8+7*(chart.stage-1),8+7*chart.stage)) + rho=self.geometry["ports"][chart.port]["rho15"] + for i,a in enumerate(axes): + for j,b in enumerate(axes):out[a][b]=F(rho[i][j]) + return tuple(map(tuple,out)) + if chart.kind=="family" or (chart.kind=="host" and chart.port>=0): + port=self.geometry["ports"][chart.port] + for i in range(8):out[i][:8]=[F(port["q"][i],2)]+list(map(F,port["complement_columns"][i])) + if chart.kind=="host": + domain,support=set(range(8)),set(chart.axes);permutation=list(range(64)) + for a,b in zip(sorted(domain-support),sorted(support-domain)): + permutation[a],permutation[b]=b,a + need(set(permutation[:8])==support,"selected owner support completion") + out=[[row[permutation[j]] for j in range(64)] for row in out] + else:need(chart.kind=="family","known fixed chart") + return tuple(map(tuple,out)) + + def _append(self,request): + need(0', 'exec'), + {'t': template, 'need': need}) + + +def compile_owners(template, moves): + t = copy.deepcopy(template) + last, seen, windows = {}, [], {} + for position, event in enumerate(t['schedule']): + if event['kind'] == 'local_cover_sweep': + seen.append((position, event['stage'], event['pair'])) + last[event['pair']] = position + elif event['kind'] == 'bridge': + last[event['dst']] = last[event['src']] = position + elif event['kind'] == 'idle': + stages = [s for p, s, pair in seen + if last.get(event['pair'], -1) < p < position and pair != event['pair']] + if event['rank'] and stages: + windows[str(event['idx'])] = [event['pair'], event['rank'], sorted(stages)] + need(windows == t['hosting']['windows'], 'windows derived from literal chronology') + calls = {(c['stage'], c['replica']): c for c in t['calls']} + need(len(calls) == 288, 'complete stage-replica call domain') + changed = set() + for move in moves: + key = move['stage'], move['call_replica'], move['helper'] + need(key not in changed, 'duplicate moved logical owner') + changed.add(key) + call = calls[key[:2]] + old, new = move['old'], move['new'] + role = 222 + move['helper'] + need(call['owners'][role] == [old['family'], ['hosted', old['child'], old['offset'], 8]], + 'exact predecessor owner') + call['owners'][role] = [new['family'], ['hosted', new['child'], new['offset'], 8]] + occupancy = defaultdict(set) + count = 0 + for call in t['calls']: + for family, route in call['owners'][222:]: + need(route[0] == 'hosted', 'host-all domain') + _, child, offset, width = route + pair, capacity, stages = t['hosting']['windows'][str(child)] + need(call['stage'] in stages and pair != call['pair'], 'untouched destination window') + need(0 <= family < 28416 and (family % 888) // 222 == pair, + 'absolute destination family pair') + need(width == 8 and 0 <= offset and offset + width <= capacity, + 'whole residual within destination') + cells = set(range(offset, offset + width)) + need(not cells.intersection(occupancy[child, family]), 'disjoint absolute owner cells') + occupancy[child, family].update(cells) + count += 1 + need(count == 125856, 'each logical helper hosted exactly once') + profile = Counter() + for call in t['calls']: + for event in t['local_programs'][call['orientation']]: + if event[0] == 0 and event[4]: profile[event[4]] += 1 + elif event[0] == 2: profile[event[5]] += 1 + idle_records = [] + for event in t['schedule']: + if event['kind'] != 'idle' or not event['rank']: continue + child, pair, capacity = event['idx'], event['pair'], event['rank'] + for replica in range(32): + for cp in range(222): + family = replica * 888 + pair * 222 + cp + used = occupancy[child, family] + need(used == set(range(len(used))), 'compact occupied prefix') + rank = capacity - len(used) + if rank: + profile[rank] += 1 + idle_records.append([child, replica, cp, family, len(used), rank]) + need(sum(profile.values()) == 903456, 'all paid requests retained') + need(sum(r*n for r,n in profile.items()) == 1808352, 'rank mass retained') + return t, profile, idle_records + + +def retained_emit(template): + """Execute the unchanged final stream-emission block of pinned emit_k.py.""" + source = (HERE / 'inputs/emit_k.py').read_text() + start = source.index(' expanded=hashlib.sha256(); count=0; local=2*V+R\n') + end = source.index(" res['additional_interface']=", start) + code = '\n'.join(line[4:] for line in source[start:end].splitlines()) + scope = {'t': template, 'res': {}, 'hashlib': hashlib, 'json': json, + 'V': 111, 'R': 437, 'LIVE': 28416} + exec(compile(code, '', 'exec'), scope) + return scope['res'] + + +def independent_emit(template): + """Use the separately retained predecessor audit encoder without adaptation.""" + source = ast.parse((HERE / 'inputs/audit_hosted_k.py').read_text()) + function = next(n for n in source.body if isinstance(n, ast.FunctionDef) and n.name == 'digest') + scope = {'hashlib': hashlib, 'json': json, 'V': 111} + exec(compile(ast.fix_missing_locations(ast.Module(body=[function], type_ignores=[])), + '', 'exec'), scope) + return scope['digest'](template) + + +def changed_event_count(before, after): + count = 0 + for old, new in zip(before['calls'], after['calls']): + changed = {i for i,(a,b) in enumerate(zip(old['owners'],new['owners'])) if a != b} + for z in before['local_programs'][old['orientation']]: + count += z[1] in changed or (z[0] != 0 and z[2] in changed) + return count diff --git a/research/r437-pooled-native-interface/replica_catalogue.py b/research/r437-pooled-native-interface/replica_catalogue.py new file mode 100644 index 0000000000..1fa6ea58c5 --- /dev/null +++ b/research/r437-pooled-native-interface/replica_catalogue.py @@ -0,0 +1,208 @@ +"""Explicit replica-indexed request interface for the frozen pooled R437 source. + +Retains canonical Base/Chart/Template/LowCodes semantics. No physical execution +or supplier admission is implied. Apache-2.0; Chris R, OpenAI Codex assistance. +""" +from bisect import bisect_right +from collections import Counter +from collections.abc import Sequence +from dataclasses import dataclass, replace +from functools import lru_cache +from hashlib import sha256 +import json +from pathlib import Path +import sys + +import adapter +import pooled_compiler + +HERE = Path(__file__).resolve().parent +VERSION = 'pooled-replica-request-v1' +need = adapter.require + +@dataclass(frozen=True) +class ReplicaRequest: + replica: int + request: object + + def __getattr__(self, name): + return getattr(self.request, name) + + def record(self): + return [VERSION, self.replica] + self.request.record() + + @property + def key(self): + r = self.request + return (r.kind, r.stage, self.replica, r.role if r.kind == 'IDLE' else r.position) + +class Requests(Sequence): + """Full 903456-site vocabulary, constructed lazily without symmetry quotient.""" + def __init__(self, catalogue, prototypes, idle_records): + self.catalogue = catalogue + self.prototypes = [tuple(r for r in prototypes if r.kind != 'IDLE' and r.stage == s) + for s in range(9)] + self.positions = [{r.position: j for j, r in enumerate(rows)} for rows in self.prototypes] + self.starts = [0] + for rows in self.prototypes: + self.starts.append(self.starts[-1] + 32 * len(rows)) + self.idles = [] + self.idle_lookup = {} + module = sys.modules[type(catalogue).__module__] + for child, replica, cp, family, used, rank in idle_records: + event = catalogue.idles[child] + axes = catalogue.pending(child)[used:] + need(len(axes) == rank, 'literal pooled idle suffix') + base = module.Base('idle', axes, rank) + base = catalogue.bases.setdefault(base.key, base) + request = module.Request('IDLE', child, child, cp, family, + event['source_level'], event['target_level'], base, + module.Chart('family', cp % 111), 'owner') + wrapped = ReplicaRequest(replica, request) + self.idle_lookup[wrapped.key] = self.starts[-1] + len(self.idles) + self.idles.append(wrapped) + + def __len__(self): + return self.starts[-1] + len(self.idles) + + def __getitem__(self, index): + if not isinstance(index, int): + raise TypeError('request indices are explicit integers') + if index < 0: + index += len(self) + if not 0 <= index < len(self): + raise IndexError(index) + if index >= self.starts[-1]: + return self.idles[index - self.starts[-1]] + stage = bisect_right(self.starts, index) - 1 + replica, slot = divmod(index-self.starts[stage], len(self.prototypes[stage])) + old = self.prototypes[stage][slot] + call = self.catalogue.template['calls'][32*stage+replica] + chart = self.catalogue.owner_chart(call, old.role) + if old.kind == 'MOVE': + request = replace(old, family=call['owners'][old.role][0], chart=chart) + else: + request = replace(old, source_chart=chart) + return ReplicaRequest(replica, request) + + def identifier(self, kind, stage, replica, position): + need(0 <= replica < 32, 'physical caller replica') + if kind == 'IDLE': + return self.idle_lookup[kind, stage, replica, position] + slot = self.positions[stage][position] + need(self.prototypes[stage][slot].kind == kind, 'physical request kind') + return self.starts[stage] + replica*len(self.prototypes[stage]) + slot + +class ReplicaTopology: + """Changed interface: IDLE enumeration takes the replica explicitly. + + Deliberately exposes no legacy `idles` table. Existing compile_node requires + an explicit consumer adaptation; feeding it expanded IDLE IDs is unsafe. + """ + replicas, pairs, ports, families, stride = 32, 4, 111, 28416, 888 + + def __init__(self, catalogue, old_topology): + self.catalogue = catalogue + self.schedule = tuple(catalogue.template['schedule']) + self.old_topology = old_topology + self.idle_groups = {} + for index, request in enumerate(catalogue.requests.idles, catalogue.requests.starts[-1]): + self.idle_groups.setdefault((request.stage,request.replica), []).append(index) + + def idle_identifiers(self, child, replica): + need(0 <= replica < 32, 'physical idle replica') + return tuple(self.idle_groups.get((child,replica), ())) + + def idle_family(self, identifier, replica): + request = self.catalogue.requests[identifier] + need(request.kind == 'IDLE' and request.replica == replica, 'exact idle replica binding') + return request.family + + @lru_cache(None) + def call(self, stage, replica): + import topology + source = self.catalogue.template['calls'][32*stage+replica] + old = self.old_topology.call(stage,replica) + owners = tuple(topology.Owner(family, self.catalogue.owner_chart(source,role)) + for role,(family,route) in enumerate(source['owners'])) + identifiers = tuple(self.catalogue.requests.identifier('MOVE' if event[0] == 0 else 'COPY', + stage,replica,position) + if event[0] in (0,2) else None + for position,event in enumerate(old.events)) + need(len(owners) == 659, 'actual pooled role inventory') + return topology.Call(stage,replica,owners,old.start,old.end,old.events,identifiers,old.reverse) + + def matrix(self, chart): + return self.catalogue.chart_matrix(chart) + + def family(self, replica, pair, side, port): + return self.old_topology.family(replica,pair,side,port) + +def load(): + catalogue, old_topology = adapter.load() + proposal = json.loads((HERE/'inputs/moves.json').read_bytes()) + pooled, profile, idles = pooled_compiler.compile_owners(catalogue.template, proposal['moves']) + prototypes = catalogue.requests + old_bits = catalogue.codes.bits + # Preserve the literal unpooled topology as a recipe-only predecessor. + import copy + old_topology.catalogue = copy.copy(catalogue) + catalogue.template = pooled + catalogue.bases = dict(catalogue.bases) + catalogue.requests = Requests(catalogue, prototypes, idles) + catalogue.profile = profile + from low_codes import LowCodes + catalogue.codes = LowCodes(catalogue.q,64,len(catalogue.requests)) + # Reject the replica-blind public identifier entry point instead of retaining + # an accidentally usable old dictionary. Requests.identifier is the new API. + catalogue.identifiers = {} + catalogue.identifier = catalogue.requests.identifier + catalogue.semantic_key = lambda request: request.key + catalogue.erase_guards = tuple((stage,replica,*rest) for stage,*rest in catalogue.erase_guards for replica in range(32)) + catalogue.source_identity = codebook_identity(catalogue) + catalogue.old_code_bits = old_bits + catalogue.charts = {catalogue.owner_chart(call,role) for call in pooled['calls'] for role in range(659)} + catalogue.charts.update(r.chart for r in catalogue.requests.idles) + catalogue.charts.update(r.chart for r in prototypes if r.kind == 'COPY') + catalogue.receipt = lambda: receipt(catalogue) + return catalogue, ReplicaTopology(catalogue, old_topology) + + +@dataclass(frozen=True) +class SourceHandle: + schema: str + identity: str + code: int + + +def source_handle(catalogue, identifier, common, low): + return SourceHandle(VERSION, catalogue.source_identity, catalogue.codes.encode(identifier,common,low)) + + +def resolve_handle(catalogue, specifications, handle): + need(isinstance(handle,SourceHandle) and handle.schema == VERSION and + handle.identity == catalogue.source_identity, 'exact pooled source codebook identity') + need(getattr(specifications,'catalogue',None) is catalogue, 'exact Specifications codebook context') + return specifications[handle.code] + + +def receipt(catalogue): + from catalogue import canonical + digest = sha256() + kinds = Counter() + for request in catalogue.requests: + kinds[request.kind] += 1 + digest.update((canonical(request.record())+'\n').encode()) + return {'physical_requests': len(catalogue.requests), 'replicas': 32, + 'request_kinds': dict(kinds), 'rank_histogram': dict(catalogue.profile), + 'ERASE_guards': len(catalogue.erase_guards), 'binding_sha256': digest.hexdigest(), + 'source_identity': catalogue.source_identity, 'schema': VERSION} + + +def codebook_identity(catalogue): + import low_codes + fields = [VERSION, catalogue.q, catalogue.dimension, len(catalogue.requests), + catalogue.codes.bits, adapter.REQUEST_DIGEST, + sha256((HERE/'inputs/moves.json').read_bytes()).hexdigest(), + sha256(Path(low_codes.__file__).read_bytes()).hexdigest()] + return sha256(json.dumps(fields,separators=(',',':')).encode()).hexdigest() diff --git a/research/r437-pooled-native-interface/verify.py b/research/r437-pooled-native-interface/verify.py new file mode 100644 index 0000000000..4a470e1e99 --- /dev/null +++ b/research/r437-pooled-native-interface/verify.py @@ -0,0 +1,42 @@ +"""Read-only, source-authenticated replay; no foreign Git objects required.""" +from hashlib import sha1, sha256 +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +sys.path.insert(0,str(HERE)) +from check_transport import need +from check_interface import run + +def regular(path): + need(path.is_file(), 'regular source file: '+str(path)) + need(all(not part.is_symlink() for part in (path,*path.parents)), 'no source symlink') + +def authenticate(): + sources = json.loads((HERE/'SOURCES.json').read_text()) + need(sources['base_commit']=='20ecf2891d80b5acf18d980b2164fb44ea7faa90','canonical base') + for row in sources['files']: + if row['usage']!='input': + continue + path=ROOT/row['path']; regular(path); data=path.read_bytes() + need(sha256(data).hexdigest()==row['sha256'] and + sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest()==row['git_blob'], + 'canonical source identity: '+row['path']) + expected=set() + for row in sources['retained']: + path=HERE/row['path']; regular(path);data=path.read_bytes();expected.add(row['path']) + need(len(data)==row['bytes'] and sha256(data).hexdigest()==row['sha256'] and + sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest()==row['git_blob'], + 'retained source identity: '+row['path']) + observed={f.relative_to(HERE).as_posix() for f in (HERE/'inputs').rglob('*') if f.is_file()} + need(expected==observed|{'adapter.py','check_transport.py','pooled_compiler.py'},'complete retained source inventory') + need('--write' not in sys.argv,'registered verification is read-only') + +if __name__ == '__main__': + authenticate() + result=run() + need(json.loads((HERE/'RESULT.json').read_bytes())==json.loads(json.dumps(result)), 'exact frozen interface receipt') + print(json.dumps(result,sort_keys=True)) + print('PASS_POOLED_REPLICA_NATIVE_INTERFACE')