diff --git a/research/e6-adapted-pairing-projected-gram-seed0883/README.md b/research/e6-adapted-pairing-projected-gram-seed0883/README.md new file mode 100644 index 0000000000..d2c76f5543 --- /dev/null +++ b/research/e6-adapted-pairing-projected-gram-seed0883/README.md @@ -0,0 +1,71 @@ +# E6 projected-Gram decoders with an adapted pairing + +**Scoped exact obstruction; no new κ or supplier.** This package tests one explicit rank-four construction family for the open E6 low-T root-unit question. It does not rule out arbitrary rational E6 decoders or arbitrary admissible pairings. + +## Model and target + +The root-unit model from PR #1590 takes the 36 rational E6 root lines and an admissible binary pairing `B`. A four-total decoder is + +`M = sum(j=0..3) p_j q_j^T`, + +with every diagonal entry nonzero and `M[t,s]=0` whenever `B[t,s]=1` off the diagonal. If `R_j` and `A_j` are the supports of `p_j` and `q_j`, its local Theorem C charge is + +`sum(j=0..3) max(5, rank_F2(B[R_j,A_j]))`. + +Here the E6 per-total floor is `w=5`. Four totals have an ideal charge of 20. The E6 T=4 break-even thresholds are 23 at h=8, 22 at h=9, and 21 at h=10–11. This package uses 22 as its predeclared target. That charge is complete for the root-unit model; it does not include a physical mapping into the selected complex provider. + +## Construction family and changed assumption + +The exact E6 lines are generated in the E8 realization, scaled by two to integer coordinates. For ordered four-coordinate subsets `U,V` of the eight axes, let `P_U` and `P_V` be the 36-by-4 root-coordinate matrices and set + +`M = P_U P_V^T`. + +This is an exact four-term rational decoder when both factors have rank four and every diagonal entry is nonzero. For each such candidate, use the **maximal compatible symmetric pairing**: diagonal entries are one, and an off-diagonal pair receives ones in both directions exactly when the root lines are orthogonal and both decoder entries vanish. Every set pairing entry is therefore admissible and is a decoder zero. + +This changes PR #2137's fixed full-orthogonality `B0` premise. The pairing is adapted to the projected decoder's zero pattern. The finite domains are all 70 principal projections `U=V`, followed, because none meets the target, by all 4,900 ordered pairs `(U,V)`. + +## Exact result + +`verify.py` exhausts both domains using integer root coordinates, exact rational rank checks, and F2 bit-matrix elimination: + +- The 70 principal projections contain five full-rank, nonzero-diagonal candidates. Their minimum charge under the maximal compatible pairing is 84. +- Across all 4,900 ordered pairs, 13 candidates are full-rank with nonzero diagonal. Their minimum charge is 65, attained at `U=[3,4,5,6]`, `V=[3,4,5,7]`, with term block ranks `[17,17,17,14]`. +- No candidate in this projected-Gram/maximal-pairing family reaches the target 22. + +The candidate counts, best witnesses, root hash, matrix and pairing hashes, and a six-clique certificate for each of the 13 valid candidates are recorded in `RESULT.json`. + +### Rank-five Gram-pairing obstruction + +For each of the 13 valid projected decoders, define the required-zero graph on E6 lines: an edge is present if the roots are nonorthogonal, or either directed entry `M[t,s]` or `M[s,t]` is nonzero. Every admissible pairing must be zero on each such edge. + +Every one of these 13 graphs contains a certified six-clique. If a symmetric pairing had a Gram representation `B=A A^T` with five binary coordinates and unit diagonal, its six vectors on that clique would have self-dot-product one and pairwise dot-product zero. Their Gram matrix would be `I_6`, of rank six, which cannot factor through `F2^5`. Thus this decoder family has no rank-five Gram pairing. + +This does **not** exclude rank-six pairings, non-Gram pairings, or subpairings whose four restricted support blocks each have low rank. The maximal-pairing cost 65 is not a lower bound for all sparser pairings. + +## Verification + +The verifier checks the 36-line E6 construction, exact norms and orthogonality, rational factor ranks and diagonal entries, pairing legality, the charged F2 block ranks, all 70/4,900 candidates, and all clique certificates. It also includes rank controls and negative controls for an illegal pairing edge and a zero decoder diagonal. The exact root-line set was compared against the pinned predecessor generator `ade.E6b()` during author verification; the replay itself uses the standard-library integer construction. + +From the repository root: + +```sh +python3 -I -O -B research/e6-adapted-pairing-projected-gram-seed0883/verify.py +python3 scripts/research_package.py --package research/e6-adapted-pairing-projected-gram-seed0883 --check-only +python3.12 scripts/research_package.py --package research/e6-adapted-pairing-projected-gram-seed0883 +``` + +Expected verifier result begins `E6_PROJECTED_GRAM_SCREEN roots=36 principal=70 valid=5 best_cost=84 ordered=4900 valid=13 best_cost=65`, followed by `NO_COST_LE_22_IN_DECLARED_PROJECTED_GRAM_FAMILY`, `NO_RANK5_GRAM_PAIRING_FOR_DECLARED_PROJECTED_DECODERS`, and `PASS_E6_ADAPTED_PAIRING_CONTROLS_AND_RESULT`. The direct verifier was replayed locally with Python 3.14.7. The registered package wrapper requires Python 3.12, which is not installed in this environment; `--check-only` and the repository selected-record gate pass, while the generic Python 3.12 replay remains for CI. + +## Open next questions + +- Can the best projected decoder use a rank-six or higher non-Gram pairing whose four restricted blocks have total charge at most 22? The first step is a shared-pairing exact rank search for that single witness; this package does not enumerate sparse subpairings. +- Can a structured rank-four E6 decoder outside the coordinate-projection family reach cost 22? The next step is to choose a new factor family and screen its favorable full local budget before synthesis. +- What source, frame, copy, precision, restoration, hosting, and interface costs would be needed to place a root-unit decoder inside the selected provider? No provider occurrence is established here. + +## Pins and credit + +The assignment seed is `0883a0f84126624d58444b85d7c6b119`, track `complex-mechanisms`, chosen task `complex-rank-shape-decoder`, priority revision 4, and exact base `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. The selected-record SHA-256 is `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. Full source blob and SHA-256 pins are in [SOURCES.json](SOURCES.json); the public claim and its scope update are in [Discussion #1166](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18937268). + +Predecessors: DreamingOfClouds' merged [PR #1590](https://github.com/CrocSwap/integer-mult-bounds/pull/1590) defines the root-unit decoder model and charge; open [PR #2111](https://github.com/CrocSwap/integer-mult-bounds/pull/2111) records the T=3 decoder questions; open [PR #2125](https://github.com/CrocSwap/integer-mult-bounds/pull/2125) records the E6 thresholds; and open [PR #2137](https://github.com/CrocSwap/integer-mult-bounds/pull/2137) excludes only its fixed-B0 coordinate-bilinear family. This package credits that work and changes the pairing premise. + +Prepared by Cinna Davis with substantial OpenAI Codex assistance. No independent human review is claimed. No κ or selected-frontier change is claimed. diff --git a/research/e6-adapted-pairing-projected-gram-seed0883/RESULT.json b/research/e6-adapted-pairing-projected-gram-seed0883/RESULT.json new file mode 100644 index 0000000000..4300d2f3c1 --- /dev/null +++ b/research/e6-adapted-pairing-projected-gram-seed0883/RESULT.json @@ -0,0 +1,2939 @@ +{ + "per_total_floor": 5, + "pivot": { + "best": { + "charged_terms": [ + 17, + 17, + 17, + 14 + ], + "cost": 65, + "matrix_sha256": "f34ea8ce4891966aee4f6fc7aa788c43cdb21173c1c065f07b7676bd84722921", + "pairing_sha256": "b684299c3878f592e27611c5c91380de55b9d86484b6f3c90bad91e9fe9f71e7", + "raw_ranks": [ + 17, + 17, + 17, + 14 + ], + "u": [ + 3, + 4, + 5, + 6 + ], + "v": [ + 3, + 4, + 5, + 7 + ] + }, + "best_ties": 8, + "target_hits": [], + "tested": 4900, + "valid": 13, + "valid_candidates": [ + { + "charged_terms": [ + 21, + 21, + 21, + 21 + ], + "cost": 84, + "matrix_sha256": "e2e724b702f9a3a5a4055193a3c5e238999cbbbae7ea347e9da3cbd5f74fb57a", + "pairing_sha256": "1f9db49238b216e4fd61ac32a99408c2562bf4e664bdb27e450b744186b4445d", + "raw_ranks": [ + 21, + 21, + 21, + 21 + ], + "u": [ + 3, + 4, + 5, + 6 + ], + "v": [ + 3, + 4, + 5, + 6 + ] + }, + { + "charged_terms": [ + 17, + 17, + 17, + 14 + ], + "cost": 65, + "matrix_sha256": "f34ea8ce4891966aee4f6fc7aa788c43cdb21173c1c065f07b7676bd84722921", + "pairing_sha256": "b684299c3878f592e27611c5c91380de55b9d86484b6f3c90bad91e9fe9f71e7", + "raw_ranks": [ + 17, + 17, + 17, + 14 + ], + "u": [ + 3, + 4, + 5, + 6 + ], + "v": [ + 3, + 4, + 5, + 7 + ] + }, + { + "charged_terms": [ + 17, + 17, + 17, + 14 + ], + "cost": 65, + "matrix_sha256": "545e45d006e5891018bb3a4981b70002e9b86805d5d985e13f3b784fbb97bc3e", + "pairing_sha256": "b684299c3878f592e27611c5c91380de55b9d86484b6f3c90bad91e9fe9f71e7", + "raw_ranks": [ + 17, + 17, + 17, + 14 + ], + "u": [ + 3, + 4, + 5, + 7 + ], + "v": [ + 3, + 4, + 5, + 6 + ] + }, + { + "charged_terms": [ + 21, + 21, + 21, + 21 + ], + "cost": 84, + "matrix_sha256": "de766cf77023c815526f802c43d6f7407f8797bc6af1d211e7476ecea7bc9c47", + "pairing_sha256": "4d08175db6e16328cf0020ff84d1e1516c70c691953b89a5aac5220bfc482353", + "raw_ranks": [ + 21, + 21, + 21, + 21 + ], + "u": [ + 3, + 4, + 5, + 7 + ], + "v": [ + 3, + 4, + 5, + 7 + ] + }, + { + "charged_terms": [ + 17, + 17, + 14, + 17 + ], + "cost": 65, + "matrix_sha256": "221620022893ecbea5cf36ef3d8c9d63100ef80281ac922719891356793cad54", + "pairing_sha256": "50b173738613137483dd3f2e6e2c70325538ed208e9ec8c15c01767ad927fff6", + "raw_ranks": [ + 17, + 17, + 14, + 17 + ], + "u": [ + 3, + 4, + 5, + 7 + ], + "v": [ + 3, + 4, + 6, + 7 + ] + }, + { + "charged_terms": [ + 17, + 17, + 14, + 17 + ], + "cost": 65, + "matrix_sha256": "044a7d797f4ce5f866f52220c6df7c868ec803c1058072b82f502226872948fb", + "pairing_sha256": "50b173738613137483dd3f2e6e2c70325538ed208e9ec8c15c01767ad927fff6", + "raw_ranks": [ + 17, + 17, + 14, + 17 + ], + "u": [ + 3, + 4, + 6, + 7 + ], + "v": [ + 3, + 4, + 5, + 7 + ] + }, + { + "charged_terms": [ + 21, + 21, + 21, + 21 + ], + "cost": 84, + "matrix_sha256": "af847c78a8c94f3d53f8eebf26a023f364e8819928350168760f5d277a8cadcc", + "pairing_sha256": "2737969708855193adaeaa28ea87ff2937f250113bd9d05ff41b303b888302ca", + "raw_ranks": [ + 21, + 21, + 21, + 21 + ], + "u": [ + 3, + 4, + 6, + 7 + ], + "v": [ + 3, + 4, + 6, + 7 + ] + }, + { + "charged_terms": [ + 17, + 14, + 17, + 17 + ], + "cost": 65, + "matrix_sha256": "e56257d4c05fbdc63d3591b136bda4fe6497cf84d2db91d17764338098b81665", + "pairing_sha256": "9f87d6aa74ccff1ac448a91f467f62937476ebf6de50996e3aa8276882af81f9", + "raw_ranks": [ + 17, + 14, + 17, + 17 + ], + "u": [ + 3, + 4, + 6, + 7 + ], + "v": [ + 3, + 5, + 6, + 7 + ] + }, + { + "charged_terms": [ + 17, + 14, + 17, + 17 + ], + "cost": 65, + "matrix_sha256": "603a922e24a6b537abd9fded7c453b98bf4b54b825d080e94d57aac08b1096d4", + "pairing_sha256": "9f87d6aa74ccff1ac448a91f467f62937476ebf6de50996e3aa8276882af81f9", + "raw_ranks": [ + 17, + 14, + 17, + 17 + ], + "u": [ + 3, + 5, + 6, + 7 + ], + "v": [ + 3, + 4, + 6, + 7 + ] + }, + { + "charged_terms": [ + 21, + 21, + 21, + 21 + ], + "cost": 84, + "matrix_sha256": "7c2bb20f998c6a7f5886cf0042f56b7a44abe392378ff8746e387a9e3872cbb5", + "pairing_sha256": "ba991f4ea657da24a84871baa0fabb1c4b7937928e4459a8624392eefa2535c1", + "raw_ranks": [ + 21, + 21, + 21, + 21 + ], + "u": [ + 3, + 5, + 6, + 7 + ], + "v": [ + 3, + 5, + 6, + 7 + ] + }, + { + "charged_terms": [ + 14, + 17, + 17, + 17 + ], + "cost": 65, + "matrix_sha256": "c92818b19df574626417a8903e3b78a3b9fcef569335bd389d192eef21b948bd", + "pairing_sha256": "ae769630228f71cd7202e832d0e13d23b19bfd83445cf5fd66508e5378ae6182", + "raw_ranks": [ + 14, + 17, + 17, + 17 + ], + "u": [ + 3, + 5, + 6, + 7 + ], + "v": [ + 4, + 5, + 6, + 7 + ] + }, + { + "charged_terms": [ + 14, + 17, + 17, + 17 + ], + "cost": 65, + "matrix_sha256": "792631667dac1a82e313a828e7639df5d171c27709dbe530e7f16b36711b3005", + "pairing_sha256": "ae769630228f71cd7202e832d0e13d23b19bfd83445cf5fd66508e5378ae6182", + "raw_ranks": [ + 14, + 17, + 17, + 17 + ], + "u": [ + 4, + 5, + 6, + 7 + ], + "v": [ + 3, + 5, + 6, + 7 + ] + }, + { + "charged_terms": [ + 21, + 21, + 21, + 21 + ], + "cost": 84, + "matrix_sha256": "8e3f34ba207e0a7a90f361f39a7337d9094bfb17d69f53ace0658c3623b90bed", + "pairing_sha256": "325c6c330e496a5973e89482fd4c1503993e4d98df4d20584f221e22ce79174c", + "raw_ranks": [ + 21, + 21, + 21, + 21 + ], + "u": [ + 4, + 5, + 6, + 7 + ], + "v": [ + 4, + 5, + 6, + 7 + ] + } + ] + }, + "principal": { + "best": { + "charged_terms": [ + 21, + 21, + 21, + 21 + ], + "cost": 84, + "matrix_sha256": "e2e724b702f9a3a5a4055193a3c5e238999cbbbae7ea347e9da3cbd5f74fb57a", + "pairing_sha256": "1f9db49238b216e4fd61ac32a99408c2562bf4e664bdb27e450b744186b4445d", + "raw_ranks": [ + 21, + 21, + 21, + 21 + ], + "u": [ + 3, + 4, + 5, + 6 + ], + "v": [ + 3, + 4, + 5, + 6 + ] + }, + "best_ties": 5, + "target_hits": [], + "tested": 70, + "valid": 5, + "valid_candidates": [ + { + "charged_terms": [ + 21, + 21, + 21, + 21 + ], + "cost": 84, + "matrix_sha256": "e2e724b702f9a3a5a4055193a3c5e238999cbbbae7ea347e9da3cbd5f74fb57a", + "pairing_sha256": "1f9db49238b216e4fd61ac32a99408c2562bf4e664bdb27e450b744186b4445d", + "raw_ranks": [ + 21, + 21, + 21, + 21 + ], + "u": [ + 3, + 4, + 5, + 6 + ], + "v": [ + 3, + 4, + 5, + 6 + ] + }, + { + "charged_terms": [ + 21, + 21, + 21, + 21 + ], + "cost": 84, + "matrix_sha256": "de766cf77023c815526f802c43d6f7407f8797bc6af1d211e7476ecea7bc9c47", + "pairing_sha256": "4d08175db6e16328cf0020ff84d1e1516c70c691953b89a5aac5220bfc482353", + "raw_ranks": [ + 21, + 21, + 21, + 21 + ], + "u": [ + 3, + 4, + 5, + 7 + ], + "v": [ + 3, + 4, + 5, + 7 + ] + }, + { + "charged_terms": [ + 21, + 21, + 21, + 21 + ], + "cost": 84, + "matrix_sha256": "af847c78a8c94f3d53f8eebf26a023f364e8819928350168760f5d277a8cadcc", + "pairing_sha256": "2737969708855193adaeaa28ea87ff2937f250113bd9d05ff41b303b888302ca", + "raw_ranks": [ + 21, + 21, + 21, + 21 + ], + "u": [ + 3, + 4, + 6, + 7 + ], + "v": [ + 3, + 4, + 6, + 7 + ] + }, + { + "charged_terms": [ + 21, + 21, + 21, + 21 + ], + "cost": 84, + "matrix_sha256": "7c2bb20f998c6a7f5886cf0042f56b7a44abe392378ff8746e387a9e3872cbb5", + "pairing_sha256": "ba991f4ea657da24a84871baa0fabb1c4b7937928e4459a8624392eefa2535c1", + "raw_ranks": [ + 21, + 21, + 21, + 21 + ], + "u": [ + 3, + 5, + 6, + 7 + ], + "v": [ + 3, + 5, + 6, + 7 + ] + }, + { + "charged_terms": [ + 21, + 21, + 21, + 21 + ], + "cost": 84, + "matrix_sha256": "8e3f34ba207e0a7a90f361f39a7337d9094bfb17d69f53ace0658c3623b90bed", + "pairing_sha256": "325c6c330e496a5973e89482fd4c1503993e4d98df4d20584f221e22ce79174c", + "raw_ranks": [ + 21, + 21, + 21, + 21 + ], + "u": [ + 4, + 5, + 6, + 7 + ], + "v": [ + 4, + 5, + 6, + 7 + ] + } + ] + }, + "rank5_gram_clique_screen": { + "candidate_count": 13, + "receipts": [ + { + "clique": [ + 0, + 1, + 2, + 3, + 4, + 21 + ], + "pairs": [ + { + "pair": [ + 0, + 1 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 3 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 0, + 4 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 0, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 1, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 1, + 3 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 1, + 4 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 1, + 21 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 4 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 21 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + } + ], + "u": [ + 3, + 4, + 5, + 6 + ], + "v": [ + 3, + 4, + 5, + 6 + ] + }, + { + "clique": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "pairs": [ + { + "pair": [ + 0, + 1 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 0, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 0, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 1, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 1, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 1, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 1, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 5 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 4 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 4, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + } + ], + "u": [ + 3, + 4, + 5, + 6 + ], + "v": [ + 3, + 4, + 5, + 7 + ] + }, + { + "clique": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "pairs": [ + { + "pair": [ + 0, + 1 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 0, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 1, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 1, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 1, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 1, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 2, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 2, + 5 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 4 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + } + ], + "u": [ + 3, + 4, + 5, + 7 + ], + "v": [ + 3, + 4, + 5, + 6 + ] + }, + { + "clique": [ + 0, + 1, + 2, + 3, + 5, + 20 + ], + "pairs": [ + { + "pair": [ + 0, + 1 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 2 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 0, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 5 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 0, + 20 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 1, + 2 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 1, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 1, + 5 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 1, + 20 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 5 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 20 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 20 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 5, + 20 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + } + ], + "u": [ + 3, + 4, + 5, + 7 + ], + "v": [ + 3, + 4, + 5, + 7 + ] + }, + { + "clique": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "pairs": [ + { + "pair": [ + 0, + 1 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 0, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 1, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 1, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 1, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 1, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 5 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 4 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 4, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + } + ], + "u": [ + 3, + 4, + 5, + 7 + ], + "v": [ + 3, + 4, + 6, + 7 + ] + }, + { + "clique": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "pairs": [ + { + "pair": [ + 0, + 1 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 0, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 1, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 1, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 1, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 1, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 2, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 2, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + }, + { + "pair": [ + 2, + 5 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 4 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + } + ], + "u": [ + 3, + 4, + 6, + 7 + ], + "v": [ + 3, + 4, + 5, + 7 + ] + }, + { + "clique": [ + 0, + 2, + 3, + 4, + 5, + 20 + ], + "pairs": [ + { + "pair": [ + 0, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 20 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 3 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 2, + 4 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 2, + 5 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 20 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 4 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 5 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 3, + 20 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 5 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 4, + 20 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 5, + 20 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + } + ], + "u": [ + 3, + 4, + 6, + 7 + ], + "v": [ + 3, + 4, + 6, + 7 + ] + }, + { + "clique": [ + 0, + 2, + 3, + 4, + 5, + 7 + ], + "pairs": [ + { + "pair": [ + 0, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 7 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 3 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 2, + 4 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 2, + 5 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 7 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 4 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 5 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 3, + 7 + ], + "reasons": [ + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 5 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 4, + 7 + ], + "reasons": [ + "M_st_nonzero" + ] + }, + { + "pair": [ + 5, + 7 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero" + ] + } + ], + "u": [ + 3, + 4, + 6, + 7 + ], + "v": [ + 3, + 5, + 6, + 7 + ] + }, + { + "clique": [ + 0, + 2, + 3, + 4, + 5, + 7 + ], + "pairs": [ + { + "pair": [ + 0, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 3 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 5 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 7 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 3 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 2, + 4 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 2, + 5 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 7 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 4 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 3, + 5 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 3, + 7 + ], + "reasons": [ + "M_ts_nonzero" + ] + }, + { + "pair": [ + 4, + 5 + ], + "reasons": [ + "nonorthogonal" + ] + }, + { + "pair": [ + 4, + 7 + ], + "reasons": [ + "M_ts_nonzero" + ] + }, + { + "pair": [ + 5, + 7 + ], + "reasons": [ + "nonorthogonal", + "M_st_nonzero" + ] + } + ], + "u": [ + 3, + 5, + 6, + 7 + ], + "v": [ + 3, + 4, + 6, + 7 + ] + }, + { + "clique": [ + 0, + 2, + 4, + 21, + 26, + 30 + ], + "pairs": [ + { + "pair": [ + 0, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 26 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 26 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 26 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 21, + 26 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 21, + 30 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 26, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + } + ], + "u": [ + 3, + 5, + 6, + 7 + ], + "v": [ + 3, + 5, + 6, + 7 + ] + }, + { + "clique": [ + 0, + 2, + 4, + 21, + 26, + 30 + ], + "pairs": [ + { + "pair": [ + 0, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 26 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 26 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 26 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 21, + 26 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 21, + 30 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 26, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + } + ], + "u": [ + 3, + 5, + 6, + 7 + ], + "v": [ + 4, + 5, + 6, + 7 + ] + }, + { + "clique": [ + 0, + 2, + 4, + 21, + 26, + 30 + ], + "pairs": [ + { + "pair": [ + 0, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 26 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 26 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 26 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 21, + 26 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 21, + 30 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 26, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + } + ], + "u": [ + 4, + 5, + 6, + 7 + ], + "v": [ + 3, + 5, + 6, + 7 + ] + }, + { + "clique": [ + 0, + 2, + 4, + 21, + 26, + 30 + ], + "pairs": [ + { + "pair": [ + 0, + 2 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 26 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 0, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 4 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 26 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 2, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 21 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 26 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 4, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 21, + 26 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 21, + 30 + ], + "reasons": [ + "M_ts_nonzero", + "M_st_nonzero" + ] + }, + { + "pair": [ + 26, + 30 + ], + "reasons": [ + "nonorthogonal", + "M_ts_nonzero", + "M_st_nonzero" + ] + } + ], + "u": [ + 4, + 5, + 6, + 7 + ], + "v": [ + 4, + 5, + 6, + 7 + ] + } + ], + "six_clique_count": 13 + }, + "root_lines": 36, + "root_sha256": "be04f28b140a975b02129588cb06ab634513cb851897789f8106b784e824acc1", + "target_cost": 22 +} diff --git a/research/e6-adapted-pairing-projected-gram-seed0883/SOURCES.json b/research/e6-adapted-pairing-projected-gram-seed0883/SOURCES.json new file mode 100644 index 0000000000..70f7359682 --- /dev/null +++ b/research/e6-adapted-pairing-projected-gram-seed0883/SOURCES.json @@ -0,0 +1,36 @@ +{ + "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/root-unit-decoder-lemmas/README.md", + "usage": "provenance", + "git_blob": "de305484c78226a3f8da5f3277ced78974116fbb", + "sha256": "e3c856bc361a57cc2424c829001dba94e8f3a1bc8f6616f9c2f740e9665506a9" + }, + { + "path": "research/root-unit-decoder-lemmas/SOURCES.json", + "usage": "provenance", + "git_blob": "5030efbe6e6f4ad14dfa51fe9a74b508e702cab7", + "sha256": "5f1caf4c862bdc9b5b8556f3369542758c6fff9f219e7b9bee8d6b93834eb05f" + }, + { + "path": "research/root-unit-decoder-lemmas/lib/ade.py", + "usage": "provenance", + "git_blob": "7e0063d97673b7d278ac9b5b4b511df8705d5f98", + "sha256": "8185afc77fd34a599094e9f93b293a5afac61f4184ec5c5a02b81ee3c0b0053c" + } + ] +} diff --git a/research/e6-adapted-pairing-projected-gram-seed0883/TASK.json b/research/e6-adapted-pairing-projected-gram-seed0883/TASK.json new file mode 100644 index 0000000000..57775ac950 --- /dev/null +++ b/research/e6-adapted-pairing-projected-gram-seed0883/TASK.json @@ -0,0 +1,126 @@ +{ + "schema_version": 1, + "task_id": "complex-rank-shape-decoder", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "complex-rank-shape-decoder", + "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md", + "research/selected-k8-unrestricted-ends/README.md", + "research/eisenstein-reduction-copy-floor/README.md" + ], + "methods": [ + "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.", + "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration." + ], + "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound.", + "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. Ideal budget: rank-16 delivery is 2.31x (levers.py).", + "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.", + "allowed_variations": [ + "One masked, overcomplete or block decoder family with exact labels and supports.", + "A scoped lower bound on effective rank for one alphabet.", + "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": [ + "Repacking idle remainders of an unchanged word (covered by the packing ceiling).", + "Repeating the eight-term all-pairs search inside its proved scope.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Searching below C=40 in the #2017 Eisenstein binary scalar-rectangle or fixed-support block-linear additive pairing model; specify a changed premise instead. This bound does not cover every complex decoder." + ], + "overlap_terms": [ + "rank shape", + "block climb", + "masked decoder", + "overcomplete", + "effective rank" + ] + }, + "scope_status": "changed", + "actual_scope": "For the exact 36 E6 root lines in the pinned E8 realization, exhaust all 70 principal and 4,900 ordered four-coordinate projected-Gram decoders M=P_U P_V^T. Price the entrywise-maximal symmetric compatible pairing B, and certify whether any candidate reaches Theorem C cost 22. For the 13 full-rank, nonzero-diagonal candidates, also certify that no rank-five Gram pairing B=A A^T over F2^5 satisfies the forced-zero graph.", + "scope_change_reason": "The assigned complex rank-shape card normally prices the selected complex word, but the current selector suggested a broad decoder route and the live handoff offered an unclaimed E6 low-T construction question. This package tests one new concrete rank-four projected-Gram family with a decoder-adapted pairing. It does not map into the selected provider or transfer a kappa.", + "bottleneck_link": "A cost-at-most-22 E6 T=4 decoder would meet the local h=9 break-even threshold and test a larger-child decoder mechanism. The result remains a root-unit local construction question; selected-provider placement and any global exponent transfer are not established.", + "budget_minutes": 60, + "stop_rule": "Exhaust the 70 principal projections, then all 4,900 ordered four-coordinate pairs if no principal candidate reaches cost 22. Build an exact six-clique witness for every full-rank nonzero-diagonal candidate to test the rank-five Gram-pairing subfamily. Stop after these finite domains; do not expand to arbitrary rational coefficient matrices or arbitrary pairings in this cycle.", + "outcome": "negative-result", + "evidence": "verify.py exactly regenerates 36 E6 lines and exhausts 70 principal plus 4,900 ordered projections. Only 13 ordered candidates have rank-four factors and nonzero diagonal; the minimum charge under the maximal compatible pairing is 65, at U=[3,4,5,6], V=[3,4,5,7]. Every one of the 13 required-zero graphs contains a certified six-clique, excluding a rank-five Gram pairing because six norm-one mutually orthogonal vectors cannot lie in F2^5. This is not a lower bound for sparser non-Gram pairings or arbitrary E6 decoders.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance in the exact construction, search, proof certificate, verifier, and writing. No independent human review is claimed.", + "open_questions": [ + { + "question": "Can one of the 13 projected-Gram decoders use a rank-six or higher admissible pairing whose four restricted support blocks have total charged cost at most 22?", + "why_it_matters": "The exact screen excludes only the entrywise-maximal pairing and rank-five Gram pairings; a remaining low-cost sparse pairing could still meet the E6 h=9 window.", + "first_step": "For the best candidate U=[3,4,5,6], V=[3,4,5,7], encode one shared symmetric B on the allowed zero pairs and exact upper bounds on the four block ranks, beginning with rank pattern (5,5,6,6).", + "blocked_by": "A complete search over arbitrary admissible B is a coupled binary matrix-rank problem and was not run in this package." + }, + { + "question": "Can an E6 rank-four rational decoder outside the four-coordinate projected-Gram family meet the same threshold?", + "why_it_matters": "Any positive answer would supply a materially different low-T block; PR #2137 covers only the fixed-B0 coordinate-bilinear family.", + "first_step": "Choose one structured non-coordinate factor family and derive its fully charged local E6 cost before synthesis.", + "blocked_by": "This package does not search arbitrary rational coefficients or give a mapping into the selected provider." + }, + { + "question": "What physical source/target frame and copy invoice would be needed to embed such a root-unit decoder in the selected complex supplier?", + "why_it_matters": "A local root-unit improvement does not change the selected integer-multiplication bound until it is placed and fully charged.", + "first_step": "Identify one exact supplier support occurrence and list input access, copies, frames, restoration, precision, and interface transitions.", + "blocked_by": "No provider support occurrence is established here." + } + ], + "assignment_seed": "0883a0f84126624d58444b85d7c6b119", + "track": "complex-mechanisms", + "selector_scope_key": "02b31ebd160542c86299", + "selector_primary_suggestion": { + "task_id": "complex-new-helper-inventory", + "scope_key": "f3b0895a4f9f1cc62e75", + "disposition": "passed over after recent helper-anchor work and overlap; selected the rank-shape decoder suggestion in the same eligible track" + }, + "catalogue_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18937268", + "claim_expiry": "2026-10-15T02:48:00Z", + "overlap_snapshot": { + "open_prs": 464, + "discussions": 923, + "complete_pagination": true, + "prs_fetched_at": "2026-10-15T00:59:39.939175+00:00", + "discussions_fetched_at": "2026-10-15T01:01:56.278040+00:00", + "latest_discussion_check": "2026-10-15T01:02:43Z" + }, + "predecessors": [ + { + "reference": "CrocSwap/integer-mult-bounds#1590", + "head": "08e134b4a0c7f04869dae703f2a2e688e53c44f0", + "role": "root-unit model, exact decoder definition, and cost formula" + }, + { + "reference": "CrocSwap/integer-mult-bounds#2111", + "head": "98da76c2839ba38538b510420dec54546ccabf0b", + "role": "three-total E6 decoder open ends" + }, + { + "reference": "CrocSwap/integer-mult-bounds#2125", + "head": "d9eb80ac183bb4df185ca044fd65432b817333bb", + "role": "E6 root-unit threshold table and standard-Gram evidence" + }, + { + "reference": "CrocSwap/integer-mult-bounds#2137", + "head": "6a022d50e21bdcf2014a26937a34d44eed3473f0", + "role": "fixed-B0 coordinate-bilinear rank-four exclusion; distinct adaptive-pairing question" + } + ], + "claim_update_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18937330", + "overlap_findings": "Exact cached overlap search found the current claim and the prior fixed-B0 E6 coordinate-family result in PR #2137; no other E6 adapted-pairing projected-Gram scope among the complete current open-PR and Discussion snapshots. PR #2137 changes the fixed-B0 premise and is a predecessor, not a duplicate." +} diff --git a/research/e6-adapted-pairing-projected-gram-seed0883/VERIFY.json b/research/e6-adapted-pairing-projected-gram-seed0883/VERIFY.json new file mode 100644 index 0000000000..3646385a0e --- /dev/null +++ b/research/e6-adapted-pairing-projected-gram-seed0883/VERIFY.json @@ -0,0 +1,20 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact E6 root generation, rational rank-four projected-Gram identities, all 70/4,900 projections, admissible maximal pairings, exact F2 charges, six-clique certificates, stored result, and positive/negative controls. The repository-pinned predecessor files are provenance only; this verifier regenerates the finite root system independently." + } + ] +} diff --git a/research/e6-adapted-pairing-projected-gram-seed0883/verify.py b/research/e6-adapted-pairing-projected-gram-seed0883/verify.py new file mode 100644 index 0000000000..d0ad70eb75 --- /dev/null +++ b/research/e6-adapted-pairing-projected-gram-seed0883/verify.py @@ -0,0 +1,338 @@ +#!/usr/bin/env python3 +"""Exact bounded search for E6 rank-four projected-Gram decoders.""" +from __future__ import annotations + +import argparse +import json +from fractions import Fraction +from hashlib import sha256 +from itertools import combinations, product +from pathlib import Path + +TARGET = 22 +FLOOR = 5 +AXES = range(8) + + +def require(condition: bool, message: str) -> None: + if not condition: + raise ValueError(message) + + +def dot(a, b): + return sum(x * y for x, y in zip(a, b)) + + +def canonical_line(v): + first = next(x for x in v if x) + return tuple(v if first > 0 else (-x for x in v)) + + +def e6_lines(): + """Return exact E6 root lines, scaled by 2, in the pinned E8 realization.""" + roots = [] + for i, j in combinations(AXES, 2): + for a, b in product((2, -2), repeat=2): + v = [0] * 8 + v[i], v[j] = a, b + roots.append(tuple(v)) + for signs in product((-1, 1), repeat=8): + if sum(x < 0 for x in signs) % 2 == 0: + roots.append(tuple(signs)) + r1 = (2, 2, 0, 0, 0, 0, 0, 0) + r2 = (2, 0, 2, 0, 0, 0, 0, 0) + lines = sorted({canonical_line(v) for v in roots if dot(v, r1) == 0 and dot(v, r2) == 0}) + require(len(lines) == 36, f"expected 36 E6 lines, got {len(lines)}") + require(all(dot(v, v) == 8 for v in lines), "root norm control failed") + return lines + + +def rank_q(rows): + if not rows: + return 0 + a = [[Fraction(x) for x in row] for row in rows] + m, n = len(a), len(a[0]) + r = 0 + for c in range(n): + pivot = next((i for i in range(r, m) if a[i][c]), None) + if pivot is None: + continue + a[r], a[pivot] = a[pivot], a[r] + value = a[r][c] + a[r] = [x / value for x in a[r]] + for i in range(m): + if i != r and a[i][c]: + factor = a[i][c] + a[i] = [x - factor * y for x, y in zip(a[i], a[r])] + r += 1 + if r == m: + break + return r + + +def rank_f2(rows): + """Rank of integer bit rows over F2; each row is one Python int.""" + pivots = {} + for value in rows: + x = value + while x: + pivot = x.bit_length() - 1 + if pivot in pivots: + x ^= pivots[pivot] + else: + pivots[pivot] = x + break + return len(pivots) + + +def submatrix_rank(b_rows, row_support, col_support): + positions = {c: k for k, c in enumerate(col_support)} + rows = [] + for r in row_support: + bits = 0 + row = b_rows[r] + for c, k in positions.items(): + if (row >> c) & 1: + bits |= 1 << k + rows.append(bits) + return rank_f2(rows) + + +def adapted_pairing(lines, matrix): + n = len(lines) + b = [0] * n + for t in range(n): + b[t] |= 1 << t + for s in range(t + 1, n): + if dot(lines[t], lines[s]) == 0 and matrix[t][s] == 0 and matrix[s][t] == 0: + b[t] |= 1 << s + b[s] |= 1 << t + return b + + +def check_pairing(lines, matrix, b_rows): + n = len(lines) + require(len(matrix) == n and len(b_rows) == n, "matrix dimension mismatch") + for t in range(n): + require((b_rows[t] >> t) & 1, "pairing diagonal is not one") + require(matrix[t][t] != 0, "decoder diagonal is zero") + for s in range(n): + if (b_rows[t] >> s) & 1: + require(t == s or dot(lines[t], lines[s]) == 0, + f"pairing has a one on nonorthogonal lines ({t},{s})") + if t != s: + require(matrix[t][s] == 0, f"decoder violates pairing zero ({t},{s})") + + +def candidate(lines, u, v): + p = [tuple(root[k] for k in u) for root in lines] + q = [tuple(root[k] for k in v) for root in lines] + if rank_q(p) != 4 or rank_q(q) != 4: + return None + matrix = [[dot(p[t], q[s]) for s in range(36)] for t in range(36)] + if any(matrix[t][t] == 0 for t in range(36)): + return None + b_rows = adapted_pairing(lines, matrix) + check_pairing(lines, matrix, b_rows) + ranks = [] + for j in range(4): + row_support = [t for t in range(36) if p[t][j] != 0] + col_support = [s for s in range(36) if q[s][j] != 0] + ranks.append(submatrix_rank(b_rows, row_support, col_support)) + charged = [max(FLOOR, rank) for rank in ranks] + return { + "u": list(u), + "v": list(v), + "raw_ranks": ranks, + "charged_terms": charged, + "cost": sum(charged), + "pairing_sha256": sha256(b"".join(x.to_bytes(5, "little") for x in b_rows)).hexdigest(), + "matrix_sha256": sha256(repr(matrix).encode()).hexdigest(), + } + + +def orthogonality_positive_control(lines): + gram = [[dot(a, b) for b in lines] for a in lines] + require(all(gram[i][i] == 8 for i in range(36)), "Gram diagonal control failed") + for i in range(36): + for j in range(36): + if i != j and dot(lines[i], lines[j]) == 0: + require(gram[i][j] == 0, "Gram orthogonality control failed") + b0 = [] + for i in range(36): + bits = 1 << i + for j in range(36): + if i != j and dot(lines[i], lines[j]) == 0: + bits |= 1 << j + b0.append(bits) + check_pairing(lines, gram, b0) + nonorthogonal = next((i, j) for i in range(36) for j in range(i + 1, 36) + if dot(lines[i], lines[j]) != 0) + bad_pairing = b0[:] + i, j = nonorthogonal + bad_pairing[i] |= 1 << j + try: + check_pairing(lines, gram, bad_pairing) + except ValueError: + pass + else: + raise ValueError("negative control failed to reject a nonorthogonal pairing edge") + bad_gram = [row[:] for row in gram] + bad_gram[0][0] = 0 + try: + check_pairing(lines, bad_gram, b0) + except ValueError: + pass + else: + raise ValueError("negative control failed to reject a zero decoder diagonal") + return gram, b0 + + +def small_rank_controls(): + require(rank_f2([0b001, 0b010, 0b100]) == 3, "F2 identity rank control failed") + require(rank_f2([0b111, 0b111, 0b111]) == 1, "F2 all-ones rank control failed") + + +def scan(lines, pairs): + tested = 0 + valid = 0 + best = None + best_ties = 0 + target_hits = [] + valid_candidates = [] + for u, v in pairs: + tested += 1 + result = candidate(lines, u, v) + if result is None: + continue + valid += 1 + valid_candidates.append(result) + key = (result["cost"], tuple(result["u"]), tuple(result["v"])) + if best is None or key < best[0]: + best = (key, result) + best_ties = 1 + elif key[0] == best[0][0]: + best_ties += 1 + if result["cost"] <= TARGET: + target_hits.append(result) + return {"tested": tested, "valid": valid, "best": None if best is None else best[1], + "best_ties": best_ties, "target_hits": target_hits, + "valid_candidates": valid_candidates} + + +def required_zero_graph(lines, u, v): + p = [tuple(root[k] for k in u) for root in lines] + q = [tuple(root[k] for k in v) for root in lines] + matrix = [[dot(p[t], q[s]) for s in range(36)] for t in range(36)] + adj = [0] * 36 + reasons = {} + for t in range(36): + for s in range(t + 1, 36): + tags = [] + if dot(lines[t], lines[s]) != 0: + tags.append("nonorthogonal") + if matrix[t][s] != 0: + tags.append("M_ts_nonzero") + if matrix[s][t] != 0: + tags.append("M_st_nonzero") + if tags: + adj[t] |= 1 << s + adj[s] |= 1 << t + reasons[(t, s)] = tags + return adj, reasons + + +def find_clique_at_least_six(adj): + """Find a six-clique in a required-zero graph, or exhaustively return None.""" + def visit(candidates, chosen): + if len(chosen) >= 6: + return chosen[:6] + if len(chosen) + candidates.bit_count() < 6: + return None + remaining = candidates + while remaining: + bit = remaining & -remaining + remaining ^= bit + vertex = bit.bit_length() - 1 + found = visit(remaining & adj[vertex], chosen + [vertex]) + if found is not None: + return found + return None + return visit((1 << len(adj)) - 1, []) + + +def run(): + small_rank_controls() + lines = e6_lines() + orthogonality_positive_control(lines) + axes4 = list(combinations(AXES, 4)) + principal = scan(lines, ((u, u) for u in axes4)) + result = {"root_lines": len(lines), "root_sha256": sha256(repr(lines).encode()).hexdigest(), + "target_cost": TARGET, "per_total_floor": FLOOR, + "principal": principal, "pivot": None} + if not principal["target_hits"]: + ordered = ((u, v) for u in axes4 for v in axes4) + result["pivot"] = scan(lines, ordered) + if result["pivot"] is not None and not result["pivot"]["target_hits"]: + clique_receipts = [] + for item in result["pivot"]["valid_candidates"]: + u, v = tuple(item["u"]), tuple(item["v"]) + adjacency, reasons = required_zero_graph(lines, u, v) + clique = find_clique_at_least_six(adjacency) + if clique is not None: + pairs = [] + for i, t in enumerate(clique): + for s in clique[i + 1:]: + pairs.append({"pair": [t, s], "reasons": reasons[(min(t, s), max(t, s))]}) + clique_receipts.append({"u": list(u), "v": list(v), "clique": clique, "pairs": pairs}) + else: + clique_receipts.append({"u": list(u), "v": list(v), "clique": None}) + result["rank5_gram_clique_screen"] = { + "candidate_count": len(result["pivot"]["valid_candidates"]), + "six_clique_count": sum(x["clique"] is not None for x in clique_receipts), + "receipts": clique_receipts, + } + return result + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--write", action="store_true", help="write the canonical RESULT.json") + args = parser.parse_args() + result = run() + result_path = Path(__file__).with_name("RESULT.json") + encoded = json.dumps(result, indent=2, sort_keys=True) + "\n" + if args.write: + result_path.write_text(encoded, encoding="utf-8", newline="\n") + else: + require(result_path.is_file(), "missing RESULT.json; regenerate with --write") + expected = json.loads(result_path.read_text(encoding="utf-8")) + require(expected == result, "stored RESULT.json differs from exact replay") + principal = result["principal"] + print("E6_PROJECTED_GRAM_SCREEN", end=" ") + print(f"roots={result['root_lines']} principal={principal['tested']} valid={principal['valid']} " + f"best_cost={None if principal['best'] is None else principal['best']['cost']}", end=" ") + if principal["target_hits"]: + print(f"target_hits={len(principal['target_hits'])} winner={principal['target_hits'][0]}") + return + pivot = result["pivot"] + if pivot is None: + print("ERROR: expected the ordered-projection pivot") + raise SystemExit(1) + print(f"ordered={pivot['tested']} valid={pivot['valid']} " + f"best_cost={None if pivot['best'] is None else pivot['best']['cost']} " + f"best={pivot['best']}") + require(not pivot["target_hits"], "unexpected target candidate; inspect exact witness") + print("NO_COST_LE_22_IN_DECLARED_PROJECTED_GRAM_FAMILY") + c = result.get("rank5_gram_clique_screen") + if c is not None: + print(f"RANK5_GRAM_PAIRING_CLIQUES candidates={c['candidate_count']} " + f"six_cliques={c['six_clique_count']}") + if c["six_clique_count"] == c["candidate_count"]: + print("NO_RANK5_GRAM_PAIRING_FOR_DECLARED_PROJECTED_DECODERS") + print("PASS_E6_ADAPTED_PAIRING_CONTROLS_AND_RESULT") + print("RESULT_SHA256", sha256(encoded.encode()).hexdigest()) + + +if __name__ == "__main__": + main()