From f7c4d65b11e658fa093f0bac9f5f4b8ca346a4b8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Krzysztof=20W=C3=B3jt?= <97155365+krzysztofwojt@users.noreply.github.com> Date: Fri, 23 Oct 2026 13:50:54 +0200 Subject: [PATCH] Bound the complete streamed R437 leaf/XOR workspace --- .../r437-streamed-leaf-workspace/PROOF.md | 236 ++ .../r437-streamed-leaf-workspace/README.md | 131 + .../r437-streamed-leaf-workspace/RESULT.json | 567 ++++ .../r437-streamed-leaf-workspace/SOURCES.json | 2508 +++++++++++++++++ .../r437-streamed-leaf-workspace/TASK.json | 84 + .../r437-streamed-leaf-workspace/VERIFY.json | 449 +++ .../actual_bridge.py | 57 + .../r437-streamed-leaf-workspace/bounds.py | 37 + .../r437-streamed-leaf-workspace/evidence.py | 114 + .../r437-streamed-leaf-workspace/pooled.py | 93 + .../r437-streamed-leaf-workspace/verify.py | 298 ++ 11 files changed, 4574 insertions(+) create mode 100644 research/r437-streamed-leaf-workspace/PROOF.md create mode 100644 research/r437-streamed-leaf-workspace/README.md create mode 100644 research/r437-streamed-leaf-workspace/RESULT.json create mode 100644 research/r437-streamed-leaf-workspace/SOURCES.json create mode 100644 research/r437-streamed-leaf-workspace/TASK.json create mode 100644 research/r437-streamed-leaf-workspace/VERIFY.json create mode 100644 research/r437-streamed-leaf-workspace/actual_bridge.py create mode 100644 research/r437-streamed-leaf-workspace/bounds.py create mode 100644 research/r437-streamed-leaf-workspace/evidence.py create mode 100644 research/r437-streamed-leaf-workspace/pooled.py create mode 100644 research/r437-streamed-leaf-workspace/verify.py diff --git a/research/r437-streamed-leaf-workspace/PROOF.md b/research/r437-streamed-leaf-workspace/PROOF.md new file mode 100644 index 0000000000..608902a983 --- /dev/null +++ b/research/r437-streamed-leaf-workspace/PROOF.md @@ -0,0 +1,236 @@ +# A fixed workspace for the complete streamed leaf/XOR interval + +Krzysztof Wójt, with substantial OpenAI Codex assistance. Apache-2.0. +JoyboyBrian's #5055 algorithm and fixtures, Jose Manuel's physical lease +lowering, David Arias's logical caller, Chris R's R437 bridge and their retained +source authors keep their credit. This is a scoped source-level refinement, +not independent acceptance of all inherited supplier hypotheses. + +## 1. Boundary and the new statement + +Retain the successful-input contract in +`research/r437-streaming-directory/PROOF.md`: a canonical old directory with +C positive physical occurrences of h fields, fixed compiled q and d, a valid +q^w context, complete equal-size source/dirty-target fibres, and a closed +prefix-local leaf. Equal byte prefixes at different positions remain different +occurrences. Put N=C*q^((w-1)*d^2) and let v be the complete fibre bit count, +including all intervening and exterior spectators. + +The callback is the retained source coefficient evaluator (or a simpler +callback with the same lifetime and extent bounds), not arbitrary Python. +It returns owned numerical coefficients, restores its borrowed prefix/Program, +does not retain a scratch lease, and invokes no recursive child inside the leaf. +Supplied fixed numerical arenas must suffice. No callback, observer or event +producer may escape/reenter this synchronous interval. This is the predecessor's +leaf boundary, not a new permission to drop an internal recursive call. + +**New composition.** The entire repeated local consumer, including its two +input-fibre copies, packet engine, all primitive passes, coefficient stacks, +prefix parsing, returned child, XOR and local disposal, can use one inventory +of A=q^2+136 physical record tapes. There is no physical Tape or Arena creation +inside that consumer. Every successful prefix ends every lease and leaves all +its physical bodies blank at the origin. The same inventory serves all N +prefixes. The returned full N*v-bit output remains an ordinary, separate tape. + +The construction uses exactly the predecessor `run.__code__`, changing only +the `Tape` allocation binding and the synchronous `visit` callback boundary. +The full producer `visit.__code__` is unchanged. It reuses the existing +`ScratchPool` and its original source-module/default-factory specialization. +Frozen files are never edited. `actual_bridge.py` selects two actual64 prefixes +only for calibration; it is not used by the complete producer theorem. + +## 2. Why this is not just passing a payload factory + +The predecessor's direct `left,right=Tape(),Tape()` sites are in `streaming.py`, +outside the source tree recognized by `ScratchPool.install`. Passing a factory +to `packet_engine` alone misses those sites, nested Counters, prefix readers, +Natural/Count work and coefficient stacks. Installing the source pool around +the *entire producer* is also wrong: its saved prefix and reusable reader are +physical persistent roles, not leases that can be ended and then reused through +a stale object. + +`Workspace.tape` has a finite phase flag. Outside the local interval it creates +the one full output. Inside it obtains a lease. The visitor suspends the producer, +installs the retained source factories, performs one complete consumer call, +uninstalls those factories, and checks the empty pool before resuming production. +The phase flag depends only on this call boundary, never on a decoded Word. +The adapter's Python specialization machinery stands for the same finite +source-specific role specialization used by the predecessor physical lowering; +it is not a general compiler or a claim that Python module scanning is free. + +The installed source pool rejects an otherwise missed raw Tape or Arena +constructor. It also specializes default factory arguments captured at import +time. Source numerical allocation uses the supplied reusable Word arenas. +All within-prefix primitive and coefficient calls, their order, guards and +copies execute unchanged. + +## 3. Lifetime proof and role count + +The retained physical-caller proof, section 5, gives q^2+128 scratch roles for +each completed source block, including the packet/primitive/callback call graph. +Its ADD/coefficient allowance explicitly includes two Callback objects, eight +main/reverse Stack tapes and an extended Program. Arbitrary history is processed +on those sequential stacks, not by retaining a callback per ancestor. Its +digit-swap allowance includes q^2 bucket roles; sequential passes dispose of the +previous output before continuing. The active sign implementation is +`inputs/pr2753/linear_sign.py`, imported by the active `stream_runner.py`. +The older vendor sign is not substituted into this argument. + +We inherit that stated lexical source bound; finite measurements below are not +a new proof of that predecessor theorem. The new wrapper adds at most seven +simultaneously held roles even if we deliberately overcount: its two copied +input fibres, a completed leaf result kept through XOR, and the XOR output plus +three nested counters. Source block and XOR phases are sequential. Eight extra +roles therefore suffice, giving q^2+136. The producer's persistent prefix, +reader and count roles, borrowed metadata and full output are separate residents. + +Within an event, the packet engine clears the changed fibre, local fibre and +copied fields after their last read; the completed previous event output is +cleared before advancing. Primitive loops clear their buckets/results and close +their counts before the next iteration. A callback closes its numerical state; +the retained pool adapter additionally retires its four now-empty Stack roles. +After the leaf, the XOR result is copied into the full output, then XOR output, +leaf result and the two input copies are cleared by the unchanged `finally`. +No lease crosses this boundary. A stale repeated clear is inert and cannot +erase a later owner; a stale read is rejected. + +Induct on local allocation/retirement events. A fresh lease sees LEFT, an origin +head and an entirely blank body, so every source read/write/unit move produces +the same symbols and heads as a fresh source tape. Only simultaneous live leases +must have distinct roles. The above lifetime bound guarantees a free role in +the stated inventory. Induct next over complete prefixes: at return the pool is +blank and unleased; the producer advances exactly as before. Thus all N complete +dirty-payload outputs and all within-prefix coefficient calls agree with #5055. + +## 4. Retained backing, including control tapes + +The following are **source parameters**, not numbers decoded to drive execution: + +- v: complete local fibre bits; +- D: largest complete copied prefix body, including code/high-word delimiters; +- P: largest Program body, including any transient extension; +- H: largest validated callback Program depth, including an extension; +- I and L: actual index/residue Word bit widths. + +Take their maxima across the allowed prefixes and source callbacks. With a fixed +history length and fixed compiled vocabulary these do not grow with C or N. +For example, an h-step Program has body +`2I+L+5+h*(Q+2I+90)` in the retained 16-bit tag vocabulary. Include the extra +step if the callback constructs one; an input Program size alone is insufficient. + +Set s=max(2I+4,L+3) and + +``` +M = max(v, D, P, (2H+3)*s, I+3, L+3, bit_length(v)+3). +``` + +Payload copies, event outputs and digit buckets contain at most v bits. Prefix +and Program copies are bounded by D and P. A VALUE stack record has two I-bit +words, a tag and three delimiters, hence 2I+4 symbols; scalar stack records have +L+3. The evaluator is a depth-first traversal: a pair frame leaves at most two +pending items per lower level, a good frame at most one, and each VALUE descent +strictly decreases the validated level. Thus 2H+3 records bound pending storage, +including the current replacement. The value stack holds at most H+1 completed +values. A reverse stack holds only one popped record. Multiple callbacks have +separate roles, not concatenated stack bodies. + +All positive cardinal products in the local layout are bounded by v: before, +gap and suffix factors grow monotonically toward a factor of the complete fibre. +The local packet/XOR prefix count is one. Natural multiplication and binary +Count.product intermediates do not exceed their final product; marginal adds one +high zero. Count/Counter bodies therefore fit bit_length(v)+3. Counters copied +from encoded exponents or ring atoms fit I+3 or L+3. Matrix arithmetic stays in +the numerical arenas and does not create another record representation. + +Consequently a fresh pool retains at most **A*(M+2) cells**: one LEFT marker, +the bounded body, and a conservative extra written blank per role. The latter +accounts for normalization/pop erasure at a prior right edge. Clearing does not +shrink backing. A pool reused from a larger earlier job must additionally charge +its entry backing; `entry_backing+A*(M+2)` is a safe conservative bound. The bound +is for physical backing, not just simultaneously live lease bodies. + +This is not a bound on all caller residents. Preserve the two borrowed full +payloads (2Nv), full owned output (Nv), old directory, current/saved prefix, +producer setup/outer/emitted/expected counters, odometer, Program/codebook, +all numerical arenas, suspended parents, and every untouched source owner. +The #5055 producer ledger still applies in full. In particular, deleting +per-prefix scratch allocation does not make the full result or input disappear. + +## 5. Movement and erasure are paid + +For the literal source `Tape.clear`, let p>=1 be its entry head and l the length +of its contiguous nonblank body. Two rewinds and the sweep give exactly + +``` +reads = p + 2l + 2 +writes = l +moves = p + 2l + 3. +``` + +The write count is erasure, not an omitted allocator operation. Stack.pop and +Count normalization also write blanks during ordinary source execution; those +remain in total primitive traffic and are not double-counted as clear writes. +All source payload copies, coefficient parsing, bucket scans and final output +copies remain paid. + +Let K be the number of acquired/retired leases and J the number of temporary +Callback.close operations. Each acquisition adds one blank-check read. Each +successful prefix performs `pool.empty`: two reads and two moves per role. +Each callback close adds four empty-stack clears; at p=1,l=0 these cost 7 cell +actions each. Repeated stale clears can only remove empty-tape source work. +Relative to the same fresh-tape consumer's record-cell action count T, a safe +uniform incremental bound is therefore + +``` +T_pool <= T + K + 28J + 4AN. +``` + +The interval starts with prepared LEFT markers and heads just after them, as +does the retained Tape contract. If instead A blank tapes start at their origin +cells, prepare them with A LEFT writes and A unit moves to the right, once. +Those setup actions are separate from the interval meters. Numerical Word +actions are unchanged. This prices the pooling interface; it does **not** turn +T, source coefficient preparation or Context construction into a newly proved +closed all-parameter runtime formula, and implies no asymptotic speedup. + +There is also an exact implementation-level conservation check. Let L_r,L_w,L_m +sum the meters of every lease at its unique retirement. At a complete boundary: + +``` +physical_reads = L_r + K + 2AN +physical_writes = L_w +physical_moves = L_m + 2AN. +``` + +`evidence.py` independently checks this equality and the clear formula at every +retirement/boundary using the physical tape meters. Its byte scans, counters and +history are verifier observations, not retained runtime state or selectors. + +## 6. Evidence, failure boundary and remaining obligations + +The complete q3/w2/d2 fixture keeps all 81 high matrices for each of three old +physical prefixes (including duplicate bytes), all 19,683 dirty payload bits, +1,458 coefficient calls, and the predecessor's independent permutation/XOR +oracle. The same 145 roles serve all 243 prefixes. All 261,468 leases retire; +the physical pool retains 1,248 cells after the first prefix and thereafter. + +The separate actual SOURCE87 request1676 calibration executes two specified +dimension-64 high prefixes, the source-produced Program/callback, 13,122 payload +bits and the actual following XOR. It retains the predecessor's independent +payload oracle, wrong-return and wrong-coefficient controls. It never claims +execution of the 3^4096 prefix domain. Calibration-only `.cells` observations +unwrap a lease's physical tape; no runtime algorithm reads those observations. + +Normal/optimized registered verification, exact receipts, under-capacity, +omitted-retirement, forbidden-constructor and dirty-reuse controls are documented +in README/TASK. Their status is reported only after running them. This is +author-checked source reasoning and finite corroboration, not proof-kernel or +independent human acceptance. + +The success contract does not promise rollback of malformed source words, +arbitrary callback exceptions or pool exhaustion. Such a failure can leave a +lease active; subsequent use is refused rather than silently reclaiming it. +Inherited per-prefix cleanup does not establish transactional rollback. +Full original q127/GL64 payload execution, source tariff T, all caller residents, +Context/codebook construction, full node/recursive restoration, stock, precision, +native/compiler/outer admission and a new kappa remain outside this result. diff --git a/research/r437-streamed-leaf-workspace/README.md b/research/r437-streamed-leaf-workspace/README.md new file mode 100644 index 0000000000..b79132b6b9 --- /dev/null +++ b/research/r437-streamed-leaf-workspace/README.md @@ -0,0 +1,131 @@ +# One retained workspace for the streamed R437 leaf and XOR + +The complete repeated leaf/XOR consumer in [#5055](https://github.com/CrocSwap/integer-mult-bounds/pull/5055) +can use one inventory of **q²+136 physical record tapes**, including its copied +input fibres, nested counters, coefficient stacks and erasure. The same +inventory serves every emitted prefix. This supplies the persistent-workspace +part of the predecessor's explicit handoff at its successful, nonrecursive +leaf boundary, with a paid pooling interface. The source traffic T still needs +an all-parameter tariff; whole-caller admission and kappa are unchanged. + +[PROOF.md](PROOF.md) derives the source-bound lifetime and retained-backing +bounds and charges the pooling interface. [pooled.py](pooled.py) specializes the +unchanged predecessor function bytecode, using the existing physical-caller +lease implementation. The producer runs outside the lease scope, preserving +its persistent prefix/reader roles. Every prefix returns the pool blank, +unleased and at its origins. Source Tape/Arena creation inside the consumer +is rejected. + +For complete local fibre size v, complete prefix body D, largest (possibly +extended) Program body P, validated callback depth H and Word widths I,L, set + +``` +A = q²+136 +s = max(2I+4, L+3) +M = max(v, D, P, (2H+3)s, I+3, L+3, bit_length(v)+3). +``` + +A fresh pool retains at most **A(M+2) cells**, independent of the number of +prefixes. For a previously used pool, its entry backing remains charged. +Relative to the original consumer traffic T, the added record-cell charge is +at most `K + 28J + 4AN`, where K is the number of leases, J the number of +temporary callback closes and N the emitted prefixes. The interval starts with +prepared LEFT markers and heads; preparing blank tapes at their origins costs +A writes and A unit moves once. Ordinary copies, movement, normalization and erasure +remain in T. The proof inherits the existing lexical q²+128 source-role bound; +the measurements below are corroboration, not its proof. + +## Evidence and scope + +[RESULT.json](RESULT.json) records two distinct tests: + +| Replay | Complete small cube | Actual SOURCE87 calibration | +| --- | ---: | ---: | +| Prefixes executed | 243 (all 3×81) | 2 selected dimension-64 prefixes | +| Complete dirty payload bits | 19,683 | 13,122 | +| Physical pool inventory | 145 | 145 | +| Observed peak leases | 27 | 28 | +| Acquisitions, each uniquely retired | 261,468 | 134,854 | +| Retained pool cells after first and final prefix | 1,248 | 199,666 | +| Retained predecessor callback calls | 1,458 | 24 | + +The small cube preserves duplicate physical prefixes, all nonzero high digits, +source order, every callback and the independent whole-payload permutation/XOR +oracle. The separate actual calibration uses request1676's source-produced +Program, nontrivial coefficient histories and complete local returns. Its +two-prefix restriction is explicit: it does not execute the 3^4096 high domain. + +At **every** boundary, the verifier checks identical physical tape identities, +all backing blank, exact acquisition/retirement equality, and conservation of +all physical reads/writes/unit moves against lease, allocation and boundary +meters. Every physical scratch clear is checked against its exact head/body +tariff, including hidden nonblank-tail rejection. Checker scans and histories +do not drive runtime decisions. Four deliberate defects must fail for their +specified reasons: insufficient roles, omitted fibre retirement, a raw Tape +constructor, and a dirty role before reuse. Inherited payload/corruption checks +remain active under both ordinary and optimized Python. + +Base main: `a5df48c55ea806d7952b65acc9c76d878ff09b13`; priority revision 7, +refined `r437-carrier-integration` card. The scoped claim is +[#4682 comment19144606](https://github.com/CrocSwap/integer-mult-bounds/discussions/4682#discussioncomment-19144606). +[TASK.json](TASK.json) records scope, value, stop conditions and follow-up. +[SOURCES.json](SOURCES.json) pins 414 live input files and three provenance +records. The loader uses the predecessor's explicitly retained historical +selected record; it does not admit today's selected #4470 frontier. + +## Reproduce + +Python 3.12, standard library only. From repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/r437-streamed-leaf-workspace --check-only +python3.12 -B scripts/research_package.py --package research/r437-streamed-leaf-workspace +``` + +The registered run executes ordinary and optimized modes, each bounded to +600 seconds. Direct commands, also usable in the committed Git-free export: + +```sh +python3.12 -I -W error -B research/r437-streamed-leaf-workspace/verify.py +python3.12 -I -W error -O -B research/r437-streamed-leaf-workspace/verify.py +``` + +Each mode runs fixtures and failure controls in separate isolated processes, +then compares the complete deterministic receipt. `--write` intentionally +regenerates that receipt. `--mode generic` and `--mode actual` print diagnostic +JSON. All external inputs are explicitly declared in [VERIFY.json](VERIFY.json). +The generic registered runner additionally checks Git provenance. + +## Limits + +The uniform statement uses the default inventory. For an explicitly larger +pool, replace A by its actual capacity in the backing and boundary charges. +The statement requires the authenticated synchronous source callback, +sufficient supplied numerical arenas and the stated true source maxima. It +excludes arbitrary callback/event producers and exceptions. A failed callback +may leave leases live; there is no transactional rollback guarantee. The full +source/target/output packets, old directory, producer roles, arenas, Program, +codebook and suspended owners remain separately charged. This is a physical +record-tape bound, not a measurement of Python process memory. + +## Open next questions + +The substantive next step in [TASK.json](TASK.json) is to connect this successful +local boundary to a complete R437 node's canonical ownership and recursive +return contract, retaining the producer and full-packet residents and giving +the source traffic T an explicit parameter tariff. Start with the unchanged +call/return owners and the two source-bound ledgers; do not infer a smaller +global reserve from the local 27/28-lease observations. Context/codebook cost, +precision/stock and native/compiler/outer admission remain separate obligations. + +## Attribution + +Krzysztof Wójt, with substantial OpenAI Codex assistance, including Luna +supporting source, coordination and metadata audits; primary-agent integration +and verification. New work is Apache-2.0. + +JoyboyBrian retains credit for #5055's streamed producer/consumer and #4981's +actual SOURCE87 fixtures and independent oracles. Jose Manuel retains credit +for the physical caller's ScratchPool and source-role proof; David Arias for +the logical caller; Chris R for the R437 integration bridge. All retained +predecessor author and licensing notices remain in the pinned source chain. diff --git a/research/r437-streamed-leaf-workspace/RESULT.json b/research/r437-streamed-leaf-workspace/RESULT.json new file mode 100644 index 0000000000..e431f9539b --- /dev/null +++ b/research/r437-streamed-leaf-workspace/RESULT.json @@ -0,0 +1,567 @@ +{ + "actual64": { + "borrowed_preserved": true, + "bound_parameters": { + "callback_depth": 2, + "fibre": 6561, + "index_bits": 13, + "prefix_body": 62180, + "program_body": 13292, + "q": 3, + "residue_bits": 5 + }, + "child_width": 2, + "complete_fiber_bits": 6561, + "consumer_sha256": "0f8e16924fd79d5c002ecafd4b77ac929a97f186b71c9fcf64992c6490a126f2", + "controls": [ + "canonical high digit", + "actual selected rank", + "one-bit wrong return changes actual SOURCE87 consumer", + "stale prefix0 coefficient vector changes second fiber", + "inverse-weight substitution changes actual output" + ], + "eager_callback_calls": [ + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 0, + "value": 8 + }, + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 0, + "value": 8 + }, + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 1, + "value": 5 + }, + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 1, + "value": 5 + }, + { + "coordinate": 0, + "negative_inverse": true, + "prefix": 0, + "value": 1 + }, + { + "coordinate": 0, + "negative_inverse": true, + "prefix": 0, + "value": 1 + }, + { + "coordinate": 0, + "negative_inverse": true, + "prefix": 1, + "value": 7 + }, + { + "coordinate": 0, + "negative_inverse": true, + "prefix": 1, + "value": 7 + }, + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 0, + "value": 8 + }, + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 0, + "value": 8 + }, + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 1, + "value": 5 + }, + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 1, + "value": 5 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 0, + "value": 2 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 0, + "value": 2 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 1, + "value": 8 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 1, + "value": 8 + }, + { + "coordinate": 1, + "negative_inverse": true, + "prefix": 0, + "value": 4 + }, + { + "coordinate": 1, + "negative_inverse": true, + "prefix": 0, + "value": 4 + }, + { + "coordinate": 1, + "negative_inverse": true, + "prefix": 1, + "value": 1 + }, + { + "coordinate": 1, + "negative_inverse": true, + "prefix": 1, + "value": 1 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 0, + "value": 2 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 0, + "value": 2 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 1, + "value": 8 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 1, + "value": 8 + } + ], + "fixture_edits": [ + 2, + 1, + 1, + 28, + 1 + ], + "full_high_cube_count": { + "bits": 6493, + "sha256": "4acde110321e89dc1be1c4b81709f91e8298a1bbff8c80d0d86adaf5b112eac2" + }, + "full_high_cube_executed": false, + "fused_callback_calls": [ + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 0, + "value": 8 + }, + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 0, + "value": 8 + }, + { + "coordinate": 0, + "negative_inverse": true, + "prefix": 0, + "value": 1 + }, + { + "coordinate": 0, + "negative_inverse": true, + "prefix": 0, + "value": 1 + }, + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 0, + "value": 8 + }, + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 0, + "value": 8 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 0, + "value": 2 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 0, + "value": 2 + }, + { + "coordinate": 1, + "negative_inverse": true, + "prefix": 0, + "value": 4 + }, + { + "coordinate": 1, + "negative_inverse": true, + "prefix": 0, + "value": 4 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 0, + "value": 2 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 0, + "value": 2 + }, + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 1, + "value": 5 + }, + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 1, + "value": 5 + }, + { + "coordinate": 0, + "negative_inverse": true, + "prefix": 1, + "value": 7 + }, + { + "coordinate": 0, + "negative_inverse": true, + "prefix": 1, + "value": 7 + }, + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 1, + "value": 5 + }, + { + "coordinate": 0, + "negative_inverse": false, + "prefix": 1, + "value": 5 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 1, + "value": 8 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 1, + "value": 8 + }, + { + "coordinate": 1, + "negative_inverse": true, + "prefix": 1, + "value": 1 + }, + { + "coordinate": 1, + "negative_inverse": true, + "prefix": 1, + "value": 1 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 1, + "value": 8 + }, + { + "coordinate": 1, + "negative_inverse": false, + "prefix": 1, + "value": 8 + } + ], + "fused_consumer_sha256": "0f8e16924fd79d5c002ecafd4b77ac929a97f186b71c9fcf64992c6490a126f2", + "fusion_invoice": { + "index": { + "moves": 843198, + "reads": 859628, + "writes": 177448 + }, + "record": { + "moves": 43706266, + "reads": 50531411, + "writes": 10278018 + }, + "residue": { + "moves": 173048120, + "reads": 165628640, + "writes": 34082134 + } + }, + "global_fiber_offsets": [ + { + "bits": 6498, + "sha256": "b2b36d04fd96500a40dd12c2b324767cf611604882bbe53fec169e03944e8c3e" + }, + { + "bits": 6498, + "sha256": "c8c7ca64fcdbf9a736c359099b045ee3d1ea7ee011730d26b07dc6f278ac66a6" + } + ], + "global_high_indices": [ + { + "bits": 6486, + "sha256": "d5e0075b1dac0a9498d27ef42281f4e9905c83ce6c8a4eba3475b374fd70561c" + }, + { + "bits": 6486, + "sha256": "7238e2dfd72a89b6e6e34610046f5adfa6ad25fb3cd65d6575ee3862583c6c85" + } + ], + "invoice": { + "index": { + "moves": 1741826, + "reads": 1775631, + "writes": 366760 + }, + "record": { + "moves": 89542666, + "reads": 103519805, + "writes": 21054105 + }, + "residue": { + "moves": 350343834, + "reads": 335348488, + "writes": 69038399 + } + }, + "literal_consumer_event": [ + 1, + 467, + 87, + 1, + 509, + 0 + ], + "literal_consumer_position": 22398, + "live_inputs": 401, + "local_child_return_lengths": [ + 6561, + 6561 + ], + "modulus": 9, + "numerical_admitted": false, + "owned_erased": true, + "pooling_surcharge_bound": 136686, + "produced_program_sha256": "a8293367597b7cb38efad9fd7b23224425b7d515b8088bf0302f225246a75ab0", + "q": 3, + "return_sha256": "4190faad3418b114a03f8116aaf352aafd2717109fef13827483f6c12306bc50", + "root_width": 2048, + "scope": "Two actual SOURCE87 prefixes and full computed leaf/XOR payload; not full high-domain execution or admission.", + "selected_prefix_count": 2, + "source_identity": "d854ee52df07cce2a47ded48539f6c25266c0c6f245c7b10a5dcafbb03f71a3b", + "source_request": 1676, + "status": "PASS_R437_STREAMED_LEAF_WORKSPACE_ACTUAL64", + "total_executed_bits": 13122, + "uniform_bound": { + "body_bound": 62180, + "fresh_retained_cells": 9016390, + "roles": 145, + "stack_record": 30, + "with_entry_reserve": 9016390 + }, + "w": 2, + "weights": [ + [ + 8, + 2 + ], + [ + 5, + 8 + ] + ], + "workspace": { + "acquisitions": 134854, + "allocation_and_boundary_actions": 136014, + "backing": 199666, + "backing_constant_after_first_prefix": true, + "callback_closes": 24, + "clear_actions": { + "moves": 7695948, + "reads": 7561094, + "writes": 3322300 + }, + "clear_calls": 134854, + "first_prefix_backing": 199666, + "largest": 62181, + "lease_actions": { + "moves": 36316620, + "reads": 40249370, + "writes": 10002642 + }, + "peak": 28, + "prefixes": 2, + "record_actions": { + "moves": 36317200, + "reads": 40384804, + "writes": 10002642 + }, + "retired": 134854, + "roles": 145 + } + }, + "authenticated_inputs": 414, + "generic": { + "bound_parameters": { + "callback_depth": 0, + "fibre": 81, + "index_bits": 8, + "prefix_body": 60, + "program_body": 0, + "q": 3, + "residue_bits": 5 + }, + "complete_consumer": { + "actual_leaf_and_xor": true, + "callbacks": 1458, + "fibre_bits": 81, + "output_sha256": "c74d323c6de93c1b73f8cc5235cc4407e564248735c3725d3ff40b87c00b7665", + "packet_bits": 19683, + "prefixes": 243, + "word_inspect_disabled": true + }, + "controls": [ + "duplicate physical prefixes retained", + "nonzero high-cube order", + "independent complete payload oracle", + "callback failure clears fixed producer stores", + "invalid new code rejected before callbacks", + "complete out-of-range old high rejected with cleanup", + "omitted physical prefix rejected after162 callbacks" + ], + "live_inputs": 406, + "pooling_surcharge_bound": 402408, + "producer": { + "dimension": 2, + "directory_bytes": 14580, + "emitted": 243, + "highs": 81, + "max_current_prefix_bytes": 60, + "no_record_constructor_in_emission_loop": true, + "old_physical_prefixes": 3, + "one_current_prefix_role": true, + "q": 3, + "sha256": "2eb4b8a1637eaba05348053ad195b29bda1c228932f3b31e9af2478abba01337", + "w": 2 + }, + "scope": "Complete q3/w2/d2 high cube with the same physical scratch pool; no production GL64 replay.", + "status": "PASS_R437_STREAMED_LEAF_WORKSPACE_GENERIC", + "uniform_bound": { + "body_bound": 81, + "fresh_retained_cells": 12035, + "roles": 145, + "stack_record": 20, + "with_entry_reserve": 12035 + }, + "workspace": { + "acquisitions": 261468, + "allocation_and_boundary_actions": 402408, + "backing": 1248, + "backing_constant_after_first_prefix": true, + "callback_closes": 0, + "clear_actions": { + "moves": 4296969, + "reads": 4035501, + "writes": 1426410 + }, + "clear_calls": 261468, + "first_prefix_backing": 1248, + "largest": 82, + "lease_actions": { + "moves": 19682028, + "reads": 18819864, + "writes": 6124329 + }, + "peak": 27, + "prefixes": 243, + "record_actions": { + "moves": 19752498, + "reads": 19151802, + "writes": 6124329 + }, + "retired": 261468, + "roles": 145 + } + }, + "numerical_admitted": false, + "scope": "Uniform successful leaf/XOR workspace refinement, with separate complete small-cube and two-prefix actual64 evidence.", + "selected_frontier_changed": false, + "status": "PASS_R437_STREAMED_LEAF_WORKSPACE", + "workspace_controls": [ + { + "control": "capacity", + "reason": "fixed scratch role inventory exhausted", + "rejected": true + }, + { + "control": "omitted-retirement", + "reason": "completed macro closes all scratch leases", + "rejected": true + }, + { + "control": "raw-constructor", + "reason": "physical Tape allocation inside a completed macro", + "rejected": true + }, + { + "control": "dirty-reuse", + "reason": "empty scratch role before reuse", + "rejected": true + } + ] +} diff --git a/research/r437-streamed-leaf-workspace/SOURCES.json b/research/r437-streamed-leaf-workspace/SOURCES.json new file mode 100644 index 0000000000..f1ad32ccb8 --- /dev/null +++ b/research/r437-streamed-leaf-workspace/SOURCES.json @@ -0,0 +1,2508 @@ +{ + "schema_version": 1, + "base_commit": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/bit-p111-r437-gl464-470-20261018/code/invoice_audit.py", + "usage": "input", + "git_blob": "f3ae8ab88bd82dff41899d682e2e087b0d9683f1", + "sha256": "8bcf640e1e27313c92c00a7a76e72d8ae995360899d178221d1c65cf9b6dda6d" + }, + { + "path": "research/bit-p111-r437-gl464-470-20261018/data/GEOMETRY.json", + "usage": "input", + "git_blob": "7158a5c55b0001a526dab6e816b7b98f0527a202", + "sha256": "b9ed0e5e0084dcd285f33bfc71aab833ddcfa1062bd80c9c83da8244276d6830" + }, + { + "path": "research/bit-p111-r437-gl464-470-20261018/vendor/assemble9.py", + "usage": "input", + "git_blob": "7c49dc0756118b2b8d90c59478cd9d54b17d4ba7", + "sha256": "808ef620230ac0ccb4c4b31a02288936fbe0be6d9b3ff715bbe828848d4642d1" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz", + "usage": "input", + "git_blob": "9eafb8776cbf78c72124f833534469ddfa5e98ec", + "sha256": "0357b7cfbd7c29b4983982baf153c8a9f1e1e412690cd7fa9fc3d23d7963b20f" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json", + "usage": "input", + "git_blob": "44006542202ca6037533a754f0bcd00549d7e088", + "sha256": "0058c491d839142aa99ef86a5ec697ce99857632228531512ea3fa74fb24d734" + }, + { + "path": "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "usage": "input", + "git_blob": "e293ddc557742637f9f679f083a1a282d87b1b13", + "sha256": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4" + }, + { + "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "usage": "input", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + { + "path": "research/encoded-child-spectators/CERTIFICATE.json", + "usage": "input", + "git_blob": "4879b20afb732ad503f8b0b576018e4d738fdf32", + "sha256": "bb66ad1cdf009c6ac81c0911ed428782aa618089506b1c7c03bdc97634e4c662" + }, + { + "path": "research/encoded-child-spectators/CONTEXT.json", + "usage": "input", + "git_blob": "1862e89a14469f01262c8bd042a89dedf7ebb556", + "sha256": "2df933c9d3b00c34a92a1eb2dba685cde12d9dd71598aab15a401e8b15f793ab" + }, + { + "path": "research/encoded-child-spectators/PROOF.md", + "usage": "input", + "git_blob": "0e4bbcf04f1a2502bae7f47d5376a72de74fb36a", + "sha256": "cf439a2ffe2bc8521377225400306df7c829af194dc6d8614a4383c7741616a2" + }, + { + "path": "research/encoded-child-spectators/README.md", + "usage": "input", + "git_blob": "c4373db5f3f22b91f51a13df62a0a5329580cc83", + "sha256": "05ab321b1ec220375115ca28fc1113edafd530d4e147e09e8534b7172661df77" + }, + { + "path": "research/encoded-child-spectators/SOURCES.json", + "usage": "input", + "git_blob": "32e976d4de444421b90138daf4597f7f5b68dafa", + "sha256": "826d4dcdc29c66b7395bad8de9201dafee12aa5aa0eaf2772b14e621439daf44" + }, + { + "path": "research/encoded-child-spectators/TASK.json", + "usage": "input", + "git_blob": "3dba6e551d43b346f02d164a139f08129e33a3f0", + "sha256": "5a72c1cd351594db7b7a29b863bec101cebd87ea9463f57f0077a74ae3c83c53" + }, + { + "path": "research/encoded-child-spectators/TIMINGS.json", + "usage": "input", + "git_blob": "9d97cda48d5318b6f4e84416bb0944aad4ffbda1", + "sha256": "d96d3a255213085ee42e1c5eaa0d16398cbdfd49161d48a76fef8a45905d359c" + }, + { + "path": "research/encoded-child-spectators/VERIFICATION.md", + "usage": "input", + "git_blob": "15de5fadd2a0fe2c23d2803656cec4859a27df26", + "sha256": "920f834f8c71856c464ea6f10b8f731d8b6b00d6897f4fd36bab28ac3b4dfc7d" + }, + { + "path": "research/encoded-child-spectators/VERIFY.json", + "usage": "input", + "git_blob": "9b1f60364dc5185b23587ee186b7dec8e78a7fc1", + "sha256": "7e9ff87a25c83d62cf926a7bbc4078b4efcaf36fc3c9018d90918f722a1fc1ea" + }, + { + "path": "research/encoded-child-spectators/bench.py", + "usage": "input", + "git_blob": "cbb9366545427c1f8ce7c84e74ad5cf7ac0c9486", + "sha256": "a4775c6c5f3ea3d30e628ebd817599b9949729ee0afd542996260a3be6533c38" + }, + { + "path": "research/encoded-child-spectators/cases.py", + "usage": "input", + "git_blob": "9b3f3e8caa66ea4d54290af9daa7a10b5f07786f", + "sha256": "3b4d727e62774c3aa562f9523f8b75dc2e805f73a11da77b7e4f58e68eb14a0c" + }, + { + "path": "research/encoded-child-spectators/controls.py", + "usage": "input", + "git_blob": "bd5d499af8ae177cd822847c248e18f6770accb6", + "sha256": "521a6be551cf9ac5b6cca1c7a293ed8626a40ed93123e2176f601a80f1295aa8" + }, + { + "path": "research/encoded-child-spectators/independent.py", + "usage": "input", + "git_blob": "7ae21806d1157a52590625e55c6cdb277991c420", + "sha256": "3208e500407ce95a15bf0e32461fecb9a416e4708cd86e034e96c26fa4073b7e" + }, + { + "path": "research/encoded-child-spectators/powers.py", + "usage": "input", + "git_blob": "b22a76cffbe6404833a87793c001f53fb09d4d25", + "sha256": "dd8c150dfa07a594651f64156ec696153fb71e8423df382f11c18f5859b662e7" + }, + { + "path": "research/encoded-child-spectators/runtime.py", + "usage": "input", + "git_blob": "56deefc868c673e717b6491563c69afa1514eabf", + "sha256": "ff4004769e01e888c0e4d9ae9d13417e7f757b4acf3aaac696087d0e5afa10e8" + }, + { + "path": "research/encoded-child-spectators/tariff.py", + "usage": "input", + "git_blob": "df1efb5aeb1c1f54e7dcc07a9754a16e94b6c557", + "sha256": "4fc26570cd637fb761a900ecba75bedf60b3d4f4b10325df0cca7c1e72bac57e" + }, + { + "path": "research/encoded-child-spectators/verify.py", + "usage": "input", + "git_blob": "c8b5ac757501747d983ba8573723310fe2d4f12f", + "sha256": "17b2c37e783a9148f0ff532bd944814c087f8bebbf59dafe574ce9ff021ceede" + }, + { + "path": "research/physical-compiler-correspondence/README.md", + "usage": "input", + "git_blob": "1b542517f938ef64a25155f96214ba332d8ce623", + "sha256": "bb04d8a05f0fbda2df0dc653118524ecaace3d22dd924179574fc115524df901" + }, + { + "path": "research/physical-compiler-correspondence/owners.py", + "usage": "input", + "git_blob": "3fdf157278aa00308df706e11fc4a9e428b05e66", + "sha256": "220918b53e45c5992471bb2fd0a95e62f410679048f3517504c851077ee94845" + }, + { + "path": "research/pr589-five-helper-hosting/PROOF.md", + "usage": "input", + "git_blob": "bbd3f12b9a32b3ad3cba85a2d5a1b3054214fa02", + "sha256": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647" + }, + { + "path": "research/pr589-five-helper-hosting/verify.py", + "usage": "input", + "git_blob": "dbc71f56bb4205ebe378ada1f9f4ea88630d1d39", + "sha256": "cf90e19ae9991b0698be03d395a8cc29061ecb307eb7fea19adfb2d23c25a367" + }, + { + "path": "research/r437-carrier-integration/admission.py", + "usage": "input", + "git_blob": "3e7586146545ca80891c11cb8b5a34f47b0ba607", + "sha256": "d34f0166a936decc4de0cc07ab4f8ca8dac6ac03f83b74b85a851098c01f3eae" + }, + { + "path": "research/r437-carrier-integration/compiler.py", + "usage": "input", + "git_blob": "345a84013327224c5c2c96232811b59262efcfe1", + "sha256": "df86b31a80e1827dc20a3a34f20305b4b9cbd3582e3d26b8a05ac90e346177fb" + }, + { + "path": "research/r437-carrier-integration/numerical.py", + "usage": "input", + "git_blob": "d3411758be96f22f8d64e02ba278dc46b21639c5", + "sha256": "83f2b60a90ab2d0354c5c84f48af246ab416605c3ae4bd62368bbe5f23bb53bb" + }, + { + "path": "research/r437-carrier-integration/physical.py", + "usage": "input", + "git_blob": "e314799b5c6deeb45a790534539d846a27d2d60c", + "sha256": "d41ea48bc8fd6e449ef17f122dfbea05adf06e7ab448063e4afd06add1152cf0" + }, + { + "path": "research/r437-oq4-caller-binding/RANK26-COST.md", + "usage": "input", + "git_blob": "15809a6154ef189cb6c2fe1c8bf3dd6459f90bec", + "sha256": "cf6e472ff945ee4c3d5dc5407aa9aa7751022819846c4d7380cb697e227b0cc9" + }, + { + "path": "research/r437-pooled-native-interface/.gitattributes", + "usage": "input", + "git_blob": "a154a13b7c8d4590e03a6949ed1e76c102fd1dbd", + "sha256": "a3c414970082c100e8f9cec6d96b7d5eec4c31660d670b50d46f2d8ac53a3b76" + }, + { + "path": "research/r437-pooled-native-interface/PROOF.md", + "usage": "input", + "git_blob": "24816d8dfb5e07978c3d7ad5010d25605d3f9a03", + "sha256": "695c3416094ee374a6b5d5152c80ce29f18358eda21e3afb7b58c2264a6d879c" + }, + { + "path": "research/r437-pooled-native-interface/README.md", + "usage": "input", + "git_blob": "6187399f1c7d947cd13f3fb064fb7b65b6d93290", + "sha256": "be6c7a6fae80047631d926e83c73a217037cfdccdc38a5e6d0f4c38865f1ca14" + }, + { + "path": "research/r437-pooled-native-interface/RESULT.json", + "usage": "input", + "git_blob": "4a03e803bfb3fe7af6808f655b9b6e828574d212", + "sha256": "27a20d575cb90c16a186a621d553e167f2bb6fd4e19541fe8d8dfc0208451658" + }, + { + "path": "research/r437-pooled-native-interface/SOURCES.json", + "usage": "input", + "git_blob": "d0987e871ac318a208bed473540ace42cbd9eaf5", + "sha256": "219bcca3f47aa555cc7c9e126ccbee3509fe7e4fe29b4968b4357ae9c1f0a006" + }, + { + "path": "research/r437-pooled-native-interface/TASK.json", + "usage": "input", + "git_blob": "31286abc91a461677a93d1c38c0895c7f00e074b", + "sha256": "f8348e1128757b7e42650100f24c690f368c230f7c72c3613617a1105fba2fc7" + }, + { + "path": "research/r437-pooled-native-interface/VALIDATION.md", + "usage": "input", + "git_blob": "ba071214dd6ad7bfe863a35856ae2f2e1b3bd11f", + "sha256": "b3b4978ca4540ea1d6083f6ba77b957750afeed222e2048f046ee62b5f31a590" + }, + { + "path": "research/r437-pooled-native-interface/VERIFY.json", + "usage": "input", + "git_blob": "885be188550090829a166baad4cc21b581ea0515", + "sha256": "c23da87b8d9cb87b651b987a71fbf76811b182be474f42dc5273c7d13e4bab2b" + }, + { + "path": "research/r437-pooled-native-interface/adapter.py", + "usage": "input", + "git_blob": "276a9a0f436ba03e2a0bb1cd95d57ebc3cc3a290", + "sha256": "c1c054e5a2c650cfc267117b32896073e6735b93c5fbfb1defe6e379c4afab9e" + }, + { + "path": "research/r437-pooled-native-interface/check_interface.py", + "usage": "input", + "git_blob": "d44bcf750f121ddd276f09ce94d8d898a3d52078", + "sha256": "b4f5fab63a262e36b5d585ad9ed6bb9436ecb8183eae233b27c8da9c448128d4" + }, + { + "path": "research/r437-pooled-native-interface/check_transport.py", + "usage": "input", + "git_blob": "5bd3c8a38aed9df3b0d4404d382268aee02dfcb3", + "sha256": "c1351777d8886754a172ed3f6e90586be5c664a93b66eda5e87fa9580f104ab7" + }, + { + "path": "research/r437-pooled-native-interface/inputs/EXPECTED.json", + "usage": "input", + "git_blob": "bc2585e1404402395a7c59ba6f6dde58b04e65a2", + "sha256": "67d06bcb90d2307a11975d6b25107a695be477f168f2dc289b8484ba0b7e2de0" + }, + { + "path": "research/r437-pooled-native-interface/inputs/catalogue.py", + "usage": "input", + "git_blob": "0efc0575a7623ac41c094d2e8772beda5a9fdc29", + "sha256": "83ea88f82d4a83c5f889774bfe3519b7ebaa24b6a0e2a969dafff012107a89bf" + }, + { + "path": "research/r437-pooled-native-interface/inputs/geometry.json.gz", + "usage": "input", + "git_blob": "a01a33c4753955ec4707db9515cee82a567cc1cb", + "sha256": "edcaebb35d313f403b2db45a2cf808617f921c83cf7a11dd5d74356570ede1a8" + }, + { + "path": "research/r437-pooled-native-interface/inputs/moves.json", + "usage": "input", + "git_blob": "2cdb414a38cff6f0b872445f0980f2e3bc1895eb", + "sha256": "0a58b239795d213743b5654c59a3e4622a0ddd4a53d8dba3fa30dedef4558dff" + }, + { + "path": "research/r437-pooled-native-interface/inputs/template.json.gz", + "usage": "input", + "git_blob": "f56efc7ca3648d2070b791d4551a3d77dd7fdde4", + "sha256": "6e03c76f5a4227394ea57e901eb7e93f4d1ee411ccfecd483fd44ea043550494" + }, + { + "path": "research/r437-pooled-native-interface/inputs/word.json.gz", + "usage": "input", + "git_blob": "c558a221dd44cbdaa732a401f9876de4c096d4a7", + "sha256": "e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e" + }, + { + "path": "research/r437-pooled-native-interface/pooled_compiler.py", + "usage": "input", + "git_blob": "512047d8b99628b097f5a597761e6647b424c92e", + "sha256": "fa1c589e5809ba8223eaf070cfb299bf55d843889d360b4d089824eb675e177c" + }, + { + "path": "research/r437-pooled-native-interface/replica_catalogue.py", + "usage": "input", + "git_blob": "1fa6ea58c5193952bc6175cbb9f1a778a6502eac", + "sha256": "d093a5a5421596d82c6c6e9fbc7fbf3f313c803a7ba423d666b98344b1912ff3" + }, + { + "path": "research/r437-pooled-native-interface/verify.py", + "usage": "input", + "git_blob": "4a470e1e9961308c094dd167df7535b26b17e035", + "sha256": "dcbe8cdfee38ce0beff30c48a07a07009f4f054fd11454a80e834188547c2ffd" + }, + { + "path": "research/r437-prefix-consumer-fusion/PROOF.md", + "usage": "input", + "git_blob": "6c8dd2daa3c29827995232f467cb0e84c59a3efd", + "sha256": "6bcf00dda6663a03df7046eb9cd6987293e4f6283a63de8ccdbbc056fe357e05" + }, + { + "path": "research/r437-prefix-consumer-fusion/SOURCES.json", + "usage": "input", + "git_blob": "27867d32645153f3e8333f43ad95b9e6f2f4c34d", + "sha256": "2cb1a1b4293a536fc6b990cb7d6e1ccd017db2edd3aec89c07814f87f380fbb1" + }, + { + "path": "research/r437-prefix-consumer-fusion/adapter.py", + "usage": "input", + "git_blob": "6be0e87fdb34a70f9c08ed634ab242a637325463", + "sha256": "1d0f495b5771ba4c1622035e58b646407c7fa2018d9af7fa90a9acecab63bd6c" + }, + { + "path": "research/r437-prefix-consumer-fusion/retained/selected-result.json", + "usage": "input", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "research/r437-prefix-consumer-fusion/verify.py", + "usage": "input", + "git_blob": "2e3c7fd7de352969afae7f5153d74980960d1e11", + "sha256": "660315073f615d4ef14f09c23a30c71ea963362bbb61a5d770abaf3fc283d40f" + }, + { + "path": "research/r437-preparation-composition/.gitattributes", + "usage": "input", + "git_blob": "fa1385d99a319b43c06f5309d1aae9fdd3adea46", + "sha256": "705fd4d6451a31d36b3df7de96f83f30ac976c9b4a6d1e51671d8e2f33e2d0da" + }, + { + "path": "research/r437-preparation-composition/POOLED-SOURCES.json", + "usage": "input", + "git_blob": "439c24dc2cbf055edae246ea8d34f57b8a73fe2b", + "sha256": "95635c15a09cdac656e91b3a13ad2bf481ef4ffdcf67c7dd3c27b8400b2751ef" + }, + { + "path": "research/r437-preparation-composition/PREDECESSORS.json", + "usage": "input", + "git_blob": "7b48c3de7c5ec00971fc8d0694d363da5146afe4", + "sha256": "61ae906bee904905b283164a2238f3640772217ccede0b53d1f7d168a90040af" + }, + { + "path": "research/r437-preparation-composition/PROOF.md", + "usage": "input", + "git_blob": "7dff5622034394009f908a659f20aa511e6becc2", + "sha256": "21c5b5a914a5417a385c41b800934c0b2e155ffef89681a6166465393f1cf7ea" + }, + { + "path": "research/r437-preparation-composition/README.md", + "usage": "input", + "git_blob": "ee2d04215e35646a1c013c39e8840744aeb0ef8c", + "sha256": "413362271e8c3ad44aba1fcc751dc683fafa4c7ea694d9bcc05325a37f25cd20" + }, + { + "path": "research/r437-preparation-composition/RESULT.json", + "usage": "input", + "git_blob": "2ff963ad94b7385a35e3ea5498c0e9bdc1f995bb", + "sha256": "372425e00746955d68c4d86afe8db4f5ca4ad6b9ff4031349af4f5bb42ece436" + }, + { + "path": "research/r437-preparation-composition/REVIEW.md", + "usage": "input", + "git_blob": "95702631001f9aa0d43cd5ea94b75d77de728f6e", + "sha256": "88b2996b16228d536c5ca8cf8192b84fcdc03605eb05795f2a7c2185adf40594" + }, + { + "path": "research/r437-preparation-composition/SOURCES.json", + "usage": "input", + "git_blob": "0839f4876a67fc26084ae94d832ccd69d2b5edb7", + "sha256": "e5822ba1b619af70e55e88a0b4bf81eddd8497bc98b5aac7b00c9d6b63b64bf9" + }, + { + "path": "research/r437-preparation-composition/TASK.json", + "usage": "input", + "git_blob": "553e385d2bac17fa42b167ec1a7b9bd38aedb5f4", + "sha256": "d3bcf16d46934bd2a802abdf07deba619c2f296aa64993d36e82cf59b9ed71ab" + }, + { + "path": "research/r437-preparation-composition/VALIDATION.json", + "usage": "input", + "git_blob": "afc5065b998c4c5adf0b50c053d01aab4a463ed8", + "sha256": "cbb9d97b34552467dc9f1eca1f9270e01381314061cc4d72cd9dafc22a880e37" + }, + { + "path": "research/r437-preparation-composition/VERIFY.json", + "usage": "input", + "git_blob": "3b839256f00c29f983f74a46e65caf4c956a3226", + "sha256": "bc6d10d1d310bdc11d94e32f0245fadc5f3ac1e9469e4029b37e2b235b9c431c" + }, + { + "path": "research/r437-preparation-composition/forward_fields.py", + "usage": "input", + "git_blob": "45dcf2467f2167293fada94ba93d6e9d367de18b", + "sha256": "4b6cb4b8a20c920c32dbad7b8e99a728d75681b0b4cdc876f4bd60730302a83b" + }, + { + "path": "research/r437-preparation-composition/independent.py", + "usage": "input", + "git_blob": "83fcd9d882ea8f70385e5c2607e5c537d1d5343a", + "sha256": "d8f29ab18fadad315c3fe86b5a3d9877dc65c602156d479d5b52ea9210dd295c" + }, + { + "path": "research/r437-preparation-composition/predecessor4025/source/CALLER.py", + "usage": "input", + "git_blob": "5a032e8923f7f8b22bb98f3e39b804beb9906c16", + "sha256": "7bc6e42072a09a08ac961e05c3da01cde012d740d4b4c605f298d994f2ad7c5a" + }, + { + "path": "research/r437-preparation-composition/predecessor4025/source/NOTICE.md", + "usage": "input", + "git_blob": "ef9f81510db86eaf2f0a7191d85e92a6db30ddc0", + "sha256": "c446b32b8a621844fb2fbe654810c8122035bdd43fed2132f1137d98cb6f9943" + }, + { + "path": "research/r437-preparation-composition/predecessor4025/source/cardinality.py", + "usage": "input", + "git_blob": "b8ba857e32c5903408e1e61ff916300848b4a208", + "sha256": "505d5e560c5a507e6184edcc19a87cf1fed243eb34a5cb21fbe1e4fe017e7f22" + }, + { + "path": "research/r437-preparation-composition/predecessor4025/source/counts.py", + "usage": "input", + "git_blob": "81b48940ce222290a40d4fb349ce827f4788469d", + "sha256": "00b476dbda0e8cc99886bf794439e1cb9e775f435f599a3557e99321fe084069" + }, + { + "path": "research/r437-preparation-composition/predecessor4025/source/directory.py", + "usage": "input", + "git_blob": "c74cacf5ce809c0561d374f137a52df0992b4226", + "sha256": "4270e370b2bfe38ef73aadcd97d1b3496b56bd582115d74331eb9e5ceb90bec7" + }, + { + "path": "research/r437-preparation-composition/predecessor4025/source/records.py", + "usage": "input", + "git_blob": "4f00467a0ff580954ad2fd0c7380240c753ddef3", + "sha256": "0c9c4b23e998597fb877bb1a29da69ac869b68262abe635b162b4dba9c69b372" + }, + { + "path": "research/r437-preparation-composition/predecessor4025/source/stream.py", + "usage": "input", + "git_blob": "5e5a4bb0f98971447043e25d4dd6991bfc070389", + "sha256": "c7dc7da5b00f27016982ada4c0416f8328568b00df16d97012f33d4b372d79b5" + }, + { + "path": "research/r437-preparation-composition/predecessor4025/source/words.py", + "usage": "input", + "git_blob": "8d4ba37e2778acb35b34e0719df2caf138fbeb50", + "sha256": "5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9" + }, + { + "path": "research/r437-preparation-composition/predecessor4025/verify.py", + "usage": "input", + "git_blob": "614e57282c0edfe39f1afe45d140cf338210e62a", + "sha256": "b2c72707bebb9ecdba2b89675830439393e6e13c76f68dad20d42d6ef70e539a" + }, + { + "path": "research/r437-preparation-composition/test_verify.py", + "usage": "input", + "git_blob": "ff9a2c364dfafc9188beb7429d58ea0f5e9732e7", + "sha256": "cdd1caaaa01980419a4c212a04961f8122f78371fb74698ffb8c5a9a1cfe7aef" + }, + { + "path": "research/r437-preparation-composition/vendor/certificates/selected-result.json", + "usage": "input", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "research/r437-preparation-composition/vendor/research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz", + "usage": "input", + "git_blob": "9eafb8776cbf78c72124f833534469ddfa5e98ec", + "sha256": "0357b7cfbd7c29b4983982baf153c8a9f1e1e412690cd7fa9fc3d23d7963b20f" + }, + { + "path": "research/r437-preparation-composition/vendor/research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json", + "usage": "input", + "git_blob": "44006542202ca6037533a754f0bcd00549d7e088", + "sha256": "0058c491d839142aa99ef86a5ec697ce99857632228531512ea3fa74fb24d734" + }, + { + "path": "research/r437-preparation-composition/vendor/research/e8-bit-p111-tuned/tune/EXPECTED.json", + "usage": "input", + "git_blob": "e293ddc557742637f9f679f083a1a282d87b1b13", + "sha256": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4" + }, + { + "path": "research/r437-preparation-composition/vendor/research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "usage": "input", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + { + "path": "research/r437-preparation-composition/vendor/research/physical-compiler-correspondence/README.md", + "usage": "input", + "git_blob": "1b542517f938ef64a25155f96214ba332d8ce623", + "sha256": "bb04d8a05f0fbda2df0dc653118524ecaace3d22dd924179574fc115524df901" + }, + { + "path": "research/r437-preparation-composition/vendor/research/physical-compiler-correspondence/owners.py", + "usage": "input", + "git_blob": "3fdf157278aa00308df706e11fc4a9e428b05e66", + "sha256": "220918b53e45c5992471bb2fd0a95e62f410679048f3517504c851077ee94845" + }, + { + "path": "research/r437-preparation-composition/vendor/research/pr589-five-helper-hosting/PROOF.md", + "usage": "input", + "git_blob": "bbd3f12b9a32b3ad3cba85a2d5a1b3054214fa02", + "sha256": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647" + }, + { + "path": "research/r437-preparation-composition/vendor/research/pr589-five-helper-hosting/verify.py", + "usage": "input", + "git_blob": "dbc71f56bb4205ebe378ada1f9f4ea88630d1d39", + "sha256": "cf90e19ae9991b0698be03d395a8cc29061ecb307eb7fea19adfb2d23c25a367" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/.gitattributes", + "usage": "input", + "git_blob": "a154a13b7c8d4590e03a6949ed1e76c102fd1dbd", + "sha256": "a3c414970082c100e8f9cec6d96b7d5eec4c31660d670b50d46f2d8ac53a3b76" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/PROOF.md", + "usage": "input", + "git_blob": "24816d8dfb5e07978c3d7ad5010d25605d3f9a03", + "sha256": "695c3416094ee374a6b5d5152c80ce29f18358eda21e3afb7b58c2264a6d879c" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/README.md", + "usage": "input", + "git_blob": "6187399f1c7d947cd13f3fb064fb7b65b6d93290", + "sha256": "be6c7a6fae80047631d926e83c73a217037cfdccdc38a5e6d0f4c38865f1ca14" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/RESULT.json", + "usage": "input", + "git_blob": "4a03e803bfb3fe7af6808f655b9b6e828574d212", + "sha256": "27a20d575cb90c16a186a621d553e167f2bb6fd4e19541fe8d8dfc0208451658" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/SOURCES.json", + "usage": "input", + "git_blob": "d0987e871ac318a208bed473540ace42cbd9eaf5", + "sha256": "219bcca3f47aa555cc7c9e126ccbee3509fe7e4fe29b4968b4357ae9c1f0a006" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/TASK.json", + "usage": "input", + "git_blob": "31286abc91a461677a93d1c38c0895c7f00e074b", + "sha256": "f8348e1128757b7e42650100f24c690f368c230f7c72c3613617a1105fba2fc7" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/VALIDATION.md", + "usage": "input", + "git_blob": "ba071214dd6ad7bfe863a35856ae2f2e1b3bd11f", + "sha256": "b3b4978ca4540ea1d6083f6ba77b957750afeed222e2048f046ee62b5f31a590" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/VERIFY.json", + "usage": "input", + "git_blob": "885be188550090829a166baad4cc21b581ea0515", + "sha256": "c23da87b8d9cb87b651b987a71fbf76811b182be474f42dc5273c7d13e4bab2b" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/adapter.py", + "usage": "input", + "git_blob": "276a9a0f436ba03e2a0bb1cd95d57ebc3cc3a290", + "sha256": "c1c054e5a2c650cfc267117b32896073e6735b93c5fbfb1defe6e379c4afab9e" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/check_interface.py", + "usage": "input", + "git_blob": "d44bcf750f121ddd276f09ce94d8d898a3d52078", + "sha256": "b4f5fab63a262e36b5d585ad9ed6bb9436ecb8183eae233b27c8da9c448128d4" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/check_transport.py", + "usage": "input", + "git_blob": "5bd3c8a38aed9df3b0d4404d382268aee02dfcb3", + "sha256": "c1351777d8886754a172ed3f6e90586be5c664a93b66eda5e87fa9580f104ab7" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/EXPECTED.json", + "usage": "input", + "git_blob": "bc2585e1404402395a7c59ba6f6dde58b04e65a2", + "sha256": "67d06bcb90d2307a11975d6b25107a695be477f168f2dc289b8484ba0b7e2de0" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/catalogue.py", + "usage": "input", + "git_blob": "0efc0575a7623ac41c094d2e8772beda5a9fdc29", + "sha256": "83ea88f82d4a83c5f889774bfe3519b7ebaa24b6a0e2a969dafff012107a89bf" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/geometry.json.gz", + "usage": "input", + "git_blob": "a01a33c4753955ec4707db9515cee82a567cc1cb", + "sha256": "edcaebb35d313f403b2db45a2cf808617f921c83cf7a11dd5d74356570ede1a8" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/moves.json", + "usage": "input", + "git_blob": "2cdb414a38cff6f0b872445f0980f2e3bc1895eb", + "sha256": "0a58b239795d213743b5654c59a3e4622a0ddd4a53d8dba3fa30dedef4558dff" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/template.json.gz", + "usage": "input", + "git_blob": "f56efc7ca3648d2070b791d4551a3d77dd7fdde4", + "sha256": "6e03c76f5a4227394ea57e901eb7e93f4d1ee411ccfecd483fd44ea043550494" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/word.json.gz", + "usage": "input", + "git_blob": "c558a221dd44cbdaa732a401f9876de4c096d4a7", + "sha256": "e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/pooled_compiler.py", + "usage": "input", + "git_blob": "512047d8b99628b097f5a597761e6647b424c92e", + "sha256": "fa1c589e5809ba8223eaf070cfb299bf55d843889d360b4d089824eb675e177c" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/replica_catalogue.py", + "usage": "input", + "git_blob": "1fa6ea58c5193952bc6175cbb9f1a778a6502eac", + "sha256": "d093a5a5421596d82c6c6e9fbc7fbf3f313c803a7ba423d666b98344b1912ff3" + }, + { + "path": "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/verify.py", + "usage": "input", + "git_blob": "4a470e1e9961308c094dd167df7535b26b17e035", + "sha256": "dcbe8cdfee38ce0beff30c48a07a07009f4f054fd11454a80e834188547c2ffd" + }, + { + "path": "research/r437-preparation-composition/vendor/research/recursive-parking-boundary/README.md", + "usage": "input", + "git_blob": "251f335ebaccc11d69393ee7aeb5a2e84526d0bb", + "sha256": "491aa208391ee4c2936510b1a5c5c018dd5509d9a0e88687c72ab8406cd77b18" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-local-ring-sweeps/PROOF.md", + "usage": "input", + "git_blob": "4330de85dd9862ed15d84ab917887d249753df99", + "sha256": "846c59440cc99e28bae93ad2af99525bc769de29368080071b8427141215b4f7" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/PROOF.md", + "usage": "input", + "git_blob": "548ecff3ef79a32c14bafc7f2309781181d3c23d", + "sha256": "e5a827e93fe313ba9bf4a2e300bae01b58b28004aa8a8ee119cf6d950edd9f93" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/README.md", + "usage": "input", + "git_blob": "abd0edba96101a025609d2840c3dbdf4d3e30aa8", + "sha256": "989ad891ce3f866c920a25e0cdd661815f982c4c854370f8c00668eaa15d770c" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/RESULT.json", + "usage": "input", + "git_blob": "44afaf8dca8f76b3c9f5ef58616b6d57ff7ff2f3", + "sha256": "de6216b9f89f22b9602867776a7fc951ec558c852e6abd4624151e95d868af56" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/SNAPSHOTS.json", + "usage": "input", + "git_blob": "034836cfaa3e4f984e900a980eecc986ec405b1d", + "sha256": "c7b3485bdae5ddf43166cd6626bd512816e179617a4234c36584f6c57c34744a" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/SOURCES.json", + "usage": "input", + "git_blob": "a27291a91519f9f4e074712afa3262c4d372aaaf", + "sha256": "94e1f55094bbd122e4ee73413650fa24072c392d53d257041cd5d38a2269e4fd" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/TASK.json", + "usage": "input", + "git_blob": "28b8d5e1cbd29824e702d384937831ddb3876da7", + "sha256": "84319cb2f8c7c121927123e8c3271c3ec4ec93fc9be362dcfdf7ee4366cd1a74" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/VALIDATION.md", + "usage": "input", + "git_blob": "5b1a9221f35cbd637183282489e8eeaa30314ea8", + "sha256": "c38eaa31a9cf3489356f2e2a675e2bc6194fa41796589edc9cbd8578b5d71c0f" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/VERIFY.json", + "usage": "input", + "git_blob": "682809777271adfe08df6e6ba2fae89571420212", + "sha256": "5bb3cf67018f35de5b825c9bb4b7a6590296da85f492ba3dbff7a6ce9bdebf8e" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/continuation_checks.py", + "usage": "input", + "git_blob": "f2be8aad16e279c0d1467e21d79d2dd81dcae8d8", + "sha256": "c6ef8fa86a7099af0eb6763a3f5bd43f8f94e1e176cfba38c0077b3e0f5fda48" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/frame_checks.py", + "usage": "input", + "git_blob": "4b992ffcb0a613da54ca24e31d25e61445799e10", + "sha256": "ced41d9244afcb5275ad5c46dc0f60265afc1e6422d29b277364e945825c4dd8" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/EVIDENCE.json", + "usage": "input", + "git_blob": "c2c347abc2b8c19bb642c4da1aad5b3e8383016f", + "sha256": "77b7cbefa2ca30acf2f77e23d14808ccd27848e9c76e4c5e68a045ef7891a07f" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/PREDECESSOR.json", + "usage": "input", + "git_blob": "56d76c357b51f4fc6856923222bfca47f03334e7", + "sha256": "e3127475913d62dbdf1b45d9283d2db2e9b689e0f81a703189150c1e5be2bca0" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/PROOF.md", + "usage": "input", + "git_blob": "1a08e57eac2a37764066d31baa3ecd3769759158", + "sha256": "552fa306d5cc228f4d8d8553f8ac5fc6a738ef2b66a2cb765ba0638cd229794d" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/README.md", + "usage": "input", + "git_blob": "75461632856f94d6b48ae820cf5d0b2b232305c2", + "sha256": "6ce41fd7e6dfbe5faecc25bd36561f0a65b6ebca6fc69d3fb72569424a405045" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/RESULT.json", + "usage": "input", + "git_blob": "75faec7844e18fc7c44543dbab87aba2ecf32b3e", + "sha256": "4919655bae2e5cff051e8f2d240a8e4ebb03392a9da2fb5328daa9248fb7e88b" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/SOURCES.json", + "usage": "input", + "git_blob": "ff8c8e36176aa56e319d0f9e584167ac21d67f33", + "sha256": "7c78f539078e1bc3d893b78b5ee24cb22dc090d3763fe554e861b6c3d3e7eaf7" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/TASK.json", + "usage": "input", + "git_blob": "d70ad317275d2a517ab1294ce48ecb1f83dfedbf", + "sha256": "ac7d4b38da31b373e665929027fc04afb66c3e9aedaea3296e3783637912d0e8" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/VALIDATION.md", + "usage": "input", + "git_blob": "d91680665a28c12c27c99336b55c3d5341dd0fe4", + "sha256": "ac0f2fab0ca810ce0202d31480daa8329cba0897ab015520a2bfd4b689c4086b" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/VERIFY.json", + "usage": "input", + "git_blob": "b6072f66c13a38b5d8dff3ca3bc5f3f3562f1b6e", + "sha256": "6ad0e07f68458afedece927550655b5bc5cd9861a70044fcd95bb10a2179f0a6" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/bootstrap.py", + "usage": "input", + "git_blob": "448c9b3a86eedb84220646ab27ff089a32ad5b9b", + "sha256": "eef1c418e8edbdf317d159683e30beaecd971c77cf41d6b09708576405e2141e" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_layout.py", + "usage": "input", + "git_blob": "be59d614d25961f891e1640bf85cf5e2f474a059", + "sha256": "454b1587d1ed5ccaea19b621a67e2ceba999d7ede61188125faa41c4dd2ab2b1" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_nested_model.py", + "usage": "input", + "git_blob": "20fed6bd389cb53fc52d0ad8389e9e7704c90265", + "sha256": "b1941b882b0659722c3c41994c82f020c1f7ab320dc28c43c2758029ef8a48b7" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_recursion.py", + "usage": "input", + "git_blob": "8f36c88e196cf5afc0d6e227ba8568a10bb23c6a", + "sha256": "dde82badf043e553bc635a34295e2b5505d84d6dfbaf96e0cfccb8a8c3dbb158" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_runtime.py", + "usage": "input", + "git_blob": "fe355a703475325bca4807b8ffedfa9f6edb74f5", + "sha256": "9fcf0c9a3c84a17446fafe8da50b63db296ba9465d48ddb6fdeac8742dfc98b1" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_sign.py", + "usage": "input", + "git_blob": "50669949a1325e8c49aa0ff714c40a50077b5eb8", + "sha256": "ee4fd34acd49962a18d268aefeb20aa3c2673a10e7a43eee3e51a9bd3cf9106a" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_sources.py", + "usage": "input", + "git_blob": "5c09a13943070a3bb3c0da06fd19fbc6916d1743", + "sha256": "1c49984ae6ee7f8a44cde16b51e486f0b3ba4ee5c973389ac8d58a82d0a0aa3b" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/consumer.py", + "usage": "input", + "git_blob": "a66d9276f829ce2c619871866816649d5f3687fd", + "sha256": "2f2a8604c23fb2c81f24320c71ed0142118d98dde3be6086adad28e89954a777" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/control_checks.py", + "usage": "input", + "git_blob": "11daa0b2221c5870d19ba2eaf411a6bff3a0398d", + "sha256": "c09d33327932b4ffbb8acb26c8a6bb621bcca542157d22f1edf72679a9359981" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/driver.py", + "usage": "input", + "git_blob": "5b7846a70aada53d87480b337e1c04217118771b", + "sha256": "ceaf8f75de9810a05ebf8f65780b6f8bd7599a5768401d5e4386182afe615cdf" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/NOTICE.md", + "usage": "input", + "git_blob": "d0318d43ed420e21dc52166a19de703aa87fbb3e", + "sha256": "fd7c42e89878cda6df86dde8720ece34625a337cf5edd795a421e2d3b42919e9" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2688-NOTICE.md", + "usage": "input", + "git_blob": "f2b49cdef83a4a685fad32c01fba93e12cfcb5a8", + "sha256": "c899fccf7bd32397f0ddd85e4af35a166cefb3e3ae3407ec40edc3ab2051b617" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2688-PROOF.md", + "usage": "input", + "git_blob": "1395e1941863e40ff6d62dd91c41de2cb56edae9", + "sha256": "fa9bec0952468e4acb760a88d45d5be216325650e1a4080cf590e07b90c9f533" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2708-README.md", + "usage": "input", + "git_blob": "79b8742f32b4ffb991f91ddd2d3c6be693084e6d", + "sha256": "5906f6b7b2c8eea90e441476c4cbd60fe2ef981b690c63357bcfe67e3104aeef" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2731-README.md", + "usage": "input", + "git_blob": "ac5b826f9c34e1faadc5d5a02d5d260823112078", + "sha256": "19683df4394de299cbd7e1cce39bf9434ad260b1a37006587cf9aed84c9c0a03" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/layout.py", + "usage": "input", + "git_blob": "aa554b14fe0f6b308d9fba0a2afc92e5a28e20cb", + "sha256": "3beef6534b02c3b011b741f957a7d9fb05a9ac0bba1fed53b2c71834e4ea6bc1" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/linear_sign.py", + "usage": "input", + "git_blob": "6a6e5c02f299fad8c4f7ab724fc36e14a22ab13c", + "sha256": "73e895fc701a4145cbe89d60f5775128354e7f08d0a45eacf22f423913f54e67" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/node.py", + "usage": "input", + "git_blob": "28c98a3573b458f7a055678d70b602b80e6e959e", + "sha256": "0bd4f640cafb5c8f070c161d86445910f77578a672bf5886936ed89e7f6bd21b" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/packet_engine.py", + "usage": "input", + "git_blob": "72543f684f38fefeacc2ee66d81661f1a2439cf7", + "sha256": "c80fc3aa9092f91cc309b2fb2dbc3618bf96bdb9b8498503993ea161f0ae2134" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/peel.py", + "usage": "input", + "git_blob": "38502515afc928082c849cd2cda8578d33a5050a", + "sha256": "8b20888f74b4cd814a97b42ec72528fbfb6d2e936c5022df726f0785d0d01a2e" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/NOTICE.md", + "usage": "input", + "git_blob": "ef9f81510db86eaf2f0a7191d85e92a6db30ddc0", + "sha256": "c446b32b8a621844fb2fbe654810c8122035bdd43fed2132f1137d98cb6f9943" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/PROOF.md", + "usage": "input", + "git_blob": "a4746d1786f41e45a36fdedf37966b80fbab3562", + "sha256": "88754d57bae35a2089d9de221ff32ba802b7a56b810f96271f3ea36985edfb14" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/README.md", + "usage": "input", + "git_blob": "988ff622029aff49d7e99deb2468684d904bc852", + "sha256": "15631eb826b2d8d54fbee18fb6f70ee035e172d524c2a209b6c467c3f0204f64" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/RESULT.json", + "usage": "input", + "git_blob": "7b7dfe0eab22a7b511483f268b97a7c707fd8b90", + "sha256": "0d94c5e9150f3fbd603526c67ea33168d3ba45e158aaf722e848bf5c316a37a8" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/SOURCES.json", + "usage": "input", + "git_blob": "4fef1a4d6c2d5e2620d3506d6032f9226870ed39", + "sha256": "1b02a5c607a5967948988c3beaf37d9975d650ad501a99fcf74c135dc1f05fdd" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/TASK.json", + "usage": "input", + "git_blob": "eb2ce7cc00df816daf566f101d56a0330852c1d9", + "sha256": "a4cd54d4b09ad12a90a5feeb39a127f0f0d5a2a04f9f88554c5fc3ee0cfe77f4" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/VERIFY.json", + "usage": "input", + "git_blob": "69c7ad75abe494be386f73a5d51359b9053cd9be", + "sha256": "e1dd0ee5f267ffa515bb345054ff8637cfedb0079b0d2da29b90b7848264926e" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/cardinal_counts.py", + "usage": "input", + "git_blob": "6a14feac45094ae9156e8c2c982d6727544f180e", + "sha256": "59ddeac102a0cc51fa49b15aae6aeb68cd68ed217fa974ce916372a177d2ec8f" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/catalogue.py", + "usage": "input", + "git_blob": "0efc0575a7623ac41c094d2e8772beda5a9fdc29", + "sha256": "83ea88f82d4a83c5f889774bfe3519b7ebaa24b6a0e2a969dafff012107a89bf" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_headers.py", + "usage": "input", + "git_blob": "1c372b19e19b838a89c0e64daeda15ec6b49f079", + "sha256": "a41dab0c487c341eb32b34a03af74454e15e9e61e7386a1ca426d83f3b68b1ca" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_layout.py", + "usage": "input", + "git_blob": "174d843716a684145f934cb55a612bca85aad725", + "sha256": "8f776a21dc0e31f9738d822cfda38db92f1e3672afb880d4246ec5e084a50a41" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_runtime.py", + "usage": "input", + "git_blob": "5647693b3a5c1555b65e281c6609f98b92d45542", + "sha256": "5357e4ff255f17c4209aaf71a3413a4148475f11180c4f829e8f0ebacd2877cb" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_sources.py", + "usage": "input", + "git_blob": "9219cdf863d9f060d6e38a4f2f4760fd227af003", + "sha256": "6463c2724e04a313181b78e90a17cd62ee42465754902cca3e9a65c6140a15a1" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/consumer.py", + "usage": "input", + "git_blob": "24b53521fce94d3349072cf47d70e62195f4d541", + "sha256": "b28ec97b0873ff2be25aff4bdde268247ffcec0d21279d0ada196de19a0bdc66" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/control.py", + "usage": "input", + "git_blob": "4f6ac09bffab43dbccc470bd0bde2ffbe969a8b2", + "sha256": "d3a93e54bb7d333b73917586407d11674d38b5c3fda4fbdc436fb5293ae7786a" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/control_checks.py", + "usage": "input", + "git_blob": "712cfddc4caaad9e788d97b0e1e3f623172c43ed", + "sha256": "5ea6ded8c2508fbb00d93655affdfe7907ffb60916389e0736249c003a7a5148" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/driver.py", + "usage": "input", + "git_blob": "0bdee4c9e348259b470a636a98e7657770f97fae", + "sha256": "ee9e42fe95ab28fdd5e927c2d46fd480305aaad610eb2ca7ae514a5d22d9f0ac" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/fresh_rows.py", + "usage": "input", + "git_blob": "aa3a327604308d3a5c7a27b65f5e631d430ab093", + "sha256": "e4ae08fbd658add630eb7754ebe0cbcb42c6f39cf4128f9cb92e27fcf5213a7d" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/layout.py", + "usage": "input", + "git_blob": "267d5ab98cd013ee82ba75e6d41609f1778af25f", + "sha256": "7534b0166805f2ae8d11495c811d2bd272cea89c89b6bb5251fd411c89245a20" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/model.py", + "usage": "input", + "git_blob": "9fb82fa57d29cdf8402f91534dffed8f586ced6c", + "sha256": "c937ae8e46162f88fc1cd7646d3b22c99273029ad0f0e3131f46ddec230676cb" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/node.py", + "usage": "input", + "git_blob": "13badda6f059da2132cbe325c071307e5191baa3", + "sha256": "b88fc9ac0b22d939311ff4f7aff788e8c87a64fd5e866498e59bd27940ee3f28" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/packet_engine.py", + "usage": "input", + "git_blob": "27a0dbf82e78252beede56ff86f5933c93eb55c1", + "sha256": "ce7f132a6a69c802406f07c4a2119ef921e8978520ff58d5eeaeedb982c257f2" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/peel.py", + "usage": "input", + "git_blob": "2ae1769a9726ab738d3981891d0b76beccac2d99", + "sha256": "3de018e68601566c364c7568b110f60c1bf34941b846cdffb94401bb799f85e3" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/topology.py", + "usage": "input", + "git_blob": "39a2916c207d04be5efc44750d8606f5da0c2990", + "sha256": "384d456ddba76de137a63b50019d5bba2e9f6daa4177c91643e0565d4cf1d44b" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/binding.py", + "usage": "input", + "git_blob": "21a5a21220a18ab62a19ac403a9944bc3a8665c8", + "sha256": "20169a8af6ed2b34069fd353a2bc1c42335ab686c58de8479baef33dd3fb493b" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/bitstream.py", + "usage": "input", + "git_blob": "4d1fd4abb0f2aabe833e5cbc9efb51039739e7ca", + "sha256": "f78bac9641007dbd8824984edcac057274fe016ce78bd9cb512d0c0913274783" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/cardinality.py", + "usage": "input", + "git_blob": "b8ba857e32c5903408e1e61ff916300848b4a208", + "sha256": "505d5e560c5a507e6184edcc19a87cf1fed243eb34a5cb21fbe1e4fe017e7f22" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/check_support.py", + "usage": "input", + "git_blob": "e1f961df9fa3a441fc5b600d1288a8d038eca51e", + "sha256": "d9977e87ddc5acdb836b8e4a4e3942da17a05b04ce67c04547d17b986b518964" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/children.py", + "usage": "input", + "git_blob": "ce4935f838516e2b08d13bec767cb803786fbc6b", + "sha256": "a78866939631214c1d1659203b2b5fc062e3c6255e9f11f975c310046b010bd6" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/controller.py", + "usage": "input", + "git_blob": "c631a9e77fbcccf0e8f448adc22978728aed7b60", + "sha256": "fa09146991f6c04e6f4b6eb9bf0c8e103e70e90a0e402ff3d69814e6aac8ff8c" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/counts.py", + "usage": "input", + "git_blob": "81b48940ce222290a40d4fb349ce827f4788469d", + "sha256": "00b476dbda0e8cc99886bf794439e1cb9e775f435f599a3557e99321fe084069" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/directory.py", + "usage": "input", + "git_blob": "c74cacf5ce809c0561d374f137a52df0992b4226", + "sha256": "4270e370b2bfe38ef73aadcd97d1b3496b56bd582115d74331eb9e5ceb90bec7" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/episode.py", + "usage": "input", + "git_blob": "30d11ff4f333813855d36da3eb5a1ab0e154bafe", + "sha256": "38f79cb2a370548471063952d5f7c74bd795a2a8496fdcf3ce0996d79e3adaff" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/forms.py", + "usage": "input", + "git_blob": "6667c0b772a63f0059c7caffec63e0d919a92398", + "sha256": "1fdf9d31b7eb107c396e33f94dad61c9d3f2c709cae61178268a44ca80dbc0b4" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/low_codes.py", + "usage": "input", + "git_blob": "737edfc4a10f4b7b3b97a7cef4b40864efd806e6", + "sha256": "f657e17f6088c840e3f7783e662257630f6d2c1e71c217721ffbca4d6ac93e87" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/matrices.py", + "usage": "input", + "git_blob": "5d497353efbb9eeaaf4facd96ab40ffb0f3aa20d", + "sha256": "00b687434039b54529ee092e34f9435cfcd66e0816eb3bd2a6688c73f4e01459" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/numeric.py", + "usage": "input", + "git_blob": "6d4ebca8398008375b8f4762d1a9f1514e8c2611", + "sha256": "7327b05c4ec3e0f6d9c352cc7de85bfd4ebe940482553e77c59a773a8c09c514" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/oracle.py", + "usage": "input", + "git_blob": "244f131466698a3ace10b657242fe1f65c07fd1f", + "sha256": "7bd18089e32ce48085b5e3a75159f6a82cdb2649ec682c53db05e399d97aef67" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/packet.py", + "usage": "input", + "git_blob": "ebc9b616514412b80c56d523776e6ba5d6766453", + "sha256": "970e7fe0719e3dfe122b248941e6f21cd90d7dd62089fa6acbd0e5412ce083a5" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/plan.py", + "usage": "input", + "git_blob": "48255d5454308c07635fae4e7eb4873b0bd2a4f8", + "sha256": "d9c8dc93762db4d3a449814aa51e2211460648694469854d89cb48cb04188cf3" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/records.py", + "usage": "input", + "git_blob": "4f00467a0ff580954ad2fd0c7380240c753ddef3", + "sha256": "0c9c4b23e998597fb877bb1a29da69ac869b68262abe635b162b4dba9c69b372" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/residual.py", + "usage": "input", + "git_blob": "3d070d2539a529f3b14ecb086a92a3db056229fe", + "sha256": "8fd24747cae498dfb2ba333e7f8a68d7315ae4c2d7530d8ca145aab95ede21df" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/routes.py", + "usage": "input", + "git_blob": "35531201dc349a811dfabc6f1f6e64697d665194", + "sha256": "ed7dc3679451696ab1dd841146b215c9515a3eec5e4ff3763f33c315f1696ada" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/selection.py", + "usage": "input", + "git_blob": "2c28f1aaec104a75c4e6c170b3e6a60300ee6700", + "sha256": "bc8e371fb1fa0b41fb05ef0b34d0f4c317b2396f9833d91f44f95c2b54b4052b" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/sources.py", + "usage": "input", + "git_blob": "16d5e7e6a28018f1e2d76d61efe2d54f6a6941d4", + "sha256": "f102edc7816d742bd89db8097254c19b843d0ef5cf6758ad42e93bcc0b214c62" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/stream.py", + "usage": "input", + "git_blob": "5e5a4bb0f98971447043e25d4dd6991bfc070389", + "sha256": "c7dc7da5b00f27016982ada4c0416f8328568b00df16d97012f33d4b372d79b5" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/stream_runner.py", + "usage": "input", + "git_blob": "efff281d4c4be5c1378e31404fbcc634fe4ade59", + "sha256": "751c5023ca0e477369e448583961ace6a76db2723bb6c26f81203def539f1249" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/trace.py", + "usage": "input", + "git_blob": "bb845a90f5bcf006e683e581e385936208f6a1f4", + "sha256": "c71ba11d793dde2ac6e4cdcf468482872975c34589bf1167f2a460cb8a74e984" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/words.py", + "usage": "input", + "git_blob": "8d4ba37e2778acb35b34e0719df2caf138fbeb50", + "sha256": "5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/verify.py", + "usage": "input", + "git_blob": "121acc1ff15ec85a8011e96eda2eb587608413b9", + "sha256": "cd83797d1f420f7e5de61c1a693110b4ee0c80bac0adae4699599046b7f76f8a" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/recursive_call.py", + "usage": "input", + "git_blob": "6d33224145aa04f7fbaf7b6cda7c9c164311a402", + "sha256": "157deaa5972557893d43494a81151483bdc46373448ec677cb6a738c9b7e6f1e" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/scheduler.py", + "usage": "input", + "git_blob": "60c2b6d065eba91dd5e0edb7a77fc087971eca3f", + "sha256": "0d96f7fbd6f90416167c5a52c0e3de942d1a0cae3d2968831932a9576701699f" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/stream_runner.py", + "usage": "input", + "git_blob": "6ba5df130bb4a0fcb06b6c630830ae3a6922921b", + "sha256": "b255feaf6cc6e40413ae73fe302bf8f290bf4dd89f4128b23a91cc9860601801" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/trace.py", + "usage": "input", + "git_blob": "4b002201ce54cdecec9acf4e874b7f71cd75fe71", + "sha256": "3a664224c558244f606b603cad816d75e94a17c9b2620a06a1530e893dfceac2" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/verify.py", + "usage": "input", + "git_blob": "96be8f5859a3f3799344d46dec1ee68170d96bfa", + "sha256": "65126e788eeea10e830fc583cf4afe0bfc4d67495cbf8ac21de3507dbe624d56" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/NOTICE.md", + "usage": "input", + "git_blob": "307c2da733f7f3a76e97c77e71072e811f40df02", + "sha256": "8640d1b52fd21e5b20e8109ce9c4957ca1e19a95e26a1c80d019a6e6f4d5f178" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/PROOF.md", + "usage": "input", + "git_blob": "7207ce7dec86694f01a3d9c049dcb87cc909e380", + "sha256": "fc9e7dcc5b385b6e508d6a6e9524b93059fa3e9fd5fcfb5eedbd85b3a54ba55e" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/README.md", + "usage": "input", + "git_blob": "c96e0d6cec56a9a5579ae159456fc15767315bc3", + "sha256": "6550a466bfafff2ca11740e931ed9fce062eb488f23e74edff7e4bbae8282bb1" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/RESULT.json", + "usage": "input", + "git_blob": "b2d1889d77019e06ac0326ac91b1322340cf3866", + "sha256": "4406fec9515bb4206c75b681f046b5441319cf1ed39a13b9b0134696b1c192a7" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/SOURCES.json", + "usage": "input", + "git_blob": "746393061c55f47412601e3d346e914762683e0c", + "sha256": "a6476b786632c2cbffabbe27eece790e378996c8b03eb17a01f1094f20fc4cdf" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/TASK.json", + "usage": "input", + "git_blob": "216dc8f8bcb33fe32d0eaccdadb0fe0383d73848", + "sha256": "964d3a4fbfb53fd58936840328ac4b770b324c9e78f722861b1db04663110626" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/VERIFY.json", + "usage": "input", + "git_blob": "6537be05745836106c753e1388ffc8b1bd23ce4c", + "sha256": "f9e252e8ab255b49c3b18d4db76cc09ebd9fb61d599305e0aca8bf295189028d" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/checks.py", + "usage": "input", + "git_blob": "46630a7648b1c93530e9253872a19cce338929ff", + "sha256": "98ffbd58881aa138b8dbae4d5722855ece2a5fdf7585e53978069ae9b064eb09" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/codec.py", + "usage": "input", + "git_blob": "9cd54d9417eb685dcd3f8293f01299ef9046ad31", + "sha256": "5b9fda8136f7e60bece54e3fcc74f4ea0bec7145fa60e1ae3a4d252741b81fd3" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/vendor/parking_machine.py", + "usage": "input", + "git_blob": "cafd614a3b7bc87b019361fcdf890ed976f26d19", + "sha256": "68134779debfb795468a1aaecbc2b9d321d7d4e451313ce7dc8fa7092561df4c" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/vendor/pr2753_recursive_call.py", + "usage": "input", + "git_blob": "6d33224145aa04f7fbaf7b6cda7c9c164311a402", + "sha256": "157deaa5972557893d43494a81151483bdc46373448ec677cb6a738c9b7e6f1e" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/vendor/words.py", + "usage": "input", + "git_blob": "8d4ba37e2778acb35b34e0719df2caf138fbeb50", + "sha256": "5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/verify.py", + "usage": "input", + "git_blob": "6be4f94eda9c96f4e7265a294f63e39309dcb0c6", + "sha256": "37f9e51e6c038a2493b4550e3cf0bd52621b6c20e115f0886406fc9909a82120" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/loader.py", + "usage": "input", + "git_blob": "4a0326c9af88626938645f288e559b5b97cb1787", + "sha256": "4d8647f520b2967a0ca7dcadeb39d6ebabbce44df4193f609fef22911d0ae67b" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_binding.py", + "usage": "input", + "git_blob": "c197eb6458be9374cb4684c654bfc99e619dcaf0", + "sha256": "9ef31765d03d2c54fad9296f2ff0707a190ce169e44de4f0f45214e3c410c01a" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_checks.py", + "usage": "input", + "git_blob": "6a9226a647d095419840fd9d6696ffcef9827b0b", + "sha256": "0631b4d6b547a76d8ea4babd3465908b9efaa058503f8330140bcc8eb22a51cb" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_code.py", + "usage": "input", + "git_blob": "2f5f8ecfac6457171707b1b5ff02b5071954fcb7", + "sha256": "f626b018124747a5f17c1603bea36cd74c00a69a0647fd7b10e9c4e2964caea8" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_controls.py", + "usage": "input", + "git_blob": "b7c1d28dd47ff463df02ea97b5907a041c05bdde", + "sha256": "a5343faffadfdd9ea0e52d4c7c4ef24ba5e8d2dee86c8af27c094ad78944b845" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_local_checks.py", + "usage": "input", + "git_blob": "421f9030f91f3ab309a9873928c09ba8a2ade580", + "sha256": "a9be60378d1282184632066b87cb044a8510b6623acf0df4dbf2f1bcd35cb830" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_machine.py", + "usage": "input", + "git_blob": "5a032e8923f7f8b22bb98f3e39b804beb9906c16", + "sha256": "7bc6e42072a09a08ac961e05c3da01cde012d740d4b4c605f298d994f2ad7c5a" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_selected_checks.py", + "usage": "input", + "git_blob": "14f224e975fdd1a580088baf26e23ca44091a2f7", + "sha256": "080e147837a4983a73e598af0cc97333e2cfb1d328f5190c9d4447a8bdbb4668" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/nested_bank_checks.py", + "usage": "input", + "git_blob": "c48f87429773e3b80719c209b4ad3f3977e3c41e", + "sha256": "4c225e7d91c767b4cedcf9f9b5222875be948bf8b4ef03cedc4f46f1d570e9bb" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/numerical_frame.py", + "usage": "input", + "git_blob": "dc92611dd5f131718806fa96470b8f3494e15e2a", + "sha256": "3fd62eda5d0b48bf31ea244708a77afdc6d16cf4fc9439d140ef422a38c7406c" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/residual_blocks.py", + "usage": "input", + "git_blob": "fba75e7649cf77e352a75324495191bbd7853c22", + "sha256": "ab7f3df8906decd2efecfb138eac1456c106bb520b2598761f699f80680d8331" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/role_parking.py", + "usage": "input", + "git_blob": "fc48c244eefdbaa3e320e86c75a7d187cb5765ef", + "sha256": "1884a3c260d81d5efbc0c33d86a810d6728e55e5764cfcd423f858cc685470f3" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/scratch_pool.py", + "usage": "input", + "git_blob": "0f22807c65d1bca374b905538512bf8c43702070", + "sha256": "41f1eb93652b7174c3b02f95f70e1a9ce2e2aed0a729e725167c8f226e65d8db" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/verify.py", + "usage": "input", + "git_blob": "fbdc87b9f98dc7722db45a42a742c5569089eeeb", + "sha256": "bfba14c842ea4d97bf160588abc061553d3e4eab66cd5f32b903e1a67e661aec" + }, + { + "path": "research/r437-preparation-composition/vendor/research/selected-bit-recursive-closure/PROOF.md", + "usage": "input", + "git_blob": "6c410cab5713979214a45835091fbeb9ee9b8531", + "sha256": "74cc8de20f21acb5123fe2d20996fe0925ea6e51b3dec633bd5221fb719b3344" + }, + { + "path": "research/r437-preparation-composition/vendor/upstream/build/sections/02-streams.tex", + "usage": "input", + "git_blob": "088fceea1867abc76271d7efe7532b779fee9039", + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + { + "path": "research/r437-preparation-composition/verify.py", + "usage": "input", + "git_blob": "955b199140ebb903ca55a543b97eeb884ea9681e", + "sha256": "98b38dd6ae9a657e34966bf683e0a732b7cbf2728cb108a86157ad8692ee7ad7" + }, + { + "path": "research/r437-reverse-row-coefficient/README.md", + "usage": "input", + "git_blob": "d23b6ecd4f6374b7bc01aada2a958e8d1fd3f1b4", + "sha256": "a7873487757b6796d9883712e59f7d79df5a5495fc143bcffa6b422fc576b07c" + }, + { + "path": "research/r437-reverse-row-coefficient/SOURCES.json", + "usage": "input", + "git_blob": "a604c6a640acd80f08b7378a00739eff45ac0830", + "sha256": "53211542c4e92eee92458f2b313d0bf6c1706e56dada488c604e93a0760fec43" + }, + { + "path": "research/r437-reverse-row-coefficient/TASK.json", + "usage": "input", + "git_blob": "c17ebdad667c0e84bdd98cbb2e942da805fe0c32", + "sha256": "4d78de8b25f29878fba3cd39679c08fed1b55af1cdb566d23b88804d1b2e7148" + }, + { + "path": "research/r437-reverse-row-coefficient/VERIFY.json", + "usage": "input", + "git_blob": "1f9455c1c7f10ff419f1a6d22fcd0596bf15052d", + "sha256": "acebfa5e7dc034cc6ff8d39de15b43b407482b1622097b05eacd86fb128b5221" + }, + { + "path": "research/r437-reverse-row-coefficient/independent.py", + "usage": "input", + "git_blob": "08ca179f3c5bff77efecb388894b974f7c94b51c", + "sha256": "d06b99de599a5b75590bb107fd605df314ed9cf8da19a9ba22bb8de0c33787b7" + }, + { + "path": "research/r437-reverse-row-coefficient/inputs/CANDIDATE-PHASES.json.gz", + "usage": "input", + "git_blob": "278422ca4a668b37274c620ad7105c953e2c26e3", + "sha256": "47c092cf409ac09c4386e5e59ea539d7406f65f746ddcf62a595353507c16607" + }, + { + "path": "research/r437-reverse-row-coefficient/inputs/R437-COMPOSED-WORD.json.gz", + "usage": "input", + "git_blob": "c558a221dd44cbdaa732a401f9876de4c096d4a7", + "sha256": "e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e" + }, + { + "path": "research/r437-reverse-row-coefficient/test_verify.py", + "usage": "input", + "git_blob": "eaf1962391ae5489eed96d697186a75c3bcdc0d8", + "sha256": "6488b70b7f67170116c0fe039cf2a254293621ad0b443751c5050d3b7cc7a039" + }, + { + "path": "research/r437-reverse-row-coefficient/verify.py", + "usage": "input", + "git_blob": "5e416b46c0975d8d39c39f86fa3d25cf3a142a93", + "sha256": "0a345d3658b868f8ccb36969e68fd1e8d5412a98a9f06b3e1a6e74ed9041216a" + }, + { + "path": "research/r437-streaming-directory/PROOF.md", + "usage": "input", + "git_blob": "fcfca4c5d044733b01826cde1e64cf17d4133031", + "sha256": "4e09e3b427042103ffc8857dd0ac3a92deaeab7cc8e769cc55361c02ee8e3be8" + }, + { + "path": "research/r437-streaming-directory/README.md", + "usage": "provenance", + "git_blob": "6e9aec64b772833e6d43a83c50efac7519600ec4", + "sha256": "1bbfd71edcbe78387ac01ef605841b5a836dfb4655587d1fcc20b800502d7f78" + }, + { + "path": "research/r437-streaming-directory/SOURCES.json", + "usage": "input", + "git_blob": "c136f111449babc639a6de2ad7ba7166795d668e", + "sha256": "c135ceb84e45bd306ab84bad7f04ba9805d2cd300641e2a9efd554c833b18a0b" + }, + { + "path": "research/r437-streaming-directory/TASK.json", + "usage": "input", + "git_blob": "7eda16a091a67525d779563d6c8e88170f0ca72c", + "sha256": "752e022011a8f7477959f23375cc856c83bbb4ed95e1dde43f6ad8779d527109" + }, + { + "path": "research/r437-streaming-directory/actual64.py", + "usage": "input", + "git_blob": "2555771fd24147a0c01aa9d1cfdf2d1d78541af6", + "sha256": "9ced8700745c355b88f828b65c02a2b04d1ab8422b8a17342e2eb421b313bda6" + }, + { + "path": "research/r437-streaming-directory/actual_bridge.py", + "usage": "input", + "git_blob": "f49db01835a77f5b7d98fcdbd861cb5241447420", + "sha256": "5fdbe2893edb8e19f8ef7f3fe6d0e813f55097c52d26c115a59f49e440c1825c" + }, + { + "path": "research/r437-streaming-directory/retained/selected-result.json", + "usage": "input", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "research/r437-streaming-directory/streaming.py", + "usage": "input", + "git_blob": "34bbcbdc1e2feed690ef949a321e130ed812ace7", + "sha256": "cb24aa4738904bbb549979a986927396c3952b09a7fedb2a2ba2db6e491982a0" + }, + { + "path": "research/r437-streaming-directory/verify.py", + "usage": "input", + "git_blob": "814d05f837b163cbb147b34f6cc069f6421ee785", + "sha256": "442df69c6ec9a7fda8b9ac23cddc8b40c3588f30adacad14c66a2e418e49c547" + }, + { + "path": "research/r437-two-window-carrier/CANDIDATE-TEMPLATE.json", + "usage": "input", + "git_blob": "96e959f07eebd6330fbbf27b628e793c1cba113c", + "sha256": "6228ba213be5ad22c42e85afb885e96594d2b355ec1fa6c4a57767b4f80bef8e" + }, + { + "path": "research/r437-two-window-carrier/CANDIDATE.json", + "usage": "input", + "git_blob": "1479f765540ce3625e4909e59b40ad6f8c3621fa", + "sha256": "0e4dc8bda7941b9c5bba2f7af9895544ca6f69666026e4835610b808c3d4d7f2" + }, + { + "path": "research/r437-two-window-carrier/HOST-RESULT.json", + "usage": "input", + "git_blob": "ee0952e10f744cf1c6d9c237006ccae4ce3c36c8", + "sha256": "000837b2b7a1e9d7e4b6b657a055c6f5f3886c7ea343239f8620f79d5d7b2ae8" + }, + { + "path": "research/r437-two-window-carrier/LOSING-CONTROL-RESULT.json", + "usage": "input", + "git_blob": "295681b3b3ac36cafc4f261dc708717ae09c5491", + "sha256": "10fde408da0c4aa44b3ec2719313a6a5be49fedbf61e290c04cea9aa37aaa4ca" + }, + { + "path": "research/r437-two-window-carrier/LOSING-CONTROL.json", + "usage": "input", + "git_blob": "49206cf3419a9b0347abfd615fee1b61089f11a0", + "sha256": "c7c9ae2fe5e336ef17892a630b947b6638b7068c74b6881d75f51b0e019a5d8a" + }, + { + "path": "research/r437-two-window-carrier/README.md", + "usage": "input", + "git_blob": "26001b13570d3d7b7e5ddeb4ad3f328bac8e201f", + "sha256": "ede0403964aafe33022999c583bc6debafea033bf46d7f98fdaf559b841e4e99" + }, + { + "path": "research/r437-two-window-carrier/RESULT.json", + "usage": "input", + "git_blob": "52fa337d99268879a82c5a69b7d3d318fa933a7e", + "sha256": "0dfeae97f64845c799857ab5ab0d83b61251b8bae52be269350c168f03c6aff9" + }, + { + "path": "research/r437-two-window-carrier/RETAINED.json", + "usage": "input", + "git_blob": "3fa87fc722c6b7c4353a3965e64dbe2d34fade38", + "sha256": "da91a8207025a4e141b7fd24a2511dfa0ff7d837b0a5d257599d44b9715747dd" + }, + { + "path": "research/r437-two-window-carrier/SOURCES.json", + "usage": "input", + "git_blob": "0839f4876a67fc26084ae94d832ccd69d2b5edb7", + "sha256": "e5822ba1b619af70e55e88a0b4bf81eddd8497bc98b5aac7b00c9d6b63b64bf9" + }, + { + "path": "research/r437-two-window-carrier/TASK.json", + "usage": "input", + "git_blob": "b719602c3f0316fa33316b6eb143c03b5aeb101c", + "sha256": "5e14a6a0845b700bd39fb0e1b4514e39a01ff2932da7603ea224fef61fd2e9c4" + }, + { + "path": "research/r437-two-window-carrier/VERIFY.json", + "usage": "input", + "git_blob": "1e4dc59c4c6da04bea7aa6300dd47246c3cf999c", + "sha256": "16318771c2ad8a1d13d9f209262e5942290fde9678a7417440b6c3888deec456" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-000.bin", + "usage": "input", + "git_blob": "7f01aa7eef382501dfbaebbe6482e944fa814d87", + "sha256": "8e00d476dfe58732a897ce3137f4b1a2cf49d385b1bb4789031f0ea3c5696aaf" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-001.bin", + "usage": "input", + "git_blob": "decd96a65dab997d67783c52b7668f758a6c115a", + "sha256": "32a7c61c62f418407bce7253ea86985ea189ff43e6f1aad14edb443d03885bfe" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-002.bin", + "usage": "input", + "git_blob": "6ce96e8a18486b1ca4467db9947a316979591dba", + "sha256": "aaa622ea2195cfd77e9fa2416725e4e97c035dcb0edfc82a5f3adcccf58e22ca" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-003.bin", + "usage": "input", + "git_blob": "e4514d27f5968bf82cb0f2ef81fd19ec1df1444a", + "sha256": "02305f71a9be6ebc9e5a28e07485bd174262879654f0cfd6273aac88acca56de" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-004.bin", + "usage": "input", + "git_blob": "4021fe43bf1748eac8b49790395a5e3f4caf3012", + "sha256": "0f2764045d5f041055e7adb4713df81a67204d60360633c26af85c0493edb9cc" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-005.bin", + "usage": "input", + "git_blob": "f1ff26b3a20cba0b1ca2b314ab3b8c1dbba54291", + "sha256": "5c88efd13b31b97af68ef967fc6cee1e8d2e7925f89169e67f960ad5b7c0f2d2" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-006.bin", + "usage": "input", + "git_blob": "35aafc44c709e257caff7eacb8dcc33ac665a1a1", + "sha256": "51d679fbcb5d567d8574912e5a985f941d020c4612f878db8a976cd01b39c8cb" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-007.bin", + "usage": "input", + "git_blob": "63e0755ffab1b56b0ea9bfad5bba51f73dc57480", + "sha256": "8c851cfbbc582b1f27f0d1c8ea8c32a4f48513f8e09ed0924beb643f4e3e4eb0" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-008.bin", + "usage": "input", + "git_blob": "9bdc1c8f54034f70fd690a7603d2d566992165e1", + "sha256": "25752503f390e5109e248d99fd9806e11c4a12158d99db6a5263b2a2ff2166aa" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-009.bin", + "usage": "input", + "git_blob": "8cdea621dccfae68a817b53ba591ec99e0202ce5", + "sha256": "e205f9bb6d396498a44f6cb4b1117efe4c5a22543bf83b11bafb9d1902fad992" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-010.bin", + "usage": "input", + "git_blob": "f2f158a0ac596eb63668545911fee6abca3a25b4", + "sha256": "40bd7ba4fd1d4c96b035ee8984be3e023fd8b4d5bf270b636bd3256ebef17447" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-011.bin", + "usage": "input", + "git_blob": "a93e192962aaa697c41a8443dd2cac27d5de6a73", + "sha256": "940a13dbb1c55f9acf6d28fcfd400ec615d911ae34c729604b29173cf66313f0" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-012.bin", + "usage": "input", + "git_blob": "db181442703c9a61e66c3ee7022b7e8a7d95416c", + "sha256": "1836611a68633b2db8422e20f9a4d8e16949f0c402893db2737dba4dc4f34e41" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-013.bin", + "usage": "input", + "git_blob": "854c9c7cea86c1251abd6c188443e359d5e75c36", + "sha256": "77bb5447b15aa1e4892425a23ec2737d91b336f4e73acc64d1d4e68528591c73" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-014.bin", + "usage": "input", + "git_blob": "aec64554648edb5f9d8c0a0e50d7d88f90b63b05", + "sha256": "10f6ebc9118d5d42b7df6b611ed8cd9f4e0adef0c50e99859232546737bad87f" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-015.bin", + "usage": "input", + "git_blob": "a1d264f85dfa54cb1ee31d306bbc75a433430161", + "sha256": "5672528cce227615c61ec77545199683112486ec428af6b755664da9363dfae1" + }, + { + "path": "research/r437-two-window-carrier/candidate-template-chunks/part-016.bin", + "usage": "input", + "git_blob": "d059e02425f35313a2d4f94f6a7ff1ed48e62171", + "sha256": "62eced9b9817294528a442297cde0bc880a7698e463c94e71f1ee91f7c04e2bf" + }, + { + "path": "research/r437-two-window-carrier/host.py", + "usage": "input", + "git_blob": "2cb9b22890fdfacea4ee51a75b7746dd35b78489", + "sha256": "df01e61dc31a1cb6b2bf3549be1e2241f7a30829c2c98567f462271e3fc216ee" + }, + { + "path": "research/r437-two-window-carrier/inputs/LICENSE", + "usage": "input", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "research/r437-two-window-carrier/inputs/OQ4-EXPECTED.json", + "usage": "input", + "git_blob": "bc2585e1404402395a7c59ba6f6dde58b04e65a2", + "sha256": "67d06bcb90d2307a11975d6b25107a695be477f168f2dc289b8484ba0b7e2de0" + }, + { + "path": "research/r437-two-window-carrier/inputs/OQ4-TEMPLATE.json.gz", + "usage": "input", + "git_blob": "f56efc7ca3648d2070b791d4551a3d77dd7fdde4", + "sha256": "6e03c76f5a4227394ea57e901eb7e93f4d1ee411ccfecd483fd44ea043550494" + }, + { + "path": "research/r437-two-window-carrier/inputs/R437-COMPOSED-WORD.json.gz", + "usage": "input", + "git_blob": "c558a221dd44cbdaa732a401f9876de4c096d4a7", + "sha256": "e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e" + }, + { + "path": "research/r437-two-window-carrier/inputs/UPSTREAM-NOTICE.md", + "usage": "input", + "git_blob": "9b519b904d456b0b5861f7469a66c365e77799a6", + "sha256": "8ed83f2f0bde43a41e44279f44d29efaeae3df44850b86f0e3578edf3ee104e4" + }, + { + "path": "research/r437-two-window-carrier/test_package.py", + "usage": "input", + "git_blob": "37789c0494949572011dbb7049f5e61eca76b3e0", + "sha256": "c1fe16dcc1207cddc855eb0be2736a94e05b5e371a7d4c8117fa6dfcf9741d7a" + }, + { + "path": "research/r437-two-window-carrier/verify.py", + "usage": "input", + "git_blob": "49fe8d80c041da0c8d3e1dc37dff15b5e8c4cb9c", + "sha256": "0e972da66ef57955b28f371dc4f958a5ad61d42e037b110cf1f3be1285dd4523" + }, + { + "path": "research/recursive-parking-boundary/README.md", + "usage": "input", + "git_blob": "251f335ebaccc11d69393ee7aeb5a2e84526d0bb", + "sha256": "491aa208391ee4c2936510b1a5c5c018dd5509d9a0e88687c72ab8406cd77b18" + }, + { + "path": "research/selected-bit-local-ring-sweeps/PROOF.md", + "usage": "input", + "git_blob": "4330de85dd9862ed15d84ab917887d249753df99", + "sha256": "846c59440cc99e28bae93ad2af99525bc769de29368080071b8427141215b4f7" + }, + { + "path": "research/selected-bit-physical-caller/PROOF.md", + "usage": "input", + "git_blob": "548ecff3ef79a32c14bafc7f2309781181d3c23d", + "sha256": "e5a827e93fe313ba9bf4a2e300bae01b58b28004aa8a8ee119cf6d950edd9f93" + }, + { + "path": "research/selected-bit-physical-caller/README.md", + "usage": "input", + "git_blob": "abd0edba96101a025609d2840c3dbdf4d3e30aa8", + "sha256": "989ad891ce3f866c920a25e0cdd661815f982c4c854370f8c00668eaa15d770c" + }, + { + "path": "research/selected-bit-physical-caller/RESULT.json", + "usage": "input", + "git_blob": "44afaf8dca8f76b3c9f5ef58616b6d57ff7ff2f3", + "sha256": "de6216b9f89f22b9602867776a7fc951ec558c852e6abd4624151e95d868af56" + }, + { + "path": "research/selected-bit-physical-caller/SNAPSHOTS.json", + "usage": "input", + "git_blob": "034836cfaa3e4f984e900a980eecc986ec405b1d", + "sha256": "c7b3485bdae5ddf43166cd6626bd512816e179617a4234c36584f6c57c34744a" + }, + { + "path": "research/selected-bit-physical-caller/SOURCES.json", + "usage": "input", + "git_blob": "a27291a91519f9f4e074712afa3262c4d372aaaf", + "sha256": "94e1f55094bbd122e4ee73413650fa24072c392d53d257041cd5d38a2269e4fd" + }, + { + "path": "research/selected-bit-physical-caller/TASK.json", + "usage": "input", + "git_blob": "28b8d5e1cbd29824e702d384937831ddb3876da7", + "sha256": "84319cb2f8c7c121927123e8c3271c3ec4ec93fc9be362dcfdf7ee4366cd1a74" + }, + { + "path": "research/selected-bit-physical-caller/VALIDATION.md", + "usage": "input", + "git_blob": "5b1a9221f35cbd637183282489e8eeaa30314ea8", + "sha256": "c38eaa31a9cf3489356f2e2a675e2bc6194fa41796589edc9cbd8578b5d71c0f" + }, + { + "path": "research/selected-bit-physical-caller/VERIFY.json", + "usage": "input", + "git_blob": "682809777271adfe08df6e6ba2fae89571420212", + "sha256": "5bb3cf67018f35de5b825c9bb4b7a6590296da85f492ba3dbff7a6ce9bdebf8e" + }, + { + "path": "research/selected-bit-physical-caller/continuation_checks.py", + "usage": "input", + "git_blob": "f2be8aad16e279c0d1467e21d79d2dd81dcae8d8", + "sha256": "c6ef8fa86a7099af0eb6763a3f5bd43f8f94e1e176cfba38c0077b3e0f5fda48" + }, + { + "path": "research/selected-bit-physical-caller/frame_checks.py", + "usage": "input", + "git_blob": "4b992ffcb0a613da54ca24e31d25e61445799e10", + "sha256": "ced41d9244afcb5275ad5c46dc0f60265afc1e6422d29b277364e945825c4dd8" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/EVIDENCE.json", + "usage": "input", + "git_blob": "c2c347abc2b8c19bb642c4da1aad5b3e8383016f", + "sha256": "77b7cbefa2ca30acf2f77e23d14808ccd27848e9c76e4c5e68a045ef7891a07f" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/PREDECESSOR.json", + "usage": "input", + "git_blob": "56d76c357b51f4fc6856923222bfca47f03334e7", + "sha256": "e3127475913d62dbdf1b45d9283d2db2e9b689e0f81a703189150c1e5be2bca0" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/PROOF.md", + "usage": "input", + "git_blob": "1a08e57eac2a37764066d31baa3ecd3769759158", + "sha256": "552fa306d5cc228f4d8d8553f8ac5fc6a738ef2b66a2cb765ba0638cd229794d" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/README.md", + "usage": "input", + "git_blob": "75461632856f94d6b48ae820cf5d0b2b232305c2", + "sha256": "6ce41fd7e6dfbe5faecc25bd36561f0a65b6ebca6fc69d3fb72569424a405045" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/RESULT.json", + "usage": "input", + "git_blob": "75faec7844e18fc7c44543dbab87aba2ecf32b3e", + "sha256": "4919655bae2e5cff051e8f2d240a8e4ebb03392a9da2fb5328daa9248fb7e88b" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/SOURCES.json", + "usage": "input", + "git_blob": "ff8c8e36176aa56e319d0f9e584167ac21d67f33", + "sha256": "7c78f539078e1bc3d893b78b5ee24cb22dc090d3763fe554e861b6c3d3e7eaf7" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/TASK.json", + "usage": "input", + "git_blob": "d70ad317275d2a517ab1294ce48ecb1f83dfedbf", + "sha256": "ac7d4b38da31b373e665929027fc04afb66c3e9aedaea3296e3783637912d0e8" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/VALIDATION.md", + "usage": "input", + "git_blob": "d91680665a28c12c27c99336b55c3d5341dd0fe4", + "sha256": "ac0f2fab0ca810ce0202d31480daa8329cba0897ab015520a2bfd4b689c4086b" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/VERIFY.json", + "usage": "input", + "git_blob": "b6072f66c13a38b5d8dff3ca3bc5f3f3562f1b6e", + "sha256": "6ad0e07f68458afedece927550655b5bc5cd9861a70044fcd95bb10a2179f0a6" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/bootstrap.py", + "usage": "input", + "git_blob": "448c9b3a86eedb84220646ab27ff089a32ad5b9b", + "sha256": "eef1c418e8edbdf317d159683e30beaecd971c77cf41d6b09708576405e2141e" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/check_layout.py", + "usage": "input", + "git_blob": "be59d614d25961f891e1640bf85cf5e2f474a059", + "sha256": "454b1587d1ed5ccaea19b621a67e2ceba999d7ede61188125faa41c4dd2ab2b1" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/check_nested_model.py", + "usage": "input", + "git_blob": "20fed6bd389cb53fc52d0ad8389e9e7704c90265", + "sha256": "b1941b882b0659722c3c41994c82f020c1f7ab320dc28c43c2758029ef8a48b7" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/check_recursion.py", + "usage": "input", + "git_blob": "8f36c88e196cf5afc0d6e227ba8568a10bb23c6a", + "sha256": "dde82badf043e553bc635a34295e2b5505d84d6dfbaf96e0cfccb8a8c3dbb158" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/check_runtime.py", + "usage": "input", + "git_blob": "fe355a703475325bca4807b8ffedfa9f6edb74f5", + "sha256": "9fcf0c9a3c84a17446fafe8da50b63db296ba9465d48ddb6fdeac8742dfc98b1" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/check_sign.py", + "usage": "input", + "git_blob": "50669949a1325e8c49aa0ff714c40a50077b5eb8", + "sha256": "ee4fd34acd49962a18d268aefeb20aa3c2673a10e7a43eee3e51a9bd3cf9106a" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/check_sources.py", + "usage": "input", + "git_blob": "5c09a13943070a3bb3c0da06fd19fbc6916d1743", + "sha256": "1c49984ae6ee7f8a44cde16b51e486f0b3ba4ee5c973389ac8d58a82d0a0aa3b" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/consumer.py", + "usage": "input", + "git_blob": "a66d9276f829ce2c619871866816649d5f3687fd", + "sha256": "2f2a8604c23fb2c81f24320c71ed0142118d98dde3be6086adad28e89954a777" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/control_checks.py", + "usage": "input", + "git_blob": "11daa0b2221c5870d19ba2eaf411a6bff3a0398d", + "sha256": "c09d33327932b4ffbb8acb26c8a6bb621bcca542157d22f1edf72679a9359981" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/driver.py", + "usage": "input", + "git_blob": "5b7846a70aada53d87480b337e1c04217118771b", + "sha256": "ceaf8f75de9810a05ebf8f65780b6f8bd7599a5768401d5e4386182afe615cdf" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/evidence/NOTICE.md", + "usage": "input", + "git_blob": "d0318d43ed420e21dc52166a19de703aa87fbb3e", + "sha256": "fd7c42e89878cda6df86dde8720ece34625a337cf5edd795a421e2d3b42919e9" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2688-NOTICE.md", + "usage": "input", + "git_blob": "f2b49cdef83a4a685fad32c01fba93e12cfcb5a8", + "sha256": "c899fccf7bd32397f0ddd85e4af35a166cefb3e3ae3407ec40edc3ab2051b617" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2688-PROOF.md", + "usage": "input", + "git_blob": "1395e1941863e40ff6d62dd91c41de2cb56edae9", + "sha256": "fa9bec0952468e4acb760a88d45d5be216325650e1a4080cf590e07b90c9f533" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2708-README.md", + "usage": "input", + "git_blob": "79b8742f32b4ffb991f91ddd2d3c6be693084e6d", + "sha256": "5906f6b7b2c8eea90e441476c4cbd60fe2ef981b690c63357bcfe67e3104aeef" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2731-README.md", + "usage": "input", + "git_blob": "ac5b826f9c34e1faadc5d5a02d5d260823112078", + "sha256": "19683df4394de299cbd7e1cce39bf9434ad260b1a37006587cf9aed84c9c0a03" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/layout.py", + "usage": "input", + "git_blob": "aa554b14fe0f6b308d9fba0a2afc92e5a28e20cb", + "sha256": "3beef6534b02c3b011b741f957a7d9fb05a9ac0bba1fed53b2c71834e4ea6bc1" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/linear_sign.py", + "usage": "input", + "git_blob": "6a6e5c02f299fad8c4f7ab724fc36e14a22ab13c", + "sha256": "73e895fc701a4145cbe89d60f5775128354e7f08d0a45eacf22f423913f54e67" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/node.py", + "usage": "input", + "git_blob": "28c98a3573b458f7a055678d70b602b80e6e959e", + "sha256": "0bd4f640cafb5c8f070c161d86445910f77578a672bf5886936ed89e7f6bd21b" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/packet_engine.py", + "usage": "input", + "git_blob": "72543f684f38fefeacc2ee66d81661f1a2439cf7", + "sha256": "c80fc3aa9092f91cc309b2fb2dbc3618bf96bdb9b8498503993ea161f0ae2134" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/peel.py", + "usage": "input", + "git_blob": "38502515afc928082c849cd2cda8578d33a5050a", + "sha256": "8b20888f74b4cd814a97b42ec72528fbfb6d2e936c5022df726f0785d0d01a2e" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/NOTICE.md", + "usage": "input", + "git_blob": "ef9f81510db86eaf2f0a7191d85e92a6db30ddc0", + "sha256": "c446b32b8a621844fb2fbe654810c8122035bdd43fed2132f1137d98cb6f9943" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/PROOF.md", + "usage": "input", + "git_blob": "a4746d1786f41e45a36fdedf37966b80fbab3562", + "sha256": "88754d57bae35a2089d9de221ff32ba802b7a56b810f96271f3ea36985edfb14" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/README.md", + "usage": "input", + "git_blob": "988ff622029aff49d7e99deb2468684d904bc852", + "sha256": "15631eb826b2d8d54fbee18fb6f70ee035e172d524c2a209b6c467c3f0204f64" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/RESULT.json", + "usage": "input", + "git_blob": "7b7dfe0eab22a7b511483f268b97a7c707fd8b90", + "sha256": "0d94c5e9150f3fbd603526c67ea33168d3ba45e158aaf722e848bf5c316a37a8" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/SOURCES.json", + "usage": "input", + "git_blob": "4fef1a4d6c2d5e2620d3506d6032f9226870ed39", + "sha256": "1b02a5c607a5967948988c3beaf37d9975d650ad501a99fcf74c135dc1f05fdd" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/TASK.json", + "usage": "input", + "git_blob": "eb2ce7cc00df816daf566f101d56a0330852c1d9", + "sha256": "a4cd54d4b09ad12a90a5feeb39a127f0f0d5a2a04f9f88554c5fc3ee0cfe77f4" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/VERIFY.json", + "usage": "input", + "git_blob": "69c7ad75abe494be386f73a5d51359b9053cd9be", + "sha256": "e1dd0ee5f267ffa515bb345054ff8637cfedb0079b0d2da29b90b7848264926e" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/cardinal_counts.py", + "usage": "input", + "git_blob": "6a14feac45094ae9156e8c2c982d6727544f180e", + "sha256": "59ddeac102a0cc51fa49b15aae6aeb68cd68ed217fa974ce916372a177d2ec8f" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/catalogue.py", + "usage": "input", + "git_blob": "0efc0575a7623ac41c094d2e8772beda5a9fdc29", + "sha256": "83ea88f82d4a83c5f889774bfe3519b7ebaa24b6a0e2a969dafff012107a89bf" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_headers.py", + "usage": "input", + "git_blob": "1c372b19e19b838a89c0e64daeda15ec6b49f079", + "sha256": "a41dab0c487c341eb32b34a03af74454e15e9e61e7386a1ca426d83f3b68b1ca" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_layout.py", + "usage": "input", + "git_blob": "174d843716a684145f934cb55a612bca85aad725", + "sha256": "8f776a21dc0e31f9738d822cfda38db92f1e3672afb880d4246ec5e084a50a41" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_runtime.py", + "usage": "input", + "git_blob": "5647693b3a5c1555b65e281c6609f98b92d45542", + "sha256": "5357e4ff255f17c4209aaf71a3413a4148475f11180c4f829e8f0ebacd2877cb" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_sources.py", + "usage": "input", + "git_blob": "9219cdf863d9f060d6e38a4f2f4760fd227af003", + "sha256": "6463c2724e04a313181b78e90a17cd62ee42465754902cca3e9a65c6140a15a1" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/consumer.py", + "usage": "input", + "git_blob": "24b53521fce94d3349072cf47d70e62195f4d541", + "sha256": "b28ec97b0873ff2be25aff4bdde268247ffcec0d21279d0ada196de19a0bdc66" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/control.py", + "usage": "input", + "git_blob": "4f6ac09bffab43dbccc470bd0bde2ffbe969a8b2", + "sha256": "d3a93e54bb7d333b73917586407d11674d38b5c3fda4fbdc436fb5293ae7786a" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/control_checks.py", + "usage": "input", + "git_blob": "712cfddc4caaad9e788d97b0e1e3f623172c43ed", + "sha256": "5ea6ded8c2508fbb00d93655affdfe7907ffb60916389e0736249c003a7a5148" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/driver.py", + "usage": "input", + "git_blob": "0bdee4c9e348259b470a636a98e7657770f97fae", + "sha256": "ee9e42fe95ab28fdd5e927c2d46fd480305aaad610eb2ca7ae514a5d22d9f0ac" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/fresh_rows.py", + "usage": "input", + "git_blob": "aa3a327604308d3a5c7a27b65f5e631d430ab093", + "sha256": "e4ae08fbd658add630eb7754ebe0cbcb42c6f39cf4128f9cb92e27fcf5213a7d" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/layout.py", + "usage": "input", + "git_blob": "267d5ab98cd013ee82ba75e6d41609f1778af25f", + "sha256": "7534b0166805f2ae8d11495c811d2bd272cea89c89b6bb5251fd411c89245a20" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/model.py", + "usage": "input", + "git_blob": "9fb82fa57d29cdf8402f91534dffed8f586ced6c", + "sha256": "c937ae8e46162f88fc1cd7646d3b22c99273029ad0f0e3131f46ddec230676cb" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/node.py", + "usage": "input", + "git_blob": "13badda6f059da2132cbe325c071307e5191baa3", + "sha256": "b88fc9ac0b22d939311ff4f7aff788e8c87a64fd5e866498e59bd27940ee3f28" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/packet_engine.py", + "usage": "input", + "git_blob": "27a0dbf82e78252beede56ff86f5933c93eb55c1", + "sha256": "ce7f132a6a69c802406f07c4a2119ef921e8978520ff58d5eeaeedb982c257f2" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/peel.py", + "usage": "input", + "git_blob": "2ae1769a9726ab738d3981891d0b76beccac2d99", + "sha256": "3de018e68601566c364c7568b110f60c1bf34941b846cdffb94401bb799f85e3" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/topology.py", + "usage": "input", + "git_blob": "39a2916c207d04be5efc44750d8606f5da0c2990", + "sha256": "384d456ddba76de137a63b50019d5bba2e9f6daa4177c91643e0565d4cf1d44b" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/binding.py", + "usage": "input", + "git_blob": "21a5a21220a18ab62a19ac403a9944bc3a8665c8", + "sha256": "20169a8af6ed2b34069fd353a2bc1c42335ab686c58de8479baef33dd3fb493b" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/bitstream.py", + "usage": "input", + "git_blob": "4d1fd4abb0f2aabe833e5cbc9efb51039739e7ca", + "sha256": "f78bac9641007dbd8824984edcac057274fe016ce78bd9cb512d0c0913274783" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/cardinality.py", + "usage": "input", + "git_blob": "b8ba857e32c5903408e1e61ff916300848b4a208", + "sha256": "505d5e560c5a507e6184edcc19a87cf1fed243eb34a5cb21fbe1e4fe017e7f22" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/check_support.py", + "usage": "input", + "git_blob": "e1f961df9fa3a441fc5b600d1288a8d038eca51e", + "sha256": "d9977e87ddc5acdb836b8e4a4e3942da17a05b04ce67c04547d17b986b518964" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/children.py", + "usage": "input", + "git_blob": "ce4935f838516e2b08d13bec767cb803786fbc6b", + "sha256": "a78866939631214c1d1659203b2b5fc062e3c6255e9f11f975c310046b010bd6" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/controller.py", + "usage": "input", + "git_blob": "c631a9e77fbcccf0e8f448adc22978728aed7b60", + "sha256": "fa09146991f6c04e6f4b6eb9bf0c8e103e70e90a0e402ff3d69814e6aac8ff8c" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/counts.py", + "usage": "input", + "git_blob": "81b48940ce222290a40d4fb349ce827f4788469d", + "sha256": "00b476dbda0e8cc99886bf794439e1cb9e775f435f599a3557e99321fe084069" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/directory.py", + "usage": "input", + "git_blob": "c74cacf5ce809c0561d374f137a52df0992b4226", + "sha256": "4270e370b2bfe38ef73aadcd97d1b3496b56bd582115d74331eb9e5ceb90bec7" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/episode.py", + "usage": "input", + "git_blob": "30d11ff4f333813855d36da3eb5a1ab0e154bafe", + "sha256": "38f79cb2a370548471063952d5f7c74bd795a2a8496fdcf3ce0996d79e3adaff" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/forms.py", + "usage": "input", + "git_blob": "6667c0b772a63f0059c7caffec63e0d919a92398", + "sha256": "1fdf9d31b7eb107c396e33f94dad61c9d3f2c709cae61178268a44ca80dbc0b4" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/low_codes.py", + "usage": "input", + "git_blob": "737edfc4a10f4b7b3b97a7cef4b40864efd806e6", + "sha256": "f657e17f6088c840e3f7783e662257630f6d2c1e71c217721ffbca4d6ac93e87" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/matrices.py", + "usage": "input", + "git_blob": "5d497353efbb9eeaaf4facd96ab40ffb0f3aa20d", + "sha256": "00b687434039b54529ee092e34f9435cfcd66e0816eb3bd2a6688c73f4e01459" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/numeric.py", + "usage": "input", + "git_blob": "6d4ebca8398008375b8f4762d1a9f1514e8c2611", + "sha256": "7327b05c4ec3e0f6d9c352cc7de85bfd4ebe940482553e77c59a773a8c09c514" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/oracle.py", + "usage": "input", + "git_blob": "244f131466698a3ace10b657242fe1f65c07fd1f", + "sha256": "7bd18089e32ce48085b5e3a75159f6a82cdb2649ec682c53db05e399d97aef67" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/packet.py", + "usage": "input", + "git_blob": "ebc9b616514412b80c56d523776e6ba5d6766453", + "sha256": "970e7fe0719e3dfe122b248941e6f21cd90d7dd62089fa6acbd0e5412ce083a5" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/plan.py", + "usage": "input", + "git_blob": "48255d5454308c07635fae4e7eb4873b0bd2a4f8", + "sha256": "d9c8dc93762db4d3a449814aa51e2211460648694469854d89cb48cb04188cf3" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/records.py", + "usage": "input", + "git_blob": "4f00467a0ff580954ad2fd0c7380240c753ddef3", + "sha256": "0c9c4b23e998597fb877bb1a29da69ac869b68262abe635b162b4dba9c69b372" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/residual.py", + "usage": "input", + "git_blob": "3d070d2539a529f3b14ecb086a92a3db056229fe", + "sha256": "8fd24747cae498dfb2ba333e7f8a68d7315ae4c2d7530d8ca145aab95ede21df" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/routes.py", + "usage": "input", + "git_blob": "35531201dc349a811dfabc6f1f6e64697d665194", + "sha256": "ed7dc3679451696ab1dd841146b215c9515a3eec5e4ff3763f33c315f1696ada" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/selection.py", + "usage": "input", + "git_blob": "2c28f1aaec104a75c4e6c170b3e6a60300ee6700", + "sha256": "bc8e371fb1fa0b41fb05ef0b34d0f4c317b2396f9833d91f44f95c2b54b4052b" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/sources.py", + "usage": "input", + "git_blob": "16d5e7e6a28018f1e2d76d61efe2d54f6a6941d4", + "sha256": "f102edc7816d742bd89db8097254c19b843d0ef5cf6758ad42e93bcc0b214c62" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/stream.py", + "usage": "input", + "git_blob": "5e5a4bb0f98971447043e25d4dd6991bfc070389", + "sha256": "c7dc7da5b00f27016982ada4c0416f8328568b00df16d97012f33d4b372d79b5" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/stream_runner.py", + "usage": "input", + "git_blob": "efff281d4c4be5c1378e31404fbcc634fe4ade59", + "sha256": "751c5023ca0e477369e448583961ace6a76db2723bb6c26f81203def539f1249" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/trace.py", + "usage": "input", + "git_blob": "bb845a90f5bcf006e683e581e385936208f6a1f4", + "sha256": "c71ba11d793dde2ac6e4cdcf468482872975c34589bf1167f2a460cb8a74e984" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/words.py", + "usage": "input", + "git_blob": "8d4ba37e2778acb35b34e0719df2caf138fbeb50", + "sha256": "5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/predecessor/verify.py", + "usage": "input", + "git_blob": "121acc1ff15ec85a8011e96eda2eb587608413b9", + "sha256": "cd83797d1f420f7e5de61c1a693110b4ee0c80bac0adae4699599046b7f76f8a" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/recursive_call.py", + "usage": "input", + "git_blob": "6d33224145aa04f7fbaf7b6cda7c9c164311a402", + "sha256": "157deaa5972557893d43494a81151483bdc46373448ec677cb6a738c9b7e6f1e" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/scheduler.py", + "usage": "input", + "git_blob": "60c2b6d065eba91dd5e0edb7a77fc087971eca3f", + "sha256": "0d96f7fbd6f90416167c5a52c0e3de942d1a0cae3d2968831932a9576701699f" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/stream_runner.py", + "usage": "input", + "git_blob": "6ba5df130bb4a0fcb06b6c630830ae3a6922921b", + "sha256": "b255feaf6cc6e40413ae73fe302bf8f290bf4dd89f4128b23a91cc9860601801" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/trace.py", + "usage": "input", + "git_blob": "4b002201ce54cdecec9acf4e874b7f71cd75fe71", + "sha256": "3a664224c558244f606b603cad816d75e94a17c9b2620a06a1530e893dfceac2" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2753/verify.py", + "usage": "input", + "git_blob": "96be8f5859a3f3799344d46dec1ee68170d96bfa", + "sha256": "65126e788eeea10e830fc583cf4afe0bfc4d67495cbf8ac21de3507dbe624d56" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/NOTICE.md", + "usage": "input", + "git_blob": "307c2da733f7f3a76e97c77e71072e811f40df02", + "sha256": "8640d1b52fd21e5b20e8109ce9c4957ca1e19a95e26a1c80d019a6e6f4d5f178" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/PROOF.md", + "usage": "input", + "git_blob": "7207ce7dec86694f01a3d9c049dcb87cc909e380", + "sha256": "fc9e7dcc5b385b6e508d6a6e9524b93059fa3e9fd5fcfb5eedbd85b3a54ba55e" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/README.md", + "usage": "input", + "git_blob": "c96e0d6cec56a9a5579ae159456fc15767315bc3", + "sha256": "6550a466bfafff2ca11740e931ed9fce062eb488f23e74edff7e4bbae8282bb1" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/RESULT.json", + "usage": "input", + "git_blob": "b2d1889d77019e06ac0326ac91b1322340cf3866", + "sha256": "4406fec9515bb4206c75b681f046b5441319cf1ed39a13b9b0134696b1c192a7" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/SOURCES.json", + "usage": "input", + "git_blob": "746393061c55f47412601e3d346e914762683e0c", + "sha256": "a6476b786632c2cbffabbe27eece790e378996c8b03eb17a01f1094f20fc4cdf" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/TASK.json", + "usage": "input", + "git_blob": "216dc8f8bcb33fe32d0eaccdadb0fe0383d73848", + "sha256": "964d3a4fbfb53fd58936840328ac4b770b324c9e78f722861b1db04663110626" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/VERIFY.json", + "usage": "input", + "git_blob": "6537be05745836106c753e1388ffc8b1bd23ce4c", + "sha256": "f9e252e8ab255b49c3b18d4db76cc09ebd9fb61d599305e0aca8bf295189028d" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/checks.py", + "usage": "input", + "git_blob": "46630a7648b1c93530e9253872a19cce338929ff", + "sha256": "98ffbd58881aa138b8dbae4d5722855ece2a5fdf7585e53978069ae9b064eb09" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/codec.py", + "usage": "input", + "git_blob": "9cd54d9417eb685dcd3f8293f01299ef9046ad31", + "sha256": "5b9fda8136f7e60bece54e3fcc74f4ea0bec7145fa60e1ae3a4d252741b81fd3" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/vendor/parking_machine.py", + "usage": "input", + "git_blob": "cafd614a3b7bc87b019361fcdf890ed976f26d19", + "sha256": "68134779debfb795468a1aaecbc2b9d321d7d4e451313ce7dc8fa7092561df4c" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/vendor/pr2753_recursive_call.py", + "usage": "input", + "git_blob": "6d33224145aa04f7fbaf7b6cda7c9c164311a402", + "sha256": "157deaa5972557893d43494a81151483bdc46373448ec677cb6a738c9b7e6f1e" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/vendor/words.py", + "usage": "input", + "git_blob": "8d4ba37e2778acb35b34e0719df2caf138fbeb50", + "sha256": "5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9" + }, + { + "path": "research/selected-bit-physical-caller/inputs/pr2769/verify.py", + "usage": "input", + "git_blob": "6be4f94eda9c96f4e7265a294f63e39309dcb0c6", + "sha256": "37f9e51e6c038a2493b4550e3cf0bd52621b6c20e115f0886406fc9909a82120" + }, + { + "path": "research/selected-bit-physical-caller/loader.py", + "usage": "input", + "git_blob": "4a0326c9af88626938645f288e559b5b97cb1787", + "sha256": "4d8647f520b2967a0ca7dcadeb39d6ebabbce44df4193f609fef22911d0ae67b" + }, + { + "path": "research/selected-bit-physical-caller/macro_binding.py", + "usage": "input", + "git_blob": "c197eb6458be9374cb4684c654bfc99e619dcaf0", + "sha256": "9ef31765d03d2c54fad9296f2ff0707a190ce169e44de4f0f45214e3c410c01a" + }, + { + "path": "research/selected-bit-physical-caller/macro_checks.py", + "usage": "input", + "git_blob": "6a9226a647d095419840fd9d6696ffcef9827b0b", + "sha256": "0631b4d6b547a76d8ea4babd3465908b9efaa058503f8330140bcc8eb22a51cb" + }, + { + "path": "research/selected-bit-physical-caller/macro_code.py", + "usage": "input", + "git_blob": "2f5f8ecfac6457171707b1b5ff02b5071954fcb7", + "sha256": "f626b018124747a5f17c1603bea36cd74c00a69a0647fd7b10e9c4e2964caea8" + }, + { + "path": "research/selected-bit-physical-caller/macro_controls.py", + "usage": "input", + "git_blob": "b7c1d28dd47ff463df02ea97b5907a041c05bdde", + "sha256": "a5343faffadfdd9ea0e52d4c7c4ef24ba5e8d2dee86c8af27c094ad78944b845" + }, + { + "path": "research/selected-bit-physical-caller/macro_local_checks.py", + "usage": "input", + "git_blob": "421f9030f91f3ab309a9873928c09ba8a2ade580", + "sha256": "a9be60378d1282184632066b87cb044a8510b6623acf0df4dbf2f1bcd35cb830" + }, + { + "path": "research/selected-bit-physical-caller/macro_machine.py", + "usage": "input", + "git_blob": "5a032e8923f7f8b22bb98f3e39b804beb9906c16", + "sha256": "7bc6e42072a09a08ac961e05c3da01cde012d740d4b4c605f298d994f2ad7c5a" + }, + { + "path": "research/selected-bit-physical-caller/macro_selected_checks.py", + "usage": "input", + "git_blob": "14f224e975fdd1a580088baf26e23ca44091a2f7", + "sha256": "080e147837a4983a73e598af0cc97333e2cfb1d328f5190c9d4447a8bdbb4668" + }, + { + "path": "research/selected-bit-physical-caller/nested_bank_checks.py", + "usage": "input", + "git_blob": "c48f87429773e3b80719c209b4ad3f3977e3c41e", + "sha256": "4c225e7d91c767b4cedcf9f9b5222875be948bf8b4ef03cedc4f46f1d570e9bb" + }, + { + "path": "research/selected-bit-physical-caller/numerical_frame.py", + "usage": "input", + "git_blob": "dc92611dd5f131718806fa96470b8f3494e15e2a", + "sha256": "3fd62eda5d0b48bf31ea244708a77afdc6d16cf4fc9439d140ef422a38c7406c" + }, + { + "path": "research/selected-bit-physical-caller/residual_blocks.py", + "usage": "input", + "git_blob": "fba75e7649cf77e352a75324495191bbd7853c22", + "sha256": "ab7f3df8906decd2efecfb138eac1456c106bb520b2598761f699f80680d8331" + }, + { + "path": "research/selected-bit-physical-caller/role_parking.py", + "usage": "input", + "git_blob": "fc48c244eefdbaa3e320e86c75a7d187cb5765ef", + "sha256": "1884a3c260d81d5efbc0c33d86a810d6728e55e5764cfcd423f858cc685470f3" + }, + { + "path": "research/selected-bit-physical-caller/scratch_pool.py", + "usage": "input", + "git_blob": "0f22807c65d1bca374b905538512bf8c43702070", + "sha256": "41f1eb93652b7174c3b02f95f70e1a9ce2e2aed0a729e725167c8f226e65d8db" + }, + { + "path": "research/selected-bit-physical-caller/verify.py", + "usage": "input", + "git_blob": "fbdc87b9f98dc7722db45a42a742c5569089eeeb", + "sha256": "bfba14c842ea4d97bf160588abc061553d3e4eab66cd5f32b903e1a67e661aec" + }, + { + "path": "research/selected-bit-recursive-closure/PROOF.md", + "usage": "input", + "git_blob": "6c410cab5713979214a45835091fbeb9ee9b8531", + "sha256": "74cc8de20f21acb5123fe2d20996fe0925ea6e51b3dec633bd5221fb719b3344" + }, + { + "path": "upstream/build/sections/02-streams.tex", + "usage": "input", + "git_blob": "088fceea1867abc76271d7efe7532b779fee9039", + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + } + ] +} diff --git a/research/r437-streamed-leaf-workspace/TASK.json b/research/r437-streamed-leaf-workspace/TASK.json new file mode 100644 index 0000000000..4f013c3356 --- /dev/null +++ b/research/r437-streamed-leaf-workspace/TASK.json @@ -0,0 +1,84 @@ +{ + "schema_version": 1, + "task_id": "r437-carrier-integration", + "priority_revision": 7, + "base_commit": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "original_card": { + "id": "r437-carrier-integration", + "question": "Can the paid R437 two-window carrier improvement be admitted by the actual pooled compiler and physical caller?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/r437-two-window-carrier/README.md", + "research/r437-reverse-row-coefficient/README.md" + ], + "methods": [ + "Close one compiler/request, caller or precision/stock implication for the pinned paid exchange.", + "Falsify that exact interface with an arbitrary-dirty-state or chronology counterexample." + ], + "acceptance_gate": "Pin the complete source and destination contracts, exact paid and scalar deltas, and all remaining assumptions. A local moment gain is not a physical or all-size supplier admission.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4067 paid profile and open integration obligations; #4147 covers the reverse row coefficient. Three additional ADDs per call and all helpers remain charged. This is not a selected supplier.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Choose one unclaimed obligation: pooled compiler codebook/request alignment, actual physical caller, or precision/stock envelope using the already reported reverse coefficient. Pin the input and receiver, preserve dirty/source windows, and test one binding with a rejection control. Stop at unresolved dependencies; do not rederive the coefficient or quote the local moment as a completed bound.", + "bottleneck_link": "The exchange changes the paid profile; integration must establish that its gain survives the complete caller.", + "allowed_variations": [ + "One compiler rebind, one actual caller boundary, or one precision/stock implication." + ], + "scope_change_triggers": [ + "Ignoring added ADDs, retaining an obsolete reverse coefficient, or declaring global admission from the local histogram." + ], + "overlap_terms": [ + "R437", + "two-window carrier", + "4067", + "4147", + "pooled compiler", + "request alignment", + "reverse row coefficient" + ], + "existing_checks": [ + { + "scope": "PR #4067: source-bound two-window carrier with (2,2) to (1,3) paid exchange and fixed OQ4 host.", + "evidence": "research/r437-two-window-carrier/README.md", + "remaining": "Pooled compiler/request rebind, physical caller and precision/stock admission.", + "status": "author-checked", + "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4147: reverse row coefficient follow-up.", + "evidence": "research/r437-reverse-row-coefficient/README.md", + "remaining": "Use the exact coefficient in a caller-bound precision/stock proof rather than repeat the arithmetic.", + "status": "author-checked", + "source_commit": "72e7bb797adf82aeb525a399f56ab8adbab8e93c", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Give the unchanged #5055 complete streamed leaf/XOR consumer one reusable physical tape inventory, a source-derived lifetime/backing bound and charged erasure/movement interface; corroborate it on the full small high cube and the separately labelled actual SOURCE87 two-prefix calibration.", + "scope_change_reason": "Choose the explicit persistent consumer-workspace question left open by #5055 under the actual physical-caller branch of the card. Claim #4682 comment19144606 after complete live overlap review; this is a bounded leaf refinement, not pooled compiler or all-size admission.", + "bottleneck_link": "#5055 removes the materialized new directory but still allocates fresh consumer scratch for every prefix. One source-derived inventory and retained-backing bound removes that accumulation at the complete leaf/XOR boundary while keeping source/target/full-output, producer, numerical arenas and suspended owners charged.", + "budget_minutes": 240, + "stop_rule": "Stop if this exact persistent leaf/XOR workspace is already supplied or claimed; if the unchanged source cannot run within one proven lease inventory; or if a payload, retirement, erasure, source-pin or cold-export check fails. Do not substitute measured peak for a source bound, omit resident owners, expand into recursive admission or change the selected frontier.", + "outcome": "partial", + "evidence": "PROOF.md gives q^2+136 roles, A(M+2) fresh retained cells and T_pool <= T + K + 28J + 4AN. RESULT.json binds complete 243-prefix / 19683-bit execution and separate two-prefix / 13122-bit SOURCE87 execution, unique retirement of all leases, exact clear tariffs, physical-traffic conservation, inherited payload controls and four rejecting workspace defects. VERIFY.json registers identical deterministic receipts under ordinary and optimized isolated Python 3.12.", + "author": "Krzysztof W\u00f3jt, with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance for source analysis, proof development, implementation, verification and writing. Luna supporting agents performed bounded coordination/source mapping and metadata audits; the primary agent owns final integration and verified the findings. No claim of independent human or proof-kernel acceptance.", + "open_questions": [ + { + "question": "Can this complete successful leaf/XOR workspace boundary be composed with one full R437 node's canonical call/return owners, with an explicit source-traffic tariff and all producer/full-packet residents charged?", + "why_it_matters": "Removing consumer scratch accumulation alone does not establish physical-caller space, chronology or whole-node time. The output, input packets, producer controls and suspended parents remain resident.", + "first_step": "Bind the unchanged R437 call/return ownership contract to this PROOF.md and #5055's producer ledger; list each resident owner at entry, leaf completion and return, and derive T from the actual primitive/callback paths rather than the finite observed peaks.", + "blocked_by": "A complete source-bound node/recursive restoration and traffic proof. Context/codebook, stock/precision and native/compiler/outer admission remain outside this package; coordinate a fresh nonoverlapping claim first." + } + ] +} diff --git a/research/r437-streamed-leaf-workspace/VERIFY.json b/research/r437-streamed-leaf-workspace/VERIFY.json new file mode 100644 index 0000000000..59136e17ad --- /dev/null +++ b/research/r437-streamed-leaf-workspace/VERIFY.json @@ -0,0 +1,449 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/bit-p111-r437-gl464-470-20261018/code/invoice_audit.py", + "research/bit-p111-r437-gl464-470-20261018/data/GEOMETRY.json", + "research/bit-p111-r437-gl464-470-20261018/vendor/assemble9.py", + "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/encoded-child-spectators/CERTIFICATE.json", + "research/encoded-child-spectators/CONTEXT.json", + "research/encoded-child-spectators/PROOF.md", + "research/encoded-child-spectators/README.md", + "research/encoded-child-spectators/SOURCES.json", + "research/encoded-child-spectators/TASK.json", + "research/encoded-child-spectators/TIMINGS.json", + "research/encoded-child-spectators/VERIFICATION.md", + "research/encoded-child-spectators/VERIFY.json", + "research/encoded-child-spectators/bench.py", + "research/encoded-child-spectators/cases.py", + "research/encoded-child-spectators/controls.py", + "research/encoded-child-spectators/independent.py", + "research/encoded-child-spectators/powers.py", + "research/encoded-child-spectators/runtime.py", + "research/encoded-child-spectators/tariff.py", + "research/encoded-child-spectators/verify.py", + "research/physical-compiler-correspondence/README.md", + "research/physical-compiler-correspondence/owners.py", + "research/pr589-five-helper-hosting/PROOF.md", + "research/pr589-five-helper-hosting/verify.py", + "research/r437-carrier-integration/admission.py", + "research/r437-carrier-integration/compiler.py", + "research/r437-carrier-integration/numerical.py", + "research/r437-carrier-integration/physical.py", + "research/r437-oq4-caller-binding/RANK26-COST.md", + "research/r437-pooled-native-interface/.gitattributes", + "research/r437-pooled-native-interface/PROOF.md", + "research/r437-pooled-native-interface/README.md", + "research/r437-pooled-native-interface/RESULT.json", + "research/r437-pooled-native-interface/SOURCES.json", + "research/r437-pooled-native-interface/TASK.json", + "research/r437-pooled-native-interface/VALIDATION.md", + "research/r437-pooled-native-interface/VERIFY.json", + "research/r437-pooled-native-interface/adapter.py", + "research/r437-pooled-native-interface/check_interface.py", + "research/r437-pooled-native-interface/check_transport.py", + "research/r437-pooled-native-interface/inputs/EXPECTED.json", + "research/r437-pooled-native-interface/inputs/catalogue.py", + "research/r437-pooled-native-interface/inputs/geometry.json.gz", + "research/r437-pooled-native-interface/inputs/moves.json", + "research/r437-pooled-native-interface/inputs/template.json.gz", + "research/r437-pooled-native-interface/inputs/word.json.gz", + "research/r437-pooled-native-interface/pooled_compiler.py", + "research/r437-pooled-native-interface/replica_catalogue.py", + "research/r437-pooled-native-interface/verify.py", + "research/r437-prefix-consumer-fusion/PROOF.md", + "research/r437-prefix-consumer-fusion/SOURCES.json", + "research/r437-prefix-consumer-fusion/adapter.py", + "research/r437-prefix-consumer-fusion/retained/selected-result.json", + "research/r437-prefix-consumer-fusion/verify.py", + "research/r437-preparation-composition/.gitattributes", + "research/r437-preparation-composition/POOLED-SOURCES.json", + "research/r437-preparation-composition/PREDECESSORS.json", + "research/r437-preparation-composition/PROOF.md", + "research/r437-preparation-composition/README.md", + "research/r437-preparation-composition/RESULT.json", + "research/r437-preparation-composition/REVIEW.md", + "research/r437-preparation-composition/SOURCES.json", + "research/r437-preparation-composition/TASK.json", + "research/r437-preparation-composition/VALIDATION.json", + "research/r437-preparation-composition/VERIFY.json", + "research/r437-preparation-composition/forward_fields.py", + "research/r437-preparation-composition/independent.py", + "research/r437-preparation-composition/predecessor4025/source/CALLER.py", + "research/r437-preparation-composition/predecessor4025/source/NOTICE.md", + "research/r437-preparation-composition/predecessor4025/source/cardinality.py", + "research/r437-preparation-composition/predecessor4025/source/counts.py", + "research/r437-preparation-composition/predecessor4025/source/directory.py", + "research/r437-preparation-composition/predecessor4025/source/records.py", + "research/r437-preparation-composition/predecessor4025/source/stream.py", + "research/r437-preparation-composition/predecessor4025/source/words.py", + "research/r437-preparation-composition/predecessor4025/verify.py", + "research/r437-preparation-composition/test_verify.py", + "research/r437-preparation-composition/vendor/certificates/selected-result.json", + "research/r437-preparation-composition/vendor/research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz", + "research/r437-preparation-composition/vendor/research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json", + "research/r437-preparation-composition/vendor/research/e8-bit-p111-tuned/tune/EXPECTED.json", + "research/r437-preparation-composition/vendor/research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "research/r437-preparation-composition/vendor/research/physical-compiler-correspondence/README.md", + "research/r437-preparation-composition/vendor/research/physical-compiler-correspondence/owners.py", + "research/r437-preparation-composition/vendor/research/pr589-five-helper-hosting/PROOF.md", + "research/r437-preparation-composition/vendor/research/pr589-five-helper-hosting/verify.py", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/.gitattributes", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/PROOF.md", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/README.md", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/RESULT.json", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/SOURCES.json", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/TASK.json", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/VALIDATION.md", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/VERIFY.json", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/adapter.py", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/check_interface.py", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/check_transport.py", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/EXPECTED.json", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/catalogue.py", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/geometry.json.gz", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/moves.json", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/template.json.gz", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/word.json.gz", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/pooled_compiler.py", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/replica_catalogue.py", + "research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/verify.py", + "research/r437-preparation-composition/vendor/research/recursive-parking-boundary/README.md", + "research/r437-preparation-composition/vendor/research/selected-bit-local-ring-sweeps/PROOF.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/PROOF.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/README.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/RESULT.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/SNAPSHOTS.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/SOURCES.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/TASK.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/VALIDATION.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/VERIFY.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/continuation_checks.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/frame_checks.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/EVIDENCE.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/PREDECESSOR.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/PROOF.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/README.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/RESULT.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/SOURCES.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/TASK.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/VALIDATION.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/VERIFY.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/bootstrap.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_layout.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_nested_model.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_recursion.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_runtime.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_sign.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_sources.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/consumer.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/control_checks.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/driver.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/NOTICE.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2688-NOTICE.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2688-PROOF.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2708-README.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2731-README.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/layout.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/linear_sign.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/node.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/packet_engine.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/peel.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/NOTICE.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/PROOF.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/README.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/RESULT.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/SOURCES.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/TASK.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/VERIFY.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/cardinal_counts.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/catalogue.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_headers.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_layout.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_runtime.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_sources.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/consumer.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/control.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/control_checks.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/driver.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/fresh_rows.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/layout.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/model.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/node.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/packet_engine.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/peel.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/topology.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/binding.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/bitstream.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/cardinality.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/check_support.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/children.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/controller.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/counts.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/directory.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/episode.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/forms.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/low_codes.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/matrices.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/numeric.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/oracle.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/packet.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/plan.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/records.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/residual.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/routes.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/selection.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/sources.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/stream.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/stream_runner.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/trace.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/words.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/verify.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/recursive_call.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/scheduler.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/stream_runner.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/trace.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/verify.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/NOTICE.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/PROOF.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/README.md", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/RESULT.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/SOURCES.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/TASK.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/VERIFY.json", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/checks.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/codec.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/vendor/parking_machine.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/vendor/pr2753_recursive_call.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/vendor/words.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/verify.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/loader.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_binding.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_checks.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_code.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_controls.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_local_checks.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_machine.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_selected_checks.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/nested_bank_checks.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/numerical_frame.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/residual_blocks.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/role_parking.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/scratch_pool.py", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/verify.py", + "research/r437-preparation-composition/vendor/research/selected-bit-recursive-closure/PROOF.md", + "research/r437-preparation-composition/vendor/upstream/build/sections/02-streams.tex", + "research/r437-preparation-composition/verify.py", + "research/r437-reverse-row-coefficient/README.md", + "research/r437-reverse-row-coefficient/SOURCES.json", + "research/r437-reverse-row-coefficient/TASK.json", + "research/r437-reverse-row-coefficient/VERIFY.json", + "research/r437-reverse-row-coefficient/independent.py", + "research/r437-reverse-row-coefficient/inputs/CANDIDATE-PHASES.json.gz", + "research/r437-reverse-row-coefficient/inputs/R437-COMPOSED-WORD.json.gz", + "research/r437-reverse-row-coefficient/test_verify.py", + "research/r437-reverse-row-coefficient/verify.py", + "research/r437-streaming-directory/PROOF.md", + "research/r437-streaming-directory/SOURCES.json", + "research/r437-streaming-directory/TASK.json", + "research/r437-streaming-directory/actual64.py", + "research/r437-streaming-directory/actual_bridge.py", + "research/r437-streaming-directory/retained/selected-result.json", + "research/r437-streaming-directory/streaming.py", + "research/r437-streaming-directory/verify.py", + "research/r437-two-window-carrier/CANDIDATE-TEMPLATE.json", + "research/r437-two-window-carrier/CANDIDATE.json", + "research/r437-two-window-carrier/HOST-RESULT.json", + "research/r437-two-window-carrier/LOSING-CONTROL-RESULT.json", + "research/r437-two-window-carrier/LOSING-CONTROL.json", + "research/r437-two-window-carrier/README.md", + "research/r437-two-window-carrier/RESULT.json", + "research/r437-two-window-carrier/RETAINED.json", + "research/r437-two-window-carrier/SOURCES.json", + "research/r437-two-window-carrier/TASK.json", + "research/r437-two-window-carrier/VERIFY.json", + "research/r437-two-window-carrier/candidate-template-chunks/part-000.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-001.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-002.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-003.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-004.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-005.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-006.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-007.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-008.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-009.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-010.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-011.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-012.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-013.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-014.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-015.bin", + "research/r437-two-window-carrier/candidate-template-chunks/part-016.bin", + "research/r437-two-window-carrier/host.py", + "research/r437-two-window-carrier/inputs/LICENSE", + "research/r437-two-window-carrier/inputs/OQ4-EXPECTED.json", + "research/r437-two-window-carrier/inputs/OQ4-TEMPLATE.json.gz", + "research/r437-two-window-carrier/inputs/R437-COMPOSED-WORD.json.gz", + "research/r437-two-window-carrier/inputs/UPSTREAM-NOTICE.md", + "research/r437-two-window-carrier/test_package.py", + "research/r437-two-window-carrier/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", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Complete R437 leaf/XOR workspace replay and controls" + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Optimized complete R437 leaf/XOR workspace replay and controls" + } + ] +} diff --git a/research/r437-streamed-leaf-workspace/actual_bridge.py b/research/r437-streamed-leaf-workspace/actual_bridge.py new file mode 100644 index 0000000000..0dbcfab375 --- /dev/null +++ b/research/r437-streamed-leaf-workspace/actual_bridge.py @@ -0,0 +1,57 @@ +"""Two selected actual64 prefixes; never a full 3**4096-domain claim. + +Adapted from JoyboyBrian's #5055 actual_bridge.py, preserving its reader/guards. +Krzysztof Wójt with substantial OpenAI Codex assistance; Apache-2.0. +""" +from pathlib import Path +import importlib.util +from cardinal_counts import Count, positive +from stream import Counter +from words import BLANK, Unsigned, need +import packet + +HERE = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location("r437_workspace_body", HERE / "pooled.py") +body = importlib.util.module_from_spec(spec) +spec.loader.exec_module(body) + + +def run(source, target, events, layout, prefixes, prefix_count, field_count, + coefficient, context, old_count, observe=None, *, workspace=None): + need(len({id(source), id(target), id(prefixes)}) == 3, "distinct streamed borrowed roles") + positive(prefix_count) + positive(old_count) + positive(context.highs) + total = Count.product(old_count, context.highs) + try: + need(total.equals(prefix_count), "complete calibration prefix product") + finally: + total.close() + + def selected(old, fields, count, code, ctx, consume): + remaining = Counter(prefix_count) + try: + old.rewind() + while not remaining.finished: + prefix = packet.read_prefix(old, field_count) + try: + consume(prefix) + finally: + prefix.clear() + remaining.decrement() + need(old.read() == BLANK, "complete calibration selected directory") + return Count(prefix_count) + finally: + old.rewind() + remaining.close() + + one = field_count.arena.literal(1) + previous, borrow = Unsigned(field_count.arena).subtract(field_count, one) + field_count.arena.free(one) + need(not borrow, "positive calibration field count") + try: + return body.run(source, target, events, layout, prefixes, previous, + old_count, 0, context, coefficient, observe, + workspace=workspace, visitor=selected) + finally: + field_count.arena.free(previous) diff --git a/research/r437-streamed-leaf-workspace/bounds.py b/research/r437-streamed-leaf-workspace/bounds.py new file mode 100644 index 0000000000..38c318b461 --- /dev/null +++ b/research/r437-streamed-leaf-workspace/bounds.py @@ -0,0 +1,37 @@ +"""Conservative source-parameter bounds; not a fresh runtime decoder. + +Krzysztof Wójt with substantial OpenAI Codex assistance; Apache-2.0. +""" + + +def workspace_bound(*, q, fibre, prefix_body, program_body, callback_depth, + index_bits, residue_bits, entry_backing=0): + values = (q, fibre, prefix_body, program_body, callback_depth, + index_bits, residue_bits, entry_backing) + if any(type(value) is not int for value in values): + raise ValueError("integer bound parameters") + if q < 2 or fibre < 1 or min(index_bits, residue_bits) < 1 or min( + prefix_body, program_body, callback_depth, entry_backing) < 0: + raise ValueError("nonnegative extents and positive radix/fibre/word widths") + roles = q * q + 136 + stack_record = max(2 * index_bits + 4, residue_bits + 3) + body = max(fibre, prefix_body, program_body, + (2 * callback_depth + 3) * stack_record, + index_bits + 3, residue_bits + 3, fibre.bit_length() + 3) + return dict(roles=roles, stack_record=stack_record, body_bound=body, + fresh_retained_cells=roles * (body + 2), + with_entry_reserve=entry_backing + roles * (body + 2)) + + +def clear_tariff(head, body): + if type(head) is not int or type(body) is not int or head < 1 or body < 0: + raise ValueError("valid starting head and contiguous body extent") + return dict(reads=head + 2 * body + 2, writes=body, moves=head + 2 * body + 3) + + +def pooling_surcharge(roles, prefixes, acquisitions, callback_closes): + if any(type(x) is not int or x < 0 for x in (roles, prefixes, acquisitions, callback_closes)) or roles == 0: + raise ValueError("nonnegative tariff counts and positive role inventory") + # Starting from blank origins, setup is `roles` writes and `roles` moves. + # The interval assumes these prepared LEFT markers and heads are supplied. + return acquisitions + 4 * roles * prefixes + 28 * callback_closes diff --git a/research/r437-streamed-leaf-workspace/evidence.py b/research/r437-streamed-leaf-workspace/evidence.py new file mode 100644 index 0000000000..7189fe9cc9 --- /dev/null +++ b/research/r437-streamed-leaf-workspace/evidence.py @@ -0,0 +1,114 @@ +"""Checker-only accounting; none of these observations select runtime actions. + +Krzysztof Wójt with substantial OpenAI Codex assistance; Apache-2.0. +""" +from contextlib import contextmanager + + +def need(value, message): + if not value: + raise ValueError(message) + + +def actions(meter): + return {name: getattr(meter, name) for name in ("reads", "writes", "moves")} + + +def plus(target, values): + for name, value in values.items(): + target[name] += value + + +class Audit: + def __init__(self, pool): + self.pool = pool + self.identities = tuple(id(tape) for tape in pool.tapes) + self.ids = set(self.identities) + self.lease_actions = dict(reads=0, writes=0, moves=0) + self.clear_actions = dict(reads=0, writes=0, moves=0) + self.retired = self.clear_calls = self.callback_closes = 0 + self.boundaries = [] + + def meter(self): + result = dict(reads=0, writes=0, moves=0) + for tape in self.pool.tapes: + plus(result, actions(tape.meter)) + return result + + @contextmanager + def installed(self): + from records import Tape + from scratch_pool import Lease + import controller + from words import BLANK + old_clear, old_retire, old_close = Tape.clear, Lease.clear, controller.Callback.close + + def clear(tape): + if id(tape) not in self.ids: + return old_clear(tape) + before, head = actions(tape.meter), tape.head + length = 0 + for value in tape.cells[1:]: + if value == BLANK: + break + length += 1 + need(all(value == BLANK for value in tape.cells[length + 1:]), + "no hidden nonblank suffix before scratch erasure") + old_clear(tape) + delta = {name: getattr(tape.meter, name) - before[name] for name in before} + need(delta == dict(reads=head + 2 * length + 2, writes=length, + moves=head + 2 * length + 3), + "literal clear read/write/unit-move formula") + self.clear_calls += 1 + plus(self.clear_actions, delta) + + def retire(lease): + active = lease.active + old_retire(lease) + if active and lease.pool is self.pool: + self.retired += 1 + plus(self.lease_actions, actions(lease.meter)) + + def close(callback): + old_close(callback) + self.callback_closes += 1 + + Tape.clear, Lease.clear, controller.Callback.close = clear, retire, close + try: + yield self + finally: + Tape.clear, Lease.clear, controller.Callback.close = old_clear, old_retire, old_close + + def observe(self, pool): + from words import BLANK + need(pool is self.pool and tuple(id(t) for t in pool.tapes) == self.identities, + "same physical roles at every complete prefix") + need(not pool.live and pool.allocations == self.retired == self.clear_calls, + "each acquisition has exactly one paid retirement") + need(all(t.head == 1 and all(x == BLANK for x in t.cells[1:]) for t in pool.tapes), + "all retained pool backing blank at the complete boundary") + prefixes, capacity = len(self.boundaries) + 1, len(pool.tapes) + total = self.meter() + need(total == dict( + reads=self.lease_actions["reads"] + pool.allocations + 2 * capacity * prefixes, + writes=self.lease_actions["writes"], + moves=self.lease_actions["moves"] + 2 * capacity * prefixes, + ), "complete physical/lease/acquire/boundary traffic conservation") + self.boundaries.append(dict( + prefixes=prefixes, roles=capacity, peak=pool.peak, + acquisitions=pool.allocations, retired=self.retired, + backing=sum(len(t.cells) for t in pool.tapes), + largest=max(len(t.cells) for t in pool.tapes), + record_actions=total, lease_actions=dict(self.lease_actions), + clear_calls=self.clear_calls, clear_actions=dict(self.clear_actions), + callback_closes=self.callback_closes, + allocation_and_boundary_actions=pool.allocations + 4 * capacity * prefixes, + )) + + def result(self): + need(self.boundaries, "nonempty complete-prefix evidence") + result = dict(self.boundaries[-1]) + result["first_prefix_backing"] = self.boundaries[0]["backing"] + result["backing_constant_after_first_prefix"] = all( + row["backing"] == result["first_prefix_backing"] for row in self.boundaries) + return result diff --git a/research/r437-streamed-leaf-workspace/pooled.py b/research/r437-streamed-leaf-workspace/pooled.py new file mode 100644 index 0000000000..e3a08fa04a --- /dev/null +++ b/research/r437-streamed-leaf-workspace/pooled.py @@ -0,0 +1,93 @@ +"""Fixed-workspace specialization of the unchanged #5055 leaf/XOR consumer. + +Krzysztof Wójt, with substantial OpenAI Codex assistance; Apache-2.0. +The source algorithm is JoyboyBrian's; physical leases are Jose Manuel's. +No frozen source is modified. This module must be loaded after the source loader. +""" + +import importlib.util +from pathlib import Path +from types import FunctionType + +from records import Tape +from scratch_pool import ScratchPool +from words import need + + +ROOT = Path(__file__).resolve().parents[2] +_spec = importlib.util.spec_from_file_location( + "r437_workspace_predecessor", + ROOT / "research/r437-streaming-directory/streaming.py", +) +_source = importlib.util.module_from_spec(_spec) +_spec.loader.exec_module(_source) + +# Public producer is exactly the predecessor's producer, including its guards. +visit = _source.visit + + +def role_capacity(q): + """A conservative source-call-graph bound, not an observed peak.""" + need(type(q) is int and q >= 2, "compiled radix at least two") + return q * q + 136 + + +class Workspace: + """One caller-owned pool, reused only at complete prefix boundaries. + + `observe` is an optional checker hook and is not part of runtime semantics. + Callers must not retain a scratch lease beyond the synchronous consumer. + """ + + def __init__(self, q, *, capacity=None, observe=None): + bound = role_capacity(q) + self.q = q + self.pool = ScratchPool(bound if capacity is None else capacity) + self.observe = observe + self.active = False + + def tape(self): + # Only the full returned output is allocated outside the local interval. + # The finite phase flag never depends on an encoded numerical value. + return self.pool.acquire() if self.active else Tape() + + def consume(self, callback, prefix): + need(not self.active and not self.pool.live, "closed workspace entry") + self.active = True + try: + with self.pool.install(): + callback(prefix) + finally: + self.active = False + # This is a successful-return contract, not arbitrary-exception rollback. + self.pool.empty() + if self.observe is not None: + self.observe(self.pool) + + +def run(source, target, events, layout, old, old_fields, old_count, code, + context, coefficient, observe=None, *, workspace=None, visitor=None): + """Execute the exact predecessor code with bounded allocation specialization. + + `visitor` is only for a separately labelled selected-prefix calibration. + The ordinary path uses the full unchanged high-cube producer. + The returned full output remains an ordinary caller-owned physical tape. + """ + owned = workspace if workspace is not None else Workspace(layout.q) + need(owned.q == layout.q, "workspace compiled radix matches layout") + producer = visit if visitor is None else visitor + + def pooled_visit(old, fields, count, source_code, ctx, callback): + def consume(prefix): + return owned.consume(callback, prefix) + return producer(old, fields, count, source_code, ctx, consume) + + body = FunctionType( + _source.run.__code__, + dict(_source.run.__globals__, Tape=owned.tape, visit=pooled_visit), + _source.run.__name__, + _source.run.__defaults__, + ) + # Literal source execution: source order, guards, callbacks and copies remain. + return body(source, target, events, layout, old, old_fields, old_count, + code, context, coefficient, observe) diff --git a/research/r437-streamed-leaf-workspace/verify.py b/research/r437-streamed-leaf-workspace/verify.py new file mode 100644 index 0000000000..ca633265c2 --- /dev/null +++ b/research/r437-streamed-leaf-workspace/verify.py @@ -0,0 +1,298 @@ +#!/usr/bin/env python3 +"""Source-bound complete producer/leaf/XOR fixed-workspace certificates. + +Krzysztof Wójt with substantial OpenAI Codex assistance; Apache-2.0. +The complete payload fixtures and their independent oracles are JoyboyBrian's. +""" + +import argparse +import ast +import hashlib +import importlib.util +import json +from pathlib import Path +import subprocess +import sys +from types import SimpleNamespace + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def need(value, message): + if not value: + raise ValueError(message) + + +def load(name, path): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def authenticate(): + manifest = json.loads((HERE / "SOURCES.json").read_text()) + rows = [row for row in manifest["files"] if row["usage"] == "input"] + for row in rows: + need(hashlib.sha256((ROOT / row["path"]).read_bytes()).hexdigest() == row["sha256"], + "source bytes " + row["path"]) + return len(rows) + + +def physical(tape): + return tape.physical if hasattr(tape, "physical") else tape + + +def bind_bound(result, parameters): + bounds = load("r437_workspace_bounds", HERE / "bounds.py") + bound = bounds.workspace_bound(**parameters) + observed = result["workspace"] + need(observed["roles"] == bound["roles"], "source-derived role reserve") + need(observed["largest"] <= bound["body_bound"] + 2 and + observed["backing"] <= bound["fresh_retained_cells"], + "source-derived retained backing reserve") + result["bound_parameters"] = parameters + result["uniform_bound"] = bound + result["pooling_surcharge_bound"] = bounds.pooling_surcharge( + observed["roles"], observed["prefixes"], observed["acquisitions"], + observed["callback_closes"]) + + +def omit_retirement(module): + """A controlled in-memory defect in exactly one predecessor cleanup site.""" + source = module._source + tree = ast.parse(Path(source.__file__).read_text(), filename=source.__file__) + changed = 0 + + class Omit(ast.NodeTransformer): + def visit_Expr(self, node): + nonlocal changed + call = node.value + if (isinstance(call, ast.Call) and isinstance(call.func, ast.Attribute) + and isinstance(call.func.value, ast.Name) + and call.func.value.id == "left" and call.func.attr == "clear"): + changed += 1 + return None + return self.generic_visit(node) + + tree = Omit().visit(tree) + need(changed == 1, "one deliberately omitted left-fibre retirement") + scope = dict(source.__dict__) + exec(compile(ast.fix_missing_locations(tree), source.__file__, "exec"), scope) + source.run = scope["run"] + + +def generic(mode="normal"): + """Retain the complete source fixture, guards and independent payload oracle.""" + path = ROOT / "research/r437-streaming-directory/verify.py" + tree = ast.parse(path.read_text(), filename=str(path)) + changes = 0 + observations = [] + + def adapter(): + module = load("r437_pooled_consumer", HERE / "pooled.py") + if mode == "omitted-retirement": + omit_retirement(module) + + def run(*args, **kwargs): + evidence = load("r437_workspace_evidence", HERE / "evidence.py") + workspace = module.Workspace(args[3].q, capacity=1 if mode == "capacity" else None) + audit = evidence.Audit(workspace.pool) + workspace.observe = audit.observe + if mode == "raw-constructor": + workspace.tape = module.Tape + elif mode == "dirty-reuse": + def dirty(pool): + audit.observe(pool) + pool.tapes[0].write(0) + workspace.observe = dirty + with audit.installed(): + result = module.run(*args, **kwargs, workspace=workspace) + observations.append(audit.result()) + return result + + return SimpleNamespace(visit=module.visit, run=run) + + class Bind(ast.NodeTransformer): + def visit_Assign(self, node): + nonlocal changes + if any(isinstance(target, ast.Name) and target.id == "streaming" + for target in node.targets): + need(isinstance(node.value, ast.Call) and + isinstance(node.value.func, ast.Name) and node.value.func.id == "module", + "pinned fixture adapter load") + changes += 1 + node.value = ast.Call(func=ast.Name(id="ADAPTER", ctx=ast.Load()), args=[], keywords=[]) + return self.generic_visit(node) + + tree = Bind().visit(tree) + ast.fix_missing_locations(tree) + need(changes == 1, "exact generic fixture adapter substitution") + scope = {"__file__": str(path), "__name__": "r437_workspace_generic", "ADAPTER": adapter} + exec(compile(tree, str(path), "exec"), scope) + result = scope["run"]() + need(len(observations) == 1 and observations[0]["prefixes"] == 243, + "all complete high-cube consumer boundaries") + final = observations[0] + need(final["backing_constant_after_first_prefix"], "fixed fixture backing across all 243 prefixes") + result["workspace"] = final + bind_bound(result, dict(q=3, fibre=81, + prefix_body=result["producer"]["max_current_prefix_bytes"], + program_body=0, callback_depth=0, index_bits=8, residue_bits=5)) + result["status"] = "PASS_R437_STREAMED_LEAF_WORKSPACE_GENERIC" + result["scope"] = "Complete q3/w2/d2 high cube with the same physical scratch pool; no production GL64 replay." + return result + + +def actual(): + """The #4981/#5055 actual SOURCE87 calibration, with explicit lease observers.""" + path = ROOT / "research/r437-prefix-consumer-fusion/verify.py" + tree = ast.parse(path.read_text(), filename=str(path)) + edits = [0, 0, 0, 0, 0] + observations = [] + parameters = [] + + def capture_bound(volume, prefixes, program, child, ia, ra): + parameters.append(dict(q=3, fibre=volume, + prefix_body=max(len(raw) - 1 for raw in prefixes), + program_body=len(physical(program).cells) - 1, + callback_depth=child.depth.inspect(), + index_bits=ia.bits, residue_bits=ra.bits)) + + def configure(adapter): + original = adapter.run + + def run(*args, **kwargs): + evidence = load("r437_workspace_evidence_actual", HERE / "evidence.py") + workspace = adapter.body.Workspace(args[3].q) + audit = evidence.Audit(workspace.pool) + workspace.observe = audit.observe + with audit.installed(): + result = original(*args, **kwargs, workspace=workspace) + observations.append(audit.result()) + return result + adapter.run = run + + class Bind(ast.NodeTransformer): + def visit_Assign(self, node): + node = self.generic_visit(node) + if any(isinstance(target, ast.Name) and target.id == "result" + for target in node.targets) and isinstance(node.value, ast.Call) and ( + isinstance(node.value.func, ast.Name) and node.value.func.id == "dict"): + edits[4] += 1 + capture = ast.parse("CAPTURE_BOUND(volume, prefix_bytes, copied, child, ia, ra)").body[0] + return [node, capture] + return node + + def visit_BinOp(self, node): + if (isinstance(node.op, ast.Div) and isinstance(node.left, ast.Name) + and node.left.id == "HERE" and isinstance(node.right, ast.Constant) + and node.right.value == "adapter.py"): + edits[0] += 1 + return ast.copy_location(ast.BinOp(ast.Name("CURRENT", ast.Load()), ast.Div(), + ast.Constant("actual_bridge.py")), node) + return self.generic_visit(node) + + def visit_FunctionDef(self, node): + if node.name == "run": + start = next(i for i, value in enumerate(node.body) if isinstance(value, ast.With)) + block = node.body[start].body + begin = next(i for i, value in enumerate(block) if isinstance(value, ast.Assign) + and any(isinstance(t, ast.Name) and t.id == "bad_count" for t in value.targets)) + end = next(i for i, value in enumerate(block) if isinstance(value, ast.Assign) + and any(isinstance(t, ast.Name) and t.id == "dirty" for t in value.targets)) + del block[begin:end] + edits[1] += 1 + return self.generic_visit(node) + + def visit_Expr(self, node): + node = self.generic_visit(node) + if (isinstance(node.value, ast.Call) and isinstance(node.value.func, ast.Attribute) + and node.value.func.attr == "exec_module" and len(node.value.args) == 1 + and isinstance(node.value.args[0], ast.Name) and node.value.args[0].id == "adapter"): + edits[2] += 1 + return [node, ast.Expr(ast.Call(ast.Name("CONFIGURE", ast.Load()), + [ast.Name("adapter", ast.Load())], []))] + return node + + def visit_Attribute(self, node): + node = self.generic_visit(node) + if node.attr == "cells": + edits[3] += 1 + node.value = ast.Call(ast.Name("PHYSICAL", ast.Load()), [node.value], []) + return node + + tree = Bind().visit(tree) + ast.fix_missing_locations(tree) + need(edits == [2, 1, 1, 28, 1], "exact actual64 adapter/guard/observer substitutions") + scope = {"__file__": str(path), "__name__": "r437_workspace_actual64", + "CURRENT": HERE, "CONFIGURE": configure, "PHYSICAL": physical, + "CAPTURE_BOUND": capture_bound} + exec(compile(tree, str(path), "exec"), scope) + result = scope["run"]() + need(len(observations) == 1 and observations[0]["prefixes"] == 2, + "actual64 both complete prefixes use identical pool") + final = observations[0] + result["workspace"] = final + need(len(parameters) == 1, "one source-parameter observation before cleanup") + bind_bound(result, parameters[0]) + result["fixture_edits"] = edits + result["status"] = "PASS_R437_STREAMED_LEAF_WORKSPACE_ACTUAL64" + result["scope"] = "Two actual SOURCE87 prefixes and full computed leaf/XOR payload; not full high-domain execution or admission." + return result + + +def main(): + parser = argparse.ArgumentParser() + failures = { + "capacity": "fixed scratch role inventory exhausted", + "omitted-retirement": "completed macro closes all scratch leases", + "raw-constructor": "physical Tape allocation inside a completed macro", + "dirty-reuse": "empty scratch role before reuse", + } + parser.add_argument("--mode", choices=("all", "generic", "actual", *failures), default="all") + parser.add_argument("--write", action="store_true") + args = parser.parse_args() + inputs = authenticate() + if args.mode in failures: + try: + generic(args.mode) + except ValueError as error: + need(str(error) == failures[args.mode], "exact workspace rejection reason: " + str(error)) + result = dict(control=args.mode, rejected=True, reason=str(error)) + else: + raise ValueError("deliberate workspace defect accepted: " + args.mode) + elif args.mode == "generic": + result = generic() + elif args.mode == "actual": + result = actual() + else: + command = [sys.executable, "-I", "-W", "error", "-B"] + if sys.flags.optimize: + command.append("-O") + cases = {} + for mode in ("generic", "actual", *failures): + completed = subprocess.run(command + [str(HERE / "verify.py"), "--mode", mode], + capture_output=True, text=True, timeout=420) + need(completed.returncode == 0, mode + " child verifier failed:\n" + completed.stderr) + cases[mode] = json.loads(completed.stdout) + result = dict(status="PASS_R437_STREAMED_LEAF_WORKSPACE", authenticated_inputs=inputs, + generic=cases.pop("generic"), actual64=cases.pop("actual"), + workspace_controls=list(cases.values()), numerical_admitted=False, + selected_frontier_changed=False, + scope="Uniform successful leaf/XOR workspace refinement, with separate complete small-cube and two-prefix actual64 evidence.") + encoded = json.dumps(result, indent=2, sort_keys=True) + "\n" + receipt = HERE / "RESULT.json" + if args.write: + receipt.write_text(encoded) + else: + need(receipt.read_text() == encoded, "typed deterministic complete workspace receipt") + print(result["status"]) + return + need(not args.write, "--write requires the complete all-mode receipt") + print(json.dumps(result, sort_keys=True)) + + +if __name__ == "__main__": + main()