diff --git a/research/r437-oq4-caller-binding/.gitattributes b/research/r437-oq4-caller-binding/.gitattributes new file mode 100644 index 0000000000..7e7e02e54f --- /dev/null +++ b/research/r437-oq4-caller-binding/.gitattributes @@ -0,0 +1,2 @@ +inputs/** -text -diff +R437-* -text -diff diff --git a/research/r437-oq4-caller-binding/BINDING.md b/research/r437-oq4-caller-binding/BINDING.md new file mode 100644 index 0000000000..f78077923c --- /dev/null +++ b/research/r437-oq4-caller-binding/BINDING.md @@ -0,0 +1,228 @@ +# The current source-to-physical boundary + +Chris R / Clear1nsight, with substantial OpenAI Codex assistance. Apache-2.0. + +## 1. Exact source delta + +Let S_old be PR3690's R437 source at36ff441 and S_new be the a24f9ff/OQ4 +source. Both catalogues are compiled with the same canonical selected compiler, +with its exact661-to659 role adaptation. The adapter retains the source checks; +it does not accept a new catalogue merely because its matrices have equal rank. + +The complete ordered records differ exactly at + + 18189,18464,18920,19854,20212,27776,27777. + +The five MOVE records are stage6, helper role644, family209. Their host chart +moves from axes22..29 to30..37. Their residual ranks and source event ordinals +are unchanged. The IDLE records retain their source ordinals and native family +charts, but change their unused-axis projectors from ranks34/34 to26/42. +Thus they move32 paid children from34 to26 and32 from34 to42. Counts and rank +mass are unchanged. This calculation includes owner routes: accepting only the +new histogram would miss five actual source changes. + +All COPY records, their identity common charts, ERASE guards and source ordinals +are unchanged. This statement concerns the complete ordered request records, +not equality of incoming dirty payloads. The latter retain the all-function +COPY contract proved in PR3936/3950. The selected source's original661-role +Catalogue still rejects the new source; our adapted Catalogue authenticates +the complete current word/template/profile/digest before use. + +The old-data positive control enforces its own exact old word/template/profile +and ordered digest using the same retained compiler. It is not an independent +implementation of that compiler. A discovery-only exploratory run determined +the new digest; the committed adapter has no discovery or disabled-guard path. +Replays recompute the catalogue against the frozen digest and reject the old +digest on new data. SOURCES.json records complete source identities. + +## 2. The real two-level generated program + +Choose current native IDLE27776 and common COPY1603. The first is the actual +new rank26 idle in window6/family209; the second is stage0/position22014, +frame515/centre475. Each source code comes from the full current Specifications +table, its actual chart and the canonical LowCodes scheme. No two-label +replacement vocabulary or synthetic ancestor is used. + +For each request choose low matrix equal to the inverse of its actual +preparation modulo3. Native preparation includes the family chart. Hence the +compiled unweighted projector is the leading-coordinate projector of its +stated rank. With w=1, zero high fields and root unit2, all incoming diagonal +weights remain2. Diagonal scalar conjugation leaves the projector unchanged; +every good pivot equals1. The required good child coefficients therefore equal +2. Coordinates0 and90 in the second child test that independently stated +identity through the actual generated callback. + +The exact generated steps are + + ROOT width2048, unit2, depth0 + -> (good, actual IDLE27776 code, rank26): width832, depth1 + -> (good, actual COPY1603 code, rank7): width91, depth2. + +Indeed832=26 floor(2048/64), and91=7 floor(832/64). Both widths exceed the +64 cutoff; neither step is merely a terminal descriptor example. The encoded +program contains the two actual source codes, ranks, flags and parent/child +widths. The current COPY prefix is appended after the frozen ancestor field. +The old rank34 label paired with the current ancestor code rejects at +`actual selected rank`; the other actual COPY label in the current prefix +rejects at `original global raw-field code`. + +This is an admissible generated source *grammar* instance, not a claim that +the root's native family209 is literally followed by a stage0 COPY in one +flat global schedule. The outer IDLE central recursive child runs another +selected node, which has its own local source vocabulary. We test this nested +descriptor/caller boundary, while the complete recursive node body is not run. + +## 3. What the physical protocol establishes + +For a complete source call of parent width n and child width c, the good +chunks are the first c head atoms and their reflected tail partners. The +existing Layout.child_extents emits + + B'=B, G'=G*A^(2(n-c)), S'=S, + +with U in its separate row port. Thus + + Z*U*B'*G'*S'*A^(2c) = Z*U*B*G*S*A^(2n). + +This is the whole-packet volume identity; it does not discard spectator +addresses or replace U by U*B. The actual fixture checks the encoded grants + + (prefixes,U,B,G,S) = (2,11,2,5*3^2432,3) + and then (2,11,2,5*3^3914,3). + +Both equal prefixes are generated by the canonical directory producer with +their separate ordinals. It is not a deduplicated header set. + +Machine.prepare_child checks that the event names the same parent Program +object, current source code and active geometry code. It copies current, +directory, extended program, prefix count, U and all three extents into fixed +handoff ports. CALL writes the exact successor PC and numerical-role labels, +parks the parent streams and numerical state, then installs the child grants. +The tested current source codes use this unchanged path. + +On protected complete_return, the child frame is closed before inverse +parking. The result stays in its distinct output port while numerical and +stream parents restore; it is then transferred to current. Two nested returns +recover the child-parent successor4 and root successor1, without replaying a +prefix. Snapshot checks cover exact numerical objects/bytes/heads and every +canonical role. Additional audits include erased-but-allocated numerical slots +and template heads; clearing live content alone is insufficient. + +Within the child parent, the actual COPY dispatch preserves stage475, clones +into copy_source, transfers the returned residual output to private stage659, +and feeds all 63 actual literal XOR readers before clearing it. Each reader +uses the unchanged physical XOR dispatcher on two complete reduced 23-bit +prefix fibres. Source and private output remain immutable through all 65 +source events22014..22078. This tests ownership, actual private-result +consumption and the physical disposal scan. + +There is also a uniform consumer implication, independent of the test bits. +Let x be the borrowed source function and z the correctly completed residual +result on the same complete packet. For arbitrary, possibly correlated target +functions y_t, the63 literal readers produce y_t XOR z, preserve x and z, +and leave every other staged role unchanged. This follows by induction over +the actual65-event interval: the source/private roles never appear as XOR +destinations, every target occurs once, and the last event is the matching +ERASE. Thus a correct completed residual is consumed without another residual +call or reversed uncompute. If X(V) is the completed physical XOR tariff, +retain the full bill `C_residual +63*X(V)+C_copy/transfer(V)+C_disposal(V)+gamma_window`. +Only under the retained linear XOR/copy/transfer contracts and admitted +metadata bounds does the extra consumer work simplify to O_q(V). The probe +tests this actual consumer using controlled z; it does not supply z's complete +residual contract or erase its cost. +The transported equality guard itself is checked over the complete literal +controller census; the controlled bit transformation is not a claim that it +equals the semantic COPY map. Three malformed physical gates reject before +handoff mutation, followed by exact parent/scratch checks. + +These checks establish actual bound protocol execution at the finite stated +context. **They do not establish a full residual body or global node.** The +input is46 bits with an explicitly controlled fibre23, outputs are declared test stimuli, stock11 is a controlled +fixture, and the receipt's global macro count is0. The complete volume at +the encoded root would be660*3^4096 bits. Native gather/route, the adapter +sweeps, complete primitive calls and the ordinary padded wrapper are not +executed on that volume by this probe. + +## 4. Uniform caller substitution: the remaining hypotheses + +A complete production source binding would use the actual current topology, +Specifications and SelectedBinding in macro_code.compile_node. Its loop order +is schedule, replica, low class, literal event. That finite compiler accepts +only q-dependent labels and emits the same fixed block vocabulary for every +input width/precision; all 64-dimensional low classes are a fixed finite +set for a fixed q. The full expansion is effective but enormous. This package +does not pretend that a sampled class is that complete emitted tuple. + +The source-relative structural implication is as follows. Suppose each emitted +NODE, GATHER_ROUTE, RESIDUAL_BEGIN, ordered sweep/leaf, CHILD, route/scatter, +XOR, bridge and exchange has its stated complete Boolean/ownership contract +on admitted encoded inputs; suppose the numerical source callback supplies +the actual source-bound coefficients at every frozen history; and suppose +the existing parking codecs preserve the encoded parent at each matched cut. +Then induction over the finite emitted word and decreasing-width recursive +tree gives the current caller contract. COPY introduces an owned clone and +the transported guard clears its owned result; it never projects arbitrary +dirt away. At a recursive cut the capsule volume identity above supplies +exactly the complete child input, and protected return supplies its one +substitution. The five chart changes and two idle changes are consumed by +the current authenticated bindings, rather than inferred from rank alone. + +This implication is not an independent proof of its primitive, callback, +stock or source-level premises. The main physical-contract map still marks +the inherited universal refinement partially reviewed. Its archival presence +does not certify the all-width current program. A uniform source/native/router +cohort must discharge or explicitly retain these premises and connect all +constructors at one source; the bounded probe does neither by itself. + +## 5. Complete cost boundary + +Let T(j,w) be the inherited uniform completed-child cost per *complete payload +bit*, including coefficients, owned output, restoration and head returns. +PR3950 supplies the rank7 low-class bound + + delta7 <= min(1,448*(q-1)/(q*(q-2))). + +Retaining its completed good/fallback contracts, the residual cover bill is + + T(7f,w)+delta7*49911*max_(1<=j<=f)T(j,w) + + A_q*(f+leaf_toll(w)+1) + gamma_orig/(N*v). + +Here gamma_orig includes encoded source/history/Count preparation, transfer +and cleanup not already charged by completed primitives. The initial clone, +output commits and final disposal remain paid. Gather/route/scatter and the +containing node's producer/wrapper work remain additional. Neither N low +classes nor repeated high prefixes create an extra coarse-child factor; +normalization is by the full complete cover volume N*v. + +At source-admitted q>2^80 the bad fraction fits10^-16. The familiar cheap +local toll additionally needs the canonical root/history, numerical preparation +and backend reserve arguments. This package does not supply them merely by +changing the request digest. The fixture's q=3 is not an admitted exponent +parameter and its finite parking instruction counts are not an asymptotic +constant. No ordinary/native/router tariff is inferred from them. + +For storage retain the full logical frame envelope M_j, the fixed owned +role/backend inventories, current and protected output, and the complete active +parking stack. Only if the inherited admitted bounds prove + + sum_j M_j <= C_q*V_root + F_q + +does the same fixed-role source lowering have O_q(V_root)+F_q visited cells. +All physical inventories must include cleared-but-visited backing, markers and +templates. A live-state snapshot or peak10 scratch leases does not prove +this uniform bound, the sharp logical coefficient11, or a reserve of nine +family packets. Interruption recovery is also outside this successful-return +contract. These are precise remaining obligations, not costs set to zero. + +## 6. Attribution and next useful result + +The adapter comparison extends zxv/PR3690's exact source adaptation and +controlled return. The physical protocol, source compiler and proofs remain +David Arias/Jose Manuel/ywz65 and their retained lineage; R437/OQ4 remains +ai-nanachi and credited predecessor work. PR3936/3950 supply the immediate +all-function and conditional-cost boundary. Full notices are retained. + +The next substantive result is the complete production constructor/refinement +join at this authenticated current catalogue, including actual native/router +consumers, original-width stock and root/precision constraints. Another finite +controlled return would add coverage, but would not discharge that join. diff --git a/research/r437-oq4-caller-binding/CATALOGUE.json b/research/r437-oq4-caller-binding/CATALOGUE.json new file mode 100644 index 0000000000..ec1daa2193 --- /dev/null +++ b/research/r437-oq4-caller-binding/CATALOGUE.json @@ -0,0 +1,447 @@ +{ + "changed_request_count": 7, + "changed_requests": [ + { + "current": [ + "MOVE", + 6, + 19241, + 644, + 209, + 0, + 251, + "5f584c3ca2a31e3c54aac81967f19d8b36d3b8074c262261e71fc98c23bb0908", + 2, + [ + "host", + -1, + -1, + [ + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37 + ] + ], + "owner", + null + ], + "identifier": 18189, + "old": [ + "MOVE", + 6, + 19241, + 644, + 210, + 0, + 251, + "5f584c3ca2a31e3c54aac81967f19d8b36d3b8074c262261e71fc98c23bb0908", + 2, + [ + "host", + -1, + -1, + [ + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29 + ] + ], + "owner", + null + ] + }, + { + "current": [ + "MOVE", + 6, + 20333, + 644, + 209, + 251, + 304, + "827bb4af0023fba3ab910662485f10f4ce7f03766cf098c605fe5a6ca2a88767", + 2, + [ + "host", + -1, + -1, + [ + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37 + ] + ], + "owner", + null + ], + "identifier": 18464, + "old": [ + "MOVE", + 6, + 20333, + 644, + 210, + 251, + 304, + "827bb4af0023fba3ab910662485f10f4ce7f03766cf098c605fe5a6ca2a88767", + 2, + [ + "host", + -1, + -1, + [ + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29 + ] + ], + "owner", + null + ] + }, + { + "current": [ + "MOVE", + 6, + 21380, + 644, + 209, + 304, + 490, + "66c3f20f6dd032fea48d25c9e14cb6f514d33720772ff3738910ce4978bf4e69", + 2, + [ + "host", + -1, + -1, + [ + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37 + ] + ], + "owner", + null + ], + "identifier": 18920, + "old": [ + "MOVE", + 6, + 21380, + 644, + 210, + 304, + 490, + "66c3f20f6dd032fea48d25c9e14cb6f514d33720772ff3738910ce4978bf4e69", + 2, + [ + "host", + -1, + -1, + [ + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29 + ] + ], + "owner", + null + ] + }, + { + "current": [ + "MOVE", + 6, + 23946, + 644, + 209, + 490, + 635, + "5a04a4c748ea57056e0f1b2130215e03dd892ced3ea2ce33891996d4b0f33435", + 1, + [ + "host", + -1, + -1, + [ + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37 + ] + ], + "owner", + null + ], + "identifier": 19854, + "old": [ + "MOVE", + 6, + 23946, + 644, + 210, + 490, + 635, + "5a04a4c748ea57056e0f1b2130215e03dd892ced3ea2ce33891996d4b0f33435", + 1, + [ + "host", + -1, + -1, + [ + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29 + ] + ], + "owner", + null + ] + }, + { + "current": [ + "MOVE", + 6, + 24888, + 644, + 209, + 635, + 1, + "13c3d4f57cea761c1d7b88abb26da0ca4001059c0f047f09bf2c16e60ecef521", + 1, + [ + "host", + -1, + -1, + [ + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37 + ] + ], + "owner", + null + ], + "identifier": 20212, + "old": [ + "MOVE", + 6, + 24888, + 644, + 210, + 635, + 1, + "13c3d4f57cea761c1d7b88abb26da0ca4001059c0f047f09bf2c16e60ecef521", + 1, + [ + "host", + -1, + -1, + [ + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29 + ] + ], + "owner", + null + ] + }, + { + "current": [ + "IDLE", + 6, + 6, + 209, + 209, + 2, + 8, + "6c38408d019ad769697cc6a8a70093cc45251d8fc1244e8c303ef4e0becdbab2", + 26, + [ + "family", + 98, + -1, + [] + ], + "owner", + null + ], + "identifier": 27776, + "old": [ + "IDLE", + 6, + 6, + 209, + 209, + 2, + 8, + "9710b96b4d5c382dbdb44bda4ccdb9e2f33217f4065ae9056958de95a9953db5", + 34, + [ + "family", + 98, + -1, + [] + ], + "owner", + null + ] + }, + { + "current": [ + "IDLE", + 6, + 6, + 210, + 210, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 99, + -1, + [] + ], + "owner", + null + ], + "identifier": 27777, + "old": [ + "IDLE", + 6, + 6, + 210, + 210, + 2, + 8, + "9710b96b4d5c382dbdb44bda4ccdb9e2f33217f4065ae9056958de95a9953db5", + 34, + [ + "family", + 99, + -1, + [] + ], + "owner", + null + ] + } + ], + "current": { + "base_labels": 540, + "binding_sha256": "cbfea55f5cd0b74a2a0d4292ad0139d2b5bb73127951127698030bc90c73c532", + "canonical_ERASE_guards": 81, + "canonical_requests": 28233, + "chart_labels": 1235, + "full_paid_requests": 903456, + "rank_histogram": { + "1": 380160, + "2": 400864, + "26": 32, + "3": 22176, + "4": 26592, + "42": 384, + "5": 29376, + "6": 17376, + "7": 26496 + }, + "replicas": 32, + "request_kinds": { + "COPY": 81, + "IDLE": 1998, + "MOVE": 26154 + } + }, + "full_GL64_low_classes_executed": false, + "literal_opcode_counts": { + "0": 836928, + "1": 6971904, + "2": 2592, + "3": 2592 + }, + "old": { + "base_labels": 540, + "binding_sha256": "0fb70d6838583f2f439a8704eb5dba84ce9dbd231d91f140da13440b680d73aa", + "canonical_ERASE_guards": 81, + "canonical_requests": 28233, + "chart_labels": 1235, + "full_paid_requests": 903456, + "rank_histogram": { + "1": 380160, + "2": 400864, + "3": 22176, + "34": 64, + "4": 26592, + "42": 352, + "5": 29376, + "6": 17376, + "7": 26496 + }, + "replicas": 32, + "request_kinds": { + "COPY": 81, + "IDLE": 1998, + "MOVE": 26154 + } + }, + "rank_profile_delta": { + "26": 32, + "34": -64, + "42": 32 + }, + "scope": "Every literal source/controller site; all-low numerical emitter remains a quantified dependency", + "stale_digest_control": "REJECTED", + "status": "PASS_FULL_OQ4_SOURCE_TOPOLOGY_AND_CHRONOLOGY" +} diff --git a/research/r437-oq4-caller-binding/COORDINATION.md b/research/r437-oq4-caller-binding/COORDINATION.md new file mode 100644 index 0000000000..f9b31d10bf --- /dev/null +++ b/research/r437-oq4-caller-binding/COORDINATION.md @@ -0,0 +1,48 @@ +# Session checkpoint and overlap + +Explicit donor assignment, canonical investigation +https://github.com/CrocSwap/integer-mult-bounds/pull/3950#issuecomment-6261156262. +Session began2026-10-19 06:28:13 UTC; approximately60 minutes, final quarter +reserved for verification/publication. Main fetched at entry, the06:53 proof +checkpoint and before submission. Scientific base remains20ecf2891d80b5acf18d980b2164fb44ea7faa90; +priority revision6 and the selected frontier remain unchanged. No task reroll, +merge, closure of others' work, or selected-frontier edit. + +PR3950 CI checked first: scientific/current head364701494bc3d726806a15d4d1d4b547c1e0f9d5, +run39209275255 completed success including registered replay and input immutability. +Current dependency heads rechecked07:01 UTC: + +| PR | Head | Relationship | +|---|---|---| +|3647|a24f9ff95c12fd0b6792e3f710569237efd72db2| Actual current OQ4 source | +|3690|03c141ef1fd372cf42951488767537e55675c072| zxv's predecessor source adapter and controlled rank34 return | +|3958|1d0650806c29ec6fea19c0d73aca3fab4c2930d1| Rohan Arun's conditional endpoint composition; retains physical/source premises | +|3959|babd2e36471422cd3e97f912a5cf2846da52a222| Rohan Arun's pooled replica owners; native emission not run at those owners | + +The latter two were read as newer overlapping claims, not admitted suppliers. +This package binds unpooled a24f9ff/OQ4. Its replica-owner symmetry checks do +not cover 3959's cross-replica owner map. It neither reprices those endpoints +nor changes the selected frontier. The physical board2319 was refreshed live; +existing1166 handoff context and targeted R437 PRs were consulted. Coverage is +partial, not a novelty certificate. + +The passing23-bit baseline is preserved locally under +execution-evidence/oq4-caller-session/baseline23. The full passing46-bit replay +before the additional explicit parking-empty assertion is also preserved. +Final registered execution and exact current hashes are in VALIDATION.json and +REPLAY.log. Documentation and publication checks are separate from scientific +execution. No frozen predecessor file or synced project source was edited. + +Stable source ordinals do not authorize retagging a predecessor's frozen +program/history. LowCodes supplies finite labels whose meaning comes from the +compiled catalogue. This test generates fresh history at the authenticated +current binding; it does not claim an arbitrary old-source program is portable. +All 132 canonical inputs and seven retained inputs are byte-pinned. The latter +were additionally compared with their exact origin Git objects; decompressed +geometry is byte-identical between old/new inputs. + +Credit zxv, ai-nanachi, Ali Romman, Sagar Thakrar, David Arias, Jose Manuel, +ywz65, Nick Petalas and the complete retained lineage. New work by Chris R / +Clear1nsight with substantial OpenAI Codex assistance; no independent human or +formal-kernel review. Outcome: partial source/protocol/consumer result; complete +GL64 production cohort and uniform supplier admission remain open. diff --git a/research/r437-oq4-caller-binding/PHYSICAL.json b/research/r437-oq4-caller-binding/PHYSICAL.json new file mode 100644 index 0000000000..6925f70e5e --- /dev/null +++ b/research/r437-oq4-caller-binding/PHYSICAL.json @@ -0,0 +1,150 @@ +{ + "ancestor_record": [ + "IDLE", + 6, + 6, + 209, + 209, + 2, + 8, + "6c38408d019ad769697cc6a8a70093cc45251d8fc1244e8c303ef4e0becdbab2", + 26, + [ + "family", + 98, + -1, + [] + ], + "owner", + null + ], + "ancestor_request": 27776, + "both_sweeps_ADD_passes_per_f": [ + 13444, + 9872 + ], + "catalogue": { + "base_labels": 540, + "binding_sha256": "cbfea55f5cd0b74a2a0d4292ad0139d2b5bb73127951127698030bc90c73c532", + "canonical_ERASE_guards": 81, + "canonical_requests": 28233, + "chart_labels": 1235, + "full_paid_requests": 903456, + "rank_histogram": { + "1": 380160, + "2": 400864, + "26": 32, + "3": 22176, + "4": 26592, + "42": 384, + "5": 29376, + "6": 17376, + "7": 26496 + }, + "replicas": 32, + "request_kinds": { + "COPY": 81, + "IDLE": 1998, + "MOVE": 26154 + } + }, + "coefficients": [ + 2, + 2 + ], + "complete_GL64_payload_executed": false, + "controlled_fibre_bits": 23, + "controlled_payload_bits": 46, + "copy_record": [ + "COPY", + 0, + 22014, + 475, + 28416, + 515, + 0, + "17d00db47184bcb2068b1b93977470b022193454b051fb759ed9f725940820f9", + 7, + [ + "identity", + -1, + -1, + [] + ], + "common", + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ] + ], + "copy_request": 1603, + "counts": { + "calls": 2, + "macros": 0, + "residuals": 2, + "returns": 2 + }, + "descriptors": [ + [ + 0, + 604846014899746145046617353091860861623039936840942280044214288652750378387933182784721747357075167426142582512494798424400943994544615504301957233101837796306684228853138102766503480935058364428628337481133796458002565353101226013684063315866030854545822321213092392935973605178681662370468400964850292493704106750879254324553668422041600642566687735180242724382442992195787383160057067145775887221211682081587413730553598024316381078131901571932038256940922394701798958043136949036379136129869709810734628327595991429596496322656393123218570767917600883436971097370292588595773601963883262799896262434434036004294490671943472701877206957585566929768176495004614923648743947641115249572709212976577410090930125411366862084907422406174948410670997292950382800910203744149304329439043729910632651626032062169023135131509455925748353674198813931836752222788444098631062780618368767148161343353698853792622420640574588594656922568640601879314332730130980925674725238292466081514759969908628007712415569424450852185584727406579097343627499896946011682281143804398922704040001778862636124570214528294552735453489724720156895076416002784120059939301475774077017851421684647078863932473241170015572119726085263929900692263938546382160210762014166246781377325343690504151163883526990323175283424786164238583591823713697859891264114089197156534487102298626222613379128691540318658598276036039784261397667699088948447392946318877885105555366535850092639237885962982481345981464550979628862109892411870767477933139803349544232367707846436735502935091262498863651939504149118177351276734565972684245747898619986731277348288169617009772401383002336785085023039812253646035627011038217026136138065974651979343560279521676615136238011892913280559921688904659999670891693522252972121510848304865580238403726277803435505905069186390677241704260583724762892662109468261686186683597528130302844116591884150767041708396869526865935793893659596763374476358213322441064930471121484, + 26, + 0, + 0, + 0 + ], + [ + 0, + 34921473926974537370065085026494418688350264890039707192590342764687770289787049135527479977026842431353154386863361226010797132269677522110320068109860772834110002692929537370144409730127505097289663512626128778925385586503547690034761494106106378967830958752271078532625245252769123554763219456043931419108700848444974260713597580635636474436501394782252306190294917315327837328749963017720313868124495532803489071055188756908764819614849754796508735559513653233981988195181994796639839738189030020687775332291822518982121983707383246764067149138021354215502270952405148611510662530282061949409118134278709314683085667020219263719485628802184730875670156300907484816367221679013406278673444280394188403425043878913006319901761650035024314886962591347771851811927849387675044658107749172654320146586418094341307988442563664630214274780006084445485376533072746151120855877187986135120688656621756260958989032330796756995837171676198855007267540805665377621645000683380311162290626793820821666826780790244270319240710228326575887698821401295222050314691202478482765038360925278441637923126370147064599178583963133933965415968098944313787224864202650212760239841126364799713928162918428618851998396208483361097741953277573643876070262278495496198657344947382621261040640564053737560020733996188635240557038519111225098335316842116978453623213859961453605324392310109891188784897134495818999483103276316544000650250720905851739129691434868112480782046908420520217259701003365634736511417840433473944617719384392321305297192057289267846047144310816823469443666069062480556651323835989227305098231983925447865296731264043060575337065040979126009003535629471722816482219137882490904730111773652239888331121689404161927808808254382694452708317424889297355862070128283811986364548599504799155565719211999150835337590457655098823271639691614678082785050642201658342272219496817377602203534540582088623525885724449484499077895792449020612485079246049740606604598361196, + 7, + 0, + 0, + 0 + ] + ], + "forward_adapter_commands": [ + 6722, + 4936 + ], + "index_bank_capacity": 1024, + "literal_COPY_window_events": 65, + "literal_COPY_window_sha256": "ff325204d6c6a9465b0d0073a500fce1d6b121d6c352cce9097c0a6d3932bf3b", + "numerical_decode_disabled": true, + "parking_charge": { + "moves": 6774360, + "reads": 8700780, + "steps": 4350390, + "writes": 3387184 + }, + "peak_scratch_leases": 10, + "private_result_consumers": 63, + "rejected_gates": [ + "wrong_parent", + "foreign_program", + "wrong_source" + ], + "residue_bank_capacity": 131072, + "scope": "Actual source-bound nested physical protocol; controlled child outputs, not complete GL64 residual execution", + "semantic_rejections": [ + "obsolete_rank34", + "foreign_COPY_prefix" + ], + "status": "PASS_ACTUAL_OQ4_NESTED_PHYSICAL_PROTOCOL", + "stock_is_controlled_fixture": true, + "widths": [ + 2048, + 832, + 91 + ] +} diff --git a/research/r437-oq4-caller-binding/R437-LICENSE b/research/r437-oq4-caller-binding/R437-LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/r437-oq4-caller-binding/R437-LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/r437-oq4-caller-binding/R437-UPSTREAM-NOTICE.md b/research/r437-oq4-caller-binding/R437-UPSTREAM-NOTICE.md new file mode 100644 index 0000000000..9b519b904d --- /dev/null +++ b/research/r437-oq4-caller-binding/R437-UPSTREAM-NOTICE.md @@ -0,0 +1,71 @@ +# Notice + +Apache-2.0 (`LICENSE`, copied from #493's package). Prepared by eumemic with substantial Anthropic Claude +assistance. + +## New in this package + +- `code/gen_p3.py` (the generator of the punctured word: the L3 skeleton of #543 restricted to the live lines, the + pseudo-target totals, the phase-A mini-nodes and extra carriers), `code/pwordl.py` (word builder for a live subset + of the 120 lines; output in the bitE8/1 layout with the `ports_geom` and `punctured` fields introduced by #545), + `data/bitE8mut-p111.json.gz` (the word), `data/punct.json` (its frozen parameters), `discovery/choose.py` and + `discovery/search.py` (the nomination of P and of the parameters; not run by `verify.sh`). +- `code/gen_p3.py` carries `derive`, `ex_part` and `plan_thirds` from #543's `code/gen_l3.py` (eumemic), and + `data/plan-l3.json` is #543's CP-SAT plan, unchanged. `code/nodeopt.py`, `code/planio.py`, `code/mutants.py`, + `code/mutrec_b.py` and `code/provenance.py` are #543's files, unchanged. +- `code/xcheck_p.py`: #543's independent checker `code/xcheck.py` with nine listed edits for v <= 120 live labels + (root-line enumeration of the lattice, frame closure and target frames over the live labels) and a new part T (the + frame and COPY rank of every retained total at the scatter, and whether it is the hyperplane of a punctured line). +- `code/mutants_p.py` (punctured-design controls), `code/adapt9p.py` (#510's nine-stage files parameterised for + v <= 120 and any copy ranks, the way #545's `adapt.py` parameterises #493's eleven-stage files), `code/cited.py`, + `code/receipt_kappa.py`, `code/summary.py`, `verify.sh`, `EXPECTED.json`, `DEPENDS.json`, `requirements.txt`, + `data/complex-b.json`, `data/selection9-p111.json` and `data/hosting11-p111.json` (frozen nominations of #442's + hosting programme, rediscovered by `verify.sh`), `.github/workflows/e8-bit-p111.yml`. + +## Vendored, byte-identical (git blob ids in `SOURCE-pr*.json`, checked by `code/provenance.py`) + +- **PR #510 (DreamingOfClouds, with Claude Opus 5.5 via Claude Code), commit 64edee1** (`vendor/pr510/`): the same 19 + files as #543's package (#510's nine-stage chain with the files it vendors from #463, #443, #442 and #315, and #503's + R480 word). Their notices are listed in #543's NOTICE and in the files. +- **PR #545 (DreamingOfClouds, with Claude Opus 5.5 via Claude Code; draft), commit 376426f** (`vendor/pr545/`): + `code/adapt.py` and `code/punct_cfg.py`, run unchanged on this package's word; `data/bitE8mut-v111-r489.json.gz`, + `data/hosting-v111-r489.json` and `EXPECTED.json` (a control). +- **PR #548 (Dugongue), commit 66dbc2b** (`data/complex/pr548/`): `EXPECTED.json` and `evidence/EXACT-ASSEMBLY.json`. +- **PR #544 (chafreaky, with OpenAI Codex assistance), commit 4858bb3** (`data/complex/pr544/`): `EXPECTED.json` and + the Linux exact-assembly receipt. +- **PR #535 (icekylinx, with GPT-6 Astra assistance), commit 8b758a1** (`data/complex/pr535/`): `EXPECTED.json` and + `evidence/audit/EXACT-ASSEMBLY-PR493.json`. + +## Used from main, unchanged (pinned in `DEPENDS.json`) + +- `research/e8-bit-carrier-skeleton` (PR #493, eumemic): the skeleton modules and D4 partition the generator imports, + #370's checker (run here in #545's v <= 120 form), the official cohort checkers, `gram_frames.py`, the record + exporter, the geometries and the eleven-stage chain that #545's `adapt.py` parameterises, #442's hosting programme, + the R489 word, the control receipts and #315's engines. +- `research/direct-delivery504-global/EXPECTED.json` (PR #531, icekylinx): its complex b and kappa. + +## Cited, not rebuilt + +Complex coarse savings in `data/complex-b.json`, each bound to its PR's receipt by `code/cited.py`: PR #548 (primary; +open), PR #544 and PR #535 (open), PR #531 (merged), and PR #484, #471 and #458 (controls). + +## Ideas used + +- PR #545 (DreamingOfClouds): the punctured-star unit. Nine lines are neither sources nor targets; each retained total + is a pseudo-target that reads what the removed target would read, at frame rank 7, so the decoder constant is 63; + the rank-mass identity with v and the decoder constant as parameters; the parameterisation of the hub chain. +- PR #543 (eumemic): the R420 L3 skeleton with keepers read by targets and rewritten in phase B. +- PR #493 (eumemic), PR #503 and #510 (DreamingOfClouds), PR #425 (Zhihao Chen / jacklightChen), PR #370 (Dylan Crow), + PR #472, #445, #443 (chafreaky), PR #442 (DaysSky), PR #463 and #315 (DreamingOfClouds), PR #386 (Zhihao Chen): the + skeleton, the scalar-interface lemma, the format, and the pricing pipelines. +- PR #523 (icekylinx): the puncture pattern on the complex side, cited by #545. +- Jacob Sussman introduced the E8 unit. + +R437 composition: Ali Romman (@aliromman), with substantial OpenAI Codex assistance, authored the public1043 helper470 source-boundary deletion. Its exact canonical-main package and NOTICE are retained in public1043/. The new contribution here composes that credited deletion with the independently validated helper464 GL, then reconstructs actual owners, full invoice, independent checks and portable replay. + +Sagar Thakrar (thakrarsagar), PR3700 Open question4, proposed the exact +window6 two-leftover coalescing used by this follow-up. No code from that +PR is imported by the author pipeline; root independently replayed its +hosting and price engines. Full owner/template/invoice regeneration and +packaging used substantial OpenAI Codex assistance. All prior credits and +Apache-2.0 notices remain in place. diff --git a/research/r437-oq4-caller-binding/RANK26-COST.md b/research/r437-oq4-caller-binding/RANK26-COST.md new file mode 100644 index 0000000000..15809a6154 --- /dev/null +++ b/research/r437-oq4-caller-binding/RANK26-COST.md @@ -0,0 +1,118 @@ +# The actual rank26 ancestor: local semantics and conditional full bill + +The new IDLE27776 has rank26. Binding it to the numerical/physical grammar is +not enough to infer a rank7-only caller budget. This note specializes the +original good/fallback construction to that actual ancestor and keeps both +the containing-node work and all inherited physical premises visible. + +## Uniform local semantic domain + +The current idle base is the diagonal projector on its26 unoccupied axes in +family209. Its chart is the actual family chart at port98. For any admitted +odd prime q, this chart and a split image/kernel basis are invertible over +Z/q^w. Right multiplication of the complete cover matrix g by this fixed +preparation is a bijection of its low GL64 classes and of all high lifts. +The requested projector therefore has the form Q=G E26 G^-1 in a suitable +source-bound chart. This identity applies to pullbacks of every Boolean +payload, with arbitrary spectators and correlated dirt. + +Ancestor-generated unit weights form a diagonal H. Each leading principal +minor of H Q H^-1 equals the corresponding minor of Q. Good/fallback +classification is consequently shared by every current high lift and every +incoming unit-weight context. It is not a new failure event for each column, +prefix, COPY label or recursion depth. + +## Rank26 bad-low-class fraction + +For I={0,...,k-1}, k<=26, Cauchy--Binet and Jacobi give + + det(G)*det(Q[I,I]) + = sum_(J subset [26], |J|=k) (-1)^(sum I+sum J) + det G[I,J] * det G[I^c,J^c] = F_k(G). + +Each polynomial F_k has degree at most64 and evaluates to1 at G=I, in every +residue field. Their product is nonzero with degree at most64*26=1664. +The elementary finite-field polynomial root bound gives an unconditional +zero fraction at most1664/q in independent matrix entries. Conditioning on +invertibility divides by + + Pr(GL64) = product_(i=1)^64(1-q^-i) > 1-1/(q-1). + +Hence the deterministic fraction of bad complete low classes satisfies + + delta26 <= min(1,1664*(q-1)/(q*(q-2))) (q>=3), + delta26 <1665/q (q>=1666). + +At q>2^80 this is below10^-16. This is the same complementary-minor proof +as PR3950, now at the actual rank26 source; it is not a new assertion that +a generic degree bound was experimentally proved by the finite callback. +The rank7 specialization retains delta7 <449/q for q>=450. + +## Complete ordered adapter invoice + +In the original good normal form, each head/tail triangular bank has + + 64*r-r*(r+1)/2 + +ordered factors, and the cross bank pays all64^2 slots, including zero +coefficients. Thus a full forward word pays + + G(r)=64^2+r*(128-r-1) + +commands, and forward plus backward column sweeps pay2*G(r)*f ordered ADDs. +This is independently counted from the triangular supports; the physical +source probe checks the actual compiled plan lengths, rather than pricing +only its first nonzero command. + +| Actual source | Rank | Forward commands | Both ADD sweeps | +|---|---:|---:|---:| +| IDLE27776 |26|6722|13444*f| +| COPY1603 |7|4936|9872*f| + +For the retained completed fallback contract, preserve its at-most49911 +main/half-reset coarse children of widths<=f and its scalar passes. Let +M_f=max_(1<=j<=f)T(j,w), without assuming monotonicity of T. Over the complete +low cover, the local per-full-payload-bit inequalities are + + C26 <= T(26f,w)+delta26*49911*M_f+L26+gamma26/(N*v), + C7 <= T(7f,w) +delta7 *49911*M_f+L7 +gamma7 /(N*v). + +L_r includes the displayed ordered scans, leaf work, source clone, intermediate +commits, returned output and paid disposal. The gamma terms retain encoded +coefficient/history/Count preparation, transfers and successful work erasure +not already paid by completed primitives. Owner gather/route/scatter and the +containing-node producer/wrapper bills remain additional. The fallback bound +and completed primitive contracts are inherited premises, not independently +proved by our controlled output test. + +With canonical root/history, fixed-tape numerical and backend reserve arguments +one obtains the usual source-specific O_q(n+w^p) local envelope; absent those +arguments, retain L_r, gamma_r and actual encoded widths. q=3 in the fixture +is not an admitted parameter for the10^-16 or exponent claim. + +## The two-level path is not the whole recursion invoice + +The good-path widths2048->832->91 show one actual nested source path. The +rank26 central child must run an entire recursive selected node, including +all families and every source call. It is not just the rank7 COPY step that +we sample inside it. In particular, replacing T(26f,w) by the cost of one +COPY1603 call would omit the rest of the node. Conversely, adding that call +again to a completed T(26f,w) would double count it. The current903456-call +invoice and original-width stock remain required. + +Compatible stock is preserved structurally because26f and7f are both at +most42f26 at IDLE +27776, and rank34->42 at IDLE27777. The rank-profile delta is +`{26:+32,34:-64,42:+32}`; total rank mass remains1808352. The stale predecessor +digest rejects the current source. [CATALOGUE.json](CATALOGUE.json) retains +every changed record, both receipts and all opcode counts. + +The current full topology passes the actual retained LocalState controller at +all **7814016** literal events across288 calls. This includes2592 COPY and2592 +matching ERASE events, with source-version/private-lifetime checks. This is a +complete literal/controller census, not an enumeration of GL64 low classes. + +The physical probe now uses **actual current records**, with no synthetic +Template vocabulary: + +| Source | Catalogue record | Actual identity | +|---|---:|---| +| Rank26 ancestor |27776| IDLE6, role209, family209, native chart port98 | +| Rank7 COPY |1603| stage0, position22014, source centre475, frame515 | + +At q=3,w=1, real generated programs and canonical raw directories pass through +the original fixed-role Machine at **2048 ->832 ->91**. The second child is +nonterminal. The test calls actual `residual_begin`, directory production, +`prepare_child`, CALL, protected `complete_return`, COPY source commit, private +MOVE, all 63 literal private-result XOR readers, and disposal. Both parent programs/streams/numerical aliases and heads +restore. Two equal prefixes keep separate physical ordinals. U remains the +separate `rows` grant; B is not substituted for U. Generated weights at child +coordinates0 and90 are2, as required by the chosen diagonalized source and +root unit2. Runtime Word.inspect is disabled for the tested operations. + +The actual obsolete rank34 descriptor and a foreign COPY prefix reject at +their source checks. Wrong parent identity, foreign Program alias and wrong +source-code gates reject before a child capsule is committed. Numerical live +roles, heads and erased work are audited after these controls and returns. +The complete finite receipt is [PHYSICAL.json](PHYSICAL.json). + +## The exact physical boundary + +The probe has a **46-bit controlled payload (two 23-bit prefix fibres), controlled child outputs and +stock11**, with residue/index bank capacities131072/1024. Its actual fixed-role parking/CALL/RETURN protocol executes; it +does not execute the full rank26 or rank7 residual body, forward/backward +adapter sweeps, original-width production stock, ordinary wrapper, native +producer or router cohort. Its small payload does not satisfy the volume +encoded by its numerical extents. All63 readers consume the controlled private +result using the actual physical XOR dispatcher, preserving source and private +value through the complete65-event COPY/read/ERASE interval at22014..22078. +The two returned bit transformations are +explicit test stimuli, not an asserted interchange oracle. + +For example, the encoded root packet alone would contain +`660*3^4096` payload bits at these extents. A successful return on46 bits +cannot certify that full endpoint. Likewise, `macros=0` in the receipt means +the complete global dispatch word was not run. No complete fixed-q GL64 word +or microtransition table was materialized. [BINDING.md](BINDING.md) separates +the instantiated capsule contract from the remaining whole-caller argument +and retains its full preparation, routing, stock and visited-cell obligations. + +This closes the previous **synthetic-ancestor/source-binding gap** at these +real physical gates. It does not close supplier admission or independently +prove PR2809's universal refinement. PR3950's conditional cost bound remains +conditional; finite parking counts here do not set its asymptotic constant. + +[RANK26-COST.md](RANK26-COST.md) also derives the actual ancestor's uniform +bad-low-class bound, `delta26 <=min(1,1664*(q-1)/(q*(q-2)))`, and its complete +conditional local bill. The actual forward adapter plan has6722 commands, +so both sweeps pay13444*f ADDs, compared with4936/9872*f for rank7. The +rank26 recursive child includes a whole node: it cannot be priced as only the +one rank7 call sampled inside it. No good/bad or containing-node charge is +deleted by the nested protocol test. + +## Reproduction and controls + +Python3.12, standard library: + +```sh +python3 -B scripts/research_package.py --package research/r437-oq4-caller-binding +``` + +The registered commands recompute both exact receipts normally and with +assertions disabled, then exercise the actual optimized catalogue CLI in a +Git-free export. Changed/missing/symlinked inputs, a stale request digest and a +falsified full-payload receipt reject. Each child process has a fresh bytecode +namespace. The commands are read-only; generation of the committed receipts +was a separate, explicitly recorded step. See REPLAY.log and VALIDATION.json +for the final measured execution, rather than inferring runtime from timeouts. + +SOURCES.json authenticates all 132 canonical live dependencies and seven retained +inputs by complete SHA256 and Git-blob identity. The custom retained records +carry exact published heads and are checked directly; generic source-history +checks apply to the canonical base pins. The retained files' origin mapping +is documented in SOURCES.json. A Git-free verifier checks bytes and scope, not +remote Git history. No native rebuild, selected cold replay, Lean, Docker, +independent human review or formal-kernel verification is claimed. + +## Open next questions + +This explicit donor assignment refines revision6 `independent-moment`; no +task reroll or selected-frontier change. Canonical guidance was read first, +with refresh checkpoints. PR3950 is the canonical investigation; the existing +#1166 handoff and #2319 physical-caller context were consulted. Targeted live +R437 PR overlap includes3690/3700/3724/3883/3936/3945/3950. Coverage is partial, +not a novelty certificate. Existing staged work, frozen inputs and synced +project sources are preserved. + +The [structured next question](TASK.json) is still the full production join: +use this authenticated catalogue with the complete finite compiler and prove +the primitive/block, numerical preparation and visited-cell bounds on admitted +root/history/stock domains. Connect ordinary, native and router constructors +at that same source. A new synthetic model or another controlled returned +payload would not complete that task. The bounded test here supplies an exact +entry point and discriminating controls, rather than hiding the missing body. + +## Credit and status + +zxv/PR3690 supplies the predecessor adapter and actual rank34 controlled gate; +this package extends that work to OQ4 and a nested actual rank26/COPY515 path. +ai-nanachi/PR3647 supplies R437/OQ4; Ali Romman/PR1043, Sagar Thakrar/PR3700, +eumemic/DreamingOfClouds and the retained native/owner lineage remain credited. +Physical/logical caller, compiler and backends: David Arias/PR2753; +Jose Manuel/jmbarrancoml/PR2809/2899/2915/3562; ywz65/PR2635 parking; +Nick Petalas/PR2808; Adam Gall, Gareth Davidson and all retained primitive, +source, geometry and assembly authors. Complete-stream/COPY semantics: +alephnan/PR1627, Adam Gall/PR2088, Ross Richardson/PR1704 and the selected +separation audits. PR3936/3950 supply the immediate complete-stream and +conditional-cost predecessors. All source notices and Apache-2.0 obligations +are retained in R437-UPSTREAM-NOTICE.md and R437-LICENSE. + +New adaptation, comparison, physical tests and writing by Chris R / Clear1nsight +with substantial OpenAI Codex assistance. This is a scoped partial result, +not a new exponent or a completed multiplication theorem. diff --git a/research/r437-oq4-caller-binding/REPLAY.log b/research/r437-oq4-caller-binding/REPLAY.log new file mode 100644 index 0000000000..52c91b7dde --- /dev/null +++ b/research/r437-oq4-caller-binding/REPLAY.log @@ -0,0 +1,11 @@ +CHECK catalogue exact source/authentication and explicit scoped receipt +{"conclusion": "Partial: real source/protocol binding; no completed GL64 production cohort", "source_bound_result": "PASS_FULL_OQ4_SOURCE_TOPOLOGY_AND_CHRONOLOGY", "status": "PASS_OQ4_CALLER_BINDING_CATALOGUE"} +CHECK catalogue exact source/authentication and explicit scoped receipt with assertions disabled +{"conclusion": "Partial: real source/protocol binding; no completed GL64 production cohort", "source_bound_result": "PASS_FULL_OQ4_SOURCE_TOPOLOGY_AND_CHRONOLOGY", "status": "PASS_OQ4_CALLER_BINDING_CATALOGUE"} +CHECK physical exact source/authentication and explicit scoped receipt +{"conclusion": "Partial: real source/protocol binding; no completed GL64 production cohort", "source_bound_result": "PASS_ACTUAL_OQ4_NESTED_PHYSICAL_PROTOCOL", "status": "PASS_OQ4_CALLER_BINDING_PHYSICAL"} +CHECK physical exact source/authentication and explicit scoped receipt with assertions disabled +{"conclusion": "Partial: real source/protocol binding; no completed GL64 production cohort", "source_bound_result": "PASS_ACTUAL_OQ4_NESTED_PHYSICAL_PROTOCOL", "status": "PASS_OQ4_CALLER_BINDING_PHYSICAL"} +CHECK export exact source/authentication and explicit scoped receipt +{"conclusion": "Partial: real source/protocol binding; no completed GL64 production cohort", "source_bound_result": "PASS_ACTUAL_OPTIMIZED_GITFREE_CLI", "status": "PASS_OQ4_CALLER_BINDING_EXPORT"} +PASS_REGISTERED_RESEARCH_PACKAGE research/r437-oq4-caller-binding outcome=partial diff --git a/research/r437-oq4-caller-binding/SOURCES.json b/research/r437-oq4-caller-binding/SOURCES.json new file mode 100644 index 0000000000..e2c9f5d125 --- /dev/null +++ b/research/r437-oq4-caller-binding/SOURCES.json @@ -0,0 +1,869 @@ +{ + "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" + } + ], + "retained": [ + { + "path": "inputs/EXPECTED.json", + "bytes": 1118, + "sha256": "67d06bcb90d2307a11975d6b25107a695be477f168f2dc289b8484ba0b7e2de0", + "git_blob": "bc2585e1404402395a7c59ba6f6dde58b04e65a2", + "origin_commit": "a24f9ff95c12fd0b6792e3f710569237efd72db2", + "origin_path": "research/bit-p111-r437-gl464-470-20261018/EXPECTED.json" + }, + { + "path": "inputs/geometry.json.gz", + "bytes": 105558, + "sha256": "edcaebb35d313f403b2db45a2cf808617f921c83cf7a11dd5d74356570ede1a8", + "git_blob": "a01a33c4753955ec4707db9515cee82a567cc1cb", + "origin_commit": "125f5afad680ef128e386fa58e76eef5fadaa5d6", + "origin_path": "research/t385-r437-copy-audit/inputs/r437-geometry.json.gz" + }, + { + "path": "inputs/old-EXPECTED.json", + "bytes": 1118, + "sha256": "ed3874fb1aa66578cdda9594022a8daec38c91f26d198746c3f94b0b4f6af3f6", + "git_blob": "027762fa595811eddb1d70cf80e0373352fbe0e5", + "origin_commit": "03c141ef1fd372cf42951488767537e55675c072", + "origin_path": "research/r437-ordinary-t360/sources/r437/EXPECTED.json" + }, + { + "path": "inputs/old-template.json.gz", + "bytes": 797869, + "sha256": "00dee04c5372ac300b678c4ac1e6770c178923099d2d4bf01be9e4bccd2a1e72", + "git_blob": "df9238596dbe8cd355a65aa170caa54f543c39cd", + "origin_commit": "03c141ef1fd372cf42951488767537e55675c072", + "origin_path": "research/r437-ordinary-t360/sources/r437/generated/GLOBAL-TEMPLATE.json.gz" + }, + { + "path": "inputs/pr3690-adapter.py", + "bytes": 3237, + "sha256": "f39d25021a688db4386877777c7771993487e5b8eab4adb18bbb0e5ac2165c5c", + "git_blob": "0b7dcf6db0834ba727cc924bbead4dc14ce354fe", + "origin_commit": "03c141ef1fd372cf42951488767537e55675c072", + "origin_path": "research/r437-ordinary-t360/adapter.py" + }, + { + "path": "inputs/template.json.gz", + "bytes": 797946, + "sha256": "6e03c76f5a4227394ea57e901eb7e93f4d1ee411ccfecd483fd44ea043550494", + "git_blob": "f56efc7ca3648d2070b791d4551a3d77dd7fdde4", + "origin_commit": "125f5afad680ef128e386fa58e76eef5fadaa5d6", + "origin_path": "research/t385-r437-copy-audit/inputs/r437-template.json.gz" + }, + { + "path": "inputs/word.json.gz", + "bytes": 42280, + "sha256": "e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e", + "git_blob": "c558a221dd44cbdaa732a401f9876de4c096d4a7", + "origin_commit": "125f5afad680ef128e386fa58e76eef5fadaa5d6", + "origin_path": "research/t385-r437-copy-audit/inputs/r437-word.json.gz" + } + ], + "origin_heads": { + "current_R437": "a24f9ff95c12fd0b6792e3f710569237efd72db2", + "predecessor_adapter": "03c141ef1fd372cf42951488767537e55675c072", + "prior_complete_stream_audit": "125f5afad680ef128e386fa58e76eef5fadaa5d6", + "uniform_local_reduction": "364701494bc3d726806a15d4d1d4b547c1e0f9d5" + }, + "retained_provenance": "Current word/template/geometry compressed bytes are lossless PR3936 inputs at its scientific head; EXPECTED is current PR3647. Old EXPECTED/template and adapter are exact PR3690 bytes. No predecessor data is edited. All seven retained inputs were compared byte-for-byte with the exact origin Git objects. Decompressed geometry equals old PR3690 geometry byte-for-byte: b9ed0e5e0084dcd285f33bfc71aab833ddcfa1062bd80c9c83da8244276d6830." +} diff --git a/research/r437-oq4-caller-binding/TASK.json b/research/r437-oq4-caller-binding/TASK.json new file mode 100644 index 0000000000..643980e3eb --- /dev/null +++ b/research/r437-oq4-caller-binding/TASK.json @@ -0,0 +1,78 @@ +{ + "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": "Refresh PR3690 to a24f9ff/OQ4, authenticate every source/controller site and bind actual rank26/COPY515 through nested physical CALL/RETURN. State full production-cohort and uniform-refinement limits.", + "scope_change_reason": "Explicit donor next step from PR3950; replaces synthetic ancestor by actual full catalogue records.", + "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": "One approximately 60-minute session from 2026-10-19 06:28 UTC, final quarter verification/publication; stop rather than call a controlled return a completed supplier.", + "outcome": "partial", + "evidence": "Exactly seven changed source records, full literal chronology; real nested physical rank26/COPY515 gates and all63 private-result consumers with controlled46-bit output/stock. No complete GL64 payload or production cohort. RANK26-COST.md proves the actual ancestor bad-class bound and complete conditional local invoice.", + "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 current full production ordinary/native/router cohort be executed or uniformly refined with an admitted root and complete GL64 payload?", + "why_it_matters": "The real-source nested protocol uses controlled child outputs and stock11; it does not execute the residual permutation or production cohort.", + "first_step": "Use actual bound catalogue cbfea55f and complete compile_node emitter; prove primitive/block contracts, encoded preparation and full visited-cell reserve under explicit source/root premises.", + "blocked_by": "Complete GL64 materialization is infeasible; inherited universal refinement, callee and source hypotheses need independent proof." + } + ], + "freshness": { + "canonical_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "priority_revision": 6, + "entry_utc": "2026-10-19T06:28:13Z", + "PR3950_head": "364701494bc3d726806a15d4d1d4b547c1e0f9d5", + "PR3950_CI": "39209275255 success; checked first", + "R437_head": "a24f9ff95c12fd0b6792e3f710569237efd72db2", + "overlap_coverage": "Targeted current R437 PRs and existing hub/physical-board context; partial, not novelty coverage", + "proof_checkpoint_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "proof_checkpoint_utc": "2026-10-19T06:53:00Z", + "claim": "https://github.com/CrocSwap/integer-mult-bounds/pull/3950#issuecomment-6261156262" + } +} diff --git a/research/r437-oq4-caller-binding/VALIDATION.json b/research/r437-oq4-caller-binding/VALIDATION.json new file mode 100644 index 0000000000..a7f52a7c7f --- /dev/null +++ b/research/r437-oq4-caller-binding/VALIDATION.json @@ -0,0 +1,27 @@ +{ + "status": "PASS", + "exit_code": 0, + "started_utc": "2026-10-19T07:06:17.436914+00:00", + "finished_utc": "2026-10-19T07:16:23.321789+00:00", + "seconds": 605.884891097001, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "registered_commands": 5, + "scientific_scope": "Partial: complete literal source/chronology; actual nested physical gates, all63 private-result consumers and full parking/port erasure with controlled46-bit output/stock. No full GL64 production cohort or uniform refinement proof.", + "executed_sha256": { + "SOURCES.json": "2db61c73afeee3a9b8958638a1aedd36239b28a10d4abb23fd28f8546f23eec6", + "test_export.py": "4626397cc6ab3112910f403a5eb9a999f1e6adbd0b68a601d7d40dff19531608", + "catalogue_audit.py": "2e42be4be899efba80056b46adc5b5ad096f622fff0d4f0af94eff1cddcdba25", + "TASK.json": "6d21bf4a1d70deaccf6a4cb313d63992111a2154097a7e463d42891c5faacd52", + "CATALOGUE.json": "fbd6b56ea4c488ea606668de84f45541ff941c44b5bfcd7314ba7b89cc845207", + "VERIFY.json": "9786818da6d80b700510f44a3ee327f68276ae3a5baead6fe5f5e29c7b9d449f", + "adapter.py": "c1c054e5a2c650cfc267117b32896073e6735b93c5fbfb1defe6e379c4afab9e", + "PHYSICAL.json": "7890b0aa1fd4d924d80618148e0363e071df840a3b5a8e55fbfc892140a35dca", + "verify.py": "a0cd5d651e743cef179793675bf5c94a66c4f19c99265432a28b2e5f14c32b22", + "physical_probe.py": "4fb0958485d7bd3d77435d882c91f4a9462ac877b0bd99cbd55d0db505a35460", + "inputs/EXPECTED.json": "67d06bcb90d2307a11975d6b25107a695be477f168f2dc289b8484ba0b7e2de0", + "inputs/old-EXPECTED.json": "ed3874fb1aa66578cdda9594022a8daec38c91f26d198746c3f94b0b4f6af3f6", + "inputs/pr3690-adapter.py": "f39d25021a688db4386877777c7771993487e5b8eab4adb18bbb0e5ac2165c5c" + }, + "replay_log_sha256": "b90be3f9a6b9da00c82947721b30bfb6643b20c2f56c2c706c1c96ede0ff8764" +} diff --git a/research/r437-oq4-caller-binding/VERIFY.json b/research/r437-oq4-caller-binding/VERIFY.json new file mode 100644 index 0000000000..c2002796cd --- /dev/null +++ b/research/r437-oq4-caller-binding/VERIFY.json @@ -0,0 +1,204 @@ +{ + "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" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py", + "--suite", + "catalogue" + ], + "timeout_seconds": 150, + "checks": "catalogue exact source/authentication and explicit scoped receipt" + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "-O", + "{package}/verify.py", + "--suite", + "catalogue" + ], + "timeout_seconds": 150, + "checks": "catalogue exact source/authentication and explicit scoped receipt with assertions disabled" + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py", + "--suite", + "physical" + ], + "timeout_seconds": 360, + "checks": "physical exact source/authentication and explicit scoped receipt" + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "-O", + "{package}/verify.py", + "--suite", + "physical" + ], + "timeout_seconds": 360, + "checks": "physical exact source/authentication and explicit scoped receipt with assertions disabled" + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py", + "--suite", + "export" + ], + "timeout_seconds": 180, + "checks": "export exact source/authentication and explicit scoped receipt" + } + ] +} diff --git a/research/r437-oq4-caller-binding/adapter.py b/research/r437-oq4-caller-binding/adapter.py new file mode 100644 index 0000000000..276a9a0f43 --- /dev/null +++ b/research/r437-oq4-caller-binding/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-oq4-caller-binding/catalogue_audit.py b/research/r437-oq4-caller-binding/catalogue_audit.py new file mode 100644 index 0000000000..e4aeafb333 --- /dev/null +++ b/research/r437-oq4-caller-binding/catalogue_audit.py @@ -0,0 +1,77 @@ +"""Full current topology/controller and authenticated old/new record delta. + +Compiler/controller are explicitly reused predecessor code, not independent +reimplementations. Apache-2.0; substantial OpenAI Codex assistance. +""" +from collections import Counter +import hashlib +import json +from pathlib import Path +import sys +import types +import adapter + + +def canonical(value): + return json.dumps(value,sort_keys=True,separators=(',',':')) + + +def run(): + current,topology = adapter.load() + from control import LocalState + counts=Counter() + for stage in range(9): + for replica in range(32): + call=topology.call(stage,replica) + state=LocalState(call) + for position,event in enumerate(call.events): + op,role=state.accept(position);counts[op]+=1 + if op in (0,2): + request=current.requests[call.requests[position]] + adapter.require((request.stage,request.position,request.role)==(stage,position,role), + 'actual literal request and controller site') + state.finish() + adapter.require(sum(counts.values())==7814016 and counts[2]==counts[3]==2592, + 'complete current chronology and COPY/disposal census') + # Same retained compiler with the exact old source data/digest, never a + # disabled guard. This is a source comparison, not an independent compiler. + source=Path(adapter.__file__).read_text() + source=adapter.replacement(source,adapter.REQUEST_DIGEST, + '0fb70d6838583f2f439a8704eb5dba84ce9dbd231d91f140da13440b680d73aa',1) + source=adapter.replacement(source,"'inputs/EXPECTED.json'","'inputs/old-EXPECTED.json'",1) + source=adapter.replacement(source,"('inputs/' + name + '.json.gz')", + "('inputs/old-template.json.gz' if name == 'template' else 'inputs/' + name + '.json.gz')",1) + source=adapter.replacement(source,"expected['profile'].get('26') == 32 and '34' not in expected['profile']", + "expected['profile'].get('34') == 64 and '26' not in expected['profile']",1) + module=types.ModuleType('authenticated_old_adapter');module.__file__=adapter.__file__ + sys.modules[module.__name__]=module + exec(compile(source,'','exec'),module.__dict__) + old,_=module.load() + adapter.require(len(old.requests)==len(current.requests)==28233,'stable source ordinal extent') + changes=[] + for i,(a,b) in enumerate(zip(old.requests,current.requests)): + adapter.require(old.semantic_key(a)==current.semantic_key(b),'stable exact source ordinal labels') + if canonical(a.record())!=canonical(b.record()): + changes.append({'identifier':i,'old':a.record(),'current':b.record()}) + rank_delta={str(r):current.profile[r]-old.profile[r] for r in sorted(set(old.profile)|set(current.profile)) + if current.profile[r]!=old.profile[r]} + adapter.require(rank_delta=={'26':32,'34':-64,'42':32},'exact OQ4 rank-profile delta') + adapter.require(sum(r*n for r,n in current.profile.items())==1808352==sum(r*n for r,n in old.profile.items()), + 'unchanged full rank mass') + old_digest=adapter.REQUEST_DIGEST + try: + adapter.REQUEST_DIGEST='0fb70d6838583f2f439a8704eb5dba84ce9dbd231d91f140da13440b680d73aa' + try:adapter.load() + except ValueError as error: + adapter.require(str(error)=='exact ordered PR2234 request records','old digest rejects current OQ4 data') + else:raise ValueError('stale ordered request digest accepted') + finally:adapter.REQUEST_DIGEST=old_digest + return {'status':'PASS_FULL_OQ4_SOURCE_TOPOLOGY_AND_CHRONOLOGY', + 'current':current.receipt(),'old':old.receipt(),'literal_opcode_counts':dict(counts), + 'changed_request_count':len(changes),'changed_requests':changes, + 'rank_profile_delta':rank_delta,'stale_digest_control':'REJECTED', + 'full_GL64_low_classes_executed':False, + 'scope':'Every literal source/controller site; all-low numerical emitter remains a quantified dependency'} + + +if __name__=='__main__':print(json.dumps(run(),sort_keys=True,indent=2)) diff --git a/research/r437-oq4-caller-binding/inputs/EXPECTED.json b/research/r437-oq4-caller-binding/inputs/EXPECTED.json new file mode 100644 index 0000000000..bc2585e140 --- /dev/null +++ b/research/r437-oq4-caller-binding/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-oq4-caller-binding/inputs/geometry.json.gz b/research/r437-oq4-caller-binding/inputs/geometry.json.gz new file mode 100644 index 0000000000..a01a33c475 Binary files /dev/null and b/research/r437-oq4-caller-binding/inputs/geometry.json.gz differ diff --git a/research/r437-oq4-caller-binding/inputs/old-EXPECTED.json b/research/r437-oq4-caller-binding/inputs/old-EXPECTED.json new file mode 100644 index 0000000000..027762fa59 --- /dev/null +++ b/research/r437-oq4-caller-binding/inputs/old-EXPECTED.json @@ -0,0 +1,34 @@ +{ + "word_gzip_sha256": "e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e", + "word_content_sha256": "da77deaf11368d016622348227657b98404b6afbc7e4f3d6fe9a246baae0dcce", + "records_sha256": "caeb2eb0e417992788c32c1f5812ada60b46d1dfdba9f4ac376299b2dede13cb", + "template_content_sha256": "2e868ff427654e47df34779299545c53aa05b8c96697ee126e80e7bc6a50990a", + "program_sha256": "d8ae6356093ce525db39c00169ad905b57fd86ec6f5f4d9761b0f196532f0d3d", + "profile": { + "1": 380160, + "2": 400864, + "3": 22176, + "4": 26592, + "5": 29376, + "6": 17376, + "7": 26496, + "34": 64, + "42": 352 + }, + "live": 28416, + "physical": 28425, + "rank_mass": 1808352, + "deficit": 10272, + "emitted_events": 7814016, + "hosted_residuals": 125856, + "BIT_c": "868314126713557740143/500000000000000000000000", + "BIT_c_decimal": "0.001736628253427115480286", + "next_grid": "1736628253427115480287/1000000000000000000000000", + "invoice": { + "prefix_bits": 177, + "charged_prefix": 192, + "two_level_bits": 393, + "charged_two_level": 512, + "ROW": 18355 + } +} diff --git a/research/r437-oq4-caller-binding/inputs/old-template.json.gz b/research/r437-oq4-caller-binding/inputs/old-template.json.gz new file mode 100644 index 0000000000..df9238596d Binary files /dev/null and b/research/r437-oq4-caller-binding/inputs/old-template.json.gz differ diff --git a/research/r437-oq4-caller-binding/inputs/pr3690-adapter.py b/research/r437-oq4-caller-binding/inputs/pr3690-adapter.py new file mode 100644 index 0000000000..0b7dcf6db0 --- /dev/null +++ b/research/r437-oq4-caller-binding/inputs/pr3690-adapter.py @@ -0,0 +1,65 @@ +"""Source-bound finite R437 request/topology adapter; no all-size admission. + +Derived from Jose Manuel's PR3562/PR2899 and David Arias/PR2753, +Nick Petalas's request/provider lineage, and ai-nanachi/Ali Romman's R437. +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 +sys.path.insert(0, str(HERE / 'sources/ordinary')) +import predecessor + + +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(): + ordinary, encoded, binary = predecessor.runtime() + import catalogue, topology + expected = json.loads((HERE/'sources/r437/EXPECTED.json').read_bytes()) + paths = {'word': HERE/'sources/r437/data/r0042/R437-COMPOSED-WORD.json.gz', + 'host': HERE/'sources/r437/generated/GLOBAL-TEMPLATE.json.gz', + 'geometry': HERE/'sources/r437/data/GEOMETRY.json'} + require(hashlib.sha256(gzip.decompress(paths['word'].read_bytes())).hexdigest() + == expected['word_content_sha256'], 'R437 actual word identity') + require(hashlib.sha256(gzip.decompress(paths['host'].read_bytes())).hexdigest() + == expected['template_content_sha256'], 'R437 complete template identity') + 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['host'],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('r437_catalogue'); module.__file__ = str(HERE/'adapter.py') + module.R437_PATHS = paths; module.R437_EXPECTED = expected + module.R437_REQUEST_DIGEST = '0fb70d6838583f2f439a8704eb5dba84ce9dbd231d91f140da13440b680d73aa' + sys.modules[module.__name__] = module + exec(compile(source, '', 'exec'), module.__dict__) + # Committed ordered request digest; no discovery bypass in the adapter. + module.R437_REQUEST_DIGEST = REQUEST_DIGEST + value = module.Catalogue(3) + code = Path(topology.__file__).read_text() + code = replacement(code, '==661', '==659', 1) + topo = types.ModuleType('r437_topology'); sys.modules[topo.__name__] = topo + exec(compile(code, '', 'exec'), topo.__dict__) + return value, topo.SelectedTopology(value), ordinary, encoded, binary + + +REQUEST_DIGEST = '0fb70d6838583f2f439a8704eb5dba84ce9dbd231d91f140da13440b680d73aa' diff --git a/research/r437-oq4-caller-binding/inputs/template.json.gz b/research/r437-oq4-caller-binding/inputs/template.json.gz new file mode 100644 index 0000000000..f56efc7ca3 Binary files /dev/null and b/research/r437-oq4-caller-binding/inputs/template.json.gz differ diff --git a/research/r437-oq4-caller-binding/inputs/word.json.gz b/research/r437-oq4-caller-binding/inputs/word.json.gz new file mode 100644 index 0000000000..c558a221dd Binary files /dev/null and b/research/r437-oq4-caller-binding/inputs/word.json.gz differ diff --git a/research/r437-oq4-caller-binding/physical_probe.py b/research/r437-oq4-caller-binding/physical_probe.py new file mode 100644 index 0000000000..cf9a4486cf --- /dev/null +++ b/research/r437-oq4-caller-binding/physical_probe.py @@ -0,0 +1,264 @@ +"""Actual OQ4 source records through nested fixed-role CALL/RETURN. + +The 46-bit controlled payload is deliberately not a complete GL64 packet. +No claim that the controlled return executes a residual permutation. +Derived from Jose Manuel's macro_selected_checks and zxv/PR3690. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from dataclasses import replace +import hashlib +import json +from pathlib import Path +from unittest.mock import patch +import adapter + + +def body(tape): + from words import BLANK + return bytes(tape.cells[1:]).rstrip(bytes([BLANK])) + + +def run(): + catalogue, topology = adapter.load() + from catalogue import Specifications + from cardinal_counts import Count + from check_support import audit, inspect_count, no_decode + from frame_checks import snapshot, restored + from macro_binding import SelectedBinding, view + from macro_code import Code + from macro_machine import Machine + import macro_machine + import oracle + from packet import read_prefix + from plan import Request + from records import Fields, Program, Tape + from controller import Callback + from words import Arena, need + + specifications = Specifications(catalogue) + binding = SelectedBinding(specifications) + ancestor_id = next(i for i,r in enumerate(catalogue.requests) + if r.kind == 'IDLE' and r.base.rank == 26) + copy_id = catalogue.identifier('COPY', 0, 22014) + ancestor_record, copy_record = (catalogue.requests[i] for i in (ancestor_id,copy_id)) + need(ancestor_id == 27776 and ancestor_record.role == 209 and ancestor_record.stage == 6, + 'actual current OQ4 idle, not a synthetic template') + need(copy_id == 1603 and copy_record.role == 475 and copy_record.old_frame == 515, + 'actual COPY515 catalogue site') + definitions = [] + for identifier,common in ((ancestor_id,False),(copy_id,True)): + template = catalogue.template_for(identifier,common) + low = tuple(map(tuple,oracle.inverse(oracle.reduce_rational(template.preparation,3),3))) + definition = binding.residual(identifier,common,low,0) + need(definition.plan.good, 'actual good native/common source class') + definitions.append(definition) + ancestor, copy = definitions + need([len(d.plan.commands) for d in definitions]==[6722,4936], + "actual rank26/rank7 full forward adapter invoices") + window = catalogue.template['local_programs']['forward'][22014:22079] + need(len(window)==65 and window[0]==[2,475,659,515,0,7,0] and + window[-1]==[3,475,659,515,0,0,0], 'actual complete COPY515 read window') + targets=tuple(event[1] for event in window[1:-1]) + need(len(targets)==len(set(targets))==63 and all( + event==[1,role,659,1,0,0] and role not in (475,659) + for role,event in zip(targets,window[1:-1])), 'all actual private-result consumers') + arena, indices = Arena(3), Arena(13) + modulus, size, depth = arena.input(3), indices.input(2048), indices.input(0) + program = Program.fixture(indices,arena,2048,2,(),catalogue.codes.bits) + source, old_directory = Tape(), Tape() + initial = bytes((i*7 ^ i//3)&1 for i in range(46)) + for bit in initial:source.append(bit) + source.rewind() + borrowed = snapshot(arena), snapshot(indices) + saved_program = body(program.tape) + counts = [Count.literal(v) for v in (2,11,2,5,3)] + code = Code(tuple(('checkpoint','controlled',i) for i in range(6)),660) + machine = Machine(binding,topology,(code,),Arena(3,131072),Arena(13,1024)) + evidence = {'ancestor_request':ancestor_id,'copy_request':copy_id, + 'ancestor_record':ancestor_record.record(),'copy_record':copy_record.record(), + 'catalogue':catalogue.receipt(),'forward_adapter_commands':[6722,4936], + 'both_sweeps_ADD_passes_per_f':[13444,9872],'controlled_payload_bits':46, 'controlled_fibre_bits':23, 'residue_bank_capacity':131072, 'index_bank_capacity':1024, + 'scope':'Actual source-bound nested physical protocol; controlled child outputs, not complete GL64 residual execution'} + + def setup_stock(): + machine.commit(machine.tape('rows'),'unused') + machine.save_count(Count.product(machine.count('unused'),machine.count('before')),'leading') + + def state(): + return (snapshot(machine.arena),snapshot(machine.indices), + {label:body(tape) for label,tape in machine.roles.items()}) + + def check_state(saved,changed=None): + restored(machine.arena,saved[0]);restored(machine.indices,saved[1]) + audit(machine.arena,[machine.arena.words[i] for i in machine.arena.live]) + audit(machine.indices,[machine.indices.words[i] for i in machine.indices.live]) + for label,tape in machine.roles.items(): + need(body(tape)==(changed if label=='current' and changed is not None else saved[2][label]), + 'exact parked numerical/stream parent restoration') + machine.boundary() + + def descriptor(level,expected,parent,child): + index = machine.indices.literal(level) + metadata,a,b = machine.program.step(index) + need(metadata == (0,expected.code,expected.plan.rank,0,0,0) and + (inspect_count(a),inspect_count(b)) == (parent,child),'actual appended source/rank/extent') + machine.indices.free_many(index,a,b) + return list(metadata) + + with machine.pool.install(): + machine.load_root(source,old_directory,program.tape,modulus,size,depth,*counts) + setup_stock() + with no_decode():machine.residual_begin('source',ancestor) + machine.close_geometry();machine.boundary() + root_state = state() + with no_decode():need(machine.block(ancestor,('good',1,0)),'actual rank26 physical gate') + machine.boundary() + need((inspect_count(machine.size),inspect_count(machine.depth)) == (832,1),'actual ancestor grants') + first_descriptor = descriptor(1,ancestor,2048,832) + root_gap = 5*3**2432 + need(tuple(inspect_count(machine.count(k)) for k in ('old_count','rows','before','gap','suffix')) + == (2,11,2,root_gap,3),'whole ancestor projected capsule with separate unused stock') + setup_stock() + machine.save_count(Count.literal(23),'fibre') + target_initial={role:bytes(((i*11+role*3)^(i//5))&1 for i in range(46)) for role in targets} + for role,bits in target_initial.items(): + for bit in bits:machine.tape(('stage',role)).append(bit) + machine.tape(('stage',role)).rewind() + machine.commit(machine.tape('source'),('stage',475)) + with no_decode(): + machine.dispatch(('copy',('stage',475),'copy_source')) + machine.residual_begin('copy_source',copy) + machine.close_geometry();machine.boundary() + machine.pc = 3 + saved = state() + saved_child_program = body(machine.tape('program')) + coordinates = (0,90) + coefficients = [] + field_count = machine.indices.literal(2) + prefix = read_prefix(machine.tape('directory'),field_count) + machine.tape('directory').rewind() + try: + for coordinate in coordinates: + index = machine.indices.literal(coordinate) + with no_decode(): + value = binding.coefficient(machine,copy,prefix,Request('child',index,child_kind='good')) + coefficients.append(inspect_count(value)) + need(coefficients[-1] == 2,'actual ancestor supplies root unit to COPY child') + machine.arena.free(value);machine.indices.free(index) + finally: + prefix.clear();machine.indices.free(field_count) + check_state(saved) + semantic_rejections=[] + # Serialize the obsolete actual rank34 using the current rank26 source + # code: this must reject before any coefficient evaluation or CALL. + bad_program=Program.fixture(machine.indices,machine.arena,2048,2, + ((0,ancestor.code,34,0,0,0),),catalogue.codes.bits) + fields=Fields.fixture(machine.indices,machine.arena, + [(d.code,[[0]*64 for _ in range(64)]) for d in definitions],catalogue.codes.bits) + for label,test_program,test_fields in [('obsolete_rank34',bad_program,fields)]: + try: + with no_decode():Callback(machine.context.ring,machine.indices,test_program,test_fields, + specifications,copy.code,allow_fallback=True) + except ValueError as error: + need(str(error)=='actual selected rank','obsolete ancestor rejects at source rank') + semantic_rejections.append(label) + else:raise ValueError('obsolete ancestor rank accepted') + bad_program.tape.clear();fields.tape.clear() + next_template=catalogue.template_for(copy_id+1,True) + other_low=tuple(map(tuple,oracle.inverse(oracle.reduce_rational(next_template.preparation,3),3))) + other=binding.residual(copy_id+1,True,other_low,0) + fields=Fields.fixture(machine.indices,machine.arena, + [(d.code,[[0]*64 for _ in range(64)]) for d in (ancestor,other)],catalogue.codes.bits) + try: + with no_decode():Callback(machine.context.ring,machine.indices,machine.program,fields, + specifications,copy.code,allow_fallback=True) + except ValueError as error: + need(str(error)=='original global raw-field code','foreign current source prefix rejects') + semantic_rejections.append('foreign_COPY_prefix') + else:raise ValueError('foreign current prefix accepted') + fields.tape.clear() + check_state(saved) + rejected=[] + original_events=macro_machine.block_events + for label,changes in [('wrong_parent',{'parent_identity':None}), + ('foreign_program',{'parent_identity':view(Program,machine,machine.program.tape)}), + ('wrong_source',{'source_code':copy.code+1})]: + def malformed(page,block): + events=original_events(page,block) + try: + for event in events:yield replace(event,**changes) if event.kind=='enter' else event + finally:events.close() + try: + with no_decode(),patch.object(macro_machine,'block_events',malformed): + machine.block(copy,('good',1,0)) + except ValueError as error: + need(str(error)=='recursive gate belongs to the current program and source','typed source rejection') + rejected.append(label) + else:raise ValueError('malformed gate accepted') + finally:machine.close_geometry() + check_state(saved) + need(all(not body(t) for t in machine.handoff.values()),'reject before child handoff mutation') + with no_decode():need(machine.block(copy,('good',1,0)),'actual rank7 physical gate') + machine.boundary() + need((inspect_count(machine.size),inspect_count(machine.depth))==(91,2),'nonterminal rank7 child') + descriptors=[descriptor(1,ancestor,2048,832),descriptor(2,copy,832,91)] + need(descriptors[0]==first_descriptor,'unchanged actual ancestor descriptor') + need(tuple(inspect_count(machine.count(k)) for k in ('old_count','rows','before','gap','suffix')) + == (2,11,2,5*3**3914,3),'complete two-level capsule, no U/B confusion') + changed = bytes(1-bit for bit in reversed(initial)) + for bit in changed:machine.output.append(bit) + machine.output.rewind() + with no_decode():need(not machine.complete_return(),'return to actual ancestor child') + need(machine.pc==4 and not machine.root and body(machine.tape('program'))==saved_child_program, + 'serialized continuation and program return') + check_state(saved,changed) + with no_decode(): + machine.dispatch(('residual_end','copy_source',copy)) + machine.dispatch(('move','copy_source',('stage',659))) + need(body(machine.tape(('stage',475)))==initial and body(machine.tape(('stage',659)))==changed, + 'physical COPY borrowed source and distinct owned output') + for role,event in zip(targets,window[1:-1]): + with no_decode():machine.dispatch(('xor',('stage',role),('stage',659))) + need(body(machine.tape(('stage',role)))==bytes(a^b for a,b in zip(target_initial[role],changed)), + 'actual physical XOR consumes the distinct returned private output') + need(body(machine.tape(('stage',475)))==initial and body(machine.tape(('stage',659)))==changed, + 'COPY source and private output immutable throughout all63 readers') + machine.boundary() + with no_decode():machine.dispatch(('clear',('stage',659))) + need(not body(machine.tape(('stage',659))) and not body(machine.tape('copy_source')), + 'paid private-output disposal') + # Controlled result of the enclosing rank26 callee, not a residual oracle. + ancestor_output = bytes(bit^1 for bit in initial) + for bit in ancestor_output:machine.output.append(bit) + machine.output.rewind() + with no_decode():need(not machine.complete_return(),'return to original physical parent') + need(machine.root and machine.pc==1,'resume original successor once') + check_state(root_state,ancestor_output) + need(not body(machine.output) and all(not body(tape) for tape in machine.handoff.values()), + 'all protected output and handoff ports consumed after both returns') + need(machine.numerical.machine.tapes == [{}, {0:'^'}] and + machine.numerical.machine.heads == [0,1], + 'complete physical parking stack and packet port restored to baseline') + machine.close_frame();machine.erase_work() + need(machine.numerical.machine.tapes == [{}, {}], + 'erase the final owned parking marker, not just parent live contents') + need(body(source)==initial and body(program.tape)==saved_program and not body(old_directory) + and source.head==program.tape.head==old_directory.head==1,'borrowed source/program/heads restored') + restored(arena,borrowed[0]);restored(indices,borrowed[1]) + evidence.update(status='PASS_ACTUAL_OQ4_NESTED_PHYSICAL_PROTOCOL',widths=[2048,832,91], + descriptors=descriptors,coefficients=coefficients,rejected_gates=rejected, + semantic_rejections=semantic_rejections, + counts=machine.counts,parking_charge=machine.numerical.machine.counts, + peak_scratch_leases=machine.pool.peak, + complete_GL64_payload_executed=False,stock_is_controlled_fixture=True, + numerical_decode_disabled=True, private_result_consumers=63, literal_COPY_window_events=65, + literal_COPY_window_sha256=hashlib.sha256(json.dumps(window,separators=(',',':')).encode()).hexdigest()) + program.tape.clear();source.clear();old_directory.clear() + for value in counts:value.close() + arena.free(modulus);indices.free_many(size,depth) + need(not arena.live and not indices.live,'closed borrowed fixture') + return evidence + + +if __name__=='__main__': + print(json.dumps(run(),sort_keys=True,indent=2)) diff --git a/research/r437-oq4-caller-binding/test_export.py b/research/r437-oq4-caller-binding/test_export.py new file mode 100644 index 0000000000..8bf354ca95 --- /dev/null +++ b/research/r437-oq4-caller-binding/test_export.py @@ -0,0 +1,57 @@ +"""Exercise the actual optimized verifier outside Git, with source controls.""" +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile + +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] + + +def run(): + sources=json.loads((HERE/'SOURCES.json').read_bytes()) + with tempfile.TemporaryDirectory(prefix='oq4-gitfree-') as temporary: + root=Path(temporary);package=root/'research/r437-oq4-caller-binding' + shutil.copytree(HERE,package,ignore=shutil.ignore_patterns('__pycache__','*.pyc')) + for row in sources['files']: + if row['usage']!='input':continue + target=root/row['path'];target.parent.mkdir(parents=True,exist_ok=True) + shutil.copyfile(ROOT/row['path'],target) + def cli(): + with tempfile.TemporaryDirectory(prefix='oq4-bytecode-') as cache: + env=os.environ.copy();env.pop('PYTHONPATH',None);env.pop('PYTHONOPTIMIZE',None) + return subprocess.run([sys.executable,'-I','-B','-O','-X','pycache_prefix='+cache, + str(package/'verify.py'),'--suite','catalogue'],cwd=root,env=env, + capture_output=True,text=True,timeout=80) + result=cli() + if result.returncode:raise ValueError('Git-free positive control: '+result.stderr[-2000:]) + mutations=[] + cases=[('changed_word',package/'inputs/word.json.gz','bytes'), + ('missing_template',package/'inputs/template.json.gz','missing'), + ('symlinked_runtime',root/'research/selected-bit-physical-caller/macro_machine.py','symlink'), + ('obsolete_request_digest',package/'adapter.py','digest'), + ('falsified_full_payload_receipt',package/'PHYSICAL.json','receipt')] + for label,path,kind in cases: + original=path.read_bytes() + if kind=='bytes':path.write_bytes(original+b'corruption') + elif kind=='missing':path.unlink() + elif kind=='symlink': + alternate=root/'same-bytes.py';alternate.write_bytes(original);path.unlink();path.symlink_to(alternate) + elif kind=='digest': + path.write_bytes(original.replace(b'cbfea55f5cd0b74a2a0d4292ad0139d2b5bb73127951127698030bc90c73c532', + b'0fb70d6838583f2f439a8704eb5dba84ce9dbd231d91f140da13440b680d73aa')) + else: + data=json.loads(original);data['complete_GL64_payload_executed']=True + path.write_text(json.dumps(data)) + try: + result=cli() + if result.returncode==0:raise ValueError('mutated CLI accepted '+label) + mutations.append(label) + finally: + if path.is_symlink():path.unlink() + path.write_bytes(original) + return {'status':'PASS_ACTUAL_OPTIMIZED_GITFREE_CLI','rejected_controls':mutations, + 'scope':'Exported source/record checker, not a repeated physical payload run'} diff --git a/research/r437-oq4-caller-binding/verify.py b/research/r437-oq4-caller-binding/verify.py new file mode 100644 index 0000000000..e1dfe7e411 --- /dev/null +++ b/research/r437-oq4-caller-binding/verify.py @@ -0,0 +1,69 @@ +"""Read-only source-bound replay, including Git-free export controls.""" +import argparse +import hashlib +import json +from pathlib import Path +import sys + +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] + + +def require(ok,message): + if not ok:raise ValueError(message) + + +def regular(path): + require(path.is_file(),'missing regular input: '+str(path)) + for part in (path,*path.parents): + require(not part.is_symlink(),'symlinked input: '+str(part)) + + +def authenticate(): + sources=json.loads((HERE/'SOURCES.json').read_bytes()) + require(sources['base_commit']=='20ecf2891d80b5acf18d980b2164fb44ea7faa90','canonical scientific base') + for row in sources['files']: + if row['usage']!='input':continue + path=ROOT/row['path'];regular(path);data=path.read_bytes() + require(hashlib.sha256(data).hexdigest()==row['sha256'],'canonical input hash: '+row['path']) + require(hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest()==row['git_blob'], + 'canonical input Git blob: '+row['path']) + inventory=set() + for row in sources['retained']: + path=HERE/row['path'];regular(path);data=path.read_bytes();inventory.add(row['path']) + require(len(data)==row['bytes'] and hashlib.sha256(data).hexdigest()==row['sha256'] and + hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest()==row['git_blob'], + 'retained source identity: '+row['path']) + observed={str(f.relative_to(HERE)) for f in (HERE/'inputs').rglob('*') if f.is_file()} + require(inventory==observed,'complete retained input inventory') + physical=json.loads((HERE/'PHYSICAL.json').read_bytes()) + require(physical['complete_GL64_payload_executed'] is False and physical['stock_is_controlled_fixture'] is True, + 'controlled physical probe is not a production cohort') + require(physical['widths']==[2048,832,91] and physical['ancestor_request']==27776 and physical['copy_request']==1603, + 'actual current source records and nonterminal extents') + return sources + + +def main(): + parser=argparse.ArgumentParser();parser.add_argument('--suite',choices=['catalogue','physical','export'],required=True) + args=parser.parse_args();authenticate() + sys.path.insert(0,str(HERE)) + if args.suite=='export': + from test_export import run + result=run() + else: + if args.suite=='catalogue': + from catalogue_audit import run + receipt='CATALOGUE.json' + else: + from physical_probe import run + receipt='PHYSICAL.json' + result=run() + require(json.loads(json.dumps(result))==json.loads((HERE/receipt).read_bytes()), + 'complete scoped receipt mismatch: '+receipt) + print(json.dumps({'status':'PASS_OQ4_CALLER_BINDING_'+args.suite.upper(), + 'source_bound_result':result['status'], + 'conclusion':'Partial: real source/protocol binding; no completed GL64 production cohort'},sort_keys=True)) + + +if __name__=='__main__':main()