From 2253023ca359782952248b1be793962a39f74165 Mon Sep 17 00:00:00 2001 From: ToikY <27568617+ToikY@users.noreply.github.com> Date: Sun, 18 Oct 2026 21:38:05 -0700 Subject: [PATCH] Certify maximal transported warp0 entrance and canonical price controls Source-bound cap and independent RREF replay of PR3929; no new kappa. Preserve predecessor bytes and AI/source attribution. --- research/warp0-entrance-cap/.gitattributes | 2 + .../INDEPENDENT-RESULT.json | 3146 +++++++++++++++++ research/warp0-entrance-cap/ORIGINS.json | 54 + research/warp0-entrance-cap/PROOF.md | 178 + research/warp0-entrance-cap/README.md | 35 + research/warp0-entrance-cap/RESULT.json | 2717 ++++++++++++++ research/warp0-entrance-cap/SOURCES.json | 18 + research/warp0-entrance-cap/TASK.json | 73 + research/warp0-entrance-cap/VERIFY.json | 49 + research/warp0-entrance-cap/independent.py | 303 ++ research/warp0-entrance-cap/source/NOTICE.md | 13 + research/warp0-entrance-cap/source/PROOF.md | 48 + .../warp0-entrance-cap/source/RESULT.json | 29 + research/warp0-entrance-cap/source/frames.py | 87 + .../source/inputs/BASE-WORD.json.gz | Bin 0 -> 72769 bytes .../source/inputs/RECIPE.json | 731 ++++ .../source/vendor/SOURCE-CREDITS.md | 14 + .../source/vendor/audit_core.py | 480 +++ research/warp0-entrance-cap/test_cli.py | 71 + research/warp0-entrance-cap/verify.py | 363 ++ 20 files changed, 8411 insertions(+) create mode 100644 research/warp0-entrance-cap/.gitattributes create mode 100644 research/warp0-entrance-cap/INDEPENDENT-RESULT.json create mode 100644 research/warp0-entrance-cap/ORIGINS.json create mode 100644 research/warp0-entrance-cap/PROOF.md create mode 100644 research/warp0-entrance-cap/README.md create mode 100644 research/warp0-entrance-cap/RESULT.json create mode 100644 research/warp0-entrance-cap/SOURCES.json create mode 100644 research/warp0-entrance-cap/TASK.json create mode 100644 research/warp0-entrance-cap/VERIFY.json create mode 100644 research/warp0-entrance-cap/independent.py create mode 100644 research/warp0-entrance-cap/source/NOTICE.md create mode 100644 research/warp0-entrance-cap/source/PROOF.md create mode 100644 research/warp0-entrance-cap/source/RESULT.json create mode 100644 research/warp0-entrance-cap/source/frames.py create mode 100644 research/warp0-entrance-cap/source/inputs/BASE-WORD.json.gz create mode 100644 research/warp0-entrance-cap/source/inputs/RECIPE.json create mode 100644 research/warp0-entrance-cap/source/vendor/SOURCE-CREDITS.md create mode 100644 research/warp0-entrance-cap/source/vendor/audit_core.py create mode 100644 research/warp0-entrance-cap/test_cli.py create mode 100644 research/warp0-entrance-cap/verify.py diff --git a/research/warp0-entrance-cap/.gitattributes b/research/warp0-entrance-cap/.gitattributes new file mode 100644 index 0000000000..bcb0208327 --- /dev/null +++ b/research/warp0-entrance-cap/.gitattributes @@ -0,0 +1,2 @@ +# Preserve the predecessor's exact bytes, including retained CRLF source files. +source/** -text diff --git a/research/warp0-entrance-cap/INDEPENDENT-RESULT.json b/research/warp0-entrance-cap/INDEPENDENT-RESULT.json new file mode 100644 index 0000000000..325df82f26 --- /dev/null +++ b/research/warp0-entrance-cap/INDEPENDENT-RESULT.json @@ -0,0 +1,3146 @@ +{ + "backward_frozen": { + "dimension": 5, + "maximal_entrance": [ + 258, + 130, + 82, + 42, + 7 + ], + "native_pullbacks": [ + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 385, + 66, + 36, + 22, + 8 + ], + "register": 85, + "warp": 49 + }, + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 262, + 134, + 102, + 22, + 8 + ], + "register": 74, + "warp": 48 + }, + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 273, + 145, + 85, + 51, + 8 + ], + "register": 55, + "warp": 47 + }, + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 258, + 130, + 67, + 22, + 8 + ], + "register": 33, + "warp": 46 + }, + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 258, + 130, + 67, + 22, + 8 + ], + "register": 329, + "warp": 12 + }, + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 385, + 66, + 36, + 22, + 8 + ], + "register": 313, + "warp": 11 + }, + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 273, + 145, + 85, + 51, + 8 + ], + "register": 297, + "warp": 10 + }, + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 273, + 145, + 85, + 51, + 8 + ], + "register": 301, + "warp": 9 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 269, + 137, + 75, + 41, + 26 + ], + "register": 31, + "warp": 57 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 257, + 137, + 67, + 37, + 22 + ], + "register": 88, + "warp": 56 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 257, + 137, + 67, + 37, + 22 + ], + "register": 80, + "warp": 55 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 259, + 131, + 75, + 42, + 25 + ], + "register": 68, + "warp": 54 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 259, + 131, + 75, + 42, + 25 + ], + "register": 397, + "warp": 19 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 257, + 137, + 67, + 37, + 22 + ], + "register": 377, + "warp": 18 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 257, + 137, + 67, + 37, + 22 + ], + "register": 381, + "warp": 17 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 257, + 161, + 70, + 19, + 13 + ], + "register": 345, + "warp": 14 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 273, + 145, + 85, + 51, + 8 + ], + "register": 101, + "warp": 53 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 385, + 66, + 36, + 22, + 8 + ], + "register": 98, + "warp": 52 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 262, + 134, + 102, + 22, + 8 + ], + "register": 83, + "warp": 51 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 258, + 130, + 67, + 22, + 8 + ], + "register": 49, + "warp": 50 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 384, + 64, + 38, + 21, + 11 + ], + "register": 225, + "warp": 21 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 259, + 131, + 67, + 51, + 8 + ], + "register": 393, + "warp": 20 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 388, + 67, + 33, + 18, + 8 + ], + "register": 281, + "warp": 8 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 388, + 67, + 33, + 18, + 8 + ], + "register": 285, + "warp": 7 + }, + { + "post_cap": [ + 409, + 72, + 48, + 4, + 3 + ], + "pre_cap": [ + 261, + 133, + 85, + 45, + 2 + ], + "register": 241, + "warp": 25 + }, + { + "post_cap": [ + 409, + 72, + 48, + 4, + 3 + ], + "pre_cap": [ + 448, + 36, + 21, + 9, + 2 + ], + "register": 234, + "warp": 24 + }, + { + "post_cap": [ + 409, + 72, + 48, + 4, + 3 + ], + "pre_cap": [ + 448, + 36, + 21, + 9, + 2 + ], + "register": 229, + "warp": 23 + }, + { + "post_cap": [ + 409, + 72, + 48, + 4, + 3 + ], + "pre_cap": [ + 448, + 36, + 21, + 9, + 2 + ], + "register": 227, + "warp": 22 + }, + { + "post_cap": [ + 426, + 96, + 24, + 6, + 1 + ], + "pre_cap": [ + 400, + 68, + 34, + 14, + 1 + ], + "register": 257, + "warp": 27 + }, + { + "post_cap": [ + 426, + 96, + 24, + 6, + 1 + ], + "pre_cap": [ + 260, + 132, + 84, + 44, + 1 + ], + "register": 245, + "warp": 26 + }, + { + "post_cap": [ + 426, + 96, + 24, + 6, + 1 + ], + "pre_cap": [ + 384, + 74, + 44, + 30, + 1 + ], + "register": 317, + "warp": 5 + }, + { + "post_cap": [ + 426, + 96, + 24, + 6, + 1 + ], + "pre_cap": [ + 266, + 138, + 74, + 30, + 1 + ], + "register": 333, + "warp": 4 + }, + { + "post_cap": [ + 288, + 160, + 75, + 25, + 7 + ], + "pre_cap": [ + 259, + 148, + 66, + 36, + 9 + ], + "register": 563, + "warp": 64 + }, + { + "post_cap": [ + 288, + 160, + 75, + 25, + 7 + ], + "pre_cap": [ + 262, + 193, + 33, + 18, + 12 + ], + "register": 542, + "warp": 41 + }, + { + "post_cap": [ + 288, + 160, + 75, + 25, + 7 + ], + "pre_cap": [ + 267, + 139, + 42, + 25, + 7 + ], + "register": 442, + "warp": 40 + }, + { + "post_cap": [ + 288, + 160, + 75, + 25, + 7 + ], + "pre_cap": [ + 385, + 70, + 33, + 18, + 12 + ], + "register": 530, + "warp": 6 + }, + { + "post_cap": [ + 391, + 65, + 32, + 20, + 10 + ], + "pre_cap": [ + 384, + 69, + 35, + 16, + 14 + ], + "register": 261, + "warp": 28 + }, + { + "post_cap": [ + 391, + 65, + 32, + 20, + 10 + ], + "pre_cap": [ + 384, + 69, + 35, + 16, + 14 + ], + "register": 259, + "warp": 3 + }, + { + "post_cap": [ + 391, + 65, + 32, + 20, + 10 + ], + "pre_cap": [ + 384, + 69, + 35, + 16, + 14 + ], + "register": 266, + "warp": 2 + }, + { + "post_cap": [ + 391, + 65, + 32, + 20, + 10 + ], + "pre_cap": [ + 261, + 133, + 85, + 37, + 8 + ], + "register": 250, + "warp": 1 + }, + { + "post_cap": [ + 257, + 129, + 76, + 42, + 30 + ], + "pre_cap": [ + 276, + 131, + 66, + 36, + 9 + ], + "register": 562, + "warp": 69 + }, + { + "post_cap": [ + 257, + 129, + 76, + 42, + 30 + ], + "pre_cap": [ + 258, + 130, + 67, + 45, + 22 + ], + "register": 553, + "warp": 68 + }, + { + "post_cap": [ + 257, + 129, + 76, + 42, + 30 + ], + "pre_cap": [ + 258, + 130, + 85, + 37, + 8 + ], + "register": 552, + "warp": 67 + }, + { + "post_cap": [ + 257, + 129, + 76, + 42, + 30 + ], + "pre_cap": [ + 385, + 66, + 36, + 22, + 9 + ], + "register": 551, + "warp": 66 + }, + { + "post_cap": [ + 391, + 68, + 34, + 17, + 8 + ], + "pre_cap": [ + 260, + 132, + 37, + 22, + 8 + ], + "register": 437, + "warp": 39 + }, + { + "post_cap": [ + 391, + 68, + 34, + 17, + 8 + ], + "pre_cap": [ + 260, + 132, + 37, + 22, + 8 + ], + "register": 435, + "warp": 38 + }, + { + "post_cap": [ + 391, + 68, + 34, + 17, + 8 + ], + "pre_cap": [ + 260, + 132, + 37, + 22, + 8 + ], + "register": 433, + "warp": 37 + }, + { + "post_cap": [ + 391, + 68, + 34, + 17, + 8 + ], + "pre_cap": [ + 386, + 65, + 37, + 20, + 8 + ], + "register": 426, + "warp": 36 + }, + { + "post_cap": [ + 260, + 132, + 75, + 42, + 25 + ], + "pre_cap": [ + 269, + 137, + 75, + 41, + 26 + ], + "register": 12, + "warp": 45 + }, + { + "post_cap": [ + 260, + 132, + 75, + 42, + 25 + ], + "pre_cap": [ + 257, + 161, + 70, + 19, + 13 + ], + "register": 6, + "warp": 44 + }, + { + "post_cap": [ + 260, + 132, + 75, + 42, + 25 + ], + "pre_cap": [ + 259, + 131, + 75, + 42, + 25 + ], + "register": 4, + "warp": 43 + }, + { + "post_cap": [ + 260, + 132, + 75, + 42, + 25 + ], + "pre_cap": [ + 257, + 161, + 70, + 19, + 13 + ], + "register": 1, + "warp": 42 + }, + { + "post_cap": [ + 272, + 144, + 75, + 42, + 7 + ], + "pre_cap": [ + 266, + 136, + 73, + 45, + 28 + ], + "register": 421, + "warp": 35 + }, + { + "post_cap": [ + 272, + 144, + 75, + 42, + 7 + ], + "pre_cap": [ + 266, + 136, + 73, + 45, + 28 + ], + "register": 419, + "warp": 34 + }, + { + "post_cap": [ + 272, + 144, + 75, + 42, + 7 + ], + "pre_cap": [ + 266, + 136, + 73, + 45, + 28 + ], + "register": 417, + "warp": 33 + }, + { + "post_cap": [ + 272, + 144, + 75, + 42, + 7 + ], + "pre_cap": [ + 265, + 137, + 75, + 45, + 24 + ], + "register": 410, + "warp": 32 + }, + { + "post_cap": [ + 409, + 80, + 40, + 5, + 2 + ], + "pre_cap": [ + 406, + 66, + 36, + 8, + 1 + ], + "register": 550, + "warp": 65 + }, + { + "post_cap": [ + 409, + 80, + 40, + 5, + 2 + ], + "pre_cap": [ + 258, + 130, + 74, + 45, + 31 + ], + "register": 565, + "warp": 30 + }, + { + "post_cap": [ + 409, + 80, + 40, + 5, + 2 + ], + "pre_cap": [ + 265, + 137, + 75, + 45, + 31 + ], + "register": 405, + "warp": 31 + }, + { + "post_cap": [ + 409, + 80, + 40, + 5, + 2 + ], + "pre_cap": [ + 258, + 130, + 84, + 44, + 1 + ], + "register": 564, + "warp": 29 + }, + { + "post_cap": [ + 320, + 192, + 42, + 25, + 7 + ], + "pre_cap": [ + 257, + 129, + 97, + 25, + 7 + ], + "register": 361, + "warp": 16 + }, + { + "post_cap": [ + 320, + 192, + 42, + 25, + 7 + ], + "pre_cap": [ + 257, + 129, + 97, + 25, + 7 + ], + "register": 365, + "warp": 15 + }, + { + "post_cap": [ + 320, + 192, + 42, + 25, + 7 + ], + "pre_cap": [ + 416, + 65, + 19, + 10, + 7 + ], + "register": 349, + "warp": 13 + }, + { + "post_cap": [ + 320, + 192, + 42, + 25, + 7 + ], + "pre_cap": [ + 258, + 130, + 82, + 42, + 7 + ], + "register": 243, + "warp": 0 + } + ], + "scalar_constraints": 1165 + }, + "backward_relaxed": { + "dimension": 5, + "maximal_entrance": [ + 258, + 130, + 82, + 42, + 7 + ], + "native_pullbacks": [ + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 385, + 66, + 36, + 22, + 8 + ], + "register": 85, + "warp": 49 + }, + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 262, + 134, + 102, + 22, + 8 + ], + "register": 74, + "warp": 48 + }, + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 273, + 145, + 85, + 51, + 8 + ], + "register": 55, + "warp": 47 + }, + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 258, + 130, + 67, + 22, + 8 + ], + "register": 33, + "warp": 46 + }, + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 258, + 130, + 67, + 22, + 8 + ], + "register": 329, + "warp": 12 + }, + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 385, + 66, + 36, + 22, + 8 + ], + "register": 313, + "warp": 11 + }, + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 273, + 145, + 85, + 51, + 8 + ], + "register": 297, + "warp": 10 + }, + { + "post_cap": [ + 391, + 64, + 33, + 18, + 12 + ], + "pre_cap": [ + 273, + 145, + 85, + 51, + 8 + ], + "register": 301, + "warp": 9 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 269, + 137, + 75, + 41, + 26 + ], + "register": 31, + "warp": 57 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 257, + 137, + 67, + 37, + 22 + ], + "register": 88, + "warp": 56 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 257, + 137, + 67, + 37, + 22 + ], + "register": 80, + "warp": 55 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 259, + 131, + 75, + 42, + 25 + ], + "register": 68, + "warp": 54 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 259, + 131, + 75, + 42, + 25 + ], + "register": 397, + "warp": 19 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 257, + 137, + 67, + 37, + 22 + ], + "register": 377, + "warp": 18 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 257, + 137, + 67, + 37, + 22 + ], + "register": 381, + "warp": 17 + }, + { + "post_cap": [ + 258, + 130, + 76, + 45, + 25 + ], + "pre_cap": [ + 257, + 161, + 70, + 19, + 13 + ], + "register": 345, + "warp": 14 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 273, + 145, + 85, + 51, + 8 + ], + "register": 101, + "warp": 53 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 385, + 66, + 36, + 22, + 8 + ], + "register": 98, + "warp": 52 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 262, + 134, + 102, + 22, + 8 + ], + "register": 83, + "warp": 51 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 258, + 130, + 67, + 22, + 8 + ], + "register": 49, + "warp": 50 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 384, + 64, + 38, + 21, + 11 + ], + "register": 225, + "warp": 21 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 259, + 131, + 67, + 51, + 8 + ], + "register": 393, + "warp": 20 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 388, + 67, + 33, + 18, + 8 + ], + "register": 281, + "warp": 8 + }, + { + "post_cap": [ + 391, + 66, + 36, + 16, + 9 + ], + "pre_cap": [ + 388, + 67, + 33, + 18, + 8 + ], + "register": 285, + "warp": 7 + }, + { + "post_cap": [ + 409, + 72, + 48, + 4, + 3 + ], + "pre_cap": [ + 261, + 133, + 85, + 45, + 2 + ], + "register": 241, + "warp": 25 + }, + { + "post_cap": [ + 409, + 72, + 48, + 4, + 3 + ], + "pre_cap": [ + 448, + 36, + 21, + 9, + 2 + ], + "register": 234, + "warp": 24 + }, + { + "post_cap": [ + 409, + 72, + 48, + 4, + 3 + ], + "pre_cap": [ + 448, + 36, + 21, + 9, + 2 + ], + "register": 229, + "warp": 23 + }, + { + "post_cap": [ + 409, + 72, + 48, + 4, + 3 + ], + "pre_cap": [ + 448, + 36, + 21, + 9, + 2 + ], + "register": 227, + "warp": 22 + }, + { + "post_cap": [ + 426, + 96, + 24, + 6, + 1 + ], + "pre_cap": [ + 400, + 68, + 34, + 14, + 1 + ], + "register": 257, + "warp": 27 + }, + { + "post_cap": [ + 426, + 96, + 24, + 6, + 1 + ], + "pre_cap": [ + 260, + 132, + 84, + 44, + 1 + ], + "register": 245, + "warp": 26 + }, + { + "post_cap": [ + 426, + 96, + 24, + 6, + 1 + ], + "pre_cap": [ + 384, + 74, + 44, + 30, + 1 + ], + "register": 317, + "warp": 5 + }, + { + "post_cap": [ + 426, + 96, + 24, + 6, + 1 + ], + "pre_cap": [ + 266, + 138, + 74, + 30, + 1 + ], + "register": 333, + "warp": 4 + }, + { + "post_cap": [ + 288, + 160, + 75, + 25, + 7 + ], + "pre_cap": [ + 259, + 148, + 66, + 36, + 9 + ], + "register": 563, + "warp": 64 + }, + { + "post_cap": [ + 288, + 160, + 75, + 25, + 7 + ], + "pre_cap": [ + 262, + 193, + 33, + 18, + 12 + ], + "register": 542, + "warp": 41 + }, + { + "post_cap": [ + 288, + 160, + 75, + 25, + 7 + ], + "pre_cap": [ + 267, + 139, + 42, + 25, + 7 + ], + "register": 442, + "warp": 40 + }, + { + "post_cap": [ + 288, + 160, + 75, + 25, + 7 + ], + "pre_cap": [ + 385, + 70, + 33, + 18, + 12 + ], + "register": 530, + "warp": 6 + }, + { + "post_cap": [ + 391, + 65, + 32, + 20, + 10 + ], + "pre_cap": [ + 384, + 69, + 35, + 16, + 14 + ], + "register": 261, + "warp": 28 + }, + { + "post_cap": [ + 391, + 65, + 32, + 20, + 10 + ], + "pre_cap": [ + 384, + 69, + 35, + 16, + 14 + ], + "register": 259, + "warp": 3 + }, + { + "post_cap": [ + 391, + 65, + 32, + 20, + 10 + ], + "pre_cap": [ + 384, + 69, + 35, + 16, + 14 + ], + "register": 266, + "warp": 2 + }, + { + "post_cap": [ + 391, + 65, + 32, + 20, + 10 + ], + "pre_cap": [ + 261, + 133, + 85, + 37, + 8 + ], + "register": 250, + "warp": 1 + }, + { + "post_cap": [ + 257, + 129, + 76, + 42, + 30 + ], + "pre_cap": [ + 276, + 131, + 66, + 36, + 9 + ], + "register": 562, + "warp": 69 + }, + { + "post_cap": [ + 257, + 129, + 76, + 42, + 30 + ], + "pre_cap": [ + 258, + 130, + 67, + 45, + 22 + ], + "register": 553, + "warp": 68 + }, + { + "post_cap": [ + 257, + 129, + 76, + 42, + 30 + ], + "pre_cap": [ + 258, + 130, + 85, + 37, + 8 + ], + "register": 552, + "warp": 67 + }, + { + "post_cap": [ + 257, + 129, + 76, + 42, + 30 + ], + "pre_cap": [ + 385, + 66, + 36, + 22, + 9 + ], + "register": 551, + "warp": 66 + }, + { + "post_cap": [ + 391, + 68, + 34, + 17, + 8 + ], + "pre_cap": [ + 260, + 132, + 37, + 22, + 8 + ], + "register": 437, + "warp": 39 + }, + { + "post_cap": [ + 391, + 68, + 34, + 17, + 8 + ], + "pre_cap": [ + 260, + 132, + 37, + 22, + 8 + ], + "register": 435, + "warp": 38 + }, + { + "post_cap": [ + 391, + 68, + 34, + 17, + 8 + ], + "pre_cap": [ + 260, + 132, + 37, + 22, + 8 + ], + "register": 433, + "warp": 37 + }, + { + "post_cap": [ + 391, + 68, + 34, + 17, + 8 + ], + "pre_cap": [ + 386, + 65, + 37, + 20, + 8 + ], + "register": 426, + "warp": 36 + }, + { + "post_cap": [ + 260, + 132, + 75, + 42, + 25 + ], + "pre_cap": [ + 269, + 137, + 75, + 41, + 26 + ], + "register": 12, + "warp": 45 + }, + { + "post_cap": [ + 260, + 132, + 75, + 42, + 25 + ], + "pre_cap": [ + 257, + 161, + 70, + 19, + 13 + ], + "register": 6, + "warp": 44 + }, + { + "post_cap": [ + 260, + 132, + 75, + 42, + 25 + ], + "pre_cap": [ + 259, + 131, + 75, + 42, + 25 + ], + "register": 4, + "warp": 43 + }, + { + "post_cap": [ + 260, + 132, + 75, + 42, + 25 + ], + "pre_cap": [ + 257, + 161, + 70, + 19, + 13 + ], + "register": 1, + "warp": 42 + }, + { + "post_cap": [ + 272, + 144, + 75, + 42, + 7 + ], + "pre_cap": [ + 266, + 136, + 73, + 45, + 28 + ], + "register": 421, + "warp": 35 + }, + { + "post_cap": [ + 272, + 144, + 75, + 42, + 7 + ], + "pre_cap": [ + 266, + 136, + 73, + 45, + 28 + ], + "register": 419, + "warp": 34 + }, + { + "post_cap": [ + 272, + 144, + 75, + 42, + 7 + ], + "pre_cap": [ + 266, + 136, + 73, + 45, + 28 + ], + "register": 417, + "warp": 33 + }, + { + "post_cap": [ + 272, + 144, + 75, + 42, + 7 + ], + "pre_cap": [ + 265, + 137, + 75, + 45, + 24 + ], + "register": 410, + "warp": 32 + }, + { + "post_cap": [ + 409, + 80, + 40, + 5, + 2 + ], + "pre_cap": [ + 406, + 66, + 36, + 8, + 1 + ], + "register": 550, + "warp": 65 + }, + { + "post_cap": [ + 409, + 80, + 40, + 5, + 2 + ], + "pre_cap": [ + 258, + 130, + 74, + 45, + 31 + ], + "register": 565, + "warp": 30 + }, + { + "post_cap": [ + 409, + 80, + 40, + 5, + 2 + ], + "pre_cap": [ + 265, + 137, + 75, + 45, + 31 + ], + "register": 405, + "warp": 31 + }, + { + "post_cap": [ + 409, + 80, + 40, + 5, + 2 + ], + "pre_cap": [ + 258, + 130, + 84, + 44, + 1 + ], + "register": 564, + "warp": 29 + }, + { + "post_cap": [ + 320, + 192, + 42, + 25, + 7 + ], + "pre_cap": [ + 257, + 129, + 97, + 25, + 7 + ], + "register": 361, + "warp": 16 + }, + { + "post_cap": [ + 320, + 192, + 42, + 25, + 7 + ], + "pre_cap": [ + 257, + 129, + 97, + 25, + 7 + ], + "register": 365, + "warp": 15 + }, + { + "post_cap": [ + 320, + 192, + 42, + 25, + 7 + ], + "pre_cap": [ + 416, + 65, + 19, + 10, + 7 + ], + "register": 349, + "warp": 13 + }, + { + "post_cap": [ + 320, + 192, + 42, + 25, + 7 + ], + "pre_cap": [ + 258, + 130, + 82, + 42, + 7 + ], + "register": 243, + "warp": 0 + } + ], + "scalar_constraints": 1165 + }, + "baseline_tail_bill": { + "1": 1490, + "2": 713, + "3": 204, + "4": 64, + "5": 20 + }, + "compressed_base_git_blob": "674ea18ade4af85ca865fb08dc973637a09e30e6", + "compressed_base_sha256": "5ca4be99851f8878cbfe0fd6c454df926b11218f17feefa1664721cf03156699", + "extensions": [ + { + "accepted": false, + "entrance": [ + 260, + 132, + 84, + 44, + 1 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 1, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 85, + 45, + 2 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 2, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 85, + 45, + 3 + ], + "failure_kind": "terminal", + "failure_register": 119, + "representative": 3, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 17, + 8, + 5, + 2 + ], + "violating_vector": 16 + }, + { + "accepted": false, + "entrance": [ + 257, + 129, + 81, + 41, + 4 + ], + "failure_kind": "terminal", + "failure_register": 119, + "representative": 4, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 17, + 8, + 5, + 2 + ], + "violating_vector": 16 + }, + { + "accepted": false, + "entrance": [ + 256, + 128, + 80, + 40, + 5 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 5, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": false, + "entrance": [ + 259, + 131, + 83, + 43, + 6 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 6, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": true, + "bill": { + "1": 1517, + "2": 699, + "3": 203, + "4": 65, + "5": 20 + }, + "cap_prefixes": [ + 13, + 12, + 11, + 11, + 11, + 11, + 11, + 11 + ], + "capped_sums": [ + 13, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "delta": { + "1": 27, + "2": -14, + "3": -1, + "4": 1 + }, + "entrance": [ + 258, + 130, + 82, + 42, + 7 + ], + "identities": [ + [ + 0, + 243, + 1 + ] + ], + "native_changes": [ + 0 + ], + "representative": 7, + "scalar_changes": 32 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 85, + 37, + 8 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 8, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 85, + 36, + 9 + ], + "failure_kind": "terminal", + "failure_register": 119, + "representative": 9, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 17, + 8, + 5, + 2 + ], + "violating_vector": 16 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 85, + 39, + 10 + ], + "failure_kind": "terminal", + "failure_register": 139, + "representative": 10, + "terminal_cap": [ + 256, + 128, + 64, + 34, + 16, + 8, + 6, + 1 + ], + "violating_vector": 32 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 85, + 38, + 11 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 11, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 85, + 33, + 12 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 12, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 85, + 32, + 13 + ], + "failure_kind": "terminal", + "failure_register": 139, + "representative": 13, + "terminal_cap": [ + 256, + 128, + 64, + 34, + 16, + 8, + 6, + 1 + ], + "violating_vector": 32 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 85, + 35, + 14 + ], + "failure_kind": "terminal", + "failure_register": 119, + "representative": 14, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 17, + 8, + 5, + 2 + ], + "violating_vector": 16 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 85, + 34, + 15 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 15, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 69, + 45, + 16 + ], + "failure_kind": "terminal", + "failure_register": 188, + "representative": 16, + "terminal_cap": [ + 320, + 192, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "violating_vector": 256 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 68, + 45, + 17 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 17, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 71, + 45, + 18 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 18, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 70, + 45, + 19 + ], + "failure_kind": "terminal", + "failure_register": 119, + "representative": 19, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 17, + 8, + 5, + 2 + ], + "violating_vector": 16 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 65, + 45, + 20 + ], + "failure_kind": "terminal", + "failure_register": 119, + "representative": 20, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 17, + 8, + 5, + 2 + ], + "violating_vector": 16 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 64, + 45, + 21 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 21, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 67, + 45, + 22 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 22, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 66, + 45, + 23 + ], + "failure_kind": "terminal", + "failure_register": 188, + "representative": 23, + "terminal_cap": [ + 320, + 192, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "violating_vector": 256 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 77, + 45, + 24 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 24, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 76, + 45, + 25 + ], + "failure_kind": "terminal", + "failure_register": 119, + "representative": 25, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 17, + 8, + 5, + 2 + ], + "violating_vector": 16 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 79, + 45, + 26 + ], + "failure_kind": "terminal", + "failure_register": 139, + "representative": 26, + "terminal_cap": [ + 256, + 128, + 64, + 34, + 16, + 8, + 6, + 1 + ], + "violating_vector": 32 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 78, + 45, + 27 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 27, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 73, + 45, + 28 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 28, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 72, + 45, + 29 + ], + "failure_kind": "terminal", + "failure_register": 139, + "representative": 29, + "terminal_cap": [ + 256, + 128, + 64, + 34, + 16, + 8, + 6, + 1 + ], + "violating_vector": 32 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 75, + 45, + 30 + ], + "failure_kind": "terminal", + "failure_register": 119, + "representative": 30, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 17, + 8, + 5, + 2 + ], + "violating_vector": 16 + }, + { + "accepted": false, + "entrance": [ + 261, + 133, + 74, + 45, + 31 + ], + "failure_kind": "terminal", + "failure_register": 112, + "representative": 31, + "terminal_cap": [ + 256, + 128, + 64, + 32, + 16, + 9, + 4, + 3 + ], + "violating_vector": 8 + } + ], + "maximal_dimension": 5, + "maximal_entrance": [ + 258, + 130, + 82, + 42, + 7 + ], + "original_entrance": [ + 261, + 133, + 85, + 45 + ], + "quotient_line_count": 31, + "rejected_quotient_lines": 30, + "scope": "Fixed literal scalar opcode word; monotone scalar-frame enlargement and compatible native transport; fixed caller cuts, A and terminal frames. No native phase rerun, global optimality or kappa claim.", + "semantic_controls": [ + "invalid_binary_vector_rejected_True", + "invalid_binary_vector_rejected_-1", + "invalid_binary_vector_rejected_512", + "singular_native_map_rejected", + "omitting_target_caps_expands_maximum_to_nine", + "dimension_six_extension_fails_cap", + "wrong_direction_violates_target_112" + ], + "status": "PASS_INDEPENDENT_WARP_ZERO_CAP" +} diff --git a/research/warp0-entrance-cap/ORIGINS.json b/research/warp0-entrance-cap/ORIGINS.json new file mode 100644 index 0000000000..409cbe323d --- /dev/null +++ b/research/warp0-entrance-cap/ORIGINS.json @@ -0,0 +1,54 @@ +{ + "head": "0c0e31cf12e8f4f07e8419a6d33ae85129fb5a01", + "source_package": "research/transported-warp-frames", + "files": [ + { + "path": "inputs/BASE-WORD.json.gz", + "git_blob": "674ea18ade4af85ca865fb08dc973637a09e30e6", + "sha256": "5ca4be99851f8878cbfe0fd6c454df926b11218f17feefa1664721cf03156699", + "bytes": 72769 + }, + { + "path": "vendor/audit_core.py", + "git_blob": "8b5e1d5f2a106402f036b63028ecef31a4e4c462", + "sha256": "888679ca8502cdcb100420fe5382a052529a494bf76cb332928b86e62612b951", + "bytes": 19364 + }, + { + "path": "vendor/SOURCE-CREDITS.md", + "git_blob": "c054fad87eeaa510865e682ee0c976c4cd728da2", + "sha256": "d4a13d8b8ed9cdb594f00efb3d1a336e09d934423330f02a1514308a720c278b", + "bytes": 2882 + }, + { + "path": "NOTICE.md", + "git_blob": "2367c1761242f63e463fc077f560408d3b849b6a", + "sha256": "7ebec97ac2601c3b94301fc0499a0e5841fc4b4a02c3e0685c3e0b1ab76a9609", + "bytes": 2367 + }, + { + "path": "PROOF.md", + "git_blob": "3cabeba04baee08afa53afc5a87b1fdc00cbe16e", + "sha256": "cd227d0cc0e34c7b4b6a850a042f0f99099f1fe9b25e0519982e8f5973603f2d", + "bytes": 6441 + }, + { + "path": "frames.py", + "git_blob": "9e68a6d543426dcbc24d6b4c6bb2550487d7aa85", + "sha256": "7ad4c0e56ba7db5f1215aa72c4270225cc5781d49c9561bffa8bea3356e37e4a", + "bytes": 3531 + }, + { + "path": "inputs/RECIPE.json", + "git_blob": "873a5b4fa5546ab7c2e5dad4a99df31b2f268a7b", + "sha256": "aa4ddab6f44c8a37892cb2261aa9302e6a9a2c809aa2472678860dd2b05b1023", + "bytes": 9736 + }, + { + "path": "RESULT.json", + "git_blob": "8dcb82a8c50587751f9023f0226d34c9a469c5d0", + "sha256": "006939c8ec8c0de90396616e4e2b35744788179397726bfdcdb99f6fa336aa38", + "bytes": 536 + } + ] +} diff --git a/research/warp0-entrance-cap/PROOF.md b/research/warp0-entrance-cap/PROOF.md new file mode 100644 index 0000000000..b8aed21159 --- /dev/null +++ b/research/warp0-entrance-cap/PROOF.md @@ -0,0 +1,178 @@ +# Exact entrance feasibility with adaptive native boundaries + +SPDX-License-Identifier: Apache-2.0. Prepared for ToikY with substantial +OpenAI Codex assistance, including separate mathematical review. This is +written mathematics, not a new proof-assistant or independent human review. + +Credit Dugongue's PR3929 at `0c0e31cf12e8f4f07e8419a6d33ae85129fb5a01` +for the transported-frame construction and compiler; dataisfire/PR3734, +zxv/PR3682, Ross Richardson/PR3605, Jeremy Kothe, Sagar Thakrar/PR3687, +Arham Tahir/PR3693 and the retained native lineage keep their source credit. +The retained notices remain authoritative for copied predecessor code. + +## Fixed domain + +All frames are subspaces of V=F2^9; + means subspace join. Freeze the source +register inventory, ordered scalar operations and coefficients, native maps +and their order, complete A/cut prefix, B prefix before zero-based warp0, +start frames, target/helper terminal caps and wrapper contracts. Each scalar +gate must use a common frame containing its ORIGINAL frame and the incoming +frames of every operand. Each later native entrance must contain its ORIGINAL +entrance and its incoming lender frame; its exit is the image under its +unchanged invertible map. Such boundaries may adapt and enlarge. No scalar +reordering, new nonidentity operation, smaller original scalar frame, changed +native map, changed endpoint or additional helper belongs to this domain. + +Here warp0 means array index zero, NOT the chronologically first native warp: +eight other B native events precede its position and remain in the frozen +prefix. All chronological event ordering, including native events at a shared +B position before that position's scalar event, is retained. +Warp0 uses lender 243 at original B position 916. Its original entrance is +U0=span(261,133,85,45), of dimension four. Choose U' containing U0 and set +its exit to G0 U'. Its incoming frame is the frozen prefix's original frame, +which must lie in U0. An explicit paid identity climb supplies the entrance +when needed. A candidate is frame-feasible if all subsequent common frames +can be chosen and each final frame lies in its fixed terminal cap. + +## Least forward closure is exact for legality + +At a scalar event touching registers R with original frame Q, set + + F_new(r) = Q + sum_(s in R) F_old(s) for every r in R. + +At a later native event on r with original entrance U and fixed map G, set + + W = U + F_old(r), F_new(r) = G W. + +Other registers keep their frames. Seed warp0 with F_new(243)=G0 U'. +These transformations preserve inclusion: joins and images of subspaces +are monotone. Induction shows that this closure is componentwise contained +in every legal completion with the same seed U'. Indeed every candidate +scalar frame contains the displayed join, and every candidate native +entrance contains W, so its exit contains G W. Thus a least-closure failure +of a fixed terminal cap excludes every completion for that U'. Conversely, +if all least frames lie in their caps, these explicit choices, paid entrance +climbs and final climbs give a legal frame assignment. This establishes +minimality for legality, without asserting minimum monetary or moment cost. + +In particular, if U1 is contained in U2, every least frame for U1 is contained +in the corresponding frame for U2. Failure at U1 persists at U2. This fact +does not require the larger seed to have only one extra dimension. + +## Backward capacities give the exact maximal seed + +Start with capacity C_r equal to the fixed terminal cap of each register. +These capacities characterize the incoming states from which some legal +completion exists: precisely those with F_r contained in C_r for every r. +Process events in reverse order, using the following exact rules. + +For a scalar event touching R with original floor Q, let + + K = intersection_(r in R) C_r. + +Require Q contained in K, then replace every touched capacity by K. The +common frame Q+sum F_r lies in every outgoing capacity exactly when Q and +each incoming F_r lie in K. Untouched capacities retain their values. + +For a native event on r with original entrance U and invertible map G, let + + K = G^(-1)(C_r). + +Require U contained in K, then replace C_r by K. There exists an entrance +W containing U+F_r with G W contained in the outgoing capacity exactly when +both U and F_r lie in K. The least choice W=U+F_r attains this condition. +The floor checks are essential: a preimage alone cannot waive the original +native entrance or scalar frame. A failed constant floor makes the entire +fixed-domain suffix infeasible. A valid original word supplies a consistency +check against this failure. + +Induction proves the product-of-capacities characterization. Immediately +after warp0, pull lender 243's capacity back through G0 and call it C0. +Check all other frozen incoming frames against their capacities and check +U0 contained in C0. Then the admissible seeds are EXACTLY + + U0 contained in U' contained in C0. + +Thus C0 is the unique maximal legal entrance in this domain, independently +of how scalar frames are optimized within the remaining legal capacities. + +## Concrete conclusion and independent evidence + +The matched, source-authenticated forward and backward receipts establish + + C0 = U0 + span(7), dim(C0)=5, + +Thus there is exactly one nontrivial legal entrance enlargement. Every +dimension-six-or-larger seed is impossible. Equivalently, the five-dimensional +quotient V/U0 has 31 lines; precisely the line represented by 7 is admitted. +Any higher-dimensional quotient subspace contains a rejected line, and +forward monotonicity preserves its failure. The backward intersection and +forward 31-line enumeration are distinct ways to certify the same boundary. +The forward checks also validate all other frozen prefix-register frames. +There are 374 superframes of U0, with quotient-dimension counts +(1,31,155,155,31,1); exactly two are feasible and the other 372 are excluded. +The receipts bind the directly authenticated BASE-WORD, not an inverse +reconstruction of an example or a copied PASS string. + +## Billing, semantics and limitations + +All centre descents, target cut-level tests and prelude warp resets precede +the changed B suffix. Preserve their original accounting convention. The +retained frame walker bills centre descents without replacing its persistent +current-centre entry; the compiler separately tracks the last served frame. +Do not silently repair that inherited convention or infer a new physical +invoice from it. No centre is touched in B. The sole centre-touching restore +gate is restore[191], on registers 230 and 92. The retained compiler replay +checks that its entire original record, including the eight-dimensional +frame, is unchanged before cancelling centre costs. +FULL cleanup occurs after the terminal tests and cannot rescue their failure. + +Changing frames and inserting scalar identities leaves the ordered free +operator product unchanged; recomputed literal inverse cleanup therefore +has the same arbitrary-dirty-input algebraic endpoint. This is a source +operator statement, not a fresh exact-native phase certificate. Realization +at new boundaries inherits PR3929's transported-frame theorem and requires +the prescribed exact lifts/phase recipes for any physical admission claim. + +## Exact price and the nonminimal-frame control + +With every entrance and terminal climb charged, the canonical completion's +new-minus-original profile is 27 H1 - 14 H2 - H3 + H4, of rank mass zero. +For the power tariff f(r)=r^q, 0 0. + +Both summands are strictly positive. The ordinary raw moment has the same +sign, since r*(m/r)^a=m^a*r^(1-a) with q=1-a and m^a positive. This is a +strict loss for this canonical completion at all power tariffs in that +range, not a universal scalar-price obstruction. Indeed the concave tariff +min(r,2) gives the opposite sign, -1, against the original profile. + +More importantly, PR3929's published recipe uses the SAME enlarged warp0 +entrance and is a legal nonminimal completion within the stated frame-floor +domain. Its original-frame containments, compiled word and stored profile +are checked separately. Canonical-minus-published is + + -H1 + 2 H2 + 3 H3 - 3 H4, + +again of rank mass zero. Its sums against min(r,j), for j=1..4, are +(1,3,3,0). For any discrete concave f on {0,1,2,3,4}, with f(0)=0, put +c_j=2f(j)-f(j-1)-f(j+1)>=0 for j=1..3. Direct expansion gives + + -f(1)+2f(2)+3f(3)-3f(4) = c_1+3c_2+3c_3 >= 0. + +Every c_j is positive for f(r)=r^q, 0 0. + +Recompiling a retained recipe and authenticating its result does not rerun +the predecessor's native phase calculation. + +Larger legal scalar frames can merge later climbs and change prices; their +optimization remains open. No global scalar-price obstruction, complete +owner/idle allocation, fresh native replay, physical caller, recurrence, +supplier, kappa improvement or selected-frontier change follows here. diff --git a/research/warp0-entrance-cap/README.md b/research/warp0-entrance-cap/README.md new file mode 100644 index 0000000000..3564944e27 --- /dev/null +++ b/research/warp0-entrance-cap/README.md @@ -0,0 +1,35 @@ +# Exact warp0 entrance cap with adaptive native frames + +This source-bound negative audit of [Dugongue PR3929](https://github.com/CrocSwap/integer-mult-bounds/pull/3929) proves the unique maximal entrance at zero-based warp0. It does not produce a new kappa or a physical supplier. + +Freeze PR3929 at `0c0e31cf12e8f4f07e8419a6d33ae85129fb5a01`, its literal BASE-WORD, A/cut and earlier B prefix, scalar operations/coefficient/order, native maps/order, register inventory and terminal caps. Scalar frames must contain their original floors; later native boundaries may enlarge compatibly with their fixed maps. Warp0 is array index zero, lender243 at B916: eight other native events occur earlier chronologically. + +## Result + +The original entrance U0=span(261,133,85,45) has dimension4. The maximal legal entrance is C0=U0+span(7), with RREF basis (258,130,82,42,7), dimension5. Exactly two of the374 superframes containing U0 are legal: U0 and C0. All372 others fail fixed terminal caps. A backward capacity proof and independent forward enumeration of all31 quotient lines agree. This excludes all larger entrance subspaces even when later native boundaries adapt; it does not exclude larger scalar frames within C0. + +The canonical least-join completion has complete rank profile `{1:2467,2:711,3:223,4:103,5:20,8:8}`, versus baseline `{1:2440,2:725,3:224,4:102,5:20,8:8}`. Its difference is `27 H1-14 H2-H3+H4`, a strict loss for every tariff r^q, 00 for0= 0 for x in prefixes) and any(x > 0 for x in prefixes), 'all-power non-improvement') + result.update(delta=delta, capped_sums=caps, cap_prefixes=prefixes) + rows.append({'representative': v, 'entrance': list(extension), **result}) + need(sum(row['accepted'] for row in rows) == 1, 'unique admitted extension') + controls = [] + for value in (True, -1, 512): + try: + basis((value,)) + except ValueError: + controls.append('invalid_binary_vector_rejected_'+str(value)) + else: + raise ValueError('invalid vector accepted') + try: + inverse((1, 2, 4, 8, 16, 32, 64, 128, 128)) + except ValueError: + controls.append('singular_native_map_rejected') + else: + raise ValueError('singular native map accepted') + counterfactual = deepcopy(word) + counterfactual['ports'] = [0]*112 + no_target_caps = backward(counterfactual, False) + need(no_target_caps['dimension'] == 9, 'caller target caps are essential') + controls.append('omitting_target_caps_expands_maximum_to_nine') + forbidden = joined(original, (7, 1)) + need(len(forbidden) == 6 and not subset(forbidden, cap), 'forbidden extra quotient line') + controls.append('dimension_six_extension_fails_cap') + bad = next(row for row in rows if row['representative'] == 1) + need(not bad['accepted'] and bad['failure_kind'] == 'terminal' and + bad['failure_register'] == 112, 'wrong entrance reaches caller target') + controls.append('wrong_direction_violates_target_112') + return {'status': 'PASS_INDEPENDENT_WARP_ZERO_CAP', + 'compressed_base_git_blob': actual, + 'compressed_base_sha256': hashlib.sha256(compressed).hexdigest(), + 'original_entrance': list(original), 'maximal_entrance': list(cap), + 'maximal_dimension': len(cap), 'quotient_line_count': 31, + 'rejected_quotient_lines': 30, 'baseline_tail_bill': base['bill'], + 'backward_relaxed': relaxed, 'backward_frozen': frozen, 'extensions': rows, + 'semantic_controls': controls, + 'scope': 'Fixed literal scalar opcode word; monotone scalar-frame enlargement and compatible native transport; fixed caller cuts, A and terminal frames. No native phase rerun, global optimality or kappa claim.'} + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--word', type=Path, required=True) + parser.add_argument('--out', type=Path) + parser.add_argument('--check', type=Path) + args = parser.parse_args() + result = compute(args.word) + text = json.dumps(result, sort_keys=True, indent=2)+'\n' + if args.check: + saved = json.loads(args.check.read_text(encoding='utf-8')) + encode = lambda value: json.dumps(value, sort_keys=True, separators=(',', ':')) + need(encode(saved) == encode(result), 'complete independent receipt') + print(result['status']) + return + if args.out: + with args.out.open('x', encoding='utf-8') as stream: + stream.write(text) + else: + print(text, end='') + + +if __name__ == '__main__': + main() diff --git a/research/warp0-entrance-cap/source/NOTICE.md b/research/warp0-entrance-cap/source/NOTICE.md new file mode 100644 index 0000000000..2367c17612 --- /dev/null +++ b/research/warp0-entrance-cap/source/NOTICE.md @@ -0,0 +1,13 @@ +# Attribution and scope + +New compiler, recipe extraction, statement, proof, controls and integration: Dugongue, with substantial OpenAI Codex assistance. Apache-2.0. No independent human or kernel review is claimed. + +The unchanged `vendor/audit_core.py` is Sagar Thakrar's (#3687) independent semantics/frame audit, adapted to the staged word through the retained source package and #3693. It explicitly credits Arham Tahir's coupled-carrier audit and shares that contract interpretation. Its complete original notice and SOURCE-CREDITS.md are preserved. + +The base supplier word comes from dataisfire's #3734 staged544 producer-return work, following zxv's #3682 staged pair and Ross Richardson's #3605 staged entrance. The canonical local/free-word frame machinery follows Jeremy Kothe, with retained credits including #2857 Lyy-iiis, #2863 Dugongue, #2833 Jeremy Kothe and #2853 philippeVV. The #3815 clock and attained packing construction is Erwan Secousses/ChaloupeMusic's; endpoint refinement #3875 is hexapode's and does not replace those construction credits. #3857 supplies prior exact endpoint evaluation/proof work by Dugongue. + +The native machinery and independent Gaussian checks retain their complete original notices. Core native-warp work is #2226, Cinna Davis (@1337isnot1337), with OpenAI Codex assistance; the retained lineage includes #514/#433 icekylinx. Wrapper code credits DreamingOfClouds/Claude Opus 5.5 and #458/chafreaky where recorded. The sparse replay driver and accelerators are Tekalign (@tekuuu), with substantial OpenAI Codex assistance. `native/NATIVE-LINEAGE-NOTICE`, `native/SOURCE-PROVENANCE.json` and nested notices are authoritative for that retained source closure. + +Local research precedent: the shared MathProof DAG's GLOBAL-FRAME-MINCUT note already supplied whole-word common-character and hyperplane cuts with fixed native boundaries. This package reuses that idea and adds a constructive compatible native-boundary change. Local source retrieval was source-only; no fresh Lean theorem or kernel evidence is asserted. + +Recent overlap reviewed includes #3889/#3890 ideal packing regions, #3886 retiming, #3884 local Gaussian primitives and #3883 supplier audit. They are contextual comparisons, not ingredients proved anew here. The 608-open-PR snapshot and bounded Discussion review do not establish exhaustive novelty. diff --git a/research/warp0-entrance-cap/source/PROOF.md b/research/warp0-entrance-cap/source/PROOF.md new file mode 100644 index 0000000000..3cabeba04b --- /dev/null +++ b/research/warp0-entrance-cap/source/PROOF.md @@ -0,0 +1,48 @@ +# A sufficient construction for transported warp frames + +All spaces below are over F₂. A frame is a subspace of V = F₂^h. A scalar operation touching several registers requires one common frame containing each current frame. Enlarging U to W costs one H_(dim W − dim U) when the difference is positive. Native warps have fixed invertible binary maps G and fixed free-operator identities K_G. Frame changes do not change G or K_G. + +## The transported-frame lemma + +Define the maximal isotropic subspace + +`L_U = {(x, x + p) : x ∈ U, p ∈ U⊥}` + +of the binary Pauli space V × V, with symplectic form x·z′ + z·x′. It has dimension h: the displayed parametrization is injective, its domain has dimension dim U + dim U⊥ = h, and isotropy follows because each cross term is x·p′ + p·x′ = 0. + +For invertible G define the native symplectic action + +`S_G(x,z) = (Gx, Gx + G^(-T)(x+z))`. + +For every U, **S_G(L_U) = L_(GU)**. Indeed substituting z = x+p gives `(Gx, Gx+G^(-T)p)`, and G^(-T)(U⊥) = (GU)⊥. The latter equality follows from `(Gx)·(G^(-T)p) = x·p`; dimensions give equality rather than inclusion. This also proves the inverse statement with G^(-1). + +Let T_U be any exact Clifford frame lift taking L_U to the computational Z subspace, with the same convention on both sides. If an exact Clifford K_G has action S_G, then + +`T_(GU) K_G T_U^(-1)` + +is monomial: its conjugation preserves the computational Z Pauli subgroup up to signs. The joint eigenspaces of the h independent Z generators are precisely the one-dimensional computational basis lines. Conjugation therefore permutes those lines. Unitarity makes the surviving coefficient on each line have modulus one. Thus its Fourier rank is zero for **every** U, not only the original U. This statement includes any global phase: multiplying K_G or either lift by a unit scalar preserves monomiality. + +This proves rank-zero realizability, not a specific phase table or a particular native gate invoice. A symplectic tableau alone does not determine global phase. Those claims require the exact phase recipes and physical gate expansion. The concrete word below passes those extra gates through the unchanged attributed native replayer, including its independent Gaussian all-column checker. No generic exact-phase identity is inferred solely from this lemma. + +## Word construction theorem + +Fix a finite legal BORROW-WORD with invertible native maps. Keep its registers, source/target/centre/terminal interfaces, scalar opcodes and coefficients, prelude warp operators and order, B native warp order and maps, and all wrapper contracts. Choose new common frames for scalar gates and new entrance/exit frames U_k′, E_k′ for B warps. Assume: + +1. Every chosen scalar frame contains the current frames of all its operands; centre descents, target cut levels and end interfaces remain legal. +2. Immediately before each B warp the lender's current frame F_k is contained in U_k′, and E_k′ = G_k U_k′. +3. The prelude's original exact frame requirements remain legal, including inverse warps. Cleanup is recomputed from the unchanged free operators. +4. The native implementation uses exact lifts and phase recipes for the new frames; any claimed physical cost beyond the rank histogram is checked separately. + +Then the following algorithm yields a legal framed implementation of the same full linear operator: apply the chosen scalar frame edits, insert the scalar identity on each lender in frame U_k′ whenever F_k ≠ U_k′, apply the unchanged K_(G_k), and continue in frame E_k′. Charge the climb before the warp by H_(dim U_k′ − dim F_k); charge every other scalar climb, centre descent and terminal climb exactly as the ordinary walker does. Preserve the original operator numbers even when B positions shift. + +**Proof.** Induct in execution order. A scalar step is legal by condition 1 and uses the same scalar operator. An inserted identity is exactly the identity on the register's underlying values and is legal by F_k ⊆ U_k′; the climb is explicitly charged. The transported-frame lemma makes the following native warp legal at rank zero and gives the required exit frame. Its underlying operator remains K_(G_k), not a conjugated or renamed operator. This proves the induction through B and restore. Centre and terminal interfaces are legal by condition 1. Deleting the inserted identities leaves the original opcode sequence, hence exactly the same ordered product of linear operators, including the arbitrary dirty inputs. Recomputing cleanup from that product preserves its intended correction. Each charge is literally the positive dimension change at its event, which proves the histogram invoice. Condition 4 supplies any stronger phase or physical admission claim; it is not assigned zero cost. ∎ + +The theorem is sufficient and constructive. It does not require a favorable histogram, a specific search method, clean helper inputs or a guessed owner schedule. Conversely it does not assert that a valid local word supplies a complete recursive owner/outer construction. + +## Concrete application + +The frozen recipe changes one of 72 B warp records: zero-based warp 0 on register 243, with entrance dimension 4 becoming 5 and exit its exact G image. It changes 36 scalar frames and emits one identity scale at B position 916. The compiler output equals every field of the frozen native-audited word, not merely its profile. The independent point-set walker checks containment, binary maps and lifted Lagrangian action. Independent free noncommutative forward/dual and reverse-boundary checks retain all symbolic dirty inputs. The full native driver additionally reconstructs exact warp recipes and global phases. + +The resulting profile is 2468 H1 + 709 H2 + 220 H3 + 106 H4 + 20 H5 + 8 H8. Compared with the original, the rank-mass change is 28 − 32 − 12 + 16 = 0. The helper inventory remains 26 of width 4, 2 of width 5, 18 of width 6, 53 of width 7, 96 of width 8 and 213 of width 9. This is an actual nontrivial positive instance of the theorem. Its price is worse near the current endpoint; there is no new κ claim. + +The reusable contribution is the explicit compatible-transport construction and its checked compiler. The shared DAG's fixed-boundary character cuts are a predecessor, not a new discovery here. Optimizing the enlarged domain and realizing a profitable complete supplier remain separate research tasks. diff --git a/research/warp0-entrance-cap/source/RESULT.json b/research/warp0-entrance-cap/source/RESULT.json new file mode 100644 index 0000000000..8dcb82a8c5 --- /dev/null +++ b/research/warp0-entrance-cap/source/RESULT.json @@ -0,0 +1,29 @@ +{ + "status": "PASS_TRANSPORTED_FRAME_RECIPE", + "profile": { + "1": 2468, + "2": 709, + "3": 220, + "4": 106, + "5": 20, + "8": 8 + }, + "profile_delta": { + "1": 28, + "2": -16, + "3": -4, + "4": 4, + "5": 0, + "8": 0 + }, + "inventory": { + "4": 26, + "5": 2, + "6": 18, + "7": 53, + "8": 96, + "9": 213 + }, + "new_kappa": null, + "scope": "Fresh exact frame, lifted-action, forward, dual and cleanup-boundary checks. Native receipt authenticated; rerun native/run_native.py for fresh phases." +} diff --git a/research/warp0-entrance-cap/source/frames.py b/research/warp0-entrance-cap/source/frames.py new file mode 100644 index 0000000000..9e68a6d543 --- /dev/null +++ b/research/warp0-entrance-cap/source/frames.py @@ -0,0 +1,87 @@ +"""Construct compatible BORROW-WORD native frame changes; no solver required. + +Dugongue, with substantial OpenAI Codex assistance. Apache-2.0. +""" +import copy +from pathlib import Path +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent / 'vendor')) +import audit_core as audit + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def compile_frames(source, recipe): + """Apply guarded scalar/warp frame edits and emit every needed paid climb. + + The original opcode sequence, warp matrices, operator numbering and caller + interfaces are retained. This function checks frame legality, not phases. + The independent full free-operator and native checks are separate gates. + """ + w = copy.deepcopy(source) + seen = set() + for edit in recipe['scalar_edits']: + section, i = edit['section'], edit['index'] + need(section in ('A', 'B', 'restore'), 'invalid scalar section') + need((section, i) not in seen, 'duplicate scalar edit') + seen.add((section, i)) + g = w[section][i] + need(g[0] != 'warp' and g[-1] == edit['old'], 'scalar source guard') + g[-1] = list(edit['new']) + edits = {} + for edit in recipe['warp_edits']: + k = edit['index'] + need(k not in edits, 'duplicate warp edit') + need(source['warps'][k][3:] == edit['old'], 'warp source guard') + edits[k] = edit['new'] + + # The independent point-set walker establishes A, centre and final legality. + cur = {r: audit.span((p,)) for r, p in enumerate(w['ports'])} + cur.update({r: audit.ZERO for r in range(audit.V, audit.N)}) + for r, frame in w['start_extra'].items(): + cur[int(r)] = audit.span(frame) + for g in w['A']: + if g[0] == 'warp': + cur[g[1]] = audit.span(g[4]) + else: + for r in audit.touched(g): + cur[r] = audit.span(g[-1]) + # Centre registers descend to the last served target level before B. + levels = {audit.V + int(t): audit.span(f) for t, f in w['target_levels'].items()} + for r in w['centers']: + served = {levels.get(g[1], audit.ZERO) for g in w['cut'] if g[2] == r} + for frame in sorted(served, key=lambda f: -audit.dim(f)): + cur[r] = frame + at = {} + for k, record in enumerate(source['warps']): + at.setdefault(record[0], []).append(k) + out = [] + for i in range(len(w['B']) + 1): + for k in at.get(i, ()): + old = source['warps'][k] + entrance, exit_frame = edits.get(k, old[3:]) + u, e = audit.span(entrance), audit.span(exit_frame) + images = audit.warp_images(old[2]) + need(audit.image_mask(images, u) == e, 'incompatible transported frame') + need(cur[old[1]] & ~u == 0, 'warp entrance would shrink') + if cur[old[1]] != u: + out.append(['scale', old[1], 1, 1, list(entrance)]) + w['warps'][k] = [len(out), old[1], copy.deepcopy(old[2]), + list(entrance), list(exit_frame)] + cur[old[1]] = e + if i < len(w['B']): + g = w['B'][i] + out.append(g) + for r in audit.touched(g): + cur[r] = audit.span(g[-1]) + w['B'] = out + w['cleanup'] = audit.derive_cleanup(w) + audit.hygiene(w) + profile, inventory, _, _, _ = audit.frame_bill(w, lagrangian=True) + w['report']['local_profile'] = {str(k): v for k, v in profile.items()} + w['report']['width_inventory'] = {str(k): v for k, v in inventory.items()} + return w diff --git a/research/warp0-entrance-cap/source/inputs/BASE-WORD.json.gz b/research/warp0-entrance-cap/source/inputs/BASE-WORD.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..674ea18ade4af85ca865fb08dc973637a09e30e6 GIT binary patch literal 72769 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 a{2=x9TiBifgoL2jalJEr?dHi{zx^MgbT>}` literal 0 HcmV?d00001 diff --git a/research/warp0-entrance-cap/source/inputs/RECIPE.json b/research/warp0-entrance-cap/source/inputs/RECIPE.json new file mode 100644 index 0000000000..873a5b4fa5 --- /dev/null +++ b/research/warp0-entrance-cap/source/inputs/RECIPE.json @@ -0,0 +1,731 @@ +{ + "scalar_edits": [ + { + "section": "B", + "index": 916, + "old": [ + 320, + 192, + 45, + 30 + ], + "new": [ + 320, + 192, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 917, + "old": [ + 320, + 192, + 45, + 30 + ], + "new": [ + 320, + 192, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 918, + "old": [ + 320, + 192, + 45, + 30 + ], + "new": [ + 320, + 192, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 919, + "old": [ + 320, + 192, + 45, + 30 + ], + "new": [ + 320, + 192, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 920, + "old": [ + 320, + 192, + 45, + 30 + ], + "new": [ + 320, + 192, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 921, + "old": [ + 320, + 192, + 45, + 30 + ], + "new": [ + 320, + 192, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 922, + "old": [ + 320, + 192, + 45, + 30 + ], + "new": [ + 320, + 192, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 923, + "old": [ + 320, + 192, + 45, + 30 + ], + "new": [ + 320, + 192, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 924, + "old": [ + 320, + 192, + 45, + 30 + ], + "new": [ + 320, + 192, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 925, + "old": [ + 320, + 192, + 45, + 30 + ], + "new": [ + 320, + 192, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 926, + "old": [ + 320, + 192, + 45, + 30 + ], + "new": [ + 320, + 192, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 927, + "old": [ + 320, + 192, + 45, + 30 + ], + "new": [ + 320, + 192, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 928, + "old": [ + 271, + 143, + 79, + 45, + 30 + ], + "new": [ + 264, + 136, + 72, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 929, + "old": [ + 320, + 192, + 41, + 26, + 4 + ], + "new": [ + 320, + 192, + 41, + 25, + 4, + 3 + ] + }, + { + "section": "B", + "index": 930, + "old": [ + 320, + 192, + 44, + 30, + 1 + ], + "new": [ + 320, + 192, + 42, + 24, + 6, + 1 + ] + }, + { + "section": "B", + "index": 931, + "old": [ + 266, + 138, + 74, + 45, + 30 + ], + "new": [ + 266, + 138, + 74, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 932, + "old": [ + 262, + 134, + 70, + 45, + 30 + ], + "new": [ + 257, + 129, + 65, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 933, + "old": [ + 320, + 192, + 32, + 19, + 13 + ], + "new": [ + 320, + 192, + 32, + 19, + 10, + 7 + ] + }, + { + "section": "B", + "index": 934, + "old": [ + 320, + 192, + 37, + 22, + 8 + ], + "new": [ + 320, + 192, + 34, + 17, + 8, + 7 + ] + }, + { + "section": "B", + "index": 935, + "old": [ + 259, + 131, + 67, + 45, + 30 + ], + "new": [ + 259, + 131, + 67, + 42, + 25, + 7 + ] + }, + { + "section": "B", + "index": 1421, + "old": [ + 263, + 135, + 71, + 37, + 22, + 8 + ], + "new": [ + 256, + 128, + 64, + 34, + 17, + 8, + 7 + ] + }, + { + "section": "B", + "index": 1422, + "old": [ + 263, + 135, + 71, + 37, + 22, + 8 + ], + "new": [ + 256, + 128, + 64, + 34, + 17, + 8, + 7 + ] + }, + { + "section": "B", + "index": 1425, + "old": [ + 259, + 131, + 67, + 41, + 26, + 4 + ], + "new": [ + 256, + 128, + 64, + 41, + 25, + 4, + 3 + ] + }, + { + "section": "B", + "index": 1426, + "old": [ + 259, + 131, + 67, + 41, + 26, + 4 + ], + "new": [ + 256, + 128, + 64, + 41, + 25, + 4, + 3 + ] + }, + { + "section": "B", + "index": 1429, + "old": [ + 262, + 134, + 70, + 44, + 30, + 1 + ], + "new": [ + 256, + 128, + 64, + 42, + 24, + 6, + 1 + ] + }, + { + "section": "B", + "index": 1430, + "old": [ + 262, + 134, + 70, + 44, + 30, + 1 + ], + "new": [ + 256, + 128, + 64, + 42, + 24, + 6, + 1 + ] + }, + { + "section": "B", + "index": 1433, + "old": [ + 263, + 135, + 71, + 32, + 19, + 13 + ], + "new": [ + 256, + 128, + 64, + 32, + 19, + 10, + 7 + ] + }, + { + "section": "B", + "index": 1434, + "old": [ + 263, + 135, + 71, + 32, + 19, + 13 + ], + "new": [ + 256, + 128, + 64, + 32, + 19, + 10, + 7 + ] + }, + { + "section": "B", + "index": 1437, + "old": [ + 259, + 131, + 67, + 33, + 18, + 12 + ], + "new": [ + 259, + 131, + 67, + 33, + 18, + 11, + 7 + ] + }, + { + "section": "B", + "index": 1438, + "old": [ + 259, + 131, + 67, + 33, + 18, + 12 + ], + "new": [ + 259, + 131, + 67, + 33, + 18, + 11, + 7 + ] + }, + { + "section": "B", + "index": 1441, + "old": [ + 320, + 192, + 33, + 18, + 8, + 4 + ], + "new": [ + 320, + 192, + 33, + 17, + 8, + 4, + 3 + ] + }, + { + "section": "B", + "index": 1442, + "old": [ + 320, + 192, + 33, + 18, + 8, + 4 + ], + "new": [ + 320, + 192, + 33, + 17, + 8, + 4, + 3 + ] + }, + { + "section": "B", + "index": 1445, + "old": [ + 320, + 192, + 32, + 18, + 12, + 1 + ], + "new": [ + 320, + 192, + 32, + 18, + 10, + 6, + 1 + ] + }, + { + "section": "B", + "index": 1446, + "old": [ + 320, + 192, + 32, + 18, + 12, + 1 + ], + "new": [ + 320, + 192, + 32, + 18, + 10, + 6, + 1 + ] + }, + { + "section": "B", + "index": 1449, + "old": [ + 262, + 134, + 70, + 33, + 18, + 12 + ], + "new": [ + 257, + 129, + 65, + 33, + 18, + 11, + 7 + ] + }, + { + "section": "B", + "index": 1450, + "old": [ + 262, + 134, + 70, + 33, + 18, + 12 + ], + "new": [ + 257, + 129, + 65, + 33, + 18, + 11, + 7 + ] + } + ], + "warp_edits": [ + { + "index": 0, + "old": [ + [ + 261, + 133, + 85, + 45 + ], + [ + 320, + 192, + 45, + 30 + ] + ], + "new": [ + [ + 258, + 130, + 82, + 42, + 7 + ], + [ + 320, + 192, + 42, + 25, + 7 + ] + ] + } + ] +} diff --git a/research/warp0-entrance-cap/source/vendor/SOURCE-CREDITS.md b/research/warp0-entrance-cap/source/vendor/SOURCE-CREDITS.md new file mode 100644 index 0000000000..c054fad87e --- /dev/null +++ b/research/warp0-entrance-cap/source/vendor/SOURCE-CREDITS.md @@ -0,0 +1,14 @@ +# Source credit and independence + +New work: dataisfire with substantial OpenAI Codex assistance, Apache-2.0. No independent human review, fresh third-party AI review or proof-kernel verification is claimed. + +The construction extends [PR3682](https://github.com/CrocSwap/integer-mult-bounds/pull/3682), head431e6c6023ef352c41696469de7fb614cd4ded8c. Its retimed word, actual T360 source clock and immutable native/parent framework are retained. The complete new source/receipt snapshot is bound by REPLAY-INPUTS.json. The new ordinary source stage is an explicit pinned record applied after the unchanged predecessor reconstruction. + +- [PR3605](https://github.com/CrocSwap/integer-mult-bounds/pull/3605), Ross Richardson, supplies the staged-entrance mechanism, literal cleanup and exact Gaussian residual-check pattern. staged_pair.py is retained; the new544 shear and its proof are separate. +- [PR3638](https://github.com/CrocSwap/integer-mult-bounds/pull/3638), head d62e1acd7518a231440383f0d0dddf54d6edf8c1, supplies the T360 source-window clock, chronological aggregate model and integral-network/literal construction, with its retained PR3605 and earlier credits. The new inventory, integer incumbent and literal fill are recomputed. No predecessor owner receipt is used as proof of the new fill. +- [PR3687](https://github.com/CrocSwap/integer-mult-bounds/pull/3687) and [PR3693](https://github.com/CrocSwap/integer-mult-bounds/pull/3693), Sagar Thakrar and roger-sato with their credited AI assistance, supply audit_core.py and the whole-word semantics adapter audit_verify.py. These bytes are retained and reused. They are independent of the current constructor in the stated interpreter scope, not a newly written independent audit or new reviewer approval. +- The coupled-word source lineage includes PR3133, PR2979, Marius-Paul Dumitrean, dcharb78, Jeremy Kothe and the retained native/owner/block-norm/outer authors. All notices and scientific engines inside the source snapshot remain intact. + +owner_audit.py is a standalone standard-library adaptation of the source-window/family/prefix/invoice predicates in PR3638's independent_literal.py. It imports no producer, optimizer or retained owner checker. Its source template, plan and actual native canonical words are authenticated inputs. Three controls mutate actual literal roles and must fail for the intended reason. It shares the credited contract interpretation; it is not evidence of independent human agreement. + +The rational finite-price enclosure is retained from the PR3682 sources. New script adapters bind it to the actual finite histogram. Native forward/backward scalar replay, wrapper/phase lowering and all-column warp recipes were freshly run for both new words; unchanged native and parent ancestry is explicitly reused. The separate new544 span(414,51) residual check includes global Gaussian phase. diff --git a/research/warp0-entrance-cap/source/vendor/audit_core.py b/research/warp0-entrance-cap/source/vendor/audit_core.py new file mode 100644 index 0000000000..8b5e1d5f2a --- /dev/null +++ b/research/warp0-entrance-cap/source/vendor/audit_core.py @@ -0,0 +1,480 @@ +"""Independent exact semantics and binary-frame bill for the BORROW-WORD format. + +Standard library only. Nothing is imported from the audited authors' code +(PR3133/PR3605 producers, cleanup generator, evaluator or frame solver); the word +format and its semantic contract were read from those pinned sources and are +credited there. The frame-bill and free-word structure (point-set spans, warp +frame and lifted-frame checks, target levels keyed by register, dual symbol +naming) re-implements, without importing, Arham Tahir's +research/coupled-carrier-independent-audit/verify.py (Apache-2.0) and shares its +reading of the contract, so this module is not independent of that audit. + +Sagar Thakrar (thakrarsagar), with substantial AI assistance from Claude +(Anthropic, Claude Opus 5.5). Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q + +V, N, H = 112, 704, 9 # sources 0..111, targets 112..223, helpers 224..703 +DUAL = 10 ** 6 # offset naming the independent dual symbols D_k = K_k^(-T) + + +class AuditFailure(Exception): + """Explicit failure; never disabled by python -O.""" + + +def need(ok, *why): + if not ok: + raise AuditFailure(' '.join(map(str, why))) + + +def is_target(r): + return V <= r < 2 * V + + +def touched(g): + return g[1:3] if g[0] == 'add' else g[1:2] + + +# ---------------------------------------------------------------------------- +# Binary frames: a subspace of F_2^9 is stored as a 512-bit point-set mask +# (bit x set iff x lies in the subspace). Containment is mask inclusion. +# ---------------------------------------------------------------------------- +_SPAN = {} + + +def span(vectors): + key = tuple(vectors) + mask = _SPAN.get(key) + if mask is None: + points = {0} + for u in key: + need(type(u) is int and 0 <= u < 512, 'frame vector out of range', u) + if u not in points: + points |= {p ^ u for p in points} + mask = sum(1 << p for p in points) + _SPAN[key] = mask + return mask + + +def points(mask): + return [x for x in range(512) if mask >> x & 1] + + +def dim(mask): + size = bin(mask).count('1') + need(size and size & (size - 1) == 0, 'not a subspace point set') + return size.bit_length() - 1 + + +FULL = (1 << 512) - 1 +ZERO = 1 + + +def hyperplane(port): + return sum(1 << x for x in range(512) if bin(x & port).count('1') % 2 == 0) + + +def warp_images(columns): + """Images of all 512 vectors under the F_2-linear map with columns G e_i.""" + need(len(columns) == H and all(type(c) is int and 0 <= c < 512 for c in columns), 'warp columns') + images = [0] * 512 + for x in range(1, 512): + low = x & -x + images[x] = images[x ^ low] ^ columns[low.bit_length() - 1] + need(len(set(images)) == 512, 'singular warp') + return images + + +def image_mask(images, mask): + return sum(1 << images[x] for x in points(mask)) + + +def lagrangian_action_ok(images, U, E): + """K_G(x,z)=(Gx, Gx+G^{-T}(x+z)) is symplectic and maps L_U to L_E, L_0 and L_FULL to themselves. + + L_U={(x,x+p): x in U, p in U^perp}. This is the binary frame action only; it + is not a Clifford phase or Gaussian-product certificate. For invertible G with + G(U)=E it is implied by the frame-map check ( = ), so it is a + consistency check of the implementation, not extra evidence. + """ + inverse = [0] * 512 + for x, y in enumerate(images): + inverse[y] = x + # G^{-T} z: bit j of the result is . + git = lambda z: sum((bin(inverse[1 << j] & z).count('1') & 1) << j for j in range(H)) + lift = lambda x, z: (images[x], images[x] ^ git(x ^ z)) + pair = lambda a, b: (bin(a[0] & b[1]).count('1') + bin(a[1] & b[0]).count('1')) & 1 + basis = [(1 << i, 0) for i in range(H)] + [(0, 1 << i) for i in range(H)] + lifted = [lift(*b) for b in basis] + if any(pair(lifted[i], lifted[j]) != pair(basis[i], basis[j]) for i in range(18) for j in range(i + 1, 18)): + return False + + def frame(mask): + us = points(mask) + perp = [p for p in range(512) if all(bin(p & u).count('1') % 2 == 0 for u in us)] + return {(u, u ^ p) for u in us for p in perp} + return all({lift(*pt) for pt in frame(a)} == frame(b) for a, b in ((ZERO, ZERO), (FULL, FULL), (U, E))) + + +# ---------------------------------------------------------------------------- +# Chronological binary-frame bill (BORROW-WORD contract) +# ---------------------------------------------------------------------------- +def frame_bill(w, lagrangian=False): + rep = w['report'] + need((rep['v'], 2 * rep['v'] + rep['R'], rep['h']) == (V, N, H), 'word geometry') + removed = set(w['removed']) + need(len(removed) == len(w['removed']) and all(2 * V <= r < N for r in removed), 'removed helpers') + live = [r for r in range(N) if r not in removed] + liveset = set(live) + B, warps = w['B'], w['warps'] + for k, (pos, lender, cols, U, E) in enumerate(warps, 1): + need(0 <= pos <= len(B), 'warp position', k) + need(lender in liveset and not is_target(lender), 'warp lender', k) + images = warp_images(cols) + su, se = span(U), span(E) + need(dim(su) == len(U) == len(E) == dim(se), 'warp frame bases', k) + need(image_mask(images, su) == se, 'warp does not map its frame', k) + if lagrangian: + need(lagrangian_action_ok(images, su, se), 'lifted frame action', k) + for name in ('A', 'B', 'restore'): + for g in w[name]: + if g[0] != 'warp': + need(all(r in liveset for r in touched(g)), 'removed/out-of-range register', name, g) + if g[0] == 'add' and not is_target(g[1]): + need(not is_target(g[2]), 'non-target reads a target', name, g) + need(all(g[-1] is None and is_target(g[1]) and g[0] == 'add' for g in w['cut']), 'cut gates') + need(all(g[-1] == [] and is_target(g[1]) for g in w['precondition'] + w['compensation']), 'zero-frame wrapper writes') + need(all(not is_target(g[1]) for g in w['restore']), 'restore writes a target') + + ports = w['ports'] + start, end = {}, {} + for r in live: + if r < V: + start[r], end[r] = span((ports[r],)), FULL + elif r < 2 * V: + start[r], end[r] = ZERO, hyperplane(ports[r - V]) + else: + start[r], end[r] = ZERO, FULL + for q, U in w['start_extra'].items(): + need(int(q) in liveset and int(q) >= 2 * V, 'entrance names a live helper', q) + start[int(q)] = span(U) + for q, U in w['helper_final'].items(): + need(int(q) in liveset and int(q) >= 2 * V, 'terminal names a live helper', q) + end[int(q)] = span(U) + + current, bill, chain = dict(start), Counter(), {} + + def climb(r, mask, where): + need(current[r] & ~mask == 0, 'frame containment fails', where, r) + d = dim(mask) - dim(current[r]) + if d: + bill[d] += 1 + chain.setdefault(r, []).append((where, d, mask)) + current[r] = mask + + npre = w['prelude_events'] + for i, g in enumerate(w['A']): + if g[0] == 'warp': + need(i < npre and len(g) == 5, 'warp outside the prelude', i) + _, r, op, fr, to = g + need(op != 0 and abs(op) <= len(warps) and warps[abs(op) - 1][1] == r, 'prelude warp lender', i) + images = warp_images(warps[abs(op) - 1][2]) + if op < 0: + inverse = [0] * 512 + for x, y in enumerate(images): + inverse[y] = x + images = inverse + need(image_mask(images, span(fr)) == span(to), 'prelude warp frame action', i) + need(current[r] == span(fr), 'prelude warp entry frame', i, r) + current[r] = span(to) + chain.setdefault(r, []).append((('A', i), 'warp', span(to))) + else: + if i < npre: + need(is_target(g[1]), 'prelude scalar writes a non-target', i) + for r in touched(g): + climb(r, span(g[-1]), ('A', i)) + levels = {V + int(t): span(U) for t, U in w['target_levels'].items()} + need(all(current[t] == levels.get(t, ZERO) for t in range(V, 2 * V)), 'target cut levels') + for q, U in zip(w['centers'], w['center_frames']): + U = span(U) + need(current[q] == U, 'centre entry frame', q) + served = {levels.get(g[1], ZERO) for g in w['cut'] if g[2] == q} + for T in sorted(served, key=lambda m: -dim(m)): + need(T & ~U == 0, 'centre descent not nested', q) + d = dim(U) - dim(T) + if d: + bill[d] += 1 + chain.setdefault(q, []).append((('centre',), d, T)) + U = T + at = {} + for k, rec in enumerate(warps, 1): + at.setdefault(rec[0], []).append(k) + for p in range(len(B) + 1): + for k in at.get(p, ()): + _, lender, _, U, E = warps[k - 1] + need(current[lender] == span(U), 'native warp entry frame', k, lender) + current[lender] = span(E) + chain.setdefault(lender, []).append((('warp', k), 'warp', span(E))) + if p < len(B): + for r in touched(B[p]): + climb(r, span(B[p][-1]), ('B', p)) + for i, g in enumerate(w['restore']): + for r in touched(g): + climb(r, span(g[-1]), ('restore', i)) + for r in live: + climb(r, end[r], ('end',)) + restored = set(map(int, w['helper_final'])) + need(all(end[r] == FULL for r in live if r not in restored and not is_target(r)), 'a FULL-cleanup register ends low') + widths = Counter(dim(end[r]) - dim(start[r]) for r in live if r >= 2 * V) + return dict(sorted(bill.items())), dict(sorted(widths.items())), chain, start, end + + +def hygiene(w): + """Inherited structural contract: dyadic scalars, power-of-two scales, wrapper and correction access.""" + entering = set(map(int, w['start_extra'])) + restored = set(map(int, w['helper_final'])) + live = set(range(N)) - set(w['removed']) + for name in ('precondition', 'compensation', 'A', 'cut', 'B', 'restore', 'cleanup'): + for g in w[name]: + if g[0] == 'warp': + continue + q = Q(g[3], g[4]) if g[0] == 'add' else Q(g[2], g[3]) + need(q != 0 and q.denominator & (q.denominator - 1) == 0, 'non-dyadic scalar', name, g) + if g[0] == 'scale': + need(abs(q.numerator) & (abs(q.numerator) - 1) == 0, 'non power-of-two scale', name, g) + for g in w['precondition'] + w['compensation']: + need(not any(r in entering | restored for r in touched(g)), 'wrapper touches an entering or restored helper', g) + for c in w['initial_corrections']: + word = c['operator_word'] + need(is_target(c['target']) and c['source'] in live and c['source'] >= 2 * V + and c['source'] not in entering, 'correction access', c) + need(word and all(w['warps'][abs(o) - 1][1] == c['source'] for o in word), 'correction operator lender', c) + q = Q(c['coefficient']) + need(q != 0 and q.denominator & (q.denominator - 1) == 0, 'correction coefficient', c) + return True + + +# ---------------------------------------------------------------------------- +# Literal inverse cleanup, derived from the contract +# ---------------------------------------------------------------------------- +def ordinary_forward(w): + """Chronological non-wrapper actions whose inverse forms cleanup.""" + out = [g for g in w['A'][w['prelude_events']:]] + at = {} + for k, rec in enumerate(w['warps'], 1): + at.setdefault(rec[0], []).append(['warp', rec[1], k]) + for p in range(len(w['B']) + 1): + out += at.get(p, []) + if p < len(w['B']): + out.append(w['B'][p]) + return out + list(w['restore']) + + +def derive_cleanup(w): + restored = set(map(int, w['helper_final'])) + buf = lambda r: r + N if r in restored else r + full = [256, 128, 64, 32, 16, 8, 4, 2, 1] + out = [] + for g in reversed(ordinary_forward(w)): + if g[0] == 'warp': + out.append(['warp', buf(g[1]), -g[2], full]) + elif is_target(g[1]): + continue + elif g[0] == 'add': + out.append(['add', buf(g[1]), buf(g[2]), -g[3], g[4], full]) + else: + need(g[0] == 'scale', 'unknown primitive', g) + out.append(['scale', buf(g[1]), g[3], g[2], full]) + return out + + +def same_cleanup(a, b): + norm = lambda c: [(g[:-1], span(g[-1])) for g in c] + return len(a) == len(b) and norm(a) == norm(b) + + +# ---------------------------------------------------------------------------- +# Exact free-operator semantics. A value is a dict {(input, word): Fraction}; +# word is a reduced tuple of signed operator ids (leftmost = applied last). +# ---------------------------------------------------------------------------- +def program(w, cleanup=None): + """Literal executed sequence: corrections, wrapper, A, cut, B+warps, restore | cleanup.""" + items = [('corr', c['target'], c['source'], tuple(c['operator_word']), Q(c['coefficient'])) + for c in w['initial_corrections']] + items += w['precondition'] + w['compensation'] + w['A'] + w['cut'] + at = {} + for k, rec in enumerate(w['warps'], 1): + at.setdefault(rec[0], []).append(['warp', rec[1], k]) + for p in range(len(w['B']) + 1): + items += at.get(p, []) + if p < len(w['B']): + items.append(w['B'][p]) + items += w['restore'] + return items, list(w['cleanup'] if cleanup is None else cleanup) + + +def dual_op(op): + return (1 if op > 0 else -1) * (abs(op) + DUAL) + + +def _left(op, word): + return word[1:] if word and word[0] == -op else (op,) + word + + +def _right(word, op): + return word[:-1] if word and word[-1] == -op else word + (op,) + + +def _axpy(dst, src, q): + for key, x in src.items(): + y = dst.get(key, 0) + q * x + if y: + dst[key] = y + else: + dst.pop(key, None) + + +def forward_rows(w, cleanup=None, dual=False, symbolic_buffers=True, snapshot=None): + """Schrodinger pass: every register's value as a combination of initial inputs. + + Live inputs are independent symbols. Private buffers are independent symbols + when symbolic_buffers is set (dirty), otherwise zero. The optional snapshot + callback sees the rows at the cleanup boundary. + """ + removed = set(w['removed']) + live = [r for r in range(N) if r not in removed] + restored = sorted(map(int, w['helper_final'])) + rows = {r: {(r, ()): Q(1)} for r in live} + for c in restored: + rows[c + N] = {(c + N, ()): Q(1)} if symbolic_buffers else {} + prefix, tail = program(w, cleanup) + + def apply(g): + kind = g[0] + if kind == 'add': + t, s, q = g[1], g[2], Q(g[3], g[4]) + need(t != s and q, 'add gate', g) + if dual: + t, s, q = s, t, -q + _axpy(rows[t], rows[s], q) + elif kind == 'scale': + q = Q(g[2], g[3]) + need(q != 0, 'zero scale', g) + if dual: + q = 1 / q + rows[g[1]] = {k: q * x for k, x in rows[g[1]].items()} + elif kind == 'warp': + op = dual_op(g[2]) if dual else g[2] + rows[g[1]] = {(var, _left(op, word)): x for (var, word), x in rows[g[1]].items()} + elif kind == 'corr': + _, t, s, word, c = g + if dual: + src, ops, dst, c = rows[t], [-dual_op(o) for o in word], s, -c + else: + src, ops, dst = rows[s], list(reversed(word)), t + moved = {} + for (var, wd), x in src.items(): + for o in ops: + wd = _left(o, wd) + moved[var, wd] = x + _axpy(rows[dst], moved, c) + else: + raise AuditFailure('unknown primitive ' + repr(g)) + + for g in prefix: + apply(g) + if snapshot is not None: + snapshot(rows) + for g in tail: + apply(g) + return rows + + +def reverse_columns(w, cleanup=None, upto_cleanup=False): + """Heisenberg pull-back: process the forward program backwards. + + cols[s] = {(output, word): coefficient}: the final output register 'output' + contains coefficient*word*x_s. Words grow on the right. Every live input and + every private buffer is an independent symbol. + """ + removed = set(w['removed']) + live = [r for r in range(N) if r not in removed] + restored = sorted(map(int, w['helper_final'])) + regs = live + [c + N for c in restored] + cols = {r: {(r, ()): Q(1)} for r in regs} + prefix, tail = program(w, cleanup) + seq = prefix if upto_cleanup else prefix + tail + for g in reversed(seq): + kind = g[0] + if kind == 'add': + t, s, q = g[1], g[2], Q(g[3], g[4]) + need(t != s and q, 'add gate', g) + _axpy(cols[s], cols[t], q) + elif kind == 'scale': + q = Q(g[2], g[3]) + need(q != 0, 'zero scale', g) + cols[g[1]] = {k: q * x for k, x in cols[g[1]].items()} + elif kind == 'warp': + op = g[2] + cols[g[1]] = {(out, _right(word, op)): x for (out, word), x in cols[g[1]].items()} + elif kind == 'corr': + _, t, s, word, c = g + moved = {} + for (out, wd), x in cols[t].items(): + for o in word: + wd = _right(wd, o) + moved[out, wd] = x + _axpy(cols[s], moved, c) + else: + raise AuditFailure('unknown primitive ' + repr(g)) + return cols + + +def transpose(cols): + rows = {} + for s, col in cols.items(): + for (r, word), x in col.items(): + rows.setdefault(r, {})[s, word] = x + return rows + + +def endpoint_defects(w, rows, dual=False): + """Compare final rows with the contract on the zero-buffer (live-input) domain. + + Returns (bad live registers, dirty buffers, buffer->live leaks, buffer self-map identity). + """ + removed = set(w['removed']) + live = [r for r in range(N) if r not in removed] + restored = sorted(map(int, w['helper_final'])) + bad = [] + for r in live: + expect = {(r, ()): Q(1)} + if dual and r < V: + expect[r + V, ()] = Q(-1) + if not dual and is_target(r): + expect[r - V, ()] = Q(1) + got = {k: x for k, x in rows.get(r, {}).items() if k[0] < N} + if got != expect: + bad.append(r) + dirty = [c for c in restored if any(k[0] < N for k in rows.get(c + N, {}))] + leaks = sorted({r for r in live for k in rows.get(r, {}) if k[0] >= N}) + buffer_identity = all({k: x for k, x in rows.get(c + N, {}).items() if k[0] >= N} == {(c + N, ()): Q(1)} + for c in restored) + return bad, dirty, leaks, buffer_identity + + +def boundary_defects(w, rows): + """Contract at the cleanup boundary (forward): targets sheared, restored helpers clean and isolated.""" + restored = set(map(int, w['helper_final'])) + out = [] + for t in range(V, 2 * V): + if {k: x for k, x in rows[t].items() if k[0] < N} != {(t, ()): Q(1), (t - V, ()): Q(1)}: + out.append(('target', t)) + for c in restored: + if rows[c] != {(c, ()): Q(1)}: + out.append(('restored', c)) + for r, row in rows.items(): + if r < N and r not in restored and any(k[0] in restored for k in row): + out.append(('restored input read', r)) + return out diff --git a/research/warp0-entrance-cap/test_cli.py b/research/warp0-entrance-cap/test_cli.py new file mode 100644 index 0000000000..a75031da95 --- /dev/null +++ b/research/warp0-entrance-cap/test_cli.py @@ -0,0 +1,71 @@ +"""Real optimized/unoptimized CLI controls. ToikY/Codex, Apache-2.0.""" +from pathlib import Path +import json +import os +import shutil +import subprocess +import sys +import tempfile +ROOT = Path(__file__).resolve().parent + +def need(ok, message): + if not ok: + raise ValueError(message) + +def run(root, checker, optimized, expected): + args = [sys.executable, '-I', '-Werror', '-B'] + (['-O'] if optimized else []) + args.append(str(root / checker)) + if checker == 'independent.py': + args += ['--word', str(root / 'source/inputs/BASE-WORD.json.gz'), + '--check', str(root / 'INDEPENDENT-RESULT.json')] + proc = subprocess.run(args, text=True, stdout=subprocess.PIPE, + stderr=subprocess.PIPE, timeout=30) + need((proc.returncode == 0) == expected, + f'{checker} optimized={optimized} expected={expected}: {proc.stdout}{proc.stderr}') + if expected: + need('PASS_' in proc.stdout, 'positive receipt') + +def mutate(root, case): + if case == 'source': + path = root / 'source/inputs/BASE-WORD.json.gz' + raw = bytearray(path.read_bytes()); raw[-1] ^= 1 + path.write_bytes(raw) + elif case in ('primary-price', 'independent-cap'): + path = root / ('RESULT.json' if case == 'primary-price' else 'INDEPENDENT-RESULT.json') + data = json.loads(path.read_text()) + if case == 'primary-price': + data['canonical_delta']['1'] += 1 + else: + data['maximal_entrance'] = [261, 133, 85, 45] + path.write_text(json.dumps(data)) + elif case == 'missing-primary': + (root / 'RESULT.json').unlink() + elif case == 'missing-independent': + (root / 'INDEPENDENT-RESULT.json').unlink() + else: + raise ValueError(case) + +def main(): + checks = 0 + for optimized in (False, True): + for checker in ('verify.py', 'independent.py'): + run(ROOT, checker, optimized, True); checks += 1 + for case, checkers in ( + ('source', ('verify.py', 'independent.py')), + ('primary-price', ('verify.py',)), + ('independent-cap', ('verify.py', 'independent.py')), + ('missing-primary', ('verify.py',)), + ('missing-independent', ('verify.py', 'independent.py'))): + with tempfile.TemporaryDirectory(prefix='warp0-cli-') as temp: + owned = Path(temp) / 'package' + shutil.copytree(ROOT, owned, ignore=shutil.ignore_patterns('__pycache__', '*.pyc')) + # Registry exports are read-only; mutate only owned copies. + os.chmod(owned, 0o755) + for child in owned.rglob('*'): + os.chmod(child, 0o755 if child.is_dir() else 0o644) + mutate(owned, case) + for checker in checkers: + run(owned, checker, optimized, False); checks += 1 + print(json.dumps({'status': 'PASS_WARP_ZERO_REAL_CLI_CONTROLS', 'checks': checks}, sort_keys=True)) +if __name__ == '__main__': + main() diff --git a/research/warp0-entrance-cap/verify.py b/research/warp0-entrance-cap/verify.py new file mode 100644 index 0000000000..9a5fdcdcdb --- /dev/null +++ b/research/warp0-entrance-cap/verify.py @@ -0,0 +1,363 @@ +"""Point-set forward closure of the zero-based native warp0 entrance. + +ToikY with substantial OpenAI Codex assistance. Apache-2.0. +The backward checker uses separate binary Gaussian elimination and imports +neither this file nor any retained executable. +""" +from collections import Counter +from functools import lru_cache +from pathlib import Path +import argparse +import copy +import gzip +import hashlib +import importlib.util +import json +import sys + +ROOT = Path(__file__).resolve().parent +ZERO = 1 +FULL = (1 << 512) - 1 +BASE_BLOB = '674ea18ade4af85ca865fb08dc973637a09e30e6' + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +@lru_cache(maxsize=None) +def points(mask): + answer = [] + while mask: + low = mask & -mask + answer.append(low.bit_length() - 1) + mask ^= low + return tuple(answer) + + +def dimension(mask): + n = mask.bit_count() + need(n > 0 and n & (n - 1) == 0, 'subspace size') + return n.bit_length() - 1 + + +@lru_cache(maxsize=None) +def span(vectors): + current = {0} + for v in vectors: + need(type(v) is int and 0 <= v < 512, 'binary vector') + current |= {x ^ v for x in current} + return sum(1 << x for x in current) + + +@lru_cache(maxsize=None) +def join(a, b): + if a & ~b == 0: + return b + if b & ~a == 0: + return a + for v in points(b): + if not (a >> v) & 1: + a |= sum(1 << (x ^ v) for x in points(a)) + return a + + +def basis(mask): + out, seen = [], ZERO + for x in points(mask): + if not (seen >> x) & 1: + out.append(x) + seen = join(seen, span((x,))) + need(seen == mask, 'basis spans frame') + return out + + +@lru_cache(maxsize=None) +def images(columns): + need(len(columns) == 9, 'native columns') + out = [0] * 512 + for x in range(1, 512): + low = x & -x + out[x] = out[x ^ low] ^ columns[low.bit_length() - 1] + need(len(set(out)) == 512, 'invertible native map') + return tuple(out) + + +def image(columns, mask): + table = images(tuple(columns)) + return sum(1 << table[x] for x in points(mask)) + + +def touched(gate): + need(gate[0] in ('add', 'scale'), 'scalar opcode') + return gate[1:3] if gate[0] == 'add' else gate[1:2] + + +def load_word(): + origin = json.loads((ROOT / 'ORIGINS.json').read_text()) + need(origin['head'] == '0c0e31cf12e8f4f07e8419a6d33ae85129fb5a01', 'source head') + for row in origin['files']: + path = (ROOT / 'source' / row['path']).resolve() + need(path.is_relative_to(ROOT / 'source') and path.is_file(), 'source path') + raw = path.read_bytes() + need(hashlib.sha256(raw).hexdigest() == row['sha256'], 'source hash') + need(hashlib.sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() == row['git_blob'], 'source blob') + raw = (ROOT / 'source/inputs/BASE-WORD.json.gz').read_bytes() + need(hashlib.sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() == BASE_BLOB, 'immutable base') + return json.loads(gzip.decompress(raw)) + + +def endpoint_caps(word): + caps = {r: FULL for r in range(704) if r not in word['removed']} + for r in range(112, 224): + port = word['ports'][r - 112] + caps[r] = sum(1 << x for x in range(512) if (port & x).bit_count() % 2 == 0) + for r, vectors in word['helper_final'].items(): + caps[int(r)] = span(tuple(vectors)) + return caps + + +def prefix(word): + current = {r: span((word['ports'][r],)) if r < 112 else ZERO + for r in range(704) if r not in word['removed']} + for r, frame in word['start_extra'].items(): + current[int(r)] = span(tuple(frame)) + bill = Counter() + def climb(r, frame): + need(current[r] & ~frame == 0, 'frozen prefix containment') + d = dimension(frame) - dimension(current[r]) + if d: + bill[d] += 1 + current[r] = frame + for gate in word['A']: + if gate[0] == 'warp': + _, r, op, before, after = gate + need(current[r] == span(tuple(before)), 'prelude entrance') + columns = word['warps'][abs(op) - 1][2] + table = images(tuple(columns)) + if op < 0: + inv = [0] * 512 + for x, y in enumerate(table): + inv[y] = x + transformed = sum(1 << inv[x] for x in points(current[r])) + else: + transformed = image(columns, current[r]) + need(transformed == span(tuple(after)), 'prelude transport') + current[r] = transformed + else: + for r in touched(gate): + climb(r, span(tuple(gate[-1]))) + levels = {112 + int(r): span(tuple(f)) for r, f in word['target_levels'].items()} + need(all(current[r] == levels.get(r, ZERO) for r in range(112, 224)), 'target cut') + # Preserve source frame_bill's temporary-descent accounting convention. + for r, vectors in zip(word['centers'], word['center_frames']): + local = span(tuple(vectors)) + need(current[r] == local, 'centre entry') + served = {levels.get(g[1], ZERO) for g in word['cut'] if g[2] == r} + for frame in sorted(served, key=lambda f: -dimension(f)): + need(frame & ~local == 0, 'centre nesting') + d = dimension(local) - dimension(frame) + if d: + bill[d] += 1 + local = frame + position = word['warps'][0][0] + need(position == 916 and word['warps'][0][1] == 243, 'frozen selected warp') + earlier = {} + for k, record in enumerate(word['warps']): + if record[0] < position: + earlier.setdefault(record[0], []).append(k) + for i, gate in enumerate(word['B'][:position]): + for k in earlier.get(i, []): + _, r, columns, before, after = word['warps'][k] + need(current[r] == span(tuple(before)), 'earlier B native entrance') + current[r] = image(columns, current[r]) + need(current[r] == span(tuple(after)), 'earlier B native exit') + for r in touched(gate): + climb(r, span(tuple(gate[-1]))) + need(current[243] == span(tuple(word['warps'][0][3])), 'warp0 original entrance') + return current, bill + + +def closure(word, entrance): + current, bill = prefix(word) + at = {} + for k, record in enumerate(word['warps']): + at.setdefault(record[0], []).append(k) + scalar_edits, warp_edits, identities = [], [], [] + def scalar(g, section, i): + frame = span(tuple(g[-1])) + for r in touched(g): + frame = join(frame, current[r]) + if frame != span(tuple(g[-1])): + scalar_edits.append({'section': section, 'index': i, 'old': g[-1], 'new': basis(frame)}) + for r in touched(g): + d = dimension(frame) - dimension(current[r]) + if d: + bill[d] += 1 + current[r] = frame + for i in range(word['warps'][0][0], len(word['B']) + 1): + for k in at.get(i, []): + old = word['warps'][k] + frame = entrance if k == 0 else join(span(tuple(old[3])), current[old[1]]) + need(current[old[1]] & ~frame == 0, 'entrance contains current') + if frame != current[old[1]]: + d = dimension(frame) - dimension(current[old[1]]) + bill[d] += 1 + identities.append({'warp': k, 'register': old[1], 'rank': d}) + exit_frame = image(old[2], frame) + if frame != span(tuple(old[3])): + warp_edits.append({'index': k, 'old': old[3:], 'new': [basis(frame), basis(exit_frame)]}) + current[old[1]] = exit_frame + if i < len(word['B']): + scalar(word['B'][i], 'B', i) + for i, gate in enumerate(word['restore']): + scalar(gate, 'restore', i) + for r, cap in sorted(endpoint_caps(word).items()): + if current[r] & ~cap: + return {'accepted': False, 'failure_register': r, + 'violating_vector': points(current[r] & ~cap)[0]} + d = dimension(cap) - dimension(current[r]) + if d: + bill[d] += 1 + return {'accepted': True, 'profile': dict(sorted(bill.items())), + 'recipe': {'scalar_edits': scalar_edits, 'warp_edits': warp_edits}, 'identities': identities} + + +def compute(word): + u = span(tuple(word['warps'][0][3])) + base = closure(word, u) + need(base['accepted'] and base['recipe'] == {'scalar_edits': [], 'warp_edits': []} + and not base['identities'], 'literal baseline control') + representatives = {} + for v in range(512): + space = join(u, span((v,))) + if dimension(space) == 5: + representatives.setdefault(space, v) + need(len(representatives) == 31, 'complete quotient line domain') + rows, allowed = [], u + for space, v in sorted(representatives.items(), key=lambda row: row[1]): + result = closure(word, space) + if result['accepted']: + allowed = join(allowed, space) + rows.append({'representative': v, 'entrance_points': list(points(space)), **result}) + accepted = [r for r in rows if r['accepted']] + need(len(accepted) == 1 and accepted[0]['representative'] == 7, 'sole allowed direction') + new = accepted[0] + delta = {r: new['profile'].get(r, 0) - base['profile'].get(r, 0) + for r in set(new['profile']) | set(base['profile'])} + delta = {r: n for r, n in sorted(delta.items()) if n} + need(delta == {1: 27, 2: -14, 3: -1, 4: 1}, 'canonical complete profile') + need(sum(r * n for r, n in delta.items()) == 0, 'rank mass preserved') + need(not any(e['section'] == 'restore' and e['index'] == 191 + for e in new['recipe']['scalar_edits']), 'centre restore unchanged') + # For q in (0,1): delta(q)=(2-2^q)(12-2^q)+(3-3^q)>0. + need([2 * 12 + 3, -12 - 2, -1, 1] == [27, -14, -1, 1], 'factor identity') + need(sum(n * min(r, 2) for r, n in delta.items()) == -1, + 'control: result does not imply every concave tariff loses') + independent = json.loads((ROOT / 'INDEPENDENT-RESULT.json').read_text()) + need(span(tuple(independent['maximal_entrance'])) == allowed, 'independent backward cap') + need(independent['rejected_quotient_lines'] == 30, 'independent exclusion count') + independent_rows = {r['representative']: r for r in independent['extensions']} + for row in rows: + other = independent_rows[row['representative']] + need(span(tuple(other['entrance'])) == span(tuple(row['entrance_points'])), 'independent domain') + need(row['accepted'] == other['accepted'], 'independent directional outcome') + # Gaussian binomial counts for subspaces of the five-dimensional quotient. + subspace_counts = [] + for k in range(6): + numerator = denominator = 1 + for i in range(k): + numerator *= 2 ** (5 - i) - 1 + denominator *= 2 ** (k - i) - 1 + need(numerator % denominator == 0, 'integral subspace count') + subspace_counts.append(numerator // denominator) + need(subspace_counts == [1, 31, 155, 155, 31, 1], 'complete entrance lattice') + return {'status': 'PASS_WARP_ZERO_ENTRANCE_CAP', 'source_blob': BASE_BLOB, + 'original_entrance_points': list(points(u)), 'maximal_entrance_points': list(points(allowed)), + 'maximal_dimension': dimension(allowed), 'quotient_lines': len(rows), 'rejected_lines': 30, + 'all_superframes_count': sum(subspace_counts), 'superframes_by_quotient_dimension': subspace_counts, + 'admissible_superframes_count': 2, + 'baseline_profile': base['profile'], 'canonical_profile': new['profile'], 'canonical_delta': delta, + 'canonical_recipe': new['recipe'], 'paid_identities': new['identities'], + 'restore191_unchanged': True, 'extensions': rows, + 'strict_all_power_loss': '27-14*2^q-3^q+4^q=(2-2^q)(12-2^q)+(3-3^q)>0 for0 0, 'strictly nonminimal published frames') + difference = {r: bill.get(r, 0) - published_bill.get(r, 0) for r in set(bill) | set(published_bill)} + difference = {r: n for r, n in sorted(difference.items()) if n} + need(difference == {1: -1, 2: 2, 3: 3, 4: -3}, 'nonminimal published price control') + caps = [sum(n * min(r, t) for r, n in difference.items()) for t in range(1, 5)] + need(caps == [1, 3, 3, 0], 'strict concavity cost countercontrol') + return {'source_compiler_and_bill': True, 'forward_dual_cleanup': True, + 'native_phases_rerun': False, 'inventory': inventory, + 'published_profile': published_bill, 'canonical_minus_published': difference, + 'difference_capped_sums': caps, + 'strictly_larger_published_scalar_frames': strict_frames, + 'nonminimal_published_completion_strictly_cheaper_for_all_powers': True} + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--write', action='store_true') + parser.add_argument('--geometry-only', action='store_true') + args = parser.parse_args() + word = load_word() + result = compute(word) + if not args.geometry_only: + result['source_crosscheck'] = source_crosscheck(word, result) + target = ROOT / 'RESULT.json' + if args.write: + need(not args.geometry_only, 'full crosscheck required') + target.write_text(json.dumps(result, sort_keys=True, indent=2) + '\n') + else: + saved = json.loads(target.read_text()) + if args.geometry_only: + saved.pop('source_crosscheck', None) + need(json.dumps(saved, sort_keys=True) == json.dumps(result, sort_keys=True), 'complete result receipt') + print(json.dumps({'status': result['status'], 'dimension': result['maximal_dimension'], + 'rejected_lines': result['rejected_lines'], 'delta': result['canonical_delta']}, sort_keys=True)) + + +if __name__ == '__main__': + main()