diff --git a/research/r439-helper-quartets-seed07/CERTIFICATE.json b/research/r439-helper-quartets-seed07/CERTIFICATE.json new file mode 100644 index 0000000000..a2bebd72b4 --- /dev/null +++ b/research/r439-helper-quartets-seed07/CERTIFICATE.json @@ -0,0 +1,2448 @@ +{ + "admitted_improvements": 2, + "baseline": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "census": [ + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 44, + 197, + 223, + 49 + ], + "indices": [ + 13, + 88 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 315, + 351, + 337, + 306 + ], + "indices": [ + 141, + 151 + ], + "matrix": [ + 1, + 3, + 12, + 8 + ], + "word": [ + [ + 1, + 0 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 265, + 270, + 344, + 313 + ], + "indices": [ + 111, + 154 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 83, + 172, + 426, + 367 + ], + "indices": [ + 28, + 195 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 333, + 297, + 393, + 417 + ], + "indices": [ + 148, + 182 + ], + "matrix": [ + 3, + 2, + 4, + 12 + ], + "word": [ + [ + 0, + 1 + ], + [ + 3, + 2 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10547842, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 131, + 149, + 269, + 88 + ], + "indices": [ + 51, + 114 + ], + "matrix": [ + 1, + 3, + 12, + 8 + ], + "word": [ + [ + 1, + 0 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 249, + 130, + 315, + 351 + ], + "indices": [ + 101, + 141 + ], + "matrix": [ + 3, + 2, + 4, + 12 + ], + "word": [ + [ + 0, + 1 + ], + [ + 3, + 2 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 14, + 235, + 199, + 50 + ], + "indices": [ + 3, + 75 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 320, + 162, + 345, + 310 + ], + "indices": [ + 143, + 155 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 307, + 19, + 362, + 329 + ], + "indices": [ + 137, + 162 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10547842, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 131, + 149, + 266, + 96 + ], + "indices": [ + 51, + 112 + ], + "matrix": [ + 1, + 3, + 12, + 8 + ], + "word": [ + [ + 1, + 0 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 33, + 206, + 375, + 435 + ], + "indices": [ + 10, + 171 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 208, + 35, + 377, + 437 + ], + "indices": [ + 81, + 173 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 265, + 270, + 307, + 19 + ], + "indices": [ + 111, + 137 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 216, + 45, + 429, + 381 + ], + "indices": [ + 85, + 196 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 292, + 145, + 322, + 90 + ], + "indices": [ + 128, + 144 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5726, + "F": 70355, + "native_ADDs": 11946, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 269, + 88, + 288, + 153 + ], + "indices": [ + 114, + 126 + ], + "matrix": [ + 3, + 14, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 1, + 2 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10523502, + "D_adds": 5729, + "F": 70091, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 52, + 62, + 250, + 318 + ], + "indices": [ + 15, + 102 + ], + "matrix": [ + 3, + 2, + 4, + 12 + ], + "word": [ + [ + 0, + 1 + ], + [ + 3, + 2 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 187, + 95, + 359, + 81 + ], + "indices": [ + 69, + 161 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 86, + 181, + 375, + 435 + ], + "indices": [ + 31, + 171 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 169, + 191, + 195, + 201 + ], + "indices": [ + 61, + 72 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 101, + 144, + 236, + 5 + ], + "indices": [ + 36, + 98 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10565614, + "D_adds": 5729, + "F": 70479, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 314, + 42, + 369, + 424 + ], + "indices": [ + 140, + 166 + ], + "matrix": [ + 1, + 3, + 4, + 12 + ], + "word": [ + [ + 1, + 0 + ], + [ + 3, + 2 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 273, + 126, + 293, + 347 + ], + "indices": [ + 116, + 129 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 92, + 180, + 410, + 118 + ], + "indices": [ + 33, + 191 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 338, + 302, + 426, + 367 + ], + "indices": [ + 152, + 195 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 282, + 0, + 426, + 367 + ], + "indices": [ + 121, + 195 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 44, + 197, + 63, + 214 + ], + "indices": [ + 13, + 22 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 18, + 1, + 411, + 399 + ], + "indices": [ + 5, + 192 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 293, + 347, + 322, + 90 + ], + "indices": [ + 129, + 144 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 263, + 264, + 401, + 413 + ], + "indices": [ + 110, + 187 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 280, + 261, + 307, + 19 + ], + "indices": [ + 120, + 137 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 63, + 214, + 205, + 221 + ], + "indices": [ + 22, + 79 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 63, + 214, + 378, + 433 + ], + "indices": [ + 22, + 174 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 303, + 65, + 408, + 385 + ], + "indices": [ + 134, + 190 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 102, + 132, + 228, + 29 + ], + "indices": [ + 37, + 92 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 117, + 121, + 226, + 238 + ], + "indices": [ + 46, + 90 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 109, + 107, + 256, + 242 + ], + "indices": [ + 40, + 106 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 288, + 153, + 294, + 276 + ], + "indices": [ + 126, + 130 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 169, + 191, + 265, + 270 + ], + "indices": [ + 61, + 111 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 178, + 75, + 365, + 326 + ], + "indices": [ + 66, + 163 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 256, + 242, + 411, + 399 + ], + "indices": [ + 106, + 192 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 198, + 24, + 203, + 36 + ], + "indices": [ + 74, + 77 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 371, + 409, + 387, + 406 + ], + "indices": [ + 168, + 178 + ], + "matrix": [ + 3, + 2, + 4, + 12 + ], + "word": [ + [ + 0, + 1 + ], + [ + 3, + 2 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10614828, + "D_adds": 5729, + "F": 70167, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 64, + 87, + 141, + 156 + ], + "indices": [ + 23, + 55 + ], + "matrix": [ + 3, + 2, + 4, + 12 + ], + "word": [ + [ + 0, + 1 + ], + [ + 3, + 2 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 343, + 398, + 377, + 437 + ], + "indices": [ + 153, + 173 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 393, + 417, + 401, + 413 + ], + "indices": [ + 182, + 187 + ], + "matrix": [ + 1, + 3, + 12, + 8 + ], + "word": [ + [ + 1, + 0 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 320, + 162, + 387, + 406 + ], + "indices": [ + 143, + 178 + ], + "matrix": [ + 3, + 2, + 4, + 12 + ], + "word": [ + [ + 0, + 1 + ], + [ + 3, + 2 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 168, + 61, + 294, + 276 + ], + "indices": [ + 60, + 130 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 33, + 206, + 72, + 68 + ], + "indices": [ + 10, + 25 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 199, + 50, + 298, + 415 + ], + "indices": [ + 75, + 132 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 273, + 126, + 377, + 437 + ], + "indices": [ + 116, + 173 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 134, + 98, + 393, + 417 + ], + "indices": [ + 52, + 182 + ], + "matrix": [ + 3, + 2, + 4, + 12 + ], + "word": [ + [ + 0, + 1 + ], + [ + 3, + 2 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 355, + 324, + 404, + 389 + ], + "indices": [ + 159, + 188 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 64, + 87, + 355, + 324 + ], + "indices": [ + 23, + 159 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 83, + 172, + 174, + 77 + ], + "indices": [ + 28, + 63 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10565614, + "D_adds": 5729, + "F": 70479, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 294, + 276, + 314, + 42 + ], + "indices": [ + 130, + 140 + ], + "matrix": [ + 3, + 2, + 4, + 12 + ], + "word": [ + [ + 0, + 1 + ], + [ + 3, + 2 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 309, + 346, + 344, + 313 + ], + "indices": [ + 138, + 154 + ], + "matrix": [ + 1, + 3, + 12, + 8 + ], + "word": [ + [ + 1, + 0 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 110, + 120, + 408, + 385 + ], + "indices": [ + 41, + 190 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 234, + 15, + 274, + 114 + ], + "indices": [ + 97, + 117 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 60, + 213, + 312, + 348 + ], + "indices": [ + 21, + 139 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5728, + "F": 70347, + "native_ADDs": 11948, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 229, + 239, + 387, + 406 + ], + "indices": [ + 93, + 178 + ], + "matrix": [ + 1, + 3, + 4, + 15 + ], + "word": [ + [ + 1, + 0 + ], + [ + 3, + 1 + ], + [ + 3, + 2 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 104, + 308, + 263, + 264 + ], + "indices": [ + 38, + 110 + ], + "matrix": [ + 3, + 2, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 211, + 143, + 229, + 239 + ], + "indices": [ + 83, + 93 + ], + "matrix": [ + 3, + 2, + 4, + 12 + ], + "word": [ + [ + 0, + 1 + ], + [ + 3, + 2 + ] + ] + } + ], + "census_sha256": "34cd212d94a5caeea01fbf774b62155a99778bb9b9dfacce738d48d2d8e06cfc", + "combinations": 1290240, + "distance_histogram": { + "0": 1, + "1": 12, + "2": 96, + "3": 542, + "4": 2058, + "5": 5316, + "6": 7530, + "7": 4058, + "8": 541, + "9": 6 + }, + "format": "r439-helper-quartets/1", + "group_order": 20160, + "quartet_count": 64, + "seed": 7, + "winner": { + "admitted": true, + "bill": { + "B": 10548832, + "D_adds": 5726, + "F": 70355, + "native_ADDs": 11946, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "helpers": [ + 269, + 88, + 288, + 153 + ], + "indices": [ + 114, + 126 + ], + "matrix": [ + 3, + 14, + 12, + 8 + ], + "word": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 1, + 2 + ] + ] + } +} diff --git a/research/r439-helper-quartets-seed07/CLAIM.md b/research/r439-helper-quartets-seed07/CLAIM.md new file mode 100644 index 0000000000..db8cb475c0 --- /dev/null +++ b/research/r439-helper-quartets-seed07/CLAIM.md @@ -0,0 +1,92 @@ +# Cycle 3 claim + +Claimed 2026-10-13 at 16:48 UTC. Assignment seed 7 was drawn once with +`secrets.randbelow(100)`, using OS randomness. Track: bit supplier. +Base: `2921874911956718fcaaaf9396fe8267b3cfa9f0`, clean fetched main. +Branch: `research/cycle03-seed07-helper-quartets`. +Finish by 17:23:24 UTC; reserve 17:13:24 onward for verification and handoff. + +Hypothesis: a general GL(4,2) basis on the union of two disjoint helper pairs +can reduce the complete ADD count of the precision-admitted PR941 R439 +candidate while retaining its 104-bit local and 192-bit nine-stage caps. +Freeze the PR915 target basis and every operation outside D. No new kappa, +selected-supplier adoption, global regeneration or changes to upstream/. + +Method and stopping rule: choose exactly 64 distinct pair-of-pair indices +by sorting SHA256 of `7:i:j` over all 19,701 unordered pairs of the 199 +PR941 pairs. Enumerate all 20,160 GL(4,2) matrices by breadth-first search +using lexicographically ordered XOR generators, retaining one shortest +word per matrix. Price all 1,290,240 combinations with preparation and +literal reverse cleanup included. For each quartet reconstruct its cheapest +representative, breaking ties by matrix tuple, and check the complete word's +positive precision bounds. Pick one admitted improvement by complete ADDs, +then F, B and quartet indices. No adaptive restarts or combination of winners. +If none passes, report the finite failed search, not a general impossibility. + +Optimistic complete price before implementation: +`6220 + 612 + 2*(197 + length(H)) + weight(E*K*H_inverse)`. +The 6,220 outside-D ADDs, 306 target preparations and 306 restorations, +197 untouched helper pairs, complete injection and both quartet passes +are all charged. Paid recursive ranks, helpers, copies and frame paths stay +fixed; a smaller local word alone does not establish a better supplier bound. + +Three candidates considered: this four-helper fusion; a simultaneous +helper-and-target basis change; further phase-A retiming. Choose the first +because its exact finite class and complete price fit this cycle. The second +would change two interacting contracts; the third overlaps existing prefix +and moment work. + +Coordination checked immediately before claiming: no pinned sprint and only +open issues #913 and #650, neither coordination. No reservation issue opened. +Live PR metadata checked through #1021; all-state searches for GL(4,2), +four-helper, quartet and helper inspected. PR941 disjoint matching, PR965 +pair-plus-singleton GL(3,2), PR967 three-helper stars and PR978 historical +R420 sharing are predecessors or adjacent scopes. PR1015 is phase B and +PR1016 is a fixed-frame moment obstruction. This search is a four-helper +fusion around the frozen PR941 matching, with all other pairs retained. + +Deliverable: exact witness and bounded-search census with source pins, +independent finite replay, negative controls, cost and scope proof; one PR +only if useful evidence and relevant checks pass, otherwise a clean local +patch and handoff. Sagar Thakrar / @thakrarsagar, with substantial OpenAI +Codex assistance. Apache-2.0; predecessor attribution retained. + +## Completed result + +Submitted 2026-10-13 at 17:10:45 UTC: +https://github.com/CrocSwap/integer-mult-bounds/pull/1045 +Implementation head: `51871a0aa67132565acba1de38bb97db14a187fb`. +This completion note is the one result update to the local claim. + +All 64 quartets and all 1,290,240 basis prices completed. The chosen quartet +`[269,88,288,153]` uses three preparations in place of two, saves five +injection ADDs and costs two additional preparation/restoration ADDs. +Complete cost: 11,949 to 11,946; this is the exact minimum in the declared +64-quartet class. The independently replayed all-disjoint-pair floor is +11,948. Sixty-two quartets give no improvement and one other saves one ADD. +Every cheapest representative passes the two inherited precision caps. +F becomes 70,355; B remains 10,548,832. No new kappa or best-circuit claim. + +Verification includes independent group/domain/distance and full-price +censuses; the 96,141-edge pair-bound dual; 661 input columns in both D +directions; 11 local and four external adverse cases plus a charged neutral +case; unchanged owning checks; native 5/9/11-stage replay on both words and +96 rejected bridge controls; 43 source pins; 25 selected-record and nine +finite-bit-contract tests. The native receipt records 186 dependency hashes. +Verification and handoff occupied the final part of the cycle, beginning +before 17:00 UTC, ahead of the reserved 17:13:24 start. + +Metadata and claims were refreshed through #1043 immediately before +submission. PR1040 changes the target basis after PR967, whereas this +construction freezes E and changes four PR941 helpers; it is credited. +PR1023 is a hosting-width result, PR1027 is an R480 six-wire circuit and +PR1043 changes source access and helper stock. No same-object claim was +found. Refreshed main is still the recorded base; all 43 source blobs and +the selected kappa are unchanged. No pinned sprint exists. The repository +has neither a codex nor a codex-automation label available. + +PR1045 is open and attached to the originating chat. GitHub CI was queued +at the 17:11 UTC submission check; success is not asserted. Whole-hosted +adoption, the complete supplier invoice, outer assembly and inherited +uniform/realization/tape/analytic assumptions remain. No full repository +suite, selected supplier cold replay, Linux run or formal proof was done. diff --git a/research/r439-helper-quartets-seed07/NATIVE-RECEIPT.json b/research/r439-helper-quartets-seed07/NATIVE-RECEIPT.json new file mode 100644 index 0000000000..0e0c7e4d1a --- /dev/null +++ b/research/r439-helper-quartets-seed07/NATIVE-RECEIPT.json @@ -0,0 +1,519 @@ +{ + "compiler": "Apple clang version 21.0.0 (clang-2100.1.1.101)\nTarget: arm64-apple-darwin25.5.0\nThread model: posix\nInstalledDir: /Library/Developer/CommandLineTools/usr/bin\n", + "dependencies": { + "boost/assert.hpp": "0bbedf7669fec61d273084e1165bdf766636bf427d0ce5e9fed378b23445969e", + "boost/assert/source_location.hpp": "6369347a61737be05950a03bc5c8cfaa5137c938cda06d81de9ee33c1c7f6528", + "boost/config.hpp": "373206390d20aa5bb9e2628eb08543399d73b853af7bfc5f1d2bd9a00bc07593", + "boost/config/compiler/clang.hpp": "ec01f6ff90a8d73d2c46dcd722ff3cafc9ad1192a25eb404858dcab3f1b4f474", + "boost/config/compiler/clang_version.hpp": "eaf8b6349c686ff27afb29c28dc1fc891fb7613fc8304939b276900c4e5b8ccd", + "boost/config/detail/posix_features.hpp": "bba105d0af558c09307941fe64ce5ce9d775990b96684708adf4a9a92070fc0a", + "boost/config/detail/select_compiler_config.hpp": "73059f6ceb2952375b9cfb71ee609bd29c595d9f82014a01676fcc47c3a692d3", + "boost/config/detail/select_platform_config.hpp": "b24a891ef5cf8b032f1073c3e7d7416bba54657e58fec6f89e66c8ff9439665e", + "boost/config/detail/select_stdlib_config.hpp": "d26cb12104c9942b2031500c291ee13754dbb43b1d944fb30a7b98b119b83456", + "boost/config/detail/suffix.hpp": "f46a617b5bd44d2076c978ad7151b31f9921517d881f57ee927b26ae4c2383ec", + "boost/config/platform/macos.hpp": "d5f923845074c86a3abfb0b5fee1e5795646e92274f722291f6e2a1e6e4d7b0d", + "boost/config/stdlib/libcpp.hpp": "83ed349fa8dae6f0ce809f63d44253261593e8677405200b11bb3b7a6751d4e3", + "boost/config/user.hpp": "d24c2d771df2ee757c930466d69a0fac11cf721aaf89820f32c05c923a4ebca7", + "boost/config/workaround.hpp": "58a94045ef72552481b69a8b614a6c92e0d21ee19798677560ec4d59e10b0f99", + "boost/container/container_fwd.hpp": "1467815af9de8e0b2d256630a5a1ba23a0d8dd4162d0e631d786b50e9af81869", + "boost/container/detail/std_fwd.hpp": "e31db3d40f075e0f099741ca190c42ef9881a91279a9e17508c38f392d6f5caf", + "boost/core/addressof.hpp": "c4a07c20efae1a947f198721961dcd902b43e5615ea0d3d9b2da140a9099b880", + "boost/core/cmath.hpp": "0cca14ccce20b16cc42e9a164c4527615efd4a8ffea41eadccce72969f13f3e6", + "boost/core/enable_if.hpp": "b4aefa20fb7a5d673ee4023e693ca74738dd84ffd5a4c248ddc06c1df812229e", + "boost/core/no_exceptions_support.hpp": "278aebfebf0d469dc3d0582e2b2ecc65729f691b727b4091dea48e65184a0aa4", + "boost/core/noncopyable.hpp": "5a8fa4f0abc94fd2fc587a3919e942d21999dfcb0eaf7189aac6f4b341f3c1c4", + "boost/core/nvp.hpp": "2455622f47eb79516706128bb4d4477de57e89871b316341110263ab7966f296", + "boost/core/snprintf.hpp": "19706b5280130370621736992c357eb036f7c0d319650b108a6d2c70bedfb0cf", + "boost/cstdfloat.hpp": "74079b2488a7ac546edb8c8e28368ce96015f5014f9c4ebbcbee4a5c34f9c76e", + "boost/cstdint.hpp": "dbbf2bba3a0b6316d7f1850ff656eb4567bb2aa10197435a525cb8ff70b6d8f5", + "boost/detail/basic_pointerbuf.hpp": "0dba08a34bdc418e3dbf6c884a8caa7c300dbc5514bc3f58311f5548423fde60", + "boost/detail/lcast_precision.hpp": "79bf37ee64b0b8d42ea51e8129184f0bc608e8f4f111368dbfb3991c7386d47b", + "boost/detail/workaround.hpp": "5d88074d61d7d93196d72b84fa62ede29be62a3f68386b78bda63eea7b32f2ba", + "boost/exception/exception.hpp": "062f57bcd7f1bdd92014beec36c59fdad44b00717ef9b108a1adb48069afee95", + "boost/integer.hpp": "03dd0b82dbdb025d4d04d933fb02ba88704f74c119ee9b85935a97dea2beefd8", + "boost/integer/common_factor_rt.hpp": "01e9d3a34e53cad2bcc3f2fbc0cc6ac602ea1fc95b9ce4d759d485c80987fa15", + "boost/integer_fwd.hpp": "be344ef833a98f8a21c91095404ba46c4fb3ab4900490551f4bd4945753804b7", + "boost/integer_traits.hpp": "b1f0d9685488b21e01fcc784855c1e228e917dfe81097b18f80059c046c637a0", + "boost/lexical_cast.hpp": "ea69bf2033300333b5a2b5c042fabb11bc67d20d168a5246110c7dc1298d1a58", + "boost/lexical_cast/bad_lexical_cast.hpp": "a7395f275f08416c0bb70bc6b23c15c94b0c22e17ec0667c9f3d80963827d261", + "boost/lexical_cast/detail/buffer_view.hpp": "5911b0bf5c5e6f8c3b334c88ca06834edcd407728b0f35897c1c299b30af31fc", + "boost/lexical_cast/detail/converter_lexical.hpp": "5c06096a5da204ba78bb1d3ebe049e4c32342da14e0ab8e74c58e351e4fd1d32", + "boost/lexical_cast/detail/converter_lexical_streams.hpp": "8e13542612406a37b82b9e1b1e0cfe0a91b9947289a5caa7801554bc7223935b", + "boost/lexical_cast/detail/converter_numeric.hpp": "bc7acba60463f1a971bed785e159b6832bd6366b34a9da70eaf20c13bf066f54", + "boost/lexical_cast/detail/inf_nan.hpp": "04ad862a7df1af6d5c810b01be2f3c3cedaa8ba6216dd3a96c4a029aa63358bc", + "boost/lexical_cast/detail/is_character.hpp": "2e10b12593b35c18056ab7a4a9f76401e8302b4dc1fd505f72d53590d612d0f3", + "boost/lexical_cast/detail/lcast_basic_unlockedbuf.hpp": "51663dde37050e295069488cf4385a29d0fa4b534dfca0dca8327f5ac7503a26", + "boost/lexical_cast/detail/lcast_char_constants.hpp": "8533181c0213e2e362f42b4f53ecbe5e53f0488f3d0ab0686c928f5cf86f19ab", + "boost/lexical_cast/detail/lcast_unsigned_converters.hpp": "60a5359011df7498e192926db822a0fa35747a6ec9cb4f3153097ea9519ca4de", + "boost/lexical_cast/detail/widest_char.hpp": "90b498bc61db0a3b8462448897638793964f240996d8cbae26729e4085ec5716", + "boost/lexical_cast/try_lexical_convert.hpp": "f004b51a5515c789d6b297824f0b44748717ac60288486951a6b1bebed105691", + "boost/limits.hpp": "2eaa67719758ec0fc72daebea6d3b8c4e8a4e26948f6bf0cc497fc0af43dca02", + "boost/math/ccmath/abs.hpp": "466b31ff67f9abed72844e874a88221683fd5cda24283ff066a75297989fe91d", + "boost/math/ccmath/detail/config.hpp": "c90281274374d955de470887d6ef5f2bbd627847798e0ba77a73965e142ea777", + "boost/math/ccmath/isinf.hpp": "b201ca74985a2a5206d432e8894e11a98b7ba4b475a05e99f5dc0ef309f5698f", + "boost/math/ccmath/isnan.hpp": "704a80d2fcfca27bfb9912aac7e377d5f244c11f730336755efbb2a915bbb538", + "boost/math/ccmath/ldexp.hpp": "24f9d21664e25f8cafe37a4269a1968b168122cf2cd25848ea25d12f2ae977a1", + "boost/math/cstdfloat/cstdfloat_cmath.hpp": "77eb17ea77efcfd763a4e77f46af7a720014316b5281271ef7bf1cffb7f243bf", + "boost/math/cstdfloat/cstdfloat_complex.hpp": "234424ef5a9e4f86319c437dc3ada33effb424676fa9016b966a9200a3c29182", + "boost/math/cstdfloat/cstdfloat_iostream.hpp": "e731ffb6038f8b64ec381092518913601d9c433509ef7ea676311cda08b22fec", + "boost/math/cstdfloat/cstdfloat_limits.hpp": "46fe83aec0bdd94754214feda2ee937075730c541c4a012c8d91029080b9d3db", + "boost/math/cstdfloat/cstdfloat_types.hpp": "ef8153f9dd23e9bcd11e751cd5e87ed285045b7ec49434a6106f1fdc506746ed", + "boost/math/policies/error_handling.hpp": "1e8be5f68151aafcdd2aa4519b5b7b8f7b72a89341a8b1be8b4316a1646f809d", + "boost/math/policies/policy.hpp": "e23f097eccb99d96563032ffa8eb9c6618fe4b625ca907d32147adad49e7402b", + "boost/math/special_functions/detail/fp_traits.hpp": "bac496b01b0d63b444a9c03c51d4e6dbbec16486ebaaffb0ab670f22b03fbbda", + "boost/math/special_functions/detail/round_fwd.hpp": "dc26bd98c9f4a2c16517c49bd77a2ffd10b3478e2680fb8148709dfcf9dacc1d", + "boost/math/special_functions/fpclassify.hpp": "fcc2c43830b96ca1cb5f54f62ce742203fa761fade8f5fb97c229d2e99ecc397", + "boost/math/special_functions/hypot.hpp": "e1a8eb17b6290bf9c71eab21b38ad5140e4f8bdc433b2036bbdb6e5451134b8b", + "boost/math/special_functions/math_fwd.hpp": "e41f20e1a3a4edce3945b613e4fe593757e3867bb57ab953be78c07b81580c92", + "boost/math/special_functions/next.hpp": "80916fd02610ddc26501cbc7fdd9143093e03de373a7c7bd8ae43d4d6d04f346", + "boost/math/special_functions/sign.hpp": "f669fec3254b9b2728b27f2cfe92d729e39fe796ff53139ad14b64e4a33d668d", + "boost/math/special_functions/trunc.hpp": "4aec3473ee322c6d50ab8a27a426df7764688eac357353313a52c4f9545d408a", + "boost/math/tools/assert.hpp": "ea589b77e8b745df78e425de0871e4641898611207a20965342b3c192bfd4cd2", + "boost/math/tools/complex.hpp": "d01e2f203986ae5d79835231ca1056717ce5766f5472324987214cdc77b27426", + "boost/math/tools/config.hpp": "0766a8529f0f2cf8c6439b9ce0283aa98dcf200e403d581e5cf47a41428835dd", + "boost/math/tools/is_constant_evaluated.hpp": "c0d893f0d445d1b04451bec5b17372b984807c96c74170e609568f8accbd6d8b", + "boost/math/tools/is_detected.hpp": "a9594db6cc0d0b9382e3b21e49ad4be03020cc65f94d153f312f192789aaf9fa", + "boost/math/tools/is_standalone.hpp": "83a9b1e4f131596ec61ff4de801ab917e89c1e2aa8f0f974d01d1ed6a9cb753f", + "boost/math/tools/mp.hpp": "22e2dcc96e6b379cd4219d3fe6d98d1bc4c51a451fefa529b4a2a0c7aa4411af", + "boost/math/tools/precision.hpp": "61392cb9ef4be2f57e7104b8eea1e34d94a804bd7aa64ace9d87263d127626b1", + "boost/math/tools/promotion.hpp": "0d3321eda9d6244861b67643c565d0bf60f15abe57db5af1eed6bd4e6c006167", + "boost/math/tools/real_cast.hpp": "1ebf4b521c4ce73d291bcfadd804d37160e3d8dc3211d5cec181377d9cff7012", + "boost/math/tools/throw_exception.hpp": "6f0ebc04d8c47e30f48718bd8ffdae4f2931ab23c9371b275832a950b7a07409", + "boost/math/tools/traits.hpp": "80d224f3cafdc10dafdefe38500de719da06921f4eb24a7ada7a51e85013cf66", + "boost/math/tools/user.hpp": "8ce56443ce5933874160edb9929254ccca8d2deda82eaf7a70be78e58bd7629a", + "boost/move/detail/std_ns_begin.hpp": "8a4085b113b623ad92d91d366d8a4b1ef55f7c2745016b15f6a058bb9f604244", + "boost/move/detail/std_ns_end.hpp": "960b933e333ba42a03f12c21d71a117a2be3c84257a66c31f33742f71877d5c2", + "boost/multiprecision/cpp_int.hpp": "2677f6c5f854060c483f08500f2d7ddb16e4d3f5e64562e414fdd1ebb4226aa4", + "boost/multiprecision/cpp_int/add.hpp": "3a6c9a403ee39f4ebb19fe1ebb7dc1a67368b0a441b419ebab733a9959cc1274", + "boost/multiprecision/cpp_int/add_unsigned.hpp": "9fd18ab658b9c20571c279f2d49df46fc713c1e0ffab1e025a98518fad30d2e0", + "boost/multiprecision/cpp_int/bitwise.hpp": "22bb953bd398773e7ea770c3bebcc051f10342cce10254b53da69f7061c22f50", + "boost/multiprecision/cpp_int/checked.hpp": "b33f0794085ffcd103c0dc576d9545af4d15a91d6dd254e87b3bea734572032d", + "boost/multiprecision/cpp_int/comparison.hpp": "506346c83b16e042f0f5cf90e0c669c50d1956dcc2dfc28e8c4a56fe6c565548", + "boost/multiprecision/cpp_int/cpp_int_config.hpp": "ca7cfa2c2fcc6f6c5e4c6daaec365d60b49dbd3f85e0a1c5cce0208a031204bf", + "boost/multiprecision/cpp_int/divide.hpp": "38fc575be7ee87acc9aae2c61cd51e7c2e328530f776ccbd2cc849ca0012eba2", + "boost/multiprecision/cpp_int/import_export.hpp": "6298449183554ab788f7b200f9f72cda46423439e9f5e19d02291b3f921d42e8", + "boost/multiprecision/cpp_int/intel_intrinsics.hpp": "0b989ebf7ea70be1a458fff8d6ec831b6f8bba59904a1a8448ee3ec392f5eda5", + "boost/multiprecision/cpp_int/limits.hpp": "e9ea155b8573e44f38e22a30e4fcdefd7a1807235300b71b77ea0f3056a3fb2d", + "boost/multiprecision/cpp_int/literals.hpp": "c271d461f00c5f7300faf758bee5d7bb96e2791f64d678eca2df02664d79a931", + "boost/multiprecision/cpp_int/misc.hpp": "34a6e903972e64bccfde75b9e800d37ac5eae5047dac8f124b273443923c3757", + "boost/multiprecision/cpp_int/multiply.hpp": "25413c62b71c24e9a4a42ea210ee206701c2a97b976960a2f9a39299905ab64c", + "boost/multiprecision/cpp_int/serialize.hpp": "bf671ec5be6b0c4fd80ffa5af353113e0cd7b559798782b97611b9a777a3b1b2", + "boost/multiprecision/cpp_int/value_pack.hpp": "4d809c194298340d60ddcde5c5ce74b56a0df2567ca50cf239a0d87c938524ac", + "boost/multiprecision/detail/assert.hpp": "f767e44bb2627a4686260ab9b715201a877532c2247da6b1ceeed3e0bc739aaa", + "boost/multiprecision/detail/bitscan.hpp": "9602b9df7fff54e2f330a9b06596525acbfa2c80808f7d7909445a56781963a5", + "boost/multiprecision/detail/check_cpp11_config.hpp": "c9cf1e182cf8024413362c8f0538fee6d29aa9c66ae0b3fde09168f43d615e23", + "boost/multiprecision/detail/constexpr.hpp": "2a04221b8778c2f7a26a650a9cbef7d0c440670c2a7e80a821dd66527f7eba5c", + "boost/multiprecision/detail/default_ops.hpp": "b6aef64267d768465db2759add522944ba1bc72a25c57ac183e2fc55f82a2b05", + "boost/multiprecision/detail/digits.hpp": "c0e7666cac94a0f541cd572bb789a08a22a73a3748ffed905fa9c0a9e1d5d067", + "boost/multiprecision/detail/empty_value.hpp": "d4a56ae2e98882c4f7c1deeb2a1fc0555e33ad4723c42d1d65d082b2e1838606", + "boost/multiprecision/detail/endian.hpp": "1b712ae71c7021b6bcdd94f4ed6a660c88800ffc51be78d64c2b2c70de7294f7", + "boost/multiprecision/detail/et_ops.hpp": "976ae4aad4a0113f0681e0e5abba803b8ef31d2fa8c94d70893c754c8bf8d61d", + "boost/multiprecision/detail/float128_functions.hpp": "157fbb9d9378cd5f0ff8367b10573b8e72010165e5d6d2b3ea1b1d906c6c0127", + "boost/multiprecision/detail/fpclassify.hpp": "6d906b72713cae6c5dbaa52c8b7fcf2ebd03c1ead59912a4469732b43387f1b2", + "boost/multiprecision/detail/functions/constants.hpp": "58a28582e001a2abbedf4a6dcd1ed25068ae3a8dfc2778d14412a7badbd44220", + "boost/multiprecision/detail/functions/pow.hpp": "4912686750dae76e829a6912718fa3889dae425919059a91bac7e753b6f4aa64", + "boost/multiprecision/detail/functions/trig.hpp": "e802b586c80227149d36621e2752ea15f90d7b22bef92f5d17426ff521fc8845", + "boost/multiprecision/detail/functions/trunc.hpp": "d23ae08ead72273a57fc8fb401fcb32946def60febbc35a303e81e97b77993ed", + "boost/multiprecision/detail/generic_interconvert.hpp": "9ec3cca3e2488a185d17c2b4dba29e8b84c1eef39e0ad1bb523b4123c370f6c0", + "boost/multiprecision/detail/hash.hpp": "e1732d23c800b86062042a0f4d80395dc96f5ddcc696ac959b7a345ddc326ad6", + "boost/multiprecision/detail/integer_ops.hpp": "9ff2b7319b50085ceef269f92ee0d66d352ec8508b6fd1e7b8b133eb5678d918", + "boost/multiprecision/detail/min_max.hpp": "02c2587cd737cb15c91ee3640e57020b5c7355652c0e424c5d1f59c7a8736db0", + "boost/multiprecision/detail/no_et_ops.hpp": "1ae8ba856da812296a0ea1dff85ed0518e3a77e364c5ae2dfd6a0c4f28b8940f", + "boost/multiprecision/detail/no_exceptions_support.hpp": "9ccda2c4a2129244a656fed2c2081fcfe0c08964a37285066688fcd5d705a838", + "boost/multiprecision/detail/number_base.hpp": "b5f13b9f303d56216cb94bec90da5889e9529c01a1d85c8a51cbd2bd3b702a7c", + "boost/multiprecision/detail/number_compare.hpp": "e1d75991ad8e536ea9e850f2169979416b3823d1209b2305d3ff78af926e0e18", + "boost/multiprecision/detail/precision.hpp": "6a260661370a86ac273f3e31686a304fbc6bffa05fa726d3494181ddbd122549", + "boost/multiprecision/detail/rebind.hpp": "2be7a28a74df4564ff6894ca4ba094e9affe9da69c17ac8d466909a16bbb6087", + "boost/multiprecision/detail/standalone_config.hpp": "ab479b39be1436d383d57cef60144831b784096b067eeadfa410ba9f447d04ec", + "boost/multiprecision/detail/ublas_interop.hpp": "b267977257ca6342b94345265c4d8efb382b2fef654961687e88df3d1a23fa56", + "boost/multiprecision/fwd.hpp": "da8f2d642828572587cf5dbac7552ba85a8a266734398bf71c596f339eadbc5e", + "boost/multiprecision/integer.hpp": "1a2d18d16098b528ce9dd13ac8fc440d543cdcb691c894255f442da7afd3734c", + "boost/multiprecision/number.hpp": "2549b437a6319ee9cbd2032560a0272611715dd89c2919dd85a4a3f9e9aed569", + "boost/multiprecision/rational_adaptor.hpp": "23757733a6f1111aab0af98bb0bf5105fde08ac412c2cbf18d51bbad42656012", + "boost/multiprecision/traits/explicit_conversion.hpp": "345bac71d2bc558ad299eb4b4eccb55e17aea6c0400a7247d3748a0ee00bc657", + "boost/multiprecision/traits/is_backend.hpp": "2259d4c191b10b2cdd8ed3d4fc47cd4e7a68f53cbb66548fa25d387cbcf2b50d", + "boost/multiprecision/traits/is_byte_container.hpp": "4219605c62b0af6b62918f9974e3f8f52c7f9a5a03d57e2a815557c2ef6fcc9b", + "boost/multiprecision/traits/is_complex.hpp": "325bd1c8b4fad14f82e9028f353dfdd9512cdf0dff5011004880989c175444d3", + "boost/multiprecision/traits/is_convertible_arithmetic.hpp": "a3c604ed31afffda69f15e8bf473b10afe0d3361dfb8b73b1da2758d4cbe9efe", + "boost/multiprecision/traits/is_restricted_conversion.hpp": "d4d900efa2b34ceb4cd3975b23f85d46f090c1d54b2e28f63d028ac731061e4e", + "boost/multiprecision/traits/is_variable_precision.hpp": "e8356c3d88d7de15a3081febb6c3a6258973c8c031b370bae2a139f2a2092500", + "boost/multiprecision/traits/max_digits10.hpp": "06859bbdc55e5ec7f329677fb9caae31a490c52327796657c7eb4d2b3f37d4cb", + "boost/multiprecision/traits/std_integer_traits.hpp": "65e01b9d8a1121d367a6b877464033cbec3a3f9fc765ad69ed5e5cdff539034d", + "boost/multiprecision/traits/transcendental_reduction_type.hpp": "88cf0f2bbd93559dad052642721dbb2fb1db63f33a090eef3c79e4ff6b25a69a", + "boost/predef/detail/_cassert.h": "688d791806004c3f334cb94fcdb604811da4647b18eb50159cd0394274b567c2", + "boost/predef/detail/os_detected.h": "4b575705f932b165c9282867d283df29afc6f9e5d17b79f1250964e9d16f8bff", + "boost/predef/detail/test.h": "4a4b5be3b09fc4e81da4734ca6a604ba3528d479874bc5f0f2d4c235fa003a97", + "boost/predef/library/c/_prefix.h": "6cfe353310a9f9db1ae4f55018358ceeb0c6b013c5cfe7b68c639d43dd910709", + "boost/predef/library/c/gnu.h": "daee5122dc6d530a702eb7071797f25532732e54068634d20bafa21fa30d2795", + "boost/predef/make.h": "ec5ee94c1e2d0e0e556d1707edf8600f1f6362bb2e1050f5f1663d965d58b287", + "boost/predef/os/bsd.h": "e4f0b4f8d5e075487309f1572c1ff0845bf2bb198e3833ea3150b1bcb515f971", + "boost/predef/os/bsd/bsdi.h": "44d0aa5486509f079447739280e6ec942150eb9af62d39625a2c65145d6a758d", + "boost/predef/os/bsd/dragonfly.h": "d04a132e3fb951b1ea61bae2bc5b2bda33d4d627cb4d9d29a81d62f72402fe33", + "boost/predef/os/bsd/free.h": "c58a5df6fe802f4ba4e170123e139045dcdb92c8ccea164399dfddef4578721e", + "boost/predef/os/bsd/net.h": "26ec0427bab036fe14b4a9c5b4248b22fcbde4f58269225bb6f41eb9141885d0", + "boost/predef/os/bsd/open.h": "d12be3d971b16a4e7f99f19dfa4429e4a6600541885da3771042ae2d69059634", + "boost/predef/os/ios.h": "ab5295eecc3c13630d9f3faf3567ef2a48101206fb00dfa466498c2e7a00ab3c", + "boost/predef/os/macos.h": "df73b14e50d4a502ff4f98b57122589fb3b7c1384712122317aa5aaba72ecb26", + "boost/predef/other/endian.h": "782a7ae02bae05da22a607f32fae78b3240456082e26e9ad4a6e32e24efea154", + "boost/predef/platform/android.h": "8361c3f4e318fbfcdf4e7794d34e3dec006f03926d6fc48e44c584084b9fa128", + "boost/predef/version_number.h": "e30fb59f4e04d32139df8b2dcda4e8c0d857190806225e4ee3e20381535e6e37", + "boost/static_assert.hpp": "bb01b665f70c8773cb44b77c55c433963ed0f1222ae772bb846e30fe468aa01b", + "boost/throw_exception.hpp": "fbf66a8b406e803d30dde7c616c15e0f1407bf0325f1d4f9665a8788aeedd745", + "boost/type_traits/add_const.hpp": "e0097bd4b39041632548f9f7951edcfb229b908969120972560123366f3a114a", + "boost/type_traits/add_volatile.hpp": "f7cdb4a75b87025798455461fe1b0f5228091fb95765ebc0f281ececbb130e9e", + "boost/type_traits/conditional.hpp": "72744e48a710e2645ecc6a696b150c63d45507cb33b8090fbc7cb8827b2a3ba7", + "boost/type_traits/detail/config.hpp": "22c6676f0907a3e6733f0a0f883bb559955ca2b06cdc26aa47610567a8522edb", + "boost/type_traits/integral_constant.hpp": "1f0f645fdf4b37a2c3c9267f10cfe0734ff8adfccb399fd0e97c53b770d50013", + "boost/type_traits/intrinsics.hpp": "1981687d37f11a103020b6bec6321ae25f9683e01476968f62f8a175bf625c38", + "boost/type_traits/is_arithmetic.hpp": "f937c0f8958d61efc196a30838fbfc085e6ed6a862fed86bec42e671e5ebe7f3", + "boost/type_traits/is_const.hpp": "1dc59162cf36e20d626a6ec7f46cf22afdf353df30d566492bfe35898286b0b6", + "boost/type_traits/is_enum.hpp": "099fec769a429ee66e417d92e93a76586814a9e6545e376db53768d99c382114", + "boost/type_traits/is_float.hpp": "21db01f64bfdd9ee24d57a0191814601a064ea05bff5f6b1f6606d9029619fd7", + "boost/type_traits/is_floating_point.hpp": "a3feea29f37289f32dfe2ca1efde2a1711f1ca6057c57d6f274aafa2a32661e6", + "boost/type_traits/is_integral.hpp": "44a55b50004642c81f775f8783cc1a2dfa90276262bb337f4fe94321179cb652", + "boost/type_traits/is_lvalue_reference.hpp": "2cdb7bf7f68f806306da0cae213c6db1d0c739257994a88bef9f035fdb58c6de", + "boost/type_traits/is_pointer.hpp": "582df44459acba171bfaf5f9e7098e6bd051acaf9f83f964245c9c94e886b1be", + "boost/type_traits/is_reference.hpp": "068dcf0a2c20efa45a587ad6c9b8d331f700d153cf35461da3d386fae1d10e35", + "boost/type_traits/is_rvalue_reference.hpp": "48a7ff6930da2d3e6a79042f8105f8c70a6f39c6f202e98b4961f7b5fa5463f5", + "boost/type_traits/is_same.hpp": "f9836b75f3be3222bc8976cd6485e0270c73df728ae2c06dae33056855483b34", + "boost/type_traits/is_signed.hpp": "f5feee3bec03907ca1e7584f7ff4bdc74b9082d6c70b35ce0d5effff17c28591", + "boost/type_traits/is_unsigned.hpp": "09aae0e2c4fb987f2ddec42a02033f25a8e8cbe755e3ea7ccf30cfa3702edc90", + "boost/type_traits/is_volatile.hpp": "0fe43f8c2c8dae4df59b50cb62b33fcb8be351b1ca78e4a6afb479faf77a4ef9", + "boost/type_traits/make_unsigned.hpp": "8bf849ed921e4ed701f418ca8c290916a490b55f24d10ee309a4be77ad4522ae", + "boost/type_traits/remove_cv.hpp": "440d007534b548b472dd33f0f8c3b18da347527ec3d501566f9ed4257c762497", + "boost/type_traits/type_identity.hpp": "c9babe7d5bf2f7b6a711e226cb39af04ce3b7ba8fb18c2de71cf82a6a8960258", + "boost/version.hpp": "063ed28eceb611d52f58e57aca61edb1e086ed902fbded81ac61936009c52cf0", + "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2", + "research/e8-bit-carrier-skeleton/code/bit/checkers/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "research/e8-bit-carrier-skeleton/code/bit/checkers/legality_h.cpp": "6c1ef2b24e57781d6951c172a1024fc4300e6fd392c9d6672079a7806ab663b3", + "research/e8-bit-carrier-skeleton/portable-include/bits/stdc++.h": "420094be2af295eed03a983dd66debbbe9cfb78d8252859f4498a615a0074b99" + }, + "python": "3.11.15 (main, Apr 14 2026, 14:45:51) [Clang 22.1.3 ]", + "status": "PASS_R439_HELPER_QUARTETS_NATIVE", + "words": { + "candidate": { + "bill": { + "B": 10548832, + "D_adds": 5726, + "F": 70355, + "native_ADDs": 11946, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "canonical_sha256": "77868e11715b8c7714f0aa67256694ca44f1540e761c090f34897af97b8c525e", + "common_frame_ADDs": 11946, + "copies": 9, + "erasures": 9, + "paid_histogram": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "rank_mass": 5129, + "records": 14875, + "staged": { + "5": { + "bridge_additions": 666, + "controls_rejected": 6, + "formal_columns_checked": 883, + "fresh_center_copies": 45, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "payload_prefix_bits": 101, + "payload_prefix_upper": "2480125329327922327549632512000" + }, + "9": { + "bridge_additions": 1998, + "controls_rejected": 18, + "formal_columns_checked": 1327, + "fresh_center_copies": 81, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "payload_prefix_bits": 101, + "payload_prefix_upper": "2480125329327922327549632512000" + }, + "11": { + "bridge_additions": 2664, + "controls_rejected": 24, + "formal_columns_checked": 1549, + "fresh_center_copies": 99, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "payload_prefix_bits": 101, + "payload_prefix_upper": "2480125329327922327549632512000" + } + } + }, + "previous": { + "bill": { + "B": 10548832, + "D_adds": 5729, + "F": 70083, + "native_ADDs": 11949, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "canonical_sha256": "06808b6a98689bba6095fd96c0602fa585dc114bf33073f30acce34b1fdff18d", + "common_frame_ADDs": 11949, + "copies": 9, + "erasures": 9, + "paid_histogram": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "rank_mass": 5129, + "records": 14878, + "staged": { + "5": { + "bridge_additions": 666, + "controls_rejected": 6, + "formal_columns_checked": 883, + "fresh_center_copies": 45, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "payload_prefix_bits": 101, + "payload_prefix_upper": "2451471101600792727738016530432" + }, + "9": { + "bridge_additions": 1998, + "controls_rejected": 18, + "formal_columns_checked": 1327, + "fresh_center_copies": 81, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "payload_prefix_bits": 101, + "payload_prefix_upper": "2451471101600792727738016530432" + }, + "11": { + "bridge_additions": 2664, + "controls_rejected": 24, + "formal_columns_checked": 1549, + "fresh_center_copies": 99, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "payload_prefix_bits": 101, + "payload_prefix_upper": "2451471101600792727738016530432" + } + } + } + } +} diff --git a/research/r439-helper-quartets-seed07/README.md b/research/r439-helper-quartets-seed07/README.md new file mode 100644 index 0000000000..0102c7e91a --- /dev/null +++ b/research/r439-helper-quartets-seed07/README.md @@ -0,0 +1,228 @@ +# A four-helper fusion below the R439 disjoint-pair floor + +One four-helper change reduces the frozen PR941 circuit from **11,949 to +11,946 complete ADDs**, including preparation and restoration. It crosses +the **11,948-ADD disjoint-pair floor** certified by PR941, whose integer dual +certificate is replayed here. The new helper graph is a connected four-node +path, outside that class. No new kappa is claimed. + +This is a small construction and an exact bounded search result. It is not +the cheapest known R439 word: Ross Richardson's PR965 reports 11,840 ADDs +with coupled triples, and PR967 reports 11,783 with restored stars. Their +savings are not combined here. The final overlap refresh also found @woklerx's +PR1040, which retunes one target step after PR967 and reports 11,780 ADDs. +That changes the target basis; this package freezes it. PR1040 head: +`9d885867f28c1f391ab395af2d0b1f2a63681bfd`. The additional evidence here is a fully priced +GL(4,2) search around a fixed, precision-admitted matching, with an exact +minimum for each of 64 prescribed quartets. + +| Quantity | Frozen PR941 | Four-helper word | +|---|---:|---:| +| Complete ADDs | 11,949 | 11,946 | +| D ADDs | 5,729 | 5,726 | +| Native records | 14,878 | 14,875 | +| Helper preparation ADDs | 199 | 200 | +| D injection ADDs | 4,719 | 4,714 | +| Forward positive maximum F | 70,083 | 70,355 | +| Reverse positive maximum B | 10,548,832 | 10,548,832 | +| Local payload bits | 101 | 101 | +| Nine-stage prefix bits | 192 | 192 | + +All 439 helper registers, nine COPY/ERASE pairs, per-register frame paths, +paid rank histogram and rank mass 5,129 are unchanged. The selected PR942 +conditional kappa remains `1661960547713947/1000000000000000000`. + +## Reproduce + +Run from the repository root with Python 3.11 or later. The finite replay +uses the standard library and source-pinned repository checkers. + +```sh +rtk proxy python3.11 -I -B research/r439-helper-quartets-seed07/verify.py +``` + +The output is JSON with `status = PASS_R439_HELPER_QUARTETS`, +`combinations = 1290240`, `columns = 661`, `native_ADDs = 11946`, +`saved_ADDs = 3` and `no_new_kappa = true`. Eleven negative controls must +be rejected, and an endpoint-neutral pair must be accepted and charged +two ADDs. Optimized isolated Python produces the same receipt. + +To print the complete deterministic census separately: + +```sh +rtk proxy python3.11 -I -B research/r439-helper-quartets-seed07/search.py +``` + +It must reproduce `CERTIFICATE.json` as parsed JSON, including census hash +`34cd212d94a5caeea01fbf774b62155a99778bb9b9dfacce738d48d2d8e06cfc`. + +The optional native replay requires a C++17 compiler and Boost headers. +Use a fresh output directory; all generated files stay there. + +```sh +rtk proxy env BOOST_INCLUDE=/path/to/boost CXX=c++ python3.11 -I -B \ + research/r439-helper-quartets-seed07/native.py /tmp/r439-quartets-native +``` + +Expected output: + +```text +PASS_R439_HELPER_QUARTETS_NATIVE ADDs=11949->11946 columns=883/1327/1549 controls=96/96 no_new_kappa +``` + +`NATIVE-RECEIPT.json` records the completed Apple clang 21 / Boost 1.85.0 +replay and all 186 non-system compiler dependency hashes. The runner saves +the exact commands, generated candidate, reports and logs in its output +directory. Toolchain versions and dependency hashes describe this run; +other supported environments should reproduce the mathematical fields, +not the environment strings. Linux CI success is not asserted. + +## The exact change and its cost + +Use local helper labels `a=269`, `b=88`, `c=288`, `d=153`, with zero-based +indices among the 439 helpers. They are pairs 114 and 126 of the frozen +PR941 `selected_pairs`. Originally the two preparations are `a ^= b` and +`c ^= d`. The replacement is the chronological word + +```text +a ^= b +c ^= d +b ^= c +``` + +Its matrix has rows `[3,14,12,8]` in the ordered basis `[a,b,c,d]`. +The second operation changes `c` before the third reads it. Restore with +the literal reverse word after the D injection and target restoration. +The other 197 helper pairs and the 306 target shears stay fixed. + +Let K be the original D coefficient matrix, E the frozen PR915 target +basis and H the complete helper basis. Prepare H on arbitrary helper data +and E on arbitrary targets, inject `M = E K H^-1`, then restore E and H. +The endpoint is exactly + +```text +(x,y,s) -> (x,y + K s,s) +``` + +over F2, including arbitrary initial helper dirt and target values. Indeed, +the prepared target is `E y`; injection gives `E y + M H s`, and restoring +E gives `y + E^-1 M H s = y + K s`. Helper restoration returns s. Sources +are never destinations. This is an F2 endpoint identity, not equality of +the corresponding integer transfer matrices. + +Write A,B,C,D for the four columns of E K. The old injection uses +`[A, A+B, C, C+D]`. The replacement uses `[A, A+B, A+B+C, C+D]`. +Their column weights are `[9,11,13,15]` and `[9,11,8,15]`, respectively. +The injection saves five ADDs; the extra preparation and restoration cost +two. The complete invoice is + +```text +200 + 306 + 4714 + 306 + 200 = 5726 D ADDs +5726 + 6220 = 11946 complete ADDs +``` + +The forward positive maximum increases, so a local norm-domination +argument would be false. Whole-word chronological replay, including +COPY/ERASE and both orientations, gives F=70,355 and B=10,548,832. The +strict inherited checks are + +```text +64 F^3 B^2 = 2480125329327922327549632512000 < 2^104 +2^18 F^5 B^4 = 5595414477252957880107217850693663956755891575010099200000 < 2^192 +``` + +The second expression occupies about 89.14% of its cap. This checks the +existing nine-stage prefix expression only; it is not a new global invoice. + +## Completed search and exact boundary + +The OS assignment draw was 7. The local claim was recorded within the first +eight minutes of the cycle. From all `choose(199,2)=19,701` pair unions, +take the first 64 under ascending SHA256 of the ASCII string `7:i:j`. +No random restarts, additional nominees or combinations of winners follow. + +For each quartet, enumerate all **20,160** invertible four-by-four matrices +over F2. Breadth-first search over the 12 lexicographically ordered XOR +generators supplies one shortest helper word per matrix. Complete prices +include both helper passes, the fixed target passes, the changed injection +and all 6,220 outside-D ADDs. Ties use the matrix tuple. Each quartet's +cheapest representative receives a complete positive-bound replay. + +The 1,290,240 prices yield 62 unchanged minima, one 11,948-ADD minimum and +one 11,946-ADD minimum. All 64 representatives pass the precision checks. +The chosen quartet is therefore optimal in this declared union of 64 +single-quartet classes, including arbitrary-length XOR preparation words +on those four helpers. It is also optimal for its own quartet. It is not +an optimum over all 19,701 quartets, different frozen matchings, several +simultaneous fusions, added registers, changed target bases or full circuits. + +The independent check enumerates the group directly by Gaussian elimination, +replays every realizing word and checks every generator edge inequality for +its proposed distance. An identity distance of zero and the inequalities +prove the lower distance bound along every path; realizing words prove the +upper bound. Set-valued column operations and independently inverted matrices +then reproduce every price and the census hash. This is an exact finite +certificate, not a failed search interpreted as an impossibility theorem. + +The predecessor's separate 96,141-edge integer vertex/odd-set dual is also +replayed. Its complete all-disjoint-pair floor is 11,948. The connected +four-helper word lies outside its hypothesis, so the new 11,946 count is +consistent with that result. + +## Verification and remaining obligations + +The Python replay checks the full 661-input D boundary in both directions, +the complete word's source/frame checker, all outside-D fields and exact +literal costs. Controls omit each quartet operation in each pass, reorder +dependent preparations, change a frame, alter an outside-D operation, +undercharge the invoice and test an endpoint-valid precision overflow. +The native replay checks 883, 1,327 and 1,549 formal columns at 5, 9 and 11 +stages for each of the two words, rejecting all 96 omitted-bridge controls. +It independently agrees on cost, bounds, paid ranks and copy lifetimes. + +Like PR915/926/941, this word intentionally fails the original syntactic +`H2_D_frame0_targets_from_helpers` and literal `K_equals_D` predicates. +Those checks are not weakened. The semantic endpoint above and its exact +column replay replace that premise for this finite result; H1/H3/H4/H5 and +the other owning-checker conclusions still pass. + +Publication checks also rejected four external package corruptions: a false +complete cost, an altered quartet operation, a duplicate JSON field and a +changed source digest. The 25 existing selected-record tests and nine finite +bit-contract tests pass. No new test framework or repository-wide artifacts +were added. + +Supplier adoption still requires acceptance of the semantic D interface, +changed whole-hosted emission and audit, complete finite/precision invoices +and outer assembly against the selected complex supplier. All-size/compiler, +common-label/mutable-source realization, whole-call hosting, tape and analytic +assumptions remain. No complete multiplication theorem, formal proof-assistant +check, supplier cold replay, repository-wide test run or human peer review is +claimed. The selected frontier and `upstream/` are unchanged. + +## Sources and credit + +Exact research base: `2921874911956718fcaaaf9396fe8267b3cfa9f0`. +`SOURCES.json` binds 43 repository files plus the predecessor's checked +manifest closure. It records the selected context separately; replay does +not consume the moving selected pointer. + +Credit Gareth Davidson / @bitplane for PR915's target basis, PR926's +two-sided helper construction and PR941's matching and exact pair bound. +PR941 head: `8af78333709a2eafd84463a7dc91467be5618b49`. Its native and +owning-checker routines are reused with attribution. Scott Woolsey Biggart's +PR733 is the two-sided mechanism predecessor. Ross Richardson's PR965 +`6292e3774abd82f2d5202190b498f35cc1628c39` supplies the GL(3,2) search +pattern adapted here to two-pair GL(4,2) fusion. PR967's independently +selected stars and PR978's historical R420 sharing are adjacent work. + +The selected R439 word is eumemic's PR555 on PR543, with DreamingOfClouds' +PR545 punctured unit and PR589 tuning. Preserve their earlier E8, frame, +hosting and source attributions in the checked dependency manifests. The +selected T37 construction and review are read for context and are not changed. + +Prepared by **Sagar Thakrar / @thakrarsagar**, with substantial **OpenAI Codex +assistance** in mathematics, search, implementation, verification and writing. +All new files are under the repository's **Apache-2.0** license. This is an +independent computation using reused source checkers, not independent human +peer review. No priority or best-known-circuit claim is made. diff --git a/research/r439-helper-quartets-seed07/SOURCES.json b/research/r439-helper-quartets-seed07/SOURCES.json new file mode 100644 index 0000000000..0463d9aea2 --- /dev/null +++ b/research/r439-helper-quartets-seed07/SOURCES.json @@ -0,0 +1,53 @@ +{ + "base_commit": "2921874911956718fcaaaf9396fe8267b3cfa9f0", + "files": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "docs/research/community-batch952-review.md": "04db59dfc2c31453229b6061bbf59547e71ce3abdc0ce0f6779144bb0dde127b", + "research/e8-bit-carrier-skeleton/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "research/e8-bit-carrier-skeleton/NOTICE.md": "5f4b7fcbf99f572be28b6da612ce775363908cdfc7810f7aca167be01c86e49a", + "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2", + "research/e8-bit-carrier-skeleton/code/bit/checkers/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "research/e8-bit-carrier-skeleton/code/bit/checkers/legality_h.cpp": "6c1ef2b24e57781d6951c172a1024fc4300e6fd392c9d6672079a7806ab663b3", + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-carrier-skeleton/code/bit/regression/stage_cohort.py": "6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a", + "research/e8-bit-carrier-skeleton/portable-include/bits/stdc++.h": "420094be2af295eed03a983dd66debbbe9cfb78d8252859f4498a615a0074b99", + "research/e8-bit-p111-tuned/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "research/e8-bit-p111-tuned/NOTICE.md": "5b88eb2b7de76aa2a3288ee3c7a08d18a5eadfa82f5e7a99e207d232aed71221", + "research/e8-bit-p111-tuned/code/xcheck_p.py": "af3decc877e27c00001cf56f50c6c09566e8e101297ab34c7860aed96a06d80e", + "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "research/r439-helper-matching/CERTIFICATE.json": "48657afe5e80eaefb3823be354a3c56d1509b4f35bed833a52b27778e5058cda", + "research/r439-helper-matching/NOMINATION.json": "d35aaec98a3bf0f65036e5a3ecbd89d115699d06df329d320e5b4d1cae9923c5", + "research/r439-helper-matching/PROOF.md": "85e7b10264aa30d2f6fb9490527d492fe7988ad63db33e0f89bfce79b056c6ae", + "research/r439-helper-matching/README.md": "59e06613a2b5a809de9cedc3530ffba556664acaa073b36fa7c71027b804ce8d", + "research/r439-helper-matching/SOURCES.json": "d954b361e3115546ea35091c93b3ea1be13d8cc34259277998d82b555adea1d1", + "research/r439-helper-matching/candidate.json.gz": "60531408445a1d7c793dff6821e767739012db1d2646f49aec7fdf7fe0b979f3", + "research/r439-helper-matching/common.py": "885d19538d04ae22387ead8e0445a0bd0d36af30c0bb4e38e439b04e535ff190", + "research/r439-helper-matching/floor-word.json.gz": "4be50c06f91bc605660d4f9fba865c330f82dc4c364041870b725c220d16244e", + "research/r439-helper-matching/vendor/pr817/README.md": "0f0ac2a905e30958d033c415304db9412947f7c6b30669b4f1d488aaddeb1c57", + "research/r439-helper-matching/vendor/pr915/CERTIFICATE.json": "a9958d9a933b57dcb9f7e5cf8e9694c0762f055a1cdab9f8ab42b2c6561fc4d7", + "research/r439-helper-matching/vendor/pr915/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "research/r439-helper-matching/vendor/pr915/NOTICE.md": "efbb1d2b2c85cbdbb7b048e2b7405e0654dfa40ddf6a1e94f11df313bdedb638", + "research/r439-helper-matching/vendor/pr915/PROOF.md": "ddb5c3affbef52fa37af13b291bf089ca16f9dfe976e5a5590188b128b262425", + "research/r439-helper-matching/vendor/pr915/README.md": "0c606598a6366bc0e6840d853c28237f8e5fe5866d89765d79815f973224f1fd", + "research/r439-helper-matching/vendor/pr915/candidate.json.gz": "ac30266144f8772ec8cd629153993aa9eb692fe745a9f95015a1b7fa88977a2e", + "research/r439-helper-matching/vendor/pr926/CERTIFICATE.json": "3abb601be609f117361e17ce5ada5477d4493ee6aec9070c749089ec923e1848", + "research/r439-helper-matching/vendor/pr926/EXPECTED.json": "17c580fbbd7a5e52f978d5ede778e8f34acf4a8cfb1e1eb3209bfaab3c8e7e9c", + "research/r439-helper-matching/vendor/pr926/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "research/r439-helper-matching/vendor/pr926/NOTICE.md": "9b5f63f17823a04b48c3e8065b4e32fe8ce1e861117cec11bd8c6f1376800d12", + "research/r439-helper-matching/vendor/pr926/PROOF.md": "c664aca1a79e55efac4af1160008f9d5377b0ef4be8dba2630512f7be6baafd7", + "research/r439-helper-matching/vendor/pr926/README.md": "88ae71c23df68050e036fdec201f356c5e0ffc10e4da3b561b04b0aa99464c7c", + "research/r439-helper-matching/vendor/pr926/SOURCES.json": "6334cb185db0568919f5fcce85edaad1ceec1ffaf3e4ac08e6e9e819a8017eb1", + "research/r439-helper-matching/vendor/pr926/candidate.json.gz": "6ac771545e823c054e005429c405dbb2c01ff80fce181b714e1af5e28b6b7cb2", + "research/r439-helper-matching/verify.py": "8d8adc25f0a59685fc72d9c62ab7e60f327eaf313d96a0c4d8d0bac88af00bdc", + "research/r439-helper-stars-seed19/README.md": "3f5ef64ed85b0e49c5751156c2bfce00643f039562aff102fbe82bc934c48f60", + "research/r439-helper-triples/README.md": "c84d5000554bcc8b59379702439be31394d3b80785b64f375022688f936d02b6", + "research/r439-helper-triples/search.py": "6fbe9125690bd899423e4676b972a5783b376ae70536e9f09a97960c77236864" + }, + "selected_context": { + "kappa": "1661960547713947/1000000000000000000", + "role": "context only; no moving selected pointer consumed at replay", + "selected_record_sha256": "1d35283cb0ce3f8db1f285683933517f9e87475d295e2b6316399ad9928c81c3" + } +} diff --git a/research/r439-helper-quartets-seed07/VERIFY-RECEIPT.json b/research/r439-helper-quartets-seed07/VERIFY-RECEIPT.json new file mode 100644 index 0000000000..671397ada3 --- /dev/null +++ b/research/r439-helper-quartets-seed07/VERIFY-RECEIPT.json @@ -0,0 +1,559 @@ +{ + "bill": { + "B": 10548832, + "D_adds": 5726, + "F": 70355, + "native_ADDs": 11946, + "nine_stage_prefix_bits": 192, + "payload_bits": 101 + }, + "candidate_sha256": "77868e11715b8c7714f0aa67256694ca44f1540e761c090f34897af97b8c525e", + "columns": 661, + "combinations": 1290240, + "controls": { + "neutral_pair_charged": 2, + "rejected": [ + "quartet-0-pass-0-omitted", + "quartet-0-pass-1-omitted", + "quartet-1-pass-0-omitted", + "quartet-1-pass-1-omitted", + "quartet-2-pass-0-omitted", + "quartet-2-pass-1-omitted", + "dependent-preparations-reordered", + "illegal-D-frame", + "outside-D-change", + "undercharged-complete-word", + "endpoint-valid-nine-stage-overflow" + ] + }, + "native_ADDs": 11946, + "no_new_kappa": true, + "pair_floor": { + "census_sha256": "0246432b2dc71203907d75f0ae6d9520a2a24a1c5326a1e57c6616dd8c21c07a", + "complete_ADD_floor": 11948, + "doubled_objective": 2520, + "exact_maximum_saving": 1260, + "largest_odd_set": 7, + "odd_sets": 19, + "oriented_pair_scores": 192282, + "positive_edges": 1885, + "tight_edges": 347, + "unordered_pairs": 96141, + "vertex_prices": 439 + }, + "saved_ADDs": 3, + "source_checks": { + "baseline": { + "labels": { + "frames": 636, + "gram_det": 1, + "labels": 111, + "lattice_rank": 8, + "punctured": 9, + "root_lines": 120 + }, + "full": { + "columns": 661, + "gates": { + "A": 2075, + "B": 712, + "C": 2574, + "D": 111 + }, + "scatter_terms": 527, + "totals": [ + { + "frame": 510, + "hyperplane_of_punctured_line": [ + 0, + 1, + 1, + 0, + -1, + 0, + 0, + 1 + ], + "rank": 7, + "register": 472 + }, + { + "frame": 511, + "hyperplane_of_punctured_line": [ + 0, + 1, + -1, + 0, + -1, + 0, + 0, + -1 + ], + "rank": 7, + "register": 473 + }, + { + "frame": 512, + "hyperplane_of_punctured_line": [ + 0, + 1, + 1, + 0, + 0, + -1, + -1, + 0 + ], + "rank": 7, + "register": 474 + }, + { + "frame": 513, + "hyperplane_of_punctured_line": [ + 0, + 1, + -1, + 0, + 0, + 1, + -1, + 0 + ], + "rank": 7, + "register": 475 + }, + { + "frame": 514, + "hyperplane_of_punctured_line": [ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + "rank": 7, + "register": 476 + }, + { + "frame": 515, + "hyperplane_of_punctured_line": [ + 1, + 1, + -1, + 1, + 0, + 0, + 0, + 0 + ], + "rank": 7, + "register": 477 + }, + { + "frame": 516, + "hyperplane_of_punctured_line": [ + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1 + ], + "rank": 7, + "register": 478 + }, + { + "frame": 517, + "hyperplane_of_punctured_line": [ + 0, + 0, + 1, + 1, + 0, + 0, + 1, + -1 + ], + "rank": 7, + "register": 479 + }, + { + "frame": 518, + "hyperplane_of_punctured_line": [ + 0, + 1, + 0, + -1, + 0, + -1, + 0, + -1 + ], + "rank": 7, + "register": 480 + } + ] + }, + "hypotheses": { + "H1_no_target_feeds_z": true, + "H2_D_frame0_targets_from_helpers": true, + "H3_A_z_only_scatter_targets_B_split": true, + "H4_C_literal_reverse_at_full": true, + "H5_V_identity": true + }, + "conclusions": { + "C_is_U_inverse": true, + "J_identity": true, + "K_equals_D": true, + "U_block_form": true + } + }, + "candidate": { + "labels": { + "frames": 636, + "gram_det": 1, + "labels": 111, + "lattice_rank": 8, + "punctured": 9, + "root_lines": 120 + }, + "full": { + "columns": 661, + "gates": { + "A": 2075, + "B": 712, + "C": 2574, + "D": 1123 + }, + "scatter_terms": 527, + "totals": [ + { + "frame": 510, + "hyperplane_of_punctured_line": [ + 0, + 1, + 1, + 0, + -1, + 0, + 0, + 1 + ], + "rank": 7, + "register": 472 + }, + { + "frame": 511, + "hyperplane_of_punctured_line": [ + 0, + 1, + -1, + 0, + -1, + 0, + 0, + -1 + ], + "rank": 7, + "register": 473 + }, + { + "frame": 512, + "hyperplane_of_punctured_line": [ + 0, + 1, + 1, + 0, + 0, + -1, + -1, + 0 + ], + "rank": 7, + "register": 474 + }, + { + "frame": 513, + "hyperplane_of_punctured_line": [ + 0, + 1, + -1, + 0, + 0, + 1, + -1, + 0 + ], + "rank": 7, + "register": 475 + }, + { + "frame": 514, + "hyperplane_of_punctured_line": [ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + "rank": 7, + "register": 476 + }, + { + "frame": 515, + "hyperplane_of_punctured_line": [ + 1, + 1, + -1, + 1, + 0, + 0, + 0, + 0 + ], + "rank": 7, + "register": 477 + }, + { + "frame": 516, + "hyperplane_of_punctured_line": [ + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1 + ], + "rank": 7, + "register": 478 + }, + { + "frame": 517, + "hyperplane_of_punctured_line": [ + 0, + 0, + 1, + 1, + 0, + 0, + 1, + -1 + ], + "rank": 7, + "register": 479 + }, + { + "frame": 518, + "hyperplane_of_punctured_line": [ + 0, + 1, + 0, + -1, + 0, + -1, + 0, + -1 + ], + "rank": 7, + "register": 480 + } + ] + }, + "hypotheses": { + "H1_no_target_feeds_z": true, + "H2_D_frame0_targets_from_helpers": false, + "H3_A_z_only_scatter_targets_B_split": true, + "H4_C_literal_reverse_at_full": true, + "H5_V_identity": true + }, + "conclusions": { + "C_is_U_inverse": true, + "J_identity": true, + "K_equals_D": false, + "U_block_form": true + } + }, + "previous": { + "labels": { + "frames": 636, + "gram_det": 1, + "labels": 111, + "lattice_rank": 8, + "punctured": 9, + "root_lines": 120 + }, + "full": { + "columns": 661, + "gates": { + "A": 2075, + "B": 712, + "C": 2574, + "D": 1121 + }, + "scatter_terms": 527, + "totals": [ + { + "frame": 510, + "hyperplane_of_punctured_line": [ + 0, + 1, + 1, + 0, + -1, + 0, + 0, + 1 + ], + "rank": 7, + "register": 472 + }, + { + "frame": 511, + "hyperplane_of_punctured_line": [ + 0, + 1, + -1, + 0, + -1, + 0, + 0, + -1 + ], + "rank": 7, + "register": 473 + }, + { + "frame": 512, + "hyperplane_of_punctured_line": [ + 0, + 1, + 1, + 0, + 0, + -1, + -1, + 0 + ], + "rank": 7, + "register": 474 + }, + { + "frame": 513, + "hyperplane_of_punctured_line": [ + 0, + 1, + -1, + 0, + 0, + 1, + -1, + 0 + ], + "rank": 7, + "register": 475 + }, + { + "frame": 514, + "hyperplane_of_punctured_line": [ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + "rank": 7, + "register": 476 + }, + { + "frame": 515, + "hyperplane_of_punctured_line": [ + 1, + 1, + -1, + 1, + 0, + 0, + 0, + 0 + ], + "rank": 7, + "register": 477 + }, + { + "frame": 516, + "hyperplane_of_punctured_line": [ + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1 + ], + "rank": 7, + "register": 478 + }, + { + "frame": 517, + "hyperplane_of_punctured_line": [ + 0, + 0, + 1, + 1, + 0, + 0, + 1, + -1 + ], + "rank": 7, + "register": 479 + }, + { + "frame": 518, + "hyperplane_of_punctured_line": [ + 0, + 1, + 0, + -1, + 0, + -1, + 0, + -1 + ], + "rank": 7, + "register": 480 + } + ] + }, + "hypotheses": { + "H1_no_target_feeds_z": true, + "H2_D_frame0_targets_from_helpers": false, + "H3_A_z_only_scatter_targets_B_split": true, + "H4_C_literal_reverse_at_full": true, + "H5_V_identity": true + }, + "conclusions": { + "C_is_U_inverse": true, + "J_identity": true, + "K_equals_D": false, + "U_block_form": true + } + } + }, + "source_pins": 43, + "status": "PASS_R439_HELPER_QUARTETS" +} diff --git a/research/r439-helper-quartets-seed07/native.py b/research/r439-helper-quartets-seed07/native.py new file mode 100644 index 0000000000..c003154f73 --- /dev/null +++ b/research/r439-helper-quartets-seed07/native.py @@ -0,0 +1,141 @@ +#!/usr/bin/env python3 +"""Unchanged native legality and 5/9/11-stage checks of the quartet word. + +Adapted from Gareth Davidson's PR941 harness, itself adapted from Sagar +Thakrar's r420-decoder-sharing/native.py. Substantial OpenAI Codex assistance; +Apache-2.0. +Usage: BOOST_INCLUDE=/path/to/boost python3 native.py NEW_OUTPUT_DIRECTORY +""" +import hashlib +import json +import os +from pathlib import Path +import runpy +import shlex +import struct +import subprocess +import sys + +HERE = Path(__file__).resolve().parent +Q = runpy.run_path(str(HERE / "verify.py")) +S, V, C, need = Q["S"], Q["V"], Q["C"], Q["need"] + + +def run(output): + Q["source_pins"]() + output = Path(output).resolve() + output.mkdir(parents=True, exist_ok=False) + original, parent, previous, target, pairs, columns = S["inputs"]() + winner = C["load"](HERE / "CERTIFICATE.json")["winner"] + operations = S["helper_operations"](pairs, winner["indices"], winner["word"]) + candidate = S["construct"](parent, target, columns, operations) + V["check_bill"](candidate, winner["bill"]) + need(C["digest"](candidate) == "77868e11715b8c7714f0aa67256694ca44f1540e761c090f34897af97b8c525e", + "candidate canonical digest") + candidate_path = output / "candidate.json" + C["write"](candidate_path, candidate) + hub = S["ROOT"] / C["HUB"] + checker = hub / "code/bit/checkers" + boost = Path(os.environ.get("BOOST_INCLUDE", "/usr/include")).resolve() + compiler = shlex.split(os.environ.get("CXX", "c++")) + options = compiler + ["-O2", "-std=c++17", "-DHDIM=8", "-DNCOPY=9", + "-I" + str(hub / "portable-include"), "-I" + str(checker), "-I" + str(boost)] + commands = [] + + def execute(args, log): + args = [str(x) for x in args] + commands.append(args) + with log.open("x") as stream: + result = subprocess.run(args, stdout=stream, stderr=subprocess.STDOUT) + if result.returncode: + raise RuntimeError(log.read_text()[-4000:]) + + builds = [("legality", "legality_h.cpp", [])] + [ + ("columns-" + str(k), "columns_k.cpp", ["-DVPORTS=111", "-DRHELP=439", "-DKPAIRS=" + str(k)]) + for k in (2, 4, 5)] + for name, source, flags in builds: + execute(options + flags + ["-MMD", "-MF", output / (name + ".d"), + "-o", output / name, checker / source], output / (name + "-build.log")) + result, nonadd = {}, {} + python = [sys.executable, "-I", "-B"] + for label, path, word in (("previous", S["PRE"] / "candidate.json.gz", previous), + ("candidate", candidate_path, candidate)): + folder = output / label + folder.mkdir() + records, cin, cout = (folder / name for name in ("records", "cin", "cout")) + execute(python + [hub / "code/bit/export_records.py", path, records], folder / "export.log") + execute(python + [hub / "code/bit/regression/stage_cohort.py", records, records, cin, cout], + folder / "stage.log") + execute([output / "legality", cin, cout, cout / "legality.json"], folder / "legality.log") + legality = C["load"](cout / "legality.json") + need(legality["status"] == "PASS_INDEPENDENT_COHORT_LEGALITY_SOURCE_OWNERS_AND_LIFECYCLE", + "native legality status") + rows = list(struct.iter_unpack("<6i", (records / "249-records.bin").read_bytes())) + moves = {} + for row in rows: + if row[0] == 0: + moves.setdefault(row[1], []).append(row) + nonadd[label] = dict(moves=moves, copy_erase=[row for row in rows if row[0] in (2, 3)]) + bill = V["bill"](word) + need(legality["common_frame_ADDs"] == bill["native_ADDs"], "native ADD cost") + need(legality["copies"] == legality["erasures"] == 9, "native copy lifecycle") + staged = {} + for k in (2, 4, 5): + name = "columns-" + str(k) + execute([output / name, cout / "COHORT249-RECORDS.bin", cout / (name + ".json")], + folder / (name + ".log")) + check = C["load"](cout / (name + ".json")) + status = ("PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" if k == 2 else + "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL") + need(check["status"] == status, "native column status") + need(check["formal_columns_checked"] == 2 * k * 111 + 439, "formal column coverage") + need(len(check["stages"]) == 2 * k + 1, "stage coverage") + need(check["bridge_additions"] == 6 * (k - 1) * 111, "bridge cost") + need(check["fresh_center_copies"] == 9 * (2 * k + 1), "stage copy cost") + need(check["payload_prefix_bits"] <= 104, "local payload cap") + controls = check["negative_controls"] + need(len(controls) == 6 * (k - 1) and all(c["rejected"] for c in controls), "bridge controls") + bounds = [int(c["cancellation_free_signed_row_l1_upper"]) for c in check["signed_lift_prefix"]] + need(bounds == [bill["F"], bill["B"]], "native positive bounds") + V["guards"](*bounds) + need(check["local_scalar_additions"] == bill["native_ADDs"], "staged ADD cost") + staged[str(2 * k + 1)] = {key: check[key] for key in + ("formal_columns_checked", "bridge_additions", "fresh_center_copies", + "payload_prefix_bits", "payload_prefix_upper", "local_raw_H")} + staged[str(2 * k + 1)]["controls_rejected"] = len(controls) + result[label] = {key: legality[key] for key in + ("records", "common_frame_ADDs", "rank_mass", "paid_histogram", "copies", "erasures")} + result[label].update(staged=staged, bill=bill, canonical_sha256=C["digest"](word)) + Q["same"](nonadd["previous"], nonadd["candidate"], "register paths or COPY/ERASE changed") + before, after = result["previous"], result["candidate"] + need(before["records"] - after["records"] == 3, "native record delta") + for key in ("rank_mass", "paid_histogram", "copies", "erasures"): + Q["same"](before[key], after[key], "paid resource change: " + key) + for stage in ("5", "9", "11"): + Q["same"](before["staged"][stage]["local_raw_H"], after["staged"][stage]["local_raw_H"], + "local raw rank change") + dependencies = {} + for name, _, _ in builds: + text = (output / (name + ".d")).read_text().replace("\\\n", " ") + for entry in shlex.split(text.split(": ", 1)[1]): + path = Path(entry).resolve() + if path.is_relative_to(boost): + key = str(path.relative_to(boost)) + elif path.is_relative_to(S["ROOT"]): + key = str(path.relative_to(S["ROOT"])) + else: + key = str(path) + dependencies[key] = hashlib.sha256(path.read_bytes()).hexdigest() + receipt = dict(status="PASS_R439_HELPER_QUARTETS_NATIVE", words=result, + python=sys.version, compiler=subprocess.check_output(compiler + ["--version"], text=True), + dependencies=dict(sorted(dependencies.items()))) + C["write"](output / "commands.json", commands) + C["write"](output / "native-report.json", receipt) + return receipt + + +if __name__ == "__main__": + if len(sys.argv) != 2: + raise SystemExit(__doc__) + receipt = run(sys.argv[1]) + print(receipt["status"], "ADDs=11949->11946 columns=883/1327/1549 controls=96/96 no_new_kappa") diff --git a/research/r439-helper-quartets-seed07/search.py b/research/r439-helper-quartets-seed07/search.py new file mode 100644 index 0000000000..aed70ebbf1 --- /dev/null +++ b/research/r439-helper-quartets-seed07/search.py @@ -0,0 +1,145 @@ +#!/usr/bin/env python3 +"""One bounded GL(4,2) fusion search around the frozen PR941 R439 word. + +Sagar Thakrar, with substantial OpenAI Codex assistance. Apache-2.0. +Uses Gareth Davidson's PR915/926/941 target basis, matching and exact bills. +The group-search mechanism follows Ross Richardson's PR965 GL(3,2) work. +""" +from collections import Counter, deque +import copy +import hashlib +import itertools +import json +from pathlib import Path +import runpy + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +PRE = ROOT / "research/r439-helper-matching" +V = runpy.run_path(str(PRE / "verify.py")) +C = V["C"] +need = C["need"] + + +def inputs(): + original = C["load"](ROOT / C["WORD"]) + parent = C["load"](PRE / "vendor/pr915/candidate.json.gz") + previous = C["load"](PRE / "candidate.json.gz") + rows, _, target = V["frozen_parent"](original, parent) + pairs = C["load"](PRE / "NOMINATION.json")["selected_pairs"] + V["validate_pairs"](pairs, parent["R"]) + need(len(pairs) == 199 and len(target) == 306, "frozen dimensions") + need(V["reconstruct"](parent, rows, target, pairs)[0] == previous, + "PR941 reconstruction") + columns = [sum(1 << i for i, row in enumerate(rows) if j in row) + for j in range(parent["R"])] + return original, parent, previous, target, pairs, columns + + +def group(): + generators = [(d, s) for d in range(4) for s in range(4) if d != s] + words = {(1, 2, 4, 8): ()} + queue = deque(words) + while queue: + matrix = queue.popleft() + for d, s in generators: + nxt = list(matrix) + nxt[d] ^= nxt[s] + nxt = tuple(nxt) + if nxt not in words: + words[nxt] = words[matrix] + ((d, s),) + queue.append(nxt) + need(len(words) == 20160, "GL(4,2) order") + return words + + +def inverse_columns(word): + masks = [1, 2, 4, 8] + for d, s in word: + masks[s] ^= masks[d] + return masks + + +def quartets(pairs): + return sorted(itertools.combinations(range(len(pairs)), 2), key=lambda ij: + hashlib.sha256(f"7:{ij[0]}:{ij[1]}".encode()).digest())[:64] + + +def helper_operations(pairs, indices, word): + first, second = indices + labels = pairs[first] + pairs[second] + operations = [] + for i, pair in enumerate(pairs): + if i == first: + operations.extend((labels[d], labels[s]) for d, s in word) + elif i != second: + operations.append(tuple(pair)) + return operations + + +def construct(parent, target, columns, operations): + transformed = list(columns) + for d, s in operations: + transformed[s] ^= transformed[d] + v = parent["v"] + helpers = [[0, 2 * v + d, [2 * v + s]] for d, s in operations] + middle = [[0, v + i, [2 * v + j for j, col in enumerate(transformed) + if col >> i & 1]] for i in range(v)] + need(all(g[2] for g in middle), "empty middle row") + result = copy.deepcopy(parent) + result["D"] = helpers + target + middle + target[::-1] + helpers[::-1] + return result + + +def admitted(bill): + return (64 * bill["F"] ** 3 * bill["B"] ** 2 < 1 << 104 and + (1 << 18) * bill["F"] ** 5 * bill["B"] ** 4 < 1 << 192) + + +def search(): + original, parent, previous, target, pairs, columns = inputs() + words = group() + basis = [(matrix, word, inverse_columns(word)) + for matrix, word in sorted(words.items())] + baseline = V["bill"](previous) + need(baseline["native_ADDs"] == 11949 and admitted(baseline), "baseline bill") + frozen = list(columns) + for d, s in pairs: + frozen[s] ^= frozen[d] + census, accepted, scan_hash = [], [], hashlib.sha256() + for indices in quartets(pairs): + labels = pairs[indices[0]] + pairs[indices[1]] + combinations = [0] * 16 + for mask in range(1, 16): + low = mask & -mask + combinations[mask] = combinations[mask ^ low] ^ columns[labels[low.bit_length() - 1]] + weights = [x.bit_count() for x in combinations] + frozen_weight = sum(frozen[j].bit_count() for j in labels) + constant = baseline["native_ADDs"] - 4 - frozen_weight + best = None + for matrix, word, masks in basis: + price = constant + 2 * len(word) + sum(weights[m] for m in masks) + scan_hash.update(bytes(indices) + bytes(matrix) + price.to_bytes(4, "big")) + item = (price, matrix, word) + if best is None or item < best: + best = item + price, matrix, word = best + candidate = construct(parent, target, columns, helper_operations(pairs, indices, word)) + bill = V["bill"](candidate) + need(price == bill["native_ADDs"], "optimistic and complete price agree") + entry = dict(indices=list(indices), helpers=labels, matrix=list(matrix), + word=[list(op) for op in word], bill=bill, admitted=admitted(bill)) + census.append(entry) + if admitted(bill) and price < baseline["native_ADDs"]: + accepted.append(entry) + winner = min(accepted, key=lambda x: (x["bill"]["native_ADDs"], x["bill"]["F"], + x["bill"]["B"], x["indices"])) if accepted else None + return dict(format="r439-helper-quartets/1", seed=7, quartet_count=64, + group_order=len(words), combinations=64 * len(words), + distance_histogram=dict(sorted(Counter(map(len, words.values())).items())), + census_sha256=scan_hash.hexdigest(), baseline=baseline, + census=census, admitted_improvements=len(accepted), winner=winner) + + +if __name__ == "__main__": + print(json.dumps(search(), indent=2, sort_keys=True)) diff --git a/research/r439-helper-quartets-seed07/verify.py b/research/r439-helper-quartets-seed07/verify.py new file mode 100644 index 0000000000..2631a5e7db --- /dev/null +++ b/research/r439-helper-quartets-seed07/verify.py @@ -0,0 +1,175 @@ +#!/usr/bin/env python3 +"""Exact bounded census, independent matrix pricing and whole-word replay. + +Sagar Thakrar, with substantial OpenAI Codex assistance. Apache-2.0. +Finite checks only; the inherited supplier assumptions remain open. +""" +import copy +import hashlib +import itertools +import json +from pathlib import Path +import runpy + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +S = runpy.run_path(str(HERE / "search.py")) +V, C, need = S["V"], S["C"], S["need"] + + +def same(actual, expected, message): + need(C["canonical"](actual) == C["canonical"](expected), message) + + +def source_pins(): + manifest = C["load"](HERE / "SOURCES.json") + for path, expected in manifest["files"].items(): + need(hashlib.sha256((ROOT / path).read_bytes()).hexdigest() == expected, + "source pin: " + path) + C["pins"](ROOT) + return len(manifest["files"]) + + +def inverse(matrix): + rows = [[(matrix[i] >> j) & 1 for j in range(4)] + [int(i == j) for j in range(4)] + for i in range(4)] + for j in range(4): + pivot = next((i for i in range(j, 4) if rows[i][j]), None) + if pivot is None: + return None + rows[j], rows[pivot] = rows[pivot], rows[j] + for i in range(4): + if i != j and rows[i][j]: + rows[i] = [a ^ b for a, b in zip(rows[i], rows[j])] + return [sum(rows[i][4 + j] << i for i in range(4)) for j in range(4)] + + +def independent_census(certificate, pairs, columns): + words = S["group"]() + inverses = {m: inv for m in itertools.product(range(1, 16), repeat=4) + if (inv := inverse(m)) is not None} + need(set(inverses) == set(words) and len(inverses) == 20160, "direct GL(4,2) domain") + for matrix, word in words.items(): + current = [1, 2, 4, 8] + for d, s in word: + current[d] ^= current[s] + same(current, matrix, "shortest-word endpoint") + for d, s in itertools.permutations(range(4), 2): + neighbor = list(matrix) + neighbor[d] ^= neighbor[s] + need(len(words[tuple(neighbor)]) <= len(word) + 1, "shortest-distance edge inequality") + need(words[(1, 2, 4, 8)] == (), "identity distance") + sets = [{i for i in range(111) if col >> i & 1} for col in columns] + frozen = [set(col) for col in sets] + for d, s in pairs: + frozen[s].symmetric_difference_update(frozen[d]) + candidates = list(itertools.combinations(range(199), 2)) + candidates.sort(key=lambda ij: hashlib.sha256(("7:%d:%d" % ij).encode()).digest()) + same([e["indices"] for e in certificate["census"]], candidates[:64], "quartet selection") + digest = hashlib.sha256() + for entry, indices in zip(certificate["census"], candidates[:64]): + labels = pairs[indices[0]] + pairs[indices[1]] + weights = [] + for mask in range(16): + value = set() + for j in range(4): + if mask >> j & 1: + value.symmetric_difference_update(sets[labels[j]]) + weights.append(len(value)) + constant = 11949 - 4 - sum(len(frozen[j]) for j in labels) + best = None + for matrix, masks in sorted(inverses.items()): + price = constant + 2 * len(words[matrix]) + sum(weights[m] for m in masks) + digest.update(bytes(indices) + bytes(matrix) + price.to_bytes(4, "big")) + choice = (price, matrix) + best = choice if best is None or choice < best else best + same(best, (entry["bill"]["native_ADDs"], entry["matrix"]), "independent minimum") + same(digest.hexdigest(), certificate["census_sha256"], "independent complete census") + + +def controls(original, candidate, reference): + rejected = [] + + def reject(label, action): + try: + action() + except ValueError: + rejected.append(label) + else: + raise ValueError("control accepted: " + label) + + def endpoint(word): + need(V["boundary_columns"](word) == reference, "D boundary mismatch") + + # These are the three connected quartet operations, not unrelated pairs. + winner = C["load"](HERE / "CERTIFICATE.json")["winner"] + helpers = winner["helpers"] + v = candidate["v"] + for index, (d, s) in enumerate(winner["word"]): + operation = [0, 2 * v + helpers[d], [2 * v + helpers[s]]] + positions = [i for i, op in enumerate(candidate["D"]) if op == operation] + need(len(positions) == 2, "quartet prepare/restore multiplicity") + for side, position in enumerate(positions): + mutant = copy.deepcopy(candidate) + del mutant["D"][position] + reject(f"quartet-{index}-pass-{side}-omitted", lambda m=mutant: endpoint(m)) + mutant = copy.deepcopy(candidate) + first = next(i for i, g in enumerate(mutant["D"]) + if g == [0, 2 * v + helpers[1], [2 * v + helpers[2]]]) + mutant["D"][first], mutant["D"][first - 1] = mutant["D"][first - 1], mutant["D"][first] + reject("dependent-preparations-reordered", lambda: endpoint(mutant)) + mutant = copy.deepcopy(candidate) + mutant["D"][0][0] = 1 + reject("illegal-D-frame", lambda: V["d_atoms"](mutant)) + mutant = copy.deepcopy(candidate) + mutant["A"][0][1] += 1 + reject("outside-D-change", lambda: V["outside_d"](original, mutant)) + bill = V["bill"](candidate) + wrong = dict(bill, native_ADDs=bill["native_ADDs"] - 1) + reject("undercharged-complete-word", lambda: V["check_bill"](candidate, wrong)) + floor = C["load"](S["PRE"] / "floor-word.json.gz") + endpoint(floor) + rejected_bill = V["bill"](floor) + reject("endpoint-valid-nine-stage-overflow", + lambda: V["guards"](rejected_bill["F"], rejected_bill["B"])) + neutral = copy.deepcopy(candidate) + op = [0, 2 * v, [2 * v + 1]] + neutral["D"] = [op, op] + neutral["D"] + endpoint(neutral) + need(V["bill"](neutral)["native_ADDs"] == bill["native_ADDs"] + 2, + "neutral pair must cost two ADDs") + return dict(rejected=rejected, neutral_pair_charged=2) + + +def verify(): + pins = source_pins() + certificate = C["load"](HERE / "CERTIFICATE.json") + same(S["search"](), certificate, "complete search regeneration") + original, parent, previous, target, pairs, columns = S["inputs"]() + independent_census(certificate, pairs, columns) + nomination = C["load"](S["PRE"] / "NOMINATION.json") + column_sets = [{i for i in range(111) if col >> i & 1} for col in columns] + pair_floor = V["dual_check"](column_sets, nomination["primary_dual"], + nomination["nominations"][0]["pairs"]) + winner = certificate["winner"] + need(winner is not None, "admitted improvement required") + operations = S["helper_operations"](pairs, winner["indices"], winner["word"]) + candidate = S["construct"](parent, target, columns, operations) + V["check_bill"](candidate, winner["bill"]) + V["guards"](winner["bill"]["F"], winner["bill"]["B"]) + reference = V["boundary_columns"](original) + for word in (previous, candidate): + V["outside_d"](original, word) + for reverse in (False, True): + need(V["boundary_columns"](word, reverse) == reference, "all 661 D columns") + negative = controls(original, candidate, reference) + source = V["source_checks"](ROOT, dict(baseline=original, previous=previous, candidate=candidate)) + return dict(status="PASS_R439_HELPER_QUARTETS", source_pins=pins, + combinations=certificate["combinations"], columns=661, + native_ADDs=winner["bill"]["native_ADDs"], saved_ADDs=3, + candidate_sha256=C["digest"](candidate), bill=winner["bill"], + controls=negative, source_checks=source, pair_floor=pair_floor, no_new_kappa=True) + + +if __name__ == "__main__": + print(json.dumps(verify(), indent=2, sort_keys=True))