From 897bfb42c389d24d2d54a381a216e1f876b42109 Mon Sep 17 00:00:00 2001 From: ross Date: Sun, 18 Oct 2026 06:16:14 +1100 Subject: [PATCH] Research: exclude one-child idle-phase absorption with fixed stream encoders --- .../INDEPENDENT.json | 1202 ++++ .../idle-single-child-absorption/PROOF.md | 181 + .../idle-single-child-absorption/README.md | 69 + .../idle-single-child-absorption/RESULT.json | 6217 +++++++++++++++++ .../idle-single-child-absorption/SOURCES.json | 137 + .../idle-single-child-absorption/TASK.json | 72 + .../idle-single-child-absorption/VERIFY.json | 49 + .../independent.py | 467 ++ .../idle-single-child-absorption/verify.py | 340 + 9 files changed, 8734 insertions(+) create mode 100644 research/idle-single-child-absorption/INDEPENDENT.json create mode 100644 research/idle-single-child-absorption/PROOF.md create mode 100644 research/idle-single-child-absorption/README.md create mode 100644 research/idle-single-child-absorption/RESULT.json create mode 100644 research/idle-single-child-absorption/SOURCES.json create mode 100644 research/idle-single-child-absorption/TASK.json create mode 100644 research/idle-single-child-absorption/VERIFY.json create mode 100644 research/idle-single-child-absorption/independent.py create mode 100644 research/idle-single-child-absorption/verify.py diff --git a/research/idle-single-child-absorption/INDEPENDENT.json b/research/idle-single-child-absorption/INDEPENDENT.json new file mode 100644 index 0000000000..18cb6985e3 --- /dev/null +++ b/research/idle-single-child-absorption/INDEPENDENT.json @@ -0,0 +1,1202 @@ +{ + "R_zero_identity_all_sites": true, + "all_eight_input_columns_checked": true, + "axis": 16, + "base_main": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "baseline_characters_checked": 147, + "candidate_characters": [ + 0, + 16, + 1, + 2, + 4, + 8, + 32, + 64, + 128, + 256, + 512, + 1024, + 2048, + 4096, + 8192, + 16384, + 32768, + 65536, + 131072, + 262144, + 524288, + 1048576, + 2097152, + 4194304, + 8388608, + 16777216, + 33554432, + 67108864, + 134217728, + 268435456, + 536870912, + 1073741824, + 2147483648, + 4294967296, + 8589934592, + 17179869184, + 34359738368, + 68719476736, + 137438953472, + 274877906944, + 549755813888, + 1099511627776, + 2199023255552, + 4398046511104, + 8796093022208, + 17592186044416, + 35184372088832, + 70368744177664, + 140737488355328, + 281474976710656, + 562949953421312, + 1125899906842624, + 2251799813685248, + 4503599627370496, + 9007199254740992, + 18014398509481984, + 36028797018963968, + 72057594037927936, + 144115188075855872, + 288230376151711744, + 576460752303423488, + 1152921504606846976, + 2305843009213693952, + 4611686018427387904, + 9223372036854775808, + 18446744073709551616, + 36893488147419103232, + 73786976294838206464, + 147573952589676412928, + 295147905179352825856, + 590295810358705651712, + 1180591620717411303424, + 2361183241434822606848, + 4722366482869645213696 + ], + "candidate_sites_checked": 20, + "controls": { + "fixed_noncoordinate_projector_accepted": true, + "noncommuting_inverse_order_control": true, + "nonzero_translation_omission_rejected": true, + "rank_two_rejected": { + "character": 16, + "defect": [ + [ + 0, + 0, + [ + -1, + 1 + ] + ], + [ + 1, + 1, + [ + -1, + 1 + ] + ] + ], + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 1 + ], + "determinant": [ + 0, + -2 + ], + "rows": [ + 0, + 1 + ] + } + }, + "single_character_false_positive_accepted": true, + "varying_projector_rejected": { + "characters": [ + 1, + 2 + ], + "defects": [ + [ + [ + 0, + 0, + [ + [ + -1, + 2 + ], + [ + 1, + 2 + ] + ] + ], + [ + 0, + 1, + [ + [ + -1, + 2 + ], + [ + 1, + 2 + ] + ] + ], + [ + 1, + 0, + [ + [ + -1, + 2 + ], + [ + 1, + 2 + ] + ] + ], + [ + 1, + 1, + [ + [ + -1, + 2 + ], + [ + 1, + 2 + ] + ] + ] + ], + [ + [ + 2, + 2, + [ + -1, + 1 + ] + ] + ] + ], + "kind": "varying_projector", + "minor": { + "determinant": [ + 0, + -1 + ], + "entries": [ + [ + 0, + 0 + ], + [ + 2, + 2 + ] + ] + } + } + }, + "destination_child": 12, + "fill_payload_sha256": "8f4d6965ba573ff2b71fd7bf6b552643e086739d90bd73c55889502077638e00", + "new_kappa": null, + "owner": 0, + "port": 0, + "residual_ranks_after": [ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 48, + 0, + 47, + 0, + 49, + 48, + 1, + 1, + 0, + 0, + 0, + 0 + ], + "residual_ranks_before": [ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 48, + 0, + 48, + 0, + 48, + 48, + 1, + 1, + 0, + 0, + 0, + 0 + ], + "retained_parser_sha256": "8be7cc5becb41c8812ee4d262222244eeacc1e01c77697669c4c2404cafda4fe", + "scope": "Fixed source-pinned T740 owner0/port0 axis16 child10-to-child12 overlay; one Fourier-diagonal scalar stream child replacement with fixed stream-only input/output adapters tensored with address identity, at one existing residual phase site; all other events fixed. Encoders that mix addresses with streams are excluded.", + "source_child": 10, + "source_controls": { + "changed_source_bytes_rejected": true, + "matching_timestamp_bytecode_ignored": true, + "unchecked_hash_bytecode_ignored": true + }, + "status": "PASS_INDEPENDENT_ALL_TWENTY_SITES_OBSTRUCTED", + "surviving_sites": [], + "translations_retained": true, + "witnesses": [ + { + "character": 16, + "child": 0, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 1, + 0, + [ + 1, + 1 + ] + ], + [ + 3, + 0, + [ + 1, + 1 + ] + ], + [ + 7, + 7, + [ + -1, + 1 + ] + ] + ], + "factor_index": 19, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 7 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 7 + ] + } + }, + { + "character": 16, + "child": 1, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 0, + 2, + [ + 1, + 1 + ] + ], + [ + 7, + 7, + [ + -1, + 1 + ] + ] + ], + "factor_index": 33, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 7 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 7 + ] + } + }, + { + "character": 16, + "child": 2, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 1, + 0, + [ + 1, + 1 + ] + ], + [ + 3, + 0, + [ + 1, + 1 + ] + ], + [ + 7, + 7, + [ + -1, + 1 + ] + ] + ], + "factor_index": 21, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 7 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 7 + ] + } + }, + { + "character": 16, + "child": 3, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 0, + 2, + [ + 1, + 1 + ] + ], + [ + 7, + 7, + [ + -1, + 1 + ] + ] + ], + "factor_index": 35, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 7 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 7 + ] + } + }, + { + "character": 16, + "child": 4, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 7, + 7, + [ + -1, + 1 + ] + ] + ], + "factor_index": 46, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 7 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 7 + ] + } + }, + { + "character": 16, + "child": 5, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 7, + 7, + [ + -1, + 1 + ] + ] + ], + "factor_index": 59, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 7 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 7 + ] + } + }, + { + "character": 16, + "child": 6, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 7, + 7, + [ + -1, + 1 + ] + ] + ], + "factor_index": 48, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 7 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 7 + ] + } + }, + { + "character": 16, + "child": 7, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 7, + 7, + [ + -1, + 1 + ] + ] + ], + "factor_index": 61, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 7 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 7 + ] + } + }, + { + "character": 16, + "child": 8, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 6, + 6, + [ + -1, + 1 + ] + ], + [ + 7, + 7, + [ + -1, + 1 + ] + ] + ], + "factor_index": 71, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 6 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 6 + ] + } + }, + { + "character": 16, + "child": 9, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 7, + 4, + [ + 1, + -1 + ] + ], + [ + 7, + 5, + [ + -1, + 1 + ] + ], + [ + 7, + 7, + [ + -1, + 1 + ] + ] + ], + "factor_index": 85, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 4 + ], + "determinant": [ + -2, + 0 + ], + "rows": [ + 0, + 7 + ] + } + }, + { + "character": 16, + "child": 10, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 7, + 7, + [ + -1, + 1 + ] + ] + ], + "factor_index": 73, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 7 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 7 + ] + } + }, + { + "character": 16, + "child": 11, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 7, + 4, + [ + 1, + -1 + ] + ], + [ + 7, + 5, + [ + -1, + 1 + ] + ], + [ + 7, + 7, + [ + -1, + 1 + ] + ] + ], + "factor_index": 87, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 4 + ], + "determinant": [ + -2, + 0 + ], + "rows": [ + 0, + 7 + ] + } + }, + { + "characters": [ + 16, + 33554432 + ], + "child": 12, + "defects": [ + [ + [ + 6, + 4, + [ + -1, + 1 + ] + ], + [ + 6, + 6, + [ + -1, + 1 + ] + ] + ], + [ + [ + 0, + 0, + [ + -1, + 1 + ] + ] + ] + ], + "factor_index": 111, + "kind": "varying_projector", + "minor": { + "determinant": [ + 0, + -2 + ], + "entries": [ + [ + 6, + 4 + ], + [ + 0, + 0 + ] + ] + } + }, + { + "character": 16, + "child": 13, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 6, + 4, + [ + -1, + 1 + ] + ], + [ + 6, + 6, + [ + -1, + 1 + ] + ] + ], + "factor_index": 113, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 4 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 6 + ] + } + }, + { + "character": 16, + "child": 14, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 6, + 4, + [ + -1, + 1 + ] + ], + [ + 6, + 6, + [ + -1, + 1 + ] + ] + ], + "factor_index": 115, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 4 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 6 + ] + } + }, + { + "character": 16, + "child": 15, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 6, + 4, + [ + -1, + 1 + ] + ], + [ + 6, + 6, + [ + -1, + 1 + ] + ] + ], + "factor_index": 117, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 4 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 6 + ] + } + }, + { + "character": 16, + "child": 16, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 6, + 4, + [ + -1, + 1 + ] + ], + [ + 6, + 6, + [ + -1, + 1 + ] + ] + ], + "factor_index": 119, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 4 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 6 + ] + } + }, + { + "character": 16, + "child": 17, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 6, + 4, + [ + -1, + 1 + ] + ], + [ + 6, + 6, + [ + -1, + 1 + ] + ] + ], + "factor_index": 121, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 4 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 6 + ] + } + }, + { + "character": 16, + "child": 18, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 6, + 4, + [ + -1, + 1 + ] + ], + [ + 6, + 6, + [ + -1, + 1 + ] + ] + ], + "factor_index": 123, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 4 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 6 + ] + } + }, + { + "character": 16, + "child": 19, + "defect": [ + [ + 0, + 0, + [ + -1, + -1 + ] + ], + [ + 6, + 4, + [ + -1, + 1 + ] + ], + [ + 6, + 6, + [ + -1, + 1 + ] + ] + ], + "factor_index": 125, + "kind": "rank_at_least_two", + "minor": { + "columns": [ + 0, + 4 + ], + "determinant": [ + 2, + 0 + ], + "rows": [ + 0, + 6 + ] + } + } + ] +} diff --git a/research/idle-single-child-absorption/PROOF.md b/research/idle-single-child-absorption/PROOF.md new file mode 100644 index 0000000000..9a8475d4e2 --- /dev/null +++ b/research/idle-single-child-absorption/PROOF.md @@ -0,0 +1,181 @@ +# A single existing phase child cannot absorb this idle-axis defect + +This is a source-bound obstruction to a precise proposed cost change. It is +not a barrier to changed words or arbitrary encodings, and gives no new kappa. + +## 1. The replacement interface + +Use the retained PR3148 T740 allocation and the literal source recipe at +owner replica zero, port zero. The independent stream inputs are arbitrary +complex arrays on `F2^73`, including arbitrary entering dirt. Transfer axis +`v=16` from residual child 10 to residual child 12. Their ranks change from +`48,48` to `47,49`. All hosted calls, other residuals, interactions, translations +and the exact target operator stay fixed. + +Permit replacing exactly one of the twenty residual phase-child positions. +At that position the new completed child is Fourier diagonal and acts on +one scalar stream. Its eigenvalue `z(x)` at character `x` can be *any* nonzero +complex number. This grants more freedom than a legitimate quarter-turn +phase child, regardless of its new address axes or rank. + +Before and after that child, grant arbitrary invertible constant scalar +stream matrices, at zero cost. Their action is explicitly +`L_stream tensor I_address` and `R_stream tensor I_address`: they apply the +same stream map at every address and do not mix addresses with stream labels. +They need not be reciprocal before normalization. Arbitrary constant global +phases and arbitrary dirty spectator streams restored exactly are allowed. +The one-child operator, rather than its private recursive implementation, +is the interface being replaced. + +This assumption is essential. A character-dependent controlled permutation, +an address-changing chart, two child uses or two changed sites belongs to a +different interface. Scalar coefficients alone do not imply stream-only action. +No such broader encoding is excluded or assigned a zero implementation cost. + +## 2. A common projector is necessary + +Let `E=e_s e_s^T` select the child's stream. With a choice of adapter order, +the local replacement at character `x` is + +``` +R(x) = L [I+(z(x)-1)E] K. +``` + +At character zero the required local operator is `R(0)=I`. Since `z(0)!=0`, +the bracket is invertible, so + +``` +K = [I+(z(0)-1)E]^-1 L^-1, +R(x) = I + (z(x)/z(0)-1) P, +P = L E L^-1, P^2=P, rank(P)=1. +``` + +The normalization also removes a constant global phase. In particular: + +1. `rank(R(x)-I)<=1` at every character; +2. all nonzero flattened matrices `R(x)-I` span the same one-dimensional + space, because the same `P` is used at every character; +3. a nonzero rank-one defect has nonzero trace, since its trace is the scalar + multiplying `P`. A nonzero rank-one nilpotent is insufficient. + +Conversely, on any supplied finite character set containing zero, rank at +most one, common one-dimensional span, nonzero trace for nonzero defects, +and `1+trace(R(x)-I)!=0` characterize this favorable interface on that set. +For a nonzero rank-one matrix `D`, `D^2=trace(D)D`, so +`P=D/trace(D)` is the required idempotent. Every rank-one idempotent is similar +to `E`. If all defects vanish, choose any `P` and all eigenvalues one. +The converse is a useful control; no finite passing set proves a full-domain +replacement or a legal physical implementation. + +Adding arbitrary dirty restored scalar spectator streams cannot avoid the +necessary condition. On the extended space the same argument gives a rank-one +projector. The full required endpoint is `R(x) direct-sum I_spectator`; any +nonzero defect therefore forces that projector to vanish on, and have no +cross terms with, all spectator rows and columns. Restriction to the eight +visible streams gives the same condition. A clean ancillary subspace or +unrestored garbage is a different promise. + +## 3. Bind the condition to literal cuts + +All matrices below are in the Fourier-character representation; global phase +is retained. At a candidate site, write the altered chronological word as +`B(x) D_site(x) A(x)`, with earlier factors on the right. Omit only that site's +residual child phase. Retain its separate address translation, the other +child at the same event, every hosted phase and every other literal event. +The required replacement is unique: + +``` +R_site(x) = B(x)^-1 T(x) A(x)^-1, +T(x) = i^popcount(x) I_8. +``` + +Both checkers verify `B D_site A` equals the altered word and +`B R_site A=T` at the tested cuts. At character zero all twenty required +replacements equal identity. The original unaltered source word equals `T` +at each character used for a witness. Thus each finite witness is an exact +counterexample to a necessary full-domain identity, not an extrapolation from +sampling. + +For nineteen sites, `x=16` alone gives a nonzero two-by-two minor of +`R_site(16)-I`. Their row/column indices and exact determinants are in +`RESULT.json`; every determinant is `2` or `-2`. This excludes all one-stream +phase replacements at those sites, even with free oblique scalar encoding. + +Site 12 exposes why checking each character separately is too weak. With +zero-based matrix indices, the exact required defects are + +``` +R_12(16)-I = (i-1)(E_(6,4)+E_(6,6)), +R_12(33554432)-I = (i-1)E_(0,0). +``` + +Each parenthesized matrix is a rank-one idempotent. They are different, +and even commute (both products are zero). Flattening positions `(6,4)` and +`(0,0)` across those two character defects gives determinant +`(i-1)^2=-2i`, which is nonzero. They cannot share one fixed projector. +This excludes the remaining site. Commutativity alone would not have sufficed. + +The finite computation covers exactly these twenty sites for this one +transfer, owner and port. The algebraic exclusion quantifies over every +nonzero eigenvalue function, every invertible *stream-only* scalar adapter +and every proposed child rank, because none can pass the necessary witnesses. +It does not quantify over other transfers or changed intervening words. + +## 4. Why this tests recursive cost + +Let `p=1-a`, `0 47,49`, but changes its eight-stream physical operator. Can the +defect be absorbed into one existing child, avoiding an additional repair call? + +For owner replica zero / port zero, the answer is **no at all twenty residual +sites** under the declared interface: one completed Fourier-diagonal phase on +one stream, surrounded by arbitrary constant invertible scalar *stream-only* +encoding and decoding (`L_stream tensor I_address`). The eigenvalue function +and all added implementation costs are granted free. Arbitrary dirty inputs, +restored dirty scalar spectators and exact global phase remain required. + +Nineteen sites fail a rank-two minor at character16. The remaining receiver +site needs two different rank-one projectors at characters16 and33554432; +their flattened minor is `-2i`. Separate per-character rank checks, and even +commutativity, miss this failure. [PROOF.md](PROOF.md) gives the normalization +argument, exact witnesses, cost connection and covered domain. + +This tests a different mechanism from PR3220's added repair tariff and +PR3229's abstract independent-group sharing. It does not cover two changed +sites, a changed interaction word, a character-dependent encoder or an encoder +mixing addresses with stream labels. It does not validate or refute another +PR's complete allocation, supplier or kappa claim. + +## Reproduction + +``` +python3.12 -B scripts/research_package.py --package research/idle-single-child-absorption +``` + +Both commands in `VERIFY.json` are standard-library-only. `verify.py` uses +authenticated retained event semantics plus exact Gaussian-rational cut +inversion; `independent.py` separately expands elementary matrices and reverses +their factors. They use all independent stream columns and retain exact phase. +The full T740 payload authenticates; only one owner/port/transfer is investigated. +`RESULT.json` and the independent committed receipt preserve exact coverage +and semantic controls. `--output /new/path.json` writes an exclusive fresh receipt. +These are finite exact checks supporting a written interface proof, not a +formal-kernel proof or full selected cold replay. Hosted CI is separate. + +Base main: `463113d675af7410ac91d53a4fed51ec6494eb9a`, priority revision6. +Selected record unchanged. Source/input pins, original card, concrete scope, +stopping rule and attribution are in `SOURCES.json` and `TASK.json`. + +## Open next questions + +- A character-dependent stream/address adapter can change the projector. + First give one actual encoder/inverse and its arbitrary-dirt endpoint, + then price all child, routing/volume, helper, precision and restoration work. + This result provides no affordable adapter. +- A joint rewrite of at least two existing sites is outside this theorem. + First specify a concrete factorization and complete recursive invoice. + The known additive two-child repair merely restores the original factors; + this result does not justify an automatic wider search. + +Structured relevance, first steps and blockers are in `TASK.json`. + +## Credit + +Ross Richardson with substantial OpenAI Codex assistance and two separately +tasked mathematical specialists. No independent human review is claimed. +The retained physical interpreter/geometry and predecessor credit remain with +Gonzalo-Mier/PR3199, Nick Petalas/PR3187, Gareth Davidson/PR1387, Jeremy +Diviney/PR3148, Rohan Arun, dcharb78, Dumitrean, Jeremy Kothe and the retained +native/geometry/selected construction lineage. PR3220 and PR3229 retain their +distinct results and credit. New material Apache-2.0; frozen sources unchanged. diff --git a/research/idle-single-child-absorption/RESULT.json b/research/idle-single-child-absorption/RESULT.json new file mode 100644 index 0000000000..617bd41503 --- /dev/null +++ b/research/idle-single-child-absorption/RESULT.json @@ -0,0 +1,6217 @@ +{ + "base": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "baseline_simultaneous_controls": 20, + "baseline_single_character_controls": 540, + "characters_tested": [ + 0, + 16, + 1, + 2, + 4, + 8, + 32, + 64, + 128, + 256, + 512, + 1024, + 2048, + 4096, + 8192, + 16384, + 32768, + 65536, + 131072, + 262144, + 524288, + 1048576, + 2097152, + 4194304, + 8388608, + 16777216, + 33554432 + ], + "contract": "One completed Fourier-diagonal phase on one stream, with fixed scalar stream-only encoder/decoder (tensor address identity); arbitrary nonzero scalar eigenvalue function; all other gates fixed.", + "new_kappa": null, + "owner_replica": 0, + "port": 0, + "sites": 20, + "status": "PASS_IDLE_SINGLE_CHILD_ABSORPTION", + "synthetic_controls": [ + "oblique-projector-accepted", + "per-character-rank-one-is-insufficient", + "nilpotent-rejected", + "rank-two-rejected" + ], + "t740_rows_authenticated": 2717280, + "transfer": { + "axis": 16, + "candidate_ranks": [ + 47, + 49 + ], + "donor": 10, + "old_ranks": [ + 48, + 48 + ], + "receiver": 12 + }, + "witness_kinds": { + "inconsistent-projector": 1, + "rank-at-least-two": 19 + }, + "witnesses": { + "0": { + "characters": [ + 16 + ], + "columns": [ + 0, + 7 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "1", + "1" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "1", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ] + ] + ] + ], + "rows": [ + 0, + 7 + ] + }, + "1": { + "characters": [ + 16 + ], + "columns": [ + 0, + 7 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "1", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ] + ] + ] + ], + "rows": [ + 0, + 7 + ] + }, + "2": { + "characters": [ + 16 + ], + "columns": [ + 0, + 7 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "1", + "1" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "1", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ] + ] + ] + ], + "rows": [ + 0, + 7 + ] + }, + "3": { + "characters": [ + 16 + ], + "columns": [ + 0, + 7 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "1", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ] + ] + ] + ], + "rows": [ + 0, + 7 + ] + }, + "4": { + "characters": [ + 16 + ], + "columns": [ + 0, + 7 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ] + ] + ] + ], + "rows": [ + 0, + 7 + ] + }, + "5": { + "characters": [ + 16 + ], + "columns": [ + 0, + 7 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ] + ] + ] + ], + "rows": [ + 0, + 7 + ] + }, + "6": { + "characters": [ + 16 + ], + "columns": [ + 0, + 7 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ] + ] + ] + ], + "rows": [ + 0, + 7 + ] + }, + "7": { + "characters": [ + 16 + ], + "columns": [ + 0, + 7 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ] + ] + ] + ], + "rows": [ + 0, + 7 + ] + }, + "8": { + "characters": [ + 16 + ], + "columns": [ + 0, + 6 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ] + ] + ] + ], + "rows": [ + 0, + 6 + ] + }, + "9": { + "characters": [ + 16 + ], + "columns": [ + 0, + 4 + ], + "determinant": [ + "-2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "-1" + ], + [ + "-1", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ] + ] + ] + ], + "rows": [ + 0, + 7 + ] + }, + "10": { + "characters": [ + 16 + ], + "columns": [ + 0, + 7 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ] + ] + ] + ], + "rows": [ + 0, + 7 + ] + }, + "11": { + "characters": [ + 16 + ], + "columns": [ + 0, + 4 + ], + "determinant": [ + "-2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "-1" + ], + [ + "-1", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ] + ] + ] + ], + "rows": [ + 0, + 7 + ] + }, + "12": { + "characters": [ + 16, + 33554432 + ], + "determinant": [ + "0", + "-2" + ], + "flat_positions": [ + 52, + 0 + ], + "kind": "inconsistent-projector", + "required_matrices": [ + [ + [ + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + ], + [ + [ + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + ] + ] + }, + "13": { + "characters": [ + 16 + ], + "columns": [ + 0, + 4 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + ] + ], + "rows": [ + 0, + 6 + ] + }, + "14": { + "characters": [ + 16 + ], + "columns": [ + 0, + 4 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + ] + ], + "rows": [ + 0, + 6 + ] + }, + "15": { + "characters": [ + 16 + ], + "columns": [ + 0, + 4 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + ] + ], + "rows": [ + 0, + 6 + ] + }, + "16": { + "characters": [ + 16 + ], + "columns": [ + 0, + 4 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + ] + ], + "rows": [ + 0, + 6 + ] + }, + "17": { + "characters": [ + 16 + ], + "columns": [ + 0, + 4 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + ] + ], + "rows": [ + 0, + 6 + ] + }, + "18": { + "characters": [ + 16 + ], + "columns": [ + 0, + 4 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + ] + ], + "rows": [ + 0, + 6 + ] + }, + "19": { + "characters": [ + 16 + ], + "columns": [ + 0, + 4 + ], + "determinant": [ + "2", + "0" + ], + "kind": "rank-at-least-two", + "required_matrices": [ + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + ] + ], + "rows": [ + 0, + 6 + ] + } + } +} diff --git a/research/idle-single-child-absorption/SOURCES.json b/research/idle-single-child-absorption/SOURCES.json new file mode 100644 index 0000000000..50a63bd274 --- /dev/null +++ b/research/idle-single-child-absorption/SOURCES.json @@ -0,0 +1,137 @@ +{ + "schema_version": 1, + "base_commit": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "input", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/adaptive-kernel-demotion/inputs/DATA-PHASES.json", + "usage": "input", + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + { + "path": "research/idle-star-paired-axis-census/README.md", + "usage": "input", + "git_blob": "6d76e96da73621aaf10299c810ce472a2b97e322", + "sha256": "1f6dec1ecb453e875193f18f4b138cc06a596f8be3677f2ad32735e79aa4e33f" + }, + { + "path": "research/idle-star-paired-axis-census/RESULT.json", + "usage": "input", + "git_blob": "daab4e70d31d3ca6e79a00573b32ca9bd5912de4", + "sha256": "a8fd3a61fec67ff330c5f743fef6b5febc6df1d8b1626f818f6a39c21d6570b9" + }, + { + "path": "research/idle-star-paired-axis-census/SOURCES.json", + "usage": "input", + "git_blob": "e23e4f3c99f0fdbb46399e9e99f5e839ecea0418", + "sha256": "3eed2495ec70135a20abd248c60609c7f0efb42dc8d7afddbacb1f8b10c63953" + }, + { + "path": "research/idle-star-paired-axis-census/TASK.json", + "usage": "input", + "git_blob": "f020a9a7d8783b50f871075a462b556d384d5d05", + "sha256": "f4e7dbb1f0305e0f22a2aaf8a942594f775ce3364cbe15031fad799e6413b198" + }, + { + "path": "research/idle-star-paired-axis-census/VERIFY.json", + "usage": "input", + "git_blob": "9a3d449cb4b6387815babe9979d47d605bafbb11", + "sha256": "072b6658d620a7fc2b4b1cc60701d252dc073c715af111d7c493ab24907381fd" + }, + { + "path": "research/idle-star-paired-axis-census/vendor/BASE-FILL.json.gz", + "usage": "input", + "git_blob": "92b49b42b8f381d686a9fb8057e74e4b7548cd5c", + "sha256": "68b8bae90144248774b1920cd27f9519caa3dc427704d8a9da6d4c491d912fc4" + }, + { + "path": "research/idle-star-paired-axis-census/vendor/EXCHANGE.json", + "usage": "input", + "git_blob": "f323db0fd94a80f691b1606e813d0738b27058ae", + "sha256": "5063791f327d067f37478488c97ce449e5b34cfb61d6309fc6924c5e360fe839" + }, + { + "path": "research/idle-star-paired-axis-census/vendor/PR3133-CREDITS.md", + "usage": "input", + "git_blob": "24f00912d4ec829c3c8d2a8d086aa135664a124c", + "sha256": "1d9d8f56d8899f55878e4cb2c4e052b22506444016a51c2e678773505f5189e6" + }, + { + "path": "research/idle-star-paired-axis-census/vendor/PR3133-NOTICE", + "usage": "input", + "git_blob": "89c20926ea7f803718f751d95989d5a269908efd", + "sha256": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661" + }, + { + "path": "research/idle-star-paired-axis-census/vendor/PROVIDERS.json", + "usage": "input", + "git_blob": "0b2343675099d0a9fe90da6e1f1e53f50235567e", + "sha256": "52eb0d85caa7b2d4a93acdf5011f52b793f61ddca86235fb03cd9a09397ad4cd" + }, + { + "path": "research/idle-star-paired-axis-census/verify.py", + "usage": "input", + "git_blob": "d6c4ade44ff7976762a542682973f5f99fe754ed", + "sha256": "8be7cc5becb41c8812ee4d262222244eeacc1e01c77697669c4c2404cafda4fe" + }, + { + "path": "research/rank7-joint-endframes/allocation/DISPATCH.json", + "usage": "input", + "git_blob": "9544fee4e6ee1f202cee22bfaeaf229ee3b2515e", + "sha256": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c" + }, + { + "path": "research/rank7-joint-endframes/allocation/ORDER.json", + "usage": "input", + "git_blob": "7409c4df1092241729739596c7648bda504e6aad", + "sha256": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + } + ], + "predecessors": [ + { + "pr": 3220, + "head": "4aa4bd8d53a2bb80fa0c7d6f634c078b33965113", + "role": "Concrete transfer and additive repair question; proof read, not a dependency replay." + }, + { + "pr": 3229, + "head": "8ec29a31efaaa99b4f7823c2d9db2142a4c810c3", + "role": "Live overlap: reported abstract direct-sum shared-repair theorem; not relied on as verified mathematics." + }, + { + "pr": 3199, + "head": "d138f8329e8c5aac9f61a071b5e21e1d49f04331", + "role": "Current live PR head for context; actual runtime bytes pinned individually at the base, not silently updated." + } + ] +} diff --git a/research/idle-single-child-absorption/TASK.json b/research/idle-single-child-absorption/TASK.json new file mode 100644 index 0000000000..4c33d22eee --- /dev/null +++ b/research/idle-single-child-absorption/TASK.json @@ -0,0 +1,72 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 6, + "base_commit": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "refined", + "actual_scope": "One-child absorbed repair of the concrete owner-zero port-zero axis16 transfer child10->12. Replace exactly one of20 residual phase sites, with arbitrary invertible stream-only scalar adapters (L_stream tensor address identity), arbitrary nonzero Fourier eigenvalue function, restored arbitrary dirty streams/spectators, all other literal gates fixed.", + "scope_change_reason": "The card permits one changed local cost interface. A separate repair child cannot pay (PR3220), and PR3229 covers abstract independent-group sharing. This tests replacement of an existing call, avoiding the additive tariff, by a decisive exact operator obligation rather than another packing census.", + "bottleneck_link": "47^(1-a)+49^(1-a)<2*48^(1-a) is a favorable recursive moment direction at fixed rank mass and call count. It is useful only if the source-bound physical operator is realizable. The operator screen grants adapters, movement, stock and restoration free; excluding it precedes implementation or larger searches.", + "budget_minutes": 240, + "stop_rule": "Stop with a verified exact counterwitness for each of20 sites, or a legal full-domain replacement and fully charged favorable invoice. No expansion to two sites, address-mixing adapters, a new owner search or a new kappa claim. Original run deadline2026-10-17T23:02:46.175752Z, closeout22:42:46.175752Z.", + "outcome": "negative-result", + "evidence": "PROOF.md and RESULT.json:19 sites have nonzero2x2 minors atcharacter16; site12 requires two different rank-one projectors atcharacters16 and33554432. Independent elementary-matrix reconstruction checks all20 sites and larger declared finite baseline/candidate domains.", + "author": "Ross Richardson", + "ai_assistance": "Substantial OpenAI Codex assistance, including two separately tasked mathematical specialists. No independent human or formal-kernel review claimed.", + "open_questions": [ + { + "question": "Can a changed interface with character-dependent stream/address encoding absorb the defect affordably?", + "why_it_matters": "It can change the projector with the Fourier character and lies outside the fixed stream-only obstruction.", + "first_step": "Specify one exact address-coupled encoding, its inverse and arbitrary-dirt endpoint; include every recursive child, routing/volume/precision/helper/restoration charge before comparing the moment.", + "blocked_by": "No affordable source-bound encoder or complete invoice supplied here." + }, + { + "question": "Can coordinated replacement of at least two existing phase sites improve the complete cost?", + "why_it_matters": "One-site absorption fails, while the two signed rank-one additive repairs of PR3220 merely undo the transfer. A coordinated changed word might alter that invoice.", + "first_step": "Present a particular joint factorization and derive its entire arbitrary-input map and paid rank/stock delta before any census.", + "blocked_by": "This result supplies neither such a factorization nor evidence that a wider search is worthwhile." + } + ] +} diff --git a/research/idle-single-child-absorption/VERIFY.json b/research/idle-single-child-absorption/VERIFY.json new file mode 100644 index 0000000000..78af330e27 --- /dev/null +++ b/research/idle-single-child-absorption/VERIFY.json @@ -0,0 +1,49 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "docs/research/agent-task-catalog.json", + "research/adaptive-kernel-demotion/inputs/DATA-PHASES.json", + "research/complex-local-word-ceiling/ceiling.py", + "research/idle-star-paired-axis-census/README.md", + "research/idle-star-paired-axis-census/RESULT.json", + "research/idle-star-paired-axis-census/SOURCES.json", + "research/idle-star-paired-axis-census/TASK.json", + "research/idle-star-paired-axis-census/VERIFY.json", + "research/idle-star-paired-axis-census/vendor/BASE-FILL.json.gz", + "research/idle-star-paired-axis-census/vendor/EXCHANGE.json", + "research/idle-star-paired-axis-census/vendor/PR3133-CREDITS.md", + "research/idle-star-paired-axis-census/vendor/PR3133-NOTICE", + "research/idle-star-paired-axis-census/vendor/PROVIDERS.json", + "research/idle-star-paired-axis-census/verify.py", + "research/rank7-joint-endframes/allocation/DISPATCH.json", + "research/rank7-joint-endframes/allocation/ORDER.json", + "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 240, + "checks": "Authenticated source interpreter and all T740 fill rows; complete20-site required replacement identities; exact rank and common-projector witnesses; actual no-move and synthetic oblique/nilpotent/rank-two controls; committed result equality." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/independent.py" + ], + "timeout_seconds": 240, + "checks": "Separately expanded elementary matrices and reverse-factor inverses;147 baseline and74 candidate character checks;20-site source-bound minors and cross-character projector defect; retained parser-byte source binding; independent controls and committed receipt." + } + ] +} diff --git a/research/idle-single-child-absorption/independent.py b/research/idle-single-child-absorption/independent.py new file mode 100644 index 0000000000..b6f6b95d24 --- /dev/null +++ b/research/idle-single-child-absorption/independent.py @@ -0,0 +1,467 @@ +#!/usr/bin/env python3 +"""Independent exact character obstruction for the owner0/port0 axis16 move. + +The retained implementation supplies authenticated JSON parsing and reconstruction +of the T740 fill. No retained operator constructor or replay is called. This +file expands elementary 8 by 8 matrices, multiplies them, and reverses their +factor lists to obtain exact inverses over Gaussian integers. +""" + +from __future__ import annotations + +import argparse +from fractions import Fraction +import hashlib +import importlib.machinery +import importlib.util +import json +import marshal +from pathlib import Path +import struct +import tempfile +import types + + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +SOURCE = ROOT / "research/idle-star-paired-axis-census/verify.py" +SOURCE_SHA256 = "8be7cc5becb41c8812ee4d262222244eeacc1e01c77697669c4c2404cafda4fe" +BASE_MAIN = "463113d675af7410ac91d53a4fed51ec6494eb9a" +Z = (0, 0) +O = (1, 0) +I = (0, 1) +N = 8 + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def plus(a, b): + return (a[0] + b[0], a[1] + b[1]) + + +def minus(a, b): + return (a[0] - b[0], a[1] - b[1]) + + +def times(a, b): + return (a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]) + + +def unit(exponent): + return (O, I, (-1, 0), (0, -1))[exponent % 4] + + +def ident(): + return [[O if a == b else Z for b in range(N)] for a in range(N)] + + +def multiply(left, right): + result = [[Z for _ in range(N)] for _ in range(N)] + for a in range(N): + for b in range(N): + coefficient = left[a][b] + if coefficient != Z: + for c in range(N): + if right[b][c] != Z: + result[a][c] = plus(result[a][c], times(coefficient, right[b][c])) + return result + + +def scale(matrix, coefficient): + return [[times(coefficient, x) for x in row] for row in matrix] + + +def defect(matrix): + return [[minus(x, O if a == b else Z) for b, x in enumerate(row)] + for a, row in enumerate(matrix)] + + +def scalar_json(number): + if isinstance(number, Fraction): + return number.numerator if number.denominator == 1 else [number.numerator, number.denominator] + return number + + +def cjson(number): + return [scalar_json(number[0]), scalar_json(number[1])] + + +def sparse_json(matrix): + return [[a, b, cjson(matrix[a][b])] for a in range(N) for b in range(N) if matrix[a][b] != Z] + + +def character_parity(character, vector): + return (character & vector).bit_count() % 2 + + +def authenticated_source(source_path=SOURCE): + need(source_path.is_file() and not source_path.is_symlink(), "retained parser path") + source_bytes = source_path.read_bytes() + need(hashlib.sha256(source_bytes).hexdigest() == SOURCE_SHA256, "retained parser source bytes") + module = types.ModuleType("_absorption_authenticated_inputs") + module.__file__ = str(source_path) + exec(compile(source_bytes, str(source_path), "exec", optimize=0), module.__dict__) + # Poison the operator functions: accidental reuse fails even during -O. + def forbidden(*_args, **_kwargs): + raise ValueError("independent oracle attempted retained matrix arithmetic") + module.run_data_event = forbidden + module.replay = forbidden + return module + + +def authenticated_context(): + """Use only the retained source's parsing/provenance side of the interface.""" + module = authenticated_source() + module.authenticate() + load = lambda path: module.decode(module.read_bytes(path)) + vendor = SOURCE.parent / "vendor" + base = load(vendor / "BASE-FILL.json.gz")["rows"] + journal = load(vendor / "EXCHANGE.json") + rows = module.project_all_ports(base, module.journal_edits(base, journal)) + order_base = load(ROOT / "research/rank7-joint-endframes/allocation/ORDER.json") + order = [[stage, replica + 74 * copy] for stage, replica in order_base for copy in range(10)] + dispatch = {(stage, replica): tag for stage, replica, tag in + load(ROOT / "research/rank7-joint-endframes/allocation/DISPATCH.json")} + providers = load(vendor / "PROVIDERS.json") + plan = load(ROOT / "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz") + template = load(ROOT / "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz") + recipes = load(ROOT / "research/adaptive-kernel-demotion/inputs/DATA-PHASES.json")["recipes"] + return module.prepare_port(0, rows[0], order, dispatch, providers, plan, template, recipes) + + +def elementary(kind, first, second=0, coefficient=0): + matrix = ident() + inverse = ident() + if kind == "phase": + matrix[first][first] = unit(second) + inverse[first][first] = unit(-second) + elif kind == "shear": + need(first != second, "self shear") + matrix[first][second] = (coefficient, 0) + inverse[first][second] = (-coefficient, 0) + elif kind == "swap": + need(first != second, "self swap") + matrix[first], matrix[second] = matrix[second], matrix[first] + inverse = [list(row) for row in matrix] + else: + raise ValueError("unknown independent elementary factor") + need(multiply(matrix, inverse) == ident() == multiply(inverse, matrix), "elementary inverse") + return matrix, inverse + + +def factors(context, residual, character): + """Column-vector factors in chronological execution order, with 20 cuts.""" + need(type(character) is int and 0 <= character < 1 << 73, "character domain") + result = [] + child_sites = {} + recipe = context["recipe"] + template = context["template"] + q = character_parity(character, recipe["q"]) + + def append(kind, a, b=0, coefficient=0, child=None): + if child is not None: + need(child not in child_sites, "duplicate child cut") + child_sites[child] = len(result) + result.append(elementary(kind, a, b, coefficient)) + + blocks = {} + stage = None + for event in template["execution_schedule"]: + if event["kind"] in ("bank_padding_cover_sweep", "translate_every_live_family"): + continue + if event["kind"] == "local_cover_sweep": + stage = event["stage"] + need(stage not in blocks, "duplicate stage") + blocks[stage] = [] + need(stage is not None, "event before stage") + blocks[stage].append(event) + need(set(blocks) == set(range(9)), "stage coverage") + + for time, (stage, replica) in enumerate(context["order"]): + for stream, axes in context["hosts"].get(time, ()): + append("phase", stream, sum(character_parity(character, v) for v in axes)) + if replica != 0: + continue + for event in blocks[stage]: + kind = event["kind"] + if kind == "local_cover_sweep": + local = next(row for row in template["recipe"] if row["kind"] == "local" + and row["stage"] == stage) + pair = local["pair"] + lower = (1 << (1 + 8 * stage)) - 1 + upper = (1 << (9 + 8 * stage)) - 1 + # Entry/exit phases are reconstructed from the interval endpoints, + # with the stage0 entry treated separately. + for side in (0, 1): + entry = (1 - side) * q if stage == 0 else (character & lower).bit_count() - side * q + append("phase", 2 * pair + side, -entry) + if local["reverse"]: + append("shear", 2 * pair, 2 * pair + 1, -1) + else: + append("shear", 2 * pair + 1, 2 * pair, 1) + for side in (0, 1): + append("phase", 2 * pair + side, (character & upper).bit_count() - side * q) + elif kind == "idle_cover_sweep": + for side, child in enumerate(event["child_indices"]): + stream = 2 * event["pair"] + side + append("phase", stream, sum(character_parity(character, v) for v in residual[child]), child=child) + # Retain this factor when the preceding phase is omitted. + append("phase", stream, 2 * character_parity(character, recipe["idle_children"][child]["translation_after"])) + elif kind == "bridge": + a, b, c = event["dst"], event["src"], event["coefficient"] + append("shear", 2 * a, 2 * b, c) + append("shear", 2 * b + 1, 2 * a + 1, -c) + elif kind == "terminal_Y_translations": + for pair in event["pairs"]: + append("phase", 2 * pair + 1, 2 * q) + elif kind == "terminal": + for pair in range(event["pairs"]): + append("swap", 2 * pair, 2 * pair + 1) + append("phase", 2 * pair + 1, 2) + else: + raise ValueError("unknown data event: " + kind) + need(set(child_sites) == set(range(20)), "twenty residual sites") + return result, child_sites + + +def operators_at_cuts(word, sites, character): + forward = [ident()] + backward_inverse = [ident()] + for matrix, inverse in word: + forward.append(multiply(matrix, forward[-1])) + backward_inverse.append(multiply(backward_inverse[-1], inverse)) + suffix = [None] * (len(word) + 1) + suffix_inverse = [None] * (len(word) + 1) + suffix[-1] = ident() + suffix_inverse[-1] = ident() + for position in range(len(word) - 1, -1, -1): + matrix, inverse = word[position] + suffix[position] = multiply(suffix[position + 1], matrix) + suffix_inverse[position] = multiply(inverse, suffix_inverse[position + 1]) + target = scale(ident(), unit(character.bit_count())) + required = {} + for child, position in sites.items(): + prefix_inv = backward_inverse[position] + suffix_inv = suffix_inverse[position + 1] + replacement = multiply(multiply(suffix_inv, target), prefix_inv) + need(multiply(multiply(suffix[position + 1], replacement), forward[position]) == target, + "B R A equals target") + required[child] = replacement + return forward[-1], required + + +def rank_two_minor(matrix): + for a in range(N): + for b in range(a + 1, N): + for c in range(N): + for d in range(c + 1, N): + determinant = minus(times(matrix[a][c], matrix[b][d]), times(matrix[a][d], matrix[b][c])) + if determinant != Z: + return {"rows": [a, b], "columns": [c, d], "determinant": cjson(determinant)} + return None + + +def ray_minor(left, right): + entries = [(a, b) for a in range(N) for b in range(N)] + pivot = next(((a, b) for a, b in entries if left[a][b] != Z), None) + if pivot is None: + return None + a, b = pivot + for c, d in entries: + determinant = minus(times(left[a][b], right[c][d]), times(right[a][b], left[c][d])) + if determinant != Z: + return {"entries": [[a, b], [c, d]], "determinant": cjson(determinant)} + return None + + +def common_projector_test(character_matrices): + """Necessary rank/ray tests only; absence of a witness is not sufficiency.""" + nonzero = [] + for character, matrix in character_matrices: + changed = defect(matrix) + minor = rank_two_minor(changed) + if minor is not None: + return {"kind": "rank_at_least_two", "character": character, "minor": minor, + "defect": sparse_json(changed)} + if sparse_json(changed): + if nonzero: + previous_character, previous = nonzero[0] + minor = ray_minor(previous, changed) + if minor is not None: + return {"kind": "varying_projector", "characters": [previous_character, character], + "minor": minor, "defects": [sparse_json(previous), sparse_json(changed)]} + nonzero.append((character, changed)) + return None + + +def controls(): + half = Fraction(1, 2) + projector = [[Z for _ in range(N)] for _ in range(N)] + for a in (0, 1): + for b in (0, 1): + projector[a][b] = (half, 0) + need(multiply(projector, projector) == projector and rank_two_minor(projector) is None, + "fixed non-coordinate projector fixture") + def phase_on(q, phase): + return [[plus(O if a == b else Z, times(minus(phase, O), q[a][b])) + for b in range(N)] for a in range(N)] + valid = [(0, ident()), (1, phase_on(projector, I)), (2, phase_on(projector, (-1, 0))), + (3, phase_on(projector, (0, -1)))] + need(common_projector_test(valid) is None, "rejected valid non-coordinate projector") + other = [[Z for _ in range(N)] for _ in range(N)] + other[2][2] = O + varying = [(0, ident()), (1, phase_on(projector, I)), (2, phase_on(other, I))] + need(common_projector_test(varying[:2]) is None, "single-character fixture must pass") + variation = common_projector_test(varying) + need(variation is not None and variation["kind"] == "varying_projector", "varying-projector control not rejected") + rank_two = ident() + rank_two[0][0] = I + rank_two[1][1] = I + ranked = common_projector_test([(0, ident()), (16, rank_two)]) + need(ranked is not None and ranked["kind"] == "rank_at_least_two", "rank-two control not rejected") + # The insertion formula must use both inverses in the displayed order. + left, left_inv = elementary("shear", 0, 1, 1) + right, right_inv = elementary("shear", 1, 0, 1) + correct = multiply(right_inv, left_inv) + reversed_order = multiply(left_inv, right_inv) + need(multiply(multiply(right, correct), left) == ident(), "noncommuting correct-order fixture") + need(multiply(multiply(right, reversed_order), left) != ident(), "noncommuting wrong-order control") + return {"fixed_noncoordinate_projector_accepted": True, "single_character_false_positive_accepted": True, + "varying_projector_rejected": variation, "rank_two_rejected": ranked, + "noncommuting_inverse_order_control": True} + + +def source_controls(): + """Demonstrate fresh byte compilation against both accepted .pyc cache forms.""" + raw = SOURCE.read_bytes() + need(hashlib.sha256(raw).hexdigest() == SOURCE_SHA256, "source-control input bytes") + with tempfile.TemporaryDirectory(prefix="absorption-source-control-") as temporary: + path = Path(temporary) / "retained.py" + path.write_bytes(raw) + cache = Path(importlib.util.cache_from_source(str(path))) + cache.parent.mkdir(parents=True, exist_ok=True) + canary = "ABSORPTION_BYTECODE_CANARY" + payload = marshal.dumps(compile("raise ValueError('" + canary + "')", str(path), "exec")) + timestamp_header = struct.pack("