diff --git a/research/complex-coded-helper-global-screen/CODED-CELL.json b/research/complex-coded-helper-global-screen/CODED-CELL.json new file mode 100644 index 0000000000..035020fc43 --- /dev/null +++ b/research/complex-coded-helper-global-screen/CODED-CELL.json @@ -0,0 +1,65 @@ +{ + "selected": [[6, 7], 1], + "core": [ + ["h0", "x4", 1], + ["y1", "x3", 1], + ["y2", "x5", 1], + ["y3", "x0", 1], + ["y4", "x2", 1], + ["y5", "x1", 1], + ["h0", "x2", 1], + ["y0", "y1", 1], + ["y2", "x1", 1], + ["y5", "y3", 1], + ["y0", "x4", 1], + ["y3", "y2", 1], + ["y5", "x3", 1], + ["y0", "x2", 1], + ["y1", "x4", 1], + ["y2", "x3", 1], + ["y4", "y3", 1], + ["y0", "x5", 1], + ["y1", "x0", 1], + ["y3", "h0", 1], + ["y4", "x3", 1], + ["y5", "x4", 1], + ["y0", "x1", 1], + ["y1", "x2", 1], + ["y2", "x0", 1], + ["y1", "x5", 1], + ["y2", "x4", 1], + ["y5", "x2", 1] + ], + "direct": [ + ["y5", "x3", 1], + ["y2", "x1", 1], + ["y3", "x2", 1], + ["y1", "x0", 1], + ["y4", "x5", 1], + ["y4", "x3", 1], + ["y5", "x2", 1], + ["y4", "x2", 1], + ["y0", "x4", 1], + ["y2", "x0", 1], + ["y0", "x5", 1], + ["y3", "x1", 1], + ["y1", "x4", 1], + ["y2", "x4", 1], + ["y3", "x0", 1], + ["y3", "x4", 1], + ["y1", "x5", 1], + ["y2", "x5", 1], + ["y0", "x3", 1], + ["y1", "x3", 1], + ["y2", "x3", 1], + ["y3", "x5", 1], + ["y0", "x2", 1], + ["y1", "x2", 1], + ["y5", "x1", 1], + ["y5", "x0", 1], + ["y5", "x4", 1], + ["y4", "x1", 1], + ["y4", "x0", 1], + ["y0", "x1", 1] + ] +} diff --git a/research/complex-coded-helper-global-screen/CONSTRUCTION-RECORD.json b/research/complex-coded-helper-global-screen/CONSTRUCTION-RECORD.json new file mode 100644 index 0000000000..30229920dd --- /dev/null +++ b/research/complex-coded-helper-global-screen/CONSTRUCTION-RECORD.json @@ -0,0 +1,2244 @@ +{ + "negative-ck": { + "coded_cell": { + "bindings": { + "h0": 448, + "x0": 18, + "x1": 269, + "x2": 82, + "x3": 429, + "x4": 50, + "x5": 445, + "y0": 130, + "y1": 134, + "y2": 194, + "y3": 198, + "y4": 162, + "y5": 166 + }, + "core_gate_indexes": [ + 673, + 674, + 675, + 676, + 677, + 678, + 679, + 680, + 681, + 682, + 683, + 684, + 685, + 686, + 687, + 688, + 689, + 690, + 691, + 692, + 693, + 694, + 695, + 696, + 697, + 698, + 699, + 700 + ], + "pair": [ + 6, + 7 + ], + "section": "B", + "sign": -1 + }, + "cold_end_transfer": { + "end_lifts": [], + "sections": { + "A": { + "introduced": 438 + }, + "cleanup": { + "dropped_by_stage": 2854, + "introduced": 8414, + "kept_own": 2 + } + }, + "skipped_removed_early_gates": [], + "tail_lifts": [] + }, + "entry_correction": { + "gates": [ + [ + "add", + 166, + 701, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 166, + 702, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 166, + 703, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 166, + 705, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 701, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 702, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 703, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 705, + -1, + 2, + [ + 6 + ] + ] + ], + "output_content_sha256": "75fe3c219f0ea014b826b42ea604f1674b7049d2a17e5b0d7d8122c1e645322a", + "profile": { + "1": 2432, + "2": 399, + "3": 469, + "4": 168, + "5": 56, + "6": 44, + "8": 8 + } + }, + "final_frame_raises": { + "changes": [ + { + "after": [ + 272, + 49, + 6 + ], + "before": [ + 49, + 6 + ], + "delta": { + "1": -2, + "2": 1 + }, + "index": 680, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 128, + 64, + 33, + 17, + 8, + 6 + ], + "before": [ + 256, + 128, + 81, + 33, + 8, + 6 + ], + "delta": { + "1": -2, + "2": 2, + "3": -2, + "4": 1 + }, + "index": 692, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 257, + 128, + 64, + 33, + 16, + 8, + 6 + ], + "before": [ + 321, + 128, + 33, + 16, + 8, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 693, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 128, + 64, + 32, + 16, + 6, + 1 + ], + "before": [ + 256, + 128, + 65, + 33, + 16, + 6 + ], + "delta": { + "1": -2, + "2": 2, + "3": -2, + "4": 1 + }, + "index": 695, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 272, + 144, + 80, + 48, + 8, + 6, + 1 + ], + "before": [ + 272, + 144, + 81, + 49, + 8, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 698, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 129, + 64, + 33, + 16, + 8, + 6 + ], + "before": [ + 256, + 193, + 33, + 16, + 8, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 700, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 273, + 128, + 64, + 33, + 8, + 6 + ], + "before": [ + 337, + 128, + 33, + 8, + 6 + ], + "delta": { + "1": 1, + "2": -1, + "3": -1, + "4": 1 + }, + "index": 689, + "section": "B", + "sweep": 1 + }, + { + "after": [ + 272, + 144, + 80, + 48, + 6, + 1 + ], + "before": [ + 272, + 144, + 81, + 49, + 6 + ], + "delta": { + "1": 1, + "2": -1, + "3": -1, + "4": 1 + }, + "index": 690, + "section": "B", + "sweep": 1 + } + ], + "domain": "coded 28 gates; one-vector extensions and maximal common-next frame; 12 sweeps maximum", + "sweeps": 3 + }, + "native_word_content_sha256": "a6b394127bb81f23a2ca7d187c1e4642b369840a82b7627f7872fc772942a5a0", + "stages": { + "coded-ck-cold": "2530fc4639227c9b225f2541715f22925877598c6ecce2656eb28f6d98a27c0a", + "coded-ck-hpe": "d0e8c7168163622b42f65c1315ec3556f24a1a56f4545686031513a9ceffa066", + "coded-ck-optimized": "a6b394127bb81f23a2ca7d187c1e4642b369840a82b7627f7872fc772942a5a0", + "coded-ck-regroup": "cbb2f5b778f13bf2667c6d013cae7e160ca739a3c3579db2e401257b68f6a00f", + "coded-ck-step1": "fa69d7482ecc2b2a4022af1f196534bb76ee09baaaa67665a836db1a7290c169", + "coded-ck-step2": "4ae3933ce2a3644800b0e62d08f1527d91ad56449de77053c633750565b4fcef", + "coded-ck-step3": "c759bf7d8791f245307a4af1b533d4ba20ad6c45e24040f34a09f8e46c1bf0ef", + "coded-ck-step4": "cb8707223f286cbb22f065a21c7b31c1d7c267d36f782d2f0e26b139fdda1efa" + } + }, + "negative-jp8": { + "coded_cell": { + "bindings": { + "h0": 448, + "x0": 18, + "x1": 269, + "x2": 82, + "x3": 429, + "x4": 50, + "x5": 445, + "y0": 130, + "y1": 134, + "y2": 194, + "y3": 198, + "y4": 162, + "y5": 166 + }, + "core_gate_indexes": [ + 673, + 674, + 675, + 676, + 677, + 678, + 679, + 680, + 681, + 682, + 683, + 684, + 685, + 686, + 687, + 688, + 689, + 690, + 691, + 692, + 693, + 694, + 695, + 696, + 697, + 698, + 699, + 700 + ], + "pair": [ + 6, + 7 + ], + "section": "B", + "sign": -1 + }, + "cold_end_transfer": { + "end_lifts": [], + "sections": { + "A": { + "introduced": 438 + }, + "cleanup": { + "dropped_by_stage": 2819, + "introduced": 9112, + "kept_own": 2 + } + }, + "skipped_removed_early_gates": [], + "tail_lifts": [] + }, + "entry_correction": { + "gates": [ + [ + "add", + 166, + 701, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 166, + 702, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 166, + 703, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 166, + 705, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 701, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 702, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 703, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 705, + -1, + 2, + [ + 6 + ] + ] + ], + "output_content_sha256": "75fe3c219f0ea014b826b42ea604f1674b7049d2a17e5b0d7d8122c1e645322a", + "profile": { + "1": 2432, + "2": 399, + "3": 469, + "4": 168, + "5": 56, + "6": 44, + "8": 8 + } + }, + "final_frame_raises": { + "changes": [ + { + "after": [ + 272, + 49, + 6 + ], + "before": [ + 49, + 6 + ], + "delta": { + "1": -2, + "2": 1 + }, + "index": 680, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 128, + 64, + 33, + 17, + 8, + 6 + ], + "before": [ + 256, + 128, + 81, + 33, + 8, + 6 + ], + "delta": { + "1": -2, + "2": 2, + "3": -2, + "4": 1 + }, + "index": 692, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 257, + 128, + 64, + 33, + 16, + 8, + 6 + ], + "before": [ + 321, + 128, + 33, + 16, + 8, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 693, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 128, + 64, + 32, + 16, + 6, + 1 + ], + "before": [ + 256, + 128, + 65, + 33, + 16, + 6 + ], + "delta": { + "1": -2, + "2": 2, + "3": -2, + "4": 1 + }, + "index": 695, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 272, + 144, + 80, + 48, + 8, + 6, + 1 + ], + "before": [ + 272, + 144, + 81, + 49, + 8, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 698, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 129, + 64, + 33, + 16, + 8, + 6 + ], + "before": [ + 256, + 193, + 33, + 16, + 8, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 700, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 273, + 128, + 64, + 33, + 8, + 6 + ], + "before": [ + 337, + 128, + 33, + 8, + 6 + ], + "delta": { + "1": 1, + "2": -1, + "3": -1, + "4": 1 + }, + "index": 689, + "section": "B", + "sweep": 1 + }, + { + "after": [ + 272, + 144, + 80, + 48, + 6, + 1 + ], + "before": [ + 272, + 144, + 81, + 49, + 6 + ], + "delta": { + "1": 1, + "2": -1, + "3": -1, + "4": 1 + }, + "index": 690, + "section": "B", + "sweep": 1 + } + ], + "domain": "coded 28 gates; one-vector extensions and maximal common-next frame; 12 sweeps maximum", + "sweeps": 3 + }, + "native_word_content_sha256": "d7eb38ba90374b914df7751d09d5b2d9e9bd5f898766cab24824d6f51d71705e", + "stages": { + "coded-jp8-cold": "0587a8edaf4a741bb2226d8c2c8c40790a71438f7a84ead7ded82a5e35cd97aa", + "coded-jp8-hpe": "4f4f28d3bf9209bb2dc4098249fc42f96ac7bcc5d4517213aab3c5f7854f8baf", + "coded-jp8-optimized": "d7eb38ba90374b914df7751d09d5b2d9e9bd5f898766cab24824d6f51d71705e", + "coded-jp8-regroup": "bfb6c4f03115df85b66e4061d469b90137124fb2b23013626ce543d411974188", + "coded-jp8-step1": "e18bd7a56bc0429bee9019a6e663205906d2bc107ee421f2614fa28c7bfa5ac8", + "coded-jp8-step2": "fea6989e0aa616fb46c007d61f79a51c56e87f6392b2dcbc828ed363b0b4ec6b", + "coded-jp8-step3": "ce871911ea4bdd2d47062d0a31fdca14f765ca88829a04fd33e56c5cd236ea8f" + } + }, + "positive-ck": { + "coded_cell": { + "bindings": { + "h0": 448, + "x0": 271, + "x1": 19, + "x2": 431, + "x3": 83, + "x4": 447, + "x5": 51, + "y0": 135, + "y1": 131, + "y2": 199, + "y3": 195, + "y4": 167, + "y5": 163 + }, + "core_gate_indexes": [ + 691, + 692, + 693, + 694, + 695, + 696, + 697, + 698, + 699, + 700, + 701, + 702, + 703, + 704, + 705, + 706, + 707, + 708, + 709, + 710, + 711, + 712, + 713, + 714, + 715, + 716, + 717, + 718 + ], + "pair": [ + 6, + 7 + ], + "section": "B", + "sign": 1 + }, + "cold_end_transfer": { + "end_lifts": [ + { + "helper": 266, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ] + }, + { + "helper": 426, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ] + }, + { + "helper": 442, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ] + } + ], + "sections": { + "A": { + "introduced": 438 + }, + "cleanup": { + "dropped_by_stage": 2848, + "introduced": 8411, + "kept_own": 2 + } + }, + "skipped_removed_early_gates": [ + 13, + 25, + 33 + ], + "tail_lifts": [ + { + "cleanup_index": 40, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ], + "registers": [ + 266, + 19 + ] + }, + { + "cleanup_index": 41, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ], + "registers": [ + 20, + 266 + ] + }, + { + "cleanup_index": 42, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ], + "registers": [ + 23, + 266 + ] + }, + { + "cleanup_index": 104, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ], + "registers": [ + 426, + 83 + ] + }, + { + "cleanup_index": 105, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ], + "registers": [ + 84, + 426 + ] + }, + { + "cleanup_index": 106, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ], + "registers": [ + 87, + 426 + ] + }, + { + "cleanup_index": 108, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ], + "registers": [ + 442, + 51 + ] + }, + { + "cleanup_index": 109, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ], + "registers": [ + 52, + 442 + ] + }, + { + "cleanup_index": 110, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ], + "registers": [ + 55, + 442 + ] + } + ] + }, + "entry_correction": { + "gates": [ + [ + "add", + 163, + 698, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 163, + 699, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 163, + 700, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 163, + 702, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 698, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 699, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 700, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 702, + -1, + 2, + [ + 6 + ] + ] + ], + "output_content_sha256": "04030e0840696cae8456e7e859c4a9b7feb8a8d5679ee22d1fcf0d950bd9b47e", + "profile": { + "1": 2462, + "2": 393, + "3": 469, + "4": 162, + "5": 56, + "6": 41, + "8": 8 + } + }, + "final_frame_raises": { + "changes": [ + { + "after": [ + 313, + 73, + 6 + ], + "before": [ + 73, + 6 + ], + "delta": { + "1": -2, + "2": 1 + }, + "index": 698, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 128, + 65, + 32, + 16, + 9, + 6 + ], + "before": [ + 256, + 128, + 65, + 41, + 16, + 6 + ], + "delta": { + "1": -2, + "2": 2, + "3": -2, + "4": 1 + }, + "index": 710, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 129, + 64, + 33, + 17, + 9, + 6 + ], + "before": [ + 256, + 136, + 73, + 33, + 24, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 718, + "section": "B", + "sweep": 0 + } + ], + "domain": "coded 28 gates; one-vector extensions and maximal common-next frame; 12 sweeps maximum", + "sweeps": 2 + }, + "full_frame_cleanup_correction": { + "gates": [ + [ + "add", + 265, + 16, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 265, + 19, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 271, + 16, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 271, + 19, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 425, + 80, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 425, + 83, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 431, + 80, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 431, + 83, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 441, + 48, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 441, + 51, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 447, + 48, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 447, + 51, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + ], + "profile_unchanged": true + }, + "native_word_content_sha256": "ffb6918e397bbc026fe7ad1914bb94e316cd6eacd1d2d249ccd7acf10749b1b2", + "stages": { + "coded-ck-cold": "24628271aaad4cc71190039afeaaa226eabd276305fea3b7af9f7d17e3bfe07d", + "coded-ck-cold-repaired": "bb2b0b9a8152d8a68da304b275309d3ec6414b68603948ff31f283aadb66a4f2", + "coded-ck-hpe": "37a99e8e096edcc0e13fcf2f573adb654307efe495f3a40d4db048f4ad8c5d37", + "coded-ck-optimized": "ffb6918e397bbc026fe7ad1914bb94e316cd6eacd1d2d249ccd7acf10749b1b2", + "coded-ck-regroup": "692e7f0c804546903533fbfd97a44209c07703819fb4aeb2c9c00529935b7af5", + "coded-ck-step1": "de5b3e1637b2b7b1060d7230e1710b3d9a77b004ec7822059b870618d20d716a", + "coded-ck-step2": "9ce84451a37a24dd5942ad66f6debc6e65c19738beaca8caac79a548b7ff7be4", + "coded-ck-step3": "e5f40f9e6f614537364ad8136a87f618776300f503d9ebe81db4839088f20a4d", + "coded-ck-step4": "589191f13caecedb4712288e168083800ad281d290287ce0785ecb0a18063c27" + } + }, + "positive-jp8": { + "coded_cell": { + "bindings": { + "h0": 448, + "x0": 271, + "x1": 19, + "x2": 431, + "x3": 83, + "x4": 447, + "x5": 51, + "y0": 135, + "y1": 131, + "y2": 199, + "y3": 195, + "y4": 167, + "y5": 163 + }, + "core_gate_indexes": [ + 691, + 692, + 693, + 694, + 695, + 696, + 697, + 698, + 699, + 700, + 701, + 702, + 703, + 704, + 705, + 706, + 707, + 708, + 709, + 710, + 711, + 712, + 713, + 714, + 715, + 716, + 717, + 718 + ], + "pair": [ + 6, + 7 + ], + "section": "B", + "sign": 1 + }, + "cold_end_transfer": { + "end_lifts": [ + { + "helper": 266, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ] + }, + { + "helper": 426, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ] + }, + { + "helper": 442, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ] + } + ], + "sections": { + "A": { + "introduced": 438 + }, + "cleanup": { + "dropped_by_stage": 2813, + "introduced": 9109, + "kept_own": 2 + } + }, + "skipped_removed_early_gates": [ + 13, + 25, + 33 + ], + "tail_lifts": [ + { + "cleanup_index": 40, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ], + "registers": [ + 266, + 19 + ] + }, + { + "cleanup_index": 41, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ], + "registers": [ + 20, + 266 + ] + }, + { + "cleanup_index": 42, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ], + "registers": [ + 23, + 266 + ] + }, + { + "cleanup_index": 104, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ], + "registers": [ + 426, + 83 + ] + }, + { + "cleanup_index": 105, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ], + "registers": [ + 84, + 426 + ] + }, + { + "cleanup_index": 106, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ], + "registers": [ + 87, + 426 + ] + }, + { + "cleanup_index": 108, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ], + "registers": [ + 442, + 51 + ] + }, + { + "cleanup_index": 109, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ], + "registers": [ + 52, + 442 + ] + }, + { + "cleanup_index": 110, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ], + "registers": [ + 55, + 442 + ] + } + ] + }, + "entry_correction": { + "gates": [ + [ + "add", + 163, + 698, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 163, + 699, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 163, + 700, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 163, + 702, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 698, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 699, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 700, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 702, + -1, + 2, + [ + 6 + ] + ] + ], + "output_content_sha256": "04030e0840696cae8456e7e859c4a9b7feb8a8d5679ee22d1fcf0d950bd9b47e", + "profile": { + "1": 2462, + "2": 393, + "3": 469, + "4": 162, + "5": 56, + "6": 41, + "8": 8 + } + }, + "final_frame_raises": { + "changes": [ + { + "after": [ + 313, + 73, + 6 + ], + "before": [ + 73, + 6 + ], + "delta": { + "1": -2, + "2": 1 + }, + "index": 698, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 128, + 65, + 32, + 16, + 9, + 6 + ], + "before": [ + 256, + 128, + 65, + 41, + 16, + 6 + ], + "delta": { + "1": -2, + "2": 2, + "3": -2, + "4": 1 + }, + "index": 710, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 129, + 64, + 33, + 17, + 9, + 6 + ], + "before": [ + 256, + 136, + 73, + 33, + 24, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 718, + "section": "B", + "sweep": 0 + } + ], + "domain": "coded 28 gates; one-vector extensions and maximal common-next frame; 12 sweeps maximum", + "sweeps": 2 + }, + "full_frame_cleanup_correction": { + "gates": [ + [ + "add", + 265, + 16, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 265, + 19, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 271, + 16, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 271, + 19, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 425, + 80, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 425, + 83, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 431, + 80, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 431, + 83, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 441, + 48, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 441, + 51, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 447, + 48, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 447, + 51, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + ], + "profile_unchanged": true + }, + "native_word_content_sha256": "8e31803f503ab2b416da2af15dd73cad1b04f33966a24b747c017bc1bfcf9934", + "stages": { + "coded-jp8-cold": "dec82b535e3bbeb4ec1ee5a26e054d83128ab815118957c8b26922177002fb4e", + "coded-jp8-cold-repaired": "fd818edcaa3495792ad79ed3159d58cf02a9cadb5e3a861d31c5a607331d490d", + "coded-jp8-hpe": "03b967e3083dac7138e58b8f04d3ad718c6ccb7dbb951ac16a716616f3ed0bc2", + "coded-jp8-optimized": "8e31803f503ab2b416da2af15dd73cad1b04f33966a24b747c017bc1bfcf9934", + "coded-jp8-regroup": "a30bbf02942ad4aa693906b95ca4ae61f5ad44c1441ab6bf0bbffec94fa5a7eb", + "coded-jp8-step1": "3dc0da9a659f50d7fb013133d94cac0d33ade9aa29a0769f299a01202377689b", + "coded-jp8-step2": "103a78c6efd8aa35cf053f0e9e5860a6425f52a9d9ea079ec77d823fafa8b15b", + "coded-jp8-step3": "54d0a10139a8bdcce2782556240f3142d28980c76ff6e68ef9f298894807a9f1" + } + } +} diff --git a/research/complex-coded-helper-global-screen/EXACT-CERTIFICATE.json b/research/complex-coded-helper-global-screen/EXACT-CERTIFICATE.json new file mode 100644 index 0000000000..03f096f8ce --- /dev/null +++ b/research/complex-coded-helper-global-screen/EXACT-CERTIFICATE.json @@ -0,0 +1,53 @@ +{ + "endpoint": "65528268492323474503/40000000000000000000000", + "patterns": 1163, + "potential_inequalities": 43031, + "mixtures": 2700, + "lambda_units_1e30": -8201202857049542392398000000, + "potential_scale": 10000000000000000, + "potentials": [ + 0, + 59314550434746, + 110079993958731, + 114380123947523, + 152189992929679, + 187269223567683, + 220011422170366, + 197583711618153, + 224836536228789, + 250606299201797, + 216161779387053, + 238154318824237, + 259060528545513, + 278948503635277, + 233891283181203, + 251059231609609, + 267413081740366, + 215818354149567, + 229949367277736, + 243402254426580, + 256204198988314, + 197941726943317, + 257256277378063, + 219365556786168, + 156607164321207, + 215921714755953, + 247475360831639, + 181711617906737, + 189131951630801, + 196100574414541, + 126718938715260, + 132403287270727, + 137681176104011, + 196995726538757, + 69161038378985, + 128475588813731, + 179241032337716 + ], + "minimum_margin_units_1e30": 23249063103322040520087343552, + "minimum_at": { + "positive": 0, + "negative": 1 + }, + "minimum_margin_greater_than": "23249063103/1000000000000" +} diff --git a/research/complex-coded-helper-global-screen/NATIVE-EXPECTED.json b/research/complex-coded-helper-global-screen/NATIVE-EXPECTED.json new file mode 100644 index 0000000000..8a989fcb11 --- /dev/null +++ b/research/complex-coded-helper-global-screen/NATIVE-EXPECTED.json @@ -0,0 +1,2434 @@ +{ + "negative-ck": { + "canonical_content_sha256": "2a29ef51b8deee2911faeb96334dab62c16de09d645497444314098447b29835", + "center_rank_sum": 64, + "cold_hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442 + ], + "compensation_additions": 8548, + "directed_edges": 3096, + "early_cleanup_gates": 120, + "frames": 1114, + "helpers": 493, + "hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 468, + 469, + 478, + 491, + 492, + 515, + 516, + 539, + 540, + 563, + 564, + 575, + 584, + 585, + 594, + 595, + 596, + 597, + 598, + 599, + 600, + 601, + 602, + 603, + 604 + ], + "input_content_sha256": "a6b394127bb81f23a2ca7d187c1e4642b369840a82b7627f7872fc772942a5a0", + "live_columns_each_orientation": 717, + "local_profile": { + "1": 2589, + "2": 549, + "3": 306, + "4": 164, + "5": 70, + "6": 8, + "8": 8 + }, + "local_rank_mass": 5723, + "refactored_cleanup": { + "provider": "ck", + "source": "k492 cold-end recipe transfer; independently audited" + }, + "refactored_cleanup_gates": 8431, + "routing_content_sha256": "7c84ac65c8b37173aa4293934f041915895e8ec30595844cc1534e2a19ae0d25", + "scalar_operations": 21762, + "scope": "Fresh exact forward and inverse-transpose scalar replay on every arbitrary input; all native frame chains and dyadic primitives. Phase lowering, wrappers, global owners and global assembly are separate.", + "status": "PASS_CHANGED_WORD_ALL_COLUMNS_AND_NATIVE_FRAMES", + "target_port_order_matches_baseline": true, + "tau": 43, + "widths": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 8, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 9, + 8, + 9, + 8, + 8, + 9, + 8, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5 + ] + }, + "negative-jp8": { + "canonical_content_sha256": "7fa93ce7be03fa80580d097aa56f206391ee3dad759ee0edc288da5e00a676e7", + "center_rank_sum": 64, + "cold_hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442 + ], + "compensation_additions": 8644, + "directed_edges": 3007, + "early_cleanup_gates": 120, + "frames": 1033, + "helpers": 493, + "hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 468, + 469, + 478, + 491, + 492, + 515, + 516, + 539, + 540, + 563, + 564, + 575, + 584, + 585, + 594, + 595, + 596, + 597, + 598, + 599, + 600, + 601, + 602, + 603, + 604 + ], + "input_content_sha256": "d7eb38ba90374b914df7751d09d5b2d9e9bd5f898766cab24824d6f51d71705e", + "live_columns_each_orientation": 717, + "local_profile": { + "1": 2505, + "2": 397, + "3": 450, + "4": 164, + "5": 70, + "6": 8, + "8": 8 + }, + "local_rank_mass": 5767, + "refactored_cleanup": { + "provider": "jp8", + "source": "k492 cold-end recipe transfer; independently audited" + }, + "refactored_cleanup_gates": 9128, + "routing_content_sha256": "7c84ac65c8b37173aa4293934f041915895e8ec30595844cc1534e2a19ae0d25", + "scalar_operations": 22519, + "scope": "Fresh exact forward and inverse-transpose scalar replay on every arbitrary input; all native frame chains and dyadic primitives. Phase lowering, wrappers, global owners and global assembly are separate.", + "status": "PASS_CHANGED_WORD_ALL_COLUMNS_AND_NATIVE_FRAMES", + "target_port_order_matches_baseline": true, + "tau": 43, + "widths": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 7, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5 + ] + }, + "positive-ck": { + "canonical_content_sha256": "fdffede0b46600550a12658de89963e5586a7eb37ed1463c10a091242bb04880", + "center_rank_sum": 64, + "cold_hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442 + ], + "compensation_additions": 8554, + "directed_edges": 3121, + "early_cleanup_gates": 117, + "frames": 1127, + "helpers": 490, + "hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 468, + 469, + 490, + 491, + 514, + 515, + 538, + 539, + 562, + 563, + 574, + 583, + 584, + 593, + 594, + 595, + 596, + 597, + 598, + 599, + 600, + 601 + ], + "input_content_sha256": "ffb6918e397bbc026fe7ad1914bb94e316cd6eacd1d2d249ccd7acf10749b1b2", + "live_columns_each_orientation": 714, + "local_profile": { + "1": 2598, + "2": 570, + "3": 312, + "4": 155, + "5": 61, + "6": 8, + "8": 8 + }, + "local_rank_mass": 5711, + "refactored_cleanup": { + "provider": "ck", + "source": "k492 cold-end recipe transfer; independently audited" + }, + "refactored_cleanup_gates": 8440, + "routing_content_sha256": "7c84ac65c8b37173aa4293934f041915895e8ec30595844cc1534e2a19ae0d25", + "scalar_operations": 21777, + "scope": "Fresh exact forward and inverse-transpose scalar replay on every arbitrary input; all native frame chains and dyadic primitives. Phase lowering, wrappers, global owners and global assembly are separate.", + "status": "PASS_CHANGED_WORD_ALL_COLUMNS_AND_NATIVE_FRAMES", + "target_port_order_matches_baseline": true, + "tau": 43, + "widths": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 8, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 9, + 8, + 9, + 8, + 8, + 9, + 8, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5 + ] + }, + "positive-jp8": { + "canonical_content_sha256": "f5c8b7a673b429d4caf99b9e6c48de6a398fbe37fe422b2495f51b3eb0229781", + "center_rank_sum": 64, + "cold_hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442 + ], + "compensation_additions": 8650, + "directed_edges": 3032, + "early_cleanup_gates": 117, + "frames": 1046, + "helpers": 490, + "hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 468, + 469, + 490, + 491, + 514, + 515, + 538, + 539, + 562, + 563, + 574, + 583, + 584, + 593, + 594, + 595, + 596, + 597, + 598, + 599, + 600, + 601 + ], + "input_content_sha256": "8e31803f503ab2b416da2af15dd73cad1b04f33966a24b747c017bc1bfcf9934", + "live_columns_each_orientation": 714, + "local_profile": { + "1": 2514, + "2": 418, + "3": 456, + "4": 155, + "5": 61, + "6": 8, + "8": 8 + }, + "local_rank_mass": 5755, + "refactored_cleanup": { + "provider": "jp8", + "source": "k492 cold-end recipe transfer; independently audited" + }, + "refactored_cleanup_gates": 9137, + "routing_content_sha256": "7c84ac65c8b37173aa4293934f041915895e8ec30595844cc1534e2a19ae0d25", + "scalar_operations": 22534, + "scope": "Fresh exact forward and inverse-transpose scalar replay on every arbitrary input; all native frame chains and dyadic primitives. Phase lowering, wrappers, global owners and global assembly are separate.", + "status": "PASS_CHANGED_WORD_ALL_COLUMNS_AND_NATIVE_FRAMES", + "target_port_order_matches_baseline": true, + "tau": 43, + "widths": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 7, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5 + ] + } +} diff --git a/research/complex-coded-helper-global-screen/NOTICE.md b/research/complex-coded-helper-global-screen/NOTICE.md new file mode 100644 index 0000000000..ddfeacd04e --- /dev/null +++ b/research/complex-coded-helper-global-screen/NOTICE.md @@ -0,0 +1,39 @@ +# Attribution and license + +Prepared by NeoKazuya with OpenAI Codex assistance, using +GPT-6-Astra. New code, certificates and text are contributed under the +repository's Apache-2.0 license. + +The coded core and initial positive-cell experiment are from our +[PR781](https://github.com/CrocSwap/integer-mult-bounds/pull/781), pinned at +`85f9cfad7708cc3873bd6b32492a618feb336e59`. The native words extend existing +community constructions; no authorship of those inherited constructions is +claimed. + +- icekylinx's PR531 packet factory and PR425/433 supplier/auditor lineage. +- Jeremy Kothe and AtomScout's PR622 K-triangle construction; Port480's stage + transfer; GlobalR, AtomReviewer, Stack492 and ColdBeyond's accompanying + helper-count, owner and cold-end work; the PR623 dispatch lineage. +- Chafik Boukhalfa/chafreaky's PR626 owner repair and portable verification, + and PR583's frame coalescing used in the inherited provider chain. +- DreamingOfClouds' PR604 cold-end construction and PR484 exact scalar audit, + with their earlier hyperplane-end and native-audit sources. +- The PR552 phase-baseline routing word and Round19's 112-port transport. + +The unchanged native auditor and budget sources are read in place. Their exact +input hashes are in `SOURCE-PINS.json`. The inherited provider package's +[NOTICE.md](../complex-k492-owner-repair/NOTICE.md), its vendor notices and +licenses remain applicable and are retained in the repository. The full prior +attribution chain is preserved there, including the PR568/569/571/575/586 and +PR591/592/593/599/601 work. + +Chafik Boukhalfa's PR795 and Charles Bethin's PR850 are related exact +owner-profile results for the SW4 inventory. Rohan Guliani's PR815 is related +frame-search work on fixed scalar programs. These comparisons do not supply +code or proof inputs to this verifier. The original research request's scope +comparison also included Sreekanth Nair/higherbeing's PR651 and Douglas +Colkitt's PR683 through PR781. + +All inherited conditional assumptions remain conditional. Native circuit replay +and the finite packing exclusion are not formal verification of the full +multiplication theorem. diff --git a/research/complex-coded-helper-global-screen/README.md b/research/complex-coded-helper-global-screen/README.md new file mode 100644 index 0000000000..2f5b78a40e --- /dev/null +++ b/research/complex-coded-helper-global-screen/README.md @@ -0,0 +1,223 @@ +# Two coded-helper embeddings: exact global packing obstruction + +**Status: scoped negative result. No new exponent or selected-bound change.** + +The one-helper packet construction in [PR781](https://github.com/CrocSwap/integer-mult-bounds/pull/781) +survives integration into two historical native provider chains. Its complete +helper bill defeats the local saving. This package retains four explicit native +circuits and proves that every nonempty mixture of these circuits with the +original providers exceeds PR626's complex moment budget, even after removing +the scheduling and physical-family restrictions from the owner problem. + +The claim concerns these four circuits and the stated whole-helper hosting +model. It does not rule out other coded circuits, frame assignments, helper +sharing contracts, dispatches or geometries. PR626 is the historical comparison; +the selected result at this package's base commit is PR799. + +## Reproduce + +From the repository root, using Python 3.11+ and its standard library: + +```sh +python -B research/complex-coded-helper-global-screen/verify.py +``` + +Expected status: `PASS_SCOPED_INTEGER_PACKING_OBSTRUCTION`. To retain the native +words after transport, detailed audit receipts, failure controls and derived +budget data, append `--out /path/to/a/new/directory`. An existing output +directory is rejected. The default uses a temporary directory. + +The command freshly replays all four committed words on every arbitrary-dirt +column in both orientations, recounts their native frame costs and helper +widths, and checks the exact certificate. It rejects five circuit mutations and +three mathematical mutations. A different gzip header and compression level +must reproduce the same complete mathematical receipt. Source archives retain +exact input hashes; generated words use hashes of their decompressed payloads. + +The inherited auditor uses assertions. It runs in a separate interpreter with +assertions enabled, including when the parent uses `-O` or inherits +`PYTHONOPTIMIZE`. New certificate guards use explicit exceptions. + +Validation passed on Windows with Python 3.13.5 and optimized Python 3.14.4 +(also with `PYTHONOPTIMIZE=2` set). The retained mathematical results agree. +No repository-wide suite, Linux CI or full selected-frontier replay is claimed. + +This is replay of retained explicit circuits, not a cold reconstruction of their +entire ancestral search. The baseline profile, dispatch and capacity inputs are +pinned to the inherited certificate. The baseline's full phase, controller, +physical-owner and outer-theorem checks are not rerun here. + +## What was integrated + +The baseline is `research/complex-k492-owner-repair/`, as retained at commit +`66849e1475c930fd7732b1a0067ffee7e1e95f60`. The five inputs used here have identical +bytes at this package's base, `f567884aeb8851b6e794af1184119a3bfbe1e631`. +`SOURCE-PINS.json` identifies them and the PR781 cell at commit +`85f9cfad7708cc3873bd6b32492a618feb336e59`. + +Two placements use the same 28-gate coded core, on pair `(6,7)`: + +| Placement | Change relative to the R492 provider | Helpers | Columns per orientation | +| --- | --- | ---: | ---: | +| positive | Open the positive cell; replace three packet helpers with one coded helper | 490 | 714 | +| negative | Recode the already expanded negative cell; add one coded helper | 493 | 717 | + +Each placement is carried through both `ck` and `jp8`. The fresh coded helper is +register 448. It has its own semantic role; it does not inherit an optimization +intended for a removed packet helper. Both variants need eight rank-one dyadic +correction reads at the start of B, after the entry wrappers. Without them the +auditor reconstructs a forbidden zero-frame read from an entering helper. + +The positive placement also needs nine tail frame lifts, three cold ends raised +from dimension 4 to 7, and twelve full-frame cleanup corrections. The negative +placement retains the old endpoints and omits the six old frame-regroup edits +on reads that the coded core replaced. These are material costs of integration. +`CONSTRUCTION-RECORD.json` records the core's register bindings and gate indices, +the corrections, final frame raises, and hashes of intermediate discovery words. +Those intermediate words are not required or regenerated by this package. + +The final native audits establish exact forward and inverse-transpose endpoints, +arbitrary helper dirt, dyadic primitives, common monotone frames, cold-end cone +conditions, cleanup restoration, and the paid profile. They do not establish +phase lowering, residual adapters or a global owner map for the changed words. +Those later stages cannot rescue a failed lower bound on the required cost. + +The resulting per-call changes are the same for `ck` and `jp8`: + +| Placement | Delta H1 | Delta H2 | Delta H3 | Delta H4 | Delta H5 | Helper-width change | +| --- | ---: | ---: | ---: | ---: | ---: | --- | +| positive | +2 | +18 | +8 | -5 | -9 | remove three width-4; add one width-9 | +| negative | -7 | -3 | +2 | +4 | 0 | add one width-9 | + +The verifier derives this table from the newly replayed words and the pinned +baseline, rather than taking it as input to the cost proof. + +## Fixed budget and favorable relaxation + +Keep PR626's 72 calls (8 `ck`, 64 `jp8`), `m = 73`, 7,168 live streams and rank +deficit 2,560. At each call choose its original word, its positive replacement, +or its negative replacement. The two replacements are not composed within a +single call. Provider-independent deltas reduce the choices to 2,700 nonempty +pairs `(p,n)` with `p >= 0`, `n >= 0`, `p+n <= 72`. + +The original aggregate local profile is + +```text +{1:181536, 2:30016, 3:31104, 4:11520, 5:5040, 6:576, 8:576}. +``` + +The baseline helper counts and available slot capacities are: + +| Helper width | 4 | 5 | 7 | 8 | 9 | +| --- | ---: | ---: | ---: | ---: | ---: | +| Count | 2160 | 3456 | 2848 | 7904 | 19056 | + +| Slot capacity | 8 | 16 | 32 | 48 | +| --- | ---: | ---: | ---: | ---: | +| Count | 5376 | 3584 | 3584 | 3584 | + +The capacity inventory is recounted both from the plan's windows (112 ports per +window) and from all 112 native data recipes (8 replicas per port). The two +rank-zero children per port and replica cannot host positive-width helpers. +The original idle profile is `{1:123, 37:1, 48:2215}`. Local plus idle rank mass +is always 520,704. + +For the lower bound, discard all time windows, call labels and physical-family +uniqueness restrictions. Each helper still occupies its full audited width in +one capacity slot. All integer multisets of widths fitting a slot are allowed, +including the empty multiset: 1,163 patterns. A pattern with leftover rank `r` +is charged just one idle child of rank `r`. Splitting it could only increase +`sum r^s` for `0 < s < 1`, so this is favorable to the candidate. No feasible +assignment or global circuit is inferred from the relaxation. + +## Exact certificate + +Use the inherited endpoint + +```text +b0 = 65528268492323474503 / 40000000000000000000000, +s = 1 - b0, +phi(r) = r^s - r, with phi(0) = 0. +``` + +Give capacities `8,16,32,48` the integer scores `6,12,24,37`, and widths +`4,5,7,8,9` the scores `3,3,5,6,7`. For a pattern P in capacity c, define + +```text +B(P) = capacity_score(c) - sum width_score(w) * count_P(w). +``` + +Enumeration checks `B(P) >= 0` for every pattern. The certificate supplies a +negative rational `lambda` and 37 rational potentials `d[0],...,d[36]`, with +`d[0]=0`. The verifier checks, for every pattern and every residue j, + +```text +phi(r(P)) >= lambda * B(P), +d[(j+B(P)) mod 37] - d[j] <= phi(r(P)) - lambda * B(P). +``` + +These are 1,163 scalar inequalities and 43,031 potential inequalities. For any +integer packing, order its slot patterns arbitrarily and telescope the second +inequality from residue zero. Their total score is fixed by the demand: + +```text +S = 81984 + 2*p - 7*n. +sum_P phi(r(P)) >= lambda*S + d[S mod 37]. +``` + +If `I` is the fixed leftover rank mass and `H_local` the audited local profile, +every such packing therefore has moment numerator at least + +```text +sum_r H_local(r)*r^s + I + lambda*S + d[S mod 37]. +``` + +`exact.py` proves this lower bound strictly exceeds `7168 * 73^s` for every +nonempty mixture. The smallest certified excess is greater than +**0.023249063103**, at `(p,n) = (0,1)`. All child ranks are at most 48, below 73, +so the normalized moment increases with b. Failure at b0 excludes b0 and every +larger saving exponent in this fixed model. + +The integer correction matters. Replacing all potentials with zero still +satisfies the pattern inequalities but fails to exclude the single negative +replacement. This is an explicit control, not an assumption of numerical MIP +optimality. A positive control verifies that the inherited *unmodified* global +profile satisfies its own endpoint. + +All real-power comparisons use rational intervals. Write `r = 2^k m` with +`1 <= m < 2`; evaluate `log r` using 48 terms of the atanh series, with argument +at most 1/3 and an explicit geometric tail. Bound `exp(-b0 log r)` by its degree +21 and degree 20 alternating polynomials, then round outward at scale `10^30`. +The stored potentials use scale `10^16`. No floating-point result, optimizer, +or shortest-path implementation is trusted by the verifier. + +## Search record and limits + +The starting experiment was PR781's seed-23 positive cell. This follow-up tried +that placement and the same pair's already expanded negative cell, retaining +the original coded core and pivot. The provider optimizations were ported to +each changed word, repaired where the native audit rejected them, and audited +again. A final greedy search considered legal raises of the 28 coded gates: +one-vector extensions and the maximal common next frame, at most 12 sweeps. +It accepted three raises for each positive word and eight for each negative +word. This is a bounded search, with no claim of frame optimality. + +Fractional LP and integer MIP exploration suggested the obstruction. The +37-state potentials were then constructed from the nonnegative reduced costs. +Only the retained exact inequalities are part of the proof. Search stopped when +the exact lower bound excluded all 2,700 mixtures; no phase lowering or global +owner nomination was attempted after that decision. + +Related owner-profile results [PR795](https://github.com/CrocSwap/integer-mult-bounds/pull/795) +and [PR850](https://github.com/CrocSwap/integer-mult-bounds/pull/850) concern the +SW4 inventory and establish stronger packing results for that fixed inventory. +[PR815](https://github.com/CrocSwap/integer-mult-bounds/pull/815) studies frame +assignments of fixed scalar words. Here the scalar words and width inventory +change. This package adds four audited embeddings of PR781 and an exact +obstruction for their mixtures in PR626's budget; it makes no general novelty +claim for integer width prices or owner-packing methods. + +The complete multiplication theorem retains its inherited all-size, +realization, hosting, precision/tape and analytic assumptions. This finite +certificate neither discharges those assumptions nor formally verifies the +full theorem. Attribution and licenses are recorded in [NOTICE.md](NOTICE.md). diff --git a/research/complex-coded-helper-global-screen/SOURCE-PINS.json b/research/complex-coded-helper-global-screen/SOURCE-PINS.json new file mode 100644 index 0000000000..1ec1292382 --- /dev/null +++ b/research/complex-coded-helper-global-screen/SOURCE-PINS.json @@ -0,0 +1,23 @@ +{ + "base_commit": "f567884aeb8851b6e794af1184119a3bfbe1e631", + "coded_cell_source": { + "commit": "85f9cfad7708cc3873bd6b32492a618feb336e59", + "path": "research/complex-packet-borrowing23/CODED-CELL.json", + "pull_request": "https://github.com/CrocSwap/integer-mult-bounds/pull/781", + "sha256": "03ba299163019b7438c5e711f0a3e3422466ee7e27d4a05c8ba0576800bc20fd" + }, + "files": { + "research/complex-k492-owner-repair/code/hpe_audit_and_transport.py": "c9a05ff291016b870b4fc925b317abd9c3a604c73ffc8920dfdbbeb475e20aa3", + "research/complex-k492-owner-repair/data/PLAN.json": "8c48ef6ce079916314126c5c3ff0003b32f24cf0fbfb2a033fc93e1e1949b5d5", + "research/complex-k492-owner-repair/data/SPEC.json": "2a2577ac526535826fed9d5f7f83f6e2e0ec058a146c64f7286720b995fa2323", + "research/complex-k492-owner-repair/vendor/multicold/vendor/pr558/vendor/pr552/complex-global/vendor531/inputs/data-base/work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "research/complex-k492-owner-repair/vendor/multicold/vendor/pr558/vendor/pr552/complex-local/inputs/phase-baseline/CANONICAL-WORD.json.gz": "e070ae2c78b4a1b644b418774af62b40d8d16e6ba89602f0474afb557d507c37" + }, + "research_origin_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "word_content_sha256": { + "negative-ck": "a6b394127bb81f23a2ca7d187c1e4642b369840a82b7627f7872fc772942a5a0", + "negative-jp8": "d7eb38ba90374b914df7751d09d5b2d9e9bd5f898766cab24824d6f51d71705e", + "positive-ck": "ffb6918e397bbc026fe7ad1914bb94e316cd6eacd1d2d249ccd7acf10749b1b2", + "positive-jp8": "8e31803f503ab2b416da2af15dd73cad1b04f33966a24b747c017bc1bfcf9934" + } +} diff --git a/research/complex-coded-helper-global-screen/exact.py b/research/complex-coded-helper-global-screen/exact.py new file mode 100644 index 0000000000..f2440b951c --- /dev/null +++ b/research/complex-coded-helper-global-screen/exact.py @@ -0,0 +1,173 @@ +"""Check the finite packing certificate using rational arithmetic only. + +The recorded potentials are witnesses, not trusted solver output. Every edge +inequality and every mixture is checked again. See README.md for the proof. +""" +from fractions import Fraction as Q +from functools import lru_cache + +SCALE = 10**30 +POTENTIAL_SCALE = 10**16 +MODULUS = 37 +CAPACITY_SCORE = {8: 6, 16: 12, 32: 24, 48: 37} +WIDTH_SCORE = {4: 3, 5: 3, 7: 5, 8: 6, 9: 7} + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def log_interval(z): + """Bound log((1+z)/(1-z)) by 48 terms and a geometric tail.""" + require(0 <= z <= Q(1, 3), "log argument outside certified range") + value, power = Q(0), z + for j in range(48): + value += 2 * power / (2*j + 1) + power *= z*z + return value, value + 2*power / (97*(1-z*z)) + + +@lru_cache(None) +def power_bounds(r, b): + """Outward-rounded integer bounds for SCALE * r**(1-b).""" + require(type(r) is int and r >= 0 and 0 < b < 1, "power domain") + if r in (0, 1): + return r*SCALE, r*SCALE + k = r.bit_length() - 1 + l2, u2 = log_interval(Q(1, 3)) + m = Q(r, 2**k) + lm, um = log_interval((m-1)/(m+1)) + lo, hi = b*(k*l2+lm), b*(k*u2+um) + require(0 < lo <= hi < 1, "exp argument outside certified range") + + def alternating(x): + term = total = Q(1) + for n in range(1, 21): + term *= -x/n + total += term + # Decreasing terms on [0,1]: degree 21 is below, degree 20 above. + return total + term*(-x)/21, total + + lower = r*alternating(hi)[0]*SCALE + upper = r*alternating(lo)[1]*SCALE + return lower.numerator//lower.denominator, -(-upper.numerator//upper.denominator) + + +def patterns(): + """All integer width multisets fitting one capacity, including empty.""" + widths = sorted(WIDTH_SCORE) + result = [] + + def visit(capacity, j, used, multiplicities): + if j == len(widths): + score = CAPACITY_SCORE[capacity] - sum( + WIDTH_SCORE[w]*n for w, n in zip(widths, multiplicities)) + result.append((capacity, capacity-used, tuple(multiplicities), score)) + return + for n in range((capacity-used)//widths[j] + 1): + visit(capacity, j+1, used+n*widths[j], multiplicities+[n]) + + for capacity in sorted(CAPACITY_SCORE): + visit(capacity, 0, 0, []) + return result + + +def shifted(base, positive, negative, deltas): + keys = set(base) | set(deltas['positive']) | set(deltas['negative']) + result = {r: base.get(r, 0) + positive*deltas['positive'].get(r, 0) + + negative*deltas['negative'].get(r, 0) for r in keys} + require(all(type(n) is int and n >= 0 for n in result.values()), + "invalid mixture inventory") + return {r: n for r, n in result.items() if n} + + +def verify(model, certificate, check_record=True): + b = Q(model['endpoint']) + require(Q(certificate['endpoint']) == b, "endpoint mismatch") + require(set(model['capacities']) == set(CAPACITY_SCORE), "capacity domain") + require(set(model['widths']) == set(WIDTH_SCORE), "width domain") + require(certificate['potential_scale'] == POTENTIAL_SCALE, "potential scale") + lam = certificate['lambda_units_1e30'] + d = certificate['potentials'] + require(type(lam) is int and lam < 0, "lambda must be a negative integer") + require(len(d) == MODULUS and all(type(x) is int for x in d) and d[0] == 0, + "potential domain or origin") + pats = patterns() + require(len(pats) == 1163, "pattern enumeration changed") + phi = {r: power_bounds(r, b)[0] - r*SCALE for r in range(49)} + potential_unit = SCALE//POTENTIAL_SCALE + for capacity, residual, counts, score in pats: + require(score >= 0, "negative pattern score") + gap = phi[residual] - lam*score + require(gap >= 0, f"pattern dual inequality: {capacity}, {counts}") + for capacity, residual, counts, score in pats: + gap = phi[residual] - lam*score + for j in range(MODULUS): + require((d[(j+score) % MODULUS]-d[j])*potential_unit <= gap, + f"potential inequality: residue {j}, capacity {capacity}, {counts}") + + # A positive control: the inherited profile really meets its own endpoint. + threshold_lo, threshold_hi = [model['live']*x for x in power_bounds(model['m'], b)] + baseline_hi = sum(n*power_bounds(r, b)[1] for r, n in model['global'].items()) + require(baseline_hi < threshold_lo, "baseline endpoint positive control") + + capacity_mass = sum(c*n for c, n in model['capacities'].items()) + capacity_score = sum(CAPACITY_SCORE[c]*n for c, n in model['capacities'].items()) + rows = [] + for positive in range(model['calls']+1): + for negative in range(model['calls']-positive+1): + if positive + negative == 0: + continue + local = shifted(model['local'], positive, negative, model['profile_deltas']) + widths = shifted(model['widths'], positive, negative, model['width_deltas']) + require(set(local) <= set(range(1, 49)) and set(widths) <= set(WIDTH_SCORE), + "mixture uses an uncertified rank or width") + idle_mass = capacity_mass - sum(w*n for w, n in widths.items()) + score = capacity_score - sum(WIDTH_SCORE[w]*n for w, n in widths.items()) + require(idle_mass >= 0 and score >= 0, "mixture mass or score") + require(sum(r*n for r, n in local.items()) + idle_mass == model['rank_mass'], + "local/idle rank conservation") + lower = (sum(n*power_bounds(r, b)[0] for r, n in local.items()) + + idle_mass*SCALE + lam*score + d[score % MODULUS]*potential_unit) + margin = lower-threshold_hi + require(margin > 0, f"budget inequality: positive={positive}, negative={negative}") + rows.append((margin, positive, negative)) + margin, positive, negative = min(rows) + summary = { + 'endpoint': str(b), 'patterns': len(pats), + 'potential_inequalities': MODULUS*len(pats), 'mixtures': len(rows), + 'lambda_units_1e30': lam, 'potential_scale': POTENTIAL_SCALE, 'potentials': d, + 'minimum_margin_units_1e30': margin, + 'minimum_at': {'positive': positive, 'negative': negative}, + 'minimum_margin_greater_than': str(Q(margin//10**18, 10**12)), + } + if check_record: + require(summary == certificate, "recorded exact-certificate summary differs") + return summary + + +def controls(model, certificate): + from copy import deepcopy + + cases = [] + bad = deepcopy(certificate) + bad['lambda_units_1e30'] += 10**24 # Raise lambda by 10^-6. + cases.append(('raise_lambda', bad, 'pattern dual inequality')) + bad = deepcopy(certificate) + bad['potentials'][22] += 1000 + cases.append(('raise_residue_22', bad, 'potential inequality')) + bad = deepcopy(certificate) + bad['potentials'] = [0]*MODULUS + # Zero potentials satisfy the edges, but cannot exclude the one-call case. + cases.append(('omit_integer_correction', bad, 'budget inequality: positive=0, negative=1')) + rejected = {} + for name, bad, expected in cases: + try: + verify(model, bad, check_record=False) + except ValueError as error: + require(expected in str(error), f"wrong failure for {name}: {error}") + rejected[name] = str(error) + else: + raise ValueError(f"negative control accepted: {name}") + return rejected diff --git a/research/complex-coded-helper-global-screen/native_worker.py b/research/complex-coded-helper-global-screen/native_worker.py new file mode 100644 index 0000000000..13529fb7d2 --- /dev/null +++ b/research/complex-coded-helper-global-screen/native_worker.py @@ -0,0 +1,105 @@ +"""Assertion-enabled replay of the pinned inherited native auditor.""" +import contextlib +import copy +from fractions import Fraction as Q +import gzip +import json +from pathlib import Path +import runpy +import sys + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + + +def main(package, auditor, routing, out): + require(__debug__, "the inherited auditor requires assertions; run without -O") + audit = runpy.run_path(str(auditor))['run'] + expected = read(package/'NATIVE-EXPECTED.json') + construction = read(package/'CONSTRUCTION-RECORD.json') + core = read(package/'CODED-CELL.json')['core'] + words, receipts = {}, {} + for name in sorted(expected): + path = package/'words'/f'{name}.json.gz' + words[name] = read(path) + cell = construction[name]['coded_cell'] + bindings, indexes = cell['bindings'], cell['core_gate_indexes'] + require(len(indexes) == len(core) == 28 and indexes == sorted(set(indexes)), + f"coded core index list: {name}") + embedded = [['add', bindings[t], bindings[s], Q(q).numerator, Q(q).denominator] + for t, s, q in core] + require([words[name]['B'][i][:-1] for i in indexes] == embedded, + f"coded core embedding: {name}") + with (out/f'{name}.log').open('w', encoding='utf-8') as log: + with contextlib.redirect_stdout(log): + audit(path, routing, out/name) + receipt = read(out/name/'SCALAR-FRAME-AUDIT.json') + receipt.pop('seconds') + require(receipt == expected[name], f"native receipt mismatch: {name}") + receipts[name] = receipt + + positive, negative = words['positive-ck'], words['negative-ck'] + provenance = construction['positive-ck'] + corrections = provenance['entry_correction']['gates'] + require(positive['B'][:len(corrections)] == corrections, "entry correction location") + cleanup = provenance['full_frame_cleanup_correction']['gates'] + require(positive['cleanup'][-len(cleanup):] == cleanup, "cleanup correction location") + cases = [] + bad = copy.deepcopy(positive) + del bad['B'][:len(corrections)] + cases.append(('omit_entry_correction', bad, 'zero-frame compensation reads an entering helper')) + bad = copy.deepcopy(positive) + del bad['cleanup'][-len(cleanup):] + cases.append(('omit_full_cleanup_correction', bad, 'arbitrary-dirt endpoint')) + bad = copy.deepcopy(positive) + lift = provenance['cold_end_transfer']['end_lifts'][0] + bad['helper_final'][str(lift['helper'])] = lift['old_frame'] + cases.append(('restore_old_cold_end', bad, 'hpe cone pre-check')) + bad = copy.deepcopy(negative) + gate = next(e for e in bad['cleanup'] if e[0] == 'add' and e[1] == 448 and e[3]) + gate[3] = 0 + cases.append(('omit_coded_helper_cleanup', bad, 'arbitrary-dirt endpoint')) + bad = copy.deepcopy(positive) + bad['report']['local_profile']['2'] -= 1 + cases.append(('understate_paid_profile', bad, 'paid local profile differs')) + rejected = {} + for name, bad, reason in cases: + path = out/f'{name}.json' + path.write_text(json.dumps(bad), encoding='utf-8') + with (out/f'{name}.log').open('w', encoding='utf-8') as log: + try: + with contextlib.redirect_stdout(log): + audit(path, routing, out/name) + except AssertionError as error: + require(reason in str(error), f"wrong failure for {name}: {error}") + rejected[name] = str(error) + else: + raise ValueError(f"negative control accepted: {name}") + + # Generated gzip identity is its entire decompressed payload, not its header. + source = package/'words'/'positive-ck.json.gz' + recompressed = out/'recompressed.json.gz' + recompressed.write_bytes(gzip.compress(gzip.decompress(source.read_bytes()), + compresslevel=1, mtime=123456789)) + require(recompressed.read_bytes() != source.read_bytes(), "recompression control unchanged") + with (out/'recompressed.log').open('w', encoding='utf-8') as log: + with contextlib.redirect_stdout(log): + audit(recompressed, routing, out/'recompressed') + receipt = read(out/'recompressed'/'SCALAR-FRAME-AUDIT.json') + receipt.pop('seconds') + require(receipt == receipts['positive-ck'], "recompression changed mathematical receipt") + result = {'receipts': receipts, 'controls_rejected': rejected, + 'recompression_control': 'PASS', 'assertions_enabled': __debug__} + (out/'NATIVE-RESULT.json').write_text(json.dumps(result, indent=2)+'\n', encoding='utf-8') + + +if __name__ == '__main__': + require(len(sys.argv) == 5, "expected package, auditor, routing and output paths") + main(*(Path(x).resolve() for x in sys.argv[1:])) diff --git a/research/complex-coded-helper-global-screen/verify.py b/research/complex-coded-helper-global-screen/verify.py new file mode 100644 index 0000000000..939600602b --- /dev/null +++ b/research/complex-coded-helper-global-screen/verify.py @@ -0,0 +1,173 @@ +"""Replay four explicit words and the exact global-budget obstruction (stdlib).""" +import argparse +from collections import Counter +import gzip +import hashlib +import json +import os +from pathlib import Path +import runpy +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +BASE = 'research/complex-k492-owner-repair/' +VENDOR = BASE + 'vendor/multicold/vendor/pr558/vendor/pr552/' +AUDITOR = BASE + 'code/hpe_audit_and_transport.py' +ROUTING = VENDOR + 'complex-local/inputs/phase-baseline/CANONICAL-WORD.json.gz' +DATA = VENDOR + 'complex-global/vendor531/inputs/data-base/work/complex-nine-native/DATA-PHASES.json' +EXACT = runpy.run_path(str(HERE/'exact.py')) +require = EXACT['require'] + + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + + +def integers(mapping): + return {int(r): n for r, n in mapping.items()} + + +def difference(new, old): + return {r: new.get(r, 0)-old.get(r, 0) for r in sorted(set(new) | set(old)) + if new.get(r, 0) != old.get(r, 0)} + + +def check_sources(): + pins = read(HERE/'SOURCE-PINS.json') + require(set(pins['files']) == {AUDITOR, ROUTING, DATA, BASE+'data/SPEC.json', + BASE+'data/PLAN.json'}, "source pin inventory") + for path, digest in pins['files'].items(): + require(hashlib.sha256((ROOT/path).read_bytes()).hexdigest() == digest, + f"source pin mismatch: {path}") + require(hashlib.sha256((HERE/'CODED-CELL.json').read_bytes()).hexdigest() + == pins['coded_cell_source']['sha256'], "coded-cell source pin") + names = {f'{variant}-{pid}' for variant in ('positive', 'negative') for pid in ('ck', 'jp8')} + require(set(pins['word_content_sha256']) == names, "candidate inventory") + for name, digest in pins['word_content_sha256'].items(): + payload = gzip.decompress((HERE/'words'/f'{name}.json.gz').read_bytes()) + require(hashlib.sha256(payload).hexdigest() == digest, f"word content pin: {name}") + require(set(read(HERE/'NATIVE-EXPECTED.json')) == names, "expected receipt inventory") + return pins + + +def model_from_receipts(receipts): + spec = read(ROOT/BASE/'data/SPEC.json') + plan = read(ROOT/BASE/'data/PLAN.json') + data = read(ROOT/DATA) + expected = spec['expected'] + dispatch = spec['dispatch'] + counts = Counter(pid for _, _, pid in dispatch) + require(counts == expected['provider_counts'] == {'ck': 8, 'jp8': 64}, "dispatch counts") + require([[c['stage'], c['replica'], c['provider']] for c in plan['provider_calls']] + == dispatch, "plan dispatch") + require(plan['order'] == spec['call_order'] == [row[:2] for row in dispatch], "call order") + require(plan['M'] == data['m'] == 73 and plan['T'] == 8 and plan['L'] == 9, + "pinned geometry") + require(len(dispatch) == plan['T']*plan['L'] and data['ports'] == 112, + "call or port count") + capacities = Counter() + for rank, times in plan['windows'].values(): + capacities[rank] += data['ports'] + native_capacities = Counter() + require(len(data['recipes']) == data['ports'], "data recipe count") + for recipe in data['recipes']: + for child in recipe['idle_children']: + native_capacities[child['rank']] += plan['T'] + # The data recipe also records two empty children per port/replica. + # They cannot host any positive-width helper and contribute zero moment. + require(native_capacities.pop(0) == 2*data['ports']*plan['T'], "zero-capacity children") + require(capacities == native_capacities == {8: 5376, 16: 3584, 32: 3584, 48: 3584}, + "window/data capacity inventories disagree") + + local, widths = Counter(), Counter() + per_call = Counter(w for row in plan['per_call_widths'] for w in row['widths']) + for pid, count in counts.items(): + source = spec['providers'][pid] + profile, inventory = integers(source['expected_profile']), integers(source['inventory']) + registry = plan['provider_registry'][pid] + require(integers(registry['actual_paid_profile']) == profile, f"baseline profile: {pid}") + require(Counter(registry['widths']) == inventory, f"baseline inventory: {pid}") + local.update({r: n*count for r, n in profile.items()}) + widths.update({w: n*count for w, n in inventory.items()}) + require(widths == per_call, "per-call baseline helper inventory") + global_profile = integers(expected['global_profile']) + idle = integers(expected['idle_remainder_profile']) + require(local + Counter(idle) == global_profile == integers(plan['profile']), + "baseline local/global accounting") + require(sum(c*n for c, n in capacities.items())-sum(w*n for w, n in widths.items()) + == sum(r*n for r, n in idle.items()), "baseline idle mass") + + profile_deltas, width_deltas = {}, {} + for variant in ('positive', 'negative'): + profiles, inventories = [], [] + for pid in sorted(counts): + name = f'{variant}-{pid}' + receipt = receipts[name] + word = read(HERE/'words'/f'{name}.json.gz') + profile = integers(receipt['local_profile']) + inventory = dict(Counter(receipt['widths'])) + require(profile == integers(word['report']['local_profile']), f"paid profile: {name}") + require(inventory == integers(word['report']['width_inventory']), f"paid widths: {name}") + require(len(receipt['widths']) == receipt['helpers'] == word['report']['R'], + f"helper count: {name}") + require(receipt['live_columns_each_orientation'] == 224 + receipt['helpers'], + f"all-column replay: {name}") + baseline = spec['providers'][pid] + profiles.append(difference(profile, integers(baseline['expected_profile']))) + inventories.append(difference(inventory, integers(baseline['inventory']))) + require(profiles[0] == profiles[1] and inventories[0] == inventories[1], + f"provider-independent deltas: {variant}") + profile_deltas[variant], width_deltas[variant] = profiles[0], inventories[0] + require(plan['live'] == expected['live'] == 7168 and plan['deficit'] == expected['deficit'], + "live/deficit budget") + require(sum(r*n for r, n in global_profile.items()) == expected['rank_mass'] + == plan['live']*plan['M']-plan['deficit'], "baseline rank mass") + return {'endpoint': expected['complex_lower'], 'm': plan['M'], 'live': plan['live'], + 'calls': len(dispatch), 'rank_mass': expected['rank_mass'], + 'capacities': dict(capacities), 'widths': dict(widths), 'local': dict(local), + 'global': global_profile, 'profile_deltas': profile_deltas, 'width_deltas': width_deltas} + + +def run(out): + pins = check_sources() + environment = os.environ.copy() + environment.pop('PYTHONOPTIMIZE', None) + subprocess.run([sys.executable, '-I', '-B', '-X', 'utf8', str(HERE/'native_worker.py'), + str(HERE), str(ROOT/AUDITOR), str(ROOT/ROUTING), str(out)], + check=True, env=environment) + native = read(out/'NATIVE-RESULT.json') + require(native['assertions_enabled'] is True, "native worker assertions disabled") + for name, receipt in native['receipts'].items(): + require(receipt['input_content_sha256'] == pins['word_content_sha256'][name], + f"audited word identity: {name}") + model = model_from_receipts(native['receipts']) + certificate = read(HERE/'EXACT-CERTIFICATE.json') + exact = EXACT['verify'](model, certificate) + controls = EXACT['controls'](model, certificate) + summary = { + 'status': 'PASS_SCOPED_INTEGER_PACKING_OBSTRUCTION', + 'native_words': len(native['receipts']), 'native_controls_rejected': len(native['controls_rejected']), + 'exact_controls_rejected': len(controls), 'recompression_control': native['recompression_control'], + 'patterns': exact['patterns'], 'potential_inequalities': exact['potential_inequalities'], + 'mixtures': exact['mixtures'], 'minimum_margin_greater_than': exact['minimum_margin_greater_than'], + 'minimum_at': exact['minimum_at'], 'scope': 'Four explicit native words; fixed #626 geometry and dispatch. No global candidate admission or new exponent.'} + (out/'RESULT.json').write_text(json.dumps({'summary': summary, 'model': model, + 'exact_controls': controls}, indent=2)+'\n', encoding='utf-8') + print(json.dumps(summary, indent=2)) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--out', type=Path, help='retain receipts in a new directory') + args = parser.parse_args() + if args.out is not None: + out = args.out.resolve() + out.mkdir(parents=True, exist_ok=False) + run(out) + else: + with tempfile.TemporaryDirectory(prefix='coded-helper-screen-') as directory: + run(Path(directory)) diff --git a/research/complex-coded-helper-global-screen/words/negative-ck.json.gz b/research/complex-coded-helper-global-screen/words/negative-ck.json.gz new file mode 100644 index 0000000000..4950d002d9 Binary files /dev/null and b/research/complex-coded-helper-global-screen/words/negative-ck.json.gz differ diff --git a/research/complex-coded-helper-global-screen/words/negative-jp8.json.gz b/research/complex-coded-helper-global-screen/words/negative-jp8.json.gz new file mode 100644 index 0000000000..c7797d3a41 Binary files /dev/null and b/research/complex-coded-helper-global-screen/words/negative-jp8.json.gz differ diff --git a/research/complex-coded-helper-global-screen/words/positive-ck.json.gz b/research/complex-coded-helper-global-screen/words/positive-ck.json.gz new file mode 100644 index 0000000000..396f1546e0 Binary files /dev/null and b/research/complex-coded-helper-global-screen/words/positive-ck.json.gz differ diff --git a/research/complex-coded-helper-global-screen/words/positive-jp8.json.gz b/research/complex-coded-helper-global-screen/words/positive-jp8.json.gz new file mode 100644 index 0000000000..286824f65f Binary files /dev/null and b/research/complex-coded-helper-global-screen/words/positive-jp8.json.gz differ