diff --git a/research/r437-carrier-integration/ADMISSION-MATRIX.md b/research/r437-carrier-integration/ADMISSION-MATRIX.md new file mode 100644 index 000000000..433c6d3e6 --- /dev/null +++ b/research/r437-carrier-integration/ADMISSION-MATRIX.md @@ -0,0 +1,27 @@ +# Admission matrix: what the integrated result establishes + +One scoped enabling result, significance class B. This table is a coverage map, +not a selected-result update. The exact receipts and frozen review determine +which checks actually passed; publication and hosted CI are separate statuses. + +| Boundary | New evidence | Exact qualification | +|---|---|---| +| Original/carrier source words and all COPY contracts | Independent complete659-column forward/reverse replay; nine capture projections; SOURCE writes and final arbitrary-DIRTY restoration | One full DIRTY capture differs. Its old operator is not reused. No new carrier is searched. | +| Pooled owner transport | All63 moves, chronology,125856 slot occurrences, actual chart-ordered left/right injections and complementary IDLE coordinates | Separately checked BIT component; no retracted #3959 complex-side headline. Physical gather/refinement is a premise. | +| Literal compiler/native requests | Complete903456 records, rebuilt codebook, actual stage/replica/event identity and matching independent digest; actual Driver and macro compiler IDLE consumers adapted | All finite metadata, not a production payload run or materialization of every GL64 plan. | +| Algebraic request domain | All fresh local idempotents plus exact characteristic polynomials;1235 chart unit determinants;179802 owner-pair witnesses | Uniform over odd primes. Split bases are selected at each fixed admissible prime; one universally dyadic-unit elimination minor is not assumed. | +| Changed bad-class/precision coverage | CompleteGL64 complementary-minor proof for every request class, unit ancestry/high-lift argument, explicit changed integer prefix and192/512 admission | Completed fallback and retained primitive/absolute route interface remain hypotheses. No floating-point or full rounding theorem is claimed. | +| Actual numerically checked source entry | Named prime2^127-1, actual fresh catalogue/native SOURCE87 specification; canonical root widths, compatible stock and guarded regional native IDLE emission | Host finite arithmetic and finite compilation. Root e=n64,w2,h0; descendant path certificate and physical guard tariffs remain separate. | +| Promoted SOURCE87 dirty acquisition | Actual Driver.local ordered dispatch traces both orientations; all659 acquisitions precede the changed MOVE; lost-read control rejects | Gather, routes and preceding residual bodies are explicitly symbolic here. Full dirty-state algebra is checked independently, not inferred from symbolic set union. | +| Source producer to completed child | Actual Context/directory/child Program and copied handoff are consumed by incoming callbacks in the new below-cutoff bridge | Complete972-bit four-atom active-child fibre, finite external spectators, nonzero GOOD ancestry; generic admitted history, not a literal selected-root reachability certificate. | +| Full residual and spectator connection | Full128-coordinate address identity modulo3 and9, including250 nonzero high fields, actual preparation, chronological pullback, and complete itinerary counts | Finite exact host algebra plus quantified pullback. It is not execution of9475 rows times all124 further atom coordinates or of the8692 adapter scans. General primitive/refinement remains inherited. | +| Return, consumer and disposal | Actual computed child output is consumed by literal D next XOR; protected metadata, borrowed bytes/heads and terminal owned erasure | D consumer extension is distinguished from the matched C/D return interval. A reduced fibre is not substituted for a production residual. | +| Logical original-root reserve | New Q+21 polynomial and directory absorption; exact compatible K^D divisor; retained11V_root+F_q under complete-packet/lifetime domain | Logical live storage. Finite tables, physical visited backing, permanent LEFT cells, blank-return and source setup time are not silently free. | +| Whole paid improvement / selected kappa | Favorable inherited recursive exchange retained; exact additional864 ADDs and changed prefix included; complete outstanding inequality in BILL.md | A global physical gain, productive full-family time/stock admission, both supplier endpoints and outer transfer remain unestablished. Selected complex-bound result unchanged. | + +The meaningful new connection is source identity and replica-aware compiler +consumption **plus** a proved numerical applicability boundary **plus** a real +produced-child handoff/consumer contract. The result would not be significant +if reduced to its request-table receipt or the already known reverse coefficient. +Same-session AI comparison and review use shared frozen sources and are not +independent human or proof-kernel acceptance. diff --git a/research/r437-carrier-integration/ADMISSION-RESULT.json b/research/r437-carrier-integration/ADMISSION-RESULT.json new file mode 100644 index 000000000..8d639eea1 --- /dev/null +++ b/research/r437-carrier-integration/ADMISSION-RESULT.json @@ -0,0 +1,192 @@ +{ + "actual_specification": { + "good": true, + "literal_source_code": { + "big_endian_sha256": "f22f11b89b8bd9674e4819b7cdf64caa75b9ea91b9ea35a31963131524258cb4", + "bit_length": 520204 + }, + "native_preparation_inverse_sha256": "2bdd659e19e949e686e7d7a0b414113374da3c683fde6d002f437bfd174dae55", + "native_preparation_sha256": "f621ce3539b7dd37d0e7f7281ba75d47383412569e8dd0b930fac64c040c2941", + "preparation_inverse_product_is_identity": true, + "rank": 2, + "specification_bound": true + }, + "admitted_entry": { + "common": false, + "compatible_rows": { + "big_endian_sha256": "f6bf5a75756bf8267103578f24f2b5934e122da6d96e68100fc2b28853da7a01", + "bit_length": 1040413 + }, + "domain": { + "I": 8, + "L": 255, + "Q": 520213, + "e": 64, + "h": 0, + "n": 64, + "w": 2 + }, + "entry_certificate_modular_square_subtract_steps": 125, + "guard_before_continuation": true, + "guard_implementation": "host finite arithmetic; exact source/parameter guard, physical encoded guard tariff open", + "mode": "numerical", + "numerical_admitted": true, + "production_payload_execution": false, + "q": "170141183460469231731687303715884105727", + "rank": 2, + "request": 1676, + "request_key": [ + "MOVE", + 0, + 0, + 22397 + ], + "row_multiplier": { + "big_endian_sha256": "4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a", + "bit_length": 1 + }, + "source_identity": "bcea2a31e9001699148b6f1ff8524a0c6c4524d70ef47add027651da31389a73", + "stock_certificate_scope": "original root" + }, + "constructor_adapter": { + "adapted_low_codes_sha256": "dbe5e7a1a6ccc5616fd4f350c67223739d49af98928d4153fecf49f9961b61a5", + "base_compiler_identity": "9be70d7e2d50c26730255b49548c4abd182897db0479cb35cf62b89a995de106", + "constructor_certificate_evaluations": 3, + "constructor_modular_square_subtract_steps": 375, + "prime_certificate": { + "exponent": 127, + "modular_square_subtract_steps": 125, + "q": "170141183460469231731687303715884105727", + "residue": 0 + }, + "retained_low_codes_sha256": "f657e17f6088c840e3f7783e662257630f6d2c1e71c217721ffbca4d6ac93e87", + "source_identity": "bcea2a31e9001699148b6f1ff8524a0c6c4524d70ef47add027651da31389a73" + }, + "controls": [ + "stale_codebook_handle", + "wrong_prime_certificate", + "composite_named_parameter", + "retained_constructor_composite_control", + "wrong_common_native_view", + "wrong_caller_request_key", + "wrong_replica_code_with_original_key", + "mismatched_specifications_context", + "untyped_integer_source", + "insufficient_stock", + "large_but_incompatible_stock", + "undersized_residue_width", + "padded_residue_width", + "undersized_source_width", + "wrong_root_index_width", + "wrong_root_precision", + "unrelated_history", + "descendant_without_root_path_certificate", + "actual_q3_cross_prime_handle", + "actual_cross_prime_specifications_context", + "semantic_fixture_is_not_numerically_admitted" + ], + "regional_emitter": { + "dimension": 64, + "emitter_certificate_modular_square_subtract_steps": 125, + "entry": { + "common": false, + "compatible_rows": { + "big_endian_sha256": "f6bf5a75756bf8267103578f24f2b5934e122da6d96e68100fc2b28853da7a01", + "bit_length": 1040413 + }, + "domain": { + "I": 8, + "L": 255, + "Q": 520213, + "e": 64, + "h": 0, + "n": 64, + "w": 2 + }, + "entry_certificate_modular_square_subtract_steps": 125, + "guard_before_continuation": true, + "guard_implementation": "host finite arithmetic; exact source/parameter guard, physical encoded guard tariff open", + "mode": "numerical", + "numerical_admitted": true, + "production_payload_execution": false, + "q": "170141183460469231731687303715884105727", + "rank": 14, + "request": 896352, + "request_key": [ + "IDLE", + 8, + 0, + 0 + ], + "row_multiplier": { + "big_endian_sha256": "4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a", + "bit_length": 1 + }, + "source_identity": "bcea2a31e9001699148b6f1ff8524a0c6c4524d70ef47add027651da31389a73", + "stock_certificate_scope": "original root" + }, + "forged_provenance_rejected": true, + "low_classes_executed": 1, + "mutated_wrapped_context_rejected": true, + "native_specification_good": false, + "old_compiler_wrapped_identity_rejected": true, + "operations": { + "block": 65828, + "checkpoint": 1, + "clear": 1, + "gather": 1, + "node": 1, + "residual_begin": 1, + "residual_end": 1, + "return": 1, + "scatter": 1 + }, + "rank": 14, + "request": 896352, + "scope": "Actual SelectedBinding and Cursor macro emission at admitted q127; one native IDLE, one GL64 low class. No packet/tape payload execution." + }, + "scope": "Actual q127 source/codebook/native specification and checked numerical+stock entry; guarded specification continuation and one actual native IDLE macro emission; no high-field directory or giant production payload executed. q3 fixture entry is semantic only. Physical encoded guard/compiler cost remains open.", + "semantic_fixture_entry": { + "common": false, + "compatible_rows": { + "big_endian_sha256": "b4b2fab41fd0a7ab8f92729e4049ab786f2b7de7db4938ba58754e3ce4c38be3", + "bit_length": 6520 + }, + "domain": { + "I": 13, + "L": 3, + "Q": 6512, + "e": 2048, + "h": 1, + "n": 64, + "w": 1 + }, + "entry_certificate_modular_square_subtract_steps": 0, + "guard_before_continuation": true, + "guard_implementation": "host finite arithmetic; exact source/parameter guard, physical encoded guard tariff open", + "mode": "semantic", + "numerical_admitted": false, + "production_payload_execution": false, + "q": "3", + "rank": 2, + "request": 1676, + "request_key": [ + "MOVE", + 0, + 0, + 22397 + ], + "row_multiplier": { + "big_endian_sha256": "4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a", + "bit_length": 1 + }, + "source_identity": "d854ee52df07cce2a47ded48539f6c25266c0c6f245c7b10a5dcafbb03f71a3b", + "stock_certificate_scope": "local semantic rows; no ancestor stock certificate" + }, + "source_sha256": { + "admission.py": "d34f0166a936decc4de0cc07ab4f8ca8dac6ac03f83b74b85a851098c01f3eae", + "compiler.py": "df86b31a80e1827dc20a3a34f20305b4b9cbd3582e3d26b8a05ac90e346177fb", + "numerical.py": "83f2b60a90ab2d0354c5c84f48af246ab416605c3ae4bd62368bbe5f23bb53bb" + }, + "status": "PASS_CHECKED_SOURCE_PARAMETER_ENTRY" +} diff --git a/research/r437-carrier-integration/BILL.md b/research/r437-carrier-integration/BILL.md new file mode 100644 index 000000000..21dedc3be --- /dev/null +++ b/research/r437-carrier-integration/BILL.md @@ -0,0 +1,151 @@ +# One compatible before/after bill and its admission boundary + +C is original R437 with the separately revalidated 63 pooled BIT owner moves. +D is #4067 with those same moves. Their source word, low-code context and +chronological handles differ; each arm must construct its own contexts. This +comparison imports neither #3959's retracted complex composition nor a pooled +headline as a selected result. + +## Complete finite compiler / inherited invoice interval + +| Quantity and unit | C | D | D minus C | +|---|---:|---:|---:| +| Paid native request sites | 903456 | 903456 | 0 | +| Native rank mass | 1808352 | 1808352 | 0 | +| Requested local projector bases | 529 | 530 | +1 | +| Interned Base objects, including retained prototypes | 541 | 542 | +1 | +| Actual source-code width at q=3 | 6512 | 6512 | 0 | +| Source-code width at every shared fixed q | LowCodes(q,64,903456).bits | same | 0 | +| Local ordinary scalar ADDs | 24208 | 24211 | +3 per call | +| Full scalar-plus-bridge invoice term | 7035840 | 7036704 | +864 | +| Global coefficient prefix | 2^18*49347^5*1113998^4 | 2^18*49347^5*1123650^4 | exact positive delta in NUMERICAL-RESULT.json | +| Prefix / two-level coefficient bit lengths | 177 / 393 | 177 / 393 | 0 / 0 | +| Charged prefix / two-level bit envelopes | 192 / 512 | 192 / 512 | 0 / 0 | +| Complete ROW coefficient under retained interface | 18355 | 18355 | 0; ceiling20161 | + +The reverse integer and prefix increase is paid, rather than rounded away by +bit-length equality. The old literal prefix cap rejects D. `numerical.py` +checks the strict integer inequalities for the named larger charged envelopes. +The source-dependent finite coefficient formula still has a retained absolute +77-factor routing/primitive premise. Equal C/D charts establish zero +incremental chart change; they do not independently prove that absolute tariff. + +The exact recursive profile delta is `{1:+288,2:-576,3:+288}`. For p=1-a, +02^80. The complete inherited98682 fallback-child +allowance fits the retained131072 charge per paid edge. This implication uses +projector, chart, low-class and weight coverage; unchanged E alone would not +establish it. Fallback time, source construction and class tests remain paid +under their named interfaces. + +The fresh source-width-aware metadata polynomial is + + (104541086181 + 17592241506793*b)*w^2, + +with Count and q^2 terms separately retained. The new directory inequality and +canonical root widths support the same conditional logical active-chain reserve +11*V_root+F_q. Original-root stock requires exact divisibility by + + (269241600*|GL64(q)|*q^(4096*(w-1)))^D(e). + +An oversized but incompatible row count rejects. This is logical live storage +with the documented frame lifetimes. It is not lifetime visited backing, +sequential blank-return on physical tapes, the selected stock coefficient, or +a proof that the inherited no-op check_stock already enforces anything. +The package's explicit checked entry and semantic fixtures are distinguished +in the admission receipt; q=3 fixtures are not numerically admitted. + +## Remaining whole-construction inequality + +Write R_X for the displayed recursive tariff sum, S for the scalar tariff, +Pi_X for complete source/coefficient/child preparation and returned-output +work, G_X for physical gather/route/scatter and primitive lowering, C_X for +checkpoint/continuation/disposal work, and F_X for finite table setup and stock +charges not already in those terms. A usable same-contract improvement needs + + R_C - R_D > 864*S + (Pi_D-Pi_C) + (G_D-G_C) + + (C_D-C_C) + (F_D-F_C), + +with the same original-root numerical and consumer contract on both sides. +The local executed differences and coefficientwise reserve results instantiate +specific pieces of this bill; they do not assign zero to the rest or subtract +unrelated upper bounds. In particular, fixed-tape metadata/allocator lowering, +absolute pooled routing/setup, full residual execution and lifetime backing +remain inherited or unresolved as stated. This package targets a substantial +**enabling integration**, not a demonstrated global paid physical speedup. +The selected supplier remains complex-bound; no selected kappa or outer transfer +is repriced. + +Credit all components and authors in README.md and SOURCES.json. New bill and +integration by Chris R / Clear1nsight with substantial OpenAI Codex assistance. +Apache-2.0. diff --git a/research/r437-carrier-integration/COMPARISON.md b/research/r437-carrier-integration/COMPARISON.md new file mode 100644 index 000000000..40e78e2e0 --- /dev/null +++ b/research/r437-carrier-integration/COMPARISON.md @@ -0,0 +1,124 @@ +# Separately written literal comparison + +`independent.py` imports no primary integration builder, old carrier builder, +pooled compiler, catalogue, or physical implementation. It reads shared frozen +mathematical inputs and independently interprets them. This is assisted checking +of common sources, not independent human acceptance or a formal-kernel proof. + +The source pins are #4067 at `a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e`, +#3647 at `a24f9ff95c12fd0b6792e3f710569237efd72db2`, #3959 at +`babd2e36471422cd3e97f912a5cf2846da52a222`, and #4010 at +`92daee4bf12255efe4ae0102eeb5f72794bf9c57`. The receipt authenticates its +literal word, old template, proposal and candidate byte inputs. Every candidate +template chunk is authenticated and the joined gzip hash is pinned. No frozen +input is modified. Source-history verification is a separate package check. + +## What is checked + +The checker uses Fraction row elimination for all 636 rationally closed frames, +and reconstructs both local chronological streams from the four word sections. +It verifies literal stream equality with each authenticated template. A separate +GF(2) interpreter tracks all 659 independent initial columns through forward and +reverse operations, including protected private COPY and ERASE. It checks full +terminal restoration, all SOURCE write observations, and COPY SOURCE rows/frames. +This symbolic scalar check does not itself prove physical native transport. + +The new rank-two SOURCE87 MOVE is at forward event 22397 (new B69), from frame 189 +to frame 509. The old MOVE was at event 22689 (old B283). Thus a source plan first +available at the old event cannot supply the earlier acquisition. There are 966 +SOURCE-write observations in either orientation; all agree. Exactly one complete +COPY DIRTY row differs: forward ordinal 7 and reverse ordinal 1 (zero-based). +All nine SOURCE rows and frame observations agree. The changed D has 55 rows. + +Chronological idle windows are derived from the outer schedule. All 63 proposed +owner changes must match their exact old owner. Absolute families, lifetime, +whole eight-coordinate support, disjoint occupancy and compact remaining +suffixes are checked with bitsets. Every one of 288 calls and 125,856 helper-owner +occurrences is covered; each IDLE suffix is enumerated once per replica/family. + +A separate request serializer computes local residual projectors by a rational +Gram-matrix inverse, rather than importing the catalogue's Gram-Schmidt code. +It derives owner charts, local and idle base hashes, native request fields, +ordered request hashes and full GL64 source-code widths. Both C and D are checked +under the retained replica request-record schema. The stronger carrier handle +schema is an integration-builder responsibility. + +## Four-way result and limits + +All four variants have 903,456 requests and rank mass 1,808,352. A/B use the original +OQ4 owners; C/D use the actual 63 pooled moves. The pooled incremental difference +D-C is exactly `{1:+288,2:-576,3:+288}`. The owner and IDLE-record digests remain +equal across the local word replacement. The fresh native request digest must +change because request positions and bases change. Equal request cardinality +alone does not authenticate old handles. + +For any real exponent `02^80; q source-admissible odd prime" + }, + "charged_envelope": { + "prefix_bits": 192, + "row_cap": 20161, + "two_level_bits": 512 + }, + "compiler_binding": { + "C": { + "code_bits": 6512, + "coverage": { + "chart_sha256": "7fdb9184c8e8f3f7027437ed446fec419a2935ece0665f9f3e865d9bd5369f45", + "charts": 1235, + "idle_enumeration": 63936, + "owner_pairs": 179802, + "owner_witness_sha256": "1818977337134cdda43778d82d79ca4a061a4fc271ad5cb0ec2966659abf2185", + "projectors": { + "bases": 541, + "domain": "every odd prime; dyadic idempotent plus characteristic polynomial t^(8-r)(t-1)^r", + "local": 529, + "sha256": "1d779db7ead07ddb80a649439e500ad7c54b8459587139486ae6547d63cb5f2d" + } + }, + "input_identity": "2aefee582eeab74d7297d7f741c00cb670e305e956a28c7f7a8fe013e7b159b5", + "request_sha256": "29ad864c2a6a31ad15162b0165b4f047cf580d9f2c147aebcfccfd564ccbbc60", + "requests": 903456, + "source_identity": "98973f100b099cfa4e7a0b7e57323f5fef31de4f57d87878ff8be5640f8ea59c" + }, + "D": { + "code_bits": 6512, + "coverage": { + "chart_sha256": "7fdb9184c8e8f3f7027437ed446fec419a2935ece0665f9f3e865d9bd5369f45", + "charts": 1235, + "idle_enumeration": 63936, + "owner_pairs": 179802, + "owner_witness_sha256": "1818977337134cdda43778d82d79ca4a061a4fc271ad5cb0ec2966659abf2185", + "projectors": { + "bases": 542, + "domain": "every odd prime; dyadic idempotent plus characteristic polynomial t^(8-r)(t-1)^r", + "local": 530, + "sha256": "6b82bcf856245beee9febfcf6dc4e926cd4c7adc01ac7b9edef2bcd68c33f655" + } + }, + "input_identity": "4cd00ec6b73d8fb7c651681efc2a0f75865d9e5b5d9a7b406558edd7593bfee7", + "request_sha256": "38f25cb3dfc2212522176cbbd2a87473db339b0d0df4e411817d3ffb1c56c94c", + "requests": 903456, + "source_identity": "d854ee52df07cce2a47ded48539f6c25266c0c6f245c7b10a5dcafbb03f71a3b" + } + }, + "controls": [ + "old_literal_global_prefix", + "shortened_prefix_word", + "shortened_two_level_word", + "understated_row_envelope", + "small_prime_bad_fraction", + "unpaid_fallback", + "zero_bad_event_allowance", + "missing_stock", + "large_but_incompatible_stock", + "child_recomputed_precision", + "unbounded_history", + "padded_source_width", + "undersized_residue_word", + "undersized_source_word", + "undersized_root_index", + "zero_metadata_reserve" + ], + "exact_component_delta": { + "E_times_compiler": 0, + "E_times_good": 0, + "J_times_high": 0, + "J_times_physical": 0, + "copy_erase_episodes": 0, + "global_prefix": 4147767507926387264639022557982451638378876603727872, + "matrix_test": 0, + "one": 0, + "selectors": 0, + "unit_adds_and_bridges": 864 + }, + "scope": "Exact integer prefix/coefficient and conditional complete-low-class fallback; logical live-symbol reserve, not floating-point error/rounding, fixed-tape visited backing, complete execution time, supplier or selected-kappa admission.", + "source_sha256": { + "research/bit-p111-r437-gl464-470-20261018/code/invoice_audit.py": "8bcf640e1e27313c92c00a7a76e72d8ae995360899d178221d1c65cf9b6dda6d", + "research/bit-p111-r437-gl464-470-20261018/data/GEOMETRY.json": "b9ed0e5e0084dcd285f33bfc71aab833ddcfa1062bd80c9c83da8244276d6830", + "research/bit-p111-r437-gl464-470-20261018/vendor/assemble9.py": "808ef620230ac0ccb4c4b31a02288936fbe0be6d9b3ff715bbe828848d4642d1", + "research/r437-oq4-caller-binding/RANK26-COST.md": "cf6e472ff945ee4c3d5dc5407aa9aa7751022819846c4d7380cb697e227b0cc9", + "research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/PROOF.md": "552fa306d5cc228f4d8d8553f8ac5fc6a738ef2b66a2cb765ba0638cd229794d", + "research/r437-reverse-row-coefficient/independent.py": "d06b99de599a5b75590bb107fd605df314ed9cf8da19a9ba22bb8de0c33787b7", + "research/r437-reverse-row-coefficient/verify.py": "0a345d3658b868f8ccb36969e68fd1e8d5412a98a9f06b3e1a6e74ed9041216a", + "research/r437-two-window-carrier/HOST-RESULT.json": "000837b2b7a1e9d7e4b6b657a055c6f5f3886c7ea343239f8620f79d5d7b2ae8", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/controller.py": "fa09146991f6c04e6f4b6eb9bf0c8e103e70e90a0e402ff3d69814e6aac8ff8c", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/matrices.py": "00b687434039b54529ee092e34f9435cfcd66e0816eb3bd2a6688c73f4e01459", + "research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/numeric.py": "7327b05c4ec3e0f6d9c352cc7de85bfd4ebe940482553e77c59a773a8c09c514" + }, + "status": "PASS_NAMED_FINITE_COEFFICIENT_AND_CONDITIONAL_LOGICAL_STOCK_BOUNDARY", + "stock": { + "depth": "D(n)=0 below64, else1+D(42*floor(n/64))", + "fixed_physical_visited_backing_admitted": false, + "formula": "K=269241600*|GL64(q)|*q^(4096*(w-1)); rows=t*K^D(n), t positive integer", + "logical_reserve": "11*V_root+F_q under stated complete-packet/root/lifetime premises", + "metadata_coarse_envelope": "2^48*(b+597)*w^2 +2^20*(ell(V)+4)+q^2", + "metadata_w2_polynomial": { + "b": 17592241506793, + "constant": 104541086181 + }, + "multiplier": 269241600 + } +} diff --git a/research/r437-carrier-integration/NUMERICAL.md b/research/r437-carrier-integration/NUMERICAL.md new file mode 100644 index 000000000..1001480b0 --- /dev/null +++ b/research/r437-carrier-integration/NUMERICAL.md @@ -0,0 +1,401 @@ +# Numerical and original-root stock admission for the regenerated carrier + +This note connects the changed finite word to **two named existing envelopes**: +the #3647 `vendor/assemble9.py` finite 192/512 coefficient invoice, and the +#2753 completed logical caller's explicit metadata/compatible-stock ledger, +retained in `r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/PROOF.md`. +It also proves the bad-low-class premise for the **fresh compiler's actual +split-projector requests**. The companion `numerical.py` computes exact integers +and rejects undersized or incompatible parameters. It does not search an +endpoint or infer an exponent from a coefficient width. + +The compiler's C/D receipts must be generated first. They supply authenticated +source identities, ordered request digests, actual rank profiles, vocabulary +width and all-base/chart checks. The numerical binding rejects replacing D by +C's source identity or unchanged request digest. The separate compiler checker, +not a digest comparison, establishes the algebraic premises below. + +## 1. Boundaries and numerical meanings + +C is original R437 with the actual 63 pooled owner moves; D is the paid carrier +with those moves independently revalidated. Both have 903,456 positive-rank +requests, rank mass 1,808,352, 288 local calls, W=28,416 and physical W+9=28,425. +The generator recounts these; their equality is an outcome, not an input to +source construction. The fresh codebook is compulsory even if code width is +equal. #3959's withdrawn whole-construction headline is not used. + +The source entry is the literal chronological request together with its current +family chart, before-frame and actual dirty source. A MOVE's positive nested +frame difference supplies its split projector; a COPY uses the already aligned +private chart; an IDLE uses the unoccupied axes of its absolute owner family. +The request is compiled once for each fixed low class, then its full-ring +numerical matrix is prepared at every actual high field and ancestral Program. +A completed child returns the **whole packet including spectators**, with the +same source identity and frozen ancestry; the matching consumer and disposal +must be executed. Numerical admission cannot move a dirty acquisition to a +later prefix or turn a COPY SOURCE observation into equality of all DIRTY rows. + +There are different quantities here: + +* 49,347 and 1,123,650 are cancellation-free integer row coefficients; the + reverse change and +3 local ADDs are reused from #4067/#4147. +* The 192 and 512 bounds are integer prefix/finite-invoice envelopes. Their + slack is proved by exact inequalities below. They are not a new rounding + grid, floating-point error analysis, or conditioning bound. +* `w` is the original root's address/ring precision. Ring arithmetic and unit + tests in the claimed source are exact modulo q^w; it is not recomputed from + a descendant's width. Existing precision/analytic interfaces remain explicit. +* `Q` is the source-code field width, which affects actual serialized Programs, + raw fields, scans, parking, and storage. It is distinct from row coefficients. +* Compatible row stock and logical live symbols are different from total + visited backing on a fixed number of physical tapes. + +## 2. The changed finite coefficient fits the named 192/512 envelope + +The retained nine-stage formula charges five forward local invocations, four +reverse invocations and eighteen bridge factors in a cancellation-free global +prefix: + + P_C = 2^18 * 49347^5 * 1113998^4, + P_D = 2^18 * 49347^5 * 1123650^4. + +Submultiplicativity of the infinity row norm bounds every chronological scalar +prefix by this product: truncating any local invocation cannot exceed its +all-prefix local maximum; later factors are each at least one. Full forward +and reverse local maxima are source-bound inputs, not peak endpoint norms. +Injective separated owner routes identify the local arbitrary-dirty coordinates; +this argument needs the compiler's before-MOVE acquisition and cannot be inferred +from a later unchanged chart. Internal native primitives retain their separately +charged completed-call contracts. + +The fresh C/D chart sets and matrices have the same independently computed +digest, so the carrier adds no chart-change routing difference. Absolute +applicability of the retained 77-factor route tariff to the pooled physical +caller is an explicit premise: owner separation and equality of chart sets +do not by themselves establish that time bound. + +For J=2,002,560 and the retained geometry's 77 route factors, `numerical.py` +recomputes every term of #3647's invoice: + + unit = 288*local_ADDs + 6*3*111*32, + J = 8*32*9*(222+437) + 8*(8*111*32) + + 2*9*32*437 + 2*(9*9*32), + high = 16*(64^2+1)^2, + good = 8*64^2+8, compiler = 128*128^3, + selectors = 2*9*32*((28416-1)+437*64*(77+144+2+63+64)), + C = unit + J*high + J*28425 + E*(good+compiler) + + 16*64^3 + 2592 + selectors + P + 1, + C_two = (C+1)^2*(E+1)^2. + +Both invoices have P and C of bit length 177 and C_two of bit length 393. +The exact inequalities P<2^192 and C_two<2^512 are checked; numerical receipts +retain the full integers, their componentwise difference and the larger D bill. +Only the scalar term (+864) and global prefix change in this **retained finite +invoice**. The old literal P_C cap rejects D. The unchanged coarse 192/512 +charges cover it with strict slack. This does not erase the larger integer or +replace a production physical invoice by its bit length. + +The retained row coefficient is 2*(64^2+1)+9909+252=18,355<20,161. +Maximum child 42 satisfies 2*42^2<64^2. These are the named finite envelope's +actual units; a local event count is not compared to 20,161. Source code setup, +physical parking, coefficient evaluation and new pre-MOVE acquisition costs +must be supplied by the integrated caller ledger, not set to zero here. + +## 3. Per-request bad-class admission, including correlated histories + +Take any fresh MOVE/COPY/IDLE request of rank 1<=r<=42. The compiler establishes +a dyadic idempotent projector P0 with characteristic polynomial +t^(8-r)(t-1)^r for each eight-dimensional block, and an invertible actual +chart with dyadic entries and determinant ±1. Reducing the polynomial identity +modulo any odd q proves that each projector has the prescribed rank, since an idempotent +is diagonalizable with distinct roots 0 and 1. Over the local ring Z/q^w its +image and kernel are finite free modules (direct summands of the free module), +so an invertible splitting basis exists at that parameter. We do not claim a +single rational rank minor is a unit for all odd primes; such a minor can have +an odd numerator. The code checks idempotence and characteristic polynomial +over Q, and uses the actual runtime split basis at the compiled parameter. +IDLE bases are coordinate projectors on their actual distinct axes (including +ranks 14 and 42), so their rank/idempotence proof is immediate from those axes; +the eight-dimensional characteristic-polynomial test covers local frame bases. +The ambient 64-dimensional request rank is the resulting r. For COPY the actual chart is the +already aligned one: applying the external owner chart twice is invalid. + +For a complete GL64 low cover, multiply g by that fixed invertible chart and +split basis. This is a bijection on GL64(F_q) and on the high lifts. In these +coordinates the projector is Q=G E_r G^-1. The numerical context may conjugate +Q by an arbitrary diagonal unit matrix H obtained from its exact ancestry. +For every principal index set I, + + det((H Q H^-1)[I,I]) = det(Q[I,I]). + +This matches the actual source: `Matrices.prepare` forms the unweighted +projector from `(low+q*high)*fixed_preparation`; `selected_page` selects its +fixed low branch; `Page.coefficient` decorates head/shear coefficients by ratios +of incoming units, leaves tail coefficients unchanged, and uses inverse units +for cross coefficients. `Callback.weight` constructs those units from root +units, good pivots, or fallback unit diagonals and checked ratios. Thus its +good/fallback classification is unchanged by the ancestral coefficients, +including correlated coefficients and repeated prefixes. It depends only on the +low G, never on a particular high lift, frozen ordinal or payload bit. + +For I={0,...,k-1}, 1<=k<=r, complementary minors give the polynomial identity + + det(G) det(Q[I,I]) + = sum_(J subset [r], |J|=k) (-1)^(sum I + sum J) + det G[I,J] det G[I^c,J^c] = F_k(G). + +Each F_k has degree <=64 and F_k(I_64)=1 in every residue field. Their product +is nonzero, with degree <=64r. The finite-field polynomial zero bound and +Pr(GL64)>1-1/(q-1) give + + delta_r <= min(1, 64*r*(q-1)/(q*(q-2))). + +This applies to both reflected MOVE orientations, each actual COPY and every +pooled IDLE, by their respective source-bound split witnesses. There is no +assumption that one matrix is good for every label. We sum each edge's cost +with its own deterministic low-class fraction; linearity of this finite sum +needs no independence between requests or ancestral weights. + +For q>2^80 and r<=42, delta_r<2689/q<10^-16. The retained exact primitive +fallback ceiling 6*128*127+3*128+6*127=98,682 is below 32*64^2=131,072. +(The completed caller's 49,911 count is an even smaller inherited ceiling; +we do not take a second saving.) Every one of the 903,456 requests retains +131,072 rank-one fallback allowances, total 118,417,784,832. Therefore the +old surcharge epsilon*131072*E has its actual per-edge coverage premise for +this freshly compiled word **under the completed fallback/weighted-child +contracts**, rather than because E happened not to change. General source +refinement, unit-weight preservation and completed fallback execution remain +explicit inherited premises. A q=3 physical fixture cannot establish this +q>2^80 numerical admission and the numerical guard rejects it. + +## 4. Fresh vocabulary in the complete metadata ledger + +With N=|GL64(F_q)|, the fresh compiler encodes both views of E=903,456 requests. +Since 2E<2^21 and N=1). The entire non-Count, non-q^2 part is at most + + (104541086181 + 17592241506793*b)*w^2 + < 2^48*(b+597)*w^2. + +This coefficientwise inequality is checked exactly, including the +5 change in +Q. It is the same named coarse envelope as the old proof, proved afresh for +its larger vocabulary, rather than inferred from matching bit lengths. + +Every associated complete packet satisfies V>=q^(2w). Since w^2<=4^(w-1), +b+597<=q for q>2^80, and ell(V)+4<=16 sqrt(V) for V>=16, + + 2^48*(b+597)*w^2/V <=2^48/q<2^-32, + 2^20*(ell(V)+4)/V <=2^24/q^w<2^-56, + q^2/V<=1. + +Thus E_meta<2V. For the actual directory, V includes each of its C_prefix*H_lifts +prefixes and at least two complete q^w atoms. Also +f<=(8192b+12311)w. Therefore + + Delta/V <= (1+1180*(8192b+12311))/q^2 <2^-130. + +For the last strict inequality, at b=81 the numerator is 797,518,341<2^30; +as b increases by one its numerator grows linearly by 9,666,560 while the +lower bound q^2>=2^(2b-2) grows by four. The w^2 factor is absorbed by +q^(2(w-1)) as above. This proof retains every physical prefix multiplicity; +it does not use a one-prefix representative as the complete directory. + +## 5. Original-root stock and the complete live-symbol reserve + +Set H_lifts=q^(4096(w-1)) and + + K=lcm(28416,28425)*N*H_lifts=269241600*N*H_lifts, + D(n)=0 if n<64, otherwise 1+D(42 floor(n/64)). + +The accepted row shape is t*K^D(n), t a positive integer. Merely providing at +least that many rows is not the contract: `check_stock_rows` rejects a larger +incompatible row count. A parent split removes W*N*H_lifts and yields + + U=t*9475*K^(D(n)-1), + +since 269241600/28416=9475. Every child width c<=42floor(n/64) satisfies +D(c)<=D(n)-1; any excess K power stays as an explicit positive row multiplier. +The actual complete packet identity is V_child=V_parent/(W*N), including +all frozen prefixes, the independent U spectator and each external gap once. +The physical fixture must establish this actual Layout/child_extents identity. +Changing the root precision or dropping U breaks this implication. + +With the retained one-active-chain scheduler, disposal and Frame lifetimes, +charge at each level 8V+32Delta+E_meta. The preceding inequalities give + + F_q + sum_j(8V_j+32Delta_j+E_meta_j) + < F_q+(10+2^-125)*WN/(WN-1)*V_root + < F_q+11V_root. + +The actual source has 659 ordinary roles, within the predecessor's 661-role +allowance; one private role, matrix dimensions and maximum rank do not increase. +Both C and D obey the same bound under the named complete-packet and lifetime +premises. The greater reverse row integer and new source-code vocabulary have +been charged where they occur. No finite controlled return proves these uniform +premises merely by fitting inside eleven packets. + +This is a **logical live-symbol** bound. Fixed physical tape cursor costs, +cleared-but-visited backing, checkpoint encoding, global allocator/codec costs, +outer padding/borrowing and eventual physical blank-return remain in the +physical ledger. They cannot be discharged by this live-space inequality. +Because N encoded directory/program/handoff -> complete 972-bit four-atom child -> literal D consumer. Parent GL64 gather/route and124-atom spectator expansion remain quantified/inherited, not physically executed.", + "status": "PASS_SOURCE_BOUND_CARRIER_REGIONAL_CALLER" +} diff --git a/research/r437-carrier-integration/PHYSICAL.md b/research/r437-carrier-integration/PHYSICAL.md new file mode 100644 index 000000000..ec8573946 --- /dev/null +++ b/research/r437-carrier-integration/PHYSICAL.md @@ -0,0 +1,243 @@ +# Fresh carrier request to an executed completed child + +This is a source-bound regional caller result, not production GL64 execution or +an admitted improvement in selected kappa. The new connection consumes the +**actual serialized child Program copied by preparation**. It executes both +coordinates of a complete rank-two child, protects its owned return, passes that +computed return to the carrier's literal next SOURCE87 consumer, then disposes +all newly owned metadata, payload and numerical work. The finite execution and +the full-parent address proof are distinct evidence layers. + +## Exact boundary and source + +`physical.py source()` resolves the regenerated compiler handle and actual +`Specifications` at q=3. It chooses the common low chart equal to the inverse of +the request's preparation matrix modulo 3. Both orientations then have a GOOD +rank-two plan. This does **not** say that every low class, or the native identity +class in reverse, is GOOD. The compiler independently records fallback branches. +The forward D request is 1676, event 22397; the reverse D request is 94518, event +4737. These integers are checked against the fresh catalogue rather than reused +as an old codebook. Full identities and fields are in the receipts. + +Executed request coverage is the common SOURCE87 MOVE at stage 0/replica 0 +and stage 1/replica 0, with f=1 and the stated GOOD chart/history. The bridge's +coordinate-independence argument covers completed GOOD children with the same +fixed field/no-half/no-reverse contract and validated immutable Program; the +full geometry lift covers their arbitrary spectator and unused-row tuples. +It does not promote this execution receipt to all 903,456 request classes, +nonfixed PAIR/COPY histories, native fallback interiors or all low classes. +Those need their own matching branch and source conditions. + +The borrowed entry consists of the fresh source, a root-2048 unit-weight-2 +Program with one validated GOOD step to current width 64, its encoded old +high-field directory, the old prefix count, and arbitrary source/consumer packet +bits. This is a generic admitted source history. Reachability of this particular +history from a selected top-level call is not asserted. Context creation, +directory production, residual validation, child constructor, metadata copying, +geometry, coefficient work, packet execution, return, consumer and teardown are +inside the measured interval. Construction of borrowed input records and the +already-live Ring precedes that interval. Host catalogue/parameter admission is +also separate from a fixed-tape admission scan tariff. + +`checked_child()` runs the joint fresh-source/Specification/parameter/stock +entry guard **before** the callback. Its q=3, w=1 example is semantic only; +`RootDomain.rows` supplies a local divisibility certificate, not a materialized +ancestor stock certificate. The original-root numerical conditions reject these +fixture parameters. The named production root gate and large-prime error/stock +proof are in `NUMERICAL.md` and `ADMISSION-RESULT.json`. + +## Original dirty acquisition + +`acquisition()` executes the actual adapted `Driver.local` chronology. All 659 +original arbitrary-DIRTY roles are gathered before its first MOVE; in particular +role 87 is acquired before the new early SOURCE87 MOVE. The controlled consumer +stops only upon the exact fresh request. Both C/D and both orientations are +checked, as is the rejection obtained by removing role 87's original acquisition. +All staged symbolic packets are cleared even on this controlled stop. + +This is an ordered acquisition trace with symbolic primitive interfaces. Its +set-union dependency model is an overapproximation, not an F2 evaluator. It does +not physically execute the GL64 gather, preceding residuals, routing or outer +family transport. `independent.py` separately proves the complete changed local +word on every one of the 659 independent dirty columns, including changed COPY +DIRTY operators. No equality of the old and new full COPY DIRTY operators is +claimed. Production gathering remains subject to the inherited primitive +refinement theorem; the trace establishes the earlier read that a later shared +preparation would not supply. + +## Produced-program bridge and proof + +The existing `SelectedBinding.child_program` constructs the actual two-step +serialized child Program (root 2048 -> 64 -> 2). Preparation copies that Program, +the complete two-field directory, prefix count, unused-row count and all three +full-parent spectator extents. The candidate constructs `IncomingWeights` from +**the copied Program**, and `packet_engine.run` consumes **the copied directory**. +The copies are therefore used by execution, not merely compared and discarded. +A corruption control changes the second produced STEP rank from 2 to 3 and is +rejected as `actual selected rank` before a child payload result is produced. + +The canonical internal `peel.run` rejects widths below 64. We preserve that +guard. The new completed-child bridge instead composes its unchanged `trace.leaf` +and `packet_engine.run` with the consumed child's incoming coefficient interface. +For the emitted GOOD child, the source, field 0, no-reverse/no-half tags and +current parent are fixed for all coordinates. Child-program construction +therefore does not depend on the coordinate. Converting a typed child coefficient +request to an incoming request against that produced Program is exactly the +same extension followed by the same whole-history callback. The finite bridge +checks the field and adapter tags, performs a charged encoded coordinate bound +check, and uses the original parent coefficient evaluator when that eligibility +check fails. Source Program and directory bytes and heads are verified immutable +through the whole child. This argument is restricted to this GOOD context; it is +not a theorem about general COPY/nonfixed ancestor histories. + +There are **six fresh coefficient evaluations per coordinate**, twelve in all. +The values are `[2,2,1,1,2,2]` per coordinate, including negative inverses. All +incoming callbacks validate the full two-step ancestry. No three-call reduction +or fixed-PAIR CSE is used. The actual generated ancestry fails the fixed-PAIR +premise, so #4059 is deferred at this site. + +Each coordinate uses the canonical eight-stage swap/ADD/sign word. For any +admitted unit lambda it realizes the weighted swap; here lambda=2 modulo 3 and +its inverse is also 2. Consequently the complete child pullback is + +``` +(x0,x1,g,y0,y1) -> (2*y1,2*y0,g,2*x1,2*x0) mod 3. +``` + +All 972 bits of the complete child with before/gap/suffix extents 2,3,2 are +executed through the real packet engine, including both coordinates and all +finite spectators. The expected permutation is independently evaluated at +every position. The map is a composition of permutations/XOR primitives, so its +correctness is pointwise for arbitrary dirty bit assignments; the particular +nonconstant fixture is execution evidence, not a basis for that universal claim. +The child emits an owned packet inside the protected `enter`/`return` interval. +For D forward, actual `episode.xor_packet` sends it to helper467 at literal event +22398; in reverse the next consumer is helper188 at event4738. The consumer sees +the computed packet, never an opaque declared child output. All outputs, copied +metadata, released numeric words and borrowed heads are checked on cleanup. + +## Full parent geometry and the unexecuted lift + +Actual `Layout.child_extents` on the source rank-two plan computes + +``` +B_child=2, G_child=3*3^124, S_child=2, U_parent=9475, +V_parent=9475*12*3^128 = U_parent*B_child*G_child*S_child*3^4. +``` + +Thus neither the 124 omitted atom coordinates nor the 9475 unused rows vanish +from the physical geometry. Complete encoded extents and unused-row metadata +are prepared and copied. The executed child uses one row and gap 3; it does not +allocate the enormous parent or pretend that metadata volume is payload volume. +For each fixed spectator/unused-row tuple the same leaf permutation acts on its +four coordinates. A tensor/direct-product lift therefore preserves every other +coordinate and arbitrary spectator data. That algebraic lift does not itself +prove fixed-tape gather or routing refinement or its scan cost. + +`residual_algebra.py` independently composes the actual 128-address residual: +4346 adapter commands, the two weighted coordinate swaps, and the inverse 4346 +commands. At the fixture's zero high fields their coefficients happen to vanish; +all commands remain paid. Its separate modulus-9/nonzero-high case has 374 +nonzero coefficients per sweep and rejects an omitted command and stale high +form. This supplies the full-parent source/operator connection, not a claim to +have physically executed those production adapter scans. A full residual has +8692 adapter passes plus 16 child passes and 17384 adapter coefficient invocations +plus the child's 12. All high-prefix and unused-row multiplicities still apply. + +## Compatible bills and controls + +`PHYSICAL-RESULT.json` is the exact ledger. Every phase records **record tape, +residue Word and index Word reads/writes/moves separately**. Those counters are +not mixed with scalar ADD counts, recursive rank tariffs, host time, finite +control or stock. The entry guard is host validation, not a zero-cost encoded +scan. Retained cleared backing and peak stock remain separate from live ownership. + +There are three comparisons: + +1. C versus D uses the same complete preparation and returned-child boundary. + All corresponding phase invoices are exactly equal at the chosen source + charts. D's literal consumer interval is separately shown, because C has no + immediate helper467 consumer. It already belongs to the carrier's paid local + word: do not add it a second time to the three-extra-ADD local charge (864 over + 288 calls). Equal local fixtures do not imply all catalogue/setup costs equal. + The compiler reports one extra distinct basis, fresh codebook identities and + unchanged code field width; its extra construction/table cost is still due. +2. Raw versus adapted complete preparation has identical produced Program and + directory bytes. #4025's shared radix is applied only to the actual Context + and directory work; #4062's monotone admission retains all source validation; + #4077's shared spectator method uses the actual Layout and pays its added + counters. All setup, copying, validation and disposal in this boundary are + measured. The raw and adapted preparations are each also equal C versus D. The adapted + path adds 34 record writes while reducing the other recorded components; this + is a vector invoice, not an unconditional improvement under arbitrary action + weights. Its sufficient weighted inequality must retain those added writes. +3. For the same D source, packet and required consumer, the **original coefficient + evaluator** constructs the child history inside each of the twelve coefficient + calls. Its comparison branch does not pay an unused outside child constructor, + handoff or incoming wrapper. The candidate pays one constructor, the complete + metadata handoff and teardown, then consumes that produced history. This is + the replacement-cost comparison; both preserve all twelve evaluations and + produce identical consumer output. The receipt checks no read/write/move lane + increases. A second genuinely losing control redundantly constructs and + disposes another identical child Program, with identical final output and a + strictly greater paid record-read count. + +The final matched D entry-through-consumer-and-cleanup invoice is: + +| Lane/action | Original evaluator | Produced-program candidate | Paid reduction | +|---|---:|---:|---:| +| record reads | 17,950,250 | 12,819,500 | 5,130,750 | +| record writes | 2,468,252 | 2,386,138 | 82,114 | +| record moves | 14,425,614 | 10,805,766 | 3,619,848 | +| residue reads | 52,441,981 | 52,416,736 | 25,245 | +| residue writes | 10,663,863 | 10,659,320 | 4,543 | +| residue moves | 56,436,050 | 56,409,320 | 26,730 | +| index reads | 595,738 | 416,012 | 179,726 | +| index writes | 124,763 | 84,851 | 39,912 | +| index moves | 585,460 | 405,876 | 179,584 | + +Every component is strictly smaller despite the candidate's added one-time +constructor and complete metadata copy. This is a local paid improvement under +any nonnegative action tariffs with at least one positive tariff; it does not +price the omitted parent production operations. The same-output redundant +constructor adds 531,490 record reads, 118,218 writes and 446,282 moves, as well +as positive index/residue work. + +For nonnegative per-action tariffs, the complete preparation adaptation is a +strict paid improvement whenever + +``` +34*c_record_write < +255676*c_record_read + 170442*c_record_move ++ 4347699*c_residue_read + 789735*c_residue_write + 4622028*c_residue_move ++ 4958*c_index_read + 1192*c_index_write + 5122*c_index_move. +``` + +This is an explicit sufficient inequality for this interval. It does not combine +these prices with recursive rank tariffs or infer a supplier endpoint. + +The ledger does not close production gather/router/source setup, all low/high +class multiplicities, encoder/allocator histories, original-root backing, +recursive tariffs or every returned-output transport. These terms cannot be +subtracted as unrelated upper bounds or assigned zero. It enables a charged +completed-child connection at this source and a scoped preparation improvement; +it does not establish a complete C/D supplier endpoint or a new exponent. + +## Attribution and next test + +The source word and physical/compiler baseline are ai-nanachi's #3647 and the +subsequent actual caller packages; pooled owners are Rohan Arun's #3959; the +carrier is #4067 and unpaidmoon's independent coefficient distinction is #4147. +The absolute/replica interface, preparation composition and caller work reuse +our #3995/#4010, #4011/#4062 and #3983/#3967. ToikY's #4025 radix and Tekalign's +#4077 spectator technique are adapted at their literal source boundaries. +Unpaidmoon's #4160 construction-traffic distinction is respected by charging +child construction to preparation. #4059 is inspected but not applied. Neither +#3985 native-history work nor #4015/QQ16 is used. + +The next discriminating test is the same produced-program bridge at a nonzero +high-field, larger-precision source under an admitted original-root stock +certificate, with encoded source/gather and full residual preparation joined to +the measured boundary. That test must preserve the early original dirty read, +all twelve child callbacks, actual adapter costs and retained backing. This is +more informative than another decimal endpoint or coefficient recomputation. diff --git a/research/r437-carrier-integration/README.md b/research/r437-carrier-integration/README.md new file mode 100644 index 000000000..9b1ed6fea --- /dev/null +++ b/research/r437-carrier-integration/README.md @@ -0,0 +1,173 @@ +# Fresh pooled R437 sources, numerical coverage and an actual child handoff + +This is one integrated continuation of Chris R/Clear1nsight's paid two-window +carrier #4067. It connects the changed word to a fresh replica-indexed source +compiler, proves a previously missing complete-low-class fallback implication, +adapts a named original-root logical reserve, and executes a source-derived +child through its produced Program/directory and an actual subsequent consumer. +It targets a **substantial enabling integration**, not a new selected kappa or +a demonstrated complete physical speedup. The selected conditional value remains +`0.001672660197076918`; its binding complex supplier and outer transfer are +unchanged. The separate #3985 native-history/QQ16 investigation is not imported. + +## New implication and exact source boundaries + +`compiler.py` rebuilds C (original R437 with the 63 pooled BIT owner moves) +and D (#4067 with independently revalidated pooled owners). The unchanged C arm +reproduces #4010's exact903456-request digest. D has a different ordered digest, +new algorithm-bound handles, and529→530 actually requested local projector +bases. All1235 charts,179802 same-family owner pairs, absolute families, +chronological owner windows and63936 exactly-once IDLE requests are checked. +Source-code width is6512 bits at q=3 in both arms, and equal at every shared +fixed q. The already-paid pooling increment is not added twice. + +Both actual consumers, `Driver.global_word` and `macro_code.compile_node`, +receive a guarded adaptation from replica-blind IDLE lookup to +`idle_identifiers(child, replica)`. The actual Driver enumerates every request +through its schedule with explicitly symbolic payload primitives. The actual +native rank14 IDLE fallback is separately compiled through `SelectedBinding` +and `Cursor`. Neither result is described as production payload execution. + +The early SOURCE87 rank-two MOVE is now event22397/request1676 at +stage0/replica0, versus event22689/request1755 in C. Its reverse is +4737/94518 versus4442/94439. Source handles bind word/template/owners/moves, +compiler algorithms, prime, code context and literal replica/event keys. +Stale, wrong-replica, replica-blind, cross-prime, Specification and source/native +mixups reject. [COMPILER.md](COMPILER.md) states the complete contract. + +The separately written [comparison checker](COMPARISON.md) reconstructs all four +A/B/C/D profiles and both complete659-column arbitrary-DIRTY words without +importing the primary builder. It also proves the transported slot maps have +`L_s J_t = delta_st I`, using the actual family-chart/permutation order, rather +than treating a slot-allocation guard as an operator proof. All COPY contracts +are retained correctly: one full DIRTY capture changes, by initial DIRTY444 XOR +initial DIRTY469, although all nine SOURCE projections/frames agree. Old full +COPY DIRTY rows are not reused. + +## Numerical admission that uses the new sources + +[NUMERICAL.md](NUMERICAL.md) connects the fresh all-prime projector/chart +certificates to a completeGL64 complementary-minor argument. For each rank-r +request, `delta_r <= min(1,64*r*(q-1)/(q*(q-2)))`. At r<=42 and q>2^80 this +fits10^-16. Unit diagonal ancestral weights preserve the relevant principal +minors; high lifts do not create additional low-class events. No independence +of correlated dirty payloads or union over source labels is assumed. The +inherited completed fallback charge is kept. This closes the surcharge's +source/coverage premise, rather than inferring it from unchanged child count. + +The old reverse integer cap does not cover1123650. Reusing unpaidmoon's #4147 +coefficient, the exact new global prefix and finite coefficient nonetheless fit +the named192-bit prefix and512-bit two-level envelopes. Full integers and all +component deltas are retained. Absolute applicability of the inherited pooled +routing/primitive tariff remains an explicit premise. + +The source-width-aware metadata polynomial and a newly derived directory +inequality retain the named conditional logical reserve `11*V_root+F_q`, with +exact compatible original-root stock divisibility. This is logical live storage +under the retained packet/frame lifetimes, not physical visited backing or a +blank-return implementation. The actual no-op `SelectedBinding.check_stock` +is not presented as enforcement. + +`admission.py` supplies an explicit package entry: typed source resolution, +canonical encoded widths and compatible original-root rows are checked before +a continuation. Executable numerical admission is an original-root entry +(n=e,h=0); descendant admission needs a separate path certificate. The named large-prime source constructor replaces only its +impractical exhaustive primality guard with the exact Lucas–Lehmer certificate +for2^127−1, retaining the codec algorithms and authenticating the adaptation in +its new identity. Its actual catalogue/native specification and bounded caller +emitter are checked; the large-prime continuation is not a physical payload +run. The host admission/compiler guard work retains its physical lowering cost. +The small-prime execution below is explicitly semantic, not numerically admitted. + +## Actual local caller and complete bill + +[PHYSICAL.md](PHYSICAL.md) and its receipt execute the complete finite active +rank-two child, including all four atoms and finite external spectators. The +actual encoded Context/directory, admission and child-program producer precede +metadata handoff. Execution adopts the produced/copied child Program and raw +field directory, evaluates both GOOD ancestry steps with actual callbacks, +executes an explicit below-cutoff bridge using the unchanged two-coordinate +leaf primitives, protects return state, and delivers +the computed output through the literal next D XOR consumer. Corrupting the +produced STEP rejects; metadata is not merely hashed alongside a separate leaf. +Borrowed bytes/heads and owned terminal cleanup are checked. + +This bridge is new package code, not execution of the unmodified whole recursive +call dispatcher: the internal-node peel method rejects widths below64, and its +guard is preserved. The actual parent geometry includes9475 unused rows and124 +further atom coordinates. The972-bit +finite active-child execution does not materialize that complete parent packet. +[RESIDUAL-ALGEBRA.md](RESIDUAL-ALGEBRA.md) separately checks its full128-coordinate +residual address operator modulo3 and9, with nonzero high fields, actual +source preparation, correct chronological pullback, and a same-output losing +control. It counts all4346 commands per adapter sweep, including zeros:8708 +passes and17384 adapter plus12 child coefficient invocations per scalar prefix. +Completed primitive/gather/router refinement and the spectator lift retain +their documented hypotheses. Symbolic acquisition tracing establishes the +actual Driver's read-before-MOVE order; it is not physical gather execution. + +The new guarded child Program reuse also survives its local replacement costs: all nine measured record/residue/index action components decrease against the original twelve-construction evaluator, including a reduction in record reads from17,950,250 to12,819,500. Both arms compute the same complete finite child, literal consumer and cleanup; the candidate pays its metadata handoff. All twelve coefficient calls remain. This local paid improvement is a component of the enabling integration, with the production geometry limits stated above. + +[BILL.md](BILL.md) gives the compatible C/D ledger and remaining sufficient +inequality. The profile delta `{1:+288,2:-576,3:+288}` remains strictly favorable +for0 (2*y1,2*y0,2^-1*x1,2^-1*x0)`. +At modulus 3, `2^-1=2`, matching the executed physical 972-bit child with all finite +external spectators. At modulus 9 the inverse is5. Unit-inverse checks remain +part of the algebra. The two pivots are recorded, so these weights are not +silently substituted for a different source. + +## Counts, rejection controls and boundary + +Per prefix and one scalar column, the literal itinerary has 8,692 adapter ADD +passes and 16 child primitive passes:8,708 total. The retained physical ADD +performs two coefficient invocations even when the value is zero. Thus the +adapter itinerary demands 17,384 coefficient invocations, and the two child +coordinates demand 12 more. These counts do not price coefficient construction, +validation, directory preparation, tape extent, parking, stock or disposal. +They must not be omitted from the compatible physical invoice. + +At modulus 9 the checker rejects both an old zero-high coefficient form and +omission of an explicitly recorded nonzero adapter command together with its +inverse. A same-output losing control appends a nonzero shear and its inverse; +it produces the same residual with two extra mandatory passes. This is an +algebraic pass-count comparison, not a measured full-packet speedup. + +This certificate executes exact host arithmetic on all 128 coordinate columns. +It executes neither `3^128` payload bits nor 8,692 physical adapter scans. The +physical 972-bit result, complete metadata geometry, and this finite full-address +certificate close different premises. General physical primitive refinement, +full high-class coverage, arbitrary ancestral validation, stock and the complete +numerical envelope remain as stated in the integrated admission matrix. + +## Credit and reproduction + +The fixed plan, GoodForm algebra and stream convention are retained source 527 +and PR2159/2160/2188/2234 mechanisms carried through the canonical physical +caller. The fresh source binds Chris R/Clear1nsight's #4067 carrier and +#3995/#4010 replica interface, ai-nanachi's #3647 word and the 63 independently +checked BIT owner moves from Rohan Arun's #3959. No retracted complex-side +headline is reused. + +Run `python3 research/r437-carrier-integration/residual_algebra.py`; the default +compares the immutable receipt without writing. `--write` explicitly regenerates +the receipt. Optimized replay uses the same explicit rejection checks. diff --git a/research/r437-carrier-integration/SOURCES.json b/research/r437-carrier-integration/SOURCES.json new file mode 100644 index 000000000..1930828ed --- /dev/null +++ b/research/r437-carrier-integration/SOURCES.json @@ -0,0 +1 @@ +{"schema_version":1,"base_commit":"12fa8c5c844be21bfefb38a19503fbd867a11244","files":[{"path":"certificates/selected-result.json","usage":"input","sha256":"bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129","git_blob":"b1fea0c94436b236cc2b7d41a7be032811b94c81"},{"path":"research/bit-p111-r437-gl464-470-20261018/code/invoice_audit.py","usage":"input","sha256":"8bcf640e1e27313c92c00a7a76e72d8ae995360899d178221d1c65cf9b6dda6d","git_blob":"f3ae8ab88bd82dff41899d682e2e087b0d9683f1"},{"path":"research/bit-p111-r437-gl464-470-20261018/data/GEOMETRY.json","usage":"input","sha256":"b9ed0e5e0084dcd285f33bfc71aab833ddcfa1062bd80c9c83da8244276d6830","git_blob":"7158a5c55b0001a526dab6e816b7b98f0527a202"},{"path":"research/bit-p111-r437-gl464-470-20261018/vendor/assemble9.py","usage":"input","sha256":"808ef620230ac0ccb4c4b31a02288936fbe0be6d9b3ff715bbe828848d4642d1","git_blob":"7c49dc0756118b2b8d90c59478cd9d54b17d4ba7"},{"path":"research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz","usage":"input","sha256":"0357b7cfbd7c29b4983982baf153c8a9f1e1e412690cd7fa9fc3d23d7963b20f","git_blob":"9eafb8776cbf78c72124f833534469ddfa5e98ec"},{"path":"research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json","usage":"input","sha256":"0058c491d839142aa99ef86a5ec697ce99857632228531512ea3fa74fb24d734","git_blob":"44006542202ca6037533a754f0bcd00549d7e088"},{"path":"research/e8-bit-p111-tuned/tune/EXPECTED.json","usage":"input","sha256":"b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4","git_blob":"e293ddc557742637f9f679f083a1a282d87b1b13"},{"path":"research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz","usage":"input","sha256":"e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f","git_blob":"85a4499bf9e4911a705d50567a2c2ef6cf23739a"},{"path":"research/encoded-child-spectators/CERTIFICATE.json","usage":"input","sha256":"bb66ad1cdf009c6ac81c0911ed428782aa618089506b1c7c03bdc97634e4c662","git_blob":"4879b20afb732ad503f8b0b576018e4d738fdf32"},{"path":"research/encoded-child-spectators/CONTEXT.json","usage":"input","sha256":"2df933c9d3b00c34a92a1eb2dba685cde12d9dd71598aab15a401e8b15f793ab","git_blob":"1862e89a14469f01262c8bd042a89dedf7ebb556"},{"path":"research/encoded-child-spectators/PROOF.md","usage":"input","sha256":"cf439a2ffe2bc8521377225400306df7c829af194dc6d8614a4383c7741616a2","git_blob":"0e4bbcf04f1a2502bae7f47d5376a72de74fb36a"},{"path":"research/encoded-child-spectators/README.md","usage":"input","sha256":"05ab321b1ec220375115ca28fc1113edafd530d4e147e09e8534b7172661df77","git_blob":"c4373db5f3f22b91f51a13df62a0a5329580cc83"},{"path":"research/encoded-child-spectators/SOURCES.json","usage":"input","sha256":"826d4dcdc29c66b7395bad8de9201dafee12aa5aa0eaf2772b14e621439daf44","git_blob":"32e976d4de444421b90138daf4597f7f5b68dafa"},{"path":"research/encoded-child-spectators/TASK.json","usage":"input","sha256":"5a72c1cd351594db7b7a29b863bec101cebd87ea9463f57f0077a74ae3c83c53","git_blob":"3dba6e551d43b346f02d164a139f08129e33a3f0"},{"path":"research/encoded-child-spectators/TIMINGS.json","usage":"input","sha256":"d96d3a255213085ee42e1c5eaa0d16398cbdfd49161d48a76fef8a45905d359c","git_blob":"9d97cda48d5318b6f4e84416bb0944aad4ffbda1"},{"path":"research/encoded-child-spectators/VERIFICATION.md","usage":"input","sha256":"920f834f8c71856c464ea6f10b8f731d8b6b00d6897f4fd36bab28ac3b4dfc7d","git_blob":"15de5fadd2a0fe2c23d2803656cec4859a27df26"},{"path":"research/encoded-child-spectators/VERIFY.json","usage":"input","sha256":"7e9ff87a25c83d62cf926a7bbc4078b4efcaf36fc3c9018d90918f722a1fc1ea","git_blob":"9b1f60364dc5185b23587ee186b7dec8e78a7fc1"},{"path":"research/encoded-child-spectators/bench.py","usage":"input","sha256":"a4775c6c5f3ea3d30e628ebd817599b9949729ee0afd542996260a3be6533c38","git_blob":"cbb9366545427c1f8ce7c84e74ad5cf7ac0c9486"},{"path":"research/encoded-child-spectators/cases.py","usage":"input","sha256":"3b4d727e62774c3aa562f9523f8b75dc2e805f73a11da77b7e4f58e68eb14a0c","git_blob":"9b3f3e8caa66ea4d54290af9daa7a10b5f07786f"},{"path":"research/encoded-child-spectators/controls.py","usage":"input","sha256":"521a6be551cf9ac5b6cca1c7a293ed8626a40ed93123e2176f601a80f1295aa8","git_blob":"bd5d499af8ae177cd822847c248e18f6770accb6"},{"path":"research/encoded-child-spectators/independent.py","usage":"input","sha256":"3208e500407ce95a15bf0e32461fecb9a416e4708cd86e034e96c26fa4073b7e","git_blob":"7ae21806d1157a52590625e55c6cdb277991c420"},{"path":"research/encoded-child-spectators/powers.py","usage":"input","sha256":"dd8c150dfa07a594651f64156ec696153fb71e8423df382f11c18f5859b662e7","git_blob":"b22a76cffbe6404833a87793c001f53fb09d4d25"},{"path":"research/encoded-child-spectators/runtime.py","usage":"input","sha256":"ff4004769e01e888c0e4d9ae9d13417e7f757b4acf3aaac696087d0e5afa10e8","git_blob":"56deefc868c673e717b6491563c69afa1514eabf"},{"path":"research/encoded-child-spectators/tariff.py","usage":"input","sha256":"4fc26570cd637fb761a900ecba75bedf60b3d4f4b10325df0cca7c1e72bac57e","git_blob":"df1efb5aeb1c1f54e7dcc07a9754a16e94b6c557"},{"path":"research/encoded-child-spectators/verify.py","usage":"input","sha256":"17b2c37e783a9148f0ff532bd944814c087f8bebbf59dafe574ce9ff021ceede","git_blob":"c8b5ac757501747d983ba8573723310fe2d4f12f"},{"path":"research/physical-compiler-correspondence/README.md","usage":"input","sha256":"bb04d8a05f0fbda2df0dc653118524ecaace3d22dd924179574fc115524df901","git_blob":"1b542517f938ef64a25155f96214ba332d8ce623"},{"path":"research/physical-compiler-correspondence/owners.py","usage":"input","sha256":"220918b53e45c5992471bb2fd0a95e62f410679048f3517504c851077ee94845","git_blob":"3fdf157278aa00308df706e11fc4a9e428b05e66"},{"path":"research/pr589-five-helper-hosting/PROOF.md","usage":"input","sha256":"59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647","git_blob":"bbd3f12b9a32b3ad3cba85a2d5a1b3054214fa02"},{"path":"research/pr589-five-helper-hosting/verify.py","usage":"input","sha256":"cf90e19ae9991b0698be03d395a8cc29061ecb307eb7fea19adfb2d23c25a367","git_blob":"dbc71f56bb4205ebe378ada1f9f4ea88630d1d39"},{"path":"research/r437-oq4-caller-binding/RANK26-COST.md","usage":"input","sha256":"cf6e472ff945ee4c3d5dc5407aa9aa7751022819846c4d7380cb697e227b0cc9","git_blob":"15809a6154ef189cb6c2fe1c8bf3dd6459f90bec"},{"path":"research/r437-pooled-native-interface/.gitattributes","usage":"input","sha256":"a3c414970082c100e8f9cec6d96b7d5eec4c31660d670b50d46f2d8ac53a3b76","git_blob":"a154a13b7c8d4590e03a6949ed1e76c102fd1dbd"},{"path":"research/r437-pooled-native-interface/PROOF.md","usage":"input","sha256":"695c3416094ee374a6b5d5152c80ce29f18358eda21e3afb7b58c2264a6d879c","git_blob":"24816d8dfb5e07978c3d7ad5010d25605d3f9a03"},{"path":"research/r437-pooled-native-interface/README.md","usage":"input","sha256":"be6c7a6fae80047631d926e83c73a217037cfdccdc38a5e6d0f4c38865f1ca14","git_blob":"6187399f1c7d947cd13f3fb064fb7b65b6d93290"},{"path":"research/r437-pooled-native-interface/RESULT.json","usage":"input","sha256":"27a20d575cb90c16a186a621d553e167f2bb6fd4e19541fe8d8dfc0208451658","git_blob":"4a03e803bfb3fe7af6808f655b9b6e828574d212"},{"path":"research/r437-pooled-native-interface/SOURCES.json","usage":"input","sha256":"219bcca3f47aa555cc7c9e126ccbee3509fe7e4fe29b4968b4357ae9c1f0a006","git_blob":"d0987e871ac318a208bed473540ace42cbd9eaf5"},{"path":"research/r437-pooled-native-interface/TASK.json","usage":"input","sha256":"f8348e1128757b7e42650100f24c690f368c230f7c72c3613617a1105fba2fc7","git_blob":"31286abc91a461677a93d1c38c0895c7f00e074b"},{"path":"research/r437-pooled-native-interface/VALIDATION.md","usage":"input","sha256":"b3b4978ca4540ea1d6083f6ba77b957750afeed222e2048f046ee62b5f31a590","git_blob":"ba071214dd6ad7bfe863a35856ae2f2e1b3bd11f"},{"path":"research/r437-pooled-native-interface/VERIFY.json","usage":"input","sha256":"c23da87b8d9cb87b651b987a71fbf76811b182be474f42dc5273c7d13e4bab2b","git_blob":"885be188550090829a166baad4cc21b581ea0515"},{"path":"research/r437-pooled-native-interface/adapter.py","usage":"input","sha256":"c1c054e5a2c650cfc267117b32896073e6735b93c5fbfb1defe6e379c4afab9e","git_blob":"276a9a0f436ba03e2a0bb1cd95d57ebc3cc3a290"},{"path":"research/r437-pooled-native-interface/check_interface.py","usage":"input","sha256":"b4f5fab63a262e36b5d585ad9ed6bb9436ecb8183eae233b27c8da9c448128d4","git_blob":"d44bcf750f121ddd276f09ce94d8d898a3d52078"},{"path":"research/r437-pooled-native-interface/check_transport.py","usage":"input","sha256":"c1351777d8886754a172ed3f6e90586be5c664a93b66eda5e87fa9580f104ab7","git_blob":"5bd3c8a38aed9df3b0d4404d382268aee02dfcb3"},{"path":"research/r437-pooled-native-interface/inputs/EXPECTED.json","usage":"input","sha256":"67d06bcb90d2307a11975d6b25107a695be477f168f2dc289b8484ba0b7e2de0","git_blob":"bc2585e1404402395a7c59ba6f6dde58b04e65a2"},{"path":"research/r437-pooled-native-interface/inputs/catalogue.py","usage":"input","sha256":"83ea88f82d4a83c5f889774bfe3519b7ebaa24b6a0e2a969dafff012107a89bf","git_blob":"0efc0575a7623ac41c094d2e8772beda5a9fdc29"},{"path":"research/r437-pooled-native-interface/inputs/geometry.json.gz","usage":"input","sha256":"edcaebb35d313f403b2db45a2cf808617f921c83cf7a11dd5d74356570ede1a8","git_blob":"a01a33c4753955ec4707db9515cee82a567cc1cb"},{"path":"research/r437-pooled-native-interface/inputs/moves.json","usage":"input","sha256":"0a58b239795d213743b5654c59a3e4622a0ddd4a53d8dba3fa30dedef4558dff","git_blob":"2cdb414a38cff6f0b872445f0980f2e3bc1895eb"},{"path":"research/r437-pooled-native-interface/inputs/template.json.gz","usage":"input","sha256":"6e03c76f5a4227394ea57e901eb7e93f4d1ee411ccfecd483fd44ea043550494","git_blob":"f56efc7ca3648d2070b791d4551a3d77dd7fdde4"},{"path":"research/r437-pooled-native-interface/inputs/word.json.gz","usage":"input","sha256":"e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e","git_blob":"c558a221dd44cbdaa732a401f9876de4c096d4a7"},{"path":"research/r437-pooled-native-interface/pooled_compiler.py","usage":"input","sha256":"fa1c589e5809ba8223eaf070cfb299bf55d843889d360b4d089824eb675e177c","git_blob":"512047d8b99628b097f5a597761e6647b424c92e"},{"path":"research/r437-pooled-native-interface/replica_catalogue.py","usage":"input","sha256":"d093a5a5421596d82c6c6e9fbc7fbf3f313c803a7ba423d666b98344b1912ff3","git_blob":"1fa6ea58c5193952bc6175cbb9f1a778a6502eac"},{"path":"research/r437-pooled-native-interface/verify.py","usage":"input","sha256":"dcbe8cdfee38ce0beff30c48a07a07009f4f054fd11454a80e834188547c2ffd","git_blob":"4a470e1e9961308c094dd167df7535b26b17e035"},{"path":"research/r437-preparation-composition/.gitattributes","usage":"input","sha256":"705fd4d6451a31d36b3df7de96f83f30ac976c9b4a6d1e51671d8e2f33e2d0da","git_blob":"fa1385d99a319b43c06f5309d1aae9fdd3adea46"},{"path":"research/r437-preparation-composition/POOLED-SOURCES.json","usage":"input","sha256":"95635c15a09cdac656e91b3a13ad2bf481ef4ffdcf67c7dd3c27b8400b2751ef","git_blob":"439c24dc2cbf055edae246ea8d34f57b8a73fe2b"},{"path":"research/r437-preparation-composition/PREDECESSORS.json","usage":"input","sha256":"61ae906bee904905b283164a2238f3640772217ccede0b53d1f7d168a90040af","git_blob":"7b48c3de7c5ec00971fc8d0694d363da5146afe4"},{"path":"research/r437-preparation-composition/PROOF.md","usage":"input","sha256":"21c5b5a914a5417a385c41b800934c0b2e155ffef89681a6166465393f1cf7ea","git_blob":"7dff5622034394009f908a659f20aa511e6becc2"},{"path":"research/r437-preparation-composition/README.md","usage":"input","sha256":"413362271e8c3ad44aba1fcc751dc683fafa4c7ea694d9bcc05325a37f25cd20","git_blob":"ee2d04215e35646a1c013c39e8840744aeb0ef8c"},{"path":"research/r437-preparation-composition/RESULT.json","usage":"input","sha256":"372425e00746955d68c4d86afe8db4f5ca4ad6b9ff4031349af4f5bb42ece436","git_blob":"2ff963ad94b7385a35e3ea5498c0e9bdc1f995bb"},{"path":"research/r437-preparation-composition/REVIEW.md","usage":"input","sha256":"88b2996b16228d536c5ca8cf8192b84fcdc03605eb05795f2a7c2185adf40594","git_blob":"95702631001f9aa0d43cd5ea94b75d77de728f6e"},{"path":"research/r437-preparation-composition/SOURCES.json","usage":"input","sha256":"e5822ba1b619af70e55e88a0b4bf81eddd8497bc98b5aac7b00c9d6b63b64bf9","git_blob":"0839f4876a67fc26084ae94d832ccd69d2b5edb7"},{"path":"research/r437-preparation-composition/TASK.json","usage":"input","sha256":"d3bcf16d46934bd2a802abdf07deba619c2f296aa64993d36e82cf59b9ed71ab","git_blob":"553e385d2bac17fa42b167ec1a7b9bd38aedb5f4"},{"path":"research/r437-preparation-composition/VALIDATION.json","usage":"input","sha256":"cbb9d97b34552467dc9f1eca1f9270e01381314061cc4d72cd9dafc22a880e37","git_blob":"afc5065b998c4c5adf0b50c053d01aab4a463ed8"},{"path":"research/r437-preparation-composition/VERIFY.json","usage":"input","sha256":"bc6d10d1d310bdc11d94e32f0245fadc5f3ac1e9469e4029b37e2b235b9c431c","git_blob":"3b839256f00c29f983f74a46e65caf4c956a3226"},{"path":"research/r437-preparation-composition/forward_fields.py","usage":"input","sha256":"4b6cb4b8a20c920c32dbad7b8e99a728d75681b0b4cdc876f4bd60730302a83b","git_blob":"45dcf2467f2167293fada94ba93d6e9d367de18b"},{"path":"research/r437-preparation-composition/independent.py","usage":"input","sha256":"d8f29ab18fadad315c3fe86b5a3d9877dc65c602156d479d5b52ea9210dd295c","git_blob":"83fcd9d882ea8f70385e5c2607e5c537d1d5343a"},{"path":"research/r437-preparation-composition/predecessor4025/source/CALLER.py","usage":"input","sha256":"7bc6e42072a09a08ac961e05c3da01cde012d740d4b4c605f298d994f2ad7c5a","git_blob":"5a032e8923f7f8b22bb98f3e39b804beb9906c16"},{"path":"research/r437-preparation-composition/predecessor4025/source/NOTICE.md","usage":"input","sha256":"c446b32b8a621844fb2fbe654810c8122035bdd43fed2132f1137d98cb6f9943","git_blob":"ef9f81510db86eaf2f0a7191d85e92a6db30ddc0"},{"path":"research/r437-preparation-composition/predecessor4025/source/cardinality.py","usage":"input","sha256":"505d5e560c5a507e6184edcc19a87cf1fed243eb34a5cb21fbe1e4fe017e7f22","git_blob":"b8ba857e32c5903408e1e61ff916300848b4a208"},{"path":"research/r437-preparation-composition/predecessor4025/source/counts.py","usage":"input","sha256":"00b476dbda0e8cc99886bf794439e1cb9e775f435f599a3557e99321fe084069","git_blob":"81b48940ce222290a40d4fb349ce827f4788469d"},{"path":"research/r437-preparation-composition/predecessor4025/source/directory.py","usage":"input","sha256":"4270e370b2bfe38ef73aadcd97d1b3496b56bd582115d74331eb9e5ceb90bec7","git_blob":"c74cacf5ce809c0561d374f137a52df0992b4226"},{"path":"research/r437-preparation-composition/predecessor4025/source/records.py","usage":"input","sha256":"0c9c4b23e998597fb877bb1a29da69ac869b68262abe635b162b4dba9c69b372","git_blob":"4f00467a0ff580954ad2fd0c7380240c753ddef3"},{"path":"research/r437-preparation-composition/predecessor4025/source/stream.py","usage":"input","sha256":"c7dc7da5b00f27016982ada4c0416f8328568b00df16d97012f33d4b372d79b5","git_blob":"5e5a4bb0f98971447043e25d4dd6991bfc070389"},{"path":"research/r437-preparation-composition/predecessor4025/source/words.py","usage":"input","sha256":"5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9","git_blob":"8d4ba37e2778acb35b34e0719df2caf138fbeb50"},{"path":"research/r437-preparation-composition/predecessor4025/verify.py","usage":"input","sha256":"b2c72707bebb9ecdba2b89675830439393e6e13c76f68dad20d42d6ef70e539a","git_blob":"614e57282c0edfe39f1afe45d140cf338210e62a"},{"path":"research/r437-preparation-composition/test_verify.py","usage":"input","sha256":"cdd1caaaa01980419a4c212a04961f8122f78371fb74698ffb8c5a9a1cfe7aef","git_blob":"ff9a2c364dfafc9188beb7429d58ea0f5e9732e7"},{"path":"research/r437-preparation-composition/vendor/certificates/selected-result.json","usage":"input","sha256":"bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129","git_blob":"b1fea0c94436b236cc2b7d41a7be032811b94c81"},{"path":"research/r437-preparation-composition/vendor/research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz","usage":"input","sha256":"0357b7cfbd7c29b4983982baf153c8a9f1e1e412690cd7fa9fc3d23d7963b20f","git_blob":"9eafb8776cbf78c72124f833534469ddfa5e98ec"},{"path":"research/r437-preparation-composition/vendor/research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json","usage":"input","sha256":"0058c491d839142aa99ef86a5ec697ce99857632228531512ea3fa74fb24d734","git_blob":"44006542202ca6037533a754f0bcd00549d7e088"},{"path":"research/r437-preparation-composition/vendor/research/e8-bit-p111-tuned/tune/EXPECTED.json","usage":"input","sha256":"b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4","git_blob":"e293ddc557742637f9f679f083a1a282d87b1b13"},{"path":"research/r437-preparation-composition/vendor/research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz","usage":"input","sha256":"e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f","git_blob":"85a4499bf9e4911a705d50567a2c2ef6cf23739a"},{"path":"research/r437-preparation-composition/vendor/research/physical-compiler-correspondence/README.md","usage":"input","sha256":"bb04d8a05f0fbda2df0dc653118524ecaace3d22dd924179574fc115524df901","git_blob":"1b542517f938ef64a25155f96214ba332d8ce623"},{"path":"research/r437-preparation-composition/vendor/research/physical-compiler-correspondence/owners.py","usage":"input","sha256":"220918b53e45c5992471bb2fd0a95e62f410679048f3517504c851077ee94845","git_blob":"3fdf157278aa00308df706e11fc4a9e428b05e66"},{"path":"research/r437-preparation-composition/vendor/research/pr589-five-helper-hosting/PROOF.md","usage":"input","sha256":"59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647","git_blob":"bbd3f12b9a32b3ad3cba85a2d5a1b3054214fa02"},{"path":"research/r437-preparation-composition/vendor/research/pr589-five-helper-hosting/verify.py","usage":"input","sha256":"cf90e19ae9991b0698be03d395a8cc29061ecb307eb7fea19adfb2d23c25a367","git_blob":"dbc71f56bb4205ebe378ada1f9f4ea88630d1d39"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/.gitattributes","usage":"input","sha256":"a3c414970082c100e8f9cec6d96b7d5eec4c31660d670b50d46f2d8ac53a3b76","git_blob":"a154a13b7c8d4590e03a6949ed1e76c102fd1dbd"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/PROOF.md","usage":"input","sha256":"695c3416094ee374a6b5d5152c80ce29f18358eda21e3afb7b58c2264a6d879c","git_blob":"24816d8dfb5e07978c3d7ad5010d25605d3f9a03"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/README.md","usage":"input","sha256":"be6c7a6fae80047631d926e83c73a217037cfdccdc38a5e6d0f4c38865f1ca14","git_blob":"6187399f1c7d947cd13f3fb064fb7b65b6d93290"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/RESULT.json","usage":"input","sha256":"27a20d575cb90c16a186a621d553e167f2bb6fd4e19541fe8d8dfc0208451658","git_blob":"4a03e803bfb3fe7af6808f655b9b6e828574d212"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/SOURCES.json","usage":"input","sha256":"219bcca3f47aa555cc7c9e126ccbee3509fe7e4fe29b4968b4357ae9c1f0a006","git_blob":"d0987e871ac318a208bed473540ace42cbd9eaf5"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/TASK.json","usage":"input","sha256":"f8348e1128757b7e42650100f24c690f368c230f7c72c3613617a1105fba2fc7","git_blob":"31286abc91a461677a93d1c38c0895c7f00e074b"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/VALIDATION.md","usage":"input","sha256":"b3b4978ca4540ea1d6083f6ba77b957750afeed222e2048f046ee62b5f31a590","git_blob":"ba071214dd6ad7bfe863a35856ae2f2e1b3bd11f"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/VERIFY.json","usage":"input","sha256":"c23da87b8d9cb87b651b987a71fbf76811b182be474f42dc5273c7d13e4bab2b","git_blob":"885be188550090829a166baad4cc21b581ea0515"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/adapter.py","usage":"input","sha256":"c1c054e5a2c650cfc267117b32896073e6735b93c5fbfb1defe6e379c4afab9e","git_blob":"276a9a0f436ba03e2a0bb1cd95d57ebc3cc3a290"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/check_interface.py","usage":"input","sha256":"b4f5fab63a262e36b5d585ad9ed6bb9436ecb8183eae233b27c8da9c448128d4","git_blob":"d44bcf750f121ddd276f09ce94d8d898a3d52078"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/check_transport.py","usage":"input","sha256":"c1351777d8886754a172ed3f6e90586be5c664a93b66eda5e87fa9580f104ab7","git_blob":"5bd3c8a38aed9df3b0d4404d382268aee02dfcb3"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/EXPECTED.json","usage":"input","sha256":"67d06bcb90d2307a11975d6b25107a695be477f168f2dc289b8484ba0b7e2de0","git_blob":"bc2585e1404402395a7c59ba6f6dde58b04e65a2"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/catalogue.py","usage":"input","sha256":"83ea88f82d4a83c5f889774bfe3519b7ebaa24b6a0e2a969dafff012107a89bf","git_blob":"0efc0575a7623ac41c094d2e8772beda5a9fdc29"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/geometry.json.gz","usage":"input","sha256":"edcaebb35d313f403b2db45a2cf808617f921c83cf7a11dd5d74356570ede1a8","git_blob":"a01a33c4753955ec4707db9515cee82a567cc1cb"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/moves.json","usage":"input","sha256":"0a58b239795d213743b5654c59a3e4622a0ddd4a53d8dba3fa30dedef4558dff","git_blob":"2cdb414a38cff6f0b872445f0980f2e3bc1895eb"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/template.json.gz","usage":"input","sha256":"6e03c76f5a4227394ea57e901eb7e93f4d1ee411ccfecd483fd44ea043550494","git_blob":"f56efc7ca3648d2070b791d4551a3d77dd7fdde4"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/inputs/word.json.gz","usage":"input","sha256":"e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e","git_blob":"c558a221dd44cbdaa732a401f9876de4c096d4a7"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/pooled_compiler.py","usage":"input","sha256":"fa1c589e5809ba8223eaf070cfb299bf55d843889d360b4d089824eb675e177c","git_blob":"512047d8b99628b097f5a597761e6647b424c92e"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/replica_catalogue.py","usage":"input","sha256":"d093a5a5421596d82c6c6e9fbc7fbf3f313c803a7ba423d666b98344b1912ff3","git_blob":"1fa6ea58c5193952bc6175cbb9f1a778a6502eac"},{"path":"research/r437-preparation-composition/vendor/research/r437-pooled-native-interface/verify.py","usage":"input","sha256":"dcbe8cdfee38ce0beff30c48a07a07009f4f054fd11454a80e834188547c2ffd","git_blob":"4a470e1e9961308c094dd167df7535b26b17e035"},{"path":"research/r437-preparation-composition/vendor/research/recursive-parking-boundary/README.md","usage":"input","sha256":"491aa208391ee4c2936510b1a5c5c018dd5509d9a0e88687c72ab8406cd77b18","git_blob":"251f335ebaccc11d69393ee7aeb5a2e84526d0bb"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-local-ring-sweeps/PROOF.md","usage":"input","sha256":"846c59440cc99e28bae93ad2af99525bc769de29368080071b8427141215b4f7","git_blob":"4330de85dd9862ed15d84ab917887d249753df99"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/PROOF.md","usage":"input","sha256":"e5a827e93fe313ba9bf4a2e300bae01b58b28004aa8a8ee119cf6d950edd9f93","git_blob":"548ecff3ef79a32c14bafc7f2309781181d3c23d"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/README.md","usage":"input","sha256":"989ad891ce3f866c920a25e0cdd661815f982c4c854370f8c00668eaa15d770c","git_blob":"abd0edba96101a025609d2840c3dbdf4d3e30aa8"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/RESULT.json","usage":"input","sha256":"de6216b9f89f22b9602867776a7fc951ec558c852e6abd4624151e95d868af56","git_blob":"44afaf8dca8f76b3c9f5ef58616b6d57ff7ff2f3"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/SNAPSHOTS.json","usage":"input","sha256":"c7b3485bdae5ddf43166cd6626bd512816e179617a4234c36584f6c57c34744a","git_blob":"034836cfaa3e4f984e900a980eecc986ec405b1d"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/SOURCES.json","usage":"input","sha256":"94e1f55094bbd122e4ee73413650fa24072c392d53d257041cd5d38a2269e4fd","git_blob":"a27291a91519f9f4e074712afa3262c4d372aaaf"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/TASK.json","usage":"input","sha256":"84319cb2f8c7c121927123e8c3271c3ec4ec93fc9be362dcfdf7ee4366cd1a74","git_blob":"28b8d5e1cbd29824e702d384937831ddb3876da7"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/VALIDATION.md","usage":"input","sha256":"c38eaa31a9cf3489356f2e2a675e2bc6194fa41796589edc9cbd8578b5d71c0f","git_blob":"5b1a9221f35cbd637183282489e8eeaa30314ea8"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/VERIFY.json","usage":"input","sha256":"5bb3cf67018f35de5b825c9bb4b7a6590296da85f492ba3dbff7a6ce9bdebf8e","git_blob":"682809777271adfe08df6e6ba2fae89571420212"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/continuation_checks.py","usage":"input","sha256":"c6ef8fa86a7099af0eb6763a3f5bd43f8f94e1e176cfba38c0077b3e0f5fda48","git_blob":"f2be8aad16e279c0d1467e21d79d2dd81dcae8d8"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/frame_checks.py","usage":"input","sha256":"ced41d9244afcb5275ad5c46dc0f60265afc1e6422d29b277364e945825c4dd8","git_blob":"4b992ffcb0a613da54ca24e31d25e61445799e10"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/EVIDENCE.json","usage":"input","sha256":"77b7cbefa2ca30acf2f77e23d14808ccd27848e9c76e4c5e68a045ef7891a07f","git_blob":"c2c347abc2b8c19bb642c4da1aad5b3e8383016f"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/PREDECESSOR.json","usage":"input","sha256":"e3127475913d62dbdf1b45d9283d2db2e9b689e0f81a703189150c1e5be2bca0","git_blob":"56d76c357b51f4fc6856923222bfca47f03334e7"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/PROOF.md","usage":"input","sha256":"552fa306d5cc228f4d8d8553f8ac5fc6a738ef2b66a2cb765ba0638cd229794d","git_blob":"1a08e57eac2a37764066d31baa3ecd3769759158"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/README.md","usage":"input","sha256":"6ce41fd7e6dfbe5faecc25bd36561f0a65b6ebca6fc69d3fb72569424a405045","git_blob":"75461632856f94d6b48ae820cf5d0b2b232305c2"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/RESULT.json","usage":"input","sha256":"4919655bae2e5cff051e8f2d240a8e4ebb03392a9da2fb5328daa9248fb7e88b","git_blob":"75faec7844e18fc7c44543dbab87aba2ecf32b3e"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/SOURCES.json","usage":"input","sha256":"7c78f539078e1bc3d893b78b5ee24cb22dc090d3763fe554e861b6c3d3e7eaf7","git_blob":"ff8c8e36176aa56e319d0f9e584167ac21d67f33"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/TASK.json","usage":"input","sha256":"ac7d4b38da31b373e665929027fc04afb66c3e9aedaea3296e3783637912d0e8","git_blob":"d70ad317275d2a517ab1294ce48ecb1f83dfedbf"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/VALIDATION.md","usage":"input","sha256":"ac0f2fab0ca810ce0202d31480daa8329cba0897ab015520a2bfd4b689c4086b","git_blob":"d91680665a28c12c27c99336b55c3d5341dd0fe4"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/VERIFY.json","usage":"input","sha256":"6ad0e07f68458afedece927550655b5bc5cd9861a70044fcd95bb10a2179f0a6","git_blob":"b6072f66c13a38b5d8dff3ca3bc5f3f3562f1b6e"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/bootstrap.py","usage":"input","sha256":"eef1c418e8edbdf317d159683e30beaecd971c77cf41d6b09708576405e2141e","git_blob":"448c9b3a86eedb84220646ab27ff089a32ad5b9b"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_layout.py","usage":"input","sha256":"454b1587d1ed5ccaea19b621a67e2ceba999d7ede61188125faa41c4dd2ab2b1","git_blob":"be59d614d25961f891e1640bf85cf5e2f474a059"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_nested_model.py","usage":"input","sha256":"b1941b882b0659722c3c41994c82f020c1f7ab320dc28c43c2758029ef8a48b7","git_blob":"20fed6bd389cb53fc52d0ad8389e9e7704c90265"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_recursion.py","usage":"input","sha256":"dde82badf043e553bc635a34295e2b5505d84d6dfbaf96e0cfccb8a8c3dbb158","git_blob":"8f36c88e196cf5afc0d6e227ba8568a10bb23c6a"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_runtime.py","usage":"input","sha256":"9fcf0c9a3c84a17446fafe8da50b63db296ba9465d48ddb6fdeac8742dfc98b1","git_blob":"fe355a703475325bca4807b8ffedfa9f6edb74f5"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_sign.py","usage":"input","sha256":"ee4fd34acd49962a18d268aefeb20aa3c2673a10e7a43eee3e51a9bd3cf9106a","git_blob":"50669949a1325e8c49aa0ff714c40a50077b5eb8"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/check_sources.py","usage":"input","sha256":"1c49984ae6ee7f8a44cde16b51e486f0b3ba4ee5c973389ac8d58a82d0a0aa3b","git_blob":"5c09a13943070a3bb3c0da06fd19fbc6916d1743"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/consumer.py","usage":"input","sha256":"2f2a8604c23fb2c81f24320c71ed0142118d98dde3be6086adad28e89954a777","git_blob":"a66d9276f829ce2c619871866816649d5f3687fd"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/control_checks.py","usage":"input","sha256":"c09d33327932b4ffbb8acb26c8a6bb621bcca542157d22f1edf72679a9359981","git_blob":"11daa0b2221c5870d19ba2eaf411a6bff3a0398d"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/driver.py","usage":"input","sha256":"ceaf8f75de9810a05ebf8f65780b6f8bd7599a5768401d5e4386182afe615cdf","git_blob":"5b7846a70aada53d87480b337e1c04217118771b"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/NOTICE.md","usage":"input","sha256":"fd7c42e89878cda6df86dde8720ece34625a337cf5edd795a421e2d3b42919e9","git_blob":"d0318d43ed420e21dc52166a19de703aa87fbb3e"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2688-NOTICE.md","usage":"input","sha256":"c899fccf7bd32397f0ddd85e4af35a166cefb3e3ae3407ec40edc3ab2051b617","git_blob":"f2b49cdef83a4a685fad32c01fba93e12cfcb5a8"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2688-PROOF.md","usage":"input","sha256":"fa9bec0952468e4acb760a88d45d5be216325650e1a4080cf590e07b90c9f533","git_blob":"1395e1941863e40ff6d62dd91c41de2cb56edae9"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2708-README.md","usage":"input","sha256":"5906f6b7b2c8eea90e441476c4cbd60fe2ef981b690c63357bcfe67e3104aeef","git_blob":"79b8742f32b4ffb991f91ddd2d3c6be693084e6d"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2731-README.md","usage":"input","sha256":"19683df4394de299cbd7e1cce39bf9434ad260b1a37006587cf9aed84c9c0a03","git_blob":"ac5b826f9c34e1faadc5d5a02d5d260823112078"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/layout.py","usage":"input","sha256":"3beef6534b02c3b011b741f957a7d9fb05a9ac0bba1fed53b2c71834e4ea6bc1","git_blob":"aa554b14fe0f6b308d9fba0a2afc92e5a28e20cb"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/linear_sign.py","usage":"input","sha256":"73e895fc701a4145cbe89d60f5775128354e7f08d0a45eacf22f423913f54e67","git_blob":"6a6e5c02f299fad8c4f7ab724fc36e14a22ab13c"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/node.py","usage":"input","sha256":"0bd4f640cafb5c8f070c161d86445910f77578a672bf5886936ed89e7f6bd21b","git_blob":"28c98a3573b458f7a055678d70b602b80e6e959e"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/packet_engine.py","usage":"input","sha256":"c80fc3aa9092f91cc309b2fb2dbc3618bf96bdb9b8498503993ea161f0ae2134","git_blob":"72543f684f38fefeacc2ee66d81661f1a2439cf7"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/peel.py","usage":"input","sha256":"8b20888f74b4cd814a97b42ec72528fbfb6d2e936c5022df726f0785d0d01a2e","git_blob":"38502515afc928082c849cd2cda8578d33a5050a"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/NOTICE.md","usage":"input","sha256":"c446b32b8a621844fb2fbe654810c8122035bdd43fed2132f1137d98cb6f9943","git_blob":"ef9f81510db86eaf2f0a7191d85e92a6db30ddc0"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/PROOF.md","usage":"input","sha256":"88754d57bae35a2089d9de221ff32ba802b7a56b810f96271f3ea36985edfb14","git_blob":"a4746d1786f41e45a36fdedf37966b80fbab3562"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/README.md","usage":"input","sha256":"15631eb826b2d8d54fbee18fb6f70ee035e172d524c2a209b6c467c3f0204f64","git_blob":"988ff622029aff49d7e99deb2468684d904bc852"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/RESULT.json","usage":"input","sha256":"0d94c5e9150f3fbd603526c67ea33168d3ba45e158aaf722e848bf5c316a37a8","git_blob":"7b7dfe0eab22a7b511483f268b97a7c707fd8b90"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/SOURCES.json","usage":"input","sha256":"1b02a5c607a5967948988c3beaf37d9975d650ad501a99fcf74c135dc1f05fdd","git_blob":"4fef1a4d6c2d5e2620d3506d6032f9226870ed39"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/TASK.json","usage":"input","sha256":"a4cd54d4b09ad12a90a5feeb39a127f0f0d5a2a04f9f88554c5fc3ee0cfe77f4","git_blob":"eb2ce7cc00df816daf566f101d56a0330852c1d9"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/VERIFY.json","usage":"input","sha256":"e1dd0ee5f267ffa515bb345054ff8637cfedb0079b0d2da29b90b7848264926e","git_blob":"69c7ad75abe494be386f73a5d51359b9053cd9be"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/cardinal_counts.py","usage":"input","sha256":"59ddeac102a0cc51fa49b15aae6aeb68cd68ed217fa974ce916372a177d2ec8f","git_blob":"6a14feac45094ae9156e8c2c982d6727544f180e"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/catalogue.py","usage":"input","sha256":"83ea88f82d4a83c5f889774bfe3519b7ebaa24b6a0e2a969dafff012107a89bf","git_blob":"0efc0575a7623ac41c094d2e8772beda5a9fdc29"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_headers.py","usage":"input","sha256":"a41dab0c487c341eb32b34a03af74454e15e9e61e7386a1ca426d83f3b68b1ca","git_blob":"1c372b19e19b838a89c0e64daeda15ec6b49f079"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_layout.py","usage":"input","sha256":"8f776a21dc0e31f9738d822cfda38db92f1e3672afb880d4246ec5e084a50a41","git_blob":"174d843716a684145f934cb55a612bca85aad725"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_runtime.py","usage":"input","sha256":"5357e4ff255f17c4209aaf71a3413a4148475f11180c4f829e8f0ebacd2877cb","git_blob":"5647693b3a5c1555b65e281c6609f98b92d45542"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_sources.py","usage":"input","sha256":"6463c2724e04a313181b78e90a17cd62ee42465754902cca3e9a65c6140a15a1","git_blob":"9219cdf863d9f060d6e38a4f2f4760fd227af003"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/consumer.py","usage":"input","sha256":"b28ec97b0873ff2be25aff4bdde268247ffcec0d21279d0ada196de19a0bdc66","git_blob":"24b53521fce94d3349072cf47d70e62195f4d541"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/control.py","usage":"input","sha256":"d3a93e54bb7d333b73917586407d11674d38b5c3fda4fbdc436fb5293ae7786a","git_blob":"4f6ac09bffab43dbccc470bd0bde2ffbe969a8b2"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/control_checks.py","usage":"input","sha256":"5ea6ded8c2508fbb00d93655affdfe7907ffb60916389e0736249c003a7a5148","git_blob":"712cfddc4caaad9e788d97b0e1e3f623172c43ed"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/driver.py","usage":"input","sha256":"ee9e42fe95ab28fdd5e927c2d46fd480305aaad610eb2ca7ae514a5d22d9f0ac","git_blob":"0bdee4c9e348259b470a636a98e7657770f97fae"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/fresh_rows.py","usage":"input","sha256":"e4ae08fbd658add630eb7754ebe0cbcb42c6f39cf4128f9cb92e27fcf5213a7d","git_blob":"aa3a327604308d3a5c7a27b65f5e631d430ab093"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/layout.py","usage":"input","sha256":"7534b0166805f2ae8d11495c811d2bd272cea89c89b6bb5251fd411c89245a20","git_blob":"267d5ab98cd013ee82ba75e6d41609f1778af25f"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/model.py","usage":"input","sha256":"c937ae8e46162f88fc1cd7646d3b22c99273029ad0f0e3131f46ddec230676cb","git_blob":"9fb82fa57d29cdf8402f91534dffed8f586ced6c"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/node.py","usage":"input","sha256":"b88fc9ac0b22d939311ff4f7aff788e8c87a64fd5e866498e59bd27940ee3f28","git_blob":"13badda6f059da2132cbe325c071307e5191baa3"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/packet_engine.py","usage":"input","sha256":"ce7f132a6a69c802406f07c4a2119ef921e8978520ff58d5eeaeedb982c257f2","git_blob":"27a0dbf82e78252beede56ff86f5933c93eb55c1"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/peel.py","usage":"input","sha256":"3de018e68601566c364c7568b110f60c1bf34941b846cdffb94401bb799f85e3","git_blob":"2ae1769a9726ab738d3981891d0b76beccac2d99"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/topology.py","usage":"input","sha256":"384d456ddba76de137a63b50019d5bba2e9f6daa4177c91643e0565d4cf1d44b","git_blob":"39a2916c207d04be5efc44750d8606f5da0c2990"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/binding.py","usage":"input","sha256":"20169a8af6ed2b34069fd353a2bc1c42335ab686c58de8479baef33dd3fb493b","git_blob":"21a5a21220a18ab62a19ac403a9944bc3a8665c8"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/bitstream.py","usage":"input","sha256":"f78bac9641007dbd8824984edcac057274fe016ce78bd9cb512d0c0913274783","git_blob":"4d1fd4abb0f2aabe833e5cbc9efb51039739e7ca"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/cardinality.py","usage":"input","sha256":"505d5e560c5a507e6184edcc19a87cf1fed243eb34a5cb21fbe1e4fe017e7f22","git_blob":"b8ba857e32c5903408e1e61ff916300848b4a208"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/check_support.py","usage":"input","sha256":"d9977e87ddc5acdb836b8e4a4e3942da17a05b04ce67c04547d17b986b518964","git_blob":"e1f961df9fa3a441fc5b600d1288a8d038eca51e"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/children.py","usage":"input","sha256":"a78866939631214c1d1659203b2b5fc062e3c6255e9f11f975c310046b010bd6","git_blob":"ce4935f838516e2b08d13bec767cb803786fbc6b"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/controller.py","usage":"input","sha256":"fa09146991f6c04e6f4b6eb9bf0c8e103e70e90a0e402ff3d69814e6aac8ff8c","git_blob":"c631a9e77fbcccf0e8f448adc22978728aed7b60"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/counts.py","usage":"input","sha256":"00b476dbda0e8cc99886bf794439e1cb9e775f435f599a3557e99321fe084069","git_blob":"81b48940ce222290a40d4fb349ce827f4788469d"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/directory.py","usage":"input","sha256":"4270e370b2bfe38ef73aadcd97d1b3496b56bd582115d74331eb9e5ceb90bec7","git_blob":"c74cacf5ce809c0561d374f137a52df0992b4226"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/episode.py","usage":"input","sha256":"38f79cb2a370548471063952d5f7c74bd795a2a8496fdcf3ce0996d79e3adaff","git_blob":"30d11ff4f333813855d36da3eb5a1ab0e154bafe"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/forms.py","usage":"input","sha256":"1fdf9d31b7eb107c396e33f94dad61c9d3f2c709cae61178268a44ca80dbc0b4","git_blob":"6667c0b772a63f0059c7caffec63e0d919a92398"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/low_codes.py","usage":"input","sha256":"f657e17f6088c840e3f7783e662257630f6d2c1e71c217721ffbca4d6ac93e87","git_blob":"737edfc4a10f4b7b3b97a7cef4b40864efd806e6"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/matrices.py","usage":"input","sha256":"00b687434039b54529ee092e34f9435cfcd66e0816eb3bd2a6688c73f4e01459","git_blob":"5d497353efbb9eeaaf4facd96ab40ffb0f3aa20d"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/numeric.py","usage":"input","sha256":"7327b05c4ec3e0f6d9c352cc7de85bfd4ebe940482553e77c59a773a8c09c514","git_blob":"6d4ebca8398008375b8f4762d1a9f1514e8c2611"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/oracle.py","usage":"input","sha256":"7bd18089e32ce48085b5e3a75159f6a82cdb2649ec682c53db05e399d97aef67","git_blob":"244f131466698a3ace10b657242fe1f65c07fd1f"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/packet.py","usage":"input","sha256":"970e7fe0719e3dfe122b248941e6f21cd90d7dd62089fa6acbd0e5412ce083a5","git_blob":"ebc9b616514412b80c56d523776e6ba5d6766453"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/plan.py","usage":"input","sha256":"d9c8dc93762db4d3a449814aa51e2211460648694469854d89cb48cb04188cf3","git_blob":"48255d5454308c07635fae4e7eb4873b0bd2a4f8"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/records.py","usage":"input","sha256":"0c9c4b23e998597fb877bb1a29da69ac869b68262abe635b162b4dba9c69b372","git_blob":"4f00467a0ff580954ad2fd0c7380240c753ddef3"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/residual.py","usage":"input","sha256":"8fd24747cae498dfb2ba333e7f8a68d7315ae4c2d7530d8ca145aab95ede21df","git_blob":"3d070d2539a529f3b14ecb086a92a3db056229fe"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/routes.py","usage":"input","sha256":"ed7dc3679451696ab1dd841146b215c9515a3eec5e4ff3763f33c315f1696ada","git_blob":"35531201dc349a811dfabc6f1f6e64697d665194"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/selection.py","usage":"input","sha256":"bc8e371fb1fa0b41fb05ef0b34d0f4c317b2396f9833d91f44f95c2b54b4052b","git_blob":"2c28f1aaec104a75c4e6c170b3e6a60300ee6700"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/sources.py","usage":"input","sha256":"f102edc7816d742bd89db8097254c19b843d0ef5cf6758ad42e93bcc0b214c62","git_blob":"16d5e7e6a28018f1e2d76d61efe2d54f6a6941d4"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/stream.py","usage":"input","sha256":"c7dc7da5b00f27016982ada4c0416f8328568b00df16d97012f33d4b372d79b5","git_blob":"5e5a4bb0f98971447043e25d4dd6991bfc070389"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/stream_runner.py","usage":"input","sha256":"751c5023ca0e477369e448583961ace6a76db2723bb6c26f81203def539f1249","git_blob":"efff281d4c4be5c1378e31404fbcc634fe4ade59"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/trace.py","usage":"input","sha256":"c71ba11d793dde2ac6e4cdcf468482872975c34589bf1167f2a460cb8a74e984","git_blob":"bb845a90f5bcf006e683e581e385936208f6a1f4"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/words.py","usage":"input","sha256":"5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9","git_blob":"8d4ba37e2778acb35b34e0719df2caf138fbeb50"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/predecessor/verify.py","usage":"input","sha256":"cd83797d1f420f7e5de61c1a693110b4ee0c80bac0adae4699599046b7f76f8a","git_blob":"121acc1ff15ec85a8011e96eda2eb587608413b9"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/recursive_call.py","usage":"input","sha256":"157deaa5972557893d43494a81151483bdc46373448ec677cb6a738c9b7e6f1e","git_blob":"6d33224145aa04f7fbaf7b6cda7c9c164311a402"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/scheduler.py","usage":"input","sha256":"0d96f7fbd6f90416167c5a52c0e3de942d1a0cae3d2968831932a9576701699f","git_blob":"60c2b6d065eba91dd5e0edb7a77fc087971eca3f"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/stream_runner.py","usage":"input","sha256":"b255feaf6cc6e40413ae73fe302bf8f290bf4dd89f4128b23a91cc9860601801","git_blob":"6ba5df130bb4a0fcb06b6c630830ae3a6922921b"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/trace.py","usage":"input","sha256":"3a664224c558244f606b603cad816d75e94a17c9b2620a06a1530e893dfceac2","git_blob":"4b002201ce54cdecec9acf4e874b7f71cd75fe71"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/verify.py","usage":"input","sha256":"65126e788eeea10e830fc583cf4afe0bfc4d67495cbf8ac21de3507dbe624d56","git_blob":"96be8f5859a3f3799344d46dec1ee68170d96bfa"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/NOTICE.md","usage":"input","sha256":"8640d1b52fd21e5b20e8109ce9c4957ca1e19a95e26a1c80d019a6e6f4d5f178","git_blob":"307c2da733f7f3a76e97c77e71072e811f40df02"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/PROOF.md","usage":"input","sha256":"fc9e7dcc5b385b6e508d6a6e9524b93059fa3e9fd5fcfb5eedbd85b3a54ba55e","git_blob":"7207ce7dec86694f01a3d9c049dcb87cc909e380"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/README.md","usage":"input","sha256":"6550a466bfafff2ca11740e931ed9fce062eb488f23e74edff7e4bbae8282bb1","git_blob":"c96e0d6cec56a9a5579ae159456fc15767315bc3"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/RESULT.json","usage":"input","sha256":"4406fec9515bb4206c75b681f046b5441319cf1ed39a13b9b0134696b1c192a7","git_blob":"b2d1889d77019e06ac0326ac91b1322340cf3866"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/SOURCES.json","usage":"input","sha256":"a6476b786632c2cbffabbe27eece790e378996c8b03eb17a01f1094f20fc4cdf","git_blob":"746393061c55f47412601e3d346e914762683e0c"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/TASK.json","usage":"input","sha256":"964d3a4fbfb53fd58936840328ac4b770b324c9e78f722861b1db04663110626","git_blob":"216dc8f8bcb33fe32d0eaccdadb0fe0383d73848"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/VERIFY.json","usage":"input","sha256":"f9e252e8ab255b49c3b18d4db76cc09ebd9fb61d599305e0aca8bf295189028d","git_blob":"6537be05745836106c753e1388ffc8b1bd23ce4c"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/checks.py","usage":"input","sha256":"98ffbd58881aa138b8dbae4d5722855ece2a5fdf7585e53978069ae9b064eb09","git_blob":"46630a7648b1c93530e9253872a19cce338929ff"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/codec.py","usage":"input","sha256":"5b9fda8136f7e60bece54e3fcc74f4ea0bec7145fa60e1ae3a4d252741b81fd3","git_blob":"9cd54d9417eb685dcd3f8293f01299ef9046ad31"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/vendor/parking_machine.py","usage":"input","sha256":"68134779debfb795468a1aaecbc2b9d321d7d4e451313ce7dc8fa7092561df4c","git_blob":"cafd614a3b7bc87b019361fcdf890ed976f26d19"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/vendor/pr2753_recursive_call.py","usage":"input","sha256":"157deaa5972557893d43494a81151483bdc46373448ec677cb6a738c9b7e6f1e","git_blob":"6d33224145aa04f7fbaf7b6cda7c9c164311a402"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/vendor/words.py","usage":"input","sha256":"5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9","git_blob":"8d4ba37e2778acb35b34e0719df2caf138fbeb50"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2769/verify.py","usage":"input","sha256":"37f9e51e6c038a2493b4550e3cf0bd52621b6c20e115f0886406fc9909a82120","git_blob":"6be4f94eda9c96f4e7265a294f63e39309dcb0c6"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/loader.py","usage":"input","sha256":"4d8647f520b2967a0ca7dcadeb39d6ebabbce44df4193f609fef22911d0ae67b","git_blob":"4a0326c9af88626938645f288e559b5b97cb1787"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_binding.py","usage":"input","sha256":"9ef31765d03d2c54fad9296f2ff0707a190ce169e44de4f0f45214e3c410c01a","git_blob":"c197eb6458be9374cb4684c654bfc99e619dcaf0"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_checks.py","usage":"input","sha256":"0631b4d6b547a76d8ea4babd3465908b9efaa058503f8330140bcc8eb22a51cb","git_blob":"6a9226a647d095419840fd9d6696ffcef9827b0b"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_code.py","usage":"input","sha256":"f626b018124747a5f17c1603bea36cd74c00a69a0647fd7b10e9c4e2964caea8","git_blob":"2f5f8ecfac6457171707b1b5ff02b5071954fcb7"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_controls.py","usage":"input","sha256":"a5343faffadfdd9ea0e52d4c7c4ef24ba5e8d2dee86c8af27c094ad78944b845","git_blob":"b7c1d28dd47ff463df02ea97b5907a041c05bdde"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_local_checks.py","usage":"input","sha256":"a9be60378d1282184632066b87cb044a8510b6623acf0df4dbf2f1bcd35cb830","git_blob":"421f9030f91f3ab309a9873928c09ba8a2ade580"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_machine.py","usage":"input","sha256":"7bc6e42072a09a08ac961e05c3da01cde012d740d4b4c605f298d994f2ad7c5a","git_blob":"5a032e8923f7f8b22bb98f3e39b804beb9906c16"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/macro_selected_checks.py","usage":"input","sha256":"080e147837a4983a73e598af0cc97333e2cfb1d328f5190c9d4447a8bdbb4668","git_blob":"14f224e975fdd1a580088baf26e23ca44091a2f7"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/nested_bank_checks.py","usage":"input","sha256":"4c225e7d91c767b4cedcf9f9b5222875be948bf8b4ef03cedc4f46f1d570e9bb","git_blob":"c48f87429773e3b80719c209b4ad3f3977e3c41e"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/numerical_frame.py","usage":"input","sha256":"3fd62eda5d0b48bf31ea244708a77afdc6d16cf4fc9439d140ef422a38c7406c","git_blob":"dc92611dd5f131718806fa96470b8f3494e15e2a"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/residual_blocks.py","usage":"input","sha256":"ab7f3df8906decd2efecfb138eac1456c106bb520b2598761f699f80680d8331","git_blob":"fba75e7649cf77e352a75324495191bbd7853c22"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/role_parking.py","usage":"input","sha256":"1884a3c260d81d5efbc0c33d86a810d6728e55e5764cfcd423f858cc685470f3","git_blob":"fc48c244eefdbaa3e320e86c75a7d187cb5765ef"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/scratch_pool.py","usage":"input","sha256":"41f1eb93652b7174c3b02f95f70e1a9ce2e2aed0a729e725167c8f226e65d8db","git_blob":"0f22807c65d1bca374b905538512bf8c43702070"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/verify.py","usage":"input","sha256":"bfba14c842ea4d97bf160588abc061553d3e4eab66cd5f32b903e1a67e661aec","git_blob":"fbdc87b9f98dc7722db45a42a742c5569089eeeb"},{"path":"research/r437-preparation-composition/vendor/research/selected-bit-recursive-closure/PROOF.md","usage":"input","sha256":"74cc8de20f21acb5123fe2d20996fe0925ea6e51b3dec633bd5221fb719b3344","git_blob":"6c410cab5713979214a45835091fbeb9ee9b8531"},{"path":"research/r437-preparation-composition/vendor/upstream/build/sections/02-streams.tex","usage":"input","sha256":"606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab","git_blob":"088fceea1867abc76271d7efe7532b779fee9039"},{"path":"research/r437-preparation-composition/verify.py","usage":"input","sha256":"98b38dd6ae9a657e34966bf683e0a732b7cbf2728cb108a86157ad8692ee7ad7","git_blob":"955b199140ebb903ca55a543b97eeb884ea9681e"},{"path":"research/r437-reverse-row-coefficient/README.md","usage":"input","sha256":"a7873487757b6796d9883712e59f7d79df5a5495fc143bcffa6b422fc576b07c","git_blob":"d23b6ecd4f6374b7bc01aada2a958e8d1fd3f1b4"},{"path":"research/r437-reverse-row-coefficient/SOURCES.json","usage":"input","sha256":"53211542c4e92eee92458f2b313d0bf6c1706e56dada488c604e93a0760fec43","git_blob":"a604c6a640acd80f08b7378a00739eff45ac0830"},{"path":"research/r437-reverse-row-coefficient/TASK.json","usage":"input","sha256":"4d78de8b25f29878fba3cd39679c08fed1b55af1cdb566d23b88804d1b2e7148","git_blob":"c17ebdad667c0e84bdd98cbb2e942da805fe0c32"},{"path":"research/r437-reverse-row-coefficient/VERIFY.json","usage":"input","sha256":"acebfa5e7dc034cc6ff8d39de15b43b407482b1622097b05eacd86fb128b5221","git_blob":"1f9455c1c7f10ff419f1a6d22fcd0596bf15052d"},{"path":"research/r437-reverse-row-coefficient/independent.py","usage":"input","sha256":"d06b99de599a5b75590bb107fd605df314ed9cf8da19a9ba22bb8de0c33787b7","git_blob":"08ca179f3c5bff77efecb388894b974f7c94b51c"},{"path":"research/r437-reverse-row-coefficient/inputs/CANDIDATE-PHASES.json.gz","usage":"input","sha256":"47c092cf409ac09c4386e5e59ea539d7406f65f746ddcf62a595353507c16607","git_blob":"278422ca4a668b37274c620ad7105c953e2c26e3"},{"path":"research/r437-reverse-row-coefficient/inputs/R437-COMPOSED-WORD.json.gz","usage":"input","sha256":"e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e","git_blob":"c558a221dd44cbdaa732a401f9876de4c096d4a7"},{"path":"research/r437-reverse-row-coefficient/test_verify.py","usage":"input","sha256":"6488b70b7f67170116c0fe039cf2a254293621ad0b443751c5050d3b7cc7a039","git_blob":"eaf1962391ae5489eed96d697186a75c3bcdc0d8"},{"path":"research/r437-reverse-row-coefficient/verify.py","usage":"input","sha256":"0a345d3658b868f8ccb36969e68fd1e8d5412a98a9f06b3e1a6e74ed9041216a","git_blob":"5e416b46c0975d8d39c39f86fa3d25cf3a142a93"},{"path":"research/r437-two-window-carrier/CANDIDATE-TEMPLATE.json","usage":"input","sha256":"6228ba213be5ad22c42e85afb885e96594d2b355ec1fa6c4a57767b4f80bef8e","git_blob":"96e959f07eebd6330fbbf27b628e793c1cba113c"},{"path":"research/r437-two-window-carrier/CANDIDATE.json","usage":"input","sha256":"0e4dc8bda7941b9c5bba2f7af9895544ca6f69666026e4835610b808c3d4d7f2","git_blob":"1479f765540ce3625e4909e59b40ad6f8c3621fa"},{"path":"research/r437-two-window-carrier/HOST-RESULT.json","usage":"input","sha256":"000837b2b7a1e9d7e4b6b657a055c6f5f3886c7ea343239f8620f79d5d7b2ae8","git_blob":"ee0952e10f744cf1c6d9c237006ccae4ce3c36c8"},{"path":"research/r437-two-window-carrier/LOSING-CONTROL-RESULT.json","usage":"input","sha256":"10fde408da0c4aa44b3ec2719313a6a5be49fedbf61e290c04cea9aa37aaa4ca","git_blob":"295681b3b3ac36cafc4f261dc708717ae09c5491"},{"path":"research/r437-two-window-carrier/LOSING-CONTROL.json","usage":"input","sha256":"c7c9ae2fe5e336ef17892a630b947b6638b7068c74b6881d75f51b0e019a5d8a","git_blob":"49206cf3419a9b0347abfd615fee1b61089f11a0"},{"path":"research/r437-two-window-carrier/README.md","usage":"input","sha256":"ede0403964aafe33022999c583bc6debafea033bf46d7f98fdaf559b841e4e99","git_blob":"26001b13570d3d7b7e5ddeb4ad3f328bac8e201f"},{"path":"research/r437-two-window-carrier/RESULT.json","usage":"input","sha256":"0dfeae97f64845c799857ab5ab0d83b61251b8bae52be269350c168f03c6aff9","git_blob":"52fa337d99268879a82c5a69b7d3d318fa933a7e"},{"path":"research/r437-two-window-carrier/RETAINED.json","usage":"input","sha256":"da91a8207025a4e141b7fd24a2511dfa0ff7d837b0a5d257599d44b9715747dd","git_blob":"3fa87fc722c6b7c4353a3965e64dbe2d34fade38"},{"path":"research/r437-two-window-carrier/SOURCES.json","usage":"input","sha256":"e5822ba1b619af70e55e88a0b4bf81eddd8497bc98b5aac7b00c9d6b63b64bf9","git_blob":"0839f4876a67fc26084ae94d832ccd69d2b5edb7"},{"path":"research/r437-two-window-carrier/TASK.json","usage":"input","sha256":"5e14a6a0845b700bd39fb0e1b4514e39a01ff2932da7603ea224fef61fd2e9c4","git_blob":"b719602c3f0316fa33316b6eb143c03b5aeb101c"},{"path":"research/r437-two-window-carrier/VERIFY.json","usage":"input","sha256":"16318771c2ad8a1d13d9f209262e5942290fde9678a7417440b6c3888deec456","git_blob":"1e4dc59c4c6da04bea7aa6300dd47246c3cf999c"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-000.bin","usage":"input","sha256":"8e00d476dfe58732a897ce3137f4b1a2cf49d385b1bb4789031f0ea3c5696aaf","git_blob":"7f01aa7eef382501dfbaebbe6482e944fa814d87"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-001.bin","usage":"input","sha256":"32a7c61c62f418407bce7253ea86985ea189ff43e6f1aad14edb443d03885bfe","git_blob":"decd96a65dab997d67783c52b7668f758a6c115a"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-002.bin","usage":"input","sha256":"aaa622ea2195cfd77e9fa2416725e4e97c035dcb0edfc82a5f3adcccf58e22ca","git_blob":"6ce96e8a18486b1ca4467db9947a316979591dba"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-003.bin","usage":"input","sha256":"02305f71a9be6ebc9e5a28e07485bd174262879654f0cfd6273aac88acca56de","git_blob":"e4514d27f5968bf82cb0f2ef81fd19ec1df1444a"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-004.bin","usage":"input","sha256":"0f2764045d5f041055e7adb4713df81a67204d60360633c26af85c0493edb9cc","git_blob":"4021fe43bf1748eac8b49790395a5e3f4caf3012"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-005.bin","usage":"input","sha256":"5c88efd13b31b97af68ef967fc6cee1e8d2e7925f89169e67f960ad5b7c0f2d2","git_blob":"f1ff26b3a20cba0b1ca2b314ab3b8c1dbba54291"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-006.bin","usage":"input","sha256":"51d679fbcb5d567d8574912e5a985f941d020c4612f878db8a976cd01b39c8cb","git_blob":"35aafc44c709e257caff7eacb8dcc33ac665a1a1"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-007.bin","usage":"input","sha256":"8c851cfbbc582b1f27f0d1c8ea8c32a4f48513f8e09ed0924beb643f4e3e4eb0","git_blob":"63e0755ffab1b56b0ea9bfad5bba51f73dc57480"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-008.bin","usage":"input","sha256":"25752503f390e5109e248d99fd9806e11c4a12158d99db6a5263b2a2ff2166aa","git_blob":"9bdc1c8f54034f70fd690a7603d2d566992165e1"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-009.bin","usage":"input","sha256":"e205f9bb6d396498a44f6cb4b1117efe4c5a22543bf83b11bafb9d1902fad992","git_blob":"8cdea621dccfae68a817b53ba591ec99e0202ce5"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-010.bin","usage":"input","sha256":"40bd7ba4fd1d4c96b035ee8984be3e023fd8b4d5bf270b636bd3256ebef17447","git_blob":"f2f158a0ac596eb63668545911fee6abca3a25b4"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-011.bin","usage":"input","sha256":"940a13dbb1c55f9acf6d28fcfd400ec615d911ae34c729604b29173cf66313f0","git_blob":"a93e192962aaa697c41a8443dd2cac27d5de6a73"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-012.bin","usage":"input","sha256":"1836611a68633b2db8422e20f9a4d8e16949f0c402893db2737dba4dc4f34e41","git_blob":"db181442703c9a61e66c3ee7022b7e8a7d95416c"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-013.bin","usage":"input","sha256":"77bb5447b15aa1e4892425a23ec2737d91b336f4e73acc64d1d4e68528591c73","git_blob":"854c9c7cea86c1251abd6c188443e359d5e75c36"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-014.bin","usage":"input","sha256":"10f6ebc9118d5d42b7df6b611ed8cd9f4e0adef0c50e99859232546737bad87f","git_blob":"aec64554648edb5f9d8c0a0e50d7d88f90b63b05"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-015.bin","usage":"input","sha256":"5672528cce227615c61ec77545199683112486ec428af6b755664da9363dfae1","git_blob":"a1d264f85dfa54cb1ee31d306bbc75a433430161"},{"path":"research/r437-two-window-carrier/candidate-template-chunks/part-016.bin","usage":"input","sha256":"62eced9b9817294528a442297cde0bc880a7698e463c94e71f1ee91f7c04e2bf","git_blob":"d059e02425f35313a2d4f94f6a7ff1ed48e62171"},{"path":"research/r437-two-window-carrier/host.py","usage":"input","sha256":"df01e61dc31a1cb6b2bf3549be1e2241f7a30829c2c98567f462271e3fc216ee","git_blob":"2cb9b22890fdfacea4ee51a75b7746dd35b78489"},{"path":"research/r437-two-window-carrier/inputs/LICENSE","usage":"input","sha256":"c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4","git_blob":"261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64"},{"path":"research/r437-two-window-carrier/inputs/OQ4-EXPECTED.json","usage":"input","sha256":"67d06bcb90d2307a11975d6b25107a695be477f168f2dc289b8484ba0b7e2de0","git_blob":"bc2585e1404402395a7c59ba6f6dde58b04e65a2"},{"path":"research/r437-two-window-carrier/inputs/OQ4-TEMPLATE.json.gz","usage":"input","sha256":"6e03c76f5a4227394ea57e901eb7e93f4d1ee411ccfecd483fd44ea043550494","git_blob":"f56efc7ca3648d2070b791d4551a3d77dd7fdde4"},{"path":"research/r437-two-window-carrier/inputs/R437-COMPOSED-WORD.json.gz","usage":"input","sha256":"e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e","git_blob":"c558a221dd44cbdaa732a401f9876de4c096d4a7"},{"path":"research/r437-two-window-carrier/inputs/UPSTREAM-NOTICE.md","usage":"input","sha256":"8ed83f2f0bde43a41e44279f44d29efaeae3df44850b86f0e3578edf3ee104e4","git_blob":"9b519b904d456b0b5861f7469a66c365e77799a6"},{"path":"research/r437-two-window-carrier/test_package.py","usage":"input","sha256":"c1fe16dcc1207cddc855eb0be2736a94e05b5e371a7d4c8117fa6dfcf9741d7a","git_blob":"37789c0494949572011dbb7049f5e61eca76b3e0"},{"path":"research/r437-two-window-carrier/verify.py","usage":"input","sha256":"0e972da66ef57955b28f371dc4f958a5ad61d42e037b110cf1f3be1285dd4523","git_blob":"49fe8d80c041da0c8d3e1dc37dff15b5e8c4cb9c"},{"path":"research/recursive-parking-boundary/README.md","usage":"input","sha256":"491aa208391ee4c2936510b1a5c5c018dd5509d9a0e88687c72ab8406cd77b18","git_blob":"251f335ebaccc11d69393ee7aeb5a2e84526d0bb"},{"path":"research/selected-bit-local-ring-sweeps/PROOF.md","usage":"input","sha256":"846c59440cc99e28bae93ad2af99525bc769de29368080071b8427141215b4f7","git_blob":"4330de85dd9862ed15d84ab917887d249753df99"},{"path":"research/selected-bit-physical-caller/PROOF.md","usage":"input","sha256":"e5a827e93fe313ba9bf4a2e300bae01b58b28004aa8a8ee119cf6d950edd9f93","git_blob":"548ecff3ef79a32c14bafc7f2309781181d3c23d"},{"path":"research/selected-bit-physical-caller/README.md","usage":"input","sha256":"989ad891ce3f866c920a25e0cdd661815f982c4c854370f8c00668eaa15d770c","git_blob":"abd0edba96101a025609d2840c3dbdf4d3e30aa8"},{"path":"research/selected-bit-physical-caller/RESULT.json","usage":"input","sha256":"de6216b9f89f22b9602867776a7fc951ec558c852e6abd4624151e95d868af56","git_blob":"44afaf8dca8f76b3c9f5ef58616b6d57ff7ff2f3"},{"path":"research/selected-bit-physical-caller/SNAPSHOTS.json","usage":"input","sha256":"c7b3485bdae5ddf43166cd6626bd512816e179617a4234c36584f6c57c34744a","git_blob":"034836cfaa3e4f984e900a980eecc986ec405b1d"},{"path":"research/selected-bit-physical-caller/SOURCES.json","usage":"input","sha256":"94e1f55094bbd122e4ee73413650fa24072c392d53d257041cd5d38a2269e4fd","git_blob":"a27291a91519f9f4e074712afa3262c4d372aaaf"},{"path":"research/selected-bit-physical-caller/TASK.json","usage":"input","sha256":"84319cb2f8c7c121927123e8c3271c3ec4ec93fc9be362dcfdf7ee4366cd1a74","git_blob":"28b8d5e1cbd29824e702d384937831ddb3876da7"},{"path":"research/selected-bit-physical-caller/VALIDATION.md","usage":"input","sha256":"c38eaa31a9cf3489356f2e2a675e2bc6194fa41796589edc9cbd8578b5d71c0f","git_blob":"5b1a9221f35cbd637183282489e8eeaa30314ea8"},{"path":"research/selected-bit-physical-caller/VERIFY.json","usage":"input","sha256":"5bb3cf67018f35de5b825c9bb4b7a6590296da85f492ba3dbff7a6ce9bdebf8e","git_blob":"682809777271adfe08df6e6ba2fae89571420212"},{"path":"research/selected-bit-physical-caller/continuation_checks.py","usage":"input","sha256":"c6ef8fa86a7099af0eb6763a3f5bd43f8f94e1e176cfba38c0077b3e0f5fda48","git_blob":"f2be8aad16e279c0d1467e21d79d2dd81dcae8d8"},{"path":"research/selected-bit-physical-caller/frame_checks.py","usage":"input","sha256":"ced41d9244afcb5275ad5c46dc0f60265afc1e6422d29b277364e945825c4dd8","git_blob":"4b992ffcb0a613da54ca24e31d25e61445799e10"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/EVIDENCE.json","usage":"input","sha256":"77b7cbefa2ca30acf2f77e23d14808ccd27848e9c76e4c5e68a045ef7891a07f","git_blob":"c2c347abc2b8c19bb642c4da1aad5b3e8383016f"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/PREDECESSOR.json","usage":"input","sha256":"e3127475913d62dbdf1b45d9283d2db2e9b689e0f81a703189150c1e5be2bca0","git_blob":"56d76c357b51f4fc6856923222bfca47f03334e7"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/PROOF.md","usage":"input","sha256":"552fa306d5cc228f4d8d8553f8ac5fc6a738ef2b66a2cb765ba0638cd229794d","git_blob":"1a08e57eac2a37764066d31baa3ecd3769759158"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/README.md","usage":"input","sha256":"6ce41fd7e6dfbe5faecc25bd36561f0a65b6ebca6fc69d3fb72569424a405045","git_blob":"75461632856f94d6b48ae820cf5d0b2b232305c2"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/RESULT.json","usage":"input","sha256":"4919655bae2e5cff051e8f2d240a8e4ebb03392a9da2fb5328daa9248fb7e88b","git_blob":"75faec7844e18fc7c44543dbab87aba2ecf32b3e"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/SOURCES.json","usage":"input","sha256":"7c78f539078e1bc3d893b78b5ee24cb22dc090d3763fe554e861b6c3d3e7eaf7","git_blob":"ff8c8e36176aa56e319d0f9e584167ac21d67f33"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/TASK.json","usage":"input","sha256":"ac7d4b38da31b373e665929027fc04afb66c3e9aedaea3296e3783637912d0e8","git_blob":"d70ad317275d2a517ab1294ce48ecb1f83dfedbf"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/VALIDATION.md","usage":"input","sha256":"ac0f2fab0ca810ce0202d31480daa8329cba0897ab015520a2bfd4b689c4086b","git_blob":"d91680665a28c12c27c99336b55c3d5341dd0fe4"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/VERIFY.json","usage":"input","sha256":"6ad0e07f68458afedece927550655b5bc5cd9861a70044fcd95bb10a2179f0a6","git_blob":"b6072f66c13a38b5d8dff3ca3bc5f3f3562f1b6e"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/bootstrap.py","usage":"input","sha256":"eef1c418e8edbdf317d159683e30beaecd971c77cf41d6b09708576405e2141e","git_blob":"448c9b3a86eedb84220646ab27ff089a32ad5b9b"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/check_layout.py","usage":"input","sha256":"454b1587d1ed5ccaea19b621a67e2ceba999d7ede61188125faa41c4dd2ab2b1","git_blob":"be59d614d25961f891e1640bf85cf5e2f474a059"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/check_nested_model.py","usage":"input","sha256":"b1941b882b0659722c3c41994c82f020c1f7ab320dc28c43c2758029ef8a48b7","git_blob":"20fed6bd389cb53fc52d0ad8389e9e7704c90265"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/check_recursion.py","usage":"input","sha256":"dde82badf043e553bc635a34295e2b5505d84d6dfbaf96e0cfccb8a8c3dbb158","git_blob":"8f36c88e196cf5afc0d6e227ba8568a10bb23c6a"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/check_runtime.py","usage":"input","sha256":"9fcf0c9a3c84a17446fafe8da50b63db296ba9465d48ddb6fdeac8742dfc98b1","git_blob":"fe355a703475325bca4807b8ffedfa9f6edb74f5"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/check_sign.py","usage":"input","sha256":"ee4fd34acd49962a18d268aefeb20aa3c2673a10e7a43eee3e51a9bd3cf9106a","git_blob":"50669949a1325e8c49aa0ff714c40a50077b5eb8"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/check_sources.py","usage":"input","sha256":"1c49984ae6ee7f8a44cde16b51e486f0b3ba4ee5c973389ac8d58a82d0a0aa3b","git_blob":"5c09a13943070a3bb3c0da06fd19fbc6916d1743"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/consumer.py","usage":"input","sha256":"2f2a8604c23fb2c81f24320c71ed0142118d98dde3be6086adad28e89954a777","git_blob":"a66d9276f829ce2c619871866816649d5f3687fd"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/control_checks.py","usage":"input","sha256":"c09d33327932b4ffbb8acb26c8a6bb621bcca542157d22f1edf72679a9359981","git_blob":"11daa0b2221c5870d19ba2eaf411a6bff3a0398d"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/driver.py","usage":"input","sha256":"ceaf8f75de9810a05ebf8f65780b6f8bd7599a5768401d5e4386182afe615cdf","git_blob":"5b7846a70aada53d87480b337e1c04217118771b"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/evidence/NOTICE.md","usage":"input","sha256":"fd7c42e89878cda6df86dde8720ece34625a337cf5edd795a421e2d3b42919e9","git_blob":"d0318d43ed420e21dc52166a19de703aa87fbb3e"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2688-NOTICE.md","usage":"input","sha256":"c899fccf7bd32397f0ddd85e4af35a166cefb3e3ae3407ec40edc3ab2051b617","git_blob":"f2b49cdef83a4a685fad32c01fba93e12cfcb5a8"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2688-PROOF.md","usage":"input","sha256":"fa9bec0952468e4acb760a88d45d5be216325650e1a4080cf590e07b90c9f533","git_blob":"1395e1941863e40ff6d62dd91c41de2cb56edae9"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2708-README.md","usage":"input","sha256":"5906f6b7b2c8eea90e441476c4cbd60fe2ef981b690c63357bcfe67e3104aeef","git_blob":"79b8742f32b4ffb991f91ddd2d3c6be693084e6d"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/evidence/pr2731-README.md","usage":"input","sha256":"19683df4394de299cbd7e1cce39bf9434ad260b1a37006587cf9aed84c9c0a03","git_blob":"ac5b826f9c34e1faadc5d5a02d5d260823112078"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/layout.py","usage":"input","sha256":"3beef6534b02c3b011b741f957a7d9fb05a9ac0bba1fed53b2c71834e4ea6bc1","git_blob":"aa554b14fe0f6b308d9fba0a2afc92e5a28e20cb"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/linear_sign.py","usage":"input","sha256":"73e895fc701a4145cbe89d60f5775128354e7f08d0a45eacf22f423913f54e67","git_blob":"6a6e5c02f299fad8c4f7ab724fc36e14a22ab13c"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/node.py","usage":"input","sha256":"0bd4f640cafb5c8f070c161d86445910f77578a672bf5886936ed89e7f6bd21b","git_blob":"28c98a3573b458f7a055678d70b602b80e6e959e"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/packet_engine.py","usage":"input","sha256":"c80fc3aa9092f91cc309b2fb2dbc3618bf96bdb9b8498503993ea161f0ae2134","git_blob":"72543f684f38fefeacc2ee66d81661f1a2439cf7"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/peel.py","usage":"input","sha256":"8b20888f74b4cd814a97b42ec72528fbfb6d2e936c5022df726f0785d0d01a2e","git_blob":"38502515afc928082c849cd2cda8578d33a5050a"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/NOTICE.md","usage":"input","sha256":"c446b32b8a621844fb2fbe654810c8122035bdd43fed2132f1137d98cb6f9943","git_blob":"ef9f81510db86eaf2f0a7191d85e92a6db30ddc0"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/PROOF.md","usage":"input","sha256":"88754d57bae35a2089d9de221ff32ba802b7a56b810f96271f3ea36985edfb14","git_blob":"a4746d1786f41e45a36fdedf37966b80fbab3562"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/README.md","usage":"input","sha256":"15631eb826b2d8d54fbee18fb6f70ee035e172d524c2a209b6c467c3f0204f64","git_blob":"988ff622029aff49d7e99deb2468684d904bc852"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/RESULT.json","usage":"input","sha256":"0d94c5e9150f3fbd603526c67ea33168d3ba45e158aaf722e848bf5c316a37a8","git_blob":"7b7dfe0eab22a7b511483f268b97a7c707fd8b90"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/SOURCES.json","usage":"input","sha256":"1b02a5c607a5967948988c3beaf37d9975d650ad501a99fcf74c135dc1f05fdd","git_blob":"4fef1a4d6c2d5e2620d3506d6032f9226870ed39"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/TASK.json","usage":"input","sha256":"a4cd54d4b09ad12a90a5feeb39a127f0f0d5a2a04f9f88554c5fc3ee0cfe77f4","git_blob":"eb2ce7cc00df816daf566f101d56a0330852c1d9"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/VERIFY.json","usage":"input","sha256":"e1dd0ee5f267ffa515bb345054ff8637cfedb0079b0d2da29b90b7848264926e","git_blob":"69c7ad75abe494be386f73a5d51359b9053cd9be"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/cardinal_counts.py","usage":"input","sha256":"59ddeac102a0cc51fa49b15aae6aeb68cd68ed217fa974ce916372a177d2ec8f","git_blob":"6a14feac45094ae9156e8c2c982d6727544f180e"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/catalogue.py","usage":"input","sha256":"83ea88f82d4a83c5f889774bfe3519b7ebaa24b6a0e2a969dafff012107a89bf","git_blob":"0efc0575a7623ac41c094d2e8772beda5a9fdc29"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_headers.py","usage":"input","sha256":"a41dab0c487c341eb32b34a03af74454e15e9e61e7386a1ca426d83f3b68b1ca","git_blob":"1c372b19e19b838a89c0e64daeda15ec6b49f079"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_layout.py","usage":"input","sha256":"8f776a21dc0e31f9738d822cfda38db92f1e3672afb880d4246ec5e084a50a41","git_blob":"174d843716a684145f934cb55a612bca85aad725"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_runtime.py","usage":"input","sha256":"5357e4ff255f17c4209aaf71a3413a4148475f11180c4f829e8f0ebacd2877cb","git_blob":"5647693b3a5c1555b65e281c6609f98b92d45542"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/check_sources.py","usage":"input","sha256":"6463c2724e04a313181b78e90a17cd62ee42465754902cca3e9a65c6140a15a1","git_blob":"9219cdf863d9f060d6e38a4f2f4760fd227af003"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/consumer.py","usage":"input","sha256":"b28ec97b0873ff2be25aff4bdde268247ffcec0d21279d0ada196de19a0bdc66","git_blob":"24b53521fce94d3349072cf47d70e62195f4d541"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/control.py","usage":"input","sha256":"d3a93e54bb7d333b73917586407d11674d38b5c3fda4fbdc436fb5293ae7786a","git_blob":"4f6ac09bffab43dbccc470bd0bde2ffbe969a8b2"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/control_checks.py","usage":"input","sha256":"5ea6ded8c2508fbb00d93655affdfe7907ffb60916389e0736249c003a7a5148","git_blob":"712cfddc4caaad9e788d97b0e1e3f623172c43ed"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/driver.py","usage":"input","sha256":"ee9e42fe95ab28fdd5e927c2d46fd480305aaad610eb2ca7ae514a5d22d9f0ac","git_blob":"0bdee4c9e348259b470a636a98e7657770f97fae"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/fresh_rows.py","usage":"input","sha256":"e4ae08fbd658add630eb7754ebe0cbcb42c6f39cf4128f9cb92e27fcf5213a7d","git_blob":"aa3a327604308d3a5c7a27b65f5e631d430ab093"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/layout.py","usage":"input","sha256":"7534b0166805f2ae8d11495c811d2bd272cea89c89b6bb5251fd411c89245a20","git_blob":"267d5ab98cd013ee82ba75e6d41609f1778af25f"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/model.py","usage":"input","sha256":"c937ae8e46162f88fc1cd7646d3b22c99273029ad0f0e3131f46ddec230676cb","git_blob":"9fb82fa57d29cdf8402f91534dffed8f586ced6c"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/node.py","usage":"input","sha256":"b88fc9ac0b22d939311ff4f7aff788e8c87a64fd5e866498e59bd27940ee3f28","git_blob":"13badda6f059da2132cbe325c071307e5191baa3"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/packet_engine.py","usage":"input","sha256":"ce7f132a6a69c802406f07c4a2119ef921e8978520ff58d5eeaeedb982c257f2","git_blob":"27a0dbf82e78252beede56ff86f5933c93eb55c1"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/peel.py","usage":"input","sha256":"3de018e68601566c364c7568b110f60c1bf34941b846cdffb94401bb799f85e3","git_blob":"2ae1769a9726ab738d3981891d0b76beccac2d99"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/topology.py","usage":"input","sha256":"384d456ddba76de137a63b50019d5bba2e9f6daa4177c91643e0565d4cf1d44b","git_blob":"39a2916c207d04be5efc44750d8606f5da0c2990"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/binding.py","usage":"input","sha256":"20169a8af6ed2b34069fd353a2bc1c42335ab686c58de8479baef33dd3fb493b","git_blob":"21a5a21220a18ab62a19ac403a9944bc3a8665c8"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/bitstream.py","usage":"input","sha256":"f78bac9641007dbd8824984edcac057274fe016ce78bd9cb512d0c0913274783","git_blob":"4d1fd4abb0f2aabe833e5cbc9efb51039739e7ca"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/cardinality.py","usage":"input","sha256":"505d5e560c5a507e6184edcc19a87cf1fed243eb34a5cb21fbe1e4fe017e7f22","git_blob":"b8ba857e32c5903408e1e61ff916300848b4a208"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/check_support.py","usage":"input","sha256":"d9977e87ddc5acdb836b8e4a4e3942da17a05b04ce67c04547d17b986b518964","git_blob":"e1f961df9fa3a441fc5b600d1288a8d038eca51e"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/children.py","usage":"input","sha256":"a78866939631214c1d1659203b2b5fc062e3c6255e9f11f975c310046b010bd6","git_blob":"ce4935f838516e2b08d13bec767cb803786fbc6b"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/controller.py","usage":"input","sha256":"fa09146991f6c04e6f4b6eb9bf0c8e103e70e90a0e402ff3d69814e6aac8ff8c","git_blob":"c631a9e77fbcccf0e8f448adc22978728aed7b60"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/counts.py","usage":"input","sha256":"00b476dbda0e8cc99886bf794439e1cb9e775f435f599a3557e99321fe084069","git_blob":"81b48940ce222290a40d4fb349ce827f4788469d"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/directory.py","usage":"input","sha256":"4270e370b2bfe38ef73aadcd97d1b3496b56bd582115d74331eb9e5ceb90bec7","git_blob":"c74cacf5ce809c0561d374f137a52df0992b4226"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/episode.py","usage":"input","sha256":"38f79cb2a370548471063952d5f7c74bd795a2a8496fdcf3ce0996d79e3adaff","git_blob":"30d11ff4f333813855d36da3eb5a1ab0e154bafe"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/forms.py","usage":"input","sha256":"1fdf9d31b7eb107c396e33f94dad61c9d3f2c709cae61178268a44ca80dbc0b4","git_blob":"6667c0b772a63f0059c7caffec63e0d919a92398"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/low_codes.py","usage":"input","sha256":"f657e17f6088c840e3f7783e662257630f6d2c1e71c217721ffbca4d6ac93e87","git_blob":"737edfc4a10f4b7b3b97a7cef4b40864efd806e6"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/matrices.py","usage":"input","sha256":"00b687434039b54529ee092e34f9435cfcd66e0816eb3bd2a6688c73f4e01459","git_blob":"5d497353efbb9eeaaf4facd96ab40ffb0f3aa20d"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/numeric.py","usage":"input","sha256":"7327b05c4ec3e0f6d9c352cc7de85bfd4ebe940482553e77c59a773a8c09c514","git_blob":"6d4ebca8398008375b8f4762d1a9f1514e8c2611"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/oracle.py","usage":"input","sha256":"7bd18089e32ce48085b5e3a75159f6a82cdb2649ec682c53db05e399d97aef67","git_blob":"244f131466698a3ace10b657242fe1f65c07fd1f"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/packet.py","usage":"input","sha256":"970e7fe0719e3dfe122b248941e6f21cd90d7dd62089fa6acbd0e5412ce083a5","git_blob":"ebc9b616514412b80c56d523776e6ba5d6766453"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/plan.py","usage":"input","sha256":"d9c8dc93762db4d3a449814aa51e2211460648694469854d89cb48cb04188cf3","git_blob":"48255d5454308c07635fae4e7eb4873b0bd2a4f8"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/records.py","usage":"input","sha256":"0c9c4b23e998597fb877bb1a29da69ac869b68262abe635b162b4dba9c69b372","git_blob":"4f00467a0ff580954ad2fd0c7380240c753ddef3"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/residual.py","usage":"input","sha256":"8fd24747cae498dfb2ba333e7f8a68d7315ae4c2d7530d8ca145aab95ede21df","git_blob":"3d070d2539a529f3b14ecb086a92a3db056229fe"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/routes.py","usage":"input","sha256":"ed7dc3679451696ab1dd841146b215c9515a3eec5e4ff3763f33c315f1696ada","git_blob":"35531201dc349a811dfabc6f1f6e64697d665194"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/selection.py","usage":"input","sha256":"bc8e371fb1fa0b41fb05ef0b34d0f4c317b2396f9833d91f44f95c2b54b4052b","git_blob":"2c28f1aaec104a75c4e6c170b3e6a60300ee6700"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/sources.py","usage":"input","sha256":"f102edc7816d742bd89db8097254c19b843d0ef5cf6758ad42e93bcc0b214c62","git_blob":"16d5e7e6a28018f1e2d76d61efe2d54f6a6941d4"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/stream.py","usage":"input","sha256":"c7dc7da5b00f27016982ada4c0416f8328568b00df16d97012f33d4b372d79b5","git_blob":"5e5a4bb0f98971447043e25d4dd6991bfc070389"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/stream_runner.py","usage":"input","sha256":"751c5023ca0e477369e448583961ace6a76db2723bb6c26f81203def539f1249","git_blob":"efff281d4c4be5c1378e31404fbcc634fe4ade59"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/trace.py","usage":"input","sha256":"c71ba11d793dde2ac6e4cdcf468482872975c34589bf1167f2a460cb8a74e984","git_blob":"bb845a90f5bcf006e683e581e385936208f6a1f4"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/vendor/words.py","usage":"input","sha256":"5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9","git_blob":"8d4ba37e2778acb35b34e0719df2caf138fbeb50"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/predecessor/verify.py","usage":"input","sha256":"cd83797d1f420f7e5de61c1a693110b4ee0c80bac0adae4699599046b7f76f8a","git_blob":"121acc1ff15ec85a8011e96eda2eb587608413b9"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/recursive_call.py","usage":"input","sha256":"157deaa5972557893d43494a81151483bdc46373448ec677cb6a738c9b7e6f1e","git_blob":"6d33224145aa04f7fbaf7b6cda7c9c164311a402"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/scheduler.py","usage":"input","sha256":"0d96f7fbd6f90416167c5a52c0e3de942d1a0cae3d2968831932a9576701699f","git_blob":"60c2b6d065eba91dd5e0edb7a77fc087971eca3f"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/stream_runner.py","usage":"input","sha256":"b255feaf6cc6e40413ae73fe302bf8f290bf4dd89f4128b23a91cc9860601801","git_blob":"6ba5df130bb4a0fcb06b6c630830ae3a6922921b"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/trace.py","usage":"input","sha256":"3a664224c558244f606b603cad816d75e94a17c9b2620a06a1530e893dfceac2","git_blob":"4b002201ce54cdecec9acf4e874b7f71cd75fe71"},{"path":"research/selected-bit-physical-caller/inputs/pr2753/verify.py","usage":"input","sha256":"65126e788eeea10e830fc583cf4afe0bfc4d67495cbf8ac21de3507dbe624d56","git_blob":"96be8f5859a3f3799344d46dec1ee68170d96bfa"},{"path":"research/selected-bit-physical-caller/inputs/pr2769/NOTICE.md","usage":"input","sha256":"8640d1b52fd21e5b20e8109ce9c4957ca1e19a95e26a1c80d019a6e6f4d5f178","git_blob":"307c2da733f7f3a76e97c77e71072e811f40df02"},{"path":"research/selected-bit-physical-caller/inputs/pr2769/PROOF.md","usage":"input","sha256":"fc9e7dcc5b385b6e508d6a6e9524b93059fa3e9fd5fcfb5eedbd85b3a54ba55e","git_blob":"7207ce7dec86694f01a3d9c049dcb87cc909e380"},{"path":"research/selected-bit-physical-caller/inputs/pr2769/README.md","usage":"input","sha256":"6550a466bfafff2ca11740e931ed9fce062eb488f23e74edff7e4bbae8282bb1","git_blob":"c96e0d6cec56a9a5579ae159456fc15767315bc3"},{"path":"research/selected-bit-physical-caller/inputs/pr2769/RESULT.json","usage":"input","sha256":"4406fec9515bb4206c75b681f046b5441319cf1ed39a13b9b0134696b1c192a7","git_blob":"b2d1889d77019e06ac0326ac91b1322340cf3866"},{"path":"research/selected-bit-physical-caller/inputs/pr2769/SOURCES.json","usage":"input","sha256":"a6476b786632c2cbffabbe27eece790e378996c8b03eb17a01f1094f20fc4cdf","git_blob":"746393061c55f47412601e3d346e914762683e0c"},{"path":"research/selected-bit-physical-caller/inputs/pr2769/TASK.json","usage":"input","sha256":"964d3a4fbfb53fd58936840328ac4b770b324c9e78f722861b1db04663110626","git_blob":"216dc8f8bcb33fe32d0eaccdadb0fe0383d73848"},{"path":"research/selected-bit-physical-caller/inputs/pr2769/VERIFY.json","usage":"input","sha256":"f9e252e8ab255b49c3b18d4db76cc09ebd9fb61d599305e0aca8bf295189028d","git_blob":"6537be05745836106c753e1388ffc8b1bd23ce4c"},{"path":"research/selected-bit-physical-caller/inputs/pr2769/checks.py","usage":"input","sha256":"98ffbd58881aa138b8dbae4d5722855ece2a5fdf7585e53978069ae9b064eb09","git_blob":"46630a7648b1c93530e9253872a19cce338929ff"},{"path":"research/selected-bit-physical-caller/inputs/pr2769/codec.py","usage":"input","sha256":"5b9fda8136f7e60bece54e3fcc74f4ea0bec7145fa60e1ae3a4d252741b81fd3","git_blob":"9cd54d9417eb685dcd3f8293f01299ef9046ad31"},{"path":"research/selected-bit-physical-caller/inputs/pr2769/vendor/parking_machine.py","usage":"input","sha256":"68134779debfb795468a1aaecbc2b9d321d7d4e451313ce7dc8fa7092561df4c","git_blob":"cafd614a3b7bc87b019361fcdf890ed976f26d19"},{"path":"research/selected-bit-physical-caller/inputs/pr2769/vendor/pr2753_recursive_call.py","usage":"input","sha256":"157deaa5972557893d43494a81151483bdc46373448ec677cb6a738c9b7e6f1e","git_blob":"6d33224145aa04f7fbaf7b6cda7c9c164311a402"},{"path":"research/selected-bit-physical-caller/inputs/pr2769/vendor/words.py","usage":"input","sha256":"5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9","git_blob":"8d4ba37e2778acb35b34e0719df2caf138fbeb50"},{"path":"research/selected-bit-physical-caller/inputs/pr2769/verify.py","usage":"input","sha256":"37f9e51e6c038a2493b4550e3cf0bd52621b6c20e115f0886406fc9909a82120","git_blob":"6be4f94eda9c96f4e7265a294f63e39309dcb0c6"},{"path":"research/selected-bit-physical-caller/loader.py","usage":"input","sha256":"4d8647f520b2967a0ca7dcadeb39d6ebabbce44df4193f609fef22911d0ae67b","git_blob":"4a0326c9af88626938645f288e559b5b97cb1787"},{"path":"research/selected-bit-physical-caller/macro_binding.py","usage":"input","sha256":"9ef31765d03d2c54fad9296f2ff0707a190ce169e44de4f0f45214e3c410c01a","git_blob":"c197eb6458be9374cb4684c654bfc99e619dcaf0"},{"path":"research/selected-bit-physical-caller/macro_checks.py","usage":"input","sha256":"0631b4d6b547a76d8ea4babd3465908b9efaa058503f8330140bcc8eb22a51cb","git_blob":"6a9226a647d095419840fd9d6696ffcef9827b0b"},{"path":"research/selected-bit-physical-caller/macro_code.py","usage":"input","sha256":"f626b018124747a5f17c1603bea36cd74c00a69a0647fd7b10e9c4e2964caea8","git_blob":"2f5f8ecfac6457171707b1b5ff02b5071954fcb7"},{"path":"research/selected-bit-physical-caller/macro_controls.py","usage":"input","sha256":"a5343faffadfdd9ea0e52d4c7c4ef24ba5e8d2dee86c8af27c094ad78944b845","git_blob":"b7c1d28dd47ff463df02ea97b5907a041c05bdde"},{"path":"research/selected-bit-physical-caller/macro_local_checks.py","usage":"input","sha256":"a9be60378d1282184632066b87cb044a8510b6623acf0df4dbf2f1bcd35cb830","git_blob":"421f9030f91f3ab309a9873928c09ba8a2ade580"},{"path":"research/selected-bit-physical-caller/macro_machine.py","usage":"input","sha256":"7bc6e42072a09a08ac961e05c3da01cde012d740d4b4c605f298d994f2ad7c5a","git_blob":"5a032e8923f7f8b22bb98f3e39b804beb9906c16"},{"path":"research/selected-bit-physical-caller/macro_selected_checks.py","usage":"input","sha256":"080e147837a4983a73e598af0cc97333e2cfb1d328f5190c9d4447a8bdbb4668","git_blob":"14f224e975fdd1a580088baf26e23ca44091a2f7"},{"path":"research/selected-bit-physical-caller/nested_bank_checks.py","usage":"input","sha256":"4c225e7d91c767b4cedcf9f9b5222875be948bf8b4ef03cedc4f46f1d570e9bb","git_blob":"c48f87429773e3b80719c209b4ad3f3977e3c41e"},{"path":"research/selected-bit-physical-caller/numerical_frame.py","usage":"input","sha256":"3fd62eda5d0b48bf31ea244708a77afdc6d16cf4fc9439d140ef422a38c7406c","git_blob":"dc92611dd5f131718806fa96470b8f3494e15e2a"},{"path":"research/selected-bit-physical-caller/residual_blocks.py","usage":"input","sha256":"ab7f3df8906decd2efecfb138eac1456c106bb520b2598761f699f80680d8331","git_blob":"fba75e7649cf77e352a75324495191bbd7853c22"},{"path":"research/selected-bit-physical-caller/role_parking.py","usage":"input","sha256":"1884a3c260d81d5efbc0c33d86a810d6728e55e5764cfcd423f858cc685470f3","git_blob":"fc48c244eefdbaa3e320e86c75a7d187cb5765ef"},{"path":"research/selected-bit-physical-caller/scratch_pool.py","usage":"input","sha256":"41f1eb93652b7174c3b02f95f70e1a9ce2e2aed0a729e725167c8f226e65d8db","git_blob":"0f22807c65d1bca374b905538512bf8c43702070"},{"path":"research/selected-bit-physical-caller/verify.py","usage":"input","sha256":"bfba14c842ea4d97bf160588abc061553d3e4eab66cd5f32b903e1a67e661aec","git_blob":"fbdc87b9f98dc7722db45a42a742c5569089eeeb"},{"path":"research/selected-bit-recursive-closure/PROOF.md","usage":"input","sha256":"74cc8de20f21acb5123fe2d20996fe0925ea6e51b3dec633bd5221fb719b3344","git_blob":"6c410cab5713979214a45835091fbeb9ee9b8531"},{"path":"upstream/build/sections/02-streams.tex","usage":"input","sha256":"606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab","git_blob":"088fceea1867abc76271d7efe7532b779fee9039"},{"path":"docs/research/agent-task-catalog.json","usage":"provenance","sha256":"352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96","git_blob":"64bfc5af6709ed9811171e0a2108f05e1219cb65"}],"provenance":"All declared runtime dependencies are immutable copies already retained on canonical main. Original donor PR heads and attribution remain in predecessor manifests. No frozen input changed."} diff --git a/research/r437-carrier-integration/TASK.json b/research/r437-carrier-integration/TASK.json new file mode 100644 index 000000000..340ac28ad --- /dev/null +++ b/research/r437-carrier-integration/TASK.json @@ -0,0 +1,94 @@ +{ + "schema_version": 1, + "task_id": "r437-carrier-integration", + "priority_revision": 7, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "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": "One integrated continuation of the paid two-window R437 carrier through fresh pooled request/source identities, actual caller interfaces, a named finite coefficient/fallback and logical stock envelope, and an executed local child/consumer boundary.", + "scope_change_reason": "Explicit donor continuation with a stricter significance gate; this is not a new carrier or root search. The ongoing #3985/#4015 native-history QQ16 stream is excluded.", + "bottleneck_link": "An already favorable rank moment becomes useful only after fresh source correspondence, numerical applicability and compatible caller costs are established.", + "budget_minutes": 60, + "stop_rule": "Investigate the actual necessary numerical budget before full compilation; no other carrier search. At most one substantial PR for a usable paid improvement, material enabling integration or consequential quantified rejection. Preserve an honest integrated handoff if no gate passes. Reserve final verification time.", + "outcome": "partial", + "evidence": "Exact all-request compiler and independent four-way receipts, all-prime projector/chart proof, changed prefix and source-width-aware reserve derivation, actual encoded preparation/child/consumer evidence with separately labelled production geometry and inherited physical refinements.", + "author": "Chris R (@Clear1nsight)", + "ai_assistance": "Substantial OpenAI Codex assistance from compiler, numerical, physical and independent comparison agents, coordinating review and a read-only adversarial review context. This is not independent human or formal-kernel acceptance.", + "open_questions": [ + { + "question": "Does the changed complete construction survive all physical tape, source-table setup and lifetime costs?", + "why_it_matters": "The selected complex-bound supplier and outer transfer are not changed by a local BIT improvement.", + "first_step": "Bind the new exact requests and all-size numerical admission to productive full caller and complete visited-cell/resource tariffs at both supplier endpoints.", + "blocked_by": "Retained uniform physical primitive/refinement, source/compiler finite-table construction time and original-root physical backing/time obligations." + } + ], + "freshness": { + "canonical_main": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "priority_revision": 7, + "entry_utc": "2026-10-20T08:13:17Z", + "live_dependency_heads": "Pinned source heads rechecked using GitHub; #3958 updated and #3959 retracted; no complex headline imported.", + "overlap_coverage": "Repository helper has no gh remote snapshot. Targeted live open/closed GitHub R437 searches and relevant source PR comments/reviews; public Discussion reads partial. No exhaustive novelty claim.", + "coordination": "Public claim was attempted through GitHub but rejected with403; in-app browser unavailable and Chrome has no display. Local decision record and proposed claim preserved.", + "prepublication_checkpoint_utc": "2026-10-20T09:01:00Z" + }, + "significance_gate": "B: material source-bound compiler/numerical/caller enabling integration, including a paid finite local Program-reuse improvement; global C/D physical bill remains incomplete." +} diff --git a/research/r437-carrier-integration/VERIFY.json b/research/r437-carrier-integration/VERIFY.json new file mode 100644 index 000000000..582e636f4 --- /dev/null +++ b/research/r437-carrier-integration/VERIFY.json @@ -0,0 +1,429 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "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-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-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-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", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Authenticated fresh compiler, independent all-DIRTY/owner/request/address checks, named numerical and checked source entry, actual produced-child/caller local contract and complete component bills." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Optimized immutable replay of the same integrated contracts and rejection controls; no assertion-dependent safety or artifact regeneration." + } + ] +} diff --git a/research/r437-carrier-integration/admission.py b/research/r437-carrier-integration/admission.py new file mode 100644 index 000000000..3e7586146 --- /dev/null +++ b/research/r437-carrier-integration/admission.py @@ -0,0 +1,317 @@ +"""Checked package entry: fresh source, exact parameter widths and compatible rows. + +This is a new package wrapper, not a patch to SelectedBinding.check_stock. +The named large-prime constructor replaces only exhaustive primality checking +by an exact Lucas-Lehmer certificate; every codebook method is retained. +All guard work here is host finite arithmetic, with no fixed-tape tariff claim. +""" +from dataclasses import dataclass, replace +from collections import Counter +from types import SimpleNamespace +from hashlib import sha256 +from pathlib import Path +import argparse +import json +import sys +import types +import compiler +import numerical + +HERE=Path(__file__).resolve().parent +Q127=2**127-1 + + +def need(ok,message): + if not ok:raise ValueError(message) + + +def prime_certificate(q, exponent=127): + need(exponent==127 and q==2**exponent-1,'exact named Mersenne prime certificate') + # 127 is prime: explicit trial division up to its square root. + need(all(127%d for d in range(2,12)),'prime Mersenne exponent') + residue=4 + for _ in range(exponent-2):residue=(residue*residue-2)%q + need(residue==0,'Lucas-Lehmer residue') + return {'q':str(q),'exponent':127,'modular_square_subtract_steps':125,'residue':0} + + +def load_certified(variant='D',q=Q127): + """Exact retained compiler with a named, authenticated primality adapter.""" + certificate=prime_certificate(q) + compiler.runtime() + original=sys.modules['low_codes'] + text=Path(original.__file__).read_text() + old='all(q % p for p in range(2, q))' + need(text.count(old)==1,'one exact exhaustive primality guard') + patched=text.replace(old,'certified_prime(q)') + module=types.ModuleType('low_codes') + module.__file__=original.__file__ + guard_evaluations=[] + def certified_prime(p): + result=prime_certificate(p) + guard_evaluations.append(result) + return True + module.certified_prime=certified_prime + # Executing an authenticated copy changes one guard; frozen bytes stay put. + sys.modules['low_codes']=module + try: + exec(compile(patched,'','exec'),module.__dict__) + cat,top=compiler.load(variant,q) + base_identity=cat.source_identity + cat.source_identity=compiler.digest({ + 'schema':'r437-exact-prime-admission-v1', + 'base_compiler_identity':base_identity, + 'admission_source_sha256':sha256(Path(__file__).read_bytes()).hexdigest(), + 'retained_low_codes_sha256':sha256(text.encode()).hexdigest(), + 'adapted_low_codes_sha256':sha256(patched.encode()).hexdigest(), + 'prime_certificate':certificate, + }) + finally:sys.modules['low_codes']=original + cat.admission_provenance={'base_compiler_identity':base_identity, + 'retained_low_codes_sha256':sha256(text.encode()).hexdigest(), + 'adapted_low_codes_sha256':sha256(patched.encode()).hexdigest(), + 'prime_certificate':certificate, + 'constructor_certificate_evaluations':1+len(guard_evaluations), + 'constructor_modular_square_subtract_steps':125*(1+len(guard_evaluations)), + 'source_identity':cat.source_identity} + return cat,top + + +def authenticate_certified(cat): + """Recompute the wrapper binding; provenance is evidence, not authority.""" + import low_codes + original=Path(low_codes.__file__).read_text() + old='all(q % p for p in range(2, q))' + need(original.count(old)==1,'retained exact primality-guard source') + adapted=original.replace(old,'certified_prime(q)') + certificate=prime_certificate(cat.q) + base=compiler.codebook_identity(cat) + retained_sha=sha256(original.encode()).hexdigest() + adapted_sha=sha256(adapted.encode()).hexdigest() + expected=compiler.digest({ + 'schema':'r437-exact-prime-admission-v1', + 'base_compiler_identity':base, + 'admission_source_sha256':sha256(Path(__file__).read_bytes()).hexdigest(), + 'retained_low_codes_sha256':retained_sha, + 'adapted_low_codes_sha256':adapted_sha, + 'prime_certificate':certificate, + }) + need(cat.source_identity==expected,'recomputed certified source identity') + provenance=getattr(cat,'admission_provenance',{}) + for key,value in [('base_compiler_identity',base),('retained_low_codes_sha256',retained_sha), + ('adapted_low_codes_sha256',adapted_sha),('prime_certificate',certificate), + ('source_identity',expected)]: + need(provenance.get(key)==value,'recomputed constructor provenance '+key) + need(cat.codes.q==cat.q and cat.codes.dimension==cat.dimension==64,'actual codec field/dimension context') + return expected + + +def admitted_compile_node(topology,binding,mode=0): + """Join the new source tag to the actual explicit-replica macro emitter.""" + need(binding.catalogue is topology.catalogue,'admitted macro source/native context') + need(getattr(binding.specifications,'catalogue',None) is binding.catalogue, + 'admitted macro Specifications context') + authenticate_certified(binding.catalogue) + return compiler.caller_emitter().compile_node(topology,binding,mode) + + +def regional_emitter(cat,top,domain): + """One actual native IDLE, full dimension, one low class, actual Cursor.""" + from macro_binding import SelectedBinding + from catalogue import Specifications + identifier=next(i for i,r in enumerate(cat.requests) if r.kind=='IDLE' and r.base.rank==14) + request=cat.requests[identifier] + region=SimpleNamespace(catalogue=cat,replicas=32, + schedule=({'kind':'idle','idx':request.stage},), + idle_identifiers=lambda child,replica:(identifier,) if (child,replica)==(request.stage,request.replica) else (), + idle_family=top.idle_family) + specs=Specifications(cat);binding=SelectedBinding(specs) + low=tuple(tuple(int(i==j) for j in range(64)) for i in range(64)) + handle=compiler.source_handle(cat,identifier,False,low) + try:compiler.compile_node(region,binding) + except ValueError:old_rejected=True + else:raise ValueError('old compiler silently accepted wrapped source') + original=cat.low_classes;cat.low_classes=lambda:iter((low,)) + try: + emitted,entry=checked_entry(cat,specs,handle,domain, + lambda:admitted_compile_node(region,binding),mode='numerical', + expected_key=handle.request_key,expected_common=False) + finally:cat.low_classes=original + residuals=[r[2] for r in emitted.operations if r[0]=='residual_begin'] + need(len(residuals)==1 and residuals[0].identifier==identifier and not residuals[0].common, + 'single actual native IDLE source') + tags=Counter(r[0] for r in emitted.operations) + need(tags['gather']==tags['scatter']==tags['clear']==1,'regional gather/return/clear') + need(emitted.operations[0]==('node',) and emitted.operations[-1]==('return',),'regional terminal control') + identity=cat.source_identity;cat.source_identity='0'*64 + try: + try:admitted_compile_node(region,binding) + except ValueError:context_rejected=True + else:raise ValueError('mutated wrapped compiler source admitted') + finally:cat.source_identity=identity + provenance=dict(cat.admission_provenance) + cat.admission_provenance=dict(provenance,base_compiler_identity='0'*64) + try: + try:admitted_compile_node(region,binding) + except ValueError:provenance_rejected=True + else:raise ValueError('forged constructor provenance admitted') + finally:cat.admission_provenance=provenance + return {'entry':entry,'request':identifier,'rank':14,'dimension':64, + 'low_classes_executed':1,'native_specification_good':specs[handle.code].good, + 'operations':dict(sorted(tags.items())), + 'old_compiler_wrapped_identity_rejected':old_rejected, + 'mutated_wrapped_context_rejected':context_rejected, + 'forged_provenance_rejected':provenance_rejected, + 'emitter_certificate_modular_square_subtract_steps':125, + 'scope':'Actual SelectedBinding and Cursor macro emission at admitted q127; one native IDLE, one GL64 low class. No packet/tape payload execution.'} + + +@dataclass(frozen=True) +class RootDomain: + e:int + n:int + w:int + h:int + L:int + I:int + Q:int + rows:int + + +def integer_receipt(n): + need(isinstance(n,int) and n>=0,'nonnegative encoded integer receipt') + packed=n.to_bytes(max(1,(n.bit_length()+7)//8),'big') + return {'bit_length':n.bit_length(),'big_endian_sha256':sha256(packed).hexdigest()} + + +def checked_entry(cat,specifications,handle,domain,callback,*,mode, + expected_key,expected_common): + """Validate BEFORE a zero-argument continuation may prepare/consume data. + + `domain.rows` is a host parameter certificate, not evidence that the giant + row payload was materialized. Semantic mode checks finite fixtures but + cannot set numerical_admitted. The continuation owns actual execution. + """ + need(mode in ('numerical','semantic'),'explicit entry domain') + need(isinstance(domain,RootDomain),'typed original-root domain') + need(isinstance(handle,compiler.SourceHandle),'typed fresh source handle') + # The fresh identity authenticates the algorithm and source bytes. Check + # the expected boundary too: another valid code is not this caller request. + need(handle.identity==cat.source_identity,'fresh source codebook identity') + if mode=='semantic': + need(cat.source_identity==compiler.codebook_identity(cat),'current semantic compiler source identity') + need(tuple(handle.request_key)==tuple(expected_key),'expected caller request identity') + identifier,common,_low=cat.codes.decode(handle.code) + need(common is expected_common,'expected common/native source view') + need(cat.requests[identifier].key==tuple(expected_key),'decoded source request identity') + spec=compiler.resolve_handle(cat,specifications,handle) + need(spec.template.rank==cat.requests[identifier].base.rank,'source/native rank agreement') + need(domain.e>=64 and 1<=domain.n<=domain.e and domain.w>=1 and domain.h>=0,'root/descendant parameter domain') + need(domain.L==(cat.q**domain.w).bit_length()+1,'actual canonical residue width') + need(domain.I==domain.e.bit_length()+1,'actual canonical root-index width') + need(domain.Q==cat.codes.bits==(2*len(cat.requests)*numerical.gl_order(cat.q)-1).bit_length(),'actual complete codebook width') + quotient=numerical.check_stock_rows(domain.rows,domain.n,cat.q,domain.w) + if mode=='numerical': + need(domain.n==domain.e and domain.h==0,'executable original-root entry; descendant path certificate required') + # The only large-prime executable certificate supported by this package. + need(getattr(cat,'admission_provenance',None) is not None,'certified prime source constructor') + authenticate_certified(cat) + numerical.check_root_domain(domain.e,domain.n,domain.w,domain.h,cat.q,domain.L,domain.I,domain.Q) + numerical.check_fallback(cat.q,[spec.template.rank]) + value=callback() + return value,{'mode':mode,'numerical_admitted':mode=='numerical', + 'source_identity':cat.source_identity,'request':identifier,'request_key':list(expected_key), + 'common':common,'rank':spec.template.rank,'q':str(cat.q), + 'domain':{k:getattr(domain,k) for k in ('e','n','w','h','L','I','Q')}, + 'compatible_rows':integer_receipt(domain.rows),'row_multiplier':integer_receipt(quotient), + 'stock_certificate_scope':'original root' if mode=='numerical' else 'local semantic rows; no ancestor stock certificate', + 'guard_before_continuation':True, + 'entry_certificate_modular_square_subtract_steps':125 if mode=='numerical' else 0, + 'guard_implementation':'host finite arithmetic; exact source/parameter guard, physical encoded guard tariff open', + 'production_payload_execution':False} + + +def run(): + cat,top=load_certified() + rt=compiler.runtime();specs=rt.catalogue.Specifications(cat) + source=compiler.early_source87(cat,top,0,0) + low=tuple(tuple(int(i==j) for j in range(64)) for i in range(64)) + handle=compiler.source_handle(cat,source['identifier'],False,low) + domain=RootDomain(64,64,2,0,(cat.q**2).bit_length()+1,(64).bit_length()+1, + cat.codes.bits,numerical.stock_unit(cat.q,2)) + reached=[] + def continuation(): + spec=compiler.resolve_handle(cat,specs,handle) + need(spec.good and spec.template.rank==2,'actual admitted SOURCE87 good native specification') + preparation=rt.catalogue.oracle.reduce_rational(spec.template.preparation,cat.q) + inverse=rt.catalogue.oracle.inverse(preparation,cat.q) + product=rt.catalogue.oracle.multiply(preparation,inverse,cat.q) + need(tuple(map(tuple,product))==low,'actual native preparation inverse over admitted field') + reached.append('actual source specification consumed') + return {'good':spec.good,'rank':spec.template.rank,'specification_bound':True, + 'native_preparation_sha256':compiler.digest(preparation), + 'native_preparation_inverse_sha256':compiler.digest(inverse), + 'preparation_inverse_product_is_identity':True, + 'literal_source_code':integer_receipt(handle.code)} + value,receipt=checked_entry(cat,specs,handle,domain,continuation,mode='numerical', + expected_key=handle.request_key,expected_common=False) + need(len(reached)==1,'single checked continuation') + rejected=[] + def reject(name,action): + before=len(reached) + try:action() + except (ValueError,KeyError):pass + else:raise ValueError('mutation admitted: '+name) + need(len(reached)==before,'rejected gate must not delegate') + rejected.append(name) + def enter(h=handle,d=domain,sp=specs,expected=handle.request_key,view=False): + return checked_entry(cat,sp,h,d,continuation,mode='numerical',expected_key=expected,expected_common=view) + reject('stale_codebook_handle',lambda:enter(h=replace(handle,identity='0'*64))) + reject('wrong_prime_certificate',lambda:prime_certificate(cat.q-2)) + reject('composite_named_parameter',lambda:load_certified(q=9)) + from low_codes import LowCodes + reject('retained_constructor_composite_control',lambda:LowCodes(9,2,1)) + reject('wrong_common_native_view',lambda:enter(view=True)) + reject('wrong_caller_request_key',lambda:enter(expected=('MOVE',0,1,source['position']))) + other=compiler.early_source87(cat,top,0,1) + wrong_code=cat.codes.encode(other['identifier'],False,low) + reject('wrong_replica_code_with_original_key',lambda:enter(h=replace(handle,code=wrong_code))) + reject('mismatched_specifications_context',lambda:enter(sp={})) + reject('untyped_integer_source',lambda:enter(h=handle.code)) + reject('insufficient_stock',lambda:enter(d=replace(domain,rows=1))) + reject('large_but_incompatible_stock',lambda:enter(d=replace(domain,rows=domain.rows+1))) + reject('undersized_residue_width',lambda:enter(d=replace(domain,L=1))) + reject('padded_residue_width',lambda:enter(d=replace(domain,L=domain.L+1))) + reject('undersized_source_width',lambda:enter(d=replace(domain,Q=1))) + reject('wrong_root_index_width',lambda:enter(d=replace(domain,I=domain.I+1))) + reject('wrong_root_precision',lambda:enter(d=replace(domain,w=1,L=cat.q.bit_length()+1,rows=numerical.stock_unit(cat.q,1)))) + reject('unrelated_history',lambda:enter(d=replace(domain,h=999))) + reject('descendant_without_root_path_certificate',lambda:enter(d=replace(domain,e=2048,h=1,I=13))) + # Actual retained small-prime constructor and fresh handle: cross-prime + # rejection is against a real q=3 context, not an invented digest string. + small,small_top=compiler.load('D',3) + small_source=compiler.early_source87(small,small_top,0,0) + small_handle=compiler.source_handle(small,small_source['identifier'],False,low) + reject('actual_q3_cross_prime_handle',lambda:enter(h=small_handle)) + small_specs=rt.catalogue.Specifications(small) + reject('actual_cross_prime_specifications_context',lambda:enter(sp=small_specs)) + fixture=RootDomain(2048,64,1,1,3,13,small.codes.bits,numerical.stock_unit(3,1)) + _,semantic=checked_entry(small,small_specs,small_handle,fixture,lambda:None, + mode='semantic',expected_key=small_handle.request_key,expected_common=False) + try:checked_entry(small,small_specs,small_handle,fixture,lambda:None, + mode='numerical',expected_key=small_handle.request_key,expected_common=False) + except ValueError:rejected.append('semantic_fixture_is_not_numerically_admitted') + else:raise ValueError('q3 fixture numerically admitted') + regional=regional_emitter(cat,top,domain) + return {'status':'PASS_CHECKED_SOURCE_PARAMETER_ENTRY','admitted_entry':receipt, + 'regional_emitter':regional, + 'actual_specification':value,'constructor_adapter':cat.admission_provenance, + 'semantic_fixture_entry':semantic,'controls':rejected, + 'source_sha256':{p.name:sha256(p.read_bytes()).hexdigest() for p in [Path(__file__),HERE/'compiler.py',HERE/'numerical.py']}, + 'scope':'Actual q127 source/codebook/native specification and checked numerical+stock entry; guarded specification continuation and one actual native IDLE macro emission; no high-field directory or giant production payload executed. q3 fixture entry is semantic only. Physical encoded guard/compiler cost remains open.'} + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--write',action='store_true');args=ap.parse_args() + result=run() + if args.write:(HERE/'ADMISSION-RESULT.json').write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + print(json.dumps(result,sort_keys=True)) diff --git a/research/r437-carrier-integration/compiler.py b/research/r437-carrier-integration/compiler.py new file mode 100644 index 000000000..345a84013 --- /dev/null +++ b/research/r437-carrier-integration/compiler.py @@ -0,0 +1,231 @@ +"""Fresh carrier-to-pooled catalogue binding; no implicit physical admission. + +Reuse ai-nanachi's R437/OQ4, Rohan Arun's pooling, and PR4010's replica API. +Chris R / Clear1nsight, with substantial OpenAI Codex assistance. Apache-2.0. +""" +from collections import Counter +from dataclasses import dataclass +from functools import lru_cache +from hashlib import sha256 +from pathlib import Path +import copy +import gzip +import importlib.util +import json +import sys +import types + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +POOLED = ROOT/'research/r437-pooled-native-interface' +CARRIER = ROOT/'research/r437-two-window-carrier' +VERSION = 'carrier-pooled-replica-v1' + +def need(ok, message): + if not ok: + raise ValueError(message) + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')) + +def digest(value): + return sha256(canonical(value).encode()).hexdigest() + +def read_gz(path): + return json.loads(gzip.decompress(path.read_bytes())) + +def candidate_template(): + manifest = json.loads((CARRIER/'CANDIDATE-TEMPLATE.json').read_bytes()) + need(manifest['format']=='exact-gzip-byte-chunks-v1', 'carrier chunk format') + chunks=[] + for i, row in enumerate(manifest['parts']): + need(row['path']==f'candidate-template-chunks/part-{i:03d}.bin','ordered carrier chunks') + data=(CARRIER/row['path']).read_bytes() + need(len(data)==row['bytes'] and sha256(data).hexdigest()==row['sha256'],'carrier chunk identity') + chunks.append(data) + data=b''.join(chunks) + need(len(data)==manifest['bytes'] and sha256(data).hexdigest()==manifest['sha256'],'carrier joined identity') + value=json.loads(gzip.decompress(data)) + need(digest(value)=='11a564406f5763111444be25c3d39cbc4e46f45d21441e526ae2e22da5149568','exact published carrier template') + return value + +def authenticate_retained(): + manifest=json.loads((POOLED/'SOURCES.json').read_bytes()) + for row in manifest['retained']: + path=POOLED/row['path'] + need(path.is_file() and not path.is_symlink(),'regular predecessor source') + data=path.read_bytes() + need(len(data)==row['bytes'] and sha256(data).hexdigest()==row['sha256'],'retained compiler/source identity '+row['path']) + +@lru_cache(None) +def runtime(): + authenticate_retained() + sys.path.insert(0,str(POOLED)) + import adapter + sys.path.insert(0,str(adapter.PHYSICAL)) + import loader + loader.activate() + import catalogue, topology, replica_catalogue, pooled_compiler + return types.SimpleNamespace(adapter=adapter,catalogue=catalogue,topology=topology, + replica=replica_catalogue,owners=pooled_compiler) + +def _replace(source, old, new, count=1): + need(source.count(old)==count,'exact catalogue adaptation context '+old[:50]) + return source.replace(old,new) + +@lru_cache(None) +def inputs(carrier): + old=read_gz(POOLED/'inputs/word.json.gz') + template=read_gz(POOLED/'inputs/template.json.gz') + expected=json.loads((POOLED/'inputs/EXPECTED.json').read_bytes()) + for name,field in [('word','word_content_sha256'),('template','template_content_sha256')]: + need(sha256(gzip.decompress((POOLED/f'inputs/{name}.json.gz').read_bytes())).hexdigest()==expected[field], 'frozen baseline '+name) + word=json.loads((CARRIER/'CANDIDATE.json').read_bytes()) if carrier else old + if carrier: + need(sha256((CARRIER/'CANDIDATE.json').read_bytes()).hexdigest()=='0e4dc8bda7941b9c5bba2f7af9895544ca6f69666026e4835610b808c3d4d7f2','carrier word publication identity') + template=candidate_template() + need(word['lines']==old['lines'] and word['frames']==old['frames'],'unchanged rational frame inventory') + return word,template,read_gz(POOLED/'inputs/geometry.json.gz') + +def load(variant='D', q=3): + """A/B are original owners; C/D use the exact 63 pooling moves. + + All variants expose the explicit replica interface and fresh identity. + Compilation uses a fixed odd prime; caller input must establish primality. + """ + need(variant in 'ABCD' and len(variant)==1,'known comparison variant') + need(isinstance(q,int) and q>=3 and q%2==1,'odd-prime parameter domain') + rt=runtime() + word, template, geometry=inputs(variant in 'BD') + moves=json.loads((POOLED/'inputs/moves.json').read_bytes())['moves'] if variant in 'CD' else [] + # Build unpooled literal prototypes first. The exact source guards survive; + # only the old frozen digest/profile constants are replaced by fresh receipts. + profile=Counter() + for call in template['calls']: + for event in template['local_programs'][call['orientation']]: + if event[0]==0: profile[event[4]]+=1 + elif event[0]==2: profile[event[5]]+=1 + for counts in template['hosting']['remainders'].values(): + for rank,count in counts.items(): + if int(rank):profile[int(rank)]+=32*count + source=Path(rt.catalogue.__file__).read_text() + source=_replace(source,'private=661','private=659') + source=_replace(source,'==661','==659',3) + source=_replace(source,'self.word,self.template,self.geometry=(self.old.read(p) for p in\n (self.old.WORD,self.old.HOST,self.old.GEO))','self.word,self.template,self.geometry=copy.deepcopy(FRESH_INPUTS)') + source=_replace(source,'expected={int(k):v for k,v in self.old.read("research/e8-bit-p111-tuned/tune/EXPECTED.json")["nine"]["profile"].items()}','expected=FRESH_PROFILE') + source=_replace(source,'==904896','==903456') + source=_replace(source,' need(self.receipt()["binding_sha256"]=="f5a4fb124709adc4b56376a3146e3609e91c0f4d3ed1931a61785a5d99bf8ee7",\n "exact ordered PR2234 request records")',' # Fresh request digest is independently checked by comparison.py.') + name='carrier_catalogue_'+variant+'_'+str(q) + module=types.ModuleType(name);module.__file__=str(HERE/'compiler.py') + module.copy=copy;module.FRESH_INPUTS=(word,template,geometry);module.FRESH_PROFILE=profile + sys.modules[name]=module + exec(compile(source,'','exec'),module.__dict__) + cat=module.Catalogue(q) + topo_source=_replace(Path(rt.topology.__file__).read_text(),'==661','==659') + tm=types.ModuleType(name+'_topology');sys.modules[tm.__name__]=tm + exec(compile(topo_source,'<659-role R437 topology>','exec'),tm.__dict__) + old_top=tm.SelectedTopology(cat) + pooled,profile,idles=rt.owners.compile_owners(template,moves) + old_top.catalogue=copy.copy(cat) + prototypes=cat.requests; old_bits=cat.codes.bits + cat.template=pooled;cat.bases=dict(cat.bases) + cat.requests=rt.replica.Requests(cat,prototypes,idles) + cat.profile=profile + from low_codes import LowCodes + cat.codes=LowCodes(q,64,len(cat.requests));cat.old_code_bits=old_bits + cat.identifiers={};cat.identifier=cat.requests.identifier + cat.semantic_key=lambda request:request.key + cat.erase_guards=tuple((stage,replica,*rest) for stage,*rest in cat.erase_guards for replica in range(32)) + cat.charts={cat.owner_chart(call,role) for call in pooled['calls'] for role in range(659)} + cat.charts.update(r.chart for r in cat.requests.idles) + cat.charts.update(r.chart for r in prototypes if r.kind=='COPY') + cat.variant=variant + cat.input_identity=digest({'word':digest(word),'template':digest(template),'pooled':digest(pooled),'moves':digest(moves)}) + cat.source_identity=codebook_identity(cat) + cat.receipt=lambda:compiler_receipt(cat) + return cat,rt.replica.ReplicaTopology(cat,old_top) + +def codebook_identity(cat): + import low_codes + algorithms=[Path(__file__),Path(runtime().catalogue.__file__),POOLED/'replica_catalogue.py', + POOLED/'pooled_compiler.py',Path(low_codes.__file__)] + return digest([VERSION,cat.input_identity,cat.q,cat.dimension,len(cat.requests),cat.codes.bits, + [(path.name,sha256(path.read_bytes()).hexdigest()) for path in algorithms]]) + +@dataclass(frozen=True) +class SourceHandle: + schema: str + identity: str + code: int + request_key: tuple + +def source_handle(cat,identifier,common,low): + r=cat.requests[identifier] + return SourceHandle(VERSION,cat.source_identity,cat.codes.encode(identifier,common,low),r.key) + +def resolve_handle(cat,specifications,handle): + need(isinstance(handle,SourceHandle) and handle.schema==VERSION and handle.identity==cat.source_identity,'exact carrier source context') + need(getattr(specifications,'catalogue',None) is cat,'exact Specifications instance context') + identifier,common,low=cat.codes.decode(handle.code) + need(cat.requests[identifier].key==handle.request_key,'literal request/replica binding') + return specifications[handle.code] + +def compiler_receipt(cat): + h=sha256();kinds=Counter();ranks=Counter() + for r in cat.requests: + h.update((canonical(r.record())+'\n').encode());kinds[r.kind]+=1;ranks[r.base.rank]+=1 + need(ranks==cat.profile,'complete fresh request profile') + return {'variant':cat.variant,'input_identity':cat.input_identity,'source_identity':cat.source_identity, + 'request_sha256':h.hexdigest(),'requests':len(cat.requests),'kinds':dict(sorted(kinds.items())), + 'profile':dict(sorted(ranks.items())),'rank_mass':sum(r*n for r,n in ranks.items()), + 'prototype_code_bits':cat.old_code_bits,'code_bits':cat.codes.bits, + 'bases':len(cat.bases),'charts':len(cat.charts),'erase_guards':len(cat.erase_guards)} + +def early_source87(cat,top,stage=0,replica=0): + call=top.call(stage,replica) + candidates=[(i,e) for i,e in enumerate(call.events) if e[0]==0 and e[1]==87 and set(e[2:4])=={189,509}] + need(len(candidates)==1,'unique affected SOURCE87 move') + position,event=candidates[0];identifier=cat.identifier('MOVE',stage,replica,position) + return {'identifier':identifier,'key':list(cat.requests[identifier].key),'position':position, + 'event':event,'record':cat.requests[identifier].record()} + +@lru_cache(None) +def logical_driver(): + """The retained generator Driver with explicit per-replica IDLE lookup.""" + runtime() + import driver + source=Path(driver.__file__).read_text() + source=_replace(source, 'for identifier in topology.idles[event["idx"]]:yield from self.idle(families,identifier,replica)', + 'for identifier in topology.idle_identifiers(event["idx"],replica):yield from self.idle(families,identifier,replica)') + module=types.ModuleType('carrier_logical_driver');sys.modules[module.__name__]=module + exec(compile(source,'','exec'),module.__dict__) + return module + +@lru_cache(None) +def caller_emitter(): + """Actual finite macro compiler, with its single IDLE consumer adapted.""" + rt=runtime() + import macro_code + source=Path(macro_code.__file__).read_text() + source=_replace(source, 'for identifier in topology.idles[event["idx"]]:', + 'for identifier in topology.idle_identifiers(event["idx"], replica):') + module=types.ModuleType('carrier_macro_code');sys.modules[module.__name__]=module + exec(compile(source,'','exec'),module.__dict__) + return module + +def compile_node(topology, binding, mode=0): + need(binding.catalogue is topology.catalogue,'macro compiler exact source/native context') + need(getattr(binding.catalogue,'source_identity',None)==codebook_identity(binding.catalogue), + 'macro compiler fresh source context') + return caller_emitter().compile_node(topology,binding,mode) + +if __name__=='__main__': + import argparse + ap=argparse.ArgumentParser();ap.add_argument('--write',action='store_true');args=ap.parse_args() + rows={} + for variant in 'CD': + cat,top=load(variant);rows[variant]=compiler_receipt(cat) + rows[variant]['source87']=[early_source87(cat,top,s) for s in (0,1)] + rows['incremental_code_bits']=rows['D']['code_bits']-rows['C']['code_bits'] + if args.write:(HERE/'COMPILER-RESULT.json').write_text(json.dumps(rows,indent=2,sort_keys=True)+'\n') + print(json.dumps(rows,sort_keys=True)) diff --git a/research/r437-carrier-integration/compiler_checks.py b/research/r437-carrier-integration/compiler_checks.py new file mode 100644 index 000000000..a0c9d13b5 --- /dev/null +++ b/research/r437-carrier-integration/compiler_checks.py @@ -0,0 +1,222 @@ +"""Full fresh catalogue, owner and algebra checks. See COMPILER.md for scope.""" +from collections import Counter,defaultdict +from dataclasses import replace +from fractions import Fraction as F +from functools import lru_cache +from hashlib import sha256 +import json +import sys +import compiler as c + +need=c.need + +def projector_certificate(cat): + """Idempotence and an exact characteristic polynomial for every base.""" + from check_transport import dyadic,dyadic_unit,determinant + result=[] + for key,base in sorted(cat.bases.items()): + if base.kind=='idle': + need(len(set(base.data))==base.rank,'idle coordinate projector rank') + result.append([key,base.rank,'coordinate',list(base.data)]) + continue + a=[list(map(F,row)) for row in base.data] + need(len(a)==8 and all(len(r)==8 for r in a),'local residual dimension') + need(all(dyadic(x) for row in a for x in row),'projector denominators invertible at odd primes') + square=[[sum(a[i][k]*a[k][j] for k in range(8)) for j in range(8)] for i in range(8)] + need(square==a,'fresh base idempotence') + # Rational elimination records a nonzero rank minor. Uniform odd-prime + # rank follows instead from the exact characteristic polynomial below. + b=[r[:] for r in a];rows=list(range(8));pivots=[];ri=0 + for j in range(8): + i=next((i for i in range(ri,8) if b[i][j]),None) + if i is None:continue + b[i],b[ri]=b[ri],b[i];rows[i],rows[ri]=rows[ri],rows[i] + pivots.append((rows[ri],j));pivot=b[ri][j] + for k in range(ri+1,8): + ratio=b[k][j]/pivot + b[k]=[x-ratio*y for x,y in zip(b[k],b[ri])] + ri+=1 + need(ri==base.rank,'rational projector rank') + minor=[[a[i][j] for _,j in pivots] for i,_ in pivots] + det=determinant(minor) + need(det!=0,'rational rank minor') + values=[] + for t in range(9): + char=determinant([[F(t if i==j else 0)-a[i][j] for j in range(8)] for i in range(8)]) + need(char==F(t)**(8-base.rank)*F(t-1)**base.rank,'exact projector characteristic polynomial') + values.append(str(char)) + result.append([key,base.rank,pivots,str(det),values]) + return {'bases':len(result),'local':sum(b.kind=='local' for b in cat.bases.values()), + 'sha256':c.digest(result),'domain':'every odd prime; dyadic idempotent plus characteristic polynomial t^(8-r)(t-1)^r'} + +def full(cat,top): + from check_transport import reconstructed_chart,dyadic,dyadic_unit,determinant,distinguishing_entry + matrices={};chartrows=[] + for chart in sorted(cat.charts,key=lambda x:c.canonical(x.key)): + matrix=reconstructed_chart(chart,cat.geometry) + need(matrix==cat.chart_matrix(chart),'independent reconstructed chart') + need(all(dyadic(x) for row in matrix for x in row),'dyadic chart') + det=determinant(matrix);need(dyadic_unit(det),'invertible every odd prime') + matrices[chart]=matrix;chartrows.append([chart.key,str(det)]) + @lru_cache(None) + def witness(a,b):return distinguishing_entry(matrices[a],matrices[b]) + wdigest=sha256();pairs=0 + for stage in range(9): + for replica in range(32): + call=top.call(stage,replica);groups=defaultdict(list) + for role,owner in enumerate(call.owners):groups[owner.family].append((role,owner.chart)) + for family,owners in sorted(groups.items()): + for i,(role,a) in enumerate(owners): + for other,b in owners[:i]: + entry=witness(a,b);pairs+=1 + wdigest.update((c.canonical([stage,replica,family,role,other,*entry])+'\n').encode()) + for identifier,r in enumerate(cat.requests): + need(cat.identifier(*r.key)==identifier,'every literal request roundtrip') + if r.kind=='IDLE':need(top.idle_family(identifier,r.replica)==r.family,'absolute IDLE family') + else: + call=top.call(r.stage,r.replica) + need(call.requests[r.position]==identifier,'actual caller request position') + owner=call.owners[r.role] + need((r.family,r.chart)==(owner.family,owner.chart) if r.kind=='MOVE' else + r.family==28416 and r.source_chart==owner.chart,'native/source owner binding') + ids=[i for event in top.schedule if event['kind']=='idle' for replica in range(32) + for i in top.idle_identifiers(event['idx'],replica)] + need(len(ids)==len(set(ids))==len(cat.requests.idles),'exactly once IDLE') + need(set(ids)==set(range(cat.requests.starts[-1],len(cat.requests))),'complete IDLE enumeration') + return {'charts':len(chartrows),'chart_sha256':c.digest(chartrows),'owner_pairs':pairs, + 'owner_witness_sha256':wdigest.hexdigest(),'idle_enumeration':len(ids), + 'projectors':projector_certificate(cat)} + +def controls(old,new,top): + from catalogue import Specifications + from sources import identity + low=tuple(tuple(map(int,row)) for row in identity(64));specs=Specifications(new) + report=[] + def reject(name,action): + try:action() + except (ValueError,TypeError,KeyError,AttributeError):report.append(name) + else:raise ValueError('accepted negative control '+name) + witness=c.early_source87(new,top) + identifier=witness['identifier'];handle=c.source_handle(new,identifier,False,low) + spec=c.resolve_handle(new,specs,handle) + need(spec.template.record[:2]==('pooled-replica-request-v1',0),'compiled explicit replica') + reject('stale baseline handle',lambda:c.resolve_handle(new,specs,c.source_handle(old,identifier,False,low))) + reject('wrong replica',lambda:c.resolve_handle(new,specs,replace(handle,request_key=('MOVE',0,1,witness['position'])))) + reject('legacy replica blind lookup',lambda:new.identifier('MOVE',0,witness['position'])) + reject('legacy IDLE enumeration',lambda:top.idles) + reject('mismatched Specifications',lambda:c.resolve_handle(new,Specifications(old),handle)) + changed=copy_catalogue(new);changed.q=5 + reject('cross prime context',lambda:c.resolve_handle(new,specs,replace(handle,identity=c.codebook_identity(changed)))) + reject('untagged integer code',lambda:c.resolve_handle(new,specs,handle.code)) + copyid=next(i for i,r in enumerate(new.requests) if r.kind=='COPY') + reject('native COPY',lambda:specs.bind(copyid,False,low)) + # A correctly typed numeric source code resolves differently after a context + # change: tagging is necessary even when field widths happen to coincide. + compiled=[] + for stage in (0,1): + item=c.early_source87(new,top,stage) + for common in (False,True): + h=c.source_handle(new,item['identifier'],common,low);s=c.resolve_handle(new,specs,h) + compiled.append({'request':item['identifier'],'stage':stage,'rank':s.template.rank,'common':common,'good':s.good}) + return {'rejected':report,'compiled_changed_sources':compiled} + +def copy_catalogue(cat): + import copy + return copy.copy(cat) + +def driver_schedule(cat,top): + """Actual global_word control flow, formal per-low payload substitution. + + Only this metadata replay substitutes tape functions. The returned Driver + class itself retains real gather/route/residual/return functions for callers. + """ + from control import LocalState + from unittest.mock import patch + module=c.logical_driver() + class FormalTape: + def close(self):pass + def clear(self):pass + class TraceDriver(module.Driver): + def local(self,families,call,low): + state=LocalState(call) + for position,_event in enumerate(call.events): + op,role=state.accept(position) + if op in (0,2):yield call.requests[position] + state.finish() + def idle(self,families,identifier,replica): + need(top.idle_family(identifier,replica)==cat.requests[identifier].family,'driver exact IDLE replica') + for _low in cat.low_classes():yield identifier + trace=object.__new__(TraceDriver) + trace.topology=top;trace.context=None;trace.observe=None;trace.old_count=None;trace.fibre=None + families=[FormalTape() for _ in range(top.families)] + original=cat.low_classes;cat.low_classes=lambda:iter(('formal-low-label',)) + try: + with patch.object(module,'family_rows',lambda _context:FormalTape()),patch.object(module,'xor_family',lambda *_args:FormalTape()): + ids=list(trace.global_word(families)) + finally:cat.low_classes=original + need(len(ids)==len(set(ids))==len(cat.requests),'actual Driver complete once-per-low paid enumeration') + need(set(ids)==set(range(len(cat.requests))),'actual Driver all fresh IDs') + h=sha256() + for identifier in ids:h.update((str(identifier)+'\n').encode()) + return {'requests_per_formal_low_label':len(ids),'chronological_identifier_sha256':h.hexdigest(), + 'source':'actual retained Driver.global_word with single explicit-replica IDLE adaptation', + 'scope':'metadata/control-flow replay; family/tape payloads substituted; no physical execution'} + +def regional_emitter(cat,top): + """A real canonical plan emitter on one actual IDLE, identity low class. + + This is an explicitly bounded region of the finite compiler, not full GL64 + enumeration or physical execution. Every replica IDLE was checked above. + """ + from catalogue import Specifications + from macro_binding import SelectedBinding + from sources import identity + from types import SimpleNamespace + import macro_code + identifier=next(i for i,r in enumerate(cat.requests) if r.kind=='IDLE' and r.base.rank==14) + request=cat.requests[identifier] + region=SimpleNamespace(catalogue=cat,replicas=32, + schedule=({'kind':'idle','idx':request.stage},), + idle_identifiers=lambda child,replica:(identifier,) if (child,replica)==(request.stage,request.replica) else (), + idle_family=top.idle_family) + specifications=Specifications(cat);binding=SelectedBinding(specifications) + low=tuple(tuple(map(int,row)) for row in identity(64)) + original=cat.low_classes + cat.low_classes=lambda:iter((low,)) + try: + try:macro_code.compile_node(region,binding) + except AttributeError:pass + else:raise ValueError('old replica-blind macro compiler accepted new topology') + emitted=c.compile_node(region,binding) + finally: + cat.low_classes=original + residuals=[row[2] for row in emitted.operations if row[0]=='residual_begin'] + need(len(residuals)==1 and residuals[0].identifier==identifier and not residuals[0].common, + 'actual native IDLE compiled exactly once') + need(emitted.operations[0]==('node',) and emitted.operations[-1]==('return',),'regional terminal control') + tags=Counter(row[0] for row in emitted.operations) + need(tags['gather']==tags['scatter']==tags['clear']==1,'regional gather/return/cleanup emitter') + wrong=SimpleNamespace(catalogue=object()) + try:c.compile_node(region,wrong) + except ValueError:pass + else:raise ValueError('macro source/native context mixup accepted') + return {'request':identifier,'replica':request.replica,'rank':14,'q':cat.q, + 'dimension':64,'low_classes_executed':1,'source_specification_good':specifications[residuals[0].code].good, + 'operations':dict(sorted(tags.items())), + 'old_replica_blind_compiler_rejected':True,'source_native_context_mixup_rejected':True, + 'scope':'actual canonical SelectedBinding and Cursor plan; one actual IDLE, identity low header; no physical execution'} + +def run(): + old,ot=c.load('C');new,nt=c.load('D') + return {'status':'PASS_FRESH_CARRIER_POOLED_COMPILER', + 'C':dict(c.compiler_receipt(old),coverage=full(old,ot)), + 'D':dict(c.compiler_receipt(new),coverage=full(new,nt)), + 'controls':controls(old,new,nt),'regional_emitter':regional_emitter(new,nt),'driver_schedule':driver_schedule(new,nt), + 'incremental_code_bits':new.codes.bits-old.codes.bits, + 'physical_execution':False,'numerical_admission':'separate numerical.py premise'} + +if __name__=='__main__': + result=run() + if '--write' in sys.argv:(c.HERE/'COMPILER-CHECKS.json').write_text(json.dumps(result,sort_keys=True,indent=2)+'\n') + else:need(json.loads((c.HERE/'COMPILER-CHECKS.json').read_text())==json.loads(json.dumps(result)),'frozen full compiler receipt') + print(json.dumps(result,sort_keys=True)) diff --git a/research/r437-carrier-integration/independent.py b/research/r437-carrier-integration/independent.py new file mode 100644 index 000000000..ece9832f4 --- /dev/null +++ b/research/r437-carrier-integration/independent.py @@ -0,0 +1,395 @@ +#!/usr/bin/env python3 +"""Literal four-way audit, no imports from the integration or predecessor builders. + +Shared mathematical sources are deliberate: this is a separately written checker, +not independent discovery, formal verification or a physical-caller proof. +Apache-2.0; Chris R / Clear1nsight with OpenAI Codex assistance. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction +import argparse +import gzip +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +RESEARCH = HERE.parent +PINS = { + 'r437-pooled-native-interface/inputs/geometry.json.gz': 'edcaebb35d313f403b2db45a2cf808617f921c83cf7a11dd5d74356570ede1a8', + 'r437-two-window-carrier/CANDIDATE.json': '0e4dc8bda7941b9c5bba2f7af9895544ca6f69666026e4835610b808c3d4d7f2', + 'r437-two-window-carrier/inputs/R437-COMPOSED-WORD.json.gz': 'e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e', + 'r437-two-window-carrier/inputs/OQ4-TEMPLATE.json.gz': '6e03c76f5a4227394ea57e901eb7e93f4d1ee411ccfecd483fd44ea043550494', + 'r437-pooled-native-interface/inputs/moves.json': '0a58b239795d213743b5654c59a3e4622a0ddd4a53d8dba3fa30dedef4558dff', +} + +def need(ok, reason): + if not ok: + raise ValueError(reason) + +def canonical(x): + return json.dumps(x, sort_keys=True, separators=(',', ':')).encode() + +def digest(x): + return hashlib.sha256(canonical(x)).hexdigest() + +def load(path): + data = (RESEARCH/path).read_bytes() + need(hashlib.sha256(data).hexdigest() == PINS[path], 'pinned input '+path) + return json.loads(gzip.decompress(data) if path.endswith('.gz') else data) + +def row_basis(rows): + pivots = {} + for raw in rows: + row = list(map(Fraction, raw)) + for i, old in sorted(pivots.items()): + a = row[i] + row = [x-a*y for x,y in zip(row, old)] + if any(row): + i = next(i for i,v in enumerate(row) if v) + a = row[i] + pivots[i] = [x/a for x in row] + return pivots + +def geometry(w): + dims = [] + for frame in w['frames']: + basis = row_basis([w['lines'][i] for i in frame]) + closed = [] + for i, raw in enumerate(w['lines']): + row = list(map(Fraction, raw)) + for j, old in sorted(basis.items()): + a = row[j] + row = [x-a*y for x,y in zip(row, old)] + if not any(row): closed.append(i) + need(frame == closed, 'rationally closed frame') + dims.append(len(basis)) + return dims + +def emit(w, dims): + """Independently expand four word sections into scalar chronological events.""" + current = w['start'][:] + events = [] + provenance = [] + def push(event, origin): + events.append(event); provenance.append(origin) + def move(role, frame, origin): + old = current[role] + need(set(w['frames'][old]).issubset(w['frames'][frame]), 'monotone frame') + if old != frame: + push([0, role, old, frame, dims[frame]-dims[old], 0], origin) + current[role] = frame + for section in ['D','A','B','C']: + if section == 'B': + for k, role in enumerate(w['ret']): + frame = current[role] + push([2,role,659,frame,0,dims[frame],0], ['COPY',k]) + for target, sources in enumerate(w['scatter']): + if k in sources: push([1,111+target,659,1,0,0], ['SCATTER',k,target]) + push([3,role,659,frame,0,0,0], ['ERASE',k]) + for i,(frame,destination,sources) in enumerate(w[section]): + origin = [section,i] + for role in [destination]+sources: move(role,frame,origin) + for source in sources: push([1,destination,source,1,frame,0], origin) + for role,frame in enumerate(w['final']): move(role,frame,['FINAL',role]) + reverse = [] + for e in reversed(events): + if e[0] == 0: reverse.append([0,e[1],e[3],e[2],e[4],1]) + elif e[0] == 1: reverse.append([1,e[1],e[2],-1,e[4],1]) + elif e[0] == 3: reverse.append([2,*e[1:5],dims[e[3]],1]) + else: reverse.append([3,*e[1:5],e[5],1]) + return {'forward':events,'reverse':reverse}, provenance + +def replay(events): + state = [1 << i for i in range(659)] + [0] + opened = None + captures, writes = [], [] + profile = Counter() + for position,e in enumerate(events): + kind,role = e[:2] + if kind == 0: profile[e[4]] += 1 + elif kind == 1: + need(role != opened and (e[2] != 659 or opened is not None), 'live COPY ownership') + state[role] ^= state[e[2]] + if role < 111: writes.append([role,hex(state[role])]) + elif kind == 2: + need(opened is None and state[659] == 0, 'private COPY vacant') + opened = role; state[659] = state[role] + captures.append([role,e[3],hex(state[role])]); profile[e[5]] += 1 + elif kind == 3: + need(opened == role and state[659] == state[role], 'exact protected return before ERASE') + state[659] = 0; opened = None + else: raise ValueError('event kind') + want = [(1 << i)^((1 << (i-111)) if 111 <= i < 222 else 0) for i in range(659)] + [0] + need(state == want and opened is None, 'all 659 independent columns and terminal restoration') + return profile, captures, writes + +def hosting(template, moves): + """Use bit occupancy, absolute family slots, and schedule-derived idle windows.""" + previous = {} + sweeps = [] + windows = {} + for pos,event in enumerate(template['schedule']): + kind = event['kind'] + if kind == 'local_cover_sweep': + previous[event['pair']] = pos + sweeps.append((pos,event['pair'],event['stage'])) + elif kind == 'bridge': + previous[event['src']] = previous[event['dst']] = pos + elif kind == 'idle': + stages = [s for p,pair,s in sweeps if previous.get(event['pair'],-1) < p < pos and pair != event['pair']] + if event['rank'] and stages: windows[str(event['idx'])] = [event['pair'],event['rank'],stages] + need(windows == template['hosting']['windows'], 'literal untouched chronological hosting windows') + calls = {(c['stage'],c['replica']):deepcopy(c) for c in template['calls']} + need(len(calls) == 288 and set(calls) == {(s,r) for s in range(9) for r in range(32)}, 'unique full call domain') + changed = set() + for change in moves: + key = change['stage'],change['call_replica'],222+change['helper'] + need(key not in changed, 'duplicate owner rewrite') + changed.add(key) + old,new = change['old'],change['new'] + owners = calls[key[:2]]['owners'] + need(owners[key[2]] == [old['family'],['hosted',old['child'],old['offset'],8]], 'literal old owner') + owners[key[2]] = [new['family'],['hosted',new['child'],new['offset'],8]] + occupied = {} + owners_digest = hashlib.sha256() + for (stage,replica),call in sorted(calls.items()): + need(call['orientation'] == ('reverse' if stage%2 else 'forward'), 'orientation') + for role,(family,route) in enumerate(call['owners']): + if role < 222: + side = role//111 ^ (stage%2) + need([family,route] == [replica*888+222*call['pair']+111*side+role%111,['data',stage,role%111]], 'absolute data owner') + else: + need(route[0] == 'hosted', 'helper route') + child,off,width = route[1:] + pair,rank,stages = windows[str(child)] + need(stage in stages and pair != call['pair'], 'owner lifetime') + need(0 <= family < 28416 and (family%888)//222 == pair, 'owner family domain') + need(width == 8 and 0 <= off <= rank-8, 'eight coordinate slot') + bits = 255 << off + used = occupied.get((child,family),0) + need(not used & bits, 'disjoint pooled cells') + occupied[child,family] = used|bits + owners_digest.update(canonical([stage,replica,role,family,route])+b'\n') + idle_profile = Counter(); idles = [] + for event in template['schedule']: + if event['kind'] != 'idle' or not event['rank']: continue + child,pair,capacity = event['idx'],event['pair'],event['rank'] + for replica in range(32): + for cp in range(222): + family = replica*888+222*pair+cp + used = occupied.get((child,family),0) + n = used.bit_count() + need(used == (1 << n)-1, 'contiguous hosted prefix') + rank = capacity-n + if rank: + idle_profile[rank] += 1 + idles.append([child,replica,cp,family,n,rank]) + return idle_profile, idles, owners_digest.hexdigest(), sorted(changed) + +def inverse(matrix): + n = len(matrix) + rows = [list(row)+[Fraction(i==j) for j in range(n)] for i,row in enumerate(matrix)] + for j in range(n): + pivot = next(i for i in range(j,n) if rows[i][j]) + rows[j],rows[pivot] = rows[pivot],rows[j] + a = rows[j][j];rows[j] = [x/a for x in rows[j]] + for i in range(n): + if i != j: + a = rows[i][j];rows[i] = [x-a*y for x,y in zip(rows[i],rows[j])] + return [row[n:] for row in rows] + +def native_digest(template, moves, w, dims, idles): + """Literal Request.record reconstruction via Gram inverse, no catalogue import.""" + projectors = [] + for frame in w['frames']: + rows = list(row_basis([w['lines'][i] for i in frame]).values()) + if not rows: + projectors.append([[Fraction(0)]*8 for _ in range(8)]);continue + gram = [[sum(a*b for a,b in zip(x,y)) for y in rows] for x in rows] + inv = inverse(gram) + p = [[sum(rows[a][i]*inv[a][b]*rows[b][j] for a in range(len(rows)) for b in range(len(rows))) for j in range(8)] for i in range(8)] + projectors.append(p) + bases = {} + def local_base(a,b): + lo,hi = (a,b) if dims[a] <= dims[b] else (b,a) + key = lo,hi + if key not in bases: + rows = [[str(x-y) for x,y in zip(r,s)] for r,s in zip(projectors[hi],projectors[lo])] + bases[key] = digest(['local',dims[hi]-dims[lo],rows]) + return bases[key] + idle_events = {e['idx']:e for e in template['schedule'] if e['kind']=='idle'} + def pending(child): + e = idle_events[child];a,b = e['source_level'],e['target_level'] + return list(range(1 if a == -1 else 8+7*a,8+7*b)) + def chart(owner): + family,route = owner + if route[0] == 'data': return ['data',route[2],route[1],[]] + _,child,offset,width = route + axes = pending(child)[offset:offset+width] + return ['host',family%111 if min(axes)<8 else -1,-1,axes] + overlay = {(m['stage'],m['call_replica'],222+m['helper']):[m['new']['family'],['hosted',m['new']['child'],m['new']['offset'],8]] for m in moves} + out = hashlib.sha256();kinds=Counter();count=0 + def add(replica,row): + nonlocal count + out.update(canonical(['pooled-replica-request-v1',replica]+row)+b'\n') + kinds[row[0]] += 1;count += 1 + for call in template['calls']: + stage,replica = call['stage'],call['replica'] + for pos,event in enumerate(template['local_programs'][call['orientation']]): + op,role = event[:2] + if op not in (0,2): continue + owner = overlay.get((stage,replica,role),call['owners'][role]) + if op == 0: + a,b,rank = event[2:5] + row = ['MOVE',stage,pos,role,owner[0],a,b,local_base(a,b),rank,chart(owner),'owner',None] + else: + a,b,rank = event[3:6] + row = ['COPY',stage,pos,role,template['live'],a,b,local_base(a,b),rank,['identity',-1,-1,[]],'common',chart(owner)] + add(replica,row) + for child,replica,cp,family,used,rank in idles: + e=idle_events[child];axes=pending(child)[used:] + need(len(axes)==rank,'idle native axes') + add(replica,['IDLE',child,child,cp,family,e['source_level'],e['target_level'],digest(['idle',rank,axes]),rank,['family',cp%111,-1,[]],'owner',None]) + # Full GL64 vocabulary width, independently evaluated integer product. + widths={} + for q in [3,5]: + size=1 + for k in range(64): size*=q**64-q**k + widths[str(q)] = (2*count*size-1).bit_length() + return {'ordered_request_sha256':out.hexdigest(),'request_kinds':dict(kinds),'request_count':count,'source_code_bits':widths, + 'local_base_labels':len(set(bases.values()))} + +def slot_injections(template,moves,geometry_data): + # Derive a common ambient family chart F_p. Actual owner chart is A*P, + # where A is F_p exactly when the selected slot touches the first8 axes. + # Otherwise F_p acts as identity on that slot, so the injections agree. + for port in geometry_data['ports']: + a = [[Fraction(port['q'][i],2)]+list(map(Fraction,port['complement_columns'][i])) for i in range(8)] + inv = inverse(a) + need(all(x.denominator & (x.denominator-1) == 0 for row in a+inv for x in row),'dyadic family chart and inverse') + need(all(sum(a[i][k]*inv[k][j] for k in range(8)) == (i==j) for i in range(8) for j in range(8)), 'family chart inverse') + idle_events={e['idx']:e for e in template['schedule'] if e['kind']=='idle'} + pending={} + by_pair={} + for child,e in idle_events.items(): + a,b=e['source_level'],e['target_level'];axes=set(range(1 if a==-1 else 8+7*a,8+7*b)) + need(not axes & by_pair.get(e['pair'],set()),'different IDLE domains disjoint within each pair') + by_pair.setdefault(e['pair'],set()).update(axes);pending[child]=sorted(axes) + override={(m['stage'],m['call_replica'],222+m['helper']):[m['new']['family'],['hosted',m['new']['child'],m['new']['offset'],8]] for m in moves} + occupied={};count=0;coordinates=0;touching=0;seen_slots=set() + for call in template['calls']: + for role,old in enumerate(call['owners'][222:],222): + family,route=override.get((call['stage'],call['replica'],role),old) + child,offset,width=route[1:];axes=pending[child][offset:offset+width] + need(len(axes)==8,'complete slot dimension') + permutation=list(range(64)) + for a,b in zip(sorted(set(range(8))-set(axes)),sorted(set(axes)-set(range(8)))): + permutation[a],permutation[b]=b,a + image=permutation[:8] + need(set(image)==set(axes),'actual column permutation injection') + # Actual owner A is identity off low8, while common F also is. + if min(axes)>=8: need(all(k>=8 for k in image),'identity branch equals common-family injection') + else: touching+=1 + previous=occupied.setdefault(family,set()) + need(not previous.intersection(axes),'global per-family slot direct sum') + previous.update(axes);count+=1;coordinates+=8;seen_slots.add((family%111,tuple(image))) + remainder_coordinates=0 + for e in template['schedule']: + if e['kind']!='idle' or not e['rank']:continue + child,pair=e['idx'],e['pair'] + for replica in range(32): + for cp in range(222): + family=replica*888+pair*222+cp + remainder_coordinates+=len(set(pending[child])-occupied.get(family,set())) + return {'helper_occurrences':count,'transported_slot_coordinates':coordinates,'distinct_port_slot_injections':len(seen_slots), + 'first8_touching_occurrences':touching,'remaining_IDLE_coordinates':remainder_coordinates, + 'family_charts_and_inverse_dyadic':111,'common_family_left_inverse':'L=E8^T P^-1 F_family^-1', + 'scope':'Exact rational injection/direct-sum identity; valid modulo every odd prime for these dyadic family charts. Local residual reduction still requires its own prime/domain guards. No physical primitive refinement is inferred.'} + +def run(): + old = load('r437-two-window-carrier/inputs/R437-COMPOSED-WORD.json.gz') + new = load('r437-two-window-carrier/CANDIDATE.json') + original = load('r437-two-window-carrier/inputs/OQ4-TEMPLATE.json.gz') + proposal = load('r437-pooled-native-interface/inputs/moves.json') + need(digest(original) == proposal['template_content_sha256'], 'pool proposal exact original template') + partroot = RESEARCH/'r437-two-window-carrier' + manifest = json.loads((partroot/'CANDIDATE-TEMPLATE.json').read_bytes()) + parts = [] + for i,p in enumerate(manifest['parts']): + need(p['path'] == 'candidate-template-chunks/part-%03d.bin'%i, 'ordered chunk path') + data = (partroot/p['path']).read_bytes() + need(len(data) == p['bytes'] and hashlib.sha256(data).hexdigest() == p['sha256'], 'chunk authentication') + parts.append(data) + compressed = b''.join(parts) + need(hashlib.sha256(compressed).hexdigest() == '5fe2bffb2d4f67ef0937240cafc22cb55c29f51157810dc917464c7714ac7f74', 'exact carrier template') + carrier = json.loads(gzip.decompress(compressed)) + dims = geometry(old) + need(old['frames'] == new['frames'] and old['lines'] == new['lines'], 'same rational geometry') + observations = {}; locals_ = {}; early = {} + for name,w,t in [('old',old,original),('new',new,carrier)]: + streams,origin = emit(w,dims) + need(streams == t['local_programs'], 'literal local stream binding '+name) + observations[name] = {} + for direction,events in streams.items(): + profile,captures,writes = replay(events) + locals_[name,direction] = profile + observations[name][direction] = {'profile':dict(sorted(profile.items())), 'captures':captures, 'SOURCE_writes':writes, + 'ADDs':sum(e[0]==1 for e in events), 'events':len(events), 'stream_sha256':digest(events)} + early[name] = [[i,origin[i],e[2],e[3],e[4]] for i,e in enumerate(streams['forward']) if e[0]==0 and e[1]==87] + differences = {} + mask = (1 << 111)-1 + for direction in ['forward','reverse']: + a,b = observations['old'][direction],observations['new'][direction] + need(a['SOURCE_writes'] == b['SOURCE_writes'], 'SOURCE write observations '+direction) + need([[r,f,int(v,16)&mask] for r,f,v in a['captures']] == [[r,f,int(v,16)&mask] for r,f,v in b['captures']], 'COPY SOURCE rows and frames '+direction) + differences[direction] = {'full_COPY_DIRTY_rows_changed':[i for i,(x,y) in enumerate(zip(a['captures'],b['captures'])) if x!=y], + 'SOURCE_writes_count':len(a['SOURCE_writes']), 'COPY_count':len(a['captures']), + 'changed_capture_witnesses':[{'ordinal':i,'role':x[0],'frame':x[1],'old_row':x[2],'new_row':y[2],'xor_row':hex(int(x[2],16)^int(y[2],16)), 'DIRTY_roles':[r for r in range(222,659) if (int(x[2],16)^int(y[2],16))>>r&1]} for i,(x,y) in enumerate(zip(a['captures'],b['captures'])) if x!=y]} + owner_data = {}; profiles = {}; native = {}; slot_receipts = {} + geometry_data = load('r437-pooled-native-interface/inputs/geometry.json.gz') + for owner_name,moves in [('OQ4',[]),('pooled',proposal['moves'])]: + before = hosting(original,moves); after = hosting(carrier,moves) + slot_receipts[owner_name] = slot_injections(carrier,moves,geometry_data) + need(before == after, 'word update leaves whole owner domain/lifetime untouched') + idle,idles,owners,changed = before + if owner_name == 'pooled': + native['C'] = native_digest(original,moves,old,dims,idles) + native['D'] = native_digest(carrier,moves,new,dims,idles) + owner_data[owner_name] = {'idle_profile':dict(sorted(idle.items())), 'idle_records':len(idles), 'idle_records_sha256':digest(idles), 'owner_sha256':owners,'changed_owners':changed} + for name,letter in [('old','A' if owner_name=='OQ4' else 'C'),('new','B' if owner_name=='OQ4' else 'D')]: + total = Counter(idle) + for s in range(9): total.update({r:n*32 for r,n in locals_[name,'reverse' if s%2 else 'forward'].items()}) + profiles[letter] = {'profile':dict(sorted(total.items())), 'requests':sum(total.values()), 'mass':sum(r*n for r,n in total.items())} + delta = Counter(profiles['D']['profile']); delta.subtract(profiles['C']['profile']) + delta = {r:n for r,n in delta.items() if n} + need(delta == {1:288,2:-576,3:288}, 'pooled carrier rank delta') + need(all(p['requests']==903456 and p['mass']==1808352 for p in profiles.values()), 'same four-way rank mass and requests') + # Meaningful stale-source/owner controls, preserving immutable fixtures. + controls = [] + stale = deepcopy(new); stale['D'] = old['D'] + try: replay(emit(stale,dims)[0]['forward']) + except ValueError: controls.append('old_D_rejected_by_arbitrary_DIRTY_identity') + else: raise ValueError('stale D accepted') + badmoves = deepcopy(proposal['moves']); badmoves[0]['new']['family'] += 222 + try: hosting(original,badmoves) + except ValueError: controls.append('wrong_destination_pair_rejected') + else: raise ValueError('bad family accepted') + try: hosting(original,proposal['moves']+[proposal['moves'][0]]) + except ValueError: controls.append('duplicate_owner_rewrite_rejected') + else: raise ValueError('duplicate owner accepted') + for name in observations: + for direction in observations[name]: + observations[name][direction].pop('captures');observations[name][direction].pop('SOURCE_writes') + return {'status':'PASS_INDEPENDENT_LITERAL_FOUR_WAY','source_sha256':PINS,'local':observations,'COPY_and_SOURCE_comparison':differences, + 'early_SOURCE87_MOVE':early,'owners':owner_data,'four_way':profiles,'D_minus_C_profile':delta, + 'native_requests':native, 'slot_injection':slot_receipts, 'D_changed_rows':sum(a!=b for a,b in zip(old['D'],new['D'])), 'controls':controls, + 'scope':'Shared authenticated source words independently interpreted; GF2 arbitrary-DIRTY identity, rational frame closure, chronological pooled ownership. No numerical envelope or physical primitive refinement follows.'} + +if __name__ == '__main__': + parser=argparse.ArgumentParser();parser.add_argument('--write',action='store_true');args=parser.parse_args() + result=run();path=HERE/'INDEPENDENT-RESULT.json' + if args.write: path.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + else: need(json.loads(json.dumps(result))==json.loads(path.read_text()),'immutable comparison receipt') + print(result['status']) diff --git a/research/r437-carrier-integration/numerical.py b/research/r437-carrier-integration/numerical.py new file mode 100644 index 000000000..d3411758b --- /dev/null +++ b/research/r437-carrier-integration/numerical.py @@ -0,0 +1,291 @@ +"""Named numerical/stock admission for the source-bound carrier. + +Adapt #3647's finite invoice and #2753's explicit logical-frame reserve; +reuse #4147's independently checked row coefficients. No exponent solver, +no floating-point arithmetic, no physical primitive assumed free. +Chris R / Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +""" +from fractions import Fraction +from functools import lru_cache +from hashlib import sha256 +from pathlib import Path +import argparse +import json +import math + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +W, PHYSICAL, M, REQUESTS = 28416, 28425, 64, 903456 +STOCK_MULTIPLIER = math.lcm(W, PHYSICAL) +EPSILON = Fraction(1, 10**16) +PROFILE_C = {1:380160,2:400877,3:22176,4:26592,5:29376,6:17375,7:26496,14:1,42:403} +PROFILE_D = {1:380448,2:400301,3:22464,4:26592,5:29376,6:17375,7:26496,14:1,42:403} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def depth(n): + need(isinstance(n, int) and n >= 1, 'positive atom width') + result = 0 + while n >= M: + n = 42 * (n // M) + result += 1 + return result + + +@lru_cache(None) +def gl_order(q): + need(isinstance(q, int) and q >= 3 and q % 2, 'odd prime domain; primality/source admissibility supplied separately') + return math.prod(q**64 - q**i for i in range(64)) + + +def stock_unit(q, w): + need(isinstance(w, int) and w >= 1, 'positive unchanged root precision') + return STOCK_MULTIPLIER * gl_order(q) * q**(4096*(w-1)) + + +def check_stock_rows(rows, n, q, w): + """Exact compatible stock, not merely a lower bound on the row count. + + q primality and source denominator admissibility are caller preconditions. + Applies also to semantic fixtures q<2^80, without numerical admission. + """ + need(isinstance(rows, int) and rows > 0, 'positive row stock') + divisor = stock_unit(q,w)**depth(n) + quotient, remainder = divmod(rows,divisor) + need(quotient > 0 and remainder == 0, 'compatible original-root stock divisor') + return quotient + + +def check_root_domain(e, n, w, h, q, residue_width, index_width, code_width): + """Exact parameter admission; q primality/source admissibility is a premise.""" + need(all(isinstance(x,int) for x in (e,n,w,h,q,residue_width,index_width,code_width)), 'integer parameter domain') + need(64 <= e and 1 <= n <= e and w >= 1 and h >= 0, 'internal original root and chronological history') + need(q > 2**80 and q % 2 == 1, 'admitted numerical prime lower bound') + need((w-1)**10000 < e**17 <= w**10000, 'root-coupled precision ceil(e^(17/10000))') + need(2**(h+1) <= 8*e*e and 17*(h+1) <= 20051*w, 'chronological history bound') + b = q.bit_length() + expected_L=(q**w).bit_length()+1 + expected_I=e.bit_length()+1 + expected_Q=(2*REQUESTS*gl_order(q)-1).bit_length() + need(residue_width == expected_L and residue_width <= b*w+2, 'exact canonical residue width') + need(index_width == expected_I and index_width <= 591*w, 'exact original-root index width') + need(code_width == expected_Q and code_width <= 4096*b+21, 'exact fresh pooled source vocabulary width') + return True + + +def bad_fraction(q, rank): + """Complementary-minor bound over complete GL64 low classes. + + Requires the authenticated request's split projector and invertible chart, + and unit diagonal ancestral weights. NUMERICAL.md proves this condition. + """ + need(q >= 3 and q % 2 and 1 <= rank <= 64, 'split-projector numerical domain') + return min(Fraction(1), Fraction(64*rank*(q-1), q*(q-2))) + + +def check_fallback(q, ranks, allowance=32*64*64, epsilon=EPSILON): + need(ranks and all(isinstance(r,int) and 1 <= r <= 42 for r in ranks), 'actual paid ranks and halving') + # More conservative than the completed 49,911-call caller. Retain the + # exact historical 128-row primitive bill so no saving is double counted. + primitive = 6*128*127+3*128+6*127 + need(primitive <= allowance, 'complete retained fallback children') + bounds = {r:bad_fraction(q,r) for r in ranks} + need(all(d <= epsilon for d in bounds.values()), 'per-request complete low-class bad fraction') + return bounds + + +def finite_invoice(forward, reverse, local_adds, profile, route_factors=77): + """Exact #3647 assemble9 finite coefficient with explicit new parameters. + + The retained source/normalizer/physical primitive interface is a premise; + this formula does not substitute for the actual physical cost ledger. + """ + E = sum(profile.values()) + need(E == REQUESTS and sum(r*n for r,n in profile.items()) == 1808352, 'source-bound request mass') + need(forward > 0 and reverse > 0 and local_adds >= 0 and route_factors >= 0, 'finite invoice parameters') + J = 8*32*9*(222+437)+8*(8*111*32)+2*9*32*437+2*(9*9*32) + prefix = 2**18 * forward**5 * reverse**4 + parts = { + 'unit_adds_and_bridges':9*32*local_adds+6*3*111*32, + 'J_times_high':J*16*(64*64+1)**2, + 'J_times_physical':J*PHYSICAL, + 'E_times_good':E*(8*64*64+8), + 'E_times_compiler':E*128*128**3, + 'matrix_test':16*64**3, + 'copy_erase_episodes':9*9*32, + 'selectors':2*9*32*((W-1)+437*64*(route_factors+144+2+63+64)), + 'global_prefix':prefix, + 'one':1, + } + coefficient = sum(parts.values()) + two = (coefficient+1)**2*(E+1)**2 + row = 2*(64*64+1)+9909+252 + return dict(parts=parts,coefficient=coefficient,two_level=two,J=J, + prefix_bits=prefix.bit_length(),coefficient_bits=coefficient.bit_length(), + two_level_bits=two.bit_length(),row=row,requests=E) + + +def check_finite_envelope(invoice, prefix_cap=2**192, two_cap=2**512, row_cap=20161): + need(invoice['parts']['global_prefix'] < prefix_cap, 'literal global-prefix envelope') + need(invoice['two_level'] < two_cap, 'two-level finite coefficient envelope') + need(invoice['row'] < row_cap, 'logical row coefficient envelope') + return True + + +def program_symbols(h,L,I,Q): + return 2*I+L+6+h*(Q+2*I+90) + + +def metadata_ledger(V,h,L,I,Q,q): + need(V>0 and h>=0 and min(L,I,Q)>0, 'metadata ledger domain') + return ((2**24+1)*(L+I+4)+8*program_symbols(h+1,L,I,Q) + +16*(h+3)*(2*I+L+8)+2**20*(V.bit_length()+4) + +2**32*(Q+1)+q*q+2**20) + + +def metadata_polynomial(b, offset=21): + """Coefficient of w^2 after replacing each lower degree by w^2. + + L <= (b+2)w, I <=591w, h+1<=1180w, h+3<=1182w, + Q<=4096b+offset. Excludes only the separately retained Count and q^2. + """ + Q = 4096*b+offset + return ((2**24+1)*(b+597)+8*(1182+b+2+6+1180*(Q+1182+90)) + +16*1182*(1182+b+2+8)+2**32*(Q+1)+2**20) + + +def check_local_reserve(V,h,L,I,Q,q,directory_symbols,table_symbols=0): + """Unabsorbed logical live-symbol gate; no visited-backing claim.""" + need(directory_symbols>=1 and table_symbols>=0, 'complete directory and table stock') + E=metadata_ledger(V,h,L,I,Q,q) + used=8*V+32*directory_symbols+E + need(used < 11*V, 'explicit local logical reserve') + return {'payload_allowance':8*V,'directories':32*directory_symbols,'metadata':E, + 'source_tables_separate':table_symbols,'logical_symbols':used+table_symbols} + + +def bind_compiler(receipts): + """Bind scalar admission to fresh C/D request/compiler receipts. + + The orchestrator separately runs compiler structural and independent + all-base/chart checks; a digest receipt alone is not their substitute. + """ + for variant,expected in [('C',PROFILE_C),('D',PROFILE_D)]: + row=receipts[variant] + need(row['variant']==variant and row['requests']==REQUESTS, 'fresh variant/request binding') + need({int(r):n for r,n in row['profile'].items()}==expected, 'actual pooled C/D profile') + need(row['rank_mass']==1808352 and row['kinds']=={'COPY':2592,'IDLE':63936,'MOVE':836928}, 'actual native class totals') + coverage=row['coverage'] + need(coverage['charts']==1235 and coverage['owner_pairs']==179802 and coverage['idle_enumeration']==63936, 'all actual charts, owner pairs and exactly-once idles') + need(coverage['projectors']['bases']==row['bases'] and row['bases']==(541 if variant=='C' else 542), 'fresh all-base split coverage') + need(len(coverage['projectors']['sha256'])==64, 'all-base algebra digest') + need(all(len(row[k])==64 for k in ['input_identity','source_identity','request_sha256']), 'source identity schema') + need(receipts['C']['source_identity'] != receipts['D']['source_identity'], 'carrier requires fresh source handles') + need(receipts['C']['request_sha256'] != receipts['D']['request_sha256'], 'changed literal request chronology') + need(receipts['C']['coverage']['chart_sha256']==receipts['D']['coverage']['chart_sha256'], 'same complete C/D chart inventory') + need(receipts['D']['code_bits']==receipts['C']['code_bits'], 'no additional carrier vocabulary width; derived C/D equality') + return {v:{k:receipts[v][k] for k in ('input_identity','source_identity','request_sha256','code_bits','requests','coverage')} for v in ('C','D')} + + +def rejection_controls(): + old=finite_invoice(49347,1113998,24208,PROFILE_C) + new=finite_invoice(49347,1123650,24211,PROFILE_D) + q=2**127-1 # Prime verified below by the exact Lucas-Lehmer recurrence. + L=(q*q).bit_length()+1;I=(64).bit_length()+1;Q=(2*REQUESTS*gl_order(q)-1).bit_length() + checks={ + 'old_literal_global_prefix':lambda:check_finite_envelope(new,prefix_cap=old['parts']['global_prefix']+1), + 'shortened_prefix_word':lambda:check_finite_envelope(new,prefix_cap=2**176), + 'shortened_two_level_word':lambda:check_finite_envelope(new,two_cap=2**392), + 'understated_row_envelope':lambda:check_finite_envelope(new,row_cap=18355), + 'small_prime_bad_fraction':lambda:check_fallback(3,list(PROFILE_D)), + 'unpaid_fallback':lambda:check_fallback(q,list(PROFILE_D),allowance=98681), + 'zero_bad_event_allowance':lambda:check_fallback(q,list(PROFILE_D),epsilon=Fraction(0)), + 'missing_stock':lambda:check_stock_rows(1,64,3,1), + 'large_but_incompatible_stock':lambda:check_stock_rows(stock_unit(3,1)+1,64,3,1), + 'child_recomputed_precision':lambda:check_root_domain(64,1,1,1,q,L,I,Q), + 'unbounded_history':lambda:check_root_domain(64,64,2,99999,q,L,I,Q), + 'padded_source_width':lambda:check_root_domain(64,64,2,0,q,L,I,Q+1), + 'undersized_residue_word':lambda:check_root_domain(64,64,2,0,q,1,I,Q), + 'undersized_source_word':lambda:check_root_domain(64,64,2,0,q,L,I,1), + 'undersized_root_index':lambda:check_root_domain(64,64,2,0,q,L,1,Q), + 'zero_metadata_reserve':lambda:check_local_reserve(1,0,1,1,1,3,1), + } + rejected=[] + for name,f in checks.items(): + try:f() + except ValueError:rejected.append(name) + else:raise ValueError('control unexpectedly admitted: '+name) + return rejected + + +def run(receipts=None): + geo=json.loads((ROOT/'research/bit-p111-r437-gl464-470-20261018/data/GEOMETRY.json').read_text()) + need(geo['max_route_factors']==77, 'retained geometry factor ceiling') + host=json.loads((ROOT/'research/r437-two-window-carrier/HOST-RESULT.json').read_text()) + need(host['calls']==288 and host['events']=={'old':7814016,'new':7814880}, 'published source word call/event binding') + for label,reverse,adds in [('old',1113998,24208),('new',1123650,24211)]: + row=host[label] + need(row['forward']['l1']==49347 and row['reverse']['l1']==reverse, 'retained independent coefficient coverage') + need(row['forward']['adds']==row['reverse']['adds']==adds, 'both source orientations scalar invoice') + need(sum(row['forward']['profile'].values())==sum(row['reverse']['profile'].values())==2915, 'both orientations complete local children') + old=finite_invoice(host['old']['forward']['l1'],host['old']['reverse']['l1'],host['old']['forward']['adds'],PROFILE_C,geo['max_route_factors']) + new=finite_invoice(host['new']['forward']['l1'],host['new']['reverse']['l1'],host['new']['forward']['adds'],PROFILE_D,geo['max_route_factors']) + check_finite_envelope(old);check_finite_envelope(new) + delta={k:new['parts'][k]-old['parts'][k] for k in old['parts']} + need(delta['unit_adds_and_bridges']==864 and all(v==0 for k,v in delta.items() if k not in ('unit_adds_and_bridges','global_prefix')),'complete finite coefficient difference') + # This sample is a numerical domain test, not an executed giant source. + q=2**127-1;s=4 + for _ in range(125):s=(s*s-2)%q + need(s==0,'Lucas-Lehmer prime witness q=2^127-1') + fallback=check_fallback(q,list(PROFILE_D)) + need(STOCK_MULTIPLIER==269241600,'exact compatible stock multiplier') + need(check_stock_rows(2*stock_unit(3,1),64,3,1)==2,'positive compatible stock control') + check_root_domain(64,64,2,0,q,(q*q).bit_length()+1,(64).bit_length()+1,(2*REQUESTS*gl_order(q)-1).bit_length()) + need(metadata_polynomial(0)==104541086181 and metadata_polynomial(1)-metadata_polynomial(0)==17592241506793,'coefficientwise pooled metadata polynomial') + need(1+1180*(8192*81+12311)<2**30,'new full-directory absorption base inequality') + need(1180*8192 < 3*(1+1180*(8192*81+12311)), 'linear directory numerator grows slower than factor four') + need((Fraction(10)+Fraction(1,2**125))*W/(W-1)<11, 'whole active-chain geometric reserve') + need(metadata_polynomial(0)<2**48*597 and metadata_polynomial(1)-metadata_polynomial(0)<2**48,'same named coarse metadata envelope') + refs=[ + 'research/bit-p111-r437-gl464-470-20261018/vendor/assemble9.py', + 'research/bit-p111-r437-gl464-470-20261018/data/GEOMETRY.json', + 'research/bit-p111-r437-gl464-470-20261018/code/invoice_audit.py', + 'research/r437-reverse-row-coefficient/verify.py', + 'research/r437-reverse-row-coefficient/independent.py', + 'research/r437-two-window-carrier/HOST-RESULT.json', + 'research/r437-oq4-caller-binding/RANK26-COST.md', + '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/controller.py', + 'research/r437-preparation-composition/vendor/research/selected-bit-physical-caller/inputs/pr2753/PROOF.md', + ] + return {'status':'PASS_NAMED_FINITE_COEFFICIENT_AND_CONDITIONAL_LOGICAL_STOCK_BOUNDARY', + 'compiler_binding':bind_compiler(receipts) if receipts is not None else 'NOT_RUN_COMPILER_RECEIPT_REQUIRED_FOR_INTEGRATED_ADMISSION', + 'C':old,'D':new,'exact_component_delta':delta, + 'charged_envelope':{'prefix_bits':192,'two_level_bits':512,'row_cap':20161}, + 'bad_event':{'sample_admitted_prime':str(q),'primality':'Lucas-Lehmer 127, 125 exact iterations', + 'per_rank_fraction':{str(r):str(d) for r,d in fallback.items()}, + 'uniform_q_lower_bound':'q>2^80; q source-admissible odd prime', + 'per_request_proved_bound':'min(1,64*r*(q-1)/(q*(q-2)))', + 'required_premises':['fresh split projector and invertible actual chart','complete GL64 low cover','unit diagonal ancestor weights','all high lifts preserve low classification'], + 'inherited_fallback_children':98682,'charged_allowance_per_request':131072,'all_request_allowance':131072*REQUESTS}, + 'stock':{'multiplier':STOCK_MULTIPLIER,'formula':'K=269241600*|GL64(q)|*q^(4096*(w-1)); rows=t*K^D(n), t positive integer', + 'depth':'D(n)=0 below64, else1+D(42*floor(n/64))', + 'metadata_w2_polynomial':{'constant':104541086181,'b':17592241506793}, + 'metadata_coarse_envelope':'2^48*(b+597)*w^2 +2^20*(ell(V)+4)+q^2', + 'logical_reserve':'11*V_root+F_q under stated complete-packet/root/lifetime premises', + 'fixed_physical_visited_backing_admitted':False}, + 'controls':rejection_controls(), + 'source_sha256':{p:sha256((ROOT/p).read_bytes()).hexdigest() for p in refs}, + 'scope':'Exact integer prefix/coefficient and conditional complete-low-class fallback; logical live-symbol reserve, not floating-point error/rounding, fixed-tape visited backing, complete execution time, supplier or selected-kappa admission.'} + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--write',action='store_true');ap.add_argument('--compiler-receipt',type=Path);args=ap.parse_args() + receipt=json.loads(args.compiler_receipt.read_text()) if args.compiler_receipt else None + result=run(receipt) + if args.write:(HERE/'NUMERICAL-RESULT.json').write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + print(json.dumps(result,sort_keys=True)) diff --git a/research/r437-carrier-integration/physical.py b/research/r437-carrier-integration/physical.py new file mode 100644 index 000000000..e314799b5 --- /dev/null +++ b/research/r437-carrier-integration/physical.py @@ -0,0 +1,447 @@ +"""Source-bound carrier preparation, complete geometry and completed-child consumer. + +Reuse #4062/#4025 preparation and #4077 spectator methods at their actual +boundaries. The executed completed-child fibre is explicitly factored from the unexecuted +production packet. Chris R / Clear1nsight, OpenAI Codex assistance. Apache-2.0. +""" +from pathlib import Path +from types import SimpleNamespace as NS +import ast, hashlib, importlib.util, json, sys +from functools import lru_cache +HERE=Path(__file__).resolve().parent; ROOT=HERE.parents[1] +sys.path.insert(0,str(HERE)) +import compiler +need=compiler.need + +def load(name,path): + spec=importlib.util.spec_from_file_location(name,path);m=importlib.util.module_from_spec(spec) + sys.modules[name]=m;spec.loader.exec_module(m);return m + +def acts(m):return {k:getattr(m,k) for k in ('reads','writes','moves')} +def sub(a,b):return {k:a[k]-b[k] for k in a} +def plus(rows):return {k:sum(r[k] for r in rows) for k in ('reads','writes','moves')} +def sha(x):return hashlib.sha256(x).hexdigest() +def count_value(x): + cells=x.tape.cells[1:];stop=cells.index(3) + need(all(v in(0,1) for v in cells[:stop]),'canonical observer Count') + return sum(v<','exec'),ns) + powers=ns['Powers'](env) + return powers,runtime.adapt(env,powers) + +def preparation(s,optimized=True): + import words as w,records as r,directory as d,counts,controller,macro_binding,cardinality,packet,numeric,layout,children + from cardinal_counts import Count + registry=[];old_init=r.Tape.__init__ + def record(t):old_init(t);registry.append(t) + r.Tape.__init__=record + original_callback=macro_binding.Callback;original_dir=d.high_power;original_counts=counts.high_power + if optimized: + f=load('carrier_forward_fields',ROOT/'research/r437-preparation-composition/forward_fields.py') + macro_binding.Callback=f.install(controller.Callback,r,Path(controller.__file__),vars(controller)) + prior=load('carrier_radix',ROOT/'research/r437-preparation-composition/predecessor4025/verify.py');prior.authenticate() + share=lambda value,ring,q,dimension:prior.high_power_shared(value,ring,q,dimension,cardinality.radix_power) + d.high_power=counts.high_power=share + Q=s.cat.codes.bits;I=13;L=3;n=64 + ia=w.Arena(I,256);ra=w.Arena(L,65536);mod=ra.literal(3);ring=w.Ring(mod) + program=r.Program.fixture(ia,ra,2048,2,((0,s.handle.code,2,0,0,0),),Q) + old_fields=r.Fields.fixture(ia,ra,[(s.handle.code,[[0]*64 for _ in range(64)])],Q) + old=old_fields.tape;old_count=Count.literal(1) + depth=ia.literal(1);size=ia.literal(n) + spectators=[Count.literal(x) for x in (2,3,2)] + extra=ra.literal(1);extra.head=2;ix=ia.literal(1);ix.head=2 + protected=[(x,bytes(x.cells),x.head) for x in [ra.template,ia.template]+[ra.words[i] for i in ra.live]+[ia.words[i] for i in ia.live]+[program.tape,old,old_count.tape]+[x.tape for x in spectators]] + live=(set(ra.live),set(ia.live));old_tapes=set(map(id,registry));slots=(len(ra.words),len(ia.words)) + def snapshot():return {'record':plus([acts(t.meter) for t in registry]),'residue':acts(ra.meter),'index':acts(ia.meter)} + phases={} + def phase(label,fn): + before=snapshot();out=fn();after=snapshot();phases[label]={k:sub(after[k],before[k]) for k in before};return out + old_inspect=w.Word.inspect;w.Word.inspect=lambda _s:(_ for _ in()).throw(ValueError('runtime Word decoding forbidden')) + ra.meter.peak_live=len(ra.live);ia.meter.peak_live=len(ia.live);start=snapshot() + context=phase('context_create',lambda:d.Context(ring,s.cat.codes)) + fields=phase('field_control',lambda:ia.literal(2)) + directory,prefixes=phase('directory_produce',lambda:d.produce(old,depth,old_count,s.handle.code,context)) + runtime=NS(indices=ia,arena=ra,context=context,program=program,binding=NS(codes=s.cat.codes),size=size,depth=depth) + binding=object.__new__(macro_binding.SelectedBinding);binding.specifications=s.specs + definition=NS(code=s.handle.code,plan=s.plan) + def validate(): + first=packet.read_prefix(directory,fields);directory.rewind() + try:binding.validate_residual(runtime,definition,first) + finally:first.clear() + phase('first_prefix_validate_dispose',validate) + # Full physical Layout, no reduced geometry. It computes the child spectator + # cardinalities even though the corresponding enormous payload is not built. + def make_geometry(): + columns=ia.literal(1) + page=numeric.Geometry(s.plan,ia,columns,depth,s.handle.code,program) + return page,layout.Layout(page,size,ring,3,*spectators),columns + page,geometry,columns=phase('geometry_create',make_geometry) + event=phase('child_event_controls',lambda:NS(first=ia.literal(0),second=ia.literal(126),width=ia.literal(2),depth=ia.literal(2),child_kind='good',field=0,reverse=False,half=False,source_code=s.handle.code,parent_identity=program)) + powers,method=phase('geometry_strategy',shared_geometry) if optimized else (None,layout.Layout.child_extents) + extents=phase('complete_child_extents',lambda:method(geometry,event.first,event.second,event.width,before=spectators[0])) + observed=[count_value(x) for x in extents] + expected=[2,3*3**124,2] + need(observed==expected,'actual rank2 source geometry including all124 other atoms and external gap') + need(observed[0]*observed[1]*observed[2]*3**4==12*3**128,'complete parent/child volume equality') + def make_child(): + first=packet.read_prefix(directory,fields);directory.rewind() + try:return binding.child_program(runtime,definition,event,first) + finally:first.clear() + output=phase('first_prefix_child_program_dispose',make_child) + outsha=sha(bytes(output.cells));dirsha=sha(bytes(directory.cells)) + # Exact typed handoff copies of all metadata. Payload copy remains explicit. + def handoff(): + result=[] + for src in [directory,output,prefixes.tape,*[e.tape for e in extents]]: + dst=r.Tape();d.append_tape(src,dst);dst.rewind();need(bytes(dst.cells)==bytes(src.cells),'handoff complete metadata copy');result.append(dst) + return result + handoffs=phase('metadata_handoff_copy',handoff) + def dispose(): + for t in handoffs:t.clear() + output.clear();directory.clear();prefixes.close() + for x in extents:x.close() + geometry.close();page.close();ia.free_many(columns,fields,event.first,event.second,event.width,event.depth);context.close() + phase('metadata_geometry_output_disposal',dispose) + end=snapshot();total={k:sub(end[k],start[k]) for k in start} + need(all(total[k]==plus([x[k] for x in phases.values()]) for k in total),'complete preparation phase invoice') + need(live==(set(ra.live),set(ia.live)),'preparation ownership restored') + need(all(bytes(x.cells)==raw and x.head==head for x,raw,head in protected),'borrowed bytes and heads restored') + need(all(t.head==1 and all(v==w.BLANK for v in t.cells[1:]) for t in registry if id(t) not in old_tapes),'all created metadata backing erased') + need(all(word.head==1 and all(v==w.BLANK for v in word.cells[1:]) for bank in(ia,ra) for i,word in enumerate(bank.words) if i not in bank.live),'released numerical backing erased') + if powers:need(not powers.busy,'spectator workspace released') + w.Word.inspect=old_inspect;macro_binding.Callback=original_callback;d.high_power=original_dir;counts.high_power=original_counts;r.Tape.__init__=old_init + return {'variant':s.cat.variant,'optimized':optimized,'request':s.record,'Q':Q,'n':n,'q':3,'w':1,'history_depth':1,'complete_high_cube':True,'high_cube_rows':1,'physical_payload_executed':False,'complete_parent_payload_bits':str(12*3**128),'child_spectators':[str(x) for x in observed],'child_width':2,'program_sha256':outsha,'directory_sha256':dirsha,'phases':phases,'total':total,'new_residue_slots':len(ra.words)-slots[0],'new_index_slots':len(ia.words)-slots[1],'additional_residue_peak':ra.meter.peak_live-len(live[0]),'additional_index_peak':ia.meter.peak_live-len(live[1]),'borrowed_preserved':True,'owned_erased':True,'CSE_applied':False,'CSE_reason':'No fixed-PAIR history; actual generated child is GOOD. No hypothetical CSE saving.'} + +def weighted_child(s, seed=1, losing=False, optimized=True, hoist=True): + """Complete rank2 child on four atoms; actual fresh source coefficients. + + The executable child domain B=2,G=3,S=2 is complete (972 bits). The parent + projection has G=3*3**124, whose lifting theorem is stated in PHYSICAL.md. + """ + import words as w,records as r,directory,macro_binding,packet_engine,trace,numeric,layout,episode,counts,controller,cardinality,peel,packet + from cardinal_counts import Count + registry=[];old_init=r.Tape.__init__ + def record(t):old_init(t);registry.append(t) + r.Tape.__init__=record + original_callback=macro_binding.Callback;original_dir=directory.high_power;original_counts=counts.high_power + if optimized: + f=load('carrier_forward_fields_join',ROOT/'research/r437-preparation-composition/forward_fields.py') + macro_binding.Callback=f.install(controller.Callback,r,Path(controller.__file__),vars(controller)) + prior_radix=load('carrier_radix_join',ROOT/'research/r437-preparation-composition/predecessor4025/verify.py');prior_radix.authenticate() + share=lambda value,ring,q,dimension:prior_radix.high_power_shared(value,ring,q,dimension,cardinality.radix_power) + directory.high_power=counts.high_power=share + ia=w.Arena(13,512);ra=w.Arena(3,65536);mod=ra.literal(3);ring=w.Ring(mod) + program=r.Program.fixture(ia,ra,2048,2,((0,s.handle.code,2,0,0,0),),s.cat.codes.bits) + old_fields=r.Fields.fixture(ia,ra,[(s.handle.code,[[0]*64 for _ in range(64)])],s.cat.codes.bits) + old_count=Count.literal(1) + parent_unused=Count.literal(9475) + parent_depth=ia.literal(1);parent_size=ia.literal(64) + binding=object.__new__(macro_binding.SelectedBinding);binding.specifications=s.specs + definition=NS(code=s.handle.code,plan=s.plan) + before,gap,suffix=[Count.literal(x) for x in(2,3,2)] + nbits=972;source=r.Tape();target=r.Tape() + initial=bytes(((i*17+i//3+seed*7)^(i//5))&1 for i in range(nbits)) + target_bits=bytes(((i*13+i//7+seed*3)^(i//2))&1 for i in range(nbits)) + for bit in initial:source.append(bit) + for bit in target_bits:target.append(bit) + source.rewind();target.rewind() + spectator=ra.literal(1);spectator.head=2 + protected=[(x,bytes(x.cells),x.head) for x in [ia.template,ra.template]+[ia.words[i] for i in ia.live]+[ra.words[i] for i in ra.live]+[program.tape,old_fields.tape,old_count.tape,parent_unused.tape,source,target,before.tape,gap.tape,suffix.tape]] + live=(set(ra.live),set(ia.live));prior=set(map(id,registry)) + def snapshot():return {'record':plus([acts(t.meter) for t in registry]),'residue':acts(ra.meter),'index':acts(ia.meter)} + phases={};coef_calls=[];lifetime=[] + def phase(name,fn): + x=snapshot();out=fn();y=snapshot();phases[name]={k:sub(y[k],x[k]) for k in x};return out + old_inspect=w.Word.inspect;w.Word.inspect=lambda _:(_ for _ in()).throw(ValueError('runtime numerical decoding forbidden')) + baseline=snapshot() + context=phase('context_create',lambda:directory.Context(ring,s.cat.codes)) + runtime=NS(indices=ia,arena=ra,context=context,program=program,binding=NS(codes=s.cat.codes),depth=parent_depth,size=parent_size) + current_directory,prefixes=phase('directory_produce',lambda:directory.produce(old_fields.tape,parent_depth,old_count,s.handle.code,context)) + fields=NS(tape=current_directory) + parent_fields=phase('current_fields_control',lambda:ia.literal(2)) + import packet + def first_action(action): + first=packet.read_prefix(current_directory,parent_fields);current_directory.rewind() + try:return action(first) + finally:first.clear() + phase('actual_validate_residual',lambda:first_action(lambda first:binding.validate_residual(runtime,definition,first))) + child_event=NS(child_kind='good',field=0,reverse=False,half=False) + child_program=phase('actual_child_program',lambda:first_action(lambda first:binding.child_program(runtime,definition,child_event,first))) if hoist else None + if losing: + need(hoist,'losing duplicate control belongs to paid hoisted path') + def redundant(): + duplicate=first_action(lambda first:binding.child_program(runtime,definition,child_event,first)) + need(bytes(duplicate.cells)==bytes(child_program.cells),'same output losing control');duplicate.clear() + phase('redundant_child_constructor_losing_control',redundant) + produced_program_sha=sha(bytes(child_program.cells)) if hoist else None;produced_directory_sha=sha(bytes(current_directory.cells)) + powers,geometry_method=phase('geometry_strategy',shared_geometry) if optimized else (None,layout.Layout.child_extents) + def parent_geometry(): + cols=ia.literal(1);g=numeric.Geometry(s.plan,ia,cols,parent_depth,s.handle.code,program) + ll=layout.Layout(g,parent_size,ring,3,before,gap,suffix) + first,second,width=[ia.literal(v) for v in(0,126,2)] + ext=geometry_method(ll,first,second,width,before=before) + need([count_value(y) for y in ext]==[2,3*3**124,2],'full actual parent spectator projection') + ia.free_many(first,second,width);ll.close();g.close();ia.free(cols) + return ext + parent_extents=phase('full_parent_child_extents',parent_geometry) + def handoff(): + out=[] + for src in [current_directory,child_program,prefixes.tape,parent_unused.tape,*[v.tape for v in parent_extents]]: + dst=r.Tape();directory.append_tape(src,dst);dst.rewind();need(bytes(dst.cells)==bytes(src.cells),'complete fresh metadata handoff');out.append(dst) + return out + handoffs=phase('complete_metadata_handoff',handoff) if hoist else [] + def adopt(): + child_size=ia.literal(2);child_depth=ia.literal(2);child_rows=Count.literal(1) + child_prefixes=Count(handoffs[2]) if hoist else prefixes + child_runtime=NS(indices=ia,arena=ra,context=context,binding=NS(codes=s.cat.codes),size=child_size,depth=child_depth) + child_runtime.program=macro_binding.view(r.Program,child_runtime,handoffs[1]) if hoist else program + binding.ambient=s.handle.code + incoming=binding.incoming(child_runtime) if hoist else None + return child_size,child_depth,child_rows,child_prefixes,child_runtime,incoming + child_size,child_depth,child_rows,child_prefixes,child_runtime,incoming=phase('adopt_actual_handoff_metadata' if hoist else 'baseline_child_geometry_controls',adopt) + def coefficient(prefix,request): + from dataclasses import replace + need(request.kind=='child' and request.child_kind=='good' and not request.half and not request.reverse,'typed completed GOOD child request') + eligible=(request.field==0 and request.reference is None and not request.reverse_adapter) + if hoist:eligible=eligible and w.Unsigned(ia).compare(request.coordinate,child_size)<0 + value=incoming.coefficient(prefix,replace(request,kind='incoming')) if hoist and eligible else binding.coefficient(runtime,definition,prefix,request) + v=sum(x<new['total']['residue']['moves'],'preparation residue traversal saving; other lanes retained explicitly') + need(prep[0]['total']==prep[2]['total'] and prep[1]['total']==prep[3]['total'],'exact C/D preparation equality') + return prep + if name in ('C','D','losing','reverse','reconstruct'): + return checked_child(source('C' if name=='C' else 'D',int(name=='reverse')),losing=name=='losing',hoist=name!='reconstruct') + need(name=='controls','known physical part') + acquisitions=[acquisition(source(v,stage)) for v in 'CD' for stage in(0,1)] + controls=[wrong_step_control(source('D'))] + for stage in(0,1): + try:acquisition(source('D',stage),drop_role=87) + except ValueError as e:need(str(e)=='SOURCE87 original dirty dependency read before early MOVE','missing original dirty read rejection') + else:raise ValueError('missing original dirty read accepted') + controls.append('missing original SOURCE87 dirty acquisition rejected orientation '+str(stage)) + return {'acquisition':acquisitions,'controls':controls} + +def audit(): + # Independent processes isolate the canonical runtime module namespace and + # allow a bounded replay of these expensive encoded arithmetic fixtures. + import subprocess,concurrent.futures + names=('preparation','C','D','losing','reverse','reconstruct','controls') + def run_part(name): + command=[sys.executable,'-I','-B']+([] if __debug__ else ['-O'])+[str(Path(__file__).resolve()),'--part',name] + p=subprocess.run(command,capture_output=True,text=True,timeout=600) + need(p.returncode==0,'physical part '+name+': '+p.stderr) + return json.loads(p.stdout) + with concurrent.futures.ThreadPoolExecutor(max_workers=3) as pool: + results=list(pool.map(run_part,names)) + prep=results[0];children=results[1:6] + c,d,losing,reverse,reconstruct=children + common=lambda x:{k:v for k,v in x['phases'].items() if 'consumer' not in k} + need(common(c)==common(d),'exact C/D matched complete return boundary invoice') + need(c['return_sha256']==d['return_sha256']==losing['return_sha256']==reverse['return_sha256'],'matched actual computed child return') + need(d['consumer_sha256']==losing['consumer_sha256']==reconstruct['consumer_sha256'],'genuine same-output losing construction') + need(all(reconstruct['total'][lane][action]>=d['total'][lane][action] for lane in d['total'] for action in d['total'][lane]),'paid handoff program consumption dominates rebuilding at each coefficient') + need(all(losing['total'][lane][action]>=d['total'][lane][action] for lane in d['total'] for action in d['total'][lane]),'losing control every lane paid') + need(losing['total']['record']['reads']>d['total']['record']['reads'],'redundant constructor strict loss') + acquisitions=results[6]['acquisition'];controls=results[6]['controls'] + return {'status':'PASS_SOURCE_BOUND_CARRIER_REGIONAL_CALLER','preparation_comparison':prep,'integrated_children':children,'acquisition':acquisitions,'controls':controls,'CSE':'not applied; no fixed-PAIR ancestor guard at these actual GOOD contexts','full_production_execution':False,'scope':'Actual fresh compiler -> encoded directory/program/handoff -> complete 972-bit four-atom child -> literal D consumer. Parent GL64 gather/route and124-atom spectator expansion remain quantified/inherited, not physically executed.'} + +def main(): + import argparse + p=argparse.ArgumentParser();p.add_argument('--audit',action='store_true');p.add_argument('--part',choices=('preparation','C','D','losing','reverse','reconstruct','controls'));p.add_argument('--check',action='store_true');p.add_argument('--variant',choices=['C','D'],default='D');p.add_argument('--original',action='store_true');p.add_argument('--output');p.add_argument('--atom',action='store_true');p.add_argument('--acquisition',action='store_true');p.add_argument('--stage',type=int,default=0);p.add_argument('--losing',action='store_true');a=p.parse_args() + s=None if a.audit or a.check or a.part else source(a.variant,a.stage);result=part(a.part) if a.part else audit() if a.audit or a.check else acquisition(s) if a.acquisition else checked_child(s,losing=a.losing,optimized=not a.original) if a.atom else preparation(s,not a.original) + raw=json.dumps(result,indent=2,sort_keys=True)+'\n' + if a.check: + need(json.loads((HERE/'PHYSICAL-RESULT.json').read_text())==result,'frozen complete physical receipt');print('PASS_CARRIER_PHYSICAL') + elif a.output:Path(a.output).write_text(raw) + else:print(raw) +if __name__=='__main__':main() diff --git a/research/r437-carrier-integration/residual_algebra.py b/research/r437-carrier-integration/residual_algebra.py new file mode 100644 index 000000000..a2b0ffe5b --- /dev/null +++ b/research/r437-carrier-integration/residual_algebra.py @@ -0,0 +1,146 @@ +#!/usr/bin/env python3 +"""Finite full-address residual algebra; no physical payload execution. +Apache-2.0. Chris R / Clear1nsight with OpenAI Codex assistance. +""" +from pathlib import Path +import json,hashlib,sys,argparse +P=Path(__file__).resolve().parent +sys.path.insert(0,str(P)) +import compiler + +def digest(x):return hashlib.sha256(json.dumps(x,sort_keys=True,separators=(',',':')).encode()).hexdigest() + +def need(x,msg): + if not x:raise ValueError(msg) +def eye(n):return [[int(i==j) for j in range(n)] for i in range(n)] +def mul(a,b,n): + out=[[0]*len(b[0]) for _ in a] + for i,row in enumerate(a): + for k,x in enumerate(row): + if x: + for j,y in enumerate(b[k]): + if y:out[i][j]=(out[i][j]+x*y)%n + return out + +def inv(a,n): + rows=[r[:]+e for r,e in zip(a,eye(len(a)))];m=len(a) + import math + for k in range(m): + pivot=next(i for i in range(k,m) if math.gcd(rows[i][k],n)==1) + rows[k],rows[pivot]=rows[pivot],rows[k] + c=pow(rows[k][k],-1,n);rows[k]=[x*c%n for x in rows[k]] + for i in range(m): + if i!=k: + c=rows[i][k];rows[i]=[(x-c*y)%n for x,y in zip(rows[i],rows[k])] + return [r[m:] for r in rows] +def rational(a,n):return [[x.numerator*pow(x.denominator,-1,n)%n for x in row] for row in a] +def rowadd(a,i,k,c,n):a[i]=[(x+c*y)%n for x,y in zip(a[i],a[k])] +def coladd(a,i,k,c,n): + for row in a:row[i]=(row[i]+c*row[k])%n + +def derive(projector,rank,mod): + m=len(projector);a=[list(reversed(row)) for row in projector];left=eye(m);right=eye(m) + rows=[];tails=[];pivots=[] + for k in range(rank): + col=m-1-k;pivot=a[k][col];iv=pow(pivot,-1,mod);pivots.append(pivot) + for i in range(k+1,m): + c=-a[i][col]*iv%mod;rows.append(c);rowadd(a,i,k,c,mod);rowadd(left,i,k,c,mod) + for j in range(col): + c=-a[k][j]*iv%mod;tails.append(c);coladd(a,j,col,c,mod);coladd(right,j,col,c,mod) + need(all(a[i][j]==(pivots[i] if i