From 49f9c1a08bf1fe67a62bd6d2825aa0d03e1b1518 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 23:03:55 -0500 Subject: [PATCH] Research five-dimensional P112 port decoder --- .../CANDIDATE.json | 3362 +++++++++++++++++ .../CLAIM.md | 10 + .../PROOF.md | 41 + .../README.md | 70 + .../RESULT.json | 70 + .../SOURCES.json | 36 + .../TASK.json | 63 + .../VERIFY.json | 23 + .../five-plane-port-p112-seed1f7fdfe4/core.py | 243 ++ .../search.py | 46 + .../verify.py | 199 + 11 files changed, 4163 insertions(+) create mode 100644 research/five-plane-port-p112-seed1f7fdfe4/CANDIDATE.json create mode 100644 research/five-plane-port-p112-seed1f7fdfe4/CLAIM.md create mode 100644 research/five-plane-port-p112-seed1f7fdfe4/PROOF.md create mode 100644 research/five-plane-port-p112-seed1f7fdfe4/README.md create mode 100644 research/five-plane-port-p112-seed1f7fdfe4/RESULT.json create mode 100644 research/five-plane-port-p112-seed1f7fdfe4/SOURCES.json create mode 100644 research/five-plane-port-p112-seed1f7fdfe4/TASK.json create mode 100644 research/five-plane-port-p112-seed1f7fdfe4/VERIFY.json create mode 100644 research/five-plane-port-p112-seed1f7fdfe4/core.py create mode 100644 research/five-plane-port-p112-seed1f7fdfe4/search.py create mode 100644 research/five-plane-port-p112-seed1f7fdfe4/verify.py diff --git a/research/five-plane-port-p112-seed1f7fdfe4/CANDIDATE.json b/research/five-plane-port-p112-seed1f7fdfe4/CANDIDATE.json new file mode 100644 index 0000000000..ca69901755 --- /dev/null +++ b/research/five-plane-port-p112-seed1f7fdfe4/CANDIDATE.json @@ -0,0 +1,3362 @@ +{ + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "candidate": { + "aggregate_translation_count": 23, + "all_in_rank1_overhead_threshold": { + "first_failing": { + "ceiling_lower": "1257591736869/125000000000000", + "ceiling_upper": "10060733894953/1000000000000000", + "ceiling_upper_decimal": 0.010060733894953, + "extra_rank1_equivalent_charge": 158, + "moment_lower": "28951625153659124931086036639517023753125453490127390358300818278217158581403/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "moment_lower_decimal": 1.000124459083649, + "moment_upper": "14475812576829562465543018319758511876562726745063695179150409139108579290707/14474011154664524427946373126085988481658748083205070504932198000989141204992", + "moment_upper_decimal": 1.000124459083649, + "total_rank1_equivalent_charge": 276 + }, + "largest_passing": { + "ceiling_lower": "631702176569/62500000000000", + "ceiling_upper": "2021446965021/200000000000000", + "ceiling_upper_decimal": 0.010107234825105, + "extra_rank1_equivalent_charge": 157, + "moment_lower": "57894931099429840998461298504541599958986150151388992800088213731053456960937/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "moment_lower_decimal": 0.9999807669205109, + "moment_upper": "57894931099429840998461298504541599958986150151388992800088213731053456960959/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "moment_upper_decimal": 0.9999807669205109, + "total_rank1_equivalent_charge": 275 + } + }, + "attempt": 365, + "attempt_cap": 10000, + "blocks": [ + [ + 0, + 25, + 33, + 71, + 89 + ], + [ + 1, + 2, + 35, + 47, + 65 + ], + [ + 3, + 50, + 69, + 84, + 91 + ], + [ + 4, + 24, + 44, + 96, + 101 + ], + [ + 5, + 42, + 43, + 45, + 88 + ], + [ + 6, + 8, + 36, + 70, + 72 + ], + [ + 7, + 9, + 10, + 34, + 63 + ], + [ + 11, + 39, + 62, + 68, + 109 + ], + [ + 12, + 15, + 48, + 78, + 82 + ], + [ + 13, + 40, + 53, + 75, + 99 + ], + [ + 14, + 27, + 28, + 30, + 77 + ], + [ + 16, + 56, + 57, + 76, + 108 + ], + [ + 17, + 58, + 107, + 110, + 111 + ], + [ + 18, + 93, + 98, + 103, + 106 + ], + [ + 19, + 29, + 52, + 54, + 105 + ], + [ + 20, + 22, + 37, + 60, + 80 + ], + [ + 21, + 23, + 26, + 31, + 74 + ], + [ + 32, + 38, + 41, + 85, + 87 + ], + [ + 46, + 79, + 86, + 100, + 102 + ], + [ + 49, + 92, + 94, + 95, + 97 + ], + [ + 51, + 61, + 67, + 73, + 81 + ], + [ + 59, + 64, + 66, + 83, + 90 + ], + [ + 55, + 104 + ] + ], + "coefficient_matrices": [ + [ + [ + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 0, + 1, + 0, + 1 + ], + [ + 1, + 1, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 1, + 1 + ], + [ + 1, + 1, + 1, + 1, + 0 + ] + ], + [ + [ + 1, + 1, + 1, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 1, + 0, + 1, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 1 + ], + [ + 1, + 1, + 1, + 1, + 0 + ] + ], + [ + [ + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ] + ], + "copy_charge": 118, + "copy_rank_histogram": { + "7": 10, + "8": 6 + }, + "five_frame_count": 161280, + "greedy_steps": 7438, + "groups": [ + [ + 0, + 25, + 33, + 71, + 89 + ], + [ + 1, + 2, + 35, + 47, + 65 + ], + [ + 3, + 50, + 69, + 84, + 91 + ], + [ + 4, + 24, + 44, + 96, + 101 + ], + [ + 5, + 42, + 43, + 45, + 88 + ], + [ + 6, + 8, + 36, + 70, + 72 + ], + [ + 7, + 9, + 10, + 34, + 63 + ], + [ + 11, + 39, + 62, + 68, + 109 + ], + [ + 12, + 15, + 48, + 78, + 82 + ], + [ + 13, + 40, + 53, + 75, + 99 + ], + [ + 14, + 27, + 28, + 30, + 77 + ], + [ + 16, + 56, + 57, + 76, + 108 + ], + [ + 17, + 58, + 107, + 110, + 111 + ], + [ + 18, + 93, + 98, + 103, + 106 + ], + [ + 19, + 29, + 52, + 54, + 105 + ], + [ + 20, + 22, + 37, + 60, + 80 + ], + [ + 21, + 23, + 26, + 31, + 74 + ], + [ + 32, + 38, + 41, + 85, + 87 + ], + [ + 46, + 79, + 86, + 100, + 102 + ], + [ + 49, + 92, + 94, + 95, + 97 + ], + [ + 51, + 61, + 67, + 73, + 81 + ], + [ + 59, + 64, + 66, + 83, + 90 + ] + ], + "local_mass": 5640, + "local_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "7": 10, + "8": 6 + }, + "moment_screen_u5": { + "ceiling_lower": "1096389827721/62500000000000", + "ceiling_upper": "17542237243537/1000000000000000", + "ceiling_upper_decimal": 0.017542237243537, + "moment_lower": "56588815460949649395869658909227335038419328019460289907480830146258405267553/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "moment_lower_decimal": 0.9774210973077914, + "moment_upper": "113177630921899298791739317818454670076838656038920579814961660292516810535149/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "moment_upper_decimal": 0.9774210973077914 + }, + "one_unit_per_aggregate_translation_screen": { + "ceiling_lower": "821798720121/50000000000000", + "ceiling_upper": "16435974402421/1000000000000000", + "ceiling_upper_decimal": 0.016435974402421, + "moment_lower": "56780157242383053261217478722553628625508735083373411987289555130018189910533/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "moment_lower_decimal": 0.9807260170599732, + "moment_upper": "113560314484766106522434957445107257251017470166746823974579110260036379821109/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "moment_upper_decimal": 0.9807260170599732 + }, + "residual": [ + 55, + 104 + ], + "term_count": 16, + "terms": [ + { + "block": 0, + "copy_rank": 7, + "group": [ + 0, + 25, + 33, + 71, + 89 + ], + "left_coeff": 31, + "left_label": 98, + "left_support": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13, + 16, + 17, + 20, + 21, + 22, + 23, + 25, + 26, + 29, + 30, + 31, + 33, + 34, + 36, + 37, + 38, + 43, + 45, + 48, + 52, + 53, + 54, + 55, + 57, + 58, + 62, + 63, + 64, + 65, + 68, + 69, + 70, + 71, + 75, + 76, + 78, + 79, + 80, + 83, + 84, + 88, + 89, + 92, + 93, + 96, + 97, + 98, + 101, + 102, + 105, + 106, + 107 + ], + "right_coeff": 9, + "right_label": 347, + "right_support": [ + 0, + 1, + 3, + 5, + 8, + 10, + 13, + 15, + 17, + 19, + 20, + 23, + 27, + 29, + 31, + 32, + 34, + 37, + 39, + 42, + 45, + 46, + 49, + 51, + 53, + 54, + 56, + 58, + 60, + 62, + 65, + 68, + 71, + 73, + 75, + 78, + 81, + 83, + 85, + 88, + 90, + 92, + 93, + 95, + 97, + 99, + 101, + 103, + 105, + 107, + 109, + 110 + ] + }, + { + "block": 0, + "copy_rank": 7, + "group": [ + 0, + 25, + 33, + 71, + 89 + ], + "left_coeff": 21, + "left_label": 316, + "left_support": [ + 0, + 1, + 2, + 5, + 9, + 10, + 13, + 14, + 17, + 18, + 20, + 23, + 24, + 28, + 29, + 32, + 33, + 36, + 38, + 39, + 42, + 43, + 44, + 45, + 47, + 50, + 53, + 54, + 57, + 60, + 63, + 64, + 69, + 70, + 73, + 76, + 77, + 82, + 83, + 89, + 90, + 92, + 93, + 94, + 97, + 98, + 99, + 102, + 103, + 106, + 109, + 110 + ], + "right_coeff": 10, + "right_label": 350, + "right_support": [ + 2, + 4, + 8, + 10, + 12, + 14, + 16, + 18, + 21, + 22, + 24, + 25, + 26, + 28, + 30, + 31, + 32, + 34, + 37, + 39, + 42, + 44, + 47, + 48, + 50, + 52, + 55, + 58, + 60, + 62, + 65, + 68, + 71, + 73, + 75, + 77, + 78, + 79, + 80, + 82, + 84, + 88, + 90, + 94, + 96, + 99, + 101, + 103, + 105, + 107, + 109, + 110 + ] + }, + { + "block": 0, + "copy_rank": 7, + "group": [ + 0, + 25, + 33, + 71, + 89 + ], + "left_coeff": 19, + "left_label": 440, + "left_support": [ + 0, + 1, + 2, + 4, + 5, + 6, + 7, + 8, + 10, + 11, + 13, + 17, + 22, + 23, + 25, + 26, + 27, + 29, + 30, + 32, + 38, + 41, + 42, + 48, + 51, + 54, + 55, + 57, + 59, + 60, + 62, + 63, + 66, + 68, + 69, + 72, + 75, + 77, + 78, + 82, + 85, + 89, + 95, + 98, + 99, + 101, + 102, + 103, + 105, + 106, + 108, + 109 + ], + "right_coeff": 12, + "right_label": 474, + "right_support": [ + 2, + 6, + 7, + 9, + 10, + 11, + 12, + 16, + 20, + 21, + 27, + 31, + 32, + 33, + 34, + 36, + 37, + 41, + 42, + 43, + 45, + 51, + 52, + 53, + 58, + 59, + 60, + 64, + 65, + 66, + 70, + 71, + 72, + 76, + 77, + 79, + 80, + 82, + 83, + 84, + 85, + 88, + 92, + 93, + 95, + 96, + 97, + 99, + 103, + 107, + 108, + 109 + ] + }, + { + "block": 0, + "copy_rank": 7, + "group": [ + 0, + 25, + 33, + 71, + 89 + ], + "left_coeff": 15, + "left_label": 479, + "left_support": [ + 0, + 1, + 3, + 4, + 5, + 6, + 7, + 9, + 10, + 11, + 13, + 14, + 15, + 17, + 18, + 19, + 22, + 23, + 24, + 25, + 26, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 36, + 37, + 41, + 42, + 43, + 44, + 46, + 47, + 48, + 49, + 50, + 54, + 55, + 56, + 58, + 59, + 60, + 64, + 65, + 66, + 70, + 71, + 72, + 76, + 81, + 88, + 94, + 99, + 103, + 107, + 108, + 109 + ], + "right_coeff": 16, + "right_label": 445, + "right_support": [ + 3, + 6, + 7, + 8, + 10, + 11, + 12, + 14, + 15, + 16, + 18, + 19, + 20, + 21, + 24, + 28, + 32, + 38, + 41, + 42, + 44, + 45, + 46, + 47, + 49, + 50, + 52, + 53, + 56, + 57, + 59, + 60, + 62, + 63, + 66, + 68, + 69, + 72, + 75, + 78, + 79, + 80, + 81, + 83, + 84, + 89, + 92, + 93, + 94, + 96, + 97, + 98, + 99, + 101, + 102, + 103, + 105, + 106, + 108, + 109 + ] + }, + { + "block": 1, + "copy_rank": 7, + "group": [ + 1, + 2, + 35, + 47, + 65 + ], + "left_coeff": 7, + "left_label": 2, + "left_support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "right_coeff": 1, + "right_label": 19, + "right_support": [ + 1, + 6, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 20, + 21, + 22, + 23, + 24, + 25, + 27, + 28, + 29, + 30, + 32, + 33, + 34, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 48, + 49, + 50, + 57, + 58, + 59, + 60, + 67, + 68, + 69, + 70, + 71, + 72, + 77, + 80, + 87, + 92, + 94, + 95, + 96, + 97, + 99, + 100, + 101, + 102, + 107, + 108, + 109, + 110, + 111 + ] + }, + { + "block": 1, + "copy_rank": 7, + "group": [ + 1, + 2, + 35, + 47, + 65 + ], + "left_coeff": 31, + "left_label": 70, + "left_support": [ + 0, + 1, + 2, + 4, + 5, + 6, + 7, + 8, + 10, + 11, + 13, + 17, + 22, + 23, + 28, + 31, + 33, + 34, + 35, + 36, + 37, + 39, + 40, + 43, + 44, + 45, + 46, + 47, + 49, + 50, + 52, + 53, + 56, + 58, + 61, + 64, + 65, + 67, + 70, + 71, + 73, + 74, + 76, + 79, + 80, + 81, + 83, + 84, + 85, + 89, + 95, + 98, + 99, + 101, + 102, + 103, + 105, + 106, + 108, + 109 + ], + "right_coeff": 2, + "right_label": 35, + "right_support": [ + 2, + 6, + 7, + 9, + 10, + 11, + 13, + 14, + 15, + 17, + 18, + 19, + 22, + 23, + 24, + 25, + 26, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 36, + 37, + 41, + 42, + 43, + 45, + 51, + 52, + 53, + 57, + 61, + 62, + 63, + 67, + 68, + 69, + 73, + 74, + 75, + 77, + 81, + 88, + 92, + 93, + 95, + 96, + 97, + 98, + 100, + 101, + 102, + 104, + 105, + 106, + 110, + 111 + ] + }, + { + "block": 1, + "copy_rank": 8, + "group": [ + 1, + 2, + 35, + 47, + 65 + ], + "left_coeff": 11, + "left_label": 316, + "left_support": [ + 0, + 1, + 2, + 5, + 9, + 10, + 13, + 14, + 17, + 18, + 20, + 23, + 24, + 28, + 29, + 32, + 33, + 36, + 38, + 39, + 42, + 43, + 44, + 45, + 47, + 50, + 53, + 54, + 57, + 60, + 63, + 64, + 69, + 70, + 73, + 76, + 77, + 82, + 83, + 89, + 90, + 92, + 93, + 94, + 97, + 98, + 99, + 102, + 103, + 106, + 109, + 110 + ], + "right_coeff": 4, + "right_label": 50, + "right_support": [ + 0, + 3, + 4, + 5, + 7, + 8, + 12, + 17, + 18, + 19, + 20, + 21, + 25, + 28, + 29, + 30, + 32, + 33, + 34, + 35, + 41, + 42, + 43, + 44, + 45, + 48, + 49, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 62, + 63, + 70, + 71, + 72, + 73, + 74, + 75, + 78, + 79, + 82, + 83, + 84, + 87, + 88, + 92, + 95, + 96, + 97, + 100, + 101, + 102, + 103, + 110, + 111 + ] + }, + { + "block": 1, + "copy_rank": 7, + "group": [ + 1, + 2, + 35, + 47, + 65 + ], + "left_coeff": 6, + "left_label": 17, + "left_support": [ + 0, + 2, + 3, + 4, + 5, + 6, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 20, + 21, + 22, + 23, + 24, + 26, + 31, + 35, + 36, + 37, + 44, + 48, + 49, + 50, + 57, + 58, + 59, + 60, + 67, + 68, + 69, + 70, + 71, + 72, + 77, + 78, + 79, + 81, + 82, + 83, + 84, + 87, + 93, + 98, + 103, + 104, + 105, + 106 + ], + "right_coeff": 8, + "right_label": 268, + "right_support": [ + 0, + 5, + 7, + 8, + 9, + 10, + 12, + 13, + 14, + 19, + 21, + 23, + 24, + 26, + 27, + 28, + 29, + 31, + 32, + 33, + 37, + 40, + 42, + 43, + 47, + 48, + 49, + 51, + 52, + 54, + 57, + 58, + 59, + 61, + 62, + 64, + 69, + 71, + 72, + 74, + 75, + 76, + 77, + 80, + 81, + 82, + 83, + 87, + 88, + 89, + 90, + 92, + 97, + 102, + 103, + 104, + 105, + 107, + 108, + 110 + ] + }, + { + "block": 1, + "copy_rank": 8, + "group": [ + 1, + 2, + 35, + 47, + 65 + ], + "left_coeff": 2, + "left_label": 35, + "left_support": [ + 2, + 6, + 7, + 9, + 10, + 11, + 13, + 14, + 15, + 17, + 18, + 19, + 22, + 23, + 24, + 25, + 26, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 36, + 37, + 41, + 42, + 43, + 45, + 51, + 52, + 53, + 57, + 61, + 62, + 63, + 67, + 68, + 69, + 73, + 74, + 75, + 77, + 81, + 88, + 92, + 93, + 95, + 96, + 97, + 98, + 100, + 101, + 102, + 104, + 105, + 106, + 110, + 111 + ], + "right_coeff": 16, + "right_label": 328, + "right_support": [ + 0, + 3, + 5, + 6, + 9, + 11, + 12, + 14, + 17, + 19, + 21, + 22, + 24, + 25, + 28, + 30, + 31, + 33, + 37, + 38, + 40, + 41, + 43, + 44, + 45, + 46, + 48, + 50, + 51, + 53, + 54, + 56, + 57, + 59, + 62, + 65, + 67, + 69, + 70, + 72, + 73, + 75, + 77, + 78, + 80, + 81, + 83, + 85, + 87, + 88, + 90, + 93, + 94, + 96, + 100, + 102, + 103, + 105, + 108, + 111 + ] + }, + { + "block": 2, + "copy_rank": 8, + "group": [ + 3, + 50, + 69, + 84, + 91 + ], + "left_coeff": 16, + "left_label": 253, + "left_support": [ + 5, + 6, + 7, + 8, + 9, + 10, + 12, + 13, + 14, + 16, + 17, + 18, + 20, + 22, + 30, + 34, + 37, + 40, + 42, + 43, + 44, + 45, + 46, + 48, + 49, + 51, + 52, + 54, + 57, + 58, + 59, + 61, + 62, + 64, + 67, + 68, + 70, + 73, + 78, + 79, + 80, + 81, + 82, + 83, + 91, + 92, + 93, + 94, + 95, + 96, + 98, + 99, + 100, + 101, + 103, + 104, + 105, + 107, + 108, + 110 + ], + "right_coeff": 13, + "right_label": 397, + "right_support": [ + 1, + 2, + 3, + 6, + 10, + 11, + 14, + 15, + 16, + 17, + 24, + 26, + 27, + 28, + 31, + 32, + 36, + 37, + 39, + 40, + 41, + 42, + 46, + 47, + 48, + 51, + 56, + 57, + 58, + 61, + 66, + 68, + 69, + 70, + 71, + 73, + 74, + 78, + 79, + 83, + 84, + 87, + 88, + 89, + 92, + 96, + 97, + 101, + 102, + 103, + 104, + 107 + ] + }, + { + "block": 2, + "copy_rank": 8, + "group": [ + 3, + 50, + 69, + 84, + 91 + ], + "left_coeff": 18, + "left_label": 489, + "left_support": [ + 1, + 7, + 12, + 13, + 14, + 15, + 20, + 21, + 22, + 23, + 24, + 25, + 27, + 28, + 29, + 30, + 31, + 35, + 36, + 37, + 44, + 48, + 49, + 50, + 61, + 62, + 63, + 64, + 65, + 66, + 73, + 74, + 75, + 76, + 77, + 78, + 80, + 86, + 88, + 89, + 90, + 91, + 92, + 94, + 95, + 96, + 97, + 98, + 103, + 104, + 105, + 106 + ], + "right_coeff": 2, + "right_label": 276, + "right_support": [ + 1, + 5, + 6, + 8, + 9, + 10, + 15, + 16, + 17, + 18, + 21, + 23, + 24, + 25, + 27, + 28, + 29, + 31, + 34, + 35, + 36, + 40, + 42, + 43, + 45, + 46, + 50, + 51, + 52, + 54, + 57, + 58, + 59, + 63, + 65, + 66, + 67, + 68, + 70, + 74, + 75, + 76, + 77, + 79, + 81, + 82, + 83, + 86, + 88, + 89, + 90, + 93, + 97, + 99, + 100, + 101, + 106, + 107, + 108, + 110 + ] + }, + { + "block": 2, + "copy_rank": 7, + "group": [ + 3, + 50, + 69, + 84, + 91 + ], + "left_coeff": 15, + "left_label": 153, + "left_support": [ + 2, + 3, + 5, + 8, + 9, + 11, + 14, + 18, + 21, + 23, + 25, + 26, + 29, + 32, + 34, + 35, + 37, + 39, + 41, + 43, + 45, + 47, + 48, + 50, + 52, + 54, + 56, + 59, + 61, + 63, + 65, + 67, + 69, + 71, + 73, + 75, + 76, + 77, + 78, + 81, + 82, + 84, + 86, + 87, + 90, + 92, + 93, + 96, + 99, + 100, + 102, + 103, + 104, + 106, + 108, + 110 + ], + "right_coeff": 16, + "right_label": 253, + "right_support": [ + 5, + 6, + 7, + 8, + 9, + 10, + 12, + 13, + 14, + 16, + 17, + 18, + 20, + 22, + 30, + 34, + 37, + 40, + 42, + 43, + 44, + 45, + 46, + 48, + 49, + 51, + 52, + 54, + 57, + 58, + 59, + 61, + 62, + 64, + 67, + 68, + 70, + 73, + 78, + 79, + 80, + 81, + 82, + 83, + 91, + 92, + 93, + 94, + 95, + 96, + 98, + 99, + 100, + 101, + 103, + 104, + 105, + 107, + 108, + 110 + ] + }, + { + "block": 3, + "copy_rank": 7, + "group": [ + 4, + 24, + 44, + 96, + 101 + ], + "left_coeff": 1, + "left_label": 131, + "left_support": [ + 4, + 6, + 7, + 8, + 9, + 11, + 12, + 13, + 15, + 16, + 17, + 19, + 21, + 23, + 25, + 26, + 27, + 28, + 30, + 31, + 32, + 34, + 35, + 37, + 38, + 40, + 42, + 46, + 49, + 52, + 54, + 56, + 59, + 62, + 64, + 66, + 68, + 70, + 72, + 73, + 75, + 76, + 77, + 83, + 90, + 92, + 93, + 94, + 95, + 97, + 98, + 99, + 100, + 102, + 103, + 104, + 106, + 107, + 109, + 111 + ], + "right_coeff": 1, + "right_label": 131, + "right_support": [ + 4, + 6, + 7, + 8, + 9, + 11, + 12, + 13, + 15, + 16, + 17, + 19, + 21, + 23, + 25, + 26, + 27, + 28, + 30, + 31, + 32, + 34, + 35, + 37, + 38, + 40, + 42, + 46, + 49, + 52, + 54, + 56, + 59, + 62, + 64, + 66, + 68, + 70, + 72, + 73, + 75, + 76, + 77, + 83, + 90, + 92, + 93, + 94, + 95, + 97, + 98, + 99, + 100, + 102, + 103, + 104, + 106, + 107, + 109, + 111 + ] + }, + { + "block": 3, + "copy_rank": 8, + "group": [ + 4, + 24, + 44, + 96, + 101 + ], + "left_coeff": 8, + "left_label": 379, + "left_support": [ + 0, + 1, + 2, + 3, + 5, + 10, + 12, + 13, + 15, + 16, + 17, + 19, + 21, + 23, + 29, + 31, + 32, + 34, + 35, + 37, + 38, + 40, + 42, + 46, + 49, + 52, + 54, + 56, + 57, + 58, + 60, + 61, + 63, + 65, + 67, + 69, + 71, + 74, + 77, + 79, + 80, + 81, + 82, + 84, + 86, + 87, + 88, + 89, + 91, + 96, + 98, + 99, + 100, + 102, + 103, + 104, + 106, + 107, + 109, + 111 + ], + "right_coeff": 4, + "right_label": 28, + "right_support": [ + 0, + 1, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 27, + 28, + 29, + 30, + 32, + 33, + 34, + 35, + 36, + 37, + 44, + 51, + 52, + 53, + 54, + 55, + 56, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 77, + 81, + 82, + 83, + 84, + 88, + 89, + 90, + 91, + 92, + 93, + 98, + 107, + 108, + 109, + 110, + 111 + ] + }, + { + "block": 3, + "copy_rank": 8, + "group": [ + 4, + 24, + 44, + 96, + 101 + ], + "left_coeff": 4, + "left_label": 28, + "left_support": [ + 0, + 1, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 27, + 28, + 29, + 30, + 32, + 33, + 34, + 35, + 36, + 37, + 44, + 51, + 52, + 53, + 54, + 55, + 56, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 77, + 81, + 82, + 83, + 84, + 88, + 89, + 90, + 91, + 92, + 93, + 98, + 107, + 108, + 109, + 110, + 111 + ], + "right_coeff": 8, + "right_label": 379, + "right_support": [ + 0, + 1, + 2, + 3, + 5, + 10, + 12, + 13, + 15, + 16, + 17, + 19, + 21, + 23, + 29, + 31, + 32, + 34, + 35, + 37, + 38, + 40, + 42, + 46, + 49, + 52, + 54, + 56, + 57, + 58, + 60, + 61, + 63, + 65, + 67, + 69, + 71, + 74, + 77, + 79, + 80, + 81, + 82, + 84, + 86, + 87, + 88, + 89, + 91, + 96, + 98, + 99, + 100, + 102, + 103, + 104, + 106, + 107, + 109, + 111 + ] + }, + { + "block": 4, + "copy_rank": 7, + "group": [ + 5, + 42, + 43, + 45, + 88 + ], + "left_coeff": 1, + "left_label": 259, + "left_support": [ + 5, + 6, + 7, + 8, + 9, + 10, + 12, + 13, + 14, + 16, + 17, + 18, + 20, + 22, + 25, + 26, + 27, + 28, + 29, + 31, + 32, + 33, + 35, + 36, + 38, + 39, + 41, + 47, + 50, + 53, + 55, + 56, + 60, + 63, + 65, + 66, + 69, + 71, + 72, + 74, + 75, + 76, + 77, + 84, + 91, + 92, + 93, + 94, + 95, + 96, + 98, + 99, + 100, + 101, + 103, + 104, + 105, + 107, + 108, + 110 + ], + "right_coeff": 1, + "right_label": 259, + "right_support": [ + 5, + 6, + 7, + 8, + 9, + 10, + 12, + 13, + 14, + 16, + 17, + 18, + 20, + 22, + 25, + 26, + 27, + 28, + 29, + 31, + 32, + 33, + 35, + 36, + 38, + 39, + 41, + 47, + 50, + 53, + 55, + 56, + 60, + 63, + 65, + 66, + 69, + 71, + 72, + 74, + 75, + 76, + 77, + 84, + 91, + 92, + 93, + 94, + 95, + 96, + 98, + 99, + 100, + 101, + 103, + 104, + 105, + 107, + 108, + 110 + ] + } + ] + }, + "catalogue_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "priority_revision": 4, + "schema_version": 1, + "seed": "1f7fdfe435b7ba318188ae826892153b", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "task_id": "coverage-law-change" +} diff --git a/research/five-plane-port-p112-seed1f7fdfe4/CLAIM.md b/research/five-plane-port-p112-seed1f7fdfe4/CLAIM.md new file mode 100644 index 0000000000..5483834613 --- /dev/null +++ b/research/five-plane-port-p112-seed1f7fdfe4/CLAIM.md @@ -0,0 +1,10 @@ +# Coordination claim + +Claim posted before the construction run: + +- Discussion: https://github.com/CrocSwap/integer-mult-bounds/discussions/2292 +- Track/task: `recursive-interfaces / coverage-law-change` +- Seed: `1f7fdfe435b7ba318188ae826892153b` +- Exact base: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2` +- Scope: a five-dimensional port cover of the selected 112 `F2^9` labels, with exact block identity, support-rank charge and `unpaid=5` moment screen. +- Result: 22 five-frames plus one pair; 16 terms; copy charge 118; the local `a=1/99` screen passes. A complete physical route and its overhead remain open. diff --git a/research/five-plane-port-p112-seed1f7fdfe4/PROOF.md b/research/five-plane-port-p112-seed1f7fdfe4/PROOF.md new file mode 100644 index 0000000000..a092b174f4 --- /dev/null +++ b/research/five-plane-port-p112-seed1f7fdfe4/PROOF.md @@ -0,0 +1,41 @@ +# Exact identities and cost model + +Let `q_0,...,q_111` be the pinned selected labels in `F2^9`. Each has odd weight, so `q_i dot q_i=1`. The certificate partitions their indices into 22 groups of five and one group of two. Every two different labels in a group have dot product zero. Thus each group matrix `A_g` has `A_g^T A_g=I`. + +For each group, the verifier stores a binary matrix `M_g`. Direct bit arithmetic checks + +```text +sum_g A_g M_g A_g^T = I_9. +``` + +It then writes each `M_g` as a sum of rank-one matrices `u v^T`. For each such term, let `l=sum_{r:u_r=1} q_{g_r}` and `r=sum_{s:v_s=1} q_{g_s}`. Its action on port `(i,j)` is `(q_i dot l)(q_j dot r)`. Summing terms gives + +```text +sum_g sum_(u,v) (q_i dot l)(q_j dot r) + = q_i^T (sum_g A_g M_g A_g^T) q_j + = q_i dot q_j. +``` + +The full 112-by-112 port identity is therefore exact, including every forbidden zero entry. The actual source support is `{i:q_i dot l=1}` and target support is `{j:q_j dot r=1}`. The charged rank is the F2 rank of their selected label-pairing matrix. The certificate histogram is `{7:10,8:6}`, giving `10*7+6*8=118`. + +For the local address correction, `X_q` translates an address basis state `e_s` to `e_(s xor q)`, and + +```text +C_q = ((1+i)I + (1-i)X_q)/2. +``` + +Expansion gives `C_q^2=X_q`. Every `X_q` is a translation, so the `C_q` commute. For every block `g`, + +```text +C_g^2 = product_(q in g) X_q = X_(xor_(q in g) q). +``` + +The verifier checks this equality exactly with Gaussian-integer numerators and common denominator `2^(2|g|)` on every one of the 512 address basis states for all 23 blocks. The decoder and correction identities accept arbitrary dirty source and target values; the finite endpoint controls check all 112 source basis vectors against three dirty-target patterns, plus zero-source preservation. + +## Conditional moment calculation + +The pinned selected word has profile `{1:2412,2:418,3:432,4:142,5:82,8:8}`. Replacing the eight rank-8 centre children by the 16 decoder terms yields `{1:2412,2:418,3:432,4:142,5:82,7:10,8:6}`. Its paid mass is 5,640 and its centre charge is 118. + +The exact pinned `ceiling.py` relaxation is evaluated at width `m=73`, `families=896`, `stages=9`, `unpaid=5`, and `a=1/99`. It uses the halving cap `R=51` and assigns all residual mass to rank 51, which is favorable to the proposed profile. The resulting interval is strictly below one at the target. The ceiling bracket and exact target interval are stored in `CANDIDATE.json`. + +To bound aggregate implementation overhead, the verifier adds each extra unit as a rank-1 child and increases the centre charge by the same amount. This conservative rank shape passes through total charge 275 and fails at 276. It is a price allowance for all unmodeled costs, not evidence that those operations can be supplied for that price. The exact 23 block translations can be provisionally charged one unit each, leaving 134 units; native routing, chart changes, hosting, restoration and precision still need a complete implementation and price. diff --git a/research/five-plane-port-p112-seed1f7fdfe4/README.md b/research/five-plane-port-p112-seed1f7fdfe4/README.md new file mode 100644 index 0000000000..b10a92098e --- /dev/null +++ b/research/five-plane-port-p112-seed1f7fdfe4/README.md @@ -0,0 +1,70 @@ +# Five-dimensional port decoder for selected P112 + +**Exact local algebraic construction; no new supplier or kappa.** This package constructs a five-dimensional port cover of the selected 112 labels in `F2^9`, solves the exact block identity, factors it into charged support terms, and verifies the dirty local endpoint. + +The cover has 22 pairwise-orthogonal five-frames and one orthogonal pair. The deterministic block solve gives + +```text +I_9 = sum_g A_g M_g A_g^T over F2 +``` + +and the 23 matrices factor into 16 rank-one terms. Their exact B14 support-pairing invoice is 10 terms of rank 7 and 6 terms of rank 8, total charge **118**. For any two selected port labels `q_i,q_j`, the resulting full decoder entry is `q_i^T I_9 q_j = q_i dot q_j`. + +## Construction and search scope + +The verifier reconstructs all 161,280 pairwise-orthogonal five-frames from the pinned selected-label set. A seed-fixed randomized greedy cover selects the first complete cover at attempt 365 after 7,438 greedy steps. It has a 10,000-attempt cap. This is a reproducible construction, not an optimum search or a universal statement about all covers. + +For each block `g`, its columns form `A_g`. The exact 81-equation F2 solve determines `M_g`; a canonical rank factorization gives source and target labels for every term. Each term is charged by the F2 rank of the selected label-pairing submatrix on its actual source and target supports. All 16 charges are positive. + +For a block `E`, define `C_E = product_{q in E} C_q`, where `C_q=((1+i)I+(1-i)X_q)/2`. Orthogonality makes the factors commute, and `C_q^2=X_q`; hence `C_E^2=X_(xor q in E)`. Exact Gaussian-dyadic replay checks this identity on all 512 address basis states for all 23 blocks. A separate dirty-input replay checks 672 source/target cases. + +## Cost ledger + +| Expense | Evidence or price | Limit | +|---|---|---| +| Source labels | 112 pinned `F2^9` labels read from the selected replay archive | Physical owner access is not mapped; include it in the overhead cap below. | +| Decoder copies / recursive ranks | 16 terms, rank histogram `{7:10,8:6}`, total 118 | Exact local support-rank invoice. | +| Helper state | No additional full-length helper is introduced by the algebraic identity | A physical schedule and its scratch restoration are not supplied. | +| Frame and interface transitions | Five-dimensional source and target port contract is explicit | Native chart changes and role transitions must fit the overhead cap. | +| Aggregate endpoint corrections | 23 exact translations `X_(xor q)` | One rank-one-equivalent unit per translation is provisional; then 134 units remain. | +| Hosting and dispatch | No owner placement or instruction schedule is claimed | Must fit the same remaining allowance. | +| Precision | Local correction numerators are exact Gaussian integers over denominator at most `2^10` | Global precision and tape costs are not priced. | +| Total additional costs | At most 157 rank-one-equivalent units beyond copy charge 118 | Exact `a=1/99` threshold; charge 275 passes and 276 fails. | + +## Favorable local cost screen + +Replacing the selected word's eight rank-8 centre children (64 mass) with the 16 terms (118 mass) gives the per-call profile + +```text +{1:2412, 2:418, 3:432, 4:142, 5:82, 7:10, 8:6} +``` + +with local mass 5,640. Applying the repository's exact relaxation with width 73, `w=896/9`, nine stages and `unpaid=5` gives a moment upper bound of `0.9774210973077914` at `a=1/99`; its certified ceiling is `0.017542237243537`. + +The exact profile leaves at most **157 additional rank-one-equivalent units** per call: total charge 275 still gives a moment upper bound `0.9999807669205109`, while 276 gives a lower bound `1.000124459083649`. The 23 exact aggregate translations `X_(xor q)` are identified. If each is provisionally priced at one rank-one-equivalent unit, 23 units are consumed and **134** remain for every other route, chart, hosting, restoration and precision cost. That unit price is a screening convention, not a realized native invoice. + +This is a local replacement-law screen. The five-unpaid endpoint contract, selected native owner placement, chart transitions, physical translation implementation, hosting, complete restoration and precision are not integrated. No selected exponent or kappa changes. + +## Reproduce + +From the repository root: + +```sh +python3 -I -O -B research/five-plane-port-p112-seed1f7fdfe4/verify.py +python3 research/five-plane-port-p112-seed1f7fdfe4/search.py --attempt-cap 10000 +python3 scripts/research_package.py --package research/five-plane-port-p112-seed1f7fdfe4 --check-only +``` + +The verifier prints `PASS_P112_FIVE_PLANE_PORT_DECODER`. Package replay targets Python 3.12; this session's direct replay used Python 3.14.7. The search writes `CANDIDATE.json` deterministically for the pinned seed and Python standard library. + +## Provenance and limits + +Base commit: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. Selected-record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. Catalogue revision 4 SHA-256: `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7`. Source archive and all live input hashes are pinned in [SOURCES.json](SOURCES.json). + +Discussion #1587 supplies the lower-dimensional plane-port endpoint; PR #1825 supplies the matched paired-plane cover. Discussion #2024 / PR #2041 studies three-plane P112 blocks and reports a bounded candidate that misses `a=1/99`. This work changes the block dimension to five and uses a seeded greedy incidence construction. Merged PR #1909 studies tetrad-local E8-root supports, a different support object. + +Prepared by Cinna Davis with substantial OpenAI Codex assistance in the formulation, search, implementation and exact replay. No independent human review is claimed. Apache-2.0. + +## Open next questions + +Can one selected native port route realize the five-frame interface within the remaining 134 rank-one-equivalent units after the provisional aggregate-translation charge? The next step is to map one block through its native chart and charge source access, frame changes, restoration and precision before extending to all 23 blocks. The current evidence is algebraic and does not establish that physical cost. diff --git a/research/five-plane-port-p112-seed1f7fdfe4/RESULT.json b/research/five-plane-port-p112-seed1f7fdfe4/RESULT.json new file mode 100644 index 0000000000..19fa619d61 --- /dev/null +++ b/research/five-plane-port-p112-seed1f7fdfe4/RESULT.json @@ -0,0 +1,70 @@ +{ + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "catalogue_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "cover": { + "attempt_cap": 10000, + "five_frame_count": 161280, + "five_frames": 22, + "found_at_attempt": 365, + "greedy_steps": 7438, + "residual_pair": [ + 55, + 104 + ] + }, + "decoder": { + "active_coefficient_entries": 45, + "block_identity": "I_9 = sum_g A_g M_g A_g^T over F2", + "copy_charge": 118, + "copy_rank_histogram": { + "7": 10, + "8": 6 + }, + "local_mass": 5640, + "local_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "7": 10, + "8": 6 + }, + "rank_one_terms": 16 + }, + "exact_checks": { + "dirty_endpoint_cases": 672, + "full_112_by_112_decoder_entries": 12544, + "gaussian_dyadic_correction_basis_cases": 11776, + "negative_controls": [ + "duplicate-port cover", + "coefficient corruption", + "deleted rank-one term" + ], + "positive_control": "56 paired-plane orthogonal matching" + }, + "limits": [ + "five-dimensional port contract is an algebraic endpoint hypothesis", + "native route, owner placement and frame transitions are unimplemented", + "aggregate translation one-unit price is provisional", + "hosting, complete restoration and precision are not integrated", + "no supplier, new kappa or selected-frontier claim" + ], + "local_screen": { + "aggregate_translation_count": 23, + "certified_ceiling_upper": 0.017542237243537, + "conditional_remaining_after_one_unit_per_translation": 134, + "first_failing_total_charge": 276, + "law": "unpaid=5", + "max_extra_rank1_equivalent_charge": 157, + "max_total_rank1_equivalent_charge": 275, + "moment_at_1_over_99": 0.9774210973077914 + }, + "priority_revision": 4, + "schema_version": 1, + "seed": "1f7fdfe435b7ba318188ae826892153b", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "status": "completed_local_algebraic_construction", + "task_id": "coverage-law-change", + "track": "recursive-interfaces" +} diff --git a/research/five-plane-port-p112-seed1f7fdfe4/SOURCES.json b/research/five-plane-port-p112-seed1f7fdfe4/SOURCES.json new file mode 100644 index 0000000000..d46d83b4be --- /dev/null +++ b/research/five-plane-port-p112-seed1f7fdfe4/SOURCES.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "research/community-frontier1094-audit/selected-replay.tar.gz", + "usage": "input", + "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f", + "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + { + "path": "research/paired-plane-port-matching-seed6c563a/CERTIFICATE.json", + "usage": "input", + "git_blob": "7ca668d7d50c7276e89b0f6f9575e1b9f1ad9ef6", + "sha256": "4fd648f7b5178bff5441bf364d58234b7bc1a43b924bc6da03013c948f1473b1" + } + ] +} diff --git a/research/five-plane-port-p112-seed1f7fdfe4/TASK.json b/research/five-plane-port-p112-seed1f7fdfe4/TASK.json new file mode 100644 index 0000000000..e45bd611ac --- /dev/null +++ b/research/five-plane-port-p112-seed1f7fdfe4/TASK.json @@ -0,0 +1,63 @@ +{ + "schema_version": 1, + "task_id": "coverage-law-change", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "coverage-law-change", + "question": "Can a template or call contract leave two or more unpaid coordinates per live family?", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/idle-axis-hosting/PROOF.md", + "certificates/selected-result.json" + ], + "methods": [ + "State a replacement for the coverage identity (mass = 72W + 64N) and the contract change that realizes it, with its implementation cost.", + "Find an obstruction: show which data-endpoint obligation forces exactly one unpaid coordinate in the current template." + ], + "acceptance_gate": "An explicit replacement identity, verified on a small complete instance with dirty inputs, priced with ceiling.ceiling(unpaid=...).", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Explain where the single unpaid coordinate per family comes from in the hosted template; propose one change and price it. Ideal budget: two unpaid coordinates per family is 3.77x (levers.py).", + "bottleneck_link": "The deficit is one coordinate per family minus the centre charge; doubling unpaid coordinates per family scales it directly.", + "allowed_variations": [ + "One template change or one endpoint-contract change.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Counting a coordinate as unpaid while leaving it unadvanced in the data endpoint." + ], + "overlap_terms": [ + "coverage identity", + "unpaid coordinate", + "deficit law", + "W - 64N" + ] + }, + "scope_status": "refined", + "actual_scope": "Construct one exact five-dimensional port decoder for the selected 112 labels in F2^9: partition them into 22 orthogonal five-frames plus one orthogonal pair, solve the block identity, factor it into charged B14 support terms, and screen the u=5 local profile.", + "scope_change_reason": "Changed the endpoint contract from line/plane/three-plane ports to five-dimensional ports and changed the object from a prior matched or tri-plane decoder to a five-frame cover of the selected F2^9 labels. The bounded method uses seeded randomized greedy incidence construction followed by an exact F2 block solve and support-rank factorization.", + "bottleneck_link": "Five unpaid coordinates increase the local deficit per live family. The exact five-frame decoder costs 118 copied-rank units and has a favorable selected-word moment screen, subject to a priced physical route and endpoint implementation.", + "budget_minutes": 60, + "stop_rule": "Enumerate all selected-label five-frames, then run the seed-fixed randomized greedy cover for at most 10,000 attempts. Stop at the first full cover whose deterministic block solve factors into positive-charge terms and passes the exact a=1/99 u=5 local screen; do not optimize beyond the first accepted cover. The run stops at attempt 365. No supplier or kappa claim without all remaining interface costs.", + "outcome": "completed", + "evidence": "CANDIDATE.json stores the 22 five-frames, residual pair, 23 F2 coefficient matrices and 16 rank-one support terms. The verified copy-rank histogram is {7:10,8:6}, charge 118. Exact replay checks the full 112x112 decoder, 11,776 C_E^2 address-basis cases and 672 dirty-input endpoint cases. Under the changed u=5 moment relaxation, a=1/99 passes; all other implementation overhead must fit within 157 additional rank-one-equivalent units, or 134 after provisionally charging one unit for each of 23 aggregate translations. No physical supplier or kappa is established.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance in mathematical formulation, search, verifier implementation, exact checks and packaging. No independent human review is claimed.", + "open_questions": [ + { + "question": "Can the five-frame source access, port chart transitions, aggregate translations, hosting, restoration and precision be realized at total extra charge at most 157 rank-one-equivalent units per call (134 after the provisional aggregate-translation charge)?", + "why_it_matters": "The local moment screen passes only under the changed u=5 contract and the stated total cost cap; excess route or precision cost removes the target-saving screen.", + "first_step": "Map one five-frame through the selected native port chart, count every local operator and restoration, and convert the complete operation list into the selected paid-rank model.", + "blocked_by": "The current package proves an algebraic endpoint and support-rank invoice, but it does not provide the selected native owner placement, chart schedule, or a rank-equivalent price for precision." + } + ] +} diff --git a/research/five-plane-port-p112-seed1f7fdfe4/VERIFY.json b/research/five-plane-port-p112-seed1f7fdfe4/VERIFY.json new file mode 100644 index 0000000000..6d5a7da899 --- /dev/null +++ b/research/five-plane-port-p112-seed1f7fdfe4/VERIFY.json @@ -0,0 +1,23 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/community-frontier1094-audit/selected-replay.tar.gz", + "research/complex-local-word-ceiling/ceiling.py", + "research/paired-plane-port-matching-seed6c563a/CERTIFICATE.json" + ], + "commands": [ + { + "argv": ["{python}", "-I", "-O", "-B", "{package}/verify.py"], + "timeout_seconds": 180, + "checks": "Pinned inputs, exact 5-frame cover and F2 identity, rank-one support charges, full 112-port decoder, exact dirty Gaussian-dyadic endpoint corrections, exact u=5 moment and overhead bracket, positive paired-plane control and corruption controls." + }, + { + "argv": ["{python}", "{package}/search.py", "--attempt-cap", "10000"], + "timeout_seconds": 180, + "checks": "Reproduces the seed-fixed randomized greedy cover and saved first accepted coefficient factorization." + } + ] +} diff --git a/research/five-plane-port-p112-seed1f7fdfe4/core.py b/research/five-plane-port-p112-seed1f7fdfe4/core.py new file mode 100644 index 0000000000..5e1b875db8 --- /dev/null +++ b/research/five-plane-port-p112-seed1f7fdfe4/core.py @@ -0,0 +1,243 @@ +#!/usr/bin/env python3 +"""Finite F2 routines for the five-plane P112 port construction.""" +from __future__ import annotations +import hashlib, importlib.util, json, random, tarfile +from pathlib import Path +ROOT = Path(__file__).resolve().parents[2] +PACKAGE = Path(__file__).resolve().parent +PORTS, DIM = 112, 9 +SEED = "1f7fdfe435b7ba318188ae826892153b" +ARCHIVE_MEMBER = "candidate/strict/global/base/work/complex-nine-native/DATA-PHASES.json" +def need(ok: bool, why: str) -> None: + if not ok: raise ValueError(why) +def dot(a: int, b: int) -> int: return (a & b).bit_count() & 1 +def rank_rows(rows: list[int], width: int) -> int: + pivots = {} + for value0 in rows: + value = value0 + while value: + p = value.bit_length() - 1 + if p in pivots: value ^= pivots[p] + else: pivots[p] = value; break + return len(pivots) +def indices(mask: int, n: int = PORTS) -> list[int]: + return [i for i in range(n) if (mask >> i) & 1] +def load_sources() -> tuple[list[int], dict]: + manifest = json.loads((PACKAGE / "SOURCES.json").read_text()) + for row in manifest["files"]: + if row["usage"] == "input": + path = ROOT / row["path"] + need(path.is_file(), "missing pinned input: " + row["path"]) + need(hashlib.sha256(path.read_bytes()).hexdigest() == row["sha256"], + "live input hash mismatch: " + row["path"]) + archive = ROOT / "research/community-frontier1094-audit/selected-replay.tar.gz" + with tarfile.open(archive, "r:gz") as tf: + member = tf.extractfile(ARCHIVE_MEMBER) + need(member is not None, "selected DATA-PHASES member missing") + data = json.loads(member.read()) + need(data["ports"] == PORTS, "selected port count") + recipes = sorted(data["recipes"], key=lambda x: x["port"]) + need(len(recipes) == PORTS and [x["port"] for x in recipes] == list(range(PORTS)), + "selected recipe order/count") + labels = [x["q"] for x in recipes] + need(len(set(labels)) == PORTS and all(0 < q < (1 << DIM) for q in labels), + "selected labels distinct 9-bit values") + need(all(q.bit_count() in (3, 7) for q in labels), "selected label weight") + # Positive control: the pinned predecessor's 56 zero-dot pairs still cover P112. + cert = json.loads((ROOT / "research/paired-plane-port-matching-seed6c563a/CERTIFICATE.json").read_text()) + pairs = cert["matching"] + used = [] + for pair in pairs: + need(len(pair) == 2 and pair[0] != pair[1], "paired-plane control edge") + need(dot(labels[pair[0]], labels[pair[1]]) == 0, "paired-plane control orthogonality") + used.extend(pair) + need(len(pairs) == PORTS // 2 and sorted(used) == list(range(PORTS)), + "paired-plane control is not a perfect matching") + return labels, data +def orthogonal_pair(mask: int, labels: list[int]) -> bool: + pair = indices(mask, len(labels)) + return len(pair) == 2 and dot(labels[pair[0]], labels[pair[1]]) == 0 +def five_frame_incidence(labels: list[int]) -> tuple[list[list[int]], int]: + """Enumerate all five-cliques in the selected-label orthogonality graph.""" + n = len(labels); adjacency = [0] * n + for i in range(n): + for j in range(i + 1, n): + if dot(labels[i], labels[j]) == 0: + adjacency[i] |= 1 << j; adjacency[j] |= 1 << i + by_port = [[] for _ in labels]; total = 0 + def visit(prefix: list[int], candidates: int) -> None: + nonlocal total + if len(prefix) == 5: + mask = sum(1 << i for i in prefix); total += 1 + for i in prefix: by_port[i].append(mask) + return + while candidates: + bit = candidates & -candidates; i = bit.bit_length() - 1; candidates ^= bit + visit(prefix + [i], candidates & adjacency[i]) + visit([], (1 << n) - 1) + return by_port, total +def find_cover(labels: list[int], max_attempts: int = 10_000) -> dict | None: + """Seeded randomized greedy cover; stops at the first exact 5-frame cover.""" + by_port, frame_count = five_frame_incidence(labels) + rng = random.Random(int(SEED, 16)) + full = (1 << len(labels)) - 1 + nodes = 0 + for attempt in range(1, max_attempts + 1): + remaining = full + groups: list[list[int]] = [] + while remaining.bit_count() > 2: + nodes += 1 + if remaining.bit_count() == 7: + candidates = [] + for i in indices(remaining, len(labels)): + for frame in by_port[i]: + if (frame & remaining) == frame and (remaining ^ frame).bit_count() == 2 \ + and orthogonal_pair(remaining ^ frame, labels): + candidates.append(frame) + else: + i = (remaining & -remaining).bit_length() - 1 + candidates = [frame for frame in by_port[i] if (frame & remaining) == frame] + if not candidates: + break + chosen = rng.choice(candidates) + groups.append(indices(chosen, len(labels))) + remaining ^= chosen + if remaining.bit_count() == 2 and orthogonal_pair(remaining, labels): + return {"groups": groups, "residual": indices(remaining, len(labels)), + "attempt": attempt, "greedy_steps": nodes, + "five_frame_count": frame_count, "attempt_cap": max_attempts} + return None + +def xor_selected(values: list[int], mask: int) -> int: + result = 0 + for i, value in enumerate(values): + if (mask >> i) & 1: result ^= value + return result + +def solve_identity(blocks: list[list[int]], labels: list[int]) -> list[list[list[int]]] | None: + """Deterministic column-echelon solution of sum A_g M_g A_g^T = I_9 over F2.""" + variables = [(g, a, b) for g in blocks for a in range(len(g)) for b in range(len(g))] + basis: list[tuple[int, int] | None] = [None] * (DIM * DIM) + for z, (g, a, b) in enumerate(variables): + value = 0 + for r in range(DIM): + if (labels[g[a]] >> r) & 1: + for c in range(DIM): + if (labels[g[b]] >> c) & 1: value |= 1 << (r * DIM + c) + coefficients = 1 << z + while value: + pivot = value.bit_length() - 1 + if basis[pivot] is None: + basis[pivot] = (value, coefficients); break + vector, combo = basis[pivot]; value ^= vector; coefficients ^= combo + target = sum(1 << (r * DIM + r) for r in range(DIM)); solution = 0 + while target: + pivot = target.bit_length() - 1 + if basis[pivot] is None: return None + vector, combo = basis[pivot]; target ^= vector; solution ^= combo + matrices = []; z = 0 + for g in blocks: + d = len(g); matrix = [[0] * d for _ in range(d)] + for a in range(d): + for b in range(d): matrix[a][b] = (solution >> z) & 1; z += 1 + matrices.append(matrix) + need(z == len(variables), "internal coefficient count") + return matrices + +def factor_matrix(group: list[int], matrix: list[list[int]], labels: list[int], block: int) -> list[dict]: + d = len(group) + columns = [sum((matrix[r][c] & 1) << r for r in range(d)) for c in range(d)] + basis: list[int] = [] + for col in columns: + if rank_rows(basis + [col], d) > len(basis): basis.append(col) + terms = [] + for k, left_coeff in enumerate(basis): + coordinates = [] + for col in columns: + match = next((mask for mask in range(1 << len(basis)) + if xor_selected(basis, mask) == col), None) + need(match is not None, "matrix column outside its basis"); coordinates.append(match) + right_coeff = sum(1 << j for j, coords in enumerate(coordinates) if (coords >> k) & 1) + left_label = xor_selected([labels[i] for i in group], left_coeff) + right_label = xor_selected([labels[i] for i in group], right_coeff) + left_support = [i for i, q in enumerate(labels) if dot(q, left_label)] + right_support = [i for i, q in enumerate(labels) if dot(q, right_label)] + pair_rows = [sum(dot(labels[i], labels[j]) << k for k, j in enumerate(right_support)) + for i in left_support] + copy_rank = rank_rows(pair_rows, len(right_support)) + terms.append({"block": block, "group": group, "left_coeff": left_coeff, + "right_coeff": right_coeff, "left_label": left_label, + "right_label": right_label, "left_support": left_support, + "right_support": right_support, "copy_rank": copy_rank}) + for r in range(d): + for c in range(d): + got = 0 + for term in terms: + got ^= ((term["left_coeff"] >> r) & 1) & ((term["right_coeff"] >> c) & 1) + need(got == matrix[r][c], "rank-one factors do not reconstruct their block") + return terms +def load_ceiling(): + path = ROOT / "research/complex-local-word-ceiling/ceiling.py" + spec = importlib.util.spec_from_file_location("pinned_complex_ceiling", path) + need(spec is not None and spec.loader is not None, "ceiling module load") + module = importlib.util.module_from_spec(spec); spec.loader.exec_module(module) + return module + +def profile_for(copy_hist: dict[int, int]) -> tuple[dict[int, int], int]: + profile = {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8} + profile[8] -= 8 + for rank, count in copy_hist.items(): profile[rank] = profile.get(rank, 0) + count + return profile, sum(rank * count for rank, count in copy_hist.items()) + +def moment_screen(profile: dict[int, int], centre: int) -> dict: + from fractions import Fraction + module = load_ceiling(); a = Fraction(1, 99) + moment = module.relax(profile, 73, 896, 9, centre, a, unpaid=5) + cap = module.ceiling(profile, 73, 896, 9, centre, unpaid=5) + return {"moment_lower": str(moment[0]), "moment_upper": str(moment[1]), + "moment_lower_decimal": float(moment[0]), "moment_upper_decimal": float(moment[1]), "ceiling_lower": str(cap[0]), + "ceiling_upper": str(cap[1]), "ceiling_upper_decimal": float(cap[1])} + +def all_in_rank1_threshold(profile: dict[int, int], centre: int) -> dict: + from fractions import Fraction + module = load_ceiling(); lo, hi = centre, 1000 + while hi - lo > 1: + mid = (lo + hi) // 2; trial = profile.copy(); trial[1] += mid - centre + if module.relax(trial, 73, 896, 9, mid, Fraction(1, 99), unpaid=5)[1] < 1: + lo = mid + else: hi = mid + values = [] + for total in (lo, hi): + trial = profile.copy(); trial[1] += total - centre + values.append({"total_rank1_equivalent_charge": total, + "extra_rank1_equivalent_charge": total - centre, + **moment_screen(trial, total)}) + return {"largest_passing": values[0], "first_failing": values[1]} + +def make_candidate(cover: dict, labels: list[int]) -> dict: + groups = cover["groups"]; blocks = groups + [cover["residual"]] + matrices = solve_identity(blocks, labels) + need(matrices is not None, "cover does not span the identity equation") + terms = [term for b, (g, matrix) in enumerate(zip(blocks, matrices)) + for term in factor_matrix(g, matrix, labels, b)] + histogram: dict[int, int] = {} + for term in terms: + charge = term["copy_rank"] + need(charge > 0, "zero-copy term is outside this priced interface") + histogram[charge] = histogram.get(charge, 0) + 1 + copy_charge = sum(rank * count for rank, count in histogram.items()) + profile, centre = profile_for(histogram) + need(centre == copy_charge, "centre charge mismatch") + shift_blocks = len(blocks) + shifted_profile = profile.copy(); shifted_profile[1] += shift_blocks + return {**cover, "blocks": blocks, "coefficient_matrices": matrices, "terms": terms, + "term_count": len(terms), + "copy_rank_histogram": {str(k): v for k, v in sorted(histogram.items())}, + "copy_charge": copy_charge, + "local_profile": {str(k): v for k, v in sorted(profile.items()) if v}, + "local_mass": sum(k * v for k, v in profile.items()), + "moment_screen_u5": moment_screen(profile, centre), + "aggregate_translation_count": shift_blocks, + "one_unit_per_aggregate_translation_screen": moment_screen( + shifted_profile, centre + shift_blocks), + "all_in_rank1_overhead_threshold": all_in_rank1_threshold(profile, centre)} diff --git a/research/five-plane-port-p112-seed1f7fdfe4/search.py b/research/five-plane-port-p112-seed1f7fdfe4/search.py new file mode 100644 index 0000000000..14acbc6942 --- /dev/null +++ b/research/five-plane-port-p112-seed1f7fdfe4/search.py @@ -0,0 +1,46 @@ +#!/usr/bin/env python3 +"""Find and price one five-dimensional P112 port cover.""" +from __future__ import annotations +import argparse, importlib.util, json +from pathlib import Path + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +spec = importlib.util.spec_from_file_location("five_plane_core", PACKAGE / "core.py") +core = importlib.util.module_from_spec(spec) +spec.loader.exec_module(core) + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--attempt-cap", type=int, default=10_000) + parser.add_argument("--out", type=Path, default=PACKAGE / "CANDIDATE.json") + args = parser.parse_args() + core.need(args.attempt_cap > 0, "positive attempt cap") + labels, _ = core.load_sources() + cover = core.find_cover(labels, args.attempt_cap) + core.need(cover is not None, "no exact cover within the stated randomized-greedy cap") + candidate = core.make_candidate(cover, labels) + task = json.loads((PACKAGE / "TASK.json").read_text()) + sources = json.loads((PACKAGE / "SOURCES.json").read_text()) + result = { + "schema_version": 1, + "seed": core.SEED, + "task_id": task["task_id"], + "priority_revision": task["priority_revision"], + "base_commit": task["base_commit"], + "selected_record_sha256": next(x["sha256"] for x in sources["files"] + if x["path"] == "certificates/selected-result.json"), + "catalogue_sha256": next(x["sha256"] for x in sources["files"] + if x["path"] == "docs/research/agent-task-catalog.json"), + "candidate": candidate, + } + args.out.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print("FOUND_FIVE_PLANE_P112", + f"attempt={cover['attempt']}", f"steps={cover['greedy_steps']}", + f"frames={cover['five_frame_count']}", f"terms={candidate['term_count']}", + f"copy_charge={candidate['copy_charge']}", + f"copy_hist={candidate['copy_rank_histogram']}", + f"a_hi={candidate['moment_screen_u5']['ceiling_upper_decimal']:.12f}") + +if __name__ == "__main__": + main() diff --git a/research/five-plane-port-p112-seed1f7fdfe4/verify.py b/research/five-plane-port-p112-seed1f7fdfe4/verify.py new file mode 100644 index 0000000000..54f2f37507 --- /dev/null +++ b/research/five-plane-port-p112-seed1f7fdfe4/verify.py @@ -0,0 +1,199 @@ +#!/usr/bin/env python3 +"""Exact replay of the five-plane P112 local decoder certificate.""" +from __future__ import annotations +import copy, importlib.util, json +from pathlib import Path +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +spec = importlib.util.spec_from_file_location("five_plane_verify_core", PACKAGE / "core.py") +core = importlib.util.module_from_spec(spec) +spec.loader.exec_module(core) + +def matrix_from_blocks(blocks, matrices, labels): + out = [[0] * core.DIM for _ in range(core.DIM)] + for group, matrix in zip(blocks, matrices): + core.need(len(matrix) == len(group) and all(len(row) == len(group) for row in matrix), + "coefficient matrix shape") + for a, i in enumerate(group): + for b, j in enumerate(group): + if matrix[a][b]: + for r in range(core.DIM): + if (labels[i] >> r) & 1: + for c in range(core.DIM): + if (labels[j] >> c) & 1: out[r][c] ^= 1 + return out + +def support_rank(left, right, labels): + rows = [sum(core.dot(labels[i], labels[j]) << k for k, j in enumerate(right)) + for i in left] + return core.rank_rows(rows, len(right)) + +def check_cover(candidate, labels): + groups = candidate["groups"]; residual = candidate["residual"] + core.need(len(groups) == 22 and all(len(g) == 5 for g in groups), "22 five-frames") + core.need(len(residual) == 2, "one residual pair") + blocks = groups + [residual] + flat = [i for g in blocks for i in g] + core.need(sorted(flat) == list(range(core.PORTS)), "cover is not a partition of P112") + for group in blocks: + core.need(len(set(group)) == len(group), "repeated port inside block") + for i in group: + core.need(core.dot(labels[i], labels[i]) == 1, "frame vector has wrong norm") + for p, i in enumerate(group): + for j in group[p + 1:]: + core.need(core.dot(labels[i], labels[j]) == 0, "block is not an orthogonal frame") + return blocks + +def check_terms(candidate, labels): + blocks = candidate["blocks"]; matrices = candidate["coefficient_matrices"] + core.need(len(blocks) == len(matrices) == 23, "block/matrix count") + got = matrix_from_blocks(blocks, matrices, labels) + core.need(got == [[int(r == c) for c in range(core.DIM)] for r in range(core.DIM)], + "sum A_g M_g A_g^T is not I_9") + terms_by_block = [[] for _ in blocks]; hist = {} + for term in candidate["terms"]: + b = term["block"]; group = blocks[b] + core.need(term["group"] == group, "term block index/group mismatch") + d = len(group); left = term["left_coeff"]; right = term["right_coeff"] + core.need(0 < left < (1 << d) and 0 < right < (1 << d), "rank-one coefficient mask") + left_label = core.xor_selected([labels[i] for i in group], left) + right_label = core.xor_selected([labels[i] for i in group], right) + core.need(term["left_label"] == left_label and term["right_label"] == right_label, + "term label xor") + ls = [i for i, q in enumerate(labels) if core.dot(q, left_label)] + rs = [i for i, q in enumerate(labels) if core.dot(q, right_label)] + core.need(term["left_support"] == ls and term["right_support"] == rs, + "term support sets") + rank = support_rank(ls, rs, labels) + core.need(rank == term["copy_rank"] and rank > 0, "B14 support-pairing charge") + hist[rank] = hist.get(rank, 0) + 1; terms_by_block[b].append(term) + for b, matrix in enumerate(matrices): + group_terms = terms_by_block[b] + for r in range(len(matrix)): + for c in range(len(matrix)): + value = 0 + for term in group_terms: + value ^= ((term["left_coeff"] >> r) & 1) & ((term["right_coeff"] >> c) & 1) + core.need(value == matrix[r][c], "rank-one term reconstruction") + need_hist = {str(k): v for k, v in sorted(hist.items())} + core.need(need_hist == candidate["copy_rank_histogram"], "copy-rank histogram") + charge = sum(k * v for k, v in hist.items()) + core.need(charge == candidate["copy_charge"] == 118, "total copy charge") + # Independently verify the induced full 112 by 112 masked decoder. + for i in range(core.PORTS): + for j in range(core.PORTS): + value = 0 + for term in candidate["terms"]: + value ^= core.dot(labels[i], term["left_label"]) & core.dot(labels[j], term["right_label"]) + core.need(value == core.dot(labels[i], labels[j]), "full P112 decoder identity") + return hist +def apply_c(state, q): + out = {} + def add(index, a, b): + olda, oldb = out.get(index, (0, 0)); out[index] = (olda + a, oldb + b) + for index, (a, b) in state.items(): + add(index, a - b, a + b) + add(index ^ q, a + b, b - a) + return {i: z for i, z in out.items() if z != (0, 0)} + +def check_dirty_endpoint(blocks, labels, terms): + checks = 0; full_target = (1 << core.PORTS) - 1 + patterns = [0, full_target, sum(1 << i for i in range(core.PORTS) if i % 2 == 0)] + for source_index in range(core.PORTS): + for dirty in patterns: + for i in range(core.PORTS): + value = (dirty >> i) & 1 + for term in terms: + value ^= core.dot(labels[i], term["left_label"]) \ + & core.dot(labels[source_index], term["right_label"]) + expected = ((dirty >> i) & 1) ^ core.dot(labels[i], labels[source_index]) + core.need(value == expected, "dirty target source-basis action") + checks += 1 + for dirty in patterns: + for i in range(core.PORTS): + value = (dirty >> i) & 1 + core.need(value == ((dirty >> i) & 1), "zero-source dirty target changed") + checks += 1 + return checks + +def check_corrections(blocks, labels): + checks = 0 + for group in blocks: + shift = 0 + for i in group: shift ^= labels[i] + for start in range(1 << core.DIM): + state = {start: (1, 0)} + for i in group + group: state = apply_c(state, labels[i]) + expected = {start ^ shift: (1 << (2 * len(group)), 0)} + core.need(state == expected, "C_E squared is not the aggregate translation") + checks += 1 + return checks + +def main(): + labels, _ = core.load_sources() + record = json.loads((PACKAGE / "CANDIDATE.json").read_text()) + candidate = record["candidate"] + core.need(record["seed"] == core.SEED and record["base_commit"] == + "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", "candidate source pins") + blocks = check_cover(candidate, labels) + hist = check_terms(candidate, labels) + + # Re-run the bounded randomized-greedy construction to bind the saved cover to the seed. + replay = core.find_cover(labels, candidate["attempt_cap"]) + core.need(replay is not None and replay == {k: candidate[k] for k in + ("groups", "residual", "attempt", "greedy_steps", "five_frame_count", "attempt_cap")}, + "seeded construction replay") + core.need(candidate["attempt"] == 365 and candidate["greedy_steps"] == 7438 and + candidate["five_frame_count"] == 161280, "bounded search receipt") + + dirty_checks = check_dirty_endpoint(blocks, labels, candidate["terms"]) + correction_checks = check_corrections(blocks, labels) + core.need(dirty_checks == 672 and correction_checks == 23 * (1 << core.DIM), + "endpoint case count") + + # Negative controls: corrupt a block, an identity coefficient, and a rank-one term. + bad_cover = copy.deepcopy(candidate); bad_cover["residual"][0] = bad_cover["groups"][0][0] + rejected_cover = False + try: check_cover(bad_cover, labels) + except ValueError: rejected_cover = True + core.need(rejected_cover, "duplicate-port cover control accepted") + bad_matrix = copy.deepcopy(candidate); bad_matrix["coefficient_matrices"][0][0][0] ^= 1 + rejected_matrix = matrix_from_blocks(bad_matrix["blocks"], bad_matrix["coefficient_matrices"], labels) != \ + [[int(r == c) for c in range(core.DIM)] for r in range(core.DIM)] + core.need(rejected_matrix, "coefficient corruption control accepted") + dropped = candidate["terms"][1:] + rejected_term = any( + sum((core.dot(labels[i], t["left_label"]) & core.dot(labels[j], t["right_label"])) + for t in dropped) % 2 != core.dot(labels[i], labels[j]) + for i in range(core.PORTS) for j in range(core.PORTS)) + core.need(rejected_term, "deleted-term control accepted") + + profile, centre = core.profile_for(hist) + screen = core.moment_screen(profile, centre) + core.need(screen == candidate["moment_screen_u5"], "exact selected-word moment receipt") + core.need(screen["moment_upper_decimal"] < 1.0 and screen["ceiling_upper_decimal"] > 1 / 99, + "u=5 local screen does not pass a=1/99") + shifted = profile.copy(); shifted[1] += len(blocks) + shifted_screen = core.moment_screen(shifted, centre + len(blocks)) + core.need(shifted_screen == candidate["one_unit_per_aggregate_translation_screen"], + "aggregate-translation cost screen") + core.need(shifted_screen["moment_upper_decimal"] < 1.0, + "one rank-1 unit per aggregate correction exceeds target") + overhead = core.all_in_rank1_threshold(profile, centre) + core.need(overhead == candidate["all_in_rank1_overhead_threshold"], "overhead budget receipt") + core.need(overhead["largest_passing"]["total_rank1_equivalent_charge"] == 275 and + overhead["first_failing"]["total_rank1_equivalent_charge"] == 276 and + overhead["largest_passing"]["moment_upper_decimal"] < 1 < + overhead["first_failing"]["moment_lower_decimal"], "rank-1 overhead threshold") + + print("PASS_P112_FIVE_PLANE_PORT_DECODER", + f"frames={len(candidate['groups'])}+1x2", + f"cover_attempt={candidate['attempt']}", + f"terms={candidate['term_count']}", f"copy={candidate['copy_charge']}", + f"rank_hist={candidate['copy_rank_histogram']}", + f"endpoint_checks={correction_checks}", f"dirty_checks={dirty_checks}", + f"a_hi={screen['ceiling_upper_decimal']:.12f}", + f"rank1_overhead={overhead['largest_passing']['extra_rank1_equivalent_charge']}") + +if __name__ == "__main__": + main()