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 01/13] 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 02/13] 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 ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 21 Oct 2026 15:08:06 -0500 Subject: [PATCH 03/13] Raise conditional kappa to 0.00272124 by retiming fresh helper boundaries --- .../ARITHMETIC-RESULT.json | 219 +++++++ research/fresh-helper-boundary/ATTEMPTS.md | 44 ++ research/fresh-helper-boundary/CHANGES.json | 562 ++++++++++++++++++ .../FRONTIER-CHECKS.json | 14 + .../NATIVE-RESULT.json.gz | Bin 0 -> 29131 bytes research/fresh-helper-boundary/PROOF.md | 224 +++++++ research/fresh-helper-boundary/README.md | 155 +++++ research/fresh-helper-boundary/RESULT.json | 18 + research/fresh-helper-boundary/SOURCES.json | 96 +++ research/fresh-helper-boundary/TASK.json | 102 ++++ research/fresh-helper-boundary/VALIDATION.md | 34 ++ research/fresh-helper-boundary/VERIFY.json | 32 + research/fresh-helper-boundary/arithmetic.py | 152 +++++ .../fresh-helper-boundary/discover-cut.cpp | 35 ++ research/fresh-helper-boundary/discover.py | 75 +++ research/fresh-helper-boundary/native.py | 183 ++++++ research/fresh-helper-boundary/verify.py | 99 +++ 17 files changed, 2044 insertions(+) create mode 100644 research/fresh-helper-boundary/ARITHMETIC-RESULT.json create mode 100644 research/fresh-helper-boundary/ATTEMPTS.md create mode 100644 research/fresh-helper-boundary/CHANGES.json create mode 100644 research/fresh-helper-boundary/FRONTIER-CHECKS.json create mode 100644 research/fresh-helper-boundary/NATIVE-RESULT.json.gz create mode 100644 research/fresh-helper-boundary/PROOF.md create mode 100644 research/fresh-helper-boundary/README.md create mode 100644 research/fresh-helper-boundary/RESULT.json create mode 100644 research/fresh-helper-boundary/SOURCES.json create mode 100644 research/fresh-helper-boundary/TASK.json create mode 100644 research/fresh-helper-boundary/VALIDATION.md create mode 100644 research/fresh-helper-boundary/VERIFY.json create mode 100644 research/fresh-helper-boundary/arithmetic.py create mode 100644 research/fresh-helper-boundary/discover-cut.cpp create mode 100644 research/fresh-helper-boundary/discover.py create mode 100644 research/fresh-helper-boundary/native.py create mode 100644 research/fresh-helper-boundary/verify.py diff --git a/research/fresh-helper-boundary/ARITHMETIC-RESULT.json b/research/fresh-helper-boundary/ARITHMETIC-RESULT.json new file mode 100644 index 0000000000..686c36fb19 --- /dev/null +++ b/research/fresh-helper-boundary/ARITHMETIC-RESULT.json @@ -0,0 +1,219 @@ +{ + "BIT": { + "admitted": "273/100000", + "gap": "118653797/10000000000000", + "inherited_unrelaxed_saving": "27418653797/10000000000000" + }, + "compiler": { + "H": 349300000000, + "N": "2^349300000000", + "eta": { + "lower": "0.140815224484524968848722108625", + "upper": "0.140815224484524968848722108626" + }, + "gap": "1/700000000", + "integer_test_exponent": 499, + "logarithm_power": 13, + "theta_upper": "6/7", + "uniform_saving": "952437/350000000", + "word_materialized": false + }, + "fixed_profile_ceiling": { + "decreasing_C_interval": [ + "0", + "1/20" + ], + "negative_derivative_upper": { + "lower": "-178315.972608883259749333049784629374", + "upper": "-178315.972608883259749333049784629373" + }, + "negative_moment_upper": { + "lower": "-8137.901782546330185425252976230749", + "upper": "-8137.901782546330185425252976230748" + }, + "remaining_C_interval": [ + "1/20", + "1" + ] + }, + "gain_over_PR4416": "3477/100000000", + "headroom_from_declared_to_root": [ + "8051/400000000000", + "50319/2500000000000" + ], + "kappa": "68031/25000000", + "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" + ], + "old_BIT_relaxation": [ + "actual_bit_above_effective" + ], + "unfunded_outer": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "outer": { + "functional_checks": { + "fixed_halo_explicit_metadata_branch": "13475000001/175000000", + "new_BIT_row_stock_sublinear_in_active_group": "697899997009/700000000000", + "new_semantic_group_guard": "3/700000000" + }, + "margins": { + "boundary_algebraic_matrix": "1333410398095129/490000000000000000", + "fused_gaussian": "1333410394285387/490000000000000000", + "global_coordinate_router": "238109/87500000", + "group_bit_router": "166676386785673/61250000000000000", + "group_scans": "349999999/350000000", + "main_transform": "1333409698095129/490000000000000000", + "microbox_face_corrections": "13475000001/175000000", + "polynomial_products": "699999999/700000000", + "sparse_union_movement": "200395910398095129/490000000000000000" + }, + "parameters": { + "a": "238109/87500000", + "b": "1904873/700000000", + "beta": "699999997/700000000", + "bit_saving": "273/100000", + "cap_xi": "445395909698095129/490000000000000000", + "complex_uniform_saving": "952437/350000000", + "d": "1/700000000", + "epsilon": "699999999/700000000", + "kappa": "68031/25000000", + "lambda_": "199455751/200000000", + "lambda_prime": "698095129/700000000", + "layout": "1/700000000", + "q": "1904871/700000000", + "r0": "1/7000000000", + "stop": "1/700000000", + "tested_saving": "2177/800000" + }, + "strict_checks": { + "actual_bit_above_effective": "383/43750000", + "actual_logarithmic_gamma_guard": "1/700000000", + "actual_logarithmic_group_guard": "44604091351904871/245000000000000000", + "alpha_logarithm_absorption": "1/7000000000", + "boundary_algebraic_matrix_above_kappa": "2798095129/490000000000000000", + "cap_above_band": "200395909698095129/490000000000000000", + "cap_below_cell": "44604089601904871/490000000000000000", + "cap_below_phase_cell_power": "534604090301904871/490000000000000000", + "complex_above_effective": "1/700000000", + "complex_below_one_over_32": "19970127/700000000", + "complex_endpoint": "1/350000000", + "epsilon_below_one": "1/700000000", + "epsilon_positive": "699999999/700000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "2794285387/490000000000000000", + "gaussian_above_main": "348095129/245000000000000000", + "global_coordinate_router_above_kappa": "1/175000000", + "global_gamma_power_slack": "9/7000000000", + "group_below_dimension": "1/350000000", + "group_bit_router_above_kappa": "436785673/61250000000000000", + "group_gauge_power_slack": "44604091316904871/245000000000000000", + "group_key_fits_record": "1/350000000", + "group_positive": "699999997/700000000", + "group_scans_above_kappa": "69809513/70000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "495134790400418148631/500000000000000000000000", + "lambda_above_internal": "1/1400000000", + "lambda_above_sigma": "3/1400000000", + "lambda_above_tau": "1/1400000000", + "lambda_prime_above_lambda": "1/1400000000", + "lambda_prime_above_leaf": "1398095127/490000000000000000", + "leaf_saving_above_effective": "698095127/490000000000000000", + "main_transform_above_kappa": "2098095129/490000000000000000", + "membership_arithmetic_fits_record": "1/700000000", + "microbox_face_corrections_above_kappa": "1684315473/21875000", + "microbox_halo_volume": "55300000003/700000000", + "new_complex_uniform_saving_above_b": "1/700000000", + "new_semantic_guard_with_C1_one": "1/700000000", + "polynomial_products_above_kappa": "698095131/700000000", + "positive_layout_slack": "1/700000000", + "q_below_effective": "1/700000000", + "q_below_internal": "1/700000000", + "q_below_leaf": "1398095127/490000000000000000", + "q_positive": "1904871/700000000", + "short_record_fallback": "698095127/700000000", + "source_axis_superpolynomial": "1/700000000", + "sparse_union_movement_above_kappa": "199062502798095129/490000000000000000", + "stop_below_one": "699999999/700000000", + "stop_positive": "1/700000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/700000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/700000000", + "union_tag_work_per_visit_fits_record": "3/700000000" + } + }, + "paid": { + "1": 33795, + "16": 448, + "2": 7725, + "3": 6675, + "32": 448, + "4": 1530, + "48": 448, + "5": 600, + "8": 1464 + }, + "paid_calls": 53133, + "productive_fields": 7688, + "relative_gain_over_PR4416": "1159/89549", + "root_bracket": [ + "1088504051/400000000000", + "6803150319/2500000000000" + ], + "status": "PASS_CHANGED_NATIVE_PROFILE_STRICTIFICATION_AND_COMPLETE_OUTER", + "strictification": { + "alpha": { + "lower": "0.999999983026163231936831206184", + "upper": "0.999999983026163231936831206185" + }, + "cutoff_base": 10, + "delta": { + "lower": "0.864870069524004068270352709182", + "upper": "0.864870069524004068270352709183" + }, + "gamma": { + "lower": "0.910935673068185945998089027910", + "upper": "0.910935673068185945998089027911" + }, + "gap": { + "lower": "0.000000705775426641554341705594", + "upper": "0.000000705775426641554341705595" + }, + "normalized_paid_upper": "312500529444649842944287051245464084985300648225953097729364854469515503029278664568874151635979493066877292627151728507225829268936433948299379518726558518343844530884174444838473561069623983608689185814338090148572417036912296673977860237369051387753314848294993638501683424262073636500572764166420861283708720335677094583332070847074689861555558356543552667138912721443073650953550760942655945597474686732201711464952735742366374988690440592748048891939/312500750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "rational_upper_limits": [ + "62499999/62500000", + "911/1000", + "173/200" + ], + "tail_offset": "3/10", + "target_floor_base": 15, + "tensor_power": 150 + }, + "targets": { + "121": 224, + "25": 448, + "4": 390, + "41": 448, + "5": 30, + "57": 448, + "7": 435, + "8": 630, + "9": 4635 + }, + "tested_saving": "2177/800000" +} diff --git a/research/fresh-helper-boundary/ATTEMPTS.md b/research/fresh-helper-boundary/ATTEMPTS.md new file mode 100644 index 0000000000..61dd1812f5 --- /dev/null +++ b/research/fresh-helper-boundary/ATTEMPTS.md @@ -0,0 +1,44 @@ +# Scope of discovery + +The new contribution changes helper entrances and exits jointly with scalar +contact frames. The old choice was optimized for a hosted owner fill. Once +all helper fields are fresh independent inputs, that objective is different: +price the paid moment minus the actual productive helper moment. + +Exploratory checks before this pivot (compiled C++ discovery, not registered +proofs or global optimality certificates): + +- All 262,144 paired p7 masks: 256 modular candidates; none passes the numerical test C=.00268649. + The old rank profile and root were reproduced. +- All 2,097,152 paired p8 masks: 576 modular candidates; none passes C=.00268649. +- 2,391,496 masks within six individual-bank toggles of the selected p7 mask: + 6,278 modular candidates; none passes the numerical test C=.00268649. +- No untouched consecutive native transports fuse. Single common-frame + components, and alpha expansions over the 1,159 existing frame spaces with + all boundaries fixed, gave no improvement at C=.003. + +The rank-sum modular test is a discovery filter. If a polynomial matrix A has +invertible A(1), a constant-basis diagonal monomial factorization implies that +the sum of ranks of its nonzero coefficient matrices equals the dimension. +A necessary mod-2 screen is particularly cheap here because A(1) stays +invertible mod 2. Scientific acceptance of the selected word uses rational +Laurent replay and full native replay, not this filter. + +Allowing helper boundary frames changes the result. A binary alpha-expansion +cut changes a selected set of scalar contacts to one frame, while hard +constraints preserve every nested chronological path and every warp contact. +The energy is the complete paid moment minus productive helper moment. Entry +and exit moves are optimized separately because their joint concave reward +is not a submodular binary cost. The submitted finite choices are recorded +explicitly in CHANGES.json; replay needs no optimizer or C++ compiler. + +The optimizer is a discovery aid. Passing every tested label does not prove +global optimality. In particular, simultaneous different-label moves, changed +scalar order, new operators, center sharing and new geometry remain open. + +A subsequent scan added all binary lines, all hyperplanes and all coordinate +subspaces of F2^9: 1,264 new distinct labels, for 2,423 tested spaces. Separate +entry and exit alpha-expansion sweeps from the submitted profile found no +negative move at C=.003. The registered proof uses only the final finite +choices and exact native/moment replay; no claim of global optimality or +exact mathematical acceptance is drawn from floating discovery costs. diff --git a/research/fresh-helper-boundary/CHANGES.json b/research/fresh-helper-boundary/CHANGES.json new file mode 100644 index 0000000000..45744fedd0 --- /dev/null +++ b/research/fresh-helper-boundary/CHANGES.json @@ -0,0 +1,562 @@ +{ + "entrances": [ + [448, 114, 0], + [449, 114, 0], + [450, 115, 0], + [451, 115, 0], + [452, 115, 0], + [453, 115, 0], + [454, 114, 0], + [455, 114, 0], + [457, 116, 0], + [458, 116, 0], + [460, 117, 0], + [462, 117, 0], + [473, 114, 0], + [474, 118, 0], + [475, 118, 0], + [476, 119, 0], + [477, 119, 0], + [478, 120, 0], + [480, 120, 0], + [482, 114, 0], + [483, 114, 0], + [484, 121, 0], + [485, 121, 0], + [486, 122, 0], + [487, 122, 0], + [492, 115, 0], + [493, 115, 0], + [502, 115, 0], + [503, 115, 0], + [504, 115, 0], + [513, 115, 0], + [514, 115, 0], + [515, 115, 0], + [516, 123, 0], + [517, 123, 0], + [518, 124, 0], + [519, 124, 0], + [520, 125, 0], + [521, 125, 0], + [522, 126, 0], + [523, 126, 0], + [524, 115, 0], + [525, 115, 0], + [526, 115, 0], + [527, 115, 0], + [528, 127, 0], + [529, 127, 0], + [530, 128, 0], + [531, 128, 0], + [532, 129, 0], + [533, 129, 0], + [534, 130, 0], + [535, 130, 0], + [536, 115, 0], + [537, 115, 0], + [538, 131, 114], + [539, 114, 0], + [544, 132, 0], + [545, 132, 0], + [546, 133, 0], + [547, 133, 0], + [548, 114, 0], + [549, 114, 0], + [550, 114, 0], + [551, 114, 0], + [553, 134, 0], + [555, 134, 0], + [556, 135, 0], + [557, 135, 0], + [558, 136, 0], + [559, 136, 0], + [563, 134, 0], + [565, 134, 0], + [570, 134, 0], + [571, 134, 0], + [572, 134, 0], + [573, 134, 0], + [578, 114, 0], + [579, 114, 0], + [580, 115, 0], + [581, 115, 0], + [582, 115, 0], + [583, 115, 0], + [585, 114, 0], + [586, 137, 0], + [587, 137, 0], + [588, 137, 0], + [589, 137, 0], + [590, 138, 0], + [591, 137, 0], + [592, 137, 0], + [593, 137, 0], + [596, 137, 0], + [597, 137, 0], + [598, 114, 0], + [599, 114, 0], + [600, 114, 0], + [601, 114, 0], + [606, 115, 0], + [607, 115, 0], + [608, 115, 0], + [609, 115, 0], + [610, 115, 0], + [611, 115, 0], + [612, 115, 0], + [614, 115, 0], + [615, 115, 0], + [616, 115, 0], + [617, 115, 0], + [618, 115, 0], + [619, 115, 0], + [620, 115, 0], + [621, 140, 0], + [622, 114, 0], + [623, 114, 0], + [624, 114, 0], + [625, 114, 0] + ], + "exits": [ + [277, 256, 299], + [282, 257, 299], + [293, 258, 301], + [298, 258, 301], + [307, 261, 303], + [309, 261, 303], + [311, 262, 1], + [314, 263, 303], + [323, 265, 304], + [325, 266, 304], + [327, 267, 1], + [330, 268, 304], + [337, 270, 305], + [339, 270, 305], + [341, 271, 305], + [346, 271, 305], + [353, 272, 307], + [355, 272, 307], + [357, 273, 307], + [362, 273, 307], + [369, 275, 308], + [371, 275, 308], + [373, 275, 308], + [378, 276, 308], + [385, 277, 309], + [387, 277, 309], + [389, 278, 309], + [394, 278, 309], + [494, 262, 1], + [495, 262, 1], + [505, 267, 1], + [506, 267, 1], + [548, 285, 1], + [560, 285, 1], + [566, 286, 279], + [567, 286, 279], + [568, 287, 280], + [569, 287, 280], + [574, 288, 279], + [575, 288, 279], + [576, 289, 281], + [577, 289, 281] + ], + "gates": [ + ["A", 626, 115, 0], + ["A", 627, 115, 0], + ["A", 628, 115, 0], + ["A", 629, 114, 0], + ["A", 630, 114, 0], + ["A", 631, 114, 0], + ["A", 632, 114, 0], + ["A", 633, 114, 0], + ["A", 1762, 134, 0], + ["A", 1763, 134, 0], + ["A", 1764, 134, 0], + ["A", 1765, 134, 0], + ["A", 1766, 134, 0], + ["A", 1767, 134, 0], + ["A", 1768, 134, 0], + ["A", 1769, 134, 0], + ["A", 1770, 134, 0], + ["A", 1771, 134, 0], + ["A", 1772, 134, 0], + ["A", 1773, 134, 0], + ["A", 1774, 134, 0], + ["A", 1775, 134, 0], + ["A", 1776, 134, 0], + ["A", 1777, 134, 0], + ["A", 1778, 134, 0], + ["A", 1779, 134, 0], + ["A", 1780, 134, 0], + ["A", 1781, 134, 0], + ["A", 1782, 134, 0], + ["A", 1783, 134, 0], + ["A", 1784, 134, 0], + ["A", 1785, 134, 0], + ["A", 1786, 134, 0], + ["A", 1787, 116, 0], + ["A", 1788, 119, 0], + ["A", 1789, 119, 0], + ["A", 1790, 119, 0], + ["A", 1791, 119, 0], + ["A", 1792, 117, 0], + ["A", 1793, 124, 0], + ["A", 1794, 124, 0], + ["A", 1795, 120, 0], + ["A", 1796, 124, 0], + ["A", 1797, 124, 0], + ["A", 1798, 125, 0], + ["A", 1799, 125, 0], + ["A", 1800, 125, 0], + ["A", 1801, 125, 0], + ["A", 1802, 135, 0], + ["A", 1803, 135, 0], + ["A", 1804, 117, 0], + ["A", 1805, 128, 0], + ["A", 1806, 128, 0], + ["A", 1807, 128, 0], + ["A", 1808, 128, 0], + ["A", 1809, 120, 0], + ["A", 1810, 130, 0], + ["A", 1811, 130, 0], + ["A", 1812, 130, 0], + ["A", 1813, 130, 0], + ["A", 1814, 133, 0], + ["A", 1815, 133, 0], + ["A", 1816, 116, 0], + ["A", 1817, 122, 0], + ["A", 1818, 122, 0], + ["A", 1819, 122, 0], + ["A", 1820, 122, 0], + ["A", 1821, 129, 0], + ["A", 1822, 129, 0], + ["A", 1823, 129, 0], + ["A", 1824, 129, 0], + ["A", 1825, 132, 0], + ["A", 1826, 132, 0], + ["A", 1827, 126, 0], + ["A", 1828, 126, 0], + ["A", 1829, 126, 0], + ["A", 1830, 126, 0], + ["A", 1831, 136, 0], + ["A", 1832, 136, 0], + ["A", 1833, 118, 0], + ["A", 1834, 118, 0], + ["A", 1835, 118, 0], + ["A", 1836, 118, 0], + ["A", 1837, 127, 0], + ["A", 1838, 127, 0], + ["A", 1839, 127, 0], + ["A", 1840, 127, 0], + ["A", 1841, 123, 0], + ["A", 1842, 123, 0], + ["A", 1843, 123, 0], + ["A", 1844, 123, 0], + ["A", 1845, 121, 0], + ["A", 1846, 121, 0], + ["A", 1847, 121, 0], + ["A", 1848, 121, 0], + ["A", 4031, 620, 621], + ["A", 4037, 622, 280], + ["B", 0, 115, 0], + ["B", 1, 115, 0], + ["B", 2, 115, 0], + ["B", 3, 115, 0], + ["B", 4, 115, 0], + ["B", 5, 115, 0], + ["B", 6, 115, 0], + ["B", 7, 115, 0], + ["B", 8, 114, 0], + ["B", 9, 114, 0], + ["B", 10, 114, 0], + ["B", 15, 114, 0], + ["B", 16, 114, 0], + ["B", 17, 114, 0], + ["B", 18, 114, 0], + ["B", 19, 115, 0], + ["B", 20, 115, 0], + ["B", 21, 115, 0], + ["B", 22, 115, 0], + ["B", 23, 115, 0], + ["B", 24, 115, 0], + ["B", 25, 115, 0], + ["B", 26, 115, 0], + ["B", 27, 114, 0], + ["B", 28, 114, 0], + ["B", 29, 114, 0], + ["B", 30, 114, 0], + ["B", 32, 114, 0], + ["B", 33, 114, 0], + ["B", 34, 114, 0], + ["B", 35, 115, 0], + ["B", 36, 115, 0], + ["B", 37, 115, 0], + ["B", 38, 115, 0], + ["B", 39, 115, 0], + ["B", 40, 115, 0], + ["B", 41, 115, 0], + ["B", 42, 115, 0], + ["B", 43, 114, 0], + ["B", 44, 114, 0], + ["B", 45, 114, 0], + ["B", 46, 114, 0], + ["B", 47, 114, 0], + ["B", 48, 114, 0], + ["B", 49, 115, 0], + ["B", 50, 115, 0], + ["B", 51, 115, 0], + ["B", 52, 115, 0], + ["B", 53, 115, 0], + ["B", 54, 115, 0], + ["B", 55, 115, 0], + ["B", 56, 115, 0], + ["B", 57, 114, 0], + ["B", 60, 114, 0], + ["B", 61, 137, 0], + ["B", 62, 137, 0], + ["B", 63, 137, 0], + ["B", 64, 137, 0], + ["B", 65, 137, 0], + ["B", 66, 137, 0], + ["B", 67, 137, 0], + ["B", 68, 137, 0], + ["B", 69, 137, 0], + ["B", 70, 137, 0], + ["B", 71, 137, 0], + ["B", 72, 137, 0], + ["B", 73, 137, 0], + ["B", 74, 137, 0], + ["B", 75, 137, 0], + ["B", 76, 137, 0], + ["B", 77, 137, 0], + ["B", 78, 137, 0], + ["B", 79, 137, 0], + ["B", 80, 137, 0], + ["B", 81, 137, 0], + ["B", 82, 137, 0], + ["B", 83, 137, 0], + ["B", 84, 137, 0], + ["B", 85, 137, 0], + ["B", 86, 137, 0], + ["B", 87, 137, 0], + ["B", 88, 137, 0], + ["B", 89, 137, 0], + ["B", 90, 137, 0], + ["B", 91, 137, 0], + ["B", 92, 137, 0], + ["B", 93, 137, 0], + ["B", 94, 137, 0], + ["B", 95, 137, 0], + ["B", 96, 137, 0], + ["B", 97, 114, 0], + ["B", 98, 114, 0], + ["B", 99, 114, 0], + ["B", 100, 114, 0], + ["B", 101, 114, 0], + ["B", 102, 114, 0], + ["B", 103, 114, 0], + ["B", 104, 114, 0], + ["B", 105, 114, 0], + ["B", 106, 114, 0], + ["B", 107, 114, 0], + ["B", 108, 114, 0], + ["B", 109, 114, 0], + ["B", 110, 114, 0], + ["B", 111, 114, 0], + ["B", 112, 114, 0], + ["B", 113, 114, 0], + ["B", 114, 114, 0], + ["B", 135, 115, 0], + ["B", 136, 115, 0], + ["B", 137, 115, 0], + ["B", 138, 115, 0], + ["B", 139, 115, 0], + ["B", 140, 115, 0], + ["B", 141, 115, 0], + ["B", 142, 115, 0], + ["B", 143, 115, 0], + ["B", 144, 115, 0], + ["B", 145, 115, 0], + ["B", 146, 115, 0], + ["B", 147, 115, 0], + ["B", 148, 115, 0], + ["B", 149, 115, 0], + ["B", 150, 115, 0], + ["B", 151, 115, 0], + ["B", 152, 115, 0], + ["B", 153, 115, 0], + ["B", 154, 115, 0], + ["B", 155, 115, 0], + ["B", 156, 115, 0], + ["B", 157, 115, 0], + ["B", 158, 115, 0], + ["B", 159, 115, 0], + ["B", 160, 115, 0], + ["B", 161, 115, 0], + ["B", 162, 115, 0], + ["B", 163, 115, 0], + ["B", 164, 115, 0], + ["B", 165, 115, 0], + ["B", 166, 115, 0], + ["B", 167, 115, 0], + ["B", 168, 115, 0], + ["B", 169, 115, 0], + ["B", 170, 115, 0], + ["B", 171, 115, 0], + ["B", 172, 115, 0], + ["B", 173, 115, 0], + ["B", 174, 115, 0], + ["B", 175, 115, 0], + ["B", 176, 115, 0], + ["B", 177, 115, 0], + ["B", 178, 115, 0], + ["B", 179, 115, 0], + ["B", 180, 115, 0], + ["B", 181, 115, 0], + ["B", 182, 115, 0], + ["B", 183, 115, 0], + ["B", 184, 115, 0], + ["B", 185, 115, 0], + ["B", 186, 115, 0], + ["B", 187, 115, 0], + ["B", 188, 115, 0], + ["B", 189, 115, 0], + ["B", 190, 115, 0], + ["B", 191, 115, 0], + ["B", 192, 115, 0], + ["B", 193, 115, 0], + ["B", 194, 115, 0], + ["B", 195, 115, 0], + ["B", 196, 115, 0], + ["B", 197, 115, 0], + ["B", 198, 115, 0], + ["B", 199, 114, 0], + ["B", 200, 114, 0], + ["B", 201, 114, 0], + ["B", 202, 114, 0], + ["B", 203, 114, 0], + ["B", 204, 114, 0], + ["B", 205, 114, 0], + ["B", 206, 114, 0], + ["B", 207, 114, 0], + ["B", 208, 114, 0], + ["B", 209, 114, 0], + ["B", 210, 114, 0], + ["B", 211, 114, 0], + ["B", 212, 114, 0], + ["B", 213, 114, 0], + ["B", 214, 114, 0], + ["B", 234, 114, 0], + ["B", 235, 114, 0], + ["B", 236, 114, 0], + ["B", 237, 114, 0], + ["B", 474, 138, 0], + ["B", 475, 731, 360], + ["B", 503, 743, 371], + ["B", 504, 744, 372], + ["B", 505, 745, 373], + ["B", 506, 746, 374], + ["B", 507, 747, 375], + ["B", 508, 748, 376], + ["B", 509, 749, 377], + ["B", 510, 750, 378], + ["B", 511, 751, 391], + ["B", 512, 752, 392], + ["B", 513, 753, 393], + ["B", 514, 754, 394], + ["B", 515, 755, 395], + ["B", 516, 756, 396], + ["B", 517, 757, 397], + ["B", 518, 758, 398], + ["B", 521, 256, 299], + ["B", 526, 257, 299], + ["B", 533, 765, 411], + ["B", 534, 766, 412], + ["B", 535, 767, 413], + ["B", 536, 768, 414], + ["B", 537, 769, 415], + ["B", 538, 770, 416], + ["B", 539, 771, 417], + ["B", 540, 772, 418], + ["B", 559, 779, 431], + ["B", 560, 780, 432], + ["B", 561, 781, 433], + ["B", 562, 782, 434], + ["B", 563, 783, 435], + ["B", 564, 784, 436], + ["B", 565, 785, 437], + ["B", 566, 786, 438], + ["B", 571, 261, 303], + ["B", 575, 263, 303], + ["B", 576, 263, 303], + ["B", 601, 268, 304], + ["B", 602, 268, 304], + ["B", 622, 271, 305], + ["B", 624, 270, 305], + ["B", 627, 271, 305], + ["B", 629, 270, 305], + ["B", 630, 140, 0], + ["B", 635, 801, 491], + ["B", 636, 802, 492], + ["B", 637, 803, 493], + ["B", 638, 804, 494], + ["B", 639, 805, 495], + ["B", 640, 806, 496], + ["B", 641, 807, 497], + ["B", 642, 808, 498], + ["B", 661, 813, 511], + ["B", 662, 814, 512], + ["B", 663, 815, 513], + ["B", 664, 816, 514], + ["B", 665, 817, 515], + ["B", 666, 818, 516], + ["B", 667, 819, 517], + ["B", 668, 820, 518], + ["B", 673, 275, 308], + ["B", 678, 276, 308], + ["B", 684, 131, 114], + ["cleanup_tail", 0, 286, 279], + ["cleanup_tail", 1, 286, 279], + ["cleanup_tail", 2, 286, 279], + ["cleanup_tail", 3, 287, 280], + ["cleanup_tail", 4, 287, 280], + ["cleanup_tail", 5, 287, 280], + ["cleanup_tail", 6, 288, 279], + ["cleanup_tail", 7, 288, 279], + ["cleanup_tail", 8, 288, 279], + ["cleanup_tail", 9, 289, 281], + ["cleanup_tail", 10, 289, 281], + ["cleanup_tail", 11, 289, 281], + ["cleanup_tail", 12, 262, 1], + ["cleanup_tail", 13, 262, 1], + ["cleanup_tail", 14, 262, 1], + ["cleanup_tail", 15, 267, 1], + ["cleanup_tail", 16, 267, 1], + ["cleanup_tail", 17, 267, 1], + ["cleanup_tail", 18, 267, 1], + ["cleanup_tail", 19, 267, 1], + ["cleanup_tail", 40, 262, 1], + ["cleanup_tail", 41, 262, 1], + ["cleanup_tail", 42, 262, 1], + ["cleanup_tail", 43, 262, 1], + ["cleanup_tail", 44, 262, 1], + ["cleanup_tail", 45, 262, 1], + ["cleanup_tail", 46, 262, 1], + ["cleanup_tail", 53, 267, 1], + ["cleanup_tail", 54, 267, 1], + ["cleanup_tail", 67, 285, 1], + ["cleanup_tail", 68, 285, 1], + ["cleanup_tail", 69, 285, 1], + ["cleanup_tail", 77, 285, 1], + ["cleanup_tail", 78, 285, 1], + ["cleanup_tail", 112, 267, 1], + ["cleanup_tail", 113, 267, 1], + ["cleanup_tail", 114, 267, 1], + ["cleanup_tail", 115, 267, 1], + ["cleanup_tail", 118, 262, 1], + ["cleanup_tail", 119, 262, 1], + ["cleanup_tail", 120, 262, 1] + ] +} diff --git a/research/fresh-helper-boundary/FRONTIER-CHECKS.json b/research/fresh-helper-boundary/FRONTIER-CHECKS.json new file mode 100644 index 0000000000..2bebc81a01 --- /dev/null +++ b/research/fresh-helper-boundary/FRONTIER-CHECKS.json @@ -0,0 +1,14 @@ +{ + "schema": "frontier-watch/1", + "started_utc": "2026-10-21T19:32:20Z", + "interval_minutes": 20, + "checks": [ + { + "utc": "2026-10-21T19:52:05Z", + "latest_pr": 4437, + "highest_conditional_claim_pr": 4416, + "kappa": "0.00268647", + "action": "No stronger new claim found. Continue from p7 and PR4433 tail theorem." + } + ] +} \ No newline at end of file diff --git a/research/fresh-helper-boundary/NATIVE-RESULT.json.gz b/research/fresh-helper-boundary/NATIVE-RESULT.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..e6fdb31624e4eb8c7c770bb4422cd07ea99ab152 GIT binary patch literal 29131 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 A!~g&Q literal 0 HcmV?d00001 diff --git a/research/fresh-helper-boundary/PROOF.md b/research/fresh-helper-boundary/PROOF.md new file mode 100644 index 0000000000..4fe9fa7eec --- /dev/null +++ b/research/fresh-helper-boundary/PROOF.md @@ -0,0 +1,224 @@ +# Proof and conditional transfer + +## 1. Boundary contract + +Use the source full-identity native unit with 632 independent persistent +fields: 224 main fields and 408 helpers. Its two orientations give the source +main shears, while every helper is autonomous in its own logical reference. +The separately owned C0 field is cleared before each use and at return. No +arbitrary persistent input is overwritten or cleared. + +A field at frame f has physical value `C_f z`, where z denotes its logical +value and `C_f` is the source canonical Fourier frame. At entry this means +`z=C_start^-1 x` for an arbitrary physical input x. It does **not** require +precomputing a Fourier transform of x for free. The helper's actual final +operator is `C_end C_start^-1`, not merely `C_end`. + +For nested frame spaces S0` and `F(.0027212601276)<0`. To establish a fixed-profile +ceiling, arithmetic.py encloses `sum (T_r-P_r) r^(1-C) log r` on each of 16 +closed intervals covering `[0,1/20]`, and proves a strictly positive lower +bound throughout. Thus F is strictly decreasing there. On 128 further closed +intervals covering `[1/20,1]`, it bounds F directly strictly below zero. These +are interval implications for every real C in the covered intervals, not +extrapolation from point samples. The positive rank-one surplus at C=0 then +gives the unique relevant crossing and excludes any later positive region. + +A chronological tensor power multiplies both moments. Paid completion of a +rank-K target by D axes changes its moment by `(K+D)^t-K^t <= D^t`, which is +at most the added paid charge. Splitting a paid job on disjoint axes increases +or preserves its t-charge. Hence tensoring, this paid completion and paid +splitting cannot pass the raw fixed-profile ceiling. This is not a ceiling +on different native profiles or other algorithms. + +## 5. Pay both strictification tails + +Let `C=.00272125`, `t=1-C`, `u=3/10`, `v=150`, `J=10^v` and `L=15^v`. +Use the chronological native product of PR4416 and PR4433, restoring every +whole-job matcher and center before resuming a suspended caller. The product +has target and paid moments `T_t^v` and `P_t^v`, respectively; it is a +substitution of whole array programs, not the tensor power of a sum. + +Canonicalize each complete raw job with both recorded monomial factors; these +need not be an inverse pair. Subsequent placement on specified disjoint axes +is coordinate conjugation. No raw Clifford endpoint is assumed conjugate to +a canonical Fourier transform merely because its rank agrees. + +After the product finishes, complete every productive rank KJ, its split charge is at most +`2 R J^-C <= 2 R^(t+u) J^-u`, since `t+u>=1`. A completion has charge below +`2 L J^-C`. Therefore the complete normalized paid moment is bounded by + +``` +alpha^v + 2 gamma^v + 2 delta^v, +alpha=P_t/T_t, +gamma=P_(t+u)/(10^u T_t), +delta=7688*15/(10^C T_t). +``` + +The interval engine certifies `alpha<1-16/10^9`, `gamma<911/1000` and +`delta<173/200`. Bernoulli's inequality and an exact rational power test give + +``` +1/(1+150*16/10^9) + 2*(911/1000)^150 + 2*(173/200)^150 < 1. +``` + +Both original tails and every completion are paid. The product ambient rank +is `m=121^150`, with no need to materialize its immense word. + +## 6. Uniform compiler, BIT and outer bill + +Use the inherited finite integer mixed-target compiler only after strict +separation. Its fields, source complements, owned centers, integral batching, +matcher restoration and final exits are those of the specified new unit. +The new logarithmic majorant of PR4433 applies with `theta=6/7` and power 13: +`10^7<15^6`, `2*(10^150)^7 <= (121^150)^6`, and +`eta=t*121^(-150*C) > theta^13`. Its base-range condition is checked as well. +For declared `kappa=.00272124`, put `d=(C-kappa)/7=1/700000000` and uniform +saving `C-d`. The explicit integer comparison at `H=349300000000` is + +``` +(H+1)^13 < 2^499, d*H=499. +``` + +It specifies a finite uniform supplier at `N=2^H` with the required strict +saving. The instruction list and integer width B_N are generated by the +source finite algorithm rather than emitted here. + +The source BIT all-size parameter proof gives, before its last relaxation, +`(1-.003)*.00275 + .003*.0000384599 = .0027418653797`. Admit this unchanged +supplier at `.00273`; both the atom/adapter and borrowed-stock inequalities +remain strict. No BIT native word, cover or precision premise is weakened. +The old `.0027` relaxation fails the new outer bill and is a rejection control. + +Set `b=kappa+5d`, `a=kappa+4d`, `q=kappa+3d`, `epsilon=1-d`, `beta=1-3d`, +`r0=d/10`, `stop=d` and `layout=d`. The complete retained ledger recomputes all +nine cost rows, 54 current strict predicates and three functional guards. +Every one is strictly positive at this point. Closed uniform/epsilon gaps, +the insufficient old BIT relaxation and the unfunded tested endpoint fail. + +## 7. Costs and the precise conditional boundary + +Replace the old finite-unit constants by counts of the actual new word: +3363 paid local calls, the complete unchanged scalar lists and coefficients, +new serialized monomial/phase generators, 632 persistent fields and one owned +C0, all 408 helper normalizers, the unchanged p7 bridges and whole idles, the +150-fold chronological substitution, every completion and split, and finally +every integer-compiler unit, route, owned bank and rank-one leaf. A literal +finite recursive enumeration defines their counts and coefficient heights; +no p3 raw count is substituted for the compiled word. The new transport and +helper recipes are available explicitly in NATIVE-RESULT.json.gz. Internal +normalizers are restored before resuming a caller. + +Apply the source finite-template precision and stock argument with these new +constants. The native fixed coefficients and generators are finite, semantic +prefix bounds are rechecked, and all changed movement/scalar/normalizer work +enters the finite constants. The positive outer spare powers absorb those +constants after an effective threshold, under the inherited semantic, +all-column, physical primitive and fixed-tape hypotheses. This is the same +conditional transfer mechanism used by PR4416/4433, not a proof that local +savings are automatically a multiplication theorem. + +Analytic decomposition, permitted physical movement and whole-job frame +realization, source all-column correctness, finite-template closure, fine-prime +padding, fixed-tape execution and exact recovery remain stated source premises. +There is no formal verification or independent human mathematical review of +the complete theorem, no practical implementation claim, and no selected-result +change. Source files and contributor attribution are retained. diff --git a/research/fresh-helper-boundary/README.md b/research/fresh-helper-boundary/README.md new file mode 100644 index 0000000000..cbcfab9ccd --- /dev/null +++ b/research/fresh-helper-boundary/README.md @@ -0,0 +1,155 @@ +# Conditional κ = 0.00272124 from fresh-helper boundary retiming + +This changes the complete native p7 paid profile and proposes + +``` +T(n) = O(n (log n)^(1 - 0.00272124)). +``` + +The conditional saving exceeds [PR4416](https://github.com/CrocSwap/integer-mult-bounds/pull/4416)'s +`0.00268647` by **0.00003477 (about 1.2943%)**, and the pinned selected +`0.0023` by **18.31%**. This is a conditional construction submitted for review; +it does not change the selected record or establish an unconditional theorem. + +The new lever is to optimize helper entrances and exits for **fresh independent +helper inputs**, rather than retain frames selected for a hosted owner fill. +Changing those boundaries together with scalar contact frames saves recursive +calls without changing the scalar order, coefficients, main operator, warp +contacts or owned center program. The exact finite patch changes **117 helper +entrances, 42 helper exits and 395 scalar contact frames**. + +| Complete raw p7 invoice | PR4416 | This construction | +| --- | ---: | ---: | +| Independent productive fields | 7,688 | 7,688 | +| Paid calls | 55,998 | **53,133** | +| Productive rank mass | 131,723 | 133,718 | +| Paid rank mass | 131,115 | 133,110 | +| Rank-one surplus | 608 | 608 | +| Proposed conditional κ | 0.00268647 | **0.00272124** | + +The call reduction is **2,865 (about 5.12%)**. These are finite instruction +counts, not measured runtime speedups. The changed masses illustrate why +counting calls or rank-one mass alone does not establish the saving: the exact +concave moment and complete consumer are checked separately. + +## Native unit and exact evidence + +For each forward or backward local invocation, the new productive helper +profile and complete paid profile are + +``` +H = {4:26, 5:2, 7:29, 8:42, 9:309}, +P = {1:2253, 2:515, 3:445, 4:102, 5:40, 8:8}. +``` + +Every one of the 408 helpers has an independent arbitrary input. The center +remains separately owned, explicitly cleared, reused and uncredited. The +source p7 controller is unchanged: `pairs=7, keep_idle_mask=232127`. Its full +rational Laurent word is replayed; all 2,688 main idle calls are retained. +The complete new raw profiles are + +``` +T = {4:390, 5:30, 7:435, 8:630, 9:4635, + 25:448, 41:448, 57:448, 121:224}, +P = {1:33795, 2:7725, 3:6675, 4:1530, 5:600, + 8:1464, 16:448, 32:448, 48:448}. +``` + +[PROOF.md](PROOF.md) proves the retiming equivalence and explains the complete +transfer. [CHANGES.json](CHANGES.json) is the explicit circuit patch; +`native.py` resynthesizes every transport and replays both orientations on all +632 arbitrary inputs using two retained literal interpreters. All new transport +edges and every distinct helper boundary are independently lowered and decoded +as exact Clifford operations, including their absolute phase. Unchanged +transport phase evidence and the original all-column/native model remain +inherited source premises. + +`arithmetic.py` uses the unchanged interval engine of +[PR4433](https://github.com/CrocSwap/integer-mult-bounds/pull/4433). It certifies + +``` +0.0027212601275 < fixed-profile mixed root < 0.0027212601276. +``` + +An interval argument covers all real `0 0 and margin(ROOT_HIGH)[1] < 0, 'Certified changed-profile root bracket') + need(KAPPA < TESTED < ROOT_LOW, 'Strict supplier and outer headroom') + # An interval proof over real C, rather than signs only at a finite mesh. + signed = {r: targets[r]-paid[r] for r in targets.keys() | paid.keys()} + derivative_lower = None + for i in range(16): + left, right = Q(i, 320), Q(i+1, 320) + lower = Q(0) + for r, count in signed.items(): + power = E.power(r, 1-right if count > 0 else 1-left) + term = E.mul(power, E.log_bounds(r)) + lower += count*term[0 if count > 0 else 1] + derivative_lower = lower if derivative_lower is None else min(derivative_lower, lower) + need(derivative_lower > 0, 'Moment is strictly decreasing on [0,1/20]') + negative_upper = None + for i in range(128): + left, right = Q(1,20)+Q(19*i,2560), Q(1,20)+Q(19*(i+1),2560) + upper = sum(count*E.power(r, 1-left if count > 0 else 1-right)[1 if count > 0 else 0] + for r, count in signed.items()) + negative_upper = upper if negative_upper is None else max(negative_upper, upper) + need(negative_upper < 0, 'Every C in [1/20,1] has negative moment') + t, v, c, b, u = 1-TESTED, 150, 10, 15, Q(3,10) + target = E.moment(targets, t) + alpha = E.divide(E.moment(paid,t), target) + gamma = E.divide(E.moment(paid,t+u), E.mul(E.power(c,u),target)) + delta = E.divide((Q(sum(targets.values())*b),)*2, E.mul(E.power(c,TESTED),target)) + limits = (1-Q(16,10**9), Q(911,1000), Q(173,200)) + for bounds, limit in zip((alpha,gamma,delta),limits): + need(0 < bounds[0] <= bounds[1] < limit < 1, 'Certified complete tail limit') + a, g, d = limits + normalized_upper = 1/(1+v*(1-a))+2*g**v+2*d**v + need(normalized_upper < 1, 'All product, original paid tail and padding charges fit') + need(1 < c < b < 121 and t+u >= 1, 'Strictification hypotheses') + # PR4433's logarithmic majorant, rebound to this changed complete invoice. + theta, power = Q(6,7), 13 + eta = E.scale(E.exp_interval(E.scale(E.log_bounds(121),-v*TESTED)),t) + need(10**7 < 15**6 and 2*(10**v)**7 <= (121**v)**6, 'Actual exit cutoff and shifted logarithm') + need(eta[0] > theta**power, 'Strict exit versus complement contraction') + need(E.exp_interval(E.scale(E.log_bounds(121),v*TESTED))[1] < 2**power, 'Full initial rank range') + gap = (TESTED-KAPPA)/7 + need(gap.numerator == 1, 'Explicit integer grid for the uniform rank') + step = gap.denominator + def wins(j): + return (step*j+1)**power < 2**j + lo, hi = 1, 2 + while not wins(hi): + lo, hi = hi, 2*hi + while hi-lo > 1: + mid = (hi+lo)//2 + if wins(mid): hi = mid + else: lo = mid + H = step*hi + need(H > 7*v and wins(hi) and not wins(hi-1), 'Strict finite uniform-rank integer test') + # The original BIT proof already supplies the stronger, unrelaxed value. + bit = native.read(ROOT/'research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json') + bit_raw = (1-Q(bit['atom_power']))*Q(bit['C1_after_cover'])+Q(bit['atom_power'])*Q(bit['old_ordinary_saving']) + bit_admitted = Q('.00273') + need(bit_raw == Q(bit['ordinary_saving_before_final_relaxation']) > bit_admitted > KAPPA, 'Retain the existing stronger BIT conversion') + need(Q(bit['atom_power']) > bit_raw and 1-bit_raw-Q(bit['atom_power']) > 0, 'Both BIT adapter/stock gaps') + O = native.load(ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py', 'fresh_boundary_outer') + params = {'kappa': KAPPA, 'tested_saving': TESTED, + 'complex_uniform_saving': KAPPA+6*gap, 'b': KAPPA+5*gap, + 'a': KAPPA+4*gap, 'q': KAPPA+3*gap, 'bit_saving': bit_admitted, + 'epsilon': 1-gap, 'beta': 1-3*gap, 'r0': gap/10, + 'stop': gap, 'layout': gap, 'd': gap} + outer = O.ledger(params) + need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 3, 'Complete consumer predicate inventory') + need(all(value > 0 for group in ('strict_checks','functional_checks') for value in outer[group].values()), 'Every inherited consumer predicate') + controls = {} + for label, patch in [('old_BIT_relaxation', {'bit_saving': Q('.0027')}), + ('closed_uniform_gap', {'complex_uniform_saving': params['b']}), + ('closed_epsilon', {'epsilon': Q(1)}), + ('unfunded_outer', {'kappa': TESTED})]: + bad = O.ledger(dict(params,**patch)) + failed = [key for key,value in bad['strict_checks'].items() if value <= 0] + need(failed, 'Reject '+label); controls[label] = failed + return encode({'status':'PASS_CHANGED_NATIVE_PROFILE_STRICTIFICATION_AND_COMPLETE_OUTER', + 'kappa':KAPPA, 'tested_saving':TESTED, 'gain_over_PR4416':KAPPA-PREVIOUS, + 'relative_gain_over_PR4416':(KAPPA-PREVIOUS)/PREVIOUS, + 'targets':dict(sorted(targets.items())), 'paid':dict(sorted(paid.items())), + 'productive_fields':sum(targets.values()), 'paid_calls':sum(paid.values()), + 'root_bracket':[ROOT_LOW,ROOT_HIGH], 'headroom_from_declared_to_root':[ROOT_LOW-KAPPA,ROOT_HIGH-KAPPA], + 'fixed_profile_ceiling':{'decreasing_C_interval':['0','1/20'], + 'negative_derivative_upper':E.display((-derivative_lower,)*2), + 'remaining_C_interval':['1/20','1'], 'negative_moment_upper':E.display((negative_upper,)*2)}, + 'strictification':{'tensor_power':v,'cutoff_base':c,'target_floor_base':b,'tail_offset':u, + 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta), + 'rational_upper_limits':limits, 'normalized_paid_upper':normalized_upper, + 'gap':E.display((1-normalized_upper,)*2)}, + 'compiler':{'theta_upper':theta,'logarithm_power':power,'eta':E.display(eta), + 'uniform_saving':params['complex_uniform_saving'],'gap':gap,'H':H, + 'N':'2^'+str(H), 'integer_test_exponent':hi, 'word_materialized':False}, + 'BIT':{'inherited_unrelaxed_saving':bit_raw,'admitted':bit_admitted,'gap':bit_raw-bit_admitted}, + 'outer':outer, 'negative_controls':controls}) + +if __name__ == '__main__': + result = run(native.read(HERE/'NATIVE-RESULT.json.gz')) + (HERE/'ARITHMETIC-RESULT.json').write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + print(json.dumps({k:result[k] for k in ('status','kappa','gain_over_PR4416','root_bracket','compiler')},sort_keys=True)) diff --git a/research/fresh-helper-boundary/discover-cut.cpp b/research/fresh-helper-boundary/discover-cut.cpp new file mode 100644 index 0000000000..5caa077ea0 --- /dev/null +++ b/research/fresh-helper-boundary/discover-cut.cpp @@ -0,0 +1,35 @@ +// Optional floating-point discovery, never a proof checker. Apache-2.0. +// Prepared with substantial OpenAI Codex assistance. +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +struct Arc{int v,rev;double cap;}; +struct Flow{vector> a;vector level,ptr;Flow(int n):a(n),level(n),ptr(n){};void edge(int u,int v,double c){Arc x{v,int(a[v].size()),c},y{u,int(a[u].size()),0};a[u].push_back(x);a[v].push_back(y);}double send(int u,int t,double f){if(u==t)return f;for(int&i=ptr[u];i1e-8&&level[e.v]==level[u]+1){double z=send(e.v,t,min(f,e.cap));if(z>1e-8){e.cap-=z;a[e.v][e.rev].cap+=z;return z;}}}return 0;}vectorcut(int s,int t){while(true){fill(level.begin(),level.end(),-1);queueq;level[s]=0;q.push(s);while(!q.empty()){int u=q.front();q.pop();for(auto e:a[u])if(e.cap>1e-8&&level[e.v]<0){level[e.v]=level[u]+1;q.push(e.v);}}if(level[t]<0){vectorv(level.size());for(int i=0;i=0;return v;}fill(ptr.begin(),ptr.end(),0);while(send(s,t,1e15)>1e-8){}}}}; +struct Node{bool mut;int oldf,newf;}; +int main(int argc,char**argv){if(argc!=3){cerr<<"usage: discover-cut entry|exit output-file"<>F>>N>>E;vectordim(F);vector>space(F);for(int f=0;f>dim[f];for(auto&x:space[f])cin>>x;}vector>sub(F,vector(F,true));for(int i=0;inodes(N);vectoridx(N,-1),rev;for(int i=0;i>m>>nodes[i].oldf>>nodes[i].newf;nodes[i].mut=m;if(m){idx[i]=rev.size();rev.push_back(i);}}vector>edges(E);for(auto&[a,b]:edges)cin>>a>>b; + int H;cin>>H;vector>helpers(H);for(auto&[i,f]:helpers)cin>>i>>f; + vectorcandidates;for(int f=0;funary(V,0);int s=V,t=V+1; + for(auto[a,b]:edges){int fa=nodes[a].newf,fb=nodes[b].oldf;double e0=powers[dim[fb]-dim[fa]];int i=idx[a],j=idx[b]; + double e10=sub[g][fb]?powers[dim[fb]-dim[g]]:INF;double e01=sub[fa][g]?powers[dim[g]-dim[fa]]:INF; + if(i>=0&&j>=0){double w=e10+e01-e0;if(w<-1e-7){cerr<<"nonsubmodular"<=0)unary[i]+=e10-e0;else if(j>=0)unary[j]+=e01-e0; + } + for(auto[i,f]:helpers){int old=nodes[i].newf;double delta=(entry?(sub[g][f] && dim[g]dim[f]))?(entry?powers[dim[f]-dim[old]]-powers[dim[f]-dim[g]]:powers[dim[old]-dim[f]]-powers[dim[g]-dim[f]]):INF;unary[idx[i]]+=delta;} + for(int i=0;i=0&&reach[idx[a]]?g:fa,gb=idx[b]>=0&&reach[idx[b]]?g:fb;if(!sub[ga][gb]){legal=false;break;}delta+=powers[dim[gb]-dim[ga]]-powers[dim[fb]-dim[fa]];} + for(auto[i,f]:helpers)if(reach[idx[i]]){int old=nodes[i].newf;if(entry?(!sub[g][f]||dim[g]>=dim[f]):(!sub[f][g]||dim[g]<=dim[f])){legal=false;break;}delta+=entry?powers[dim[f]-dim[old]]-powers[dim[f]-dim[g]]:powers[dim[old]-dim[f]]-powers[dim[g]-dim[f]];} + if(legal&&delta < -1e-8){int count=0;for(int i=0;i=-1e-8){cerr<<"NO_GAIN round "<= 224: + continue + out.append(e) + for r, f in enumerate(c['final']): + climb(r, f) + return out + +def run(changes=None, phase_check=True): + c = read(BASE/'THREE-base-FULL-IDENTITY-CANONICAL.json.gz') + original = read(BASE/'THREE-base-FULL-IDENTITY-NATIVE.json.gz') + changes = read(HERE/'CHANGES.json') if changes is None else changes + for key, frame_key in (('entrances', 'start'), ('exits', 'final')): + seen = set() + for role, old, new in changes[key]: + need(role not in seen and 224 <= role < 632 and c[frame_key][role] == old, 'Bound unique helper boundary') + seen.add(role); c[frame_key][role] = new + maps = {d: gates(p) for d, p in original.items()} + need(set(maps['forward']) == set(maps['backward']), 'Both scalar orientations have the same contact inventory') + for key in maps['forward']: + f = original['forward'][maps['forward'][key]] + b = original['backward'][maps['backward'][key]] + need(b[1] == dual(f[1]) and b[2] == f[2], 'Actual inverse-transpose scalar correspondence') + changed = deepcopy(original) + seen = set() + for phase, ordinal, old, new in changes['gates']: + key = (phase, ordinal) + need(key not in seen and key in maps['forward'], 'Bound unique retimed scalar contact') + seen.add(key) + for d in changed: + e = changed[d][maps[d][key]] + need(e[2] == old, 'Original scalar frame pin') + e[2] = new + programs = {d: synthesize(c, p) for d, p in changed.items()} + V = load(ROOT/'research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py', 'fresh_boundary_rows') + X = load(ROOT/'research/kappa-rebuild/complex/native_extensions.py', 'fresh_boundary_literal') + checks = {} + profiles = {} + for d, p in programs.items(): + rows, receipt = X.literal_replay(V, c, p, d == 'backward') + for r in range(632): + need(rows['L', r] == V.expected(('L', r), [], d == 'backward', False), 'Every actual arbitrary-input endpoint, role '+str(r)) + profiles[d] = Counter({int(k): v for k, v in receipt['paid_profile'].items()}) + rebound = deepcopy(c) + rebound['local_profile'] = dict(profiles[d]) + receipt['second_literal'] = V.replay(p, rebound, [], d == 'backward', False) + checks[d] = receipt + need(profiles['forward'] == profiles['backward'], 'Same complete native tariff in both orientations') + H = Counter() + for r in range(224, 632): + a, b = c['start'][r], c['final'][r] + need(span(c['frames'][a]) <= span(c['frames'][b]), 'Nested productive helper boundary') + width = len(c['frames'][b])-len(c['frames'][a]) + need(width > 0, 'Every declared helper is independently productive') + H[width] += 1 + physical = [] + if phase_check: + ce = load(ROOT/'research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py', 'fresh_boundary_clifford') + P = load(ROOT/'research/kappa-function-composition/complex/prune_native.py', 'fresh_boundary_lowering') + N = X.N + old_edges = {(e[3], e[4]) for e in original['forward'] if e[0] == 'climb'} + new_edges = {(e[3], e[4]) for e in programs['forward'] if e[0] == 'climb'} + helper_edges = {(c['start'][r], c['final'][r]) for r in range(224, 632)} + for a, b in sorted((new_edges-old_edges) | helper_edges): + op = ce.canonical_frame(9, c['frames'][a]).adjoint().then(ce.canonical_frame(9, c['frames'][b])) + want = len(c['frames'][b])-len(c['frames'][a]) + directions = {} + for d in ('forward', 'backward'): + actual = P.conjugate(ce, op) if d == 'backward' else op + rec = N.lower_exact(P, ce, actual) + need(rec['rank'] == want, 'New physical Fourier rank including phase') + directions[d] = rec + physical.append({'old': a, 'new': b, 'rank': want, 'recipes': directions}) + return {'status': 'PASS_RETIMED_BOTH_ORIENTATIONS_ALL_632_COLUMNS', + 'helpers': dict(sorted(H.items())), 'paid': dict(sorted(profiles['forward'].items())), + 'changed_entrances': len(changes['entrances']), 'changed_exits': len(changes['exits']), + 'changed_scalar_frames': len(changes['gates']), 'native': checks, + 'new_physical_edges_and_boundaries': physical}, c, programs + +if __name__ == '__main__': + import argparse + p = argparse.ArgumentParser(); p.add_argument('--skip-phase', action='store_true'); p.add_argument('--write-result', action='store_true'); args = p.parse_args() + result, _, _ = run(phase_check=not args.skip_phase) + if args.write_result: + need(not args.skip_phase, 'Do not replace a complete phase receipt with a diagnostic') + (HERE/'NATIVE-RESULT.json.gz').write_bytes(gzip.compress((json.dumps(result, indent=2, sort_keys=True)+'\n').encode(),mtime=0)) + print(json.dumps({k: v for k, v in result.items() if k not in ('native', 'new_physical_edges_and_boundaries')}, sort_keys=True)) diff --git a/research/fresh-helper-boundary/verify.py b/research/fresh-helper-boundary/verify.py new file mode 100644 index 0000000000..e434dbf7c6 --- /dev/null +++ b/research/fresh-helper-boundary/verify.py @@ -0,0 +1,99 @@ +"""Replay the changed native unit and its conditional multiplication endpoint. + +Standard library only. Apache-2.0; substantial OpenAI Codex assistance. +""" +import argparse +import gzip +from copy import deepcopy +from hashlib import sha256, sha1 +import json +from pathlib import Path +import native +import arithmetic + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + +def need(ok, why): + if not ok: + raise ValueError(why) + +def authenticate(): + manifest = native.read(HERE/'SOURCES.json') + seen = set() + for row in manifest['files']: + if row['usage'] != 'input': + continue + path = Path(row['path']) + need(not path.is_absolute() and '..' not in path.parts and str(path) not in seen, 'Canonical unique input') + seen.add(str(path)) + actual = ROOT + for part in path.parts: + actual /= part + need(not actual.is_symlink(), 'No source alias') + data = actual.read_bytes() + need(sha256(data).hexdigest() == row['sha256'], 'Changed source: '+str(path)) + need(sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() == row['git_blob'], 'Changed source Git blob') + return len(seen) + +def controls(result, c, programs): + # This is a literal original-word control, not a second mathematical review. + baseline, _, _ = native.run({'entrances':[], 'exits':[], 'gates':[]}, phase_check=False) + need(baseline['helpers'] == {5:28,6:18,7:56,8:93,9:213}, 'Recover the actual predecessor helper profile') + need(baseline['paid'] == {1:2487,2:713,3:224,4:102,5:20,8:8}, 'Recover the actual predecessor paid profile') + V = native.load(ROOT/'research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py','boundary_control_rows') + rebound = deepcopy(c); rebound['local_profile'] = result['paid'] + bad = deepcopy(programs['forward']) + bad.pop(next(i for i, e in enumerate(bad) if e[0] == 'center')) + rejected = False + try: + V.replay(bad, rebound, [], False, False) + except (ValueError, AssertionError): + rejected = True + need(rejected, 'A missing paid center is rejected at the actual frame contact') + # A pure global-phase corruption has an unchanged Pauli tableau. + ce = native.load(ROOT/'research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py','boundary_control_phase') + P = native.load(ROOT/'research/kappa-function-composition/complex/prune_native.py','boundary_control_decode') + row = result['new_physical_edges_and_boundaries'][0] + rec = deepcopy(row['recipes']['forward']) + def decode(r): + left = P.monomial(ce, r['left'],9) + if r['rank']: + return P.monomial(ce,r['right'],9).then(ce.fourier(9,range(r['rank']))).then(left) + return left + original = decode(rec) + rec['left']['phase'] = (rec['left']['phase']+1)%4 + changed = decode(rec) + need(changed.tab == original.tab and changed.zero_state() != original.zero_state(), 'Absolute phase corruption is detected beyond tableau equality') + return {'predecessor_recovered':True,'omitted_center_rejected':True,'global_phase_only_corruption_rejected':True} + +def verify(write=False): + count = authenticate() + result, c, programs = native.run() + math = arithmetic.run(result) + checks = controls(result,c,programs) + artifacts = {'NATIVE-RESULT.json.gz': result, 'ARITHMETIC-RESULT.json': math} + for name, value in artifacts.items(): + normalized = json.loads(json.dumps(value)) + if write: + data = (json.dumps(normalized,indent=2,sort_keys=True)+'\n').encode() + (HERE/name).write_bytes(gzip.compress(data,mtime=0) if name.endswith('.gz') else data) + else: + need(normalized == native.read(HERE/name), 'Exact receipt replay: '+name) + receipt = {'status':'PASS_FRESH_HELPER_BOUNDARY_CONDITIONAL_KAPPA', + 'kappa_decimal':'0.00272124', 'source_inputs':count, + 'physical_edges_and_boundaries':len(result['new_physical_edges_and_boundaries']), + 'changed_entrances':result['changed_entrances'], 'changed_exits':result['changed_exits'], + 'changed_scalar_frames':result['changed_scalar_frames'], + 'controls':checks, 'scientific_receipts':{name:sha256(gzip.decompress((HERE/name).read_bytes()) if name.endswith('.gz') else (HERE/name).read_bytes()).hexdigest() for name in artifacts}} + if write: + (HERE/'RESULT.json').write_text(json.dumps(receipt,indent=2,sort_keys=True)+'\n') + else: + need(receipt == native.read(HERE/'RESULT.json'), 'Final checked receipt') + return receipt + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--write-receipts', action='store_true', help='Author receipts explicitly; ordinary replay does not write.') + args = parser.parse_args() + print(json.dumps(verify(args.write_receipts),sort_keys=True)) From eb6195fe3acd45669f17d7dd957e5b0177957f57 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 21 Oct 2026 15:24:43 -0500 Subject: [PATCH 04/13] Combine query thinning and helper retiming for conditional kappa 0.00300105 --- .../FRONTIER-CHECKS.json | 9 +- research/fresh-helper-thinned/AUDIT-4440.md | 44 +++ research/fresh-helper-thinned/PROOF.md | 132 +++++++++ research/fresh-helper-thinned/README.md | 92 ++++++ research/fresh-helper-thinned/RESULT.json | 237 +++++++++++++++ research/fresh-helper-thinned/SOURCES.json | 278 ++++++++++++++++++ research/fresh-helper-thinned/TASK.json | 96 ++++++ research/fresh-helper-thinned/VALIDATION.md | 26 ++ research/fresh-helper-thinned/VERIFY.json | 60 ++++ research/fresh-helper-thinned/verify.py | 180 ++++++++++++ 10 files changed, 1153 insertions(+), 1 deletion(-) create mode 100644 research/fresh-helper-thinned/AUDIT-4440.md create mode 100644 research/fresh-helper-thinned/PROOF.md create mode 100644 research/fresh-helper-thinned/README.md create mode 100644 research/fresh-helper-thinned/RESULT.json create mode 100644 research/fresh-helper-thinned/SOURCES.json create mode 100644 research/fresh-helper-thinned/TASK.json create mode 100644 research/fresh-helper-thinned/VALIDATION.md create mode 100644 research/fresh-helper-thinned/VERIFY.json create mode 100644 research/fresh-helper-thinned/verify.py diff --git a/research/fresh-helper-boundary/FRONTIER-CHECKS.json b/research/fresh-helper-boundary/FRONTIER-CHECKS.json index 2bebc81a01..df86354352 100644 --- a/research/fresh-helper-boundary/FRONTIER-CHECKS.json +++ b/research/fresh-helper-boundary/FRONTIER-CHECKS.json @@ -9,6 +9,13 @@ "highest_conditional_claim_pr": 4416, "kappa": "0.00268647", "action": "No stronger new claim found. Continue from p7 and PR4433 tail theorem." + }, + { + "utc": "2026-10-21T20:12:23Z", + "latest_pr": 4442, + "highest_conditional_claim_pr": 4440, + "kappa": "0.00296", + "action": "Audited exact head 40e22a83; registered replay passed. Switched to the stronger query-thinned construction and combined the verified helper retiming. New result is in research/fresh-helper-thinned." } ] -} \ No newline at end of file +} diff --git a/research/fresh-helper-thinned/AUDIT-4440.md b/research/fresh-helper-thinned/AUDIT-4440.md new file mode 100644 index 0000000000..64c4a98675 --- /dev/null +++ b/research/fresh-helper-thinned/AUDIT-4440.md @@ -0,0 +1,44 @@ +# Audit of PR4440 at 40e22a83ed660d3d6074c4f2dbf14bfb621eee51 + +The 20:12 UTC frontier check found PR4440's conditional 0.00296 above the first +helper-retiming result. Work switched to that source. Its complete registered +Python 3.12.15 replay passed before this combination was developed. Normal +combined replay repeats its full verifier and compares its saved receipt. + +No blocking defect was found **under its stated native, arbitrary-column, +owned-erasure and transfer contracts**. This is an AI-assisted source/proof +and finite-replay audit, not independent human or formal theorem acceptance. + +- **Paid query primitive.** Clear an owned stream, copy the donor, pay one + rank-one Q or Q^-1 job, add/subtract into the target, and erase only the owned + stream. The donor is retained; copied data create no productive input. + The inverse complex Gaussian is normalized with its actual Pauli translation, + not an order-two assumption. Literal arbitrary X/Y/Z columns reject omitted + clear/erase steps. Arbitrary-column physical lowering and owned erasure remain + explicit retained contracts rather than consequences of the finite test. +- **Actual controller.** Rational Laurent and binary coefficient checks replay + every emitted LOCAL, QUERY_SHEAR, IDLE, bridge and boundary program. Replacing + even stages also removes exactly those stage factors from idle operators and + target monomials. Lost helper inventories are charged. A wrong query direction + or altered coefficient changes the checked operator. +- **Native geometry.** Complex forward/inverse contact phases use the same + old-nine/fresh-eight chart on all 112 ports; the central q is fixed. Removing + inactive spectator blocks does not remove an active transform. BIT separately + checks all 111 rational charts and the original native child/copy bills. +- **Chronology and owners.** Full calls return their center before the next + query call. The one sequential owned stream can be reused at raw level; + nested products allocate the distinct centers required by suspended callers. + All full-call helpers are fresh independent fields. No copy, center or inactive + stage receives productive credit. +- **Complete costs.** The literal and closed-form invoices agree. Paid products, + completion and splitting charge both tails; the strict compiler is used only + after separation. The stronger BIT conversion pays its delayed cover fallback + and changes its atom power to 0.004; retaining 0.003 fails the adapter comparison. + Nine outer rows, 54 predicates and four guards are recomputed, with controls. +- **Limits.** The huge winning words and widths are finite algorithmic + specifications. Source all-column, owned-erasure, legal matcher, tape, + precision, analytic and recovery obligations remain conditional. + +The combination below makes no edit to PR4440. Its full and query main operators +stay fixed. It replaces only each full unit by an all-input-equivalent native +unit, then independently rebuilds the complete paid/productive invoice. diff --git a/research/fresh-helper-thinned/PROOF.md b/research/fresh-helper-thinned/PROOF.md new file mode 100644 index 0000000000..bf68dc2b98 --- /dev/null +++ b/research/fresh-helper-thinned/PROOF.md @@ -0,0 +1,132 @@ +# Conditional combination proof + +## 1. Exact unit substitution + +Use the source full-identity main shears and autonomous helpers in both +orientations. The retiming lemma of `fresh-helper-boundary/PROOF.md` changes +helper entrance/exit gauges and scalar contact frames while preserving every +logical row, main boundary, warp contact, scalar order/coefficient and owned +center. Both actual native words are replayed on all 632 arbitrary input +columns; 320 distinct new transport edges/helper boundaries are lowered and +decoded with absolute phase. Every helper boundary is normalized with its +recorded input and output monomials around the complete local job. These +factors need not be an inverse pair. + +Consequently a full LOCAL call in PR4440's complex word can be replaced by +this unit without changing its physical main operator. Allocate its 408 fresh +helper fields on the same distinct owner slots. Their new target profile is +`{4:26,5:2,7:29,8:42,9:309}` and paid profile is +`{1:2253,2:515,3:445,4:102,5:40,8:8}`. Each center remains owned and uncredited. +The same formal gauge equivalence applies under the retained all-column block +lifts; no sum of operators is tensor-powered. + +The source p17 controller has 19 full calls and 16 copied query shears. Every +thin query, full-call phase contact, main boundary and whole idle is unchanged. +The copied-query primitive and its zero/erase and physical Q contracts are +those audited in AUDIT-4440.md. Substitution therefore preserves the entire +main word. The normal verifier freshly executes both source verifiers before +using this implication. + +## 2. Entire changed invoice + +Count the actual emitted source events. Each LOCAL contributes one new H and +P; each QUERY_SHEAR contributes 112 paid rank-one jobs and no productive field; +each nonzero IDLE contributes 224 jobs of rank eight times its listed active +stage count. Each actual main diagonal monomial contributes 112 independent +rank `1+8*number_of_active_stages` fields. This gives + +``` +T={4:494,5:38,7:551,8:798,9:5871,17:448,25:448,33:448, + 41:448,49:448,57:448,65:448,73:448,153:224}, +P={1:44599,2:9785,3:8455,4:1938,5:760,8:152,16:448, + 24:448,32:448,40:448,48:448,56:448,64:448,72:448}. +``` + +There are 11,560 independent productive fields, 69,273 paid calls and rank +masses 260,798 and 259,998. Surplus 800 is preserved. An independent subtraction +of nineteen old helper/paid inventories and addition of nineteen new ones to +the source invoice must agree exactly with these event counts. + +At C=.003001052 the strict raw moment is checked by two rational interval +engines. Root signs at .0030010541830 and .0030010541834 enclose the new root. +As in the source helper package, interval derivatives prove strict decrease +on [0,1/20], and 128 closed interval enclosures exclude any positive moment on +[1/20,1]. This is a fixed-profile ceiling, not a global optimum. Chronological +products multiply the moments; paid completion loses moment by concavity and +splitting increases paid charge. Those operations cannot beat this raw ceiling. + +## 3. Pay both tails and specify a finite uniform rank + +Use t=1-C, u=1/5, v=1024, cutoff J=20^v and floor L=21^v. Apply the source +chronological product and whole-job completion/splitting algorithm, preserving +all spectators, restored matchers, distinct productive fields and owned banks. +Exactly the same charged theorem bounds the normalized paid moment by + +``` +alpha^v + 2 gamma^v + 2 delta^v, +alpha=P_t/T_t, +gamma=P_(t+u)/(20^u*T_t), +delta=11560*21/(20^C*T_t). +``` + +The new exact limits are `alpha<1-10^-9`, `gamma<97/100`, `delta<19/20`. +The old gamma limit 31/32 fails on this changed invoice and is explicitly +rejected. Both new tail limits to power 128 are strictly below 1/16. Hence +both tails at v=1024 are below 2^-32, and the exact rational inequality is + +``` +1/(1+1024/10^9) + 4/2^32 < 1. +``` + +Every completion and original paid tail is included. Final paid ranks are +at most 20^v and every productive target is at least 21^v. The maximum target +and ambient rank is m=153^v. + +Use PR4433's general logarithmic majorant, not an uncharged direct compiler. +Put theta=63/64 and p=1000. Check `20^64<21^63`, +`2*(20^v)^64 <= (153^v)^63`, and `eta=t*153^(-v*C)>theta^1000`. +The complete base range satisfies `153^(v*C)<2^1000` as well. These are precisely +the shifted exit, complement and base-range hypotheses of that majorant. + +For declared kappa=.00300105, set d=(C-kappa)/7=1/3500000000 and uniform +saving C-d. Let H be the reported multiple of 3500000000 satisfying +`(H+1)^1000 < 2^(d*H)`, and reject the previous grid point. RESULT.json +records the exact integers, giving the explicit sufficient rank N=2^H. +The source integer mixed flow supplies its integral widths, complements, owned +centers and exit jobs. The massive word is algorithmically specified, not emitted. + +## 4. Nonrecursive work, BIT and outer bill + +The complete local scalar lists retain the checked maximum allowance 158,168. +Bound each paid-job and helper monomial pair by 1000 elementary fixed +nine-coordinate records: Gaussian elimination, swaps, quadratic/linear phases, +offsets and global phase fit this conservative bound. The resulting local +scalar plus route allowance is below 10^7. The remaining 240 fixed warp +events and 448 main boundary adapters contribute fewer than 688,000 further +elementary records, also within that 10^7 local budget. Nineteen such units, all source query +records, bridges, boundary words and fixed chart records fit the retained raw +10^9 record bound; the verifier checks that larger substituted allowance. + +Update every product/compiler count from this actual word. The source finite +record bound and precision/stock prescription include the new normalizers, +every paid query and copied stream, all completions/splits, source complements, +owned banks, routes and rank-one leaves. No small predecessor constant is +substituted for the final compiled word. Fixed constants are absorbed only +through the positive spare powers of the inherited conditional transfer. + +Retain PR4440's entire BIT construction: pre-cover saving .003459, covered +saving .00345 and atom power .004. Its ordinary saving is .0034363538396, +admitted at .0034, strictly above the new complex endpoint. Its adapter, stock, +cover, owned queries and effective compiler remain unchanged. Normal replay +freshly checks that complete source construction. + +Set b=kappa+5d, a=kappa+4d, q=kappa+3d, epsilon=1-d, beta=1-3d, +r0=d/10 and stop=layout=d. Recompute all nine outer rows, 54 strict predicates +and four functional guards, including the actual new BIT atom. Every check +passes. Old BIT admission, a closed uniform/epsilon gap and the unfunded tested +endpoint are rejected. + +The source arbitrary-column native, owned-erasure, permitted physical matching, +finite-template precision, analytic decomposition, fixed-tape, prime and exact +recovery contracts remain conditional premises. These finite exact checks are +not formal verification or independent human acceptance of the complete theorem. diff --git a/research/fresh-helper-thinned/README.md b/research/fresh-helper-thinned/README.md new file mode 100644 index 0000000000..344616d665 --- /dev/null +++ b/research/fresh-helper-thinned/README.md @@ -0,0 +1,92 @@ +# Conditional κ = 0.00300105: fresh helper retiming on query-thinned controllers + +This builds on the stronger [PR4440](https://github.com/CrocSwap/integer-mult-bounds/pull/4440) +found during the requested 20-minute frontier check. After auditing its exact +head, replace all 19 full complex native calls by the verified fresh-helper +unit of `research/fresh-helper-boundary`. The main controller, 16 paid query +shears and stronger ordinary BIT supplier stay those of PR4440. The proposed +conditional bound is + +``` +T(n) = O(n (log n)^(1 - 0.00300105)). +``` + +The gain is **0.00004105 (about 1.39%) over PR4440's 0.00296**, +**about 11.71% over PR4416's 0.00268647**, and **30.48% over the pinned +selected 0.0023**. The new result is author-checked and awaits review; it +retains the conditional source implementation and transfer contracts. + +| Complete complex raw invoice | PR4440 | Combined construction | +| --- | ---: | ---: | +| Full native calls / paid query shears | 19 / 16 | 19 / 16 | +| Independent productive fields | 11,560 | 11,560 | +| Paid calls | 72,902 | **69,273** | +| Productive / paid rank mass | 258,271 / 257,471 | 260,798 / 259,998 | +| Rank-one surplus | 800 | 800 | +| Proposed conditional κ | 0.00296 | **0.00300105** | + +The native retiming removes **3,629 paid calls**. It changes 117 helper +entrances, 42 exits and 395 scalar frames in each full invocation, with exactly +the same main operator and complete owned-center program. Thus substitution +is a native operator equivalence, not merely replacement of a histogram. +Every helper is still a distinct arbitrary original input; query copies and +centers receive no productive credit. [PROOF.md](PROOF.md) gives the join. + +The exact changed-profile root is enclosed by + +``` +0.0030010541830 < root < 0.0030010541834. +``` + +An interval proof covers every real `0 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "871499999253/875000000000", + "fixed_halo_explicit_metadata_branch": "67375000001/875000000", + "new_BIT_row_stock_sublinear_in_active_group": "3489499997009/3500000000000", + "new_semantic_group_guard": "3/3500000000" + }, + "margins": { + "boundary_algebraic_matrix": "18381438244748161/6125000000000000000", + "fused_gaussian": "18381438234244483/6125000000000000000", + "global_coordinate_router": "10503679/3500000000", + "group_bit_router": "36762879968488963/12250000000000000000", + "group_scans": "1749999999/1750000000", + "main_transform": "18381436494748161/6125000000000000000", + "microbox_face_corrections": "67375000001/875000000", + "polynomial_products": "3499999999/3500000000", + "sparse_union_movement": "2506662688244748161/6125000000000000000" + }, + "parameters": { + "a": "10503679/3500000000", + "b": "8206/2734375", + "beta": "3499999997/3500000000", + "bit_saving": "17/5000", + "cap_xi": "5569162686494748161/6125000000000000000", + "complex_uniform_saving": "10503681/3500000000", + "d": "1/3500000000", + "epsilon": "3499999999/3500000000", + "kappa": "60021/20000000", + "lambda_": "996998949/1000000000", + "lambda_prime": "1744748161/1750000000", + "layout": "1/3500000000", + "q": "5251839/1750000000", + "r0": "1/35000000000", + "stop": "1/3500000000", + "tested_saving": "750263/250000000" + }, + "strict_checks": { + "actual_bit_above_effective": "1396321/3500000000", + "actual_logarithmic_gamma_guard": "1/3500000000", + "actual_logarithmic_group_guard": "555837316130251839/3062500000000000000", + "alpha_logarithm_absorption": "1/35000000000", + "boundary_algebraic_matrix_above_kappa": "6994748161/6125000000000000000", + "cap_above_band": "2506662686494748161/6125000000000000000", + "cap_below_cell": "555837311755251839/6125000000000000000", + "cap_below_phase_cell_power": "6680837313505251839/6125000000000000000", + "complex_above_effective": "1/3500000000", + "complex_below_one_over_32": "2471783/87500000", + "complex_endpoint": "1/1750000000", + "epsilon_below_one": "1/3500000000", + "epsilon_positive": "3499999999/3500000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "6984244483/6125000000000000000", + "gaussian_above_main": "869748161/3062500000000000000", + "global_coordinate_router_above_kappa": "1/875000000", + "global_gamma_power_slack": "9/35000000000", + "group_below_dimension": "1/1750000000", + "group_bit_router_above_kappa": "17468488963/12250000000000000000", + "group_gauge_power_slack": "555837316042751839/3062500000000000000", + "group_key_fits_record": "1/1750000000", + "group_positive": "3499999997/3500000000", + "group_scans_above_kappa": "3489496323/3500000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "635039790400418148631/500000000000000000000000", + "lambda_above_internal": "1/7000000000", + "lambda_above_sigma": "3/7000000000", + "lambda_above_tau": "1/7000000000", + "lambda_prime_above_lambda": "1/7000000000", + "lambda_prime_above_leaf": "85321/149536132812500", + "leaf_saving_above_effective": "2726169/9570312500000000", + "main_transform_above_kappa": "5244748161/6125000000000000000", + "membership_arithmetic_fits_record": "1/3500000000", + "microbox_face_corrections_above_kappa": "269489496329/3500000000", + "microbox_halo_volume": "276500000003/3500000000", + "new_complex_uniform_saving_above_b": "1/3500000000", + "new_semantic_guard_with_C1_one": "1/3500000000", + "polynomial_products_above_kappa": "872374081/875000000", + "positive_layout_slack": "1/3500000000", + "q_below_effective": "1/3500000000", + "q_below_internal": "1/3500000000", + "q_below_leaf": "85321/149536132812500", + "q_positive": "5251839/1750000000", + "short_record_fallback": "2726169/2734375", + "source_axis_superpolynomial": "1/3500000000", + "sparse_union_movement_above_kappa": "2488281256994748161/6125000000000000000", + "stop_below_one": "3499999999/3500000000", + "stop_positive": "1/3500000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/3500000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/3500000000", + "union_tag_work_per_visit_fits_record": "3/3500000000" + } + }, + "paid": { + "1": 44599, + "16": 448, + "2": 9785, + "24": 448, + "3": 8455, + "32": 448, + "4": 1938, + "40": 448, + "48": 448, + "5": 760, + "56": 448, + "64": 448, + "72": 448, + "8": 152 + }, + "paid_calls": 69273, + "productive_fields": 11560, + "query_shears": 16, + "scope": "Author-checked conditional construction; retained native/all-column, owned-erasure, whole-job, analytic, precision, tape, prime and recovery contracts. No selected promotion or formal/human acceptance.", + "source_heads": { + "PR4440": "40e22a83ed660d3d6074c4f2dbf14bfb621eee51", + "helper_retiming": "ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9" + }, + "source_inputs": 41, + "status": "PASS_CONDITIONAL_FRESH_HELPER_QUERY_THINNED_KAPPA", + "strictification": { + "alpha": { + "lower": "0.999999997758999184602267590366", + "upper": "0.999999997758999184602267590367" + }, + "cutoff": 20, + "delta": { + "lower": "0.932537400874663431699700098660", + "upper": "0.932537400874663431699700098661" + }, + "floor": 21, + "gamma": { + "lower": "0.969126930833863729265427869330", + "upper": "0.969126930833863729265427869331" + }, + "limits": [ + "999999999/1000000000", + "97/100", + "19/20" + ], + "normalized_paid_upper": "2097152001953127/2097154147483648", + "power": 1024, + "tail_offset": "1/5", + "tested": "750263/250000000" + }, + "targets": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 494, + "41": 448, + "49": 448, + "5": 38, + "57": 448, + "65": 448, + "7": 551, + "73": 448, + "8": 798, + "9": 5871 + } +} diff --git a/research/fresh-helper-thinned/SOURCES.json b/research/fresh-helper-thinned/SOURCES.json new file mode 100644 index 0000000000..4089ad3711 --- /dev/null +++ b/research/fresh-helper-thinned/SOURCES.json @@ -0,0 +1,278 @@ +{ + "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/fresh-helper-boundary/ARITHMETIC-RESULT.json", + "usage": "input", + "git_blob": "686c36fb19680db327f797ebdfe612487d8c53f8", + "sha256": "5d25fec9ac4b036c93846a50dccfa4af030e2982f5cec02e28702193bf157cf7", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/ARITHMETIC-RESULT.json" + }, + { + "path": "research/fresh-helper-boundary/CHANGES.json", + "usage": "input", + "git_blob": "45744fedd0e28967aa72586048b8bc0c72f419a9", + "sha256": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/CHANGES.json" + }, + { + "path": "research/fresh-helper-boundary/NATIVE-RESULT.json.gz", + "usage": "input", + "git_blob": "e6fdb31624e4eb8c7c770bb4422cd07ea99ab152", + "sha256": "37d0848458b289eb50271c47adef6e74014ae30be6363d09394b2337b566b839", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/NATIVE-RESULT.json.gz" + }, + { + "path": "research/fresh-helper-boundary/RESULT.json", + "usage": "input", + "git_blob": "e26608e20be115d28f8853a8c1a12bebfc8e8ec3", + "sha256": "34163eeeef1cd712de457d7fd3b0435f98a12ac456b82256b078f33225456fbd", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/RESULT.json" + }, + { + "path": "research/fresh-helper-boundary/SOURCES.json", + "usage": "input", + "git_blob": "0b40275502f4263a19905f4fb50e346a3629c712", + "sha256": "01998e9b86222d10811fc0114dcd5c946ff9e95025a7cacd00e67a3eefe543d0", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/SOURCES.json" + }, + { + "path": "research/fresh-helper-boundary/arithmetic.py", + "usage": "input", + "git_blob": "4822f04ae09d84a16e8fa8656a533e23fd4068f0", + "sha256": "212bae96d0ddcbc25076afe2589a47736c66b77420057f28c44c937ad087fc07", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/arithmetic.py" + }, + { + "path": "research/fresh-helper-boundary/native.py", + "usage": "input", + "git_blob": "1b36f6cb5f205c33bf48811e0b1b3621c55e8154", + "sha256": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/native.py" + }, + { + "path": "research/fresh-helper-boundary/verify.py", + "usage": "input", + "git_blob": "e434dbf7c68afa0390a307fd15f32348b0e87207", + "sha256": "4c18851214400cf955e10565d89357029d9e765140233831472ce23f0c3ee7bf", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/verify.py" + }, + { + "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-causal-continuation/buffer-borrowing/verify_buffers.py", + "usage": "input", + "git_blob": "5a55034ec9e6185d981e16c28e1e2e455069e2cb", + "sha256": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7" + }, + { + "path": "research/kappa-function-composition/complex/prune_native.py", + "usage": "input", + "git_blob": "8c3e11b2408fa96eefa3ebe7952d1b11b90b772b", + "sha256": "f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257" + }, + { + "path": "research/kappa-rebuild/architecture/mixed_target_probe.py", + "usage": "input", + "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + }, + { + "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/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "usage": "input", + "git_blob": "4a8c4ed26e53a72362d571c972e65aff546be784", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61" + }, + { + "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "usage": "input", + "git_blob": "b46d44c6ee624968dd57be928b0c15d9d45f3b2c", + "sha256": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39" + }, + { + "path": "research/kappa-rebuild/complex/native_extensions.py", + "usage": "input", + "git_blob": "7f84894efc309546a903d314c7ac1473e7f594a8", + "sha256": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3" + }, + { + "path": "research/kappa-rebuild/complex/power_two_balance.py", + "usage": "input", + "git_blob": "a55ae0ce78a1861965f899a82604b276260f636c", + "sha256": "76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424" + }, + { + "path": "research/kappa-rebuild/complex/rebuild_native.py", + "usage": "input", + "git_blob": "78a7b1b0e6e43a1347fb361f45c6e0eaff8dd27b", + "sha256": "f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5" + }, + { + "path": "research/kappa-rebuild/transfer-audit/p3_native_audit.py", + "usage": "input", + "git_blob": "0f3a4067a4b4e20d0e6ca0f84f41851c5168f76d", + "sha256": "5504a55a50546418d10c522984438cdeedb44993f7c1dab7bd4aa1ae0515d902" + }, + { + "path": "research/pr4359-p7-padding/P7-FACTOR.json", + "usage": "input", + "git_blob": "04c7ef620e760cc8f1764bbf0ccd7f32c6a5bd86", + "sha256": "6f96f6be5d8441f71cbe6ebb1657c69b543eb085b848b92b591b7ac01d6e6598" + }, + { + "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/query-thinned-controllers/BIT-CONTROLLER.json", + "usage": "input", + "git_blob": "89c400d5970024b3debe870c36ce43889beed001", + "sha256": "39ac84fb848b908f7ba051fae4556d507900c421dc5d23501a9c0cb1d61fd08d", + "pin": "head:40e22a83ed660d3d6074c4f2dbf14bfb621eee51:research/query-thinned-controllers/BIT-CONTROLLER.json" + }, + { + "path": "research/query-thinned-controllers/COMPLEX-CONTROLLER.json", + "usage": "input", + "git_blob": "39318f6ad9baf0838a274ca1042b1e3ba0e74bf9", + "sha256": "bf1143325d8380fab40cd5a85449f9a5412f0340deba7f4693714c92ae320088", + "pin": "head:40e22a83ed660d3d6074c4f2dbf14bfb621eee51:research/query-thinned-controllers/COMPLEX-CONTROLLER.json" + }, + { + "path": "research/query-thinned-controllers/RESULT.json", + "usage": "input", + "git_blob": "e0695152c98d727edfd0d2034b58a1c7e8682c0c", + "sha256": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f", + "pin": "head:40e22a83ed660d3d6074c4f2dbf14bfb621eee51:research/query-thinned-controllers/RESULT.json" + }, + { + "path": "research/query-thinned-controllers/SOURCES.json", + "usage": "input", + "git_blob": "0f061c87ff87c43ff1ea0fc418582e9ccea3bc1d", + "sha256": "74b73563d9f78a4562d376b6f33528d652e41097f65747667f112a3e1fa81d29", + "pin": "head:40e22a83ed660d3d6074c4f2dbf14bfb621eee51:research/query-thinned-controllers/SOURCES.json" + }, + { + "path": "research/query-thinned-controllers/controller.py", + "usage": "input", + "git_blob": "d4557e08cfb9fe57cc1ae4024705a72dc95f3583", + "sha256": "8b462d660487b1be4940357c4c7522967b1bfaede3c02b1c66109b85acae0fd2", + "pin": "head:40e22a83ed660d3d6074c4f2dbf14bfb621eee51:research/query-thinned-controllers/controller.py" + }, + { + "path": "research/query-thinned-controllers/verify.py", + "usage": "input", + "git_blob": "f1114036fff66f57014e5c1256141fb78ff4c4a9", + "sha256": "07dea601d6bbaa4d90e576f20c8607c37fb01e8778c798d919fa9df435049950", + "pin": "head:40e22a83ed660d3d6074c4f2dbf14bfb621eee51:research/query-thinned-controllers/verify.py" + }, + { + "path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + } + ] +} diff --git a/research/fresh-helper-thinned/TASK.json b/research/fresh-helper-thinned/TASK.json new file mode 100644 index 0000000000..ee8b8e27d1 --- /dev/null +++ b/research/fresh-helper-thinned/TASK.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 7, + "base_commit": "3a23e9d9d2e67833515d1c60a17e966bcdcab43c", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Can the #4088 four-provider dispatch satisfy the complete ordinary/outer admission contract?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/scatter-boundary-decision/README.md" + ], + "methods": [ + "Trace one hypothesis through the source, checker and complete caller.", + "Construct one semantically invalid but superficially well-formed fixture and test rejection." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4088 Scope and Open next questions: local words, native receipts and literal fill do not include a rerun of the mixed four-provider ordinary/outer engine. #3801 is the newer scatter-boundary decision; do not restart #2977 as if untouched.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Pin the provider registry, four native source closures and dispatch. Make a bounded acceptance coverage map or one registry adapter preserving every inherited admission predicate and rejection control (including an omitted fourth provider). Record remaining ordinary/outer obligations and a resource estimate before heavy execution. Stop at unresolved source/caller dependencies; no selected-result promotion from a local pass.", + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "allowed_variations": [ + "One provider-registry, dispatch, native-closure or admission-predicate obligation; separate branches must name distinct coverage." + ], + "scope_change_triggers": [ + "Reporting the historical timing-only diagnostic as a new current acceptance bug.", + "Calling a malformed mutant a failure of the selected construction, or importing an opt-in repair without testing the exporter boundary.", + "Running another root enclosure instead of validating dispatch or weakening an inherited predicate to make mixed admission pass." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics", + "4088", + "3801", + "staged544-mixed-fourth-entry", + "scatter-boundary-decision" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Combine the exact-head PR4440 query-thinned complex controller and stronger BIT supplier with the verified helper boundary retiming; certify a new complete conditional kappa beyond both predecessors.", + "scope_change_reason": "The explicit user task is to beat the strongest current kappa and switch to any stronger PR found in 20-minute checks. PR4440 at head 40e22a83 appeared during this run; its query-thinned native construction supersedes the first p7 result. This package audits and builds on that exact head, combining it with the independently replayed fresh helper retiming.", + "bottleneck_link": "Changing the complete nineteen-call native paid/productive profile improves the binding complex moment while retaining all copied-query charges and the stronger BIT consumer.", + "budget_minutes": 60, + "stop_rule": "Do not continue a superseded lesser kappa. Audit the stronger exact source, check actual unit substitution and the entire outer bill; no root digit-only or selected-frontier promotion.", + "outcome": "completed", + "evidence": "README.md; PROOF.md; AUDIT-4440.md; RESULT.json; SOURCES.json; VALIDATION.md", + "author": "1337isnot1337 with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance. No subagents or independent human mathematical review.", + "open_questions": [ + { + "question": "Can another simultaneous multi-frame or query/native topology change beat the new fixed-profile root?", + "why_it_matters": "Only about 4.18e-9 headroom remains in this invoice; another substantial improvement requires a changed profile.", + "first_step": "Start from the two pinned native units and emit a literal changed chronological word with all helper, owned-query and idle charges before a new root claim.", + "blocked_by": "No global optimum or complete multi-frame search is supplied." + }, + { + "question": "Can the owned-query and helper-retiming interfaces be independently proved at arbitrary column multiplicity?", + "why_it_matters": "The finite replays inherit source native, owned-erasure and whole-job contracts.", + "first_step": "Audit AUDIT-4440.md and the block-lift/whole-job clauses of both pinned source proofs.", + "blocked_by": "Finite phase/operator evidence is not formal or human acceptance of the entire source stack." + } + ] +} diff --git a/research/fresh-helper-thinned/VALIDATION.md b/research/fresh-helper-thinned/VALIDATION.md new file mode 100644 index 0000000000..ed9998e51a --- /dev/null +++ b/research/fresh-helper-thinned/VALIDATION.md @@ -0,0 +1,26 @@ +# Validation and limits + +- Source PR4440 head 40e22a83ed660d3d6074c4f2dbf14bfb621eee51: the unchanged + registered CPython 3.12.15 replay passed during the frontier audit. +- Helper retiming head ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9: complete + CPython 3.12.15 registered replay, 320 phase/boundary checks, all 632 arbitrary + columns in both native orientations, negative controls and separate Git-free + replay passed before composition. Its published optimizer reproduces its patch. +- New arithmetic authoring freshly authenticates all pinned inputs, counts the + actual combined event word, and checks the full changed moment, root ceiling, + both tail bounds, logarithmic rank, enlarged scalar/route budget and outer bill. + The authoring path uses previously checked source receipts. Normal registered + replay freshly executes both full source verifiers and compares the combined + receipt. That normal registered CPython 3.12.15 replay passed, freshly + executing both complete source verifiers before the new arithmetic checks. + +No source package was edited. Both exact predecessor commits are retained in +publication ancestry. The selected record is unchanged. No Lean, Docker, +all-history suite, formal theorem acceptance or independent human review is +claimed. Native all-column, owned-erasure, whole-job, physical/tape, analytic, +precision, prime and exact-recovery premises remain conditional. + +The first hosted plan run at predecessor ccdae89 failed four pre-existing +selected-status navigation tests before reaching research replay. The submission +repairs only the two navigation documents, retaining selected kappa 0.0023 and +all historical content. The six targeted navigation/locale tests pass. diff --git a/research/fresh-helper-thinned/VERIFY.json b/research/fresh-helper-thinned/VERIFY.json new file mode 100644 index 0000000000..5af213891f --- /dev/null +++ b/research/fresh-helper-thinned/VERIFY.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/fresh-helper-boundary/ARITHMETIC-RESULT.json", + "research/fresh-helper-boundary/CHANGES.json", + "research/fresh-helper-boundary/NATIVE-RESULT.json.gz", + "research/fresh-helper-boundary/RESULT.json", + "research/fresh-helper-boundary/SOURCES.json", + "research/fresh-helper-boundary/arithmetic.py", + "research/fresh-helper-boundary/native.py", + "research/fresh-helper-boundary/verify.py", + "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-causal-continuation/buffer-borrowing/verify_buffers.py", + "research/kappa-function-composition/complex/prune_native.py", + "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/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "research/kappa-rebuild/complex/native_extensions.py", + "research/kappa-rebuild/complex/power_two_balance.py", + "research/kappa-rebuild/complex/rebuild_native.py", + "research/kappa-rebuild/transfer-audit/p3_native_audit.py", + "research/pr4359-p7-padding/P7-FACTOR.json", + "research/pr4359-p7-padding/TENSOR.md", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/pr4359-p7-padding/native_inventory.py", + "research/query-thinned-controllers/BIT-CONTROLLER.json", + "research/query-thinned-controllers/COMPLEX-CONTROLLER.json", + "research/query-thinned-controllers/RESULT.json", + "research/query-thinned-controllers/SOURCES.json", + "research/query-thinned-controllers/controller.py", + "research/query-thinned-controllers/verify.py", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Freshly replay both exact-head source constructions; independently count the combined native/query/idle invoice; certify changed root and all-C fixed-profile ceiling, both charged tails with repaired gamma limit, logarithmic compiler rank, complete stronger BIT and all 54 outer predicates plus four guards." + } + ] +} diff --git a/research/fresh-helper-thinned/verify.py b/research/fresh-helper-thinned/verify.py new file mode 100644 index 0000000000..9ba85a59aa --- /dev/null +++ b/research/fresh-helper-thinned/verify.py @@ -0,0 +1,180 @@ +"""Combine the exact helper retiming with audited PR4440 query thinning. + +Apache-2.0; substantial OpenAI Codex assistance. Source notices retained. +Normal replay freshly executes both source verifiers, then this new ledger. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha1, sha256 +import argparse +import gzip +import importlib.util +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +KAPPA, TESTED = Q('.00300105'), Q('.003001052') +ROOT_LOW, ROOT_HIGH = Q('.0030010541830'), Q('.0030010541834') + +def need(ok, why): + if not ok: raise ValueError(why) + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + +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 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(): + seen=set() + for row in read(HERE/'SOURCES.json')['files']: + if row['usage']!='input': continue + p=Path(row['path']);need(not p.is_absolute() and '..' not in p.parts and str(p) not in seen,'Canonical input') + seen.add(str(p));actual=ROOT + for part in p.parts: + actual/=part;need(not actual.is_symlink(),'No source aliases') + b=actual.read_bytes() + need(sha256(b).hexdigest()==row['sha256'],'Changed source: '+str(p)) + need(sha1(b'blob '+str(len(b)).encode()+b'\0'+b).hexdigest()==row['git_blob'],'Changed Git source blob') + return len(seen) + +def ceiling(E,T,P): + signed={r:T[r]-P[r] for r in T.keys()|P.keys()} + def margin(c): + a,b=E.moment(T,1-c),E.moment(P,1-c) + return a[0]-b[1],a[1]-b[0] + need(margin(ROOT_LOW)[0]>0 and margin(ROOT_HIGH)[1]<0,'New complete profile root bracket') + derivative=None + for i in range(16): + l,r=Q(i,320),Q(i+1,320);low=Q(0) + for rank,n in signed.items(): + term=E.mul(E.power(rank,1-r if n>0 else 1-l),E.log_bounds(rank)) + low+=n*term[0 if n>0 else 1] + derivative=low if derivative is None else min(derivative,low) + upper=None + for i in range(128): + l,r=Q(1,20)+Q(19*i,2560),Q(1,20)+Q(19*(i+1),2560) + hi=sum(n*E.power(rank,1-l if n>0 else 1-r)[1 if n>0 else 0] for rank,n in signed.items()) + upper=hi if upper is None else max(hi,upper) + need(derivative>0 and upper<0,'Fixed-profile ceiling for every real 00,'No nonzero charge for erased idle stage') + P[rank]+=224;idle+=224 + for term in word['diagonal']: + need(term[0] in (-1,1) and all(x in (0,1) for x in term[1:]),'Actual normalized main target') + T[1+8*sum(term[1:])]+=112 + need((full,thin,idle)==(19,16,3584),'Every full, copied-query and whole-idle event') + need(sum(T.values())==11560 and sum(P.values())==69273,'Complete new productive/call counts') + need((sum(r*n for r,n in T.items()),sum(r*n for r,n in P.items()))==(260798,259998),'Preserve the exact surplus 800') + # Independent substitution into the source invoice must give the same ledger. + oldH={5:28,6:18,7:56,8:93,9:213};oldP={1:2487,2:713,3:224,4:102,5:20,8:8} + ref=source_query['complex_invoice'] + for key,new,old_unit,new_unit in [('targets',T,oldH,H),('paid',P,oldP,N)]: + check=Counter({int(k):v for k,v in ref[key].items()}) + check.subtract({k:19*v for k,v in old_unit.items()});check.update({k:19*v for k,v in new_unit.items()}) + need(+check==new,'Literal event count equals whole-call substitution: '+key) + E=S.C.load(ROOT/'research/higher-moment-strictification/verify.py','combined_exact_intervals') + root=ceiling(E,T,P) + t,u,v,c,b=1-TESTED,Q(1,5),1024,20,21 + target=E.moment(T,t);alpha=E.divide(E.moment(P,t),target) + other=S.C.load(ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','combined_separate_intervals') + tl,th=other.moment(T,TESTED);pl,ph=other.moment(P,TESTED) + need(tl>ph and max(tl,target[0])<=min(th,target[1]),'Independent exact raw-moment engine') + gamma=E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target)) + delta=E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,TESTED),target)) + alpha_gap=Q(1,1000000000);g,d=Q(97,100),Q(19,20) + need(alpha[1]<1-alpha_gap and gamma[1]Q(31,32),'The previous gamma limit fails and is explicitly replaced') + # Apply PR4433's general logarithmic majorant at the actual new ambient rank. + theta,power=Q(63,64),1000 + eta=E.scale(E.power(153,-v*TESTED),t) + need(2*(20**v)**64<=(153**v)**63 and eta[0]>theta**power,'Shifted exit and complement capacity') + need(E.power(153,v*TESTED)[1]<2**power,'Initial compiler range') + gap=(TESTED-KAPPA)/7;need(gap.numerator==1,'Integer compiler grid') + step=gap.denominator + def passes(j):return (step*j+1)**power<2**j + lo,hi=1,2 + while not passes(hi):lo,hi=hi,2*hi + while hi-lo>1: + mid=(lo+hi)//2 + if passes(mid):hi=mid + else:lo=mid + height=step*hi + need(height>8*v and passes(hi) and not passes(hi-1),'Effective uniform rank integer inequality') + # The changed local list is charged under an explicit larger fixed bound. + local_scalar=max(x['real_scalar_allowance'] for x in local['native'].values()) + local_routes=(sum(N.values())+2*408)*1000 + need(local_scalar+local_routes<10**7,'Every new local scalar and monomial route fits') + scalar_upper=19*10**7+16*1792+32*112*(len(word['physical_events'])+sum(len(word['boundaries'][k+'_program']) for k in ('left','right'))) + need(scalar_upper<10**9,'Retain the complete raw nonrecursive bound') + bit=source_query['ordinary_BIT'];atom=Q(bit['atom']);ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599') + admitted=Q(bit['admitted']);need(atom==Q('.004') and atom>ordinary>admitted>TESTED and atom<1-ordinary,'Complete stronger source BIT admission') + L=S.C.load(ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','combined_outer_ledger') + params={'kappa':KAPPA,'tested_saving':TESTED,'complex_uniform_saving':KAPPA+6*gap, + 'b':KAPPA+5*gap,'a':KAPPA+4*gap,'q':KAPPA+3*gap,'bit_saving':admitted, + 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} + 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 outer predicate inventory') + need(all(x>0 for key in ('strict_checks','functional_checks') for x in outer[key].values()),'Every complete outer inequality') + controls={} + for name,patch in [('old_BIT',{'bit_saving':Q('.0027')}),('closed_uniform',{'complex_uniform_saving':params['b']}),('unfunded_endpoint',{'kappa':TESTED}),('closed_epsilon',{'epsilon':Q(1)})]: + bad=L.ledger(dict(params,**patch));failed=[k for k,x in bad['strict_checks'].items() if x<=0] + need(failed,'Reject '+name);controls[name]=failed + return encode({'status':'PASS_CONDITIONAL_FRESH_HELPER_QUERY_THINNED_KAPPA', 'kappa':KAPPA,'kappa_decimal':'0.00300105', + 'source_inputs':count,'source_heads':{'PR4440':'40e22a83ed660d3d6074c4f2dbf14bfb621eee51','helper_retiming':'ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9'}, + 'gain_over_PR4440':KAPPA-Q('.00296'),'gain_over_PR4416':KAPPA-Q('.00268647'), + 'targets':dict(sorted(T.items())),'paid':dict(sorted(P.items())),'full_calls':full,'query_shears':thin, + 'paid_calls':sum(P.values()),'productive_fields':sum(T.values()),'fixed_profile_ceiling':root, + 'strictification':{'tested':TESTED,'power':v,'cutoff':c,'floor':b,'tail_offset':u, + 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta), + 'limits':[1-alpha_gap,g,d],'normalized_paid_upper':bound}, + 'compiler':{'theta':theta,'logarithm_power':power,'eta':E.display(eta),'uniform_saving':params['complex_uniform_saving'], + 'gap':gap,'H':height,'N':'2^'+str(height),'integer_test_exponent':hi,'word_materialized':False}, + 'nonrecursive':{'local_scalar_allowance':local_scalar,'local_route_bound':local_routes,'raw_upper':scalar_upper,'raw_budget':10**9}, + 'ordinary_BIT':bit,'outer':outer,'negative_controls':controls, + 'scope':'Author-checked conditional construction; retained native/all-column, owned-erasure, whole-job, analytic, precision, tape, prime and recovery contracts. No selected promotion or formal/human acceptance.'}) + +if __name__=='__main__': + parser=argparse.ArgumentParser() + parser.add_argument('--write',action='store_true',help='Author the new arithmetic receipt from already-audited dependency receipts; normal replay freshly reruns both dependencies.') + args=parser.parse_args();result=run(execute_sources=not args.write) + if args.write:(HERE/'RESULT.json').write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + else:need(result==read(HERE/'RESULT.json'),'Exact combined receipt replay') + print(json.dumps({k:result[k] for k in ('status','kappa_decimal','gain_over_PR4440','compiler')},sort_keys=True)) From 5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 21 Oct 2026 15:24:43 -0500 Subject: [PATCH 05/13] Repair selected checkpoint navigation blocking research CI --- 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 53880d1ade4b1d50906ce5187577ae2ffb492067 Mon Sep 17 00:00:00 2001 From: zxv Date: Wed, 21 Oct 2026 16:53:41 -0400 Subject: [PATCH 06/13] Improve native frame contact and conditional kappa to 0.00300120 --- .../native-lattice-retiming/LITERATURE.md | 42 + .../NATIVE-RESULT.json | 816 ++++++++++++++++++ research/native-lattice-retiming/NOTICE.md | 16 + research/native-lattice-retiming/PATCH.json | 8 + research/native-lattice-retiming/PROOF.md | 96 +++ research/native-lattice-retiming/README.md | 131 +++ research/native-lattice-retiming/RESULT.json | 396 +++++++++ research/native-lattice-retiming/SOURCES.json | 282 ++++++ research/native-lattice-retiming/TASK.json | 123 +++ .../native-lattice-retiming/VALIDATION.md | 26 + research/native-lattice-retiming/VERIFY.json | 69 ++ .../native-lattice-retiming/arithmetic.py | 136 +++ .../discover-lattice.cpp | 68 ++ research/native-lattice-retiming/discover.py | 59 ++ research/native-lattice-retiming/native.py | 94 ++ research/native-lattice-retiming/verify.py | 41 + 16 files changed, 2403 insertions(+) create mode 100644 research/native-lattice-retiming/LITERATURE.md create mode 100644 research/native-lattice-retiming/NATIVE-RESULT.json create mode 100644 research/native-lattice-retiming/NOTICE.md create mode 100644 research/native-lattice-retiming/PATCH.json create mode 100644 research/native-lattice-retiming/PROOF.md create mode 100644 research/native-lattice-retiming/README.md create mode 100644 research/native-lattice-retiming/RESULT.json create mode 100644 research/native-lattice-retiming/SOURCES.json create mode 100644 research/native-lattice-retiming/TASK.json create mode 100644 research/native-lattice-retiming/VALIDATION.md create mode 100644 research/native-lattice-retiming/VERIFY.json create mode 100644 research/native-lattice-retiming/arithmetic.py create mode 100644 research/native-lattice-retiming/discover-lattice.cpp create mode 100644 research/native-lattice-retiming/discover.py create mode 100644 research/native-lattice-retiming/native.py create mode 100644 research/native-lattice-retiming/verify.py diff --git a/research/native-lattice-retiming/LITERATURE.md b/research/native-lattice-retiming/LITERATURE.md new file mode 100644 index 0000000000..96469b6e48 --- /dev/null +++ b/research/native-lattice-retiming/LITERATURE.md @@ -0,0 +1,42 @@ +# Literature evaluated during this continuation + +Local research notes, 21 October 2026. This revisits zxv's +[0.0023 literature list](../kappa-0023-productive-jobs/LITERATURE.md). +The sources motivate experiments; their theorems are not imported as native +instructions or as a proof of the new multiplication bound. + +| Paper | Applicable idea | Missing transfer / outcome here | +| --- | --- | --- | +| [Dumas–Grenet, In-place accumulation, §3 and Theorem 5](https://arxiv.org/html/2307.12712v3) | Prepare output registers by subtraction, accumulate once, then distribute by restoring the changed register. Inputs must be restored; the computed function cannot use its output as scratch. | Native Fourier frame contacts still need payment. Our exact commuting-ADD folding removes 108 scalar records in each orientation but leaves the recursive profile unchanged, even after retiming. This is not the κ improvement. A multi-target native interface remains a useful larger direction. | +| [Brislawn, Causal Complementation, §§2.2–2.4](https://arxiv.org/html/2408.07970v1) | Couple elimination to divisibility and causal availability rather than use an arbitrary inverse. | The paper works with causal polynomial filter matrices; our controller has several independent Laurent variables and restricted dyadic/native contacts. No direct factorization theorem applies. It suggested checking the actual subspace lattice instead of the old finite frame menu. The accepted three-dimensional contact is proved separately by native replay and Clifford decoding. | +| [Urschel, block unitriangular representations, Lemma 5](https://arxiv.org/html/2305.00485v2) | Short alternating block shears can represent a general special-linear operator. | Its construction uses inverses over a field. Neither dyadic coefficients nor cheap native block operators follow from the six-factor count. Deferred until an explicit small legal block factorization replaces paid work. | +| [Buhrman–Cleve–Koucký–Loff–Speelman, catalytic space](https://eccc.weizmann.ac.il/report/2014/053/) | Arbitrary initial workspace must return exactly. | Tested a joint-boundary move allowing helpers to become zero-width catalysts and removing their productive credit. No improving move was found in the declared single-label experiment. The accepted move keeps all helpers productive. No catalytic-space upper bound is transferred. | +| [Robere–Zuiddam, amortized/catalytic circuits](https://eccc.weizmann.ac.il/report/2021/035/) | Optimize the cost against the complete resource ledger. | Repeated copies of one function on one input do not supply independent productive fields. Retained as a discipline for the objective, not a source of output credit. | + +The useful change of direction was to leave the exhausted p7 idle-mask model, +read the newly published #4440/#4441 constructions, and search new subspaces +of their actual native word. This produces a changed paid profile. No claim +is made that any cited author supplied this contact or the new κ. + +## Bounded discovery and limitations + +Before the new upstream sources appeared, bidirectional coordinate retiming, +75 commuting-ADD combinations (108 removed records), and 1,320 paired +same/complement rank-one idle-projector experiments found no paid improvement. +Those are local-only exploratory results; they are not global barriers. + +Starting from #4441's exact native patch, the optional lattice optimizer tries +joining frames with each binary line and intersecting them with each binary +hyperplane, with paired helper-boundary decisions and exact nesting checks. +At the discovery exponent 1−0.00300106 it finds one move: intersect frame 732 +with the hyperplane orthogonal to binary vector 2, at phase B scalar 480. +Its floating objective is only a ranking aid. `verify.py` does not run a +solver or trust the objective; it executes the explicit PATCH.json. + +Subsequent exploratory expansion over 111,887 distinct old/new candidate +spaces, and the same expansion after scalar folding, found no additional +improving single-label move in that particular program. Simultaneous +multiple-label moves, changed scalar graphs and other providers remain open. +No global or exact search-optimality claim is made. + +Apache-2.0 for these notes. Papers retain their own copyrights and licenses. diff --git a/research/native-lattice-retiming/NATIVE-RESULT.json b/research/native-lattice-retiming/NATIVE-RESULT.json new file mode 100644 index 0000000000..b5c0af78f1 --- /dev/null +++ b/research/native-lattice-retiming/NATIVE-RESULT.json @@ -0,0 +1,816 @@ +{ + "controls": { + "global_phase_only_corruption_rejected": true, + "wrong_scalar_frame_rejected": true + }, + "helpers": { + "4": 26, + "5": 2, + "7": 29, + "8": 42, + "9": 309 + }, + "native": { + "backward": { + "arbitrary_owned_C0_cleared": true, + "independent_interpreter": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158168, + "direction": "backward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2254, + "2": 514, + "3": 444, + "4": 103, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290 + }, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "l1_witness": { + "event": 6396, + "role": [ + "L", + 225 + ] + }, + "max_denominator": 64, + "max_formal_prefix_l1": "169", + "paid_profile": { + "1": 2254, + "2": 514, + "3": 444, + "4": 103, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290, + "real_scalar_allowance": 158168, + "scalar_frames_checked": true + }, + "forward": { + "arbitrary_owned_C0_cleared": true, + "independent_interpreter": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158120, + "direction": "forward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2254, + "2": 514, + "3": 444, + "4": 103, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290 + }, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "l1_witness": { + "event": 19099, + "role": [ + "L", + 224 + ] + }, + "max_denominator": 32, + "max_formal_prefix_l1": "457", + "paid_profile": { + "1": 2254, + "2": 514, + "3": 444, + "4": 103, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290, + "real_scalar_allowance": 158120, + "scalar_frames_checked": true + } + }, + "new_physical_edges": [ + { + "new_basis": [ + 45, + 133, + 336 + ], + "old_basis": [ + 133, + 45 + ], + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 8, + 16, + 33, + 64, + 129, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 2 + ], + "matrix_rows": [ + 336, + 1, + 2, + 4, + 8, + 272, + 32, + 320, + 128 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 80, + 0, + 80, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 8, + 16, + 33, + 64, + 129, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 3, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 336, + 1, + 2, + 4, + 8, + 272, + 32, + 320, + 128 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 80, + 0, + 80, + 0, + 0 + ] + } + } + } + }, + { + "new_basis": [ + 45, + 133, + 336 + ], + "old_basis": [ + 336, + 45 + ], + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 9, + 16, + 32, + 64, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 2, + 0 + ], + "matrix_rows": [ + 133, + 129, + 2, + 132, + 8, + 16, + 32, + 64, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 5, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 9, + 16, + 32, + 64, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 0, + 0, + 0, + 0, + 2, + 0 + ], + "matrix_rows": [ + 133, + 129, + 2, + 132, + 8, + 16, + 32, + 64, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 5, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new_basis": [ + 258, + 128, + 64, + 33, + 18, + 9, + 5 + ], + "old_basis": [ + 45, + 133, + 336 + ], + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 16, + 40, + 69, + 129, + 258, + 4, + 8, + 5, + 10 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 10, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 3, + 2, + 0, + 2, + 2, + 1 + ], + "matrix_rows": [ + 172, + 16, + 36, + 338, + 13, + 18, + 128, + 160, + 256 + ], + "offset": 438, + "phase": 2, + "quadratic_rows": [ + 12, + 322, + 1, + 9, + 64, + 0, + 274, + 0, + 322 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 16, + 40, + 69, + 129, + 258, + 4, + 8, + 5, + 10 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 10, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 1, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 172, + 16, + 36, + 338, + 13, + 18, + 128, + 160, + 256 + ], + "offset": 443, + "phase": 3, + "quadratic_rows": [ + 12, + 322, + 1, + 9, + 64, + 0, + 274, + 0, + 322 + ] + } + } + } + }, + { + "new_basis": [ + 258, + 133, + 66, + 45, + 16 + ], + "old_basis": [ + 45, + 133, + 336 + ], + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 16, + 32, + 66, + 128, + 1, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 320, + 338, + 1, + 322, + 4, + 8, + 256, + 32, + 128 + ], + "offset": 64, + "phase": 3, + "quadratic_rows": [ + 0, + 18, + 0, + 0, + 66, + 0, + 272, + 0, + 320 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 16, + 32, + 66, + 128, + 1, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 320, + 338, + 1, + 322, + 4, + 8, + 256, + 32, + 128 + ], + "offset": 66, + "phase": 0, + "quadratic_rows": [ + 0, + 18, + 0, + 0, + 66, + 0, + 272, + 0, + 320 + ] + } + } + } + } + ], + "paid": { + "1": 2254, + "2": 514, + "3": 444, + "4": 103, + "5": 40, + "8": 8 + }, + "status": "PASS_NEW_LATTICE_CONTACT_BOTH_ORIENTATIONS_ALL_COLUMNS" +} diff --git a/research/native-lattice-retiming/NOTICE.md b/research/native-lattice-retiming/NOTICE.md new file mode 100644 index 0000000000..e7add6c881 --- /dev/null +++ b/research/native-lattice-retiming/NOTICE.md @@ -0,0 +1,16 @@ +# Attribution + +New work prepared for zxv with substantial OpenAI Codex assistance; Apache-2.0. +No subagents were used. Source files remain unchanged in their existing paths. + +The native supplier, reconstruction, arbitrary-input interpreters, complex +controller, higher-moment strictification and logarithmic compiler retain zxv's +PR4359/PR4433 lineage. Fresh-helper boundary retiming is Cinna Davis's PR4441; +query thinning and the stronger BIT interface are Cinna Davis's PR4440. +Mixed-target integer flow is Jacob Alan Sussman's Theorem 1G. The retained +native/Clifford/BIT sources preserve their original contributor notices, +including DreamingOfClouds, eumemic and their predecessor contributions. + +The optional min-cut discovery code adapts PR4441's Apache-2.0 floating Dinic +implementation. Its new moves act on the subspace lattice. The mathematical +claim depends on the explicit exact contact, not the optimizer. diff --git a/research/native-lattice-retiming/PATCH.json b/research/native-lattice-retiming/PATCH.json new file mode 100644 index 0000000000..be818ab439 --- /dev/null +++ b/research/native-lattice-retiming/PATCH.json @@ -0,0 +1,8 @@ +{ + "phase": "B", + "scalar_ordinal": 480, + "old_frame": 732, + "old_basis": [258, 133, 82, 45], + "new_basis": [45, 133, 336], + "forward_gate": ["add", ["L", 90], ["L", 253], 1, 1] +} diff --git a/research/native-lattice-retiming/PROOF.md b/research/native-lattice-retiming/PROOF.md new file mode 100644 index 0000000000..c966d4df2c --- /dev/null +++ b/research/native-lattice-retiming/PROOF.md @@ -0,0 +1,96 @@ +# Native contact and conditional transfer + +## Scope and source boundary + +Source PR4441 is fixed at `5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39`, +including PR4440 at `40e22a83ed660d3d6074c4f2dbf14bfb621eee51`. +Their conditional contracts are retained. No selected result, independent +scientific acceptance or universal implementation hypothesis is promoted. +The exact byte closure is SOURCES.json. New work stays local for user review. + +## One legal contact outside the predecessor frame menu + +Use PR4441's chronological word and all its boundary changes. A field with +logical value z and frame S holds C_S z. A paid nested transport from S to T +implements C_T C_S^-1, retaining z. At a common frame T an ADD is +C_T z_i + a C_T z_j = C_T(z_i + a z_j). Thus changing common frames while +keeping every contact legal preserves the entire formal logical program. +This is an induction over the actual instruction sequence, not a tensor power +of an equality between sums of matrices. + +The source forward ADD at phase B, persistent ordinal 480, is +`L90 += L253`. Its old frame is span(258,133,82,45). Set +S=span(45,133,336), the intersection with the hyperplane perpendicular to 2. +The generator checks strict inclusion. Both previous contacts lie in S; +both following contacts contain S. Resynthesis therefore uses only ascending +nested transports. All warp and owned-center contacts keep their actual +original gauges. The backward ADD is matched to the literal source dual, +then receives the same common frame. + +Two source interpreters execute both new words on 632 arbitrary persistent +input columns, plus an arbitrary owned-center entry column. The main shears +and all autonomous helper rows match exactly; C0 is cleared only at its legal +owned operations. Main and helper boundaries are unchanged from PR4441. +Four newly used edge types receive complete forward and conjugate Clifford +recipes; serialized decoding checks tableau and exact zero-state phase. +The old edges and unchanged helper normalizers retain their pinned evidence. +Wrong-contact and phase-only corruptions are rejected. + +At every permitted positive column multiplicity the same formal gauge +induction applies to the allowed generator lifts. This uses the retained +all-column/native contract, including the new fixed Clifford monomial +recipes. The finite checks do not independently prove that universal +implementation or the physical tape model. + +## Why the invoice improves + +The complete local change is + + P_new = P_old + [1] + [4] - [2] - [3]. + +No target, field count, scalar coefficient/order, query or center is removed. +For 0theta^p and 153^(v*C)<2^p. These are the exit/contraction +and initial-range conditions of PR4433's generalized majorant. With +kappa=.00300120 and d=(C-kappa)/7=1/350000000, the verifier finds +H=2299850000000 with (H+1)^160<2^(d*H). The previous grid value fails. +The same construction at kappa=.00300105 gives H=249900000000. + +Every expanded program is finite. Its complete raw nonrecursive record bound +is below 10^9, and the source explicit product, adapter, precision and stock +prescriptions apply to these new finite ranks and lists. Suspended instances +retain distinct center storage; no materialized gigantic program is claimed. +The BIT supplier remains the source stronger ordinary admission .0034 with +atom .004. Exact outer arithmetic passes all nine rows, 54 current predicates, +four guards and 63 legacy predicates at the new point. The same-kappa rank +comparison separately checks the complete current outer ledger. + +The conclusion is conditional on the retained native/all-column, +whole-job/owned-erasure, finite-precision, analytic, physical tape, prime and +exact-recovery contracts: T(n)=O(n*(log n)^(1-.00300120)). It is not an +unconditional theorem, formal proof or practical runtime claim. diff --git a/research/native-lattice-retiming/README.md b/research/native-lattice-retiming/README.md new file mode 100644 index 0000000000..8d4e9ca201 --- /dev/null +++ b/research/native-lattice-retiming/README.md @@ -0,0 +1,131 @@ +# A new native contact: conditional κ = 0.00300120 + +**Local for user review. Do not push, publish a PR or post Discussions.** + +A changed native paid profile raises the conditional multiplication saving to +**κ = 0.00300120** and specifies sufficient uniform rank +**`2^2299850000000`**. The κ gain over +[PR4441](https://github.com/CrocSwap/integer-mult-bounds/pull/4441) is modest: +`0.00000015` (about 0.005%). The exponent of its sufficient uniform rank falls +by **71.88×**. At PR4441's unchanged κ=0.00300105, the rank can instead be +**`2^249900000000`**, a **661.53×** exponent reduction. +These are sufficient mathematical template sizes, not practical speedups. + +This builds on zxv's selected [0.0023 construction](../kappa-0023-productive-jobs/README.md), +its [higher-moment/logarithmic compiler](../higher-moment-strictification/README.md), +and Cinna Davis's new query-thinning and fresh-helper constructions +([PR4440](https://github.com/CrocSwap/integer-mult-bounds/pull/4440), +[PR4441](https://github.com/CrocSwap/integer-mult-bounds/pull/4441)). +Both pending source heads are pinned; they are author-checked conditional +claims, not independently accepted frontier updates. The selected record stays +0.0023. The new work retains their native/all-column, owned-erasure, whole-job, +precision, analytic, fixed-tape, prime and exact-recovery premises. + +## The actual construction change + +At phase B, persistent scalar ordinal 480, the forward ADD is +`L90 += L253`. Its old common frame has basis `[258,133,82,45]`. +Replace it by the three-dimensional subspace with basis `[45,133,336]`. +It is the old space intersected with the hyperplane orthogonal to binary +vector 2. Apply the same frame change at the literal inverse-transpose ADD in +the backward word. Scalar order, coefficients, warp contacts, main boundaries, +helper boundaries and all eight complete centers remain those of PR4441. + +Direct ascending transports before and after the changed contact give: + +| Local resource | PR4441 | New word | +| --- | ---: | ---: | +| Paid rank 1 | 2253 | 2254 | +| Paid rank 2 | 515 | 514 | +| Paid rank 3 | 445 | 444 | +| Paid rank 4 | 102 | 103 | +| Paid rank 5 / rank 8 | 40 / 8 | 40 / 8 | +| Productive helper widths | 26×4, 2×5, 29×7, 42×8, 309×9 | same | + +Thus the net paid change is `H2+H3 → H1+H4`. For every real `0 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "87149999253/87500000000", + "fixed_halo_explicit_metadata_branch": "6737500001/87500000", + "new_BIT_row_stock_sublinear_in_active_group": "348949997009/350000000000", + "new_semantic_group_guard": "3/350000000" + }, + "margins": { + "boundary_algebraic_matrix": "367648398949577/122500000000000000", + "fused_gaussian": "367648396848731/122500000000000000", + "global_coordinate_router": "131303/43750000", + "group_bit_router": "45956093356091/15312500000000000", + "group_scans": "174999999/175000000", + "main_transform": "367648048949577/122500000000000000", + "microbox_face_corrections": "6737500001/87500000", + "polynomial_products": "349999999/350000000", + "sparse_union_movement": "50133273398949577/122500000000000000" + }, + "parameters": { + "a": "131303/43750000", + "b": "42017/14000000", + "beta": "349999997/350000000", + "bit_saving": "17/5000", + "cap_xi": "111383273048949577/122500000000000000", + "complex_uniform_saving": "525213/175000000", + "d": "1/350000000", + "epsilon": "349999999/350000000", + "kappa": "7503/2500000", + "lambda_": "99699879/100000000", + "lambda_prime": "348949577/350000000", + "layout": "1/350000000", + "q": "1050423/350000000", + "r0": "1/3500000000", + "stop": "1/350000000", + "tested_saving": "150061/50000000" + }, + "strict_checks": { + "actual_bit_above_effective": "17447/43750000", + "actual_logarithmic_gamma_guard": "1/350000000", + "actual_logarithmic_group_guard": "11116727476050423/61250000000000000", + "alpha_logarithm_absorption": "1/3500000000", + "boundary_algebraic_matrix_above_kappa": "1398949577/122500000000000000", + "cap_above_band": "50133273048949577/122500000000000000", + "cap_below_cell": "11116726601050423/122500000000000000", + "cap_below_phase_cell_power": "133616726951050423/122500000000000000", + "complex_above_effective": "1/350000000", + "complex_below_one_over_32": "395483/14000000", + "complex_endpoint": "1/175000000", + "epsilon_below_one": "1/350000000", + "epsilon_positive": "349999999/350000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "1396848731/122500000000000000", + "gaussian_above_main": "173949577/61250000000000000", + "global_coordinate_router_above_kappa": "1/87500000", + "global_gamma_power_slack": "9/3500000000", + "group_below_dimension": "1/175000000", + "group_bit_router_above_kappa": "218356091/15312500000000000", + "group_gauge_power_slack": "11116727458550423/61250000000000000", + "group_key_fits_record": "1/175000000", + "group_positive": "349999997/350000000", + "group_scans_above_kappa": "174474789/175000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "635114790400418148631/500000000000000000000000", + "lambda_above_internal": "1/700000000", + "lambda_above_sigma": "3/700000000", + "lambda_above_tau": "1/700000000", + "lambda_prime_above_lambda": "1/700000000", + "lambda_prime_above_leaf": "27957983/4900000000000000", + "leaf_saving_above_effective": "13957983/4900000000000000", + "main_transform_above_kappa": "1048949577/122500000000000000", + "membership_arithmetic_fits_record": "1/350000000", + "microbox_face_corrections_above_kappa": "1684309349/21875000", + "microbox_halo_volume": "27650000003/350000000", + "new_complex_uniform_saving_above_b": "1/350000000", + "new_semantic_guard_with_C1_one": "1/350000000", + "polynomial_products_above_kappa": "348949579/350000000", + "positive_layout_slack": "1/350000000", + "q_below_effective": "1/350000000", + "q_below_internal": "1/350000000", + "q_below_leaf": "27957983/4900000000000000", + "q_positive": "1050423/350000000", + "short_record_fallback": "13957983/14000000", + "source_axis_superpolynomial": "1/350000000", + "sparse_union_movement_above_kappa": "49765626398949577/122500000000000000", + "stop_below_one": "349999999/350000000", + "stop_positive": "1/350000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/350000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/350000000", + "union_tag_work_per_visit_fits_record": "3/350000000" + } + }, + "paid": { + "1": 44618, + "16": 448, + "2": 9766, + "24": 448, + "3": 8436, + "32": 448, + "4": 1957, + "40": 448, + "48": 448, + "5": 760, + "56": 448, + "64": 448, + "72": 448, + "8": 152 + }, + "rank_exponent_reduction": "472330/6571", + "rank_surplus": 800, + "raw_moment_margin": { + "lower": "0.005035901012260126500228750242", + "upper": "0.005035901012260126500228750243" + }, + "raw_root": [ + "3001239017/1000000000000", + "30012390173/10000000000000" + ], + "raw_root_scope": "Unique crossing on [0,.01]; no universal or global mechanism ceiling.", + "same_kappa_rank_exponent_reduction": "236165/357", + "same_predecessor_kappa_compiler": { + "H": 249900000000, + "N": "2^249900000000", + "eta": { + "lower": "0.000037402048244786272108248731", + "upper": "0.000037402048244786272108248732" + }, + "gap": "17/700000000", + "integer_exponent": 6069, + "logarithm_power": 160, + "theta": "15/16", + "uniform_saving": "2100837/700000000", + "word_materialized": false + }, + "same_predecessor_kappa_outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "174299987301/175000000000", + "fixed_halo_explicit_metadata_branch": "13475000017/175000000", + "new_BIT_row_stock_sublinear_in_active_group": "697899949153/700000000000", + "new_semantic_group_guard": "51/700000000" + }, + "margins": { + "boundary_algebraic_matrix": "735281032143319/245000000000000000", + "fused_gaussian": "735280996429957/245000000000000000", + "global_coordinate_router": "2100803/700000000", + "group_bit_router": "1470573892859047/490000000000000000", + "group_scans": "349999983/350000000", + "main_transform": "735275082143319/245000000000000000", + "microbox_face_corrections": "13475000017/175000000", + "polynomial_products": "699999983/700000000", + "sparse_union_movement": "100266531032143319/245000000000000000" + }, + "parameters": { + "a": "2100803/700000000", + "b": "105041/35000000", + "beta": "699999949/700000000", + "bit_saving": "17/5000", + "cap_xi": "222766525082143319/245000000000000000", + "complex_uniform_saving": "2100837/700000000", + "d": "17/700000000", + "epsilon": "699999983/700000000", + "kappa": "60021/20000000", + "lambda_": "199399773/200000000", + "lambda_prime": "348949607/350000000", + "layout": "17/700000000", + "q": "1050393/350000000", + "r0": "17/7000000000", + "stop": "17/700000000", + "tested_saving": "150061/50000000" + }, + "strict_checks": { + "actual_bit_above_effective": "279197/700000000", + "actual_logarithmic_gamma_guard": "17/700000000", + "actual_logarithmic_group_guard": "22233483842856681/122500000000000000", + "alpha_logarithm_absorption": "17/7000000000", + "boundary_algebraic_matrix_above_kappa": "23782143319/245000000000000000", + "cap_above_band": "100266525082143319/245000000000000000", + "cap_below_cell": "22233468967856681/245000000000000000", + "cap_below_phase_cell_power": "267233474917856681/245000000000000000", + "complex_above_effective": "17/700000000", + "complex_below_one_over_32": "988709/35000000", + "complex_endpoint": "17/350000000", + "epsilon_below_one": "17/700000000", + "epsilon_positive": "699999983/700000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "23746429957/245000000000000000", + "gaussian_above_main": "2957143319/122500000000000000", + "global_coordinate_router_above_kappa": "17/175000000", + "global_gamma_power_slack": "153/7000000000", + "group_below_dimension": "17/350000000", + "group_bit_router_above_kappa": "59392859047/490000000000000000", + "group_gauge_power_slack": "22233483545356681/122500000000000000", + "group_key_fits_record": "17/350000000", + "group_positive": "699999949/700000000", + "group_scans_above_kappa": "697899231/700000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "635039790400418148631/500000000000000000000000", + "lambda_above_internal": "17/1400000000", + "lambda_above_sigma": "51/1400000000", + "lambda_above_tau": "17/1400000000", + "lambda_prime_above_lambda": "17/1400000000", + "lambda_prime_above_leaf": "1188214303/24500000000000000", + "leaf_saving_above_effective": "593214303/24500000000000000", + "main_transform_above_kappa": "17832143319/245000000000000000", + "membership_arithmetic_fits_record": "17/700000000", + "microbox_face_corrections_above_kappa": "53897899333/700000000", + "microbox_halo_volume": "55300000051/700000000", + "new_complex_uniform_saving_above_b": "17/700000000", + "new_semantic_guard_with_C1_one": "17/700000000", + "polynomial_products_above_kappa": "43618703/43750000", + "positive_layout_slack": "17/700000000", + "q_below_effective": "17/700000000", + "q_below_internal": "17/700000000", + "q_below_leaf": "1188214303/24500000000000000", + "q_positive": "1050393/350000000", + "short_record_fallback": "34894959/35000000", + "source_axis_superpolynomial": "17/700000000", + "sparse_union_movement_above_kappa": "99531273782143319/245000000000000000", + "stop_below_one": "699999983/700000000", + "stop_positive": "17/700000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "51/700000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "51/700000000", + "union_tag_work_per_visit_fits_record": "51/700000000" + } + }, + "status": "PASS_CONDITIONAL_NEW_NATIVE_PROFILE_KAPPA", + "strictification": { + "alpha": { + "lower": "0.999999980480394484617151340349", + "upper": "0.999999980480394484617151340350" + }, + "cutoff": 18, + "delta": { + "lower": "0.977253011855658562221385892786", + "upper": "0.977253011855658562221385892787" + }, + "floor": 22, + "gamma": { + "lower": "0.981971726999571315878434078558", + "upper": "0.981971726999571315878434078559" + }, + "limits": [ + "999999981/1000000000", + "491/500", + "391/400" + ], + "normalized_paid_upper": "3135316342855047938216186285366284791836015552731567401908176734930110521667998541808860782674464246329116429895882753096247698522148271859666641784228677573912605332725923383934714825294597676931624212032514027646967981541336965729076185554268027233444327337403745878243356820959932112007771549864881590155015123496432209395021364448015796884438028569244657405717369951884743365972882095120039957983925379611291360772632665217708326491914268771819562848029846703500646180491671401882021101698766069617361586201262698776684351995258277190425359783195465694122176833672706484066530574724789787037479061017911116773108073612235843989560762616998581715509178001466468362876164703345435291409263816689904692103757941883488341058980494142712686923568812288022949192890478433946276536436589153790091599648369106702773634555281575360964032314712840386529515907102227717937795524446796747828703981436724132739380841411013441416769926025052267538328282156106210906013225055943965375562532068983730967116286827198591247798727678176171320478590738500846420117865786648859883120410371898612074031256962522241496076154923725770848767431043120528509433496714324101025959590085951574021714319434271053115042416232189788263853499205089931368330261666401396910361932147924932944049888383159214229752743917428741596819317242725132712760528603789131532630741472925548561970849762668570817110437699349242714467130025311116618881358860815044369352216933087978747203390374142945600672289781753394274808328461504479642084553107824308868694078844054600750174201186469373656303128692027810576278159672148330996943494335356428296005636709069876376626933852810296702680886721507369314046399539101605976615201231427346183584818214127701391923728250913847612146632050052126755457091296857078080483746571485029373221974027408859524785238239130664547070069062887791736006969711830300497542975648628304802085160737580120878371177685768802133093055833042983690068619665100866536539147891836775462897136439867703923989275080988185809322290236782727815805504224638071293970925407386829055785555936017618119880456302458931410718717523322804435169311032474465174265268263099422925367321268723174472263506975656429644591851528543559670335484908199131423006788263629803652987/3135325528854913035113346724853144051552102259356465975465195756269284493200158883437639560729811317502778741665335773348010541036368854326255535712764450586037113873286263239677927235348235120600546751065096192000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "power": 675, + "tested": "150061/50000000", + "u": "3/25" + }, + "targets": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 494, + "41": 448, + "49": 448, + "5": 38, + "57": 448, + "65": 448, + "7": 551, + "73": 448, + "8": 798, + "9": 5871 + } +} diff --git a/research/native-lattice-retiming/SOURCES.json b/research/native-lattice-retiming/SOURCES.json new file mode 100644 index 0000000000..5378362135 --- /dev/null +++ b/research/native-lattice-retiming/SOURCES.json @@ -0,0 +1,282 @@ +{ + "base_commit": "28f58f6f9b72ddfe7aa5b986d1b678356c4e6350", + "files": [ + { + "git_blob": "686c36fb19680db327f797ebdfe612487d8c53f8", + "path": "research/fresh-helper-boundary/ARITHMETIC-RESULT.json", + "sha256": "5d25fec9ac4b036c93846a50dccfa4af030e2982f5cec02e28702193bf157cf7", + "usage": "input" + }, + { + "git_blob": "45744fedd0e28967aa72586048b8bc0c72f419a9", + "path": "research/fresh-helper-boundary/CHANGES.json", + "sha256": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624", + "usage": "input" + }, + { + "git_blob": "e6fdb31624e4eb8c7c770bb4422cd07ea99ab152", + "path": "research/fresh-helper-boundary/NATIVE-RESULT.json.gz", + "sha256": "37d0848458b289eb50271c47adef6e74014ae30be6363d09394b2337b566b839", + "usage": "input" + }, + { + "git_blob": "e26608e20be115d28f8853a8c1a12bebfc8e8ec3", + "path": "research/fresh-helper-boundary/RESULT.json", + "sha256": "34163eeeef1cd712de457d7fd3b0435f98a12ac456b82256b078f33225456fbd", + "usage": "input" + }, + { + "git_blob": "0b40275502f4263a19905f4fb50e346a3629c712", + "path": "research/fresh-helper-boundary/SOURCES.json", + "sha256": "01998e9b86222d10811fc0114dcd5c946ff9e95025a7cacd00e67a3eefe543d0", + "usage": "input" + }, + { + "git_blob": "4822f04ae09d84a16e8fa8656a533e23fd4068f0", + "path": "research/fresh-helper-boundary/arithmetic.py", + "sha256": "212bae96d0ddcbc25076afe2589a47736c66b77420057f28c44c937ad087fc07", + "usage": "input" + }, + { + "git_blob": "1b36f6cb5f205c33bf48811e0b1b3621c55e8154", + "path": "research/fresh-helper-boundary/native.py", + "sha256": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29", + "usage": "input" + }, + { + "git_blob": "e434dbf7c68afa0390a307fd15f32348b0e87207", + "path": "research/fresh-helper-boundary/verify.py", + "sha256": "4c18851214400cf955e10565d89357029d9e765140233831472ce23f0c3ee7bf", + "usage": "input" + }, + { + "git_blob": "e223acd07a6b1f4f1c9f2778b8ea64d4b7a2be55", + "path": "research/fresh-helper-thinned/RESULT.json", + "sha256": "8e7db2fed5f4be6a7f944bc59e7942ccbcc3e6c36130b5671331540c183ada21", + "usage": "input" + }, + { + "git_blob": "0a736ca89e1eafb73a30e1f2589cc45e6b5f76c3", + "path": "research/higher-moment-strictification/README.md", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d", + "usage": "input" + }, + { + "git_blob": "d3b6149c5c1cca84c7c305f6e2e32c814e30777e", + "path": "research/higher-moment-strictification/vendor/check_ledger.py", + "sha256": "1dd56009986eb14dd6603c9193c7ad71dd45c7d005bf71c9cd3f916e66f54d98", + "usage": "input" + }, + { + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "path": "research/higher-moment-strictification/verify.py", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "usage": "input" + }, + { + "git_blob": "8b40135a84e7f0f0cd44bed69655801310b916a7", + "path": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "sha256": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85", + "usage": "input" + }, + { + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "path": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "usage": "input" + }, + { + "git_blob": "5a55034ec9e6185d981e16c28e1e2e455069e2cb", + "path": "research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "sha256": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7", + "usage": "input" + }, + { + "git_blob": "8c3e11b2408fa96eefa3ebe7952d1b11b90b772b", + "path": "research/kappa-function-composition/complex/prune_native.py", + "sha256": "f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257", + "usage": "input" + }, + { + "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e", + "path": "research/kappa-rebuild/architecture/mixed_target_probe.py", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a", + "usage": "input" + }, + { + "git_blob": "fbe6da7241357d89cf5c55b2e7ce2d0d046be32a", + "path": "research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json", + "sha256": "edb273f59a27356ad89f38791590c3c806b228c3510eb508e01e89f2caba95ef", + "usage": "input" + }, + { + "git_blob": "e8c5e4f077fea0bef355e6c3013c7f252d3606cf", + "path": "research/kappa-rebuild/bit/BIT-P3-NATIVE-BINDING.json", + "sha256": "9ece46fdfda6182e757e9a3b1f513fb3d029d730f3bafdcd6ed59180a14175b0", + "usage": "input" + }, + { + "git_blob": "a58774e237c9362869a60a22bda35be09fb85872", + "path": "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "sha256": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443", + "usage": "input" + }, + { + "git_blob": "6a139eedbc1015c13df6f2a4333e1a89b5edd18d", + "path": "research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json", + "sha256": "2f69a19f417c0e0d141c180f9b2fae3d358391b9a230f5848ee07c45450e70bf", + "usage": "input" + }, + { + "git_blob": "f4c4082d89969ea311219d9af8013082d599f6f1", + "path": "research/kappa-rebuild/bit/bit_native_binding.py", + "sha256": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7", + "usage": "input" + }, + { + "git_blob": "cb0cff7c8be5f38f2ee52201d9d0907f9dfd7947", + "path": "research/kappa-rebuild/bit/complex_controller_factor.py", + "sha256": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497", + "usage": "input" + }, + { + "git_blob": "9c7a8bd5d3ae4c19952648c815031858d6627b96", + "path": "research/kappa-rebuild/bit/mixed_productive_bit.py", + "sha256": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e", + "usage": "input" + }, + { + "git_blob": "f97a23d7d21bd7f79c9d0cb14d8c6b44fddd3f23", + "path": "research/kappa-rebuild/complex/FULL-IDENTITY.md", + "sha256": "c4aa88c4943ef041e9542c519b7600ecf26ed6caff92558fdb07ac88ace64c17", + "usage": "input" + }, + { + "git_blob": "c6edcbdc43bf36bb11201235027d0ec170d07fc8", + "path": "research/kappa-rebuild/complex/full-identity-certificates/RESULT.json", + "sha256": "943d5fad2fc529f470df05a35446e07ecaef7344abfce450d2c2eb2c9b3798f6", + "usage": "input" + }, + { + "git_blob": "4a8c4ed26e53a72362d571c972e65aff546be784", + "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61", + "usage": "input" + }, + { + "git_blob": "b46d44c6ee624968dd57be928b0c15d9d45f3b2c", + "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "sha256": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39", + "usage": "input" + }, + { + "git_blob": "7f84894efc309546a903d314c7ac1473e7f594a8", + "path": "research/kappa-rebuild/complex/native_extensions.py", + "sha256": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3", + "usage": "input" + }, + { + "git_blob": "a55ae0ce78a1861965f899a82604b276260f636c", + "path": "research/kappa-rebuild/complex/power_two_balance.py", + "sha256": "76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424", + "usage": "input" + }, + { + "git_blob": "78a7b1b0e6e43a1347fb361f45c6e0eaff8dd27b", + "path": "research/kappa-rebuild/complex/rebuild_native.py", + "sha256": "f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5", + "usage": "input" + }, + { + "git_blob": "0f3a4067a4b4e20d0e6ca0f84f41851c5168f76d", + "path": "research/kappa-rebuild/transfer-audit/p3_native_audit.py", + "sha256": "5504a55a50546418d10c522984438cdeedb44993f7c1dab7bd4aa1ae0515d902", + "usage": "input" + }, + { + "git_blob": "04c7ef620e760cc8f1764bbf0ccd7f32c6a5bd86", + "path": "research/pr4359-p7-padding/P7-FACTOR.json", + "sha256": "6f96f6be5d8441f71cbe6ebb1657c69b543eb085b848b92b591b7ac01d6e6598", + "usage": "input" + }, + { + "git_blob": "8ecfd3e4d0bcb449ecb1e150c4f1f4fbb39ca656", + "path": "research/pr4359-p7-padding/TENSOR.md", + "sha256": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3", + "usage": "input" + }, + { + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "usage": "input" + }, + { + "git_blob": "8d2d96e3998254c2333c43fe47cdfd074cbd811e", + "path": "research/pr4359-p7-padding/native_inventory.py", + "sha256": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32", + "usage": "input" + }, + { + "git_blob": "89c400d5970024b3debe870c36ce43889beed001", + "path": "research/query-thinned-controllers/BIT-CONTROLLER.json", + "sha256": "39ac84fb848b908f7ba051fae4556d507900c421dc5d23501a9c0cb1d61fd08d", + "usage": "input" + }, + { + "git_blob": "39318f6ad9baf0838a274ca1042b1e3ba0e74bf9", + "path": "research/query-thinned-controllers/COMPLEX-CONTROLLER.json", + "sha256": "bf1143325d8380fab40cd5a85449f9a5412f0340deba7f4693714c92ae320088", + "usage": "input" + }, + { + "git_blob": "e0695152c98d727edfd0d2034b58a1c7e8682c0c", + "path": "research/query-thinned-controllers/RESULT.json", + "sha256": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f", + "usage": "input" + }, + { + "git_blob": "0f061c87ff87c43ff1ea0fc418582e9ccea3bc1d", + "path": "research/query-thinned-controllers/SOURCES.json", + "sha256": "74b73563d9f78a4562d376b6f33528d652e41097f65747667f112a3e1fa81d29", + "usage": "input" + }, + { + "git_blob": "d4557e08cfb9fe57cc1ae4024705a72dc95f3583", + "path": "research/query-thinned-controllers/controller.py", + "sha256": "8b462d660487b1be4940357c4c7522967b1bfaede3c02b1c66109b85acae0fd2", + "usage": "input" + }, + { + "git_blob": "f1114036fff66f57014e5c1256141fb78ff4c4a9", + "path": "research/query-thinned-controllers/verify.py", + "sha256": "07dea601d6bbaa4d90e576f20c8607c37fb01e8778c798d919fa9df435049950", + "usage": "input" + }, + { + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "usage": "input" + }, + { + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "path": "docs/research/agent-task-catalog.json", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96", + "usage": "provenance" + }, + { + "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40", + "path": "certificates/selected-result.json", + "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9", + "usage": "provenance" + }, + { + "git_blob": "2fe84a7b30b1e26e60ce0ec4775894eb1831c5d6", + "path": "autoresearch.md", + "sha256": "d16f0d3bb4d4b213d06c128db6d6460b0fe9ec1ac5a6c1ea1febf1db40e7b60d", + "usage": "provenance" + } + ], + "schema_version": 1 +} diff --git a/research/native-lattice-retiming/TASK.json b/research/native-lattice-retiming/TASK.json new file mode 100644 index 0000000000..5c9dd61a4c --- /dev/null +++ b/research/native-lattice-retiming/TASK.json @@ -0,0 +1,123 @@ +{ + "actual_scope": "Build a changed native frame contact beyond PR4441, then completely pay tensor completion, finite uniform compilation and the integer-multiplication consumer.", + "ai_assistance": "Substantial OpenAI Codex assistance; no subagents.", + "author": "zxv, with substantial OpenAI Codex assistance", + "base_commit": "28f58f6f9b72ddfe7aa5b986d1b678356c4e6350", + "bottleneck_link": "New subspaces outside the predecessor frame menu can change the raw paid profile while exact native endpoints and all helper outputs stay fixed.", + "budget_minutes": 60, + "evidence": "Explicit one-contact native patch; two all-column replays in both orientations, new absolute-phase transports, complete changed invoice, two moment engines, both paid tails, finite ranks and all outer predicates.", + "open_questions": [ + { + "blocked_by": "No global optimization certificate; keep all fixed contacts and exact replay.", + "first_step": "Start from PATCH.json and test one fully charged coordinated new-label move.", + "question": "Can simultaneous moves to different frame labels improve the full invoice further?", + "why_it_matters": "A fixed-frame-menu optimum does not cover the subspace lattice." + }, + { + "blocked_by": "No complete restoration and frame-transfer invoice.", + "first_step": "Price the Dumas\u2013Grenet prepare/accumulate/distribute pattern through actual Fourier frames.", + "question": "Can a multi-target accumulating native interface share a paid query?", + "why_it_matters": "This could yield a larger change than local retiming." + }, + { + "blocked_by": "These universal contracts remain premises.", + "first_step": "Audit a named caller and retained hypothesis in PR4359/4440/4441.", + "question": "Do the inherited all-column, precision and tape contracts survive independent scientific review?", + "why_it_matters": "Exact finite arithmetic is not unconditional or formal acceptance." + } + ], + "original_card": { + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "allowed_variations": [ + "One provider-registry, dispatch, native-closure or admission-predicate obligation; separate branches must name distinct coverage." + ], + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "existing_checks": [ + { + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "status": "author-checked" + }, + { + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "scope": "PR #3801: successor scatter-boundary decision package.", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "status": "author-checked" + } + ], + "first_experiment": "Pin the provider registry, four native source closures and dispatch. Make a bounded acceptance coverage map or one registry adapter preserving every inherited admission predicate and rejection control (including an omitted fourth provider). Record remaining ordinary/outer obligations and a resource estimate before heavy execution. Stop at unresolved source/caller dependencies; no selected-result promotion from a local pass.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4088 Scope and Open next questions: local words, native receipts and literal fill do not include a rerun of the mixed four-provider ordinary/outer engine. #3801 is the newer scatter-boundary decision; do not restart #2977 as if untouched.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "id": "supplier-boundary-audit", + "methods": [ + "Trace one hypothesis through the source, checker and complete caller.", + "Construct one semantically invalid but superficially well-formed fixture and test rejection." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics", + "4088", + "3801", + "staged544-mixed-fourth-entry", + "scatter-boundary-decision" + ], + "question": "Can the #4088 four-provider dispatch satisfy the complete ordinary/outer admission contract?", + "scope_change_triggers": [ + "Reporting the historical timing-only diagnostic as a new current acceptance bug.", + "Calling a malformed mutant a failure of the selected construction, or importing an opt-in repair without testing the exporter boundary.", + "Running another root enclosure instead of validating dispatch or weakening an inherited predicate to make mixed admission pass." + ], + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/scatter-boundary-decision/README.md" + ] + }, + "outcome": "completed", + "overlap": { + "checked_at_utc": "2026-10-21T20:51:25Z", + "discussion_records": 3289, + "limits": "Sparse local coverage; no arbitrary diffs or closed remote PR-body coverage; no novelty certificate. No public participation authorized for this successor.", + "local_HEAD_notes": 5739, + "local_notes_searched": 23, + "open_pr_bodies": 301, + "remote_pagination_complete": true + }, + "priority_revision": 7, + "publication_policy": "User explicitly requested no publication of this successor. No push, PR or Discussion post.", + "resource_budget": "Single-process bounded controller arithmetic, under a few minutes per screen; no Lean, Docker, concurrent artifact replay or native historical suites.", + "schema_version": 1, + "scope_change_reason": "The explicit user requests a genuine kappa improvement, keeps this successor local, and asks for a literature pivot if stuck. Newly published PR4440/4441 change the useful starting model.", + "scope_decision": "Stop this finite model screen. No new hill-climbing construction step found. Keep the root-retuning witness as a separately labelled diagnostic, and require changed words/interfaces/providers/stock for the next actual climb.", + "scope_status": "changed", + "stop_rule": "Freeze a strictly improving exact paid profile, retain all inherited native and consumer obligations, run complete relevant checks, and leave the result local for user review.", + "task_id": "supplier-boundary-audit", + "upstream_checkpoint": { + "checked_at_utc": "2026-10-21T20:31:00Z", + "commit": "2a13eb1827784206202db90e5dc8327cf8a250db", + "pending_sources": { + "PR4440": "40e22a83ed660d3d6074c4f2dbf14bfb621eee51", + "PR4441": "5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39" + }, + "priority_revision": 7 + } +} diff --git a/research/native-lattice-retiming/VALIDATION.md b/research/native-lattice-retiming/VALIDATION.md new file mode 100644 index 0000000000..3e26da177c --- /dev/null +++ b/research/native-lattice-retiming/VALIDATION.md @@ -0,0 +1,26 @@ +# Validation + +Local only, CPython 3.12.8 on macOS arm64, 21 October 2026. + +- Explicit receipt generation: **PASS**. Two native interpreters replay both + orientations, 632 arbitrary persistent columns and owned-center erasure. +- Four new edge types: forward and conjugate serialized Clifford recipes + decode with the right rank, tableau and absolute zero-state phase. +- Complete p17 Laurent/source word and full changed invoice: **PASS**. +- Two exact interval engines, both paid tails, the two finite uniform ranks, + 54+4 current outer predicates, nine-row agreement and 63 legacy predicates: + **PASS**. Wrong contact, phase-only, short-product-bound and outer mutants + reject at their intended gates. +- Optional C++20 discovery: **PASS**, reproducing exactly phase B contact 480 + and the new span `[0,45,133,168,336,381,469,504]`. + +Registered replay, committed-byte preflight and Git-free optimized replay are +recorded after the first committed package is validated. No hosted CI, Lean, +Docker, complete historical suite or independent scientific review is claimed. + +Source ancestry includes PR4440 head +`40e22a83ed660d3d6074c4f2dbf14bfb621eee51` and PR4441 head +`5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39`. SOURCES.json binds the exact +43 consumed source files; unchanged historical native/owned-query/analytic +contracts remain explicit premises. Pending-source acceptance is not inherited +from the reviewed .0023 or .00268647 checkpoints. diff --git a/research/native-lattice-retiming/VERIFY.json b/research/native-lattice-retiming/VERIFY.json new file mode 100644 index 0000000000..a0eb02eb26 --- /dev/null +++ b/research/native-lattice-retiming/VERIFY.json @@ -0,0 +1,69 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "checks": "Authenticate exact source bytes; replay both orientations and 632 arbitrary inputs with two native interpreters; decode all new physical edges with absolute phase; rebuild the unchanged p17 Laurent controller and changed full invoice; certify two-engine moments, both paid tails, finite compiler ranks, stronger BIT and all 54+4 current and 63 legacy outer predicates, with mutation controls.", + "timeout_seconds": 600 + } + ], + "inputs": [ + "research/fresh-helper-boundary/ARITHMETIC-RESULT.json", + "research/fresh-helper-boundary/CHANGES.json", + "research/fresh-helper-boundary/NATIVE-RESULT.json.gz", + "research/fresh-helper-boundary/RESULT.json", + "research/fresh-helper-boundary/SOURCES.json", + "research/fresh-helper-boundary/arithmetic.py", + "research/fresh-helper-boundary/native.py", + "research/fresh-helper-boundary/verify.py", + "research/fresh-helper-thinned/RESULT.json", + "research/higher-moment-strictification/README.md", + "research/higher-moment-strictification/vendor/check_ledger.py", + "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-causal-continuation/buffer-borrowing/verify_buffers.py", + "research/kappa-function-composition/complex/prune_native.py", + "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/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "research/kappa-rebuild/complex/native_extensions.py", + "research/kappa-rebuild/complex/power_two_balance.py", + "research/kappa-rebuild/complex/rebuild_native.py", + "research/kappa-rebuild/transfer-audit/p3_native_audit.py", + "research/native-lattice-retiming/NATIVE-RESULT.json", + "research/native-lattice-retiming/PATCH.json", + "research/native-lattice-retiming/RESULT.json", + "research/native-lattice-retiming/SOURCES.json", + "research/native-lattice-retiming/arithmetic.py", + "research/native-lattice-retiming/native.py", + "research/native-lattice-retiming/verify.py", + "research/pr4359-p7-padding/P7-FACTOR.json", + "research/pr4359-p7-padding/TENSOR.md", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/pr4359-p7-padding/native_inventory.py", + "research/query-thinned-controllers/BIT-CONTROLLER.json", + "research/query-thinned-controllers/COMPLEX-CONTROLLER.json", + "research/query-thinned-controllers/RESULT.json", + "research/query-thinned-controllers/SOURCES.json", + "research/query-thinned-controllers/controller.py", + "research/query-thinned-controllers/verify.py", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py" + ], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/native-lattice-retiming/arithmetic.py b/research/native-lattice-retiming/arithmetic.py new file mode 100644 index 0000000000..ea5fb38dfb --- /dev/null +++ b/research/native-lattice-retiming/arithmetic.py @@ -0,0 +1,136 @@ +"""Complete changed invoice, paid tails, rank and outer consumer. +Apache-2.0. Substantial OpenAI Codex assistance. Credits: PR4359/4433, +Cinna Davis PR4440/4441, and Jacob Alan Sussman's mixed-target flow. +""" +from collections import Counter +from fractions import Fraction as Q +from pathlib import Path +import ast +import json +import native + +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +KAPPA,TESTED=Q('.00300120'),Q('.00300122') +LOW,HIGH=Q('.0030012390170'),Q('.0030012390173') +need=native.need + +def encoded(x): + if isinstance(x,Q):return str(x) + if isinstance(x,dict):return {str(k):encoded(v) for k,v in x.items()} + if isinstance(x,(tuple,list)):return [encoded(v) for v in x] + return x + +def uniform(E,v,theta,power,kappa): + t=1-TESTED + eta=E.scale(E.power(153,-v*TESTED),t) + need(18**16<22**15 and 2*(18**v)**16<=(153**v)**15,'Strict shifted logarithm contraction') + need(eta[0]>theta**power and E.power(153,v*TESTED)[1]<2**power,'Both logarithmic induction conditions') + gap=(TESTED-kappa)/7 + step=gap.denominator + def passes(j):return (step*j+1)**power<2**(gap.numerator*j) + lo,hi=1,2 + while not passes(hi):lo,hi=hi,2*hi + while hi-lo>1: + mid=(lo+hi)//2 + if passes(mid):hi=mid + else:lo=mid + H=step*hi + need(H>8*v and passes(hi) and not passes(hi-1),'Effective winning integer rank and prior-grid control') + return dict(theta=theta,logarithm_power=power,eta=E.display(eta),gap=gap, + uniform_saving=TESTED-gap,H=H,N='2^'+str(H),integer_exponent=gap.numerator*hi, + word_materialized=False) + +def legacy(params,outer): + source=ROOT/'research/higher-moment-strictification/vendor/check_ledger.py' + parsed=ast.parse(source.read_bytes()) + fn=next(n for n in parsed.body if isinstance(n,ast.FunctionDef) and n.name=='ledger') + constants=[n for n in parsed.body if isinstance(n,ast.Assign) and any(isinstance(t,ast.Name) and t.id.startswith('KAPPA_') for t in n.targets)] + d=params['d'];eps,beta,q,a=(params[k] for k in ('epsilon','beta','q','a')) + grid=10**10;backoff=Q((eps*q*grid).__floor__(),grid)-KAPPA + need(backoff>0,'Positive exact legacy grid backoff') + env={'Q':Q,'R0':params['r0'],'ZETA':Q(1,10**8),'SLACK':d,'STOP':d,'FLOOR':grid,'BACKOFF':backoff, + 'EPS':eps,'BETA':beta,'THETA_POWER':Q(2),'HALO_POWER':48,'CORE_POWER':128,'STRASSEN_TAU':Q(45,16), + 'b':params['b'],'q':q,'a':a,'bit':params['bit_saving'], + 'online':Q('0.001730970419199163702738'),'old':Q('0.001730970419199163702738')} + exec(compile(ast.fix_missing_locations(ast.Module(body=constants+[fn],type_ignores=[])),'pinned legacy outer','exec'),env) + result=env['ledger']('native_lattice') + need(result['kappa']==KAPPA and result['margins']==outer['margins'],'Nine outer rows agree independently') + need(len(result['strict_checks'])==63 and all(x>0 for x in result['strict_checks'].values()),'All 63 legacy predicates') + return dict(checks=result['strict_checks'],grid=grid,backoff=backoff) + +def run(local): + E=native.load(ROOT/'research/higher-moment-strictification/verify.py','lattice_exact_intervals') + C=native.load(ROOT/'research/query-thinned-controllers/controller.py','lattice_query_controller') + word=native.read(ROOT/'research/query-thinned-controllers/COMPLEX-CONTROLLER.json') + need(json.loads(json.dumps(C.run('complex',17,8)))==word,'Exact unchanged source physical word and Laurent boundaries') + H={int(k):v for k,v in local['helpers'].items()};N={int(k):v for k,v in local['paid'].items()} + T,P=Counter(),Counter();full=thin=idle=0 + for e in word['physical_events']: + if e[0]=='LOCAL':full+=1;T.update(H);P.update(N) + elif e[0]=='QUERY_SHEAR':thin+=1;P[1]+=112 + elif e[0]=='IDLE':P[8*len(e[2])]+=224;idle+=224 + for term in word['diagonal']:T[1+8*sum(term[1:])]+=112 + need((full,thin,idle)==(19,16,3584),'Every native, query and whole idle') + predecessor=native.read(ROOT/'research/fresh-helper-thinned/RESULT.json') + oldT=Counter({int(k):v for k,v in predecessor['targets'].items()});oldP=Counter({int(k):v for k,v in predecessor['paid'].items()}) + need(T==oldT and P==oldP+Counter({1:19,4:19})-Counter({2:19,3:19}),'Independent complete profile substitution') + need(sum(T.values())==11560 and sum(P.values())==69273,'Complete field and call counts') + need((sum(r*n for r,n in T.items()),sum(r*n for r,n in P.items()))==(260798,259998),'Unchanged rank masses and surplus 800') + def margin(c): + a,b=E.moment(T,1-c),E.moment(P,1-c) + return a[0]-b[1],a[1]-b[0] + need(margin(LOW)[0]>0 and margin(HIGH)[1]<0,'Exact changed raw-root bracket') + # Positive decreasing on [0,.01], sufficient to isolate this first root. + derivative=sum(n*E.mul(E.power(r,Q('.99')),E.log_bounds(r))[0] for r,n in T.items())-sum(n*E.mul(E.power(r,1),E.log_bounds(r))[1] for r,n in P.items()) + need(derivative>0,'Strictly decreasing throughout C in [0,.01]') + other=native.load(ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','lattice_other_intervals') + tl,th=other.moment(T,TESTED);pl,ph=other.moment(P,TESTED) + t=1-TESTED;target=E.moment(T,t);paid=E.moment(P,t) + need(tl>ph and max(tl,target[0])<=min(th,target[1]),'Second exact raw moment engine') + alpha=E.divide(paid,target);u=Q(3,25);v=675;c=18;b=22 + gamma=E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target)) + delta=E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,TESTED),target)) + ag,g,d=Q(19,10**9),Q(491,500),Q(391,400) + need(t+u>=1 and alpha[1]<1-ag and gamma[1]1,'Short-product bound negative control') + rank=uniform(E,v,Q(15,16),160,KAPPA) + same=uniform(E,v,Q(15,16),160,Q('.00300105')) + bit=native.read(ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT'] + atom=Q(bit['atom']);ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599');admitted=Q(bit['admitted']) + need(atom==Q('.004') and atom>ordinary>admitted>TESTED and atom<1-ordinary,'Retain the entire stronger ordinary BIT admission') + gap=(TESTED-KAPPA)/7 + params=dict(kappa=KAPPA,tested_saving=TESTED,complex_uniform_saving=rank['uniform_saving'], + b=KAPPA+5*gap,a=KAPPA+4*gap,q=KAPPA+3*gap,bit_saving=admitted, + epsilon=1-gap,beta=1-3*gap,r0=gap/10,stop=gap,layout=gap,d=gap) + L=native.load(ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','lattice_outer') + 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,'Full current consumer predicates') + need(all(x>0 for group in ('strict_checks','functional_checks') for x in outer[group].values()),'Every current outer predicate') + oldchecks=legacy(params,outer) + source_kappa=Q('.00300105');sg=(TESTED-source_kappa)/7 + sp=dict(kappa=source_kappa,tested_saving=TESTED,complex_uniform_saving=same['uniform_saving'], + b=source_kappa+5*sg,a=source_kappa+4*sg,q=source_kappa+3*sg,bit_saving=admitted, + epsilon=1-sg,beta=1-3*sg,r0=sg/10,stop=sg,layout=sg,d=sg) + same_outer=L.ledger(sp);same_outer['functional_checks']['actual_new_BIT_stock_sublinear']=sp['beta']*(1-atom) + need(all(x>0 for group in ('strict_checks','functional_checks') for x in same_outer[group].values()),'Same-kappa full outer comparison') + controls={} + for name,patch in [('old_BIT',{'bit_saving':Q('.0027')}),('closed_uniform',{'complex_uniform_saving':params['b']}),('unfunded_kappa',{'kappa':TESTED}),('closed_epsilon',{'epsilon':Q(1)})]: + bad=L.ledger(dict(params,**patch));failed=[k for k,x in bad['strict_checks'].items() if x<=0];need(failed,'Reject '+name);controls[name]=failed + local_scalar=max(x['real_scalar_allowance'] for x in local['native'].values()) + routes=(sum(N.values())+2*408)*1000 + need(local_scalar+routes<10**7,'All unchanged scalar and changed physical route costs fit') + raw=19*10**7+16*1792+32*112*(len(word['physical_events'])+sum(len(word['boundaries'][k+'_program']) for k in ('left','right'))) + need(raw<10**9,'Complete nonrecursive raw budget') + return encoded(dict(status='PASS_CONDITIONAL_NEW_NATIVE_PROFILE_KAPPA',kappa=KAPPA,kappa_decimal='0.00300120', + gain_over_PR4441=KAPPA-Q('.00300105'),targets=dict(sorted(T.items())),paid=dict(sorted(P.items())), + rank_surplus=800,raw_root=[LOW,HIGH],raw_root_scope='Unique crossing on [0,.01]; no universal or global mechanism ceiling.', + derivative_negative_upper=-derivative,raw_moment_margin=E.display(margin(TESTED)), + strictification=dict(tested=TESTED,power=v,cutoff=c,floor=b,u=u,alpha=E.display(alpha),gamma=E.display(gamma),delta=E.display(delta),limits=[1-ag,g,d],normalized_paid_upper=bound), + compiler=rank,same_predecessor_kappa_compiler=same, + rank_exponent_reduction=Q(int(predecessor['compiler']['H']),rank['H']),same_kappa_rank_exponent_reduction=Q(int(predecessor['compiler']['H']),same['H']), + ordinary_BIT=bit,outer=outer,same_predecessor_kappa_outer=same_outer,legacy_outer=oldchecks,negative_controls=controls, + nonrecursive=dict(local_scalar=local_scalar,route_bound=routes,raw_upper=raw,budget=10**9))) diff --git a/research/native-lattice-retiming/discover-lattice.cpp b/research/native-lattice-retiming/discover-lattice.cpp new file mode 100644 index 0000000000..1798964ac4 --- /dev/null +++ b/research/native-lattice-retiming/discover-lattice.cpp @@ -0,0 +1,68 @@ +// Optional floating-point discovery, never a proof checker. Apache-2.0. +// Prepared with substantial OpenAI Codex assistance. +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +struct Arc{int v,rev;double cap;}; +struct Flow{vector> a;vector level,ptr;Flow(int n):a(n),level(n),ptr(n){};void edge(int u,int v,double c){Arc x{v,int(a[v].size()),c},y{u,int(a[u].size()),0};a[u].push_back(x);a[v].push_back(y);}double send(int u,int t,double f){if(u==t)return f;for(int&i=ptr[u];i1e-8&&level[e.v]==level[u]+1){double z=send(e.v,t,min(f,e.cap));if(z>1e-8){e.cap-=z;a[e.v][e.rev].cap+=z;return z;}}}return 0;}vectorcut(int s,int t){while(true){fill(level.begin(),level.end(),-1);queueq;level[s]=0;q.push(s);while(!q.empty()){int u=q.front();q.pop();for(auto e:a[u])if(e.cap>1e-8&&level[e.v]<0){level[e.v]=level[u]+1;q.push(e.v);}}if(level[t]<0){vectorv(level.size());for(int i=0;i=0;return v;}fill(ptr.begin(),ptr.end(),0);while(send(s,t,1e15)>1e-8){}}}}; + +struct Frame{int dim;array bits;}; +bool sub(const Frame&a,const Frame&b){for(int k=0;k<8;k++)if(a.bits[k]&~b.bits[k])return false;return true;} +bool contains(const Frame&f,int v){return(f.bits[v/64]>>(v%64))&1;} +Frame mapped(const Frame&f,int v,bool join){Frame g=f;if(join){if(contains(f,v))return g;g.dim++;for(int x=0;x<512;x++)if(contains(f,x))g.bits[(x^v)/64]|=1ULL<<((x^v)%64);}else{bool changed=false;for(int x=0;x<512;x++)if(contains(f,x)&&(__builtin_popcount(unsigned(x&v))&1)){g.bits[x/64]&=~(1ULL<<(x%64));changed=true;}if(changed)g.dim--;}return g;} +struct Node{bool mut;int oldf,newf;}; +int main(int argc,char**argv){ + if(argc!=2)return 2; + int F,N,E;cin>>F>>N>>E;vectorframes(F);map,int>lookup; + for(int f=0;f>frames[f].dim;for(auto&x:frames[f].bits)cin>>x;lookup[frames[f].bits]=f;} + vectornodes(N);vectoridx(N,-1),rev; + for(int i=0;i>m>>nodes[i].oldf>>nodes[i].newf;nodes[i].mut=m;} + vector>edges(E);for(auto&[a,b]:edges)cin>>a>>b; + int H;cin>>H;vector>helpers(H);for(auto&[a,b]:helpers)cin>>a>>b; + for(int i=0;iused;for(auto n:nodes){used.insert(n.oldf);used.insert(n.newf);}vectorproposal(frames.size()); + for(int f:used)proposal[f]=mapped(frames[f],v,join); + Flow flow(V+2);vectorunary(V,0);int s=V,t=V+1; + for(auto[a,b]:edges){int fa=nodes[a].newf,fb=nodes[b].oldf;auto A=frames[fa],B=frames[fb],GA=proposal[fa],GB=proposal[fb]; + if(!sub(A,B)){cerr<<"bad baseline edge"<=0&&i==j){unary[i]+=e11-e00;continue;} + if(i>=0&&j>=0){double w=e10+e01-e00-e11;if(w<-1e-7){cerr<<"nonsubmodular "<=0)unary[i]+=e10-e00;else if(j>=0)unary[j]+=e01-e00; + } + for(auto[a,b]:helpers){auto A=frames[nodes[a].newf],B=frames[nodes[b].oldf],GA=proposal[nodes[a].newf],GB=proposal[nodes[b].oldf]; + unary[idx[a]]+=powers[B.dim-A.dim]-powers[GB.dim-GA.dim]; + } + for(int i=0;i=0&&reach[idx[a]]?proposal[fa]:A,GB=idx[b]>=0&&reach[idx[b]]?proposal[fb]:B; + if(!sub(GA,GB)){legal=false;break;}delta+=powers[GB.dim-GA.dim]-powers[B.dim-A.dim]; + } + for(auto[a,b]:helpers)if(reach[idx[a]]){auto A=frames[nodes[a].newf],B=frames[nodes[b].oldf],GA=proposal[nodes[a].newf],GB=proposal[nodes[b].oldf];delta+=powers[B.dim-A.dim]-powers[GB.dim-GA.dim];} + if(legal&&delta < -1e-8){int count=0,h=0;for(auto[a,b]:helpers)if(reach[idx[a]])h++; + vectortranslated(frames.size(),-1); + for(int f:used){auto G=proposal[f];auto it=lookup.find(G.bits);if(it==lookup.end()){int k=frames.size();lookup[G.bits]=k;frames.push_back(G);translated[f]=k;}else translated[f]=it->second;} + for(int k=0;k=0&&reach[idx[k]]){nodes[k].oldf=translated[nodes[k].oldf];nodes[k].newf=translated[nodes[k].newf];count++;} + gain+=delta;cerr<<"ACCEPT round "<=-1e-8)break; + } +} diff --git a/research/native-lattice-retiming/discover.py b/research/native-lattice-retiming/discover.py new file mode 100644 index 0000000000..425a74925c --- /dev/null +++ b/research/native-lattice-retiming/discover.py @@ -0,0 +1,59 @@ +"""Optional floating discovery; never mathematical acceptance. +Apache-2.0, Codex assistance. Min-cut base credited to Cinna Davis PR4441. +""" +import argparse +import json +from pathlib import Path +import subprocess +import native + +def main(output): + output.mkdir(parents=True,exist_ok=False) + N,c,_,baseline=native.build() + c['frames'].pop() # The explicit candidate must not seed its own discovery. + program=baseline['forward'];nodes=[];paths=[[] for _ in range(632)] + def contact(old,new,roles,mutable=False,index=-1): + i=len(nodes);nodes.append(dict(old=old,new=new,roles=roles,mutable=mutable,index=index)) + for r in roles:paths[r].append(i) + for r,f in enumerate(c['start']):contact(f,f,[r],r>=224) + for i,e in enumerate(program): + if e[0]=='scalar': + g=e[1];rr=g[1:3] if g[0] in ('add','copy') else g[1:2];roles=[r[1] for r in rr if r[0]=='L'] + if roles:contact(e[2],e[2],roles,all(r[0]=='L' for r in rr),i) + elif e[0]=='warp':contact(e[3],e[4],[e[1][1]],False,i) + last=len(nodes) + for r,f in enumerate(c['final']):contact(f,f,[r],r>=224) + edges=[(a,b) for path in paths for a,b in zip(path,path[1:])] + graph=output/'input.graph' + with graph.open('w') as out: + print(len(c['frames']),len(nodes),len(edges),file=out) + for basis in c['frames']: + sp=N.span(basis) + print(len(basis),*[sum(1<<(v%64) for v in sp if v//64==b) for b in range(8)],file=out) + for n in nodes:print(int(n['mutable']),n['old'],n['new'],file=out) + for a,b in edges:print(a,b,file=out) + print(408,file=out) + for r in range(224,632):print(r,last+r,file=out) + executable=output/'discover-lattice';solution=output/'solution.txt' + subprocess.run(['c++','-O3','-std=c++20',str(native.HERE/'discover-lattice.cpp'),'-o',str(executable)],check=True,timeout=120) + with graph.open() as inp,(output/'discovery.log').open('w') as log: + subprocess.run([str(executable),str(solution)],stdin=inp,stdout=log,stderr=log,check=True,timeout=600) + native.need(solution.exists(),'No improved candidate found') + lines=solution.read_text().splitlines();F,M=map(int,lines[0].split());native.need(M==len(nodes),'Discovery dimensions') + spaces=[] + for line in lines[1:F+1]: + d,*chunks=map(int,line.split());sp=frozenset(x for x in range(512) if chunks[x//64]>>(x%64)&1) + native.need(len(sp)==1< Date: Wed, 21 Oct 2026 16:57:45 -0400 Subject: [PATCH 07/13] Record native lattice replay and isolated export validation --- research/native-lattice-retiming/README.md | 2 +- research/native-lattice-retiming/TASK.json | 16 +++- .../native-lattice-retiming/VALIDATION.md | 75 +++++++++++++------ 3 files changed, 70 insertions(+), 23 deletions(-) diff --git a/research/native-lattice-retiming/README.md b/research/native-lattice-retiming/README.md index 8d4e9ca201..2cc4f47bd9 100644 --- a/research/native-lattice-retiming/README.md +++ b/research/native-lattice-retiming/README.md @@ -1,4 +1,4 @@ -# A new native contact: conditional κ = 0.00300120 +# Conditional κ = 0.00300120 (71.9× smaller uniform-rank exponent) **Local for user review. Do not push, publish a PR or post Discussions.** diff --git a/research/native-lattice-retiming/TASK.json b/research/native-lattice-retiming/TASK.json index 5c9dd61a4c..6f6a1cc8bc 100644 --- a/research/native-lattice-retiming/TASK.json +++ b/research/native-lattice-retiming/TASK.json @@ -112,12 +112,26 @@ "stop_rule": "Freeze a strictly improving exact paid profile, retain all inherited native and consumer obligations, run complete relevant checks, and leave the result local for user review.", "task_id": "supplier-boundary-audit", "upstream_checkpoint": { - "checked_at_utc": "2026-10-21T20:31:00Z", + "checked_at_utc": "2026-10-21T20:56:24Z", "commit": "2a13eb1827784206202db90e5dc8327cf8a250db", "pending_sources": { "PR4440": "40e22a83ed660d3d6074c4f2dbf14bfb621eee51", "PR4441": "5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39" }, "priority_revision": 7 + }, + "validation": { + "changed_receipt": "rejected", + "changed_source": "rejected", + "committed_bytes": "pass", + "export_integrity": "pass", + "git_free_optimized": "pass", + "metadata_pins": "pass", + "no_publication": true, + "optional_discovery": "reproduces exact patch", + "platform": "macOS arm64", + "python": "3.12.8", + "registered_replay": "pass", + "source_history": "unavailable: shallow checkout" } } diff --git a/research/native-lattice-retiming/VALIDATION.md b/research/native-lattice-retiming/VALIDATION.md index 3e26da177c..908ed71d94 100644 --- a/research/native-lattice-retiming/VALIDATION.md +++ b/research/native-lattice-retiming/VALIDATION.md @@ -1,26 +1,59 @@ # Validation -Local only, CPython 3.12.8 on macOS arm64, 21 October 2026. - -- Explicit receipt generation: **PASS**. Two native interpreters replay both - orientations, 632 arbitrary persistent columns and owned-center erasure. -- Four new edge types: forward and conjugate serialized Clifford recipes - decode with the right rank, tableau and absolute zero-state phase. -- Complete p17 Laurent/source word and full changed invoice: **PASS**. -- Two exact interval engines, both paid tails, the two finite uniform ranks, - 54+4 current outer predicates, nine-row agreement and 63 legacy predicates: - **PASS**. Wrong contact, phase-only, short-product-bound and outer mutants - reject at their intended gates. -- Optional C++20 discovery: **PASS**, reproducing exactly phase B contact 480 - and the new span `[0,45,133,168,336,381,469,504]`. - -Registered replay, committed-byte preflight and Git-free optimized replay are -recorded after the first committed package is validated. No hosted CI, Lean, -Docker, complete historical suite or independent scientific review is claimed. +All scientific checks below pass on CPython 3.12.8, macOS arm64, 21 October +2026. Scientific code/receipts were committed at +`71c54ffcfee4c77d77164f9b02bdf763a8f267d0`; the final follow-up only records +validation and changes documentation/task status. + +| Check | Result | +| --- | --- | +| Metadata and all source pins | PASS_PACKAGE_METADATA_AND_PINS | +| Registered full replay | PASS_REGISTERED_RESEARCH_PACKAGE | +| Both native orientations, two interpreters, 632 arbitrary persistent columns, arbitrary owned-center entry then legal erasure | PASS | +| Four new edge types, forward/conjugate Clifford decoding, exact rank and absolute phase | PASS | +| Complete p17 physical/Laurent word, changed full paid/productive invoice | PASS | +| Two interval engines, new root bracket, both paid strictification tails, both finite uniform ranks | PASS | +| Nine outer rows, 54 current predicates, four guards and 63 legacy predicates | PASS | +| Wrong contact, global-phase-only, short-product-bound and outer negative controls | REJECTED as intended | +| Committed-byte preflight, 59 exported files | PASS_RESEARCH_COMMIT_BYTES | +| Deterministic committed export and independent integrity check | PASS_RESEARCH_EXPORT | +| Isolated Git-free optimized replay (`-I -O -B`, explicit package import path) | PASS_CONDITIONAL_NEW_NATIVE_PROFILE_KAPPA | +| Changed pinned source comment in the Git-free export | Rejected by source authentication | +| Changed saved κ receipt in the Git-free export, full optimized replay | Rejected at exact RESULT.json comparison | +| Optional C++20 discovery | Reproduces exactly phase B contact 480 and the new span | + +Commands: + +```sh +python3.12 -B scripts/research_package.py --package research/native-lattice-retiming --check-only +python3.12 -B scripts/research_package.py --package research/native-lattice-retiming +python3.12 -B scripts/check_research_commit.py --package research/native-lattice-retiming +python3.12 -B scripts/export_research_package.py export --package research/native-lattice-retiming --ref 71c54ffcfee4c77d77164f9b02bdf763a8f267d0 --output /tmp/native-lattice-71c54ff.tar +python3.12 -B scripts/export_research_package.py check /tmp/native-lattice-71c54ff.tar +python3.12 -B research/native-lattice-retiming/discover.py --output /tmp/native-lattice-discovery-replay +``` + +The checked export was extracted without Git, then `verify.py` ran through +`runpy.run_path` under `python3.12 -I -O -B` with only the explicit package +folder inserted into `sys.path`. Its normal 43-input authentication, complete +native and arithmetic checks and receipt comparisons all ran. The two external +mutation controls used that export and restored the exact original bytes. +The optional compiler was Apple clang 21.0.0 with `-O3 -std=c++20`. + +`--check-source-history` is **unavailable**: its explicit precondition rejects +this shallow checkout with “source-history check requires full Git history.” +No unshallow fetch was attempted. Exact pending heads and consumed bytes are +present, pinned and retained in local merge ancestry; the unavailable check +is not presented as scientific or provenance acceptance. Source ancestry includes PR4440 head `40e22a83ed660d3d6074c4f2dbf14bfb621eee51` and PR4441 head -`5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39`. SOURCES.json binds the exact -43 consumed source files; unchanged historical native/owned-query/analytic -contracts remain explicit premises. Pending-source acceptance is not inherited -from the reviewed .0023 or .00268647 checkpoints. +`5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39`. SOURCES.json binds the 43 +consumed source files. The final upstream checkpoint at 20:56 UTC found +canonical main still `2a13eb1827784206202db90e5dc8327cf8a250db`, unchanged +priority guidance, unchanged pending heads and selected κ=.0023. + +No hosted CI, Lean, Docker, complete historical suite or independent +scientific review is claimed. Universal native/all-column, owned-query, +precision, physical tape, analytic and recovery contracts remain conditional +premises. No push, PR or Discussion post was made for this package. From de6869e2e4d9c6f630bac5de4a919d99a2cb884b Mon Sep 17 00:00:00 2001 From: zxv Date: Wed, 21 Oct 2026 17:37:26 -0400 Subject: [PATCH 08/13] Prepare reviewed lattice contribution for publication --- .../native-lattice-retiming/LITERATURE.md | 6 ++++- research/native-lattice-retiming/PROOF.md | 2 +- research/native-lattice-retiming/README.md | 12 +++++++--- research/native-lattice-retiming/SOURCES.json | 2 +- research/native-lattice-retiming/TASK.json | 24 ++++++++++++------- .../native-lattice-retiming/VALIDATION.md | 18 +++++++++++++- 6 files changed, 48 insertions(+), 16 deletions(-) diff --git a/research/native-lattice-retiming/LITERATURE.md b/research/native-lattice-retiming/LITERATURE.md index 96469b6e48..2e3a5b7846 100644 --- a/research/native-lattice-retiming/LITERATURE.md +++ b/research/native-lattice-retiming/LITERATURE.md @@ -1,6 +1,6 @@ # Literature evaluated during this continuation -Local research notes, 21 October 2026. This revisits zxv's +Research notes, 21 October 2026. This revisits my [0.0023 literature list](../kappa-0023-productive-jobs/LITERATURE.md). The sources motivate experiments; their theorems are not imported as native instructions or as a proof of the new multiplication bound. @@ -40,3 +40,7 @@ multiple-label moves, changed scalar graphs and other providers remain open. No global or exact search-optimality claim is made. Apache-2.0 for these notes. Papers retain their own copyrights and licenses. + +Submission refresh: concurrent [PR4447](https://github.com/CrocSwap/integer-mult-bounds/pull/4447) +reports the same contact and profile. This separate discovery and replay is +retained with the smaller charged templates; no novelty claim is made. diff --git a/research/native-lattice-retiming/PROOF.md b/research/native-lattice-retiming/PROOF.md index c966d4df2c..5ed2cacea7 100644 --- a/research/native-lattice-retiming/PROOF.md +++ b/research/native-lattice-retiming/PROOF.md @@ -6,7 +6,7 @@ Source PR4441 is fixed at `5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39`, including PR4440 at `40e22a83ed660d3d6074c4f2dbf14bfb621eee51`. Their conditional contracts are retained. No selected result, independent scientific acceptance or universal implementation hypothesis is promoted. -The exact byte closure is SOURCES.json. New work stays local for user review. +The exact byte closure is SOURCES.json. The user authorized submission after review. ## One legal contact outside the predecessor frame menu diff --git a/research/native-lattice-retiming/README.md b/research/native-lattice-retiming/README.md index 2cc4f47bd9..22cb2378ee 100644 --- a/research/native-lattice-retiming/README.md +++ b/research/native-lattice-retiming/README.md @@ -1,6 +1,6 @@ # Conditional κ = 0.00300120 (71.9× smaller uniform-rank exponent) -**Local for user review. Do not push, publish a PR or post Discussions.** +**Submission authorized by the user after review on 21 October 2026.** A changed native paid profile raises the conditional multiplication saving to **κ = 0.00300120** and specifies sufficient uniform rank @@ -11,8 +11,14 @@ by **71.88×**. At PR4441's unchanged κ=0.00300105, the rank can instead be **`2^249900000000`**, a **661.53×** exponent reduction. These are sufficient mathematical template sizes, not practical speedups. -This builds on zxv's selected [0.0023 construction](../kappa-0023-productive-jobs/README.md), -its [higher-moment/logarithmic compiler](../higher-moment-strictification/README.md), +The submission refresh found concurrent [PR4447](https://github.com/CrocSwap/integer-mult-bounds/pull/4447), +which uses the same B/480 contact and paid profile and declares κ=0.00300123. +This contribution retains the reviewed κ=0.00300120 and supplies the smaller +paid-tail and uniform-template bounds above, with a separate discovery path. +No unique-discovery or strongest-κ claim is made. + +This builds on my selected [0.0023 construction](../kappa-0023-productive-jobs/README.md), +my [higher-moment/logarithmic compiler](../higher-moment-strictification/README.md), and Cinna Davis's new query-thinning and fresh-helper constructions ([PR4440](https://github.com/CrocSwap/integer-mult-bounds/pull/4440), [PR4441](https://github.com/CrocSwap/integer-mult-bounds/pull/4441)). diff --git a/research/native-lattice-retiming/SOURCES.json b/research/native-lattice-retiming/SOURCES.json index 5378362135..5dc627b3b2 100644 --- a/research/native-lattice-retiming/SOURCES.json +++ b/research/native-lattice-retiming/SOURCES.json @@ -1,5 +1,5 @@ { - "base_commit": "28f58f6f9b72ddfe7aa5b986d1b678356c4e6350", + "base_commit": "5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39", "files": [ { "git_blob": "686c36fb19680db327f797ebdfe612487d8c53f8", diff --git a/research/native-lattice-retiming/TASK.json b/research/native-lattice-retiming/TASK.json index 6f6a1cc8bc..544002777e 100644 --- a/research/native-lattice-retiming/TASK.json +++ b/research/native-lattice-retiming/TASK.json @@ -2,7 +2,7 @@ "actual_scope": "Build a changed native frame contact beyond PR4441, then completely pay tensor completion, finite uniform compilation and the integer-multiplication consumer.", "ai_assistance": "Substantial OpenAI Codex assistance; no subagents.", "author": "zxv, with substantial OpenAI Codex assistance", - "base_commit": "28f58f6f9b72ddfe7aa5b986d1b678356c4e6350", + "base_commit": "5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39", "bottleneck_link": "New subspaces outside the predecessor frame menu can change the raw paid profile while exact native endpoints and all helper outputs stay fixed.", "budget_minutes": 60, "evidence": "Explicit one-contact native patch; two all-column replays in both orientations, new absolute-phase transports, complete changed invoice, two moment engines, both paid tails, finite ranks and all outer predicates.", @@ -100,19 +100,25 @@ "local_HEAD_notes": 5739, "local_notes_searched": 23, "open_pr_bodies": 301, - "remote_pagination_complete": true + "remote_pagination_complete": true, + "submission_refresh": { + "canonical_main": "2a13eb1827784206202db90e5dc8327cf8a250db", + "checked_at_utc": "2026-10-21T21:36:00Z", + "concurrent_PR4447": "322e0ec764aa7ef7801383feb1f656e460dd8bed", + "finding": "Same B/480 contact and paid profile, declared kappa .00300123. This contribution retains .00300120 and gives substantially smaller sufficient templates. No novelty or strongest-endpoint claim." + } }, "priority_revision": 7, - "publication_policy": "User explicitly requested no publication of this successor. No push, PR or Discussion post.", + "publication_policy": "User approved submission of this reviewed contribution on 2026-10-21. First-person prose refers to the author, zxv. No further Discussion participation is requested.", "resource_budget": "Single-process bounded controller arithmetic, under a few minutes per screen; no Lean, Docker, concurrent artifact replay or native historical suites.", "schema_version": 1, - "scope_change_reason": "The explicit user requests a genuine kappa improvement, keeps this successor local, and asks for a literature pivot if stuck. Newly published PR4440/4441 change the useful starting model.", - "scope_decision": "Stop this finite model screen. No new hill-climbing construction step found. Keep the root-retuning witness as a separately labelled diagnostic, and require changed words/interfaces/providers/stock for the next actual climb.", + "scope_change_reason": "The explicit user requested a changed native construction and literature evaluation when stuck, then approved submission after reviewing the local result. PR4440/4441 supplied the useful starting model.", + "scope_decision": "The new exact contact changes the paid profile and passes the fully charged conditional transfer. Publish the reviewed result and smaller finite ranks; acknowledge concurrent PR4447 without a novelty or strongest-kappa claim.", "scope_status": "changed", - "stop_rule": "Freeze a strictly improving exact paid profile, retain all inherited native and consumer obligations, run complete relevant checks, and leave the result local for user review.", + "stop_rule": "Publish the reviewed, strictly improving exact paid profile with all inherited native and consumer obligations retained; do not expand the mathematical scope during submission.", "task_id": "supplier-boundary-audit", "upstream_checkpoint": { - "checked_at_utc": "2026-10-21T20:56:24Z", + "checked_at_utc": "2026-10-21T21:36:00Z", "commit": "2a13eb1827784206202db90e5dc8327cf8a250db", "pending_sources": { "PR4440": "40e22a83ed660d3d6074c4f2dbf14bfb621eee51", @@ -127,11 +133,11 @@ "export_integrity": "pass", "git_free_optimized": "pass", "metadata_pins": "pass", - "no_publication": true, "optional_discovery": "reproduces exact patch", "platform": "macOS arm64", "python": "3.12.8", "registered_replay": "pass", - "source_history": "unavailable: shallow checkout" + "source_history": "unavailable: shallow checkout", + "unpublished_at_initial_validation": true } } diff --git a/research/native-lattice-retiming/VALIDATION.md b/research/native-lattice-retiming/VALIDATION.md index 908ed71d94..d63d8cce0b 100644 --- a/research/native-lattice-retiming/VALIDATION.md +++ b/research/native-lattice-retiming/VALIDATION.md @@ -56,4 +56,20 @@ priority guidance, unchanged pending heads and selected κ=.0023. No hosted CI, Lean, Docker, complete historical suite or independent scientific review is claimed. Universal native/all-column, owned-query, precision, physical tape, analytic and recovery contracts remain conditional -premises. No push, PR or Discussion post was made for this package. +premises. At the initial validation checkpoint this package was unpublished. +The user subsequently approved submission after review. + +## Publication preparation + +The submission branch starts from public PR4441 head `5f9d871c` and carries +only this package beyond that dependency. The earlier unpublished p7 negative +screen remains on its local branch and is excluded. All 46 source/provenance +rows were checked byte-for-byte against this public base before updating the +base pin; no scientific program, patch or receipt changed. The original local +validation commit is retained locally, and its code/receipt bytes are identical +to this submission's scientific files. + +The 21:36 UTC refresh found unchanged canonical main and guidance, plus +concurrent PR4447 at `322e0ec764aa7ef7801383feb1f656e460dd8bed`. Its same +contact/profile and higher declared endpoint are acknowledged in README.md +and the PR description. No unique-discovery or strongest-kappa claim is made. From b990896676e7dd966c61950d6e979f7c383d1c22 Mon Sep 17 00:00:00 2001 From: zxv Date: Wed, 21 Oct 2026 18:40:27 -0400 Subject: [PATCH 09/13] Add net-tax and log-moment rank compiler (18.28x smaller exponent) --- .../net-tax-rank-compiler/BENCHMARKS.json | 144 +++ research/net-tax-rank-compiler/LOG-MOMENTS.md | 284 +++++ research/net-tax-rank-compiler/PROOF.md | 343 +++++ research/net-tax-rank-compiler/README.md | 171 +++ research/net-tax-rank-compiler/RESULT.json | 1116 +++++++++++++++++ research/net-tax-rank-compiler/SHIFTED-LOG.md | 134 ++ research/net-tax-rank-compiler/SOURCES.json | 90 ++ research/net-tax-rank-compiler/TASK.json | 132 ++ research/net-tax-rank-compiler/VERIFY.json | 29 + .../net-tax-rank-compiler/WEIGHTED-EXITS.md | 268 ++++ research/net-tax-rank-compiler/compiler.py | 316 +++++ research/net-tax-rank-compiler/intervals.py | 150 +++ research/net-tax-rank-compiler/test_math.py | 186 +++ research/net-tax-rank-compiler/verify.py | 198 +++ 14 files changed, 3561 insertions(+) create mode 100644 research/net-tax-rank-compiler/BENCHMARKS.json create mode 100644 research/net-tax-rank-compiler/LOG-MOMENTS.md create mode 100644 research/net-tax-rank-compiler/PROOF.md create mode 100644 research/net-tax-rank-compiler/README.md create mode 100644 research/net-tax-rank-compiler/RESULT.json create mode 100644 research/net-tax-rank-compiler/SHIFTED-LOG.md create mode 100644 research/net-tax-rank-compiler/SOURCES.json create mode 100644 research/net-tax-rank-compiler/TASK.json create mode 100644 research/net-tax-rank-compiler/VERIFY.json create mode 100644 research/net-tax-rank-compiler/WEIGHTED-EXITS.md create mode 100644 research/net-tax-rank-compiler/compiler.py create mode 100644 research/net-tax-rank-compiler/intervals.py create mode 100644 research/net-tax-rank-compiler/test_math.py create mode 100644 research/net-tax-rank-compiler/verify.py diff --git a/research/net-tax-rank-compiler/BENCHMARKS.json b/research/net-tax-rank-compiler/BENCHMARKS.json new file mode 100644 index 0000000000..5c411a1916 --- /dev/null +++ b/research/net-tax-rank-compiler/BENCHMARKS.json @@ -0,0 +1,144 @@ +{ + "schema_version": 1, + "cases": [ + { + "name": "native-source-parameters", + "source": "research/native-lattice-retiming/RESULT.json", + "profile_key": null, + "witness": { + "saving": ".00300122", + "kappa": ".00300120", + "v": 675, + "cutoff": 18, + "floor": 22, + "u": "3/25", + "p": 160, + "log_shift": 1, + "uniform_method": "shifted", + "theta": "15/16" + } + }, + { + "name": "native-net-shift", + "source": "research/native-lattice-retiming/RESULT.json", + "profile_key": null, + "witness": { + "saving": ".00300122", + "kappa": ".00300120", + "v": 476, + "cutoff": 18, + "floor": 22, + "u": "3/25", + "p": 108, + "log_shift": 19040, + "uniform_method": "shifted", + "theta": "173/185" + } + }, + { + "name": "native-weighted-same-C", + "source": "research/native-lattice-retiming/RESULT.json", + "profile_key": null, + "witness": { + "saving": ".00300122", + "kappa": ".00300120", + "v": 227, + "cutoff": 20, + "floor": 21, + "u": "861/5000", + "p": 28, + "log_shift": 454, + "uniform_method": "weighted", + "weighted": { + "mean_upper": "431/500", + "A_lower": "231/500", + "A_upper": "463/1000", + "ambient_log_lower": "1679/1000", + "floor_log_lower": "127/125" + } + } + }, + { + "name": "native-concentrated-same-C", + "source": "research/native-lattice-retiming/RESULT.json", + "profile_key": null, + "witness": { + "saving": ".00300122", + "kappa": ".00300120", + "v": 227, + "cutoff": 20, + "floor": 21, + "u": "861/5000", + "p": 21, + "log_shift": 3405, + "uniform_method": "log-moments", + "weighted": { + "raw_mean_upper": "431/500", + "A_lower": "347/100", + "A_upper": "139/40", + "ambient_log_lower": "1679/1000", + "floor_log_lower": "127/125", + "raw_log_bound": "3/2", + "paid_excess_upper": "1/100000" + } + } + }, + { + "name": "native-concentrated-balanced", + "source": "research/native-lattice-retiming/RESULT.json", + "profile_key": null, + "witness": { + "saving": "90037/30000000", + "kappa": ".00300120", + "v": 260, + "cutoff": 20, + "floor": 21, + "u": "171/1000", + "p": 24, + "log_shift": 3900, + "uniform_method": "log-moments", + "weighted": { + "raw_mean_upper": "431/500", + "A_lower": "347/100", + "A_upper": "139/40", + "ambient_log_lower": "1679/1000", + "floor_log_lower": "127/125", + "raw_log_bound": "3/2", + "paid_excess_upper": "1/100000" + } + } + }, + { + "name": "p7-net-shift-same-C", + "source": "research/higher-moment-strictification/RESULT.json", + "profile_key": "invoice_oracle", + "witness": { + "saving": ".00268648", + "kappa": ".00268647", + "v": 113, + "cutoff": 9, + "floor": 15, + "u": "33/125", + "p": 7, + "log_shift": 1356, + "theta": "56/69" + } + }, + { + "name": "p7-net-shift-balanced", + "source": "research/higher-moment-strictification/RESULT.json", + "profile_key": "invoice_oracle", + "witness": { + "saving": "11551891/4300000000", + "kappa": ".00268647", + "v": 100, + "cutoff": 10, + "floor": 15, + "u": "31/100", + "p": 8, + "log_shift": 1700, + "theta": "57/67" + } + } + ] +} diff --git a/research/net-tax-rank-compiler/LOG-MOMENTS.md b/research/net-tax-rank-compiler/LOG-MOMENTS.md new file mode 100644 index 0000000000..b75cf923df --- /dev/null +++ b/research/net-tax-rank-compiler/LOG-MOMENTS.md @@ -0,0 +1,284 @@ +# Retaining concentration of the paid tensor's log ranks + +The mean-only certificate in [WEIGHTED-EXITS.md](WEIGHTED-EXITS.md) replaces +one completed unit's log rank by a Bernoulli random variable. A tensor unit +has substantially more structure: before splitting, its normalized log rank +is an average of independent raw log ranks. The following finite rational +certificate retains that concentration, bounds the effect of every paid +completion, and uses the same inherited integer compiler. + +This is a bound on normalized paid rank-one leaves, conditional on the +source native and finite compiler contracts. No new native operation, +unpaid completion, overlapping-rank compiler or selected-frontier change +is asserted. All probability laws below describe finite weighted +inventories; they do not replace whole integer jobs by fractional inputs. + +## Raw tensor moments + +Fix `01`, a positive integer `v`, a positive support bound `L`, +and a raw paid inventory with positive `t`-moment `P_t`. Under its +probability law `P_r*r^t/P_t`, put + +``` +Y = ln(r)/ln(c), +0<=Y<=L, E[Y]<=q0, 0<=q0<=L. +``` + +For a chronological `v`-fold product, let `J=c^v`. The normalized raw +tensor log rank is exactly + +``` +X_raw = ln(R)/ln(J) = (Y_1+...+Y_v)/v, +``` + +with independent copies of the raw law. The raw product's paid `t`-moment +is `A_raw=P_t^v`. + +The convex chord bound replaces each `Y_i` by `L` times a Bernoulli random +variable of mean `q0/L`. For every positive integer `i`, this gives + +``` +E[X_raw^i] <= M_i, +M_i = (L/v)^i * sum_(j=0..i) S(i,j)*(q0/L)^j*(v)_j. (1) +``` + +Here `S(i,j)` are Stirling numbers of the second kind, and `(v)_j` are +integer falling factorials, zero for `j>v`. Equation (1) follows either by +expanding the binomial moment or by applying convex order one variable at +a time to the nonnegative convex function `x^i`. When `L,q0` are rational, +all `M_i` are rational. + +## Splitting, full paid completion and normalization + +Split every original paid rank above `J`, and also split every paid +completion into positive ranks at most `J`. Let the final paid `t`-moment +be `Q_t`. Define its actual excess by + +``` +E_actual = Q_t-A_raw >= 0, +x = E_actual/A_raw. +``` + +The excess contains the increase in original-paid moment from splitting +**plus the full paid moment of completion calls**. It does not subtract +productive target-completion credit. Suppose a proved paid bound gives + +``` +0<=x<=epsilon. +``` + +For the final completed paid law, put `X=ln(r)/ln(J)`, so `0<=X<=1`. +Its `i`-th moment has the rational upper bound + +``` +E[X^i] <= mu_i := min(1, (M_i+epsilon)/(1+epsilon)), (2) +mu_0 := 1. +``` + +The denominator in (2) needs a capped reference law. It is not justified +merely by overcounting an unnormalized numerator. For an original tensor +call `R>J`, use the reference value +`min(ln(R)/ln(J),1)^i=1`. If its split paid moment is `Q_R`, the split +weighted `i`-moment is at most `Q_R`, so its increase over this capped +reference is at most `Q_R-R^t`. For `R<=J`, the original call is unchanged. +Each full completion contributes at most its full paid moment, because +its final log ranks also lie in `[0,1]`. Thus, with + +``` +m_i = E[min(X_raw,1)^i] <= min(1,M_i), +``` + +the final weighted numerator is at most `A_raw*m_i+E_actual`. +Dividing by the actual total `A_raw+E_actual` gives +`E[X^i]<=(m_i+x)/(1+x)`. For `m_i<=1`, this expression increases with +`x`, since its derivative is `(1-m_i)/(1+x)^2>=0`. Substitution of +`x<=epsilon` and `m_i<=min(1,M_i)` proves (2). The cap is an auxiliary +proof device, not a change to the native program. + +A convenient paid excess bound from this package is + +``` +epsilon >= (splitting_coefficient*gamma_u^v + 2*delta^v)/alpha^v. +``` + +The second term is the predecessor's full completion bound. A sharper +proved full completion bound may replace it. The net completion tax used +to prove a superpotential cannot replace it. + +## Bell-polynomial exit certificate + +The separated compiler's exact exit law is proved in WEIGHTED-EXITS.md: +at height `G`, it consists of `G+1` independent copies of the completed +paid log law. Take a positive integer `p`, positive scale `a=h*ln(2)`, +and rational bounds + +``` +a/ln(J) <= A_bar, +(a+ln(m))/ln(J) >= B_under, +ln(k_min)/ln(J) >= beta > 0. +``` + +Require `B_under>0` as well. + +The ambient `m` and productive minimum `k_min` in these displays belong +to the **completed tensor unit**, not the raw unit. + +For `0<=k<=n<=p`, construct partial exponential Bell polynomials from +the upper moments in (2): + +``` +Bell(0,0) = 1, +Bell(n,0) = 0 for n>0, +Bell(0,k) = 0 for k>0, +Bell(n,k) = sum_(i=1..n-k+1) + binom(n-1,i-1)*mu_i*Bell(n-i,k-1). +``` + +They have nonnegative coefficients in the `mu_i`. Also set + +``` +Shift(r) = sum_(i=0..r) binom(r,i)*A_bar^(r-i)*mu_i. +``` + +For `0<=j<=p`, form + +``` +C_j = sum_(i=j..p) binom(p,i)*Shift(p-i)*Bell(i,j), +D_j = sum_(i=j..p) binom(p,i)*S(i,j)*B_under^(p-i)*beta^i. +``` + +All `D_j` are positive. If `C_j<=lambda*D_j` for every `j`, then + +``` +E[(a+ln(exit))^p] <= lambda*(a+ln(n))^p (3) +``` + +at every integer compiler rank `n>=m`. + +To prove (3), write `u=G`, separate one completed paid variable `X_0`, +and expand the moments of the other `u` independent variables. For their +actual moments, the standard finite identity is + +``` +E[(X_1+...+X_u)^i] + = sum_(j=0..i) (u)_j*Bell_actual(i,j). +``` + +It follows directly by grouping the indices in the expanded power by +their equality partition; each occupied index contributes its corresponding +moment. Replacing actual moments by the upper bounds `mu_i` preserves the +inequality because all coefficients are nonnegative. Expanding +`(A_bar+X_0+...+X_u)^p` therefore gives at most +`sum_j C_j*(u)_j`. Expanding `(B_under+beta*u)^p` gives exactly +`sum_j D_j*(u)_j`. + +The falling factorials are nonnegative for every integer `u>=0`. +Coefficient domination proves the desired polynomial comparison. +Finally, `ln(n)>=ln(m)+G*ln(k_min)` implies +`(a+ln(n))/ln(J)>=B_under+beta*u`, completing the proof. + +This general coefficient test also accepts other rigorously proved upper +log moments; the raw chord bound (1) is one reusable source of them. + +## Uniform-rank consequence + +As in WEIGHTED-EXITS.md, it is enough that + +``` +lambda < eta := t*m^(t-1), +m^(1-t) <= (1+ln(m)/a)^p. +``` + +The first inequality pays exits by source complements. The second covers +the entire ordinary base range by the monotone endpoint argument in +SHIFTED-LOG.md. Strong induction gives + +``` +L(n) <= n^t*(1+ln(n)/a)^p. +``` + +For `N=2^H` and desired exponent `z>t`, the final exact guard is + +``` +(h+H)^p < h^p*2^((z-t)*H). +``` + +Neither the pointwise maximum-exit contraction nor the Bernoulli +mean-only certificate is needed when (3) is used instead. + +## Balanced native4453 diagnostic + +The package's balanced construction uses the unchanged raw paid profile +and the exact parameters + +``` +C=90037/30000000, t=1-C, +v=260, c=20, b=21, u=171/1000, +m=153^260, J=20^260, k_min>=21^260. +``` + +A rational log-moment witness is + +``` +q0=431/500, L=3/2, epsilon=1/100000, +p=24, h=3900=15*v, +A_bar=139/40, +B_under=347/100+1679/1000=5149/1000, +beta=127/125. +``` + +The raw maximum 72 satisfies `72^2<20^3`, proving `Y<=3/2`. The raw +mean and full paid excess need their separate profile-bound interval +checks. The full paid relative excess is below +`0.000001447491519=1`, paid ranks `r_j>=1`, +ambient rank `m=max_i k_i` containing every paid job, and `B` independent +productive fields. Write + +``` +T_s = sum_i k_i^s, P_s = sum_j r_j^s, +0=C, sigma=t+u>=1. +``` + +Choose integers `1=1`, and set `J=c^v`, `L=b^v`. +The chronological native product has productive ranks `K`, paid ranks `R`, +`B^v` productive fields and moments `T_s^v`, `P_s^v`. Its ambient rank is +`m^v`. These assertions use the native product contract in Section 6 below; +they are not consequences of histogram arithmetic alone. + +For an integer `D>=0`, define the exact disjoint splitting charge + +``` +S_t(D,J) = q J^t + r^t, D=qJ+r, 0<=r=0` has its unique maximum at +`x=t^(1/C)`, with value `h`. In particular `0J`, put `x=R/J>1` and `rho=frac(x)`. The exact charge gives + +``` +tau(R)/J^t = x-x^t+rho^t-rho <= x-x^t+h. (2) +``` + +For any `u>=C`, the right side is at most `A(C,u) x^(t+u)`. +Indeed, after dividing by `x^t`, the difference between this proposed upper +bound and (2) is + +``` +G(x) = A x^u-x^C+1-h x^(-t). +G(1) = A-h >= 0, +G'(x) = Au x^(u-1)-C x^(C-1)+ht x^(-t-1) >= 0. +``` + +The last inequality uses `Au>=C`, `u>=C` and `x>=1`. Hence + +``` +tau(R) <= A(C,u) R^(t+u) J^(-u). (3) +``` + +For the useful range `C<=u<=C/h`, this coefficient is simply `C/u`. +In particular this holds throughout `C<=u<=1`. + +A different bound can be stronger. Let `n=ceil(R/J)` be the number of +nonzero split pieces. Concavity gives + +``` +S_t(R,J) <= n^C R^t, +tau(R) <= (n^C-1) R^t. (4) +``` + +For `u>C`, the function `(y^C-1)y^(-u)` on `y>=1` has derivative + +``` +y^(-u-1) [u-(u-C)y^C]. +``` + +It increases up to the unique point `y^C=u/(u-C)` and decreases afterwards. +Its maximum is + +``` +M(C,u) = (C/u)(1-C/u)^((u-C)/C). +``` + +Since `n<2R/J`, (4) therefore implies + +``` +tau(R) <= K(C,u) R^(t+u) J^(-u), +K(C,u) = 2^u (C/u)(1-C/u)^((u-C)/C), u>C. (5) +``` + +At `u=C`, the supremum of `(y^C-1)y^(-C)=1-y^(-C)` is one, +so the valid endpoint definition is `K(C,C)=2^C`. The strict inequalities +in intermediate estimates are not needed: the final certificate will be +strict. Define + +``` +Q(C,u) = min(A(C,u),K(C,u)). +``` + +Then `0=1`, +`y^C-1 <= (C/u)(y^u-1) <= (C/u)y^u`, followed by `n<2R/J`. +For `u>C`, (5) improves its coefficient by the factor +`(1-C/u)^((u-C)/C)<1`; at `u=C`, (3) improves it from `2^C` to one. + +When `C,u` are rational, `K` can be certified without floating point. +Choose a positive integer `d` clearing the denominators of `u` and +`(u-C)/C`. Then + +``` +K(C,u)^d = 2^(du) (C/u)^d (1-C/u)^(d(u-C)/C) +``` + +is rational. A rational upper bound `q` for `K` is equivalent to the exact +rational comparison `q^d >= K^d`. Directed rational log/exp enclosures are +another option, particularly when the clearing exponent is large. + +## 3. Stronger completion net tax + +For `D=L-K>0`, the exact division formula and the definition of `h` imply + +``` +S_t(D,J) <= D J^(-C)+hJ^t. +``` + +Consequently + +``` +E(K) <= LJ^(-C)-L^t + (K^t-KJ^(-C)) + hJ^t + <= LJ^(-C)+2hJ^t-L^t =: H(L,J). (7) +``` + +The second step applies `x^t-x<=h` to `x=K/J`. It does not replace a +restricted sum over `K1`, + +``` +H(L,J)/J^t = L/J-(L/J)^t+2h > 0. +``` + +There are at most `B^v` completed owners, so multiplying the nonnegative +upper bound in (7) by `B^v` is legal even when fewer owners are completed: + +``` +sum_(K= 1-alpha^v-Q(C,u)gamma^v-delta^v-2h epsilon^v+delta0^v. +``` + +Therefore the exact strict inequality + +``` +alpha^v+Q(C,u)gamma^v+delta^v+2h epsilon^v-delta0^v < 1 (9) +``` + +certifies a strict final `t`-moment advantage. The negative term in (9) +belongs to the nonnegative per-owner bound (7), so it is not legitimate to +reuse it after independently discarding other parts of that bound. + +If the h-bound is inconvenient, the valid weaker certificate is + +``` +alpha^v+Q(C,u)gamma^v+3^C delta^v-delta0^v < 1. (10) +``` + +Both improve on charging the entire split/completion invoice on top of the +old moment. Equation (9) is uniformly stronger than (10). Neither requires +the ratios individually to be less than one if the displayed finite +inequality is certified directly. + +For a certificate with interval bounds, all positive terms use upper +bounds and the subtracted `delta0^v` uses a lower bound. Any upper bounds +on `Q` and `h` suffice. Displayed decimals are not substitutes for this +directed exact comparison. + +## 5. What the finite compiler receives + +The transformed unit has all paid ranks at most `J`, all productive ranks +at least `L`, and ambient rank `m^v`; hence strict separation holds. +If (9) or (10) holds, it has `P'_t 9.4810102643e-8, +raw normalized paid log mean < .860094 < 431/500, +full relative paid excess < 1.448e-6 < 1/100000, +largest polynomial coefficient ratio < .019353, +source complement capacity > .0196759. +``` + +The final check is the exact integer inequality + +``` +(3900+125790000000)^24 < 3900^24 * 2^599. +``` + +The previous specified grid point fails. Degree 23 fails this particular +moment-envelope certificate, and dropping tensor concentration makes the +degree-24 certificate fail. These are discriminating checks of the new +argument, not lower bounds on every possible compiler. + +## Reproduction and future use + +From the repository root, with Python 3.12 and no third-party dependencies: + +```sh +python3.12 -B research/net-tax-rank-compiler/verify.py +python3.12 -B scripts/research_package.py --package research/net-tax-rank-compiler +``` + +The first command authenticates the pinned sources, reproduces all seven +certificates, compares the committed receipt, checks the exact exit law +against six literal pinned compiler flows, and runs the mathematical and +rejection controls. It does not rerun the native or outer producer suites. +Use `--write` only after inspecting intentional changes to the exact receipt. + +The generic checker accepts a profile with positive integer `targets` and +`paid` histograms, and a rational witness. See [BENCHMARKS.json](BENCHMARKS.json) +for complete examples of the three compiler methods: + +```sh +python3.12 -B research/net-tax-rank-compiler/compiler.py --example native-concentrated-balanced +python3.12 -B research/net-tax-rank-compiler/compiler.py profile.json witness.json +``` + +The supported profile contract takes the ambient rank as the largest +productive rank and requires all paid ranks to fit. The witness specifies +`saving`, `kappa`, `v`, integer `cutoff` and `floor`, rational `u`, integer +`p` and `log_shift`. `uniform_method` selects `shifted`, `weighted`, or +`log-moments`. The latter two additionally give rational log bounds under +`weighted`; `log-moments` names its raw bound `raw_mean_upper` and requires +`raw_log_bound` and `paid_excess_upper`. The checker verifies every proposed +inequality; numerical search results are never accepted as evidence. + +For a new submission, bind its actual complete native histogram and native +hypotheses, propose a witness, run the checker, then bind the resulting +uniform saving to that submission's complete consumer. A generic profile +file is a conditional mathematical input, not a native admission. + +## Proof and verification boundaries + +Read [PROOF.md](PROOF.md), [SHIFTED-LOG.md](SHIFTED-LOG.md), +[WEIGHTED-EXITS.md](WEIGHTED-EXITS.md), and [LOG-MOMENTS.md](LOG-MOMENTS.md). +[RESULT.json](RESULT.json) records directed interval bounds, the complete +rational coefficient lists, source hashes, exact rank witnesses and rejected +mutations. Interval arithmetic is adapted from my PR4433 code, using exact +fractions, explicit series tails and outward rounding at 192 fractional bits. + +The package verifies the changed finite moment and leaf-count arguments. +The exact raw invoices, native operator receipts and outer parameter points +are inherited from the source-pinned predecessors. Every retained endpoint +has the same κ and a supplied uniform saving at least as strong as its +original consumer requires. This monotone comparison reuses its outer point +and recorded positive margins; checking receipt consistency is explicitly +different from replaying the producer's native or outer proof engines. + +All-column arbitrary-input correctness, whole-job adapters, spectators, +owned-center restoration, native tensor closure, analytic decomposition, +precision, fixed-tape costs, fine-prime exclusions and exact recovery remain +inherited hypotheses. The transformed words are finite algorithmic +prescriptions. Their numerical productive widths, denominator growth, +scalar counts and precision/storage constants are not materialized here; +their complete finite-word counting prescriptions remain required. +No Lean, Docker or all-history replay was run. + +## Open next questions + +- **Tighter raw log moments.** Replace the raw bounded-support chord bound + with exact raw moment enclosures, then check whether the positive + coefficient test reduces the integer degree. This needs a complete, + directed moment list; numerical precision alone is insufficient. +- **A changed paid profile for κ.** Replay one actual native transition + change with its complete invoice, then apply this compiler. The current + profile's raw moment ceiling is unchanged by smaller rank bounds. +- **Width and physical constants.** Start with one small separated unit's + exact batch-width recurrence. Ambient rank does not control the full + materialized word or its owned-bank requirement. + +Structured questions and blockers are in [TASK.json](TASK.json). + +## Attribution and review state + +zxv, with substantial OpenAI Codex assistance, including user-requested +Sol 6.1 xhigh subagents for divergent probes and independent mathematical +audits. These are author-side AI checks, not formal verification or an +independent human review. This contribution remains local for user review. + +The finite integer compiler is Jacob Alan Sussman's Theorem 1G, retained +through PR4268/PR4359. Chronological product/completion and logarithmic +predecessors are retained through PR4414/PR4416, PR4411 and my PR4433. +Native4453 retains Cinna Davis's PR4440/PR4441 contributions and the complete +predecessor attribution, including my κ=.0023 construction. +[SOURCES.json](SOURCES.json) pins exact bytes. New work is Apache-2.0; +existing source notices and frozen evidence are unchanged. diff --git a/research/net-tax-rank-compiler/RESULT.json b/research/net-tax-rank-compiler/RESULT.json new file mode 100644 index 0000000000..602eb0bf1a --- /dev/null +++ b/research/net-tax-rank-compiler/RESULT.json @@ -0,0 +1,1116 @@ +{ + "exact_math_tests": 9, + "examples": { + "native-concentrated-balanced": { + "consumer_binding": { + "available_uniform_saving": "105043/35000000", + "functional_checks_in_receipt": 4, + "legacy_checks_in_receipt": 63, + "producer_replayed": false, + "rank_exponent_reduction": "32855/1797", + "required_uniform_saving": "525213/175000000", + "retained_kappa": "7503/2500000", + "source_H": 2299850000000, + "status": "INHERITED_RECEIPT_AND_MONOTONE_BOUND_BINDING", + "strict_checks_in_receipt": 54 + }, + "net_tax": { + "alpha": { + "lower": "0.999999994166048050341243139078", + "upper": "0.999999994166048050341243139079" + }, + "ambient_base": 153, + "completion_net_tax_upper": { + "lower": "0.000000000484846449554332706462", + "upper": "0.000000000484846449554332706463" + }, + "concavity_remainder": { + "lower": "0.001105751766643808364288097960", + "upper": "0.001105751766643808364288097961" + }, + "cutoff": 20, + "delta": { + "lower": "0.932537503569635779748487117641", + "upper": "0.932537503569635779748487117642" + }, + "delta0": { + "lower": "0.932400961478163177802374052850", + "upper": "0.932400961478163177802374052851" + }, + "epsilon": { + "lower": "0.888130955780605504522368683467", + "upper": "0.888130955780605504522368683468" + }, + "floor": 21, + "gamma": { + "lower": "0.967655820956269741530571022394", + "upper": "0.967655820956269741530571022395" + }, + "normalized_net_charge": { + "lower": "0.999999905189897356748650974084", + "upper": "0.999999905189897356748650974085" + }, + "original_splitting_tax_upper": { + "lower": "0.000001421531411860752586215832", + "upper": "0.000001421531411860752586215833" + }, + "predecessor_full_charge_bound": { + "lower": "1.000386183864934564285670631313", + "upper": "1.000386183864934564285670631314" + }, + "productive_fields_base": 11560, + "rank_one_masses": { + "paid": 259998, + "target": 260798 + }, + "saving": "90037/30000000", + "splitting_coefficient": { + "lower": "0.007333629403448838634819398532", + "upper": "0.007333629403448838634819398533" + }, + "strict_gap_lower": { + "lower": "0.000000094810102643251349025915", + "upper": "0.000000094810102643251349025916" + }, + "u": "171/1000", + "v": 260, + "word_materialized": false + }, + "uniform": { + "H": 125790000000, + "N": "2^125790000000", + "eta": { + "lower": "0.019675906372710418424472814349", + "upper": "0.019675906372710418424472814350" + }, + "gap": "1/210000000", + "grid_index": 599, + "grid_step": 210000000, + "kappa": "7503/2500000", + "log_shift": 3900, + "method": "log-moments", + "ordinary_base_cost": { + "lower": "50.671046496209105952155578480793", + "upper": "50.671046496209105952155578480794" + }, + "ordinary_base_factor": { + "lower": "12977.481816126499548590581723378131", + "upper": "12977.481816126499548590581723378132" + }, + "p": 24, + "previous_grid_point_fails": true, + "uniform_saving": "105043/35000000", + "weighted_exit": { + "A": { + "lower": "3.470673197396387613955465516464", + "upper": "3.470673197396387613955465516465" + }, + "A_lower": "347/100", + "A_upper": "139/40", + "ambient_log_lower": "1679/1000", + "coefficient_ratio_max": { + "lower": "0.019352722774694608575957993948", + "upper": "0.019352722774694608575957993949" + }, + "completed_normalized_log_mean_upper": { + "lower": "0.860095297195434298601204332725", + "upper": "0.860095297195434298601204332726" + }, + "denominator_coefficients": [ + "120600582057083966985222497866594951562051162933266588135349751311636709249689784301586401/1000000000000000000000000000000000000000000000000000000000000000000000000", + "140091299482203946756650799580570647332698796754031453781251909453468271285657544206621941/15625000000000000000000000000000000000000000000000000000000000000000000", + "655248936980435441963651431543824354311388626622339266886848277826949833975871377568964781/3906250000000000000000000000000000000000000000000000000000000000000000", + "302461863406778525621616725778094576895003976282892177613212545734324785668427029821523667/244140625000000000000000000000000000000000000000000000000000000000000", + "549601453365507866728523085031541062277865255939602218486768740801809808451603739488169233/122070312500000000000000000000000000000000000000000000000000000000000", + "7018030724405521320644067028610555214072970513641971461952603152061319875773116798498411/762939453125000000000000000000000000000000000000000000000000000000", + "2202539648018547692552392282816507112851605359623520733933438362242896972839646619091861/190734863281250000000000000000000000000000000000000000000000000000", + "22614709664767393843908654306437583570301686102998584988567812305895124346906581490729/2384185791015625000000000000000000000000000000000000000000000000", + "63646779283742386541657826017972511124697053772971386260418865424680502396373952911651/11920928955078125000000000000000000000000000000000000000000000000", + "39718197745742295807975064220703857647589516793638380769608476858467810014025211177/18626451492309570312500000000000000000000000000000000000000000", + "14448463648231360253271738926770844451256648236319634315895460378468276152897444681/23283064365386962890625000000000000000000000000000000000000000", + "195437270953074588473926732591358053586298917788447818419207517679209780806376219/1455191522836685180664062500000000000000000000000000000000000", + "15972972743184864122149691293341898669389176713405382113474534590753212275290603/727595761418342590332031250000000000000000000000000000000000", + "12465767560288403438211369210554882155539108664577624154299418103562373603687/4547473508864641189575195312500000000000000000000000000000", + "299596170689031874670968977337863792243382454365625204799116192753738336613/1136868377216160297393798828125000000000000000000000000000", + "6959854394963275353657998049679728436854264673684062195421014156243068949/355271367880050092935562133789062500000000000000000000000", + "160192859372107830632618649204969087020287884205489133769079068858740391/142108547152020037174224853515625000000000000000000000000", + "555900940266730676576844743378860891716992913118238885299392685379973/11102230246251565404236316680908203125000000000000000000", + "4731086043186802110697666662074216161081320707685227908371157424229/2775557561562891351059079170227050781250000000000000000", + "7615098643688231931225760775463745710009428445930985813582756867/173472347597680709441192448139190673828125000000000000", + "72613357407572932794668738103941459221571496827460576279594589/86736173798840354720596224069595336914062500000000000", + "154766957201134167926961493349175327843874307419565315109691/13552527156068805425093160010874271392822265625000000", + "355885570479664803993430174414139167342974081519342512861/3388131789017201356273290002718567848205566406250000", + "123244730684073180978444312760214049298336249252019517/211758236813575084767080625169910490512847900390625", + "309948331588294698593287544714691068355585331491841/211758236813575084767080625169910490512847900390625" + ], + "floor_log_lower": "127/125", + "full_paid_relative_excess": { + "lower": "0.000001447491518642763738467577", + "upper": "0.000001447491518642763738467578" + }, + "log_moment_upper_bounds": [ + "1", + "86201/100001", + "48435999/65000650", + "1364637086213/2112521125000", + "308437753109728117/549255492500000000", + "8738323063568447445703/17850803506250000000000", + "15276519456561691021157261/35701607012500000000000000", + "5657124004159348095702170048633/15083928962781250000000000000000", + "646325327250368320781291962965505469/1960910765161562500000000000000000000", + "18509884718635517770440520334746758086507/63729599867750781250000000000000000000000", + "193272601234461939882122357000912878734192547/753167998437054687500000000000000000000000000", + "489653453045298997698617462666573749753636393441/2154060475529976406250000000000000000000000000000", + "56534203769260346846596762115671946690950029465178969/280027861818896932812500000000000000000000000000000000", + "125848253784652816744433115961284421475054270570227396711/700069654547242332031250000000000000000000000000000000000", + "189861520217562160166048117042858420738966317198847102965848301/1183117716184839541132812500000000000000000000000000000000000000", + "5522313133523833113105753159096271783476341265885053594220445709269/38451325776007285086816406250000000000000000000000000000000000000000", + "128820034436151998538908175152441730589489220243311975772263089453965261/999734470176189412257226562500000000000000000000000000000000000000000000", + "3765606512661548537729359320139249851014818193796331238611948117708132810451/32491370280726155898359863281250000000000000000000000000000000000000000000000", + "33952611745165148693846530554138937289138145428838509005606094775142693203917141/324913702807261558983598632812500000000000000000000000000000000000000000000000000", + "12965800498009573765694993402630921113129488988429663458714310211873434453251883213829/137276039436068008670570422363281250000000000000000000000000000000000000000000000000000", + "138835924039826542192378423992885974157598495859836021509299974721107744556253641914628119/1622353193335349193379468627929687500000000000000000000000000000000000000000000000000000000", + "9015784823538256024342420190188286899867781001498830043861225970739521266652564087106363589523/115998253323477467326632006896972656250000000000000000000000000000000000000000000000000000000000", + "1067032923049220883421510364391225726154853473925375742460456592920289616904717060784502927082930957/15079772932052070752462160896606445312500000000000000000000000000000000000000000000000000000000000000", + "31646014742217428903938522201673206398808544713244709059014745645953445021079904033320111884857219434349/490092620291692299455020229139709472656250000000000000000000000000000000000000000000000000000000000000000", + "3763040494571451223735210621765413527744330373580634770827370320687624568045294881480282169009424691387675553/63712040637919998929152629788162231445312500000000000000000000000000000000000000000000000000000000000000000000" + ], + "maximizing_coefficient": 24, + "numerator_coefficients": [ + "2062137846059713494507368073051105971137001507529951614375316476793406991831448800118608137727043162139987463750992207655239973/1019392650206719982866442076610595703125000000000000000000000000000000000000000000000000000000000000000000000000", + "998645066361285161627339654256620189054061734415995266943881655271432028638103889765373700759811042704870535832144700113319770812303/6371267775832637812914192131446011306762695312500000000000000000000000000000000000000000000000000000000000000000000", + "3687073783777443016806295578599553689023910256819687389462499594976640157086962703776418803878473322696702719334746882932014925912769/1225256055482768488325446398724485724399185180664062500000000000000000000000000000000000000000000000000000000000000", + "85259257644934138518886546090127573374000833900288452571283935337216982202992852110014268815976262080295090363843901719093508357909153/3770056332440994818493322009810686059250551300048828125000000000000000000000000000000000000000000000000000000000000", + "175501874131644173490068948240975293772588461131032540778498309453582493873698454562636147247747667736422550386486052596862991594794459/2109143514967451316610633254842396736285954576538085937500000000000000000000000000000000000000000000000000000000000", + "1391815381786752223607212512150693233400544705019643989809483995893622005213770919392799412949450858775553523522512907713675398784218697/8112171563086926888937689850672866000974297831091735839843750000000000000000000000000000000000000000000000000000000", + "13534818067294628777880937492676678841931469553802407457748106000603090048027593683551511346795921777232812650012990316804205978668855227/62401943729250444293896763289010559458725442877461898132324218750000000000000000000000000000000000000000000000000000", + "661464334440591504627379444957431232052795713625355484611342529418890606986728038023817739079476496721392417986694061173094004508254761/3692459630099866082741994216369434885462723676443235074041748046875000000000000000000000000000000000000000000000000", + "59833228372260507457038342385171225774360241487527864338052563759573439702832578039996688046845117185208146315847401233239376299908364181/590799448751386733024451461809855772769852528588799921022798154296875000000000000000000000000000000000000000000000000", + "18447208012639530755195219732113285524520866402300509474583436659631641884537169722662814726293461411695445094551799842970574140038653283/454465659035287882224447466403441439482754020856989083863083370983398437500000000000000000000000000000000000000000000", + "4141616158180736459267946670527868222057814695393935577935665344893198889490134994743819003672873835863186733197763541819841317753581479/349592464378367873156361316060081133767037575690152041349170770628544824218750000000000000000000000000000000000000000", + "9503368031066509144185583405005067209446093380548827840527934114699094868658354818810824542970233608678715709453513183461578438207124733/3697649580128007908832713150390056808040507410312498434197525851633425198400878906250000000000000000000000000000000000", + "670746325064630784190875748207355134092213170467221849651289246680686446957581824984615231384955855339610576679705636935875762522607/1593431196009107282458565705260938701719057591879879904735879352163145131269531250000000000000000000000000000000000", + "141783998806490618476815445539181933887541120506143708390702596029705213353183096977263332540411567319347475651198182211535593045311393/2692925650242603861268049591651405315769266382350299808974026141516766828998226267578125000000000000000000000000000000", + "24817380092039490002912449776223635279947543177884629418472735030515189698467701834573054239229000162962180910828572155081071737718799/4896277417271102340557567767540585145131680136389315112676574330505785448484574999710546875000000000000000000000000000", + "35521036558995230491762462063447675901718013400871266771611815589883458846116217187818292276959926099866384408390181982529537921627229/94160122693178366376557179677274241365060220253666903958225021081713278968058843181933538085937500000000000000000000000", + "50363397192899147716195724129790833326142836631091412916640695219605226104581214732617607244503695531676497051620618489051541488979937/2317810813400745800866977113823286501107049128759863153901897928170439288636271354347454951909375000000000000000000000000", + "1722299519112699594388784041319566006414294394645130511728634493990178089261168130159540495955741072212204783955179432520053481044039/1782949224237599852557681371995711333824661691731654425025720728576708456176275166969998789583764687500000000000000000000", + "2051549341206425683650881171293253935401175511292977714949613712628265674654332042784583629388048327451956409164795558131529225351/62341505375169308690776466741588506676153843998201809145803181321118679134994298242016380754253864515625000000000000000", + "894670599903329731333088305299118104687528130458762964844859633367014533094125501409205254923281393443423255939905215829367171167/1055020641065313329573072491644330997189887170620091850465909281357308913137910969284595092459500734764571875000000000000", + "47751099705639321960581406340104898373903033001042249216677859451247183539676215482185186404478525949899559161362322901395532169/2951136199361465685891939083550342490908696697879155388487871162098244716718999575928078149399791132229145512500000000000", + "5513957143090635009474491103568599383970734081827376798147452737467259726084609876736464649950718897120290090902964453766350261/24971402167660040235412906178733044567438202794851904600353320345314248223713718788586316716918566485803958341158750000000", + "858602638581411384438408126497023955077818051768616593566536689766306681690812426065157885321643734754710746113087468706092949/422597185689998284913796712901143309041111767608735975866757788713376484658700792590024966739912449824856892597175042250000", + "3660636248367252138453725003480071163537027573855914516003487487983726427088452404165847197619612148132903757951849713692567/325078008970657834535881423744824861903232445174163125558858812531741244941190291998423743838138345345657800897000780000325", + "28333178412079463821055346771782989625688214347123956821468603656941748560781642533001682048003322509856414874675508801/1000240027602024106264250534599461113548407523612809617104180961636126907511354744610534596425041062602024002760002400001" + ], + "paid_excess_upper": "1/100000", + "raw_log_bound": "3/2", + "raw_mean_upper": "431/500", + "raw_normalized_log_mean": { + "lower": "0.860093849703915655837465865147", + "upper": "0.860093849703915655837465865148" + } + }, + "word_materialized": false + } + }, + "native-concentrated-same-C": { + "consumer_binding": { + "available_uniform_saving": "525213/175000000", + "functional_checks_in_receipt": 4, + "legacy_checks_in_receipt": 63, + "producer_replayed": false, + "rank_exponent_reduction": "6571/541", + "required_uniform_saving": "525213/175000000", + "retained_kappa": "7503/2500000", + "source_H": 2299850000000, + "status": "INHERITED_RECEIPT_AND_MONOTONE_BOUND_BINDING", + "strict_checks_in_receipt": 54 + }, + "net_tax": { + "alpha": { + "lower": "0.999999980480394484617151340349", + "upper": "0.999999980480394484617151340350" + }, + "ambient_base": 153, + "completion_net_tax_upper": { + "lower": "0.000000004253136810652179152787", + "upper": "0.000000004253136810652179152788" + }, + "concavity_remainder": { + "lower": "0.001105746846824639582517605973", + "upper": "0.001105746846824639582517605974" + }, + "cutoff": 20, + "delta": { + "lower": "0.932537496018535482645863756363", + "upper": "0.932537496018535482645863756364" + }, + "delta0": { + "lower": "0.932400954534728454117835318138", + "upper": "0.932400954534728454117835318139" + }, + "epsilon": { + "lower": "0.888130948589081412043679767964", + "upper": "0.888130948589081412043679767965" + }, + "floor": 21, + "gamma": { + "lower": "0.967680583560301995122679333354", + "upper": "0.967680583560301995122679333355" + }, + "normalized_net_charge": { + "lower": "0.999999778491395888838568958850", + "upper": "0.999999778491395888838568958851" + }, + "original_splitting_tax_upper": { + "lower": "0.000004205178937668649448311045", + "upper": "0.000004205178937668649448311046" + }, + "predecessor_full_charge_bound": { + "lower": "1.001149814170285771597867700095", + "upper": "1.001149814170285771597867700096" + }, + "productive_fields_base": 11560, + "rank_one_masses": { + "paid": 259998, + "target": 260798 + }, + "saving": "150061/50000000", + "splitting_coefficient": { + "lower": "0.007288100286103697517156721620", + "upper": "0.007288100286103697517156721621" + }, + "strict_gap_lower": { + "lower": "0.000000221508604111161431041149", + "upper": "0.000000221508604111161431041150" + }, + "u": "861/5000", + "v": 227, + "word_materialized": false + }, + "uniform": { + "H": 189350000000, + "N": "2^189350000000", + "eta": { + "lower": "0.032382825087010588608864248290", + "upper": "0.032382825087010588608864248291" + }, + "gap": "1/350000000", + "grid_index": 541, + "grid_step": 350000000, + "kappa": "7503/2500000", + "log_shift": 3405, + "method": "log-moments", + "ordinary_base_cost": { + "lower": "30.787887632444907912678916220096", + "upper": "30.787887632444907912678916220097" + }, + "ordinary_base_factor": { + "lower": "3972.296205213899032456444751275063", + "upper": "3972.296205213899032456444751275064" + }, + "p": 21, + "previous_grid_point_fails": true, + "uniform_saving": "525213/175000000", + "weighted_exit": { + "A": { + "lower": "3.470673197396387613955465516464", + "upper": "3.470673197396387613955465516465" + }, + "A_lower": "347/100", + "A_upper": "139/40", + "ambient_log_lower": "1679/1000", + "coefficient_ratio_max": { + "lower": "0.031688327364701261637953429177", + "upper": "0.031688327364701261637953429178" + }, + "completed_normalized_log_mean_upper": { + "lower": "0.860098327562930756011096334931", + "upper": "0.860098327562930756011096334932" + }, + "denominator_coefficients": [ + "883447463930444712235886675793371162533624351604016247554458027902301325383149/1000000000000000000000000000000000000000000000000000000000000000", + "4736922792108896916920118845350561645062647971111512672710671858243264733008747/125000000000000000000000000000000000000000000000000000000000000", + "685986050958760330418874010205278493789133236347393500688662376913879397729681/1562500000000000000000000000000000000000000000000000000000000", + "410939691529848673085988144563459134011552753297015602059378146861090936560779/195312500000000000000000000000000000000000000000000000000000", + "250051940225663362974521842179967629476919865299878626109129945509223367992073/48828125000000000000000000000000000000000000000000000000000", + "43693086661540304562219323053776651430303887526925683508087765521331352396903/6103515625000000000000000000000000000000000000000000000000", + "2973138028164414059051315733179597358890913947959139067554711978130909760083/476837158203125000000000000000000000000000000000000000000", + "213549492208733116115809213207270830389228298858379262749835817406556455209/59604644775390625000000000000000000000000000000000000000", + "42190984073309767181608727890265100630200952526693674867322525751779756509/29802322387695312500000000000000000000000000000000000000", + "1477612761788935944075649692556149878686377339073610835993675050659948779/3725290298461914062500000000000000000000000000000000000", + "18766168667076263531312917086174234297818346837784431762474359936109719/232830643653869628906250000000000000000000000000000000", + "351413547210732218848565268575079250094714387231950728374782925815037/29103830456733703613281250000000000000000000000000000", + "1962096074333656049165470282821503815436166605661467862082042201117/1455191522836685180664062500000000000000000000000000", + "102718952069906422426013846244798293922236911355160896707663277711/909494701772928237915039062500000000000000000000000", + "40397214484292387855561452294472608858259673674300193148621119/5684341886080801486968994140625000000000000000000", + "1189053543217003945042796092160905592033642336630654964676849/3552713678800500929355621337890625000000000000000", + "41486939458809279963242847610606296920283256145338574698041/3552713678800500929355621337890625000000000000000", + "131531635562873761007130691922492769794110829783403245343/444089209850062616169452667236328125000000000000", + "29339533982776349978593873360100241309580097717396161/5551115123125782702118158340454101562500000000", + "43481068681037372165253559014731618761674235805179/693889390390722837764769792556762695312500000", + "383036832090610985740265237532920452797521870289/867361737988403547205962240695953369140625000", + "151313661355466579537756144585602921111718527/108420217248550443400745280086994171142578125" + ], + "floor_log_lower": "127/125", + "full_paid_relative_excess": { + "lower": "0.000004465382864981825236973860", + "upper": "0.000004465382864981825236973861" + }, + "log_moment_upper_bounds": [ + "1", + "86201/100001", + "84611607/113501135", + "83319388192/128823788225", + "2057717209191442/3655374990884375", + "203917302397906572571/414885061465376562500", + "5067769452592213974801793/11772363619080059960937500", + "505335576544482506157628273543/1336163270765586805566406250000", + "2527198359404298466844060991607763/7582726561594705121589355468750000", + "253537174835430108721286068278374798207/860639464740999031300391845703125000000", + "579816871688752527505465199460607379288899/2220058619275077046649874420166015625000000", + "643682834929594720314562692977099080978940743253/2771743186164933692742368213577270507812500000000", + "16288235790016960879594418964502655356601810715178697/78648212907429993531564698060255050659179687500000000", + "330694757951279319907753132044773600870430067041632886901/1785314432998660853166518645967789649963378906250000000000", + "8416652864165622802095012671923276086148821483375772148730871/50658297036337001708599966579336031317710876464843750000000000", + "859306779404414493066904198675830099095590393586477172856156976413/5749716713624249693926096206754639554560184478759765625000000000000", + "21994895977446900099119971700793338255228922845591512579633423074070909/163148211749088085065152979866662897360645234584808349609375000000000000", + "2258233002313888284634699510175129865561300723116002185321664292767173823369/18517322033521497654894863214866238850433234125375747680664062500000000000000", + "11624848440041454510750927033470474838670444029569190945458695513120441305889547/105085802540234499191528348744365905476208603661507368087768554687500000000000000", + "600062231005838148325831831199031506487558585169136766176450833516490992369936088269/5963619294158307829119233791242765135774838257790543138980865478515625000000000000000", + "1411763595138825175732800785871780963602941700531805009840069177053936490002344687234223/15383427042885634968296205347864860066146457778618787415325641632080078125000000000000000", + "1611912714294816976087265352133708549968081181020242962517706741224708631348238262266248826051/19206208663042715257917812376809277792583852536605556088034063577651977539062500000000000000000" + ], + "maximizing_coefficient": 21, + "numerator_coefficients": [ + "33381325498576173946633352804456890625347204719556265988143242909030365314803195967818835311208780966985056698139759277939/1351516784032486946960133475766433823924661747423764582400000000000000000000000000000000000000000000000000000", + "1687657483901809701629373517272210660993601251167070938170728986362160454615027748458425997821080805165105362459430167036859603/1535829885454917354351821678524081236662387493228680477324800000000000000000000000000000000000000000000000000000", + "4406593638937689563155101885793996865691384197785873611865315452068664128812407862985885031853321586324625547762548209748306591/338291903910522445710432862718252528078139673370839815887571200000000000000000000000000000000000000000000000000", + "171796575138269319852688129104574782123090621239169039813094331738800254466136423555633096325299419447919315042093854094976497/2709613831233973175289467096891307253531601560012603318267761920000000000000000000000000000000000000000000000", + "4097682450003474265264940469071148375391075348514905041841054688705731186640492450379211657441741426947929563213099990169135459/26260837181581621731483189345537478266648022587057478314810916805120000000000000000000000000000000000000000000", + "1156465497032203623118985666917982067375443181611533257029193760889866257731167372793146342865328857154369979681406219051146897/5258530194223756016760213091195621474055003818038315756827005389324800000000000000000000000000000000000000000", + "3069848655704013772843402376510826026051344774506609233878311500360893192243465347398165109397288783097971338752822866403879469/15926324497462191849538597914810536270090084815209652406340944452964104000000000000000000000000000000000000000", + "780891960415226343270737147660758230777636075166573618183156606924050434639369160803154891301818223512358387959044900900209261/7016072141280690075531759163343473293151006923373482159852426371105124952000000000000000000000000000000000000", + "109167664490247631052297897729546546216680239616286658864980592043783196560192658185602110032379248805355219484674895986507471/2472649269428053879271370742179773296170550989759547451867497760482409164140800000000000000000000000000000000", + "13516268373492040599479785197044124946166466583465414333917056033358330582476250713655481711306074519569633019789306108790131/1089283698643501391986856147967927354142516605845570505437011645577098673230150400000000000000000000000000000", + "3032559551281794370645717550291599598291762570722240454504728853300699827086744224714106568299476115919439166793959832139801/1199663647004942540749753322168950477330460386576683877909764334464267009049430288000000000000000000000000000", + "1002744213025635549809294715175676971729125034967947569316709212898368534925934859239692827903501634732069546539483500593093/2642457364848926410077446739432097283778047777930726089754500951778880290131103044720000000000000000000000000", + "98825858485747314083351078810278361105918420103230921345659868844105713519687768592107886013797183110444544334336590034659/2328179550152048369463918514448891281718841901681502552436474446509601831659915731938720000000000000000000000", + "8034028057713130517454255948556380409966035979534204391762584666724837970336424307737783078396991935599326503639015823169/2256408030962383153253193364755453169775176210670106875954360081391606714049388162295720992000000000000000000", + "55741462426227847804543958666028475488928955192242787003785729298226217176649736902543494719836726432895185187896275351/248505572141265724348538094349019903558025766787688719936466919052028703757326944512923342424000000000000000", + "526165548759686098145073009269941590216904519816164471108870583646478647322868429294028141111308575740866366381256969/49761325029432746697192947482972245445947406296627272091242748041894117750173111290021720395960000000000000", + "323754693913279674541697492748769629763247655608418803384278571682631350686415192977757868386761052385388549787373719/876860310884282661227487566739155509575363273492339002008170228535234126719834590680786266311259200000000000", + "39818021316703088552305685858194027957327695715459198895192357665115262571737721047355798763002111696664829098854521/4249145319101897156209294386679758551733501893557626951268763617891063554921638625239481857230460545600000000", + "31318609622707673862111854306531183690049100399501107986032389442515431170807287866188529147789108448979847369469/187188890332823267629112620247736799529472212712623899891554022269922575575206512846948645464715103533280000", + "163645697748391089490273719224813591793836555495936580117762260491499209945949472661324835360985826060156950293/82462890846575592890655908094246377487871148649670055564120236920768843524652980137478905264832489288244640", + "127057886584561407085334329857200202932771964618779781689388944613485511204459573606188523421645832603607529053/9081906990692076943456477384727678408771588916426933068796902876997582732718967694634392076419068019068009080", + "44234221092026053757821239229324760531561751071429280695515994821806815750175243229402504974160634210201/1000210021001330059852034954265162820349293933527195271893932034911628054264203490598501330002100002100001" + ], + "paid_excess_upper": "1/100000", + "raw_log_bound": "3/2", + "raw_mean_upper": "431/500", + "raw_normalized_log_mean": { + "lower": "0.860093862180065774185859361071", + "upper": "0.860093862180065774185859361072" + } + }, + "word_materialized": false + } + }, + "native-net-shift": { + "consumer_binding": { + "available_uniform_saving": "525213/175000000", + "functional_checks_in_receipt": 4, + "legacy_checks_in_receipt": 63, + "producer_replayed": false, + "rank_exponent_reduction": "6571/2765", + "required_uniform_saving": "525213/175000000", + "retained_kappa": "7503/2500000", + "source_H": 2299850000000, + "status": "INHERITED_RECEIPT_AND_MONOTONE_BOUND_BINDING", + "strict_checks_in_receipt": 54 + }, + "net_tax": { + "alpha": { + "lower": "0.999999980480394484617151340349", + "upper": "0.999999980480394484617151340350" + }, + "ambient_base": 153, + "completion_net_tax_upper": { + "lower": "0.000004364803520178245236237837", + "upper": "0.000004364803520178245236237838" + }, + "concavity_remainder": { + "lower": "0.001105746846824639582517605973", + "upper": "0.001105746846824639582517605974" + }, + "cutoff": 18, + "delta": { + "lower": "0.977253011855658562221385892786", + "upper": "0.977253011855658562221385892787" + }, + "delta0": { + "lower": "0.976664631677490096071204495515", + "upper": "0.976664631677490096071204495516" + }, + "epsilon": { + "lower": "0.799570646063720641817497548643", + "upper": "0.799570646063720641817497548644" + }, + "floor": 22, + "gamma": { + "lower": "0.981971726999571315878434078558", + "upper": "0.981971726999571315878434078559" + }, + "normalized_net_charge": { + "lower": "0.999996829571729106399397178801", + "upper": "0.999996829571729106399397178802" + }, + "original_splitting_tax_upper": { + "lower": "0.000001756057360637542674691433", + "upper": "0.000001756057360637542674691434" + }, + "predecessor_full_charge_bound": { + "lower": "1.000372586718960987074603543263", + "upper": "1.000372586718960987074603543264" + }, + "productive_fields_base": 11560, + "rank_one_masses": { + "paid": 259998, + "target": 260798 + }, + "saving": "150061/50000000", + "splitting_coefficient": { + "lower": "0.010125639068149840285647268152", + "upper": "0.010125639068149840285647268153" + }, + "strict_gap_lower": { + "lower": "0.000003170428270893600602821198", + "upper": "0.000003170428270893600602821199" + }, + "u": "3/25", + "v": 476, + "word_materialized": false + }, + "uniform": { + "H": 967750000000, + "N": "2^967750000000", + "eta": { + "lower": "0.000754547474185486933219190219", + "upper": "0.000754547474185486933219190220" + }, + "gap": "1/350000000", + "grid_index": 2765, + "grid_step": 350000000, + "kappa": "7503/2500000", + "log_shift": 19040, + "method": "shifted", + "ordinary_base_cost": { + "lower": "1321.320147650394729187842555665094", + "upper": "1321.320147650394729187842555665095" + }, + "ordinary_base_factor": { + "lower": "66107367.515365596532016231725406878240", + "upper": "66107367.515365596532016231725406878241" + }, + "p": 108, + "previous_grid_point_fails": true, + "theta": "173/185", + "uniform_saving": "525213/175000000", + "word_materialized": false + } + }, + "native-source-parameters": { + "consumer_binding": { + "available_uniform_saving": "525213/175000000", + "functional_checks_in_receipt": 4, + "legacy_checks_in_receipt": 63, + "producer_replayed": false, + "rank_exponent_reduction": "1", + "required_uniform_saving": "525213/175000000", + "retained_kappa": "7503/2500000", + "source_H": 2299850000000, + "status": "INHERITED_RECEIPT_AND_MONOTONE_BOUND_BINDING", + "strict_checks_in_receipt": 54 + }, + "net_tax": { + "alpha": { + "lower": "0.999999980480394484617151340349", + "upper": "0.999999980480394484617151340350" + }, + "ambient_base": 153, + "completion_net_tax_upper": { + "lower": "0.000000060052817548701191872008", + "upper": "0.000000060052817548701191872009" + }, + "concavity_remainder": { + "lower": "0.001105746846824639582517605973", + "upper": "0.001105746846824639582517605974" + }, + "cutoff": 18, + "delta": { + "lower": "0.977253011855658562221385892786", + "upper": "0.977253011855658562221385892787" + }, + "delta0": { + "lower": "0.976664631677490096071204495515", + "upper": "0.976664631677490096071204495516" + }, + "epsilon": { + "lower": "0.799570646063720641817497548643", + "upper": "0.799570646063720641817497548644" + }, + "floor": 22, + "gamma": { + "lower": "0.981971726999571315878434078558", + "upper": "0.981971726999571315878434078559" + }, + "normalized_net_charge": { + "lower": "0.999986931420767776182585713057", + "upper": "0.999986931420767776182585713058" + }, + "original_splitting_tax_upper": { + "lower": "0.000000047015002103422332013161", + "upper": "0.000000047015002103422332013162" + }, + "predecessor_full_charge_bound": { + "lower": "0.999996470237080130167576831940", + "upper": "0.999996470237080130167576831941" + }, + "productive_fields_base": 11560, + "rank_one_masses": { + "paid": 259998, + "target": 260798 + }, + "saving": "150061/50000000", + "splitting_coefficient": { + "lower": "0.010125639068149840285647268152", + "upper": "0.010125639068149840285647268153" + }, + "strict_gap_lower": { + "lower": "0.000013068579232223817414286942", + "upper": "0.000013068579232223817414286943" + }, + "u": "3/25", + "v": 675, + "word_materialized": false + }, + "uniform": { + "H": 2299850000000, + "N": "2^2299850000000", + "eta": { + "lower": "0.000037402048244786272108248731", + "upper": "0.000037402048244786272108248732" + }, + "gap": "1/350000000", + "grid_index": 6571, + "grid_step": 350000000, + "kappa": "7503/2500000", + "log_shift": 1, + "method": "shifted", + "ordinary_base_cost": { + "lower": "26656.261536130671513711578407307682", + "upper": "26656.261536130671513711578407307683" + }, + "ordinary_base_factor": { + "lower": "267694942215561885759272880041880831892636834258631116311698250860802331654876074069894046033948125898443838918385195838082756425482317467039027699496433289330162974770067221610815524231296755934942652439677452910274860327315054710197958597952276785268229395338649775171563335829726820284119487089139881578668883657403257100441406263810921146057022571941605637346753723029657962947464901656427325368793817171764556048306294277058705951831353196206205621302314471472108355845663696487989144051287492238048307523402007707250360523850416125492683304294723707595137781290596861589731634843546442.995990766841384415868643409334", + "upper": "267694942215561885759272880041880831892636834258631116328618412640433566922146474715544713703370486436685783850953258256132778811833634663445420922749256369730460192128259516546170257040632035940317955776131178509576423452919410542836245428284906882046738880198963044939075874360151165452299798895689155230192551789456907271664942891756059061883883996833204282454363378864997122212545323122097510012024912589198313992567964515852176373195933618819224772702439799687563690509734115252271624229131037507175306660844179682064676718225404685711489106338671938818492975872517936528993887850276327.513876789723636475978575589811" + }, + "p": 160, + "previous_grid_point_fails": true, + "theta": "15/16", + "uniform_saving": "525213/175000000", + "word_materialized": false + } + }, + "native-weighted-same-C": { + "consumer_binding": { + "available_uniform_saving": "525213/175000000", + "functional_checks_in_receipt": 4, + "legacy_checks_in_receipt": 63, + "producer_replayed": false, + "rank_exponent_reduction": "6571/819", + "required_uniform_saving": "525213/175000000", + "retained_kappa": "7503/2500000", + "source_H": 2299850000000, + "status": "INHERITED_RECEIPT_AND_MONOTONE_BOUND_BINDING", + "strict_checks_in_receipt": 54 + }, + "net_tax": { + "alpha": { + "lower": "0.999999980480394484617151340349", + "upper": "0.999999980480394484617151340350" + }, + "ambient_base": 153, + "completion_net_tax_upper": { + "lower": "0.000000004253136810652179152787", + "upper": "0.000000004253136810652179152788" + }, + "concavity_remainder": { + "lower": "0.001105746846824639582517605973", + "upper": "0.001105746846824639582517605974" + }, + "cutoff": 20, + "delta": { + "lower": "0.932537496018535482645863756363", + "upper": "0.932537496018535482645863756364" + }, + "delta0": { + "lower": "0.932400954534728454117835318138", + "upper": "0.932400954534728454117835318139" + }, + "epsilon": { + "lower": "0.888130948589081412043679767964", + "upper": "0.888130948589081412043679767965" + }, + "floor": 21, + "gamma": { + "lower": "0.967680583560301995122679333354", + "upper": "0.967680583560301995122679333355" + }, + "normalized_net_charge": { + "lower": "0.999999778491395888838568958850", + "upper": "0.999999778491395888838568958851" + }, + "original_splitting_tax_upper": { + "lower": "0.000004205178937668649448311045", + "upper": "0.000004205178937668649448311046" + }, + "predecessor_full_charge_bound": { + "lower": "1.001149814170285771597867700095", + "upper": "1.001149814170285771597867700096" + }, + "productive_fields_base": 11560, + "rank_one_masses": { + "paid": 259998, + "target": 260798 + }, + "saving": "150061/50000000", + "splitting_coefficient": { + "lower": "0.007288100286103697517156721620", + "upper": "0.007288100286103697517156721621" + }, + "strict_gap_lower": { + "lower": "0.000000221508604111161431041149", + "upper": "0.000000221508604111161431041150" + }, + "u": "861/5000", + "v": 227, + "word_materialized": false + }, + "uniform": { + "H": 286650000000, + "N": "2^286650000000", + "eta": { + "lower": "0.032382825087010588608864248290", + "upper": "0.032382825087010588608864248291" + }, + "gap": "1/350000000", + "grid_index": 819, + "grid_step": 350000000, + "kappa": "7503/2500000", + "log_shift": 454, + "method": "weighted", + "ordinary_base_cost": { + "lower": "30.787887632444907912678916220096", + "upper": "30.787887632444907912678916220097" + }, + "ordinary_base_factor": { + "lower": "4293752188920541966.342259029754834491198963559165", + "upper": "4293752188920541966.342259029754834491198963559166" + }, + "p": 28, + "previous_grid_point_fails": true, + "uniform_saving": "525213/175000000", + "weighted_exit": { + "A": { + "lower": "0.462756426319518348527395402195", + "upper": "0.462756426319518348527395402196" + }, + "A_lower": "231/500", + "A_upper": "463/1000", + "ambient_log_lower": "1679/1000", + "coefficient_ratio_max": { + "lower": "0.032042961827364629932195365523", + "upper": "0.032042961827364629932195365524" + }, + "completed_normalized_log_mean_upper": { + "lower": "0.860098327562930756011096334931", + "upper": "0.860098327562930756011096334932" + }, + "denominator_coefficients": [ + "1808284185863726540702967547173055928078210174894892077356143934264567521633136942977046092721/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "596430825264474838099419057796928332073220241846930949550486678119805589488440141343621955308573/6250000000000000000000000000000000000000000000000000000000000000000000000000000000", + "36814858936591661397439705900337861057490360254679372361904581491315017695126152917587948864550237/312500000000000000000000000000000000000000000000000000000000000000000000000000000", + "1702020144942068007690595151280795411494056539635594558489033291572678041630953171333099894688743353/97656250000000000000000000000000000000000000000000000000000000000000000000000000", + "155759610013868990297525291740043135581525417536393232783266374717874541263464109376710763944986823451/244140625000000000000000000000000000000000000000000000000000000000000000000000000", + "32447331258461605316561558139573243866109743303354278949456073215706263518909547861290102791010585659/3814697265625000000000000000000000000000000000000000000000000000000000000000000", + "49604342396965407024930669082730368729079537720155849133418229409922164698099810122528711054193952337/953674316406250000000000000000000000000000000000000000000000000000000000000000", + "10091061224481847895875862023553770424945582142670970339294260831140901228060857425346367662124856571/59604644775390625000000000000000000000000000000000000000000000000000000000000", + "19357498166982316201834041477341196067419741603194494180580964052155793347019513198947341239790855961/59604644775390625000000000000000000000000000000000000000000000000000000000000", + "5884654865390220331503506952872155480245177709010815093815417195587265231334563157630161474777631/14901161193847656250000000000000000000000000000000000000000000000000000000", + "29919614329112170704485547105165448255200190310349974815988821374999465504643162228766350008557791/93132257461547851562500000000000000000000000000000000000000000000000000000", + "1060127679176428711746506735006953521754479883685679731918691323719842752679736625408345387123043/5820766091346740722656250000000000000000000000000000000000000000000000000", + "216125580244242635668151945015815061296739050618009947114774482884592427374440180463348841889983/2910383045673370361328125000000000000000000000000000000000000000000000000", + "20298268091092026318690926701134192340427656902396698101547054061921561240718108914284334069/909494701772928237915039062500000000000000000000000000000000000000000", + "5729704299983446598819461137892779929055195988103196054191716600715417077949878717072043583/1136868377216160297393798828125000000000000000000000000000000000000000", + "308367698233694482019668061121678529365783918555807726223970976647101965711498627262994757/355271367880050092935562133789062500000000000000000000000000000000000", + "81923057474567640087855505570860221671452859034359822585843064656120937009216981555789199/710542735760100185871124267578125000000000000000000000000000000000000", + "52885879973424031037713709914014007144018395070972427949937853756370693733549834597023/4440892098500626161694526672363281250000000000000000000000000000000", + "1067425712900408453035868242800415435795678278163116896148518415091298544666983085747/1110223024625156540423631668090820312500000000000000000000000000000", + "4219799779395377069763444461383231455107080688179300893204784383156643109732883747/69388939039072283776476979255676269531250000000000000000000000000", + "522421612470664508690257290008392101231562533085205555996614374849142875481079253/173472347597680709441192448139190673828125000000000000000000000000", + "63035179665958625170909560046714094313045366841199848922280151397820868163211/542101086242752217003726400434970855712890625000000000000000000", + "470469775915280509688092723628659337017869568616004126052832604989165425593/135525271560688054250931600108742713928222656250000000000000000", + "133867708907810158479164162469900782694154942053669806162638857582719199/1694065894508600678136645001359283924102783203125000000000000", + "56812131922264485408762385838504623097134955491068173796404267595493551/42351647362715016953416125033982098102569580078125000000000000", + "108468789314613320716388072170928346884774378073025702396314703216293/6617444900424221398971269536559702828526496887207031250000000", + "224709887453168148200390874928821342844930490414960246531762022069/1654361225106055349742817384139925707131624221801757812500000", + "70472476263831366588476578784169041535492831817626866232689897/103397576569128459358926086508745356695726513862609863281250", + "80631397449585884167753993329574755403270206405810971374081/51698788284564229679463043254372678347863256931304931640625" + ], + "floor_log_lower": "127/125", + "full_paid_relative_excess": { + "lower": "0.000004465382864981825236973860", + "upper": "0.000004465382864981825236973861" + }, + "maximizing_coefficient": 11, + "mean_upper": "431/500", + "numerator_coefficients": [ + "36504667523283372496164164310126922643795971902886487561026481282417087361175540943462233/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "8490395228733322650483300259141175607316365102358679963954315706974764573971189220440100101661/125000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "407477995555848662796537500893382325387626915967585828608764191883455509667469007039369250955477/1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "4438795666907729592969887787705671130789502273945603945080975930783518186733412521714281263674664597/31250000000000000000000000000000000000000000000000000000000000000000000000000000000", + "21752254091255382585831342199127672961081727032258746723466840851913462275685625161103075070245547203/2500000000000000000000000000000000000000000000000000000000000000000000000000000000", + "125753951469783300683479146429288732572135973744985545388458271222253922170892875832718457400513706587/781250000000000000000000000000000000000000000000000000000000000000000000000000000", + "952767403719305706726862329877803235487276565987032659916069671826025297190156513128610120954278597297/781250000000000000000000000000000000000000000000000000000000000000000000000000000", + "178444467875094853441374499896529272580602166973123591680824782868002598313025943011995439147293453443/39062500000000000000000000000000000000000000000000000000000000000000000000000000", + "7487565274032247573953368268457898416468002008150068181096495776525281267186637125150541001642465154141/781250000000000000000000000000000000000000000000000000000000000000000000000000000", + "239966740470880845534895070665052469156336696413113542867463761209306867151436430145614811205305246511/19531250000000000000000000000000000000000000000000000000000000000000000000000000", + "1001103934745868077423803915457030699027716905336389037424461302029833313576111364928093841908989539027/97656250000000000000000000000000000000000000000000000000000000000000000000000000", + "142478958158342362675100026568217710834639673115150116274114501315462626434459066865117980775670227963/24414062500000000000000000000000000000000000000000000000000000000000000000000000", + "22947850305226636163931933325017117205807568283078272429580196091955452187081763091111166996013990227/9765625000000000000000000000000000000000000000000000000000000000000000000000000", + "1049960782085096330491894401099186735869327983221218601796261981449216569523774166543932160418027889/1525878906250000000000000000000000000000000000000000000000000000000000000000000", + "45696564441130397378362149426590246923339436196633227260515360099073690390651919170021645044287499/305175781250000000000000000000000000000000000000000000000000000000000000000000", + "9393148882756589682089309957722249497815154757276945181616271844463362641271941509744691142590053/381469726562500000000000000000000000000000000000000000000000000000000000000000", + "9457563298287887205336902367019816963077606700412721100639268005569735518537976930498098281662279/3051757812500000000000000000000000000000000000000000000000000000000000000000000", + "22986802093084164527522949501567762662079586796558145100597914721112482681530395658575480849139/76293945312500000000000000000000000000000000000000000000000000000000000000000", + "8684492896362163823924088878384387139972844237144664636466715255613525856226103113361546007459/381469726562500000000000000000000000000000000000000000000000000000000000000000", + "25578897294343604861419942008140876774183602625215688971853536962205449447447134213471222859/19073486328125000000000000000000000000000000000000000000000000000000000000000", + "11745864071704310248921218243711703155774858081750363737839717694658117728381710949856145413/190734863281250000000000000000000000000000000000000000000000000000000000000000", + "26183753687717393583599155970874935357359980659962522087878524308680530252489381727527763/11920928955078125000000000000000000000000000000000000000000000000000000000000", + "143930152998042142521993361024312390761588217033305802398911014216380268106731487266077/2384185791015625000000000000000000000000000000000000000000000000000000000000", + "3758888255263971542589302524160539041242136499717586830726839466403052815488357057911/2980232238769531250000000000000000000000000000000000000000000000000000000000", + "46725470301106159509243654086702340617733956065901720885762479340573570352374507883/2384185791015625000000000000000000000000000000000000000000000000000000000000", + "1629131485032213594525805334953466679869465625333466122169664599757215904452879089/7450580596923828125000000000000000000000000000000000000000000000000000000000", + "12299022910438634571675263256698452977216855489477754441620561843906409134622929/7450580596923828125000000000000000000000000000000000000000000000000000000000", + "561098396673636890118142489521264961349902196520296156037167276905281407161/74505805969238281250000000000000000000000000000000000000000000000000000000", + "58259072263632257200896028182044133544159924524270692183093012851403586241/3725290298461914062500000000000000000000000000000000000000000000000000000000" + ], + "raw_normalized_log_mean": { + "lower": "0.860093862180065774185859361071", + "upper": "0.860093862180065774185859361072" + } + }, + "word_materialized": false + } + }, + "p7-net-shift-balanced": { + "consumer_binding": { + "available_uniform_saving": "11551881/4300000000", + "functional_checks_in_receipt": 3, + "legacy_checks_in_receipt": 63, + "producer_replayed": false, + "rank_exponent_reduction": "17465/4429", + "required_uniform_saving": "376107/140000000", + "retained_kappa": "268647/100000000", + "source_H": 349300000000, + "status": "INHERITED_RECEIPT_AND_MONOTONE_BOUND_BINDING", + "strict_checks_in_receipt": 54 + }, + "net_tax": { + "alpha": { + "lower": "0.999999995226160367448558520784", + "upper": "0.999999995226160367448558520785" + }, + "ambient_base": 121, + "completion_net_tax_upper": { + "lower": "0.000000229256243311259605573976", + "upper": "0.000000229256243311259605573977" + }, + "concavity_remainder": { + "lower": "0.000989632686375363818713799788", + "upper": "0.000989632686375363818713799789" + }, + "cutoff": 10, + "delta": { + "lower": "0.877942790977848064391977059295", + "upper": "0.877942790977848064391977059296" + }, + "delta0": { + "lower": "0.876986989232235238455954259827", + "upper": "0.876986989232235238455954259828" + }, + "epsilon": { + "lower": "0.585295193985232042927984706197", + "upper": "0.585295193985232042927984706198" + }, + "floor": 15, + "gamma": { + "lower": "0.904120626501763030210363841895", + "upper": "0.904120626501763030210363841896" + }, + "normalized_net_charge": { + "lower": "0.999999918356490204683584275239", + "upper": "0.999999918356490204683584275240" + }, + "original_splitting_tax_upper": { + "lower": "0.000000166484097340338773822667", + "upper": "0.000000166484097340338773822668" + }, + "predecessor_full_charge_bound": { + "lower": "1.000087847161358855383372140894", + "upper": "1.000087847161358855383372140895" + }, + "productive_fields_base": 7688, + "rank_one_masses": { + "paid": 131115, + "target": 131723 + }, + "saving": "11551891/4300000000", + "splitting_coefficient": { + "lower": "0.003969492866208143004795927169", + "upper": "0.003969492866208143004795927170" + }, + "strict_gap_lower": { + "lower": "0.000000081643509795316415724760", + "upper": "0.000000081643509795316415724761" + }, + "u": "31/100", + "v": 100, + "word_materialized": false + }, + "uniform": { + "H": 88580000000, + "N": "2^88580000000", + "eta": { + "lower": "0.274975671868075902247454481374", + "upper": "0.274975671868075902247454481375" + }, + "gap": "1/430000000", + "grid_index": 206, + "grid_step": 430000000, + "kappa": "268647/100000000", + "log_shift": 1700, + "method": "shifted", + "ordinary_base_cost": { + "lower": "3.626915453812975067216784358696", + "upper": "3.626915453812975067216784358697" + }, + "ordinary_base_factor": { + "lower": "15.357938139093674718917526192385", + "upper": "15.357938139093674718917526192386" + }, + "p": 8, + "previous_grid_point_fails": true, + "theta": "57/67", + "uniform_saving": "11551881/4300000000", + "word_materialized": false + } + }, + "p7-net-shift-same-C": { + "consumer_binding": { + "available_uniform_saving": "376107/140000000", + "functional_checks_in_receipt": 3, + "legacy_checks_in_receipt": 63, + "producer_replayed": false, + "rank_exponent_reduction": "499/186", + "required_uniform_saving": "376107/140000000", + "retained_kappa": "268647/100000000", + "source_H": 349300000000, + "status": "INHERITED_RECEIPT_AND_MONOTONE_BOUND_BINDING", + "strict_checks_in_receipt": 54 + }, + "net_tax": { + "alpha": { + "lower": "0.999999984403907977028692329024", + "upper": "0.999999984403907977028692329025" + }, + "ambient_base": 121, + "completion_net_tax_upper": { + "lower": "0.000000060655354547465695101486", + "upper": "0.000000060655354547465695101487" + }, + "concavity_remainder": { + "lower": "0.000989630370214448971145589376", + "upper": "0.000989630370214448971145589377" + }, + "cutoff": 9, + "delta": { + "lower": "0.878191321134544702177728120307", + "upper": "0.878191321134544702177728120308" + }, + "delta0": { + "lower": "0.876986985700210447011163521179", + "upper": "0.876986985700210447011163521180" + }, + "epsilon": { + "lower": "0.526914792680726821306636872184", + "upper": "0.526914792680726821306636872185" + }, + "floor": 15, + "gamma": { + "lower": "0.930676354460701007214399379978", + "upper": "0.930676354460701007214399379979" + }, + "normalized_net_charge": { + "lower": "0.999999644856914397431457677392", + "upper": "0.999999644856914397431457677393" + }, + "original_splitting_tax_upper": { + "lower": "0.000001346558419236001069293288", + "upper": "0.000001346558419236001069293289" + }, + "predecessor_full_charge_bound": { + "lower": "1.000595129602136722680533740393", + "upper": "1.000595129602136722680533740394" + }, + "productive_fields_base": 7688, + "rank_one_masses": { + "paid": 131115, + "target": 131723 + }, + "saving": "33581/12500000", + "splitting_coefficient": { + "lower": "0.004518292673517239417487878298", + "upper": "0.004518292673517239417487878299" + }, + "strict_gap_lower": { + "lower": "0.000000355143085602568542322607", + "upper": "0.000000355143085602568542322608" + }, + "u": "33/125", + "v": 113, + "word_materialized": false + }, + "uniform": { + "H": 130200000000, + "N": "2^130200000000", + "eta": { + "lower": "0.232571174583557478852309977539", + "upper": "0.232571174583557478852309977540" + }, + "gap": "1/700000000", + "grid_index": 186, + "grid_step": 700000000, + "kappa": "268647/100000000", + "log_shift": 1356, + "method": "shifted", + "ordinary_base_cost": { + "lower": "4.288207778912378366129882553496", + "upper": "4.288207778912378366129882553497" + }, + "ordinary_base_factor": { + "lower": "24.210097689715686829319529444643", + "upper": "24.210097689715686829319529444644" + }, + "p": 7, + "previous_grid_point_fails": true, + "theta": "56/69", + "uniform_saving": "376107/140000000", + "word_materialized": false + } + } + }, + "literal_pinned_flow_checks": [ + { + "G": 0, + "exits": { + "1": 4, + "2": 1 + }, + "literal_classes": 1, + "top_rank": 5 + }, + { + "G": 0, + "exits": { + "1": 4, + "2": 1 + }, + "literal_classes": 1, + "top_rank": 14 + }, + { + "G": 1, + "exits": { + "1": 16, + "2": 8, + "4": 1 + }, + "literal_classes": 6, + "top_rank": 15 + }, + { + "G": 1, + "exits": { + "1": 16, + "2": 8, + "4": 1 + }, + "literal_classes": 6, + "top_rank": 44 + }, + { + "G": 2, + "exits": { + "1": 64, + "2": 48, + "4": 12, + "8": 1 + }, + "literal_classes": 31, + "top_rank": 45 + }, + { + "G": 3, + "exits": { + "1": 256, + "2": 256, + "4": 96, + "8": 16, + "16": 1 + }, + "literal_classes": 156, + "top_rank": 135 + } + ], + "rejected_mutations": { + "closed_uniform_saving": "uniform exponent domain", + "degree23": "all weighted exit polynomial coefficients below capacity", + "drop_tensor_concentration": "all weighted exit polynomial coefficients below capacity", + "invalid_tail_exponent": "net tax exponent domain", + "too_small_tensor": "strict net moment certificate", + "understated_full_paid_excess": "full paid mass perturbation", + "understated_log_support": "raw paid log support", + "understated_raw_mean": "raw paid log mean", + "wrong_log_shift_enclosure": "normalized log shift enclosure" + }, + "schema_version": 1, + "scope": "Conditional finite rank/leaf bounds; inherited native and outer producer receipts; no new kappa, selected frontier, materialized word or physical runtime claim.", + "source_mutation_rejected": true, + "source_sha256": { + "research/higher-moment-strictification/README.md": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d", + "research/higher-moment-strictification/RESULT.json": "ad79e3c0459e7b495a0ca34010553b12147779a007389e1695cc1336f123c156", + "research/higher-moment-strictification/vendor/FINITE-PRECOMPILATION.md": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8", + "research/higher-moment-strictification/vendor/p7-TENSOR.md": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3", + "research/higher-moment-strictification/verify.py": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "research/kappa-rebuild/architecture/sources/Sussman-563b4e6/research/record-track/programs/theorem-1g/tree_flow.py": "750782f6d1cc0a9fff8a768899f3f4c62a7efdf0696d8b5a5d640b1836f5ab72", + "research/native-lattice-retiming/NATIVE-RESULT.json": "a2e7a8f9eba6712dc92c47e6d86aaf18b8400f1ae5fe13ca19bbb65e76a25018", + "research/native-lattice-retiming/PROOF.md": "d137119bd238304295498d85186e6c0d36915002f7fcca4d75605f76a339edfc", + "research/native-lattice-retiming/README.md": "c2ef9c38cfd1d9ea8b2a3de3910471001a0592ea334d1e364e6ca41a8e322ee2", + "research/native-lattice-retiming/RESULT.json": "1ac2e581ea51e6448503a68caf4bf44aeb32470c2e2674c91f007af4a3abd2e3" + }, + "status": "PASS_NET_TAX_AND_LOG_MOMENT_RANK_COMPILER" +} diff --git a/research/net-tax-rank-compiler/SHIFTED-LOG.md b/research/net-tax-rank-compiler/SHIFTED-LOG.md new file mode 100644 index 0000000000..48a70bceba --- /dev/null +++ b/research/net-tax-rank-compiler/SHIFTED-LOG.md @@ -0,0 +1,134 @@ +# A normalized logarithmic majorant + +This extends the logarithmic majorant in PR4411 and PR4433 without changing +their finite integer compiler, its source complements, or its native +hypotheses. The new parameter normalizes the logarithm by a scale adapted to +the fixed mixed unit. All logarithms in the theorem are base two. + +Assume the separated finite compiler has ordinary base `L(n)=n` for +`0<=n=m`, + +``` +L(n) = sum_s w_s L(n-s) + sum_e x_e L(e), +sum_s w_s = 1, +n/m < s <= n, +sum_e x_e e^t <= sum_s w_s s^t, +1 <= e <= r_max*(n/m)^theta < n, +theta = log(r_max)/log(k_min) < 1. +``` + +Here the normalized nonnegative weights arise from whole integer batches; +the moment inequality follows from the strict mixed-unit superpotential. +These are the inherited compiler premises, not a replacement native proof. + +Choose `0=1, +F(0) := 0. +``` + +The scale and power may be real. Integer `h` and `p`, and rational +`theta_bar`, make the shift guard and final-rank checks particularly simple +exact arithmetic. The separate check `r_max^b<=k_min^a` implies the required +`theta<=theta_bar`. + +## Base range + +Put `x=log(n)` and `M=log(m)`. For positive `x`, the function +`log(1+x/h)/x` decreases: its derivative has the sign of +`x/(h+x)-ln(1+x/h)`, which is nonpositive because +`ln(1+u)>=u/(1+u)` for `u>=0`. Therefore the base guard implies + +``` +p*log(1+x/h) >= (1-t)*x for 0<=x<=M. +``` + +Exponentiation proves `F(n)>=n` throughout the ordinary base range. At +`n=1`, both sides are one. This single endpoint guard covers every integer +base rank; checking a sample of them is unnecessary. + +## Exit contraction + +Because `n/m>=1` and `theta<=theta_bar`, + +``` +log(e) <= log(r_max) + theta_bar*(log(n)-log(m)). +``` + +The shift guard is exactly + +``` +(1-theta_bar)*h + log(r_max)-theta_bar*log(m) <= 0. +``` + +Consequently `h+log(e)<=theta_bar*(h+log(n))`. Writing +`A(n)=(1+log(n)/h)^p` gives + +``` +A(e) <= theta_bar^p*A(n), +sum_e x_e F(e) <= theta_bar^p*A(n)*sum_s w_s s^t. +``` + +The factor `h` cancels in this ratio. Increasing it is therefore available +up to the explicit shift guard, rather than forcing the original value one. + +## Complements and induction + +The factor `A` increases on positive ranks. For `y=s/n>1/m`, concavity gives + +``` +1-(1-y)^t >= t*y >= t*m^(t-1)*y^t = eta*y^t. +``` + +Treating a zero-rank complement as zero, this implies + +``` +F(n)-sum_s w_s F(n-s) >= eta*A(n)*sum_s w_s s^t. +``` + +The strict capacity guard pays the exit bound. All recursive ranks are +smaller than `n`, so strong induction proves the assertion. The argument +uses monotonicity of `A`; it does not require that `A` be concave or that +`p<=1`. + +## Specified uniform rank + +For a desired exponent `z>t` and `N=2^H`, the sufficient final condition is + +``` +(1+H/h)^p < 2^((z-t)*H). +``` + +For positive integers `h,p,H`, and an integer `J=(z-t)*H`, this is exactly + +``` +(h+H)^p < h^p*2^J. +``` + +Thus normalized logarithms preserve a finite exact integer final-rank +certificate. This bounds normalized paid rank-one leaves. Actual productive +width, scalar records, owned banks, precision constants, physical costs and +recovery thresholds still come from the newly compiled finite word and the +inherited native and outer arguments. + +As a diagnostic using PR4453's unchanged `v=675`, `p=160` and +`theta_bar=15/16`, one may take `h=40*v=27000`: the shift condition reduces +to `2^40*18^16<=153^15`. The endpoint base condition also remains strict. +This changes the final sufficient-rank inequality itself. A standalone +numerical diagnostic is not a new certified rank or an independent native +admission; the package's exact verifier supplies its instantiated values. + +Prepared with substantial OpenAI Codex assistance. The finite integer +lockstep compiler is Jacob Alan Sussman's construction, retained through +PR4359; the logarithmic-majorant predecessors are zxv's PR4411 and PR4433. +New material is Apache-2.0. diff --git a/research/net-tax-rank-compiler/SOURCES.json b/research/net-tax-rank-compiler/SOURCES.json new file mode 100644 index 0000000000..81684a2e2c --- /dev/null +++ b/research/net-tax-rank-compiler/SOURCES.json @@ -0,0 +1,90 @@ +{ + "schema_version": 1, + "base_commit": "de6869e2e4d9c6f630bac5de4a919d99a2cb884b", + "files": [ + { + "path": "research/native-lattice-retiming/RESULT.json", + "usage": "input", + "sha256": "1ac2e581ea51e6448503a68caf4bf44aeb32470c2e2674c91f007af4a3abd2e3", + "git_blob": "93defc5ececebd542332fc42d6a78f0af222cd1c" + }, + { + "path": "research/native-lattice-retiming/NATIVE-RESULT.json", + "usage": "input", + "sha256": "a2e7a8f9eba6712dc92c47e6d86aaf18b8400f1ae5fe13ca19bbb65e76a25018", + "git_blob": "b5c0af78f1c2aa07e921898b48862bb6e8d9569c" + }, + { + "path": "research/native-lattice-retiming/README.md", + "usage": "input", + "sha256": "c2ef9c38cfd1d9ea8b2a3de3910471001a0592ea334d1e364e6ca41a8e322ee2", + "git_blob": "22cb2378eedf42895126b19ad22aa609774876ce" + }, + { + "path": "research/native-lattice-retiming/PROOF.md", + "usage": "input", + "sha256": "d137119bd238304295498d85186e6c0d36915002f7fcca4d75605f76a339edfc", + "git_blob": "5ed2cacea7e8e4ceeace5bc21745bfae6d41c4a1" + }, + { + "path": "research/higher-moment-strictification/RESULT.json", + "usage": "input", + "sha256": "ad79e3c0459e7b495a0ca34010553b12147779a007389e1695cc1336f123c156", + "git_blob": "e66b39c674028adfd22f0de3170555dccda52f6a" + }, + { + "path": "research/higher-moment-strictification/README.md", + "usage": "input", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d", + "git_blob": "0a736ca89e1eafb73a30e1f2589cc45e6b5f76c3" + }, + { + "path": "research/higher-moment-strictification/verify.py", + "usage": "input", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699" + }, + { + "path": "research/higher-moment-strictification/vendor/p7-TENSOR.md", + "usage": "input", + "sha256": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3", + "git_blob": "8ecfd3e4d0bcb449ecb1e150c4f1f4fbb39ca656" + }, + { + "path": "research/higher-moment-strictification/vendor/FINITE-PRECOMPILATION.md", + "usage": "input", + "sha256": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8", + "git_blob": "4badb40f0919c515823cb07e44c6470d4d6469ca" + }, + { + "path": "research/kappa-rebuild/architecture/sources/Sussman-563b4e6/research/record-track/programs/theorem-1g/tree_flow.py", + "usage": "input", + "sha256": "750782f6d1cc0a9fff8a768899f3f4c62a7efdf0696d8b5a5d640b1836f5ab72", + "git_blob": "31a9c1ae4d116b12e8db7d8e06f723f10425068d" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9", + "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40" + }, + { + "path": "autoresearch.md", + "usage": "provenance", + "sha256": "d16f0d3bb4d4b213d06c128db6d6460b0fe9ec1ac5a6c1ea1febf1db40e7b60d", + "git_blob": "2fe84a7b30b1e26e60ce0ec4775894eb1831c5d6" + }, + { + "path": "CONTRIBUTING.md", + "usage": "provenance", + "sha256": "8a49fe97e2ad088a2b2e0c5b222aaab08752783b1f9c1260790d7dd13011d215", + "git_blob": "fe54f23f19b082a9f8df3da9b2e205f7e230acf3" + } + ] +} diff --git a/research/net-tax-rank-compiler/TASK.json b/research/net-tax-rank-compiler/TASK.json new file mode 100644 index 0000000000..b91c112d79 --- /dev/null +++ b/research/net-tax-rank-compiler/TASK.json @@ -0,0 +1,132 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 7, + "base_commit": "de6869e2e4d9c6f630bac5de4a919d99a2cb884b", + "original_card": { + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "allowed_variations": [ + "One provider-registry, dispatch, native-closure or admission-predicate obligation; separate branches must name distinct coverage." + ], + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "existing_checks": [ + { + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "status": "author-checked" + }, + { + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "scope": "PR #3801: successor scatter-boundary decision package.", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "status": "author-checked" + } + ], + "first_experiment": "Pin the provider registry, four native source closures and dispatch. Make a bounded acceptance coverage map or one registry adapter preserving every inherited admission predicate and rejection control (including an omitted fourth provider). Record remaining ordinary/outer obligations and a resource estimate before heavy execution. Stop at unresolved source/caller dependencies; no selected-result promotion from a local pass.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4088 Scope and Open next questions: local words, native receipts and literal fill do not include a rerun of the mixed four-provider ordinary/outer engine. #3801 is the newer scatter-boundary decision; do not restart #2977 as if untouched.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "id": "supplier-boundary-audit", + "methods": [ + "Trace one hypothesis through the source, checker and complete caller.", + "Construct one semantically invalid but superficially well-formed fixture and test rejection." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics", + "4088", + "3801", + "staged544-mixed-fourth-entry", + "scatter-boundary-decision" + ], + "question": "Can the #4088 four-provider dispatch satisfy the complete ordinary/outer admission contract?", + "scope_change_triggers": [ + "Reporting the historical timing-only diagnostic as a new current acceptance bug.", + "Calling a malformed mutant a failure of the selected construction, or importing an opt-in repair without testing the exporter boundary.", + "Running another root enclosure instead of validating dispatch or weakening an inherited predicate to make mixed admission pass." + ], + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/scatter-boundary-decision/README.md" + ] + }, + "scope_status": "changed", + "actual_scope": "Develop reusable structural rank reductions for the chronological-product and finite uniform compiler, with exact reusable witnesses on native4453 and p7 profiles.", + "scope_change_reason": "The user explicitly assigned systematic structural rank reduction for future submissions; this overrides the catalogue default supplier audit. No new native profile or kappa hill step is claimed.", + "bottleneck_link": "Net concavity taxes and paid logarithmic moments reduce the tensor power and the sufficient uniform rank without changing native jobs.", + "stop_rule": "Finish a source-bound theorem and exact reusable certificate with discriminating controls; keep local for user review and leave further supplier changes open.", + "evidence": "Net gap identity, sharp concavity coefficients, normalized-log induction, exact iid exit law, convex-order and Bell-polynomial certificates, literal pinned-flow probes and independent agent audit.", + "author": "zxv, with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance, including three user-requested Sol 6.1 xhigh subagents for divergent probes and independent audits.", + "budget_minutes": 60, + "outcome": "completed", + "open_questions": [ + { + "question": "Can exact raw logarithmic moments tighten the bounded-support concentration certificate?", + "why_it_matters": "The current Bernoulli bound keeps the tensor concentration but still overestimates the raw log law.", + "first_step": "Replace concentrated_moments with raw-moment Bell coefficients, retaining the capped-reference excess proof and the same positive coefficient test.", + "blocked_by": "Need directed enclosures for the complete moment list and explicit coefficient controls." + }, + { + "question": "Can a native word change improve kappa while using this smaller-rank compiler?", + "why_it_matters": "Compiler improvements preserve the raw moment ceiling; a kappa hill step needs a changed fully paid profile.", + "first_step": "Pin the recent native frame/contact proposals, alter one actual paid transition, replay its complete operator and invoice, then run this generic certificate tool.", + "blocked_by": "No new paid-profile improvement is proved in this package." + }, + { + "question": "Can productive width and batch denominators be bounded usefully as well?", + "why_it_matters": "A smaller ambient rank alone does not control materialized word size or owned-bank requirements.", + "first_step": "Record exact batch-width and source/exit recurrences for a small separated unit before extrapolating.", + "blocked_by": "The winning words remain algorithm-defined and their full widths are not emitted." + } + ], + "publication_policy": "Keep this contribution local for user review. No PR or Discussion publication is authorized for this contribution yet.", + "upstream_checkpoint": { + "checked_at_utc": "2026-10-21T22:13:49Z", + "canonical_main": "2a13eb1827784206202db90e5dc8327cf8a250db", + "priority_revision": 7, + "refresh_checked_at_utc": "2026-10-21T22:39:21Z", + "refresh_result": "Canonical main and relevant guidance unchanged." + }, + "overlap": { + "checked_at_utc": "2026-10-21T22:18:00Z", + "open_prs": 310, + "discussion_records": 3301, + "remote_pagination_complete": true, + "local_notes_searched": 23, + "local_HEAD_notes": 5739, + "limits": "Sparse local note coverage (5716 unsearched); no arbitrary diffs or closed remote PR-body search. This is not a novelty certificate. Start-here, recent handoffs and active discussions were read." + }, + "validation": { + "registered_replay": "pass", + "metadata_and_source_pins": "pass", + "isolated_optimized_direct_replay": "pass", + "exact_math_tests": 9, + "rejected_certificate_mutations": 9, + "literal_pinned_flow_checks": 6, + "source_mutation_control": "rejected", + "native_and_outer_producer_suites": "inherited source receipts, not rerun", + "platform": "macOS arm64", + "python": "3.12.8", + "independent_mathematical_checks": "Separate Sol 6.1 xhigh audit; Bell coefficients independently recovered through iid moment convolution and Newton differences." + } +} diff --git a/research/net-tax-rank-compiler/VERIFY.json b/research/net-tax-rank-compiler/VERIFY.json new file mode 100644 index 0000000000..0527cd3652 --- /dev/null +++ b/research/net-tax-rank-compiler/VERIFY.json @@ -0,0 +1,29 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/native-lattice-retiming/RESULT.json", + "research/native-lattice-retiming/NATIVE-RESULT.json", + "research/native-lattice-retiming/README.md", + "research/native-lattice-retiming/PROOF.md", + "research/higher-moment-strictification/RESULT.json", + "research/higher-moment-strictification/README.md", + "research/higher-moment-strictification/verify.py", + "research/higher-moment-strictification/vendor/p7-TENSOR.md", + "research/higher-moment-strictification/vendor/FINITE-PRECOMPILATION.md", + "research/kappa-rebuild/architecture/sources/Sussman-563b4e6/research/record-track/programs/theorem-1g/tree_flow.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Authenticate source receipts; certify seven net-tax, shifted-log, weighted-exit and concentrated-log-moment witnesses with rational intervals and polynomial coefficients; compare literal pinned lockstep exits, exact mathematical controls, and deliberate rejection cases. Native and outer producers are inherited receipts, not rerun." + } + ] +} diff --git a/research/net-tax-rank-compiler/WEIGHTED-EXITS.md b/research/net-tax-rank-compiler/WEIGHTED-EXITS.md new file mode 100644 index 0000000000..c0f6469d31 --- /dev/null +++ b/research/net-tax-rank-compiler/WEIGHTED-EXITS.md @@ -0,0 +1,268 @@ +# A paid-log-moment compiler bound + +The largest paid rank need not determine the logarithmic power. The +separated integer compiler has an exact exit distribution: its exits are +the chronological paid word raised to the power `G+1`. This permits an +average logarithmic contraction, certified by a finite list of rational +polynomial coefficients. + +The construction, native premises, source complement recurrence and moment +cancellation are inherited from Jacob Alan Sussman's separated lockstep +compiler as retained in PR4359 and the logarithmic compiler of PR4411 and +PR4433. Only the bound on its normalized leaves changes here. There is no +new routing operation, fractional job, or independent productive credit. + +## Exact exits of the separated compiler + +Let the fixed mixed unit have ambient rank `m`, productive minimum `k_min`, +and a chronological paid inventory `P_r`, with + +``` +1 <= r_max < k_min <= m. +``` + +At top rank `n>=m`, put + +``` +G = floor(log_(k_min)(n/m)). +``` + +The inherited construction has one class for every paid-round path of +length `d<=G`, and degree `G-d` in that class. Separation consumes all +parent paid jobs, so there are no premature exits. At depth `G`, a path +has column multiplier `rho<=r_max^G0`; for `G=0`, +the single root has multiplier one and `m<=n`. Consequently the degree-zero +point is present in every depth-`G` class, with its exact integer weight +`u(0)=1`. + +Each such leaf unit issues its complete chronological paid word. Therefore +the complete exit multiset is exactly + +``` +{ r_1*...*r_(G+1) : each position chooses one actual paid call }, +``` + +including all multiplicities. The statement uses the compiler's complete +class construction, including child classes whose missing inputs are top +sources. A missing parent point does not omit the corresponding child +class. Chronological paths are not matched across different paid positions. + +For `0=r_max`, with `J>1`, and let + +``` +X = ln(r)/ln(J) in [0,1], +E[X] <= q, 0<=q<=1. +``` + +Take an integer power `p>=1` and a positive natural-log shift `a`. Choose +positive rational bounds `A_bar`, `B_under`, `beta` satisfying + +``` +a/ln(J) <= A_bar, +(a+ln(m))/ln(J) >= B_under, +ln(k_min)/ln(J) >= beta. +``` + +Let `S(i,j)` be the Stirling numbers of the second kind, with +`S(0,0)=1`, zero outside `0<=j<=i`, and + +``` +S(i+1,j) = j*S(i,j)+S(i,j-1). +``` + +For `0<=j<=p`, form the nonnegative numerator coefficients and positive +denominator coefficients + +``` +C_j = q^j * sum_(i=j..p) binom(p,i)*S(i,j) + * [q*(A_bar+1)^(p-i)+(1-q)*A_bar^(p-i)], +D_j = sum_(i=j..p) binom(p,i)*S(i,j) + * B_under^(p-i)*beta^i. +``` + +If every `C_j<=lambda*D_j`, then for every integer top rank `n>=m`, + +``` +E[(a+ln(exit))^p] <= lambda*(a+ln(n))^p. (1) +``` + +Here the expectation uses the exact `t`-weighted exit inventory above. +The certificate has only `p+1` rational comparisons; it does not enumerate +the product paid histogram or the compiler flow at unbounded ranks. + +### Proof by convex order + +For a convex function `f` on `[0,1]`, the chord inequality gives +`f(x)<=(1-x)f(0)+x*f(1)`. For an increasing convex function, taking the +expectation and using `E[X]<=q` bounds it by the Bernoulli-`q` expectation. +Applying this one variable at a time to +`(A_bar+x_1+...+x_(G+1))^p` proves + +``` +E[(a/ln(J)+sum X_i)^p] + <= E[(A_bar+Binomial(G+1,q))^p]. +``` + +Write `u=G` and split the binomial as `Binomial(u,q)+Z`, with `Z` an +independent Bernoulli-`q` variable. The identity + +``` +E[Binomial(u,q)^i] = sum_(j=0..i) S(i,j)*q^j*(u)_j +``` + +uses the falling factorial `(u)_j=u*(u-1)*...*(u-j+1)`, with `(u)_0=1`. +Expanding the previous display gives exactly `sum_j C_j*(u)_j`. +The same power-to-falling-factorial identity expands +`(B_under+beta*u)^p` as `sum_j D_j*(u)_j`. + +For every integer `u>=0`, all `(u)_j` are nonnegative (and vanish when +`j>u`). Coefficient domination therefore proves + +``` +E[(A_bar+Binomial(u+1,q))^p] + <= lambda*(B_under+beta*u)^p. +``` + +Finally `ln(n)>=ln(m)+G*ln(k_min)`, so +`(a+ln(n))/ln(J)>=B_under+beta*u`. Multiplication by `ln(J)^p` proves (1). +The coefficient condition is sufficient; its failure is not a theorem +about the compiler's true optimum. + +## Closing the source-complement induction + +Retain the exact compiler recurrence and moment inequality from +[SHIFTED-LOG.md](SHIFTED-LOG.md). Set + +``` +A(n) = (1+ln(n)/a)^p, +eta = t*m^(t-1). +``` + +If the finite coefficient certificate has `lambda= eta*A(n)*sum_s w_s*s^t. +``` + +It is enough to check the same endpoint base guard + +``` +m^(1-t) <= (1+ln(m)/a)^p. +``` + +The monotonicity argument in SHIFTED-LOG.md then covers every ordinary base +rank, and strong induction proves `L(n)<=n^t*A(n)`. The earlier pointwise +shift guard is not required when it is replaced by this averaged exit +certificate. The final sufficient-rank check remains + +``` +(h+H)^p < h^p*2^((z-t)*H), where a=h*ln(2), N=2^H. +``` + +This still requires the stated native compiler and strict mixed-unit +superpotential. It does not establish a compiler for overlapping ranks. + +## Bounding the paid log mean after splitting and completion + +The mean premise can be checked without emitting the completed histogram. +For a raw paid inventory with moment `P_t`, put + +``` +mu_raw = sum_r P_r*r^t*ln(r) / P_t, +A_raw = P_t^v, +J = c^v. +``` + +Suppose `E_split` bounds the **increase** in original-paid `t`-moment from +splitting, and `F_completion` bounds the **full paid `t`-moment** of all +split completion calls. Define `E=E_split+F_completion`. In particular, +`F_completion` must not subtract productive target-completion credit. A net +completion tax suitable for proving a superpotential cannot replace this +full paid charge in the mean bound. + +An original call `R>J` has split paid moment `Q_R>=R^t`, and every split +rank is at most `J`. Thus + +``` +sum_(split r) r^t*ln(r)-R^t*ln(R) + <= (Q_R-R^t)*ln(J). +``` + +Calls `R<=J` are unchanged. Every completion call also has split ranks at +most `J`, so its weighted log sum is at most its full paid moment times +`ln(J)`. The completed paid moment is at least `A_raw`, because splitting +increases a sublinear positive moment and completion adds nonnegative paid +calls. Consequently its normalized log mean obeys + +``` +E[X] <= mu_raw/ln(c) + E/A_raw. (2) +``` + +For example, certifying `mu_raw/ln(c)<=179/200` and +`E/A_raw<=1/200` gives `q=9/10`. Equation (2) is deliberately conservative; +the actual completed paid moment can give a sharper denominator. + +## A small rational specialization + +For a completed native4453 unit with + +``` +m=153^v, J=18^v, k_min>=22^v, h=4*v, +``` + +the integer comparisons + +``` +18^19 < 2^80, 2^4 < 18, +18^26 < 153^15, 18^16 < 22^15 +``` + +give `19/20<=a/ln(J)<=1`, +`(a+ln(m))/ln(J)>=19/20+26/15=161/60`, and +`ln(k_min)/ln(J)>=16/15`. Hence one may use + +``` +A_bar=1, B_under=161/60, beta=16/15, q=9/10. +``` + +At `p=60`, all 61 rational coefficient ratios are strictly below +`17/25000=0.00068`; the largest is at `j=16`, approximately +`0.0006795228122899847`. Thus any instance with `eta>3/4000=0.00075` passes +the exit guard, provided the paid-mean and base obligations also pass. +With the same bounds, `p=58` fails this coefficient guard. Setting `q=1` +also fails at `p=60`, so the certificate uses distribution information that +the largest-rank estimate omits. + +These are exact finite polynomial comparisons; displayed decimal values +are explanatory. The package verifier must bind the actual raw profile, +full completion bill, exponent, power, scale, all inequalities and final +rank before treating a concrete specialization as certified. This note +does not select a new frontier or independently admit a native supplier. + +Prepared with substantial OpenAI Codex assistance. New material is +Apache-2.0. The source compiler and prior logarithmic arguments retain the +attribution stated above and in the package provenance. diff --git a/research/net-tax-rank-compiler/compiler.py b/research/net-tax-rank-compiler/compiler.py new file mode 100644 index 0000000000..f5b5e5bb93 --- /dev/null +++ b/research/net-tax-rank-compiler/compiler.py @@ -0,0 +1,316 @@ +#!/usr/bin/env python3 +"""Reusable exact sufficient certificates; no search result is trusted. + +The mathematical contracts are in PROOF.md. This checker certifies finite +moment and compiler inequalities, conditional on the supplied native unit. +zxv with substantial OpenAI Codex assistance. Apache-2.0. +""" +import argparse +import json +from fractions import Fraction as Q +from math import comb +from pathlib import Path +import sys +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import intervals as E + + +def histogram(value): + E.need(isinstance(value, dict) and value, 'nonempty rank histogram') + result = {} + for key, count in value.items(): + rank = int(key) + E.need(str(rank) == str(key) and rank > 0, 'canonical positive rank') + E.need(type(count) is int and count > 0, 'positive integer multiplicity') + result[rank] = count + return result + + +def tax_data(profile, witness): + T, P = histogram(profile['targets']), histogram(profile['paid']) + m = max(T) + C, u = Q(witness['saving']), Q(witness['u']) + t = 1-C + v, c, b = (witness[k] for k in ('v', 'cutoff', 'floor')) + E.need(all(type(x) is int for x in (v, c, b)), 'integer construction') + E.need(0 < C < 1 and C <= u and v >= 1, 'net tax exponent domain') + E.need(1 < c < b < m and max(P) <= m, 'strict finite rank separation') + T1, P1 = (sum(k*n for k, n in h.items()) for h in (T, P)) + E.need(T1 > P1, 'positive rank-one surplus') + target = E.moment(T, t) + paid = E.moment(P, t) + alpha = E.divide(paid, target) + gamma = E.divide(E.moment(P, t+u), E.mul(E.power(c, u), target)) + B = sum(T.values()) + delta = E.divide((Q(B*b),)*2, E.mul(E.power(c, C), target)) + delta0 = E.divide(E.scale(E.power(b, t), B), target) + concavity_remainder = E.scale(E.qpower(t, t/C), C) + monotone_coefficient = (max(C/u, concavity_remainder[0]), + max(C/u, concavity_remainder[1])) + if u == C: + jensen_coefficient = E.power(2, C) + else: + jensen_coefficient = E.scale( + E.mul(E.power(2, u), E.qpower(1-C/u, u/C-1)), C/u) + coefficient = (min(monotone_coefficient[0], jensen_coefficient[0]), + min(monotone_coefficient[1], jensen_coefficient[1])) + epsilon = E.divide(E.scale(E.power(c, t), B), target) + original_tax = E.mul(coefficient, E.ipow(gamma, v)) + completion_tax = E.sub( + E.add(E.ipow(delta, v), + E.scale(E.mul(concavity_remainder, E.ipow(epsilon, v)), 2)), + E.ipow(delta0, v)) + bound = E.add(E.add(E.ipow(alpha, v), original_tax), completion_tax) + E.need(bound[1] < 1, 'strict net moment certificate') + old_bound = E.add(E.ipow(alpha, v), + E.scale(E.add(E.ipow(gamma, v), E.ipow(delta, v)), 2)) + return locals() + + +def net_tax(profile, witness): + data = tax_data(profile, witness) + C, u, v, c, b, m, B, T1, P1 = (data[k] for k in + ('C', 'u', 'v', 'c', 'b', 'm', 'B', 'T1', 'P1')) + alpha, gamma, delta, delta0, epsilon = (data[k] for k in + ('alpha', 'gamma', 'delta', 'delta0', 'epsilon')) + concavity_remainder, coefficient, original_tax, completion_tax, bound, old_bound = ( + data[k] for k in ('concavity_remainder', 'coefficient', 'original_tax', + 'completion_tax', 'bound', 'old_bound')) + return {'saving': str(C), 'v': v, 'cutoff': c, 'floor': b, + 'u': str(u), 'ambient_base': m, 'productive_fields_base': B, + 'rank_one_masses': {'target': T1, 'paid': P1}, + 'alpha': E.display(alpha), 'gamma': E.display(gamma), + 'delta': E.display(delta), 'delta0': E.display(delta0), + 'epsilon': E.display(epsilon), + 'concavity_remainder': E.display(concavity_remainder), + 'splitting_coefficient': E.display(coefficient), + 'original_splitting_tax_upper': E.display(original_tax), + 'completion_net_tax_upper': E.display(completion_tax), + 'normalized_net_charge': E.display(bound), + 'strict_gap_lower': E.display(E.sub((Q(1),)*2, bound)), + 'predecessor_full_charge_bound': E.display(old_bound), + 'word_materialized': False} + + +def weighted_coefficients(p, q, A, B0, beta): + """Coefficient comparison in the nonnegative integer falling-factorial basis.""" + E.need(type(p) is int and 1 <= p <= 200, 'bounded positive polynomial degree') + E.need(0 < q <= 1 and A > 0 and B0 > 0 and beta > 0, + 'positive weighted-exit constants') + S = [[0]*(p+1) for _ in range(p+1)] + S[0][0] = 1 + for i in range(1, p+1): + for j in range(1, i+1): + S[i][j] = S[i-1][j-1]+j*S[i-1][j] + numerator, denominator = [], [] + for j in range(p+1): + numerator.append(q**j*sum( + comb(p, i)*S[i][j]*(q*(A+1)**(p-i)+(1-q)*A**(p-i)) + for i in range(j, p+1))) + denominator.append(sum( + comb(p, i)*S[i][j]*B0**(p-i)*beta**i + for i in range(j, p+1))) + ratios = [x/y for x, y in zip(numerator, denominator)] + return max(ratios), ratios.index(max(ratios)), numerator, denominator + + +def moment_coefficients(p, moments, A, B0, beta): + """Arbitrary upper log moments, using partial exponential Bell polynomials.""" + E.need(type(p) is int and 1 <= p <= 200 and len(moments) == p+1, + 'bounded complete moment list') + E.need(moments[0] == 1 and all(0 <= x <= 1 for x in moments), + 'unit-interval moment upper bounds') + bell = [[Q(0)]*(p+1) for _ in range(p+1)] + bell[0][0] = Q(1) + for n in range(1, p+1): + for k in range(1, n+1): + bell[n][k] = sum(comb(n-1, j-1)*moments[j]*bell[n-j][k-1] + for j in range(1, n-k+2)) + shifted = [sum(comb(n, i)*A**(n-i)*moments[i] for i in range(n+1)) + for n in range(p+1)] + numerator = [sum(comb(p, l)*shifted[p-l]*bell[l][j] + for l in range(j, p+1)) for j in range(p+1)] + # The denominator's conversion to falling factorials is unchanged. + _, _, _, denominator = weighted_coefficients(p, Q(1), A, B0, beta) + ratios = [x/y for x, y in zip(numerator, denominator)] + return max(ratios), ratios.index(max(ratios)), numerator, denominator + + +def concentrated_moments(p, v, raw_mean_upper, raw_bound, excess_upper): + """Raw tensor concentration, then capped-reference mass perturbation.""" + E.need(type(v) is int and v >= 1 and 0 < raw_mean_upper <= raw_bound, + 'bounded raw log law') + E.need(excess_upper >= 0, 'nonnegative paid mass perturbation') + q = raw_mean_upper/raw_bound + S = [[0]*(p+1) for _ in range(p+1)] + S[0][0] = 1 + for n in range(1, p+1): + for k in range(1, n+1): + S[n][k] = S[n-1][k-1]+k*S[n-1][k] + falling = [1] + for k in range(1, p+1): + falling.append(falling[-1]*(v-k+1) if k <= v else 0) + moments = [Q(1)] + for i in range(1, p+1): + raw = (raw_bound/v)**i*sum(S[i][k]*falling[k]*q**k for k in range(i+1)) + moments.append(min(Q(1), (raw+excess_upper)/(1+excess_upper))) + return moments + + +def weighted_exit(profile, witness, eta): + data = tax_data(profile, witness) + p, h, v, c, b, m = (witness['p'], witness['log_shift'], data['v'], + data['c'], data['b'], data['m']) + options = witness['weighted'] + mean_key = ('raw_mean_upper' if witness['uniform_method'] == 'log-moments' + else 'mean_upper') + q, amin, amax, D, K = (Q(options[k]) for k in + (mean_key, 'A_lower', 'A_upper', 'ambient_log_lower', 'floor_log_lower')) + E.need(0 < q <= 1 and 0 < amin <= amax and D > 0 and K > 0, + 'weighted guard domain') + logc = E.log_bounds(c) + A = E.scale(E.divide(E.log_bounds(2), logc), Q(h, v)) + E.need(amin <= A[0] and A[1] <= amax, 'normalized log shift enclosure') + E.need(D <= E.divide(E.log_bounds(m), logc)[0], 'ambient log ratio') + E.need(K <= E.divide(E.log_bounds(b), logc)[0], 'target log ratio') + P, t = data['P'], data['t'] + log_moment = (Q(0), Q(0)) + for rank, count in P.items(): + log_moment = E.add(log_moment, + E.scale(E.mul(E.power(rank, t), E.log_bounds(rank)), count)) + raw_mean = E.divide(log_moment, E.mul(data['paid'], logc)) + # Full completion paid charge is needed here; the net completion tax + # subtracts new target credit and cannot bound paid log moments. + full_excess = E.add(data['original_tax'], E.scale(E.ipow(data['delta'], v), 2)) + relative_excess = E.divide(full_excess, E.ipow(data['alpha'], v)) + mean = E.add(raw_mean, relative_excess) + if witness['uniform_method'] == 'log-moments': + raw_bound = Q(options['raw_log_bound']) + excess_upper = Q(options['paid_excess_upper']) + E.need(raw_bound > 0 and excess_upper > 0, 'concentration guard domain') + E.need(raw_mean[1] < q, 'raw paid log mean') + E.need(max(P)**raw_bound.denominator <= c**raw_bound.numerator, + 'raw paid log support') + E.need(relative_excess[1] < excess_upper, 'full paid mass perturbation') + moments = concentrated_moments(p, v, q, raw_bound, excess_upper) + ratio, degree, num, den = moment_coefficients(p, moments, amax, amin+D, K) + moment_details = {'raw_log_bound': str(raw_bound), + 'paid_excess_upper': str(excess_upper), + 'log_moment_upper_bounds': [str(x) for x in moments]} + else: + E.need(mean[1] < q, 'completed paid log mean') + ratio, degree, num, den = weighted_coefficients(p, q, amax, amin+D, K) + moment_details = {} + E.need(ratio < eta[0], 'all weighted exit polynomial coefficients below capacity') + return {mean_key: str(q), **moment_details, + 'raw_normalized_log_mean': E.display(raw_mean), + 'full_paid_relative_excess': E.display(relative_excess), + 'completed_normalized_log_mean_upper': E.display(mean), + 'A': E.display(A), 'A_lower': str(amin), 'A_upper': str(amax), + 'ambient_log_lower': str(D), 'floor_log_lower': str(K), + 'coefficient_ratio_max': E.display((ratio, ratio)), + 'maximizing_coefficient': degree, + 'numerator_coefficients': [str(x) for x in num], + 'denominator_coefficients': [str(x) for x in den]} + + +def uniform(profile, witness): + """Shifted-log induction, with exact integer-grid final-rank search.""" + T = histogram(profile['targets']) + m = max(T) + C, kappa = Q(witness['saving']), Q(witness['kappa']) + t = 1-C + v, c, b = (witness[k] for k in ('v', 'cutoff', 'floor')) + p, h = witness['p'], witness.get('log_shift', 1) + E.need(type(p) is int and p > 0 and type(h) is int and h > 0, + 'positive integer logarithm power and shift') + E.need(0 < kappa < C < 1, 'uniform exponent domain') + eta = E.scale(E.ipow(E.power(m, -C), v), t) + method = witness.get('uniform_method', 'shifted') + details = {} + if method == 'shifted': + theta = Q(witness['theta']) + E.need(0 < theta < 1, 'theta domain') + a, d = theta.numerator, theta.denominator + E.need(c**d < b**a, 'theta above actual separation exponent') + E.need(2**(h*(d-a))*c**(v*d) <= m**(v*a), 'shifted logarithm guard') + E.need(theta**p < eta[0], 'exit contraction below complement capacity') + details['theta'] = str(theta) + elif method in ('weighted', 'log-moments'): + details['weighted_exit'] = weighted_exit(profile, witness, eta) + else: + raise ValueError('unknown uniform certificate method') + log_m = E.scale(E.divide(E.log_bounds(m), E.log_bounds(2)), v) + base_factor = E.ipow(E.add((Q(1),)*2, E.scale(log_m, Q(1, h))), p) + base_cost = E.ipow(E.power(m, C), v) + E.need(base_cost[1] < base_factor[0], 'entire ordinary base range fits') + gap = (C-kappa)/7 + step, gain = gap.denominator, gap.numerator + + def passes(j): + H = step*j + # (1+H/h)^p < 2^(gap*H), with no transcendental evaluation. + return (h+H)**p < h**p * 2**(gain*j) + + low, high = 0, 1 + while not passes(high): + low, high = high, 2*high + E.need(high.bit_length() < 40, 'bounded final-rank grid search') + while high-low > 1: + mid = (low+high)//2 + if passes(mid): + high = mid + else: + low = mid + H = step*high + E.need(passes(high) and (high == 1 or not passes(high-1)), + 'passing grid point and preceding failure') + # Above p/gap/ln(2), p*ln(1+H/h)-gap*H*ln(2) decreases. + # ln(2)>1/2 is enough for this conservative check. + E.need(H+h > 2*p/gap, 'decreasing final rank comparison') + E.need(Q(H) > log_m[1], 'uniform rank beyond ordinary base') + return {'kappa': str(kappa), 'gap': str(gap), 'method': method, **details, + 'uniform_saving': str(C-gap), + 'p': p, 'log_shift': h, 'eta': E.display(eta), + 'ordinary_base_cost': E.display(base_cost), + 'ordinary_base_factor': E.display(base_factor), + 'H': H, 'N': '2^'+str(H), 'grid_step': step, + 'grid_index': high, 'previous_grid_point_fails': high > 1, + 'word_materialized': False} + + +def certify(profile, witness): + return {'net_tax': net_tax(profile, witness), + 'uniform': uniform(profile, witness)} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('profile', type=Path, nargs='?') + parser.add_argument('witness', type=Path, nargs='?') + parser.add_argument('--example', help='replay one source-bound BENCHMARKS.json example') + args = parser.parse_args() + if args.example: + if args.profile or args.witness: + parser.error('choose --example or two input files') + here = Path(__file__).resolve().parent + cases = json.loads((here/'BENCHMARKS.json').read_text())['cases'] + matches = [case for case in cases if case['name'] == args.example] + if len(matches) != 1: + parser.error('unknown example') + case = matches[0] + profile = json.loads((here.parents[1]/case['source']).read_text()) + if case['profile_key']: + profile = profile[case['profile_key']] + witness = case['witness'] + else: + if not args.profile or not args.witness: + parser.error('provide profile.json witness.json, or --example NAME') + profile, witness = (json.loads(path.read_text()) + for path in (args.profile, args.witness)) + result = certify(profile, witness) + print(json.dumps(result, sort_keys=True, indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/net-tax-rank-compiler/intervals.py b/research/net-tax-rank-compiler/intervals.py new file mode 100644 index 0000000000..f3d990ab63 --- /dev/null +++ b/research/net-tax-rank-compiler/intervals.py @@ -0,0 +1,150 @@ +#!/usr/bin/env python3 +"""Outward rational intervals, adapted from my PR4433 arithmetic. + +All endpoints are fractions; series tails and every rounding are outward. +zxv with substantial OpenAI Codex assistance. Apache-2.0. +""" +from fractions import Fraction as Q +from functools import lru_cache +GRID = 2**192 + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def down(x): + return Q((x*GRID).__floor__(), GRID) + + +def up(x): + return Q(-((-x*GRID).__floor__()), GRID) + + +def rounded(lo, hi): + return down(lo), up(hi) + + +def mul(a, b): + products = [x*y for x in a for y in b] + return rounded(min(products), max(products)) + + +def scale(a, x): + return mul(a, (x, x)) + + +def divide(a, b): + need(b[0] > 0, 'positive interval denominator') + return mul(a, rounded(1/b[1], 1/b[0])) + + +@lru_cache(None) +def log_bounds(n): + """Exact atanh series, binary reduction; round only the final interval.""" + need(isinstance(n, int) and n >= 1, 'positive integer logarithm') + + def series(x): + u = (x-1)/(x+1) + term, total = u, Q(0) + for j in range(80): + total += 2*term/(2*j+1) + term *= u*u + tail = 2*term/(161*(1-u*u)) + return total, total+tail + + k = n.bit_length()-1 + a, b = series(Q(2)) + c, d = series(Q(n, 2**k)) + return rounded(k*a+c, k*b+d) + + +def exp_point(x): + """Outward fixed-point Taylor enclosure, with binary scaling/squaring.""" + need(abs(x) < 16, 'bounded exponential argument') + if x < 0: + a, b = exp_point(-x) + return rounded(1/b, 1/a) + divisions = 0 + while x > Q(1, 2): + x /= 2 + divisions += 1 + term = total = (Q(1), Q(1)) + for j in range(1, 65): + term = scale(term, x/j) + total = rounded(total[0]+term[0], total[1]+term[1]) + following = scale(term, x/65) + # Every remaining ratio is <= 1/132. Twice the next term is safe. + result = rounded(total[0], total[1]+2*following[1]) + for _ in range(divisions): + result = mul(result, result) + return result + + +def exp_interval(a): + return exp_point(a[0])[0], exp_point(a[1])[1] + + +@lru_cache(None) +def power(n, exponent): + return exp_interval(scale(log_bounds(n), exponent)) + + +def moment(histogram, exponent): + low = high = Q(0) + for n, count in histogram.items(): + a, b = power(n, exponent) + low += count*a + high += count*b + return rounded(low, high) + + +def display(a): + unit = 10**30 + + def fixed(n): + sign = '-' if n < 0 else '' + s = str(abs(n)).rjust(31, '0') + return sign+s[:-30]+'.'+s[-30:] + + return {'lower': fixed((a[0]*unit).__floor__()), + 'upper': fixed(-((-a[1]*unit).__floor__()))} + + +def encoded(x): + if isinstance(x, Q): + return str(x) + if isinstance(x, dict): + return {str(k): encoded(v) for k, v in x.items()} + if isinstance(x, (list, tuple)): + return [encoded(v) for v in x] + return x + + + +def add(a, b): + return rounded(a[0]+b[0], a[1]+b[1]) + + +def sub(a, b): + return rounded(a[0]-b[1], a[1]-b[0]) + + +def ipow(a, n): + """Integer powers of a nonnegative interval, bounded-size endpoints.""" + need(type(n) is int and n >= 0 and a[0] >= 0, 'nonnegative integer power') + out = (Q(1), Q(1)) + while n: + if n & 1: + out = mul(out, a) + a = mul(a, a) + n //= 2 + return out + + +def qpower(x, exponent): + """Positive rational base, rational exponent, with an enclosed logarithm.""" + x = Q(x) + need(x > 0, 'positive rational power base') + return exp_interval(scale(sub(log_bounds(x.numerator), + log_bounds(x.denominator)), exponent)) diff --git a/research/net-tax-rank-compiler/test_math.py b/research/net-tax-rank-compiler/test_math.py new file mode 100644 index 0000000000..25344d6eec --- /dev/null +++ b/research/net-tax-rank-compiler/test_math.py @@ -0,0 +1,186 @@ +"""Discriminating exact checks of the two structural proof steps. + +These finite cases check identities and failure modes; the general proofs +remain PROOF.md and SHIFTED-LOG.md. +""" +from collections import Counter +from fractions import Fraction as Q +from itertools import product +from math import comb, prod, factorial +import unittest +import intervals as E +import compiler + + +def exact_splits(rank, cutoff): + q, r = divmod(rank, cutoff) + return [cutoff]*q + ([r] if r else []) + + +def polynomial(ranks): + """Formal coefficients of symbols X_rank, before evaluating X_rank=rank^t.""" + return Counter(ranks) + + +def linear(*terms): + out = Counter() + for multiplier, values in terms: + for key, count in values.items(): + out[key] += multiplier*count + return {key: count for key, count in out.items() if count} + + +class NetTaxMath(unittest.TestCase): + def test_literal_gap_identity_and_target_credit_control(self): + targets, paid = [1, 4, 4, 9], [1, 1, 8] + for v in (1, 2, 3): + T = [prod(word) for word in product(targets, repeat=v)] + P = [prod(word) for word in product(paid, repeat=v)] + J, L = 2**v, 5**v + split_paid = [part for rank in P for part in exact_splits(rank, J)] + completions = [K for K in T if K < L] + split_completion = [part for K in completions + for part in exact_splits(L-K, J)] + final_targets = polynomial([max(K, L) for K in T]) + final_paid = polynomial(split_paid+split_completion) + raw_gap = linear((1, polynomial(T)), (-1, polynomial(P))) + original_tax = linear((1, polynomial(split_paid)), (-1, polynomial(P))) + completion_tax = linear((1, polynomial(split_completion)), + (-1, polynomial([L]*len(completions))), + (1, polynomial(completions))) + direct = linear((1, final_targets), (-1, final_paid)) + decomposed = linear((1, raw_gap), (-1, original_tax), (-1, completion_tax)) + self.assertEqual(direct, decomposed) + # Omitting the new target moment is a genuine incorrect identity. + missing_credit = linear((1, raw_gap), (-1, original_tax), + (-1, polynomial(split_completion))) + self.assertNotEqual(direct, missing_credit) + self.assertEqual(sum(T)-sum(P), + sum(max(K, L) for K in T)-sum(split_paid+split_completion)) + + def test_paid_tax_against_literal_splits(self): + C, t = Q(1, 2), Q(1, 2) + for u in (C, Q(3, 4), Q(3, 2), Q(3)): + h = E.scale(E.qpower(t, t/C), C) + monotone = (max(C/u, h[0]), max(C/u, h[1])) + jensen = (E.power(2, C) if u == C else E.scale( + E.mul(E.power(2, u), E.qpower(1-C/u, u/C-1)), C/u)) + for J in range(1, 13): + for R in range(J+1, 65): + charge = E.moment(Counter(exact_splits(R, J)), t) + tax = E.sub(charge, E.power(R, t)) + scale = E.mul(E.power(R, t+u), E.power(J, -u)) + # Each coefficient is valid independently, including u=C + # and u large enough that h dominates C/u. + for coefficient in (monotone, jensen): + bound = E.mul(coefficient, scale) + self.assertLess(tax[1], bound[0]) + + def test_completion_net_tax_against_literal_splits(self): + C, t = Q(1, 2), Q(1, 2) + h = E.scale(E.qpower(t, t/C), C) + for J in range(1, 9): + for L in range(J+1, 25): + universal = E.sub(E.add(E.mul((Q(L),)*2, E.power(J, -C)), + E.scale(E.mul(h, E.power(J, t)), 2)), + E.power(L, t)) + for K in range(1, L): + literal = E.sub(E.add(E.power(K, t), + E.moment(Counter(exact_splits(L-K, J)), t)), + E.power(L, t)) + if 4*K == J and 4*((L-K) % J) == J: + # Both maxima rho^t-rho are attained at rho=1/4; + # this is exact equality, independently of rounding. + self.assertLessEqual(literal[0], universal[1]) + self.assertLessEqual(universal[0], literal[1]) + else: + self.assertLess(literal[1], universal[0]) + # Including target credit matters: completion can cost + # far less than its entire paid charge. + if K == L-1: + paid = E.moment(Counter(exact_splits(L-K, J)), t) + self.assertLess(literal[1], paid[0]) + + def test_rational_interval_reference_points(self): + self.assertLess(E.log_bounds(2)[0], Q('0.693147180559945309417232121459')) + self.assertGreater(E.log_bounds(2)[1], Q('0.693147180559945309417232121458')) + for base, exponent, exact in ((4, Q(1, 2), 2), (9, Q(1, 2), 3), + (Q(1, 4), Q(-1, 2), 2)): + lo, hi = E.qpower(base, exponent) + self.assertLessEqual(lo, exact) + self.assertGreaterEqual(hi, exact) + + def test_convex_order_against_nonbernoulli_inventory(self): + # A genuine three-point law with mean1/2. Iterated chord domination + # bounds it by Binomial(n,1/2), including its actual variance. + law = [(Q(0), Q(1, 4)), (Q(1, 2), Q(1, 2)), (Q(1), Q(1, 4))] + for n in range(1, 5): + for p in (1, 2, 5, 8): + actual = sum(prod(w for _, w in word)*(1+sum(x for x, _ in word))**p + for word in product(law, repeat=n)) + chord = sum(Q(comb(n, k), 2**n)*(1+k)**p for k in range(n+1)) + self.assertLessEqual(actual, chord) + + def test_weighted_polynomial_identity_and_shift_control(self): + p, q, A, B0, beta = 7, Q(3, 5), Q(4, 5), Q(5, 2), Q(6, 5) + _, _, numerator, denominator = compiler.weighted_coefficients(p, q, A, B0, beta) + for G in range(0, 10): + falling = [prod(range(G-j+1, G+1)) for j in range(p+1)] + lhs = sum(comb(G+1, k)*q**k*(1-q)**(G+1-k)*(A+k)**p + for k in range(G+2)) + self.assertEqual(lhs, sum(x*y for x, y in zip(numerator, falling))) + self.assertEqual((B0+beta*G)**p, + sum(x*y for x, y in zip(denominator, falling))) + # Dropping the final paid round (G rather thanG+1) is false atG0. + self.assertNotEqual(numerator[0], A**p) + + def test_target_credit_is_invalid_for_paid_log_mean(self): + J, L, K, t = 4, 25, 1, Q(1, 2) + paid = E.moment(Counter(exact_splits(L-K, J)), t) + net = E.sub(E.add(E.power(K, t), paid), E.power(L, t)) + self.assertGreater(paid[0], net[1]) + # Every completion piece here has rankJ. Its full paid moment, + # rather than the smaller net tax, multiplies lnJ exactly. + literal_log = E.scale(E.log_bounds(J), 12) + wrong_log = E.mul(net, E.log_bounds(J)) + self.assertGreater(literal_log[0], wrong_log[1]) + + def test_bell_coefficients_against_independent_newton_differences(self): + p, A, B0, beta = 7, Q(4, 5), Q(5, 2), Q(6, 5) + law = {Q(0): Q(1, 4), Q(1, 2): Q(1, 2), Q(1): Q(1, 4)} + moments = [sum(weight*x**i for x, weight in law.items()) for i in range(p+1)] + _, _, numerator, _ = compiler.moment_coefficients(p, moments, A, B0, beta) + distribution = {Q(0): Q(1)} + values = [] + for G in range(p+1): + changed = Counter() + for x, a in distribution.items(): + for y, b in law.items(): + changed[x+y] += a*b + distribution = changed + values.append(sum(weight*(A+x)**p for x, weight in distribution.items())) + newton = [] + while values: + newton.append(values[0]/factorial(len(newton))) + values = [b-a for a, b in zip(values, values[1:])] + self.assertEqual(numerator, newton) + # Bernoulli moments reduce exactly to the earlier weighted theorem. + q = Q(3, 5) + self.assertEqual(compiler.moment_coefficients(p, [Q(1)]+[q]*p, A, B0, beta), + compiler.weighted_coefficients(p, q, A, B0, beta)) + + def test_concentration_and_capped_mass_perturbation(self): + v, rho, raw_mean, epsilon = 3, Q(3, 2), Q(3, 4), Q(1, 10) + p = 9 + bounds = compiler.concentrated_moments(p, v, raw_mean, rho, epsilon) + for i in range(1, p+1): + capped = sum(Q(comb(v, k), 2**v)*min(Q(1), rho*k/v)**i + for k in range(v+1)) + for actual_excess in (Q(0), epsilon/2, epsilon): + final = (capped+actual_excess)/(1+actual_excess) + self.assertLessEqual(final, bounds[i]) + self.assertLessEqual(bounds[i], 1) + + +if __name__ == '__main__': + unittest.main() diff --git a/research/net-tax-rank-compiler/verify.py b/research/net-tax-rank-compiler/verify.py new file mode 100644 index 0000000000..62f81b2a38 --- /dev/null +++ b/research/net-tax-rank-compiler/verify.py @@ -0,0 +1,198 @@ +#!/usr/bin/env python3 +"""Source-bound replay of the scoped rank certificates. + +Native and outer producer receipts are inherited, not recomputed here. +zxv with substantial OpenAI Codex assistance. Apache-2.0. +""" +import argparse +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha1, sha256 +import io +import json +from pathlib import Path +import sys +import unittest +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +import compiler +import intervals as E +import test_math + +ROOT = HERE.parents[1] +FLOW = ('research/kappa-rebuild/architecture/sources/Sussman-563b4e6/' + 'research/record-track/programs/theorem-1g/tree_flow.py') + + +def authenticate_bytes(raw, row): + E.need(sha256(raw).hexdigest() == row['sha256'], 'source SHA256: '+row['path']) + E.need(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() + == row['git_blob'], 'source Git blob: '+row['path']) + + +def authenticate(): + manifest = json.loads((HERE/'SOURCES.json').read_text()) + receipts = {} + for row in manifest['files']: + if row['usage'] == 'input': + raw = (ROOT/row['path']).read_bytes() + authenticate_bytes(raw, row) + receipts[row['path']] = row['sha256'] + first = next(row for row in manifest['files'] if row['usage'] == 'input') + try: + authenticate_bytes((ROOT/first['path']).read_bytes()+b' ', first) + except ValueError: + pass + else: + raise ValueError('source mutation control accepted') + return receipts + + +def literal_flow_checks(): + # Execute authenticated source bytes directly, bypassing bytecode caches. + path = ROOT/FLOW + env = {'__file__': str(path), '__name__': 'pinned_tree_flow_oracle'} + exec(compile(path.read_bytes(), str(path), 'exec'), env) + receipt = [] + for n in (5, 14, 15, 44, 45, 135): + paid = [1, 1, 1, 1, 2] + actual, tree = env['lockstep_literal']({3: 2, 5: 1}, paid, n) + expected = Counter({1: 1}) + for _ in range(tree.G+1): + changed = Counter() + for rank, count in expected.items(): + for r in paid: + changed[rank*r] += count + expected = changed + E.need(actual['issued_before_start'] and actual['exits'] == dict(expected), + 'literal chronological exit law') + receipt.append({'top_rank': n, 'G': tree.G, + 'exits': dict(sorted(expected.items())), + 'literal_classes': actual['classes']}) + return receipt + + +def inherited_consumer(source, result, kind): + if kind == 'native': + outer, original = source['outer'], source['compiler'] + legacy = source['legacy_outer']['checks'] + else: + outer, original = source['outer']['ledger'], source['uniform_rank'] + legacy = source['outer']['legacy_63_checks'] + point = outer['parameters'] + E.need(Q(result['uniform']['kappa']) == Q(source['kappa']) == Q(point['kappa']), + 'unchanged inherited kappa point') + required = Q(point['complex_uniform_saving']) + available = Q(result['uniform']['uniform_saving']) + E.need(available >= required, 'new uniform bound supplies retained outer point') + E.need(Q(original['uniform_saving']) == required, 'source compiler/consumer binding') + for name in ('strict_checks', 'functional_checks'): + E.need(outer[name] and all(Q(x) > 0 for x in outer[name].values()), + 'positive inherited consumer receipt: '+name) + E.need(len(outer['margins']) == 9 + and all(Q(x) > Q(source['kappa']) for x in outer['margins'].values()), + 'nine inherited outer margins') + E.need(len(legacy) == 63 and all(Q(x) > 0 for x in legacy.values()), + 'legacy inherited receipt') + return {'status': 'INHERITED_RECEIPT_AND_MONOTONE_BOUND_BINDING', + 'producer_replayed': False, 'source_H': original['H'], + 'retained_kappa': str(Q(source['kappa'])), + 'required_uniform_saving': str(required), + 'available_uniform_saving': str(available), + 'strict_checks_in_receipt': len(outer['strict_checks']), + 'functional_checks_in_receipt': len(outer['functional_checks']), + 'legacy_checks_in_receipt': len(legacy), + 'rank_exponent_reduction': str(Q(original['H'], result['uniform']['H']))} + + +def expect_rejected(profile, witness, fragment, mutate): + changed = deepcopy(witness) + mutate(changed) + try: + compiler.certify(profile, changed) + except ValueError as exc: + E.need(fragment in str(exc), 'unexpected rejection: '+str(exc)) + return str(exc) + raise ValueError('invalid certificate accepted: '+fragment) + + +def run(): + sources = authenticate() + tests = unittest.defaultTestLoader.loadTestsFromModule(test_math) + stream = io.StringIO() + tested = unittest.TextTestRunner(stream=stream, verbosity=1).run(tests) + E.need(tested.wasSuccessful(), stream.getvalue()) + examples, profiles, witnesses = {}, {}, {} + for case in json.loads((HERE/'BENCHMARKS.json').read_text())['cases']: + source = json.loads((ROOT/case['source']).read_text()) + kind = 'p7' if case['profile_key'] else 'native' + if kind == 'native': + E.need(source['status'] == 'PASS_CONDITIONAL_NEW_NATIVE_PROFILE_KAPPA', + 'native source receipt status') + else: + E.need(source['status'] == 'PASS_HIGHER_MOMENT_STRICTIFICATION', + 'p7 source receipt status') + profile = source if case['profile_key'] is None else source[case['profile_key']] + result = compiler.certify(profile, case['witness']) + result['consumer_binding'] = inherited_consumer(source, result, kind) + examples[case['name']] = result + profiles[case['name']], witnesses[case['name']] = profile, case['witness'] + baseline = examples['native-source-parameters']['uniform']['H'] + native = json.loads((ROOT/'research/native-lattice-retiming/RESULT.json').read_text()) + E.need(baseline == native['compiler']['H'], 'source rank reproduced by old parameters') + final_name = 'native-concentrated-balanced' + profile, witness = profiles[final_name], witnesses[final_name] + negatives = {} + for name, fragment, mutation in ( + ('too_small_tensor', 'strict net moment', lambda w: w.update(v=20)), + ('invalid_tail_exponent', 'net tax exponent', lambda w: w.update(u='1/100000')), + ('closed_uniform_saving', 'uniform exponent', lambda w: w.update(kappa=w['saving'])), + ('degree23', 'polynomial coefficients', lambda w: w.update(p=23)), + ('understated_raw_mean', 'raw paid log mean', + lambda w: w['weighted'].update(raw_mean_upper='4/5')), + ('understated_log_support', 'raw paid log support', + lambda w: w['weighted'].update(raw_log_bound='1')), + ('understated_full_paid_excess', 'full paid mass perturbation', + lambda w: w['weighted'].update(paid_excess_upper='1/100000000')), + ('wrong_log_shift_enclosure', 'normalized log shift', + lambda w: w['weighted'].update(A_upper='347/100')), + ('drop_tensor_concentration', 'polynomial coefficients', + lambda w: (w.update(uniform_method='weighted'), + w['weighted'].update(mean_upper=w['weighted']['raw_mean_upper']))), + ): + negatives[name] = expect_rejected(profile, witness, fragment, mutation) + # The earlier full-charge proof fails on the new small tensor, so the + # improvement cannot be obtained merely by retaining its estimate. + old = examples[final_name]['net_tax']['predecessor_full_charge_bound'] + E.need(Q(old['lower']) > 1, 'old full-charge comparison fails') + return {'schema_version': 1, 'status': 'PASS_NET_TAX_AND_LOG_MOMENT_RANK_COMPILER', + 'scope': 'Conditional finite rank/leaf bounds; inherited native and outer producer receipts; no new kappa, selected frontier, materialized word or physical runtime claim.', + 'source_sha256': sources, 'examples': examples, + 'literal_pinned_flow_checks': literal_flow_checks(), + 'exact_math_tests': tested.testsRun, + 'rejected_mutations': negatives, + 'source_mutation_rejected': True} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true', help='replace the local exact receipt') + args = parser.parse_args() + result = run() + payload = json.dumps(result, indent=2, sort_keys=True)+'\n' + target = HERE/'RESULT.json' + if args.write: + target.write_text(payload) + else: + E.need(target.read_text() == payload, 'receipt differs; inspect then run --write') + print(json.dumps({'status': result['status'], 'examples': { + name: {'H': item['uniform']['H'], 'v': item['net_tax']['v'], + 'method': item['uniform']['method']} + for name, item in result['examples'].items()}, + 'exact_math_tests': result['exact_math_tests'], + 'rejected_mutations': len(result['rejected_mutations'])}, sort_keys=True)) + + +if __name__ == '__main__': + main() From 638f4fb6035abb2562f25d9fb7b570d9f2354108 Mon Sep 17 00:00:00 2001 From: zxv Date: Wed, 21 Oct 2026 18:40:50 -0400 Subject: [PATCH 10/13] Enforce authenticated benchmark and compiler-oracle coverage --- research/net-tax-rank-compiler/README.md | 3 ++- research/net-tax-rank-compiler/compiler.py | 2 +- research/net-tax-rank-compiler/verify.py | 2 ++ 3 files changed, 5 insertions(+), 2 deletions(-) diff --git a/research/net-tax-rank-compiler/README.md b/research/net-tax-rank-compiler/README.md index ccf5fe17a5..fca02f443e 100644 --- a/research/net-tax-rank-compiler/README.md +++ b/research/net-tax-rank-compiler/README.md @@ -13,7 +13,8 @@ The contribution is four connected proof steps and a generic exact checker: 1. **Net splitting and completion taxes.** Charge the increase in paid moment and retain the productive moment added by same-owner completion. - The splitting coefficient scales as `O(C/u)` rather than a fixed two. + For `C<=u<=1`, the splitting coefficient scales as `O(C/u)` rather + than a fixed two. 2. **Normalized logarithmic majorants.** Use `(1+log2(n)/h)^p`, checking the entire ordinary base range at one endpoint. The scale is a certified parameter adapted to the finite unit. diff --git a/research/net-tax-rank-compiler/compiler.py b/research/net-tax-rank-compiler/compiler.py index f5b5e5bb93..bc58fbd7a7 100644 --- a/research/net-tax-rank-compiler/compiler.py +++ b/research/net-tax-rank-compiler/compiler.py @@ -288,7 +288,7 @@ def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('profile', type=Path, nargs='?') parser.add_argument('witness', type=Path, nargs='?') - parser.add_argument('--example', help='replay one source-bound BENCHMARKS.json example') + parser.add_argument('--example', help='replay a BENCHMARKS.json example; verify.py authenticates sources') args = parser.parse_args() if args.example: if args.profile or args.witness: diff --git a/research/net-tax-rank-compiler/verify.py b/research/net-tax-rank-compiler/verify.py index 62f81b2a38..048fd977e2 100644 --- a/research/net-tax-rank-compiler/verify.py +++ b/research/net-tax-rank-compiler/verify.py @@ -119,12 +119,14 @@ def expect_rejected(profile, witness, fragment, mutate): def run(): sources = authenticate() + E.need(FLOW in sources, 'literal oracle must be an authenticated live input') tests = unittest.defaultTestLoader.loadTestsFromModule(test_math) stream = io.StringIO() tested = unittest.TextTestRunner(stream=stream, verbosity=1).run(tests) E.need(tested.wasSuccessful(), stream.getvalue()) examples, profiles, witnesses = {}, {}, {} for case in json.loads((HERE/'BENCHMARKS.json').read_text())['cases']: + E.need(case['source'] in sources, 'benchmark source must be an authenticated live input') source = json.loads((ROOT/case['source']).read_text()) kind = 'p7' if case['profile_key'] else 'native' if kind == 'native': From 393cdcf0a2dd33c3d05487d8251b84b284bbc57d Mon Sep 17 00:00:00 2001 From: zxv Date: Wed, 21 Oct 2026 18:42:32 -0400 Subject: [PATCH 11/13] Record portable replay and independent audit evidence --- research/net-tax-rank-compiler/TASK.json | 8 ++- research/net-tax-rank-compiler/VALIDATION.md | 53 ++++++++++++++++++++ 2 files changed, 60 insertions(+), 1 deletion(-) create mode 100644 research/net-tax-rank-compiler/VALIDATION.md diff --git a/research/net-tax-rank-compiler/TASK.json b/research/net-tax-rank-compiler/TASK.json index b91c112d79..343ea8f7f4 100644 --- a/research/net-tax-rank-compiler/TASK.json +++ b/research/net-tax-rank-compiler/TASK.json @@ -127,6 +127,12 @@ "native_and_outer_producer_suites": "inherited source receipts, not rerun", "platform": "macOS arm64", "python": "3.12.8", - "independent_mathematical_checks": "Separate Sol 6.1 xhigh audit; Bell coefficients independently recovered through iid moment convolution and Newton differences." + "independent_mathematical_checks": "Separate Sol 6.1 xhigh audit; Bell coefficients independently recovered through iid moment convolution and Newton differences.", + "committed_bytes": "pass at 638f4fb6035abb2562f25d9fb7b570d9f2354108", + "export_integrity": "pass", + "git_free_isolated_optimized_export": "pass; PATH=/nonexistent", + "exported_source_and_receipt_mutations": "rejected", + "optional_source_history": "unavailable: shallow checkout; not a passing ancestry check", + "publication": "local only" } } diff --git a/research/net-tax-rank-compiler/VALIDATION.md b/research/net-tax-rank-compiler/VALIDATION.md new file mode 100644 index 0000000000..185a4bcb95 --- /dev/null +++ b/research/net-tax-rank-compiler/VALIDATION.md @@ -0,0 +1,53 @@ +# Validation of the structural rank compiler + +Validated on 2026-10-21, macOS arm64, Python 3.12.8. Scientific code at +`638f4fb6035abb2562f25d9fb7b570d9f2354108`; later validation metadata does +not change the certificate machinery or mathematical receipt. + +- Registered metadata/source pins and the bounded package replay pass. +- Seven exact benchmark certificates pass, including the original native + rank parameters and two separate source profiles. +- Nine mathematical tests pass: formal net-gap accounting, literal split + taxes, completion bounds including equality, rational interval reference + points, convex order, coefficient identities, independent Newton-difference + reconstruction of Bell coefficients, and capped mass perturbations. +- Nine invalid witnesses are rejected, including degree 23, removal of + tensor concentration, understated full paid costs and invalid log bounds. +- Six literal flows from the unchanged authenticated Sussman oracle agree + exactly with independent `(G+1)`-fold paid-histogram convolution. +- Committed-byte preflight passes for all 24 package/input files. +- The committed export passes transport/inventory integrity. Its direct + verifier passes under `python3.12 -I -O -B` with no Git checkout and + `PATH=/nonexistent`. Mutating a pinned source or its output receipt is + rejected in that export. +- Separate user-requested Sol 6.1 xhigh agents audited the mathematical + bounds and source/consumer binding. One audit recovered Bell coefficients + through ordinary iid moment convolution and Newton differences, avoiding + the implementation's Bell recurrence. + +Reproduction: + +```sh +python3.12 -B scripts/research_package.py --package research/net-tax-rank-compiler +python3.12 -I -O -B research/net-tax-rank-compiler/verify.py +python3.12 -B scripts/check_research_commit.py --package research/net-tax-rank-compiler +``` + +The optional `--check-source-history` preflight is **unavailable** because +this checkout is shallow; it requests full Git history. This is not a +passing ancestry check. Exact committed input bytes and Git-free direct +replay were checked separately; no full-history fetch was attempted. + +Canonical main was refreshed at 22:39 UTC and remains +`2a13eb1827784206202db90e5dc8327cf8a250db`; relevant guidance is unchanged. +Overlap checking covers 310 open PR bodies and 3,301 discussion records, +with complete remote pagination. Local coverage is sparse: 23 of 5,739 +HEAD note paths were searched. This is not a novelty certificate. + +Native and outer producer suites were not rerun. Their authenticated source +receipts and conditional obligations are explicitly inherited. The new +uniform saving supplies the retained outer point by monotonicity. No +winning word, full productive width, physical count, precision constant, +new κ or selected-frontier update is certified by this replay. + +No PR, Discussion post or remote branch was published for this contribution. From 896b877eae0b297c6da1ee78c6dd6a94a9c5868f Mon Sep 17 00:00:00 2001 From: zxv Date: Wed, 21 Oct 2026 20:16:57 -0400 Subject: [PATCH 12/13] Record approval to publish the reviewed rank compiler --- research/net-tax-rank-compiler/README.md | 2 +- research/net-tax-rank-compiler/TASK.json | 8 +++++--- research/net-tax-rank-compiler/VALIDATION.md | 3 ++- 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/research/net-tax-rank-compiler/README.md b/research/net-tax-rank-compiler/README.md index fca02f443e..2e2d973866 100644 --- a/research/net-tax-rank-compiler/README.md +++ b/research/net-tax-rank-compiler/README.md @@ -161,7 +161,7 @@ Structured questions and blockers are in [TASK.json](TASK.json). zxv, with substantial OpenAI Codex assistance, including user-requested Sol 6.1 xhigh subagents for divergent probes and independent mathematical audits. These are author-side AI checks, not formal verification or an -independent human review. This contribution remains local for user review. +independent human review. The user authorized submission of this reviewed contribution on 2026-10-22. The finite integer compiler is Jacob Alan Sussman's Theorem 1G, retained through PR4268/PR4359. Chronological product/completion and logarithmic diff --git a/research/net-tax-rank-compiler/TASK.json b/research/net-tax-rank-compiler/TASK.json index 343ea8f7f4..3401994676 100644 --- a/research/net-tax-rank-compiler/TASK.json +++ b/research/net-tax-rank-compiler/TASK.json @@ -73,7 +73,7 @@ "actual_scope": "Develop reusable structural rank reductions for the chronological-product and finite uniform compiler, with exact reusable witnesses on native4453 and p7 profiles.", "scope_change_reason": "The user explicitly assigned systematic structural rank reduction for future submissions; this overrides the catalogue default supplier audit. No new native profile or kappa hill step is claimed.", "bottleneck_link": "Net concavity taxes and paid logarithmic moments reduce the tensor power and the sufficient uniform rank without changing native jobs.", - "stop_rule": "Finish a source-bound theorem and exact reusable certificate with discriminating controls; keep local for user review and leave further supplier changes open.", + "stop_rule": "Publish the reviewed rank-compiler contribution, retaining its exact scientific scope; start the next larger contribution in a fresh tree.", "evidence": "Net gap identity, sharp concavity coefficients, normalized-log induction, exact iid exit law, convex-order and Bell-polynomial certificates, literal pinned-flow probes and independent agent audit.", "author": "zxv, with substantial OpenAI Codex assistance", "ai_assistance": "Substantial OpenAI Codex assistance, including three user-requested Sol 6.1 xhigh subagents for divergent probes and independent audits.", @@ -99,13 +99,15 @@ "blocked_by": "The winning words remain algorithm-defined and their full widths are not emitted." } ], - "publication_policy": "Keep this contribution local for user review. No PR or Discussion publication is authorized for this contribution yet.", + "publication_policy": "User approved submission of this reviewed contribution on 2026-10-22. No Discussion participation is requested. Future contributions remain local for review; future subagents should use Sol 6.1 medium.", "upstream_checkpoint": { "checked_at_utc": "2026-10-21T22:13:49Z", "canonical_main": "2a13eb1827784206202db90e5dc8327cf8a250db", "priority_revision": 7, "refresh_checked_at_utc": "2026-10-21T22:39:21Z", - "refresh_result": "Canonical main and relevant guidance unchanged." + "refresh_result": "Canonical main and relevant guidance unchanged.", + "publication_refresh_checked_at_utc": "2026-10-22T00:16:00Z", + "publication_refresh_result": "Canonical main and relevant guidance unchanged; newer pending PR4470/4479 acknowledged without changing this reviewed result." }, "overlap": { "checked_at_utc": "2026-10-21T22:18:00Z", diff --git a/research/net-tax-rank-compiler/VALIDATION.md b/research/net-tax-rank-compiler/VALIDATION.md index 185a4bcb95..9ade189564 100644 --- a/research/net-tax-rank-compiler/VALIDATION.md +++ b/research/net-tax-rank-compiler/VALIDATION.md @@ -50,4 +50,5 @@ uniform saving supplies the retained outer point by monotonicity. No winning word, full productive width, physical count, precision constant, new κ or selected-frontier update is certified by this replay. -No PR, Discussion post or remote branch was published for this contribution. +The initial validation was local. The user authorized PR submission on +2026-10-22; no Discussion participation is requested. From 4cf054a50c5718616594ec4ca2c9114278120a8b Mon Sep 17 00:00:00 2001 From: zxv Date: Wed, 21 Oct 2026 20:44:07 -0400 Subject: [PATCH 13/13] Exclude inherited shared-doc edits from the rank compiler PR --- docs/ci-verification.md | 12 ------------ docs/research/current-status.md | 6 ++---- 2 files changed, 2 insertions(+), 16 deletions(-) diff --git a/docs/ci-verification.md b/docs/ci-verification.md index 50e8120dc0..582e416aaf 100644 --- a/docs/ci-verification.md +++ b/docs/ci-verification.md @@ -2,18 +2,6 @@ ## 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 532af84312..62a8cbb097 100644 --- a/docs/research/current-status.md +++ b/docs/research/current-status.md @@ -1,14 +1,12 @@ # 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. -All sections below are a historical snapshot; the selected-result.json record above is authoritative. - -## Historical checkpoint through #1094 +## Historical selected status 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.