diff --git a/research/selected-control-table-binding/NOTICE.md b/research/selected-control-table-binding/NOTICE.md new file mode 100644 index 0000000000..846a4c163e --- /dev/null +++ b/research/selected-control-table-binding/NOTICE.md @@ -0,0 +1,31 @@ +# Credit and exact source reuse + +Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance. +New code, proof and documentation use the repository's Apache-2.0 license. + +Jose Manuel (@jmbarrancoml) supplied PR2234's selected provider, chronological +expressions, low-class macroplans and recursive-closure proposal, and PR2310's +iterative evaluator, prepared-table tests and uniform-control argument. Those +are the principal predecessors. Their used source files and both original +notices are copied byte for byte, with original paths, exact commits, Git blobs +and SHA256 values in `SOURCES.json`. No predecessor source is edited here. + +The vendored normal-form and descriptor lineage retains source527 and the +OpenAI framework, Ross Richardson's PR2159 fallback algebra, this account's +PR2160 good normal form and PR2188 mixed descriptors, and Jose Manuel's +PR2171/2195/2207 stream continuations. Their algorithms and the diagonal +covariance argument are reused and attributed; this contribution supplies +the joined table adapter, a scoped interface proof and independent local +matrix checks. + +The selected source lineage includes DreamingOfClouds' PR589 on eumemic's +PR555 base, alephnan's retained PR1627 hosting/provider checks, Dugongue, +Rohan Arun, Zhihao Chen and the remaining contributors identified in the +retained source notices. Gareth Davidson's PR2289/2295 recurrence/moment +formalizations motivate the uniform physical-charge handoff but are not +built or claimed proved by this package. PR1379's tape parking result is +context and is not reproduced here. + +All reported checks are author-run. Independent human review, formal proof, +complete physical realization and adoption of either pending predecessor +remain separate obligations. diff --git a/research/selected-control-table-binding/PROOF.md b/research/selected-control-table-binding/PROOF.md new file mode 100644 index 0000000000..482bb7aef1 --- /dev/null +++ b/research/selected-control-table-binding/PROOF.md @@ -0,0 +1,169 @@ +# Binding full-ring preparation to the iterative control evaluator + +This is a structural compiler-interface lemma. PR2234 supplies the selected +request catalogue, full-ring projector preparation and chronological weighted +expressions; PR2310 supplies the iterative evaluator. We join those two +implementations without changing them. The weighted normal forms and diagonal +covariance are credited to source527, PR2159, this account's PR2160/2188 and +the intervening selected compiler work. They are hypotheses of this binding +lemma, not new results attributed here. + +The exact versions are PR2234 `d047ef86fbc5b1614d3d8e2b8d3441413beab73f` +and PR2310 `a5258f548bfb6da71c3b72733fbbd2fb4995c929`. Both are pending +proposals. All used source bytes and notices are retained in `sources/` and +authenticated by `SOURCES.json` before import. + +## 1. Inputs and theorem + +Fix an odd prime q, a positive atom width w and R = Z/(q^w). Fix the selected +PR589 catalogue at the base in `SOURCES.json`. Start with n_0 > 0 atoms and a +constant unit a in R. Take a finite chronological chain of h descents. For +each descent there is a selected request, an exact low GL64(F_q) matrix and +a frozen high matrix in [0,q^(w-1))^(64 by 64). The complete raw matrix is +g = low + q high. The slot number counts every descent, including unit and +orientation children. No frozen field is deleted after a unit reset. + +The chain metadata must satisfy the consumer finite-format bounds, checked +by `Program.extents`. Each event must be one of the actual children emitted by PR2234's +`residual_plan` for its current expression and low matrix. In particular: + +* A good event has the selected rank r, f = floor(n/64) > 0 and child size rf. +* A paired-diagonal event has field 0 <= j < 127, child size f, and reversal + exactly when j >= 64. Its branch is fallback, as established by the low + matrix. Arbitrarily choosing the opposite orientation is not a legal event. +* A unit event has size f; an orientation event has size floor(f/2) > 0. + Each resets the weight to the constant 1 and increments the global depth. + +Assume the named producer normal forms give the following coefficients from +the FULL unweighted matrix: good pivot vector delta, and fallback terminal +diagonal d with final original-row permutation pi. Assume the producer's +actual-label formula P = g sigma P0 sigma^-1 g^-1 and weighted normal-form +identities hold. The adapter verifies the two implemented projector routes +agree and checks that the chosen descent occurs in the emitted low macroplan; +those finite runtime checks do not replace proofs of the producer algorithms. + +**Theorem.** `compile_chain`, followed by the unmodified PR2310 `evaluate`, +returns the same unit weight as the actual PR2234 generated expression for +every valid final atom index. It reads only coefficient tables at their +original live global slots, makes no request for the current fresh matrix or +unused stock, and restores the table head. Numerical high fields at and before +the last reset need not be prepared. Replacing them while retaining the exact +low/request specifications cannot change the result. + +This algebraic theorem does not need the relation w = ceil(e^(17/10000)). +When using PR2310's cost bound, that relation and all its other physical +premises must be supplied separately. The finite fixtures here do satisfy +the relation with e = w n_0; width one is tested only at the root n_0 = 1. + +## 2. The exact table interpretation + +For a good event, put its r full-ring pivots in table entries 0 through r-1 +and pad the remaining 64-r entries with 1. Pad the unused diagonal with 1 +and unused permutation with the identity. Since an admitted final index +i < rf has floor(i/f) < r, no good evaluation can read a padded pivot. +The consumer computes + + child(i) = parent(i) delta_floor(i/f). + +This is precisely the source expression's formula. Restricting delta to its +residue modulo q changes valid weights; the replay includes such a witness. + +For a pair event use all 128 entries of the FULL unweighted elimination's +terminal diagonal and final original-row permutation. For t in [0,f), define + + b(row,t) = parent(row*f+t), if row < 64; otherwise 1. + +At a physical child index i, let t=i for a head field and t=f-1-i for a tail +field. The consumer computes + + child(i) = d_j b(pi(j),t) / b(j,t). + +These are units, so division is defined in R. It is the source FallbackPair +formula, including the complete parent coordinate and physical reversal. +The final row permutation cannot be replaced by an identity just because +the original residual is an involution. The finite control uses an actual +selected fallback with a nonidentity permutation and a nonconstant parent. + +For completeness, diagonal covariance explains why this is the relevant +weighted pivot: at a fixed atom column t, let B_t be diagonal with the 64 +incoming weights followed by 64 ones. During elimination the weighted state +is B_(pi_current,t) M_current B_t^-1. Multiplication by units preserves the +first available unit-pivot itinerary. The final weighted diagonal is +d_j b(pi(j),t)/b(j,t). This is the predecessor's covariance argument. Our +separate oracle actually eliminates B_t M B_t^-1 and compares all 128 +diagonal entries and the full original-row permutation in the listed cases. + +## 3. Extents, resets and source binding + +Induct on chronological events. Before an event, the compiled Program extent +and the source Expression extent agree. The good and pair size rules above +preserve equality. At a unit reset both use f or floor(f/2); the source starts +a new expression with `birth_depth = old_depth + 1`, while the Program keeps +the earlier size steps and inserts a unit step. Thus their final sizes and +global depth agree even though their expression histories have different +representations. Every index requested by a good or pair continuation lies +in its parent's first 64f atoms. Remainder atoms are never read. + +The source expression after the last reset contains only the suffix strictly +after that reset. The consumer's unit step also returns 1 without making a +parent request. Therefore no live evaluation reaches a table at or before +that reset. The adapter preserves those slot positions using valid neutral +pages but does not read their high matrices. It validates all historical +low/request specifications to establish that the recorded chain was legal. +The dead numerical fields themselves are outside the dependency graph. + +Before making any numerical table, the adapter checks exact equality of +`FieldSpecification(q,w,request,low)` at the specified global slot. It also +checks membership in the selected catalogue, complete frozen-prefix length +and actual macroplan-child equality. This binds request identity, chart, +rank, low class, atom orientation and chronology together. A same-rank +request is not an interchangeable source. Page tags are local slot tokens +after these exact checks; they are not cryptographic source identifiers. +Table construction never receives unused-stock coordinates. + +Starting at the final index, induction on the pending consumer request stack +now proves value equality. A root or unit event returns its stated constant; +a good continuation multiplies the matching parent value by the matching +pivot; a pair continuation evaluates its two ordered bank requests and the +matching unit quotient. These are exactly the three cases in section 2. +The predecessor reader returns the head to zero on every page read. Its +evaluator empties pending/value stacks before return and never writes page +contents. This proves the stated semantic and head boundary. + +## 4. Independent evidence and its limits + +The finite replay loads the actual selected word, hosting template and +geometry through the pinned PR2234 provider. It reconstructs 28,278 canonical +requests, 32 replicas and the 904,896-entry paid profile. This source binding +is attributed reuse, not another independent supplier census. + +The new fixtures use selected MOVE, COPY and IDLE requests, every positive +selected paid rank (1 through 7 and 42), owner data/host charts, complete +low/high matrices and mixed histories with unit resets. Their sparse raw +matrix family is constructed by the predecessor fixture routine; it is not +an enumeration of all GL64 matrices, low classes, high lifts or descendants. +Large root extents are represented by integers; no huge payload is executed. + +`oracle.py` imports no predecessor matrix or descriptor code. It constructs +the projector directly from the raw matrix, the source label and chart, +bypassing the producer's split basis. It obtains good weighted pivots from +the unreversed weighted projector by normalized forward elimination. For a +fallback it builds the full weighted 128 by 128 residual and uses normalized +Gauss-Jordan elimination, contrasting with the producer's unnormalized +algorithm. Incoming parent values and catalogue/geometry decoding are reused +explicitly. This is independent local arithmetic evidence, not a code-disjoint +proof of the complete recursive supplier. + +The finite receipt and semantic fault controls are in `RESULT.json`. Their +success corroborates the structural argument and identifies necessary +bindings. No flaw in the correctly bound predecessor evaluator is claimed. +The concurrent Discussion #2319 claim studies complete two-dimensional +dispatch; the present actual selected-dimension coefficient audit is a +separate restricted interface check, not priority for that broader program. + +We do not execute complete payload passes, owner packets, recursive children, +parking or cleanup at the physical machine level. We do not prove a uniform +bit-operation bound for this Python adapter or transfer the selected exponent. +In particular, table preparation and the descriptor stack still need joining +to the complete stream dispatcher at each actual coefficient-preparation site. +No formal proof assistant, full selected cold replay or new kappa is claimed. diff --git a/research/selected-control-table-binding/README.md b/research/selected-control-table-binding/README.md new file mode 100644 index 0000000000..78443069c1 --- /dev/null +++ b/research/selected-control-table-binding/README.md @@ -0,0 +1,69 @@ +# Actual selected BIT matrices bind to the compiled control tables + +This package joins PR2234's actual full-ring producer to PR2310's iterative +control evaluator. The adapter checks the selected request, exact frozen +field specification and actual low-class child before constructing a table. +It retains original global slots after unit resets and the fallback child's +physical atom reversal. Neither predecessor implementation is changed. + +[PROOF.md](PROOF.md) proves the structural binding for every admitted finite +chain under the stated producer normal-form hypotheses. It also shows why +numerical high fields before the last reset need not be prepared. This takes +the preparation/evaluator handoff; the claim is in +[Discussion #2304](https://github.com/CrocSwap/integer-mult-bounds/discussions/2304#discussioncomment-18941098). +It does not establish the complete payload dispatcher or a new exponent. + +The final overlap check found Jose Manuel's concurrent +[Discussion #2319](https://github.com/CrocSwap/integer-mult-bounds/discussions/2319) +claim for joined preparation and completed-child dispatch in a generic +two-dimensional caller. This package supplies a separate, scoped coefficient +binding audit on actual selected 64-dimensional requests. It does not claim +priority for the broader joined-execution handoff or duplicate that payload work. + +## Evidence and reproduction + +The source-bound replay covers 12 actual selected request representatives, +all paid ranks 1–7 and 42, and MOVE/COPY/IDLE requests. It passes 87 fixtures, +801 generated-weight comparisons and 12,642 independent local equalities. +The matrix oracle constructs the raw-label projector independently of the +producer's split basis and uses normalized elimination. Catalogue decoding +and incoming parent descriptors are explicitly reused and credited. + +Thirteen semantic controls include concrete counterexamples to low-only +coefficients (2 instead of 8), discarded row permutation (1 instead of 8) +and omitted atom reversal (8 instead of 2), all modulo 9. Other controls cover +source identity, legal child selection, reset slots and inaccessible stock. +The fixtures include mixed paths over Z/9, Z/25 and Z/27 and a width-one root. +They do not enumerate all matrices or execute large payloads. + +With Python 3.12 and the standard library, from the repository root: + +```sh +python3 scripts/research_package.py --package research/selected-control-table-binding +``` + +The hook runs normal and optimized replays plus artifact-integrity tests. +The direct command `python3 -I -B research/selected-control-table-binding/verify.py` +prints `PASS_SELECTED_CONTROL_TABLE_BINDING fixtures=87 coordinate_equalities=801 independent_equalities=12642 controls=13`. +`--emit` prints the full deterministic [receipt](RESULT.json) without writing +files. Exact base, dependency heads, source hashes and scope are in +[SOURCES.json](SOURCES.json) and [TASK.json](TASK.json). + +## Open next questions + +Coordinate with the active #2319 dispatch investigation to connect this bound evaluator to one complete stream coefficient-preparation +site, including high-header spectators, inverse cleanup and local work +lifetime. This would join semantic values to the pending physical-charge +argument; the complete payload dispatcher remains the blocker. A separate +formalization can prove the reset/extent induction on the explicit grammar. +[TASK.json](TASK.json) gives concrete first steps for both. + +## Credit and limits + +Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance. +Jose Manuel (@jmbarrancoml) supplied both pending principal predecessors; +the retained notices credit source527, Ross Richardson, this account's +PR2160/2188, and the selected supplier lineage. See [NOTICE.md](NOTICE.md). +This is an author-checked scoped proof and finite certificate. No independent +human review, Lean proof, complete physical supplier, cold replay or kappa +change is claimed. diff --git a/research/selected-control-table-binding/RESULT.json b/research/selected-control-table-binding/RESULT.json new file mode 100644 index 0000000000..461f3a3519 --- /dev/null +++ b/research/selected-control-table-binding/RESULT.json @@ -0,0 +1,8525 @@ +{ + "authenticated_sources": 17, + "catalogue": { + "base_labels": 541, + "binding_sha256": "f5a4fb124709adc4b56376a3146e3609e91c0f4d3ed1931a61785a5d99bf8ee7", + "canonical_ERASE_guards": 81, + "canonical_requests": 28278, + "chart_labels": 1235, + "full_paid_requests": 904896, + "rank_histogram": { + "1": 381024, + "2": 400416, + "3": 22752, + "4": 26880, + "5": 29376, + "6": 17376, + "7": 26784, + "42": 288 + }, + "replicas": 32, + "request_kinds": { + "COPY": 81, + "IDLE": 1998, + "MOVE": 26199 + } + }, + "controls": [ + { + "control": "low-only coefficients", + "correct": 8, + "incorrect": 2, + "index": 0 + }, + { + "control": "discard original-row permutation", + "correct": 8, + "incorrect": 1, + "index": 0 + }, + { + "control": "omit physical atom reversal", + "correct": 2, + "incorrect": 8, + "index": 0 + }, + "compact frozen slots after reset", + "swap exact field specifications", + "capture current fresh matrix", + "same-rank wrong selected request", + "orientation not in actual macroplan", + "pair on a good low class", + "unit reset absent from macroplan", + "unused stock is inaccessible", + "dead high-field change leaves tables and values unchanged", + "nonunit good pivot" + ], + "coordinate_equalities": 801, + "fixture_cases": 87, + "fixtures": [ + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 18085, + 222, + 444, + 0, + 2, + "5a7dce9c52ac8c9c23fa89766439abfc412b5242b444945289a83828ffa9ae6d", + 1, + [ + "host", + 0, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "9b9af3015059bdf6b13ff52bb2526bddb500139ecb703387ba03feca44c47c52", + "values": [ + [ + 0, + 2 + ], + [ + 1, + 2 + ], + [ + 2, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 18085, + 222, + 444, + 0, + 2, + "5a7dce9c52ac8c9c23fa89766439abfc412b5242b444945289a83828ffa9ae6d", + 1, + [ + "host", + 0, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "fbdb7617a5a5210681ab12631b1527c37d2830234f5c54f406099ad42321e81c", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 18085, + 222, + 444, + 0, + 2, + "5a7dce9c52ac8c9c23fa89766439abfc412b5242b444945289a83828ffa9ae6d", + 1, + [ + "host", + 0, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "89e65146fb4e58a0f9e417c101861e941a0ac04f0f1530693a45861f0fa6ce84", + "values": [ + [ + 0, + 8 + ], + [ + 1, + 8 + ], + [ + 2, + 8 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 18085, + 222, + 444, + 0, + 2, + "5a7dce9c52ac8c9c23fa89766439abfc412b5242b444945289a83828ffa9ae6d", + 1, + [ + "host", + 0, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "fbdb7617a5a5210681ab12631b1527c37d2830234f5c54f406099ad42321e81c", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 18085, + 222, + 444, + 0, + 2, + "5a7dce9c52ac8c9c23fa89766439abfc412b5242b444945289a83828ffa9ae6d", + 1, + [ + "host", + 0, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "61cb18dafdd3ffe66d5752914e52808ffa17357d4ba5305061a5a68a955bc61c", + "values": [ + [ + 0, + 5 + ], + [ + 1, + 5 + ], + [ + 2, + 5 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 18085, + 222, + 444, + 0, + 2, + "5a7dce9c52ac8c9c23fa89766439abfc412b5242b444945289a83828ffa9ae6d", + 1, + [ + "host", + 0, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "fbdb7617a5a5210681ab12631b1527c37d2830234f5c54f406099ad42321e81c", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 18570, + 481, + 530, + 0, + 113, + "e144a11d5462ed7aadab42b392be088174d90e04ce2a1d9b681b50393e6f78fb", + 2, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 6, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "9b9af3015059bdf6b13ff52bb2526bddb500139ecb703387ba03feca44c47c52", + "values": [ + [ + 0, + 2 + ], + [ + 1, + 2 + ], + [ + 2, + 2 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 18570, + 481, + 530, + 0, + 113, + "e144a11d5462ed7aadab42b392be088174d90e04ce2a1d9b681b50393e6f78fb", + 2, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "3b344c3b94a9836bc38b7673b254699f5c3d7ffa8aac8a77ce281290d0f5f3ab", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 18570, + 481, + 530, + 0, + 113, + "e144a11d5462ed7aadab42b392be088174d90e04ce2a1d9b681b50393e6f78fb", + 2, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 6, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "89e65146fb4e58a0f9e417c101861e941a0ac04f0f1530693a45861f0fa6ce84", + "values": [ + [ + 0, + 8 + ], + [ + 1, + 8 + ], + [ + 2, + 8 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 18570, + 481, + 530, + 0, + 113, + "e144a11d5462ed7aadab42b392be088174d90e04ce2a1d9b681b50393e6f78fb", + 2, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "3b344c3b94a9836bc38b7673b254699f5c3d7ffa8aac8a77ce281290d0f5f3ab", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 18570, + 481, + 530, + 0, + 113, + "e144a11d5462ed7aadab42b392be088174d90e04ce2a1d9b681b50393e6f78fb", + 2, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 6, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "61cb18dafdd3ffe66d5752914e52808ffa17357d4ba5305061a5a68a955bc61c", + "values": [ + [ + 0, + 5 + ], + [ + 1, + 5 + ], + [ + 2, + 5 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 18570, + 481, + 530, + 0, + 113, + "e144a11d5462ed7aadab42b392be088174d90e04ce2a1d9b681b50393e6f78fb", + 2, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "3b344c3b94a9836bc38b7673b254699f5c3d7ffa8aac8a77ce281290d0f5f3ab", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 19420, + 243, + 451, + 11, + 266, + "0af907a7e059e23b8a9c833c3f4f5ac92800de567050474b0063fed92b660118", + 3, + [ + "host", + 7, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 9, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "9b9af3015059bdf6b13ff52bb2526bddb500139ecb703387ba03feca44c47c52", + "values": [ + [ + 0, + 2 + ], + [ + 1, + 2 + ], + [ + 2, + 2 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 19420, + 243, + 451, + 11, + 266, + "0af907a7e059e23b8a9c833c3f4f5ac92800de567050474b0063fed92b660118", + 3, + [ + "host", + 7, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "fa48e27aa21d99a45b06760dd98019b83c09744943df0986da32b9f3e5e0b950", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 19420, + 243, + 451, + 11, + 266, + "0af907a7e059e23b8a9c833c3f4f5ac92800de567050474b0063fed92b660118", + 3, + [ + "host", + 7, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 9, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "89e65146fb4e58a0f9e417c101861e941a0ac04f0f1530693a45861f0fa6ce84", + "values": [ + [ + 0, + 8 + ], + [ + 1, + 8 + ], + [ + 2, + 8 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 19420, + 243, + 451, + 11, + 266, + "0af907a7e059e23b8a9c833c3f4f5ac92800de567050474b0063fed92b660118", + 3, + [ + "host", + 7, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "fa48e27aa21d99a45b06760dd98019b83c09744943df0986da32b9f3e5e0b950", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 19420, + 243, + 451, + 11, + 266, + "0af907a7e059e23b8a9c833c3f4f5ac92800de567050474b0063fed92b660118", + 3, + [ + "host", + 7, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 9, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "61cb18dafdd3ffe66d5752914e52808ffa17357d4ba5305061a5a68a955bc61c", + "values": [ + [ + 0, + 5 + ], + [ + 1, + 5 + ], + [ + 2, + 5 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 19420, + 243, + 451, + 11, + 266, + "0af907a7e059e23b8a9c833c3f4f5ac92800de567050474b0063fed92b660118", + 3, + [ + "host", + 7, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "fa48e27aa21d99a45b06760dd98019b83c09744943df0986da32b9f3e5e0b950", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 21631, + 436, + 515, + 221, + 470, + "d6e67abcb25ba3e0b7419138cec8008a305e4dbd32d3aa13909a950921a38cae", + 4, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 12, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "9b9af3015059bdf6b13ff52bb2526bddb500139ecb703387ba03feca44c47c52", + "values": [ + [ + 0, + 2 + ], + [ + 1, + 2 + ], + [ + 2, + 2 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 10, + 2 + ], + [ + 11, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 21631, + 436, + 515, + 221, + 470, + "d6e67abcb25ba3e0b7419138cec8008a305e4dbd32d3aa13909a950921a38cae", + 4, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "796877cb349e2eab2a0068feb1049e1f394ff6c1cfd7c7c5abd44f8ca6e56248", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 21631, + 436, + 515, + 221, + 470, + "d6e67abcb25ba3e0b7419138cec8008a305e4dbd32d3aa13909a950921a38cae", + 4, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 12, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "89e65146fb4e58a0f9e417c101861e941a0ac04f0f1530693a45861f0fa6ce84", + "values": [ + [ + 0, + 8 + ], + [ + 1, + 8 + ], + [ + 2, + 8 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 10, + 2 + ], + [ + 11, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 21631, + 436, + 515, + 221, + 470, + "d6e67abcb25ba3e0b7419138cec8008a305e4dbd32d3aa13909a950921a38cae", + 4, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "796877cb349e2eab2a0068feb1049e1f394ff6c1cfd7c7c5abd44f8ca6e56248", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 21631, + 436, + 515, + 221, + 470, + "d6e67abcb25ba3e0b7419138cec8008a305e4dbd32d3aa13909a950921a38cae", + 4, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 12, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "61cb18dafdd3ffe66d5752914e52808ffa17357d4ba5305061a5a68a955bc61c", + "values": [ + [ + 0, + 5 + ], + [ + 1, + 5 + ], + [ + 2, + 5 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 10, + 2 + ], + [ + 11, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 21631, + 436, + 515, + 221, + 470, + "d6e67abcb25ba3e0b7419138cec8008a305e4dbd32d3aa13909a950921a38cae", + 4, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "796877cb349e2eab2a0068feb1049e1f394ff6c1cfd7c7c5abd44f8ca6e56248", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 21710, + 229, + 446, + 5, + 336, + "997a668b363c2dd86feeae26fbfcdc7320f6820c50df9323acd70f3f566972bb", + 5, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 15, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "9b9af3015059bdf6b13ff52bb2526bddb500139ecb703387ba03feca44c47c52", + "values": [ + [ + 0, + 2 + ], + [ + 1, + 2 + ], + [ + 2, + 2 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 10, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 21710, + 229, + 446, + 5, + 336, + "997a668b363c2dd86feeae26fbfcdc7320f6820c50df9323acd70f3f566972bb", + 5, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "c93208cd8f0e7ec8dd30c95e5f6f9bf6822b8a15c4740f2e0157461fb50dab48", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 21710, + 229, + 446, + 5, + 336, + "997a668b363c2dd86feeae26fbfcdc7320f6820c50df9323acd70f3f566972bb", + 5, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 15, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "89e65146fb4e58a0f9e417c101861e941a0ac04f0f1530693a45861f0fa6ce84", + "values": [ + [ + 0, + 8 + ], + [ + 1, + 8 + ], + [ + 2, + 8 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 10, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 21710, + 229, + 446, + 5, + 336, + "997a668b363c2dd86feeae26fbfcdc7320f6820c50df9323acd70f3f566972bb", + 5, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "c93208cd8f0e7ec8dd30c95e5f6f9bf6822b8a15c4740f2e0157461fb50dab48", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 21710, + 229, + 446, + 5, + 336, + "997a668b363c2dd86feeae26fbfcdc7320f6820c50df9323acd70f3f566972bb", + 5, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 15, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "61cb18dafdd3ffe66d5752914e52808ffa17357d4ba5305061a5a68a955bc61c", + "values": [ + [ + 0, + 5 + ], + [ + 1, + 5 + ], + [ + 2, + 5 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 10, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 21710, + 229, + 446, + 5, + 336, + "997a668b363c2dd86feeae26fbfcdc7320f6820c50df9323acd70f3f566972bb", + 5, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "c93208cd8f0e7ec8dd30c95e5f6f9bf6822b8a15c4740f2e0157461fb50dab48", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 21700, + 469, + 526, + 52, + 517, + "cba8a5a7051c8791019f79a0683883e56cfb47467127932a4a14af63975f65ca", + 6, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 18, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "9b9af3015059bdf6b13ff52bb2526bddb500139ecb703387ba03feca44c47c52", + "values": [ + [ + 0, + 2 + ], + [ + 1, + 2 + ], + [ + 2, + 2 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 10, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ], + [ + 15, + 2 + ], + [ + 16, + 2 + ], + [ + 17, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 21700, + 469, + 526, + 52, + 517, + "cba8a5a7051c8791019f79a0683883e56cfb47467127932a4a14af63975f65ca", + 6, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "defda5602f437669f3ad2892c07b0fc3cba19a400aeb8c7b6dc90d3dcf3b67a2", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 21700, + 469, + 526, + 52, + 517, + "cba8a5a7051c8791019f79a0683883e56cfb47467127932a4a14af63975f65ca", + 6, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 18, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "89e65146fb4e58a0f9e417c101861e941a0ac04f0f1530693a45861f0fa6ce84", + "values": [ + [ + 0, + 8 + ], + [ + 1, + 8 + ], + [ + 2, + 8 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 10, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ], + [ + 15, + 2 + ], + [ + 16, + 2 + ], + [ + 17, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 21700, + 469, + 526, + 52, + 517, + "cba8a5a7051c8791019f79a0683883e56cfb47467127932a4a14af63975f65ca", + 6, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "defda5602f437669f3ad2892c07b0fc3cba19a400aeb8c7b6dc90d3dcf3b67a2", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 21700, + 469, + 526, + 52, + 517, + "cba8a5a7051c8791019f79a0683883e56cfb47467127932a4a14af63975f65ca", + 6, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 18, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "61cb18dafdd3ffe66d5752914e52808ffa17357d4ba5305061a5a68a955bc61c", + "values": [ + [ + 0, + 5 + ], + [ + 1, + 5 + ], + [ + 2, + 5 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 5, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 10, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ], + [ + 15, + 2 + ], + [ + 16, + 2 + ], + [ + 17, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 21700, + 469, + 526, + 52, + 517, + "cba8a5a7051c8791019f79a0683883e56cfb47467127932a4a14af63975f65ca", + 6, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "defda5602f437669f3ad2892c07b0fc3cba19a400aeb8c7b6dc90d3dcf3b67a2", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 21, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "9b9af3015059bdf6b13ff52bb2526bddb500139ecb703387ba03feca44c47c52", + "values": [ + [ + 0, + 2 + ], + [ + 1, + 2 + ], + [ + 2, + 2 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ], + [ + 16, + 2 + ], + [ + 17, + 2 + ], + [ + 18, + 2 + ], + [ + 19, + 2 + ], + [ + 20, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "541c20465adfb107add087ea5ca6e909c6cec02c2b05a51bb245e8d8f5df80f2", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 21, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "89e65146fb4e58a0f9e417c101861e941a0ac04f0f1530693a45861f0fa6ce84", + "values": [ + [ + 0, + 8 + ], + [ + 1, + 8 + ], + [ + 2, + 8 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ], + [ + 16, + 2 + ], + [ + 17, + 2 + ], + [ + 18, + 2 + ], + [ + 19, + 2 + ], + [ + 20, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "541c20465adfb107add087ea5ca6e909c6cec02c2b05a51bb245e8d8f5df80f2", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 21, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "61cb18dafdd3ffe66d5752914e52808ffa17357d4ba5305061a5a68a955bc61c", + "values": [ + [ + 0, + 5 + ], + [ + 1, + 5 + ], + [ + 2, + 5 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ], + [ + 16, + 2 + ], + [ + 17, + 2 + ], + [ + 18, + 2 + ], + [ + 19, + 2 + ], + [ + 20, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "541c20465adfb107add087ea5ca6e909c6cec02c2b05a51bb245e8d8f5df80f2", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 126, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "9b9af3015059bdf6b13ff52bb2526bddb500139ecb703387ba03feca44c47c52", + "values": [ + [ + 0, + 2 + ], + [ + 7, + 2 + ], + [ + 14, + 2 + ], + [ + 22, + 2 + ], + [ + 29, + 2 + ], + [ + 37, + 2 + ], + [ + 44, + 2 + ], + [ + 51, + 2 + ], + [ + 59, + 2 + ], + [ + 66, + 2 + ], + [ + 74, + 2 + ], + [ + 81, + 2 + ], + [ + 88, + 2 + ], + [ + 96, + 2 + ], + [ + 103, + 2 + ], + [ + 111, + 2 + ], + [ + 118, + 2 + ], + [ + 125, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "a7fd21939c4d75cb71e923bc6bccc8d3b07cba637ee7cef45a9780720968fc8d", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 126, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "89e65146fb4e58a0f9e417c101861e941a0ac04f0f1530693a45861f0fa6ce84", + "values": [ + [ + 0, + 8 + ], + [ + 7, + 2 + ], + [ + 14, + 2 + ], + [ + 22, + 2 + ], + [ + 29, + 2 + ], + [ + 37, + 2 + ], + [ + 44, + 2 + ], + [ + 51, + 2 + ], + [ + 59, + 2 + ], + [ + 66, + 2 + ], + [ + 74, + 2 + ], + [ + 81, + 2 + ], + [ + 88, + 2 + ], + [ + 96, + 2 + ], + [ + 103, + 2 + ], + [ + 111, + 2 + ], + [ + 118, + 2 + ], + [ + 125, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "a7fd21939c4d75cb71e923bc6bccc8d3b07cba637ee7cef45a9780720968fc8d", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 126, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "61cb18dafdd3ffe66d5752914e52808ffa17357d4ba5305061a5a68a955bc61c", + "values": [ + [ + 0, + 5 + ], + [ + 7, + 2 + ], + [ + 14, + 2 + ], + [ + 22, + 2 + ], + [ + 29, + 2 + ], + [ + 37, + 2 + ], + [ + 44, + 2 + ], + [ + 51, + 2 + ], + [ + 59, + 2 + ], + [ + 66, + 2 + ], + [ + 74, + 2 + ], + [ + 81, + 2 + ], + [ + 88, + 2 + ], + [ + 96, + 2 + ], + [ + 103, + 2 + ], + [ + 111, + 2 + ], + [ + 118, + 2 + ], + [ + 125, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "a7fd21939c4d75cb71e923bc6bccc8d3b07cba637ee7cef45a9780720968fc8d", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "COPY", + 0, + 21816, + 472, + 28416, + 510, + 0, + "c097fc120eea0e30ceaae6f2f6bad489ec86945dfecb852fb50c2d46d64185cd", + 7, + [ + "identity", + -1, + -1, + [] + ], + "common", + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ] + ], + 0, + false, + false + ] + ], + "final_size": 21, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "9b9af3015059bdf6b13ff52bb2526bddb500139ecb703387ba03feca44c47c52", + "values": [ + [ + 0, + 2 + ], + [ + 1, + 2 + ], + [ + 2, + 2 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ], + [ + 16, + 2 + ], + [ + 17, + 2 + ], + [ + 18, + 2 + ], + [ + 19, + 2 + ], + [ + 20, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "COPY", + 0, + 21816, + 472, + 28416, + 510, + 0, + "c097fc120eea0e30ceaae6f2f6bad489ec86945dfecb852fb50c2d46d64185cd", + 7, + [ + "identity", + -1, + -1, + [] + ], + "common", + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ] + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "541c20465adfb107add087ea5ca6e909c6cec02c2b05a51bb245e8d8f5df80f2", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "COPY", + 0, + 21816, + 472, + 28416, + 510, + 0, + "c097fc120eea0e30ceaae6f2f6bad489ec86945dfecb852fb50c2d46d64185cd", + 7, + [ + "identity", + -1, + -1, + [] + ], + "common", + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ] + ], + 0, + false, + false + ] + ], + "final_size": 21, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "89e65146fb4e58a0f9e417c101861e941a0ac04f0f1530693a45861f0fa6ce84", + "values": [ + [ + 0, + 8 + ], + [ + 1, + 8 + ], + [ + 2, + 8 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ], + [ + 16, + 2 + ], + [ + 17, + 2 + ], + [ + 18, + 2 + ], + [ + 19, + 2 + ], + [ + 20, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "COPY", + 0, + 21816, + 472, + 28416, + 510, + 0, + "c097fc120eea0e30ceaae6f2f6bad489ec86945dfecb852fb50c2d46d64185cd", + 7, + [ + "identity", + -1, + -1, + [] + ], + "common", + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ] + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "541c20465adfb107add087ea5ca6e909c6cec02c2b05a51bb245e8d8f5df80f2", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "COPY", + 0, + 21816, + 472, + 28416, + 510, + 0, + "c097fc120eea0e30ceaae6f2f6bad489ec86945dfecb852fb50c2d46d64185cd", + 7, + [ + "identity", + -1, + -1, + [] + ], + "common", + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ] + ], + 0, + false, + false + ] + ], + "final_size": 21, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "61cb18dafdd3ffe66d5752914e52808ffa17357d4ba5305061a5a68a955bc61c", + "values": [ + [ + 0, + 5 + ], + [ + 1, + 5 + ], + [ + 2, + 5 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ], + [ + 16, + 2 + ], + [ + 17, + 2 + ], + [ + 18, + 2 + ], + [ + 19, + 2 + ], + [ + 20, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "COPY", + 0, + 21816, + 472, + 28416, + 510, + 0, + "c097fc120eea0e30ceaae6f2f6bad489ec86945dfecb852fb50c2d46d64185cd", + 7, + [ + "identity", + -1, + -1, + [] + ], + "common", + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ] + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "541c20465adfb107add087ea5ca6e909c6cec02c2b05a51bb245e8d8f5df80f2", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "COPY", + 0, + 22296, + 480, + 28416, + 518, + 0, + "8b61ca0ec188bdff78363fab35f5a7754e5833417fc20f1c300534cdeb6feefb", + 7, + [ + "identity", + -1, + -1, + [] + ], + "common", + [ + "host", + 86, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ] + ], + 0, + false, + false + ] + ], + "final_size": 21, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "9b9af3015059bdf6b13ff52bb2526bddb500139ecb703387ba03feca44c47c52", + "values": [ + [ + 0, + 2 + ], + [ + 1, + 2 + ], + [ + 2, + 2 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ], + [ + 16, + 2 + ], + [ + 17, + 2 + ], + [ + 18, + 2 + ], + [ + 19, + 2 + ], + [ + 20, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "COPY", + 0, + 22296, + 480, + 28416, + 518, + 0, + "8b61ca0ec188bdff78363fab35f5a7754e5833417fc20f1c300534cdeb6feefb", + 7, + [ + "identity", + -1, + -1, + [] + ], + "common", + [ + "host", + 86, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ] + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "541c20465adfb107add087ea5ca6e909c6cec02c2b05a51bb245e8d8f5df80f2", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "COPY", + 0, + 22296, + 480, + 28416, + 518, + 0, + "8b61ca0ec188bdff78363fab35f5a7754e5833417fc20f1c300534cdeb6feefb", + 7, + [ + "identity", + -1, + -1, + [] + ], + "common", + [ + "host", + 86, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ] + ], + 0, + false, + false + ] + ], + "final_size": 21, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "89e65146fb4e58a0f9e417c101861e941a0ac04f0f1530693a45861f0fa6ce84", + "values": [ + [ + 0, + 8 + ], + [ + 1, + 8 + ], + [ + 2, + 8 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ], + [ + 16, + 2 + ], + [ + 17, + 2 + ], + [ + 18, + 2 + ], + [ + 19, + 2 + ], + [ + 20, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "COPY", + 0, + 22296, + 480, + 28416, + 518, + 0, + "8b61ca0ec188bdff78363fab35f5a7754e5833417fc20f1c300534cdeb6feefb", + 7, + [ + "identity", + -1, + -1, + [] + ], + "common", + [ + "host", + 86, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ] + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "541c20465adfb107add087ea5ca6e909c6cec02c2b05a51bb245e8d8f5df80f2", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "COPY", + 0, + 22296, + 480, + 28416, + 518, + 0, + "8b61ca0ec188bdff78363fab35f5a7754e5833417fc20f1c300534cdeb6feefb", + 7, + [ + "identity", + -1, + -1, + [] + ], + "common", + [ + "host", + 86, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ] + ], + 0, + false, + false + ] + ], + "final_size": 21, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "61cb18dafdd3ffe66d5752914e52808ffa17357d4ba5305061a5a68a955bc61c", + "values": [ + [ + 0, + 5 + ], + [ + 1, + 5 + ], + [ + 2, + 5 + ], + [ + 3, + 2 + ], + [ + 4, + 2 + ], + [ + 6, + 2 + ], + [ + 7, + 2 + ], + [ + 8, + 2 + ], + [ + 9, + 2 + ], + [ + 11, + 2 + ], + [ + 12, + 2 + ], + [ + 13, + 2 + ], + [ + 14, + 2 + ], + [ + 16, + 2 + ], + [ + 17, + 2 + ], + [ + 18, + 2 + ], + [ + 19, + 2 + ], + [ + 20, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "COPY", + 0, + 22296, + 480, + 28416, + 518, + 0, + "8b61ca0ec188bdff78363fab35f5a7754e5833417fc20f1c300534cdeb6feefb", + 7, + [ + "identity", + -1, + -1, + [] + ], + "common", + [ + "host", + 86, + -1, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ] + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "541c20465adfb107add087ea5ca6e909c6cec02c2b05a51bb245e8d8f5df80f2", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 8, + 18568, + 6, + 672, + 8, + 113, + "3e44c760dd24f98e43624503620dd0b2eba4b0049670695496526f68c3d2e25c", + 1, + [ + "data", + 6, + 8, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "9b9af3015059bdf6b13ff52bb2526bddb500139ecb703387ba03feca44c47c52", + "values": [ + [ + 0, + 2 + ], + [ + 1, + 2 + ], + [ + 2, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 8, + 18568, + 6, + 672, + 8, + 113, + "3e44c760dd24f98e43624503620dd0b2eba4b0049670695496526f68c3d2e25c", + 1, + [ + "data", + 6, + 8, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "fbdb7617a5a5210681ab12631b1527c37d2830234f5c54f406099ad42321e81c", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 8, + 18568, + 6, + 672, + 8, + 113, + "3e44c760dd24f98e43624503620dd0b2eba4b0049670695496526f68c3d2e25c", + 1, + [ + "data", + 6, + 8, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "89e65146fb4e58a0f9e417c101861e941a0ac04f0f1530693a45861f0fa6ce84", + "values": [ + [ + 0, + 8 + ], + [ + 1, + 8 + ], + [ + 2, + 8 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 8, + 18568, + 6, + 672, + 8, + 113, + "3e44c760dd24f98e43624503620dd0b2eba4b0049670695496526f68c3d2e25c", + 1, + [ + "data", + 6, + 8, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "fbdb7617a5a5210681ab12631b1527c37d2830234f5c54f406099ad42321e81c", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 8, + 18568, + 6, + 672, + 8, + 113, + "3e44c760dd24f98e43624503620dd0b2eba4b0049670695496526f68c3d2e25c", + 1, + [ + "data", + 6, + 8, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "61cb18dafdd3ffe66d5752914e52808ffa17357d4ba5305061a5a68a955bc61c", + "values": [ + [ + 0, + 5 + ], + [ + 1, + 5 + ], + [ + 2, + 5 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 8, + 18568, + 6, + 672, + 8, + 113, + "3e44c760dd24f98e43624503620dd0b2eba4b0049670695496526f68c3d2e25c", + 1, + [ + "data", + 6, + 8, + [] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "fbdb7617a5a5210681ab12631b1527c37d2830234f5c54f406099ad42321e81c", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 18087, + 223, + 444, + 0, + 2, + "5a7dce9c52ac8c9c23fa89766439abfc412b5242b444945289a83828ffa9ae6d", + 1, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "9b9af3015059bdf6b13ff52bb2526bddb500139ecb703387ba03feca44c47c52", + "values": [ + [ + 0, + 2 + ], + [ + 1, + 2 + ], + [ + 2, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 18087, + 223, + 444, + 0, + 2, + "5a7dce9c52ac8c9c23fa89766439abfc412b5242b444945289a83828ffa9ae6d", + 1, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "fbdb7617a5a5210681ab12631b1527c37d2830234f5c54f406099ad42321e81c", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 18087, + 223, + 444, + 0, + 2, + "5a7dce9c52ac8c9c23fa89766439abfc412b5242b444945289a83828ffa9ae6d", + 1, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "89e65146fb4e58a0f9e417c101861e941a0ac04f0f1530693a45861f0fa6ce84", + "values": [ + [ + 0, + 8 + ], + [ + 1, + 8 + ], + [ + 2, + 8 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 18087, + 223, + 444, + 0, + 2, + "5a7dce9c52ac8c9c23fa89766439abfc412b5242b444945289a83828ffa9ae6d", + 1, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "fbdb7617a5a5210681ab12631b1527c37d2830234f5c54f406099ad42321e81c", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "MOVE", + 0, + 18087, + 223, + 444, + 0, + 2, + "5a7dce9c52ac8c9c23fa89766439abfc412b5242b444945289a83828ffa9ae6d", + 1, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "61cb18dafdd3ffe66d5752914e52808ffa17357d4ba5305061a5a68a955bc61c", + "values": [ + [ + 0, + 5 + ], + [ + 1, + 5 + ], + [ + 2, + 5 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "pair", + [ + "MOVE", + 0, + 18087, + 223, + 444, + 0, + 2, + "5a7dce9c52ac8c9c23fa89766439abfc412b5242b444945289a83828ffa9ae6d", + 1, + [ + "host", + -1, + -1, + [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + ], + "owner", + null + ], + 0, + false, + false + ] + ], + "final_size": 3, + "global_slots_read": [ + 0 + ], + "q": 3, + "root_size": 209, + "root_unit": 2, + "table_sha256": "fbdb7617a5a5210681ab12631b1527c37d2830234f5c54f406099ad42321e81c", + "values": [ + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 1, + false, + false + ] + ], + "final_size": 172032, + "global_slots_read": [ + 0, + 1 + ], + "path": "good_pair_forward", + "q": 3, + "root_size": 16777233, + "root_unit": 2, + "table_sha256": "99515d0c3bc3aefe6aba514b862ecfa8460e72a7cd06edca465cf4e045aca45c", + "values": [ + [ + 0, + 8 + ], + [ + 10119, + 8 + ], + [ + 20239, + 8 + ], + [ + 30358, + 8 + ], + [ + 40478, + 8 + ], + [ + 50597, + 8 + ], + [ + 60717, + 8 + ], + [ + 70836, + 8 + ], + [ + 80956, + 8 + ], + [ + 91075, + 5 + ], + [ + 101195, + 5 + ], + [ + 111314, + 5 + ], + [ + 121434, + 5 + ], + [ + 131553, + 5 + ], + [ + 141673, + 5 + ], + [ + 151792, + 5 + ], + [ + 161912, + 5 + ], + [ + 172031, + 5 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 126, + true, + false + ] + ], + "final_size": 172032, + "global_slots_read": [ + 0, + 1 + ], + "path": "good_pair_reverse", + "q": 3, + "root_size": 16777233, + "root_unit": 2, + "table_sha256": "99515d0c3bc3aefe6aba514b862ecfa8460e72a7cd06edca465cf4e045aca45c", + "values": [ + [ + 0, + 2 + ], + [ + 10119, + 2 + ], + [ + 20239, + 2 + ], + [ + 30358, + 2 + ], + [ + 40478, + 2 + ], + [ + 50597, + 2 + ], + [ + 60717, + 2 + ], + [ + 70836, + 2 + ], + [ + 80956, + 2 + ], + [ + 91075, + 8 + ], + [ + 101195, + 8 + ], + [ + 111314, + 8 + ], + [ + 121434, + 8 + ], + [ + 131553, + 8 + ], + [ + 141673, + 8 + ], + [ + 151792, + 8 + ], + [ + 161912, + 8 + ], + [ + 172031, + 8 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 1, + false, + false + ], + [ + "good", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 126, + true, + false + ] + ], + "final_size": 294, + "global_slots_read": [ + 0, + 1, + 2, + 3 + ], + "path": "good_pair_good_pair", + "q": 3, + "root_size": 16777233, + "root_unit": 2, + "table_sha256": "bcd74e63fba1f4cc88bf9e1830ccca5d9e3791b022dfecf0363f2b5780433d05", + "values": [ + [ + 0, + 2 + ], + [ + 17, + 2 + ], + [ + 34, + 2 + ], + [ + 51, + 2 + ], + [ + 69, + 2 + ], + [ + 86, + 2 + ], + [ + 103, + 2 + ], + [ + 121, + 2 + ], + [ + 138, + 2 + ], + [ + 155, + 2 + ], + [ + 172, + 2 + ], + [ + 190, + 2 + ], + [ + 207, + 2 + ], + [ + 224, + 2 + ], + [ + 242, + 2 + ], + [ + 259, + 2 + ], + [ + 276, + 2 + ], + [ + 293, + 2 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "unit", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + true + ], + [ + "good", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 126, + true, + false + ] + ], + "final_size": 147, + "global_slots_read": [ + 2, + 3 + ], + "path": "good_reset_good_pair", + "q": 3, + "root_size": 16777233, + "root_unit": 2, + "table_sha256": "8279bb785703296ccaad6e4428f5abf453fc7d9af62c40d458b640576fd92b69", + "values": [ + [ + 0, + 7 + ], + [ + 8, + 7 + ], + [ + 17, + 7 + ], + [ + 25, + 7 + ], + [ + 34, + 7 + ], + [ + 43, + 7 + ], + [ + 51, + 7 + ], + [ + 60, + 7 + ], + [ + 69, + 7 + ], + [ + 77, + 7 + ], + [ + 86, + 7 + ], + [ + 95, + 7 + ], + [ + 103, + 7 + ], + [ + 112, + 7 + ], + [ + 121, + 7 + ], + [ + 129, + 7 + ], + [ + 138, + 7 + ], + [ + 146, + 7 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "unit", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 126, + true, + false + ] + ], + "final_size": 2688, + "global_slots_read": [ + 2 + ], + "path": "good_reset_pair", + "q": 3, + "root_size": 16777233, + "root_unit": 2, + "table_sha256": "b7ec4ed1d601d0fdb407c4b2463438b26278bd3a1d8006bc01bbd1e7de0882b5", + "values": [ + [ + 0, + 1 + ], + [ + 158, + 1 + ], + [ + 316, + 1 + ], + [ + 474, + 1 + ], + [ + 632, + 1 + ], + [ + 790, + 1 + ], + [ + 948, + 1 + ], + [ + 1106, + 1 + ], + [ + 1264, + 1 + ], + [ + 1423, + 1 + ], + [ + 1581, + 1 + ], + [ + 1739, + 1 + ], + [ + 1897, + 1 + ], + [ + 2055, + 1 + ], + [ + 2213, + 1 + ], + [ + 2371, + 1 + ], + [ + 2529, + 1 + ], + [ + 2687, + 1 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 1, + false, + false + ] + ], + "final_size": 172032, + "global_slots_read": [ + 0, + 1 + ], + "path": "good_pair_forward", + "q": 5, + "root_size": 16777233, + "root_unit": 2, + "table_sha256": "de41fb78982d58a6072e4ec18b1ce4749d38174134e14d56d026902e8419dead", + "values": [ + [ + 0, + 23 + ], + [ + 10119, + 23 + ], + [ + 20239, + 23 + ], + [ + 30358, + 23 + ], + [ + 40478, + 23 + ], + [ + 50597, + 23 + ], + [ + 60717, + 23 + ], + [ + 70836, + 23 + ], + [ + 80956, + 23 + ], + [ + 91075, + 13 + ], + [ + 101195, + 13 + ], + [ + 111314, + 13 + ], + [ + 121434, + 13 + ], + [ + 131553, + 13 + ], + [ + 141673, + 13 + ], + [ + 151792, + 13 + ], + [ + 161912, + 13 + ], + [ + 172031, + 13 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 126, + true, + false + ] + ], + "final_size": 172032, + "global_slots_read": [ + 0, + 1 + ], + "path": "good_pair_reverse", + "q": 5, + "root_size": 16777233, + "root_unit": 2, + "table_sha256": "de41fb78982d58a6072e4ec18b1ce4749d38174134e14d56d026902e8419dead", + "values": [ + [ + 0, + 2 + ], + [ + 10119, + 2 + ], + [ + 20239, + 2 + ], + [ + 30358, + 2 + ], + [ + 40478, + 2 + ], + [ + 50597, + 2 + ], + [ + 60717, + 2 + ], + [ + 70836, + 2 + ], + [ + 80956, + 2 + ], + [ + 91075, + 12 + ], + [ + 101195, + 12 + ], + [ + 111314, + 12 + ], + [ + 121434, + 12 + ], + [ + 131553, + 12 + ], + [ + 141673, + 12 + ], + [ + 151792, + 12 + ], + [ + 161912, + 12 + ], + [ + 172031, + 12 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 1, + false, + false + ], + [ + "good", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 126, + true, + false + ] + ], + "final_size": 294, + "global_slots_read": [ + 0, + 1, + 2, + 3 + ], + "path": "good_pair_good_pair", + "q": 5, + "root_size": 16777233, + "root_unit": 2, + "table_sha256": "1d0ae30dcb30be87f5fec07d59e31e917101ab2858c9b713112f9d45adb9575d", + "values": [ + [ + 0, + 3 + ], + [ + 17, + 3 + ], + [ + 34, + 3 + ], + [ + 51, + 3 + ], + [ + 69, + 3 + ], + [ + 86, + 3 + ], + [ + 103, + 3 + ], + [ + 121, + 3 + ], + [ + 138, + 3 + ], + [ + 155, + 3 + ], + [ + 172, + 3 + ], + [ + 190, + 3 + ], + [ + 207, + 3 + ], + [ + 224, + 3 + ], + [ + 242, + 3 + ], + [ + 259, + 3 + ], + [ + 276, + 3 + ], + [ + 293, + 3 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "unit", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + true + ], + [ + "good", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 126, + true, + false + ] + ], + "final_size": 147, + "global_slots_read": [ + 2, + 3 + ], + "path": "good_reset_good_pair", + "q": 5, + "root_size": 16777233, + "root_unit": 2, + "table_sha256": "ec194c3f072e45fc54d9466fd3adbb3098dbb76db323cb4d5cf0ff936f7559ca", + "values": [ + [ + 0, + 11 + ], + [ + 8, + 11 + ], + [ + 17, + 11 + ], + [ + 25, + 11 + ], + [ + 34, + 11 + ], + [ + 43, + 11 + ], + [ + 51, + 11 + ], + [ + 60, + 11 + ], + [ + 69, + 11 + ], + [ + 77, + 11 + ], + [ + 86, + 11 + ], + [ + 95, + 11 + ], + [ + 103, + 11 + ], + [ + 112, + 11 + ], + [ + 121, + 11 + ], + [ + 129, + 11 + ], + [ + 138, + 11 + ], + [ + 146, + 11 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "unit", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 126, + true, + false + ] + ], + "final_size": 2688, + "global_slots_read": [ + 2 + ], + "path": "good_reset_pair", + "q": 5, + "root_size": 16777233, + "root_unit": 2, + "table_sha256": "94cad3885918196c75eedcc6a90a92609e38b2cc7347f540ff08046184349b18", + "values": [ + [ + 0, + 1 + ], + [ + 158, + 1 + ], + [ + 316, + 1 + ], + [ + 474, + 1 + ], + [ + 632, + 1 + ], + [ + 790, + 1 + ], + [ + 948, + 1 + ], + [ + 1106, + 1 + ], + [ + 1264, + 1 + ], + [ + 1423, + 1 + ], + [ + 1581, + 1 + ], + [ + 1739, + 1 + ], + [ + 1897, + 1 + ], + [ + 2055, + 1 + ], + [ + 2213, + 1 + ], + [ + 2371, + 1 + ], + [ + 2529, + 1 + ], + [ + 2687, + 1 + ] + ], + "width": 2 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 1, + false, + false + ] + ], + "final_size": 42548743626221119203496369696051945396123716248579675244096095665773295429526890173043871107367763515650466610760408482827294029581859024153136900154488885463029696226285009764352, + "global_slots_read": [ + 0, + 1 + ], + "path": "good_pair_forward", + "q": 3, + "root_size": 4149515568880992958512407863691161151012446232242436899995657329690652811412908146399707048947103794288197886611300789182395151075411775307886874834113963687061181803401509523685376, + "root_unit": 2, + "table_sha256": "b3d3c0fda91bf1f690a1a955b2aa85de6f54bd77a57a464583396250266cae51", + "values": [ + [ + 0, + 17 + ], + [ + 2502867272130654070793904099767761493889630367563510308476240921516076201736875892531992418080456677391203918280024028401605531151874060244302170597322875615472335072134412339079, + 17 + ], + [ + 5005734544261308141587808199535522987779260735127020616952481843032152403473751785063984836160913354782407836560048056803211062303748120488604341194645751230944670144268824678159, + 17 + ], + [ + 7508601816391962212381712299303284481668891102690530925428722764548228605210627677595977254241370032173611754840072085204816593455622180732906511791968626846417005216403237017238, + 17 + ], + [ + 10011469088522616283175616399071045975558521470254041233904963686064304806947503570127969672321826709564815673120096113606422124607496240977208682389291502461889340288537649356318, + 17 + ], + [ + 12514336360653270353969520498838807469448151837817551542381204607580381008684379462659962090402283386956019591400120142008027655759370301221510852986614378077361675360672061695397, + 17 + ], + [ + 15017203632783924424763424598606568963337782205381061850857445529096457210421255355191954508482740064347223509680144170409633186911244361465813023583937253692834010432806474034477, + 17 + ], + [ + 17520070904914578495557328698374330457227412572944572159333686450612533412158131247723946926563196741738427427960168198811238718063118421710115194181260129308306345504940886373556, + 17 + ], + [ + 20022938177045232566351232798142091951117042940508082467809927372128609613895007140255939344643653419129631346240192227212844249214992481954417364778583004923778680577075298712636, + 17 + ], + [ + 22525805449175886637145136897909853445006673308071592776286168293644685815631883032787931762724110096520835264520216255614449780366866542198719535375905880539251015649209711051715, + 14 + ], + [ + 25028672721306540707939040997677614938896303675635103084762409215160762017368758925319924180804566773912039182800240284016055311518740602443021705973228756154723350721344123390795, + 14 + ], + [ + 27531539993437194778732945097445376432785934043198613393238650136676838219105634817851916598885023451303243101080264312417660842670614662687323876570551631770195685793478535729874, + 14 + ], + [ + 30034407265567848849526849197213137926675564410762123701714891058192914420842510710383909016965480128694447019360288340819266373822488722931626047167874507385668020865612948068954, + 14 + ], + [ + 32537274537698502920320753296980899420565194778325634010191131979708990622579386602915901435045936806085650937640312369220871904974362783175928217765197383001140355937747360408033, + 14 + ], + [ + 35040141809829156991114657396748660914454825145889144318667372901225066824316262495447893853126393483476854855920336397622477436126236843420230388362520258616612691009881772747113, + 14 + ], + [ + 37543009081959811061908561496516422408344455513452654627143613822741143026053138387979886271206850160868058774200360426024082967278110903664532558959843134232085026082016185086192, + 14 + ], + [ + 40045876354090465132702465596284183902234085881016164935619854744257219227790014280511878689287306838259262692480384454425688498429984963908834729557166009847557361154150597425272, + 14 + ], + [ + 42548743626221119203496369696051945396123716248579675244096095665773295429526890173043871107367763515650466610760408482827294029581859024153136900154488885463029696226285009764351, + 14 + ] + ], + "width": 3 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 126, + true, + false + ] + ], + "final_size": 42548743626221119203496369696051945396123716248579675244096095665773295429526890173043871107367763515650466610760408482827294029581859024153136900154488885463029696226285009764352, + "global_slots_read": [ + 0, + 1 + ], + "path": "good_pair_reverse", + "q": 3, + "root_size": 4149515568880992958512407863691161151012446232242436899995657329690652811412908146399707048947103794288197886611300789182395151075411775307886874834113963687061181803401509523685376, + "root_unit": 2, + "table_sha256": "b3d3c0fda91bf1f690a1a955b2aa85de6f54bd77a57a464583396250266cae51", + "values": [ + [ + 0, + 2 + ], + [ + 2502867272130654070793904099767761493889630367563510308476240921516076201736875892531992418080456677391203918280024028401605531151874060244302170597322875615472335072134412339079, + 2 + ], + [ + 5005734544261308141587808199535522987779260735127020616952481843032152403473751785063984836160913354782407836560048056803211062303748120488604341194645751230944670144268824678159, + 2 + ], + [ + 7508601816391962212381712299303284481668891102690530925428722764548228605210627677595977254241370032173611754840072085204816593455622180732906511791968626846417005216403237017238, + 2 + ], + [ + 10011469088522616283175616399071045975558521470254041233904963686064304806947503570127969672321826709564815673120096113606422124607496240977208682389291502461889340288537649356318, + 2 + ], + [ + 12514336360653270353969520498838807469448151837817551542381204607580381008684379462659962090402283386956019591400120142008027655759370301221510852986614378077361675360672061695397, + 2 + ], + [ + 15017203632783924424763424598606568963337782205381061850857445529096457210421255355191954508482740064347223509680144170409633186911244361465813023583937253692834010432806474034477, + 2 + ], + [ + 17520070904914578495557328698374330457227412572944572159333686450612533412158131247723946926563196741738427427960168198811238718063118421710115194181260129308306345504940886373556, + 2 + ], + [ + 20022938177045232566351232798142091951117042940508082467809927372128609613895007140255939344643653419129631346240192227212844249214992481954417364778583004923778680577075298712636, + 2 + ], + [ + 22525805449175886637145136897909853445006673308071592776286168293644685815631883032787931762724110096520835264520216255614449780366866542198719535375905880539251015649209711051715, + 8 + ], + [ + 25028672721306540707939040997677614938896303675635103084762409215160762017368758925319924180804566773912039182800240284016055311518740602443021705973228756154723350721344123390795, + 8 + ], + [ + 27531539993437194778732945097445376432785934043198613393238650136676838219105634817851916598885023451303243101080264312417660842670614662687323876570551631770195685793478535729874, + 8 + ], + [ + 30034407265567848849526849197213137926675564410762123701714891058192914420842510710383909016965480128694447019360288340819266373822488722931626047167874507385668020865612948068954, + 8 + ], + [ + 32537274537698502920320753296980899420565194778325634010191131979708990622579386602915901435045936806085650937640312369220871904974362783175928217765197383001140355937747360408033, + 8 + ], + [ + 35040141809829156991114657396748660914454825145889144318667372901225066824316262495447893853126393483476854855920336397622477436126236843420230388362520258616612691009881772747113, + 8 + ], + [ + 37543009081959811061908561496516422408344455513452654627143613822741143026053138387979886271206850160868058774200360426024082967278110903664532558959843134232085026082016185086192, + 8 + ], + [ + 40045876354090465132702465596284183902234085881016164935619854744257219227790014280511878689287306838259262692480384454425688498429984963908834729557166009847557361154150597425272, + 8 + ], + [ + 42548743626221119203496369696051945396123716248579675244096095665773295429526890173043871107367763515650466610760408482827294029581859024153136900154488885463029696226285009764351, + 8 + ] + ], + "width": 3 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 1, + false, + false + ], + [ + "good", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 126, + true, + false + ] + ], + "final_size": 72715138033092733013787741179776273870328616635756280934734538491311784181320368948073021912005455226941715399248744965769301320086184855730458569599956591367482391011717545984, + "global_slots_read": [ + 0, + 1, + 2, + 3 + ], + "path": "good_pair_good_pair", + "q": 3, + "root_size": 4149515568880992958512407863691161151012446232242436899995657329690652811412908146399707048947103794288197886611300789182395151075411775307886874834113963687061181803401509523685376, + "root_unit": 2, + "table_sha256": "0a16857a2efc91e8e140f273661a9f9fb61098005c6d7d5f1a3a92547ef146e9", + "values": [ + [ + 0, + 11 + ], + [ + 4277361060770160765516925951751545521784036272691545937337325793606575540077668761651354230117967954525983258779337939162900077652128520925321092329409211256910728883042208587, + 11 + ], + [ + 8554722121540321531033851903503091043568072545383091874674651587213151080155337523302708460235935909051966517558675878325800155304257041850642184658818422513821457766084417174, + 11 + ], + [ + 12832083182310482296550777855254636565352108818074637812011977380819726620233006284954062690353903863577949776338013817488700232956385562775963276988227633770732186649126625761, + 11 + ], + [ + 17109444243080643062067703807006182087136145090766183749349303174426302160310675046605416920471871818103933035117351756651600310608514083701284369317636845027642915532168834349, + 11 + ], + [ + 21386805303850803827584629758757727608920181363457729686686628968032877700388343808256771150589839772629916293896689695814500388260642604626605461647046056284553644415211042936, + 11 + ], + [ + 25664166364620964593101555710509273130704217636149275624023954761639453240466012569908125380707807727155899552676027634977400465912771125551926553976455267541464373298253251523, + 11 + ], + [ + 29941527425391125358618481662260818652488253908840821561361280555246028780543681331559479610825775681681882811455365574140300543564899646477247646305864478798375102181295460111, + 11 + ], + [ + 34218888486161286124135407614012364174272290181532367498698606348852604320621350093210833840943743636207866070234703513303200621217028167402568738635273690055285831064337668698, + 11 + ], + [ + 38496249546931446889652333565763909696056326454223913436035932142459179860699018854862188071061711590733849329014041452466100698869156688327889830964682901312196559947379877285, + 11 + ], + [ + 42773610607701607655169259517515455217840362726915459373373257936065755400776687616513542301179679545259832587793379391629000776521285209253210923294092112569107288830422085872, + 11 + ], + [ + 47050971668471768420686185469267000739624398999607005310710583729672330940854356378164896531297647499785815846572717330791900854173413730178532015623501323826018017713464294460, + 11 + ], + [ + 51328332729241929186203111421018546261408435272298551248047909523278906480932025139816250761415615454311799105352055269954800931825542251103853107952910535082928746596506503047, + 11 + ], + [ + 55605693790012089951720037372770091783192471544990097185385235316885482021009693901467604991533583408837782364131393209117701009477670772029174200282319746339839475479548711634, + 11 + ], + [ + 59883054850782250717236963324521637304976507817681643122722561110492057561087362663118959221651551363363765622910731148280601087129799292954495292611728957596750204362590920222, + 11 + ], + [ + 64160415911552411482753889276273182826760544090373189060059886904098633101165031424770313451769519317889748881690069087443501164781927813879816384941138168853660933245633128809, + 11 + ], + [ + 68437776972322572248270815228024728348544580363064734997397212697705208641242700186421667681887487272415732140469407026606401242434056334805137477270547380110571662128675337396, + 11 + ], + [ + 72715138033092733013787741179776273870328616635756280934734538491311784181320368948073021912005455226941715399248744965769301320086184855730458569599956591367482391011717545983, + 11 + ] + ], + "width": 3 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "unit", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + true + ], + [ + "good", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 126, + true, + false + ] + ], + "final_size": 36357569016546366506893870589888136935164308317878140467367269245655892090660184474036510956002727613470857699624372482884650660043092427865229284799978295683741195505858772992, + "global_slots_read": [ + 2, + 3 + ], + "path": "good_reset_good_pair", + "q": 3, + "root_size": 4149515568880992958512407863691161151012446232242436899995657329690652811412908146399707048947103794288197886611300789182395151075411775307886874834113963687061181803401509523685376, + "root_unit": 2, + "table_sha256": "3545601acdc6f0e0c2800e60292b462ee2cafe5248b0f6b8993521ff670b876d", + "values": [ + [ + 0, + 7 + ], + [ + 2138680530385080382758462975875772760892018136345772968668662896803287770038834380825677115058983977262991629389668969581450038826064260462660546164704605628455364441521104293, + 7 + ], + [ + 4277361060770160765516925951751545521784036272691545937337325793606575540077668761651354230117967954525983258779337939162900077652128520925321092329409211256910728883042208587, + 7 + ], + [ + 6416041591155241148275388927627318282676054409037318906005988690409863310116503142477031345176951931788974888169006908744350116478192781387981638494113816885366093324563312880, + 7 + ], + [ + 8554722121540321531033851903503091043568072545383091874674651587213151080155337523302708460235935909051966517558675878325800155304257041850642184658818422513821457766084417174, + 7 + ], + [ + 10693402651925401913792314879378863804460090681728864843343314484016438850194171904128385575294919886314958146948344847907250194130321302313302730823523028142276822207605521468, + 7 + ], + [ + 12832083182310482296550777855254636565352108818074637812011977380819726620233006284954062690353903863577949776338013817488700232956385562775963276988227633770732186649126625761, + 7 + ], + [ + 14970763712695562679309240831130409326244126954420410780680640277623014390271840665779739805412887840840941405727682787070150271782449823238623823152932239399187551090647730055, + 7 + ], + [ + 17109444243080643062067703807006182087136145090766183749349303174426302160310675046605416920471871818103933035117351756651600310608514083701284369317636845027642915532168834349, + 7 + ], + [ + 19248124773465723444826166782881954848028163227111956718017966071229589930349509427431094035530855795366924664507020726233050349434578344163944915482341450656098279973689938642, + 7 + ], + [ + 21386805303850803827584629758757727608920181363457729686686628968032877700388343808256771150589839772629916293896689695814500388260642604626605461647046056284553644415211042936, + 7 + ], + [ + 23525485834235884210343092734633500369812199499803502655355291864836165470427178189082448265648823749892907923286358665395950427086706865089266007811750661913009008856732147230, + 7 + ], + [ + 25664166364620964593101555710509273130704217636149275624023954761639453240466012569908125380707807727155899552676027634977400465912771125551926553976455267541464373298253251523, + 7 + ], + [ + 27802846895006044975860018686385045891596235772495048592692617658442741010504846950733802495766791704418891182065696604558850504738835386014587100141159873169919737739774355817, + 7 + ], + [ + 29941527425391125358618481662260818652488253908840821561361280555246028780543681331559479610825775681681882811455365574140300543564899646477247646305864478798375102181295460111, + 7 + ], + [ + 32080207955776205741376944638136591413380272045186594530029943452049316550582515712385156725884759658944874440845034543721750582390963906939908192470569084426830466622816564404, + 7 + ], + [ + 34218888486161286124135407614012364174272290181532367498698606348852604320621350093210833840943743636207866070234703513303200621217028167402568738635273690055285831064337668698, + 7 + ], + [ + 36357569016546366506893870589888136935164308317878140467367269245655892090660184474036510956002727613470857699624372482884650660043092427865229284799978295683741195505858772991, + 7 + ] + ], + "width": 3 + }, + { + "events": [ + [ + "good", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "unit", + [ + "MOVE", + 0, + 23299, + 114, + 114, + 0, + 528, + "9bab2d0e6a5a6bf6eba8a4415fd87d065312f8eb01fd253fd579d2846a62a629", + 7, + [ + "data", + 3, + 0, + [] + ], + "owner", + null + ], + 0, + false, + false + ], + [ + "pair", + [ + "IDLE", + 6, + 6, + 213, + 213, + 2, + 8, + "3aeb89340b4aabdf7cdcbee3271e2bc7650188d764ee08ebbcef3be8bc3b6661", + 42, + [ + "family", + 102, + -1, + [] + ], + "owner", + null + ], + 126, + true, + false + ] + ], + "final_size": 664824119159704987554630776500811646814433066384057425689001494777707741086357658953810486052621304932038540793131382544176469212216547252392764064913888835359839003535703277568, + "global_slots_read": [ + 2 + ], + "path": "good_reset_pair", + "q": 3, + "root_size": 4149515568880992958512407863691161151012446232242436899995657329690652811412908146399707048947103794288197886611300789182395151075411775307886874834113963687061181803401509523685376, + "root_unit": 2, + "table_sha256": "1dd70228e7c0621ed6b5e0b1ea3c8e2e3524f8d8a4c0f104882a98aa9fd1161a", + "values": [ + [ + 0, + 1 + ], + [ + 39107301127041469856154751558871273342025474493179848569941264398688690652138685820812381532507135584237561223125375443775086424248032191317221415583169931491755235502100192798, + 1 + ], + [ + 78214602254082939712309503117742546684050948986359697139882528797377381304277371641624763065014271168475122446250750887550172848496064382634442831166339862983510471004200385596, + 1 + ], + [ + 117321903381124409568464254676613820026076423479539545709823793196066071956416057462437144597521406752712683669376126331325259272744096573951664246749509794475265706506300578394, + 1 + ], + [ + 156429204508165879424619006235485093368101897972719394279765057594754762608554743283249526130028542336950244892501501775100345696992128765268885662332679725967020942008400771192, + 1 + ], + [ + 195536505635207349280773757794356366710127372465899242849706321993443453260693429104061907662535677921187806115626877218875432121240160956586107077915849657458776177510500963990, + 1 + ], + [ + 234643806762248819136928509353227640052152846959079091419647586392132143912832114924874289195042813505425367338752252662650518545488193147903328493499019588950531413012601156788, + 1 + ], + [ + 273751107889290288993083260912098913394178321452258939989588850790820834564970800745686670727549949089662928561877628106425604969736225339220549909082189520442286648514701349586, + 1 + ], + [ + 312858409016331758849238012470970186736203795945438788559530115189509525217109486566499052260057084673900489785003003550200691393984257530537771324665359451934041884016801542384, + 1 + ], + [ + 351965710143373228705392764029841460078229270438618637129471379588198215869248172387311433792564220258138051008128378993975777818232289721854992740248529383425797119518901735183, + 1 + ], + [ + 391073011270414698561547515588712733420254744931798485699412643986886906521386858208123815325071355842375612231253754437750864242480321913172214155831699314917552355021001927981, + 1 + ], + [ + 430180312397456168417702267147584006762280219424978334269353908385575597173525544028936196857578491426613173454379129881525950666728354104489435571414869246409307590523102120779, + 1 + ], + [ + 469287613524497638273857018706455280104305693918158182839295172784264287825664229849748578390085627010850734677504505325301037090976386295806656986998039177901062826025202313577, + 1 + ], + [ + 508394914651539108130011770265326553446331168411338031409236437182952978477802915670560959922592762595088295900629880769076123515224418487123878402581209109392818061527302506375, + 1 + ], + [ + 547502215778580577986166521824197826788356642904517879979177701581641669129941601491373341455099898179325857123755256212851209939472450678441099818164379040884573297029402699173, + 1 + ], + [ + 586609516905622047842321273383069100130382117397697728549118965980330359782080287312185722987607033763563418346880631656626296363720482869758321233747548972376328532531502891971, + 1 + ], + [ + 625716818032663517698476024941940373472407591890877577119060230379019050434218973132998104520114169347800979570006007100401382787968515061075542649330718903868083768033603084769, + 1 + ], + [ + 664824119159704987554630776500811646814433066384057425689001494777707741086357658953810486052621304932038540793131382544176469212216547252392764064913888835359839003535703277567, + 1 + ] + ], + "width": 3 + } + ], + "independent_equalities": 12642, + "independent_local_oracles": [ + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 3, + "independent_values_sha256": "6b48d51c46365b706b9ef366b884b023ad8bb625bae98264ce7a390386139329", + "kind": "good", + "nonidentity_permutation_entries": 0 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 387, + "independent_values_sha256": "4138aa0b40c5e31d40d61d9897775c90a8a72fbe0334c293fc8119add906f02e", + "kind": "pair", + "nonidentity_permutation_entries": 6 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 6, + "independent_values_sha256": "deb02927c18a816edc90e5f09461944e70e5a511647cfc8cee046fd1bde13754", + "kind": "good", + "nonidentity_permutation_entries": 0 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 387, + "independent_values_sha256": "d8a768f838adb9623eda455f8f33830d2ec748a31b7b6e75add886109cc94577", + "kind": "pair", + "nonidentity_permutation_entries": 12 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 9, + "independent_values_sha256": "e41b36d990af466bfc969a7e22c2c06fb38bc3c6d4d6f0b75d1ade933c5a427f", + "kind": "good", + "nonidentity_permutation_entries": 0 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 387, + "independent_values_sha256": "af68b2799fe0da6809d3e045f0fc44596013b354d2086cd8c3cb5d7613adadaa", + "kind": "pair", + "nonidentity_permutation_entries": 18 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 12, + "independent_values_sha256": "a3ca4f90d71e423234b488a3827ac031fcb5fbee914be9ae468ae12aa89f7b6a", + "kind": "good", + "nonidentity_permutation_entries": 0 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 387, + "independent_values_sha256": "f2ee441484e25b2b55e5959e8f5984b90f5c0acd64eb8689fc244f50da82d6e2", + "kind": "pair", + "nonidentity_permutation_entries": 24 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 15, + "independent_values_sha256": "e8be41886020362bb77d587c87b0bc1f61d5192a8c11531b73deb043961979cd", + "kind": "good", + "nonidentity_permutation_entries": 0 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 387, + "independent_values_sha256": "7a6b7856813dae78d6b6de791087d9283991f78d6e31cac6206898ef1031156b", + "kind": "pair", + "nonidentity_permutation_entries": 30 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 18, + "independent_values_sha256": "282f0ad44bef0817b40f2310b906d375bebe5ab18ef92780fea265616ce2d368", + "kind": "good", + "nonidentity_permutation_entries": 0 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 387, + "independent_values_sha256": "f0ea2768ba8a6cfdbf9cd28e0aa4a6dec682afc45102c34c0ca60f9e7fe1f15f", + "kind": "pair", + "nonidentity_permutation_entries": 36 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 21, + "independent_values_sha256": "1c8f79feb50672f0cc7336d501eb0467ed4be6371e77225b26dd22d48555fb1a", + "kind": "good", + "nonidentity_permutation_entries": 0 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 387, + "independent_values_sha256": "6bef7f6d11833be3925e8dffa809cb54c8eeaaaba4239a63e17396669689daba", + "kind": "pair", + "nonidentity_permutation_entries": 42 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 126, + "independent_values_sha256": "6b00406b16d787dd9b2bafd621c2a8d7dff6cc8f652b3471f1d73fb05e079e04", + "kind": "good", + "nonidentity_permutation_entries": 0 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 387, + "independent_values_sha256": "12aed20bdfc3726b0d1fcc5f01023148669d2ac78474a553d7a782c4f9682ed1", + "kind": "pair", + "nonidentity_permutation_entries": 252 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 21, + "independent_values_sha256": "1c8f79feb50672f0cc7336d501eb0467ed4be6371e77225b26dd22d48555fb1a", + "kind": "good", + "nonidentity_permutation_entries": 0 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 387, + "independent_values_sha256": "6bef7f6d11833be3925e8dffa809cb54c8eeaaaba4239a63e17396669689daba", + "kind": "pair", + "nonidentity_permutation_entries": 42 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 21, + "independent_values_sha256": "1c8f79feb50672f0cc7336d501eb0467ed4be6371e77225b26dd22d48555fb1a", + "kind": "good", + "nonidentity_permutation_entries": 0 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 387, + "independent_values_sha256": "6bef7f6d11833be3925e8dffa809cb54c8eeaaaba4239a63e17396669689daba", + "kind": "pair", + "nonidentity_permutation_entries": 42 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 3, + "independent_values_sha256": "6b48d51c46365b706b9ef366b884b023ad8bb625bae98264ce7a390386139329", + "kind": "good", + "nonidentity_permutation_entries": 0 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 387, + "independent_values_sha256": "4138aa0b40c5e31d40d61d9897775c90a8a72fbe0334c293fc8119add906f02e", + "kind": "pair", + "nonidentity_permutation_entries": 6 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 3, + "independent_values_sha256": "6b48d51c46365b706b9ef366b884b023ad8bb625bae98264ce7a390386139329", + "kind": "good", + "nonidentity_permutation_entries": 0 + }, + { + "columns": [ + 0, + 1, + 2 + ], + "equalities": 387, + "independent_values_sha256": "4138aa0b40c5e31d40d61d9897775c90a8a72fbe0334c293fc8119add906f02e", + "kind": "pair", + "nonidentity_permutation_entries": 6 + }, + { + "columns": [ + 0, + 57344, + 86016, + 172031 + ], + "equalities": 516, + "independent_values_sha256": "5b16f2af41432ebfd8e4a4b5ba9dbb10050ac0c77355c4383f7f06831743232e", + "kind": "pair", + "nonidentity_permutation_entries": 336 + }, + { + "columns": [ + 0, + 57344, + 86016, + 172031 + ], + "equalities": 516, + "independent_values_sha256": "5b16f2af41432ebfd8e4a4b5ba9dbb10050ac0c77355c4383f7f06831743232e", + "kind": "pair", + "nonidentity_permutation_entries": 336 + }, + { + "columns": [ + 0, + 98, + 147, + 293 + ], + "equalities": 516, + "independent_values_sha256": "8b5249881821fcf584e08bf960bf92996a58a404d9e6737202dfe183fe6c1cb8", + "kind": "pair", + "nonidentity_permutation_entries": 336 + }, + { + "columns": [ + 0, + 49, + 73, + 146 + ], + "equalities": 516, + "independent_values_sha256": "ccbf6d932fbb060a500d2786d491ccc1baf2bcd0f8a6972da734febb3352d8f9", + "kind": "pair", + "nonidentity_permutation_entries": 336 + }, + { + "columns": [ + 0, + 896, + 1344, + 2687 + ], + "equalities": 516, + "independent_values_sha256": "c4d367ba41b169c43717f1534f29881753ddf382d55ff28e4f07caaf776b755a", + "kind": "pair", + "nonidentity_permutation_entries": 336 + }, + { + "columns": [ + 0, + 57344, + 86016, + 172031 + ], + "equalities": 516, + "independent_values_sha256": "c2c20a4a84956e0154a0b953867ee2bc77a244052f0495c859a641f43f877a66", + "kind": "pair", + "nonidentity_permutation_entries": 336 + }, + { + "columns": [ + 0, + 57344, + 86016, + 172031 + ], + "equalities": 516, + "independent_values_sha256": "c2c20a4a84956e0154a0b953867ee2bc77a244052f0495c859a641f43f877a66", + "kind": "pair", + "nonidentity_permutation_entries": 336 + }, + { + "columns": [ + 0, + 98, + 147, + 293 + ], + "equalities": 516, + "independent_values_sha256": "24529e294eb1cdfa2f86ad7c488e57a5b3fa8c673660f98bb890e010094d0685", + "kind": "pair", + "nonidentity_permutation_entries": 336 + }, + { + "columns": [ + 0, + 49, + 73, + 146 + ], + "equalities": 516, + "independent_values_sha256": "e2719d8eed4539e41952dd61f9c311c88add386b9a718010fd740de72ce92dc1", + "kind": "pair", + "nonidentity_permutation_entries": 336 + }, + { + "columns": [ + 0, + 896, + 1344, + 2687 + ], + "equalities": 516, + "independent_values_sha256": "6d19f1c06c71e22664788035f2af893d71ec90b7cd90ab7b5be5b3d92401a67f", + "kind": "pair", + "nonidentity_permutation_entries": 336 + }, + { + "columns": [ + 0, + 14182914542073706401165456565350648465374572082859891748032031888591098476508963391014623702455921171883488870253469494275764676527286341384378966718162961821009898742095003254784, + 21274371813110559601748184848025972698061858124289837622048047832886647714763445086521935553683881757825233305380204241413647014790929512076568450077244442731514848113142504882176, + 42548743626221119203496369696051945396123716248579675244096095665773295429526890173043871107367763515650466610760408482827294029581859024153136900154488885463029696226285009764351 + ], + "equalities": 516, + "independent_values_sha256": "d49cf05e7c073aca9aec86b93ae385b57324ee7e1cdab9bd759bb6c7528e9f3a", + "kind": "pair", + "nonidentity_permutation_entries": 336 + }, + { + "columns": [ + 0, + 14182914542073706401165456565350648465374572082859891748032031888591098476508963391014623702455921171883488870253469494275764676527286341384378966718162961821009898742095003254784, + 21274371813110559601748184848025972698061858124289837622048047832886647714763445086521935553683881757825233305380204241413647014790929512076568450077244442731514848113142504882176, + 42548743626221119203496369696051945396123716248579675244096095665773295429526890173043871107367763515650466610760408482827294029581859024153136900154488885463029696226285009764351 + ], + "equalities": 516, + "independent_values_sha256": "d49cf05e7c073aca9aec86b93ae385b57324ee7e1cdab9bd759bb6c7528e9f3a", + "kind": "pair", + "nonidentity_permutation_entries": 336 + }, + { + "columns": [ + 0, + 24238379344364244337929247059925424623442872211918760311578179497103928060440122982691007304001818408980571799749581655256433773362061618576819523199985530455827463670572515328, + 36357569016546366506893870589888136935164308317878140467367269245655892090660184474036510956002727613470857699624372482884650660043092427865229284799978295683741195505858772992, + 72715138033092733013787741179776273870328616635756280934734538491311784181320368948073021912005455226941715399248744965769301320086184855730458569599956591367482391011717545983 + ], + "equalities": 516, + "independent_values_sha256": "58cadc10191966ab2bbaac7d70faa041c97f50dd0fa2708fca6a77e27d850228", + "kind": "pair", + "nonidentity_permutation_entries": 336 + }, + { + "columns": [ + 0, + 12119189672182122168964623529962712311721436105959380155789089748551964030220061491345503652000909204490285899874790827628216886681030809288409761599992765227913731835286257664, + 18178784508273183253446935294944068467582154158939070233683634622827946045330092237018255478001363806735428849812186241442325330021546213932614642399989147841870597752929386496, + 36357569016546366506893870589888136935164308317878140467367269245655892090660184474036510956002727613470857699624372482884650660043092427865229284799978295683741195505858772991 + ], + "equalities": 516, + "independent_values_sha256": "ce0efce4fad11d7b719034f4264dbb6cc8a3b121d424bb1a8ee80f0853074910", + "kind": "pair", + "nonidentity_permutation_entries": 336 + }, + { + "columns": [ + 0, + 221608039719901662518210258833603882271477688794685808563000498259235913695452552984603495350873768310679513597710460848058823070738849084130921354971296278453279667845234425856, + 332412059579852493777315388250405823407216533192028712844500747388853870543178829476905243026310652466019270396565691272088234606108273626196382032456944417679919501767851638784, + 664824119159704987554630776500811646814433066384057425689001494777707741086357658953810486052621304932038540793131382544176469212216547252392764064913888835359839003535703277567 + ], + "equalities": 516, + "independent_values_sha256": "2c8573756f386d2ace106783343b6369ba65d6790ce9bd5ef3faf2ddcd5c307c", + "kind": "pair", + "nonidentity_permutation_entries": 336 + } + ], + "scope": "Actual selected-label coefficient binding and conditional structural proof; no complete payload, physical runtime, supplier admission or new kappa.", + "selected_request_representatives": 12, + "status": "PASS_SELECTED_CONTROL_TABLE_BINDING", + "width_one_root": true +} diff --git a/research/selected-control-table-binding/SOURCES.json b/research/selected-control-table-binding/SOURCES.json new file mode 100644 index 0000000000..e14186c3e2 --- /dev/null +++ b/research/selected-control-table-binding/SOURCES.json @@ -0,0 +1,134 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz", + "usage": "input", + "git_blob": "9eafb8776cbf78c72124f833534469ddfa5e98ec", + "sha256": "0357b7cfbd7c29b4983982baf153c8a9f1e1e412690cd7fa9fc3d23d7963b20f" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json", + "usage": "input", + "git_blob": "44006542202ca6037533a754f0bcd00549d7e088", + "sha256": "0058c491d839142aa99ef86a5ec697ce99857632228531512ea3fa74fb24d734" + }, + { + "path": "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "usage": "input", + "git_blob": "e293ddc557742637f9f679f083a1a282d87b1b13", + "sha256": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4" + }, + { + "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "usage": "input", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + { + "path": "research/pr589-five-helper-hosting/verify.py", + "usage": "input", + "git_blob": "dbc71f56bb4205ebe378ada1f9f4ea88630d1d39", + "sha256": "cf90e19ae9991b0698be03d395a8cc29061ecb307eb7fea19adfb2d23c25a367" + } + ], + "vendored": [ + { + "path": "sources/pr2310/control.py", + "source_path": "research/selected-control-uniformity/control.py", + "commit": "a5258f548bfb6da71c3b72733fbbd2fb4995c929", + "git_blob": "3d9ab566d9bcbc30180c13c4321c6cc349d00e6a", + "sha256": "b2de80d8292e4af8ac86e1b4db35cb968f304c797c5faa4ee13be74eacf06739" + }, + { + "path": "sources/pr2310/PROOF.md", + "source_path": "research/selected-control-uniformity/PROOF.md", + "commit": "a5258f548bfb6da71c3b72733fbbd2fb4995c929", + "git_blob": "1b8db5d0dabe7bb02fc05f843d22991f9e19c9a3", + "sha256": "a46ec34988750656c8d6a9d6420bed529807ab1509a5eeda6a72a593efcca5e5" + }, + { + "path": "sources/pr2310/NOTICE.md", + "source_path": "research/selected-control-uniformity/NOTICE.md", + "commit": "a5258f548bfb6da71c3b72733fbbd2fb4995c929", + "git_blob": "7fe56b0130e487ed869887da77f8bc788f85e430", + "sha256": "3852a06b0a563a2413f7b011fe9ac81f28d5455ea1b39be4c2834543fa8389af" + }, + { + "path": "sources/pr2234/provider.py", + "source_path": "research/selected-bit-recursive-closure/provider.py", + "commit": "d047ef86fbc5b1614d3d8e2b8d3441413beab73f", + "git_blob": "67bb3d8dbeb78b7be83f224cf744cb46578928c8", + "sha256": "90b8274045b8011c883bb47cacd88d2d312ba943e8ce2941f10d7d61f3479b22" + }, + { + "path": "sources/pr2234/expressions.py", + "source_path": "research/selected-bit-recursive-closure/expressions.py", + "commit": "d047ef86fbc5b1614d3d8e2b8d3441413beab73f", + "git_blob": "5d20d691edbf1ff024871d38658d96f867785be6", + "sha256": "d31c858b770a5d8b1b54ef74d9fb4383245601e600e2c85820cae78815dc86f7" + }, + { + "path": "sources/pr2234/recursive_plan.py", + "source_path": "research/selected-bit-recursive-closure/recursive_plan.py", + "commit": "d047ef86fbc5b1614d3d8e2b8d3441413beab73f", + "git_blob": "4396434ed4d8013862fdc6889e8e5e5d3061654c", + "sha256": "49a6bbc8b942064a58e646585efb44c2c6b3ca1abc8d1e49193d9b8a3c708b74" + }, + { + "path": "sources/pr2234/PROOF.md", + "source_path": "research/selected-bit-recursive-closure/PROOF.md", + "commit": "d047ef86fbc5b1614d3d8e2b8d3441413beab73f", + "git_blob": "6c410cab5713979214a45835091fbeb9ee9b8531", + "sha256": "74cc8de20f21acb5123fe2d20996fe0925ea6e51b3dec633bd5221fb719b3344" + }, + { + "path": "sources/pr2234/NOTICE.md", + "source_path": "research/selected-bit-recursive-closure/NOTICE.md", + "commit": "d047ef86fbc5b1614d3d8e2b8d3441413beab73f", + "git_blob": "a5ccfbecbd225d4b63d9ce85edb2fac90f37147c", + "sha256": "c144e34c24470ca53df77527b9687ae9b345a4d88a506d839312ca26584cfe79" + }, + { + "path": "sources/pr2234/vendor/descriptor.py", + "source_path": "research/selected-bit-recursive-closure/vendor/descriptor.py", + "commit": "d047ef86fbc5b1614d3d8e2b8d3441413beab73f", + "git_blob": "738eafc5b54f544fe4b5a4df7d8dabb31d56db17", + "sha256": "8cf5bba2d3c82c4bf447b8679fed174112623feb162dae1880f3613893c6a63d" + }, + { + "path": "sources/pr2234/vendor/controlled_normalizer.py", + "source_path": "research/selected-bit-recursive-closure/vendor/controlled_normalizer.py", + "commit": "d047ef86fbc5b1614d3d8e2b8d3441413beab73f", + "git_blob": "3e8a72e7ce705c51ff24e9015ccf6463204ff193", + "sha256": "401605930f674bd3c27337687fe7425f0d8776703c83bfd42d4c0e10cae6fb77" + }, + { + "path": "sources/pr2234/vendor/fallback_program.py", + "source_path": "research/selected-bit-recursive-closure/vendor/fallback_program.py", + "commit": "d047ef86fbc5b1614d3d8e2b8d3441413beab73f", + "git_blob": "c899b7c8d0fb90262ee7b1599461c99390964d4b", + "sha256": "03d2823f6d8c2a9de9514b4aa641ec7a5648ca3902684484ac588d234dc58061" + }, + { + "path": "sources/pr2234/vendor/ring_algebra.py", + "source_path": "research/selected-bit-recursive-closure/vendor/ring_algebra.py", + "commit": "d047ef86fbc5b1614d3d8e2b8d3441413beab73f", + "git_blob": "c924d1e8dbb63734a4e9107a1f9526794394b4e2", + "sha256": "9f21b6bbd3dc13f49245b56e8d9828b121ce798de6b5b7ad18e5d9c2e5d9adc2" + } + ] +} diff --git a/research/selected-control-table-binding/TASK.json b/research/selected-control-table-binding/TASK.json new file mode 100644 index 0000000000..8ea6751d4b --- /dev/null +++ b/research/selected-control-table-binding/TASK.json @@ -0,0 +1,92 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Can one exact all-size/compiler, precision, hosting or restoration implication be proved or falsified?", + "starting_points": [ + "certificates/selected-result.json", + "docs/audit.md" + ], + "methods": [ + "Prove one missing implication with explicit quantified hypotheses.", + "Find an exact counterexample at the claimed interface boundary." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the selected review scope and choose one exact all-size or precision implication.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write its quantified inputs and conclusion; find a missing hypothesis or construct a minimal exact adversarial instance.", + "bottleneck_link": "Finite supplier improvements are useful only under the retained transfer obligations.", + "allowed_variations": [ + "Choose one tape, precision, hosting or restoration lemma." + ], + "scope_change_triggers": [ + "Replacing a quantified obligation with another finite smoke test." + ], + "overlap_terms": [ + "uniform transfer", + "all-size", + "precision" + ] + }, + "scope_status": "refined", + "actual_scope": "Bind actual selected PR2234 full-ring preparation and legal low-class descendants to PR2310 Program/Table semantics, including mixed Good/Pair paths and global frozen slots after unit reset.", + "scope_change_reason": "The suggested uniform-transfer audit is refined to the explicit unclaimed preparation/evaluator handoff in Discussion #2304; numerical stock bounds and the earlier generic descriptor algebra are already covered.", + "bottleneck_link": "A root-independent control bound still needs the prepared table to describe the actual selected child; this supplies that exact coefficient-source connection under the named producer normal forms.", + "budget_minutes": 60, + "stop_rule": "Stop at a source-bound mismatch or a scoped table-binding proof and finite exact evidence; do not expand into the complete physical payload or infer a new exponent.", + "outcome": "completed", + "evidence": "87 fixtures; 801 coordinate comparisons; 12642 independent local equalities; 13 semantic controls, plus source/receipt integrity checks. RESULT.json records exact cases.", + "author": "commdata2338", + "ai_assistance": "Substantial OpenAI Codex assistance in mathematical analysis, code, verification and writing.", + "open_questions": [ + { + "question": "Can the bound table evaluator be called at every actual stream coefficient-preparation site without a hidden full-parent vector or fresh-field read?", + "why_it_matters": "The new binding establishes values, while the complete dispatcher and the uniform physical charge must be joined to execute the supplier.", + "first_step": "Coordinate with the active Discussion #2319 two-dimensional dispatch investigation; bind one actual selected controlled-ADD callback to this evaluator and check high-header spectators, inverse cleanup and work lifetime.", + "blocked_by": "A full payload dispatcher and its physical preparation/lifetime accounting remain outside this package." + }, + { + "question": "Can the structural adapter lemma be independently formalized with exact global slots and reset extents?", + "why_it_matters": "The all-chain statement is a written proof, and finite checks do not quantify over every chain.", + "first_step": "Formalize the three descriptor constructors and the chronological-to-birth-depth translation, then prove evaluation equality by induction.", + "blocked_by": "A formal representation of the pending producer and evaluator contracts is not supplied here." + } + ], + "selection": { + "seed": "1666912cb72ea23ea7840a7d03438b89", + "track": "adversarial-audit", + "catalogue_scope_key": "603f341b99f590f17a76", + "refined_scope_key": "selected-BIT/PR2234-full-ring-to-PR2310-table/actual-label-mixed-reset-binding", + "discussion": 2304 + }, + "dependency_heads": { + "2234": "d047ef86fbc5b1614d3d8e2b8d3441413beab73f", + "2310": "a5258f548bfb6da71c3b72733fbbd2fb4995c929" + }, + "final_upstream_checkpoint": { + "utc": "2026-10-15T05:19:24.042700+00:00", + "commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "priority_revision": 4, + "changed_paths": [], + "decision": "Continue the frozen binding audit; main, guidance, selected record and source baseline are unchanged." + }, + "overlap_at_finish": { + "public_claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2304#discussioncomment-18941098", + "concurrent_claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2319", + "difference": "The concurrent claim executes complete generic two-dimensional packets/children. This package independently audits coefficient-source binding on actual selected 64-dimensional requests and executes no complete physical payload.", + "pr_snapshot_utc": "2026-10-15T05:15:02.657475+00:00", + "discussion_snapshot_utc": "2026-10-15T05:18:03.093031+00:00", + "coverage": "537 open PRs, 1035 discussion records; complete pagination; offline cached scope may miss later changes and arbitrary code diffs." + } +} diff --git a/research/selected-control-table-binding/VERIFY.json b/research/selected-control-table-binding/VERIFY.json new file mode 100644 index 0000000000..ab163bf425 --- /dev/null +++ b/research/selected-control-table-binding/VERIFY.json @@ -0,0 +1,46 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz", + "research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json", + "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "research/pr589-five-helper-hosting/verify.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 480, + "checks": "Actual producer-to-table binding, independent weighted elimination and all semantic controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 480, + "checks": "Identical complete receipt and semantic controls with Python assertions disabled." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/test_integrity.py" + ], + "timeout_seconds": 60, + "checks": "Every source/blob pin, typed and complete receipt comparison, and actual altered-vendor CLI rejection before import." + } + ] +} diff --git a/research/selected-control-table-binding/binding.py b/research/selected-control-table-binding/binding.py new file mode 100644 index 0000000000..11544c58a8 --- /dev/null +++ b/research/selected-control-table-binding/binding.py @@ -0,0 +1,138 @@ +"""Bind selected full-ring fields to the pinned PR2310 control interface. + +New interface glue; producer algebra and iterative evaluation are reused and +credited. Prepared for commdata2338 with substantial OpenAI Codex assistance. +Apache-2.0. +""" +from dataclasses import dataclass +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +sys.path[:0] = [str(HERE / "sources/pr2310"), + str(HERE / "sources/pr2234"), + str(HERE / "sources/pr2234/vendor")] + +import control +import descriptor as d +import provider +from controlled_normalizer import Arithmetic +from expressions import Expression, BoundExpression, FrozenFields, FieldSpecification +from recursive_plan import residual_plan + + +def need(test, message): + if not test: + raise ValueError(message) + + +@dataclass(frozen=True) +class Event: + """One actual descent. A unit reset still freezes one physical field.""" + kind: str + request: object + low: tuple + field: int = 0 + reverse: bool = False + half: bool = False + + +@dataclass(frozen=True) +class Compilation: + program: object + tables: tuple + expression: object + live_slots: tuple + + +def neutral_table(tag): + # Unread entries have no mathematical coefficient role. The consumer's + # fixed-size page format requires valid unit padding at every slot. + return control.Table(tag, (1,) * 64, (1,) * 128, tuple(range(128))) + + +def prepare_table(header, kind, tag): + """Use the FULL unweighted matrix, preserving the producer's row order.""" + modulus = header.q ** header.width + p = d.projector(header.read(Arithmetic(modulus)), header.axes, modulus) + need(p == header.direct_projector(), "actual chart/base projector binding") + blank = neutral_table(tag) + if kind == "good": + pivots = d.good_pivots(p, header.request.base.rank, modulus) + return control.Table(tag, pivots + (1,) * (64 - len(pivots)), + blank.diagonal, blank.permutation) + need(kind == "pair", "coefficient-bearing descent") + plan = d.elimination(d.residual(p, modulus), modulus) + return control.Table(tag, blank.pivots, plan.diagonal, plan.permutation) + + +def compile_chain(q, width, root_size, root_unit, events, fields, catalogue): + """Compile one chronological chain; reject wrong source specifications. + + Tags are local slot tokens, not source hashes. Source equality is checked + on the full FieldSpecification before a table is produced. A caller must + preserve this pair of outputs; arbitrary pre-made tables are not trusted. + """ + need(len(fields.high_matrices) == len(events) == len(fields.specifications), + "complete frozen field prefix") + expression = Expression(q, width, root_size, root_unit) + steps = [] + for slot, event in enumerate(events): + need(event.request in catalogue.requests, "selected provider request") + specification = FieldSpecification(q, width, event.request, event.low) + need(fields.specifications[slot] == specification, "exact frozen source specification") + need(event.kind in ("good", "pair", "unit"), "descent kind") + need(event.kind == "unit" or not event.half, "halving only at unit reset") + need(event.kind == "pair" or (event.field == 0 and not event.reverse), + "pair-only field and orientation") + tag = slot + 1 + steps.append(control.Step(event.kind, tag, event.request.base.rank, + event.field, event.reverse, event.half)) + plan = residual_plan(expression, event.request, event.low, catalogue) + if event.kind == "unit": + f = expression.size // 64 + child = expression.unit_child(f // 2 if event.half else f) + child_kind = "orientation" if event.half else "unit" + else: + child = expression.append(event.kind, event.request, event.low, + slot, event.field, event.reverse) + child_kind = event.kind + need(any(c.kind == child_kind and c.expression == child for c in plan.children), + "descent is present in the actual low-class macroplan") + expression = child + program = control.Program(q, width, root_size, root_unit, tuple(steps)) + sizes = program.extents() + need(sizes[-1] == expression.size and expression.depth == len(events), + "program and source expression extents") + # A reset makes all earlier numerical coefficients irrelevant. Keep the + # physical slots but do not read or prepare their high matrices. + first_live = 1 + max((i for i, e in enumerate(events) if e.kind == "unit"), default=-1) + tables = [] + for slot, event in enumerate(events): + tag = slot + 1 + if slot < first_live: + tables.append(neutral_table(tag)) + continue + specification = FieldSpecification(q, width, event.request, event.low) + high = fields.high(slot, specification) + raw = provider.RawHeader(q, width, event.low, high, event.request.header_space) + header = provider.GeneralHeader(raw, event.request, catalogue) + tables.append(prepare_table(header, event.kind, tag)) + return Compilation(program, tuple(tables), expression, + tuple(range(first_live, len(events)))) + + +def run(compilation, index): + meter = control.Meter() + tape = control.FrozenTape(compilation.tables, + compilation.program.q ** compilation.program.width, meter) + original = tape.data + value = control.evaluate(compilation.program, tape, index) + need(tape.data == original and tape.head == 0, "readonly tables and restored head") + need(set(meter.field_reads) <= set(compilation.live_slots), "only live global slots read") + return value, meter + + +def bound_reference(compilation, fields, catalogue): + """Attributed PR2234 oracle, not an independent algebra implementation.""" + return provider.build_weights(BoundExpression(compilation.expression, catalogue, fields))[0] diff --git a/research/selected-control-table-binding/checks.py b/research/selected-control-table-binding/checks.py new file mode 100644 index 0000000000..dc0d06d148 --- /dev/null +++ b/research/selected-control-table-binding/checks.py @@ -0,0 +1,243 @@ +"""Actual selected-label fixtures and adversarial binding controls.""" +from dataclasses import asdict, replace +from hashlib import sha256 +import json + +import binding as b +import oracle + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")) + + +def digest(value): + return sha256(canonical(value).encode()).hexdigest() + + +def indices(size): + return sorted({0, size - 1} | {size * j // 17 for j in range(1, 17)}) + + +def root_coupling(width, root_size): + e = width * root_size + b.need((width - 1) ** 10000 < e ** 17 <= width ** 10000, + "fixture satisfies the retained original-width coupling") + + +def fields_for(headers): + return b.FrozenFields.from_headers(headers) + + +def prepare_case(catalogue, descriptions, q=3, width=2, root_size=64**4 + 17, root_unit=2): + root_coupling(width, root_size) + events, headers = [], [] + for kind, request, high, field, half in descriptions: + header = b.provider.fixture_header(catalogue, request, q, width, + bad=kind != "good", high=high) + headers.append(header) + events.append(b.Event(kind, request, header.raw.low, field, + kind == "pair" and field >= 64, half)) + fields = fields_for(tuple(headers)) + compilation = b.compile_chain(q, width, root_size, root_unit, + tuple(events), fields, catalogue) + reference = b.bound_reference(compilation, fields_for(tuple(headers)), catalogue) + return compilation, reference, tuple(events), tuple(headers) + + +def check_case(catalogue, descriptions, **kwargs): + compilation, reference, events, headers = prepare_case(catalogue, descriptions, **kwargs) + values, reads = [], set() + for i in indices(reference.size): + actual, meter = b.run(compilation, i) + b.need(actual == reference.value(i), "compiled value equals actual generated descriptor") + reads.update(meter.field_reads) + values.append([i, actual]) + b.need(reads <= set(compilation.live_slots), "reset dead ancestry is never read") + return {"q": compilation.program.q, "width": compilation.program.width, + "root_size": compilation.program.root_size, "root_unit": compilation.program.unit, + "events": [[e.kind, e.request.record(), e.field, e.reverse, e.half] for e in events], + "final_size": reference.size, "global_slots_read": sorted(reads), + "table_sha256": digest([asdict(t) for t in compilation.tables]), + "values": values}, (compilation, reference, events, headers) + + +def actual_requests(catalogue): + chosen = [next(r for r in catalogue.requests if r.kind == "MOVE" and r.base.rank == rank) + for rank in range(1, 8)] + chosen.append(next(r for r in catalogue.requests if r.kind == "IDLE" and r.base.rank == 42)) + for frame in (510, 518): + chosen.append(next(r for r in catalogue.requests if r.kind == "COPY" and r.old_frame == frame)) + chosen += [next(r for r in catalogue.requests if r.kind == "MOVE" and r.chart.kind == "data" and r.stage == 8), + next(r for r in catalogue.requests if r.kind == "MOVE" and r.chart.kind == "host" and r.chart.port >= 0), + next(r for r in catalogue.requests if r.kind == "MOVE" and r.chart.kind == "host" and r.chart.port < 0)] + return list(dict.fromkeys(chosen)) + + +def independent_last_step(catalogue, fixture): + compilation, reference, events, headers = fixture + event, header = events[-1], headers[-1] + p = oracle.actual_projector(header) + b.need(p == header.direct_projector(), "independent raw-label projector equality") + if len(events) == 1: + parent = b.d.Root(compilation.program.root_size, header.q**header.width, compilation.program.unit) + else: + prefix = b.compile_chain(header.q, header.width, compilation.program.root_size, + compilation.program.unit, events[:-1], fields_for(headers[:-1]), catalogue) + parent = b.bound_reference(prefix, fields_for(headers[:-1]), catalogue) + modulus = header.q**header.width + f = parent.size // 64 + columns = sorted({0, f // 3, f // 2, f - 1}) + checked, permutation_changes = 0, 0 + signatures = [] + for t in columns: + incoming = [parent.value(row*f + t) for row in range(64)] + if event.kind == "good": + pivots = oracle.weighted_good_pivots(p, incoming, event.request.base.rank, modulus) + for k, value in enumerate(pivots): + b.need(b.run(compilation, k*f+t)[0] == value, + "compiled good value equals independent weighted LU pivot") + checked += 1 + signatures.append(pivots) + else: + b.need(event.kind == "pair", "independent last-step domain") + weighted = oracle.weighted_residual(p, incoming, modulus) + diagonal, pi = oracle.normalized_elimination(weighted, modulus) + table = compilation.tables[-1] + bank = incoming + [1]*64 + expected = tuple(table.diagonal[j] * bank[table.permutation[j]] * + pow(bank[j], -1, modulus) % modulus for j in range(128)) + b.need(diagonal == expected and pi == table.permutation, + "all weighted diagonal entries and original-row permutation") + i = f - 1 - t if event.reverse else t + b.need(b.run(compilation, i)[0] == diagonal[event.field], + "compiled pair value equals independent weighted elimination") + checked += 129 + permutation_changes += sum(i != j for i, j in enumerate(pi)) + signatures.append(diagonal) + return {"kind": event.kind, "columns": columns, "equalities": checked, + "nonidentity_permutation_entries": permutation_changes, + "independent_values_sha256": digest(signatures)} + + +def rejects(thunk, label): + try: + thunk() + except ValueError: + return label + raise ValueError("invalid binding was accepted: " + label) + + +def differs(compilation, reference, label): + for i in indices(reference.size): + actual = b.run(compilation, i)[0] + if actual != reference.value(i): + return {"control": label, "index": i, "incorrect": actual, "correct": reference.value(i)} + raise ValueError("mutation did not exercise its proposed failure: " + label) + + +def controls(catalogue, good_fixture, pair_fixture, reverse_fixture, reset_fixture): + out = [] + comp, ref, events, headers = good_fixture + h = headers[-1] + low = replace(h, raw=replace(h.raw, high=tuple((0,)*64 for _ in range(64)))) + table = b.prepare_table(low, "good", comp.tables[-1].tag) + out.append(differs(replace(comp, tables=comp.tables[:-1]+(table,)), ref, "low-only coefficients")) + comp, ref, events, headers = pair_fixture + table = replace(comp.tables[-1], permutation=tuple(range(128))) + out.append(differs(replace(comp, tables=comp.tables[:-1]+(table,)), ref, "discard original-row permutation")) + comp, ref, events, headers = reverse_fixture + step = replace(comp.program.steps[-1], reverse=False) + program = replace(comp.program, steps=comp.program.steps[:-1]+(step,)) + out.append(differs(replace(comp, program=program), ref, "omit physical atom reversal")) + comp, ref, events, headers = reset_fixture + q, width, n, a = comp.program.q, comp.program.width, comp.program.root_size, comp.program.unit + out.append(rejects(lambda: b.run(replace(comp, tables=comp.tables[2:]), 0), "compact frozen slots after reset")) + f = fields_for(headers) + swapped = replace(f, specifications=f.specifications[:-2]+tuple(reversed(f.specifications[-2:]))) + out.append(rejects(lambda: b.compile_chain(q, width, n, a, events, swapped, catalogue), "swap exact field specifications")) + extra = replace(f, high_matrices=f.high_matrices+(f.high_matrices[-1],), + specifications=f.specifications+(f.specifications[-1],)) + out.append(rejects(lambda: b.compile_chain(q, width, n, a, events, extra, catalogue), "capture current fresh matrix")) + changed = list(events) + alternate = next(r for r in catalogue.requests if r.base.rank == events[-1].request.base.rank and + r != events[-1].request) + changed[-1] = replace(changed[-1], request=alternate) + out.append(rejects(lambda: b.compile_chain(q, width, n, a, tuple(changed), fields_for(headers), catalogue), + "same-rank wrong selected request")) + changed = events[:-1]+(replace(events[-1], reverse=False),) + out.append(rejects(lambda: b.compile_chain(q, width, n, a, changed, fields_for(headers), catalogue), + "orientation not in actual macroplan")) + good, _, ev, hs = good_fixture + wrong_branch = (replace(ev[0], kind="pair", field=1),) + out.append(rejects(lambda: b.compile_chain(good.program.q, good.program.width, good.program.root_size, + good.program.unit, wrong_branch, fields_for(hs), catalogue), + "pair on a good low class")) + wrong_reset = (replace(ev[0], kind="unit"),) + out.append(rejects(lambda: b.compile_chain(good.program.q, good.program.width, good.program.root_size, + good.program.unit, wrong_reset, fields_for(hs), catalogue), + "unit reset absent from macroplan")) + out.append(rejects(lambda: fields_for(headers).unused, "unused stock is inaccessible")) + mutated_headers = tuple(replace(h, raw=replace(h.raw, high=tuple((0,)*64 for _ in range(64)))) + if i < 2 else h for i, h in enumerate(headers)) + changed_fields = fields_for(mutated_headers) + changed_comp = b.compile_chain(q, width, n, a, events, changed_fields, catalogue) + b.need(changed_fields.reads == list(comp.live_slots), "dead high fields were not prepared") + b.need(changed_comp.tables == comp.tables, "unit reset removes dead numerical dependence") + out.append("dead high-field change leaves tables and values unchanged") + bad_header = pair_fixture[3][-1] + out.append(rejects(lambda: b.prepare_table(bad_header, "good", 1), "nonunit good pivot")) + return out + + +def run(catalogue): + chosen = actual_requests(catalogue) + records, oracle_records = [], [] + good_fixture = None + for request in chosen: + for high in (0, 1, 2): + for kind, field in (("good", 0), ("pair", 0)): + record, fixture = check_case(catalogue, [(kind, request, high, field, False)], root_size=209) + records.append(record) + if high == 1: + oracle_records.append(independent_last_step(catalogue, fixture)) + if request.base.rank == 42 and kind == "good" and high == 1: + good_fixture = fixture + r42 = next(r for r in chosen if r.base.rank == 42) + r7 = next(r for r in chosen if r.base.rank == 7) + paths = { + "good_pair_forward": [("good", r42, 1, 0, False), ("pair", r42, 1, 1, False)], + "good_pair_reverse": [("good", r42, 1, 0, False), ("pair", r42, 1, 126, False)], + "good_pair_good_pair": [("good", r42, 1, 0, False), ("pair", r7, 1, 1, False), + ("good", r7, 2, 0, False), ("pair", r42, 1, 126, False)], + "good_reset_good_pair": [("good", r42, 1, 0, False), ("unit", r7, 1, 0, True), + ("good", r7, 2, 0, False), ("pair", r42, 1, 126, False)], + "good_reset_pair": [("good", r42, 1, 0, False), ("unit", r7, 1, 0, False), + ("pair", r42, 1, 126, False)], + } + fixtures = {} + for q, width, root_size in ((3, 2, 64**4+17), (5, 2, 64**4+17), (3, 3, 2**600)): + for name, descriptions in paths.items(): + record, fixture = check_case(catalogue, descriptions, q=q, width=width, root_size=root_size) + record["path"] = name + records.append(record) + oracle_records.append(independent_last_step(catalogue, fixture)) + if (q, width) == (3, 2): + fixtures[name] = fixture + empty = b.compile_chain(3, 1, 1, 2, (), b.FrozenFields((), ()), catalogue) + b.need(b.run(empty, 0)[0] == 2 and not empty.tables, "width-one root bypass") + failure_controls = controls(catalogue, good_fixture, fixtures["good_pair_forward"], + fixtures["good_pair_reverse"], fixtures["good_reset_good_pair"]) + catalogue_receipt = catalogue.receipt() + # The reused producer exposes integer histogram keys; the receipt boundary + # is JSON, whose object keys are strings. Normalize this one known mapping + # before strict comparison, without relaxing any value types or fields. + catalogue_receipt["rank_histogram"] = { + str(k): v for k, v in catalogue_receipt["rank_histogram"].items()} + return {"status": "PASS_SELECTED_CONTROL_TABLE_BINDING", + "catalogue": catalogue_receipt, "selected_request_representatives": len(chosen), + "fixture_cases": len(records), "coordinate_equalities": sum(len(r["values"]) for r in records), + "independent_local_oracles": oracle_records, + "independent_equalities": sum(r["equalities"] for r in oracle_records), + "width_one_root": True, "controls": failure_controls, "fixtures": records, + "scope": "Actual selected-label coefficient binding and conditional structural proof; no complete payload, physical runtime, supplier admission or new kappa."} diff --git a/research/selected-control-table-binding/oracle.py b/research/selected-control-table-binding/oracle.py new file mode 100644 index 0000000000..61740be28c --- /dev/null +++ b/research/selected-control-table-binding/oracle.py @@ -0,0 +1,118 @@ +"""Independent dense local-ring oracle for the table's mathematical meaning. + +This module imports no predecessor algebra. It uses normalized row reduction, +where the producer uses unnormalized elimination; good pivots are extracted +from the unreversed weighted projector instead of its northeast cross block. +""" +from math import gcd + + +def need(test, message): + if not test: + raise ValueError(message) + + +def identity(n): + return [[int(i == j) for j in range(n)] for i in range(n)] + + +def product(a, b, modulus): + columns = list(zip(*b)) + return [[sum(x * y for x, y in zip(row, col)) % modulus + for col in columns] for row in a] + + +def inverse(a, modulus): + n = len(a) + rows = [list(row) + e for row, e in zip(a, identity(n))] + for j in range(n): + k = next((i for i in range(j, n) if gcd(rows[i][j], modulus) == 1), None) + need(k is not None, "oracle invertible matrix") + rows[j], rows[k] = rows[k], rows[j] + rows[j] = [(x * pow(rows[j][j], -1, modulus)) % modulus for x in rows[j]] + for i in range(n): + if i != j: + coefficient = rows[i][j] + rows[i] = [(x - coefficient * y) % modulus for x, y in zip(rows[i], rows[j])] + need([r[:n] for r in rows] == identity(n), "oracle inverse endpoint") + return [r[n:] for r in rows] + + +def actual_projector(header): + """Raw GL matrix and actual label, bypassing the producer's split basis.""" + modulus, q = header.q ** header.width, header.q + g = [[x + q * y for x, y in zip(a, b)] for a, b in zip(header.low, header.high)] + sigma = [[x.numerator * pow(x.denominator, -1, modulus) % modulus for x in row] + for row in header.catalogue.chart_matrix(header.request.chart)] + base = header.request.base + p = [[0] * 64 for _ in range(64)] + if base.kind == "idle": + for axis in base.data: + p[axis][axis] = 1 + else: + need(base.kind == "local", "oracle selected label kind") + for i, row in enumerate(base.data): + for j, x in enumerate(row): + p[i][j] = x.numerator * pow(x.denominator, -1, modulus) % modulus + common = product(g, sigma, modulus) + return product(product(common, p, modulus), inverse(common, modulus), modulus) + + +def weighted_good_pivots(projector, weights, rank, modulus): + """Leading LU pivots of diag(weights) P; no column-reversal code.""" + rows = [[weight * x % modulus for x in row] for weight, row in zip(weights, projector)] + pivots = [] + for k in range(rank): + pivot = rows[k][k] + need(gcd(pivot, modulus) == 1, "oracle generic leading minor") + pivots.append(pivot) + rows[k] = [x * pow(pivot, -1, modulus) % modulus for x in rows[k]] + for i in range(k + 1, len(rows)): + c = rows[i][k] + rows[i] = [(x - c * y) % modulus for x, y in zip(rows[i], rows[k])] + need(all(not any(row) for row in rows[rank:]), "oracle rank endpoint") + return tuple(pivots) + + +def weighted_residual(projector, weights, modulus): + n = len(projector) + bank = list(weights) + [1] * n + rows = [] + for i in range(2 * n): + row = [] + for j in range(2 * n): + if i < n and j < n: + x = int(i == j) - projector[i][j] + elif i < n: + x = projector[i][2 * n - 1 - j] + elif j < n: + x = projector[2 * n - 1 - i][j] + else: + x = int(i == j) - projector[2 * n - 1 - i][2 * n - 1 - j] + row.append(bank[i] * x * pow(bank[j], -1, modulus) % modulus) + rows.append(row) + return rows + + +def normalized_elimination(matrix, modulus): + """Return pre-normalization pivots and original-row permutation.""" + rows = [list(row) for row in matrix] + n = len(rows) + permutation, pivots = list(range(n)), [] + for column in range(n): + row = next((i for i in range(column, n) if gcd(rows[i][column], modulus) == 1), None) + need(row is not None, "oracle residual unit pivot") + rows[column], rows[row] = rows[row], rows[column] + permutation[column], permutation[row] = permutation[row], permutation[column] + pivot = rows[column][column] + pivots.append(pivot) + inv = pow(pivot, -1, modulus) + rows[column] = [x * inv % modulus for x in rows[column]] + for i in range(n): + if i == column: + continue + c = rows[i][column] + if c: + rows[i] = [(x - c * y) % modulus for x, y in zip(rows[i], rows[column])] + need(rows == identity(n), "oracle normalized elimination endpoint") + return tuple(pivots), tuple(permutation) diff --git a/research/selected-control-table-binding/sources/pr2234/NOTICE.md b/research/selected-control-table-binding/sources/pr2234/NOTICE.md new file mode 100644 index 0000000000..a5ccfbecbd --- /dev/null +++ b/research/selected-control-table-binding/sources/pr2234/NOTICE.md @@ -0,0 +1,54 @@ +# Attribution and source scope + +Jose Manuel (`jmbarrancoml`) prepared this contribution with substantial +OpenAI Codex assistance in mathematical analysis, code, tests and writing. +We use the repository's Apache-2.0 license and retain source notices in the +eight unchanged vendored Python files. `SOURCES.json` records their original +paths, commits and SHA256 values; we checked byte equality against those +Git objects before publication. + +We credit the following predecessors: + +* OpenAI's retained framework and Douglas Colkitt: the stream, ordinary + interchange, row-volume and tape contracts, with their source notices. +* DreamingOfClouds: selected PR589 tuning, on eumemic's PR555 base word. + The lineage includes Dugongue's PR541/548 and rohanarun's PR542. +* alephnan: PR1627, retained as `research/pr589-five-helper-hosting`, for the + literal word, whole-call dirty-helper cancellation and chronological proof. +* eumemic: PR490's whole-owner GL local-ring argument. +* The source527 contributors: retained normal forms, weighted leaf + factorization and ordinary borrowing method, with the existing notices. +* commdata2338: PR2160 selected good normal form, PR2188 mixed descriptor + grammar, and PR1379 unequal-buffer parking boundary. We vendor PR2188's + `descriptor.py` unchanged at `77bb4e8cfe3e8c89f6e281eaf948454ee487796a`. +* RossRichardson: PR2159 full-ring fallback topology, covariance and charge, + at `9022b980917b7a9dd0bf1e9cb8012a16ea30293b`. +* Jose Manuel: PR2157 fixed dyadic routes (`eb1bf93950e9b14f7fadca7892866e9f29a26ad3`), + PR2171 controlled streams (`416aac58960660edced905dc7d914c126d357290`), + PR2195 GL packet integration (`3a1cf78a1ba6322129e42d80c50d21765524d612`), + and PR2207 fallback continuation (`149d55d90d3c0877ed3d78e1deca8eb2f72e0d00`). +* The authors of the retained `moment.py` and `base_two_moment.py` engines: + we reuse their rational arithmetic at one coarse point, with input pins. +* 1337isnot1337: adjacent PR2212 route inventory, at + `cd37bdf943876f81a60522e13cf838a464ed3104`; we do not reproduce that census. + +The new work binds the remaining actual residual labels, gives causal symbolic +field references and completed leaf/header bases, and composes the weighted +caller by strong induction. We derive the resulting ordinary-interchange +saving with the elementary base. We claim neither a new generic weighted +factorization nor a new generic parking lemma. + +The retained `physical_stream.py` contains an explicit weighted-child test +oracle and `qadic_streams.py` contains an ordinary test oracle. We retain +those files unchanged for their sequential primitives and arithmetic. The +new completed leaf/header paths never call those oracles; the replay replaces +them with rejecting functions. Their presence does not implement recursive +children. PROOF.md supplies that separate construction. + +The pending predecessor PRs remain subject to review. We have not merged or +closed them. The repository's selected result remains unchanged. + +For the exact written premises, see the pinned +[PR2195 packet proof](https://github.com/CrocSwap/integer-mult-bounds/blob/3a1cf78a1ba6322129e42d80c50d21765524d612/research/selected-bit-local-ring-sweeps/PROOF.md), +[PR2171 adapter proof](https://github.com/CrocSwap/integer-mult-bounds/blob/416aac58960660edced905dc7d914c126d357290/research/selected-bit-controlled-streams/PROOF.md) +and [PR2207 fallback proof](https://github.com/CrocSwap/integer-mult-bounds/blob/149d55d90d3c0877ed3d78e1deca8eb2f72e0d00/research/selected-bit-fallback-streams/PROOF.md). diff --git a/research/selected-control-table-binding/sources/pr2234/PROOF.md b/research/selected-control-table-binding/sources/pr2234/PROOF.md new file mode 100644 index 0000000000..6c410cab57 --- /dev/null +++ b/research/selected-control-table-binding/sources/pr2234/PROOF.md @@ -0,0 +1,433 @@ +# Recursive closure of the selected BIT interchange + +We give a written construction on a fixed number of finite-alphabet multitape +streams. We retain the sequential stream model of `02-streams.tex`: complete +address ranges, arbitrary Boolean payload, charged scans, counters, rewinds and +scratch erasure. We prove an ordinary binary chunk-interchange bound + + O(V E^(1-a)), a = 169711/100000000 = 0.00169711, + +for two complete E-bit address chunks and arbitrary complete spectators, where +V counts payload bits. The machine restores spectators and clears its work. +We fix one odd prime q>2^80 throughout; constants and the fixed tape count may +depend on q and the selected word. We make no practical runtime claim. + +We supply a mathematical algorithm and finite interface checks. We have not +translated the entire recursive machine into transition tables or a proof +assistant. Reviewers must assess the composition argument below. The selected +finite certificate and the multiplication theorem have further interfaces, +including the complex supplier and analytic transfer; we leave their status +unchanged. + +## 1. Sources and the recursive contract + +We use DreamingOfClouds' selected PR589 word, building on eumemic's PR555 word, +and alephnan's PR1627 literal/chronological proof. We reuse the GL local-ring +packet integration of PR2195, the good adapters of PR2171, the fallback word +of PR2159/PR2207, and commdata2338's PR2188 weight grammar. Source527 already +gives the weighted factorization and outer borrowing method. PR1379 supplies +the unequal-buffer parking boundary. `SOURCES.json` pins the executable inputs; +`NOTICE.md` identifies the pending source commits and mathematical reuse. + +Fix an original radix-q width e, c=17/10000, and w=ceil(e^c). Put B=q^w and +R=Z/B. We keep w fixed throughout one coarse recursion. Let C_n reverse n +atom positions. For a diagonal unit vector A, we construct + + F_A(H,D) = (A C_n D, C_n A^-1 H). + +We quantify over any two ordered complete n-atom chunks, with arbitrary +complete preceding, intervening and following fields. This includes two +subchunks of one former bank, which we need for fallback reversals. We allow +arbitrary correlated dirty payload values. + +We generate A from a constant unit by the Good and FallbackPair expressions +below. A may read earlier frozen matrix fields; it may not read this node's +fresh family, matrix or unused stock. A unit child starts a new constant +expression but retains its global generation depth. We bound that depth by +the original root width, including after such a reset. + +At return we require the specified address permutation on I/O, pointwise +restoration of row and spectator coordinates, empty local work and restored +head positions. For a parking top h, we visit no cell below h-1 and write no +cell below h. We require a time bound uniform in parked contents and h. + +## 2. Actual residuals and full-ring preparation + +PR1627 reconstructs 636 rational frame projectors and proves the nesting +identities used by both selected literal programs. Their entries lie in +Z[1/2]. For an idempotent P0 of rational rank r, its characteristic polynomial +is T^(64-r)(T-1)^r. Reduction modulo an odd q preserves this identity and +idempotent diagonalizability, hence rank r, including when q divides r. + +Choose independent image columns of P0 and kernel columns of I-P0 modulo q. +Their lifts form a unit matrix B0 over R and satisfy + + P0 = B0 diag(I_r,0) B0^-1. + +We compute this identity in control arithmetic. We do not move payload through +B0. For the actual owner chart sigma and raw physical header g, the provider +passes g sigma B0 to the retained coordinate normalizer. It therefore computes +exactly P=g sigma P0 sigma^-1 g^-1. + +For MOVE, we use the positive nested frame difference and the actual owner +sigma. The common stage projector cancels. The reflected orientation gives +the same positive residual. For COPY, we first copy and align the source +packet to d=g sigma. Its private header is d and its projector label is P0; +we set its additional chart to I. Applying sigma again would change the +operator. ERASE retains the literal transported-source equality guard. + +For an idle remainder, we subtract the actual hosted slots from its pending +axes and use the fixed family chart. We skip the zero remainder. The provider +binds 28,278 canonical requests and 32 replicas, giving + + H_1=381024, H_2=400416, H_3=22752, H_4=26880, + H_5=29376, H_6=17376, H_7=26784, H_42=288. + +We obtain 541 distinct base labels and 1,235 assembled charts. The finite +checks verify image/kernel bases over Z/9 and Z/25 for each label, and 120 +full 128-coordinate operators from selected MOVE, COPY and idle requests. +These cases supplement the identities; they do not enumerate GL64(R). + +## 3. One schedule per complete low packet + +Write g=g0+qG with g0 in GL64(F_q) and G in [q^(w-1)]^4096. For a fixed +request, call g0 good when the first r northeast pivots of PC are units. +Equivalently, require the leading k principal minors of P to be nonzero +modulo q for 1<=k<=r. Unit tests depend only on g0. The full coefficients +still depend on G. + +For each k, multiply its minor by det(g)^k to obtain a polynomial of degree +at most 64k in the entries of g. Conjugating the fixed split rank-r projector +to diag(I_r,0) gives a nonzero witness. The union of these zero sets has +fraction at most 64r(r+1)/(2q) in all matrices. Since + + |GL64(F_q)|/q^4096 = product_(i=1)^64 (1-q^-i) > 1/2, + +the bad fraction for this request is at most 2*64^3/q<10^-16. We use this +bound separately for each paid edge. We do not require one matrix to be good +for every label or multiply the bound by the number of labels. + +On a good packet, unweighted northeast elimination gives unit-lower matrices +L,R0 and a pivot vector delta. Split rank and a unit rank-r minor force the +remaining Schur block to vanish over R itself. We retain q-multiples in the +arithmetic; reduction modulo q alone would not establish that conclusion. +The normal-form factorization in source527/PR2171 uses ordered head, tail +and cross ADDs, one weighted child, and the inverse adapters. For n=64f, + + A_child[k f+j] = A[k f+j] delta_k, 0<=k=1. Recompute on split and merge rather than retaining +an array indexed by the high fibre. Ripple counters have amortized linear +movement cost; initialize them once per scan and do not reread unrelated +spectator counters per fibre. Fixed low tables and finite labels depend on +q, not e. Thus these scans have the stated uniform bounds. For independently +chosen n,w,d, retain the preparation quotient instead of this absorption. + +The selected word has fixed length. Good and bad bodies use O(n) ordered +atom passes; header routes use O(Vw) each; selections, XORs, erasure and +parking use O(V) each. We include their finite q-dependent multiplicities +in a constant C. The local nonrecursive charge is C V(n+w), including the +remainder leaf. This is an asymptotic accounting, not an explicit optimized +finite invoice for the selected multiplier. PR2212 prices the separate +same-family route inventory and leaves further whole-invocation charges. + +Normalize by logical volume and bound the worst generated call by T(n,w). +For positive widths below 64, T<=Cw. The bad fraction is at most epsilon=10^-16 +for each request, and each fallback has at most 32*64^2 children of width at +most f=floor(n/64). We may overcount good calls on bad classes, obtaining + + T(n,w) <= sum_r (H_r/W) T(r f,w) + + epsilon F/W * max_(1<=j<=f) T(j,w) + C(n+w), + F=32*64^2*sum_r H_r=118606528512. + +We prove a monotone upper bound, so the maximum causes no extra factor. +Define mu_t=(sum H_r(r/64)^t + epsilon F(1/64)^t)/W. The two retained outward +rational engines independently give + + mu_1 = 2874298095721977/2890625000000000 < 199/200, + mu_(1-c) < 9999/10000. + +Induct on n and use f<=n/64. Increasing C to cover the leaf constants gives + + T(n,w) <= 200 C n + 10000 C n^(1-c) w. + +Indeed the first term leaves at least Cn after the recursive linear mass, +and the second leaves at least C n^(1-c)w>=Cw. We treat n=0 separately. +The resulting constants are independent of ancestor contents, stack top, +row multiplicity and original e. + +## 8. Internal borrowing and binary interchange + +Choose the sufficient stock S=K(w)^D(e) from the original width e, before +choosing a body width. Since M=1,"proper expression ancestor width") + size=node.request.base.rank*f if node.kind=="good" else f + return size + + def append(self,kind,request,low_matrix,high_slot,field=0,reverse=False): + need(kind in ("good","pair"),"generated child expression kind") + need(0=64,"proper recursive child label") + need(high_slot==self.depth,"append the newly frozen parent field") + if kind=="pair": + need(0<=field<127,"paired-diagonal child field") + node=AncestorReference(kind,request,low_matrix,high_slot,field,reverse) + result=Expression(self.q,self.width,self.root_size,self.root_unit,self.path+(node,),self.birth_depth) + need(result.size<=42*(self.size//64)=0): + port=self.geometry["ports"][chart.port] + for i in range(8): + out[i][:8]=[F(port["q"][i],2)]+list(map(F,port["complement_columns"][i])) + if chart.kind=="host": + domain=set(range(8));support=set(chart.axes);perm=list(range(64)) + for a,b in zip(sorted(domain-support),sorted(support-domain)): + perm[a],perm[b]=b,a + need(set(perm[:8])==support,"selected support completion") + out=[[row[perm[j]] for j in range(64)] for row in out] + else: + need(chart.kind=="family","known chart type") + return tuple(map(tuple,out)) + + def _append(self,request): + need(request.base.rank>0,"positive recursive residual") + self.requests.append(request);self.charts.add(request.chart) + if request.source_chart: + self.charts.add(request.source_chart) + + def _bind(self): + t=self.template + need((t["m"],t["stages"],t["replicas"],t["live"])==(64,9,32,28416),"selected provider dimensions") + for stage in range(9): + call=t["calls"][stage*32] + for rep in range(32): + other=t["calls"][stage*32+rep] + need((other["stage"],other["replica"],other["orientation"],other["local_hash"]) + ==(stage,rep,call["orientation"],call["local_hash"]),"replica program binding") + need(len(other["owners"])==len(call["owners"])==661,"replica owner inventory") + need(all(route==r0 and family==f0+888*rep + for (family,route),(f0,r0) in zip(other["owners"],call["owners"])), + "replica owner symmetry") + opened=None + for pos,event in enumerate(t["local_programs"][call["orientation"]]): + op,role=event[:2] + if op==0: + _,_,a,b,rank,_=event + base=self.base(a,b) + need(base.rank==rank and opened is None,"MOVE binding and private interval") + self._append(Request("MOVE",stage,pos,role,call["owners"][role][0],a,b, + base,self.owner_chart(call,role),"owner")) + elif op==2: + _,_,temporary,a,b,rank,_=event + need(temporary==661 and opened is None,"fresh COPY role") + base=self.base(a,b) + need(base.rank==rank==7,"literal rank-seven COPY") + opened=Request("COPY",stage,pos,role,t["live"],a,b,base, + Chart("identity"),"common",self.owner_chart(call,role)) + self._append(opened) + elif op==3: + _,_,temporary,a,b,_,_=event + need(opened is not None and opened.role==role and temporary==661 and + opened.base==self.base(a,b),"matching transported ERASE") + self.erase_guards.append((stage,pos,opened.position,role,opened.base.key)) + opened=None + else: + need(op==1,"known literal event") + need(opened is None,"closed private temporary") + occupied=defaultdict(set) + for child,copy,offset,width,_stage,_helper in t["hosting"]["slots"]: + axes=self.pending(child)[offset:offset+width] + need(not occupied[child,copy].intersection(axes),"disjoint hosted slots") + occupied[child,copy].update(axes) + for child,event in self.idles.items(): + pending=set(self.pending(child));histogram=Counter() + for copy in range(222): + axes=tuple(sorted(pending-occupied[child,copy]));rank=len(axes) + histogram[rank]+=1 + if not rank: + continue + base=Base("idle",axes,rank);self.bases.setdefault(base.key,base) + self._append(Request("IDLE",child,child,copy,event["pair"]*222+copy, + event["source_level"],event["target_level"],base,Chart("family",copy%111),"owner")) + if str(child) in t["hosting"]["remainders"]: + need({str(r):n for r,n in histogram.items()}==t["hosting"]["remainders"][str(child)], + "actual idle remainder binding") + else: + need(histogram==Counter({0:222}),"unlisted idle has zero residual") + self.profile=Counter() + for request in self.requests: + self.profile[request.base.rank]+=32 + expected={int(k):v for k,v in self.old.read("research/e8-bit-p111-tuned/tune/EXPECTED.json")["nine"]["profile"].items()} + need(dict(self.profile)==expected and sum(self.profile.values())==904896,"complete selected child provider") + + def receipt(self): + binding=sha256() + for request in self.requests: + binding.update((canonical(request.record())+"\n").encode()) + return {"canonical_requests":len(self.requests),"replicas":32, + "full_paid_requests":sum(self.profile.values()), + "request_kinds":dict(Counter(r.kind for r in self.requests)), + "base_labels":len(self.bases),"chart_labels":len(self.charts), + "rank_histogram":dict(sorted(self.profile.items())), + "canonical_ERASE_guards":len(self.erase_guards), + "binding_sha256":binding.hexdigest()} + + +@dataclass(frozen=True) +class RawHeader: + q: int + width: int + low: tuple + high: tuple + space: str + + def full(self,arithmetic,low_only=False): + need(self.q>=3 and self.q%2 and self.width>=1,"odd prime-power header domain") + need(len(self.low)==len(self.high)==64 and all(len(r)==64 for r in self.low+self.high), + "physical header dimensions") + cap=self.q**(self.width-1);out=[] + for a,b in zip(self.low,self.high): + row=[] + for x,y in zip(a,b): + need(0<=x=1,"proper recursive ancestor width") + p=d.projector(h.read(arithmetic,low_only),h.axes,modulus) + if ancestor.kind=="good": + weights=d.Good(weights,64,f,d.good_pivots(p,len(h.axes),modulus)) + elif ancestor.kind=="pair": + plan=d.elimination(d.residual(p,modulus),modulus) + weights=d.FallbackPair(weights,64,f,plan,ancestor.field,ancestor.reverse) + else: + raise ValueError("known generated ancestor kind") + return weights,arithmetic + + +@dataclass +class GoodPrefix: + header: GeneralHeader + ancestor_weights: tuple + atom_columns: int + + @property + def q(self): return self.header.q + @property + def width(self): return self.header.width + @property + def low(self): return self.header.low + @property + def high(self): return self.header.high + + def full_matrix(self,arithmetic,low_only=False): + return self.header.read(arithmetic,low_only) + + def weights(self,arithmetic): + arithmetic.prefix_cells+=len(self.ancestor_weights) + return list(self.ancestor_weights) + + +def prepare_good(recipe,header): + need((recipe.q,recipe.width)==(header.q,header.width),"good call ring") + weights,arithmetic=build_weights(recipe) + f=weights.size//64 + need(f>=1,"internal good call") + prefix=GoodPrefix(header,tuple(weights.value(i) for i in range(64*f)),f) + result=coordinate_good_prepare(prefix,header.axes) + result.arithmetic.counts.update(arithmetic.counts) + result.arithmetic.prefix_cells+=arithmetic.prefix_cells + need(result.projector==header.direct_projector(),"good full-frame projector binding") + return result + + +def prepare_fallback(recipe,header): + need((recipe.q,recipe.width)==(header.q,header.width),"fallback call ring") + result=coordinate_fallback_prepare(Prefix(recipe.root_size,recipe.root_unit,recipe.ancestors,header)) + need(result.matrix==d.residual(header.direct_projector(),header.q**header.width), + "fallback full-frame projector binding") + return result + + +def raw_header(q,width,matrix,space): + modulus=q**width + return RawHeader(q,width,tuple(tuple(x%modulus%q for x in row) for row in matrix), + tuple(tuple((x%modulus)//q for x in row) for row in matrix),space) + + +def fixture_header(catalogue,request,q=3,width=2,bad=False,high=1): + """A raw GL chart for the actual label; no payload basis change occurs.""" + modulus=q**width;r=request.base.rank + h=ring.eye(64) + if bad: + h[0][0],h[0][r],h[r][0],h[r][r]=q,q-1,1,1+q*high + else: + c=q*high + h[0][0],h[0][r],h[r][0],h[r][r]=1,1,c,1+c + basis=request.base.basis(q,width) + sigma=ring.reduce_matrix(catalogue.chart_matrix(request.chart),modulus) + physical=ring.multiply(ring.multiply(h,ring.inverse(basis,q,modulus),modulus), + ring.inverse(sigma,q,modulus),modulus) + return GeneralHeader(raw_header(q,width,physical,request.header_space),request,catalogue) diff --git a/research/selected-control-table-binding/sources/pr2234/recursive_plan.py b/research/selected-control-table-binding/sources/pr2234/recursive_plan.py new file mode 100644 index 0000000000..4396434ed4 --- /dev/null +++ b/research/selected-control-table-binding/sources/pr2234/recursive_plan.py @@ -0,0 +1,156 @@ +"""Low-class macroplans and symbolic proper-width recursive calls. + +This file builds plans, not a full selected payload simulator. PROOF.md gives +the sequential interpretation and induction. No high matrix enters a plan. +""" +from dataclasses import dataclass +from collections import Counter +from hashlib import sha256 + +import descriptor as d +from controlled_normalizer import Arithmetic, schedule +from fallback_program import compile_program +from expressions import FieldSpecification +from provider import RawHeader, GeneralHeader, need, canonical + + +def depth(n): + result=0 + while n>=64: + n=42*(n//64) + result+=1 + return result + + +@dataclass(frozen=True) +class Child: + kind: str + first: int + second: int + expression: object + + +@dataclass(frozen=True) +class ResidualPlan: + branch: str + parent_size: int + frozen_field: object + children: tuple + operations: tuple + + +def residual_plan(expression,request,low_matrix,catalogue): + """Freeze only the parent field's specification; values stay on I/O.""" + n=expression.size;f=n//64;q=expression.q + need(f>=1,"internal residual node") + raw=RawHeader(q,1,low_matrix,tuple((0,)*64 for _ in range(64)),request.header_space) + header=GeneralHeader(raw,request,catalogue) + p=d.projector(header.read(Arithmetic(q)),header.axes,q) + specification=FieldSpecification(q,expression.width,request,low_matrix) + try: + d.good_pivots(p,request.base.rank,q) + good=True + except ValueError: + good=False + if good: + child=expression.append("good",request,low_matrix,expression.depth) + # Coordinates refer to the core: first 64f head, last 64f tail. + children=(Child("good",0,128*f-child.size,child),) + operations=tuple(schedule(64,request.base.rank,1)) + branch="good" + else: + program=compile_program(d.elimination(d.residual(p,q),q)) + children=[] + for op in program: + if op.kind!="swap": + continue + i,k=op.target,op.source + same=(i<64)==(k<64) + def reversal(): + if f//2: + children.append(Child("orientation",k*f,(k+1)*f-f//2, + expression.unit_child(f//2))) + if same: + reversal() + if op.coefficient.kind=="pair": + child=expression.append("pair",request,low_matrix,expression.depth, + field=i,reverse=i>=64) + else: + need(op.coefficient.kind=="unit","fallback child grammar") + child=expression.unit_child(f) + children.append(Child(op.coefficient.kind,i*f,k*f,child)) + if same: + reversal() + operations=tuple((op.kind,op.target,op.source,op.coefficient.kind, + op.coefficient.reduction_index) for op in program) + children=tuple(children);branch="fallback" + need(len(children)<=32*64**2,"retained fallback allowance") + for child in children: + size=child.expression.size + need(0=3 and prefix.q%2 and prefix.width>=1 and prefix.atom_columns>=1 + and 1<=r=1,"schedule dimensions") + forward=[] + for j in range(f): + row_slot=column_slot=0 + for k in range(rank): + for i in range(k+1,n): + forward.append(("head",i*f+j,k*f+j,row_slot,j,1));row_slot+=1 + for k in range(rank): + column=n-1-k + for source in range(column): + forward.append(("tail",n*f+column*f+f-1-j,n*f+source*f+f-1-j,column_slot,j,-1));column_slot+=1 + for i in range(n): + for k in range(n): + forward.append(("cross",n*f+i*f+f-1-j,k*f+j,i*n+k,j,1)) + need(all(target>source for _,target,source,_,_,_ in forward),"later-target schedule") + backward=[(*slot[:5],-slot[5]) for slot in reversed(forward)] + return forward,backward + + +def coefficient(prepared,slot): + kind,_,_,index,j,sign=slot + m,n,f=prepared.modulus,prepared.n,prepared.f + if kind=="head": + i,k,c=prepared.rows[index] + value=prepared.arithmetic.mul(prepared.arithmetic.mul(c,prepared.weights[i*f+j]), + prepared.arithmetic.inv(prepared.weights[k*f+j])) + elif kind=="tail":value=prepared.columns[index][2] + elif kind=="cross": + i,k=divmod(index,n) + value=prepared.arithmetic.mul(prepared.cross[i][k],prepared.arithmetic.inv(prepared.weights[k*f+j])) + else:raise ValueError("unknown adapter kind") + return sign*value%m + + +def child_weights(prepared): + return tuple(prepared.weights[k*prepared.f+j]*pivot%prepared.modulus + for k,pivot in enumerate(prepared.pivots) for j in range(prepared.f)) + + +def execute_addresses(prepared,head,tail): + """Reference address execution, not the physical stream regression.""" + values=list(head)+list(tail);forward,backward=schedule(prepared.n,prepared.rank,prepared.f) + for slot in forward: + _,target,source,_,_,_=slot + values[target]=(values[target]+coefficient(prepared,slot)*values[source])%prepared.modulus + for i,weight in enumerate(child_weights(prepared)): + j=len(values)-1-i + values[i],values[j]=weight*values[j]%prepared.modulus,pow(weight,-1,prepared.modulus)*values[i]%prepared.modulus + for slot in backward: + _,target,source,_,_,_=slot + values[target]=(values[target]+coefficient(prepared,slot)*values[source])%prepared.modulus + return values[:len(head)],values[len(head):] diff --git a/research/selected-control-table-binding/sources/pr2234/vendor/descriptor.py b/research/selected-control-table-binding/sources/pr2234/vendor/descriptor.py new file mode 100644 index 0000000000..738eafc5b5 --- /dev/null +++ b/research/selected-control-table-binding/sources/pr2234/vendor/descriptor.py @@ -0,0 +1,234 @@ +"""Explicit good/fallback child weights over Z/q^w. + +Prepared for commdata2338 with substantial OpenAI Codex assistance. +Apache-2.0. Diagonal covariance and fallback algebra are inherited from +source527 and Ross Richardson's PR2159; the descriptor continuation takes +Jose Manuel's PR2171 handoff. No predecessor executable is imported. +""" + +from dataclasses import dataclass +from math import gcd + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def identity(n): + return [[int(i == j) for j in range(n)] for i in range(n)] + + +def multiply(a, b, modulus): + result = [[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: + result[i][j] = (result[i][j] + x * y) % modulus + return result + + +def inverse(a, modulus): + n = len(a) + rows = [list(row) + unit for row, unit in zip(a, identity(n))] + for k in range(n): + p = next((i for i in range(k, n) if gcd(rows[i][k], modulus) == 1), None) + require(p is not None, "matrix has no unit pivot") + rows[k], rows[p] = rows[p], rows[k] + d = pow(rows[k][k], -1, modulus) + rows[k] = [x * d % modulus for x in rows[k]] + for i in range(n): + if i != k and rows[i][k]: + c = rows[i][k] + rows[i] = [(x - c * y) % modulus for x, y in zip(rows[i], rows[k])] + require([row[:n] for row in rows] == identity(n), "inverse endpoint") + return [row[n:] for row in rows] + + +def projector(chart, axes, modulus): + gi = inverse(chart, modulus) + return multiply([[row[k] for k in axes] for row in chart], + [gi[k] for k in axes], modulus) + + +def residual(p, modulus): + """Unweighted [[I-P,PC],[CP,I-CPC]], in physical coordinate order.""" + n = len(p) + out = [[0] * (2 * n) for _ in range(2 * n)] + for i in range(n): + for j in range(n): + out[i][j] = (int(i == j) - p[i][j]) % modulus + out[i][n+j] = p[i][n-1-j] + out[n+i][j] = p[n-1-i][j] + out[n+i][n+j] = (int(i == j) - p[n-1-i][n-1-j]) % modulus + return out + + +def good_pivots(p, rank, modulus): + """Unweighted northeast elimination of P C, with full-ring coefficients.""" + n = len(p) + a = [row[::-1] for row in p] + pivots = [] + for k in range(rank): + c = n - 1 - k + pivot = a[k][c] + require(gcd(pivot, modulus) == 1, "nongeneric good ancestor") + pivots.append(pivot) + inv = pow(pivot, -1, modulus) + for i in range(k+1, n): + scale = a[i][c] * inv % modulus + if scale: + a[i] = [(x - scale*y) % modulus for x, y in zip(a[i], a[k])] + for j in range(c): + scale = a[k][j] * inv % modulus + if scale: + for i in range(n): + a[i][j] = (a[i][j] - scale*a[i][c]) % modulus + expected = [[0] * n for _ in range(n)] + for k, d in enumerate(pivots): + expected[k][n-1-k] = d + require(a == expected, "complete good cross-block endpoint") + return tuple(pivots) + + +@dataclass(frozen=True) +class Plan: + modulus: int + diagonal: tuple + permutation: tuple + pivots: tuple + operations: tuple + + +def elimination(matrix, modulus): + """All-row unnormalized elimination; pi[i] is the ORIGINAL row at i.""" + n = len(matrix) + require(n > 0 and all(len(row) == n for row in matrix), "square matrix") + a = [[x % modulus for x in row] for row in matrix] + pi, pivots, operations = list(range(n)), [], [] + for k in range(n): + p = next((i for i in range(k, n) if gcd(a[i][k], modulus) == 1), None) + require(p is not None, "fallback unit pivot") + pivots.append(p) + if p != k: + a[k], a[p] = a[p], a[k] + pi[k], pi[p] = pi[p], pi[k] + operations.append(("swap", k, p, 0)) + inv = pow(a[k][k], -1, modulus) + for i in range(n): + if i == k: + continue + c = -a[i][k] * inv % modulus + operations.append(("add", i, k, c)) # Keep zero slots. + if c: + a[i] = [(x + c*y) % modulus for x, y in zip(a[i], a[k])] + require(all(a[i][j] == 0 for i in range(n) for j in range(n) if i != j), + "fallback diagonal endpoint") + return Plan(modulus, tuple(a[i][i] for i in range(n)), tuple(pi), + tuple(pivots), tuple(operations)) + + +@dataclass(frozen=True) +class Root: + size: int + modulus: int + unit: int = 1 + + def value(self, index): + require(0 <= index < self.size, "root index extent") + require(gcd(self.unit, self.modulus) == 1, "root weight unit") + return self.unit % self.modulus + + +@dataclass(frozen=True) +class Good: + parent: object + dimension: int + columns: int + pivots: tuple + + def __post_init__(self): + require(self.dimension > len(self.pivots) > 0, "good rank") + require(self.columns == self.parent.size // self.dimension and self.columns > 0, + "good coarse child width") + require(all(gcd(x, self.modulus) == 1 for x in self.pivots), "good pivot units") + + @property + def modulus(self): + return self.parent.modulus + + @property + def size(self): + return len(self.pivots) * self.columns + + def value(self, index): + require(0 <= index < self.size, "good child index extent") + k, _ = divmod(index, self.columns) + return self.parent.value(index) * self.pivots[k] % self.modulus + + +@dataclass(frozen=True) +class FallbackPair: + """Weights for F_a within a weighted diagonal-pair J_a J_1. + + The first physical field is `field`; its atom orientation can be reversed. + The head-bank conjugator has parent weights, the tail-bank conjugator 1. + `plan` is prepared once from the FULL UNWEIGHTED parent residual. + """ + parent: object + dimension: int + columns: int + plan: Plan + field: int + reverse: bool + + def __post_init__(self): + n = 2 * self.dimension + require(self.columns == self.parent.size // self.dimension and self.columns > 0, + "fallback coarse child width") + require(self.plan.modulus == self.modulus, "fallback plan modulus") + require(len(self.plan.diagonal) == n and len(self.plan.permutation) == n, + "fallback plan dimension") + require(sorted(self.plan.permutation) == list(range(n)), "fallback row permutation") + require(0 <= self.field < n-1, "paired diagonal field") + require(all(gcd(d, self.modulus) == 1 for d in self.plan.diagonal), "fallback diagonal units") + + @property + def modulus(self): + return self.parent.modulus + + @property + def size(self): + return self.columns + + def bank_weight(self, row, column): + if row < self.dimension: + return self.parent.value(row * self.columns + column) + return 1 + + def value(self, index): + require(0 <= index < self.size, "fallback child index extent") + j = self.columns - 1 - index if self.reverse else index + numerator = self.bank_weight(self.plan.permutation[self.field], j) + denominator = self.bank_weight(self.field, j) + return (self.plan.diagonal[self.field] * numerator * + pow(denominator, -1, self.modulus)) % self.modulus + + +def weighted_residual(matrix, weights, modulus): + n = len(matrix) // 2 + require(len(matrix) == 2*n and len(weights) == n, "weighted residual dimensions") + b = list(weights) + [1] * n + require(all(gcd(x, modulus) == 1 for x in b), "diagonal conjugator units") + return [[b[i] * x * pow(b[j], -1, modulus) % modulus + for j, x in enumerate(row)] for i, row in enumerate(matrix)] + + +def reversed_child(head, tail, weights, modulus): + require(len(head) == len(tail) == len(weights), "child extent") + require(all(gcd(a, modulus) == 1 for a in weights), "child weight units") + f = len(weights) + return ([weights[t] * tail[f-1-t] % modulus for t in range(f)], + [pow(weights[f-1-t], -1, modulus) * head[f-1-t] % modulus for t in range(f)]) diff --git a/research/selected-control-table-binding/sources/pr2234/vendor/fallback_program.py b/research/selected-control-table-binding/sources/pr2234/vendor/fallback_program.py new file mode 100644 index 0000000000..c899b7c8d0 --- /dev/null +++ b/research/selected-control-table-binding/sources/pr2234/vendor/fallback_program.py @@ -0,0 +1,259 @@ +"""Intermediate-permutation descriptors for a complete mixed fallback word. + +Covariance and diagonal-pair descriptors: source527, PR2159 and PR2188. +This continuation binds every shear, inverse chronology and physical index. +Jose Manuel, with substantial OpenAI Codex assistance; Apache-2.0. +""" +from dataclasses import dataclass +from math import gcd, prod + +from descriptor import (Root, Good, FallbackPair, elimination, good_pivots, + projector, residual, require, identity) +from controlled_normalizer import Arithmetic + + +@dataclass(frozen=True) +class Header: + q: int + width: int + low: tuple + high: tuple + axes: tuple + + @property + def dimension(self): + return len(self.low) + + def read(self, arithmetic, low_only=False): + m = self.dimension + require(1 <= len(self.axes) < m <= 64, "header projector dimension") + require(len(set(self.axes)) == len(self.axes) and + all(0 <= i < m for i in self.axes), "header projector axes") + require(len(self.high) == m and + all(len(row) == m for row in self.low + self.high), "header extent") + cap = self.q ** (self.width - 1) + out = [] + for a, b in zip(self.low, self.high): + row = [] + for x, y in zip(a, b): + require(0 <= x < self.q and 0 <= y < cap, "header digit range") + arithmetic.prefix_cells += 2 + row.append(x + (0 if low_only else self.q * y)) + out.append(row) + return out + + +@dataclass(frozen=True) +class Ancestor: + kind: str + header: Header + field: int = 0 + reverse: bool = False + + +@dataclass(frozen=True) +class Prefix: + root_size: int + root_unit: int + ancestors: tuple + current: Header + + +@dataclass(frozen=True) +class Coefficient: + kind: str + first: int = 0 + second: int = 0 + scalar: int = 1 + permutation: tuple = () + reduction_index: int = -1 + + +@dataclass(frozen=True) +class Instruction: + kind: str + target: int + source: int + coefficient: Coefficient + + +@dataclass +class Prepared: + prefix: Prefix + weights: object + matrix: list + plan: object + columns: int + operations: tuple + arithmetic: Arithmetic + matrix_preparations: int + + @property + def dimension(self): + return self.prefix.current.dimension + + @property + def modulus(self): + return self.plan.modulus + + +def annotated_reductions(plan): + pi = list(range(len(plan.diagonal))) + out = [] + for index, (kind, i, k, c) in enumerate(plan.operations): + out.append((kind, i, k, c, tuple(pi), index)) + if kind == "swap": + pi[i], pi[k] = pi[k], pi[i] + require(tuple(pi) == plan.permutation, "complete original-row permutation") + return out + + +def compile_program(plan): + n, modulus = len(plan.diagonal), plan.modulus + unit = Coefficient("unit") + out = [] + for i, diagonal in enumerate(plan.diagonal[:-1]): + out.append(Instruction("swap", i, n-1, unit)) + out.append(Instruction("swap", i, n-1, + Coefficient("pair", i, n-1, diagonal, plan.permutation))) + sign = prod(plan.diagonal) % modulus + require(sign in (1, modulus-1), "fallback determinant sign") + if sign != 1: + out.append(Instruction("sign", n-1, -1, Coefficient("fixed", scalar=-1))) + for kind, i, k, c, pi, index in reversed(annotated_reductions(plan)): + if kind == "swap": + out.append(Instruction("swap", i, k, unit)) + continue + coefficient = Coefficient("shear", i, k, -c % modulus, pi, index) + if i > k: + out.append(Instruction("lower", i, k, coefficient)) + else: + out.extend((Instruction("swap", i, k, unit), + Instruction("lower", k, i, coefficient), + Instruction("swap", i, k, unit))) + require(all(op.target > op.source for op in out if op.kind == "lower"), + "ordered physical ADD fields") + return tuple(out) + + +def prepare(prefix, low_only_ancestors=False, low_only_current=False): + header = prefix.current + require(header.q >= 3 and header.q % 2 and header.width >= 1, "odd ring domain") + modulus = header.q ** header.width + arithmetic = Arithmetic(modulus) + weights = Root(prefix.root_size, modulus, prefix.root_unit) + preparations = 0 + for ancestor in prefix.ancestors: + h = ancestor.header + require((h.q, h.width) == (header.q, header.width), "fixed radix and atom width") + f = weights.size // h.dimension + require(f >= 1, "proper ancestor block extent") + p = projector(h.read(arithmetic, low_only_ancestors), h.axes, modulus) + preparations += 1 + if ancestor.kind == "good": + pivots = good_pivots(p, len(h.axes), modulus) + weights = Good(weights, h.dimension, f, pivots) + elif ancestor.kind == "pair": + plan = elimination(residual(p, modulus), modulus) + weights = FallbackPair(weights, h.dimension, f, plan, + ancestor.field, ancestor.reverse) + else: + raise ValueError("unknown ancestor descriptor") + f = weights.size // header.dimension + require(f >= 1, "current fallback block extent") + p = projector(header.read(arithmetic, low_only_current), header.axes, modulus) + matrix = residual(p, modulus) + plan = elimination(matrix, modulus) + return Prepared(prefix, weights, matrix, plan, f, compile_program(plan), + arithmetic, preparations + 1) + + +def bank_weight(prepared, row, column): + m, f = prepared.dimension, prepared.columns + require(0 <= row < 2*m and 0 <= column < f, "bank weight index") + if row >= m: + return 1 + prepared.arithmetic.counts["descriptor_value_requests"] += 1 + value = prepared.weights.value(row*f + column) + require(gcd(value, prepared.modulus) == 1, "generated ancestor unit") + return value + + +def coefficient(prepared, descriptor, column, final_permutation=False): + if descriptor.kind == "unit": + return 1 + if descriptor.kind == "fixed": + return descriptor.scalar % prepared.modulus + if descriptor.kind == "pair": + numerator_row = descriptor.permutation[descriptor.first] + denominator_row = descriptor.first + elif descriptor.kind == "shear": + pi = prepared.plan.permutation if final_permutation else descriptor.permutation + numerator_row, denominator_row = pi[descriptor.first], pi[descriptor.second] + else: + raise ValueError("unknown coefficient descriptor") + a = bank_weight(prepared, numerator_row, column) + b = bank_weight(prepared, denominator_row, column) + return prepared.arithmetic.mul(descriptor.scalar, + prepared.arithmetic.mul(a, prepared.arithmetic.inv(b))) + + +def physical_atom(field, column, m, f): + return field*f + (column if field < m else f-1-column) + + +def child_descriptor(prepared, operation): + require(operation.kind == "swap", "weighted child operation") + if operation.coefficient.kind == "unit": + return Root(prepared.columns, prepared.modulus) + require(operation.coefficient.kind == "pair" and + operation.target == operation.coefficient.first and + operation.source == 2*prepared.dimension-1, "fallback pair child binding") + return FallbackPair(prepared.weights, prepared.dimension, prepared.columns, + prepared.plan, operation.target, + operation.target >= prepared.dimension) + + +def logical_column(field, atom, m, f): + require(0 <= atom < f, "physical atom extent") + return atom if field < m else f-1-atom + + +def shape(operations): + return tuple((x.kind, x.target, x.source, x.coefficient.kind, + x.coefficient.reduction_index) for x in operations) + + +def reconstruct(prepared, column, final_permutation=False): + """Full ADDRESS operator; payload execution uses the separate stream code.""" + n, modulus = 2*prepared.dimension, prepared.modulus + out = identity(n) + for op in prepared.operations: + i, k = op.target, op.source + c = coefficient(prepared, op.coefficient, column, final_permutation) + if op.kind == "lower": + if c: + out[i] = [(x+c*y) % modulus for x, y in zip(out[i], out[k])] + elif op.kind == "swap": + a, b = out[i], out[k] + out[i] = [c*x % modulus for x in b] + inverse = pow(c, -1, modulus) + out[k] = [inverse*x % modulus for x in a] + else: + out[i] = [c*x % modulus for x in out[i]] + return out + + +def paid_children(prepared): + f, m = prepared.columns, prepared.dimension + widths = [] + for op in prepared.operations: + if op.kind != "swap": + continue + same_orientation = (op.target < m) == (op.source < m) + if same_orientation and f//2: + widths.append(f//2) + widths.append(f) + if same_orientation and f//2: + widths.append(f//2) + return widths diff --git a/research/selected-control-table-binding/sources/pr2234/vendor/ring_algebra.py b/research/selected-control-table-binding/sources/pr2234/vendor/ring_algebra.py new file mode 100644 index 0000000000..c924d1e8db --- /dev/null +++ b/research/selected-control-table-binding/sources/pr2234/vendor/ring_algebra.py @@ -0,0 +1,196 @@ +"""Exact local-ring checks for the selected dyadic frame identities.""" +from math import gcd + + +def need(condition,message): + if not condition:raise ValueError(message) + + +def eye(n):return [[int(i==j) for j in range(n)] for i in range(n)] +def transpose(a):return [list(row) for row in zip(*a)] + + +def multiply(a,b,modulus): + 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)%modulus + return out + + +def difference(a,b,modulus): + return [[(x-y)%modulus for x,y in zip(row,other)] for row,other in zip(a,b)] + + +def reduce_matrix(a,modulus): + return [[x.numerator*pow(x.denominator,-1,modulus)%modulus for x in row] for row in a] + + +def inverse(a,q,modulus): + n=len(a);rows=[list(row)+unit for row,unit in zip(a,eye(n))] + for j in range(n): + pivot=next((i for i in range(j,n) if gcd(rows[i][j],q)==1),None) + need(pivot is not None,"unit matrix pivot") + rows[j],rows[pivot]=rows[pivot],rows[j] + unit=pow(rows[j][j],-1,modulus) + rows[j]=[x*unit%modulus for x in rows[j]] + for i in range(n): + if i!=j and rows[i][j]: + c=rows[i][j];rows[i]=[(x-c*y)%modulus for x,y in zip(rows[i],rows[j])] + need([row[:n] for row in rows]==eye(n),"inverse endpoint") + return [row[n:] for row in rows] + + +def independent_columns(a,q): + rows=[[x%q for x in row] for row in a];rank=0;columns=[] + for j in range(len(rows[0])): + pivot=next((i for i in range(rank,len(rows)) if rows[i][j]),None) + if pivot is None:continue + rows[rank],rows[pivot]=rows[pivot],rows[rank] + u=pow(rows[rank][j],-1,q) + rows[rank]=[x*u%q for x in rows[rank]] + for i in range(len(rows)): + if i!=rank and rows[i][j]: + c=rows[i][j];rows[i]=[(x-c*y)%q for x,y in zip(rows[i],rows[rank])] + columns.append(j);rank+=1 + if rank==len(rows):break + return columns + + +def split_basis(p,rank,q,modulus): + """Lift an image/kernel basis from F_q using the actual ring columns.""" + n=len(p);complement=difference(eye(n),p,modulus) + image=independent_columns(p,q);kernel=independent_columns(complement,q) + need(len(image)==rank and len(kernel)==n-rank,"specialized rank") + basis=[[p[i][j] for j in image]+[complement[i][j] for j in kernel] for i in range(n)] + inv=inverse(basis,q,modulus) + diagonal=[[int(i==j and i8:g[0][n-1]=1+q + return g,inverse(g,q,modulus) + + +def conjugate(p,g,gi,modulus): + return multiply(multiply(g,p,modulus),gi,modulus) + + +def lifted_stage(p,stage,n=64,reverse=False): + out=[[0]*n for _ in range(n)] + for i in range(8): + for j in range(8):out[i][j]=(int(i==j)-p[i][j]) if reverse else p[i][j] + for i in range(8,8+7*stage):out[i][i]=1 + return out + + +def ring_certificate(projectors,dims,programs,word): + residuals={};pairs=set() + for orientation,events in programs.items(): + rev=orientation=="reverse" + for event in events: + if event[0] not in (0,2):continue + a,b=(event[2],event[3]) if event[0]==0 else (event[3],event[4]) + rank=event[4] if event[0]==0 else event[5] + lo,hi=(a,b) if dims[a]<=dims[b] else (b,a) + p=tuple(tuple(x-y for x,y in zip(r,s)) for r,s in zip(projectors[hi],projectors[lo])) + need(all(x.denominator&(x.denominator-1)==0 for row in p for x in row),"dyadic residual") + need(sum(p[i][i] for i in range(8))==rank,"exact rational residual rank") + residuals[p]=rank;pairs.add((rev,a,b,p)) + tests=list(zip(projectors,dims))+list(residuals.items()) + ring_cases=0;rank_divisible_by_prime=0;basis_digest=[] + for q,width in ((3,2),(5,2),(7,2),(3,3)): + modulus=q**width + for rational,rank in tests: + p=reduce_matrix(rational,modulus) + image,kernel,_=split_basis(p,rank,q,modulus) + basis_digest.append([q,width,rank,image,kernel]) + ring_cases+=1;rank_divisible_by_prime+=int(rank>0 and rank%q==0) + transports=0 + for q,width,high in ((3,2,True),(5,2,False),(3,3,True)): + modulus=q**width;g,gi=chart(8,q,width,high) + weights=[(1+i%(q-1)+q*(i+1))%modulus for i in range(8)] + labels={} + for rev,a,b,residual in pairs: + for f in (a,b): + if (rev,f) not in labels: + p=reduce_matrix(projectors[f],modulus) + if rev:p=difference(eye(8),p,modulus) + labels[rev,f]=weighted_swap(conjugate(p,g,gi,modulus),weights,modulus) + r=conjugate(reduce_matrix(residual,modulus),g,gi,modulus) + need(multiply(labels[rev,a],labels[rev,b],modulus)==weighted_swap(r,weights,modulus),"weighted ring MOVE/COPY transport") + transports+=1 + # A high-only departure from O: a transpose shortcut passes modulo3. + q,modulus=3,9;g,gi=chart(8,q,2,True) + p=reduce_matrix(projectors[word["start"][8]],modulus) + good=conjugate(p,g,gi,modulus);bad=conjugate(p,g,transpose(g),modulus) + defect=difference(multiply(bad,bad,modulus),bad,modulus) + need(multiply(good,good,modulus)==good,"GL inverse conjugation") + need(all((x-y)%q==0 for r,s in zip(good,bad) for x,y in zip(r,s)),"same low projector") + need((good[1][1],bad[1][1],defect[1][1])==(1,4,6),"zero-based transpose witness") + bad_swap=weighted_swap(bad,[1]*8,modulus) + need(difference(multiply(bad_swap,bad_swap,modulus),eye(16),modulus)[1][1]==3,"bad involution control") + # Reorthogonalizing also fails, even when each replacement is an idempotent. + root=word["lines"][word["frames"][word["start"][8]][0]] + need(root==[0,1,1,0,1,0,0,1],"selected port-eight line") + u=[row[0] for row in multiply(g,[[x] for x in root],modulus)] + v=[row[0] for row in multiply(transpose(gi),[[x] for x in root],modulus)] + def orthogonal_line(vector): + norm=sum(x*x for x in vector)%modulus + return [[x*y*pow(norm,-1,modulus)%modulus for y in vector] for x in vector] + wrong_p=orthogonal_line(u) + wrong_q=difference(eye(8),orthogonal_line(v),modulus) + split_basis(wrong_p,1,q,modulus);split_basis(wrong_q,7,q,modulus) + for candidate,reference in ((wrong_p,good),(wrong_q,difference(eye(8),good,modulus))): + need(all((x-y)%q==0 for a,b in zip(candidate,reference) for x,y in zip(a,b)),"reorthogonalized low agreement") + action=weighted_swap(candidate,[1]*8,modulus) + need(multiply(action,action,modulus)==eye(16),"reorthogonalized individual involution") + wrong_endpoint=multiply(weighted_swap(wrong_p,[1]*8,modulus),weighted_swap(wrong_q,[1]*8,modulus),modulus) + endpoint_defect=difference(wrong_endpoint,weighted_swap(eye(8),[1]*8,modulus),modulus) + need((endpoint_defect[1][4],endpoint_defect[4][1])==(6,3),"reorthogonalization loses complementary kernels") + # Actual ambient dimension, stage padding and a chart mixing local/exterior axes. + ambient=0 + for q,width in ((3,2),(5,2)): + modulus=q**width;g,gi=chart(64,q,width) + weights=[(1+i%(q-1)+q*(i+1))%modulus for i in range(64)] + for stage in (0,3,8): + for rev in (False,True): + a=reduce_matrix(lifted_stage(projectors[510],stage,reverse=rev),modulus) + b=reduce_matrix(lifted_stage(projectors[0],stage,reverse=rev),modulus) + r=reduce_matrix(lifted_stage(projectors[510],0),modulus) + aa=weighted_swap(conjugate(a,g,gi,modulus),weights,modulus) + bb=weighted_swap(conjugate(b,g,gi,modulus),weights,modulus) + rr=weighted_swap(conjugate(r,g,gi,modulus),weights,modulus) + need(multiply(aa,bb,modulus)==rr,"ambient weighted rank-seven COPY") + ambient+=1 + return {"frames":len(projectors),"distinct_nested_residuals":len(residuals), + "split_basis_cases":ring_cases,"rank_divisible_by_prime_cases":rank_divisible_by_prime, + "weighted_transport_cases":transports,"ambient_COPY_cases":ambient, + "transpose_shortcut_control":{"status":"REJECT","q":3,"width":2,"entry":[1,1], + "good":1,"bad":4,"idempotence_defect":6,"involution_defect":3}, + "reorthogonalization_control":{"status":"REJECT","q":3,"width":2, + "individual_ranks":[1,7],"individual_involutions":True,"same_low_projectors":True, + "endpoint_defect_entries":[[1,4,6],[4,1,3]]}, + "basis_choices":basis_digest} diff --git a/research/selected-control-table-binding/sources/pr2310/NOTICE.md b/research/selected-control-table-binding/sources/pr2310/NOTICE.md new file mode 100644 index 0000000000..7fe56b0130 --- /dev/null +++ b/research/selected-control-table-binding/sources/pr2310/NOTICE.md @@ -0,0 +1,33 @@ +# Attribution and scope + +Jose Manuel (`jmbarrancoml`) prepared the iterative control interpreter, +global-slot/reset checks, explicit polynomial envelope and uniform fibre +absorption argument with substantial OpenAI Codex assistance. New material +uses Apache-2.0. We claim no independent human or new formal verification. + +commdata2338's PR2188 supplies the Root/Good/FallbackPair grammar, building +on source527, Ross Richardson's PR2159 fallback algebra and Jose Manuel's +PR2171 handoff. `reference.py` adapts the three value formulas from that +descriptor as retained in PR2234. We replace the descriptor objects with +level-indexed program records and add the unit-reset base case. We import +no unchanged predecessor executable and make no independent source-replay +claim for this reference. + +Jose Manuel's PR2234 supplies the selected caller, chronological expression +binding, retained stream adapters and root-coupled recursion. Its notices +retain DreamingOfClouds, eumemic, alephnan, Rohan Arun and the rest of the +selected supplier lineage. commdata2338's PR1379 supplies the parking-boundary +argument, and OpenAI's frozen stream source supplies the local counter and +complete-fibre conventions. + +Gareth Davidson (`bitplane`) formalizes the stopped recurrence in PR2289 +and discharges its fractional moment in PR2295. He identifies the uniform +physical charge as a remaining premise. We address its control/metadata +portion under the named payload primitives; we do not claim that those +Lean developments prove our new compiler or the full selected machine. + +SOURCES.json pins the relevant PR2234 text and implementation interfaces. +Those pending files are proof/source references, not runtime imports in this +package. The local checker authenticates the declared live inputs and tests +the new control model. Independent assessment of the complete physical +realization remains open. diff --git a/research/selected-control-table-binding/sources/pr2310/PROOF.md b/research/selected-control-table-binding/sources/pr2310/PROOF.md new file mode 100644 index 0000000000..1b8db5d0da --- /dev/null +++ b/research/selected-control-table-binding/sources/pr2310/PROOF.md @@ -0,0 +1,220 @@ +# One control-work constant across selected BIT root contexts + +We address the physical-charge handoff in PR2289/2295. PR2234 states a +nonchild bound `C V(n+w)` but leaves its control preparation in polynomial +notation. We give an explicit compiler discipline and polynomial envelope +for that preparation, including field access after a unit reset. We retain +the selected literal schedule and the completed payload primitives. + +The result concerns their nonchild work. It does not prove the entire +selected machine, rerun its GL64 payload, or improve the selected exponent. +We claim no new recurrence or moment result. Gareth Davidson's PR2289/2295 +formalize those separate implications; their physical premises remain +distinct from the Lean proof. + +## 1. Quantified context + +Fix q, an odd prime, and the selected dimension 64 and literal word. The +production construction chooses q>2^80; the argument here only needs q>=3. +For an original digit width e>=1 set + + c=17/10000, w=ceil(e^c), B=q^w. + +Keep w fixed throughout that coarse recursion. Global generation depth h +counts every descent, including unit and orientation children. The selected +proper-width rule gives `h<=2 ceil(log2(max(2,e)))`; at e=1 there are no +descendants. The incoming atom width n is at most e. Each generated weight +reads only earlier frozen matrix fields and its fixed descriptor. It does +not read the current fresh matrix, unused stock or arbitrary spectators. + +We implement each bounded-dimensional modular preparation using schoolbook +binary arithmetic. Constants may depend on q and the fixed selected word, +but not on e,w,n,h, matrix values, arbitrary spectator cardinalities, row +multiplicity or the parking-stack position. We count full payload volume V +at the current node, after any enclosing one-time padding. + +**Claim.** For the pass compiler below, one scalar/atom pass costs O_q(V), +one fixed header route costs O_q(Vw), and the selected node's complete +nonchild work costs `C_q V(n+w)` with one constant C_q across these contexts. +We include coefficient preparation, local metadata, counters, rewinds, +scratch erasure and parked control state. This statement uses the retained +linear payload-pass and parking constructions at their stated boundaries. + +## 2. A shared descriptor and a local evaluator + +Store one chronological chain of Good, FallbackPair and unit-reset records. +Each record holds its parent index, atom extent, finite request/low-class +metadata and global frozen-field slot. A unit reset starts a new constant +weight expression but increments the global age. It does not delete a +physical coordinate or silently renumber later field references. + +For a fixed prefix fibre, maintain its generated matrix fields as local +counters. A field has 4096 radix-q digits per high layer and a fixed low +matrix. Accessing a requested field scans this compact control band and +returns its head. The band excludes arbitrary spectator and unused-stock +counters. Build the full-ring projector and the unweighted normalizer or +128-by-128 fallback plan from this field. No parent weight appears in that +matrix preparation. + +The weight grammar, with m=64 and f=floor(parent_size/m), is + + Root(i)=a; + Good(i)=Parent(i)*delta_floor(i/f); + Pair(i)=d_j * B_(pi(j),t) / B_(j,t), + B_(r,t)=Parent(r*f+t) for r=2, root coupling gives + + e^17<=w^10000, e<=w^589, + h<=2 ceil(log2 e), 2^(h+1)<=8e^2. + +Thus one weight evaluation visits at most 8e^2 grammar nodes. Both local +indices and the generated control chain fit +`O_q(h(w+log(e+1)))=O_q(w^2)` bits, since +`log2 e<=589 log2 w` and `log2 w<=w`. This includes sequential table +location and return of the local head, rather than a unit-cost random read. + +Modular operands have O_q(w) bits. Long multiplication and reduction cost +O_q(w^2); Euclidean inversion has O_q(w) division steps of O_q(w^2) cost, +so O_q(w^3) suffices. The 64/128 matrix dimensions are fixed. Their complete +projectors, bases, elimination, coefficient and scalar preparation therefore +cost O_q(w^3), independent of rank, high values and pivot itinerary. The +stack/control scan fits within that allowance. Preparing at most e requested +values and their fixed-size plans costs + + E(w)<=A_q e^3 w^3<=A_q w^1800. + +For an exact exponent check, raise to the seventeenth power: +`e^51 w^51<=w^30051<=w^30600=(w^1800)^17`. +The constant A_q also covers root parsing, a literal vector if requested, +local scratch erasure and the finite initial cases. We do not scan a vector +of length e inside each grammar node; such a different implementation needs +its own bound. + +When w=1, root coupling forces e=1. There is no recursive ancestry or +growing descriptor. The high-header field has cardinality 1, and its route +takes the retained identity bypass. Fixed low-class operations still have +a q-dependent constant cost. Thus the same envelope covers this case. + +## 4. Uniform absorption, including high-header fibres + +For any positive integers w and A, + + w^A/A! <= binomial(w+A-1,A) <= 2^(w+A-1). + +The first inequality compares the factors w,w+1,...,w+A-1 with w; the +second uses the sum of the row of Pascal's triangle. Since q>=2, + + w^1800 / q^(w-1) <= 2^1800 * 1800!. + +Define `K_q=A_q*2^1800*1800!`. We obtain E(w)<=K_q q^(w-1) for all +w>=1, with no cutoff depending on the root context. The body target has +the larger range q^w. We do not substitute q^w for a header's q^(w-1) +range or infer this assertion from numerical sampling of w. + +For a complete atom pass, at most V/q^w target fibres each require one +coefficient preparation. Splitting and merging each perform one such scan; +they may recompute rather than save an enormous coefficient table. Hence + + O_q(V) + O_q((V/q^w) E(w)) = O_q(V). + +The actual retained controlled-ADD implementation prepares once per parent +prefix before its unused/source/middle loops, which is less frequent than +this conservative count. At header boundaries use V/q^(w-1) instead. +The fixed route uses O(w) elementary passes and therefore costs O_q(Vw). + +## 5. Arbitrary spectators require separate counters + +An unrelated prefix can have bit length L independent of w. Repeatedly +reading it at each target fibre would cost `Theta(V L/q^(w-1))`, which +the preceding bound does not cover. In particular, the finite Python +header model's `(prefix//middle)%radix` must not become a fresh division +of a long flattened address on each visit. + +Compile the pass as nested counters for `before`, active source x, `middle`, +target blocks and suffix bits. The offset reads only x, permitted generated +fields and fixed low carries. Hold x while the middle loop runs. Advance +and reset arbitrary spectator counters in their own bands; do not include +them in an ancestry scan. For fixed header scaling, update the piece index +as a finite residue state, since its multiplier belongs to the fixed route +alphabet. Prepare its endpoints once per pass. + +Copy target blocks by nested block/suffix counters. Do not multiply an +arbitrarily long suffix descriptor into a fresh flattened length at each +fibre. A suffix counter reset costs O(log(2S)) and precedes S copied bits; +`log2(2S)<=2S` absorbs it. Ripple carry/decrement visits amortize over a +complete counter traversal. Initialize arbitrary shape lengths once per +pass, charging their fixed polynomial in log(2V) to O(V). The source's +fixed collapsed-field convention supplies exactly these local counters. + +This is a compiler choice within the retained stream interface. We do not +claim the Python indexed-address model already implements bit-cost arithmetic +or that arbitrary spectral/row counters have O(w) bits. + +## 6. Node charge, reset boundary and parking + +The selected good and fallback bodies use O(n) atom passes, with fixed +dimension, rank and low-class multiplicities. Fixed header routes contribute +O(Vw); selection, XOR, copy/erase and packet replacement contribute O(V). +The peeled remainder has fewer than 64 atoms and costs O(Vw). Summing these +charges gives one `C_q V(n+w)`. + +Before a recursive call, discard numerical preparation and pass a shared +symbolic descriptor. Copy the needed local metadata once; keep the frozen +field coordinates in the complete I/O prefix. The child reconstructs their +values through its local counters. It reads no buried ancestor record. +The remaining descriptor/control volume has a polynomial bound in w and +can be charged to the same complete-fibre allowance. Add its O_q(V) copying, +parking, restoration and cleanup to the retained unequal-buffer wrapper. +No counter needs an additional tape per recursive depth: the stacks and +records occupy a fixed set of marked work tapes. + +The constant may be enormous and depends on the selected program and q. +It is independent of ancestor values, root width, arbitrary spectator sizes, +row multiplicity and stack offset. This supplies the uniform-control and +local-state portion of the nonchild-charge premise. The complete selected +payload endpoint, physical pass implementation and recursion remain the +named PR2234 construction; we do not equate a control evaluator with its +entire realization or claim a new Lean instantiation. + +## 7. Evidence and credit + +The finite checks compare an iterative evaluator with an attributed recursive +reference for the retained weight grammar, exercise unit-reset descendants +with global field slots, +and test counter-based offsets against address formulas. They include +independence from fresh stock, stale/compacted-field rejection and stack/head +cleanup. Exact inequalities certify the polynomial exponent and factorial +absorption. Finite operation counts supplement the all-size argument above; +they do not bound Python runtime or enumerate the selected GL64 payload. + +We credit commdata2338's shared descriptor grammar, Ross Richardson's +fallback algebra, the selected supplier lineage and the existing PR2234 +stream constructions. Gareth Davidson's PR2289/2295 supply the separate +formal recurrence/moment results and the explicit physical-charge handoff. +Jose Manuel (`jmbarrancoml`) prepared this contribution with substantial +OpenAI Codex assistance. Independent review remains necessary. diff --git a/research/selected-control-table-binding/sources/pr2310/control.py b/research/selected-control-table-binding/sources/pr2310/control.py new file mode 100644 index 0000000000..3d9ab566d9 --- /dev/null +++ b/research/selected-control-table-binding/sources/pr2310/control.py @@ -0,0 +1,200 @@ +"""Iterative generated-weight control with sequential frozen-table access. + +Tables represent completed fixed-size full-ring preparation. Their producer +cost is a separate part of PROOF.md, not measured by this finite interpreter. +""" +from dataclasses import dataclass, field +from math import gcd + + +def need(test, message): + if not test: + raise ValueError(message) + + +@dataclass(frozen=True) +class Step: + kind: str + tag: int + rank: int = 7 + field: int = 1 + reverse: bool = False + half: bool = False + + +@dataclass(frozen=True) +class Program: + q: int + width: int + root_size: int + unit: int + steps: tuple + + def extents(self): + need(self.q >= 3 and self.q % 2 and self.width >= 1, "odd atom ring") + need(gcd(self.unit, self.q) == 1 and self.root_size > 0, "root unit and extent") + out = [self.root_size] + for step in self.steps: + f = out[-1] // 64 + need(f >= 1 and step.tag >= 0 and + step.tag.bit_length() <= 4096 * (self.q**self.width).bit_length() + 64, + "internal descriptor extent") + if step.kind == "good": + need(1 <= step.rank <= 42, "selected good rank") + size = step.rank * f + elif step.kind == "pair": + need(0 <= step.field < 127, "diagonal pair field") + size = f + else: + need(step.kind == "unit", "generated descriptor kind") + size = f // 2 if step.half else f + need(0 < size <= 42 * f < out[-1], "proper generated child") + out.append(size) + return out + + +@dataclass(frozen=True) +class Table: + tag: int + pivots: tuple + diagonal: tuple + permutation: tuple + + +@dataclass +class Meter: + requests: int = 0 + combines: int = 0 + field_reads: list = field(default_factory=list) + bit_reads: int = 0 + head_moves: int = 0 + ring_operations: int = 0 + maximum_stack_items: int = 0 + + +class FrozenTape: + """Read-only, fixed-size pages with charged head motion and word decoding.""" + def __init__(self, tables, modulus, meter): + self.modulus = modulus + self.word_bits = (modulus - 1).bit_length() + self.tag_bits = max(16, max((t.tag.bit_length() for t in tables), default=0)) + need(self.tag_bits <= 4096 * modulus.bit_length() + 64, "bounded low/request metadata") + self.page_bits = self.tag_bits + 192 * self.word_bits + 128 * 7 + self.count = len(tables) + self.meter = meter + self.head = 0 + data = [] + def emit(value, width): + need(0 <= value < 1 << width, "encoded field extent") + data.extend((value >> j) & 1 for j in range(width)) + for table in tables: + need(len(table.pivots) == 64 and len(table.diagonal) == 128, + "fixed preparation table dimensions") + need(sorted(table.permutation) == list(range(128)), "row permutation") + need(all(0 <= x < modulus and gcd(x, modulus) == 1 + for x in table.pivots + table.diagonal), "prepared units") + emit(table.tag, self.tag_bits) + for value in table.pivots + table.diagonal: + emit(value, self.word_bits) + for value in table.permutation: + emit(value, 7) + self.data = tuple(data) + + @property + def unused_stock(self): + raise ValueError("unused stock is outside coefficient control") + + def move(self, destination): + need(0 <= destination <= len(self.data), "local frozen-tape boundary") + self.meter.head_moves += abs(destination - self.head) + self.head = destination + + def word(self, width): + value = 0 + for j in range(width): + need(self.head < len(self.data), "complete control word") + value |= self.data[self.head] << j + self.head += 1 + self.meter.bit_reads += 1 + self.meter.head_moves += 1 + return value + + def read(self, slot, tag): + need(0 <= slot < self.count, "frozen field excludes current fresh matrix") + self.move(slot * self.page_bits) + observed = self.word(self.tag_bits) + pivots = tuple(self.word(self.word_bits) for _ in range(64)) + diagonal = tuple(self.word(self.word_bits) for _ in range(128)) + permutation = tuple(self.word(7) for _ in range(128)) + self.move(0) + need(observed == tag, "frozen low/request binding") + self.meter.field_reads.append(slot) + return Table(observed, pivots, diagonal, permutation) + + +def evaluate(program, tape, index): + sizes = program.extents() + depth = len(program.steps) + need(tape.count == depth, "retain the global frozen-field prefix") + need(0 <= index < sizes[-1], "requested weight extent") + modulus = program.q**program.width + need(tape.modulus == modulus and tape.head == 0, "one local ring and head origin") + pending, values = [("value", depth, index)], [] + meter = tape.meter + while pending: + meter.maximum_stack_items = max(meter.maximum_stack_items, len(pending) + len(values)) + event = pending.pop() + if event[0] == "constant": + values.append(event[1]) + elif event[0] == "multiply": + values[-1] = values[-1] * event[1] % modulus + meter.ring_operations += 1 + meter.combines += 1 + elif event[0] == "pair": + denominator, numerator = values.pop(), values.pop() + need(gcd(denominator, modulus) == 1, "generated denominator unit") + values.append(event[1] * numerator * pow(denominator, -1, modulus) % modulus) + meter.ring_operations += 3 + meter.combines += 1 + else: + _, level, coordinate = event + meter.requests += 1 + need(0 <= coordinate < sizes[level], "recursive index extent") + if level == 0: + values.append(program.unit % modulus) + continue + step = program.steps[level - 1] + if step.kind == "unit": + values.append(1) + continue + table = tape.read(level - 1, step.tag) + f = sizes[level - 1] // 64 + if step.kind == "good": + pending.extend((("multiply", table.pivots[coordinate // f]), + ("value", level - 1, coordinate))) + else: + j = f - 1 - coordinate if step.reverse else coordinate + def bank(row): + return ("value", level - 1, row * f + j) if row < 64 else ("constant", 1) + pending.extend((("pair", table.diagonal[step.field]), + bank(step.field), bank(table.permutation[step.field]))) + need(len(values) == 1 and gcd(values[0], modulus) == 1, "one completed unit value") + result = values.pop() + need(not pending and not values and tape.head == 0, "local stack and head restoration") + return result + + +def header_offsets(before, radix, middle, coefficient, carry, meter): + """Active-source counter stays separate from arbitrary spectator counters.""" + need(before >= 1 and middle >= 1 and radix >= 1, "complete header rectangle") + for _before in range(before): + for source in range(radix): + if radix == 1: + offset = 0 + else: + offset = (coefficient * source + carry) % radix + meter["active_preparations"] += 1 + meter["active_bits_read"] += max(1, source.bit_length()) + for _middle in range(middle): + meter["fibres"] += 1 + yield offset diff --git a/research/selected-control-table-binding/test_integrity.py b/research/selected-control-table-binding/test_integrity.py new file mode 100644 index 0000000000..34c627721c --- /dev/null +++ b/research/selected-control-table-binding/test_integrity.py @@ -0,0 +1,71 @@ +#!/usr/bin/env python3 +"""Artifact corruption controls, including an actual copied-source CLI failure.""" +import copy +import importlib.util +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest + +HERE = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location("binding_verifier", HERE / "verify.py") +verify = importlib.util.module_from_spec(spec) +spec.loader.exec_module(verify) + + +class Integrity(unittest.TestCase): + def test_every_source_and_blob(self): + manifest = json.loads((HERE / "SOURCES.json").read_text()) + records = [(verify.ROOT / r["path"], r) for r in manifest["files"] if r["usage"] == "input"] + records += [(HERE / r["path"], r) for r in manifest["vendored"]] + for path, record in records: + with self.subTest(path=record["path"]): + data = path.read_bytes() + verify.authenticate(data, record) + with self.assertRaisesRegex(ValueError, "source SHA256"): + verify.authenticate(data + b"\n", record) + with self.assertRaisesRegex(ValueError, "source Git blob"): + verify.authenticate(data, dict(record, git_blob="0" * 40)) + + def test_complete_typed_receipt(self): + result = json.loads((HERE / "RESULT.json").read_text()) + verify.compare_receipt(result, copy.deepcopy(result)) + mutations = [] + changed = copy.deepcopy(result) + changed["width_one_root"] = 1 # Python's raw dict equality accepts True == 1. + self.assertEqual(changed, result) + mutations.append(changed) + changed = copy.deepcopy(result) + changed["fixtures"][0]["values"][0][1] += 1 + mutations.append(changed) + changed = copy.deepcopy(result) + changed["fixtures"][0]["global_slots_read"] = [] + mutations.append(changed) + changed = copy.deepcopy(result) + del changed["independent_local_oracles"] + mutations.append(changed) + for changed in mutations: + with self.assertRaisesRegex(ValueError, "typed receipt"): + verify.compare_receipt(result, changed) + + def test_modified_vendor_rejected_before_import(self): + # The temporary directory is explicitly under the invoking workspace's + # TMPDIR when set, and no source checkout file is changed. + with tempfile.TemporaryDirectory(prefix="control-binding-") as temporary: + copied = Path(temporary) / "package" + shutil.copytree(HERE, copied, ignore=shutil.ignore_patterns("__pycache__")) + target = copied / "sources/pr2310/control.py" + target.write_text(target.read_text() + "\nraise RuntimeError('must not execute')\n") + result = subprocess.run([sys.executable, "-I", "-O", "-B", str(copied / "verify.py"), + "--repository", str(verify.ROOT)], + text=True, capture_output=True, timeout=15) + self.assertNotEqual(result.returncode, 0) + self.assertIn("source SHA256: sources/pr2310/control.py", result.stderr) + self.assertNotIn("RuntimeError", result.stderr) + + +if __name__ == "__main__": + unittest.main() diff --git a/research/selected-control-table-binding/verify.py b/research/selected-control-table-binding/verify.py new file mode 100644 index 0000000000..d7470bab75 --- /dev/null +++ b/research/selected-control-table-binding/verify.py @@ -0,0 +1,72 @@ +#!/usr/bin/env python3 +"""Read-only, source-bound replay; --emit prints the deterministic receipt.""" +import argparse +from hashlib import sha1, sha256 +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def need(test, message): + if not test: + raise ValueError(message) + + +def authenticate(data, record): + need(sha256(data).hexdigest() == record["sha256"], "source SHA256: " + record["path"]) + blob = sha1(b"blob " + str(len(data)).encode() + b"\0" + data).hexdigest() + need(blob == record["git_blob"], "source Git blob: " + record["path"]) + + +def sources(root=ROOT, package=HERE): + manifest = json.loads((package / "SOURCES.json").read_text()) + count = 0 + for record in manifest["files"]: + if record["usage"] == "input": + authenticate((root / record["path"]).read_bytes(), record) + count += 1 + for record in manifest["vendored"]: + authenticate((package / record["path"]).read_bytes(), record) + count += 1 + return count + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")) + + +def compare_receipt(actual, expected): + need(canonical(actual) == canonical(expected), "complete typed receipt equality") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--emit", action="store_true") + parser.add_argument("--repository", type=Path, default=ROOT, + help="repository supplying the pinned immutable inputs") + args = parser.parse_args() + count = sources(args.repository) + sys.path.insert(0, str(HERE)) + import binding + import checks + result = checks.run(binding.provider.Catalogue(args.repository)) + result["authenticated_sources"] = count + if args.emit: + print(json.dumps(result, indent=2, sort_keys=True)) + else: + expected = json.loads((HERE / "RESULT.json").read_text()) + compare_receipt(result, expected) + print(result["status"], "fixtures=" + str(result["fixture_cases"]), + "coordinate_equalities=" + str(result["coordinate_equalities"]), + "independent_equalities=" + str(result["independent_equalities"]), + "controls=" + str(len(result["controls"]))) + + +if __name__ == "__main__": + try: + main() + except (ValueError, OSError, KeyError) as error: + raise SystemExit("FAIL_SELECTED_CONTROL_TABLE_BINDING: " + str(error))