diff --git a/research/seven-cube-affine-seed43/CERTIFICATE.json b/research/seven-cube-affine-seed43/CERTIFICATE.json new file mode 100644 index 0000000000..da17d36863 --- /dev/null +++ b/research/seven-cube-affine-seed43/CERTIFICATE.json @@ -0,0 +1,2398 @@ +{ + "schema_version": 1, + "assignment_seed": 43, + "dimension": 7, + "ports": 128, + "affine_forms": 255, + "ordered_pairs": 65025, + "rank_orbits": [ + { + "key": [ + 0, + 0, + 0, + 0 + ], + "forms": [ + 128, + 128 + ], + "multiplicity": 1, + "rank": 64, + "diagonal": 128 + }, + { + "key": [ + 0, + 0, + 1, + 0 + ], + "forms": [ + 1, + 1 + ], + "multiplicity": 14, + "rank": 42, + "diagonal": 64 + }, + { + "key": [ + 0, + 0, + 1, + 1 + ], + "forms": [ + 1, + 129 + ], + "multiplicity": 14, + "rank": 20, + "diagonal": 0 + }, + { + "key": [ + 0, + 0, + 2, + 0 + ], + "forms": [ + 3, + 3 + ], + "multiplicity": 42, + "rank": 42, + "diagonal": 64 + }, + { + "key": [ + 0, + 0, + 2, + 1 + ], + "forms": [ + 3, + 131 + ], + "multiplicity": 42, + "rank": 20, + "diagonal": 0 + }, + { + "key": [ + 0, + 0, + 3, + 0 + ], + "forms": [ + 7, + 7 + ], + "multiplicity": 70, + "rank": 48, + "diagonal": 64 + }, + { + "key": [ + 0, + 0, + 3, + 1 + ], + "forms": [ + 7, + 135 + ], + "multiplicity": 70, + "rank": 32, + "diagonal": 0 + }, + { + "key": [ + 0, + 0, + 4, + 0 + ], + "forms": [ + 15, + 15 + ], + "multiplicity": 70, + "rank": 48, + "diagonal": 64 + }, + { + "key": [ + 0, + 0, + 4, + 1 + ], + "forms": [ + 15, + 143 + ], + "multiplicity": 70, + "rank": 32, + "diagonal": 0 + }, + { + "key": [ + 0, + 0, + 5, + 0 + ], + "forms": [ + 31, + 31 + ], + "multiplicity": 42, + "rank": 54, + "diagonal": 64 + }, + { + "key": [ + 0, + 0, + 5, + 1 + ], + "forms": [ + 31, + 159 + ], + "multiplicity": 42, + "rank": 44, + "diagonal": 0 + }, + { + "key": [ + 0, + 0, + 6, + 0 + ], + "forms": [ + 63, + 63 + ], + "multiplicity": 14, + "rank": 54, + "diagonal": 64 + }, + { + "key": [ + 0, + 0, + 6, + 1 + ], + "forms": [ + 63, + 191 + ], + "multiplicity": 14, + "rank": 44, + "diagonal": 0 + }, + { + "key": [ + 0, + 0, + 7, + 0 + ], + "forms": [ + 127, + 127 + ], + "multiplicity": 2, + "rank": 64, + "diagonal": 64 + }, + { + "key": [ + 0, + 0, + 7, + 1 + ], + "forms": [ + 127, + 255 + ], + "multiplicity": 2, + "rank": 64, + "diagonal": 0 + }, + { + "key": [ + 0, + 1, + 0, + 0 + ], + "forms": [ + 128, + 1 + ], + "multiplicity": 14, + "rank": 42, + "diagonal": 64 + }, + { + "key": [ + 0, + 1, + 1, + 0 + ], + "forms": [ + 2, + 3 + ], + "multiplicity": 168, + "rank": 36, + "diagonal": 32 + }, + { + "key": [ + 0, + 1, + 2, + 0 + ], + "forms": [ + 6, + 7 + ], + "multiplicity": 420, + "rank": 36, + "diagonal": 32 + }, + { + "key": [ + 0, + 1, + 3, + 0 + ], + "forms": [ + 14, + 15 + ], + "multiplicity": 560, + "rank": 45, + "diagonal": 32 + }, + { + "key": [ + 0, + 1, + 4, + 0 + ], + "forms": [ + 30, + 31 + ], + "multiplicity": 420, + "rank": 45, + "diagonal": 32 + }, + { + "key": [ + 0, + 1, + 5, + 0 + ], + "forms": [ + 62, + 63 + ], + "multiplicity": 168, + "rank": 54, + "diagonal": 32 + }, + { + "key": [ + 0, + 1, + 6, + 0 + ], + "forms": [ + 126, + 127 + ], + "multiplicity": 28, + "rank": 54, + "diagonal": 32 + }, + { + "key": [ + 0, + 2, + 0, + 0 + ], + "forms": [ + 128, + 3 + ], + "multiplicity": 42, + "rank": 42, + "diagonal": 64 + }, + { + "key": [ + 0, + 2, + 1, + 0 + ], + "forms": [ + 4, + 7 + ], + "multiplicity": 420, + "rank": 36, + "diagonal": 32 + }, + { + "key": [ + 0, + 2, + 2, + 0 + ], + "forms": [ + 12, + 15 + ], + "multiplicity": 840, + "rank": 36, + "diagonal": 32 + }, + { + "key": [ + 0, + 2, + 3, + 0 + ], + "forms": [ + 28, + 31 + ], + "multiplicity": 840, + "rank": 45, + "diagonal": 32 + }, + { + "key": [ + 0, + 2, + 4, + 0 + ], + "forms": [ + 60, + 63 + ], + "multiplicity": 420, + "rank": 45, + "diagonal": 32 + }, + { + "key": [ + 0, + 2, + 5, + 0 + ], + "forms": [ + 124, + 127 + ], + "multiplicity": 84, + "rank": 54, + "diagonal": 32 + }, + { + "key": [ + 0, + 3, + 0, + 0 + ], + "forms": [ + 128, + 7 + ], + "multiplicity": 70, + "rank": 48, + "diagonal": 64 + }, + { + "key": [ + 0, + 3, + 1, + 0 + ], + "forms": [ + 8, + 15 + ], + "multiplicity": 560, + "rank": 39, + "diagonal": 32 + }, + { + "key": [ + 0, + 3, + 2, + 0 + ], + "forms": [ + 24, + 31 + ], + "multiplicity": 840, + "rank": 39, + "diagonal": 32 + }, + { + "key": [ + 0, + 3, + 3, + 0 + ], + "forms": [ + 56, + 63 + ], + "multiplicity": 560, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 0, + 3, + 4, + 0 + ], + "forms": [ + 120, + 127 + ], + "multiplicity": 140, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 0, + 4, + 0, + 0 + ], + "forms": [ + 128, + 15 + ], + "multiplicity": 70, + "rank": 48, + "diagonal": 64 + }, + { + "key": [ + 0, + 4, + 1, + 0 + ], + "forms": [ + 16, + 31 + ], + "multiplicity": 420, + "rank": 39, + "diagonal": 32 + }, + { + "key": [ + 0, + 4, + 2, + 0 + ], + "forms": [ + 48, + 63 + ], + "multiplicity": 420, + "rank": 39, + "diagonal": 32 + }, + { + "key": [ + 0, + 4, + 3, + 0 + ], + "forms": [ + 112, + 127 + ], + "multiplicity": 140, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 0, + 5, + 0, + 0 + ], + "forms": [ + 128, + 31 + ], + "multiplicity": 42, + "rank": 54, + "diagonal": 64 + }, + { + "key": [ + 0, + 5, + 1, + 0 + ], + "forms": [ + 32, + 63 + ], + "multiplicity": 168, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 0, + 5, + 2, + 0 + ], + "forms": [ + 96, + 127 + ], + "multiplicity": 84, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 0, + 6, + 0, + 0 + ], + "forms": [ + 128, + 63 + ], + "multiplicity": 14, + "rank": 54, + "diagonal": 64 + }, + { + "key": [ + 0, + 6, + 1, + 0 + ], + "forms": [ + 64, + 127 + ], + "multiplicity": 28, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 0, + 7, + 0, + 0 + ], + "forms": [ + 128, + 127 + ], + "multiplicity": 2, + "rank": 64, + "diagonal": 64 + }, + { + "key": [ + 1, + 0, + 0, + 0 + ], + "forms": [ + 1, + 128 + ], + "multiplicity": 14, + "rank": 42, + "diagonal": 64 + }, + { + "key": [ + 1, + 0, + 1, + 0 + ], + "forms": [ + 3, + 2 + ], + "multiplicity": 168, + "rank": 36, + "diagonal": 32 + }, + { + "key": [ + 1, + 0, + 2, + 0 + ], + "forms": [ + 7, + 6 + ], + "multiplicity": 420, + "rank": 36, + "diagonal": 32 + }, + { + "key": [ + 1, + 0, + 3, + 0 + ], + "forms": [ + 15, + 14 + ], + "multiplicity": 560, + "rank": 45, + "diagonal": 32 + }, + { + "key": [ + 1, + 0, + 4, + 0 + ], + "forms": [ + 31, + 30 + ], + "multiplicity": 420, + "rank": 45, + "diagonal": 32 + }, + { + "key": [ + 1, + 0, + 5, + 0 + ], + "forms": [ + 63, + 62 + ], + "multiplicity": 168, + "rank": 54, + "diagonal": 32 + }, + { + "key": [ + 1, + 0, + 6, + 0 + ], + "forms": [ + 127, + 126 + ], + "multiplicity": 28, + "rank": 54, + "diagonal": 32 + }, + { + "key": [ + 1, + 1, + 0, + 0 + ], + "forms": [ + 1, + 2 + ], + "multiplicity": 168, + "rank": 36, + "diagonal": 32 + }, + { + "key": [ + 1, + 1, + 1, + 0 + ], + "forms": [ + 5, + 6 + ], + "multiplicity": 840, + "rank": 36, + "diagonal": 32 + }, + { + "key": [ + 1, + 1, + 2, + 0 + ], + "forms": [ + 13, + 14 + ], + "multiplicity": 1680, + "rank": 45, + "diagonal": 32 + }, + { + "key": [ + 1, + 1, + 3, + 0 + ], + "forms": [ + 29, + 30 + ], + "multiplicity": 1680, + "rank": 45, + "diagonal": 32 + }, + { + "key": [ + 1, + 1, + 4, + 0 + ], + "forms": [ + 61, + 62 + ], + "multiplicity": 840, + "rank": 54, + "diagonal": 32 + }, + { + "key": [ + 1, + 1, + 5, + 0 + ], + "forms": [ + 125, + 126 + ], + "multiplicity": 168, + "rank": 54, + "diagonal": 32 + }, + { + "key": [ + 1, + 2, + 0, + 0 + ], + "forms": [ + 1, + 6 + ], + "multiplicity": 420, + "rank": 30, + "diagonal": 32 + }, + { + "key": [ + 1, + 2, + 1, + 0 + ], + "forms": [ + 9, + 14 + ], + "multiplicity": 1680, + "rank": 39, + "diagonal": 32 + }, + { + "key": [ + 1, + 2, + 2, + 0 + ], + "forms": [ + 25, + 30 + ], + "multiplicity": 2520, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 1, + 2, + 3, + 0 + ], + "forms": [ + 57, + 62 + ], + "multiplicity": 1680, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 1, + 2, + 4, + 0 + ], + "forms": [ + 121, + 126 + ], + "multiplicity": 420, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 1, + 3, + 0, + 0 + ], + "forms": [ + 1, + 14 + ], + "multiplicity": 560, + "rank": 39, + "diagonal": 32 + }, + { + "key": [ + 1, + 3, + 1, + 0 + ], + "forms": [ + 17, + 30 + ], + "multiplicity": 1680, + "rank": 39, + "diagonal": 32 + }, + { + "key": [ + 1, + 3, + 2, + 0 + ], + "forms": [ + 49, + 62 + ], + "multiplicity": 1680, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 1, + 3, + 3, + 0 + ], + "forms": [ + 113, + 126 + ], + "multiplicity": 560, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 1, + 4, + 0, + 0 + ], + "forms": [ + 1, + 30 + ], + "multiplicity": 420, + "rank": 33, + "diagonal": 32 + }, + { + "key": [ + 1, + 4, + 1, + 0 + ], + "forms": [ + 33, + 62 + ], + "multiplicity": 840, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 1, + 4, + 2, + 0 + ], + "forms": [ + 97, + 126 + ], + "multiplicity": 420, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 1, + 5, + 0, + 0 + ], + "forms": [ + 1, + 62 + ], + "multiplicity": 168, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 1, + 5, + 1, + 0 + ], + "forms": [ + 65, + 126 + ], + "multiplicity": 168, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 1, + 6, + 0, + 0 + ], + "forms": [ + 1, + 126 + ], + "multiplicity": 28, + "rank": 32, + "diagonal": 32 + }, + { + "key": [ + 2, + 0, + 0, + 0 + ], + "forms": [ + 3, + 128 + ], + "multiplicity": 42, + "rank": 42, + "diagonal": 64 + }, + { + "key": [ + 2, + 0, + 1, + 0 + ], + "forms": [ + 7, + 4 + ], + "multiplicity": 420, + "rank": 36, + "diagonal": 32 + }, + { + "key": [ + 2, + 0, + 2, + 0 + ], + "forms": [ + 15, + 12 + ], + "multiplicity": 840, + "rank": 36, + "diagonal": 32 + }, + { + "key": [ + 2, + 0, + 3, + 0 + ], + "forms": [ + 31, + 28 + ], + "multiplicity": 840, + "rank": 45, + "diagonal": 32 + }, + { + "key": [ + 2, + 0, + 4, + 0 + ], + "forms": [ + 63, + 60 + ], + "multiplicity": 420, + "rank": 45, + "diagonal": 32 + }, + { + "key": [ + 2, + 0, + 5, + 0 + ], + "forms": [ + 127, + 124 + ], + "multiplicity": 84, + "rank": 54, + "diagonal": 32 + }, + { + "key": [ + 2, + 1, + 0, + 0 + ], + "forms": [ + 3, + 4 + ], + "multiplicity": 420, + "rank": 30, + "diagonal": 32 + }, + { + "key": [ + 2, + 1, + 1, + 0 + ], + "forms": [ + 11, + 12 + ], + "multiplicity": 1680, + "rank": 39, + "diagonal": 32 + }, + { + "key": [ + 2, + 1, + 2, + 0 + ], + "forms": [ + 27, + 28 + ], + "multiplicity": 2520, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 2, + 1, + 3, + 0 + ], + "forms": [ + 59, + 60 + ], + "multiplicity": 1680, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 2, + 1, + 4, + 0 + ], + "forms": [ + 123, + 124 + ], + "multiplicity": 420, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 2, + 2, + 0, + 0 + ], + "forms": [ + 3, + 12 + ], + "multiplicity": 840, + "rank": 30, + "diagonal": 32 + }, + { + "key": [ + 2, + 2, + 1, + 0 + ], + "forms": [ + 19, + 28 + ], + "multiplicity": 2520, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 2, + 2, + 2, + 0 + ], + "forms": [ + 51, + 60 + ], + "multiplicity": 2520, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 2, + 2, + 3, + 0 + ], + "forms": [ + 115, + 124 + ], + "multiplicity": 840, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 2, + 3, + 0, + 0 + ], + "forms": [ + 3, + 28 + ], + "multiplicity": 840, + "rank": 33, + "diagonal": 32 + }, + { + "key": [ + 2, + 3, + 1, + 0 + ], + "forms": [ + 35, + 60 + ], + "multiplicity": 1680, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 2, + 3, + 2, + 0 + ], + "forms": [ + 99, + 124 + ], + "multiplicity": 840, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 2, + 4, + 0, + 0 + ], + "forms": [ + 3, + 60 + ], + "multiplicity": 420, + "rank": 33, + "diagonal": 32 + }, + { + "key": [ + 2, + 4, + 1, + 0 + ], + "forms": [ + 67, + 124 + ], + "multiplicity": 420, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 2, + 5, + 0, + 0 + ], + "forms": [ + 3, + 124 + ], + "multiplicity": 84, + "rank": 32, + "diagonal": 32 + }, + { + "key": [ + 3, + 0, + 0, + 0 + ], + "forms": [ + 7, + 128 + ], + "multiplicity": 70, + "rank": 48, + "diagonal": 64 + }, + { + "key": [ + 3, + 0, + 1, + 0 + ], + "forms": [ + 15, + 8 + ], + "multiplicity": 560, + "rank": 39, + "diagonal": 32 + }, + { + "key": [ + 3, + 0, + 2, + 0 + ], + "forms": [ + 31, + 24 + ], + "multiplicity": 840, + "rank": 39, + "diagonal": 32 + }, + { + "key": [ + 3, + 0, + 3, + 0 + ], + "forms": [ + 63, + 56 + ], + "multiplicity": 560, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 3, + 0, + 4, + 0 + ], + "forms": [ + 127, + 120 + ], + "multiplicity": 140, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 3, + 1, + 0, + 0 + ], + "forms": [ + 7, + 8 + ], + "multiplicity": 560, + "rank": 39, + "diagonal": 32 + }, + { + "key": [ + 3, + 1, + 1, + 0 + ], + "forms": [ + 23, + 24 + ], + "multiplicity": 1680, + "rank": 39, + "diagonal": 32 + }, + { + "key": [ + 3, + 1, + 2, + 0 + ], + "forms": [ + 55, + 56 + ], + "multiplicity": 1680, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 3, + 1, + 3, + 0 + ], + "forms": [ + 119, + 120 + ], + "multiplicity": 560, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 3, + 2, + 0, + 0 + ], + "forms": [ + 7, + 24 + ], + "multiplicity": 840, + "rank": 33, + "diagonal": 32 + }, + { + "key": [ + 3, + 2, + 1, + 0 + ], + "forms": [ + 39, + 56 + ], + "multiplicity": 1680, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 3, + 2, + 2, + 0 + ], + "forms": [ + 103, + 120 + ], + "multiplicity": 840, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 3, + 3, + 0, + 0 + ], + "forms": [ + 7, + 56 + ], + "multiplicity": 560, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 3, + 3, + 1, + 0 + ], + "forms": [ + 71, + 120 + ], + "multiplicity": 560, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 3, + 4, + 0, + 0 + ], + "forms": [ + 7, + 120 + ], + "multiplicity": 140, + "rank": 32, + "diagonal": 32 + }, + { + "key": [ + 4, + 0, + 0, + 0 + ], + "forms": [ + 15, + 128 + ], + "multiplicity": 70, + "rank": 48, + "diagonal": 64 + }, + { + "key": [ + 4, + 0, + 1, + 0 + ], + "forms": [ + 31, + 16 + ], + "multiplicity": 420, + "rank": 39, + "diagonal": 32 + }, + { + "key": [ + 4, + 0, + 2, + 0 + ], + "forms": [ + 63, + 48 + ], + "multiplicity": 420, + "rank": 39, + "diagonal": 32 + }, + { + "key": [ + 4, + 0, + 3, + 0 + ], + "forms": [ + 127, + 112 + ], + "multiplicity": 140, + "rank": 48, + "diagonal": 32 + }, + { + "key": [ + 4, + 1, + 0, + 0 + ], + "forms": [ + 15, + 16 + ], + "multiplicity": 420, + "rank": 33, + "diagonal": 32 + }, + { + "key": [ + 4, + 1, + 1, + 0 + ], + "forms": [ + 47, + 48 + ], + "multiplicity": 840, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 4, + 1, + 2, + 0 + ], + "forms": [ + 111, + 112 + ], + "multiplicity": 420, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 4, + 2, + 0, + 0 + ], + "forms": [ + 15, + 48 + ], + "multiplicity": 420, + "rank": 33, + "diagonal": 32 + }, + { + "key": [ + 4, + 2, + 1, + 0 + ], + "forms": [ + 79, + 112 + ], + "multiplicity": 420, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 4, + 3, + 0, + 0 + ], + "forms": [ + 15, + 112 + ], + "multiplicity": 140, + "rank": 32, + "diagonal": 32 + }, + { + "key": [ + 5, + 0, + 0, + 0 + ], + "forms": [ + 31, + 128 + ], + "multiplicity": 42, + "rank": 54, + "diagonal": 64 + }, + { + "key": [ + 5, + 0, + 1, + 0 + ], + "forms": [ + 63, + 32 + ], + "multiplicity": 168, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 5, + 0, + 2, + 0 + ], + "forms": [ + 127, + 96 + ], + "multiplicity": 84, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 5, + 1, + 0, + 0 + ], + "forms": [ + 31, + 32 + ], + "multiplicity": 168, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 5, + 1, + 1, + 0 + ], + "forms": [ + 95, + 96 + ], + "multiplicity": 168, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 5, + 2, + 0, + 0 + ], + "forms": [ + 31, + 96 + ], + "multiplicity": 84, + "rank": 32, + "diagonal": 32 + }, + { + "key": [ + 6, + 0, + 0, + 0 + ], + "forms": [ + 63, + 128 + ], + "multiplicity": 14, + "rank": 54, + "diagonal": 64 + }, + { + "key": [ + 6, + 0, + 1, + 0 + ], + "forms": [ + 127, + 64 + ], + "multiplicity": 28, + "rank": 42, + "diagonal": 32 + }, + { + "key": [ + 6, + 1, + 0, + 0 + ], + "forms": [ + 63, + 64 + ], + "multiplicity": 28, + "rank": 32, + "diagonal": 32 + }, + { + "key": [ + 7, + 0, + 0, + 0 + ], + "forms": [ + 127, + 128 + ], + "multiplicity": 2, + "rank": 64, + "diagonal": 64 + } + ], + "rank_histogram": [ + [ + 20, + 56 + ], + [ + 30, + 1680 + ], + [ + 32, + 644 + ], + [ + 33, + 3360 + ], + [ + 36, + 4704 + ], + [ + 39, + 12320 + ], + [ + 42, + 21000 + ], + [ + 44, + 56 + ], + [ + 45, + 7840 + ], + [ + 48, + 11620 + ], + [ + 54, + 1736 + ], + [ + 64, + 9 + ] + ], + "maximum_diagonal_by_rank": [ + [ + 20, + 0 + ], + [ + 30, + 32 + ], + [ + 32, + 32 + ], + [ + 33, + 32 + ], + [ + 36, + 32 + ], + [ + 39, + 32 + ], + [ + 42, + 64 + ], + [ + 44, + 0 + ], + [ + 45, + 32 + ], + [ + 48, + 64 + ], + [ + 54, + 64 + ], + [ + 64, + 128 + ] + ], + "factor_census": { + "2": { + "reader_sets": 3, + "source_assignments": 3, + "nonzero_assignments": 3, + "cost_histogram": [ + [ + 128, + 3 + ] + ], + "minimum": 128, + "witness": [ + [ + 127, + 128 + ], + [ + 128, + 255 + ] + ] + }, + "3": { + "reader_sets": 7, + "source_assignments": 1792, + "nonzero_assignments": 1777, + "cost_histogram": [ + [ + 138, + 56 + ], + [ + 144, + 140 + ], + [ + 148, + 112 + ], + [ + 150, + 56 + ], + [ + 160, + 1288 + ], + [ + 172, + 112 + ], + [ + 192, + 13 + ] + ], + "minimum": 138, + "witness": [ + [ + 127, + 1 + ], + [ + 128, + 126 + ], + [ + 255, + 129 + ] + ] + }, + "4": { + "reader_sets": 2205, + "source_assignments": 564480, + "nonzero_assignments": 494802, + "cost_histogram": [ + [ + 128, + 126 + ], + [ + 148, + 476 + ], + [ + 150, + 1680 + ], + [ + 156, + 1680 + ], + [ + 158, + 112 + ], + [ + 160, + 1694 + ], + [ + 162, + 6720 + ], + [ + 165, + 13440 + ], + [ + 168, + 15232 + ], + [ + 170, + 616 + ], + [ + 171, + 6720 + ], + [ + 172, + 476 + ], + [ + 174, + 39088 + ], + [ + 175, + 6720 + ], + [ + 176, + 1820 + ], + [ + 177, + 24640 + ], + [ + 178, + 3360 + ], + [ + 180, + 86520 + ], + [ + 182, + 616 + ], + [ + 183, + 31360 + ], + [ + 184, + 12208 + ], + [ + 186, + 37296 + ], + [ + 187, + 6720 + ], + [ + 189, + 17920 + ], + [ + 190, + 23968 + ], + [ + 192, + 16100 + ], + [ + 193, + 6720 + ], + [ + 194, + 112 + ], + [ + 196, + 51408 + ], + [ + 199, + 35840 + ], + [ + 202, + 21000 + ], + [ + 204, + 224 + ], + [ + 205, + 6720 + ], + [ + 208, + 4900 + ], + [ + 212, + 140 + ], + [ + 214, + 8680 + ], + [ + 224, + 1610 + ], + [ + 236, + 140 + ] + ], + "minimum": 128, + "witness": [ + [ + 1, + 126 + ], + [ + 126, + 129 + ], + [ + 129, + 254 + ], + [ + 254, + 1 + ] + ] + } + }, + "max_diagonal_at_cost127": { + "1": 128, + "2": 192, + "3": 192, + "4": 128, + "5": 64, + "6": 0 + }, + "max_diagonal_at_cost128": { + "1": 128, + "2": 256, + "3": 192, + "4": 128, + "5": 64, + "6": 0 + }, + "witnesses": { + "two_terms": { + "terms": [ + [ + 127, + 127 + ], + [ + 255, + 255 + ] + ], + "ranks": [ + 64, + 64 + ], + "total": 128, + "peak": 64, + "entries_checked": 16384 + }, + "four_terms": { + "terms": [ + [ + 2, + 125 + ], + [ + 125, + 130 + ], + [ + 130, + 253 + ], + [ + 253, + 2 + ] + ], + "ranks": [ + 32, + 32, + 32, + 32 + ], + "total": 128, + "peak": 32, + "entries_checked": 16384 + }, + "peak30": { + "terms": [ + [ + 6, + 129 + ], + [ + 134, + 1 + ], + [ + 1, + 134 + ], + [ + 129, + 6 + ], + [ + 24, + 96 + ], + [ + 96, + 152 + ], + [ + 152, + 224 + ], + [ + 224, + 24 + ] + ], + "ranks": [ + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30 + ], + "total": 240, + "peak": 30, + "entries_checked": 16384 + } + }, + "total_floor": 128, + "peak_floor": 30, + "minimum_peak_at_total_floor": 32, + "optimistic_deficit_upper_bound": -128, + "controls": [ + "omitted_fourth_term", + "flipped_source_constant", + "empty_star_only", + "rational_sum_is_not_binary_sum", + "rank20_cannot_cover_diagonal", + "four_term_diagonal_relaxation_is_insufficient", + "three_term_naive_minimum_is_insufficient", + "copy127_would_change_budget", + "constant_form_orbit_not_duplicated", + "complementary_coordinate_rank_is20" + ] +} diff --git a/research/seven-cube-affine-seed43/OVERLAP.json b/research/seven-cube-affine-seed43/OVERLAP.json new file mode 100644 index 0000000000..aca0a9057a --- /dev/null +++ b/research/seven-cube-affine-seed43/OVERLAP.json @@ -0,0 +1,418 @@ +{ + "initial_general": { + "status": "POSSIBLE_OVERLAP_NOT_A_NOVELTY_CERTIFICATE", + "searched_at": "2026-10-14T02:35:01.737798+00:00", + "terms": [ + "masked decoder", + "five-cube", + "ten-term", + "overcomplete" + ], + "coverage": { + "open_prs": { + "fetched_at": "2026-10-14T02:34:39.095175+00:00", + "complete_pagination": true, + "records": 763 + }, + "discussions": { + "fetched_at": "2026-10-14T02:35:01.694348+00:00", + "complete_pagination": true, + "records": 205 + } + }, + "local_records": 328, + "warnings": [], + "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission.", + "matches_total": 29, + "matches": [ + { + "kind": "local-readme", + "title": "research/five-cube-coded-copy-seed42/README.md", + "path": "research/five-cube-coded-copy-seed42/README.md", + "sha256": "5d594b1a5e972f10728bff6c5427a87dfcc0b19ac3fa444a1c2536afd7e2e784", + "matched_terms": [ + "five-cube", + "overcomplete" + ], + "score": 4, + "excerpt": "# Exact affine five-cube copy floor, with four rank-eight terms\n\n**Research note / scoped negative result. No new kappa or physical supplier.**\n\nRoss Richardson's PR958 excludes coded coordinate-star combinations from\nits five-port quadratic obstruction. This package resolves that gap for\nthe smallest case, `p=k=5`, including arbitrary finite overcomplete affine\nfactorizations of the full decoder matrix.\n\nThe exact algebraic copy-rank sum is at least **32**, equal to the 32 ports.\nThe decoder ha" + }, + { + "kind": "pr", + "number": 1213, + "title": "Research: classify the P112 masked decoder coordinate component (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1213", + "head": "8867cf20fbe0d3960f68bcffca118a5ac0624f7f", + "updated_at": "2026-10-13T20:22:41Z", + "draft": false, + "state": "open", + "matched_terms": [ + "masked decoder", + "overcomplete" + ], + "score": 4, + "excerpt": "## Change and mathematical scope\n\nMasked decoders leave the odd-pair entries unconstrained, so the existing all-pairs copy-cost floor does not directly apply. This scoped research result classifies the entire complex connected component containing the standard P112 eight-term decoder: every point is a factor-basis change and reciprocal row scaling of an all-pairs decoder. Consequently every continuous path of exact eight-term masked solutions from that starting point retains copy cost at least 6" + }, + { + "kind": "pr", + "number": 1224, + "title": "Research: nine-term complex E8 decoders are one-sided overcomplete representations (seed 42, no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1224", + "head": "00e6ed0810b8ebc7f6133e2c036d0f1c9a3a4162", + "updated_at": "2026-10-13T20:26:31Z", + "draft": false, + "state": "open", + "matched_terms": [ + "ten-term", + "overcomplete" + ], + "score": 4, + "excerpt": "is nondegenerate.\n- **Corollary B (m = 9).** At most one factor leaves the live root code. An exact ten-term decoder with outside-code columns on both factors is checked, so this is specific to nine terms.\n- **Corollary C.** A one-sided nine-term decoder is the same as an overcomplete representation. Choose nine column normals b_k with one dependency z, and give each live line *any* coefficient vector with \u03a3 d_ik b_k = 2r_i.\n- **Lemma D.** Proportional column normals merge without increasing cos" + }, + { + "kind": "pr", + "number": 1177, + "title": "Research: exact arbitrary-mask three-total five-cube boundary (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1177", + "head": "e878ef36109bc6d7e21e62d03c22d8ec36f6f936", + "updated_at": "2026-10-13T19:43:35Z", + "draft": false, + "state": "open", + "matched_terms": [ + "five-cube" + ], + "score": 3, + "excerpt": "PR1046 leaves non-affine port masks outside its five-cube copy theorem. This **research note / scoped negative result** resolves the full decoder with at most three arbitrary binary outer products. Its exact total pairing-rank minimum is **32**; a three-total witness has ranks **8 + 16 + 8**, versus the exact affine three-total minimum **35**. Every cost-32 triple has peak rank 16. For canonical distinct readers, the 131,068 equality masks are precisely the nonempty proper subsets of one parity " + }, + { + "kind": "pr", + "number": 1222, + "title": "Research: quadratic five-cube copy floor and sharp rank-cap tradeoff (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1222", + "head": "c6fe323581d3803a080b000b263a07edf2b00b54", + "updated_at": "2026-10-13T20:23:53Z", + "draft": false, + "state": "open", + "matched_terms": [ + "five-cube" + ], + "score": 3, + "excerpt": "PR1046 leaves nonlinear masks outside its affine five-cube decoder theorem. This scoped structural negative result covers every common code `span_F2{1, parity, h}` with Boolean `degree(h) <= 2`, allowing any finite number of binary rank-one terms. All 16,383 augmented codes have exact minimum pairing-rank sum 32. In the 16,368 genuinely quadratic codes, imposing rank at most 15 on every term raises the total to at least 34 or makes the factorization impossible. A `13 + 13 + 8` witness attains 34" + }, + { + "kind": "pr", + "number": 1389, + "title": "Research: rank-8 masked decoders are gauge-rigid on P111 and type-(4,4) P104 units (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1389", + "head": "5480912a95c3edd0a9ef7532dcc7fc7060d12380", + "updated_at": "2026-10-13T23:58:48Z", + "draft": false, + "state": "open", + "matched_terms": [ + "masked decoder" + ], + "score": 3, + "excerpt": "## Change and mathematical scope\n\nThis is a scoped structural result: **no new \u03ba, no construction.** It adds only `research/complex-rank8-rigidity-p111-p104-44/`. The selected record, `upstream/` and all frozen pins are unchanged.\n\nPR #1212 (burntout76) proves rank-8 gauge rigidity, K = D(2G)D\u207b\u00b9, of the masked (E-graph) system on P112, P120 and the type-(2,2,2,2) P104 units. Its PROOF.md \u00a710 leaves two gaps, and this PR closes both:\n\n- **P111 (all 112 units):** Lemma 5\u2032 covers a class with three" + }, + { + "kind": "pr", + "number": 1425, + "title": "Research: rank-8 masked decoders are gauge-rigid on P112 minus an odd pair \u2014 completes P110 with #1419 (no new \u03ba)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1425", + "head": "4b707c22e3caad28172f3c80479684f4e402fd93", + "updated_at": "2026-10-14T00:41:51Z", + "draft": false, + "state": "open", + "matched_terms": [ + "masked decoder" + ], + "score": 3, + "excerpt": "## Change and mathematical scope\n\nThis is a scoped structural result: **no new \u03ba, no construction.** It adds only `research/complex-rank8-rigidity-p110-odd/`. The selected record, `upstream/` and all frozen pins are unchanged.\n\n#1419 shows that rank-8 rigidity of #1212's system (E) passes to supersets. That makes P112 minus any **orthogonal** pair rigid. It cannot reach an **odd pair**, because no frame contains one. The 2912 odd pairs of P112 form two FRAME0-stabiliser orbits, of sizes 224 and " + }, + { + "kind": "pr", + "number": 1474, + "title": "Research: rank-8 masked decoders are gauge-rigid on every P108 unit \u2014 168 orbit certificates, census-free coverage (no new \u03ba)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1474", + "head": "311dd4e1eacef2b1301c68baf0276a9c51b32422", + "updated_at": "2026-10-14T01:20:36Z", + "draft": false, + "state": "open", + "matched_terms": [ + "masked decoder" + ], + "score": 3, + "excerpt": "## Change and mathematical scope\n\nThis is a scoped structural result: **no new \u03ba, no construction.** It adds only `research/complex-rank8-rigidity-p108/`. The selected record, `upstream/` and all frozen pins are unchanged.\n\n#1419's extension lemma makes P112 minus X rigid whenever X lies inside a frame of P112. For four-line punctures that leaves **168 of the 180 FRAME0-stabiliser orbits**, 6132952 of 6210820 quadruples: 166 orbits contain an odd pair and 2 are orthogonal but lie in no P112 fram" + }, + { + "kind": "pr", + "number": 1469, + "title": "Research: rank-8 masked decoders are gauge-rigid on every P109 unit \u2014 19 new orbit certificates (no new \u03ba)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1469", + "head": "d9d101b3123b6f1d17afe80e5e70a71fb3b29e39", + "updated_at": "2026-10-14T01:20:54Z", + "draft": false, + "state": "open", + "matched_terms": [ + "masked decoder" + ], + "score": 3, + "excerpt": "## Change and mathematical scope\n\nThis is a scoped structural result: **no new \u03ba, no construction.** It adds only `research/complex-rank8-rigidity-p109/`. The selected record, `upstream/` and all frozen pins are unchanged.\n\n#1419's extension lemma makes P112 minus X rigid whenever X lies inside a frame of P112. For three-line punctures that leaves **198688 of the 227920 triples**, which fall into **19 FRAME0-stabiliser orbits**: 18 contain an odd pair, and one (1792 triples) is pairwise orthogon" + }, + { + "kind": "pr", + "number": 1399, + "title": "Research: rank-8 masked decoders are gauge-rigid on the 896 admissible P104 units (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1399", + "head": "4e1ba3a1ded94772cce5f8c0ad667a92afd6c493", + "updated_at": "2026-10-14T00:14:38Z", + "draft": false, + "state": "open", + "matched_terms": [ + "masked decoder" + ], + "score": 3, + "excerpt": "## Change and mathematical scope\n\nThis is a scoped structural result: **no new \u03ba, no construction.** It adds only `research/complex-rank8-rigidity-p104-admissible/`. The selected record, `upstream/` and all frozen pins are unchanged.\n\nPR #1212 (burntout76) proves rank-8 gauge rigidity, K = D(2G)D\u207b\u00b9, of the masked (E-graph) system on P112, P120 and the 336 type-(2,2,2,2) P104 units. Its PROOF.md \u00a710 leaves the **896 admissible P104 units** open (PR717's P104 among them). On #1212's pivot there, f" + }, + { + "kind": "pr", + "number": 1482, + "title": "Research: two-mask five-cube cost 47 versus 48 under rank cap 14", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1482", + "head": "4faed28a0e6c8a0aa5faa87b281b9373fb5d8403", + "updated_at": "2026-10-14T01:27:25Z", + "draft": false, + "state": "open", + "matched_terms": [ + "five-cube" + ], + "score": 3, + "excerpt": "With every term capped at pairing rank 14, the five-cube code `C=span_F2{1,p,x0*x1,(1+x1)*x2}` has exact minimum total cost **47**, while every common one-mask subcode of this C either cannot decode or costs at least **48**. The attaining word has ranks **7+13+13+14**. This is a **scoped structural result / research note**, not a new kappa or physical supplier.\n\nThe package also certifies the complete rank-cap table for all **720** codes generated by two signed coordinate-product masks on distin" + }, + { + "kind": "pr", + "number": 1180, + "title": "Structural proof: overcomplete factor-linear E8 decoders retain the puncture copy-cost floor", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1180", + "head": "75b408646d558147a4eb250fc407d1fbfcb8df4e", + "updated_at": "2026-10-13T19:46:21Z", + "draft": false, + "state": "open", + "matched_terms": [ + "overcomplete" + ], + "score": 3, + "excerpt": "radiction. An exact nine-term factorization\nwith outside-code columns demonstrates why unrestricted overcomplete decoders\nremain open. The inherited real-flat classification is explicitly retained.\n\nStandard-library replay checks the source-bound predecessor geometric facts,\nfour complex overcomplete examples over all root pairs and 25 punctures,\n1024 root-pair costs, 16 rational Gram certificates, a 12544-entry outside-code\nidentity, five mathematical controls and six package mutations. Reprodu" + }, + { + "number": 1330, + "title": "P112 rank-six star trims: complete frame-coverage census (seed20)", + "kind": "discussion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1330", + "updated_at": "2026-10-13T23:13:17Z", + "matched_terms": [ + "masked decoder", + "ten-term" + ], + "score": 2, + "excerpt": "d Weyl/row-dual engines. The all-rank-six integer frame-demand relaxation has sharp copy bill 60: a ten-term exact support witness satisfies every frame demand, and the inherited nine-root argument excludes fewer terms. The witness leaves 21 diagonals uncovered, proving it cannot be a masked decoder. One 120-second diagonal-cover refinement had no feasible incumbent; no infeasibility theorem follows.\n\nFull registered Python3.12.15 replay and all eight tests pass, including 524160 small-matrix jo" + }, + { + "number": 1448, + "title": "CLAIM: independent audit of PR1212 complete-class and gluing lemmas", + "kind": "discussion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1448", + "updated_at": "2026-10-14T01:54:41Z", + "matched_terms": [ + "masked decoder" + ], + "score": 1, + "excerpt": "l be identified separately. This is deliberately an independent audit, not a duplicate claim of the masked decoder theorem.\n\nExpected artifact: a scoped audit finding and, if warranted, a compact independently replayable audit package. No new kappa, supplier, selected-frontier change or all-size theorem. Substantial GPT-6 Pro assistance through ChatGPT, with Codex orchestration and local verification, will be disclosed.\n\nScope status: changed from the selector's complex-masked-decoder constructi" + }, + { + "number": 1539, + "title": "CLAIM: sixth-root phases in the signed complex connector (seed 29)", + "kind": "discussion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1539", + "updated_at": "2026-10-14T02:28:16Z", + "matched_terms": [ + "overcomplete" + ], + "score": 1, + "excerpt": " command and semantic controls. No selected-supplier or kappa claim.\n\nCandidates considered: masked overcomplete decoder; new helper inventory; phase-enriched connector. Selected the last because the first two have many nearby active claims and this odd restoration mechanism changes a precise assumption.\n\nExpected finish: 2026-10-14 03:21 UTC (2026-10-13 11:21 p.m. EDT). Claim expires then. No pinned sprint issue exists; local claim is retained as well.\n\nCredit: Ross Richardson PR944, @martinxxx" + }, + { + "kind": "local-readme", + "title": "research/p112-single-lift/README.md", + "path": "research/p112-single-lift/README.md", + "sha256": "b0aa432b38e6317661d4edfe5fa37c377cff937a527fe83a55261e7202ce2442", + "matched_terms": [ + "masked decoder" + ], + "score": 1, + "excerpt": "ting\n\nThe equality is to `2G` on every matrix entry. Arbitrary changes of the\neight reader columns, masked decoders with additional free corrections,\nmultiple added totals, other geometries, complex rather than real scalar\ncoefficients, and interacting delivery programs remain outside scope.\n\nThe interpretation as a physical copy lower bound inherits **PR446 Theorem\nC's separate-total, drop-free gathering and copy-tree assumptions**. At the\nbase commit the ledger lists PR446 as unreviewed and PR" + }, + { + "kind": "pr", + "number": 1320, + "title": "Prove a nine-root obstruction for one masked P112 co-star decoder", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1320", + "head": "ab2061c1249b027e08cf7b9426d6c913526d1e39", + "updated_at": "2026-10-13T22:36:16Z", + "draft": false, + "state": "open", + "matched_terms": [ + "masked decoder" + ], + "score": 1, + "excerpt": "\n\n## Task and overlap\n\nTask `complex-masked-decoder`; scope **refined** from constructing a changed masked decoder to an exact obstruction for this one nine-term co-star assignment. It changes the eight-term/all-pairs assumptions rather than re-running their known bound. Base: `dadfea6e8a78ff6ba901705f87532a71c6f5bbb8`; exact historical model commit/blob/SHA-256 and the original task card are retained in `SOURCES.json` and `TASK.json`.\n\nNearest adjacent work: [#1292](https://github.com/CrocSwap/" + }, + { + "kind": "pr", + "number": 1375, + "title": "Research: COPY floor 64 for two-coordinate P112 mixing with small free rectangles (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1375", + "head": "4a533aff2a7a87c9b36e077a31774b332a7f64bd", + "updated_at": "2026-10-13T23:46:30Z", + "draft": false, + "state": "open", + "matched_terms": [ + "overcomplete" + ], + "score": 1, + "excerpt": " exact erasure calculation then extended it to the two support domains above. It changes the masked/overcomplete assumptions rather than repeating the eight-term all-pairs theorem.\n- **Method and domain:** a complete five-stratum classification for every coordinate pair, an exact F2 census of minimum-support functionals and pairings, and a quantified coefficient-rank proof for every complex invertible factor change. No random search and no floating-point acceptance.\n- **Optimistic budget:** six " + }, + { + "kind": "pr", + "number": 1347, + "title": "Research: P112 rank-six star trims have sharp frame-demand bill 60", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1347", + "head": "64fd5f9e91961dedc16118fcc7ad71ee82efe28f", + "updated_at": "2026-10-13T23:11:57Z", + "draft": false, + "state": "open", + "matched_terms": [ + "masked decoder" + ], + "score": 1, + "excerpt": "## Result and scope\n\n**Research note / scoped structural proof. No masked decoder, physical supplier, or new kappa.**\n\nFor every arbitrary rank-six support restriction of an original cost-seven P112 C/N root-star atom, at most **1,120 of the 1,260 live orthogonal frames** can be met on both factors. A rank-factorization lemma reduces all joint cuts to maximal one-axis codeword cuts. The complete census covers **7,616 tagged parents and 967,232 maximal slices**; two separately implemented engines" + }, + { + "kind": "pr", + "number": 1236, + "title": "Research: close the masked root-star assembly gap with sharp cost 64 (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1236", + "head": "ee8437bd9879272094e20c024cd34a53c4e84cd8", + "updated_at": "2026-10-13T20:46:58Z", + "draft": false, + "state": "open", + "matched_terms": [ + "overcomplete" + ], + "score": 1, + "excerpt": "13's eight-term masked rigidity, #1191's one-sided root-linear theorem, and #1180/#1224's all-pairs overcomplete work are complementary and are not proof dependencies.\n\nPrepared for David Arias with substantial OpenAI Codex assistance in research, proof, both implementations, testing, review and writing. Separate AI review is not independent human review. Apache-2.0.\n" + } + ] + }, + "chosen_scope": { + "status": "POSSIBLE_OVERLAP_NOT_A_NOVELTY_CERTIFICATE", + "searched_at": "2026-10-14T02:37:33.529768+00:00", + "terms": [ + "seven-port", + "seven-cube", + "cubic Gram", + "k=7", + "128 ports" + ], + "coverage": { + "open_prs": { + "fetched_at": "2026-10-14T02:34:39.095175+00:00", + "complete_pagination": true, + "records": 763 + }, + "discussions": { + "fetched_at": "2026-10-14T02:35:01.694348+00:00", + "complete_pagination": true, + "records": 205 + } + }, + "local_records": 328, + "warnings": [], + "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission.", + "matches_total": 1, + "matches": [ + { + "kind": "pr", + "number": 1371, + "title": "Independent verification: PR589 family map by exact projector algebra", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1371", + "head": "d47c4c300a53bb206becd13db89cea8c287c929b", + "updated_at": "2026-10-13T23:37:14Z", + "draft": false, + "state": "open", + "matched_terms": [ + "k=7" + ], + "score": 1, + "excerpt": "ra-seed10/verify.py\n```\n\nExpected: `PASS_BIT_FAMILY_PROJECTOR_ALGEBRA children=0,7 factors=2+4 q_rank=7 controls=3 no_new_kappa`.\n\nLocal checks: the verifier, three-control package check, and `scripts/research_package.py --check-only` pass on CPython 3.14.7. Python 3.12 is not installed locally, so the registered Python 3.12 replay wrapper was not run here.\n\n## Pins and credit\n\n- Base: `bce54fb3f895cbe5cd4c0eb477c3afeed100190f`.\n- Selected kappa: `836330098538459/500000000000000000`; selected PR" + } + ] + }, + "scope_assessment": "Nearest results PR1046/1177/1222/1482 concern the five-cube. The only seven-scope search hit, PR1371, uses rank7 in an unrelated PR589 projector audit. Full source diffs and every nested artifact were not searched; this is not a novelty certificate. No pinned sprint issue exists; the donor local-claim fallback applies.", + "final_refresh": { + "status": "POSSIBLE_OVERLAP_NOT_A_NOVELTY_CERTIFICATE", + "searched_at": "2026-10-14T02:57:44.323072+00:00", + "terms": [ + "seven-cube", + "seven-port", + "cubic Gram", + "affine seven" + ], + "coverage": { + "open_prs": { + "fetched_at": "2026-10-14T02:57:14.772459+00:00", + "complete_pagination": true, + "records": 713 + }, + "discussions": { + "fetched_at": "2026-10-14T02:57:44.279769+00:00", + "complete_pagination": true, + "records": 218 + } + }, + "local_records": 330, + "warnings": [], + "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission.", + "matches_total": 2, + "matches": [ + { + "kind": "local-readme", + "title": "research/seven-cube-affine-seed43/README.md", + "path": "research/seven-cube-affine-seed43/README.md", + "sha256": "a50021a5cbfda08c15babe83fe0738b19c59eab95656424a6e142039b197d842", + "matched_terms": [ + "seven-cube", + "seven-port", + "affine seven" + ], + "score": 5, + "excerpt": "# Affine seven-cube decoding: copy floor 128, peak floor 30\n\n**Scoped structural negative result. No new kappa or physical supplier.**\n\nThe smallest seven-port cube admits a cubic, drop-free correction geometry.\nEven after arbitrary affine recoding and any finite number of delivered\nterms, its algebraic copy-rank sum is at least **128**, equal to its port\ncount. Two terms attain `64+64`; four attain `32+32+32+32`.\n\nUnlike the affine five-cube result, the sum and peak optima cannot be attained\nto" + }, + { + "kind": "local-task", + "title": "research/seven-cube-affine-seed43/TASK.json", + "path": "research/seven-cube-affine-seed43/TASK.json", + "sha256": "aa1b0121ad2ee1204d1576708a44457c3f75ec0f5c36a3923a1abdf9b1e22978", + "matched_terms": [ + "seven-cube", + "seven-port", + "cubic gram" + ], + "score": 5, + "excerpt": "ercomplete\",\n \"eight-term\"\n ]\n },\n \"scope_status\": \"changed\",\n \"actual_scope\": \"Smallest seven-port cube x in F2^7; cubic Gram sum of Walsh characters of degree <=3; full parity decoder; arbitrary finite affine binary factorization\",\n \"scope_change_reason\": \"The donor explicitly assigned structural decoder research with seed43. This is a seven-port binary/cubic geometry result, not the catalogue card's E8 complex decoder; it changes the five-cube geometry rather than reopening a clos" + } + ] + }, + "upstream_head_observed": "680967accfd4311f3241dc154e1f434869747b43", + "final_assessment": "Complete scan found only this new local package for seven-cube/seven-port/cubic-Gram/affine-seven terms. This does not guarantee novelty; closed PRs are represented only by the local ledger/notes and code diffs are not searched." +} diff --git a/research/seven-cube-affine-seed43/README.md b/research/seven-cube-affine-seed43/README.md new file mode 100644 index 0000000000..0cca53a25f --- /dev/null +++ b/research/seven-cube-affine-seed43/README.md @@ -0,0 +1,244 @@ +# Affine seven-cube decoding: copy floor 128, peak floor 30 + +**Scoped structural negative result. No new kappa or physical supplier.** + +The smallest seven-port cube admits a cubic, drop-free correction geometry. +Even after arbitrary affine recoding and any finite number of delivered +terms, its algebraic copy-rank sum is at least **128**, equal to its port +count. Two terms attain `64+64`; four attain `32+32+32+32`. + +Unlike the affine five-cube result, the sum and peak optima cannot be attained +together. The smallest possible peak term rank is **30**, attained here by +eight terms of total cost 240. Among total-cost-128 decoders, the smallest +peak is **32**. We do **not** claim that 240 is the minimum total under cap 30. + +Under the explicitly inherited additive stage ledger, the favorable complete +budget is `D <= (s-1)*128 - s*C <= -128` for every `s>=3`. This grants all +gathers, source access, helpers, arithmetic, frame changes, restoration, +recursive overhead and other nonnegative expenses zero cost. The resulting +negative deficit already excludes positive saving in that model. No circuit +implementation or further supplier optimization is warranted by this result. + +## Object and exact scope + +Identify the 128 ports selecting one coordinate from each of seven pairs +with `x in F2^7`. Write `j=7-|x XOR y|` for intersection size and use + +``` +G[x,y] = (4/3)(j-1)(j-3)(j-5) + = sum_{S subset {0,...,6}, |S|<=3} (-1)^(sum_{i in S}(x_i+y_i)). +``` + +Thus G is an integral positive semidefinite Gram matrix of rank 64, +realized by the 64 Walsh features of degree at most three. Distinct ports +with odd intersection 1, 3 or 5 are orthogonal. Coordinate-star decoding +has matrix + +``` +B[x,y] = j mod2 = 1+p(x)+p(y), p(x)=x0+...+x6 in F2. +``` + +Adding the intersection-1/3/5 corrections gives the identity. This is +PR231's star-family identity specialized to seven ports. The common +coordinate-star code is exactly the eight-dimensional affine code +`C={a dot x+c}`. The constant is available as the XOR of two complementary +coordinate stars; no free empty-star observation is assumed. + +Allow every finite binary factorization `B=sum_i f_i g_i^T`, with nonzero +`f_i,g_i in C`, including nonsymmetric and redundant factorizations. +Equality is required on **all** 16,384 port pairs, not only on a correction +mask. Its objective is + +``` +C_total = sum_i rank_Q G[support(f_i), support(g_i)]. +``` + +This is an algebraic lower bound under the inherited per-total copy rule, +not an invoice that realizes either witness. Changed Gram matrices, +non-affine masks, masked identities, extra ports (`p>7`), interactive +delivery and information retained between stages are outside the result. + +## Exhaustive finite evidence + +An affine form is encoded by an integer 1 through 255: bits 0 through 6 +are linear coefficients and bit 7 is the constant. Simultaneous cube +translation and coordinate permutation preserve G. For linear parts a,b, +the orbit key counts coordinates of types `(1,0),(0,1),(1,1)`; when a=b is +nonzero it also records the XOR of the constants. Independent a,b allow +both constants to be normalized by a translation. A zero linear part is +necessarily the nonzero constant form. These observations cover all cases. + +There are **127 ordered orbits**, covering all **65,025 ordered pairs**. +The separate checker verifies multiplicities both combinatorially and by +enumerating the 255 forms. Both compute exact rational ranks, with no +floating-point or finite-field acceptance decision. + +| Rank | Ordered pairs | Maximum diagonal coverage | +|---:|---:|---:| +| 20 | 56 | 0 | +| 30 | 1,680 | 32 | +| 32 | 644 | 32 | +| 33 | 3,360 | 32 | +| 36 | 4,704 | 32 | +| 39 | 12,320 | 32 | +| 42 | 21,000 | 64 | +| 44 | 56 | 0 | +| 45 | 7,840 | 32 | +| 48 | 11,620 | 64 | +| 54 | 1,736 | 64 | +| 64 | 9 | 128 | + +The certificate also contains the full reduced factorization census: + +| Terms | Reader sets/multisets | Source assignments, including zeros | All factors nonzero | Minimum | +|---:|---:|---:|---:|---:| +| 2 | 3 | 3 | 3 | 128 | +| 3 | 7 | 1,792 | 1,777 | 138 | +| 4, distinct readers in a rank-three space | 2,205 | 564,480 | 494,802 | 128 | + +Full cost histograms and attaining words are in [CERTIFICATE.json](CERTIFICATE.json). +The enumeration stops at the end of these exact domains; there is no +heuristic search, numerical tolerance, timeout exclusion or novelty claim +based on a different random seed. + +## Why this proves the unrestricted finite-term floor + +The binary rank of B is two; its row and column code is +`U=span{1,p}`. If A and D list the n reader and source columns, respectively, +`B=A D^T` and Sylvester's inequality gives `rank(A)+rank(D)<=n+2`. +Each span contains U. Transposition preserves every pairing cost. + +For two terms, both spans equal U: the three unordered bases are exhausted. +For three terms, one span equals U: after transposition its nonzero columns +are a multiset from the three nonzero members of U. Exactly seven such +multisets span U. The census includes repetitions and gives the exact +three-term minimum 138. + +For four terms, one factor span has dimension at most three. Repeated +reader columns can be merged by XORing their source columns. This cannot +increase cost: the XOR support lies in the union of the two old supports, +and concatenation rank is subadditive. Zero factors can then be discarded. +The resulting two-/three-term decoder already costs at least 128. If four +distinct reader columns remain, their span has dimension three and contains +U. There are `(256-4)/4=63` such spaces, each with seven nonzero vectors and +35 four-element subsets. Each subset spans its space, and each of the +eight source coefficient columns has a one-dimensional solution freedom. +That is exactly `63*35*256=564480` assignments. The minimum is 128. + +The diagonal of B is one everywhere, so the sum of the intersection sizes +`|support(f_i) intersect support(g_i)|` must be at least 128. Using the +table, the largest possible coverage for five terms of cost at most 127 is +64; for six it is zero. These are deliberately optimistic type-multiset +relaxations, checked by dynamic programming and independent enumeration. +Seven or more terms cost at least `7*20=140`. Zero or one term cannot have binary +rank two. All finite term counts are therefore covered. + +The three-/four-term enumeration is necessary here: unlike the five-cube +argument, the seven-cube diagonal relaxation alone permits four rank-30 +terms, and the one-U-factor estimate permits three rank-42 terms. Neither +relaxed tuple solves the full decoder identity. They are explicit controls +against claiming the floor from counting alone. + +## Sharp witnesses and the peak separation + +The two parity totals give `B=p p^T+(1+p)(1+p)^T`, each of rank 64. +For the four-term witness take `h=x1` (seed43 mod7) and `q=p+h`: + +``` +B = h q^T + q(1+h)^T + (1+h)(1+q)^T + (1+q)h^T. +``` + +Each term has rank 32. To attain peak 30, let +`a=x0`, `b=x1+x2`, `c=x3+x4`, `d=x5+x6`. The eight pairs of forms are + +``` +(b,1+a), (1+b,a), (a,1+b), (1+a,b), +(c,d), (d,1+c), (1+c,1+d), (1+d,c). +``` + +Their binary sum is B and each has rank 30. Every term of smaller rank +has rank 20 and zero diagonal, so peak 30 is sharp. + +For total cost 128, the same diagonal relaxation at budget **128** excludes +five and six terms; seven already cost 140. Two terms have peak 64, three +terms cost at least 138, and four terms of peak at most 30 would have total +at most 120, contradicting the proved sum floor. The rank table has no +rank 31, and the four-term witness attains peak 32. Thus the two optima +cannot be attained together. The exact total optimum under peak cap 30 +is not established; its diagonal/term-count relaxation gives a lower +bound 140 and the displayed word gives an upper bound 240. + +## Reproduce and verification scope + +From the repository root, Python 3.12 and the standard library: + +```sh +python3.12 -I -B scripts/research_package.py --package research/seven-cube-affine-seed43 +``` + +This runs both implementations. Expected markers: + +``` +PASS_SEVEN_CUBE_AFFINE pairs=65025 orbits=127 assignments=566275 copy_floor=128 peak_floor=30 controls=10 no_new_kappa +PASS_SEVEN_CUBE_INDEPENDENT pairs=65025 orbits=127 assignments=566275 literal_entries=49152 controls=10 no_new_kappa +``` + +`verify.py` uses the intersection polynomial, gcd-normalized integer +elimination and subset-syndrome solutions. `independent.py` imports no +generator or predecessor code: it builds Walsh features, uses Fraction +elimination and solves coefficient equations by binary RREF. It checks +the 64 coefficient equations for every enumerated source assignment. +Both compare every certificate field, check the three witnesses literally +on 49,152 port pairs, and run ten semantic or proof-boundary controls. +Both work under `-I -O -B`. Certificate generation is explicit and refuses +to overwrite an existing path. The optional command +`python3.12 -I -B research/seven-cube-affine-seed43/test_package.py` checks +both programs in a read-only relocated checkout and rejects five artifact/source +corruptions with both implementations. [VALIDATION.json](VALIDATION.json) records +the local environment and executed checks; hosted CI is separate. + +This is exact finite evidence supporting the written scoped argument, +not proof-assistant verification, independent human review, or a proof +of the multiplication theorem. The selected cold replay, native supplier, +hosting, precision/tape, all-size/compiler, common-label/mutable-source, +bit H1-H5 and analytic transfer obligations are not discharged here. + +## Provenance, overlap and credit + +Assignment seed **43**, drawn with OS randomness, selected the structural +decoder track. Exact base: `64039f1bd3b6a523b96083fd858ad040a75e3030`. +The selected conditional result at this base is PR1094, +`kappa=836330098538459/500000000000000000`, with complex binding and bit +supplier PR589. Its source manifest, actual T16 construction and maintainer +review were followed. This package changes none of them or `upstream/`. + +[TASK.json](TASK.json) records the three candidate scopes and local claim; +[SOURCES.json](SOURCES.json) pins the base, Git blobs and SHA256 digests; +[OVERLAP.json](OVERLAP.json) records the bounded live scan and its limits. +No pinned sprint issue existed, so the donor's local-claim fallback was used. +The catalogue card is marked changed: this is a seven-port binary/cubic +side result, not an E8 complex masked-decoder construction. + +Credit **Joel Pulikkan / GamingPuzzled (PR231)** for the star-family parity +identity; **Ross Richardson (PR958)** for the five-port geometry and +optimistic-budget approach; **martinxxx9 (PR1046)** for the affine five-cube +copy floor and factor-span reduction; and **icekylinx/eumemic**, with the +retained **DreamingOfClouds, Jacob Sussman and Zhihao Chen** copy/frame +lineage. PR1046 is incorporated; this does not reopen its five-cube search. +Pending PR1177, PR1222 and PR1482 treat nonlinear masks on that five-cube, +not this seven-cube. They are overlap context, not theorem dependencies. + +Prepared by **Hanson Sun (@bbMisk)** with substantial **OpenAI Codex +assistance** in mathematics, both implementations, verification and prose. +Apache-2.0. The separate implementation is by the same AI-assisted author. + +## Open next questions + +Can a fully priced two-stage construction retain one of the four displayed +coded totals and thereby change the additive `s*C` charge? That premise +must change before this geometry could help the supplier. A feasible first +step is an exact arbitrary-dirty two-stage map using the explicit four-term +decoder, charging source access, all frame transitions and restoration. +The blocker is the absence of such a legal physical interface; a rank-table +optimization alone cannot remove the present negative deficit. This is an +unclaimed next question, not evidence that retention is possible. diff --git a/research/seven-cube-affine-seed43/SOURCES.json b/research/seven-cube-affine-seed43/SOURCES.json new file mode 100644 index 0000000000..871ac09f90 --- /dev/null +++ b/research/seven-cube-affine-seed43/SOURCES.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "base_commit": "64039f1bd3b6a523b96083fd858ad040a75e3030", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "c05fafaa25ba95b2d5af86b1800427198e3d20eb", + "sha256": "89b5928bc92c81e2647b6d702a7ad85a6795b8f44e2eb267b2ff3145d8f2b2ce" + }, + { + "path": "research/five-cube-coded-copy-seed42/PROOF.md", + "usage": "input", + "git_blob": "2f804f0d881477cb2274796d4e3027dbe7d827e4", + "sha256": "f6ed4a359a5e4cc4b27d9ffb096ef34beab45dc2eddf976f2984dc544853408c" + }, + { + "path": "research/five-port-quadratic-decoder/PROOF.md", + "usage": "input", + "git_blob": "57d6abf19382012797a47d9769163e77397fed83", + "sha256": "df4437193b9e8f478673c5050735d5c67964c103e5e7c29ee124ae0f38b9b442" + }, + { + "path": "research/hypercube-decoder-parity/README.md", + "usage": "input", + "git_blob": "3a13dfd89b801a0a72db7ef50be7d324addc7949", + "sha256": "2dc89289d1d979aec6709b8c55a2af7cd39d97297bc20fb94adc7d4cdf867cd1" + } + ] +} diff --git a/research/seven-cube-affine-seed43/TASK.json b/research/seven-cube-affine-seed43/TASK.json new file mode 100644 index 0000000000..cd6b214fc0 --- /dev/null +++ b/research/seven-cube-affine-seed43/TASK.json @@ -0,0 +1,82 @@ +{ + "schema_version": 1, + "task_id": "complex-masked-decoder", + "priority_revision": 2, + "base_commit": "64039f1bd3b6a523b96083fd858ad040a75e3030", + "original_card": { + "id": "complex-masked-decoder", + "question": "Can one specified masked or overcomplete decoder improve the complete moment budget?", + "starting_points": [ + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md" + ], + "methods": [ + "Synthesize a decoder with exact coefficients and fully priced helper endpoints.", + "Bound the best possible budget for a fixed support alphabet before synthesis." + ], + "acceptance_gate": "Change an assumption of the eight-term all-pairs bound and count all copied information, frames and restoration.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-decoder-field-extension-seed44/verify.py" + ], + "expected": "PASS_COMPLEX_DECODER_FIELD_EXTENSION_S44", + "inspect": "Locate the excluded classes: masked identities, at least nine terms, and deeper punctures.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Choose one finite support alphabet and test exact decoding constraints before building a whole network.", + "bottleneck_link": "A cheaper fully realized decoder could increase deficit or lower recursive cost on the binding complex side.", + "allowed_variations": [ + "Select a specific masked or overcomplete family with exact labels and supports." + ], + "scope_change_triggers": [ + "Repeating the exact eight-term all-pairs search inside its proved scope." + ], + "overlap_terms": [ + "masked decoder", + "overcomplete", + "eight-term" + ] + }, + "scope_status": "changed", + "actual_scope": "Smallest seven-port cube x in F2^7; cubic Gram sum of Walsh characters of degree <=3; full parity decoder; arbitrary finite affine binary factorization", + "scope_change_reason": "The donor explicitly assigned structural decoder research with seed43. This is a seven-port binary/cubic geometry result, not the catalogue card's E8 complex decoder; it changes the five-cube geometry rather than reopening a closed domain.", + "bottleneck_link": "Scoped negative side result: affine recoding cannot make the cubic seven-cube positive under the inherited additive stage ledger. The selected complex supplier remains binding; no supplier or kappa change.", + "budget_minutes": 45, + "stop_rule": "Exhaust all 127 affine-pair orbits and the 566275 reduced source assignments; use the written rank/diagonal argument for all finite term counts. Stop construction effort if copied-rank sum is at least 128. Reserve final 12 of 45 minutes for verification and handoff.", + "outcome": "negative-result", + "evidence": "CERTIFICATE.json and README.md: sum floor 128; peak floor 30; minimum peak 32 at total 128; optimistic D <= -128.", + "author": "Hanson Sun (@bbMisk)", + "ai_assistance": "Substantial OpenAI Codex assistance in research, written argument, both separately implemented checkers, tests and prose. No independent human review.", + "open_questions": [ + { + "question": "Can one of the four coded totals be retained legally across two consecutive stages?", + "why_it_matters": "The additive s*C charge must change before this geometry can help.", + "first_step": "Write an exact arbitrary-dirty two-stage map for the displayed four-term decoder and charge source access, every frame transition and restoration.", + "blocked_by": "No physical retention interface or paid implementation is supplied." + } + ], + "assignment": { + "track": "structural decoder research", + "assignment_seed": 43, + "base_commit": "64039f1bd3b6a523b96083fd858ad040a75e3030", + "object": "Smallest seven-port cube x in F2^7; cubic Gram sum of Walsh characters of degree <=3; full parity decoder; arbitrary finite affine binary factorization", + "changed_hypothesis": "Seven-port cubic geometry instead of the closed five-port quadratic case; not a larger search in the same domain", + "candidates": [ + "P112 nine-term outside-code decoder (overlaps PR1224 and1320)", + "Seven-cube affine copied-rank floor (chosen by seed43 mod3 =1)", + "Dirty centre hosting (claimed in Discussion1516)" + ], + "method": "Coordinate-permutation and translation orbits of all255 nonzero affine forms; exact rational restricted-Gram ranks; rank/diagonal lower bounds and explicit attaining words", + "optimistic_budget": "v=128; D <= (s-1)*128 - s*C for s>=3, granting every other required cost zero; stop constructive work if C>=128", + "stopping_rule": "Complete finite rank orbit census, plus a written quantified factorization bound if justified; no parameter optimizer", + "expected_artifact": "Scoped theorem or bounded negative evidence, standalone exact replay, source pins, controls and one focused PR if warranted", + "expected_finish_utc": "2026-10-14T03:16:54Z", + "verification_start_utc": "2026-10-14T03:04:54Z", + "coordination": "No pinned issue; donor local-claim fallback. Live complete snapshot at02:35UTC covers763 open PRs and205 discussion records.", + "author": "Hanson Sun (@bbMisk)", + "assistance": "Substantial OpenAI Codex assistance", + "status": "completed locally; single PR submission pending" + } +} diff --git a/research/seven-cube-affine-seed43/VALIDATION.json b/research/seven-cube-affine-seed43/VALIDATION.json new file mode 100644 index 0000000000..590d3a27cd --- /dev/null +++ b/research/seven-cube-affine-seed43/VALIDATION.json @@ -0,0 +1,49 @@ +{ + "checked_utc": "2026-10-14T02:58:57.396467+00:00", + "base_commit": "64039f1bd3b6a523b96083fd858ad040a75e3030", + "environment": { + "platform": "macOS-27.0.1-arm64-arm-64bit-Mach-O", + "primary_python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "registered_python": "3.12.13" + }, + "checks": [ + { + "command": "python3.12 -I -B scripts/research_package.py --package research/seven-cube-affine-seed43", + "result": "PASS_REGISTERED_RESEARCH_PACKAGE; both complete implementations pass" + }, + { + "command": "python3.12 -I -B research/seven-cube-affine-seed43/test_package.py", + "result": "PASS; two optimized read-only relocated executions and ten intended corruption rejections" + }, + { + "command": "python3.12 -B scripts/verify_selected_result.py", + "result": "PASS; selected record, exact kappa, source inventory and proof supplement" + }, + { + "command": "python3.12 -I -B scripts/research_package.py --package research/seven-cube-affine-seed43 --check-only", + "result": "PASS_PACKAGE_METADATA_AND_PINS after final metadata updates" + } + ], + "mathematical_coverage": { + "ordered_affine_pairs": 65025, + "exact_rational_rank_orbits": 127, + "reduced_source_assignments": 566275, + "independent_coefficient_equations_per_assignment": 64, + "literal_witness_entries_per_implementation": 49152 + }, + "not_run": [ + "selected supplier cold replay", + "native/physical supplier admission", + "hosting/precision/tape or analytic adoption", + "proof-assistant verification", + "independent human review", + "hosted CI status not yet known" + ], + "upstream_refresh": { + "head": "680967accfd4311f3241dc154e1f434869747b43", + "changed_paths_since_base": 464, + "relevant_seven_cube_paths": 0, + "all_three_live_input_blobs_unchanged": true, + "selected_kappa_unchanged": true + } +} diff --git a/research/seven-cube-affine-seed43/VERIFY.json b/research/seven-cube-affine-seed43/VERIFY.json new file mode 100644 index 0000000000..50b311aff8 --- /dev/null +++ b/research/seven-cube-affine-seed43/VERIFY.json @@ -0,0 +1,33 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/five-cube-coded-copy-seed42/PROOF.md", + "research/five-port-quadratic-decoder/PROOF.md", + "research/hypercube-decoder-parity/README.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact integer ranks, complete reduced factor census, sum/peak attainments and 10 semantic/proof-boundary controls." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/independent.py" + ], + "timeout_seconds": 240, + "checks": "Separate Walsh features, Fraction elimination, RREF source enumeration, all 64 coefficients per assignment, literal witnesses and full receipt comparison." + } + ] +} diff --git a/research/seven-cube-affine-seed43/independent.py b/research/seven-cube-affine-seed43/independent.py new file mode 100644 index 0000000000..7c90873a13 --- /dev/null +++ b/research/seven-cube-affine-seed43/independent.py @@ -0,0 +1,250 @@ +#!/usr/bin/env python3 +"""Separate Walsh/Fraction/RREF oracle; no imports from the census generator. + +Hanson Sun with substantial OpenAI Codex assistance; Apache-2.0. +Implementation independence is not independent human review. +""" +from collections import Counter +from fractions import Fraction +import hashlib +from itertools import combinations, combinations_with_replacement, product +import json +from math import factorial +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def insist(condition, message): + if not condition: + raise ValueError(message) + + +def rational_rank(matrix): + """Normalized rational row echelon form, separate from integer elimination.""" + basis = {} + for original in matrix: + row = [Fraction(x) for x in original] + for pivot, old in sorted(basis.items()): + if row[pivot]: + scale = row[pivot] + row = [a - scale * b for a, b in zip(row, old)] + pivot = next((j for j, x in enumerate(row) if x), None) + if pivot is not None: + scale = row[pivot] + basis[pivot] = [x / scale for x in row] + return len(basis) + + +POINTS = [tuple((x >> j) & 1 for j in range(7)) + (1,) for x in range(128)] +VALUES = {f: [sum(((f >> j) & 1) * v[j] for j in range(8)) % 2 for v in POINTS] + for f in range(1, 256)} +SUPPORTS = {f: [x for x, b in enumerate(values) if b] for f, values in VALUES.items()} + + +def classify(f, g): + cells = Counter((((f >> j) & 1), ((g >> j) & 1)) for j in range(7)) + equal_nonzero = f % 128 == g % 128 != 0 + phase = int((f >= 128) != (g >= 128)) if equal_nonzero else 0 + return cells[1, 0], cells[0, 1], cells[1, 1], phase + + +def ranks(): + features = [mask for mask in range(128) if mask.bit_count() <= 3] + insist(len(features) == 64, "cubic feature count") + kernel = [sum(-1 if (m & x).bit_count() % 2 else 1 for m in features) for x in range(128)] + for x in range(128): + j = 7 - x.bit_count() + insist(3 * kernel[x] == 4 * (j - 1) * (j - 3) * (j - 5), "Walsh/cubic mismatch") + counts = Counter(classify(f, g) for f in range(1, 256) for g in range(1, 256)) + rows = [] + for a in range(8): + for b in range(8 - a): + for c in range(8 - a - b): + d = 7 - a - b - c + equal = a == b == 0 and c > 0 + for flip in range(2 if equal else 1): + f = sum(1 << j for j in list(range(a)) + list(range(a + b, a + b + c))) + g = sum(1 << j for j in range(a, a + b + c)) + if f == 0: + f = 128 + if g == 0: + g = 128 + elif flip: + g += 128 + ways = factorial(7) // (factorial(a) * factorial(b) * factorial(c) * factorial(d)) + constants = 1 if a + b + c == 0 else (2 if equal or a + c == 0 or b + c == 0 else 4) + key = [a, b, c, flip] + insist(counts[tuple(key)] == ways * constants, "orbit multiplicity") + A, B = SUPPORTS[f], SUPPORTS[g] + rows.append({"key": key, "forms": [f, g], "multiplicity": ways * constants, + "rank": rational_rank([[kernel[x ^ y] for y in B] for x in A]), + "diagonal": sum(VALUES[f][x] * VALUES[g][x] for x in range(128))}) + insist(len(rows) == len(counts) == 127 and sum(counts.values()) == 65025, "rank coverage") + return sorted(rows, key=lambda r: r["key"]) + + +def solve_sources(readers): + """RREF of eight equations whose right sides are source-code vectors.""" + n = len(readers) + rows = [[sum(((f >> bit) & 1) << i for i, f in enumerate(readers)), 128 if bit < 7 else 255] + for bit in range(8)] + pivots, pos = [], 0 + for col in range(n): + k = next((k for k in range(pos, 8) if (rows[k][0] >> col) & 1), None) + if k is None: + continue + rows[pos], rows[k] = rows[k], rows[pos] + for k in range(8): + if k != pos and rows[k][0] >> col & 1: + rows[k][0] ^= rows[pos][0] + rows[k][1] ^= rows[pos][1] + pivots.append(col) + pos += 1 + if any(lhs == 0 and rhs for lhs, rhs in rows): + return None + free = [i for i in range(n) if i not in pivots] + insist(len(free) <= 1, "unexpected RREF nullity") + solutions = [] + for h in range(256 if free else 1): + gs = [0] * n + if free: + gs[free[0]] = h + for i, col in enumerate(pivots): + gs[col] = rows[i][1] ^ (h if free and rows[i][0] >> free[0] & 1 else 0) + solutions.append(tuple(gs)) + return solutions + + +def valid_coefficients(fs, gs): + for bit in range(8): + row = 0 + for f, g in zip(fs, gs): + if f >> bit & 1: + row ^= g + if row != (128 if bit < 7 else 255): + return False + return True + + +def census(cost): + u = (0, 127, 128, 255) + # Unique quotient representatives with coefficient bits6 and7 set to zero. + spaces = [sorted(u + tuple(h ^ q for q in u)) for h in range(1, 64)] + answers = {} + for n in (2, 3, 4): + if n == 2: + readers = list(combinations(u[1:], 2)) + elif n == 3: + readers = list(combinations_with_replacement(u[1:], 3)) + else: + readers = [fs for W in spaces for fs in combinations(W[1:], 4)] + insist(len(readers) == len(set(readers)), "duplicate reader subset") + sets = assignments = nonzero = 0 + hist = Counter() + best = None + for fs in readers: + solutions = solve_sources(fs) + if solutions is None: + continue + sets += 1 + for gs in solutions: + assignments += 1 + insist(valid_coefficients(fs, gs), "RREF produced a false identity") + if any(g == 0 for g in gs): + continue + nonzero += 1 + bill = sum(cost(f, g) for f, g in zip(fs, gs)) + hist[bill] += 1 + item = (bill, fs, gs) + if best is None or item < best: + best = item + answers[str(n)] = {"reader_sets": sets, "source_assignments": assignments, + "nonzero_assignments": nonzero, "cost_histogram": sorted([k, v] for k, v in hist.items()), + "minimum": best[0], "witness": [list(x) for x in zip(best[1], best[2])]} + return answers + + +def literal(word, binary=True): + for x, y in product(range(128), repeat=2): + z = sum(VALUES[f][x] * VALUES[g][y] for f, g in word) + if (z % 2 if binary else z) != (1 + x.bit_count() + y.bit_count()) % 2: + return False + return True + + +def main(): + sources = json.loads((HERE / "SOURCES.json").read_text()) + live = [s for s in sources["files"] if s["usage"] == "input"] + insist(len(live) == 3, "source count") + for s in live: + insist(hashlib.sha256((ROOT / s["path"]).read_bytes()).hexdigest() == s["sha256"], "source hash: " + s["path"]) + rows = ranks() + by_key = {tuple(r["key"]): r["rank"] for r in rows} + cost = lambda f, g: by_key[classify(f, g)] + # Precompute all ordered costs without consulting the committed rank table. + costs = {(f, g): cost(f, g) for f in range(1, 256) for g in range(1, 256)} + factors = census(lambda f, g: costs[f, g]) + hist, diag = Counter(), {} + for r in rows: + hist[r["rank"]] += r["multiplicity"] + diag[r["rank"]] = max(diag.get(r["rank"], 0), r["diagonal"]) + # Enumerate unordered rank-type multisets, rather than dynamic programming. + bounds = {} + for limit in (127, 128): + bounds[limit] = {} + for n in range(1, 7): + bounds[limit][str(n)] = max((sum(diag[c] for c in cs) + for cs in combinations_with_replacement(sorted(diag), n) + if sum(cs) <= limit), default=-1) + maxima = bounds[127] + words = { + "two_terms": [(127, 127), (255, 255)], + "four_terms": [(2, 125), (125, 130), (130, 253), (253, 2)], + "peak30": [(6, 129), (134, 1), (1, 134), (129, 6), + (24, 96), (96, 152), (152, 224), (224, 24)], + } + witnesses = {} + for name, word in words.items(): + insist(literal(word), "literal decoder failed") + rs = [costs[f, g] for f, g in word] + witnesses[name] = {"terms": [list(t) for t in word], "ranks": rs, + "total": sum(rs), "peak": max(rs), "entries_checked": 16384} + bad = words["four_terms"][:] + bad[0] = (2, 253) + tests = [not literal(words["four_terms"][:-1]), not literal(bad), not literal([(128, 128)]), + not literal(words["four_terms"], binary=False), diag[20] == 0, + maxima["4"] >= 128, 3 * 42 < 128 < factors["3"]["minimum"], + 16 * 128 - 17 * 127 > 16 * 128 - 17 * 128, + next(r for r in rows if r["key"] == [0, 0, 0, 0])["multiplicity"] == 1, + costs[1, 129] == 20 != costs[1, 1]] + insist(all(tests), "negative/logic control failed") + insist([factors[str(n)]["minimum"] for n in (2, 3, 4)] == [128, 138, 128], "short factor bound") + insist(maxima["5"] == 64 and maxima["6"] == 0 and min(hist) == 20, "long factor bound") + insist(bounds[128]["5"] == 64 and bounds[128]["6"] == 0, "equality-length bound") + insist(witnesses["four_terms"]["total"] == 128 and witnesses["four_terms"]["peak"] == 32, + "sharp sum witness") + insist(witnesses["peak30"]["peak"] == 30 and min(k for k, d in diag.items() if d) == 30, + "sharp peak witness") + expected = {"schema_version": 1, "assignment_seed": 43, "dimension": 7, "ports": 128, + "affine_forms": 255, "ordered_pairs": 65025, "rank_orbits": rows, + "rank_histogram": sorted([k, v] for k, v in hist.items()), + "maximum_diagonal_by_rank": sorted([k, v] for k, v in diag.items()), + "factor_census": factors, "max_diagonal_at_cost127": maxima, + "max_diagonal_at_cost128": bounds[128], + "witnesses": witnesses, "total_floor": 128, "peak_floor": 30, + "minimum_peak_at_total_floor": 32, "optimistic_deficit_upper_bound": -128, + "controls": ["omitted_fourth_term", "flipped_source_constant", "empty_star_only", + "rational_sum_is_not_binary_sum", "rank20_cannot_cover_diagonal", + "four_term_diagonal_relaxation_is_insufficient", "three_term_naive_minimum_is_insufficient", + "copy127_would_change_budget", "constant_form_orbit_not_duplicated", + "complementary_coordinate_rank_is20"]} + insist(json.loads((HERE / "CERTIFICATE.json").read_text()) == expected, + "certificate differs from independent Walsh/Fraction/RREF reconstruction") + print("PASS_SEVEN_CUBE_INDEPENDENT pairs=65025 orbits=127 assignments=566275 " + "literal_entries=49152 controls=10 no_new_kappa") + + +if __name__ == "__main__": + main() diff --git a/research/seven-cube-affine-seed43/test_package.py b/research/seven-cube-affine-seed43/test_package.py new file mode 100644 index 0000000000..49e19e80a9 --- /dev/null +++ b/research/seven-cube-affine-seed43/test_package.py @@ -0,0 +1,80 @@ +#!/usr/bin/env python3 +"""Receipt/source corruptions and optimized read-only relocation, stdlib only. + +Hanson Sun with substantial OpenAI Codex assistance; Apache-2.0. +""" +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def check(ok, message): + if not ok: + raise RuntimeError(message) + + +def run(root, expected=None): + for name in ("verify.py", "independent.py"): + script = root / "research" / HERE.name / name + result = subprocess.run([sys.executable, "-I", "-O", "-B", str(script)], + cwd=root, capture_output=True, text=True, timeout=180) + if expected is None: + check(result.returncode == 0 and "PASS_SEVEN_CUBE" in result.stdout, + name + " relocation failed: " + result.stdout + result.stderr) + else: + check(result.returncode != 0 and expected in result.stderr, + name + " failed to reject the intended mutation: " + result.stdout + result.stderr) + + +def main(): + with tempfile.TemporaryDirectory(prefix="seven cube exact ") as temp: + root = Path(temp) / "relocated checkout" + package = root / "research" / HERE.name + shutil.copytree(HERE, package, ignore=shutil.ignore_patterns("__pycache__")) + inputs = [s for s in json.loads((HERE / "SOURCES.json").read_text())["files"] if s["usage"] == "input"] + for source in inputs: + path = root / source["path"] + path.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(ROOT / source["path"], path) + files = [p for p in root.rglob("*") if p.is_file()] + dirs = sorted([p for p in root.rglob("*") if p.is_dir()] + [root], key=lambda p: len(p.parts), reverse=True) + try: + for path in files: + path.chmod(0o444) + for path in dirs: + path.chmod(0o555) + run(root) + finally: + for path in dirs: + path.chmod(0o755) + for path in files: + path.chmod(0o644) + original = (package / "CERTIFICATE.json").read_bytes() + mutations = [ + ("rank-underclaim", lambda x: x["rank_orbits"][0].update(rank=63)), + ("omitted-orbit", lambda x: x["rank_orbits"].pop()), + ("omitted-assignment", lambda x: x["factor_census"]["4"].update(source_assignments=564479)), + ("omitted-witness-term", lambda x: x["witnesses"]["four_terms"]["terms"].pop()), + ] + for name, mutate in mutations: + receipt = json.loads(original) + mutate(receipt) + (package / "CERTIFICATE.json").write_text(json.dumps(receipt)) + run(root, "certificate differs") + print("REJECTED " + name, flush=True) + (package / "CERTIFICATE.json").write_bytes(original) + source = root / inputs[0]["path"] + source.write_bytes(source.read_bytes() + b"\nsource mutation\n") + run(root, "source ") + print("REJECTED source-corruption", flush=True) + print("PASS_SEVEN_CUBE_PACKAGE_TESTS readonly_relocation=2 corruption_rejections=10") + + +if __name__ == "__main__": + main() diff --git a/research/seven-cube-affine-seed43/verify.py b/research/seven-cube-affine-seed43/verify.py new file mode 100644 index 0000000000..27f76c5957 --- /dev/null +++ b/research/seven-cube-affine-seed43/verify.py @@ -0,0 +1,262 @@ +#!/usr/bin/env python3 +"""Exact affine seven-cube census. Hanson Sun; substantial OpenAI Codex assistance. + +Apache-2.0. Standard library only. Does not import predecessor or oracle code. +The quantified reduction from arbitrary finite words is in README.md. +""" +import argparse +from collections import Counter +import hashlib +import itertools +import json +import math +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +N, V, P, ONE = 7, 128, 127, 128 +U = (0, P, ONE, P ^ ONE) + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def value(f, x): + return ((f % V & x).bit_count() ^ (f // V)) & 1 + + +def gram(x, y): + j = N - (x ^ y).bit_count() + numerator = 4 * (j - 1) * (j - 3) * (j - 5) + require(numerator % 3 == 0, "nonintegral cubic Gram") + return numerator // 3 + + +def rank_integer(matrix): + """Gaussian elimination using gcd-normalized integer row operations.""" + a = [list(row) for row in matrix] + nr, nc, r = len(a), len(a[0]), 0 + for j in range(nc): + k = next((k for k in range(r, nr) if a[k][j]), None) + if k is None: + continue + a[r], a[k] = a[k], a[r] + for k in range(r + 1, nr): + if a[k][j]: + d = math.gcd(a[r][j], a[k][j]) + u, v = a[r][j] // d, a[k][j] // d + row = [u * x - v * y for x, y in zip(a[k][j:], a[r][j:])] + d = math.gcd(*row) + a[k][j:] = [x // d for x in row] if d else row + r += 1 + if r == nr: + break + return r + + +def orbit(f, g): + a, b = f % V, g % V + return ((a & ~b).bit_count(), (b & ~a).bit_count(), + (a & b).bit_count(), ((f // V) ^ (g // V)) if a == b and a else 0) + + +def representative(key): + aonly, bonly, both, flip = key + a = (1 << aonly) - 1 + b = ((1 << bonly) - 1) << aonly + shared = ((1 << both) - 1) << (aonly + bonly) + a, b = a | shared, b | shared + return a | (V if not a else 0), b | (V if not b else flip * V) + + +def dyad(f, g): + return sum((f if g >> j & 1 else 0) << (8 * j) for j in range(8)) + + +TARGET = dyad(P, ONE) ^ dyad(ONE, P ^ ONE) + + +def symbolic_word(word): + z = 0 + for f, g in word: + z ^= dyad(f, g) + return z + + +def literal_word(word): + return all(sum(value(f, x) * value(g, y) for f, g in word) % 2 + == (1 + x.bit_count() + y.bit_count()) % 2 + for x in range(V) for y in range(V)) + + +def rank_census(): + counts = Counter(orbit(f, g) for f in range(1, 256) for g in range(1, 256)) + supports = {f: [x for x in range(V) if value(f, x)] for f in range(1, 256)} + G = [[gram(x, y) for y in range(V)] for x in range(V)] + rows = [] + for key, count in sorted(counts.items()): + f, g = representative(key) + A, B = supports[f], supports[g] + rows.append({"key": list(key), "forms": [f, g], "multiplicity": count, + "rank": rank_integer([[G[x][y] for y in B] for x in A]), + "diagonal": len(set(A) & set(B))}) + require(len(rows) == 127 and sum(counts.values()) == 65025, "incomplete rank domain") + return rows + + +def histogram(counter): + return [[k, counter[k]] for k in sorted(counter)] + + +def factor_census(cost): + spaces = sorted({tuple(sorted(set(U) | {h ^ u for u in U})) + for h in range(256) if h not in U}) + require(len(spaces) == 63, "wrong quotient-space count") + result = {} + for n in (2, 3, 4): + if n == 2: + readers = list(itertools.combinations(U[1:], 2)) + elif n == 3: + readers = list(itertools.combinations_with_replacement(U[1:], 3)) + else: + readers = sorted({fs for W in spaces for fs in itertools.combinations(W[1:], 4)}) + sets = candidates = valid = 0 + bills = Counter() + best = None + for fs in readers: + syndromes = [0] * (1 << n) + for mask in range(1, 1 << n): + bit = mask & -mask + syndromes[mask] = syndromes[mask ^ bit] ^ fs[bit.bit_length() - 1] + if ONE not in syndromes or P ^ ONE not in syndromes: + continue + sets += 1 + left, right = syndromes.index(ONE), syndromes.index(P ^ ONE) + null = [i for i, x in enumerate(syndromes) if x == 0] + require(len(null) == (1 if n == 2 else 2), "unexpected nullity") + base = [((P if left >> i & 1 else 0) ^ (ONE if right >> i & 1 else 0)) + for i in range(n)] + for h in range(1 if n == 2 else 256): + candidates += 1 + gs = tuple(b ^ (h if null[-1] >> i & 1 else 0) for i, b in enumerate(base)) + if 0 in gs: + continue + valid += 1 + bill = sum(cost(f, g) for f, g in zip(fs, gs)) + bills[bill] += 1 + candidate = (bill, fs, gs) + if best is None or candidate < best: + best = candidate + result[str(n)] = {"reader_sets": sets, "source_assignments": candidates, + "nonzero_assignments": valid, "cost_histogram": histogram(bills), + "minimum": best[0], "witness": [list(x) for x in zip(best[1], best[2])]} + require([result[str(n)]["source_assignments"] for n in (2, 3, 4)] + == [3, 1792, 564480], "incomplete factor domain") + return result + + +def diagonal_relaxation(rows, limit=127): + types = {(r["rank"], r["diagonal"]) for r in rows} + dp = {0: 0} + maxima = {} + for n in range(1, 7): + nxt = {} + for old, covered in dp.items(): + for rank, diagonal in types: + bill = old + rank + if bill <= limit: + nxt[bill] = max(nxt.get(bill, -1), covered + diagonal) + dp = nxt + maxima[str(n)] = max(dp.values(), default=-1) + return maxima + + +def check_sources(): + source = json.loads((HERE / "SOURCES.json").read_text()) + inputs = [f for f in source["files"] if f["usage"] == "input"] + require(len(inputs) == 3, "source inventory changed") + for f in inputs: + require(hashlib.sha256((ROOT / f["path"]).read_bytes()).hexdigest() == f["sha256"], + "source mismatch: " + f["path"]) + + +def compute(): + rows = rank_census() + table = {tuple(r["key"]): r["rank"] for r in rows} + cost = lambda f, g: table[orbit(f, g)] + counts, diagonal = Counter(), {} + for row in rows: + counts[row["rank"]] += row["multiplicity"] + diagonal[row["rank"]] = max(diagonal.get(row["rank"], 0), row["diagonal"]) + factors = factor_census(cost) + require([factors[str(n)]["minimum"] for n in (2, 3, 4)] == [128, 138, 128], + "unexpected factor optimum") + relax = diagonal_relaxation(rows) + at_floor = diagonal_relaxation(rows, 128) + require(relax["5"] == 64 and relax["6"] == 0, "long-word exclusion failed") + require(at_floor["5"] == 64 and at_floor["6"] == 0, "equality-length exclusion failed") + require(min(counts) == 20 and 7 * min(counts) > 128, "term-count cutoff failed") + # Assignment seed43 chooses coordinate 43 mod7 =1 for the four-term witness. + h, q = 1 << (43 % N), P ^ (1 << (43 % N)) + words = { + "two_terms": [(P, P), (P ^ ONE, P ^ ONE)], + "four_terms": [(h, q), (q, h ^ ONE), (h ^ ONE, q ^ ONE), (q ^ ONE, h)], + "peak30": [(6, 129), (134, 1), (1, 134), (129, 6), + (24, 96), (96, 152), (152, 224), (224, 24)], + } + witnesses = {} + for name, word in words.items(): + require(symbolic_word(word) == TARGET and literal_word(word), "bad decoder " + name) + ranks = [cost(f, g) for f, g in word] + witnesses[name] = {"terms": [list(t) for t in word], "ranks": ranks, + "total": sum(ranks), "peak": max(ranks), "entries_checked": V * V} + controls = [] + def control(name, rejects): + require(rejects, "negative control accepted: " + name) + controls.append(name) + control("omitted_fourth_term", not literal_word(words["four_terms"][:-1])) + bad = list(words["four_terms"]) + bad[0] = (bad[0][0], bad[0][1] ^ ONE) + control("flipped_source_constant", not literal_word(bad)) + control("empty_star_only", not literal_word([(ONE, ONE)])) + control("rational_sum_is_not_binary_sum", any( + sum(value(f, x) * value(g, y) for f, g in words["four_terms"]) + != (1 + x.bit_count() + y.bit_count()) % 2 for x in range(V) for y in range(V))) + control("rank20_cannot_cover_diagonal", diagonal[20] == 0) + control("four_term_diagonal_relaxation_is_insufficient", relax["4"] >= V) + control("three_term_naive_minimum_is_insufficient", 3 * 42 < V and factors["3"]["minimum"] > V) + control("copy127_would_change_budget", (17 - 1) * V - 17 * 127 > (17 - 1) * V - 17 * V) + control("constant_form_orbit_not_duplicated", next(r for r in rows if r["key"] == [0, 0, 0, 0])["multiplicity"] == 1) + control("complementary_coordinate_rank_is20", cost(1, 129) == 20 and cost(1, 1) != 20) + return {"schema_version": 1, "assignment_seed": 43, "dimension": N, "ports": V, + "affine_forms": 255, "ordered_pairs": 65025, "rank_orbits": rows, + "rank_histogram": histogram(counts), + "maximum_diagonal_by_rank": [[r, diagonal[r]] for r in sorted(diagonal)], + "factor_census": factors, "max_diagonal_at_cost127": relax, + "max_diagonal_at_cost128": at_floor, + "witnesses": witnesses, "total_floor": 128, "peak_floor": 30, + "minimum_peak_at_total_floor": 32, "optimistic_deficit_upper_bound": -128, + "controls": controls} + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument("--write-certificate", type=Path) + args = ap.parse_args() + check_sources() + receipt = compute() + if args.write_certificate: + with args.write_certificate.open("x") as out: + json.dump(receipt, out, indent=2) + out.write("\n") + else: + require(json.loads((HERE / "CERTIFICATE.json").read_text()) == receipt, + "certificate differs from complete recomputation") + print("PASS_SEVEN_CUBE_AFFINE pairs=65025 orbits=127 assignments=566275 " + "copy_floor=128 peak_floor=30 controls=10 no_new_kappa") + + +if __name__ == "__main__": + main()