From 73e323159d65c974debb180189694fd59144da5f Mon Sep 17 00:00:00 2001 From: Gareth Davidson Date: Wed, 14 Oct 2026 17:30:46 +0100 Subject: [PATCH 1/2] Research: bound joint selected k8 helper-end and frame contractions --- .../DISCOVERY.json | 1522 +++++++++++++++++ .../DUALS.json.gz | Bin 0 -> 47940 bytes .../EXPECTED.json | 164 ++ .../INPUTS.json | 14 + .../NOTICE.md | 40 + .../PRIMAL.json.gz | Bin 0 -> 7791 bytes .../PROOF.md | 204 +++ .../README.md | 134 ++ .../SOURCES.json | 90 + .../TASK.json | 433 +++++ .../VERIFY.json | 54 + .../common.py | 108 ++ .../independent.py | 455 +++++ .../materialize.py | 40 + .../model.py | 118 ++ .../nominate.py | 123 ++ .../references/CEILING.md | 108 ++ .../references/END-RECIPE.json | 242 +++ .../references/END-WITNESS.md | 98 ++ .../references/FRAME-METHOD.md | 75 + .../references/SLOT-PINS.json | 47 + .../references/WORD-LINEAGE.md | 101 ++ .../references/WORD.json.gz | Bin 0 -> 57222 bytes .../references/audit_local.py | 171 ++ .../references/ceiling.py | 152 ++ .../references/construct.py | 37 + .../references/frame_model.py | 434 +++++ .../references/gen_duals.py | 149 ++ .../test_package.py | 204 +++ .../verify.py | 177 ++ 30 files changed, 5494 insertions(+) create mode 100644 research/selected-k8-endpoint-contractions/DISCOVERY.json create mode 100644 research/selected-k8-endpoint-contractions/DUALS.json.gz create mode 100644 research/selected-k8-endpoint-contractions/EXPECTED.json create mode 100644 research/selected-k8-endpoint-contractions/INPUTS.json create mode 100644 research/selected-k8-endpoint-contractions/NOTICE.md create mode 100644 research/selected-k8-endpoint-contractions/PRIMAL.json.gz create mode 100644 research/selected-k8-endpoint-contractions/PROOF.md create mode 100644 research/selected-k8-endpoint-contractions/README.md create mode 100644 research/selected-k8-endpoint-contractions/SOURCES.json create mode 100644 research/selected-k8-endpoint-contractions/TASK.json create mode 100644 research/selected-k8-endpoint-contractions/VERIFY.json create mode 100644 research/selected-k8-endpoint-contractions/common.py create mode 100644 research/selected-k8-endpoint-contractions/independent.py create mode 100644 research/selected-k8-endpoint-contractions/materialize.py create mode 100644 research/selected-k8-endpoint-contractions/model.py create mode 100644 research/selected-k8-endpoint-contractions/nominate.py create mode 100644 research/selected-k8-endpoint-contractions/references/CEILING.md create mode 100644 research/selected-k8-endpoint-contractions/references/END-RECIPE.json create mode 100644 research/selected-k8-endpoint-contractions/references/END-WITNESS.md create mode 100644 research/selected-k8-endpoint-contractions/references/FRAME-METHOD.md create mode 100644 research/selected-k8-endpoint-contractions/references/SLOT-PINS.json create mode 100644 research/selected-k8-endpoint-contractions/references/WORD-LINEAGE.md create mode 100644 research/selected-k8-endpoint-contractions/references/WORD.json.gz create mode 100644 research/selected-k8-endpoint-contractions/references/audit_local.py create mode 100644 research/selected-k8-endpoint-contractions/references/ceiling.py create mode 100644 research/selected-k8-endpoint-contractions/references/construct.py create mode 100644 research/selected-k8-endpoint-contractions/references/frame_model.py create mode 100644 research/selected-k8-endpoint-contractions/references/gen_duals.py create mode 100644 research/selected-k8-endpoint-contractions/test_package.py create mode 100644 research/selected-k8-endpoint-contractions/verify.py diff --git a/research/selected-k8-endpoint-contractions/DISCOVERY.json b/research/selected-k8-endpoint-contractions/DISCOVERY.json new file mode 100644 index 0000000000..4402b857ab --- /dev/null +++ b/research/selected-k8-endpoint-contractions/DISCOVERY.json @@ -0,0 +1,1522 @@ +{ + "versions": { + "highspy": "1.15.1", + "numpy": "2.5.4", + "scipy": "1.18.1" + }, + "components": [ + { + "first": [ + "E", + 311 + ], + "nodes": 23, + "rows": 179, + "columns": 192, + "fractional_columns": 0, + "numeric_objective": 204.21695383497496 + }, + { + "first": [ + "E", + 327 + ], + "nodes": 691, + "rows": 4799, + "columns": 4592, + "fractional_columns": 0, + "numeric_objective": 6386.787362295278 + }, + { + "first": [ + "E", + 448 + ], + "nodes": 197, + "rows": 1405, + "columns": 1300, + "fractional_columns": 0, + "numeric_objective": 1878.6101049982842 + }, + { + "first": [ + "E", + 500 + ], + "nodes": 9, + "rows": 57, + "columns": 54, + "fractional_columns": 0, + "numeric_objective": 102.10847691748745 + }, + { + "first": [ + "E", + 501 + ], + "nodes": 9, + "rows": 57, + "columns": 54, + "fractional_columns": 0, + "numeric_objective": 102.10847691748745 + }, + { + "first": [ + "G", + 616 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 758 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 900 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1042 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1184 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1266 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1270 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1274 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1278 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1311 + ], + "nodes": 326, + "rows": 5556, + "columns": 8546, + "fractional_columns": 0, + "numeric_objective": 583.5694316572738 + }, + { + "first": [ + "G", + 1420 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1424 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1428 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1432 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1574 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1578 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1582 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1586 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1728 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1732 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1736 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1740 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1882 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1886 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1890 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 1894 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2036 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2040 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2044 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2048 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2190 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2194 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2198 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2202 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2344 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2348 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2352 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2356 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2461 + ], + "nodes": 10, + "rows": 154, + "columns": 288, + "fractional_columns": 0, + "numeric_objective": 40.846615369751866 + }, + { + "first": [ + "G", + 2498 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2502 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2506 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2510 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2615 + ], + "nodes": 10, + "rows": 154, + "columns": 288, + "fractional_columns": 0, + "numeric_objective": 40.846615369751866 + }, + { + "first": [ + "G", + 2652 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2656 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2660 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2664 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2769 + ], + "nodes": 10, + "rows": 154, + "columns": 288, + "fractional_columns": 0, + "numeric_objective": 40.846615369751866 + }, + { + "first": [ + "G", + 2806 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2810 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2814 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2818 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2923 + ], + "nodes": 10, + "rows": 154, + "columns": 288, + "fractional_columns": 0, + "numeric_objective": 40.846615369751866 + }, + { + "first": [ + "G", + 2960 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2964 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2968 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 2972 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 3005 + ], + "nodes": 90, + "rows": 1514, + "columns": 2224, + "fractional_columns": 0, + "numeric_objective": 119.00453098089815 + }, + { + "first": [ + "G", + 3114 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 3118 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 3122 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 3126 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 3159 + ], + "nodes": 90, + "rows": 1514, + "columns": 2224, + "fractional_columns": 0, + "numeric_objective": 119.00453098089815 + }, + { + "first": [ + "G", + 3268 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 3272 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 3276 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 3280 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 3313 + ], + "nodes": 90, + "rows": 1514, + "columns": 2224, + "fractional_columns": 0, + "numeric_objective": 119.00453098089815 + }, + { + "first": [ + "G", + 3978 + ], + "nodes": 21, + "rows": 141, + "columns": 132, + "fractional_columns": 0, + "numeric_objective": 255.41699679873673 + }, + { + "first": [ + "G", + 4062 + ], + "nodes": 21, + "rows": 141, + "columns": 132, + "fractional_columns": 0, + "numeric_objective": 255.41699679873676 + }, + { + "first": [ + "G", + 4083 + ], + "nodes": 21, + "rows": 141, + "columns": 132, + "fractional_columns": 0, + "numeric_objective": 255.41699679873673 + }, + { + "first": [ + "G", + 4104 + ], + "nodes": 21, + "rows": 141, + "columns": 132, + "fractional_columns": 0, + "numeric_objective": 255.41699679873676 + }, + { + "first": [ + "G", + 4125 + ], + "nodes": 21, + "rows": 141, + "columns": 132, + "fractional_columns": 0, + "numeric_objective": 255.41699679873676 + }, + { + "first": [ + "G", + 4683 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4686 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4689 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4692 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4695 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4698 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4701 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4704 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4707 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4710 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4713 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4716 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4719 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4722 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4725 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4728 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4731 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4734 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4737 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4740 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4743 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4746 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4749 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4752 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4755 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4758 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4761 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4764 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4767 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4770 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4773 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4776 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4779 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4782 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4785 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4788 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4791 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4794 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4797 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4800 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4803 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4806 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4809 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4812 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4815 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4818 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4821 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4824 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4827 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4830 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4833 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4836 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4839 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4842 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4845 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + }, + { + "first": [ + "G", + 4848 + ], + "nodes": 1, + "rows": 1, + "columns": 2, + "fractional_columns": 0, + "numeric_objective": 3.948086077223247 + } + ], + "complete_integral_candidate": true, + "symbolic_component_objective": { + "1": "819", + "2": "438", + "3": "416", + "4": "128", + "5": "50", + "6": "0", + "7": "0", + "8": "0", + "9": "0" + }, + "candidate_profile": { + "1": 2400, + "2": 446, + "3": 416, + "4": 142, + "5": 82, + "8": 8 + }, + "changed_endpoints": [ + 574, + 575, + 580, + 581 + ], + "changed_gate_frames": 163, + "canonical_duals_sha256": "c83cfcd8020913c3d358399ae2bd16fb95e8aaee7c47c4112bc6807653f296d0" +} diff --git a/research/selected-k8-endpoint-contractions/DUALS.json.gz b/research/selected-k8-endpoint-contractions/DUALS.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..cb83a0b0026bfa098edfedced26907bd0800f229 GIT binary patch literal 47940 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
r#G$QEeK^RFXy| zb*eG1t*3XF*9ocU*dfZyW2{qN{f(N+bXR{|r(sxj?{t{|0d6a|<920~HsMLo`CGWUPgXjs=vkeEvqA2}7Q5e(s)Al2svcjgl(% zeg6@6cls{mSMU*L*SvAk=jpe0b^men#Z&Yv5rBI4^o#Oj=Iz}0#DEk#eW&McSoDhP zn_Gh-0)9D6ar7bmRl&;jpwz0sE&%q6{~?~ZnC#>r2sWwwzX8M$nZQBifL2*3U!Qyc z6ab421OZ5Z(g4ftQLatl-~WPvt$}S-f?)zmt`h<7Qd90y06ubaK5{@dDqA)xn0z>n ze7JwHNOZ9XNI7pnnPiJvahIBRi@I$<*%hSh8eM$mUwnomFX>-Q7F|pRQjQ-`M%|*8 z+@;38N-V!lL~xf{aF>GOBe&us2hWaY&sGA+Q{%`}`xm1}7o&reBL7ahJNTEynx*GX97z zh5#uC4k!b+sD*Z^!LAZ>|4$wWK5|Pwa$q(p`~S*QQT#T!yZL$FwCVSJxcTw%+V$Zm z<8ofZ^F6*wTk_uTsp55VvFh{bUeNbr@%o%l@bmVt>htY+b?}phu?Rr literal 0 HcmV?d00001 diff --git a/research/selected-k8-endpoint-contractions/EXPECTED.json b/research/selected-k8-endpoint-contractions/EXPECTED.json new file mode 100644 index 0000000000..7581a95e71 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/EXPECTED.json @@ -0,0 +1,164 @@ +{ + "a_bracket": [ + "845099025151/500000000000000", + "1690198050303/1000000000000000" + ], + "attaining_contracted_ends": [ + 574, + 575, + 580, + 581 + ], + "bills": { + "1690198050303/1000000000000000": [ + "164831441711219711256809062548369701947902785692060484013862439/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "329662883422439422513618125096739403895805571384120968027724915/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "35491136290869/20000000000000000": [ + "28366093828269560521727384830766206250226840555885609297121176345453932379/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "221610108033355941575995193990360986329897191842856322633759190198858847/904625697166532776746648320380374280103671755200316906558262375061821325312" + ], + "845099025151/500000000000000": [ + "-817584525779388915848662239543911811389968483603640981013099/14474011154664524427946373126085988481658748083205070504932198000989141204992", + "-6540676206235111326789297916351294491119747868829127848104755/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ] + }, + "ceiling_ratio_upper": "563399350101/563351369696", + "component_sizes": { + "1": 117, + "10": 4, + "197": 1, + "21": 5, + "23": 1, + "326": 1, + "691": 1, + "9": 2, + "90": 3 + }, + "domain_sizes": { + "16": 30, + "2": 1144, + "5": 613 + }, + "duality": { + "columns": 23456, + "components": 135, + "distinct_reduced_vectors": 443, + "positive": 8529, + "rows": 18033, + "zero": 14927 + }, + "duals_sha256": "c83cfcd8020913c3d358399ae2bd16fb95e8aaee7c47c4112bc6807653f296d0", + "forced_ends": [ + 273, + 275, + 277, + 282, + 289, + 291, + 293, + 298, + 305, + 307, + 309, + 314, + 321, + 323, + 325, + 330, + 337, + 339, + 341, + 346, + 353, + 355, + 357, + 362, + 369, + 371, + 373, + 378, + 385, + 387, + 389, + 394 + ], + "free_ends": [ + 311, + 327, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 484, + 485, + 498, + 500, + 501, + 508, + 509, + 510, + 512, + 513, + 531, + 532, + 533, + 543, + 554, + 555, + 556, + 557, + 566, + 567, + 572, + 573, + 574, + 575, + 580, + 581, + 582, + 583, + 584, + 585, + 586, + 587, + 588, + 589, + 590, + 591 + ], + "free_gates": 1741, + "gates": 5413, + "graph": { + "cone_edges": 106, + "cone_helpers": 78, + "cones_sha256": "5546e8ad5d979e0eaf618a4adbb333a7ec6b3528ef71bbf659b05ba2e5fc0004", + "domains_sha256": "dc1778d2f5e671e7f308b336daa7f45815ea86f081bf52c538212e051ed68e0e", + "edge_count": 10328, + "edges_sha256": "4f30b8c3c22b7e70bf48ce5398212512081acb7fed4a61ad67873bc032218e62", + "node_count": 6941, + "nodes_sha256": "a7783e87cfc4705d7c0400612aeb5beaea96f36fad64f27a892c47aef6952233" + }, + "idle_mass": 1650, + "kappa_cap": "1690198050303/1001690198050303", + "local_mass": 5582, + "primal_sha256": "462c3fef57ad4711e7767450c31e3f29d78ada18f54070df436510359386e3de", + "profile": { + "1": 2400, + "2": 446, + "3": 416, + "4": 142, + "5": 82, + "8": 8 + }, + "restricted_ends": 78, + "schema": "selected-k8-endpoint-contraction-bound-v1", + "scope": "fixed scalar word and entrances; all nested restricted helper ends and gate frames; full idle charge; no global supplier or new kappa", + "status": "PASS_SELECTED_K8_ENDPOINT_CONTRACTION_BOUND", + "target_a": "35491136290869/20000000000000000", + "word_sha256": "c2b294300760e1fd6eeab8c22c4d13e4633dca40e52cac8da0d68163a76e3ca8" +} diff --git a/research/selected-k8-endpoint-contractions/INPUTS.json b/research/selected-k8-endpoint-contractions/INPUTS.json new file mode 100644 index 0000000000..e3cecc5518 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/INPUTS.json @@ -0,0 +1,14 @@ +{ + "research/r480-owner-optimum/inputs/local/FULL-WORD.json.gz": "WORD.json.gz", + "research/gauge44-slots/construction/slots/SLOT-PINS-k8.json": "SLOT-PINS.json", + "research/complex-x4-frame-bound/model.py": "frame_model.py", + "research/complex-x4-frame-bound/gen_duals.py": "gen_duals.py", + "research/complex-x4-frame-bound/README.md": "FRAME-METHOD.md", + "research/complex-local-word-ceiling/ceiling.py": "ceiling.py", + "research/complex-local-word-ceiling/README.md": "CEILING.md", + "research/gauge44-slots/independent/audit_local.py": "audit_local.py", + "research/k8-rank7-composition/data/END-RECIPE.json": "END-RECIPE.json", + "research/k8-rank7-composition/construct.py": "construct.py", + "research/k8-rank7-composition/README.md": "END-WITNESS.md", + "research/selected1042-lineage-resolution98/README.md": "WORD-LINEAGE.md" +} diff --git a/research/selected-k8-endpoint-contractions/NOTICE.md b/research/selected-k8-endpoint-contractions/NOTICE.md new file mode 100644 index 0000000000..e792de3654 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/NOTICE.md @@ -0,0 +1,40 @@ +# Attribution and license + +Prepared by Gareth Davidson (@bitplane), with substantial OpenAI Codex +assistance in the mathematics, implementation, certificates, checks and +writing. Apache-2.0. No independent human or proof-assistant review is claimed. + +The complete frame-domain and local-polytope method is navinor's retained +`complex-x4-frame-bound`, following chafreaky/PR557, ntedvs/PR776 and Rohan +Guliani/PR815. The original model, generator and README are copied unchanged +under references. This package extends the model with variable nested +endpoint nodes and excess prices relative to idle work. Nomination code +adapts navinor's generator, which discloses Claude Code assistance. + +The source utilities, dual-checking structure, independent bitset/integer-root +implementation and controls are adapted from Gareth Davidson's PR1671, +mathematical commit `11fbeaf34609147c124323c2f5e74fc450dad931`, with disclosed +OpenAI Codex assistance. They are modified here to reconstruct the changed +endpoint domain, cone edges, primal attainment and variable-mass cost model. +The predecessor's fixed-endpoint theorem is not assumed to prove this result. +The two implementations have the same AI-assisted author and share source +utilities and candidate certificate data. + +Alexander Schwartzman's PR1030 constructs rank-seven helper ends, and +Cinna Davis (@1337isnot1337) transfers that mechanism to the selected k8 word +in PR1090. The retained recipe, constructor and README preserve attribution; +the exact two-end recipe is replayed as a native positive control. Particular +smaller ends are not claimed as a new mechanism here. Arham Tahir's PR1583 +establishes endpoint rigidity with the gate frames fixed, a different scope. + +Douglas Colkitt's PR1240 supplies the retained exact ceiling engine and +planning model, following Sagar Thakrar's PR1012 coverage law. The selected +word and hosting line retain Jeremy Kothe, Rohan Arun, Hao Yan/FanPUYen, +icekylinx and the cumulative geometry, controller, ownership, native compiler, +bit-supplier and upstream credits in the selected review. The retained local +auditor credits icekylinx and OpenAI GPT-6 Astra assistance. Woklerx supplied +the word-lineage reconciliation used to avoid the stale R492 predecessor. + +Every references file is an unchanged copy, with exact source SHA256 and +Git-blob pins in SOURCES.json. Selected records, frozen predecessors, +upstream source archives and inherited licenses remain unchanged. diff --git a/research/selected-k8-endpoint-contractions/PRIMAL.json.gz b/research/selected-k8-endpoint-contractions/PRIMAL.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..c1e76c5f4aeebc7b8e0e508a01c5a3d0da84a6a6 GIT binary patch literal 7791 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 G7ybt`v)ily literal 0 HcmV?d00001 diff --git a/research/selected-k8-endpoint-contractions/PROOF.md b/research/selected-k8-endpoint-contractions/PROOF.md new file mode 100644 index 0000000000..f375fa8312 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/PROOF.md @@ -0,0 +1,204 @@ +# Joint nested endpoint and frame bound + +## Object and scope + +The fixed selected k8 word is identified by decompressed SHA256 +`c2b294300760e1fd6eeab8c22c4d13e4633dca40e52cac8da0d68163a76e3ca8`. +SLOT-PINS-k8 and the retained lineage reconciliation bind the R480 word to +the selected construction. It has 112 source ports, 112 target ports, +480 helpers, and 5,413 A/B/early-cleanup scalar gates. + +Fix all scalar operations, coefficients and order, every entrance, +centre/cut/target interface, and early/full cleanup membership and order. +For each of the 78 originally restricted helpers q, let S_q and H_q be +its original entrance and end. Permit every new end E_q satisfying +S_q <= E_q <= H_q, where <= means subspace inclusion in F2^9. The other +402 helpers occur in full-frame cleanup and retain full ends. Every +A/B/early-cleanup gate frame may vary, subject to monotone register paths, +common frames for both operands of ADD, and the native low-end cone rules. +The centre descents remain eight rank-eight children. + +The model charges climbs into fixed A/B centre and target pins; the native +auditor requires the preceding frame already equal its pin. Allowing the +charged climb enlarges the feasible set. Thus a lower bound for this +model applies to every native assignment in the stated class. The shipped +attaining assignment also passes that stronger native condition. + +This changes the fixed-gate-frame premise of PR1583 and the fixed-endpoint +premise of PR1671. PR1030/1090 already supply particular contracted-end +constructions. Neither a new LP method nor first discovery of smaller +helper ends is claimed. + +## Complete finite model + +Each register has an ordered chain from its fixed start through shared +gate nodes and applicable A/B pins to its end. Positive edge multiplicity +counts how many registers pay the same frame transition. A strict jump +of dimension d creates that many rank-d children. End nodes for the 78 +restricted helpers are variable, with their original H_q as upper cap. + +Derive the exact scalar prefix P including its dirty-target compensation. +For each restricted helper q, compute + + K_q = (support of row q of P^-1) + union (support of column q of P), excluding q. + +If b(k) is register k's last pre-tail node, native admission requires +F_b(k) <= E_q for every k in K_q. Add these as zero-charge containment +edges b(k) -> E_q. They constrain frames and never create recursive work. +The helper's own condition follows from its register chain. There are +106 such edges, retained separately from the 10,222 merged paid edges. + +All edges go forward in the event order. Join predecessor lower frames +in that order, and intersect successor upper frames and end caps in +reverse order; fixed nodes retain their prescribed frames. Induction +proves lo_n <= F_n <= hi_n for every feasible assignment. Enumerate every +subspace of hi_n/lo_n and lift it. The largest quotient dimension is +three; complete domain sizes are 1, 2, 5 and 16. + +The resulting domains have: + +- 1,741 free gates: 1,098 with two choices, 613 with five, 30 with sixteen; +- 46 free ends, each with exactly its forced rank-seven lower frame or + its original rank-eight upper frame; +- 32 restricted ends forced to their original subspaces, and 402 full ends. + +This covers the simultaneous choices; it is not an enumeration of 2^46 +complete native words. Shared-node and cone constraints still apply. +Free nodes form 135 components of sizes + + 117 x 1, 2 x 9, 4 x 10, 5 x 21, 1 x 23, + 3 x 90, 1 x 197, 1 x 326, 1 x 691. + +An independent implementation reconstructs all bounds, domains and edges +using 512-bit subspace sets, quotient closure and inverse row covectors. +It agrees with every geometry digest and count in EXPECTED.json. + +## Variable mass must be recharged + +Let P_r count all local rank-r children, including centre work. A register's +climb dimensions telescope from its fixed start to its chosen end. +Consequently local mass L = sum r P_r varies with the ends. The old +fixed-mass reduction subtracting L times the rank-one price cannot be +used as a constant objective here. + +Under the unchanged width-73, 896-family/nine-call coverage law, total +paid rank mass per call is + + T = 72 (896/9) + 64 = 7232. + +Any decrease in local mass exposes exactly as much idle mass, T-L. +The strict halving guard permits idle rank at most 51, since +2*51^2 < 73^2 <= 2*52^2. For a>=0, cost per unit rank decreases with rank. +Every idle packing therefore costs at least fractional rank-51 packing. +Put w=896/9 and define + + h_d(a) = (d/73)^(1-a), + Phi_d(a) = 73 [h_d(a) - (d/51) h_51(a)], d=1,...,9. + +The complete favorable normalized bill is + + B_P(a) = [sum P_d h_d(a) + ((T-L)/51) h_51(a)] / w + = [T (73/51)^a + sum P_d Phi_d(a)] / (73 w). + +The first term is constant across endpoint choices. Minimizing the sum of +Phi charges therefore minimizes the *complete* relaxed bill even though +local mass varies. All local ranks are at most nine and every possible +nested contraction leaves idle mass nonnegative. + +The cost of omitting this recharging is observable: for the attaining +profile below, retaining the obsolete idle mass 1,646 instead of 1,650 +makes the 5% target incorrectly pass. The control checks this false +positive using exact outward bounds. Released workspace is not free work. + +## Exact dual certificate and attainment + +For every free node n and complete frame choice F, use a nonnegative +variable x(n,F). For every edge between free nodes, use y(n,m,F,G) for +every nested pair F<=G, with both marginals equal to the corresponding x +variables. Normalize each x distribution to one. Unary costs count edges +to fixed/forced nodes; pair costs count paid multiplicity, including zero +for the additional cone edges. Every literal legal assignment gives a +zero/one feasible LP point, so the LP minimum is a lower bound. + +For each component write min c.z subject to A z=b, z>=0. DUALS.json.gz +supplies a rational linear form in Phi_1,...,Phi_9 for every used equality +row. The two checkers reconstruct all rows/columns and prove + + c - A^T q >= 0, + b^T q = the shipped primal component cost, coefficient by coefficient. + +There are 18,033 rows and 23,456 columns. Of the reduced-cost vectors, +14,927 vanish identically and 8,529 are strictly positive at each of the +two test exponents below; 443 distinct vectors occur. No solver tolerance, +status, primal float or numerical basis is acceptance evidence. HiGHS +only nominated the rational certificate and integral assignment. + +The complete primal is checked against every domain and containment edge. +Together with fixed edges and centre work its profile is + + P* = {1:2400, 2:446, 3:416, 4:142, 5:82, 8:8}, + L* = 5582, T-L* = 1650. + +It contracts helpers 574,575,580,581 to rank-seven ends. The unchanged +native auditor accepts its actual annotated word on all 704 input columns +in both orientations, including arbitrary dirty helper data, frame paths, +entrances, full cleanup, endpoint maps and low-end cones. Baseline and +credited PR1090 two-end words pass the same audit. This is exact local +scalar/frame validation. Emitted native programs, phase/wrapper admission, +a new physical owner allocation and the outer invoice were not replayed. + +## Certified ceiling and 5% exclusion + +Set + + a_lo = 1690198050302 / 10^15, + a_hi = 1690198050303 / 10^15, + a_target = (21/20) (1690054109089 / 10^15). + +The exact dual inequalities and primal-objective identities hold at a_hi +and a_target. At these exponents P* minimizes the complete LP relaxation. +Independent outward arithmetic proves + + B_P*(a_lo) < 1 < B_P*(a_hi), + B_P*(a_target) > 1. + +At a_hi every legal assignment has local excess cost at least P* and idle +cost at least the rank-51 relaxation. Its full bill exceeds one. Every +actual child has rank less than 73, so its cost increases with a; the +failure at a_hi excludes all larger savings. Summing the per-call bound +also permits different legal endpoint/frame assignments in different calls. + +The feasible P* assignment supplies the lower bracket for the favorable +relaxation; fractional idle packing need not be realizable. Thus the best +relaxed ceiling lies strictly between a_lo and a_hi. Relative to the old +ceiling's certified lower endpoint, the ratio is less than + + 563399350101 / 563351369696 < 1.0000852. + +Joint nested contractions can therefore improve that ceiling by less than +0.00852%, and cannot meet the 5% gate. Under the retained balanced planning +transfer, kappa < 1690198050303/1001690198050303. This is a bound on the +stated mechanism, not a new multiplication exponent. + +The theorem does not assert optimality at every exponent, classify all +attaining assignments, compare all possible helper inventories, or exclude +nonnested ends, changed entrances, scalar rewrites, reordered/changed +cleanup, shared centres or a different coverage law. The small bracketed +ceiling gain does not establish an attainable global improvement. + +## Arithmetic and verification limits + +The primary uses the retained outward log/exp engine. The separate checker +uses 256-bit integer-square-root intervals and 96-bit dyadic exponent +brackets, outward multiplication and an explicit carry-to-one case. Exact +square comparisons calibrate 72 rank cases; an invalid root oracle fails. +Both implementations share source/JSON utilities and certificate data, but +no frame, LP or moment mathematics. Both were written by the same +AI-assisted author; no independent human or proof-assistant review is claimed. + +Finite controls additionally reject omitted frame/end choices, centre work, +common-gate edges, primal nodes, dual components, overstated objectives, +wrong idle mass/coverage, source drift and malformed JSON. They support the +implementation; the universal implication within the finite domain follows +from the complete-domain and weak-duality argument above. diff --git a/research/selected-k8-endpoint-contractions/README.md b/research/selected-k8-endpoint-contractions/README.md new file mode 100644 index 0000000000..d8bba6d6c8 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/README.md @@ -0,0 +1,134 @@ +# Joint helper-end and gate-frame ceiling for the selected k8 word + +**Scoped negative result, no new kappa.** Simultaneously shrinking any of +the 78 restricted helper ends to nested subspaces, while changing every +A/B/early-cleanup gate frame, still gives + + a < 0.001690198050303, + kappa < 1690198050303/1001690198050303 ≈ 0.001687346101213. + +The favorable ceiling can rise by less than **0.00852%**, far below the +5% target. Scalar operations/order, entrances, centre cut, target levels, +early/full cleanup membership and the coverage/guard contract are fixed. + +This changes both the fixed-gate-frame premise of Arham Tahir's +[PR1583](https://github.com/CrocSwap/integer-mult-bounds/pull/1583) and the +fixed-endpoint premise of [PR1671](https://github.com/CrocSwap/integer-mult-bounds/pull/1671). +Alexander Schwartzman's PR1030 and Cinna Davis's retained PR1090 already +construct particular smaller ends. The new contribution is the complete +joint optimization bound, with variable local mass fully recharged as idle. + +## Evidence + +The [proof](PROOF.md) gives the precise quantified domain and cost argument. +The selected R480 word is bound by SLOT-PINS-k8 and decompressed SHA256 +`c2b294300760e1fd6eeab8c22c4d13e4633dca40e52cac8da0d68163a76e3ca8`. +The stale R492 predecessor is excluded using the retained lineage analysis. + +- All 5,413 gate frames are covered; 1,741 have more than one choice. +- Of 78 restricted ends, 32 are forced and 46 have two complete subspace + choices. The other 402 helpers retain full ends because of full cleanup. +- All 106 low-end cone relations are represented explicitly as zero-charge + containment edges. The full model has 135 components, 18,033 LP rows and + 23,456 columns, each checked with exact rational dual coefficients. +- An integral assignment matches every dual objective at the ceiling + endpoint and the 5% target. It contracts ends 574,575,580,581 and gives + `{1:2400,2:446,3:416,4:142,5:82,8:8}`, local mass 5,582 and idle mass 1,650. +- A separate bitset/covector implementation reconstructs every domain, + edge and cone, then checks the dual signs and ceiling with integer-root + arithmetic, importing no primary frame/LP/moment code. +- The unchanged native auditor accepts the baseline, retained PR1090 + two-end witness and four-end attaining word on **704 columns in both + orientations**, including dirty state and restoration. + +The receipt brackets the best favorable primitive ceiling between +0.001690198050302 and 0.001690198050303. This does not assert frame/end +optimality at every exponent or a realizable fractional idle packing. +Different legal choices in different invocations are covered by summing +the per-call lower bound. + +Shrinking the ends releases four rank units into idle work. Keeping the +old idle mass 1,646 would incorrectly pass the 5% target; the exact control +exposes this false positive. Using rank-excess prices relative to rank-51 +idle packing makes the coupled objective correct for varying local mass. + +## Reproduce + +Python 3.12 and the standard library, from the repository root: + +```sh +python3.12 -I -B scripts/research_package.py \ + --package research/selected-k8-endpoint-contractions +``` + +This runs the primary, separate implementation and control suite. Both +checkers preserve all guards under `-O`; unchanged legacy code is compiled +with its assertions enabled. Normal replay is read-only. The explicit +`verify.py --write-expected` option regenerates the deterministic receipt. +DUALS and PRIMAL identities use canonical parsed payloads, not gzip bytes. + +The registered replay passed on CPython 3.12.3 (`/usr/bin/python3.12`), +including all 18 control groups. Both checkers also passed on CPython +3.14.4 with `-I -O -B` from a relocated, read-only package; all files +remained unchanged. The canonical receipt SHA256 is +`4b9847122d6cd93b61eaa391fa1a67191824e287fe2d828cb0f38ff6b5f1658f`. + +`nominate.py` is optional discovery code adapted from navinor's credited +HiGHS generator. It used highspy 1.15.1, NumPy 2.5.4 and SciPy 1.18.1 in an +isolated environment. DISCOVERY.json contains noncertifying numerical +diagnostics. Acceptance requires no solver dependency. + +## Scope and coordination + +Single random nonce `27a9e1612f686c5cfc60b3fb45d023cb`, revision-3 +`complex-mechanisms / complex-new-helper-inventory`, no reroll. Base main +`15d2aca0385b61596155e8421140d08d27e543af`. The prescribed baseline-source, +ceiling and lever controls passed. An initial optimistic budget waived +all climbs of the 78 affected helpers, retained other local work and +recharged idle mass; its a ceiling below 0.001826483000117 left headroom +for the complete constraint screen. It was not a realizable assignment. +[Discussion1674](https://github.com/CrocSwap/integer-mult-bounds/discussions/1674) +records the scoped claim and outcome; TASK.json retains the card and pins. + +The final overlap refresh covered 409 open PRs at 06:38:34 UTC and 330 +discussions at 06:39:18 UTC on 2026-10-14, with complete pagination. +PR1583, PR1090 and PR1671 heads were rechecked. Search covers metadata, +not arbitrary code, and is not a novelty certificate. Main at +`d78fe4bbb6f6b769e39586f8bb3ba8c31a31fd3a` preserved all 19 checked +instruction, selection, replay and source paths and had no package collision. + +This is the card's bounded endpoint-contract obstruction. It does not +supply a construction passing its acceptance gate. No whole hosted +supplier, selected cold replay, global invoice, all-size compiler, +precision/tape or analytic-transfer theorem is claimed. Remaining packing +headroom below this ceiling is not claimed eliminated. Nonnested end +changes, entrances, scalar chronology, cleanup membership, new helpers, +shared centre work and changed coverage laws remain outside scope. +The 704-column checks are exact local scalar/frame audits. Emitted native +programs and phase/wrapper admission were not replayed. + +## Open next questions + +1. **Nonnested ends or changed entrances.** Pin one actual endpoint pair, + derive complete frame and cone constraints, and price its whole profile. + These changes can escape the interval domains above; dirty-state + correctness and the complete hosting invoice remain obligations. +2. **Change a scalar dependency or early-cleanup cut.** Recompute the + complete frame intervals and full ceiling for one declared rewrite. + It needs enough charged headroom to meet the target, plus a valid + changed-word contract. +3. **Host the attaining four-end word.** First compare its exact annotations + against existing rank-seven-end constructions, then test one whole-helper + owner placement. Local optimality supplies no global improvement by + itself; the available ceiling gain is tiny and the full native/global, + precision and outer obligations have not been replayed. + +## Credit + +Gareth Davidson (@bitplane), with substantial OpenAI Codex assistance. +Retains navinor's frame method; chafreaky/PR557, ntedvs/PR776 and Rohan +Guliani/PR815; Alexander Schwartzman/PR1030 and Cinna Davis/PR1090; +Arham Tahir/PR1583; Douglas Colkitt/PR1240 and Sagar Thakrar/PR1012; +the Jeremy Kothe/Rohan Arun/Hao Yan/icekylinx construction lineage and +woklerx word reconciliation. See NOTICE.md and exact SOURCES.json pins. +Apache-2.0; no independent human or full formal verification is asserted. diff --git a/research/selected-k8-endpoint-contractions/SOURCES.json b/research/selected-k8-endpoint-contractions/SOURCES.json new file mode 100644 index 0000000000..840e5dd338 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/SOURCES.json @@ -0,0 +1,90 @@ +{ + "schema_version": 1, + "base_commit": "15d2aca0385b61596155e8421140d08d27e543af", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" + }, + { + "path": "research/complex-local-word-ceiling/README.md", + "usage": "input", + "git_blob": "f5f742f8196da29d2c3f4dffb3c27685ca9401f6", + "sha256": "b60be039cb0e03e064a27407d0bce9e58908d793da5ee405c876de5aebfa5f81" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + { + "path": "research/complex-x4-frame-bound/README.md", + "usage": "input", + "git_blob": "e2ddf660ac1dabaf5286531dc784f9b21bfdd5bd", + "sha256": "0f5c4c73f9c20935b05698405543eccbf15a82663052a3d612ce7148799b34f4" + }, + { + "path": "research/complex-x4-frame-bound/gen_duals.py", + "usage": "input", + "git_blob": "bd85022a44dde95c14710d7dd28fed6b81926fd1", + "sha256": "9aac56f7cd1c497bfc50f0fb47bd5b14761033127575665d576d948ee11fc3f8" + }, + { + "path": "research/complex-x4-frame-bound/model.py", + "usage": "input", + "git_blob": "33cfb4f404be0ed9fabd53a362084ef8dbc1911c", + "sha256": "0fa808a82e12a8928e43de3131958b9018476ee8c25b1ebc841316705e4f0eff" + }, + { + "path": "research/gauge44-slots/construction/slots/SLOT-PINS-k8.json", + "usage": "input", + "git_blob": "2702c368f4de0b671577aee9a0e2df41c1b27658", + "sha256": "55dd229684febecb80638eff9c6b3986623e8539c6c956753b350209c3e0efe2" + }, + { + "path": "research/gauge44-slots/independent/audit_local.py", + "usage": "input", + "git_blob": "4744d8783c25bf7bf5076886169077ca3808309a", + "sha256": "03afcfc9da428b3f6edac81c1fee7f277ab81b64998efae78380b63498dec6cd" + }, + { + "path": "research/k8-rank7-composition/README.md", + "usage": "input", + "git_blob": "306ec133620358b6d043311d59f91013bbf1f886", + "sha256": "51a82cb44080ffa34fc0fa6a63a3ed7ecd63bea9c9e0258fb45adb36ae90563b" + }, + { + "path": "research/k8-rank7-composition/construct.py", + "usage": "input", + "git_blob": "5600f92cbb9d391563af88f59eafd0e16a3b33b0", + "sha256": "bdeb1584fc09457cb6d7e10977df6a9e009501ab26e52534e37df64ae3056324" + }, + { + "path": "research/k8-rank7-composition/data/END-RECIPE.json", + "usage": "input", + "git_blob": "7af7b6341c06589239bcf4c4634febbc8f757ec2", + "sha256": "071da31acee1c91c8297e81481bc505fb62b17444801c6b6bac3235e34dc0918" + }, + { + "path": "research/r480-owner-optimum/inputs/local/FULL-WORD.json.gz", + "usage": "input", + "git_blob": "723decbca8995e916d6f4b783aa3e1ddd4eb47fe", + "sha256": "49596aa4ed4fd36cd4582fd0e8ddeb09fd80370a7d8aea1ede52a135b536d289" + }, + { + "path": "research/selected1042-lineage-resolution98/README.md", + "usage": "input", + "git_blob": "b9d19db8834b1cd8b64e564555581748e870f948", + "sha256": "750417e6e34c6e0ce61fb85addfbdc5020dbbc12f01ba1a10df4cadc26d74845" + } + ] +} diff --git a/research/selected-k8-endpoint-contractions/TASK.json b/research/selected-k8-endpoint-contractions/TASK.json new file mode 100644 index 0000000000..417fe7b1f0 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/TASK.json @@ -0,0 +1,433 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 3, + "base_commit": "15d2aca0385b61596155e8421140d08d27e543af", + "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": [ + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json" + ], + "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.", + "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." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "refined", + "actual_scope": "Same exact R480 scalar word/order, entrances, centre cut, target levels and early/full cleanup membership/order. For each originally restricted helper, its new end may be any subspace containing its entrance and contained in its original end. All A/B/early-cleanup gate frames vary simultaneously. The 402 full-cleanup helpers stay full. Low-end cones must track the chosen endpoint, not the old cap.", + "scope_change_reason": "Changes the helper endpoint contract jointly with all gate frames. Fixed-endpoint and fixed-frame predecessors do not cover the class. A scoped obstruction does not pass the construction acceptance gate.", + "bottleneck_link": "Determines whether simultaneous smaller helper ends can improve the complete paid local profile enough to escape the selected fixed-endpoint packing ceiling.", + "budget_minutes": 120, + "stop_rule": "One complete nested-endpoint screen with exact certificate, or a narrowly stated proof/interface obstruction. Do not expand to changed entrances, scalar rewrites or nonnested endpoint rotations in this pass.", + "outcome": "negative-result", + "evidence": "135 exact dual components, 23456 columns, 46 binary endpoint domains and 1741 free gates. Full ceiling a < 0.001690198050303, less than 0.00852% above the baseline ceiling; 5% target excluded. A four-end attaining local word passes all 704 scalar/frame input columns in both orientations.", + "author": "Gareth Davidson (@bitplane), with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in mathematics, implementation, checking and writing; no independent human review.", + "open_questions": [ + { + "question": "Can a nonnested end subspace or a changed entrance escape the nested-endpoint bound?", + "why_it_matters": "These changes can alter complete gate intervals and the helper width contract.", + "first_step": "Pin one new endpoint/entrance pair and reconstruct its cone constraints plus full paid profile before synthesis.", + "blocked_by": "Arbitrary-dirty correctness, legal frames and the complete hosting invoice." + }, + { + "question": "Can a scalar rewrite or changed early-cleanup membership deliver a target-scale gain?", + "why_it_matters": "The fixed chronological dependency graph limits the present endpoint freedom.", + "first_step": "Change one declared dependency or cleanup cut, recompute complete frame domains and screen the full profile.", + "blocked_by": "A complete changed-word contract and at least 5% ceiling headroom." + }, + { + "question": "Can the four-end local optimum be given a complete physical hosting and outer invoice?", + "why_it_matters": "Local attainment does not establish a supplier improvement.", + "first_step": "Compare the frozen PRIMAL annotations with existing rank-seven-end constructions and test one whole-helper owner placement.", + "blocked_by": "The tiny available ceiling gain and unrun native/global construction, precision and outer replay." + } + ], + "selection_nonce": "27a9e1612f686c5cfc60b3fb45d023cb", + "catalogue_scope_key": "5868e5281a1e63d41a22", + "discussion": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1674", + "predecessors": { + "frame_method": "navinor complex-x4-frame-bound; PR1671 selected fixed-end certificate", + "endpoint_witness": "Alexander Schwartzman PR1030; Cinna Davis PR1090 k8 transfer", + "endpoint_audit": "Arham Tahir PR1583 head04516881142961cdf97a828fbbc63d72e232a148", + "ceiling": "Douglas Colkitt PR1240, Sagar Thakrar PR1012" + }, + "first_experiment": { + "baseline": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "removed_helper_climbs": { + "1": 194, + "3": 60, + "2": 46 + }, + "optimistic_profile": { + "1": 2218, + "2": 372, + "3": 372, + "4": 142, + "5": 82, + "8": 8 + }, + "affected_helpers": [ + 273, + 275, + 277, + 282, + 289, + 291, + 293, + 298, + 305, + 307, + 309, + 311, + 314, + 321, + 323, + 325, + 327, + 330, + 337, + 339, + 341, + 346, + 353, + 355, + 357, + 362, + 369, + 371, + 373, + 378, + 385, + 387, + 389, + 394, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 484, + 485, + 498, + 500, + 501, + 508, + 509, + 510, + 512, + 513, + 531, + 532, + 533, + 543, + 554, + 555, + 556, + 557, + 566, + 567, + 572, + 573, + 574, + 575, + 580, + 581, + 582, + 583, + 584, + 585, + 586, + 587, + 588, + 589, + 590, + 591 + ], + "scope": "Optimistic planning only: waive all climbs of the 78 restricted-end helpers while keeping all other local calls; exposed mass is charged as ideal idle. No frame or scalar realization asserted.", + "baseline_ceiling": [ + "1690054109088/1000000000000000", + "1690054109089/1000000000000000" + ], + "optimistic_ceiling": [ + "1826483000116/1000000000000000", + "1826483000117/1000000000000000" + ], + "optimistic_local_mass": 5120, + "optimistic_idle_mass": 2112, + "five_percent_gate_has_optimistic_headroom": true + }, + "canonical_receipt_sha256": "4b9847122d6cd93b61eaa391fa1a67191824e287fe2d828cb0f38ff6b5f1658f", + "canonical_duals_sha256": "c83cfcd8020913c3d358399ae2bd16fb95e8aaee7c47c4112bc6807653f296d0", + "canonical_primal_sha256": "462c3fef57ad4711e7767450c31e3f29d78ada18f54070df436510359386e3de", + "instruction_gist_revision": "6d8cffe3dcb0680b68ae8a9d79b98e6e719f1f34", + "overlap": { + "initial": { + "searched_at": "2026-10-14T06:11:43.120698+00:00", + "coverage": { + "open_prs": { + "fetched_at": "2026-10-14T06:11:01.725824+00:00", + "complete_pagination": true, + "records": 457 + }, + "discussions": { + "fetched_at": "2026-10-14T06:11:43.089017+00:00", + "complete_pagination": true, + "records": 319 + } + }, + "warnings": [], + "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission.", + "matches_total": 43 + }, + "final": { + "searched_at": "2026-10-14T06:39:18.689085+00:00", + "coverage": { + "open_prs": { + "fetched_at": "2026-10-14T06:38:34.245950+00:00", + "complete_pagination": true, + "records": 409 + }, + "discussions": { + "fetched_at": "2026-10-14T06:39:18.652522+00:00", + "complete_pagination": true, + "records": 330 + } + }, + "warnings": [], + "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission.", + "matches_total": 6 + }, + "reviewed_predecessor_heads": [ + { + "headRefOid": "04516881142961cdf97a828fbbc63d72e232a148", + "number": 1583, + "state": "OPEN", + "title": "Audit selected k8 helper endpoint rigidity and rank-preserving failures", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1583" + }, + { + "headRefOid": "b535975a5948afafda984e73c301183a634ff8c8", + "number": 1090, + "state": "MERGED", + "title": "Conditional \u03ba = 0.001672404744903063: rank-seven helper ends on the k8 word", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1090" + }, + { + "headRefOid": "ce130d291f5ab6dd801544886a16f62d42d86118", + "number": 1671, + "state": "OPEN", + "title": "Research: exact complete frame ceiling for the selected k8 word", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1671" + } + ] + }, + "latest_main_check": { + "verified_at_utc": "2026-10-14T06:40:55.601877+00:00", + "base": "15d2aca0385b61596155e8421140d08d27e543af", + "main": "d78fe4bbb6f6b769e39586f8bb3ba8c31a31fd3a", + "records": [ + { + "path": "AGENTS.md", + "base_blob": "860762e04e963e1b163b8fa5267854c0040a9e67", + "main_blob": "860762e04e963e1b163b8fa5267854c0040a9e67", + "same": true + }, + { + "path": "CONTRIBUTING.md", + "base_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "main_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "same": true + }, + { + "path": "autoresearch.md", + "base_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82", + "main_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82", + "same": true + }, + { + "path": "docs/research/agent-task-catalog.json", + "base_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "main_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "same": true + }, + { + "path": "certificates/selected-result.json", + "base_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "main_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "same": true + }, + { + "path": "scripts/research_package.py", + "base_blob": "f1475a7e8bcffab0e65034bb08cdcd69e95f6d6d", + "main_blob": "f1475a7e8bcffab0e65034bb08cdcd69e95f6d6d", + "same": true + }, + { + "path": "docs/research/research-package-guide.md", + "base_blob": "2b4841ab5d00f2a17f1379718a061a9cf8fe88ee", + "main_blob": "2b4841ab5d00f2a17f1379718a061a9cf8fe88ee", + "same": true + }, + { + "path": "research/r480-owner-optimum/inputs/local/FULL-WORD.json.gz", + "base_blob": "723decbca8995e916d6f4b783aa3e1ddd4eb47fe", + "main_blob": "723decbca8995e916d6f4b783aa3e1ddd4eb47fe", + "same": true + }, + { + "path": "research/gauge44-slots/construction/slots/SLOT-PINS-k8.json", + "base_blob": "2702c368f4de0b671577aee9a0e2df41c1b27658", + "main_blob": "2702c368f4de0b671577aee9a0e2df41c1b27658", + "same": true + }, + { + "path": "research/complex-x4-frame-bound/model.py", + "base_blob": "33cfb4f404be0ed9fabd53a362084ef8dbc1911c", + "main_blob": "33cfb4f404be0ed9fabd53a362084ef8dbc1911c", + "same": true + }, + { + "path": "research/complex-x4-frame-bound/gen_duals.py", + "base_blob": "bd85022a44dde95c14710d7dd28fed6b81926fd1", + "main_blob": "bd85022a44dde95c14710d7dd28fed6b81926fd1", + "same": true + }, + { + "path": "research/complex-x4-frame-bound/README.md", + "base_blob": "e2ddf660ac1dabaf5286531dc784f9b21bfdd5bd", + "main_blob": "e2ddf660ac1dabaf5286531dc784f9b21bfdd5bd", + "same": true + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "base_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "main_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "same": true + }, + { + "path": "research/complex-local-word-ceiling/README.md", + "base_blob": "f5f742f8196da29d2c3f4dffb3c27685ca9401f6", + "main_blob": "f5f742f8196da29d2c3f4dffb3c27685ca9401f6", + "same": true + }, + { + "path": "research/gauge44-slots/independent/audit_local.py", + "base_blob": "4744d8783c25bf7bf5076886169077ca3808309a", + "main_blob": "4744d8783c25bf7bf5076886169077ca3808309a", + "same": true + }, + { + "path": "research/k8-rank7-composition/data/END-RECIPE.json", + "base_blob": "7af7b6341c06589239bcf4c4634febbc8f757ec2", + "main_blob": "7af7b6341c06589239bcf4c4634febbc8f757ec2", + "same": true + }, + { + "path": "research/k8-rank7-composition/construct.py", + "base_blob": "5600f92cbb9d391563af88f59eafd0e16a3b33b0", + "main_blob": "5600f92cbb9d391563af88f59eafd0e16a3b33b0", + "same": true + }, + { + "path": "research/k8-rank7-composition/README.md", + "base_blob": "306ec133620358b6d043311d59f91013bbf1f886", + "main_blob": "306ec133620358b6d043311d59f91013bbf1f886", + "same": true + }, + { + "path": "research/selected1042-lineage-resolution98/README.md", + "base_blob": "b9d19db8834b1cd8b64e564555581748e870f948", + "main_blob": "b9d19db8834b1cd8b64e564555581748e870f948", + "same": true + } + ], + "package_path_collision": false + }, + "validation": { + "registered": { + "python": "CPython 3.12.3", + "executable": "/usr/bin/python3.12", + "argv": [ + "/usr/bin/python3.12", + "-I", + "-B", + "scripts/research_package.py", + "--package", + "research/selected-k8-endpoint-contractions" + ], + "exit_code": 0, + "control_groups": 18, + "primary_components": 135, + "primary_columns": 23456, + "separate_checker_root_calibrations": 72, + "local_scalar_frame_audits": "baseline, credited two-end word and four-end optimum; each 704 input columns in both orientations" + }, + "additional": { + "python": "CPython 3.14.4", + "argv_flags": [ + "-I", + "-O", + "-B" + ], + "commands": [ + "verify.py", + "independent.py" + ], + "relocated": true, + "files_mode": "0444", + "directories_mode": "0555", + "exit_codes": [ + 0, + 0 + ], + "all_package_files_unchanged": true + }, + "unrun": [ + "selected full cold replay", + "emitted native program and phase/wrapper admission", + "new complete physical owner allocation and global invoice", + "all-size compiler and precision/tape obligations", + "outer analytic transfer" + ], + "scope": "Exact local scalar/frame and certificate checks; no new full multiplication theorem or selected frontier update." + } +} diff --git a/research/selected-k8-endpoint-contractions/VERIFY.json b/research/selected-k8-endpoint-contractions/VERIFY.json new file mode 100644 index 0000000000..e08faaa0a4 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/VERIFY.json @@ -0,0 +1,54 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/complex-local-word-ceiling/README.md", + "research/complex-local-word-ceiling/ceiling.py", + "research/complex-x4-frame-bound/README.md", + "research/complex-x4-frame-bound/gen_duals.py", + "research/complex-x4-frame-bound/model.py", + "research/gauge44-slots/construction/slots/SLOT-PINS-k8.json", + "research/gauge44-slots/independent/audit_local.py", + "research/k8-rank7-composition/README.md", + "research/k8-rank7-composition/construct.py", + "research/k8-rank7-composition/data/END-RECIPE.json", + "research/r480-owner-optimum/inputs/local/FULL-WORD.json.gz", + "research/selected1042-lineage-resolution98/README.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Every coupled endpoint/frame LP column with exact variable-mass excess prices, primal attainment and full ceiling bracket." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/independent.py" + ], + "timeout_seconds": 120, + "checks": "Separate bitset/covector graph reconstruction, all dual inequalities and integer-root full-moment bounds." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/test_package.py" + ], + "timeout_seconds": 300, + "checks": "Three full local scalar/frame audits; missing idle-work false positive, missing endpoint/frame choices, optimized relocation and external corruptions." + } + ] +} diff --git a/research/selected-k8-endpoint-contractions/common.py b/research/selected-k8-endpoint-contractions/common.py new file mode 100644 index 0000000000..801586a07f --- /dev/null +++ b/research/selected-k8-endpoint-contractions/common.py @@ -0,0 +1,108 @@ +"""Source binding and serialization; no frame or optimization mathematics. + +Adapted from Gareth Davidson PR1671 (11fbeaf34609147c124323c2f5e74fc450dad931). +Gareth Davidson with OpenAI Codex assistance. Apache-2.0. +""" +import gzip +import hashlib +import json +from pathlib import Path +import types + +HERE = Path(__file__).resolve().parent +BASE = "15d2aca0385b61596155e8421140d08d27e543af" +WORD_SHA = "c2b294300760e1fd6eeab8c22c4d13e4633dca40e52cac8da0d68163a76e3ca8" +PROFILE = {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8} +INPUTS = { + "research/r480-owner-optimum/inputs/local/FULL-WORD.json.gz": "WORD.json.gz", + "research/gauge44-slots/construction/slots/SLOT-PINS-k8.json": "SLOT-PINS.json", + "research/complex-x4-frame-bound/model.py": "frame_model.py", + "research/complex-x4-frame-bound/gen_duals.py": "gen_duals.py", + "research/complex-x4-frame-bound/README.md": "FRAME-METHOD.md", + "research/complex-local-word-ceiling/ceiling.py": "ceiling.py", + "research/complex-local-word-ceiling/README.md": "CEILING.md", + "research/gauge44-slots/independent/audit_local.py": "audit_local.py", + "research/k8-rank7-composition/data/END-RECIPE.json": "END-RECIPE.json", + "research/k8-rank7-composition/construct.py": "construct.py", + "research/k8-rank7-composition/README.md": "END-WITNESS.md", + "research/selected1042-lineage-resolution98/README.md": "WORD-LINEAGE.md" +} + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def parse(raw): + def pairs(items): + result = {} + for key, value in items: + need(key not in result, "duplicate JSON key: " + key) + result[key] = value + return result + def bad(value): + raise ValueError("noninteger/nonfinite JSON number: " + value) + return json.loads(raw, object_pairs_hook=pairs, parse_float=bad, parse_constant=bad) + + +def canonical(obj): + return json.dumps(obj, sort_keys=True, separators=(",", ":"), allow_nan=False).encode() + + +def digest(obj): + return hashlib.sha256(canonical(obj)).hexdigest() + + +def source_bindings(): + need(parse((HERE / "INPUTS.json").read_bytes()) == INPUTS, "input mapping") + data = parse((HERE / "SOURCES.json").read_bytes()) + provenance = {"certificates/selected-result.json", "docs/research/agent-task-catalog.json"} + need(data["base_commit"] == BASE, "source base") + need(len(data["files"]) == len(INPUTS) + 2 and + {r["path"] for r in data["files"]} == set(INPUTS) | provenance, "source inventory") + for row in data["files"]: + path = row["path"] + need(row["usage"] == ("input" if path in INPUTS else "provenance"), "source role") + if path not in INPUTS: + continue + raw = (HERE / "references" / INPUTS[path]).read_bytes() + need(hashlib.sha256(raw).hexdigest() == row["sha256"], "retained source SHA256") + blob = hashlib.sha1(b"blob " + str(len(raw)).encode() + b"\0" + raw).hexdigest() + need(blob == row["git_blob"], "retained source Git blob") + live = HERE.parents[1] / path + if live.exists(): + need(live.read_bytes() == raw, "live mathematical source drift") + + +def retained(name): + """Keep the retained source's guards active even when the caller uses -O.""" + path = HERE / "references" / name + result = types.ModuleType("retained_" + path.stem) + result.__file__ = str(path) + exec(compile(path.read_bytes(), str(path), "exec", optimize=0), result.__dict__) + return result + + +def word(): + raw = gzip.decompress((HERE / "references/WORD.json.gz").read_bytes()) + pins = parse((HERE / "references/SLOT-PINS.json").read_bytes()) + need(hashlib.sha256(raw).hexdigest() == pins["word_sha256"] == WORD_SHA, "selected word content pin") + data = parse(raw) + need({int(r): n for r, n in data["report"]["local_profile"].items()} == PROFILE, "baseline local profile") + need(data["report"]["R"] == 480 and data["report"]["h"] == 9 and data["report"]["v"] == 112, + "selected word dimensions") + need(sum(r*n for r, n in PROFILE.items()) == 5586, "local rank mass") + return data + + +def duals(): + raw = gzip.decompress((HERE / "DUALS.json.gz").read_bytes()) + data = parse(raw) + need(data["schema"] == "selected-k8-contracted-end-duals-v1" and data["word_sha256"] == WORD_SHA, + "dual word binding") + return data + + +def primal_data(): + return parse(gzip.decompress((HERE / "PRIMAL.json.gz").read_bytes())) diff --git a/research/selected-k8-endpoint-contractions/independent.py b/research/selected-k8-endpoint-contractions/independent.py new file mode 100644 index 0000000000..c9135b91bb --- /dev/null +++ b/research/selected-k8-endpoint-contractions/independent.py @@ -0,0 +1,455 @@ +#!/usr/bin/env python3 +"""Separate bitset/event-graph and integer-root dual checker. Apache-2.0. + +Shares only source binding/JSON utilities with the primary checker. Does not +import the retained frame model, LP generator, ceiling engine or primary code. +Adapts Gareth Davidson PR1671, mathematical commit +11fbeaf34609147c124323c2f5e74fc450dad931, to coupled variable endpoints. +Gareth Davidson, with substantial OpenAI Codex assistance. +""" +from collections import Counter, defaultdict +from fractions import Fraction as Q +from functools import lru_cache +import importlib.util +import json +from math import isqrt +from pathlib import Path + +HERE = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location("independent_sources", HERE / "common.py") +U = importlib.util.module_from_spec(spec) +spec.loader.exec_module(U) +need = U.need +FULL = (1 << 512)-1 +SCALE = 1 << 256 +BITS = 96 +BASE_LO = Q(1690054109088, 10**15) +BASE_HI = Q(1690054109089, 10**15) +TARGET = Q(21, 20)*BASE_HI +RANKS = range(1, 10) + + +def elements(mask): + while mask: + bit = mask & -mask + yield bit.bit_length()-1 + mask ^= bit + + +@lru_cache(None) +def extend(frame, vector): + if (frame >> vector) & 1: + return frame + return frame | sum(1 << (x ^ vector) for x in elements(frame)) + + +def frame(vectors): + result = 1 + for vector in vectors: + need(type(vector) is int and 0 <= vector < 512, "frame-vector domain") + result = extend(result, vector) + return result + + +def dimension(space): + size = space.bit_count() + need(size > 0 and not size & (size-1), "subspace size") + return size.bit_length()-1 + + +@lru_cache(None) +def canonical_frame(space): + pivots = {} + for value in elements(space): + v = value + for p in sorted(pivots, reverse=True): + if (v >> p) & 1: + v ^= pivots[p] + if v: + p = v.bit_length()-1 + for k in list(pivots): + if (pivots[k] >> p) & 1: + pivots[k] ^= v + pivots[p] = v + result = tuple(pivots[p] for p in sorted(pivots, reverse=True)) + need(frame(result) == space, "canonical-frame span") + return result + + +@lru_cache(None) +def join(left, right): + result = left + for x in canonical_frame(right): + result = extend(result, x) + return result + + +@lru_cache(None) +def small_spaces(k): + seen, todo = {1}, [1] + while todo: + sub = todo.pop() + for x in range(1, 1 << k): + other = extend(sub, x) + if other not in seen: + seen.add(other) + todo.append(other) + return tuple(sorted(seen)) + + +def interval(lo, hi): + need(lo & ~hi == 0, "independent empty interval") + complement, current = [], lo + for x in canonical_frame(hi): + if not ((current >> x) & 1): + complement.append(x) + current = extend(current, x) + need(current == hi and len(complement) <= 4, "complete quotient domain") + result = [] + for sub in small_spaces(len(complement)): + value = lo + for bits in elements(sub): + x = 0 + for j, c in enumerate(complement): + if (bits >> j) & 1: + x ^= c + value = extend(value, x) + result.append(value) + need(len(set(result)) == len(result), "independent duplicate frame") + return sorted(result, key=lambda x: (dimension(x), canonical_frame(x))) + + +def operands(op): + need(op[0] in ("add", "scale"), "scalar primitive") + return op[1:3] if op[0] == "add" else op[1:2] + + +def scalar(rows, operations): + for op in operations: + if op[0] == "add": + t, s = op[1:3] + a = Q(op[3], op[4]) + for key, value in tuple(rows[s].items()): + new = rows[t].get(key, Q(0)) + a*value + if new: + rows[t][key] = new + else: + rows[t].pop(key, None) + else: + t = op[1] + a = Q(op[2], op[3]) + need(a, "invertible scale") + rows[t] = {key: a*value for key, value in rows[t].items()} + + +def cone_supports(word, n, v, low): + """Forward restricted columns, plus row covectors propagated through inverses.""" + main = word["A"]+word["cut"]+word["B"] + response = [{r: Q(1)} if r >= 2*v else {} for r in range(n)] + scalar(response, main) + dirty = [response[r].copy() if v <= r < 2*v else {} for r in range(n)] + scalar(dirty, word["precondition"]) + compensation = [["add", r, k, -a.numerator, a.denominator, []] + for r in range(v, 2*v) for k, a in sorted(dirty[r].items())] + prefix = word["precondition"]+compensation+main + columns = [{r: Q(1)} if r in low else {} for r in range(n)] + scalar(columns, prefix) + inverses = {q: {q: Q(1)} for q in low} + for op in prefix: + if op[0] == "add": + t, s = op[1:3] + a = Q(op[3], op[4]) + for row in inverses.values(): + if t in row: + new = row.get(s, Q(0))-a*row[t] + if new: + row[s] = new + else: + row.pop(s, None) + else: + t = op[1] + a = Q(op[2], op[3]) + for row in inverses.values(): + if t in row: + row[t] /= a + return {q: sorted((set(inverses[q]) | {k for k in range(n) if q in columns[k]})-{q}) + for q in low} + + +def build(word): + v, n = 112, 704 + fixed = {} + for q in range(n): + start = frame([word["ports"][q]]) if q < v else 1 + if str(q) in word["start_extra"]: + start = frame(word["start_extra"][str(q)]) + if v <= q < 2*v: + p = word["ports"][q-v] + end = sum(1 << x for x in range(512) if (x & p).bit_count() % 2 == 0) + else: + end = FULL + if str(q) in word["helper_final"]: + end = frame(word["helper_final"][str(q)]) + fixed[("S", q)], fixed[("E", q)] = start, end + low = {int(q): frame(x) for q, x in word["helper_final"].items()} + cones = cone_supports(word, n, v, low) + levels = {int(t): frame(x) for t, x in word["target_levels"].items()} + pins = {q: frame(x) for q, x in zip(word["centers"], word["center_frames"])} + need(len(pins) == 8, "independent centre count") + for t in range(v): + need(v+t not in pins, "centre/target collision") + pins[v+t] = levels.get(t, 1) + for q, f in pins.items(): + fixed[("P", q)] = f + centres = [] + for q, f in zip(word["centers"], word["center_frames"]): + cur = frame(f) + served = {levels.get(op[1]-v, 1) for op in word["cut"] if op[2] == q} + for target in sorted(served, key=lambda x: -dimension(x)): + need(target & ~cur == 0, "independent centre descent") + if target != cur: + centres.append(dimension(cur)-dimension(target)) + cur = target + tail = [word["cleanup"][i][:-1]+[f] for i, f in word["early_cleanup"]] + operations = word["A"]+word["B"]+tail + nA, nB = len(word["A"]), len(word["B"]) + chains = {q: [("S", q)] for q in range(n)} + order = [("S", q) for q in range(n)] + boundaries = {} + for i, op in enumerate(operations): + if i == nA: + for q in pins: + node = ("P", q) + chains[q].append(node) + order.append(node) + if i == nA+nB: + boundaries = {q: chains[q][-1] for q in range(n)} + node = ("G", i) + order.append(node) + for q in operands(op): + chains[q].append(node) + for q in range(n): + node = ("E", q) + chains[q].append(node) + order.append(node) + need(len(operations) > nA+nB, "selected word must have tail events") + edges = Counter((a, b) for ch in chains.values() for a, b in zip(ch, ch[1:])) + cone_edges = sorted({(boundaries[k], ("E",q)) for q,support in cones.items() for k in support}) + for edge in cone_edges: + edges.setdefault(edge, 0) + original_fixed = dict(fixed) + for q in low: + del fixed[("E",q)] + pred, succ = defaultdict(set), defaultdict(set) + for a, b in edges: + pred[b].add(a) + succ[a].add(b) + lo, hi = {}, {} + for node in order: + lower = 1 + for p in pred[node]: + lower = join(lower, lo[p]) + lo[node] = fixed.get(node, lower) + need(lower & ~lo[node] == 0, "independent fixed lower bound") + for node in reversed(order): + upper = low.get(node[1], FULL) if node[0]=="E" else FULL + for child in succ[node]: + upper &= hi[child] + hi[node] = fixed.get(node, upper) + need(hi[node] & ~upper == 0 and lo[node] & ~hi[node] == 0, "independent upper bound") + given = {**original_fixed, **{("G", i): frame(op[-1]) for i, op in enumerate(operations)}} + domains = {node: interval(lo[node],hi[node]) for node in order if lo[node]!=hi[node]} + profile = Counter(centres) + for (a, b), mult in edges.items(): + need(given[a] & ~given[b] == 0, "independent baseline nesting") + d = dimension(given[b])-dimension(given[a]) + if d and mult: + profile[d] += mult + need(dict(profile) == U.PROFILE, "independent baseline profile") + for node, f in given.items(): + need(lo[node] & ~f == 0 and f & ~hi[node] == 0, "independent given frame interval") + unseen, comps = set(domains), [] + while unseen: + start = min(unseen) + todo, comp = [start], set() + while todo: + node = todo.pop() + if node not in unseen: + continue + unseen.remove(node) + comp.add(node) + todo.extend((pred[node] | succ[node]) & unseen) + comps.append(sorted(comp)) + graph = {"nodes_sha256": U.digest([[list(n), lo[n], hi[n]] for n in sorted(lo)]), + "domains_sha256": U.digest([[list(n), sorted(domains[n])] for n in sorted(domains)]), + "edges_sha256": U.digest([[list(a), list(b), k] for (a, b), k in sorted(edges.items())]), + "cones_sha256": U.digest([[q,support] for q,support in sorted(cones.items())]), + "node_count": len(lo), "edge_count": len(edges), "cone_helpers": len(cones), "cone_edges": len(cone_edges)} + return dict(lo=lo, hi=hi, given=given, domains=domains, edges=edges, comps=comps, + graph=graph, centres=centres, chains=chains, original_caps=low, cones=cones) + + +def ceil_sqrt(n): + r = isqrt(n) + return r + int(r*r != n) + + +@lru_cache(None) +def child(r, a): + """Enclose (r/73)*(73/r)^a with dyadic exponent brackets and integer square roots.""" + need(1 <= r <= 73 and 0 <= a < 1, "root oracle domain") + lo = (73*SCALE)//r + hi = (73*SCALE+r-1)//r + integer_base = (lo, hi) + roots = [] + for _ in range(BITS): + lo, hi = isqrt(lo*SCALE), ceil_sqrt(hi*SCALE) + roots.append((lo, hi)) + power = (a.numerator << BITS)//a.denominator + def evaluate(k): + need(0 <= k <= 1 << BITS, "dyadic exponent bracket") + if k == 1 << BITS: + return integer_base + lower = upper = SCALE + for j, (left, right) in enumerate(roots, 1): + if (k >> (BITS-j)) & 1: + lower = (lower*left)//SCALE + upper = (upper*right+SCALE-1)//SCALE + return lower, upper + return Q(r*evaluate(power)[0], 73*SCALE), Q(r*evaluate(power+1)[1], 73*SCALE) + + +def charges(a): + costs={d:child(d,a) for d in RANKS} + idle=child(51,a) + return {d:(73*(costs[d][0]-Q(d,51)*idle[1]), + 73*(costs[d][1]-Q(d,51)*idle[0])) for d in RANKS} + + +def check(data, duals, bounds): + need(len(duals["components"]) == len(data["comps"]), "independent component coverage") + stats = Counter() + residuals = set() + for comp, record in zip(data["comps"], duals["components"]): + need(record["first"] == json.dumps(comp[0]) and record["nodes"] == len(comp), "independent component identity") + members = set(comp) + domain = data["domains"] + unary = {n: {f: Counter() for f in domain[n]} for n in comp} + pairs = {} + for (a, b), mult in data["edges"].items(): + if a in members and b in members: + pairs[(a, b)] = mult + elif a in members: + for f in domain[a]: + d = dimension(data["given"][b])-dimension(f) + need(f & ~data["given"][b] == 0, "independent unary nesting") + if d: + unary[a][f][d] += mult + elif b in members: + for f in domain[b]: + d = dimension(f)-dimension(data["given"][a]) + need(data["given"][a] & ~f == 0, "independent unary nesting") + if d: + unary[b][f][d] += mult + rows = {json.dumps(("N", n)) for n in comp} + touching = defaultdict(list) + for a, b in pairs: + for side, node in enumerate((a, b)): + touching[node].append((a, b, side)) + rows.update(json.dumps(("M", a, b, side, canonical_frame(f))) for f in domain[node]) + need(set(record["duals"]) <= rows, "independent unknown dual row") + q = {k: {int(d): Q(v) for d, v in vec.items()} for k, vec in record["duals"].items()} + need(all(d in RANKS for vec in q.values() for d in vec), "independent dual coordinate") + def add_to(vec, key, sign): + for d, v in q.get(json.dumps(key), {}).items(): + vec[d] = vec.get(d, Q(0))+sign*v + def accept(vec): + clean = {d: Q(vec.get(d, 0)) for d in RANKS} + if any(clean.values()): + for bound in bounds: + value = sum((v*bound[d][0 if v > 0 else 1] for d, v in clean.items() if v), Q(0)) + need(value > 0, "independent reduced cost") + stats["positive"] += 1 + else: + stats["zero"] += 1 + residuals.add(tuple(str(clean[d]) for d in RANKS)) + stats["columns"] += 1 + objective, baseline = Counter(), Counter() + for node in comp: + add_to(objective, ("N", node), 1) + baseline.update(unary[node][data["given"][node]]) + for f in domain[node]: + vec = dict(unary[node][f]) + add_to(vec, ("N", node), -1) + for a, b, side in touching[node]: + add_to(vec, ("M", a, b, side, canonical_frame(f)), 1) + accept(vec) + for (a, b), mult in pairs.items(): + d = dimension(data["given"][b])-dimension(data["given"][a]) + if d: + baseline[d] += mult + for left in domain[a]: + for right in domain[b]: + if left & ~right: + continue + d = dimension(right)-dimension(left) + vec = {d: mult} if d else {} + add_to(vec, ("M", a, b, 0, canonical_frame(left)), -1) + add_to(vec, ("M", a, b, 1, canonical_frame(right)), -1) + accept(vec) + need(all(objective[d] == baseline[d] for d in RANKS), "independent exact primal/dual identity") + stats.update(components=1, rows=len(rows)) + stats["distinct_reduced_vectors"] = len(residuals) + return dict(stats) + + +def main(): + U.source_bindings() + expected=U.parse((HERE/"EXPECTED.json").read_bytes()) + data=build(U.word()) + need(data["graph"]==expected["graph"],"independent complete graph differs") + dual=U.duals() + need(U.digest(dual)==expected["duals_sha256"],"independent dual binding") + primal=U.primal_data() + need(U.digest(primal)==expected["primal_sha256"],"independent primal binding") + need(set(primal["assignment"])=={json.dumps(n) for n in data["domains"]},"independent primal domain") + for n,choices in data["domains"].items(): + f=frame(primal["assignment"][json.dumps(n)]) + need(f in choices,"independent primal choice") + data["given"][n]=f + profile=Counter(data["centres"]) + for (a,b),mult in data["edges"].items(): + left,right=data["given"][a],data["given"][b] + need(left & ~right==0,"independent primal containment, including cones") + d=dimension(right)-dimension(left) + if d and mult:profile[d]+=mult + need(dict(profile)=={1:2400,2:446,3:416,4:142,5:82,8:8},"independent complete primal bill") + need({str(r):n for r,n in sorted(profile.items())}==expected["profile"]==primal["profile"],"independent profile fields") + free_ends=sorted(n[1] for n in data["domains"] if n[0]=="E") + need(free_ends==expected["free_ends"] and len(free_ends)==46,"independent endpoint coverage") + forced=sorted(set(data["original_caps"])-set(free_ends)) + need(forced==expected["forced_ends"] and len(forced)==32,"independent forced ends") + changed=sorted(q for q,cap in data["original_caps"].items() if data["given"][("E",q)]!=cap) + need(changed==expected["attaining_contracted_ends"]==[574,575,580,581],"independent attaining ends") + need(expected["gates"]==5413 and expected["free_gates"]==len(data["domains"])-46==1741,"independent gate coverage") + for r in range(1,73): + lo,hi=child(r,Q(1,2)) + need(lo*lo<=Q(r,73)<=hi*hi,"square-root oracle calibration") + need(child(37,1-Q(1,1<<100))[1]>=1,"dyadic carry") + lo,hi=map(Q,expected["a_bracket"]) + need(BASE_HI1,"independent full ceiling sign") + need(str(hi/(1+hi))==expected["kappa_cap"] and str(TARGET)==expected["target_a"],"independent planning fields") + print("PASS_K8_ENDPOINT_INDEPENDENT", "components="+str(stats["components"]), + "columns="+str(stats["columns"]),"root_calibrations=72","graph_and_duality_match=True") + + +if __name__=="__main__":main() diff --git a/research/selected-k8-endpoint-contractions/materialize.py b/research/selected-k8-endpoint-contractions/materialize.py new file mode 100644 index 0000000000..bbef20cbcb --- /dev/null +++ b/research/selected-k8-endpoint-contractions/materialize.py @@ -0,0 +1,40 @@ +"""Exact candidate parsing and native-word annotations; no solver is used. + +Gareth Davidson with OpenAI Codex assistance. Apache-2.0. +""" +from collections import Counter +from copy import deepcopy +import json + + +def primal(U, model): + data = U.primal_data() + raw = data["assignment"] + U.need(set(raw) == {json.dumps(n) for n in model.domain}, "complete primal node coverage") + assignment = {} + for node, domain in model.domain.items(): + f = tuple(raw[json.dumps(node)]) + U.need(f in domain, "primal frame outside complete domain") + assignment[node] = f + profile = model.profile(assignment) + U.need(profile == {int(r): n for r, n in data["profile"].items()}, "primal profile") + return assignment, profile + + +def native_word(word, model, assignment): + result = deepcopy(word) + for i in range(len(word["A"])): + result["A"][i][-1] = list(model.frame_of(("G", i), assignment)) + for i in range(len(word["B"])): + result["B"][i][-1] = list(model.frame_of(("G", model.nA+i), assignment)) + for i in range(len(word["early_cleanup"])): + result["early_cleanup"][i][1] = list(model.frame_of(("G", model.nA+model.nB+i), assignment)) + for q in model.original_caps: + result["helper_final"][str(q)] = list(model.frame_of(("E", q), assignment)) + profile = model.profile(assignment) + widths = Counter(len(model.frame_of(("E", q), assignment))-len(model.fixed_frames[("S", q)]) + for q in range(2*model.v, model.n)) + result["report"].update(local_profile={str(r): n for r, n in profile.items()}, + local_rank_mass=sum(r*n for r, n in profile.items()), + width_inventory={str(r): n for r, n in sorted(widths.items())}) + return result diff --git a/research/selected-k8-endpoint-contractions/model.py b/research/selected-k8-endpoint-contractions/model.py new file mode 100644 index 0000000000..ddbbb0d0a5 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/model.py @@ -0,0 +1,118 @@ +"""Variable nested helper ends, with complete frame domains and coupled cones. + +Extends navinor's unchanged frame model in references/frame_model.py. +Gareth Davidson with OpenAI Codex assistance. Apache-2.0. +""" +from collections import defaultdict +from fractions import Fraction as Q +from pathlib import Path +from types import ModuleType + +HERE = Path(__file__).resolve().parent +M = ModuleType("retained_frame_model") +exec(compile((HERE / "references/frame_model.py").read_bytes(), + str(HERE / "references/frame_model.py"), "exec", optimize=0), M.__dict__) + + +def require(ok, why): + if not ok: + raise ValueError(why) + + +def cone_supports(word, n, v): + """Separate support for every low-end helper; do not merge their end caps.""" + ident = lambda: [{k: Q(1)} for k in range(n)] + main = word["A"] + word["cut"] + word["B"] + raw = ident() + for event in main: + M.apply(event, raw) + dirt = [{} for _ in range(n)] + for y in range(v, 2 * v): + dirt[y] = {k: a for k, a in raw[y].items() if k >= 2 * v} + for event in word["precondition"]: + M.apply(event, dirt) + compensation = [["add", y, k, -a.numerator, a.denominator, []] + for y in range(v, 2 * v) for k, a in sorted(dirt[y].items())] + prefix = word["precondition"] + compensation + main + direct, inverse = ident(), ident() + for event in prefix: + M.apply(event, direct) + for event in reversed(prefix): + M.apply(M.invert(event), inverse) + return {int(q): sorted((set(inverse[int(q)]) | + {k for k in range(n) if int(q) in direct[k]}) - {int(q)}) + for q in word["helper_final"]} + + +class Model(M.Model): + """Every nested endpoint contraction with all original gate frames free.""" + + def __init__(self, word): + super().__init__(word) + self.original_caps = {int(q): M.basis(U) for q, U in word["helper_final"].items()} + self.cones = cone_supports(word, self.n, self.v) + self.original_edges = dict(self.edges) + self.boundaries = {} + for q, chain in self.chains.items(): + before = [node for node in chain if node[0] in ("S", "P") or + (node[0] == "G" and node[1] < self.nA + self.nB)] + self.boundaries[q] = before[-1] + self.cone_edges = sorted({(self.boundaries[k], ("E", q)) + for q, support in self.cones.items() for k in support}) + for edge in self.cone_edges: + self.edges.setdefault(edge, 0) + # A cone edge imposes containment, but creates no recursive child. + for q in self.original_caps: + del self.fixed_frames[("E", q)] + pins = sorted(node for node in self.fixed_frames if node[0] == "P") + order = [("S", q) for q in range(self.n)] + for i in range(len(self.gates)): + if i == self.nA: + order.extend(pins) + order.append(("G", i)) + order.extend(("E", q) for q in range(self.n)) + self.order = order + pos = {node: i for i, node in enumerate(order)} + pred, succ = defaultdict(list), defaultdict(list) + for a, b in self.edges: + require(pos[a] < pos[b], "nonchronological containment edge") + pred[b].append(a) + succ[a].append(b) + lo, hi = {}, {} + for node in order: + joined = M.join(lo[a] for a in pred[node]) + if node in self.fixed_frames: + require(M.contained(joined, self.fixed_frames[node]), "inconsistent fixed lower frame") + lo[node] = self.fixed_frames[node] + else: + lo[node] = joined + for node in reversed(order): + U = self.original_caps.get(node[1], M.FULL) if node[0] == "E" else M.FULL + for b in succ[node]: + U = M.meet(U, hi[b]) + if node in self.fixed_frames: + require(M.contained(self.fixed_frames[node], U), "inconsistent fixed upper frame") + U = self.fixed_frames[node] + hi[node] = U + require(M.contained(lo[node], U), "empty complete domain") + self.lo, self.hi = lo, hi + self.domain = {node: M.interval(lo[node], hi[node]) for node in order if lo[node] != hi[node]} + for node, choices in self.domain.items(): + require(self.given_frame(node) in choices, "baseline missing from domain") + self.profile(self.baseline()) + + def given_frame(self, node): + return self.given[node[1]] if node[0] == "G" else self.original_caps[node[1]] + + def baseline(self): + return {node: self.given_frame(node) for node in self.domain} + + def profile(self, assignment): + return {d: n for d, n in super().profile(assignment).items() if n} + + def components(self): + return sorted([sorted(c) for c in super().components()], key=lambda c: c[0]) + + +lp = M.lp +assignment_cost = M.assignment_cost diff --git a/research/selected-k8-endpoint-contractions/nominate.py b/research/selected-k8-endpoint-contractions/nominate.py new file mode 100644 index 0000000000..0bb2cefde4 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/nominate.py @@ -0,0 +1,123 @@ +#!/usr/bin/env python3 +"""Optional HiGHS nomination, adapted from navinor's retained gen_duals.py. +Solver outputs are proposals; acceptance rechecks all columns exactly. +Gareth Davidson with OpenAI Codex assistance. Apache-2.0. +""" +import gzip, json, sys, hashlib +from fractions import Fraction as F +from pathlib import Path +import highspy +import numpy as np +import scipy +import scipy.sparse as sp +import scipy.sparse.linalg as spla +HERE=Path(__file__).resolve().parent +sys.path.insert(0,str(HERE)) +import model as M +RANKS=range(1,10) +A=F(21,20)*F(1690054109089,10**15) + +def solve(rows, rhs, cols, gamma): + nr, nc = len(rows), len(cols) + start, index, value = [0], [], [] + cost = [] + for _, c, entries in cols: + cost.append(sum(c[d] * gamma[d] for d in range(len(c)))) + for i, a in sorted(entries): + index.append(i) + value.append(float(a)) + start.append(len(index)) + lp = highspy.HighsLp() + lp.num_col_, lp.num_row_ = nc, nr + lp.col_cost_ = np.array(cost) + lp.col_lower_ = np.zeros(nc) + lp.col_upper_ = np.full(nc, highspy.kHighsInf) + lp.row_lower_ = np.array(rhs, dtype=float) + lp.row_upper_ = np.array(rhs, dtype=float) + lp.a_matrix_.format_ = highspy.MatrixFormat.kColwise + lp.a_matrix_.start_ = np.array(start, dtype=np.int32) + lp.a_matrix_.index_ = np.array(index, dtype=np.int32) + lp.a_matrix_.value_ = np.array(value) + h = highspy.Highs() + h.setOptionValue('output_flag', False) + h.setOptionValue('presolve', 'off') + h.setOptionValue('solver', 'simplex') + h.passModel(lp) + h.run() + assert h.getModelStatus() == highspy.HighsModelStatus.kOptimal, h.modelStatusToString(h.getModelStatus()) + basis = h.getBasis() + sol = h.getSolution() + return h.getInfo().objective_function_value, basis, list(sol.col_value) + + +def symbolic_duals(rows, cols, basis): + basic_cols = [j for j in range(len(cols)) if basis.col_status[j] == highspy.HighsBasisStatus.kBasic] + active_rows = [i for i in range(len(rows)) if basis.row_status[i] != highspy.HighsBasisStatus.kBasic] + assert len(basic_cols) == len(active_rows), (len(basic_cols), len(active_rows)) + rpos = {i: k for k, i in enumerate(active_rows)} + data, ri, ci = [], [], [] + for kc, j in enumerate(basic_cols): + for i, a in cols[j][2]: + if i in rpos: + # transpose: row = basic column, column = active row + ri.append(kc) + ci.append(rpos[i]) + data.append(float(a)) + At = sp.csc_matrix((data, (ri, ci)), shape=(len(basic_cols), len(active_rows))) + lu = spla.splu(At) + q = {} + for d in RANKS: + rhs_d = np.array([float(cols[j][1][d]) for j in basic_cols]) + sol = lu.solve(rhs_d) + for k, i in enumerate(active_rows): + x = F(float(sol[k])).limit_denominator(1 << 20) + if x: + q.setdefault(i, {})[d] = x + # exact check on the basic columns: A_B^T q == c_B coordinate-wise + for j in basic_cols: + key, c, entries = cols[j] + for d in RANKS: + s = sum((a * q.get(i, {}).get(d, 0) for i, a in entries), F(0)) + assert s == c[d], ('rationalised dual is not exact on a basic column', key, d, s, c[d]) + return q + + +def main(): + raw=gzip.decompress((HERE/'references/WORD.json.gz').read_bytes()) + word=json.loads(raw); model=M.Model(word); a=float(A) + gamma=[0.0]+[d*((73/d)**a-(73/51)**a)/a for d in RANKS] + out={'schema':'selected-k8-contracted-end-duals-v1','nomination_a':str(A), + 'word_sha256':hashlib.sha256(raw).hexdigest(),'components':[]} + report={'versions':{'highspy':highspy.Highs().version(),'numpy':np.__version__,'scipy':scipy.__version__},'components':[]} + candidate={}; total=[F(0)]*10 + for index,comp in enumerate(model.components()): + labels,unary,pairs=model.component_problem(comp) + rows,rhs,cols=M.lp(labels,unary,pairs) + obj,basis,x=solve(rows,rhs,cols,gamma) + q=symbolic_duals(rows,cols,basis) + objective={d:sum((rhs[i]*vec.get(d,0) for i,vec in q.items()),F(0)) for d in RANKS} + for d in RANKS:total[d]+=objective[d] + fractional=sum(1 for value in x if 1e-81-1e-8] + if len(chosen)==1:candidate[node]=chosen[0] + report['components'].append({'first':comp[0],'nodes':len(comp),'rows':len(rows),'columns':len(cols),'fractional_columns':fractional,'numeric_objective':obj}) + out['components'].append({'first':json.dumps(comp[0]),'nodes':len(comp),'duals':{json.dumps(rows[i]):{str(d):str(z) for d,z in sorted(vec.items())} for i,vec in sorted(q.items())}}) + if index%20==0 or fractional:print(index,len(comp),len(cols),'fractional',fractional,flush=True) + full=len(candidate)==len(model.domain) + report['complete_integral_candidate']=full + report['symbolic_component_objective']={str(d):str(total[d]) for d in RANKS} + if full: + profile=model.profile(candidate) + report['candidate_profile']=profile + report['changed_endpoints']=[n[1] for n in candidate if n[0]=='E' and candidate[n]!=model.original_caps[n[1]]] + report['changed_gate_frames']=sum(n[0]=='G' and candidate[n]!=model.given[n[1]] for n in candidate) + primal={'assignment':{json.dumps(n):list(fr) for n,fr in sorted(candidate.items())},'profile':profile} + (HERE/'PRIMAL.json.gz').write_bytes(gzip.compress(json.dumps(primal,sort_keys=True,separators=(',',':')).encode(),mtime=0)) + data=json.dumps(out,sort_keys=True,separators=(',',':')).encode() + (HERE/'DUALS.json.gz').write_bytes(gzip.compress(data,mtime=0)) + report['canonical_duals_sha256']=hashlib.sha256(data).hexdigest() + (HERE/'DISCOVERY.json').write_text(json.dumps(report,indent=2)+'\n') + print('NOMINATED_NOT_CERTIFIED',len(out['components']),full,report.get('candidate_profile'),report.get('changed_endpoints'),flush=True) + +if __name__=='__main__':main() diff --git a/research/selected-k8-endpoint-contractions/references/CEILING.md b/research/selected-k8-endpoint-contractions/references/CEILING.md new file mode 100644 index 0000000000..f5f742f819 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/references/CEILING.md @@ -0,0 +1,108 @@ +# Packing ceiling and target budget for the selected complex local word + +**Scoped obstruction and planning tool. No new κ; the selected record is unchanged.** + +The selected complex supplier (#1094) fixes a local word with this paid profile per call: +`{1:2412, 2:418, 3:432, 4:142, 5:82, 8:8}`, local mass 5,586. Everything else in the record is +idle-remainder packing on 896 live data families per nine-stage replica (2 × 4 pairs × 112 ports, +all 492 helpers hosted). + +Under PR1012's coverage identity, paid mass is exactly `72·W + 64·N`, so each call carries 1,646 units +of idle mass. Every child of rank `r` costs `(r/73)^(1−a) = r·r^(−a)·73^(a−1)`, which is non-increasing +per unit of mass in `r`. So **no** idle histogram beats putting all idle mass into (fractional) children +of the largest rank allowed by the outer halving guard, `R = 51` (73² > 2·51²). + +## Results (exact rational intervals, `verify.py`) + +| Quantity | Value | +|---|---| +| Ceiling for any hosting, owner packing or idle-remainder change of this word | **a < 0.001690054109089** | +| Implied κ bound (`κ < a/(1+a)` when the complex side binds) | **κ < 0.001687202646** | +| Maximum gain over the selected κ 0.001672660197076918 | **+0.869%** | +| Selected endpoint / relaxation at the endpoint | below the ceiling; actual moment ≥ relaxation | +| Previous record #1042 | same paid local profile plus an admissible idle histogram (derived idle `{1:2249, 2:1, 3:400, 7:3, 16:47, 48:4850}` matches its README); endpoint below the same ceiling | + +This updates the fixed-word ceilings computed for earlier words +([static44](../static44-packing-ceiling/README.md), PR525, PR643) to the selected hosted T16/T37 line. It +uses the coverage law instead of a dual certificate. At the level of this cost decomposition, #1042→#1094 keeps the local paid profile and changes the +idle contribution. This arithmetic check does not by itself establish identical circuits or attribute every +implementation change to packing. Less than 0.87% of packing headroom remains under the stated model. + +### What a local word must pay for the planning target a = 1/99 + +Rewrite `relax(a) ≤ 1` as `Σ n_r p_r(a) ≤ B(a)`. Here `p_r(a) = (r/73)^(1−a) − r(51/73)^(1−a)/51` is the +excess of a local rank-r child over ideal idle mass, and `B(a) = w − (72w+64)(51/73)^(1−a)/51` is the +budget per call. + +| a | Budget B | Selected word's excess spend | Ratio | +|---|---:|---:|---:| +| selected endpoint 0.0016755 | 0.42752 | 0.42330 | 0.990 | +| target 1/99 | 0.12753 | 2.59681 | **20.4** | + +At a = 1/99, the selected word's excess spend is 20.4 times the budget. **Even deleting all 2,412 rank-1 +children per call, with everything else fixed, cannot reach it.** The allowed rank-1 count is negative. +With 112 ports and this nine-stage template, a target-scale gain needs a local word whose fully priced +excess spend is about 95% lower. Otherwise the coverage law itself must change: more unpaid coordinates +per family, a smaller 64-per-call centre charge, or more families per call. Helper-inventory proposals +can be screened against these numbers before any network is built: `ceiling.ceiling(local, 73, 896, 9, 64)` +takes a per-call local profile. + +### Ideal lever budgets + +`levers.py` changes one premise at a time and reports the packing ceiling. These are favorable relaxations +that omit the costs of realizing each lever. + +| Lever | Ceiling × | κ cap | +|---|---:|---:| +| Centre path free (no rank-8 copies, no 64-per-call charge) | 2.80 | 0.00472 | +| Centre path shared by two calls | 1.90 | 0.00320 | +| Local mass as rank-16 children | 2.31 | 0.00389 | +| Local mass as rank-8 children | 1.62 | 0.00273 | +| Two unpaid coordinates per live family | 3.77 | 0.00634 | +| Centre free and rank-16 children | 6.51 | 0.01089 | + +## Scope and limits + +- The bound holds for one fixed paid local profile (in particular, for a fixed local word), 112 ports, the nine-stage four-pair + template, the coverage law and the outer halving guard. It allows fractional counts and every repacking, + without checking physical realizability. +- It does **not** bound other local words. Many open claims above the selected κ (for example #1148's + joint-entrance word and its descendants, all ≤ 0.0016759) change the local word, so they are outside it. + Changed port counts, templates, coverage laws, centre charges or outer recipes are also outside it. +- `κ < a/(1+a)` is the retained balanced reduction's planning ceiling. The actual seven-step recipe gives + slightly less. +- Four controls run: + - an idle-rank cap of 52 is rejected; + - a local mass beyond the coverage law is rejected; + - one extra rank-1 child lowers the ceiling; + - 25 sampled integer idle histograms all have exact moment above one at the ceiling. + +## Reproduce + +```sh +python3 -I -B research/complex-local-word-ceiling/verify.py # ~10 s, PASS_COMPLEX_LOCAL_WORD_CEILING +python3 scripts/research_package.py --package research/complex-local-word-ceiling +python3 -I -B research/complex-local-word-ceiling/levers.py # ~5 s, planning budgets +``` + +`verify.py --write` regenerates `RESULT.json`. The exact arithmetic in `ceiling.py` uses the standard +library only: atanh logarithm chains, Taylor exponentials with remainder, and outward rounding to 2⁻²⁵⁶. + +## Open next questions + +- **What is the ceiling of each pending local word?** The ceiling separates packing headroom from + word gains in the review queue. A first step is to run `ceiling()` on the per-call local profiles of + #1148/#1169/#1218, after subtracting their idle histograms. The blocker is that each claim's idle + histogram must be extracted from its package. +- **How does the target budget scale with the port count V?** `B(a)` grows linearly with families per call. + Whether a decoder's excess spend grows more slowly decides if wider words can help. A first step is to + fit `Σ n_r p_r` against V across the recorded complex words (R439–R560 lineage). The blocker is per-call + local profiles for different V on a comparable template. + +## Credit + +The coverage identity is PR1012's. The fixed-word packing-ceiling idea comes from the static44, PR525 and +PR643 lineage, and the catalogue mixture bound from Ali Romman's +[heterogeneous-owner-assembly](../heterogeneous-owner-assembly/README.md). The selected construction +credits are in its review. Prepared by Douglas Colkitt with substantial Claude (Anthropic) assistance. +Apache-2.0. diff --git a/research/selected-k8-endpoint-contractions/references/END-RECIPE.json b/research/selected-k8-endpoint-contractions/references/END-RECIPE.json new file mode 100644 index 0000000000..7af7b6341c --- /dev/null +++ b/research/selected-k8-endpoint-contractions/references/END-RECIPE.json @@ -0,0 +1,242 @@ +{ + "ends": [ + [ + 574, + [ + 256, + 128, + 96, + 16, + 8, + 4, + 2, + 1 + ], + [ + 256, + 128, + 96, + 17, + 9, + 5, + 3 + ] + ], + [ + 575, + [ + 256, + 128, + 96, + 16, + 8, + 4, + 2, + 1 + ], + [ + 256, + 128, + 96, + 17, + 9, + 5, + 3 + ] + ] + ], + "B_frames": [ + [ + 994, + [ + 260, + 130, + 96, + 20, + 10, + 1 + ], + [ + 261, + 131, + 96, + 20, + 10 + ] + ], + [ + 995, + [ + 258, + 132, + 96, + 20, + 10, + 1 + ], + [ + 259, + 133, + 96, + 20, + 10 + ] + ], + [ + 1026, + [ + 264, + 137, + 96, + 24, + 4, + 3 + ], + [ + 268, + 137, + 96, + 24, + 3 + ] + ], + [ + 1027, + [ + 265, + 136, + 96, + 24, + 4, + 3 + ], + [ + 265, + 140, + 96, + 24, + 3 + ] + ], + [ + 1106, + [ + 260, + 130, + 96, + 20, + 10, + 1 + ], + [ + 261, + 131, + 96, + 20, + 10 + ] + ], + [ + 1107, + [ + 258, + 132, + 96, + 20, + 10, + 1 + ], + [ + 259, + 133, + 96, + 20, + 10 + ] + ], + [ + 1138, + [ + 264, + 137, + 96, + 24, + 4, + 3 + ], + [ + 268, + 137, + 96, + 24, + 3 + ] + ], + [ + 1139, + [ + 265, + 136, + 96, + 24, + 4, + 3 + ], + [ + 265, + 140, + 96, + 24, + 3 + ] + ] + ], + "early_cleanup": [ + [ + 93, + 93, + [ + 256, + 128, + 96, + 16, + 8, + 4, + 2, + 1 + ], + [ + 256, + 128, + 96, + 17, + 9, + 5, + 3 + ] + ], + [ + 94, + 94, + [ + 256, + 128, + 96, + 16, + 8, + 4, + 2, + 1 + ], + [ + 256, + 128, + 96, + 17, + 9, + 5, + 3 + ] + ] + ] +} diff --git a/research/selected-k8-endpoint-contractions/references/END-WITNESS.md b/research/selected-k8-endpoint-contractions/references/END-WITNESS.md new file mode 100644 index 0000000000..306ec13362 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/references/END-WITNESS.md @@ -0,0 +1,98 @@ +# Conditional kappa from smaller ends on the k8 word + +This finite construction certifies + +**κ = 0.001672404744903063**, + +or `1672404744903063 / 10^18`. The conservative calculation gives +`0.001672404742051193`. It improves the pinned PR1031 construction +`0.001672167430672016` by exactly `237314231047 / 10^18`. The base selected +certificate records PR942's `0.001661960547713947`; that selection is unchanged. + +This is a distinct construction, pending review. The last overlap scan found +PR1082 claiming a larger `0.001672653061493085` using the preceding k8 terminal +interface. This package claims a new smaller-end interface with a complete +paid packing, without claiming the highest pending or accepted frontier. + +## What changes + +Alexander Schwartzman's PR1030 helpers 588/589 map to **574/575** in the k8 +word. Their final frames become the dimension-seven space +`span_GF(2){256,128,96,17,9,5,3}`. Eight B frames and two early tails change. +The scalar program, gate order, all entrances and the center interface are +preserved. All twelve literal edits and both endpoint hashes are frozen in +`data/END-RECIPE.json` and `construct.py`. + +The local profile changes from +`{1:2412,2:418,3:432,4:142,5:82,8:8}` to +`{1:2406,2:432,3:424,4:142,5:82,8:8}`. Width per call decreases **3730 -> 3728**; +local rank mass decreases **5586 -> 5584**. Keeping the previous owners fails +the improvement screen: every newly exposed residual is priced. The new +69,120-role map in `data/OWNERS.json.gz` pays those residuals, whole helpers, +copies, spectators, source windows, restores, frame and coefficient work, +physical routing, and every recursive child through the unchanged full invoice. + +The final global profile is +`{1:348779,2:62233,3:61410,4:20459,5:11808,7:7,8:1156,16:16,32:1,48:4864}`. +It has 144 complete invocations, rank mass 1,041,408 and deficit 5,120. The +prefix is **397 < 512** bits and the physical row coefficient is +**16469 < 20161**. The complex supplier binds; PR589 is cited unchanged and +its complete bad-residue bit profile is repriced. + +## Reproduce + +Base: `2921874911956718fcaaaf9396fe8267b3cfa9f0`. PR1031: +`e900534f0beda892c726723524203b97471fb9a3`. PR1030: +`d71857cd0ae7824e935aac17327e4ec27f66322b`. All retained source archives and +348 main files are SHA-256 pinned in `SOURCES.json`. No solver or GitHub fetch +is required for replay; Python 3.12+ with assertions enabled is sufficient. + +From the repository root, with a new output directory: + +```sh +python3 -I -B research/k8-rank7-composition/reproduce.py --work /tmp/k8-rank7-replay +python3 -I -B research/k8-rank7-composition/check_controls.py --replay /tmp/k8-rank7-replay +``` + +Expected markers: + +```text +PASS_K8_RANK7_COMPLETE_REPRODUCTION 0.001672404744903063 +PASS_K8_RANK7_SEMANTIC_CONTROLS 10 +``` + +The command explicitly reuses the frozen parent ancestry in `evidence/ANCESTRY.json` +and `sources/SLOT-NATIVE.tar.gz`. That ancestry was freshly built before +publication: all 21 k8 chain stages, five cold-end control batches, native +programs/wrappers/phases, and all 34 new-slot controls passed. The portable +command checks its receipt and source identities, freshly constructs the +new word and native code, checks every exact scalar column in both +orientations, all frames and wrapper cones, and freshly verifies all phases. +It then replays both the preceding and new T16 controller, source geometry, +full invoice, both exact moment engines and all 47 outer conditions. +It does not rerun the inherited scalar constructors during every replay. + +Both full admissions include 69 admission controls, 12 bit controls, 15 +controller mutations and six independent owner controls. Ten additional +controls reject incomplete tails, invalid read frames/end spaces, false +profiles/widths, duplicate or split helpers, bad slices, restoration of the +preceding larger ends on the new map, and the next outer grid point. + +## Search and mathematical scope + +The changed width inventory is outside PR942's fixed-U8 all-replica theorem. +Searches used seed 32 and stopped at explicit budgets: six greedy epochs, +80 restricted MILPs (three seconds each), two global MILPs (120 seconds +each), one global CP-SAT run (120 seconds), and 12 window searches (18 +seconds each). The global MILPs found no integer witness. The final map is +feasible; neither failed searches nor restricted solver optimality establish +a global packing optimum. Exact domains, completed attempts, accepted moves, +software versions and stopping rules are in `evidence/SEARCH.json.gz`. +Reproduction consumes frozen data and performs independent admission. + +The inherited all-size/compiler, common-label and mutable-source realization, +whole-call hosting, physical implementation, precision/tape, exact recovery, +analytic transfer and bit H1-H5 obligations remain. This is a finite conditional +certificate, not an unconditional theorem or a full Lean proof. Contributor +credit, inherited licenses and substantial AI assistance are recorded in +`NOTICE.md` and the preserved source notices. diff --git a/research/selected-k8-endpoint-contractions/references/FRAME-METHOD.md b/research/selected-k8-endpoint-contractions/references/FRAME-METHOD.md new file mode 100644 index 0000000000..e2ddf660ac --- /dev/null +++ b/research/selected-k8-endpoint-contractions/references/FRAME-METHOD.md @@ -0,0 +1,75 @@ +# Frame reassignment cannot raise the selected X4 complex supplier + +**Scoped negative result. No new κ.** Base `f567884aeb8851b6e794af1184119a3bfbe1e631`, where the selected κ = 0.001661634653669567 comes from #799 with #589 on #555 and the complex side binds. Complex-supplier sprint track, OS seed 28 (see `CLAIM.md`). + +## Claim + +Fix the scalar program of the selected complex word, PR799's X4 word (decompressed content `1e1d99ba…`), which serves all 72 complex calls. Keep its gate list and order, registers, coefficients, start and end frames (so every helper width), cut, centres, target levels, precondition, FULL cleanup and the set of early-cleanup (tail) gates. Let each of its 6,364 A, B and tail gate frames be any subspace of F₂⁹ allowed by the frame contract that `research/gauge44-frames-x/independent/audit_local.py` checks: + +- frames are nested along every register, from its start frame to its end frame; +- centres and targets sit at their centre frame and target level at the start of B; +- for each of the 126 low-end helpers, every register in its inverse-row or dirt-column cone ends B inside that helper's end frame. + +No such assignment admits the native complex saving + + b_next = 832200139425241163957/500000000000000000000000 = 0.001664400278850482327914, + +the next 10⁻²⁴ grid point above the selected endpoint `0.001664400278850482327913`. Every child rank is below 73, so no larger b is admitted either. The pinned outer engine (`outer.py`) requires κ < ε·q = (1−η)q/(1+q) with q = a(1−2η) (`compact_phase_layer`) and a < b (`complex_above_bit`), so κ < b/(1+b). Since b_next/(1+b_next) = 0.0016616346536695670758… lies below the next κ tick 0.001661634653669568, frame reassignment alone cannot raise the selected κ. + +## Proof outline + +1. **Domains.** Forward joins from fixed starts and start-of-B pins give a lower frame `lo`. Backward meets from fixed ends, pins and cone ceilings give an upper frame `hi`. By induction every legal frame lies in `[lo, hi]`. Here `dim(hi/lo) ≤ 3`: 5,163 gates are forced and 1,201 have 2, 5 or 16 choices (965, 206 and 30 gates). The verifier enumerates each interval and checks its size against the Gaussian-binomial count. +2. **Cost.** A strict climb of dimension d along a register is one paid child of rank d (the `audit_local.py` rule). Climbs telescope along each register, so rank mass is fixed. The native moment then depends on the assignment only through C_d = M_d − d·M₁ with M_d = d·(73/d)^b, and C₀ = C₁ = 0. +3. **LP.** Free gates linked along register chains form 140 components. Each component's local-polytope LP has a variable for every (gate, frame) and for every nested frame pair on each merged register edge: 9,483 rows and 12,019 columns in total. Every legal assignment is a 0/1 point. +4. **Exact duals.** Each dual entry is a linear form in C₂…C₉ with integer coefficients. The verifier rebuilds every row, column and cost from the word, then checks every reduced cost. 8,582 are identically zero, and 3,437 are strictly positive under outward rational bounds from both pinned engines (`moment.py`, Mercator series, and `base_two_moment.py`, atanh series). In every component the dual objective equals the selected assignment's cost as an exact coefficient identity. By weak duality the selected frames minimise the local moment. +5. **Global step.** 72 times the local profile plus the remainder {1:1, 3:1, 44:1, 48:2396} reproduces the pinned global profile. Both engines put the global moment strictly above 1 at b_next and strictly below 1 at the selected endpoint. Each call costs at least the selected word, so any reassignment, even a different one in each call, has moment above 1 at b_next. + +The model relaxes the centre equality at the start of B to a charged climb, and it omits native-chain conditions beyond `audit_local.py`. Both choices only enlarge the feasible set, so the bound also covers the stricter native contract. + +## Cross-check against the independent auditor + +`crosscheck.py` draws 12 random legal reassignments (40 frame changes each, seed 28), writes each into the word with the profile the model predicts, and runs the pinned `audit_local.py` unchanged. All 12 pass its exact two-orientation scalar replay and its frame, centre, target and cone checks with the predicted profile. All 12 are strictly costlier at b_next. The auditor refuses a frame below the forward join and a mismatched profile. Receipt: `data/CROSSCHECK.json`. + +## Reproduce + +Python 3.11 or newer, standard library only, assertions on, from the repository root: + +```sh +python3 -B research/complex-x4-frame-bound/verify.py --controls +``` + +Expected final line: `PASS_X4_FRAME_ASSIGNMENT_EXCLUSION controls=6/6`, in about 5 seconds. The six controls must each be rejected: a dropped component, an inflated dual, an omitted frame choice, the accepted endpoint in place of b_next, a legal but costlier baseline, and a changed word. `RESULT.json` is the receipt of this command. + +Optional commands: + +```sh +python3 -B research/complex-x4-frame-bound/crosscheck.py # about 1 minute +python3 -B research/complex-x4-frame-bound/verify.py --word /tmp/x4/jx/FULL-WORD.json.gz +``` + +The second form checks a freshly rebuilt word from `research/gauge44-frames-x/README.md`; the content hash must match. By default the verifier reads the retained replay archive `research/community-frontier799-audit/pr799-replay.tar.gz`, whose hash the maintainer's integration receipt records. + +`gen_duals.py` nominated the duals with HiGHS (highspy 1.15.1, SciPy 1.18.1, NumPy 2.5.4, Python 3.12.14). Two runs wrote byte-identical `data/DUALS.json.gz`. The generator is not part of the proof: `verify.py` imports no solver and trusts no floating-point value. + +Checked on Windows 11 with CPython 3.12.14 and 3.14.7. + +## What this leaves for the complex track + +Per call, 1,745 of the 2,548 rank-1 children, all 56 rank-5 children and the eight centre descents lie on register edges between forced frames. Any κ gain from this supplier needs a scalar change (read sets, gate order, tail membership), new start or end frames (entrances, low ends, widths), or a change to owners and hosting. Frame re-choice on X4 is closed at b_next. + +## Scope + +Not covered: scalar rewrites, gate reordering or read-set exchanges; moving gates into or out of the early cleanup; entrance promotions or any other start or end frame change; owners, hosting and the finite invoice; the bit supplier; other outer theorems. The exclusion holds at b_next for the fixed word. It does not replay the native construction chain. The inherited all-size compiler, common-label and mutable-source realization, whole-call hosting, precision and tape, and analytic hypotheses remain. This is a finite certificate, not a Lean proof. + +## Prior work + +- chafreaky's #557 (`research/frame-domain-ceiling`) introduced complete F₂ domains, this LP relaxation and symbolic exact duals, for the PR551 word. +- ntedvs's #776 (open) applies the method to #626's jp8 and ck words, with tail frames outside its scope. +- Rohansguliani's #815 (open) solves PR699's SW4 word and #626's words with floating-point LP and CP-SAT, with tail frames fixed, and rediscovers #741. +- JointXF reported in #799 that FrameCoal's optimiser reaches the X4 profile. The #799 review keeps that as a search report. This package corroborates it with an exact certificate. + +This package is a new implementation for the native gauge44 word format. Unlike the earlier packages, it frees the 163 early-cleanup frames and derives the low-end cone ceilings from the exact prefix map. + +The X4 word is Jeremy Kothe's #799 construction on chafreaky's #741 frames, BRoute's SW4 exchange, BlockInvert's promotions, the p6n and no-triangle layers and icekylinx's #645 gauge44 factory, with the lineage recorded in `research/gauge44-frames-x/README.md` and `CONTRIBUTORS.md`. + +Prepared for @navinor with substantial assistance from Claude Code. Apache-2.0. No independent human review. diff --git a/research/selected-k8-endpoint-contractions/references/SLOT-PINS.json b/research/selected-k8-endpoint-contractions/references/SLOT-PINS.json new file mode 100644 index 0000000000..2702c368f4 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/references/SLOT-PINS.json @@ -0,0 +1,47 @@ +{ + "base_sha256": "db2c7cfb3f8eee2b76c2e0154fc530520fb4d90cd9511a002cab527b16033b83", + "word_sha256": "c2b294300760e1fd6eeab8c22c4d13e4633dca40e52cac8da0d68163a76e3ca8", + "canonical_sha256": "4ddb29fb9bc6f27e0c0fbfcf19a2a93a3496ad900d0f6d89059d0305c9576c0c", + "program_sha256": { + "forward": "071ecdacc0bb3ac16046aad4119ed551a945cb0ed6c57002a548a3e2232503d8", + "backward": "f36c5831106f5637102c6bedeec76ed2b223c6671ce42fd0eceed9ef24725b23" + }, + "clifford_recipes_sha256": "d0768f2164d5f64a2fdbec422f1cfde4e400818792f1904ca541958377243731", + "slot_controls": [ + "C0_identity", + "donation_after", + "donation_after@236", + "donation_after@238", + "donation_after@434", + "donation_after@436", + "donation_after@439", + "donation_after@444", + "donation_after@446", + "drop_preread", + "drop_preread@236", + "drop_preread@238", + "drop_preread@434", + "drop_preread@436", + "drop_preread@439", + "drop_preread@444", + "drop_preread@446", + "drop_restore", + "drop_restore@236", + "drop_restore@238", + "drop_restore@434", + "drop_restore@436", + "drop_restore@439", + "drop_restore@444", + "drop_restore@446", + "recipe", + "restore_full", + "restore_full@236", + "restore_full@238", + "restore_full@434", + "restore_full@436", + "restore_full@439", + "restore_full@444", + "restore_full@446" + ], + "kappa_decimal": "0.00167166528321877" +} diff --git a/research/selected-k8-endpoint-contractions/references/WORD-LINEAGE.md b/research/selected-k8-endpoint-contractions/references/WORD-LINEAGE.md new file mode 100644 index 0000000000..b9d19db883 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/references/WORD-LINEAGE.md @@ -0,0 +1,101 @@ +# Which word is selected in the PR1042 replay? + +The retained package file `research/gauge44-slots-t16/evidence/local/FULL-WORD.json.gz` +is an **R492 predecessor**, not the selected R480 seven-slot word. Its canonical +contents match `base/cold44/FULL-WORD.json.gz` in the maintainer's selected replay. +The selected word is the archive member **`slots/local/FULL-WORD.json.gz`**. +Five archive members contain that same canonical word. This package provides an +executable inventory and rejects confusing the retained evidence, the pre-slot +R480 word, or a compressed-container digest with the selected word. + +No selected mathematical input was found to be wrong. The original README +already requires freshly built `--local` output, and the selected orchestrator +passes that output explicitly. This is a provenance reconciliation with concrete +rejection controls, not a correction of the accepted conditional bound. + +## Three distinctions checked + +| Object | Retained evidence | Selected archive word | +|---|---:|---:| +| Helper count | 492 | 480 | +| B operations | 1918 | 1846 | +| A operations | 3738 | 3451 | +| Cleanup operations | 28150 | 6796 | + +The selected decoded payload is already compact sorted JSON. Its payload and +canonical SHA-256 both equal the original slot pin +`c2b294300760e1fd6eeab8c22c4d13e4633dca40e52cac8da0d68163a76e3ca8`. +Its committed gzip container SHA-256 is instead +`49596aa4ed4fd36cd4582fd0e8ddeb09fd80370a7d8aea1ede52a135b536d289`. +Both are correct in their respective domains. The verifier accepts recompressed +and reformatted copies when every parsed word field remains identical. It keeps +exact raw hashes for the frozen source archive and its recorded artifact receipts. + +The selected word's own report retains the stage-local status +`EXACT_CLEAN_OWN_Y_EARLY_CENTER_WORD_NOT_ADMITTED`. The later composition receipt +is `PASS_COMPLETE_PR1042_COMPOSITION`. They describe different stages and are +not contradictory. The old PR799 wording in the assembly scope similarly +describes inherited lineage; the explicit selected pointers, T16 receipt and +source-bound profile identify the PR1042 composition. This note does not turn a +stage-local claim into full admission by renaming it. + +## Exact evidence + +The command checks all files listed in the pinned selected-source manifest, +all **458 regular unique archive members**, the **457 artifact digests** in the +producer receipt, all ten recorded construction stages and their source/log +digests, and the selected assembly's identical archived and retained bytes. +It inventories every **35 FULL-WORD member**, including duplicate stages, using +container, decompressed-payload and canonical digests separately. Five aliases +match the selected slot pin; the retained R492 file matches only the historical +`base/cold44` member. + +An additional arithmetic bridge checks the local profile +`{1:2412,2:418,3:432,4:142,5:82,8:8}`, its local rank mass 5586, and its helper-width +inventory. Multiplying that profile by 144 whole invocations and adding the +recorded T16 idle profile reproduces the independent receipt, T16 replay and +assembly profile exactly, with total rank mass **1041408**. The assembly retains +PR589 on the bit side and conditional kappa `1672188119205421/10^18`. + +The complete word inventory, equality classes and exact values are in +`EXPECTED.json`. Eight controls reject the R492 word, the pre-slot R480 word, +an omitted operation, changed idle profile, omitted whole call, false helper +count, wrong digest domain and duplicate JSON. The archive is read in memory; +no tar paths are extracted or executed. + +## Reproduce + +From the repository root, Python 3.10+ standard library: + +```sh +python -I -O -B research/selected1042-lineage-resolution98/verify.py +``` + +Expected: `PASS_SELECTED1042_LINEAGE selected_R=480 retained_R=492 words=35 aliases=5 controls=8`. +The default command writes nothing. `--write-certificate` writes only when no +certificate exists. Every check remains active under `-O`. + +## Scope and provenance + +Base `ba82555c64e1879e4b7decce28186f208fcb8262`, assigned seed98 without reroll. +The selected snapshot is frozen for reproducibility. Later selected frontiers +are outside this investigation. This command checks provenance consistency and +profile arithmetic; it **does not rerun the original native construction**, all +controls, moment engines or outer inequalities, authenticate historical +execution, or prove the full multiplication theorem. It does not prove that a +different word with the same profile is correct. Source hashes and the exact +canonical word pin prevent substituting such a word here. + +The selected construction, source manifests and replay are credited to Jeremy +Kothe, Rohan Arun, Hao Yan and the credited compiler/supplier lineage, with +Douglas Colkitt's maintainer orchestration. The gzip distinction follows the +repository's existing reproducibility policy and Maxime Fleury's earlier audit; +no new general hashing principle is claimed. Concurrent local analysis of the +mutable-leaver cores first noticed the retained R492 evidence path; this package +adds the complete archive reconciliation and profile binding, not that core +optimality result. Prepared for @woklerx with substantial OpenAI Codex assistance. +Apache-2.0; algorithmic crosschecks and AI review are not independent human review. + +Fresh PR1112 independently checks the selected finite invoice, guards and outer +slacks. This package does not repeat that audit; it identifies exact word +artifacts and verifies their provenance and profile linkage. diff --git a/research/selected-k8-endpoint-contractions/references/WORD.json.gz b/research/selected-k8-endpoint-contractions/references/WORD.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..723decbca8995e916d6f4b783aa3e1ddd4eb47fe GIT binary patch literal 57222 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 and piv[j]>>k&1:piv[j]^=piv[k] + return tuple(piv[k] for k in sorted(piv,reverse=True)) + +def contained(a,b):return basis(a+b)==b + +def registers(e):return e[1:3] if e[0]=='add' else e[1:2] + +def apply(e,rows,dual=False): + if e[0]=='add': + t,s=e[1:3];q=F(e[3],e[4]);require(t!=s,'self add') + if dual:t,s,q=s,t,-q + dst=rows[t] + for k,x in list(rows[s].items()): + a=dst.get(k,F(0))+q*x + if a:dst[k]=a + else:dst.pop(k,None) + elif e[0]=='scale': + t=e[1];q=F(e[2],e[3]);require(q!=0,'zero scale') + if dual:q=1/q + rows[t]={k:q*x for k,x in rows[t].items()} + else:raise RuntimeError('unknown scalar primitive') + +def invert(e): + r=list(e) + if r[0]=='add':r[3]=-r[3] + else:r[2],r[3]=r[3],r[2] + return r + +def check_parent_interface(word,main): + # Read only the retained boundary data. No builder or local checker is imported. + relative="research/community-k492-audit/pr622/replay/baseline558/complex-global/base/split-centres/CANONICAL-WORD.json.gz" + path=main/relative;raw=path.read_bytes() + require(hashlib.sha256(raw).hexdigest()=="66d3c3c70983224650643a0a05a21ac6c6959f84d0f4528650601016f5a76844",'parent canonical input pin') + parent=json.loads(gzip.decompress(raw)) + tau=lambda x:x^(43 if (x&43).bit_count()%2 else 0) + ports=parent['ports'];v=word['report']['v'] + require(len(ports)==len(set(ports))==v,'parent port count') + require(set(map(tau,word['ports']))==set(ports),'transported source/target ports') + moved={i:ports.index(tau(p)) for i,p in enumerate(word['ports'])} + centers=[moved.get(r,r) for r in word['centers']] + actual=[list(basis([tau(x) for x in frame])) for frame in word['center_frames']] + expected=[parent['frames'][f] for f in parent['center_frames']] + require(len(centers)==len(set(centers))==len(actual)==8,'eight distinct centre carriers') + require(actual==expected and all(len(f)==8 for f in actual),'ordered centre frame interface') + return dict(parent_path=relative,parent_file_sha256=hashlib.sha256(raw).hexdigest(), + transport_tau=43,ordered_frame_bases_match=True,all_ports_match=True, + transported_centers=centers,source_centers=[r for r in centers if r=2*v} + for e in w['precondition']:apply(e,dirt) + compensation=[['add',y,k,-a.numerator,a.denominator,[]] for y in range(v,2*v) for k,a in sorted(dirt[y].items())] + entering=set(map(int,w.get('start_extra',{})));lowends=set(map(int,w.get('helper_final',{}))) + coldends=lowends-entering + require(not any(e[2] in entering for e in compensation),'nonzero entrance response') + require(not any(r in entering|coldends for e in w['precondition']+compensation for r in registers(e)), 'pre-wrapper touch of residual helper') + require(all(e[-1]==[] for e in w['precondition']+compensation),'nonzero frame precondition') + early=w.get('early_cleanup',[]);earlyids={i for i,U in early} + require(len(earlyids)==len(early),'duplicate early cleanup gate') + tail=[w['cleanup'][i][:-1]+[U] for i,U in early] + cleanup=[e for i,e in enumerate(w['cleanup']) if i not in earlyids] + prefix=w['precondition']+compensation+main + program=prefix+tail+cleanup + for dual in (False,True): + actual=ident() + for e in program:apply(e,actual,dual) + expected=ident() + for t in range(v):expected[t if dual else v+t][v+t if dual else t]=F(-1 if dual else 1) + bad=[i for i in range(n) if actual[i]!=expected[i]] + require(not bad,'all-column endpoint failure '+str((dual,bad[:8]))) + print('endpoint', 'dual' if dual else 'forward','PASS',flush=True) + full=basis([1< 1 is a what-if for a changed coverage law only); + * the local word fixes its own paid child profile `local` (per call); + * every remaining unit of mass is an idle/remainder child of rank at most R, where the outer + recipe's halving guard m^2 > 2 R^2 bounds R (R = 51 for m = 73). + +Lemma. For a >= 0, a child of rank r costs (r/m)^(1-a) = r * c(r), with c(r) = r^(-a) m^(a-1) +non-increasing in r. Hence, with idle mass M fixed and idle ranks <= R, every idle histogram has +moment >= the relaxation that puts all of M into (possibly fractional) rank-R children: + + relax(a) = [ sum_local n_r (r/m)^(1-a) + (M/R) (R/m)^(1-a) ] / w (per call). + +The moment is increasing in a. So relax(a*) > 1 certifies that no hosting, owner packing or +idle-remainder change of the given local word, template and outer recipe certifies a saving +>= a*. Under the retained reduction kappa < a/(1+a) when the complex side binds, so +a*/(1+a*) also bounds kappa. This is a bound for the stated model, not for other local words, +templates, coverage laws or outer recipes. + +Exact rational intervals: ln k from atanh chains, exp by Taylor with Lagrange remainder, +outward rounding to 2^-PREC. Standard library only. Douglas Colkitt, with Claude (Anthropic) +assistance. +""" +from fractions import Fraction as Q +from functools import lru_cache +from math import isqrt + +PREC = 256 + + +def require(ok, why): + if not ok: + raise ValueError(why) + + +def down(x): + return Q((x.numerator << PREC) // x.denominator, 1 << PREC) + + +def up(x): + return -down(-x) + + +@lru_cache(None) +def atanh(t): + """Enclosure of atanh(t) for rational 0 < t <= 1/3.""" + require(0 < t <= Q(1, 3), 'atanh range') + s, p, k = Q(0), t, 0 + while True: + term = p / (2 * k + 1) + s += term + p *= t * t + k += 1 + tail = p / ((2 * k + 1) * (1 - t * t)) + if tail < Q(1, 1 << (PREC + 8)): + return down(s), up(s + tail) + + +@lru_cache(None) +def ln(k): + """Enclosure of ln k for an integer k >= 1: ln k = ln(k-1) + 2 atanh(1/(2k-1)).""" + require(isinstance(k, int) and k >= 1, 'ln domain') + if k == 1: + return Q(0), Q(0) + lo, hi = ln(k - 1) + a, b = atanh(Q(1, 2 * k - 1)) + return down(lo + 2 * a), up(hi + 2 * b) + + +def exp(lo, hi): + """Enclosure of exp([lo, hi]) for 0 <= lo <= hi <= 1/2.""" + require(0 <= lo <= hi <= Q(1, 2), 'exp range') + def series(y, upper): + s, t, k = Q(1), Q(1), 0 + while True: + k += 1 + t = t * y / k + s += t + if t * y < Q(1, 1 << (PREC + 8)): + return up(s + 2 * t * y / (k + 1)) if upper else down(s) + return series(lo, False), series(hi, True) + + +def child_cost(r, m, a): + """Enclosure of (r/m)^(1-a) = (r/m) exp(a ln(m/r)).""" + lm, um = ln(m) + lr, ur = ln(r) + e = exp(max(Q(0), a * (lm - ur)), a * (um - lr)) + return down(Q(r, m) * e[0]), up(Q(r, m) * e[1]) + + +def max_idle_rank(m): + """Largest R with m^2 > 2 R^2 (outer halving guard).""" + R = isqrt((m * m - 1) // 2) + while 2 * (R + 1) ** 2 < m * m: + R += 1 + while 2 * R * R >= m * m: + R -= 1 + return R + + +def model(local, m, families, stages, centre, R=None, unpaid=1): + """Per-call quantities. local: {rank: count per call (Fraction ok)}.""" + R = max_idle_rank(m) if R is None else R + require(2 * R * R < m * m, 'idle rank cap violates the halving guard') + require(all(0 < r < m for r in local) and all(n >= 0 for n in local.values()), 'local profile') + w = Q(families, stages) + require(1 <= unpaid < m, 'unpaid coordinates per family') + total = (m - unpaid) * w + centre + local_mass = sum(r * Q(n) for r, n in local.items()) + idle = total - local_mass + require(idle >= 0, 'local word pays more mass than the coverage law allows') + return dict(R=R, w=w, total_mass=total, local_mass=local_mass, idle_mass=idle, deficit=unpaid * w - centre) + + +def relax(local, m, families, stages, centre, a, R=None, unpaid=1): + """Enclosure of the per-call relaxation moment at saving a.""" + q = model(local, m, families, stages, centre, R, unpaid) + lo = hi = Q(0) + for r, n in local.items(): + c = child_cost(r, m, a) + lo, hi = lo + Q(n) * c[0], hi + Q(n) * c[1] + c = child_cost(q['R'], m, a) + k = q['idle_mass'] / q['R'] + lo, hi = lo + k * c[0], hi + k * c[1] + return down(lo / q['w']), up(hi / q['w']) + + +def ceiling(local, m, families, stages, centre, grid=Q(1, 10 ** 15), R=None, unpaid=1): + """Grid bracket [a_lo, a_hi]: relax(a_lo) < 1 < relax(a_hi), certified. a_hi is the ceiling.""" + lo, hi = Q(0), Q(1, 20) + require(relax(local, m, families, stages, centre, hi, R, unpaid)[0] > 1, 'search window too small') + require(relax(local, m, families, stages, centre, lo, R, unpaid)[1] < 1, 'relaxation has no positive saving') + while hi - lo > grid: + mid = Q(int((lo + hi) / 2 / grid)) * grid + if mid <= lo: + mid = lo + grid + v = relax(local, m, families, stages, centre, mid, R, unpaid) + if v[1] < 1: + lo = mid + elif v[0] > 1: + hi = mid + else: + raise ValueError('enclosure too wide to separate the grid point') + return lo, hi diff --git a/research/selected-k8-endpoint-contractions/references/construct.py b/research/selected-k8-endpoint-contractions/references/construct.py new file mode 100644 index 0000000000..5600f92cbb --- /dev/null +++ b/research/selected-k8-endpoint-contractions/references/construct.py @@ -0,0 +1,37 @@ +# SPDX-License-Identifier: Apache-2.0 +# Prepared for 1337isnot1337 with substantial OpenAI Codex assistance. +"""Twelve literal frame edits; scalar program and every other field preserved.""" +import argparse,copy,gzip,hashlib,importlib.util,json +from collections import Counter +from pathlib import Path +BASE='c2b294300760e1fd6eeab8c22c4d13e4633dca40e52cac8da0d68163a76e3ca8' +TARGET='f64e0942edc5eb2d45b0a3b068ba942436f35ba9a077ff53d7e4424d1617b2cd' +HERE=Path(__file__).resolve().parent + +def build(path,promotion): + raw=gzip.decompress(path.read_bytes()) + if hashlib.sha256(raw).hexdigest()!=BASE:raise ValueError('source content pin') + w=json.loads(raw);base=copy.deepcopy(w);recipe=json.loads((HERE/'data/END-RECIPE.json').read_bytes()) + if [x[0] for x in recipe['ends']]!=[574,575]:raise ValueError('end sites') + for q,old,new in recipe['ends']: + if w['helper_final'][str(q)]!=old:raise ValueError('old end') + w['helper_final'][str(q)]=new + for i,old,new in recipe['B_frames']: + if w['B'][i][-1]!=old:raise ValueError('old B frame') + w['B'][i][-1]=new + for i,k,old,new in recipe['early_cleanup']: + if w['early_cleanup'][i]!=[k,old]:raise ValueError('old early tail') + w['early_cleanup'][i][1]=new + s=importlib.util.spec_from_file_location('credited_promotion',promotion);m=importlib.util.module_from_spec(s);s.loader.exec_module(m) + H=Counter({int(k):v for k,v in base['report']['local_profile'].items()});H.subtract(m.chain_profile(base));H.update(m.chain_profile(w));H=+H + w['report'].update(local_profile={str(k):v for k,v in sorted(H.items())},local_rank_mass=sum(k*v for k,v in H.items()),width_inventory={str(k):v for k,v in sorted(m.widths(w).items())}) + data=json.dumps(w,sort_keys=True,separators=(',',':')).encode() + if hashlib.sha256(data).hexdigest()!=TARGET:raise ValueError('constructed word pin') + for section in ('A','cut','B','precondition','cleanup'): + if [e[:-1] for e in w[section]]!=[e[:-1] for e in base[section]]:raise ValueError('scalar changed') + return data + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--input',type=Path,required=True);ap.add_argument('--promotion',type=Path,required=True);ap.add_argument('--output',type=Path,required=True);a=ap.parse_args() + if a.output.exists():raise ValueError('output exists') + data=build(a.input,a.promotion);a.output.write_bytes(gzip.compress(data,mtime=0));print('PASS_K8_RANK7_TWELVE_FRAME_CONSTRUCTION') diff --git a/research/selected-k8-endpoint-contractions/references/frame_model.py b/research/selected-k8-endpoint-contractions/references/frame_model.py new file mode 100644 index 0000000000..33cfb4f404 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/references/frame_model.py @@ -0,0 +1,434 @@ +"""Complete frame-assignment model of a fixed native complex word (standard library only). + +The frame contract is the one checked by research/gauge44-frames-x/independent/audit_local.py: + +* every register has a fixed start frame and a fixed end frame; +* an A, B or tail gate has one frame, shared by its registers, and frames are monotone + (nested) along every register's event sequence; +* centre registers equal their centre frame, and targets their target level, at the start of B; +* for every low-end helper q, every register k in q's inverse-row or dirt-column cone has its + end-of-B frame inside q's end frame; +* each strict climb of dimension d along a register pays one child of rank d, and the eight + centre descents are fixed. + +The scalar program (gate list, order, registers, coefficients, cut, precondition, cleanup) is +fixed. Only the frames of A, B and early-cleanup (tail) gates vary. A climb into a centre or +target pin at the start of B is admitted and charged; the contract requires it to be zero, so +this only enlarges the feasible set. +""" +import gzip +import json +from collections import defaultdict +from fractions import Fraction as F + +H = 9 +FULL = tuple(1 << i for i in range(H - 1, -1, -1)) + + +def basis(vs): + piv = {} + for a in vs: + while a: + bit = a.bit_length() - 1 + if bit in piv: + a ^= piv[bit] + else: + piv[bit] = a + break + for k in sorted(piv): + for j in piv: + if j > k and piv[j] >> k & 1: + piv[j] ^= piv[k] + return tuple(piv[k] for k in sorted(piv, reverse=True)) + + +def contained(a, b): + return basis(list(a) + list(b)) == tuple(b) + + +def join(frames): + return basis([x for f in frames for x in f]) + + +def meet(a, b): + """Zassenhaus intersection of two subspaces of F_2^H.""" + rows = [(u << H) | u for u in a] + [x << H for x in b] + return basis([r for r in basis(rows) if r >> H == 0]) + + +def interval(lo, hi): + """Every subspace F with lo <= F <= hi, by closure over the quotient hi/lo.""" + assert contained(lo, hi), (lo, hi) + comp, cur = [], list(lo) + for x in hi: + if len(basis(cur + [x])) > len(basis(cur)): + comp.append(x) + cur.append(x) + k = len(comp) + assert k <= 4, 'quotient dimension above 4 is not enumerated' + vectors = list(range(1, 1 << k)) + out = [] + for mask in range(1 << len(vectors)): + chosen = {vectors[i] for i in range(len(vectors)) if mask >> i & 1} + if all((a ^ b) in chosen for a in chosen for b in chosen if a != b): + lifted = [] + for a in chosen: + x = 0 + for i in range(k): + if a >> i & 1: + x ^= comp[i] + lifted.append(x) + out.append(basis(list(lo) + lifted)) + assert len(set(out)) == len(out) + return sorted(out, key=lambda f: (len(f), f)) + + +def registers(e): + return tuple(e[1:3]) if e[0] == 'add' else tuple(e[1:2]) + + +def apply(e, rows, dual=False): + if e[0] == 'add': + t, s = e[1:3] + q = F(e[3], e[4]) + if dual: + t, s, q = s, t, -q + dst = rows[t] + for k, x in list(rows[s].items()): + a = dst.get(k, F(0)) + q * x + if a: + dst[k] = a + else: + dst.pop(k, None) + elif e[0] == 'scale': + t = e[1] + q = F(e[2], e[3]) + if dual: + q = 1 / q + rows[t] = {k: q * x for k, x in rows[t].items()} + else: + raise RuntimeError('unknown scalar primitive') + + +def invert(e): + r = list(e) + if r[0] == 'add': + r[3] = -r[3] + else: + r[2], r[3] = r[3], r[2] + return r + + +def cone_ceilings(w, n, v, low_ends): + """End-of-B ceilings implied by the low-end cone conditions of audit_local.py.""" + ident = lambda: [{k: F(1)} for k in range(n)] + main = w['A'] + w['cut'] + w['B'] + raw = ident() + for e in main: + apply(e, raw) + dirt = [{} for _ in range(n)] + for y in range(v, 2 * v): + dirt[y] = {k: a for k, a in raw[y].items() if k >= 2 * v} + for e in w['precondition']: + apply(e, dirt) + compensation = [['add', y, k, -a.numerator, a.denominator, []] + for y in range(v, 2 * v) for k, a in sorted(dirt[y].items())] + prefix = w['precondition'] + compensation + main + p, pinv = ident(), ident() + for e in prefix: + apply(e, p) + for e in reversed(prefix): + apply(invert(e), pinv) + holders = defaultdict(set) + for k in range(n): + for j in p[k]: + holders[j].add(k) + ceil = {} + for q, U in low_ends.items(): + for k in set(pinv[q]) | holders[q]: + if k != q: + ceil[k] = meet(ceil.get(k, FULL), U) + return ceil + + +class Model: + """Event graph, complete domains and components of a native complex word.""" + + def __init__(self, w): + rep = w['report'] + self.v, self.R = v, R = rep['v'], rep['R'] + assert rep['h'] == H + self.n = n = 2 * v + R + end = [FULL] * v + [basis([x for x in range(1, 1 << H) if (x & p).bit_count() % 2 == 0]) + for p in w['ports']] + [FULL] * R + low = {int(q): basis(U) for q, U in w.get('helper_final', {}).items()} + for q, U in low.items(): + assert 2 * v <= q < n + end[q] = U + start = [(p,) for p in w['ports']] + [()] * (v + R) + for q, U in w.get('start_extra', {}).items(): + assert 2 * v <= int(q) < n + start[int(q)] = basis(U) + early = w.get('early_cleanup', []) + assert len({i for i, _ in early}) == len(early) + tail = [w['cleanup'][i][:-1] + [U] for i, U in early] + lev = {int(t): basis(U) for t, U in w.get('target_levels', {}).items()} + pins = {q: basis(U) for q, U in zip(w['centers'], w['center_frames'])} + assert len(pins) == 8 + for t in range(v): + assert v + t not in pins + pins[v + t] = lev.get(t, ()) + self.ceil = cone_ceilings(w, n, v, low) + # centre descents: fixed children, recorded separately (audit_local.py rule) + self.centre_children = [] + for q, U in zip(w['centers'], w['center_frames']): + U = basis(U) + served = {lev.get(e[1] - v, ()) for e in w['cut'] if e[2] == q} + for T in sorted(served, key=lambda x: -len(x)): + assert contained(T, U) + if T != U: + self.centre_children.append(len(U) - len(T)) + U = T + # nodes: ('S',q) start, ('G',i) gate, ('P',q) start-of-B pin, ('E',q) end + gates = [('A', e) for e in w['A']] + [('B', e) for e in w['B']] + [('T', e) for e in tail] + self.gates = gates + self.given = [basis(e[-1]) for _, e in gates] + self.regs = [registers(e) for _, e in gates] + for rs in self.regs: + assert len(set(rs)) == len(rs) and all(0 <= q < n for q in rs) + nA, nB = len(w['A']), len(w['B']) + self.nA, self.nB = nA, nB + fixed = {} + for q in range(n): + fixed[('S', q)] = start[q] + fixed[('E', q)] = end[q] + for q, U in pins.items(): + fixed[('P', q)] = U + chains = defaultdict(list) + for q in range(n): + chains[q].append(('S', q)) + boundary = {} # register -> index in its chain of the last pre-tail node + for i, rs in enumerate(self.regs): + if i == nA: + for q in pins: + chains[q].append(('P', q)) + if i == nA + nB: + for q in range(n): + boundary[q] = len(chains[q]) - 1 + for q in rs: + chains[q].append(('G', i)) + if len(gates) == nA: + for q in pins: + chains[q].append(('P', q)) + if len(gates) <= nA + nB: + for q in range(n): + boundary[q] = len(chains[q]) - 1 + for q in range(n): + chains[q].append(('E', q)) + self.chains = chains + self.fixed_frames = fixed + # forward joins and backward meets + order = [('S', q) for q in range(n)] + for i in range(len(gates)): + if i == nA: + order += [('P', q) for q in pins] + order.append(('G', i)) + if len(gates) == nA: + order += [('P', q) for q in pins] + order += [('E', q) for q in range(n)] + position = {node: k for k, node in enumerate(order)} + pred = defaultdict(list) + succ = defaultdict(list) + for q, ch in chains.items(): + for a, b in zip(ch, ch[1:]): + assert position[a] < position[b] + succ[a].append((q, b)) + pred[b].append((q, a)) + lo, hi = {}, {} + for node in order: + if node in fixed: + lo[node] = fixed[node] + for q, a in pred[node]: + assert contained(lo[a], fixed[node]), ('fixed frame below forward join', node) + else: + lo[node] = join(lo[a] for q, a in pred[node]) + ceil_at = defaultdict(list) # node -> ceilings applying to that node + for q, k in boundary.items(): + if q in self.ceil: + ceil_at[chains[q][k]].append(self.ceil[q]) + for node in reversed(order): + if node in fixed: + hi[node] = fixed[node] + else: + U = FULL + for q, b in succ[node]: + U = meet(U, hi[b]) + for C in ceil_at[node]: + U = meet(U, C) + hi[node] = U + assert contained(lo[node], hi[node]), ('empty domain', node) + for node, Cs in ceil_at.items(): + if node in fixed: + assert all(contained(fixed[node], C) for C in Cs), ('fixed frame above a cone ceiling', node) + self.lo, self.hi = lo, hi + self.domain = {} + for i in range(len(gates)): + node = ('G', i) + if lo[node] != hi[node]: + self.domain[node] = interval(lo[node], hi[node]) + assert self.given[i] in self.domain[node] + else: + assert self.given[i] == lo[node], ('given frame differs from forced frame', i) + # edges, merged by endpoint pair, with integer multiplicity + mult = defaultdict(int) + for q, ch in chains.items(): + for a, b in zip(ch, ch[1:]): + mult[(a, b)] += 1 + self.edges = dict(mult) + + def frame_of(self, node, assignment): + if node in self.fixed_frames: + return self.fixed_frames[node] + if node in self.domain: + return assignment[node] + return self.lo[node] + + def baseline(self): + return {('G', i): self.given[i] for i in range(len(self.gates)) if ('G', i) in self.domain} + + def profile(self, assignment): + """Paid children of an assignment (graph climbs plus fixed centre descents).""" + count = defaultdict(int) + for (a, b), m in self.edges.items(): + A, B = self.frame_of(a, assignment), self.frame_of(b, assignment) + if not contained(A, B): + raise ValueError(('non-monotone', a, b)) + d = len(B) - len(A) + if d: + count[d] += m + for d in self.centre_children: + count[d] += 1 + return dict(sorted(count.items())) + + def components(self): + parent = {node: node for node in self.domain} + + def find(x): + while parent[x] != x: + parent[x] = parent[parent[x]] + x = parent[x] + return x + for (a, b) in self.edges: + if a in self.domain and b in self.domain: + parent[find(a)] = find(b) + groups = defaultdict(list) + for node in self.domain: + groups[find(node)].append(node) + comps = [sorted(g, key=lambda x: x[1]) for g in groups.values()] + return sorted(comps, key=lambda c: c[0][1]) + + def component_problem(self, comp): + """Unary and pairwise rank-count potentials of one component. + + Costs are integer vectors c[0..H]; c[d] counts children of rank d. + Returns (labels, unary, pairs): unary[node][F] collects the edges from the node + to fixed or forced neighbours, and pairs[(a,b)][(F,G)] the merged edges between + two members (only nested pairs F <= G appear). Edges with no free endpoint + belong to no component; fixed_profile() counts them. + """ + members = set(comp) + labels = {node: self.domain[node] for node in comp} + zero = lambda: [0] * (H + 1) + unary = {node: {Fr: zero() for Fr in labels[node]} for node in comp} + pairs = {} + for (a, b), m in self.edges.items(): + ina, inb = a in members, b in members + if not (ina or inb): + continue + if ina and inb: + table = {} + for Fa in labels[a]: + for Fb in labels[b]: + if contained(Fa, Fb): + c = zero() + d = len(Fb) - len(Fa) + if d: + c[d] += m + table[(Fa, Fb)] = c + pairs[(a, b)] = table + elif ina: + Fb = self.frame_of(b, None) + for Fa in labels[a]: + assert contained(Fa, Fb) + d = len(Fb) - len(Fa) + if d: + unary[a][Fa][d] += m + else: + Fa = self.frame_of(a, None) + for Fb in labels[b]: + assert contained(Fa, Fb) + d = len(Fb) - len(Fa) + if d: + unary[b][Fb][d] += m + return labels, unary, pairs + + def fixed_profile(self): + """Children on edges between two fixed or forced nodes, plus centre descents.""" + count = defaultdict(int) + for (a, b), m in self.edges.items(): + if a in self.domain or b in self.domain: + continue + A, B = self.frame_of(a, None), self.frame_of(b, None) + assert contained(A, B) + d = len(B) - len(A) + if d: + count[d] += m + for d in self.centre_children: + count[d] += 1 + return count + + +def lp(labels, unary, pairs): + """Local-polytope LP of one component: min c.z, A z = rhs, z >= 0. + + Rows: ('N', node) normalisation (rhs 1); ('M', a, b, side, frame) marginal of the + merged edge (a, b) at endpoint side 0 (a) or 1 (b) (rhs 0). + Columns: ('x', node, frame) and ('y', a, b, frame_a, frame_b) with F_a <= F_b. + Every literal legal assignment gives a 0/1 feasible point. + """ + rows = [('N', node) for node in sorted(labels)] + for (a, b) in sorted(pairs): + rows += [('M', a, b, 0, Fa) for Fa in labels[a]] + rows += [('M', a, b, 1, Fb) for Fb in labels[b]] + index = {r: i for i, r in enumerate(rows)} + rhs = [1 if r[0] == 'N' else 0 for r in rows] + touching = defaultdict(list) + for (a, b) in sorted(pairs): + touching[a].append((a, b, 0)) + touching[b].append((a, b, 1)) + cols = [] + for node in sorted(labels): + for Fr in labels[node]: + entries = [(index[('N', node)], 1)] + entries += [(index[('M', a, b, side, Fr)], -1) for a, b, side in touching[node]] + cols.append((('x', node, Fr), unary[node][Fr], entries)) + for (a, b) in sorted(pairs): + for (Fa, Fb), c in sorted(pairs[(a, b)].items()): + cols.append((('y', a, b, Fa, Fb), c, + [(index[('M', a, b, 0, Fa)], 1), (index[('M', a, b, 1, Fb)], 1)])) + return rows, rhs, cols + + +def assignment_cost(labels, unary, pairs, assignment): + c = [0] * (H + 1) + for node in labels: + for d, x in enumerate(unary[node][assignment[node]]): + c[d] += x + for (a, b), table in pairs.items(): + for d, x in enumerate(table[(assignment[a], assignment[b])]): + c[d] += x + return c + + +def load_word(raw_gz): + return json.loads(gzip.decompress(raw_gz)) diff --git a/research/selected-k8-endpoint-contractions/references/gen_duals.py b/research/selected-k8-endpoint-contractions/references/gen_duals.py new file mode 100644 index 0000000000..bd85022a44 --- /dev/null +++ b/research/selected-k8-endpoint-contractions/references/gen_duals.py @@ -0,0 +1,149 @@ +"""Nominate symbolic exact duals for every component (solver side; not part of the proof). + +Needs numpy, scipy and highspy. HiGHS solves each component's LP at the excluded +exponent; its optimal basis is then inverted for each rank coordinate C_2..C_9 +separately, so every dual entry is a rational linear form in those charges. The +rational values are checked exactly here and again, independently of any solver, +by verify.py. Output: data/DUALS.json.gz (deterministic). +""" +import argparse +import gzip +import json +import sys +from fractions import Fraction as F +from pathlib import Path + +import highspy +import numpy as np +import scipy.sparse as sp +import scipy.sparse.linalg as spla + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +import model as M # noqa: E402 +import verify as V # noqa: E402 + +RANKS = range(2, M.H + 1) + + +def numeric_charges(b): + """C_d / (b * 73^b) as floats; only the solver uses these.""" + x = float(b) + return [0.0, 0.0] + [(d ** (1 - x) - d) / x for d in RANKS] + + +def solve(rows, rhs, cols, gamma): + nr, nc = len(rows), len(cols) + start, index, value = [0], [], [] + cost = [] + for _, c, entries in cols: + cost.append(sum(c[d] * gamma[d] for d in range(len(c)))) + for i, a in sorted(entries): + index.append(i) + value.append(float(a)) + start.append(len(index)) + lp = highspy.HighsLp() + lp.num_col_, lp.num_row_ = nc, nr + lp.col_cost_ = np.array(cost) + lp.col_lower_ = np.zeros(nc) + lp.col_upper_ = np.full(nc, highspy.kHighsInf) + lp.row_lower_ = np.array(rhs, dtype=float) + lp.row_upper_ = np.array(rhs, dtype=float) + lp.a_matrix_.format_ = highspy.MatrixFormat.kColwise + lp.a_matrix_.start_ = np.array(start, dtype=np.int32) + lp.a_matrix_.index_ = np.array(index, dtype=np.int32) + lp.a_matrix_.value_ = np.array(value) + h = highspy.Highs() + h.setOptionValue('output_flag', False) + h.setOptionValue('presolve', 'off') + h.setOptionValue('solver', 'simplex') + h.passModel(lp) + h.run() + assert h.getModelStatus() == highspy.HighsModelStatus.kOptimal, h.modelStatusToString(h.getModelStatus()) + basis = h.getBasis() + sol = h.getSolution() + return h.getInfo().objective_function_value, basis, list(sol.col_value) + + +def symbolic_duals(rows, cols, basis): + basic_cols = [j for j in range(len(cols)) if basis.col_status[j] == highspy.HighsBasisStatus.kBasic] + active_rows = [i for i in range(len(rows)) if basis.row_status[i] != highspy.HighsBasisStatus.kBasic] + assert len(basic_cols) == len(active_rows), (len(basic_cols), len(active_rows)) + rpos = {i: k for k, i in enumerate(active_rows)} + data, ri, ci = [], [], [] + for kc, j in enumerate(basic_cols): + for i, a in cols[j][2]: + if i in rpos: + # transpose: row = basic column, column = active row + ri.append(kc) + ci.append(rpos[i]) + data.append(float(a)) + At = sp.csc_matrix((data, (ri, ci)), shape=(len(basic_cols), len(active_rows))) + lu = spla.splu(At) + q = {} + for d in RANKS: + rhs_d = np.array([float(cols[j][1][d]) for j in basic_cols]) + sol = lu.solve(rhs_d) + for k, i in enumerate(active_rows): + x = F(float(sol[k])).limit_denominator(1 << 20) + if x: + q.setdefault(i, {})[d] = x + # exact check on the basic columns: A_B^T q == c_B coordinate-wise + for j in basic_cols: + key, c, entries = cols[j] + for d in RANKS: + s = sum((a * q.get(i, {}).get(d, 0) for i, a in entries), F(0)) + assert s == c[d], ('rationalised dual is not exact on a basic column', key, d, s, c[d]) + return q + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--output', type=Path, default=HERE / 'data' / 'DUALS.json.gz') + args = parser.parse_args() + word, src = V.load_selected_word(V.REPO) + model = M.Model(word) + b = V.excluded_exponent(V.REPO) + gamma = numeric_charges(b) + comps = model.components() + out = {'excluded_b': f'{b.numerator}/{b.denominator}', 'word_content_sha256': src['content_sha256'], + 'components': []} + base_total = [0] * (M.H + 1) + for n, comp in enumerate(comps): + labels, unary, pairs = model.component_problem(comp) + rows, rhs, cols = M.lp(labels, unary, pairs) + base = M.assignment_cost(labels, unary, pairs, {node: model.baseline()[node] for node in comp}) + base_num = sum(base[d] * gamma[d] for d in range(len(base))) + obj, basis, x = solve(rows, rhs, cols, gamma) + gap = base_num - obj + if gap > 1e-7: + frac = [cols[j][0] for j in range(len(cols)) if 1e-9 < x[j] < 1 - 1e-9] + print('component', n, 'LP below baseline by', gap, 'fractional columns', len(frac), flush=True) + q = symbolic_duals(rows, cols, basis) + dual_obj = [0] * (M.H + 1) + for i, vec in q.items(): + if rhs[i]: + for d, x_ in vec.items(): + dual_obj[d] += x_ * rhs[i] + neg = 0 + for key, c, entries in cols: + r = sum((c[d] - sum((a * q.get(i, {}).get(d, 0) for i, a in entries), F(0))) * gamma[d] for d in RANKS) + if r < -1e-9: + neg += 1 + same = all(dual_obj[d] == base[d] for d in RANKS) + print(f'component {n}: nodes={len(comp)} rows={len(rows)} cols={len(cols)} ' + f'lp={obj:.9f} base={base_num:.9f} identity={same} negative_reduced={neg}', flush=True) + for d in RANKS: + base_total[d] += base[d] + out['components'].append({ + 'first': json.dumps(comp[0]), 'nodes': len(comp), + 'duals': {json.dumps(rows[i]): {str(d): f'{x_.numerator}/{x_.denominator}' for d, x_ in sorted(vec.items())} + for i, vec in sorted(q.items())}}) + args.output.parent.mkdir(parents=True, exist_ok=True) + payload = json.dumps(out, sort_keys=True, separators=(',', ':')).encode() + args.output.write_bytes(gzip.compress(payload, mtime=0)) + print('wrote', args.output, len(payload), 'bytes; components', len(comps)) + + +if __name__ == '__main__': + main() diff --git a/research/selected-k8-endpoint-contractions/test_package.py b/research/selected-k8-endpoint-contractions/test_package.py new file mode 100644 index 0000000000..dea3a0175e --- /dev/null +++ b/research/selected-k8-endpoint-contractions/test_package.py @@ -0,0 +1,204 @@ +#!/usr/bin/env python3 +"""Native fixtures, endpoint/idle-accounting controls and external corruptions. + +Adapts Gareth Davidson PR1671 (11fbeaf34609147c124323c2f5e74fc450dad931). +Gareth Davidson with OpenAI Codex assistance. Apache-2.0. +""" +from contextlib import redirect_stdout +import copy +from fractions import Fraction as Q +import gzip +from hashlib import sha256 +import importlib.util +import io +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent + + +def module(name, path): + spec = importlib.util.spec_from_file_location(name, path) + result = importlib.util.module_from_spec(spec) + spec.loader.exec_module(result) + return result + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def fails(action, text): + try: + action() + except (ValueError, RuntimeError, AssertionError) as error: + need(text in str(error), "wrong failure: "+str(error)) + else: + raise ValueError("control did not reject: "+text) + + +def inventory(path): + return {str(f.relative_to(path)): sha256(f.read_bytes()).hexdigest() + for f in path.rglob("*") if f.is_file()} + + +def main(): + V = module("tested_k8_primary", HERE / "verify.py") + I = module("tested_k8_independent", HERE / "independent.py") + U = V.U + U.source_bindings() + M, C, auditor = V.local("model"), U.retained("ceiling.py"), U.retained("audit_local.py") + P = V.local("materialize") + word = U.word() + model = M.Model(word) + duals = U.duals() + expected = U.parse((HERE/"EXPECTED.json").read_bytes()) + cap = Q(expected["a_bracket"][1]) + assignment, profile = P.primal(U, model) + bounds = {"cap": V.charges(C, cap), "target": V.charges(C, V.TARGET)} + controls = [] + with tempfile.TemporaryDirectory(prefix="k8-frame-controls-") as directory: + root = Path(directory) + # The existing all-column auditor checks scalar endpoints in both + # orientations, exact frame bills and the low-end cones independently. + native_profiles = {} + credited = model.baseline() + recipe = U.parse((HERE/"references/END-RECIPE.json").read_bytes()) + for q, old, new in recipe["ends"]: + need(list(model.original_caps[q]) == old, "credited old endpoint") + credited[("E",q)] = M.M.basis(new) + for i, old, new in recipe["B_frames"]: + need(word["B"][i][-1] == old, "credited old B frame") + credited[("G",model.nA+i)] = M.M.basis(new) + for i, k, old, new in recipe["early_cleanup"]: + need(word["early_cleanup"][i] == [k,old], "credited old early tail") + credited[("G",model.nA+model.nB+i)] = M.M.basis(new) + for label, chosen in (("baseline", model.baseline()), ("credited-two-ends", credited), + ("four-end-optimum", assignment)): + fixture = P.native_word(word,model,chosen) + for section in ("A","cut","B","precondition","cleanup"): + need([e[:-1] for e in fixture[section]] == [e[:-1] for e in word[section]], + "native scalar chronology unchanged") + chosen_profile = model.profile(chosen) + path, receipt = root/(label+".json.gz"), root/(label+"-audit.json") + path.write_bytes(gzip.compress(U.canonical(fixture), mtime=0)) + with redirect_stdout(io.StringIO()): + auditor.run(path, receipt) + checked = json.loads(receipt.read_text()) + need(checked["status"] == "PASS_INDEPENDENT_EXACT_FORWARD_AND_DUAL_ENDPOINT_FRAMES_ENTRANCES_CONES", + "legacy native auditor") + need(checked["checked_columns"] == 704 and checked["local_profile"] == fixture["report"]["local_profile"], + "all-column native fixture coverage") + native_profiles[label] = chosen_profile + need(len({tuple(sorted(p.items())) for p in native_profiles.values()})==3, + "three distinct native profiles") + controls.append("three-704-column-both-orientation-native-audits") + + # A reduced local mass is exposed idle work, not free removed work. + correct=C.relax(profile,73,896,9,64,V.TARGET) + fake_upper=(sum((n*C.child_cost(r,73,V.TARGET)[1] for r,n in profile.items()),Q(0)) + +Q(1646,51)*C.child_cost(51,73,V.TARGET)[1])/Q(896,9) + need(correct[0]>1 and fake_upper<1,"missing four idle ranks creates a false target pass") + controls.append("omitted-idle-mass-false-positive") + + broken=copy.deepcopy(model) + endpoint=("E",574) + broken.domain[endpoint]=[model.original_caps[574]] + fails(lambda:V.check_duals(M,broken,duals,assignment,profile,bounds),"complete frame interval") + controls.append("omitted-feasible-contracted-end") + + broken = copy.deepcopy(model) + node = next(n for n in broken.domain if len(broken.domain[n]) > 2) + broken.domain[node].pop() + fails(lambda: V.check_duals(M, broken, duals, assignment, profile, bounds), "complete frame interval") + controls.append("omitted-feasible-frame-choice") + + broken = copy.deepcopy(model) + broken.centre_children = [] + fails(lambda: V.check_duals(M, broken, duals, assignment, profile, bounds), "full fixed and variable cost coverage") + controls.append("omitted-centre-work") + + broken = copy.deepcopy(model) + edge = next(e for e in broken.edges if e[0] in broken.domain and e[1] in broken.domain) + del broken.edges[edge] + fails(lambda: V.check_duals(M, broken, duals, assignment, profile, bounds), "dual row domain") + controls.append("omitted-common-gate-edge") + + old = I.isqrt + I.isqrt = lambda n: old(n)+3 + I.child.cache_clear() + fails(I.main, "square-root oracle calibration") + I.isqrt = old + I.child.cache_clear() + controls.append("invalid-square-root-oracle") + + target = root/"relocated" + shutil.copytree(HERE, target, ignore=shutil.ignore_patterns("__pycache__", "*.pyc")) + def run(script="verify.py", error=None): + result = subprocess.run([sys.executable, "-I", "-O", "-B", str(target/script)], + cwd=directory, text=True, capture_output=True, timeout=120) + if error is None: + need(result.returncode == 0 and "PASS_" in result.stdout, "relocated replay: "+result.stderr) + else: + need(result.returncode != 0 and error in result.stderr, "wrong corruption rejection: "+result.stderr) + before = inventory(target) + for f in target.rglob("*"): + if f.is_file(): + f.chmod(0o444) + run() + run("independent.py") + need(inventory(target) == before, "read-only package changed") + controls.append("both-optimized-read-only-relocated-checkers") + for f in target.rglob("*"): + if f.is_file(): + f.chmod(0o644) + + def mutate(label, file, change, error): + path = target/file + raw = path.read_bytes() + path.write_bytes(change(raw)) + try: + run(error=error) + controls.append(label) + finally: + path.write_bytes(raw) + def edit(raw, change): + data = json.loads(raw) + change(data) + return U.canonical(data) + def change_dual(raw, change): + return gzip.compress(edit(gzip.decompress(raw), change), mtime=0) + mutate("omitted-dual-component", "DUALS.json.gz", + lambda raw: change_dual(raw, lambda x: x["components"].pop()), "component coverage") + def overstate(x): + record = x["components"][0]["duals"] + key = next(k for k in record if json.loads(k)[0] == "N") + record[key]["1"] = str(Q(record[key].get("1", "0"))+1) + mutate("overstated-dual-objective", "DUALS.json.gz", + lambda raw: change_dual(raw, overstate), "negative or uncertified reduced cost") + mutate("omitted-primal-node", "PRIMAL.json.gz", + lambda raw: change_dual(raw, lambda x: x["assignment"].pop(next(iter(x["assignment"])))), + "complete primal node coverage") + mutate("false-idle-mass", "EXPECTED.json", + lambda raw: edit(raw, lambda x: x.update(idle_mass=1646)), "receipt mismatch") + mutate("false-gate-coverage", "EXPECTED.json", + lambda raw: edit(raw, lambda x: x.update(free_gates=1740)), "receipt mismatch") + mutate("missing-source-inventory", "SOURCES.json", + lambda raw: edit(raw, lambda x: x["files"].pop()), "source inventory") + mutate("retained-model-drift", "references/frame_model.py", lambda raw: raw+b"\n", "retained source SHA256") + mutate("selected-word-drift", "references/WORD.json.gz", lambda raw: raw+b"\n", "retained source SHA256") + mutate("duplicate-receipt-key", "EXPECTED.json", lambda raw: b'{"x":0,"x":1}', "duplicate JSON key") + mutate("nonfinite-receipt", "EXPECTED.json", lambda raw: b'{"x":NaN}', "noninteger/nonfinite JSON number") + need(inventory(target) == before, "corruptions not restored") + print("PASS_K8_ENDPOINT_PACKAGE_CONTROLS", "checks="+str(len(controls))) + print(json.dumps(controls)) + print("native_profiles="+json.dumps(native_profiles, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/selected-k8-endpoint-contractions/verify.py b/research/selected-k8-endpoint-contractions/verify.py new file mode 100644 index 0000000000..32d245f0af --- /dev/null +++ b/research/selected-k8-endpoint-contractions/verify.py @@ -0,0 +1,177 @@ +#!/usr/bin/env python3 +"""Complete joint endpoint/frame bound, with variable-mass excess prices. + +Adapts Gareth Davidson PR1671, mathematical commit 11fbeaf34609147c124323c2f5e74fc450dad931. +Gareth Davidson with OpenAI Codex assistance. Apache-2.0. +""" +import argparse +from collections import Counter +from fractions import Fraction as Q +import importlib.util +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location("k8_common", HERE / "common.py") +U = importlib.util.module_from_spec(spec) +spec.loader.exec_module(U) +need = U.need +RANKS = range(1, 10) +BASE_LO = Q(1690054109088, 10**15) +BASE_HI = Q(1690054109089, 10**15) +TARGET = Q(21, 20) * BASE_HI + + +def span_mask(frame): + values = {0} + for vector in frame: + values |= {x ^ vector for x in values} + return sum(1 << x for x in values) + + +def graph_receipt(model): + nodes = [[list(n), span_mask(model.lo[n]), span_mask(model.hi[n])] for n in sorted(model.lo)] + domains = [[list(n), sorted(span_mask(f) for f in model.domain[n])] for n in sorted(model.domain)] + edges = [[list(a), list(b), k] for (a, b), k in sorted(model.edges.items())] + cones = [[q, support] for q, support in sorted(model.cones.items())] + return {"nodes_sha256": U.digest(nodes), "domains_sha256": U.digest(domains), + "edges_sha256": U.digest(edges), "cones_sha256": U.digest(cones), + "node_count": len(nodes), "edge_count": len(edges), "cone_helpers": len(cones), "cone_edges": len(model.cone_edges)} + + +def subspace_count(k): + total = 0 + for d in range(k+1): + top = bottom = 1 + for j in range(d): + top *= (1 << (k-j)) - 1 + bottom *= (1 << (d-j)) - 1 + total += top // bottom + return total + + +def charges(C, a): + costs = {d: C.child_cost(d, 73, a) for d in RANKS} + idle = C.child_cost(51, 73, a) + # Local mass varies. Reprice every released unit as idle, not as saved work. + return {d: (73*(costs[d][0]-Q(d,51)*idle[1]), + 73*(costs[d][1]-Q(d,51)*idle[0])) for d in RANKS} + + +def lower(vec, bounds): + return sum((value * bounds[d][0 if value > 0 else 1] + for d, value in vec.items() if value), Q(0)) + + +def check_duals(M, model, data, assignment, profile, all_bounds): + comps = model.components() + need(len(data["components"]) == len(comps), "component coverage") + stats = Counter() + total = Counter({d:n for d,n in model.fixed_profile().items() if n}) + distinct_reduced = set() + for comp, record in zip(comps, data["components"]): + need(record["first"] == json.dumps(comp[0]) and record["nodes"] == len(comp), "component identity") + labels, unary, pairs = model.component_problem(comp) + for node in comp: + domain = labels[node] + k = len(model.hi[node])-len(model.lo[node]) + need(len(domain) == len(set(domain)) == subspace_count(k), "complete frame interval") + need(all(M.M.contained(model.lo[node], f) and M.M.contained(f, model.hi[node]) for f in domain), + "frame outside interval") + rows, rhs, cols = M.lp(labels, unary, pairs) + keys = [json.dumps(row) for row in rows] + need(set(record["duals"]) <= set(keys), "dual row domain") + dual = [] + for key in keys: + vec = {int(d): Q(v) for d, v in record["duals"].get(key, {}).items()} + need(all(d in RANKS for d in vec), "dual rank coordinate") + dual.append(vec) + for _, cost, entries in cols: + residual = {d: Q(cost[d]) for d in RANKS} + for row, multiplier in entries: + for d, value in dual[row].items(): + residual[d] -= multiplier*value + if any(residual.values()): + for bounds in all_bounds.values(): + need(lower(residual, bounds) > 0, "negative or uncertified reduced cost") + stats["positive"] += 1 + else: + stats["zero"] += 1 + distinct_reduced.add(tuple(str(residual[d]) for d in RANKS)) + objective = {d: sum((rhs[i]*v.get(d, 0) for i, v in enumerate(dual)), Q(0)) for d in RANKS} + baseline = M.assignment_cost(labels, unary, pairs, {n: assignment[n] for n in comp}) + need(all(objective[d] == baseline[d] for d in RANKS), "dual/primal coefficient identity") + total.update({d: baseline[d] for d in range(1, 10) if baseline[d]}) + stats.update(rows=len(rows), columns=len(cols), components=1) + need(dict(total) == profile, "full fixed and variable cost coverage") + stats["distinct_reduced_vectors"] = len(distinct_reduced) + return dict(stats) + + +def local(name): + spec=importlib.util.spec_from_file_location("endpoint_"+name,HERE/(name+".py")) + result=importlib.util.module_from_spec(spec) + spec.loader.exec_module(result) + return result + + +def run(): + U.source_bindings() + word=U.word() + M,C,P=local("model"),U.retained("ceiling.py"),local("materialize") + model=M.Model(word) + need(model.profile(model.baseline())==U.PROFILE,"baseline profile") + assignment,profile=P.primal(U,model) + need(profile=={1:2400,2:446,3:416,4:142,5:82,8:8},"optimal profile binding") + lo,hi=C.ceiling(profile,73,896,9,64) + need(BASE_HI1,"ceiling bracket sign") + bills[str(a)]=[str(left-1),str(right-1)] + free_ends=[n for n in model.domain if n[0]=="E"] + need(len(model.original_caps)==78 and len(free_ends)==46,"all endpoint coverage") + need(all(len(model.lo[n])==7 and len(model.hi[n])==8 and len(model.domain[n])==2 + for n in free_ends),"complete binary endpoint domains") + changed_ends=[q for q,cap in sorted(model.original_caps.items()) + if model.frame_of(("E",q),assignment)!=cap] + need(changed_ends==[574,575,580,581],"attaining contracted ends") + return {"schema":"selected-k8-endpoint-contraction-bound-v1", + "status":"PASS_SELECTED_K8_ENDPOINT_CONTRACTION_BOUND","word_sha256":U.WORD_SHA, + "duals_sha256":U.digest(data),"primal_sha256":U.digest(U.primal_data()), + "profile":{str(r):n for r,n in profile.items()},"local_mass":5582,"idle_mass":1650, + "gates":len(model.gates),"free_gates":len(model.domain)-len(free_ends), + "restricted_ends":78,"free_ends":[n[1] for n in free_ends], + "forced_ends":sorted(set(model.original_caps)-{n[1] for n in free_ends}), + "attaining_contracted_ends":changed_ends, + "component_sizes":{str(k):v for k,v in sorted(Counter(map(len,model.components())).items())}, + "domain_sizes":{str(k):v for k,v in sorted(Counter(map(len,model.domain.values())).items())}, + "graph":graph_receipt(model),"duality":stats, + "a_bracket":[str(lo),str(hi)],"kappa_cap":str(hi/(1+hi)),"target_a":str(TARGET), + "ceiling_ratio_upper":str(hi/BASE_LO),"bills":bills, + "scope":"fixed scalar word and entrances; all nested restricted helper ends and gate frames; full idle charge; no global supplier or new kappa"} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-expected", action="store_true") + args = parser.parse_args() + receipt = run() + path = HERE / "EXPECTED.json" + if args.write_expected: + path.write_text(json.dumps(receipt, indent=2, sort_keys=True)+"\n") + else: + need(U.parse(path.read_bytes()) == receipt, "receipt mismatch") + print(receipt["status"], "components="+str(receipt["duality"]["components"]), + "columns="+str(receipt["duality"]["columns"]), "receipt_sha256="+U.digest(receipt)) + + +if __name__ == "__main__": + main() From d47b4b656732f840c9b3252cad5a4efa20924b71 Mon Sep 17 00:00:00 2001 From: Gareth Davidson Date: Wed, 14 Oct 2026 17:35:06 +0100 Subject: [PATCH 2/2] Record pass 33 publication and refreshed upstream validation --- .../README.md | 23 +- .../TASK.json | 222 ++++++++++++++++-- 2 files changed, 213 insertions(+), 32 deletions(-) diff --git a/research/selected-k8-endpoint-contractions/README.md b/research/selected-k8-endpoint-contractions/README.md index d8bba6d6c8..216845b091 100644 --- a/research/selected-k8-endpoint-contractions/README.md +++ b/research/selected-k8-endpoint-contractions/README.md @@ -90,12 +90,23 @@ for the complete constraint screen. It was not a realizable assignment. [Discussion1674](https://github.com/CrocSwap/integer-mult-bounds/discussions/1674) records the scoped claim and outcome; TASK.json retains the card and pins. -The final overlap refresh covered 409 open PRs at 06:38:34 UTC and 330 -discussions at 06:39:18 UTC on 2026-10-14, with complete pagination. -PR1583, PR1090 and PR1671 heads were rechecked. Search covers metadata, -not arbitrary code, and is not a novelty certificate. Main at -`d78fe4bbb6f6b769e39586f8bb3ba8c31a31fd3a` preserved all 19 checked -instruction, selection, replay and source paths and had no package collision. +The publication refresh covered 433 open PRs at 16:32:27 UTC and 622 +Discussions at 16:33:41 UTC on 2026-10-14, with complete pagination. +PR1583, PR1090 and PR1671 retained their exact heads and are now merged. +Search covers metadata, not arbitrary code, and is not a novelty certificate. +Main at `01a65937ece11b56d515c81f039464ae3043c1c1` preserved all 12 +mathematical inputs and the selected record, with no package collision. +Its changed package runner passed a fresh full CPython 3.12 registered replay. +The other changed guidance adds an E8 scope map and CI invalidation details. + +Ross Richardson's intervening `selected-k8-uniform-frame-audit` extends +PR1671 uniformly over a power-price interval with fixed ends. It is +complementary to this variable-end result and is not a certificate input. +The helper-450 emitted audits and the source-independent full-cleanup +obstruction also have distinct scopes; TASK.json records that review. + +Published as [PR1995](https://github.com/CrocSwap/integer-mult-bounds/pull/1995). +Mathematical commit: `73e323159d65c974debb180189694fd59144da5f`. This is the card's bounded endpoint-contract obstruction. It does not supply a construction passing its acceptance gate. No whole hosted diff --git a/research/selected-k8-endpoint-contractions/TASK.json b/research/selected-k8-endpoint-contractions/TASK.json index 417fe7b1f0..85aceac270 100644 --- a/research/selected-k8-endpoint-contractions/TASK.json +++ b/research/selected-k8-endpoint-contractions/TASK.json @@ -218,7 +218,30 @@ "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission.", "matches_total": 43 }, - "final": { + "reviewed_predecessor_heads": [ + { + "headRefOid": "04516881142961cdf97a828fbbc63d72e232a148", + "number": 1583, + "state": "MERGED", + "title": "Audit selected k8 helper endpoint rigidity and rank-preserving failures", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1583" + }, + { + "headRefOid": "b535975a5948afafda984e73c301183a634ff8c8", + "number": 1090, + "state": "MERGED", + "title": "Conditional \u03ba = 0.001672404744903063: rank-seven helper ends on the k8 word", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1090" + }, + { + "headRefOid": "ce130d291f5ab6dd801544886a16f62d42d86118", + "number": 1671, + "state": "MERGED", + "title": "Research: exact complete frame ceiling for the selected k8 word", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1671" + } + ], + "before_pause": { "searched_at": "2026-10-14T06:39:18.689085+00:00", "coverage": { "open_prs": { @@ -236,34 +259,48 @@ "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission.", "matches_total": 6 }, - "reviewed_predecessor_heads": [ + "final": { + "searched_at": "2026-10-14T16:33:41.725170+00:00", + "coverage": { + "open_prs": { + "fetched_at": "2026-10-14T16:32:27.475898+00:00", + "complete_pagination": true, + "records": 433 + }, + "discussions": { + "fetched_at": "2026-10-14T16:33:41.681355+00:00", + "complete_pagination": true, + "records": 622 + } + }, + "warnings": [], + "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission.", + "matches_total": 9 + }, + "intervening_main_review": [ { - "headRefOid": "04516881142961cdf97a828fbbc63d72e232a148", - "number": 1583, - "state": "OPEN", - "title": "Audit selected k8 helper endpoint rigidity and rank-preserving failures", - "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1583" + "package": "research/selected-k8-uniform-frame-audit", + "author": "Ross Richardson", + "scope": "Uniform power-cost optimality and profile rigidity for fixed ends. Does not include variable ends; read as complementary work, not a certificate input." }, { - "headRefOid": "b535975a5948afafda984e73c301183a634ff8c8", - "number": 1090, - "state": "MERGED", - "title": "Conditional \u03ba = 0.001672404744903063: rank-seven helper ends on the k8 word", - "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1090" + "package": "research/selected-k8-catalogue-scope", + "scope": "Navigation/source-bound comparison of the selected inventory with the historical catalogue, not a joint contraction bound." }, { - "headRefOid": "ce130d291f5ab6dd801544886a16f62d42d86118", - "number": 1671, - "state": "OPEN", - "title": "Research: exact complete frame ceiling for the selected k8 word", - "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1671" + "package": "research/k8-hpe450-binding and research/k8-hpe450-forward-audit", + "scope": "Emitted helper 450 restoration/operator binding, not endpoint optimization." + }, + { + "package": "research/r480-source-independent-cleanup", + "scope": "Deferral/covariance of the 402 full-cleanup helpers; these are fixed full in this package." } ] }, "latest_main_check": { - "verified_at_utc": "2026-10-14T06:40:55.601877+00:00", + "verified_at_utc": "2026-10-14T16:32:34.865744+00:00", "base": "15d2aca0385b61596155e8421140d08d27e543af", - "main": "d78fe4bbb6f6b769e39586f8bb3ba8c31a31fd3a", + "main": "01a65937ece11b56d515c81f039464ae3043c1c1", "records": [ { "path": "AGENTS.md", @@ -280,8 +317,8 @@ { "path": "autoresearch.md", "base_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82", - "main_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82", - "same": true + "main_blob": "84c108dd0d650944066ee34796e733f2329acf28", + "same": false }, { "path": "docs/research/agent-task-catalog.json", @@ -298,14 +335,14 @@ { "path": "scripts/research_package.py", "base_blob": "f1475a7e8bcffab0e65034bb08cdcd69e95f6d6d", - "main_blob": "f1475a7e8bcffab0e65034bb08cdcd69e95f6d6d", - "same": true + "main_blob": "2b85498087ba032c29d62a0b2080065ac9e53ff6", + "same": false }, { "path": "docs/research/research-package-guide.md", "base_blob": "2b4841ab5d00f2a17f1379718a061a9cf8fe88ee", - "main_blob": "2b4841ab5d00f2a17f1379718a061a9cf8fe88ee", - "same": true + "main_blob": "8dc1a921179dcc7a9ecc2dc961ccd77b5ed60c02", + "same": false }, { "path": "research/r480-owner-optimum/inputs/local/FULL-WORD.json.gz", @@ -428,6 +465,139 @@ "all-size compiler and precision/tape obligations", "outer analytic transfer" ], - "scope": "Exact local scalar/frame and certificate checks; no new full multiplication theorem or selected frontier update." + "scope": "Exact local scalar/frame and certificate checks; no new full multiplication theorem or selected frontier update.", + "current_main_runner": { + "main": "01a65937ece11b56d515c81f039464ae3043c1c1", + "runner_git_blob": "2b85498087ba032c29d62a0b2080065ac9e53ff6", + "runner_sha256": "f719e8f7435ebbd7b2ced72f77e244292248799f33fd7e4e1ca74f6a9645dc6c", + "python": "CPython 3.12.3", + "full_registered_replay_exit_code": 0, + "control_groups": 18, + "method": "Imported unchanged runner bytes from the pinned current main, set ROOT to this checkout, and invoked main with the package argument. All mathematical inputs and the selected record remain unchanged." + } + }, + "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/1995", + "mathematical_head": "73e323159d65c974debb180189694fd59144da5f", + "latest_main_check_before_pause": { + "verified_at_utc": "2026-10-14T06:40:55.601877+00:00", + "base": "15d2aca0385b61596155e8421140d08d27e543af", + "main": "d78fe4bbb6f6b769e39586f8bb3ba8c31a31fd3a", + "records": [ + { + "path": "AGENTS.md", + "base_blob": "860762e04e963e1b163b8fa5267854c0040a9e67", + "main_blob": "860762e04e963e1b163b8fa5267854c0040a9e67", + "same": true + }, + { + "path": "CONTRIBUTING.md", + "base_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "main_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "same": true + }, + { + "path": "autoresearch.md", + "base_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82", + "main_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82", + "same": true + }, + { + "path": "docs/research/agent-task-catalog.json", + "base_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "main_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "same": true + }, + { + "path": "certificates/selected-result.json", + "base_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "main_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "same": true + }, + { + "path": "scripts/research_package.py", + "base_blob": "f1475a7e8bcffab0e65034bb08cdcd69e95f6d6d", + "main_blob": "f1475a7e8bcffab0e65034bb08cdcd69e95f6d6d", + "same": true + }, + { + "path": "docs/research/research-package-guide.md", + "base_blob": "2b4841ab5d00f2a17f1379718a061a9cf8fe88ee", + "main_blob": "2b4841ab5d00f2a17f1379718a061a9cf8fe88ee", + "same": true + }, + { + "path": "research/r480-owner-optimum/inputs/local/FULL-WORD.json.gz", + "base_blob": "723decbca8995e916d6f4b783aa3e1ddd4eb47fe", + "main_blob": "723decbca8995e916d6f4b783aa3e1ddd4eb47fe", + "same": true + }, + { + "path": "research/gauge44-slots/construction/slots/SLOT-PINS-k8.json", + "base_blob": "2702c368f4de0b671577aee9a0e2df41c1b27658", + "main_blob": "2702c368f4de0b671577aee9a0e2df41c1b27658", + "same": true + }, + { + "path": "research/complex-x4-frame-bound/model.py", + "base_blob": "33cfb4f404be0ed9fabd53a362084ef8dbc1911c", + "main_blob": "33cfb4f404be0ed9fabd53a362084ef8dbc1911c", + "same": true + }, + { + "path": "research/complex-x4-frame-bound/gen_duals.py", + "base_blob": "bd85022a44dde95c14710d7dd28fed6b81926fd1", + "main_blob": "bd85022a44dde95c14710d7dd28fed6b81926fd1", + "same": true + }, + { + "path": "research/complex-x4-frame-bound/README.md", + "base_blob": "e2ddf660ac1dabaf5286531dc784f9b21bfdd5bd", + "main_blob": "e2ddf660ac1dabaf5286531dc784f9b21bfdd5bd", + "same": true + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "base_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "main_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "same": true + }, + { + "path": "research/complex-local-word-ceiling/README.md", + "base_blob": "f5f742f8196da29d2c3f4dffb3c27685ca9401f6", + "main_blob": "f5f742f8196da29d2c3f4dffb3c27685ca9401f6", + "same": true + }, + { + "path": "research/gauge44-slots/independent/audit_local.py", + "base_blob": "4744d8783c25bf7bf5076886169077ca3808309a", + "main_blob": "4744d8783c25bf7bf5076886169077ca3808309a", + "same": true + }, + { + "path": "research/k8-rank7-composition/data/END-RECIPE.json", + "base_blob": "7af7b6341c06589239bcf4c4634febbc8f757ec2", + "main_blob": "7af7b6341c06589239bcf4c4634febbc8f757ec2", + "same": true + }, + { + "path": "research/k8-rank7-composition/construct.py", + "base_blob": "5600f92cbb9d391563af88f59eafd0e16a3b33b0", + "main_blob": "5600f92cbb9d391563af88f59eafd0e16a3b33b0", + "same": true + }, + { + "path": "research/k8-rank7-composition/README.md", + "base_blob": "306ec133620358b6d043311d59f91013bbf1f886", + "main_blob": "306ec133620358b6d043311d59f91013bbf1f886", + "same": true + }, + { + "path": "research/selected1042-lineage-resolution98/README.md", + "base_blob": "b9d19db8834b1cd8b64e564555581748e870f948", + "main_blob": "b9d19db8834b1cd8b64e564555581748e870f948", + "same": true + } + ], + "package_path_collision": false } }