From 914a53a2300a1c2ea9ece15022e3f4d6c6be6272 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 21 Oct 2026 15:07:46 -0500 Subject: [PATCH 1/4] Construct query-thinned productive controllers at conditional kappa 0.00296 --- .../BIT-CONTROLLER.json | 2175 ++++++ .../COMPLEX-CONTROLLER.json | 5801 +++++++++++++++++ research/query-thinned-controllers/PROOF.md | 278 + research/query-thinned-controllers/README.md | 39 + .../query-thinned-controllers/RESULT.json | 356 + .../query-thinned-controllers/SOURCES.json | 120 + research/query-thinned-controllers/TASK.json | 86 + .../query-thinned-controllers/VALIDATION.md | 43 + .../query-thinned-controllers/VERIFY.json | 36 + .../query-thinned-controllers/controller.py | 208 + research/query-thinned-controllers/verify.py | 202 + 11 files changed, 9344 insertions(+) create mode 100644 research/query-thinned-controllers/BIT-CONTROLLER.json create mode 100644 research/query-thinned-controllers/COMPLEX-CONTROLLER.json create mode 100644 research/query-thinned-controllers/PROOF.md create mode 100644 research/query-thinned-controllers/README.md create mode 100644 research/query-thinned-controllers/RESULT.json create mode 100644 research/query-thinned-controllers/SOURCES.json create mode 100644 research/query-thinned-controllers/TASK.json create mode 100644 research/query-thinned-controllers/VALIDATION.md create mode 100644 research/query-thinned-controllers/VERIFY.json create mode 100644 research/query-thinned-controllers/controller.py create mode 100644 research/query-thinned-controllers/verify.py diff --git a/research/query-thinned-controllers/BIT-CONTROLLER.json b/research/query-thinned-controllers/BIT-CONTROLLER.json new file mode 100644 index 0000000000..89c400d597 --- /dev/null +++ b/research/query-thinned-controllers/BIT-CONTROLLER.json @@ -0,0 +1,2175 @@ +{ + "ambient_rank": 127, + "boundaries": { + "boundary_unit_ADDs_per_port": 160, + "coefficient_projectors": { + "12884901889": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1073741824, + 2147483648 + ], + "1367": [ + 1280, + 0, + 1280, + 0, + 1280, + 0, + 1280, + 0, + 1280, + 682, + 0, + 682, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "13958643713": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 268435456, + 536870912, + 0, + 0 + ], + "14227079169": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 67108864, + 134217728, + 0, + 0, + 0, + 0 + ], + "14294188033": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16777216, + 33554432, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "14310965249": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4194304, + 8388608, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "14315159553": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1048576, + 2097152, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "14316208129": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 262144, + 524288, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "14316470273": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 65536, + 131072, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "14316557655": [ + 16384, + 0, + 16384, + 0, + 16384, + 0, + 16384, + 0, + 16384, + 0, + 16384, + 0, + 16384, + 0, + 16384, + 43690, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "21847": [ + 20480, + 0, + 20480, + 0, + 20480, + 0, + 20480, + 0, + 20480, + 0, + 20480, + 0, + 20480, + 10922, + 0, + 10922, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "23": [ + 20, + 0, + 20, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "343": [ + 320, + 0, + 320, + 0, + 320, + 0, + 320, + 170, + 0, + 170, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "5463": [ + 5120, + 0, + 5120, + 0, + 5120, + 0, + 5120, + 0, + 5120, + 0, + 5120, + 2730, + 0, + 2730, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "7": [ + 5, + 2, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "87": [ + 80, + 0, + 80, + 0, + 80, + 42, + 0, + 42, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "diagonal_monomials": [ + 7, + 7, + 23, + 23, + 87, + 87, + 343, + 343, + 1367, + 1367, + 5463, + 5463, + 21847, + 21847, + 12884901889, + 12884901889, + 13958643713, + 13958643713, + 14227079169, + 14227079169, + 14294188033, + 14294188033, + 14310965249, + 14310965249, + 14315159553, + 14315159553, + 14316208129, + 14316208129, + 14316470273, + 14316470273, + 14316557655, + 14316557655 + ], + "full_coefficient_endpoint_sha256": "0164c424ad261c955e105330fcec5942d9a863d1b6030f70e786f5cdafb2acef", + "left_program": [ + [ + "SWAP", + 30, + 31 + ], + [ + "SWAP", + 21, + 25 + ], + [ + "SWAP", + 20, + 24 + ], + [ + "SWAP", + 19, + 27 + ], + [ + "SWAP", + 18, + 26 + ], + [ + "SWAP", + 17, + 29 + ], + [ + "SWAP", + 16, + 28 + ], + [ + "SWAP", + 15, + 30 + ], + [ + "ADD", + 12, + 14 + ], + [ + "ADD", + 10, + 14 + ], + [ + "ADD", + 8, + 14 + ], + [ + "ADD", + 6, + 14 + ], + [ + "ADD", + 4, + 14 + ], + [ + "ADD", + 2, + 14 + ], + [ + "ADD", + 0, + 14 + ], + [ + "SWAP", + 14, + 31 + ], + [ + "ADD", + 30, + 13 + ], + [ + "ADD", + 10, + 12 + ], + [ + "ADD", + 8, + 12 + ], + [ + "ADD", + 6, + 12 + ], + [ + "ADD", + 4, + 12 + ], + [ + "ADD", + 2, + 12 + ], + [ + "ADD", + 0, + 12 + ], + [ + "SWAP", + 12, + 13 + ], + [ + "ADD", + 30, + 11 + ], + [ + "ADD", + 12, + 11 + ], + [ + "ADD", + 8, + 10 + ], + [ + "ADD", + 6, + 10 + ], + [ + "ADD", + 4, + 10 + ], + [ + "ADD", + 2, + 10 + ], + [ + "ADD", + 0, + 10 + ], + [ + "SWAP", + 10, + 11 + ], + [ + "ADD", + 30, + 9 + ], + [ + "ADD", + 12, + 9 + ], + [ + "ADD", + 10, + 9 + ], + [ + "ADD", + 6, + 8 + ], + [ + "ADD", + 4, + 8 + ], + [ + "ADD", + 2, + 8 + ], + [ + "ADD", + 0, + 8 + ], + [ + "SWAP", + 8, + 9 + ], + [ + "ADD", + 30, + 7 + ], + [ + "ADD", + 12, + 7 + ], + [ + "ADD", + 10, + 7 + ], + [ + "ADD", + 8, + 7 + ], + [ + "ADD", + 4, + 6 + ], + [ + "ADD", + 2, + 6 + ], + [ + "ADD", + 0, + 6 + ], + [ + "SWAP", + 6, + 7 + ], + [ + "ADD", + 30, + 5 + ], + [ + "ADD", + 12, + 5 + ], + [ + "ADD", + 10, + 5 + ], + [ + "ADD", + 8, + 5 + ], + [ + "ADD", + 6, + 5 + ], + [ + "ADD", + 2, + 4 + ], + [ + "ADD", + 0, + 4 + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 30, + 3 + ], + [ + "ADD", + 12, + 3 + ], + [ + "ADD", + 10, + 3 + ], + [ + "ADD", + 8, + 3 + ], + [ + "ADD", + 6, + 3 + ], + [ + "ADD", + 4, + 3 + ], + [ + "ADD", + 0, + 2 + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 30, + 1 + ], + [ + "ADD", + 12, + 1 + ], + [ + "ADD", + 10, + 1 + ], + [ + "ADD", + 8, + 1 + ], + [ + "ADD", + 6, + 1 + ], + [ + "ADD", + 4, + 1 + ], + [ + "ADD", + 2, + 1 + ] + ], + "left_rows": [ + 5, + 2, + 10, + 20, + 42, + 80, + 170, + 320, + 682, + 1280, + 2730, + 5120, + 10922, + 20480, + 1073741824, + 2147483648, + 268435456, + 536870912, + 67108864, + 134217728, + 16777216, + 33554432, + 4194304, + 8388608, + 1048576, + 2097152, + 262144, + 524288, + 65536, + 131072, + 43690, + 16384 + ], + "right_program": [ + [ + "ADD", + 13, + 31 + ], + [ + "SWAP", + 30, + 31 + ], + [ + "SWAP", + 21, + 25 + ], + [ + "SWAP", + 20, + 24 + ], + [ + "SWAP", + 19, + 27 + ], + [ + "SWAP", + 18, + 26 + ], + [ + "SWAP", + 17, + 29 + ], + [ + "SWAP", + 16, + 28 + ], + [ + "SWAP", + 15, + 31 + ], + [ + "SWAP", + 14, + 30 + ], + [ + "ADD", + 11, + 13 + ], + [ + "ADD", + 15, + 12 + ], + [ + "SWAP", + 12, + 13 + ], + [ + "ADD", + 9, + 11 + ], + [ + "ADD", + 13, + 10 + ], + [ + "SWAP", + 10, + 11 + ], + [ + "ADD", + 7, + 9 + ], + [ + "ADD", + 11, + 8 + ], + [ + "SWAP", + 8, + 9 + ], + [ + "ADD", + 5, + 7 + ], + [ + "ADD", + 9, + 6 + ], + [ + "SWAP", + 6, + 7 + ], + [ + "ADD", + 3, + 5 + ], + [ + "ADD", + 7, + 4 + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 0, + 3 + ], + [ + "ADD", + 5, + 2 + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 3, + 1 + ] + ], + "right_rows": [ + 2147494569, + 2, + 2147494568, + 6, + 2147494560, + 20, + 2147494528, + 80, + 2147494400, + 320, + 2147493888, + 1280, + 2147491840, + 5120, + 2147483648, + 1073745920, + 268435456, + 536870912, + 67108864, + 134217728, + 16777216, + 33554432, + 4194304, + 8388608, + 1048576, + 2097152, + 262144, + 524288, + 65536, + 131072, + 16384, + 32768 + ] + }, + "diagonal": [ + 7, + 7, + 23, + 23, + 87, + 87, + 343, + 343, + 1367, + 1367, + 5463, + 5463, + 21847, + 21847, + 12884901889, + 12884901889, + 13958643713, + 13958643713, + 14227079169, + 14227079169, + 14294188033, + 14294188033, + 14310965249, + 14310965249, + 14315159553, + 14315159553, + 14316208129, + 14316208129, + 14316470273, + 14316470273, + 14316557655, + 14316557655 + ], + "invoice": { + "main": { + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 222, + "127": 222 + }, + "owned_streams_reused_sequentially": 1, + "paid": { + "1": 25479, + "2": 24156, + "3": 1422, + "4": 792, + "5": 1836, + "6": 198, + "7": 342, + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444, + "63": 222 + }, + "paid_calls": 57555, + "productive_fields": 11454, + "rank_surplus": 753, + "raw_scalar_record_bound": 1000000000, + "targets": { + "8": 7902, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 222, + "127": 222 + }, + "thick_calls": 18, + "thick_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ], + "thin_queries": 1665, + "whole_idle": { + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444, + "63": 222 + } + }, + "keep_mask": 35047648968703, + "kind": "bit", + "pairs": 16, + "physical_events": [ + [ + "LOCAL", + 0, + 0, + false + ], + [ + "LOCAL", + 1, + 0, + true + ], + [ + "IDLE", + 1, + [ + 0, + 1 + ] + ], + [ + "ADD", + 0, + 2 + ], + [ + "ADD", + 3, + 1 + ], + [ + "QUERY_SHEAR", + 2, + 0, + false + ], + [ + "ADD", + 0, + 2 + ], + [ + "ADD", + 3, + 1 + ], + [ + "LOCAL", + 3, + 1, + true + ], + [ + "IDLE", + 2, + [ + 0, + 1, + 3 + ] + ], + [ + "ADD", + 2, + 4 + ], + [ + "ADD", + 5, + 3 + ], + [ + "QUERY_SHEAR", + 4, + 1, + false + ], + [ + "ADD", + 2, + 4 + ], + [ + "ADD", + 5, + 3 + ], + [ + "LOCAL", + 5, + 2, + true + ], + [ + "IDLE", + 3, + [ + 0, + 1, + 3, + 5 + ] + ], + [ + "ADD", + 4, + 6 + ], + [ + "ADD", + 7, + 5 + ], + [ + "QUERY_SHEAR", + 6, + 2, + false + ], + [ + "ADD", + 4, + 6 + ], + [ + "ADD", + 7, + 5 + ], + [ + "LOCAL", + 7, + 3, + true + ], + [ + "IDLE", + 4, + [ + 0, + 1, + 3, + 5, + 7 + ] + ], + [ + "ADD", + 6, + 8 + ], + [ + "ADD", + 9, + 7 + ], + [ + "QUERY_SHEAR", + 8, + 3, + false + ], + [ + "ADD", + 6, + 8 + ], + [ + "ADD", + 9, + 7 + ], + [ + "LOCAL", + 9, + 4, + true + ], + [ + "IDLE", + 5, + [ + 0, + 1, + 3, + 5, + 7, + 9 + ] + ], + [ + "ADD", + 8, + 10 + ], + [ + "ADD", + 11, + 9 + ], + [ + "QUERY_SHEAR", + 10, + 4, + false + ], + [ + "ADD", + 8, + 10 + ], + [ + "ADD", + 11, + 9 + ], + [ + "LOCAL", + 11, + 5, + true + ], + [ + "IDLE", + 6, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11 + ] + ], + [ + "ADD", + 10, + 12 + ], + [ + "ADD", + 13, + 11 + ], + [ + "QUERY_SHEAR", + 12, + 5, + false + ], + [ + "ADD", + 10, + 12 + ], + [ + "ADD", + 13, + 11 + ], + [ + "LOCAL", + 13, + 6, + true + ], + [ + "IDLE", + 7, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13 + ] + ], + [ + "ADD", + 12, + 14 + ], + [ + "ADD", + 15, + 13 + ], + [ + "QUERY_SHEAR", + 14, + 6, + false + ], + [ + "ADD", + 12, + 14 + ], + [ + "ADD", + 15, + 13 + ], + [ + "LOCAL", + 15, + 7, + true + ], + [ + "ADD", + 14, + 16 + ], + [ + "ADD", + 17, + 15 + ], + [ + "QUERY_SHEAR", + 16, + 7, + false + ], + [ + "ADD", + 14, + 16 + ], + [ + "ADD", + 17, + 15 + ], + [ + "LOCAL", + 17, + 8, + true + ], + [ + "ADD", + 16, + 18 + ], + [ + "ADD", + 19, + 17 + ], + [ + "QUERY_SHEAR", + 18, + 8, + false + ], + [ + "ADD", + 16, + 18 + ], + [ + "ADD", + 19, + 17 + ], + [ + "LOCAL", + 19, + 9, + true + ], + [ + "ADD", + 18, + 20 + ], + [ + "ADD", + 21, + 19 + ], + [ + "QUERY_SHEAR", + 20, + 9, + false + ], + [ + "ADD", + 18, + 20 + ], + [ + "ADD", + 21, + 19 + ], + [ + "LOCAL", + 21, + 10, + true + ], + [ + "ADD", + 20, + 22 + ], + [ + "ADD", + 23, + 21 + ], + [ + "QUERY_SHEAR", + 22, + 10, + false + ], + [ + "ADD", + 20, + 22 + ], + [ + "ADD", + 23, + 21 + ], + [ + "LOCAL", + 23, + 11, + true + ], + [ + "ADD", + 22, + 24 + ], + [ + "ADD", + 25, + 23 + ], + [ + "QUERY_SHEAR", + 24, + 11, + false + ], + [ + "ADD", + 22, + 24 + ], + [ + "ADD", + 25, + 23 + ], + [ + "LOCAL", + 25, + 12, + true + ], + [ + "ADD", + 24, + 26 + ], + [ + "ADD", + 27, + 25 + ], + [ + "QUERY_SHEAR", + 26, + 12, + false + ], + [ + "ADD", + 24, + 26 + ], + [ + "ADD", + 27, + 25 + ], + [ + "LOCAL", + 27, + 13, + true + ], + [ + "ADD", + 26, + 28 + ], + [ + "ADD", + 29, + 27 + ], + [ + "QUERY_SHEAR", + 28, + 13, + false + ], + [ + "ADD", + 26, + 28 + ], + [ + "ADD", + 29, + 27 + ], + [ + "LOCAL", + 29, + 14, + true + ], + [ + "ADD", + 28, + 30 + ], + [ + "ADD", + 31, + 29 + ], + [ + "QUERY_SHEAR", + 30, + 14, + false + ], + [ + "ADD", + 28, + 30 + ], + [ + "ADD", + 31, + 29 + ], + [ + "LOCAL", + 31, + 15, + true + ], + [ + "LOCAL", + 32, + 15, + false + ], + [ + "IDLE", + 7, + [ + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 8, + [ + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 9, + [ + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 10, + [ + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 11, + [ + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 12, + [ + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 13, + [ + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 14, + [ + 31, + 32 + ] + ], + [ + "ADD", + 30, + 28 + ], + [ + "ADD", + 29, + 31 + ], + [ + "ADD", + 28, + 26 + ], + [ + "ADD", + 27, + 29 + ], + [ + "ADD", + 26, + 24 + ], + [ + "ADD", + 25, + 27 + ], + [ + "ADD", + 24, + 22 + ], + [ + "ADD", + 23, + 25 + ], + [ + "ADD", + 22, + 20 + ], + [ + "ADD", + 21, + 23 + ], + [ + "ADD", + 20, + 18 + ], + [ + "ADD", + 19, + 21 + ], + [ + "ADD", + 18, + 16 + ], + [ + "ADD", + 17, + 19 + ], + [ + "ADD", + 16, + 14 + ], + [ + "ADD", + 15, + 17 + ], + [ + "ADD", + 14, + 12 + ], + [ + "ADD", + 13, + 15 + ], + [ + "ADD", + 12, + 10 + ], + [ + "ADD", + 11, + 13 + ], + [ + "ADD", + 10, + 8 + ], + [ + "ADD", + 9, + 11 + ], + [ + "ADD", + 8, + 6 + ], + [ + "ADD", + 7, + 9 + ], + [ + "ADD", + 6, + 4 + ], + [ + "ADD", + 5, + 7 + ], + [ + "ADD", + 4, + 2 + ], + [ + "ADD", + 3, + 5 + ], + [ + "ADD", + 2, + 0 + ], + [ + "ADD", + 1, + 3 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "SWAP", + 2, + 3 + ], + [ + "SWAP", + 4, + 5 + ], + [ + "SWAP", + 6, + 7 + ], + [ + "SWAP", + 8, + 9 + ], + [ + "SWAP", + 10, + 11 + ], + [ + "SWAP", + 12, + 13 + ], + [ + "SWAP", + 14, + 15 + ], + [ + "SWAP", + 16, + 17 + ], + [ + "SWAP", + 18, + 19 + ], + [ + "SWAP", + 20, + 21 + ], + [ + "SWAP", + 22, + 23 + ], + [ + "SWAP", + 24, + 25 + ], + [ + "SWAP", + 26, + 27 + ], + [ + "SWAP", + 28, + 29 + ], + [ + "SWAP", + 30, + 31 + ] + ], + "prefix_pairs": 7 +} diff --git a/research/query-thinned-controllers/COMPLEX-CONTROLLER.json b/research/query-thinned-controllers/COMPLEX-CONTROLLER.json new file mode 100644 index 0000000000..39318f6ad9 --- /dev/null +++ b/research/query-thinned-controllers/COMPLEX-CONTROLLER.json @@ -0,0 +1,5801 @@ +{ + "ambient_rank": 153, + "boundaries": { + "left": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "left_program": [ + [ + "SWAP", + 29, + 31 + ], + [ + "SWAP", + 28, + 29 + ], + [ + "SWAP", + 27, + 30 + ], + [ + "SWAP", + 25, + 27 + ], + [ + "SWAP", + 24, + 31 + ], + [ + "SWAP", + 23, + 27 + ], + [ + "SWAP", + 22, + 27 + ], + [ + "SWAP", + 21, + 23 + ], + [ + "SWAP", + 20, + 30 + ], + [ + "SWAP", + 19, + 24 + ], + [ + "SWAP", + 18, + 28 + ], + [ + "SWAP", + 17, + 33 + ], + [ + "ADD", + 14, + 16, + "1" + ], + [ + "ADD", + 12, + 16, + "-1" + ], + [ + "ADD", + 10, + 16, + "1" + ], + [ + "ADD", + 8, + 16, + "-1" + ], + [ + "ADD", + 6, + 16, + "1" + ], + [ + "ADD", + 4, + 16, + "-1" + ], + [ + "ADD", + 2, + 16, + "1" + ], + [ + "ADD", + 0, + 16, + "-1" + ], + [ + "ADD", + 33, + 15, + "-1" + ], + [ + "SCALE", + 15, + "-1" + ], + [ + "SWAP", + 15, + 32 + ], + [ + "ADD", + 12, + 14, + "1" + ], + [ + "ADD", + 10, + 14, + "-1" + ], + [ + "ADD", + 8, + 14, + "1" + ], + [ + "ADD", + 6, + 14, + "-1" + ], + [ + "ADD", + 4, + 14, + "1" + ], + [ + "ADD", + 2, + 14, + "-1" + ], + [ + "ADD", + 0, + 14, + "1" + ], + [ + "SWAP", + 14, + 15 + ], + [ + "ADD", + 33, + 13, + "1" + ], + [ + "ADD", + 32, + 13, + "1" + ], + [ + "SWAP", + 13, + 31 + ], + [ + "ADD", + 10, + 12, + "1" + ], + [ + "ADD", + 8, + 12, + "-1" + ], + [ + "ADD", + 6, + 12, + "1" + ], + [ + "ADD", + 4, + 12, + "-1" + ], + [ + "ADD", + 2, + 12, + "1" + ], + [ + "ADD", + 0, + 12, + "-1" + ], + [ + "SWAP", + 12, + 14 + ], + [ + "ADD", + 33, + 11, + "-1" + ], + [ + "ADD", + 32, + 11, + "-1" + ], + [ + "ADD", + 31, + 11, + "-1" + ], + [ + "SCALE", + 11, + "-1" + ], + [ + "SWAP", + 11, + 30 + ], + [ + "ADD", + 8, + 10, + "1" + ], + [ + "ADD", + 6, + 10, + "-1" + ], + [ + "ADD", + 4, + 10, + "1" + ], + [ + "ADD", + 2, + 10, + "-1" + ], + [ + "ADD", + 0, + 10, + "1" + ], + [ + "SWAP", + 10, + 13 + ], + [ + "ADD", + 33, + 9, + "1" + ], + [ + "ADD", + 32, + 9, + "1" + ], + [ + "ADD", + 31, + 9, + "1" + ], + [ + "ADD", + 30, + 9, + "1" + ], + [ + "SWAP", + 9, + 29 + ], + [ + "ADD", + 6, + 8, + "1" + ], + [ + "ADD", + 4, + 8, + "-1" + ], + [ + "ADD", + 2, + 8, + "1" + ], + [ + "ADD", + 0, + 8, + "-1" + ], + [ + "SWAP", + 8, + 12 + ], + [ + "ADD", + 33, + 7, + "-1" + ], + [ + "ADD", + 32, + 7, + "-1" + ], + [ + "ADD", + 31, + 7, + "-1" + ], + [ + "ADD", + 30, + 7, + "-1" + ], + [ + "ADD", + 29, + 7, + "-1" + ], + [ + "SCALE", + 7, + "-1" + ], + [ + "SWAP", + 7, + 28 + ], + [ + "ADD", + 4, + 6, + "1" + ], + [ + "ADD", + 2, + 6, + "-1" + ], + [ + "ADD", + 0, + 6, + "1" + ], + [ + "SWAP", + 6, + 11 + ], + [ + "ADD", + 33, + 5, + "1" + ], + [ + "ADD", + 32, + 5, + "1" + ], + [ + "ADD", + 31, + 5, + "1" + ], + [ + "ADD", + 30, + 5, + "1" + ], + [ + "ADD", + 29, + 5, + "1" + ], + [ + "ADD", + 28, + 5, + "1" + ], + [ + "SWAP", + 5, + 27 + ], + [ + "ADD", + 2, + 4, + "1" + ], + [ + "ADD", + 0, + 4, + "-1" + ], + [ + "SWAP", + 4, + 10 + ], + [ + "ADD", + 33, + 3, + "-1" + ], + [ + "ADD", + 32, + 3, + "-1" + ], + [ + "ADD", + 31, + 3, + "-1" + ], + [ + "ADD", + 30, + 3, + "-1" + ], + [ + "ADD", + 29, + 3, + "-1" + ], + [ + "ADD", + 28, + 3, + "-1" + ], + [ + "ADD", + 27, + 3, + "-1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 26 + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "SWAP", + 2, + 9 + ], + [ + "ADD", + 33, + 1, + "1" + ], + [ + "ADD", + 32, + 1, + "1" + ], + [ + "ADD", + 31, + 1, + "1" + ], + [ + "ADD", + 30, + 1, + "1" + ], + [ + "ADD", + 29, + 1, + "1" + ], + [ + "ADD", + 28, + 1, + "1" + ], + [ + "ADD", + 27, + 1, + "1" + ], + [ + "ADD", + 26, + 1, + "1" + ], + [ + "SWAP", + 1, + 25 + ], + [ + "SWAP", + 0, + 8 + ] + ], + "right": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "right_program": [ + [ + "ADD", + 33, + 32, + "-1" + ], + [ + "SCALE", + 32, + "-1" + ], + [ + "ADD", + 32, + 31, + "1" + ], + [ + "ADD", + 30, + 31, + "-1" + ], + [ + "ADD", + 29, + 31, + "-1" + ], + [ + "ADD", + 28, + 31, + "-1" + ], + [ + "SCALE", + 31, + "-1" + ], + [ + "ADD", + 31, + 30, + "-1" + ], + [ + "ADD", + 29, + 30, + "-1" + ], + [ + "ADD", + 28, + 30, + "-1" + ], + [ + "SCALE", + 30, + "-1" + ], + [ + "ADD", + 31, + 29, + "-1" + ], + [ + "ADD", + 28, + 29, + "-1" + ], + [ + "SWAP", + 29, + 30 + ], + [ + "ADD", + 31, + 28, + "-1" + ], + [ + "SCALE", + 28, + "-1" + ], + [ + "ADD", + 31, + 27, + "1" + ], + [ + "ADD", + 26, + 27, + "-1" + ], + [ + "ADD", + 25, + 27, + "-1" + ], + [ + "SWAP", + 27, + 30 + ], + [ + "ADD", + 30, + 26, + "1" + ], + [ + "ADD", + 25, + 26, + "-1" + ], + [ + "SCALE", + 26, + "-1" + ], + [ + "ADD", + 30, + 25, + "1" + ], + [ + "SWAP", + 25, + 26 + ], + [ + "SWAP", + 24, + 29 + ], + [ + "SWAP", + 23, + 25 + ], + [ + "SWAP", + 22, + 23 + ], + [ + "SWAP", + 21, + 25 + ], + [ + "SWAP", + 20, + 27 + ], + [ + "SWAP", + 19, + 29 + ], + [ + "SWAP", + 18, + 31 + ], + [ + "SWAP", + 17, + 33 + ], + [ + "ADD", + 15, + 16, + "-1" + ], + [ + "ADD", + 14, + 15, + "-1" + ], + [ + "SWAP", + 15, + 32 + ], + [ + "ADD", + 13, + 14, + "-1" + ], + [ + "SWAP", + 14, + 32 + ], + [ + "ADD", + 12, + 13, + "-1" + ], + [ + "SWAP", + 13, + 24 + ], + [ + "ADD", + 11, + 12, + "-1" + ], + [ + "SWAP", + 12, + 32 + ], + [ + "ADD", + 10, + 11, + "-1" + ], + [ + "SWAP", + 11, + 20 + ], + [ + "ADD", + 9, + 10, + "-1" + ], + [ + "SWAP", + 10, + 24 + ], + [ + "ADD", + 8, + 9, + "-1" + ], + [ + "SWAP", + 9, + 28 + ], + [ + "SWAP", + 8, + 32 + ], + [ + "SWAP", + 7, + 18 + ], + [ + "SWAP", + 6, + 20 + ], + [ + "SWAP", + 5, + 22 + ], + [ + "SWAP", + 4, + 24 + ], + [ + "SWAP", + 3, + 26 + ], + [ + "SWAP", + 2, + 28 + ], + [ + "SWAP", + 1, + 30 + ], + [ + "SWAP", + 0, + 32 + ] + ] + }, + "diagonal": [ + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ] + ], + "invoice": { + "main": { + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "153": 224 + }, + "owned_streams_reused_sequentially": 1, + "paid": { + "1": 49045, + "2": 13547, + "3": 4256, + "4": 1938, + "5": 380, + "8": 152, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + }, + "paid_calls": 72902, + "productive_fields": 11560, + "rank_surplus": 800, + "raw_scalar_record_bound": 1000000000, + "targets": { + "5": 532, + "6": 342, + "7": 1064, + "8": 1767, + "9": 4047, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "153": 224 + }, + "thick_calls": 19, + "thick_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ], + "thin_queries": 1792, + "whole_idle": { + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + } + }, + "keep_mask": 280378328416255, + "kind": "complex", + "pairs": 17, + "physical_events": [ + [ + "LOCAL", + 0, + 0, + false + ], + [ + "LOCAL", + 1, + 0, + true + ], + [ + "IDLE", + 1, + [ + 0, + 1 + ] + ], + [ + "ADD", + 0, + 2, + 1 + ], + [ + "ADD", + 3, + 1, + -1 + ], + [ + "QUERY_SHEAR", + 2, + 0, + false + ], + [ + "ADD", + 0, + 2, + -1 + ], + [ + "ADD", + 3, + 1, + 1 + ], + [ + "LOCAL", + 3, + 1, + true + ], + [ + "IDLE", + 2, + [ + 0, + 1, + 3 + ] + ], + [ + "ADD", + 2, + 4, + 1 + ], + [ + "ADD", + 5, + 3, + -1 + ], + [ + "QUERY_SHEAR", + 4, + 1, + false + ], + [ + "ADD", + 2, + 4, + -1 + ], + [ + "ADD", + 5, + 3, + 1 + ], + [ + "LOCAL", + 5, + 2, + true + ], + [ + "IDLE", + 3, + [ + 0, + 1, + 3, + 5 + ] + ], + [ + "ADD", + 4, + 6, + 1 + ], + [ + "ADD", + 7, + 5, + -1 + ], + [ + "QUERY_SHEAR", + 6, + 2, + false + ], + [ + "ADD", + 4, + 6, + -1 + ], + [ + "ADD", + 7, + 5, + 1 + ], + [ + "LOCAL", + 7, + 3, + true + ], + [ + "IDLE", + 4, + [ + 0, + 1, + 3, + 5, + 7 + ] + ], + [ + "ADD", + 6, + 8, + 1 + ], + [ + "ADD", + 9, + 7, + -1 + ], + [ + "QUERY_SHEAR", + 8, + 3, + false + ], + [ + "ADD", + 6, + 8, + -1 + ], + [ + "ADD", + 9, + 7, + 1 + ], + [ + "LOCAL", + 9, + 4, + true + ], + [ + "IDLE", + 5, + [ + 0, + 1, + 3, + 5, + 7, + 9 + ] + ], + [ + "ADD", + 8, + 10, + 1 + ], + [ + "ADD", + 11, + 9, + -1 + ], + [ + "QUERY_SHEAR", + 10, + 4, + false + ], + [ + "ADD", + 8, + 10, + -1 + ], + [ + "ADD", + 11, + 9, + 1 + ], + [ + "LOCAL", + 11, + 5, + true + ], + [ + "IDLE", + 6, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11 + ] + ], + [ + "ADD", + 10, + 12, + 1 + ], + [ + "ADD", + 13, + 11, + -1 + ], + [ + "QUERY_SHEAR", + 12, + 5, + false + ], + [ + "ADD", + 10, + 12, + -1 + ], + [ + "ADD", + 13, + 11, + 1 + ], + [ + "LOCAL", + 13, + 6, + true + ], + [ + "IDLE", + 7, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13 + ] + ], + [ + "ADD", + 12, + 14, + 1 + ], + [ + "ADD", + 15, + 13, + -1 + ], + [ + "QUERY_SHEAR", + 14, + 6, + false + ], + [ + "ADD", + 12, + 14, + -1 + ], + [ + "ADD", + 15, + 13, + 1 + ], + [ + "LOCAL", + 15, + 7, + true + ], + [ + "IDLE", + 8, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15 + ] + ], + [ + "ADD", + 14, + 16, + 1 + ], + [ + "ADD", + 17, + 15, + -1 + ], + [ + "QUERY_SHEAR", + 16, + 7, + false + ], + [ + "ADD", + 14, + 16, + -1 + ], + [ + "ADD", + 17, + 15, + 1 + ], + [ + "LOCAL", + 17, + 8, + true + ], + [ + "ADD", + 16, + 18, + 1 + ], + [ + "ADD", + 19, + 17, + -1 + ], + [ + "QUERY_SHEAR", + 18, + 8, + false + ], + [ + "ADD", + 16, + 18, + -1 + ], + [ + "ADD", + 19, + 17, + 1 + ], + [ + "LOCAL", + 19, + 9, + true + ], + [ + "ADD", + 18, + 20, + 1 + ], + [ + "ADD", + 21, + 19, + -1 + ], + [ + "QUERY_SHEAR", + 20, + 9, + false + ], + [ + "ADD", + 18, + 20, + -1 + ], + [ + "ADD", + 21, + 19, + 1 + ], + [ + "LOCAL", + 21, + 10, + true + ], + [ + "ADD", + 20, + 22, + 1 + ], + [ + "ADD", + 23, + 21, + -1 + ], + [ + "QUERY_SHEAR", + 22, + 10, + false + ], + [ + "ADD", + 20, + 22, + -1 + ], + [ + "ADD", + 23, + 21, + 1 + ], + [ + "LOCAL", + 23, + 11, + true + ], + [ + "ADD", + 22, + 24, + 1 + ], + [ + "ADD", + 25, + 23, + -1 + ], + [ + "QUERY_SHEAR", + 24, + 11, + false + ], + [ + "ADD", + 22, + 24, + -1 + ], + [ + "ADD", + 25, + 23, + 1 + ], + [ + "LOCAL", + 25, + 12, + true + ], + [ + "ADD", + 24, + 26, + 1 + ], + [ + "ADD", + 27, + 25, + -1 + ], + [ + "QUERY_SHEAR", + 26, + 12, + false + ], + [ + "ADD", + 24, + 26, + -1 + ], + [ + "ADD", + 27, + 25, + 1 + ], + [ + "LOCAL", + 27, + 13, + true + ], + [ + "ADD", + 26, + 28, + 1 + ], + [ + "ADD", + 29, + 27, + -1 + ], + [ + "QUERY_SHEAR", + 28, + 13, + false + ], + [ + "ADD", + 26, + 28, + -1 + ], + [ + "ADD", + 29, + 27, + 1 + ], + [ + "LOCAL", + 29, + 14, + true + ], + [ + "ADD", + 28, + 30, + 1 + ], + [ + "ADD", + 31, + 29, + -1 + ], + [ + "QUERY_SHEAR", + 30, + 14, + false + ], + [ + "ADD", + 28, + 30, + -1 + ], + [ + "ADD", + 31, + 29, + 1 + ], + [ + "LOCAL", + 31, + 15, + true + ], + [ + "ADD", + 30, + 32, + 1 + ], + [ + "ADD", + 33, + 31, + -1 + ], + [ + "QUERY_SHEAR", + 32, + 15, + false + ], + [ + "ADD", + 30, + 32, + -1 + ], + [ + "ADD", + 33, + 31, + 1 + ], + [ + "LOCAL", + 33, + 16, + true + ], + [ + "LOCAL", + 34, + 16, + false + ], + [ + "IDLE", + 8, + [ + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ] + ], + [ + "IDLE", + 9, + [ + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ] + ], + [ + "IDLE", + 10, + [ + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ] + ], + [ + "IDLE", + 11, + [ + 25, + 27, + 29, + 31, + 33, + 34 + ] + ], + [ + "IDLE", + 12, + [ + 27, + 29, + 31, + 33, + 34 + ] + ], + [ + "IDLE", + 13, + [ + 29, + 31, + 33, + 34 + ] + ], + [ + "IDLE", + 14, + [ + 31, + 33, + 34 + ] + ], + [ + "IDLE", + 15, + [ + 33, + 34 + ] + ], + [ + "ADD", + 32, + 30, + 1 + ], + [ + "ADD", + 31, + 33, + -1 + ], + [ + "ADD", + 30, + 28, + 1 + ], + [ + "ADD", + 29, + 31, + -1 + ], + [ + "ADD", + 28, + 26, + 1 + ], + [ + "ADD", + 27, + 29, + -1 + ], + [ + "ADD", + 26, + 24, + 1 + ], + [ + "ADD", + 25, + 27, + -1 + ], + [ + "ADD", + 24, + 22, + 1 + ], + [ + "ADD", + 23, + 25, + -1 + ], + [ + "ADD", + 22, + 20, + 1 + ], + [ + "ADD", + 21, + 23, + -1 + ], + [ + "ADD", + 20, + 18, + 1 + ], + [ + "ADD", + 19, + 21, + -1 + ], + [ + "ADD", + 18, + 16, + 1 + ], + [ + "ADD", + 17, + 19, + -1 + ], + [ + "ADD", + 16, + 14, + 1 + ], + [ + "ADD", + 15, + 17, + -1 + ], + [ + "ADD", + 14, + 12, + 1 + ], + [ + "ADD", + 13, + 15, + -1 + ], + [ + "ADD", + 12, + 10, + 1 + ], + [ + "ADD", + 11, + 13, + -1 + ], + [ + "ADD", + 10, + 8, + 1 + ], + [ + "ADD", + 9, + 11, + -1 + ], + [ + "ADD", + 8, + 6, + 1 + ], + [ + "ADD", + 7, + 9, + -1 + ], + [ + "ADD", + 6, + 4, + 1 + ], + [ + "ADD", + 5, + 7, + -1 + ], + [ + "ADD", + 4, + 2, + 1 + ], + [ + "ADD", + 3, + 5, + -1 + ], + [ + "ADD", + 2, + 0, + 1 + ], + [ + "ADD", + 1, + 3, + -1 + ], + [ + "SIGNED_SWAP", + 0, + 1 + ], + [ + "SIGNED_SWAP", + 2, + 3 + ], + [ + "SIGNED_SWAP", + 4, + 5 + ], + [ + "SIGNED_SWAP", + 6, + 7 + ], + [ + "SIGNED_SWAP", + 8, + 9 + ], + [ + "SIGNED_SWAP", + 10, + 11 + ], + [ + "SIGNED_SWAP", + 12, + 13 + ], + [ + "SIGNED_SWAP", + 14, + 15 + ], + [ + "SIGNED_SWAP", + 16, + 17 + ], + [ + "SIGNED_SWAP", + 18, + 19 + ], + [ + "SIGNED_SWAP", + 20, + 21 + ], + [ + "SIGNED_SWAP", + 22, + 23 + ], + [ + "SIGNED_SWAP", + 24, + 25 + ], + [ + "SIGNED_SWAP", + 26, + 27 + ], + [ + "SIGNED_SWAP", + 28, + 29 + ], + [ + "SIGNED_SWAP", + 30, + 31 + ], + [ + "SIGNED_SWAP", + 32, + 33 + ] + ], + "prefix_pairs": 8 +} diff --git a/research/query-thinned-controllers/PROOF.md b/research/query-thinned-controllers/PROOF.md new file mode 100644 index 0000000000..9068f42989 --- /dev/null +++ b/research/query-thinned-controllers/PROOF.md @@ -0,0 +1,278 @@ +# Query-thinned productive controllers + +## Conditional result + +Under the retained native, whole-job matching, owned-erasure, tape, analytic, +precision and exact-recovery contracts of #4359/#4416, the construction below +gives + + T(n) = O(n (log n)^(1 - kappa)), kappa = 37/12500 = 0.00296. + +This is a new author-checked conditional construction. It is not an +unconditional theorem, a formal-kernel proof, a practical implementation or a +change to the selected record. It improves #4416/#4433's conditional 0.00268647 +by about 10.1818%, and the selected 0.0023 checkpoint by about 28.6957%. +Those percentages compare exponent savings, not running times. + +The new mechanism replaces selected full native invocations by copied +rank-one query shears. Losing their productive helpers is charged. Removing +their stage multipliers also removes the corresponding parts of every idle +transform and main target. These coupled changes improve the complete moment; +merely deleting a local bill would not. + +## 1. Exact local interfaces + +Retain the source local word's all-column interpretation. For complex data, +on each of 112 ports write Q for its central rank-one Gaussian and D_s for +the commuting fresh eight-axis multiplier at stage s. Stage zero instead +uses the source nine-axis multiplier times Q^-1. The forward and backward +physical local maps are + + D_s S_y(Q^-1), D_s S_x(-Q). + +The complete THREE-base supplier has independent helper targets + + {5:28, 6:18, 7:56, 8:93, 9:213} + +and unsplit paid profile + + {1:2487, 2:713, 3:224, 4:102, 5:20, 8:8}. + +Its 408 helpers are arbitrary original fields. The one sequentially reused +owned center receives no productive credit. These source words and their +all-column/phase evidence are retained unchanged; this contribution does not +repeat their full historical physical replay. + +For BIT, retain the PR589 local word on 111 ports and 439 arbitrary helpers. +Each helper target has rank 8, D_s has rank 7, Q is the port's rank-one +projector involution, and the paid profile is + + {1:1323, 2:1342, 3:79, 4:44, 5:102, 6:11, 7:19}. + +Its nine copied-center episodes remain in that profile. Its rational charts +and common-weight delayed-cover interpretation remain explicit premises. + +### The new query-only call + +To implement S_y(Q^-1) on arbitrary X,Y, clear one owned stream Z, copy X +into Z, perform Q^-1 on Z, add Z to Y, and erase Z. Return X unchanged and +Z zero. Backward uses Q and subtracts from X. Each port costs exactly one +paid rank-one job, plus the copy/add/erase and fixed matching/routing work. +There is no independent input or output credit for Z. + +For complex data Q^-1 is one positive Gaussian followed by its physical +Pauli translation: the Z4 phases -q and q+2q agree. It is not replaced by Q +using an order-two assumption. For BIT Q^-1=Q. The same construction at +column multiplicity f makes a rank-f request; this cost is never treated as +a scalar operation. Erasure is the inherited owned-stream erasure operation, +not a claim about reversible or dirty-borrowed erasure. + +## 2. The two actual finite controller words + +Start with the credited paired path controller, keeping all middle idle +windows and splitting the initial/terminal windows at a. Let p be the pair +count, with 2p+1 local stages. Keep the full native call at stages + + S = {0, 2p} union {1,3,...,2p-1}. + +Replace each other local call by its query-only shear. In every idle word, +remove those same stage multipliers. Every scalar bridge and signed exchange +remains in its original chronological place. Thus there are p+2 full native +calls and p-1 query shears. Thin stages have no fresh axes or helpers. + +`controller.py` constructs the words and constant scalar boundaries. The +verifier replays the emitted LOCAL, QUERY_SHEAR, IDLE, ADD and exchange events +directly, compares with the original polynomial specialized by D_s=1 on thin +stages, and checks every coefficient of L A R against the advertised diagonal. +The complex check is over rational Laurent polynomials, with all Q signs +retained. BIT has a separate exact binary group-ring factorization. + +Only two finite words are needed: + +| Family | p | a | Full native calls | Query shears | Active ambient rank | +|---|---:|---:|---:|---:|---:| +| Complex | 17 | 8 | 19 | 16 | 153 | +| BIT | 16 | 7 | 18 | 15 | 127 | + +Unused fresh blocks can be removed by an injective relabeling. All noninitial +complex native contacts occur on the same old-nine plus fresh-eight space; +other blocks are fixed spectators. Exact forward/inverse phase checks on +all 112 ports establish this contact independently of the number of stages. +The initial native call is unchanged. The binary rational 15-dimensional +charts are likewise checked on all 111 ports. Tensoring these identities with +I_f preserves them for each positive column multiplicity under the inherited +all-column implementation contract. + +For block rank d and port count v, the main targets are two v-field copies +of rank 1+d(p+2), and two v-field copies of rank 1+d(j+1) for j=1..a and +j=1..p-1-a. The corresponding whole idle ranks are d(j+1), each with 2v +calls. The old one-stage middle idles have become identities. In addition, +there are (p+2) fresh helper inventories, (p+2) native paid inventories, and +v(p-1) paid rank-one queries. Literal and formula-derived ledgers agree. + +All helper identities are allocated freshly per full invocation. The main +fields, helpers and suspended centers have distinct physical slots. Scalar +boundary changes are invertible, so independent arbitrary main inputs remain +independent. Thin copies introduce no new sources. Center/query ownership is +retained until the relevant call returns, and every matcher is undone. + +The exact invoices are in RESULT.json. Their basic resource counts are: + +| Family | Productive fields | Paid jobs | Productive rank mass | Paid rank mass | Surplus | +|---|---:|---:|---:|---:|---:| +| Complex | 11,560 | 72,902 | 258,271 | 257,471 | 800 | +| BIT | 11,454 | 57,555 | 217,506 | 216,753 | 753 | + +Both paid and target ranks overlap. They are not directly admitted to the +strict compiler. Raw numerical roots near 0.002960345565 and 0.003464248972 +were discovery aids; the argument uses the exact strict tests below. + +## 3. Charged tensor completion and splitting + +Apply #4416's chronological product construction and #4433's higher-moment +tail theorem to each new native unit. This is composition of actual programs: +copies are paused at the same paid position, a complete child unit runs on +distinct current owners, and it returns before any parent resumes. Correlated +values in distinct slots are allowed. No product of sums of operator matrices +is substituted for this schedule. + +Write T_t,P_t for the raw moments, B for the productive field count, +t=1-C, and choose cutoff c, target floor b, u>=C and integer power v. +After the product finishes, complete every rank K2^26*N^5, also avoiding the finite denominators and +rank witnesses, exceeds 256/(C0-C1)*N^5 and pays the complete fallback. + +Change the atom power to delta=0.004. With retained old ordinary saving +a_old=0.0000384599, the ordinary saving is exactly + + (1-delta)*C1+delta*a_old = 0.0034363538396 > 0.0034. + +Admit 0.0034. The linear adapter has saving delta>0.0034363538396; stock +is sublinear because delta<1-0.0034363538396. The old delta=0.003 fails +this adapter comparison and is explicitly rejected. All compiled dimensions, +role counts, routes, centers and leaf counts replace the old p3 constants in +the delayed-cover stock formulas. For fixed compiled N,B,P, the borrowed +digits remain O(w log e)=o(e), with w=ceil(e^0.004). + +Put kappa=0.00296, C=0.00296030, d=(C-kappa)/7, and + + complex_uniform = kappa+6d, b=kappa+5d, + a=kappa+4d, q=kappa+3d, + epsilon=1-d, beta=1-3d, r0=d/10, stop=layout=d. + +Use the admitted BIT saving 0.0034 in the unchanged nine-row outer ledger. +All 54 named strict predicates and the three retained functional predicates +pass. An additional functional predicate binds the new BIT atom explicitly, +beta*(1-0.004)>0. The smallest outer saving exceeds kappa by +629378373/4900000000000000. Old BIT admission, zero layout, closed epsilon, +closed complex slack and an unfunded endpoint each fail their intended checks. + +## 5. Finite constants, precision and scope + +No new operation is declared free. Raw scalar programs, signed swaps, copy/ +erase records, affine port charts and inverse routes are finite emitted lists. +The conservative raw scalar record bound is 10^9, above the checked local, +query and boundary bills. Every query adds its own paid job and its own +fixed routing records. Initial/end charts and target normalizers are retained. + +For a raw unit with productive count B, paid count P and scalar bound L0, +a v-fold chronological product has at most +L0*v*(B+P)^v nonrecursive records before final completion. Its old paid rank +mass is P1^v, and added completion rank is at most B^v*b^v. Bound all new +completion/splitting records by their integer rank masses, then multiply by +10*m^(2v)+10 to cover whole-job normalizers and inverse routes. This is a +constructive finite overestimate, not a claim that those movements vanish. +Allocate a distinct center to each simultaneously suspended instance; a +bound by the total expanded record count suffices. The integer compiler adds +only finitely many effective classes and clears their batch denominators. + +Apply the retained semantic-precision and stock prescriptions to these new +finite lists, coefficient heights, prefix row norms, owned centers and +matchers. They are fixed constants before the asymptotic input size varies. +All raw complex boundary coefficients are unit signed scalars; native dyadic +coefficients and BIT rational cover entries retain their pinned bounds. A +brute-force product of per-record row-mass bounds supplies an effective +prefix bound if a sharper bound is unnecessary. Increase the fixed precision +constant and fixed stock coefficient accordingly. The outer slack conditions +are strict, so absorbing these fixed constants does not change their powers. +This inherits the same all-column, physical tape, native movement/repair, +precision, analytic and recovery contracts as the reviewed source; it does +not independently prove that historical implementation stack. + +## 6. Sources, attribution, validation and next questions + +Canonical baseline: 3a23e9d9d2e67833515d1c60a17e966bcdcab43c, priority +revision 7. Refreshed main and PR checks are recorded in TASK.json. Live +overlap covered all open PR bodies and Discussion pages; sparse local README +coverage and closed-PR-body coverage are incomplete. No novelty theorem is +claimed. #4194's coded/clean local hybrid addresses a different interface; +this construction uses complete native calls and copied rank-one shears. + +Credit: zxv for the retained controller/native construction and higher-moment +tail proof (#4359/#4433); Jacob Alan Sussman for mixed-target integer flow +(#4268); Cinna Davis for the p7 paid-completion/native construction (#4416); +DreamingOfClouds, eumemic and their retained PR589/PR555 BIT lineage; +David Ganz, Jeremy Kothe, Rohan Arun, Marius-Paul Dumitrean, Erwan Secousses +and the native/outer contributors named in the unchanged source notices and +the selected contributor map. New query-thinning construction, proofs and +checks were prepared for Cinna Davis with substantial OpenAI Codex assistance. +Apache-2.0. No subagents were used. + +Reproduce with the registered command in README.md. Finite source, physical +operator, phase, interval, invoice and outer checks support this written +conditional proof; they do not constitute formal verification. Full old native +word replays, Lean and Docker were not rerun for this contribution. + +Open next questions, with first steps and blockers, are in TASK.json. The +next useful audit is the whole-job/owned-query lowering at arbitrary column +multiplicity. The next improvement question is a changed local query/native +alphabet or controller topology. A larger path census alone gives no global +optimality or assurance of a stronger complete construction. diff --git a/research/query-thinned-controllers/README.md b/research/query-thinned-controllers/README.md new file mode 100644 index 0000000000..6d1099e9a5 --- /dev/null +++ b/research/query-thinned-controllers/README.md @@ -0,0 +1,39 @@ +# Conditional κ = 0.00296 through query-thinned productive controllers + +The new construction replaces selected full native calls by paid rank-one +query shears, charging the lost productive helpers and removing the same +stage multipliers from the idle and main transforms. It gives an author-checked +conditional multiplication saving **κ = 37/12500 = 0.00296**, approximately +**10.18% above #4416/#4433's 0.00268647**. + +The complex controller uses 17 pairs, 19 full native calls and 16 query shears. +The accompanying BIT controller uses 16 pairs, 18 full calls and 15 query +shears, supporting a stronger ordinary BIT saving of 0.0034 after all cover +and atom-conversion charges. The complete outer ledger passes at κ=0.00296. + +[PROOF.md](PROOF.md) gives the native query implementation, chronological +product and paid completion, effective compiler ranks, changed BIT stock +parameters, full cost/precision obligations, attribution and conditional scope. +[RESULT.json](RESULT.json) records the exact arithmetic and rejection controls. +The two controller JSON files contain their actual emitted event lists and +constant scalar boundary programs. `controller.py` regenerates them; normal +verification directly replays them without repeating factor discovery. + +```sh +python3.12 -B scripts/research_package.py --package research/query-thinned-controllers +python3.12 -O -B research/query-thinned-controllers/verify.py +``` + +See VALIDATION.md for the exact executed environments and commands. + +This retains the reviewed source's all-column native, owned-erasure, +whole-job matching, fixed-tape, precision, analytic, prime and recovery +premises. It claims no unconditional theorem, formal verification, practical +speedup, global controller optimum or selected-frontier change. + +## Open next questions + +Open next questions are recorded in [TASK.json](TASK.json), with relevance, +first steps and blockers. Prepared for Cinna Davis with substantial OpenAI +Codex assistance; no subagents. Apache-2.0. Source attribution is in PROOF.md +and the unchanged pinned predecessor notices. diff --git a/research/query-thinned-controllers/RESULT.json b/research/query-thinned-controllers/RESULT.json new file mode 100644 index 0000000000..e0695152c9 --- /dev/null +++ b/research/query-thinned-controllers/RESULT.json @@ -0,0 +1,356 @@ +{ + "bit_invoice": { + "main": { + "127": 222, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 222 + }, + "owned_streams_reused_sequentially": 1, + "paid": { + "1": 25479, + "14": 444, + "2": 24156, + "21": 444, + "28": 444, + "3": 1422, + "35": 444, + "4": 792, + "42": 444, + "49": 444, + "5": 1836, + "56": 444, + "6": 198, + "63": 222, + "7": 342 + }, + "paid_calls": 57555, + "productive_fields": 11454, + "rank_surplus": 753, + "raw_scalar_record_bound": 1000000000, + "targets": { + "127": 222, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 222, + "8": 7902 + }, + "thick_calls": 18, + "thick_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ], + "thin_queries": 1665, + "whole_idle": { + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444, + "63": 222 + } + }, + "bit_strictification": { + "alpha": { + "lower": "0.999995735238059506641600561767", + "upper": "0.999995735238059506641600561768" + }, + "compiler_H0": 3755884544, + "cutoff_base": 17, + "delta": { + "lower": "0.949707924144871179442776557218", + "upper": "0.949707924144871179442776557219" + }, + "gamma": { + "lower": "0.957429821066420278606254392110", + "upper": "0.957429821066420278606254392111" + }, + "normalized_surplus_lower": "68719461047/16845935476736", + "tail_exponent": "1/5", + "target_floor_base": 18, + "tensor_power": 1024, + "tested_saving": "173/50000", + "uniform_H1": 25986965159937, + "uniform_N": "2^25986965159937", + "uniform_saving": "3459/1000000", + "winning_word_materialized": false + }, + "complex_invoice": { + "main": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448 + }, + "owned_streams_reused_sequentially": 1, + "paid": { + "1": 49045, + "16": 448, + "2": 13547, + "24": 448, + "3": 4256, + "32": 448, + "4": 1938, + "40": 448, + "48": 448, + "5": 380, + "56": 448, + "64": 448, + "72": 448, + "8": 152 + }, + "paid_calls": 72902, + "productive_fields": 11560, + "rank_surplus": 800, + "raw_scalar_record_bound": 1000000000, + "targets": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "5": 532, + "57": 448, + "6": 342, + "65": 448, + "7": 1064, + "73": 448, + "8": 1767, + "9": 4047 + }, + "thick_calls": 19, + "thick_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ], + "thin_queries": 1792, + "whole_idle": { + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + } + }, + "complex_strictification": { + "alpha": { + "lower": "0.999999952117240859760145478345", + "upper": "0.999999952117240859760145478346" + }, + "compiler_H0": 75415467350, + "cutoff_base": 20, + "delta": { + "lower": "0.941649713484853845388929204840", + "upper": "0.941649713484853845388929204841" + }, + "gamma": { + "lower": "0.967466409565147920980822933859", + "upper": "0.967466409565147920980822933860" + }, + "normalized_surplus_lower": "8589700209/251666829934592", + "tail_exponent": "1/5", + "target_floor_base": 21, + "tensor_power": 1024, + "tested_saving": "29603/10000000", + "uniform_H1": 10418370291022217, + "uniform_N": "2^10418370291022217", + "uniform_saving": "103609/35000000", + "winning_word_materialized": false + }, + "kappa": "37/12500", + "minimum_outer_margin_minus_kappa": "629378373/4900000000000000", + "native": { + "binary_charts": 111, + "complex_contacts_and_inverses": 896, + "owned_stream_restored_zero": true, + "thin_paid_rank_per_port": 1, + "thin_productive_credit": 0 + }, + "negative_controls": { + "closed_epsilon": [ + "epsilon_below_one", + "global_gamma_power_slack", + "actual_logarithmic_gamma_guard", + "source_axis_superpolynomial", + "gaussian_above_main", + "new_semantic_guard_with_C1_one" + ], + "closed_uniform_gap": [ + "new_complex_uniform_saving_above_b" + ], + "missing_layout": [ + "positive_layout_slack" + ], + "old_BIT_cap": [ + "actual_bit_above_effective" + ], + "unfunded_kappa": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "old_atom_rejected": true, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "17429997759/17500000000", + "fixed_halo_explicit_metadata_branch": "1347500003/17500000", + "new_BIT_row_stock_sublinear_in_active_group": "69789991027/70000000000", + "new_semantic_group_guard": "9/70000000" + }, + "margins": { + "boundary_algebraic_matrix": "14504839378373/4900000000000000", + "fused_gaussian": "14504838135119/4900000000000000", + "global_coordinate_router": "51803/17500000", + "group_bit_router": "3626262033773/1225000000000000", + "group_scans": "34999997/35000000", + "main_transform": "14504629378373/4900000000000000", + "microbox_face_corrections": "1347500003/17500000", + "polynomial_products": "69999997/70000000", + "sparse_union_movement": "2005129839378373/4900000000000000" + }, + "parameters": { + "a": "51803/17500000", + "b": "41443/14000000", + "beta": "69999991/70000000", + "bit_saving": "17/5000", + "cap_xi": "4455129629378373/4900000000000000", + "complex_uniform_saving": "103609/35000000", + "d": "3/70000000", + "epsilon": "69999997/70000000", + "kappa": "37/12500", + "lambda_": "19940797/20000000", + "lambda_prime": "69792791/70000000", + "layout": "3/70000000", + "q": "207209/70000000", + "r0": "3/700000000", + "stop": "3/70000000", + "tested_saving": "29603/10000000" + }, + "strict_checks": { + "actual_bit_above_effective": "7697/17500000", + "actual_logarithmic_gamma_guard": "3/70000000", + "actual_logarithmic_group_guard": "444870685621627/2450000000000000", + "alpha_logarithm_absorption": "3/700000000", + "boundary_algebraic_matrix_above_kappa": "839378373/4900000000000000", + "cap_above_band": "2005129629378373/4900000000000000", + "cap_below_cell": "444870160621627/4900000000000000", + "cap_below_phase_cell_power": "5344870370621627/4900000000000000", + "complex_above_effective": "3/70000000", + "complex_below_one_over_32": "396057/14000000", + "complex_endpoint": "3/35000000", + "epsilon_below_one": "3/70000000", + "epsilon_positive": "69999997/70000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "838135119/4900000000000000", + "gaussian_above_main": "104378373/2450000000000000", + "global_coordinate_router_above_kappa": "3/17500000", + "global_gamma_power_slack": "27/700000000", + "group_below_dimension": "3/35000000", + "group_bit_router_above_kappa": "262033773/1225000000000000", + "group_gauge_power_slack": "444870675121627/2450000000000000", + "group_key_fits_record": "3/35000000", + "group_positive": "69999991/70000000", + "group_scans_above_kappa": "34896397/35000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "614514790400418148631/500000000000000000000000", + "lambda_above_internal": "3/140000000", + "lambda_above_sigma": "9/140000000", + "lambda_above_tau": "3/140000000", + "lambda_prime_above_lambda": "3/140000000", + "lambda_prime_above_leaf": "83875671/980000000000000", + "leaf_saving_above_effective": "41875671/980000000000000", + "main_transform_above_kappa": "629378373/4900000000000000", + "membership_arithmetic_fits_record": "3/70000000", + "microbox_face_corrections_above_kappa": "1347448203/17500000", + "microbox_halo_volume": "5530000009/70000000", + "new_complex_uniform_saving_above_b": "3/70000000", + "new_semantic_guard_with_C1_one": "3/70000000", + "polynomial_products_above_kappa": "69792797/70000000", + "positive_layout_slack": "3/70000000", + "q_below_effective": "3/70000000", + "q_below_internal": "3/70000000", + "q_below_leaf": "83875671/980000000000000", + "q_positive": "207209/70000000", + "short_record_fallback": "13958557/14000000", + "source_axis_superpolynomial": "3/70000000", + "sparse_union_movement_above_kappa": "1990625839378373/4900000000000000", + "stop_below_one": "69999997/70000000", + "stop_positive": "3/70000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "9/70000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "9/70000000", + "union_tag_work_per_visit_fits_record": "9/70000000" + } + }, + "relative_gain_over_p7": "27353/268647", + "schema": "query-thinned-productive-controllers/1", + "scope": "Conditional native construction; all-column, erasure, whole-job matching, fixed-tape, precision, analytic, prime and exact-recovery premises retained. No unconditional theorem or selected promotion.", + "source_inputs_authenticated": 17, + "status": "PASS_CONDITIONAL_QUERY_THINNED_KAPPA_00296" +} diff --git a/research/query-thinned-controllers/SOURCES.json b/research/query-thinned-controllers/SOURCES.json new file mode 100644 index 0000000000..0f061c87ff --- /dev/null +++ b/research/query-thinned-controllers/SOURCES.json @@ -0,0 +1,120 @@ +{ + "schema_version": 1, + "base_commit": "3a23e9d9d2e67833515d1c60a17e966bcdcab43c", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40", + "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "research/higher-moment-strictification/README.md", + "usage": "input", + "git_blob": "0a736ca89e1eafb73a30e1f2589cc45e6b5f76c3", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d" + }, + { + "path": "research/higher-moment-strictification/verify.py", + "usage": "input", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + { + "path": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "usage": "input", + "git_blob": "8b40135a84e7f0f0cd44bed69655801310b916a7", + "sha256": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85" + }, + { + "path": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "usage": "input", + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "path": "research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json", + "usage": "input", + "git_blob": "fbe6da7241357d89cf5c55b2e7ce2d0d046be32a", + "sha256": "edb273f59a27356ad89f38791590c3c806b228c3510eb508e01e89f2caba95ef" + }, + { + "path": "research/kappa-rebuild/bit/BIT-P3-NATIVE-BINDING.json", + "usage": "input", + "git_blob": "e8c5e4f077fea0bef355e6c3013c7f252d3606cf", + "sha256": "9ece46fdfda6182e757e9a3b1f513fb3d029d730f3bafdcd6ed59180a14175b0" + }, + { + "path": "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "usage": "input", + "git_blob": "a58774e237c9362869a60a22bda35be09fb85872", + "sha256": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443" + }, + { + "path": "research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json", + "usage": "input", + "git_blob": "6a139eedbc1015c13df6f2a4333e1a89b5edd18d", + "sha256": "2f69a19f417c0e0d141c180f9b2fae3d358391b9a230f5848ee07c45450e70bf" + }, + { + "path": "research/kappa-rebuild/bit/bit_native_binding.py", + "usage": "input", + "git_blob": "f4c4082d89969ea311219d9af8013082d599f6f1", + "sha256": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7" + }, + { + "path": "research/kappa-rebuild/bit/complex_controller_factor.py", + "usage": "input", + "git_blob": "cb0cff7c8be5f38f2ee52201d9d0907f9dfd7947", + "sha256": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497" + }, + { + "path": "research/kappa-rebuild/bit/mixed_productive_bit.py", + "usage": "input", + "git_blob": "9c7a8bd5d3ae4c19952648c815031858d6627b96", + "sha256": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e" + }, + { + "path": "research/kappa-rebuild/complex/FULL-IDENTITY.md", + "usage": "input", + "git_blob": "f97a23d7d21bd7f79c9d0cb14d8c6b44fddd3f23", + "sha256": "c4aa88c4943ef041e9542c519b7600ecf26ed6caff92558fdb07ac88ace64c17" + }, + { + "path": "research/kappa-rebuild/complex/full-identity-certificates/RESULT.json", + "usage": "input", + "git_blob": "c6edcbdc43bf36bb11201235027d0ec170d07fc8", + "sha256": "943d5fad2fc529f470df05a35446e07ecaef7344abfce450d2c2eb2c9b3798f6" + }, + { + "path": "research/pr4359-p7-padding/TENSOR.md", + "usage": "input", + "git_blob": "8ecfd3e4d0bcb449ecb1e150c4f1f4fbb39ca656", + "sha256": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3" + }, + { + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "usage": "input", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/pr4359-p7-padding/native_inventory.py", + "usage": "input", + "git_blob": "8d2d96e3998254c2333c43fe47cdfd074cbd811e", + "sha256": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32" + }, + { + "path": "research/kappa-rebuild/architecture/mixed_target_probe.py", + "usage": "input", + "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + } + ] +} diff --git a/research/query-thinned-controllers/TASK.json b/research/query-thinned-controllers/TASK.json new file mode 100644 index 0000000000..ebba49a09c --- /dev/null +++ b/research/query-thinned-controllers/TASK.json @@ -0,0 +1,86 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 7, + "base_commit": "3a23e9d9d2e67833515d1c60a17e966bcdcab43c", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "changed", + "actual_scope": "Construct query-thinned complex and BIT productive controllers and carry their exact physical words, paid tails, ordinary BIT conversion and complete outer costs to conditional kappa 0.00296.", + "scope_change_reason": "Explicit user assignment to improve kappa using the new productive-helper mechanism. The current card predates the selected changed interface; this replaces its frozen local-packing question with a complete global native/query construction.", + "bottleneck_link": "Selected full-native path calls impose stage and idle transforms even where a paid rank-one shear suffices. Removing them changes the full target/paid moment; a stronger BIT admission is needed above the prior cap.", + "budget_minutes": 60, + "stop_rule": "Finish the two actual finite native/query words and all caller costs; reject the endpoint if physical query ownership, full invoice, paid completion, BIT cover/stock or any outer predicate fails.", + "outcome": "completed", + "evidence": "PROOF.md, RESULT.json, COMPLEX-CONTROLLER.json, BIT-CONTROLLER.json, VALIDATION.md", + "author": "Cinna Davis / 1337isnot1337, with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in derivation, implementation, audit and writing; no subagents.", + "open_questions": [ + { + "question": "Can the arbitrary-column owned-query lowering receive an independent native/tape audit?", + "why_it_matters": "It is the new primitive interface connecting the physical word to the changed exponent.", + "first_step": "Replay one complex inverse query and one binary cover query at two column multiplicities, charging copy, matching, read and erasure.", + "blocked_by": "Independent native/tape review of the retained all-column contracts." + }, + { + "question": "Can a changed local query/native alphabet or branching controller exceed this complete moment?", + "why_it_matters": "The old all-native p7 screen does not constrain this changed alphabet.", + "first_step": "Define a different complete finite physical word and screen its full invoice before larger native reconstruction.", + "blocked_by": "No stronger complete native/query construction has been established." + } + ], + "upstream_checkpoint": { + "main": "2a13eb1827784206202db90e5dc8327cf8a250db", + "checked_at_utc": "2026-10-21T20:06:00Z", + "priority_revision": 7, + "selected_kappa": "0.0023", + "stronger_reviewed_conditional_kappa": "0.00268647" + }, + "overlap_coverage": { + "open_prs": "296 bodies, complete pagination, 2026-10-21T19:50:54Z", + "discussions": "3284 records, complete pagination, 2026-10-21T19:51:43Z", + "local_readmes": "sparse; incomplete", + "closed_pr_bodies": "not exhaustively searched", + "additional_checks": "PR4194 coded/clean hybrid differs; PR4433 higher-moment theorem adopted. Frontier rechecked at 19:33, 19:51 and 20:06 UTC, through #4439; no higher kappa found." + } +} diff --git a/research/query-thinned-controllers/VALIDATION.md b/research/query-thinned-controllers/VALIDATION.md new file mode 100644 index 0000000000..2924d84be3 --- /dev/null +++ b/research/query-thinned-controllers/VALIDATION.md @@ -0,0 +1,43 @@ +# Validation and limits + +Environment: Linux x86_64, CPython **3.12.14** (bundled runtime). Initial +factor discovery also ran on CPython 3.14.8. Standard library only. No +subagents, Lean build, Docker run or full historical suite. + +Completed on 2026-10-21: + +- `python3.12 -B scripts/research_package.py --package research/query-thinned-controllers --check-only` + passes metadata and all 17 input pins. +- `python3.12 -B scripts/research_package.py --package research/query-thinned-controllers` + passes the complete registered replay. +- `python3.12 -O -B research/query-thinned-controllers/verify.py` passes + from a separate **Git-free export** containing this package and exactly the + declared input files. Its RESULT.json agrees with the normal replay. +- The two external rejection controls also run in that Git-free export under + optimized Python. Appending a comment to the pinned interval source rejects + with `Changed source`. Changing an emitted QUERY_SHEAR to LOCAL rejects the + physical-event equality check. Both altered export files were restored; + no canonical predecessor file was changed. +- Internal controls execute omitted-clear and omitted-erase query words, + reverse a query's actual orientation, change a Laurent coefficient, retain + the old BIT cap or atom, close the complex/epsilon gap, omit layout, and + request the unfunded outer endpoint. Their intended gates reject. + +The exact native contacts include 896 complex forward/inverse checks and +111 rational binary charts. Both complete physical event lists are replayed. +Two rational interval implementations agree on the strict native moments. +The complete charged tensor tails, effective compiler ranks, ordinary BIT +cover/conversion and nine-row outer ledger pass. All 54 strict outer +predicates, three inherited functional predicates and the added stock guard +are retained. + +The actual local full-native words and their all-column implementation are +reused from the pinned reviewed lineage. Their entire historical physical +stack was not rerun. New winning tensor/uniform words are specified by +finite algorithms; their enormous instruction lists have not been emitted. +No finite pass establishes an unconditional theorem or formal verification. + +The exact-commit preflight and source-history check are run after committing +the package; the submitted PR describes their result and hosted CI separately. +All reports retain the inherited native, whole-job, owned-erasure, fixed-tape, +precision, analytic, prime-supply and exact-recovery proof boundaries. diff --git a/research/query-thinned-controllers/VERIFY.json b/research/query-thinned-controllers/VERIFY.json new file mode 100644 index 0000000000..768aad6d68 --- /dev/null +++ b/research/query-thinned-controllers/VERIFY.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/higher-moment-strictification/README.md", + "research/higher-moment-strictification/verify.py", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "research/kappa-rebuild/architecture/mixed_target_probe.py", + "research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json", + "research/kappa-rebuild/bit/BIT-P3-NATIVE-BINDING.json", + "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json", + "research/kappa-rebuild/bit/bit_native_binding.py", + "research/kappa-rebuild/bit/complex_controller_factor.py", + "research/kappa-rebuild/bit/mixed_productive_bit.py", + "research/kappa-rebuild/complex/FULL-IDENTITY.md", + "research/kappa-rebuild/complex/full-identity-certificates/RESULT.json", + "research/pr4359-p7-padding/TENSOR.md", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/pr4359-p7-padding/native_inventory.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Authenticate source blobs; replay both emitted physical controller words and exact boundary programs; native phase and rational chart checks; full query, completion, compiler, BIT cover and outer costs with negative controls." + } + ] +} diff --git a/research/query-thinned-controllers/controller.py b/research/query-thinned-controllers/controller.py new file mode 100644 index 0000000000..d4557e08cf --- /dev/null +++ b/research/query-thinned-controllers/controller.py @@ -0,0 +1,208 @@ +#!/usr/bin/env python3 +"""Exact native/query controller construction. Apache-2.0; Codex assistance.""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +import importlib.util +import json +from pathlib import Path +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def engines(): + reference = ROOT/'research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py' + load(reference, 'joint_pair_dag') + base = ROOT/'research/kappa-rebuild/bit' + bit = load(base/'mixed_productive_bit.py', 'mixed_productive_bit') + complex_ = load(base/'complex_controller_factor.py', 'query_complex_factor') + return bit, complex_ + + +def keep_mask(p, a): + b = p-1-a + return sum(1 << i for i in list(range(1, 2*p-2, 2))+ + list(range(0, 2*a, 2))+list(range(3*(p-1)-b, 3*(p-1)))) + + +def thick_stages(p): + return {0, 2*p, *range(1, 2*p, 2)} + + +def specialize_complex(coefficients, thick): + result = {} + for term, matrix in coefficients.items(): + key = (term[0],)+tuple(x if s in thick else 0 for s, x in enumerate(term[1:])) + out = result.setdefault(key, [[Q(0)]*len(matrix) for _ in matrix]) + for i, row in enumerate(matrix): + for j, value in enumerate(row): + out[i][j] += value + return {k: m for k, m in result.items() if any(any(row) for row in m)} + + +def specialize_bit(coefficients, thick): + keep = 1+sum(1 << (s+1) for s in thick) + out = {} + for term, matrix in coefficients.items(): + key = term & keep + old = out.setdefault(key, [0]*len(matrix)) + for i, row in enumerate(matrix): + old[i] ^= row + return {k: m for k, m in out.items() if any(m)} + + +def replay_events(events, p, kind): + """Literal second replay of the emitted word, including query-only gates.""" + _, engine = engines() + size, stages = 2*p, 2*p+1 + zero = (0,)*(stages+1) + matrix = [[{zero: Q(i == j)} if i == j else {} for j in range(size)] for i in range(size)] + for event in events: + op = event[0] + if op in ('LOCAL', 'QUERY_SHEAR'): + _, stage, pair, backward = event + x, y = 2*pair, 2*pair+1 + if backward: x, y = y, x + term = (1 if backward else -1,)+(0,)*stages + matrix[y] = [engine.plus(a, engine.monomial_times(b, term, -1 if backward else 1)) for a, b in zip(matrix[y], matrix[x])] + if op == 'LOCAL': + term = (0,)+tuple(int(s == stage) for s in range(stages)) + for role in (x, y): matrix[role] = [engine.monomial_times(a, term) for a in matrix[role]] + elif op == 'IDLE': + _, pair, selected = event + term = (0,)+tuple(int(s in selected) for s in range(stages)) + for role in (2*pair, 2*pair+1): matrix[role] = [engine.monomial_times(a, term) for a in matrix[role]] + elif op == 'ADD': + _, dst, src, *coefficient = event + c = coefficient[0] if coefficient else 1 + matrix[dst] = [engine.plus(a, b, c) for a, b in zip(matrix[dst], matrix[src])] + elif op in ('SWAP', 'SIGNED_SWAP'): + _, x, y = event + matrix[x], matrix[y] = matrix[y], [engine.monomial_times(a, zero, -1 if op == 'SIGNED_SWAP' else 1) for a in matrix[x]] + else: + raise ValueError('Unknown emitted event: '+op) + result = {} + for i, row in enumerate(matrix): + for j, poly in enumerate(row): + for key, value in poly.items(): + if kind == 'complex': + result.setdefault(key, [[Q(0)]*size for _ in range(size)])[i][j] += value + elif value.numerator % 2: + need(value.denominator == 1, 'Integral binary replay coefficient') + term = (key[0] % 2)+sum((exponent % 2) << (s+1) for s, exponent in enumerate(key[1:])) + result.setdefault(term, [0]*size)[i] ^= 1 << j + return {k: m for k, m in result.items() if any(any(r) for r in m)} if kind == 'complex' else {k: m for k, m in result.items() if any(m)} + + +def inventories(kind, p, a, diagonal, idles): + thick = thick_stages(p) + ports, block = (112, 8) if kind == 'complex' else (111, 7) + if kind == 'complex': + local = json.loads((ROOT/'research/kappa-rebuild/complex/full-identity-certificates/RESULT.json').read_text())['providers']['THREE-base'] + helpers = {int(k): v for k, v in local['helper_boundary']['widths'].items()} + children = {int(k): v for k, v in local['unsplit_replays']['forward']['paid_profile'].items()} + selected = [[s for s, x in enumerate(term[1:]) if x] for term in diagonal] + need(all(term[0] in (-1, 1) for term in diagonal), 'Only legal central Gaussian normalizers') + else: + helpers = {8: 439} + children = {1: 1323, 2: 1342, 3: 79, 4: 44, 5: 102, 6: 11, 7: 19} + selected = [[s for s in range(2*p+1) if term >> (s+1) & 1] for term in diagonal] + need(all(term & 1 for term in diagonal), 'Every binary main output retains its central rank-one factor') + targets = Counter({r: len(thick)*n for r, n in helpers.items()}) + paid = Counter({r: len(thick)*n for r, n in children.items()}) + thin_calls = ports*(2*p+1-len(thick)) + paid[1] += thin_calls + main = Counter() + for stages in selected: + need(set(stages) <= thick, 'No removed stage receives output credit') + main[1+block*len(stages)] += ports + targets.update(main) + idle = Counter() + for row in idles: + if row['retained']: + rank = block*len(thick.intersection(row['stages'])) + if rank: + idle[rank] += 2*ports + paid.update(idle) + # A second derivation uses only the declared prefix/suffix intervals. + expected_main = Counter({1+block*(p+2): 2*ports}) + expected_idle = Counter() + for length in (a, p-1-a): + for j in range(1, length+1): + expected_main[1+block*(j+1)] += 2*ports + expected_idle[block*(j+1)] += 2*ports + need(main == expected_main and idle == expected_idle, 'Literal and interval-derived complete invoices agree') + surplus = sum(r*n for r, n in targets.items())-sum(r*n for r, n in paid.items()) + need(surplus == (48*len(thick)-112 if kind == 'complex' else 48*len(thick)-111), 'Rank mass includes every query and lost helper') + return {'targets': dict(sorted(targets.items())), 'paid': dict(sorted(paid.items())), + 'main': dict(sorted(main.items())), 'whole_idle': dict(sorted(idle.items())), + 'productive_fields': sum(targets.values()), 'paid_calls': sum(paid.values()), + 'rank_surplus': surplus, 'thin_queries': thin_calls, + 'thick_calls': len(thick), 'thick_stages': sorted(thick), + 'raw_scalar_record_bound': 10**9, 'owned_streams_reused_sequentially': 1} + + +def run(kind, p, a): + bit, complex_ = engines() + mask = keep_mask(p, a) + thick = thick_stages(p) + if kind == 'complex': + coefficients, events, idles = complex_.controller(p, mask) + coefficients = specialize_complex(coefficients, thick) + factor = complex_.factor(coefficients) + need(factor is not None, 'Exact rational Laurent simultaneous factorization') + diagonal = factor['diagonal'] + boundaries = {'left': complex_.serialize_matrix(factor['left']), + 'right': complex_.serialize_matrix(factor['right']), + 'left_program': factor['left_program'], 'right_program': factor['right_program']} + need(all(Q(row[-1]) in (1, -1) for program in (factor['left_program'], factor['right_program']) + for row in program if row[0] in ('ADD', 'SCALE')), 'Unit scalar boundary coefficients') + else: + coefficients, events, idles = bit.physical_controller(p, mask) + coefficients = specialize_bit(coefficients, thick) + factor = bit.simultaneous_monomial_factor(coefficients) + need(factor is not None, 'Exact binary group-ring simultaneous factorization') + diagonal = factor['diagonal_monomials'] + boundaries = factor + invoice = inventories(kind, p, a, diagonal, idles) + new_events = [] + for row in events: + if row[0] == 'LOCAL' and row[1] not in thick: + new_events.append(['QUERY_SHEAR', *row[1:]]) + elif row[0] == 'IDLE': + selected = ([s for s in row[2] if s in thick] if kind == 'complex' else + [s for s in range(2*p+1) if row[2] >> (s+1) & 1 and s in thick]) + if selected: + new_events.append(['IDLE', row[1], selected]) + else: + new_events.append(row) + need(sum(row[0] == 'LOCAL' for row in new_events) == p+2, 'Exactly p+2 full native calls') + need(sum(row[0] == 'QUERY_SHEAR' for row in new_events) == p-1, 'Exactly p-1 copied-query shears') + return {'kind': kind, 'pairs': p, 'prefix_pairs': a, 'keep_mask': mask, + 'ambient_rank': 1+(8 if kind == 'complex' else 7)*(p+2), + 'diagonal': diagonal, 'boundaries': boundaries, + 'physical_events': new_events, 'invoice': invoice} + + +if __name__ == '__main__': + for kind, p, a in [('complex', 17, 8), ('bit', 16, 7)]: + row = run(kind, p, a) + path = HERE/(kind.upper()+'-CONTROLLER.json') + path.write_text(json.dumps(row, indent=2, sort_keys=True)+'\n') + print(kind, row['invoice'], flush=True) diff --git a/research/query-thinned-controllers/verify.py b/research/query-thinned-controllers/verify.py new file mode 100644 index 0000000000..f1114036ff --- /dev/null +++ b/research/query-thinned-controllers/verify.py @@ -0,0 +1,202 @@ +#!/usr/bin/env python3 +"""Exact finite replay for the conditional query-thinned construction. + +Apache-2.0. Prepared for Cinna Davis with substantial OpenAI Codex assistance. +Retains zxv's native/factor/tail work and Jacob Alan Sussman's integer flow. +""" +from fractions import Fraction as Q +from hashlib import sha1, sha256 +import argparse +import json +import sys +sys.dont_write_bytecode = True +import controller as C +HERE, ROOT, need = C.HERE, C.ROOT, C.need + + +def encode(x): + if isinstance(x, Q): return str(x) + if isinstance(x, dict): return {str(k): encode(v) for k, v in x.items()} + if isinstance(x, (list, tuple)): return [encode(v) for v in x] + return x + + +def authenticate(): + count = 0 + for row in json.loads((HERE/'SOURCES.json').read_text())['files']: + if row['usage'] != 'input': continue + path = ROOT/row['path']; raw = path.read_bytes() + need(not path.is_symlink(), 'No source alias') + need(sha256(raw).hexdigest() == row['sha256'], 'Changed source: '+row['path']) + need(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == row['git_blob'], 'Changed Git blob') + count += 1 + return count + + +def controllers(): + B, E = C.engines(); result = {} + for kind, p, a in [('complex', 17, 8), ('bit', 16, 7)]: + row = json.loads((HERE/(kind.upper()+'-CONTROLLER.json')).read_text()) + thick, mask = C.thick_stages(p), C.keep_mask(p, a) + if kind == 'complex': + coefficients, events, idles = E.controller(p, mask) + coefficients = C.specialize_complex(coefficients, thick) + left = [[Q(x) for x in r] for r in row['boundaries']['left']] + right = [[Q(x) for x in r] for r in row['boundaries']['right']] + diagonal = [tuple(term) for term in row['diagonal']] + transformed = {k: B.matrix_multiply(B.matrix_multiply(left, m), right) for k, m in coefficients.items()} + expected = {k: [[Q(i == j and diagonal[i] == k) for j in range(2*p)] for i in range(2*p)] for k in set(diagonal)} + need(transformed == expected, 'All exact rational Laurent coefficients, including signs and Q powers') + for name, matrix in [('left', left), ('right', right)]: + need(E.scalar_program(matrix) == row['boundaries'][name+'_program'], 'Literal unit scalar boundary program') + changed = dict(coefficients) + k = next(iter(changed)); changed[k] = [r[:] for r in changed[k]]; changed[k][0][0] += 1 + need(B.matrix_multiply(B.matrix_multiply(left, changed[k]), right) != expected.get(k), 'A changed physical coefficient is rejected') + else: + coefficients, events, idles = B.physical_controller(p, mask) + coefficients = C.specialize_bit(coefficients, thick) + fresh = B.simultaneous_monomial_factor(coefficients) + need(fresh == row['boundaries'], 'Exact binary physical operator and scalar boundaries') + diagonal = fresh['diagonal_monomials'] + need(C.replay_events(row['physical_events'], p, kind) == coefficients, + 'Emitted native/query/idle word equals the specialized physical source') + mutant = json.loads(json.dumps(row['physical_events'])) + # Every removed stage is forward; changing its direction must change + # the actual operator rather than merely a tariff field. + next(ev for ev in mutant if ev[0] == 'QUERY_SHEAR')[3] = True + need(C.replay_events(mutant, p, kind) != coefficients, 'Wrong query orientation rejected') + invoice = C.inventories(kind, p, a, diagonal, idles) + ports = 112 if kind == 'complex' else 111 + boundary_records = (sum(len(row['boundaries'][name+'_program']) for name in ('left', 'right')) + if kind == 'complex' else row['boundaries']['boundary_unit_ADDs_per_port']) + scalar_upper = (p+2)*10**6+16*invoice['thin_queries']+32*ports*(len(row['physical_events'])+boundary_records) + need(scalar_upper < invoice['raw_scalar_record_bound'], 'Conservative complete scalar/route count fits') + need(encode(invoice) == row['invoice'], 'Literal and closed-form complete '+kind+' invoice') + result[kind] = invoice + return result + + +def native_contacts(): + n = C.load(ROOT/'research/pr4359-p7-padding/native_inventory.py', 'thinned_native_phases') + phases = json.loads((ROOT/'research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json').read_text()) + axes = tuple(1 << i for i in range(17)); old = [(a, 1) for a in axes[:9]]; fresh = [(a, 1) for a in axes[9:]] + checks = 0 + for recipe in phases['recipes']: + q = recipe['q']; basis = recipe['idle_children'][0]['orthogonal_axes'][:8] + need(all((b&q).bit_count() % 2 == 0 for b in basis), 'Old eight-space perpendicular to q') + swaps = [b ^ axes[9+i] for i, b in enumerate(basis)] + route = tuple(e ^ n.act(swaps, sum(((e&v).bit_count() % 2) << i for i, v in enumerate(swaps))) for e in axes) + need(all(n.act(route, route[i]) == axes[i] for i in range(17)), 'Exact physical route inverse') + need(all((a&b).bit_count() % 2 == int(i == j) for i, a in enumerate(route) for j, b in enumerate(route)), 'Orthogonal physical route') + need(n.act(route, q) == q, 'Central query direction fixed') + need(n.polynomial(n.norm([(q, -1)]), 17) == n.polynomial(n.norm([(q, 1), (q, 2)]), 17), + 'Inverse thin Gaussian is one positive query and a physical translation') + for sign in (-1, 1): + raw = (n.norm(old), n.norm(old+[(q, -1)])) + entry = (n.norm(fresh+[(q, sign)]), n.norm(fresh)) + out0 = n.norm(fresh+[(a, sign) for a in axes[:9]]) + local_out = (out0, n.norm(list(out0)+[(q, -sign)])) + out = (n.norm(old+fresh), n.norm(old+fresh+[(q, -1)])) + for x, y in list(zip(raw, entry))+list(zip(local_out, out)): + n.contact(x, y, route, 17); checks += 1 + for x, y in zip(raw, out): + need(n.polynomial(n.norm(list(y)+[(a, -c) for a, c in x]), 17) == n.polynomial(n.norm(fresh), 17), 'Exactly the fresh eight-axis multiplier') + bit = C.load(ROOT/'research/kappa-rebuild/bit/bit_native_binding.py', 'thinned_binary_charts') + ports = json.loads((ROOT/'research/kappa-rebuild/bit/BIT-P3-NATIVE-BINDING.json').read_text())['ports'] + local = json.loads((ROOT/'research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json').read_text())['local'] + for direction in local['signed_directions']: + need({int(k): v for k, v in direction['profile'].items()} == C.engines()[0].LOCAL, + 'Every actual binary local child remains charged') + need(direction['unit_ADDs'] < 10**6 and direction['owned_COPY_episodes'] == 9, + 'Native binary scalar and owned-center bills retained') + for row in ports: + p = [[Q(x) for x in r] for r in row['central_projector']]; rho = [[Q(x) for x in r] for r in row['chart_15']] + active = [[p[i][j] if i < 8 and j < 8 else Q(i == j and i >= 8) for j in range(15)] for i in range(15)] + full = [[Q(i == j and i < 8) for j in range(15)] for i in range(15)] + need(bit.multiply(rho, rho) == bit.ident(15) and bit.multiply(bit.multiply(rho, active), rho) == full, 'BIT exact arbitrary-column chart') + need(bit.multiply(p, p) == p and sum(p[i][i] for i in range(8)) == 1, 'BIT query rank one') + # Formal independent X,Y,Z columns. Mutants execute the same word with + # an actual omitted operation; they are not merely different receipts. + for e in (-1, 1): + def execute(clear=True, erase=True): + x, y, z = {('X', 0): 1}, {('Y', 0): 1}, {('Z', 0): 1} + if clear: z = {} + for key, value in x.items(): z[key] = z.get(key, 0)+value + z = {(name, power+e): value for (name, power), value in z.items()} + for key, value in z.items(): y[key] = y.get(key, 0)+(-1 if e == 1 else 1)*value + if erase: z = {} + return x, y, z + expected = ({('X', 0): 1}, {('Y', 0): 1, ('X', e): -1 if e == 1 else 1}, {}) + need(execute() == expected, 'Completed arbitrary-input owned-query shear') + need(execute(clear=False) != expected and execute(erase=False) != expected, 'Clear/erase omission controls rejected') + return {'complex_contacts_and_inverses': checks, 'binary_charts': len(ports), + 'thin_paid_rank_per_port': 1, 'thin_productive_credit': 0, 'owned_stream_restored_zero': True} + + +def tail(E, invoice, tested, uniform, cutoff, floor, alpha_gap): + T, P = invoice['targets'], invoice['paid']; t, u, v = 1-tested, Q(1, 5), 1024 + target, paid = E.moment(T, t), E.moment(P, t) + alpha = E.divide(paid, target) + other = C.load(ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py', 'separate_rational_moment_engine') + tl, th = other.moment(T, tested); pl, ph = other.moment(P, tested) + need(tl > ph and max(target[0], tl) <= min(target[1], th) + and max(paid[0], pl) <= min(paid[1], ph), 'Separate rational interval engine agrees') + gamma = E.divide(E.moment(P, t+u), E.mul(E.power(cutoff, u), target)) + delta = E.divide((Q(sum(T.values())*floor),)*2, E.mul(E.power(cutoff, tested), target)) + need(alpha[1] < 1-alpha_gap and gamma[1] < Q(31, 32) and delta[1] < Q(19, 20), 'Three completely charged tail ratios') + need(Q(31, 32)**128 < Q(1, 16) and Q(19, 20)**128 < Q(1, 16), 'Exact decay blocks') + surplus = 1-Q(1)/(1+v*alpha_gap)-Q(4, 2**32) + need(surplus > 0, 'Original and completion tails both fit') + need(cutoff**64 < floor**63 and max(T) < 256, 'Strict ranks after completion and splitting') + h = Q(1, 64); z, z0 = 1-uniform, (t+1-uniform)/2; gap = z0-t + B, debt = (5+8*h)*v, 1+8*v*(1-z0) + x = (gap*B+debt)/(h*gap); H0 = -((-x.numerator)//x.denominator) + x = H0*(1-z0)/(z-z0); H1 = x.numerator//x.denominator+1 + need(H0 >= 8*v and H0*h*gap >= gap*B+debt and H1*(z-z0) > H0*(1-z0), 'Effective integer compiler bound') + return {'tested_saving': tested, 'uniform_saving': uniform, 'alpha': E.display(alpha), + 'gamma': E.display(gamma), 'delta': E.display(delta), 'tensor_power': v, + 'cutoff_base': cutoff, 'target_floor_base': floor, 'tail_exponent': u, + 'normalized_surplus_lower': surplus, 'compiler_H0': H0, 'uniform_H1': H1, + 'uniform_N': '2^'+str(H1), 'winning_word_materialized': False} + + +def run(): + count = authenticate(); rows = controllers(); native = native_contacts() + E = C.load(ROOT/'research/higher-moment-strictification/verify.py', 'credited_exact_intervals') + kappa, tested = Q('.00296'), Q('.00296030'); d = (tested-kappa)/7 + complex_ = tail(E, rows['complex'], tested, kappa+6*d, 20, 21, Q(1, 30000000)) + bit = tail(E, rows['bit'], Q('.00346'), Q('.003459'), 17, 18, Q(1, 250000)) + before, after, atom, old = Q('.003459'), Q('.00345'), Q('.004'), Q('.0000384599') + ordinary, admitted = (1-atom)*after+atom*old, Q('.0034') + need(before > after and atom > ordinary > admitted and atom < 1-ordinary, 'Complete ordinary BIT conversion') + need(Q('.003') < ordinary and 2**26 > 256/(before-after), 'Old atom rejected and finite prime bound') + L = C.load(ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py', 'complete_outer_ledger') + params = {'kappa': kappa, 'tested_saving': tested, 'complex_uniform_saving': kappa+6*d, + 'b': kappa+5*d, 'a': kappa+4*d, 'q': kappa+3*d, 'bit_saving': admitted, + 'epsilon': 1-d, 'beta': 1-3*d, 'r0': d/10, 'stop': d, 'layout': d, 'd': d} + outer = L.ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear'] = params['beta']*(1-atom) + need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete predicate inventory') + need(all(x > 0 for group in ('strict_checks', 'functional_checks') for x in outer[group].values()), 'All outer predicates') + controls = {} + for label, changes in [('old_BIT_cap', {'bit_saving': Q('.0027')}), ('closed_uniform_gap', {'complex_uniform_saving': params['b']}), + ('unfunded_kappa', {'kappa': tested}), ('closed_epsilon', {'epsilon': Q(1)}), ('missing_layout', {'layout': Q(0)})]: + bad = L.ledger(dict(params, **changes)); failed = [k for k, v in bad['strict_checks'].items() if v <= 0] + need(failed, 'Reject '+label); controls[label] = failed + return encode({'schema': 'query-thinned-productive-controllers/1', 'status': 'PASS_CONDITIONAL_QUERY_THINNED_KAPPA_00296', + 'kappa': kappa, 'relative_gain_over_p7': kappa/Q('.00268647')-1, + 'source_inputs_authenticated': count, 'native': native, 'complex_invoice': rows['complex'], 'bit_invoice': rows['bit'], + 'complex_strictification': complex_, 'bit_strictification': bit, + 'ordinary_BIT': {'before_cover': before, 'after_cover': after, 'atom': atom, 'ordinary_saving': ordinary, + 'admitted': admitted, 'prime_rule': 'odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses'}, + 'outer': outer, 'minimum_outer_margin_minus_kappa': min(outer['margins'].values())-kappa, + 'negative_controls': controls, 'old_atom_rejected': True, + 'scope': 'Conditional native construction; all-column, erasure, whole-job matching, fixed-tape, precision, analytic, prime and exact-recovery premises retained. No unconditional theorem or selected promotion.'}) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__); parser.add_argument('--write', action='store_true'); args = parser.parse_args() + result = run(); output = HERE/'RESULT.json' + if args.write: output.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + else: need(result == json.loads(output.read_text()), 'Complete receipt matches exact replay') + print(json.dumps({k: result[k] for k in ('status', 'kappa', 'source_inputs_authenticated', 'minimum_outer_margin_minus_kappa')}, sort_keys=True)) From 40e22a83ed660d3d6074c4f2dbf14bfb621eee51 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 21 Oct 2026 15:08:04 -0500 Subject: [PATCH 2/4] Record committed-byte and source-history validation --- research/query-thinned-controllers/VALIDATION.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/research/query-thinned-controllers/VALIDATION.md b/research/query-thinned-controllers/VALIDATION.md index 2924d84be3..8e9598ece7 100644 --- a/research/query-thinned-controllers/VALIDATION.md +++ b/research/query-thinned-controllers/VALIDATION.md @@ -37,7 +37,8 @@ stack was not rerun. New winning tensor/uniform words are specified by finite algorithms; their enormous instruction lists have not been emitted. No finite pass establishes an unconditional theorem or formal verification. -The exact-commit preflight and source-history check are run after committing -the package; the submitted PR describes their result and hosted CI separately. +The committed-byte preflight and source-history check both pass after +committing the package, with all 28 package/input files matching and the pinned +canonical base in publication ancestry. Hosted CI is reported separately. All reports retain the inherited native, whole-job, owned-erasure, fixed-tape, precision, analytic, prime-supply and exact-recovery proof boundaries. From f3b4a3abfbf0aad28e4737be7ec38345f439c5fc Mon Sep 17 00:00:00 2001 From: 1337isnot1337 <164028474+1337isnot1337@users.noreply.github.com> Date: Wed, 21 Oct 2026 23:13:26 +0000 Subject: [PATCH 3/4] docs: correct selected frontier and historical checkpoint navigation --- docs/ci-verification.md | 12 ++++++++++++ docs/research/current-status.md | 6 ++++-- 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/docs/ci-verification.md b/docs/ci-verification.md index 582e416aaf..50e8120dc0 100644 --- a/docs/ci-verification.md +++ b/docs/ci-verification.md @@ -2,6 +2,18 @@ ## Current selected-family replay +Resolve the [selected record](../certificates/selected-result.json) before +running a historical checkpoint. The current cold replay is +`make frontier4359-verify`, using the +[proof review](research/pr-intake-evidence/pr4359/PROOF-REVIEW.md), +[validation](research/pr-intake-evidence/pr4359/VALIDATION.json) and +[source manifest](../certificates/frontier4359-source.json). +The [frontier4359 workflow](../.github/workflows/frontier4359.yml) provides +hosted replay evidence. Metadata and source-pin checks are separate from +operator replay and do not discharge the inherited theorem assumptions. + +## Historical frontier1094 replay + Start with the [selected record](../certificates/selected-result.json). Its `reproduce`, `review`, `source_manifest` and `validation` fields identify the replay command, scoped assessment, source bindings and integration evidence. diff --git a/docs/research/current-status.md b/docs/research/current-status.md index 62a8cbb097..532af84312 100644 --- a/docs/research/current-status.md +++ b/docs/research/current-status.md @@ -1,12 +1,14 @@ # Current reviewed status -Selected conditional κ: **0.0023 = 23/10000**, zxv’s #4359 productive-helper construction, using Jacob Alan Sussman’s mixed-target recursion and the credited cumulative native/outer lineage. +Selected conditional κ: **0.0023** (= 23/10000), zxv’s #4359 productive-helper construction, using Jacob Alan Sussman’s mixed-target recursion and the credited cumulative native/outer lineage. [Selected record](../../certificates/selected-result.json) · [Proof review](pr-intake-evidence/pr4359/PROOF-REVIEW.md) · [Integration receipt](pr-intake-evidence/pr4359/INTEGRATION.json) · [Contributors](community-productive4359-contributors.md). Cold replay: `make frontier4359-verify`. The fresh 23-stage replay and 59 normalized artifacts pass; the changed interfaces have an AI-assisted proof review under retained analytic/native/fixed-tape hypotheses. Winning uniform templates are not materialized. This is not a complete formal or independent human verification. #4404 independently checks a narrower arithmetic/flow scope. -## Historical selected status through #1094 +All sections below are a historical snapshot; the selected-result.json record above is authoritative. + +## Historical checkpoint through #1094 Historical selected conditional κ: **0.001672660197076918**, Rohan Arun's #1094 on Jeremy Kothe's #1087 packing and the cumulative k8/slot/T16 construction. The bit supplier remains #589 on #555. From 9123d75afea5096d25eb98b2b6080cbbe0d91c01 Mon Sep 17 00:00:00 2001 From: 1337isnot1337 <164028474+1337isnot1337@users.noreply.github.com> Date: Wed, 21 Oct 2026 23:13:38 +0000 Subject: [PATCH 4/4] ci: reconcile historical package inputs after status navigation update --- .../d8-mixed-target-seeda97c8e/SOURCES.json | 8 ++++---- research/d8-mixed-target-seeda97c8e/VERIFY.json | 4 ---- research/historical-1042-link/RESULT.json | 5 +++-- research/historical-1042-link/SOURCES.json | 17 +++++++++++++---- research/historical-1042-link/VERIFY.json | 15 ++++++++++++--- research/historical-1042-link/verify.py | 10 ++++++++-- research/test-suite-locale-reads/SOURCES.json | 5 +++-- 7 files changed, 43 insertions(+), 21 deletions(-) diff --git a/research/d8-mixed-target-seeda97c8e/SOURCES.json b/research/d8-mixed-target-seeda97c8e/SOURCES.json index 9384463ff4..5dcfa9dd60 100644 --- a/research/d8-mixed-target-seeda97c8e/SOURCES.json +++ b/research/d8-mixed-target-seeda97c8e/SOURCES.json @@ -4,25 +4,25 @@ "files": [ { "path": "autoresearch.md", - "usage": "input", + "usage": "provenance", "git_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82", "sha256": "215b3222f6a943edc69422a28ac21ea1f397ddf54770f1d87ac4195385d73699" }, { "path": "certificates/selected-result.json", - "usage": "input", + "usage": "provenance", "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" }, { "path": "docs/research/agent-task-catalog.json", - "usage": "input", + "usage": "provenance", "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" }, { "path": "docs/research/current-status.md", - "usage": "input", + "usage": "provenance", "git_blob": "d73b4ff9da41f044e793422db4318be17e234a6c", "sha256": "adb54af005eb11edaf84d782fe729338680ff908f6d4fbf39ba1062d2e7d8a77" }, diff --git a/research/d8-mixed-target-seeda97c8e/VERIFY.json b/research/d8-mixed-target-seeda97c8e/VERIFY.json index caff4adf82..2726200ed3 100644 --- a/research/d8-mixed-target-seeda97c8e/VERIFY.json +++ b/research/d8-mixed-target-seeda97c8e/VERIFY.json @@ -4,10 +4,6 @@ "python": "3.12", "requirements": [], "inputs": [ - "autoresearch.md", - "certificates/selected-result.json", - "docs/research/agent-task-catalog.json", - "docs/research/current-status.md", "research/bit-three-register-lower-bound/README.md", "research/d8-mixed-target-seeda97c8e/verify.py" ], diff --git a/research/historical-1042-link/RESULT.json b/research/historical-1042-link/RESULT.json index a9d58d2881..30ec98c793 100644 --- a/research/historical-1042-link/RESULT.json +++ b/research/historical-1042-link/RESULT.json @@ -2,8 +2,9 @@ "historical_href": "../../certificates/selected-result.json", "checkpoint": "certificates/checkpoints/frontier1042.json", "historical_kappa": "1672188119205421/1000000000000000000", - "live_kappa": "836330098538459/500000000000000000", + "live_kappa": "23/10000", "same_href": true, "kappas_differ": true, - "no_new_kappa": true + "no_new_kappa": true, + "intermediate_checkpoint": "certificates/checkpoints/frontier1094.json" } diff --git a/research/historical-1042-link/SOURCES.json b/research/historical-1042-link/SOURCES.json index c6119ca5a8..d66f3b7b62 100644 --- a/research/historical-1042-link/SOURCES.json +++ b/research/historical-1042-link/SOURCES.json @@ -11,20 +11,29 @@ { "path": "docs/research/current-status.md", "usage": "input", - "git_blob": "4e0a8b7cdacc1d9680f7f81d03624118bb20416d", - "sha256": "00a08925c51b26d168b8099ddeed659ac4381f7e04f3c7fd0e9de8e71f206823" + "git_blob": "532af84312cbfeb39a1e4659d8398deb560f1e4a", + "sha256": "54c843968d0b178369a7e56161be44c4692935c3f46ce261678aeedadb309891", + "pin": "head:f3b4a3abfbf0aad28e4737be7ec38345f439c5fc:docs/research/current-status.md" }, { "path": "certificates/selected-result.json", "usage": "input", - "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", - "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40", + "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9", + "pin": "head:f3b4a3abfbf0aad28e4737be7ec38345f439c5fc:certificates/selected-result.json" }, { "path": "certificates/checkpoints/frontier1042.json", "usage": "input", "git_blob": "f451ced6626a1f03aba6915ce23a136b01ebe51d", "sha256": "207d1f49f113c585024b9d3c17eadbb8b1be17c1321e3d190aabe2f18ce1c5b7" + }, + { + "path": "certificates/checkpoints/frontier1094.json", + "usage": "input", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "pin": "head:f3b4a3abfbf0aad28e4737be7ec38345f439c5fc:certificates/checkpoints/frontier1094.json" } ] } diff --git a/research/historical-1042-link/VERIFY.json b/research/historical-1042-link/VERIFY.json index 5cff7b26c9..5138c1b017 100644 --- a/research/historical-1042-link/VERIFY.json +++ b/research/historical-1042-link/VERIFY.json @@ -6,16 +6,25 @@ "inputs": [ "docs/research/current-status.md", "certificates/selected-result.json", - "certificates/checkpoints/frontier1042.json" + "certificates/checkpoints/frontier1042.json", + "certificates/checkpoints/frontier1094.json" ], "commands": [ { - "argv": ["{python}", "-B", "{package}/verify.py"], + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], "timeout_seconds": 30, "checks": "Compare the #1042 status link with the live record and the frontier1042 checkpoint." }, { - "argv": ["{python}", "-B", "{package}/test_verify.py"], + "argv": [ + "{python}", + "-B", + "{package}/test_verify.py" + ], "timeout_seconds": 30, "checks": "Check the printed decimal and the historical section cut." } diff --git a/research/historical-1042-link/verify.py b/research/historical-1042-link/verify.py index 12170922e5..2ffd4a8ce4 100644 --- a/research/historical-1042-link/verify.py +++ b/research/historical-1042-link/verify.py @@ -2,7 +2,8 @@ """Separate the #1042 status link from the live selected record. The historical section states the #1042 kappa and links to the live record. -The matching checkpoint is the selected record's previous_record field. +The matching checkpoint is reached through the selected record's historical +previous_record chain (currently via frontier1094). """ import hashlib @@ -16,6 +17,7 @@ MARKER = "PASS_HISTORICAL_1042_LINK kappas_differ=true no_new_kappa" HREF = "../../certificates/selected-result.json" CHECKPOINT = "certificates/checkpoints/frontier1042.json" +INTERMEDIATE = "certificates/checkpoints/frontier1094.json" SHOWN = "0.001672188119205421" @@ -43,6 +45,7 @@ def authenticate(): "docs/research/current-status.md", "certificates/selected-result.json", "certificates/checkpoints/frontier1042.json", + "certificates/checkpoints/frontier1094.json", } require(set(pinned) == expected, "input inventory changed") for path, row in pinned.items(): @@ -64,12 +67,15 @@ def evaluate(): require(HREF in section, "the historical section lost the live-record link") require(SHOWN in section, "the historical kappa sentence moved") require(Fraction(SHOWN) == Fraction(old["kappa"]), "the checkpoint kappa left the printed decimal") - require(live["previous_record"] == CHECKPOINT, "the previous-record pointer moved") + require(live["previous_record"] == INTERMEDIATE, "the live previous-record pointer moved") + intermediate = json.loads((ROOT / INTERMEDIATE).read_text(encoding="utf-8")) + require(intermediate["previous_record"] == CHECKPOINT, "the checkpoint ancestry link moved") require(Fraction(live["kappa"]) != Fraction(old["kappa"]), "the live and historical kappas agree") require(text.index(HREF) < text.index("# Historical status through #1042"), "the live section lost its record link") return { "historical_href": HREF, "checkpoint": CHECKPOINT, + "intermediate_checkpoint": INTERMEDIATE, "historical_kappa": old["kappa"], "live_kappa": live["kappa"], "same_href": True, diff --git a/research/test-suite-locale-reads/SOURCES.json b/research/test-suite-locale-reads/SOURCES.json index be5f08378a..d089b51561 100644 --- a/research/test-suite-locale-reads/SOURCES.json +++ b/research/test-suite-locale-reads/SOURCES.json @@ -17,8 +17,9 @@ { "path": "docs/research/current-status.md", "usage": "input", - "git_blob": "d73b4ff9da41f044e793422db4318be17e234a6c", - "sha256": "adb54af005eb11edaf84d782fe729338680ff908f6d4fbf39ba1062d2e7d8a77" + "git_blob": "532af84312cbfeb39a1e4659d8398deb560f1e4a", + "sha256": "54c843968d0b178369a7e56161be44c4692935c3f46ce261678aeedadb309891", + "pin": "head:f3b4a3abfbf0aad28e4737be7ec38345f439c5fc:docs/research/current-status.md" }, { "path": "tests/test_research_current_status.py",