From 4a533aff2a7a87c9b36e077a31774b332a7f64bd Mon Sep 17 00:00:00 2001 From: commdata2338 <199849969+commdata2338@users.noreply.github.com> Date: Tue, 13 Oct 2026 18:45:46 -0500 Subject: [PATCH] Research: COPY floor 64 for two-coordinate P112 mixing with small free rectangles For all 28 P112 coordinate pairs and arbitrary GL(3,C) mixing of two original coordinate terms with one free correction, at least two replacement terms keep pairing rank at least eight, so the decoder's COPY cost stays at least 64. This holds for a nonzero correction with at most 23 rows and 23 columns, or with both supports at most 11. A rank-nine singleton completion attains the floor. Follows the two-coordinate handoff of PR #1331. No supplier or kappa claim. Adds research/p112-two-coordinate-small-rectangle/ only. Submitted by @commdata2338 with substantial AI assistance (OpenAI Codex research and implementation; packaged with Claude Code). --- .../CERTIFICATE.json | 15547 ++++++++++++++++ .../README.md | 267 + .../SOURCES.json | 30 + .../TASK.json | 119 + .../VALIDATION.md | 46 + .../VERIFY.json | 32 + .../independent_check.py | 213 + .../verify.py | 383 + 8 files changed, 16637 insertions(+) create mode 100644 research/p112-two-coordinate-small-rectangle/CERTIFICATE.json create mode 100644 research/p112-two-coordinate-small-rectangle/README.md create mode 100644 research/p112-two-coordinate-small-rectangle/SOURCES.json create mode 100644 research/p112-two-coordinate-small-rectangle/TASK.json create mode 100644 research/p112-two-coordinate-small-rectangle/VALIDATION.md create mode 100644 research/p112-two-coordinate-small-rectangle/VERIFY.json create mode 100644 research/p112-two-coordinate-small-rectangle/independent_check.py create mode 100644 research/p112-two-coordinate-small-rectangle/verify.py diff --git a/research/p112-two-coordinate-small-rectangle/CERTIFICATE.json b/research/p112-two-coordinate-small-rectangle/CERTIFICATE.json new file mode 100644 index 0000000000..e69ad4b112 --- /dev/null +++ b/research/p112-two-coordinate-small-rectangle/CERTIFICATE.json @@ -0,0 +1,15547 @@ +{ + "boundary": { + "common_odd_neighbors": [], + "deleted": [ + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "functional": 257, + "pair": [ + 0, + 1 + ], + "span_after": 8, + "span_before": 9, + "stratum": "plus" + }, + "controls": [ + "nonfree diagonal correction", + "singular factor change", + "inverse without ordinary transpose", + "twelve-row zero-product input outside theorem domain", + "twenty-four-row nonzero input outside theorem domain", + "source digest drift", + "omitted live input", + "false twelve-erasure span extension", + "corrupted support receipt" + ], + "fixtures": [ + { + "costs": [ + 8, + 8, + 0 + ], + "full_masked_matrix_rank": 9, + "name": "sharp singleton", + "pair": [ + 0, + 1 + ] + }, + { + "costs": [ + 9, + 9, + 9 + ], + "name": "dense singleton", + "pair": [ + 0, + 1 + ] + }, + { + "costs": [ + 9, + 9, + 9 + ], + "name": "complex ordinary transpose", + "pair": [ + 0, + 7 + ] + }, + { + "costs": [ + 9, + 9, + 9 + ], + "name": "four by five rectangle", + "pair": [ + 2, + 6 + ] + }, + { + "costs": [ + 8, + 9, + 9 + ], + "name": "zero left correction", + "pair": [ + 1, + 5 + ] + }, + { + "costs": [ + 8, + 9, + 9 + ], + "name": "zero right correction", + "pair": [ + 3, + 4 + ] + }, + { + "costs": [ + 8, + 9, + 9 + ], + "name": "zero correction", + "pair": [ + 0, + 1 + ] + }, + { + "costs": [ + 9, + 9, + 9 + ], + "name": "support cancellation", + "pair": [ + 0, + 1 + ] + }, + { + "costs": [ + 9, + 9, + 9 + ], + "name": "twenty-three by one rectangle", + "pair": [ + 0, + 1 + ] + } + ], + "free_boundary": { + "common_odd_neighbors": [ + 0 + ], + "deleted": [ + 27, + 28, + 31, + 32, + 69, + 70, + 73, + 74, + 77, + 78, + 81, + 82, + 85, + 86, + 89, + 90, + 93, + 94, + 97, + 98, + 103, + 104, + 107, + 108 + ], + "functional": 4, + "pair": [ + 0, + 1 + ], + "span_after": 7, + "span_before": 8, + "stratum": "x" + }, + "pairs": [ + { + "pair": [ + 0, + 1 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 0, + 2 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 0, + 3 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 35, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 0, + 4 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 36, + 37, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 66, + 67, + 68, + 69, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 98, + 99, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 66, + 67, + 70, + 71, + 72, + 73, + 74, + 75, + 78, + 79, + 80, + 81, + 82, + 83, + 86, + 87, + 88, + 89, + 90, + 91, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 34, + 35, + 36, + 37, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 76, + 77, + 78, + 79, + 80, + 81, + 84, + 85, + 86, + 87, + 88, + 89, + 92, + 93, + 94, + 95, + 96, + 97, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 0, + 5 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 38, + 39, + 40, + 41, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 62, + 63, + 64, + 65, + 70, + 71, + 72, + 73, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 94, + 95, + 96, + 97, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 24, + 25, + 27, + 28, + 29, + 30, + 31, + 33, + 34, + 35, + 38, + 39, + 40, + 41, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 62, + 63, + 64, + 65, + 68, + 69, + 72, + 73, + 74, + 75, + 76, + 77, + 80, + 81, + 82, + 83, + 84, + 85, + 88, + 89, + 90, + 91, + 92, + 93, + 96, + 97, + 98, + 99, + 100, + 101, + 103, + 104, + 105, + 106, + 107, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 24, + 25, + 26, + 28, + 29, + 30, + 31, + 32, + 34, + 35, + 38, + 39, + 40, + 41, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 62, + 63, + 64, + 65, + 68, + 69, + 70, + 71, + 74, + 75, + 76, + 77, + 78, + 79, + 82, + 83, + 84, + 85, + 86, + 87, + 90, + 91, + 92, + 93, + 94, + 95, + 98, + 99, + 100, + 101, + 102, + 104, + 105, + 106, + 107, + 108, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 38, + 39, + 40, + 41, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 62, + 63, + 64, + 65, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 0, + 6 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 38, + 39, + 40, + 41, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 62, + 63, + 64, + 65, + 68, + 69, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 98, + 99, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 27, + 30, + 31, + 32, + 33, + 34, + 35, + 38, + 39, + 40, + 41, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 62, + 63, + 64, + 65, + 69, + 70, + 71, + 72, + 73, + 75, + 76, + 77, + 79, + 81, + 82, + 83, + 84, + 85, + 87, + 89, + 90, + 91, + 93, + 94, + 95, + 96, + 97, + 99, + 100, + 101, + 102, + 103, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 27, + 28, + 29, + 32, + 33, + 34, + 35, + 38, + 39, + 40, + 41, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 62, + 63, + 64, + 65, + 68, + 70, + 71, + 72, + 73, + 74, + 76, + 77, + 78, + 80, + 82, + 83, + 84, + 85, + 86, + 88, + 90, + 91, + 92, + 94, + 95, + 96, + 97, + 98, + 100, + 101, + 102, + 103, + 104, + 105, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 38, + 39, + 40, + 41, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 62, + 63, + 64, + 65, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 0, + 7 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 36, + 37, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 66, + 67, + 70, + 71, + 72, + 73, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 94, + 95, + 96, + 97, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 27, + 29, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 66, + 67, + 68, + 69, + 71, + 73, + 74, + 75, + 77, + 78, + 79, + 80, + 81, + 83, + 85, + 86, + 87, + 88, + 89, + 91, + 92, + 93, + 95, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 105, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 27, + 28, + 30, + 32, + 33, + 34, + 35, + 36, + 37, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 66, + 67, + 68, + 69, + 70, + 72, + 74, + 75, + 76, + 78, + 79, + 80, + 81, + 82, + 84, + 86, + 87, + 88, + 89, + 90, + 92, + 93, + 94, + 96, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 106, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 1, + 2 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 1, + 3 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 100, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 1, + 4 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 36, + 37, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 66, + 67, + 68, + 69, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 98, + 99, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 34, + 35, + 38, + 39, + 40, + 41, + 42, + 43, + 46, + 47, + 48, + 49, + 50, + 51, + 54, + 55, + 56, + 57, + 58, + 59, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 98, + 99, + 100, + 101, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 44, + 45, + 46, + 47, + 48, + 49, + 52, + 53, + 54, + 55, + 56, + 57, + 60, + 61, + 62, + 63, + 64, + 65, + 68, + 69, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 1, + 5 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 38, + 39, + 40, + 41, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 62, + 63, + 64, + 65, + 70, + 71, + 72, + 73, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 94, + 95, + 96, + 97, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 24, + 25, + 26, + 28, + 29, + 30, + 31, + 32, + 34, + 35, + 36, + 37, + 40, + 41, + 42, + 43, + 44, + 45, + 48, + 49, + 50, + 51, + 52, + 53, + 56, + 57, + 58, + 59, + 60, + 61, + 64, + 65, + 66, + 67, + 70, + 71, + 72, + 73, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 94, + 95, + 96, + 97, + 100, + 101, + 103, + 104, + 105, + 106, + 107, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 24, + 25, + 27, + 28, + 29, + 30, + 31, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 42, + 43, + 44, + 45, + 46, + 47, + 50, + 51, + 52, + 53, + 54, + 55, + 58, + 59, + 60, + 61, + 62, + 63, + 66, + 67, + 70, + 71, + 72, + 73, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 94, + 95, + 96, + 97, + 100, + 101, + 102, + 104, + 105, + 106, + 107, + 108, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 70, + 71, + 72, + 73, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 94, + 95, + 96, + 97, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 1, + 6 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 38, + 39, + 40, + 41, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 62, + 63, + 64, + 65, + 68, + 69, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 98, + 99, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 27, + 28, + 29, + 32, + 33, + 34, + 35, + 36, + 37, + 39, + 41, + 42, + 43, + 45, + 46, + 47, + 48, + 49, + 51, + 53, + 54, + 55, + 56, + 57, + 59, + 60, + 61, + 63, + 65, + 66, + 67, + 68, + 69, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 98, + 99, + 100, + 101, + 102, + 103, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 27, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 40, + 42, + 43, + 44, + 46, + 47, + 48, + 49, + 50, + 52, + 54, + 55, + 56, + 57, + 58, + 60, + 61, + 62, + 64, + 66, + 67, + 68, + 69, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 1, + 7 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 36, + 37, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 66, + 67, + 70, + 71, + 72, + 73, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 94, + 95, + 96, + 97, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 27, + 28, + 30, + 32, + 33, + 34, + 35, + 37, + 38, + 39, + 40, + 41, + 43, + 44, + 45, + 47, + 49, + 50, + 51, + 52, + 53, + 55, + 57, + 58, + 59, + 61, + 62, + 63, + 64, + 65, + 67, + 70, + 71, + 72, + 73, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 94, + 95, + 96, + 97, + 100, + 101, + 102, + 103, + 105, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 27, + 29, + 31, + 32, + 33, + 34, + 35, + 36, + 38, + 39, + 40, + 41, + 42, + 44, + 45, + 46, + 48, + 50, + 51, + 52, + 53, + 54, + 56, + 58, + 59, + 60, + 62, + 63, + 64, + 65, + 66, + 70, + 71, + 72, + 73, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 94, + 95, + 96, + 97, + 100, + 101, + 102, + 103, + 104, + 106, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 70, + 71, + 72, + 73, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 94, + 95, + 96, + 97, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 2, + 3 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 25, + 34, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 101, + 110 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 2, + 4 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 36, + 37, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 66, + 67, + 68, + 69, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 98, + 99, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 14, + 15, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 16, + 17, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 100, + 101, + 102, + 103, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 2, + 5 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 38, + 39, + 40, + 41, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 62, + 63, + 64, + 65, + 70, + 71, + 72, + 73, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 94, + 95, + 96, + 97, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 9, + 10, + 11, + 12, + 13, + 15, + 17, + 18, + 19, + 20, + 21, + 23, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 10, + 11, + 12, + 13, + 14, + 16, + 18, + 19, + 20, + 21, + 22, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 36, + 37, + 40, + 41, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 62, + 63, + 66, + 67, + 68, + 69, + 72, + 73, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 94, + 95, + 98, + 99, + 100, + 101, + 102, + 103, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 2, + 6 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 38, + 39, + 40, + 41, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 62, + 63, + 64, + 65, + 68, + 69, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 98, + 99, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 12, + 13, + 14, + 15, + 16, + 17, + 20, + 21, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 34, + 35, + 36, + 37, + 38, + 40, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 63, + 65, + 66, + 67, + 68, + 70, + 71, + 72, + 73, + 74, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 93, + 94, + 95, + 96, + 97, + 99, + 100, + 101, + 104, + 105, + 106, + 107, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 14, + 15, + 16, + 17, + 18, + 19, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 34, + 35, + 36, + 37, + 39, + 41, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 62, + 64, + 66, + 67, + 69, + 70, + 71, + 72, + 73, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 94, + 95, + 96, + 97, + 98, + 100, + 101, + 104, + 105, + 106, + 107, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 104, + 105, + 106, + 107, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 2, + 7 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 36, + 37, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 66, + 67, + 70, + 71, + 72, + 73, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 94, + 95, + 96, + 97, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 11, + 13, + 14, + 15, + 16, + 17, + 19, + 21, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 34, + 35, + 36, + 38, + 39, + 40, + 41, + 42, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 61, + 62, + 63, + 64, + 65, + 67, + 68, + 69, + 70, + 72, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 95, + 97, + 98, + 99, + 100, + 101, + 104, + 105, + 106, + 107, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 12, + 14, + 15, + 16, + 17, + 18, + 20, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 34, + 35, + 37, + 38, + 39, + 40, + 41, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 62, + 63, + 64, + 65, + 66, + 68, + 69, + 71, + 73, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 94, + 96, + 98, + 99, + 100, + 101, + 104, + 105, + 106, + 107, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 104, + 105, + 106, + 107, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 3, + 4 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 36, + 37, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 66, + 67, + 68, + 69, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 98, + 99, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 36, + 37, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 66, + 67, + 68, + 69, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 98, + 99, + 100, + 101, + 102, + 103, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 36, + 37, + 42, + 43, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 60, + 61, + 66, + 67, + 68, + 69, + 74, + 75, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 92, + 93, + 98, + 99, + 100, + 101, + 102, + 103, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 36, + 37, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 66, + 67, + 68, + 69, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 98, + 99, + 100, + 101, + 102, + 103, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 3, + 5 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 38, + 39, + 40, + 41, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 62, + 63, + 64, + 65, + 70, + 71, + 72, + 73, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 94, + 95, + 96, + 97, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 10, + 11, + 12, + 13, + 14, + 17, + 18, + 19, + 20, + 21, + 23, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 38, + 39, + 40, + 41, + 44, + 45, + 46, + 47, + 50, + 51, + 52, + 53, + 56, + 57, + 58, + 59, + 62, + 63, + 64, + 65, + 70, + 71, + 72, + 73, + 76, + 77, + 78, + 79, + 82, + 83, + 84, + 85, + 88, + 89, + 90, + 91, + 94, + 95, + 96, + 97, + 100, + 101, + 102, + 103, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 9, + 10, + 11, + 12, + 13, + 15, + 16, + 18, + 19, + 20, + 21, + 22, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 38, + 39, + 40, + 41, + 44, + 45, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 58, + 59, + 62, + 63, + 64, + 65, + 70, + 71, + 72, + 73, + 76, + 77, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 90, + 91, + 94, + 95, + 96, + 97, + 100, + 101, + 102, + 103, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 38, + 39, + 40, + 41, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 62, + 63, + 64, + 65, + 70, + 71, + 72, + 73, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 94, + 95, + 96, + 97, + 100, + 101, + 102, + 103, + 108, + 109, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 3, + 6 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 38, + 39, + 40, + 41, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 62, + 63, + 64, + 65, + 68, + 69, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 98, + 99, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 14, + 15, + 16, + 17, + 20, + 21, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 34, + 35, + 38, + 39, + 40, + 41, + 44, + 46, + 47, + 48, + 49, + 50, + 53, + 54, + 55, + 56, + 57, + 59, + 62, + 63, + 64, + 65, + 68, + 69, + 74, + 75, + 76, + 77, + 78, + 80, + 82, + 83, + 84, + 85, + 87, + 89, + 90, + 91, + 92, + 93, + 98, + 99, + 100, + 101, + 104, + 105, + 106, + 107, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 34, + 35, + 38, + 39, + 40, + 41, + 45, + 46, + 47, + 48, + 49, + 51, + 52, + 54, + 55, + 56, + 57, + 58, + 62, + 63, + 64, + 65, + 68, + 69, + 74, + 75, + 76, + 77, + 79, + 81, + 82, + 83, + 84, + 85, + 86, + 88, + 90, + 91, + 92, + 93, + 98, + 99, + 100, + 101, + 104, + 105, + 106, + 107, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 34, + 35, + 38, + 39, + 40, + 41, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 62, + 63, + 64, + 65, + 68, + 69, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 98, + 99, + 100, + 101, + 104, + 105, + 106, + 107, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 3, + 7 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 34, + 35, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 100, + 101, + 110, + 111 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 36, + 37, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 66, + 67, + 70, + 71, + 72, + 73, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 94, + 95, + 96, + 97, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 12, + 14, + 15, + 16, + 17, + 19, + 21, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 34, + 35, + 36, + 37, + 42, + 43, + 44, + 45, + 46, + 48, + 50, + 51, + 52, + 53, + 55, + 57, + 58, + 59, + 60, + 61, + 66, + 67, + 70, + 71, + 72, + 73, + 76, + 78, + 79, + 80, + 81, + 82, + 85, + 86, + 87, + 88, + 89, + 91, + 94, + 95, + 96, + 97, + 100, + 101, + 104, + 105, + 106, + 107, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 11, + 13, + 14, + 15, + 16, + 17, + 18, + 20, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 34, + 35, + 36, + 37, + 42, + 43, + 44, + 45, + 47, + 49, + 50, + 51, + 52, + 53, + 54, + 56, + 58, + 59, + 60, + 61, + 66, + 67, + 70, + 71, + 72, + 73, + 77, + 78, + 79, + 80, + 81, + 83, + 84, + 86, + 87, + 88, + 89, + 90, + 94, + 95, + 96, + 97, + 100, + 101, + 104, + 105, + 106, + 107, + 110, + 111 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 34, + 35, + 36, + 37, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 66, + 67, + 70, + 71, + 72, + 73, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 94, + 95, + 96, + 97, + 100, + 101, + 104, + 105, + 106, + 107, + 110, + 111 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 4, + 5 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 36, + 37, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 66, + 67, + 68, + 69, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 98, + 99, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 38, + 39, + 40, + 41, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 62, + 63, + 64, + 65, + 70, + 71, + 72, + 73, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 94, + 95, + 96, + 97, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 4, + 5, + 6, + 7, + 8, + 15, + 16, + 23, + 26, + 33, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 102, + 109 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 9, + 14, + 17, + 22, + 27, + 32, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 103, + 108 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 4, + 6 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 36, + 37, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 66, + 67, + 68, + 69, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 98, + 99, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 38, + 39, + 40, + 41, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 62, + 63, + 64, + 65, + 68, + 69, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 98, + 99, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 2, + 3, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 51, + 52, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 99, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 1, + 4, + 5, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 45, + 50, + 53, + 58, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 69, + 74, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 93, + 98, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 98, + 99, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 4, + 7 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 36, + 37, + 42, + 43, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 60, + 61, + 66, + 67, + 68, + 69, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 98, + 99, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 36, + 37, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 66, + 67, + 70, + 71, + 72, + 73, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 94, + 95, + 96, + 97, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 1, + 3, + 5, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 36, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 83, + 84, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 0, + 2, + 4, + 6, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 37, + 42, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 61, + 66, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 77, + 82, + 85, + 90, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 36, + 37, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 5, + 6 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 38, + 39, + 40, + 41, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 62, + 63, + 64, + 65, + 70, + 71, + 72, + 73, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 94, + 95, + 96, + 97, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 38, + 39, + 40, + 41, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 62, + 63, + 64, + 65, + 68, + 69, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 98, + 99, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 1, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 38, + 41, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 62, + 65, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 78, + 81, + 86, + 89, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 2, + 3, + 4, + 5, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 39, + 40, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 63, + 64, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 79, + 80, + 87, + 88, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 38, + 39, + 40, + 41, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 62, + 63, + 64, + 65, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 5, + 7 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 23, + 26, + 27, + 32, + 33, + 38, + 39, + 40, + 41, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 62, + 63, + 64, + 65, + 70, + 71, + 72, + 73, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 94, + 95, + 96, + 97, + 102, + 103, + 108, + 109 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 36, + 37, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 66, + 67, + 70, + 71, + 72, + 73, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 94, + 95, + 96, + 97, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 2, + 5, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 46, + 49, + 54, + 57, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 70, + 73, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 94, + 97, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 1, + 3, + 4, + 6, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 47, + 48, + 55, + 56, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 71, + 72, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 95, + 96, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 70, + 71, + 72, + 73, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 94, + 95, + 96, + 97, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + }, + { + "pair": [ + 6, + 7 + ], + "pairing_ranks": [ + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 8, + 8, + 8 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ], + [ + 8, + 8, + 9, + 9, + 9 + ] + ], + "strata": [ + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "x", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 38, + 39, + 40, + 41, + 44, + 45, + 50, + 51, + 52, + 53, + 58, + 59, + 62, + 63, + 64, + 65, + 68, + 69, + 74, + 75, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 92, + 93, + 98, + 99, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 24, + "free_distance": 24, + "free_weight_spectrum": { + "24": 112, + "28": 112 + }, + "name": "y", + "span": 8, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 36, + 37, + 42, + 43, + 46, + 47, + 48, + 49, + 54, + 55, + 56, + 57, + 60, + 61, + 66, + 67, + 70, + 71, + 72, + 73, + 76, + 77, + 82, + 83, + 84, + 85, + 90, + 91, + 94, + 95, + 96, + 97, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "0": 1, + "24": 126, + "28": 256, + "32": 126, + "56": 2 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "plus", + "span": 9, + "support": [ + 0, + 3, + 4, + 7, + 10, + 13, + 18, + 21, + 28, + 31, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 104, + 107 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 12, + "free_distance": 34, + "free_weight_spectrum": { + "34": 76, + "36": 24, + "42": 12 + }, + "name": "minus", + "span": 9, + "support": [ + 1, + 2, + 5, + 6, + 11, + 12, + 19, + 20, + 29, + 30, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 105, + 106 + ], + "weight_spectrum": { + "12": 1, + "32": 2, + "34": 152, + "36": 60, + "38": 80, + "40": 60, + "42": 152, + "44": 2, + "64": 1, + "76": 1 + } + }, + { + "distance": 24, + "free_distance": 40, + "free_weight_spectrum": { + "40": 88, + "44": 24 + }, + "name": "generic", + "span": 9, + "support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 28, + 29, + 30, + 31, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 104, + 105, + 106, + 107 + ], + "weight_spectrum": { + "24": 1, + "32": 2, + "40": 188, + "44": 128, + "48": 188, + "56": 2, + "64": 1, + "88": 1 + } + } + ] + } + ], + "root_order": "lexicographic positive-first doubled E8 roots", + "roots": [ + [ + 0, + 0, + 0, + 0, + 0, + 2, + -2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + -2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + -2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 0, + -2 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 2, + 0 + ], + [ + 0, + 0, + 0, + 2, + -2, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 2, + 0, + -2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + -2, + 0 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + -2 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 2, + 0 + ], + [ + 0, + 0, + 0, + 2, + 0, + 2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 2, + 2, + 0, + 0, + 0 + ], + [ + 0, + 0, + 2, + 0, + -2, + 0, + 0, + 0 + ], + [ + 0, + 0, + 2, + 0, + 0, + -2, + 0, + 0 + ], + [ + 0, + 0, + 2, + 0, + 0, + 0, + -2, + 0 + ], + [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + -2 + ], + [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 2, + 0, + 0, + 0, + 2, + 0 + ], + [ + 0, + 0, + 2, + 0, + 0, + 2, + 0, + 0 + ], + [ + 0, + 0, + 2, + 0, + 2, + 0, + 0, + 0 + ], + [ + 0, + 2, + -2, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 2, + 0, + -2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 2, + 0, + 0, + -2, + 0, + 0, + 0 + ], + [ + 0, + 2, + 0, + 0, + 0, + -2, + 0, + 0 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + -2, + 0 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + -2 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + 2, + 0 + ], + [ + 0, + 2, + 0, + 0, + 0, + 2, + 0, + 0 + ], + [ + 0, + 2, + 0, + 0, + 2, + 0, + 0, + 0 + ], + [ + 0, + 2, + 0, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + -1, + -1, + -1, + -1, + -1, + -1, + 1 + ], + [ + 1, + -1, + -1, + -1, + -1, + -1, + 1, + -1 + ], + [ + 1, + -1, + -1, + -1, + -1, + 1, + -1, + -1 + ], + [ + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1 + ], + [ + 1, + -1, + -1, + -1, + 1, + -1, + -1, + -1 + ], + [ + 1, + -1, + -1, + -1, + 1, + -1, + 1, + 1 + ], + [ + 1, + -1, + -1, + -1, + 1, + 1, + -1, + 1 + ], + [ + 1, + -1, + -1, + -1, + 1, + 1, + 1, + -1 + ], + [ + 1, + -1, + -1, + 1, + -1, + -1, + -1, + -1 + ], + [ + 1, + -1, + -1, + 1, + -1, + -1, + 1, + 1 + ], + [ + 1, + -1, + -1, + 1, + -1, + 1, + -1, + 1 + ], + [ + 1, + -1, + -1, + 1, + -1, + 1, + 1, + -1 + ], + [ + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1 + ], + [ + 1, + -1, + -1, + 1, + 1, + -1, + 1, + -1 + ], + [ + 1, + -1, + -1, + 1, + 1, + 1, + -1, + -1 + ], + [ + 1, + -1, + -1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + -1, + 1, + -1, + -1, + -1, + -1, + -1 + ], + [ + 1, + -1, + 1, + -1, + -1, + -1, + 1, + 1 + ], + [ + 1, + -1, + 1, + -1, + -1, + 1, + -1, + 1 + ], + [ + 1, + -1, + 1, + -1, + -1, + 1, + 1, + -1 + ], + [ + 1, + -1, + 1, + -1, + 1, + -1, + -1, + 1 + ], + [ + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1 + ], + [ + 1, + -1, + 1, + -1, + 1, + 1, + -1, + -1 + ], + [ + 1, + -1, + 1, + -1, + 1, + 1, + 1, + 1 + ], + [ + 1, + -1, + 1, + 1, + -1, + -1, + -1, + 1 + ], + [ + 1, + -1, + 1, + 1, + -1, + -1, + 1, + -1 + ], + [ + 1, + -1, + 1, + 1, + -1, + 1, + -1, + -1 + ], + [ + 1, + -1, + 1, + 1, + -1, + 1, + 1, + 1 + ], + [ + 1, + -1, + 1, + 1, + 1, + -1, + -1, + -1 + ], + [ + 1, + -1, + 1, + 1, + 1, + -1, + 1, + 1 + ], + [ + 1, + -1, + 1, + 1, + 1, + 1, + -1, + 1 + ], + [ + 1, + -1, + 1, + 1, + 1, + 1, + 1, + -1 + ], + [ + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + [ + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1 + ], + [ + 1, + 1, + -1, + -1, + -1, + 1, + -1, + 1 + ], + [ + 1, + 1, + -1, + -1, + -1, + 1, + 1, + -1 + ], + [ + 1, + 1, + -1, + -1, + 1, + -1, + -1, + 1 + ], + [ + 1, + 1, + -1, + -1, + 1, + -1, + 1, + -1 + ], + [ + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1 + ], + [ + 1, + 1, + -1, + -1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 1, + -1, + 1, + -1, + -1, + -1, + 1 + ], + [ + 1, + 1, + -1, + 1, + -1, + -1, + 1, + -1 + ], + [ + 1, + 1, + -1, + 1, + -1, + 1, + -1, + -1 + ], + [ + 1, + 1, + -1, + 1, + -1, + 1, + 1, + 1 + ], + [ + 1, + 1, + -1, + 1, + 1, + -1, + -1, + -1 + ], + [ + 1, + 1, + -1, + 1, + 1, + -1, + 1, + 1 + ], + [ + 1, + 1, + -1, + 1, + 1, + 1, + -1, + 1 + ], + [ + 1, + 1, + -1, + 1, + 1, + 1, + 1, + -1 + ], + [ + 1, + 1, + 1, + -1, + -1, + -1, + -1, + 1 + ], + [ + 1, + 1, + 1, + -1, + -1, + -1, + 1, + -1 + ], + [ + 1, + 1, + 1, + -1, + -1, + 1, + -1, + -1 + ], + [ + 1, + 1, + 1, + -1, + -1, + 1, + 1, + 1 + ], + [ + 1, + 1, + 1, + -1, + 1, + -1, + -1, + -1 + ], + [ + 1, + 1, + 1, + -1, + 1, + -1, + 1, + 1 + ], + [ + 1, + 1, + 1, + -1, + 1, + 1, + -1, + 1 + ], + [ + 1, + 1, + 1, + -1, + 1, + 1, + 1, + -1 + ], + [ + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1 + ], + [ + 1, + 1, + 1, + 1, + -1, + -1, + 1, + 1 + ], + [ + 1, + 1, + 1, + 1, + -1, + 1, + -1, + 1 + ], + [ + 1, + 1, + 1, + 1, + -1, + 1, + 1, + -1 + ], + [ + 1, + 1, + 1, + 1, + 1, + -1, + -1, + 1 + ], + [ + 1, + 1, + 1, + 1, + 1, + -1, + 1, + -1 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 2, + 0, + -2, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + -2, + 0, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + 0, + -2, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + 0, + 0, + -2, + 0, + 0 + ], + [ + 2, + 0, + 0, + 0, + 0, + 0, + -2, + 0 + ], + [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + -2 + ], + [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 2, + 0, + 0, + 0, + 0, + 0, + 2, + 0 + ], + [ + 2, + 0, + 0, + 0, + 0, + 2, + 0, + 0 + ], + [ + 2, + 0, + 0, + 0, + 2, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ], + [ + 2, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ] + ], + "schema_version": 1, + "summary": { + "coordinate_costs": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "coordinate_pairs": 28, + "distance_counts": { + "12": 56, + "24": 84 + }, + "free_distance_counts": { + "24": 56, + "34": 56, + "40": 28 + }, + "functional_evaluations": 71540, + "max_deleted_per_side": 11, + "max_nonzero_free_deleted_per_side": 23, + "nonzero_functionals_per_stratum": 511, + "pairing_rank_counts": { + "8": 448, + "9": 252 + }, + "pairings": 700, + "span_counts": { + "8": 56, + "9": 84 + }, + "support_strata": 140, + "whole_copy_floor": 64 + } +} diff --git a/research/p112-two-coordinate-small-rectangle/README.md b/research/p112-two-coordinate-small-rectangle/README.md new file mode 100644 index 0000000000..6b1dba8894 --- /dev/null +++ b/research/p112-two-coordinate-small-rectangle/README.md @@ -0,0 +1,267 @@ +# Two P112 coordinate terms resist a small free rectangle + +**Scoped obstruction, with exact finite premises; no new kappa or supplier.** +On the fixed P112 coordinate decoder, mix any two of its eight coordinate +terms with one free rectangular correction by any `M in GL(3,C)`. If the +correction is nonzero and uses at most **23 rows and 23 columns**, at least two of the three +replacement terms have COPY pairing rank at least eight. The whole decoder +therefore retains COPY cost at least **64**, and its separate COPY power bill +cannot improve. Identity mixing attains the bound, including a nonzero odd +singleton correction of matrix rank nine. A second statement covers zero-factor +cases when each support has size at most **11**. + +This answers a restricted part of Arham Tahir's [PR1331](https://github.com/CrocSwap/integer-mult-bounds/pull/1331) +/ [Discussion1316](https://github.com/CrocSwap/integer-mult-bounds/discussions/1316) +two-coordinate handoff. PR1331 allows any free rectangle but mixes only one +coordinate. Here two coordinates mix coherently; the rectangle is small. +Neither result subsumes the other. The concurrent +[Discussion1360](https://github.com/CrocSwap/integer-mult-bounds/discussions/1360) +claim by Arham Tahir concerns arbitrary nine-term factorizations of a singleton +completion; our larger-rectangle/two-coordinate domain is complementary. +That claim is provisional and is not a proof dependency. +The initial singleton claim was refined +after the same finite calculation gave erasure distance at least twelve, then +free-compatible erasure distance at least twenty-four. + +## Model and quantified statement + +Use the pinned PR845/PR717 geometry in [SOURCES.json](SOURCES.json). The 112 +live root lines are the E8 lines minus the standard orthogonal eight-frame. +Let `X` be their `112 x 8` coordinate matrix, with entries `0,1,-1` and +`XX^T = 2G` and column rank eight. For binary labels `L_i`, the nondegenerate ambient form satisfies + +`B_ij = = (G_ij + 1) mod 2`. + +For index sets `A,C`, define `rho(A,C) = rank_F2 B[A,C]`. A scalar term +`d t^T` costs `rho(supp(d),supp(t))`. Coefficients are complex and determine +supports; they are **not** reduced modulo two. This is the inherited +separate-term COPY objective, not a new physical implementation contract. + +Choose distinct coordinate columns `x=X[:,k]`, `y=X[:,l]`. Choose arbitrary +complex vectors `u,v`, with supports `U,V`, satisfying + +`B[U,V]=0`, and either + +- `1 <= |U| <= 23` and `1 <= |V| <= 23`, or +- `|U| <= 11` and `|V| <= 11`, allowing zero vectors. + +The pairing condition makes `uv^T` a free correction +on odd entries: it vanishes on all constrained even entries. For arbitrary +`M in GL(3,C)`, form + +`D = [x,y,u] M`, `T = [x,y,v] M^(-T)`. + +Thus `DT^T = xx^T + yy^T + uv^T`, using **ordinary transpose**. +The other six coordinate terms stay fixed. + +**Theorem.** At least two terms of `D T^T` have pairing rank at least eight. +Consequently their sum of ranks is at least sixteen, and the complete +decoder has COPY cost at least sixty-four. This statement includes all +28 coordinate pairs, all such supports and coefficients, every complex +invertible factor change, and the zero-correction boundaries. + +## Finite geometry behind the proof + +Any nonzero complex combination `a*x+b*y` has exactly one of five support +patterns. The exceptional projective coefficient ratios are `x`, `y`, +`x+y`, `x-y`; every other ratio gives `supp(x) union supp(y)`. Indeed, a row +with two nonzero coordinate entries can cancel only at `a/b = +1` or `-1`. +This exhausts complex coefficients, including nonreal ratios. + +For each of the 28 pairs, the exact census is: + +| Support stratum | Size | Span dimension | Erasure distance | Free-compatible distance | +|---|---:|---:|---:|---:| +| `x` | 56 | 8 | 24 | 24 | +| `y` | 56 | 8 | 24 | 24 | +| `x+y` | 76 | 9 | 12 | 34 | +| `x-y` | 76 | 9 | 12 | 34 | +| generic union | 88 | 9 | 24 | 40 | + +The erasure distance of a support `S` is the minimum **positive** value of +`#{i in S : f(L_i)=1}` over the 511 nonzero ambient binary functionals. +Functionals annihilating the whole support have weight zero and are excluded +from that minimum. The certificate checks their count as well. For the +**free-compatible** distance, additionally require the deletion support +`W={i in S : f(L_i)=1}` to have at least one live common odd neighbor `j`, +meaning `B[W,{j}]=0`. The checker records the complete filtered weight +spectrum as well as its minimum. + +All **700 ordered within-pair support pairings** have rank at least eight: +448 have rank eight and 252 have rank nine. The census checks all 71,540 +support/functional combinations, not a random sample or a floating-point +rank calculation. Complete supports, weight spectra, pairing matrices and +two boundary witnesses are in [CERTIFICATE.json](CERTIFICATE.json). + +**Erasure lemma.** Removing at most eleven indices preserves the label span +of every stratum. If a deletion reduced the span, some ambient functional +would vanish on the retained span but not on the original span. Its positive +weight on the original support would be no greater than the number deleted, +contradicting the minimum of twelve. This is a finite-dimensional linear +algebra argument, so enumeration of all deletion subsets is unnecessary. + +**Free-compatible erasure lemma.** Suppose `U,V` are nonempty and +`B[U,V]=0`. If removing `U` from a stratum lowered its span, the same +functional argument would give a nonempty witness `W` contained in `U`. +Every index of `V` is then a common odd neighbor of `W`. Its weight must +therefore be at least the free-compatible distance, which is at least 24. +Consequently `|U|<=23` preserves every stratum span. Transpose for `V`. +Nonemptiness on both sides is essential to this argument. The unconditional +lemma covers the theorem's smaller domain when a factor is zero. + +**Boundaries of these premises.** For pair `(0,1)` and the plus stratum, deleting +canonical root indices `100..111` lowers its span from nine to eight. The +primary checker records functional 257 as a witness; the second checker +recomputes the span loss directly from Euclidean pairings. Thus twelve cannot +replace eleven in the universal **span-preservation premise**. This is not +a decoder improvement and does not show that the theorem's eleven bound is +sharp. In fact this twelve-row deletion has **no common odd neighbor**, so it +cannot support a nonzero free rectangle. + +The separate `free_boundary` witness uses pair `(0,1)`, the `x` stratum and +24 explicitly listed rows. They have common odd neighbor `{0}`, and deleting +them lowers the span from eight to seven. Thus 24 cannot replace 23 in the +uniform **free-compatible span-preservation premise**. This is a valid free +support rectangle, but no factor-change saving or sharp decoder threshold is +claimed. A 23-by-one subrectangle supplies an additional exact positive fixture. + +## Proof over arbitrary complex factor changes + +Let `a_j in C^2` be the first two entries of column `j` of `M`, and `b_j in C^2` +the first two entries of column `j` of `M^(-T)`. The top-left block of +`M M^(-1)=I_3` gives + +`sum_(j=1..3) a_j b_j^T = I_2`. + +Since each summand has complex rank at most one, at least two indices `j` +have **both** `a_j != 0` and `b_j != 0`. This argument does not assume that +`u,v` are nonzero or that either three-column factor has full rank. + +Fix such an index. The corresponding left factor is a nonzero combination +of `x,y` plus a multiple of `u`; outside `U` its support contains the +original combination's support. More precisely, if that combination has +support `S`, then `S minus U` is contained in the actual left support. +The same argument gives `C minus V` on the right for one of the five strata +`C`. The applicable erasure lemma, with cap 23 for a nonzero free rectangle or +cap 11 without that nonemptiness assumption, gives + +`span(L_(S minus U)) = span(L_S)`, +`span(L_(C minus V)) = span(L_C)`. + +Pairing rank depends only on these two spans. Hence the survivor pairing +rank equals `rho(S,C) >= 8`. Enlarging either support cannot decrease rank, +so the actual term costs at least eight. Apply this to the two active indices. +The remaining term has nonnegative cost. The other six original terms each +cost eight. This proves the theorem, including arbitrary cancellations, +triangular changes, nonreal coefficients, and zero-vector cases. + +The free-rectangle condition supplies both masked-decoder validity and the +23-per-side strengthening. The unconditional 11-per-side rank argument does +not require it. + +## Optimistic complete COPY screen + +For `0 <= a < 1`, write `q=1-a > 0`. If the three replacement ranks are `r_j`, +then at least two individually satisfy `r_j>=8`, so + +`sum_j r_j^q >= 2 * 8^q`. + +Adding the six unchanged terms gives at least `8 * 8^q`, the original COPY +bill. This is stronger than a sum-of-ranks bound: a sum of sixteen alone +would not establish the two-child power inequality. The comparison requires +unchanged width, normalization and common multiplicity for the COPY calls. +It already rejects this family as a COPY-saving route when all extra work +is granted zero cost. It does not price another child histogram, owner layout, +shared-copy convention or a complete supplier; other charges and denominators +cannot be silently cancelled if their contracts change. + +## Reproduce and failure controls + +Python 3.12, standard library only; from the repository root: + +```sh +python3 -I -B research/p112-two-coordinate-small-rectangle/verify.py +python3 -I -B research/p112-two-coordinate-small-rectangle/independent_check.py +python3 scripts/research_package.py --package research/p112-two-coordinate-small-rectangle +``` + +Expected primary and independent final lines: + +```text +PASS_P112_TWO_COORDINATE_SMALL_RECTANGLE pairs=28 strata=140 characters=71540 pairings=700 erasures=11 nonzero_free_erasures=23 fixtures=9 controls=9 copy_floor=64 +PASS_P112_SMALL_RECTANGLE_INDEPENDENT strata=140 characters=71540 pairings=700 boundaries=12,24 controls=9 +``` + +The registered replay runs both checkers and verifies historical provenance +and working input pins. Both remain active under `python3 -I -O -B`. +To regenerate the receipt into a **new** path, pass `verify.py --write PATH`; +ordinary verification does not rewrite artifacts. + +The primary checker uses the pinned source's exact labels. It replays nine +Gaussian-rational fixtures on all 12,544 entries each: identity/sharpness, +nonsymmetric dense mixing, complex ordinary transpose, a four-by-five free +rectangle, zero-left, zero-right, zero correction, an actual cancellation, and a +23-by-one rectangle. For the sharp singleton it also checks that adjoining +each singleton to all eight coordinate columns has rational rank nine. +Hence `[X,u][X,v]^T` has rank nine: the first factor is injective and the +second transpose is surjective in dimension nine. +Nine controls reject a nonfree correction, singular matrix, inverse without +transpose, out-of-domain twelve-row zero-product and twenty-four-row nonzero corrections, +source drift, omitted input, +a false twelve-erasure extension, and a changed support receipt. + +The second checker imports neither the primary checker nor the predecessor +geometry. It independently builds doubled Euclidean E8 roots and the full +binary Gram pairing. Its nine-row basis generates all 511 nonzero dual +**evaluations**, and elimination runs from the opposite bit direction. It +recomputes all supports, both spectra, 700 ranks and both boundary span losses. +Nine corrupt-receipt controls cover pair omission, support changes, incorrect +distance, incorrect pairing rank, repeated boundary deletion, wrong roots and +a false summary, incorrect free-compatible distance and omitted odd neighbor. +The primary checker's factor-change examples and source pins +are separate coverage; the second checker verifies the finite proof premises. +These are two implementations by the same AI-assisted contributor, not human +review or proof-assistant formalization. + +## Scope, provenance and credit + +Base: `bce54fb3f895cbe5cd4c0eb477c3afeed100190f`, fetched from main at entry. +Chooser nonce: `44ef721f92930cbeabe2df5c07bc184b`; complex-mechanisms; +`complex-masked-decoder`, scope key `2a6f2c726b78f9ae7d26`, priority revision 2. +[TASK.json](TASK.json) records the local card, refinement, overlap and limits. +PR1331 head `f08b698cc2bd74e2425486728a008e531fc35f0e` is a contextual +predecessor, fetched anonymously; no theorem or code from that PR is imported. + +Credit Arham Tahir / PR1331 for the one-coordinate free-rectangle predecessor +and explicit two-coordinate question; DreamingOfClouds / PR717 for the masked +B14 model and PR446/595 for the separate-total lineage; Joel Pulikkan / +GamingPuzzled / PR620 for the coordinate COPY64 decoder; Mihir Srivastava / +PR845 for the exact P112 geometry; themilkman216 / PR968 for the pairing-cost +model; and woklerx / PR1077 for the task's complex-coefficient positive control. +This account's PR1304 studies fixed A8 simplex normals on matching punctures, +which is a different all-pairs family. No predecessor file is modified. +This package and retained inputs are Apache-2.0. + +No physical word, gathering, restoration, frame changes, owner admission, +precision bounds, all-size/compiler result or new selected bound is supplied. +The inherited common-label/mutable-source, hosting, precision/tape, analytic +transfer and bit H1-H5 obligations are not checked by this package. The +selected full cold replay is unrelated and was not run. Hosted CI, maintainer +acceptance and independent human review are also not claimed. + +Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance. + +## Open next questions + +Can a nonzero free rectangle with at least twenty-four indices on one side +exploit a span-losing coordinate support to reduce the two-coordinate COPY +moment? This is the first size the strengthened proof leaves open. A feasible +first step is to take the recorded 24-row `free_boundary` witness and its +common odd neighbor `{0}`, then solve the actual GL(3,C) cancellation +constraints while pricing every term. The blocker is that a free support +rectangle and span loss do not satisfy the coupled inverse-factor identities +or establish any gain. The twelve-row unrestricted witness is already known +to have no common odd neighbor and should not be used for a nonzero correction. +The zero-factor cases above eleven per side are a separate open branch of this +proof. Larger rectangles, three or more mixed coordinates, other punctures and +shared-copy objectives remain outside scope. diff --git a/research/p112-two-coordinate-small-rectangle/SOURCES.json b/research/p112-two-coordinate-small-rectangle/SOURCES.json new file mode 100644 index 0000000000..83b147dc79 --- /dev/null +++ b/research/p112-two-coordinate-small-rectangle/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "c05fafaa25ba95b2d5af86b1800427198e3d20eb", + "sha256": "89b5928bc92c81e2647b6d702a7ad85a6795b8f44e2eb267b2ff3145d8f2b2ce" + }, + { + "path": "research/complex-frame-pair-decoders/PROOF.md", + "usage": "input", + "git_blob": "889f3a653ed1bdbb7df61ebe3af4f2103602a1f4", + "sha256": "ba53c1d8a9bc2d935d546bde46ca7341bd65f8515013e07b073296b4db2a9a74" + }, + { + "path": "research/p112-single-lift/geometry.py", + "usage": "input", + "git_blob": "34c1abf059d7be5fe5e5044cf01a09b843071c68", + "sha256": "3857c11ec731a602b8059d85d58fbb3b641bab687bb33016a0e54f7567752c8a" + } + ] +} diff --git a/research/p112-two-coordinate-small-rectangle/TASK.json b/research/p112-two-coordinate-small-rectangle/TASK.json new file mode 100644 index 0000000000..08aec5f3c0 --- /dev/null +++ b/research/p112-two-coordinate-small-rectangle/TASK.json @@ -0,0 +1,119 @@ +{ + "schema_version": 1, + "task_id": "complex-masked-decoder", + "priority_revision": 2, + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "original_card": { + "id": "complex-masked-decoder", + "question": "Can one specified masked or overcomplete decoder improve the complete moment budget?", + "starting_points": [ + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md" + ], + "methods": [ + "Synthesize a decoder with exact coefficients and fully priced helper endpoints.", + "Bound the best possible budget for a fixed support alphabet before synthesis." + ], + "acceptance_gate": "Change an assumption of the eight-term all-pairs bound and count all copied information, frames and restoration.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-decoder-field-extension-seed44/verify.py" + ], + "expected": "PASS_COMPLEX_DECODER_FIELD_EXTENSION_S44", + "inspect": "Locate the excluded classes: masked identities, at least nine terms, and deeper punctures.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Choose one finite support alphabet and test exact decoding constraints before building a whole network.", + "bottleneck_link": "A cheaper fully realized decoder could increase deficit or lower recursive cost on the binding complex side.", + "allowed_variations": [ + "Select a specific masked or overcomplete family with exact labels and supports." + ], + "scope_change_triggers": [ + "Repeating the exact eight-term all-pairs search inside its proved scope." + ], + "overlap_terms": [ + "masked decoder", + "overcomplete", + "eight-term" + ] + }, + "scope_status": "refined", + "actual_scope": "P112: arbitrary GL(3,C) mixing of any two coordinate terms with one nonzero free rectangle of at most 23 rows and 23 columns; the at-most-11-per-side domain also allows zero factors. COPY cost and separate power-bill obstruction.", + "scope_change_reason": "Select the masked overcomplete branch and PR1331 two-coordinate handoff. Initially restrict to singleton rectangles; the same complete functional census gives unconditional distance 12 and free-compatible distance 24, extending the theorem to supports <=11 including zero factors, and <=23 when both factors are nonzero. No eight-term all-pairs search is repeated.", + "bottleneck_link": "A cheaper complete COPY bill is necessary for this fixed-width replacement to improve the complex mechanism while other work is unchanged. Two separately rank-eight products rule out that saving even with all additional charges granted zero.", + "budget_minutes": 60, + "stop_rule": "Stop synthesis once the optimistic COPY screen excludes an improvement; reserve final quarter for exact replay, controls, source/overlap checks and handoff. About sixty minutes; hard stop 2026-10-14T00:47Z.", + "outcome": "negative-result", + "evidence": "README.md quantified proof; CERTIFICATE.json complete 140-stratum/71540-character/700-pairing census with ordinary and free-compatible weight spectra, plus 12/24-erasure boundaries; nine exact Gaussian-rational fixtures including rank-nine sharpness; nine primary and nine separate-checker controls.", + "author": "commdata2338", + "ai_assistance": "Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance in mathematics, implementation, verification and writing. No independent human review claimed.", + "open_questions": [ + { + "question": "Can a nonzero free rectangle beyond the 23-per-side cap exploit the compatible 24-erasure witness under GL(3,C)?", + "why_it_matters": "This is the first support size outside the proved free-compatible span-preservation premise and supplies a concrete remaining two-coordinate route.", + "first_step": "Use the 24-row free_boundary witness and its common odd neighbor {0} in CERTIFICATE.json; solve exact coupled factor-cancellation constraints while pricing all three supports. The unrestricted 12-row witness has no odd neighbor and cannot be used.", + "blocked_by": "A free support rectangle and span loss do not imply a coupled factor identity or COPY gain; the full physical budget remains required." + }, + { + "question": "Can a zero outer-product representation with one nonzero factor supported on 12 or more indices evade the smaller-domain proof?", + "why_it_matters": "The free-compatible argument requires both factors nonzero; this is an explicit boundary, not silently covered by the 23 threshold.", + "first_step": "Classify the three-term coefficient-kernel cases when one correction factor is zero, retaining all term costs.", + "blocked_by": "The required nonempty opposite support is absent; a separate subadditivity or factorization argument is needed." + } + ], + "chooser": { + "nonce": "44ef721f92930cbeabe2df5c07bc184b", + "track": "complex-mechanisms", + "scope_key": "2a6f2c726b78f9ae7d26", + "refined_scope_key": "p112-two-coordinate-small-rectangle/GL3C/all28-pairs/nonzero-support23-or-support11" + }, + "contextual_predecessors": [ + { + "pr": 1331, + "head": "f08b698cc2bd74e2425486728a008e531fc35f0e", + "author": "Arham Tahir", + "dependency": "Context and question only; no imported pending theorem/code." + } + ], + "overlap": { + "queries": [ + "--task complex-new-helper-inventory", + "--task complex-masked-decoder", + "GL(3; two coordinate; free rectangle", + "two-coordinate; small rectangle; singleton" + ], + "entry_open_prs_fetched_at": "2026-10-13T23:16:31.144623+00:00", + "entry_discussions_fetched_at": "2026-10-13T23:16:49.182031+00:00", + "coverage": "834 open PRs including drafts; 76 discussion records; both fully paginated (shared snapshot refreshed every 10 minutes). Offline cached snapshot may miss newer changes; no code-diff novelty claim.", + "nearest": "PR1331 treats one coordinate/arbitrary rectangle; this treats two coordinates/small rectangle. PR1212/1213 rank-eight masked rigidity, PR1224 all-pairs nine-term, PR1304 fixed A8-simplex P112 are distinct.", + "coordination": "Claim posted in discussion #1316 (comment 18911259) by the submitting account; the agent session itself made no GitHub writes.", + "final_coverage": { + "open_prs": { + "fetched_at": "2026-10-13T23:26:56.258153+00:00", + "complete_pagination": true, + "records": 835 + }, + "discussions": { + "fetched_at": "2026-10-13T23:27:22.735766+00:00", + "complete_pagination": true, + "records": 86 + } + }, + "final_searched_at": "2026-10-13T23:34:07.031765+00:00", + "complementary_active_claim": "Discussion1360 by Arham Tahir, snapshot 2026-10-13T23:27:22.735766+00:00: arbitrary GL(9,C) factorizations of a singleton completion. This package instead treats larger free rectangles and only two coherently mixed coordinates. Neither full stated domain subsumes the other; the claim remains provisional.", + "local_siblings": "portable-replay audits PR1006 input-role hashes; uniform-transfer-audit studies fixed-tape parking boundaries. Earlier completed claims cover A8-simplex P112, zero-frame bit XORs and bit pending projectors. All differ from this support-stratum result." + }, + "optimistic_budget": "Six unchanged rank-eight COPY terms plus three replacement terms. At least two replacements individually have rank >=8, so for q=1-a>0 their bill is >=2*8^q. Same width, normalization and multiplicity required. No full supplier histogram claimed.", + "unchecked_obligations": [ + "nonzero correction supports above 23 or zero-factor cases above 11", + "three or more mixed coordinates", + "other punctures or shared-copy accounting", + "physical gathering, frames, restoration and owner realization", + "full native cold replay", + "all-size/compiler and common-label/mutable-source interfaces", + "precision/tape, analytic transfer and bit H1-H5", + "human review, hosted CI and maintainer acceptance" + ] +} diff --git a/research/p112-two-coordinate-small-rectangle/VALIDATION.md b/research/p112-two-coordinate-small-rectangle/VALIDATION.md new file mode 100644 index 0000000000..84baabc791 --- /dev/null +++ b/research/p112-two-coordinate-small-rectangle/VALIDATION.md @@ -0,0 +1,46 @@ +# Validation receipt + +Run locally on 2026-10-13T23:36:05.353741+00:00, Linux x86_64, +Python `3.12.3`, standard library only. One verification +process at a time; no third-party packages, native builds, GPU, or Lean. + +## Passing checks + +- Task first working example: + `python3 -B research/complex-decoder-field-extension-seed44/verify.py`. + Final status `PASS_COMPLEX_DECODER_FIELD_EXTENSION_S44`, p=0..24, + examples=3, attaining=25, pairing=14400, controls=7. Orientation only. +- `python3 -B scripts/research_package.py --package research/p112-two-coordinate-small-rectangle`. + Metadata, historical provenance and live pins pass. Both registered exact + checkers pass: 140 strata, 71,540 functionals, 700 support pairings, nine + Gaussian-rational fixtures, nine primary and nine separate-checker controls. + Local observed elapsed time about 3.9 seconds; this is not a benchmark claim. +- Both checker commands with `python3 -I -O -B` pass, so their checks remain + active with Python assertions disabled. About 4.8 seconds total locally. +- `python3 -B scripts/research_package.py --package research/p112-two-coordinate-small-rectangle --check-only` + passes again after the final task/overlap documentation update. +- Pinned geometry, model proof and selected-result working bytes match the + base. Only this new package is included in the contribution. + +Normal verification compares the complete deterministic receipt and does not +rewrite it. The receipt was generated to fresh paths and separately checked +before installation. The second checker derives the root/dual-code geometry +without importing the primary checker or the predecessor geometry. + +## Exact claims checked and limits + +The finite premise is erasure distance 12 without extra conditions, and +free-compatible erasure distance 24. Exact boundary witnesses lose span at +12 and 24 deletions; the first has no common odd neighbor, and the second +has neighbor {0}. Neither boundary is a decoder gain or a sharp decoder +threshold. The quantified GL(3,C) implication is a written linear-algebra +proof in README.md, not a finite sampling claim or proof-assistant result. + +No full selected cold replay, physical word, owner/frame admission, restoration, +precision/tape, all-size/compiler, analytic transfer or bit-interface theorem +was run or discharged. Supports outside the two stated domains, more mixed +coordinates, other punctures and shared-copy accounting remain open. Hosted +CI, maintainer acceptance and independent human review remain unperformed. + +Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance. +Apache-2.0. diff --git a/research/p112-two-coordinate-small-rectangle/VERIFY.json b/research/p112-two-coordinate-small-rectangle/VERIFY.json new file mode 100644 index 0000000000..eb77a93846 --- /dev/null +++ b/research/p112-two-coordinate-small-rectangle/VERIFY.json @@ -0,0 +1,32 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/complex-frame-pair-decoders/PROOF.md", + "research/p112-single-lift/geometry.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Pinned geometry, complete ordinary/free-compatible binary erasure and pairing certificate, nine exact complex fixtures and nine failure controls." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/independent_check.py" + ], + "timeout_seconds": 60, + "checks": "Separate Euclidean/dual-code replay of all finite premises, both boundary witnesses and nine receipt mutations." + } + ] +} diff --git a/research/p112-two-coordinate-small-rectangle/independent_check.py b/research/p112-two-coordinate-small-rectangle/independent_check.py new file mode 100644 index 0000000000..1368a0090a --- /dev/null +++ b/research/p112-two-coordinate-small-rectangle/independent_check.py @@ -0,0 +1,213 @@ +#!/usr/bin/env python3 +"""Recheck finite premises from doubled Euclidean roots, without primary imports. + +Apache-2.0. Prepared for commdata2338 with substantial OpenAI Codex assistance. +This separate implementation is not independent human review. +""" +import argparse +from collections import Counter +from copy import deepcopy +from itertools import combinations, product +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def basis(rows): + """Eliminate from the least significant end, unlike the primary checker.""" + pivots = {} + for original in rows: + value = original + while value: + bit = value & -value + if bit in pivots: + value ^= pivots[bit] + else: + pivots[bit] = value + break + return list(pivots.values()) + + +def dot(a, b): + return sum(x*y for x, y in zip(a, b)) + + +def geometric_model(): + root_set = set() + for i, j in combinations(range(8), 2): + for sign in (-1, 1): + row = [0] * 8 + row[i], row[j] = 2, 2*sign + root_set.add(tuple(row)) + for tail in product((-1, 1), repeat=7): + row = (1,)+tail + if sum(x == -1 for x in row) % 2 == 0: + root_set.add(row) + frame = [] + for i in (0, 2, 4, 6): + for sign in (1, -1): + row = [0] * 8 + row[i], row[i+1] = 2, 2*sign + frame.append(tuple(row)) + require(len(root_set) == 120 and set(frame) <= root_set, "E8 roots and frame") + roots = sorted(root_set.difference(frame)) + require(len(roots) == 112, "puncture size") + x = [[dot(r, f)//4 for f in frame] for r in roots] + b = [sum(((dot(r, s)//4+1) % 2) << j for j, s in enumerate(roots)) for r in roots] + require(all(dot(x[i], x[j]) == dot(roots[i], roots[j])//2 + for i in range(112) for j in range(112)), "all-entry coordinate identity") + generators = basis(b) + require(len(generators) == 9, "binary ambient rank") + characters = [0] + for row in generators: + characters += [old ^ row for old in characters] + require(len(set(characters)) == 512, "complete binary dual evaluation space") + return roots, x, b, characters[1:] + + +def check(receipt, model): + roots, x, b, characters = model + require(receipt["schema_version"] == 1, "schema") + require(receipt["roots"] == [list(r) for r in roots], "root binding") + expected_pairs = [list(pair) for pair in combinations(range(8), 2)] + require([row["pair"] for row in receipt["pairs"]] == expected_pairs, "pair coverage") + dims, distances, pair_ranks, free_distances = Counter(), Counter(), Counter(), Counter() + count = 0 + names = ["x", "y", "plus", "minus", "generic"] + all_supports = {} + for entry in receipt["pairs"]: + k, l = entry["pair"] + require([r["name"] for r in entry["strata"]] == names, "stratum coverage") + # Generic complex ratios cancel no nonzero row: use the union directly. + predicates = [lambda a, c: a != 0, lambda a, c: c != 0, + lambda a, c: a+c != 0, lambda a, c: a-c != 0, + lambda a, c: a != 0 or c != 0] + supports = [] + for record, predicate in zip(entry["strata"], predicates): + support = [i for i in range(112) if predicate(x[i][k], x[i][l])] + require(record["support"] == support, "exact support") + mask = sum(1 << i for i in support) + spectrum = Counter((row & mask).bit_count() for row in characters) + distance = min(weight for weight in spectrum if weight) + dimension = len(basis(b[i] for i in support)) + free_spectrum = Counter() + for character in characters: + deleted = mask & character + if deleted: + forbidden = 0 + for i in range(112): + if deleted >> i & 1: + forbidden |= b[i] + if forbidden != (1 << 112)-1: + free_spectrum[deleted.bit_count()] += 1 + free_distance = min(free_spectrum) + require(record["free_distance"] == free_distance and free_distance >= 24, + "free-compatible distance") + require(record["free_weight_spectrum"] == {str(w): n for w, n in free_spectrum.items()}, + "free-compatible spectrum") + free_distances[free_distance] += 1 + require(record["span"] == dimension, "span dimension") + require(record["distance"] == distance and distance >= 12, "erasure distance") + require(record["weight_spectrum"] == {str(w): n for w, n in spectrum.items()}, + "complete weight spectrum") + require(spectrum.get(0, 0) == 2**(9-dimension)-1, "annihilator count") + dims[dimension] += 1 + distances[distance] += 1 + count += len(characters) + supports.append(support) + all_supports[(k, l, record["name"])] = support + matrix = [] + for left in supports: + row = [] + for right in supports: + mask = sum(1 << i for i in right) + rho = len(basis(b[i] & mask for i in left)) + require(rho >= 8, "pairing floor") + row.append(rho) + pair_ranks[rho] += 1 + matrix.append(row) + require(entry["pairing_ranks"] == matrix, "pairing matrix") + boundary = receipt["boundary"] + key = (*boundary["pair"], boundary["stratum"]) + support = all_supports[key] + deleted = boundary["deleted"] + require(len(deleted) == len(set(deleted)) == 12 and set(deleted) <= set(support), + "twelve distinct boundary deletions") + before = len(basis(b[i] for i in support)) + after = len(basis(b[i] for i in support if i not in deleted)) + require(before == boundary["span_before"] and after == boundary["span_after"] + and after < before, "boundary span loss") + odd_neighbors = [j for j in range(112) if all(not (b[i] >> j & 1) for i in deleted)] + require(boundary["common_odd_neighbors"] == odd_neighbors == [], "twelve-row nonfree boundary") + fb = receipt["free_boundary"] + support = all_supports[(*fb["pair"], fb["stratum"])] + erased = fb["deleted"] + require(len(erased) == len(set(erased)) == 24 and set(erased) <= set(support), + "twenty-four distinct boundary deletions") + odd_neighbors = [j for j in range(112) if all(not (b[i] >> j & 1) for i in erased)] + require(odd_neighbors == fb["common_odd_neighbors"] and bool(odd_neighbors), + "free boundary odd neighbors") + before = len(basis(b[i] for i in support)) + after = len(basis(b[i] for i in support if i not in erased)) + require(before == fb["span_before"] and after == fb["span_after"] and after < before, + "free boundary span loss") + summary = {"coordinate_pairs": 28, "support_strata": 140, + "nonzero_functionals_per_stratum": 511, "functional_evaluations": count, + "pairings": 700, "span_counts": {str(k): v for k, v in dims.items()}, + "distance_counts": {str(k): v for k, v in distances.items()}, + "pairing_rank_counts": {str(k): v for k, v in pair_ranks.items()}, + "free_distance_counts": {str(k): v for k, v in free_distances.items()}, + "max_deleted_per_side": 11, "max_nonzero_free_deleted_per_side": 23, + "coordinate_costs": [8]*8, + "whole_copy_floor": 64} + require(receipt["summary"] == summary, "summary") + + +def controls(receipt, model): + mutations = [] + r = deepcopy(receipt); r["pairs"].pop(); mutations.append((r, "pair coverage")) + r = deepcopy(receipt); r["pairs"][0]["strata"][0]["support"].pop() + mutations.append((r, "exact support")) + r = deepcopy(receipt); r["pairs"][0]["strata"][2]["distance"] = 13 + mutations.append((r, "erasure distance")) + r = deepcopy(receipt); r["pairs"][0]["pairing_ranks"][0][0] = 7 + mutations.append((r, "pairing matrix")) + r = deepcopy(receipt); r["boundary"]["deleted"][0] = r["boundary"]["deleted"][1] + mutations.append((r, "twelve distinct boundary deletions")) + r = deepcopy(receipt); r["roots"][0][0] += 1; mutations.append((r, "root binding")) + r = deepcopy(receipt); r["summary"]["whole_copy_floor"] = 65 + mutations.append((r, "summary")) + r = deepcopy(receipt); r["pairs"][0]["strata"][0]["free_distance"] = 25 + mutations.append((r, "free-compatible distance")) + r = deepcopy(receipt); r["free_boundary"]["common_odd_neighbors"] = [] + mutations.append((r, "free boundary odd neighbors")) + for mutated, message in mutations: + try: + check(mutated, model) + except ValueError as exc: + require(message in str(exc), "unexpected rejection reason: " + str(exc)) + else: + raise ValueError("accepted corrupted premise: " + message) + return len(mutations) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--receipt", type=Path, default=HERE / "CERTIFICATE.json") + args = parser.parse_args() + receipt = json.loads(args.receipt.read_text()) + model = geometric_model() + check(receipt, model) + n = controls(receipt, model) + print(f"PASS_P112_SMALL_RECTANGLE_INDEPENDENT strata=140 characters=71540 " + f"pairings=700 boundaries=12,24 controls={n}") + + +if __name__ == "__main__": + main() diff --git a/research/p112-two-coordinate-small-rectangle/verify.py b/research/p112-two-coordinate-small-rectangle/verify.py new file mode 100644 index 0000000000..cdbd27fe37 --- /dev/null +++ b/research/p112-two-coordinate-small-rectangle/verify.py @@ -0,0 +1,383 @@ +#!/usr/bin/env python3 +"""Exact finite premises for the two-coordinate small-rectangle obstruction. + +Apache-2.0. Prepared for commdata2338 with substantial OpenAI Codex assistance. +The quantified complex theorem is in README.md; examples are controls only. +""" +import argparse +from collections import Counter +from copy import deepcopy +from fractions import Fraction as F +import hashlib +import importlib.util +from itertools import combinations +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +INPUTS = {"research/p112-single-lift/geometry.py", + "research/complex-frame-pair-decoders/PROOF.md"} +STRATA = [("x", 1, 0), ("y", 0, 1), ("plus", 1, 1), + ("minus", 1, -1), ("generic", 1, 2)] + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def check_sources(sources): + rows = [r for r in sources["files"] if r["usage"] == "input"] + need(len(rows) == len(INPUTS) and {r["path"] for r in rows} == INPUTS, + "complete live source inventory") + for row in rows: + need(hashlib.sha256((ROOT / row["path"]).read_bytes()).hexdigest() + == row["sha256"], "source digest: " + row["path"]) + + +def rank(rows): + basis = {} + for v in rows: + while v: + p = v.bit_length() - 1 + if p in basis: + v ^= basis[p] + else: + basis[p] = v + break + return len(basis) + + +def rational_rank(rows): + pivots = {} + for original in rows: + row = list(map(F, original)) + for j, previous in sorted(pivots.items()): + if row[j]: + scale = row[j] + row = [a-scale*c for a, c in zip(row, previous)] + pivot = next((j for j, value in enumerate(row) if value), None) + if pivot is not None: + scale = row[pivot] + pivots[pivot] = [value/scale for value in row] + return len(pivots) + + +def bitmask(indices): + return sum(1 << i for i in indices) + + +def cost(b, left, right): + m = bitmask(right) + return rank(b[i] & m for i in left) + + +def model(): + spec = importlib.util.spec_from_file_location("p112_geometry", ROOT / + "research/p112-single-lift/geometry.py") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + data = module.build() + module.check_geometry(data) + ordering = sorted(range(112), key=lambda i: max(tuple(data["roots"][i]), + tuple(-v for v in data["roots"][i]))) + roots, x, labels, duals = [], [], [], [] + for i in ordering: + r = data["roots"][i] + canonical = max(tuple(r), tuple(-v for v in r)) + sign = 1 if tuple(r) == canonical else -1 + roots.append(list(canonical)) + x.append([sign * v for v in data["X"][i]]) + labels.append(data["labels"][i]) + duals.append(data["duals"][i]) + b = [bitmask(j for j in range(112) if (a & labels[j]).bit_count() % 2) + for a in duals] + need(rank(b) == 9 and rank(labels) == 9, "ambient rank nine") + return roots, x, labels, b + + +def premises(roots, x, labels, b): + characters = [bitmask(i for i, v in enumerate(labels) + if (f & v).bit_count() % 2) for f in range(1, 512)] + pairs, dims, distances, pair_ranks = [], Counter(), Counter(), Counter() + free_distances = Counter() + boundary = free_boundary = None + for k, l in combinations(range(8), 2): + records = [] + for name, a, c in STRATA: + support = [i for i, row in enumerate(x) if a * row[k] + c * row[l]] + m = bitmask(support) + spectrum = Counter((m & ch).bit_count() for ch in characters) + distance = min(w for w in spectrum if w) + dimension = rank(labels[i] for i in support) + viable = [] + for f, ch in enumerate(characters, 1): + deleted_mask = m & ch + if deleted_mask: + neighbors = [j for j in range(112) if not (b[j] & deleted_mask)] + if neighbors: + viable.append((deleted_mask.bit_count(), f, deleted_mask, neighbors)) + free_distance = min(v[0] for v in viable) + need(free_distance >= 24, "free-compatible erasure distance") + free_spectrum = Counter(v[0] for v in viable) + free_distances[free_distance] += 1 + if free_boundary is None and free_distance == 24: + weight, f, deleted_mask, neighbors = min(viable) + deleted = [i for i in support if deleted_mask >> i & 1] + after = rank(labels[i] for i in support if i not in deleted) + need(after < dimension, "free-compatible boundary span loss") + free_boundary = {"pair": [k, l], "stratum": name, "functional": f, + "deleted": deleted, "common_odd_neighbors": neighbors, + "span_before": dimension, "span_after": after} + need(dimension in (8, 9) and distance >= 12, "span and erasure distance") + need(spectrum.get(0, 0) == 2 ** (9-dimension) - 1, + "annihilator count") + if name == "generic": + need(support == [i for i, row in enumerate(x) if row[k] or row[l]], + "generic stratum is the union") + records.append({"name": name, "support": support, "span": dimension, + "distance": distance, "free_distance": free_distance, + "free_weight_spectrum": {str(w): free_spectrum[w] for w in sorted(free_spectrum)}, + "weight_spectrum": {str(w): spectrum[w] for w in sorted(spectrum)}}) + dims[dimension] += 1 + distances[distance] += 1 + if distance == 12 and boundary is None: + f = next(f for f, ch in enumerate(characters, 1) + if (m & ch).bit_count() == distance) + deleted = [i for i in support if (f & labels[i]).bit_count() % 2] + remaining = [i for i in support if i not in deleted] + after = rank(labels[i] for i in remaining) + need(after < dimension, "twelve-erasure boundary witness") + boundary = {"pair": [k, l], "stratum": name, "functional": f, + "deleted": deleted, "span_before": dimension, + "span_after": after, + "common_odd_neighbors": [j for j in range(112) + if all(not (b[i] >> j & 1) for i in deleted)]} + matrix = [[cost(b, a["support"], c["support"]) for c in records] + for a in records] + need(all(v >= 8 for row in matrix for v in row), "all support pairings >= eight") + pair_ranks.update(v for row in matrix for v in row) + pairs.append({"pair": [k, l], "strata": records, "pairing_ranks": matrix}) + coordinate_costs = [cost(b, [i for i in range(112) if x[i][k]], + [i for i in range(112) if x[i][k]]) for k in range(8)] + need(coordinate_costs == [8] * 8, "coordinate positive control") + return {"schema_version": 1, "root_order": "lexicographic positive-first doubled E8 roots", + "roots": roots, "pairs": pairs, "boundary": boundary, "free_boundary": free_boundary, + "summary": {"coordinate_pairs": 28, "support_strata": 140, + "nonzero_functionals_per_stratum": 511, + "functional_evaluations": 71540, "pairings": 700, + "span_counts": {str(k): v for k, v in sorted(dims.items())}, + "distance_counts": {str(k): v for k, v in sorted(distances.items())}, + "pairing_rank_counts": {str(k): v for k, v in sorted(pair_ranks.items())}, + "free_distance_counts": {str(k): v for k, v in sorted(free_distances.items())}, + "max_deleted_per_side": 11, "max_nonzero_free_deleted_per_side": 23, + "coordinate_costs": coordinate_costs, + "whole_copy_floor": 64}} + + +# A pair of rational numbers represents a Gaussian rational, without floats. +def q(z): + if isinstance(z, tuple): + return tuple(map(F, z)) + return F(z), F(0) + + +def add(a, b): + return a[0]+b[0], a[1]+b[1] + + +def neg(a): + return -a[0], -a[1] + + +def mul(a, b): + return a[0]*b[0]-a[1]*b[1], a[0]*b[1]+a[1]*b[0] + + +def inv(a): + n = a[0]*a[0]+a[1]*a[1] + need(bool(n), "nonzero Gaussian divisor") + return a[0]/n, -a[1]/n + + +def nz(a): + return bool(a[0] or a[1]) + + +def total(values): + result = q(0) + for value in values: + result = add(result, value) + return result + + +def inverse(matrix): + n = len(matrix) + rows = [list(row)+[q(i == j) for j in range(n)] for i, row in enumerate(matrix)] + for j in range(n): + pivot = next((i for i in range(j, n) if nz(rows[i][j])), None) + need(pivot is not None, "invertible factor change") + rows[j], rows[pivot] = rows[pivot], rows[j] + scale = inv(rows[j][j]) + rows[j] = [mul(z, scale) for z in rows[j]] + for i in range(n): + if i != j: + factor = rows[i][j] + rows[i] = [add(a, neg(mul(factor, c))) for a, c in zip(rows[i], rows[j])] + return [row[n:] for row in rows] + + +def mix(x, pair, u, v, raw_matrix, wrong_transpose=False): + matrix = [[q(z) for z in row] for row in raw_matrix] + back = inverse(matrix) + left, right = [], [] + k, l = pair + for i in range(112): + a, c = [q(x[i][k]), q(x[i][l]), u[i]], [q(x[i][k]), q(x[i][l]), v[i]] + left.append([total(mul(a[t], matrix[t][j]) for t in range(3)) for j in range(3)]) + right.append([total(mul(c[t], back[t][j] if wrong_transpose else back[j][t]) + for t in range(3)) for j in range(3)]) + return left, right + + +def check_fixture(x, b, pair, u, v, matrix, wrong_transpose=False): + us, vs = [i for i, z in enumerate(u) if nz(z)], [i for i, z in enumerate(v) if nz(z)] + cap = 23 if us and vs else 11 + need(len(us) <= cap and len(vs) <= cap, "small support domain") + need(cost(b, us, vs) == 0, "free odd rectangle") + left, right = mix(x, pair, u, v, matrix, wrong_transpose) + k, l = pair + for i in range(112): + for j in range(112): + wanted = add(q(x[i][k]*x[j][k]+x[i][l]*x[j][l]), mul(u[i], v[j])) + actual = total(mul(left[i][t], right[j][t]) for t in range(3)) + need(wanted == actual, "ordinary-transpose factor identity") + costs = [cost(b, [i for i in range(112) if nz(left[i][t])], + [i for i in range(112) if nz(right[i][t])]) for t in range(3)] + need(sum(c >= 8 for c in costs) >= 2, "two separately rank-eight products") + return costs + + +def rejected(call, expected): + try: + call() + except ValueError as exc: + need(expected in str(exc), "wrong rejection: " + str(exc)) + return + raise ValueError("control unexpectedly accepted: " + expected) + + +def fixtures_and_controls(x, labels, b, certificate, sources): + z = [q(0)] * 112 + odd = next((i, j) for i in range(112) for j in range(112) if not (b[i] >> j & 1)) + u, v = list(z), list(z) + u[odd[0]], v[odd[1]] = q(1), q((2, 1)) + identity = [[1, 0, 0], [0, 1, 0], [0, 0, 1]] + dense = [[1, 1, 1], [1, 2, 3], [1, 4, 6]] + complex_matrix = [[1, (0, 1), 1], [0, 1, 1], [1, 0, (0, 1)]] + # A genuinely two-sided, non-singleton zero rectangle. + U = [odd[0]] + for i in range(112): + if i not in U and len(U) < 4: + V = [j for j in range(112) if all(not (b[t] >> j & 1) for t in U+[i])] + if len(V) >= 5: + U.append(i) + V = [j for j in range(112) if all(not (b[t] >> j & 1) for t in U)][:5] + need(len(U) == 4 and len(V) == 5, "non-singleton fixture rectangle") + ru, rv = list(z), list(z) + for i in U: + ru[i] = q(x[i][0]+x[i][1] or 1) + for i in V: + rv[i] = q((1, -1)) + # Force an actual support cancellation in a coherent three-term change. + cu = list(z) + cancellation_row = next(i for i in range(112) if x[i][0]+x[i][1]) + cu[cancellation_row] = q(-(x[cancellation_row][0]+x[cancellation_row][1])) + cv = list(z) + cv[next(j for j in range(112) if not (b[cancellation_row] >> j & 1))] = q(1) + fu, fv = list(z), list(z) + for i in certificate["free_boundary"]["deleted"][:-1]: + fu[i] = q(1) + fv[certificate["free_boundary"]["common_odd_neighbors"][0]] = q(1) + cases = [("sharp singleton", (0, 1), u, v, identity), + ("dense singleton", (0, 1), u, v, dense), + ("complex ordinary transpose", (0, 7), u, v, complex_matrix), + ("four by five rectangle", (2, 6), ru, rv, dense), + ("zero left correction", (1, 5), z, v, dense), + ("zero right correction", (3, 4), u, z, dense), + ("zero correction", (0, 1), z, z, complex_matrix), + ("support cancellation", (0, 1), cu, cv, dense), + ("twenty-three by one rectangle", (0, 1), fu, fv, dense)] + results = [{"name": name, "pair": list(pair), "costs": check_fixture(x, b, pair, a, c, m)} + for name, pair, a, c, m in cases] + need(results[0]["costs"] == [8, 8, 0], "sharp copy floor") + need(all(rational_rank([row + [int(i == point)] for i, row in enumerate(x)]) == 9 + for point in odd), "singleton completion has rank nine") + results[0]["full_masked_matrix_rank"] = 9 + left, _ = mix(x, (0, 1), cu, cv, dense) + need(not nz(left[cancellation_row][0]), "actual cancellation exercised") + controls = [] + wrong = list(z); wrong[odd[0]] = q(1) + rejected(lambda: check_fixture(x, b, (0, 1), u, wrong, identity), "free odd rectangle") + controls.append("nonfree diagonal correction") + rejected(lambda: check_fixture(x, b, (0, 1), u, v, [[1, 1, 0]]*3), "invertible") + controls.append("singular factor change") + rejected(lambda: check_fixture(x, b, (0, 1), u, v, dense, True), "factor identity") + controls.append("inverse without ordinary transpose") + large = list(z) + for i in range(12): large[i] = q(1) + rejected(lambda: check_fixture(x, b, (0, 1), large, z, identity), "small support domain") + controls.append("twelve-row zero-product input outside theorem domain") + fu24 = list(fu) + fu24[certificate["free_boundary"]["deleted"][-1]] = q(1) + rejected(lambda: check_fixture(x, b, (0, 1), fu24, fv, identity), "small support domain") + controls.append("twenty-four-row nonzero input outside theorem domain") + bad_sources = deepcopy(sources) + next(r for r in bad_sources["files"] if r["usage"] == "input")["sha256"] = "0"*64 + rejected(lambda: check_sources(bad_sources), "source digest") + controls.append("source digest drift") + bad_sources = deepcopy(sources) + bad_sources["files"] = [r for r in bad_sources["files"] if r["path"] != sorted(INPUTS)[0]] + rejected(lambda: check_sources(bad_sources), "complete live source inventory") + controls.append("omitted live input") + boundary = certificate["boundary"] + row = next(p for p in certificate["pairs"] if p["pair"] == boundary["pair"]) + st = next(s for s in row["strata"] if s["name"] == boundary["stratum"]) + remaining = [i for i in st["support"] if i not in boundary["deleted"]] + rejected(lambda: need(rank(labels[i] for i in remaining) == st["span"], + "false twelve-erasure extension"), "false twelve-erasure extension") + controls.append("false twelve-erasure span extension") + return results, controls + + +def compare_receipt(actual, expected): + need(actual == expected, "certificate mismatch") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write", type=Path, help="write a fresh receipt; never overwrite") + args = parser.parse_args() + sources = json.loads((HERE / "SOURCES.json").read_text()) + check_sources(sources) + roots, x, labels, b = model() + certificate = premises(roots, x, labels, b) + fixtures, controls = fixtures_and_controls(x, labels, b, certificate, sources) + certificate["fixtures"] = fixtures + certificate["controls"] = controls + changed = deepcopy(certificate) + changed["pairs"][0]["strata"][0]["support"].pop() + rejected(lambda: compare_receipt(changed, certificate), "certificate mismatch") + certificate["controls"].append("corrupted support receipt") + if args.write: + with args.write.open("x") as f: + f.write(json.dumps(certificate, indent=2, sort_keys=True)+"\n") + else: + compare_receipt(json.loads((HERE / "CERTIFICATE.json").read_text()), certificate) + print("PASS_P112_TWO_COORDINATE_SMALL_RECTANGLE pairs=28 strata=140 " + "characters=71540 pairings=700 erasures=11 nonzero_free_erasures=23 fixtures=9 controls=9 copy_floor=64") + + +if __name__ == "__main__": + main()