diff --git a/research/gaussian-root-retirement/CONTROLLER.json b/research/gaussian-root-retirement/CONTROLLER.json new file mode 100644 index 0000000000..1214da5121 --- /dev/null +++ b/research/gaussian-root-retirement/CONTROLLER.json @@ -0,0 +1,4405 @@ +{ + "schema": "mixed-projector-query-root/2", + "roles": 35, + "stages": 18, + "ambient_rank": 153, + "nodes": [ + { + "roles": [ + 6, + 7 + ], + "stages": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "exponent": 1 + }, + { + "roles": [ + 8, + 9 + ], + "stages": [ + 1, + 2, + 3 + ], + "exponent": -1 + }, + { + "roles": [ + 10, + 11 + ], + "stages": [ + 2, + 3 + ], + "exponent": -1 + }, + { + "roles": [ + 12, + 13 + ], + "stages": [ + 4, + 5, + 6, + 7 + ], + "exponent": 1 + }, + { + "roles": [ + 14, + 15 + ], + "stages": [ + 4, + 5 + ], + "exponent": -1 + }, + { + "roles": [ + 16, + 17 + ], + "stages": [ + 6, + 7 + ], + "exponent": 1 + }, + { + "roles": [ + 18, + 19 + ], + "stages": [ + 8, + 9 + ], + "exponent": 1 + }, + { + "roles": [ + 20, + 21 + ], + "stages": [ + 10, + 11 + ], + "exponent": 1 + }, + { + "roles": [ + 22, + 23 + ], + "stages": [ + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ], + "exponent": 1 + }, + { + "roles": [ + 24, + 25 + ], + "stages": [ + 12, + 13, + 14 + ], + "exponent": -1 + }, + { + "roles": [ + 26, + 27 + ], + "stages": [ + 13, + 14 + ], + "exponent": -1 + }, + { + "roles": [ + 28, + 29 + ], + "stages": [ + 15, + 16, + 17, + 18 + ], + "exponent": 1 + }, + { + "roles": [ + 30, + 31 + ], + "stages": [ + 15, + 16 + ], + "exponent": -1 + }, + { + "roles": [ + 32, + 33 + ], + "stages": [ + 17, + 18 + ], + "exponent": 1 + } + ], + "events": [ + [ + "ADD", + 4, + 20, + "-1" + ], + [ + "LAMBDA", + 4, + -1 + ], + [ + "ADD", + 21, + 4, + "-1" + ], + [ + "LAMBDA", + 4, + 1 + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 4, + 5, + "-3" + ], + [ + "ADD", + 3, + 5, + "1" + ], + [ + "ADD", + 2, + 5, + "-3" + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 0, + 5, + "2" + ], + [ + "ADD", + 2, + 4, + "-2" + ], + [ + "ADD", + 0, + 4, + "1" + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 5, + 3, + "2" + ], + [ + "ADD", + 2, + 3, + "-2" + ], + [ + "ADD", + 0, + 3, + "1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 5, + 2, + "1" + ], + [ + "ADD", + 0, + 2, + "1/2" + ], + [ + "SCALE", + 2, + "-1/2" + ], + [ + "ADD", + 4, + 1, + "-1" + ], + [ + "ADD", + 3, + 1, + "1" + ], + [ + "ADD", + 2, + 1, + "-1/2" + ], + [ + "ADD", + 0, + 1, + "-1/2" + ], + [ + "ADD", + 4, + 0, + "2" + ], + [ + "ADD", + 3, + 0, + "-2" + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "ADD", + 1, + 0, + "-2" + ], + [ + "SCALE", + 0, + "2" + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 0, + 5, + "-2" + ], + [ + "ADD", + 1, + 4, + "1" + ], + [ + "ADD", + 0, + 4, + "-2" + ], + [ + "ADD", + 1, + 3, + "1" + ], + [ + "ADD", + 0, + 3, + "-3" + ], + [ + "ADD", + 1, + 2, + "1" + ], + [ + "ADD", + 0, + 2, + "-2" + ], + [ + "ADD", + 4, + 1, + "2" + ], + [ + "ADD", + 3, + 1, + "-2" + ], + [ + "ADD", + 2, + 1, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "SWAP", + 0, + 7 + ], + [ + "SWAP", + 1, + 6 + ], + [ + "SWAP", + 6, + 7 + ], + [ + "ADD", + 0, + 6, + 1 + ], + [ + "ADD", + 7, + 1, + -1 + ], + [ + "QUERY", + 6, + 7, + -1 + ], + [ + "ADD", + 7, + 1, + 1 + ], + [ + "ADD", + 0, + 6, + -1 + ], + [ + "IDLE", + 6, + 7, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 1, + 9 + ], + [ + "SWAP", + 0, + 8 + ], + [ + "SWAP", + 8, + 9 + ], + [ + "ADD", + 1, + 8, + 1 + ], + [ + "ADD", + 9, + 0, + -1 + ], + [ + "QUERY", + 8, + 9, + 1 + ], + [ + "ADD", + 9, + 0, + 1 + ], + [ + "ADD", + 1, + 8, + -1 + ], + [ + "IDLE", + 8, + 9, + [ + 1, + 2, + 3 + ] + ], + [ + "SCALE", + 0, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 1, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "SCALE", + 0, + -1 + ], + [ + "SWAP", + 1, + 11 + ], + [ + "SWAP", + 0, + 10 + ], + [ + "SWAP", + 10, + 11 + ], + [ + "ADD", + 1, + 10, + 1 + ], + [ + "ADD", + 11, + 0, + -1 + ], + [ + "QUERY", + 10, + 11, + 1 + ], + [ + "ADD", + 11, + 0, + 1 + ], + [ + "ADD", + 1, + 10, + -1 + ], + [ + "IDLE", + 10, + 11, + [ + 2, + 3 + ] + ], + [ + "SCALE", + 0, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 2, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "SCALE", + 0, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 3, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "ADD", + 1, + 10, + 1 + ], + [ + "SCALE", + 10, + -1 + ], + [ + "ADD", + 10, + 1, + 1 + ], + [ + "SWAP", + 0, + 11 + ], + [ + "SCALE", + 11, + -1 + ], + [ + "ADD", + 11, + 0, + 1 + ], + [ + "ADD", + 1, + 8, + 1 + ], + [ + "SCALE", + 8, + -1 + ], + [ + "ADD", + 8, + 1, + 1 + ], + [ + "SWAP", + 0, + 9 + ], + [ + "SCALE", + 9, + -1 + ], + [ + "ADD", + 9, + 0, + 1 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 13 + ], + [ + "SWAP", + 1, + 12 + ], + [ + "SWAP", + 12, + 13 + ], + [ + "ADD", + 0, + 12, + 1 + ], + [ + "ADD", + 13, + 1, + -1 + ], + [ + "QUERY", + 12, + 13, + -1 + ], + [ + "ADD", + 13, + 1, + 1 + ], + [ + "ADD", + 0, + 12, + -1 + ], + [ + "IDLE", + 12, + 13, + [ + 4, + 5, + 6, + 7 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 1, + 15 + ], + [ + "SWAP", + 0, + 14 + ], + [ + "SWAP", + 14, + 15 + ], + [ + "ADD", + 1, + 14, + 1 + ], + [ + "ADD", + 15, + 0, + -1 + ], + [ + "QUERY", + 14, + 15, + 1 + ], + [ + "ADD", + 15, + 0, + 1 + ], + [ + "ADD", + 1, + 14, + -1 + ], + [ + "IDLE", + 14, + 15, + [ + 4, + 5 + ] + ], + [ + "SCALE", + 0, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 4, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "SCALE", + 0, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 5, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "ADD", + 1, + 14, + 1 + ], + [ + "SCALE", + 14, + -1 + ], + [ + "ADD", + 14, + 1, + 1 + ], + [ + "SWAP", + 0, + 15 + ], + [ + "SCALE", + 15, + -1 + ], + [ + "ADD", + 15, + 0, + 1 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 17 + ], + [ + "SWAP", + 1, + 16 + ], + [ + "SWAP", + 16, + 17 + ], + [ + "ADD", + 0, + 16, + 1 + ], + [ + "ADD", + 17, + 1, + -1 + ], + [ + "QUERY", + 16, + 17, + -1 + ], + [ + "ADD", + 17, + 1, + 1 + ], + [ + "ADD", + 0, + 16, + -1 + ], + [ + "IDLE", + 16, + 17, + [ + 6, + 7 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 6, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 7, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "ADD", + 0, + 16, + 1 + ], + [ + "SCALE", + 16, + -1 + ], + [ + "ADD", + 16, + 0, + 1 + ], + [ + "SWAP", + 1, + 17 + ], + [ + "SCALE", + 17, + -1 + ], + [ + "ADD", + 17, + 1, + 1 + ], + [ + "ADD", + 0, + 12, + 1 + ], + [ + "SCALE", + 12, + -1 + ], + [ + "ADD", + 12, + 0, + 1 + ], + [ + "SWAP", + 1, + 13 + ], + [ + "SCALE", + 13, + -1 + ], + [ + "ADD", + 13, + 1, + 1 + ], + [ + "ADD", + 0, + 6, + 1 + ], + [ + "SCALE", + 6, + -1 + ], + [ + "ADD", + 6, + 0, + 1 + ], + [ + "SWAP", + 1, + 7 + ], + [ + "SCALE", + 7, + -1 + ], + [ + "ADD", + 7, + 1, + 1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + -1 + ], + [ + "ADD", + 4, + 5, + "-2" + ], + [ + "ADD", + 3, + 5, + "2" + ], + [ + "ADD", + 2, + 5, + "-1" + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 0, + 5, + "2" + ], + [ + "ADD", + 3, + 4, + "1/2" + ], + [ + "ADD", + 2, + 4, + "-1/2" + ], + [ + "ADD", + 1, + 4, + "1/2" + ], + [ + "ADD", + 0, + 4, + "3/2" + ], + [ + "SCALE", + 4, + "1/2" + ], + [ + "ADD", + 4, + 3, + "3" + ], + [ + "ADD", + 2, + 3, + "-1" + ], + [ + "ADD", + 1, + 3, + "1" + ], + [ + "ADD", + 0, + 3, + "5" + ], + [ + "SCALE", + 3, + "-2" + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 4, + 2, + "-1" + ], + [ + "ADD", + 3, + 2, + "1" + ], + [ + "ADD", + 1, + 2, + "1/2" + ], + [ + "ADD", + 0, + 2, + "2" + ], + [ + "SCALE", + 2, + "1/2" + ], + [ + "ADD", + 4, + 1, + "2" + ], + [ + "ADD", + 3, + 1, + "-2" + ], + [ + "ADD", + 2, + 1, + "1" + ], + [ + "SCALE", + 1, + "-2" + ], + [ + "ADD", + 2, + 5, + "1" + ], + [ + "ADD", + 2, + 4, + "1" + ], + [ + "ADD", + 2, + 3, + "2" + ], + [ + "ADD", + 1, + 3, + "-1" + ], + [ + "ADD", + 0, + 3, + "1" + ], + [ + "ADD", + 4, + 2, + "2" + ], + [ + "ADD", + 3, + 2, + "-2" + ], + [ + "ADD", + 0, + 2, + "-1" + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "SWAP", + 0, + 19 + ], + [ + "SWAP", + 1, + 18 + ], + [ + "SWAP", + 18, + 19 + ], + [ + "ADD", + 0, + 18, + 1 + ], + [ + "ADD", + 19, + 1, + -1 + ], + [ + "QUERY", + 18, + 19, + -1 + ], + [ + "ADD", + 19, + 1, + 1 + ], + [ + "ADD", + 0, + 18, + -1 + ], + [ + "IDLE", + 18, + 19, + [ + 8, + 9 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 8, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 9, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "ADD", + 0, + 18, + 1 + ], + [ + "SCALE", + 18, + -1 + ], + [ + "ADD", + 18, + 0, + 1 + ], + [ + "SWAP", + 1, + 19 + ], + [ + "SCALE", + 19, + -1 + ], + [ + "ADD", + 19, + 1, + 1 + ], + [ + "IDLE_ONE", + 2, + [ + 8, + 9 + ] + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + -1 + ], + [ + "ADD", + 4, + 5, + "-2" + ], + [ + "ADD", + 3, + 5, + "2" + ], + [ + "ADD", + 2, + 5, + "-1" + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 3, + 4, + "3/4" + ], + [ + "ADD", + 2, + 4, + "-1/2" + ], + [ + "ADD", + 1, + 4, + "1/4" + ], + [ + "ADD", + 0, + 4, + "1/4" + ], + [ + "SCALE", + 4, + "1/4" + ], + [ + "ADD", + 4, + 3, + "-3" + ], + [ + "ADD", + 2, + 3, + "2" + ], + [ + "ADD", + 1, + 3, + "1" + ], + [ + "ADD", + 0, + 3, + "-3" + ], + [ + "SCALE", + 3, + "4" + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 4, + 2, + "-2" + ], + [ + "ADD", + 3, + 2, + "2" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "ADD", + 0, + 2, + "2" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "SWAP", + 0, + 1 + ], + [ + "ADD", + 0, + 5, + "-1" + ], + [ + "ADD", + 0, + 4, + "-1" + ], + [ + "ADD", + 0, + 3, + "-1" + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + -1 + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 1, + 4, + "1" + ], + [ + "ADD", + 1, + 3, + "1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "SWAP", + 0, + 2 + ], + [ + "ADD", + 0, + 5, + "-1" + ], + [ + "ADD", + 0, + 4, + "-1" + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + -1 + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 1, + 4, + "1" + ], + [ + "ADD", + 1, + 3, + "-1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "SWAP", + 1, + 3 + ], + [ + "SWAP", + 0, + 3 + ], + [ + "ADD", + 0, + 5, + "-1" + ], + [ + "ADD", + 0, + 3, + "1" + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + -1 + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 1, + 4, + "-1" + ], + [ + "ADD", + 1, + 3, + "-1" + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SWAP", + 2, + 4 + ], + [ + "SWAP", + 1, + 4 + ], + [ + "SWAP", + 0, + 4 + ], + [ + "ADD", + 2, + 4, + "1" + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 2, + 3, + "3/2" + ], + [ + "ADD", + 0, + 3, + "-1/2" + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 5, + 2, + "2" + ], + [ + "ADD", + 4, + 2, + "-2" + ], + [ + "ADD", + 1, + 2, + "-2" + ], + [ + "ADD", + 0, + 2, + "3" + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "SWAP", + 1, + 3 + ], + [ + "ADD", + 5, + 0, + "-2" + ], + [ + "ADD", + 4, + 0, + "2" + ], + [ + "ADD", + 3, + 0, + "2" + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "SWAP", + 0, + 21 + ], + [ + "SWAP", + 1, + 20 + ], + [ + "SWAP", + 20, + 21 + ], + [ + "ADD", + 0, + 20, + 1 + ], + [ + "ADD", + 21, + 1, + -1 + ], + [ + "QUERY", + 20, + 21, + -1 + ], + [ + "ADD", + 4, + 2, + "1" + ], + [ + "ADD", + 2, + 4, + "-1" + ], + [ + "ADD", + 4, + 2, + "1" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 21, + 4, + "1" + ], + [ + "ADD", + 4, + 1, + "1" + ], + [ + "LAMBDA", + 20, + 1 + ], + [ + "ADD", + 4, + 20, + "-1" + ], + [ + "LAMBDA", + 20, + -1 + ], + [ + "ADD", + 4, + 21, + "1" + ], + [ + "ADD", + 34, + 21, + "-1" + ], + [ + "LAMBDA", + 20, + 1 + ], + [ + "ADD", + 34, + 20, + "1" + ], + [ + "LAMBDA", + 20, + -1 + ], + [ + "ADD", + 34, + 1, + "-1" + ], + [ + "ADD", + 21, + 34, + "-1" + ], + [ + "SCALE", + 34, + "-1" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "ADD", + 34, + 2, + "-1" + ], + [ + "ADD", + 2, + 34, + "1" + ], + [ + "ADD", + 34, + 2, + "-1" + ], + [ + "ADD", + 21, + 1, + 1 + ], + [ + "ADD", + 0, + 20, + -1 + ], + [ + "IDLE", + 20, + 21, + [ + 10, + 11 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 10, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 11, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "ADD", + 0, + 20, + 1 + ], + [ + "SCALE", + 20, + -1 + ], + [ + "ADD", + 20, + 0, + 1 + ], + [ + "SWAP", + 1, + 21 + ], + [ + "SCALE", + 21, + -1 + ], + [ + "ADD", + 21, + 1, + 1 + ], + [ + "IDLE_ONE", + 2, + [ + 10, + 11 + ] + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + -1 + ], + [ + "ADD", + 34, + 5, + "1" + ], + [ + "ADD", + 3, + 5, + "1" + ], + [ + "ADD", + 1, + 5, + "1/2" + ], + [ + "SCALE", + 5, + "-1/2" + ], + [ + "ADD", + 5, + 34, + "1/2" + ], + [ + "ADD", + 3, + 34, + "-1" + ], + [ + "ADD", + 2, + 34, + "-1" + ], + [ + "ADD", + 1, + 34, + "-3/2" + ], + [ + "ADD", + 34, + 3, + "1" + ], + [ + "ADD", + 2, + 3, + "1/2" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "ADD", + 5, + 1, + "2" + ], + [ + "ADD", + 34, + 1, + "2" + ], + [ + "ADD", + 3, + 1, + "-2" + ], + [ + "ADD", + 2, + 1, + "1" + ], + [ + "SCALE", + 1, + "-2" + ], + [ + "SWAP", + 0, + 5 + ], + [ + "ADD", + 2, + 5, + "1" + ], + [ + "ADD", + 2, + 34, + "1" + ], + [ + "ADD", + 2, + 3, + "3/2" + ], + [ + "ADD", + 0, + 3, + "-1/2" + ], + [ + "ADD", + 5, + 2, + "-2" + ], + [ + "ADD", + 34, + 2, + "2" + ], + [ + "ADD", + 3, + 2, + "-2" + ], + [ + "ADD", + 1, + 2, + "-2" + ], + [ + "ADD", + 0, + 2, + "3" + ], + [ + "SCALE", + 2, + "2" + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "ADD", + 34, + 0, + "-2" + ], + [ + "ADD", + 3, + 0, + "2" + ], + [ + "ADD", + 2, + 0, + "2" + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "SWAP", + 0, + 23 + ], + [ + "SWAP", + 1, + 22 + ], + [ + "SWAP", + 22, + 23 + ], + [ + "ADD", + 0, + 22, + 1 + ], + [ + "ADD", + 23, + 1, + -1 + ], + [ + "QUERY", + 22, + 23, + -1 + ], + [ + "ADD", + 23, + 1, + 1 + ], + [ + "ADD", + 0, + 22, + -1 + ], + [ + "IDLE", + 22, + 23, + [ + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 1, + 25 + ], + [ + "SWAP", + 0, + 24 + ], + [ + "SWAP", + 24, + 25 + ], + [ + "ADD", + 1, + 24, + 1 + ], + [ + "ADD", + 25, + 0, + -1 + ], + [ + "QUERY", + 24, + 25, + 1 + ], + [ + "ADD", + 25, + 0, + 1 + ], + [ + "ADD", + 1, + 24, + -1 + ], + [ + "IDLE", + 24, + 25, + [ + 12, + 13, + 14 + ] + ], + [ + "SCALE", + 0, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 12, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "SCALE", + 0, + -1 + ], + [ + "SWAP", + 1, + 27 + ], + [ + "SWAP", + 0, + 26 + ], + [ + "SWAP", + 26, + 27 + ], + [ + "ADD", + 1, + 26, + 1 + ], + [ + "ADD", + 27, + 0, + -1 + ], + [ + "QUERY", + 26, + 27, + 1 + ], + [ + "ADD", + 27, + 0, + 1 + ], + [ + "ADD", + 1, + 26, + -1 + ], + [ + "IDLE", + 26, + 27, + [ + 13, + 14 + ] + ], + [ + "SCALE", + 0, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 13, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "SCALE", + 0, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 14, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "ADD", + 1, + 26, + 1 + ], + [ + "SCALE", + 26, + -1 + ], + [ + "ADD", + 26, + 1, + 1 + ], + [ + "SWAP", + 0, + 27 + ], + [ + "SCALE", + 27, + -1 + ], + [ + "ADD", + 27, + 0, + 1 + ], + [ + "ADD", + 1, + 24, + 1 + ], + [ + "SCALE", + 24, + -1 + ], + [ + "ADD", + 24, + 1, + 1 + ], + [ + "SWAP", + 0, + 25 + ], + [ + "SCALE", + 25, + -1 + ], + [ + "ADD", + 25, + 0, + 1 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 29 + ], + [ + "SWAP", + 1, + 28 + ], + [ + "SWAP", + 28, + 29 + ], + [ + "ADD", + 0, + 28, + 1 + ], + [ + "ADD", + 29, + 1, + -1 + ], + [ + "QUERY", + 28, + 29, + -1 + ], + [ + "ADD", + 29, + 1, + 1 + ], + [ + "ADD", + 0, + 28, + -1 + ], + [ + "IDLE", + 28, + 29, + [ + 15, + 16, + 17, + 18 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 1, + 31 + ], + [ + "SWAP", + 0, + 30 + ], + [ + "SWAP", + 30, + 31 + ], + [ + "ADD", + 1, + 30, + 1 + ], + [ + "ADD", + 31, + 0, + -1 + ], + [ + "QUERY", + 30, + 31, + 1 + ], + [ + "ADD", + 31, + 0, + 1 + ], + [ + "ADD", + 1, + 30, + -1 + ], + [ + "IDLE", + 30, + 31, + [ + 15, + 16 + ] + ], + [ + "SCALE", + 0, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 15, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "SCALE", + 0, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 16, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "ADD", + 1, + 30, + 1 + ], + [ + "SCALE", + 30, + -1 + ], + [ + "ADD", + 30, + 1, + 1 + ], + [ + "SWAP", + 0, + 31 + ], + [ + "SCALE", + 31, + -1 + ], + [ + "ADD", + 31, + 0, + 1 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 33 + ], + [ + "SWAP", + 1, + 32 + ], + [ + "SWAP", + 32, + 33 + ], + [ + "ADD", + 0, + 32, + 1 + ], + [ + "ADD", + 33, + 1, + -1 + ], + [ + "QUERY", + 32, + 33, + -1 + ], + [ + "ADD", + 33, + 1, + 1 + ], + [ + "ADD", + 0, + 32, + -1 + ], + [ + "IDLE", + 32, + 33, + [ + 17, + 18 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 17, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 18, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "ADD", + 0, + 32, + 1 + ], + [ + "SCALE", + 32, + -1 + ], + [ + "ADD", + 32, + 0, + 1 + ], + [ + "SWAP", + 1, + 33 + ], + [ + "SCALE", + 33, + -1 + ], + [ + "ADD", + 33, + 1, + 1 + ], + [ + "ADD", + 0, + 28, + 1 + ], + [ + "SCALE", + 28, + -1 + ], + [ + "ADD", + 28, + 0, + 1 + ], + [ + "SWAP", + 1, + 29 + ], + [ + "SCALE", + 29, + -1 + ], + [ + "ADD", + 29, + 1, + 1 + ], + [ + "ADD", + 0, + 22, + 1 + ], + [ + "SCALE", + 22, + -1 + ], + [ + "ADD", + 22, + 0, + 1 + ], + [ + "SWAP", + 1, + 23 + ], + [ + "SCALE", + 23, + -1 + ], + [ + "ADD", + 23, + 1, + 1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + -1 + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 0, + 5, + "2" + ], + [ + "SCALE", + 5, + "-1" + ], + [ + "ADD", + 5, + 34, + "-2" + ], + [ + "ADD", + 1, + 34, + "1" + ], + [ + "ADD", + 0, + 34, + "2" + ], + [ + "ADD", + 5, + 3, + "-2" + ], + [ + "ADD", + 34, + 3, + "1" + ], + [ + "ADD", + 2, + 3, + "-3/2" + ], + [ + "ADD", + 1, + 3, + "1/2" + ], + [ + "ADD", + 0, + 3, + "2" + ], + [ + "SCALE", + 3, + "1/2" + ], + [ + "ADD", + 5, + 2, + "1" + ], + [ + "ADD", + 34, + 2, + "1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "ADD", + 0, + 2, + "-1" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 5, + 1, + "2" + ], + [ + "ADD", + 0, + 1, + "-2" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "ADD", + 5, + 0, + "1" + ], + [ + "ADD", + 34, + 0, + "-1" + ], + [ + "ADD", + 3, + 0, + "1" + ], + [ + "ADD", + 2, + 0, + "-1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 2, + 5, + "1" + ], + [ + "SCALE", + 5, + "-1" + ], + [ + "ADD", + 3, + 34, + "1" + ], + [ + "ADD", + 2, + 34, + "-1/2" + ], + [ + "ADD", + 1, + 34, + "1/2" + ], + [ + "SCALE", + 34, + "-1/2" + ], + [ + "SWAP", + 34, + 5 + ], + [ + "ADD", + 5, + 3, + "1/2" + ], + [ + "ADD", + 2, + 3, + "3/2" + ], + [ + "ADD", + 1, + 3, + "-1/2" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 5, + 2, + "1" + ], + [ + "ADD", + 34, + 2, + "2" + ], + [ + "ADD", + 1, + 2, + "1" + ], + [ + "ADD", + 0, + 2, + "-2" + ], + [ + "SCALE", + 2, + "2" + ], + [ + "ADD", + 5, + 1, + "-1" + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LAMBDA", + 2, + -1 + ], + [ + "LAMBDA", + 3, + -1 + ], + [ + "LAMBDA", + 34, + -1 + ], + [ + "LAMBDA", + 5, + -1 + ], + [ + "LAMBDA", + 34, + 1 + ], + [ + "LAMBDA", + 20, + 1 + ], + [ + "Q_POWER", + 21, + -2 + ], + [ + "LAMBDA", + 21, + 1 + ], + [ + "SCALE", + 34, + "-1" + ], + [ + "LAMBDA", + 34, + -1 + ], + [ + "ADD", + 21, + 34, + "1" + ], + [ + "LAMBDA", + 34, + 1 + ], + [ + "ADD", + 34, + 20, + "1" + ], + [ + "LAMBDA", + 4, + -1 + ], + [ + "LAMBDA", + 20, + -1 + ], + [ + "LAMBDA", + 21, + -1 + ] + ], + "diagonal": [ + [ + -1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ] +} diff --git a/research/gaussian-root-retirement/NOTICE b/research/gaussian-root-retirement/NOTICE new file mode 100644 index 0000000000..6b0ca905ea --- /dev/null +++ b/research/gaussian-root-retirement/NOTICE @@ -0,0 +1,25 @@ +New Gaussian retirement construction, proof, caller checks and package: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents or independent scientific review are claimed. + +Retained sources are byte-exact in native-source.tar and engines.tar. +RETAINED.json records every original path, head, Git blob and SHA256. +Original source headers, proof files and notices remain in the archives. + +https://github.com/CrocSwap/integer-mult-bounds/pull/5599 +The independent causal handoff and productive helper method; retain the +PR5602/5611/5615 basis and dyadic-completion lineage. +https://github.com/CrocSwap/integer-mult-bounds/pull/6398 +Ali Romman's mixed projector root, based on PR6348 and the retained native, +query, productive recursion, interval, compiler and outer proof sources. +https://github.com/CrocSwap/integer-mult-bounds/pull/6529 +Ali Romman's scaled transport fusion. Predecessors include Rohan Arun's +PR6399/6417, Erwan L.'s PR6453, DreamingOfClouds' PR6375, and PR6353/6372. +https://github.com/CrocSwap/integer-mult-bounds/pull/6524 +Ali Romman's explicit complete replay interfaces. Native sources retain +David Arias, Cinna Davis, Gareth Davidson and earlier contributor credit. +Integer interval work retains ywz65 and Nick Petalas credit. + +Other retained contributors include Jacob Alan Sussman, Mason Hale, +Pierre-Loic Doulcet, Chris R / Clear1nsight, zxv and Cao Yifan. +The exact archive notices provide the complete retained source attribution. diff --git a/research/gaussian-root-retirement/PHYSICAL-EDITS.json b/research/gaussian-root-retirement/PHYSICAL-EDITS.json new file mode 100644 index 0000000000..022a1d6af0 --- /dev/null +++ b/research/gaussian-root-retirement/PHYSICAL-EDITS.json @@ -0,0 +1,6 @@ +[ + [ + " positive = list(axes[:9]) if selected[0] else [q]", + " need(qp in (-1, 0, 1) and not (qp == 0 and selected[0]), 'Declared central phase and fresh-stage target')\n positive = list(axes[:9]) if selected[0] else ([q] if qp else [])" + ] +] diff --git a/research/gaussian-root-retirement/PRICING-EDITS.json b/research/gaussian-root-retirement/PRICING-EDITS.json new file mode 100644 index 0000000000..a8ba13d9f0 --- /dev/null +++ b/research/gaussian-root-retirement/PRICING-EDITS.json @@ -0,0 +1,46 @@ +[ + [ + "KAPPA = Q('0.003288299')", + "KAPPA = Q('0.00329394')" + ], + [ + "TESTED = Q('0.003288304')", + "TESTED = Q('0.003293945')" + ], + [ + "PREVIOUS = Q('0.003287014')", + "PREVIOUS = Q('0.003288299')" + ], + [ + " main[1+8*sum(term[1:])] += 104", + " main[int(term[0] % 2)+8*sum(term[1:])] += 104" + ], + [ + " need((targets, paid) == formula_invoice(local), 'Independent tree and emitted-event counts')", + " expected_targets, expected_paid = formula_invoice(local)\n expected_targets.update({1:104,16:104,17:-104})\n need((targets, paid) == (expected_targets, expected_paid), 'Independent tree, retirement delta and emitted-event counts')" + ], + [ + "counts['LAMBDA'] == 20", + "counts['LAMBDA'] == 34" + ], + [ + "(13652, 67096)", + "(13756, 67096)" + ], + [ + "32*34*104*len(word['events']) + 34*104*(26+1000)", + "32*35*104*len(word['events']) + 35*104*(26+1000)" + ], + [ + "'kappa_decimal': '0.003288299'", + "'kappa_decimal': '0.00329394'" + ], + [ + "'refinement_kind': 'Two scaled transport fusions with an output basis correction; unchanged mixed root.'", + "'refinement_kind': 'Independent Gaussian retirement changes the complete productive profile.'" + ], + [ + " low, high, grid = 0, 10**24, 10**26\n while high-low > 1:\n middle = (low+high)//2\n if margin(Q(middle, grid))[0] > 0:\n low = middle\n else:\n high = middle\n lower, upper = Q(low, grid), Q(high, grid)\n", + " from root_interval import construct\n bracket, _ = construct(E, T, P)\n lower, upper = Q(bracket['lower'], bracket['grid']), Q(bracket['upper'], bracket['grid'])\n" + ] +] diff --git a/research/gaussian-root-retirement/PROOF.md b/research/gaussian-root-retirement/PROOF.md new file mode 100644 index 0000000000..3901c21d02 --- /dev/null +++ b/research/gaussian-root-retirement/PROOF.md @@ -0,0 +1,130 @@ +# A Gaussian output before the suffix + +## 1. Exact source and claim + +The native source is PR6529 at +`44b0d0e8961201ac1656490b4384a7752e1cd9c5`. Its caller is the PR6398 +34-field word. Number events from zero. Let P be its prefix through event 328, +`QUERY 20 21 -1`. Let q denote the central Gaussian Q in the replay. +All 18 stage variables D_j commute with q and with one another. + +Set + +```text +λ = (1+i)/2 + (1-i)q²/2, +S = λ q⁻¹. +``` + +Then λ⁻¹ is its complex conjugate, λ² = q², and S² = 1. Thus λ and its +inverse are ordinary linear combinations of the identity and the ordinary +translation q². The retained physical checker verifies the translation and +its absolute phase. These ordinary scalars stay outside tensor powers. + +Fields 4, 20 and 21 have the same two-stage factor D = D_10 D_11. An even +central translation and λ normalize all three complete outputs to S D. +The other fields keep their source targets. All input fields are arbitrary. + +## 2. Two exact dual pairs + +Use row vectors a,c and column vectors b,d: + +```text +a = e1ᵀ - 2e2ᵀ - λe20ᵀ + e21ᵀ, +b = -e2 - e21, +c = e20ᵀ - e4ᵀ, +d = -λ⁻¹e21 - e4. +``` + +The identities are + +```text +ab = cd = 1, aP = Sc, Pd = Sb. +``` + +`check_caller.py` checks both pairings and both prefix identities over the full +central polynomial ring. It does not specialize q² to one or test only numeric +values of the D_j. + +Let G and J be the literal ordinary basis words in `WITNESS.json`. The checker +also verifies + +```text +e4ᵀG = c, Gd = e4, +e4ᵀJ = a, Jb = e4. +``` + +Every gate is invertible. ADD coefficients are dyadic; SCALE uses a dyadic +unit; λ has the stated ordinary inverse. G acts only on fields 4,20,21. + +## 3. Separate the completed Gaussian from the remaining work + +Apply G⁻¹ at the input. At the cut, apply J. The pivot row and column of +`JPG⁻¹` are both exactly `S e4`. Therefore the pivot has no coupling to the +other inputs or outputs at this cut. In block form, the prefix is `S ⊕ K`. + +Let F be the complete source diagonal after the three output normalizations. +Since G mixes only equal S D targets, G commutes with F. Apply G at the output. +The complete map remains `GFG⁻¹ = F`. The suffix after J must therefore have +pivot block D and zero coupling to the other fields: its pivot block times S +is S D. This uses S²=1 and the exact arbitrary-input source identity. + +Return the completed pivot output. Give the suffix a new independent input in +field 34. In the literal word, rename pivot 4 to 34 in J⁻¹ and every later gate, +including the output basis. Other fields still pass through K and its matching +suffix. This is a direct sum of two independent targets, S and D, in place of +one S D target. It is not a copy of one input to two output targets. + +Finally apply λ⁻¹ to the three original group fields. The returned pivot has +target q⁻¹. The new field has target D_10 D_11. The complete 35-field word has +609 events. Both full forward replay and an independent reverse-row replay +check every one of its 1,225 coefficient positions. Deletion, sign and target +mutations reject the claimed identity. + +## 4. Physical maps and all costs + +For each of the 104 ports, the central q axis is orthogonal to the two fresh +8-axis stage blocks. The old Gaussian target has rank 17. The returned q⁻¹ +target has rank 1 after an ordinary q² translation. The fresh target has rank 16 +and no central factor. The physical checker compares complete phase polynomials, +including the absence of that central factor. It checks every port. + +At each positive tensor width f, substitute q tensor f and D_j tensor f in +the same ring identity. Define the ordinary normalizer from the square of +that central operator. Do not tensor its scalar coefficients. The two new +Gaussian ranks are f and 16f. This retains the source tensor convention and +its framework assumptions. + +The ordered full-stage calls, thin-query signs, and whole-idle stage sets stay +fixed. Only some role names change. Every native call still receives arbitrary +inputs and fresh independent helper fields. All 67,096 paid jobs and all native +helper credits stay in the source invoice. The productive change is exactly + +```text +104(H1 + H16 - H17). +``` + +For H_r=r^t and 0H17. Rank mass stays +fixed. The gain comes from independent outputs, not from a larger rank count. +The total productive-field count becomes 13,756. + +The caller has one extra public field per port. The native owned inventory is +unchanged: 29 labels, 45 lifetimes, peak 13. The complete ordinary-work upper +bound is 254,699,248, below the retained 10^9 allowance. It includes every scalar +basis gate, central normalization, route and output adapter. The coefficient, +storage, growth and precision estimates remain explicit in `pricing.py`. + +## 5. Conditional κ and the fixed invoice limit + +Two rational engines certify the positive complete moment at the tested saving +0.003293945. They independently certify both signs of the raw bracket stated +in the README. A negative derivative bound gives a unique crossing through the +retained BIT range. The old caller fails at the new claim in both engines. + +The productive recursion, completion tails, uniform compiler threshold and all +outer inequalities are checked with the enlarged target count. The result is +conditional κ=0.00329394 under the same five framework assumptions. No selected +frontier change or independent scientific acceptance follows from this replay. + +The fixed invoice cannot reach the current 1% target 0.00332118199. A larger +result must change the caller, source word or another charged interface. More +digits of this crossing do not provide that change. diff --git a/research/gaussian-root-retirement/README.md b/research/gaussian-root-retirement/README.md new file mode 100644 index 0000000000..da18f0d8ab --- /dev/null +++ b/research/gaussian-root-retirement/README.md @@ -0,0 +1,101 @@ +# Independent Gaussian retirement: conditional κ = 0.00329394 + +The complete caller returns one central Gaussian output before its two-stage +suffix. A fresh independent input then uses that suffix. On each of 104 ports, +this replaces one rank-17 target with independent rank-1 and rank-16 targets. +Every paid Gaussian call stays in the invoice. + +The conditional claim is **κ = 0.00329394**. The increment over +[PR6529](https://github.com/CrocSwap/integer-mult-bounds/pull/6529), +κ = 0.003288299, is **0.000005641, or 0.17154766%**. This percentage excludes +all gains in the source chain. The requested 1% gain is not achieved. + +| Complete invoice | PR6529 | This caller | +|---|---:|---:| +| Independent caller fields per port | 34 | 35 | +| Caller events | 570 | 609 | +| Productive fields, with native helpers | 13,652 | 13,756 | +| Paid Gaussian jobs | 67,096 | 67,096 | +| Full native calls / thin queries | 18 / 17 | 18 / 17 | +| Rank-mass surplus | 760 | 760 | + +The target change is `104(H1 + H16 - H17)`, where `Hr = r^(1-κ)`. +It is positive for every exponent strictly between zero and one. The source +native word, its helper targets and its owned lifetimes stay fixed. All added +basis gates, routes, output normalizers and the additional public field enter +the complete ordinary-work allowance. + +Start with [PROOF.md](PROOF.md), [retirement.py](retirement.py) and +[WITNESS.json](WITNESS.json). [RESULT.json](RESULT.json) records the exact +caller, phase, price, compiler and outer checks. [RESEARCH.md](RESEARCH.md) +states the scope of the discovery and the limit of this fixed invoice. + +## Evidence + +The forward polynomial replay checks all 1,225 coefficients over +`Q(i)[Q,D_1,...,D_18]/(Q^4-1)`. A separate reverse-row engine checks the same +complete map. Both dual-pair identities and both literal basis maps are checked. +The fresh input is arbitrary; it is not prepared zero storage. + +The source replay regenerates PR6529 and retains its checks and controls. It +checks all 799 native columns, 2,939 native maps, 208 main adapters, and all +7,488 physical contacts. The candidate then checks all target phases, all +whole idles, both rational price engines, the uniform compiler, and all +54 strict plus four functional outer predicates. See [VALIDATION.md](VALIDATION.md) +for the executed commands and publication status. + +The unique raw crossing for this fixed invoice lies in +`(0.00329394637095319036829691, 0.00329394637095319036829692)`. +The claim uses the tested saving `0.003293945`, below that interval. +This is a ceiling for this invoice, not for other words or callers. + +## Reproduce + +From the repository root, with CPython 3.12: + +```sh +python3.12 -B scripts/research_package.py --package research/gaussian-root-retirement +``` + +The package needs only the standard library. Both normal and optimized runs are +registered. The two source archives contain every runtime input, with original +paths, heads, Git blobs, SHA256 hashes and notices. The adapter checks preserve +all source checks. Explicit engine dependencies use the interfaces from PR6524; +no imported function or class is patched. + +## Scope and limits + +This is an author-checked conditional construction. It is not independent +scientific acceptance, a formal proof of the full multiplication theorem, or a +measured runtime gain. The five inherited framework assumptions remain: +`native_all_columns`, `owned_erasure`, `compiler`, `precision_tape`, and +`analytic_recovery`. The large uniform word and rounded multiplier are not +materialized. The selected frontier is unchanged. + +The source stack includes pending PRs. Passing the registered replay does not +admit that stack. The new result improves the caller boundary; it does not prove +optimality over other cuts, native words, target groups or query networks. + +## Open next questions + +- Can another caller return a larger Gaussian factor at a legal intermediate + cut? First test exact dual pairings on a changed word and write its complete + target and paid invoice. The present fixed word has little remaining price + headroom. A favorable numerical screen is not a caller. +- Can a repeated Gaussian-assisted interface have a favorable complete cost? + First supply exact transition matrices, a closed endpoint and native helper + delivery. The current small-state searches do not supply such a cycle. +- Can an independent reviewer check the prefix identities and the 104 physical + output normalizations? The small basis and separate reverse engine provide + bounded entry points. Full framework admission is a separate task. + +## Credit + +New construction, proof and package: Ali Romman with substantial OpenAI Codex +assistance; no subagents. Apache-2.0. The independent handoff method comes from +PR5599 and the PR5602/5611/5615 line. The root comes from PR6398 and PR6348. +PR6529 supplies the complete native word; PR6524 supplies the replay engines. +Credit Cinna Davis, Jacob Alan Sussman, Rohan Arun, Erwan L., DreamingOfClouds, +David Arias, Gareth Davidson, Mason Hale, Pierre-Loic Doulcet, Chris R / +Clear1nsight, zxv, Cao Yifan, and all authors in the retained notices. +[NOTICE](NOTICE) gives the source links and attribution boundary. diff --git a/research/gaussian-root-retirement/RESEARCH.md b/research/gaussian-root-retirement/RESEARCH.md new file mode 100644 index 0000000000..9a58dd93f7 --- /dev/null +++ b/research/gaussian-root-retirement/RESEARCH.md @@ -0,0 +1,36 @@ +# Discovery and remaining scope + +The new step changes a hypothesis of the PR6398 packing ceiling. That ceiling +keeps each complete Gaussian target intact. This caller returns one factor at +an intermediate cut and gives the suffix a fresh input. Its target inventory +is therefore outside that fixed-target model. + +The discovery screen first set q²=1. It searched the equal-target groups and +paid-event cuts in the literal 34-field caller. It found the group 4,20,21 after +event 328. A separate q²=-1 calculation gave compatible dual pairs. Neither +specialized calculation was used as a substitute for the full-ring proof. The +published checker validates the unspecialized pair and complete caller. + +The first emitted word normalized every original output. Only the three group +outputs need that normalization. The final construction uses 609 events instead +of 684. This reduces ordinary work and proof surface; it does not add another +κ gain. The native source was then updated from PR6398 to PR6529. The reported +increment compares the new caller with PR6529 and excludes that inherited gain. + +The source invoice is preserved, except for the 104 legal target splits. The +strict raw bracket is less than 6.371e-9 above the conditional claim. This is +almost all the gain available from this exact invoice. It is not a global +ceiling for independent Gaussian retirement. + +Further local discovery tests covered supplier-boundary shears, larger scalar +roots, changed query words, owned-lifetime output bases, and short moving-state +Gaussian-assisted templates. They did not produce another complete caller. +These were bounded searches, not universal impossibility proofs. Their work +files are not runtime inputs to this package and are not published as exact +exhaustive coverage claims. No relaxed favorable price is counted as a result. + +A useful next construction needs a larger independent target split or a new +closed query interface. It must bind the actual native helper maps and charge +all helper debits, idles, routes, COPY/CLEAR work, restoration, compiler and +outer costs. The 1% target over PR6529 is 0.00332118199. This package does not +meet that target. diff --git a/research/gaussian-root-retirement/RESULT.json b/research/gaussian-root-retirement/RESULT.json new file mode 100644 index 0000000000..3bcf9f740b --- /dev/null +++ b/research/gaussian-root-retirement/RESULT.json @@ -0,0 +1,316 @@ +{ + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "candidate": { + "caller": { + "coefficients": 1225, + "event_sha256": "e30e87523bfe8dcf009843965a617a664a1ce802850bb07ac2ca198fa818a124", + "events": 609, + "inputs": 35, + "native_stages": 18 + }, + "complete_cost": { + "compiler": { + "H": 138100200000000, + "N": "2^138100200000000", + "eta": { + "lower": "0.000000000000021343548942378562", + "upper": "0.000000000000021343548942378563" + }, + "gap": "1/1400000000", + "integer_test_exponent": 98643, + "logarithm_power": 2100, + "theta": "63/64", + "uniform_saving": "2305761/700000000", + "word_materialized": false + }, + "derivative_upper": "-709185992340617917271102325360006905223896764960473050137748773/3138550867693340381917894711603833208051177722232017256448", + "full_forward_calls": 18, + "gain": "5641/1000000000", + "kappa": "164697/50000000", + "kappa_decimal": "0.00329394", + "margin_at_previous": { + "lower": "1.294383344079915739634444114064", + "upper": "1.294383344079915739634444114065" + }, + "negative_controls": { + "coarse_tail": "The block tail bound cannot fund this near-limit claim.", + "old_BIT": "An outer inequality fails at BIT saving0.0027.", + "old_completion": "Cutoff16 and floor17 give a ratio above one." + }, + "nonrecursive": { + "local_routes": 5384000, + "local_scalar": 137218, + "paid_rank_mass": 184962, + "peak_owned_fields": 13, + "raw_budget": 1000000000, + "raw_scalar_upper": 254699248, + "scalar_growth_bound": "At most 2^(10^9 + R*f), where R is the full paid rank mass." + }, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "348599999253/350000000000", + "fixed_halo_explicit_metadata_branch": "26950000001/350000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799997009/1400000000000", + "new_semantic_group_guard": "3/1400000000" + }, + "margins": { + "boundary_algebraic_matrix": "6456127995388481/1960000000000000000", + "fused_gaussian": "6456127986165443/1960000000000000000", + "global_coordinate_router": "14411/4375000", + "group_bit_router": "20175404331767/6125000000000000", + "group_scans": "699999999/700000000", + "main_transform": "6456126595388481/1960000000000000000", + "microbox_face_corrections": "26950000001/350000000", + "polynomial_products": "1399999999/1400000000", + "sparse_union_movement": "802706127995388481/1960000000000000000" + }, + "parameters": { + "a": "14411/4375000", + "b": "4611521/1400000000", + "beta": "1399999997/1400000000", + "bit_saving": "17/5000", + "cap_xi": "1782706126595388481/1960000000000000000", + "complex_uniform_saving": "2305761/700000000", + "d": "1/1400000000", + "epsilon": "1399999999/1400000000", + "kappa": "164697/50000000", + "lambda_": "398682423/400000000", + "lambda_prime": "1395388481/1400000000", + "layout": "1/1400000000", + "q": "4611519/1400000000", + "r0": "1/14000000000", + "stop": "1/1400000000", + "tested_saving": "658789/200000000" + }, + "strict_checks": { + "actual_bit_above_effective": "58/546875", + "actual_logarithmic_gamma_guard": "1/1400000000", + "actual_logarithmic_group_guard": "177293875504611519/980000000000000000", + "alpha_logarithm_absorption": "1/14000000000", + "boundary_algebraic_matrix_above_kappa": "5595388481/1960000000000000000", + "cap_above_band": "802706126595388481/1960000000000000000", + "cap_below_cell": "177293872004611519/1960000000000000000", + "cap_below_phase_cell_power": "2137293873404611519/1960000000000000000", + "complex_above_effective": "1/1400000000", + "complex_below_one_over_32": "39138479/1400000000", + "complex_endpoint": "1/700000000", + "epsilon_below_one": "1/1400000000", + "epsilon_positive": "1399999999/1400000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "5586165443/1960000000000000000", + "gaussian_above_main": "695388481/980000000000000000", + "global_coordinate_router_above_kappa": "1/350000000", + "global_gamma_power_slack": "9/14000000000", + "group_below_dimension": "1/700000000", + "group_bit_router_above_kappa": "21831767/6125000000000000", + "group_gauge_power_slack": "177293875434611519/980000000000000000", + "group_key_fits_record": "1/700000000", + "group_positive": "1399999997/1400000000", + "group_scans_above_kappa": "697694241/700000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "781484790400418148631/500000000000000000000000", + "lambda_above_internal": "1/2800000000", + "lambda_above_sigma": "3/2800000000", + "lambda_above_tau": "1/2800000000", + "lambda_prime_above_lambda": "1/2800000000", + "lambda_prime_above_leaf": "2795388479/1960000000000000000", + "leaf_saving_above_effective": "1395388479/1960000000000000000", + "main_transform_above_kappa": "4195388481/1960000000000000000", + "membership_arithmetic_fits_record": "1/1400000000", + "microbox_face_corrections_above_kappa": "13474423561/175000000", + "microbox_halo_volume": "110600000003/1400000000", + "new_complex_uniform_saving_above_b": "1/1400000000", + "new_semantic_guard_with_C1_one": "1/1400000000", + "polynomial_products_above_kappa": "1395388483/1400000000", + "positive_layout_slack": "1/1400000000", + "q_below_effective": "1/1400000000", + "q_below_internal": "1/1400000000", + "q_below_leaf": "2795388479/1960000000000000000", + "q_positive": "4611519/1400000000", + "short_record_fallback": "1395388479/1400000000", + "source_axis_superpolynomial": "1/1400000000", + "sparse_union_movement_above_kappa": "796250005595388481/1960000000000000000", + "stop_below_one": "1399999999/1400000000", + "stop_positive": "1/1400000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000", + "union_tag_work_per_visit_fits_record": "3/1400000000" + } + }, + "paid": { + "1": 41980, + "16": 1872, + "2": 8154, + "24": 416, + "3": 8838, + "32": 416, + "4": 1926, + "5": 2754, + "56": 416, + "6": 144, + "7": 162, + "8": 18 + }, + "paid_calls": 67096, + "previous_fixed_root": "3288299/1000000000", + "productive_fields": 13756, + "rank_mass_surplus": 760, + "raw_endpoint_margins": { + "lower": { + "first": { + "lower": "0.000000000000000000001070125900", + "upper": "0.000000000000000000001070125901" + }, + "second": { + "lower": "0.000000000000000000001070125900", + "upper": "0.000000000000000000001070125901" + } + }, + "upper": { + "first": { + "lower": "-0.000000000000000000001221858508", + "upper": "-0.000000000000000000001221858507" + }, + "second": { + "lower": "-0.000000000000000000001221858508", + "upper": "-0.000000000000000000001221858507" + } + } + }, + "raw_headroom": [ + "637095319036829691/100000000000000000000000000", + "159273829759207423/25000000000000000000000000" + ], + "raw_root_interval": [ + "329394637095319036829691/100000000000000000000000000", + "82348659273829759207423/25000000000000000000000000" + ], + "refinement_kind": "Independent Gaussian retirement changes the complete productive profile.", + "relative_gain_percent": "564100/3288299", + "strictification": { + "alpha": { + "lower": "0.999999998291106770622495989553", + "upper": "0.999999998291106770622495989554" + }, + "coarse_tail_upper": "1/288230376151711744", + "cutoff": 12, + "delta": { + "lower": "0.964631407891465146160234341582", + "upper": "0.964631407891465146160234341583" + }, + "exact_tail_upper": "25968816751883113995464804882194607929411683780884226645678925307002110843550133104420123760101479474839221201004686329940160027670126004133743828536680673994452725629745611397250341115761363323607003552687034005960488068717359911143395851784415362067355137094922219194655890106807315973377901994681558011665956719293922523423896736235903448997789236780141543787761778864696595800906890151999691226382701024017325569269316595526470733042482962997961321816289689038860231064735268262348181833735526073481800371738520564423855188853455070167523225315015758774805697502433771984614850668873883495604089682521242370834384375582830712704865727861176177048771394427407255002047824069363883041195805737568221434593424664912374095681332409910102117819689183603716909776665801384439952751837667700413070379263323130466094707734337887831258005980440847552037834301818581649745499092009029235117704964733313829410497453470070887466638307413753043426496924817422338541543232280481901189410625113352540990925659205592694157405025696376596135904922863017205099824220302784597597394276398809139342815771451800330237414693097687353116020292427829621137741888194987614319546272900374357630911060621372780363425799229823027419399322430473329066822665185057155378959634917707139348139444417502434894646589809020275954413976196338353104990927739225086991331116260532892993604070852131850799788364871935788080589906984695519250577337599768456831251607249423700889021932369256023863626543373232166438214597277750913930476188423662975734340573982417743812475341013829410134208659166050139798547596876083645842576454904158460099622845601362359202659966547393643799328843973215865146723977900950651432448361170601246192090126412244869008028749978164391847944132606805504798364996996014218459024410664453957811779516913670216928724470380796391020353614030246272618410655142564538377734059025000305119155917226445867387899027040451866939956717377831530119449900953585057952699220008085352148706159738644321313531284032818479141559396247029143750425762501948430437369399481810562584909868262778814839240692102964314788286773148559517247633145270422345099190454145942630831266195509922086728349392801157236390281356642879102356486891062424937470616665957496696759574300833108099958404347149016512657584919622710050001356487455986180867964952023672761039188124022692190974214751766725701356295495524587296011840901864611875504808599874948117351460747134887391055383954183357815228423956967508253485665094444536753140118928942192591489028112227793683148117180821470944630106089051895287977293005179296095836333159834273766684727267011939930469961979884670796085309878886992937168024435902854601180811049624073160626754017381247943964404431354002824473361814782176441811959489344592309505051971888333364522225539320640095711622097910757473509357949732179456944382304691192060425703256673043353601/1931516324011626346020150553929126181823590488535040186824856567180029479223493376445786096950954795100702784533083281033646760271068018983122291972202644881704691011563710483989867650744695251376055025107666230739164093587389628866535770117611912392089755082590080472028477987071289165684289011377905352698232800507758208042820675070709030399021754206793830358905406733535942588887996076001927509337965834979072536427646331464401971792582375342958569384054354332096896759837269698218889565287567707539585095032991822857620010464317015726455734074643321122388044097708028635229432698100703335425310388288440000351711930613276786493722293418289870150700918405798037757934100708219508469592822795997483826085672921016197325327430119841909503482096760772795264133044082205866449934298354644012164798932775556083457809449912592220889802005953323685819720454613153020534455067493961231922206456679179219662713499049824991117775198073492812006682664088284693545727589314279309950009246830913459976142947529615742696134568887882410861948007763929800878314246201090904986140186077798864508547948608132255423035988434446214058699770626557465193128157512845357439793247851632224246499990611115646221003615087011758590423628181610786764420573006921761893949737802418426782447136548014140198447242737897751623530788833864390071832506056728849302290191408954510946220861486311039370054837095614883730158737099345289640173098512240742485291913040000974074836991713791813260339229632451698438087840996110693416312325768841145996367942811788448367825625035192908389092377054549306070546491079416016630873092882144703817485287986047453762937574793229088607594726623087172119290857442922186749727030568744100000419699941602816789656590538128654775884335322288115044042902368007647928447785494309683729219830178145535848830929931533192822883913681010006628877851664234722515418098809600795075237161618710226944692109669822041946629850162941173319519204709693533513108874099949758590208958136931346480022816743599142611017726137114510998217900038246478615246956350952278485410366122587953267937544436255099465307497011848059680873269896755574862120101016159541436240691657472394148008527677335225016052476207952397501417607437147877605303564057067564064530504494183216739444916912001687735183605267399161590281721705618193211199161475332334316832897783160549981482614788840809957569982115145402182575160480094711317055554905021931999461941405791251356057108718863869053217661463840775172788114991998596171377364481496742568202736663003363999728620841731079859176245940071187874843669264882594126717901436208421673886795099603467547525863026278936933835810347290598467230778790873267966902348777280946055188109006665306325326165168038148974262863542508287344559517219458554951908638902157539612839480289421087336446182774503962079866786903470546386259662184092799534574936219344193317288975481261643484673081344", + "floor": 13, + "gamma": { + "lower": "0.924133215092881436494207941683", + "upper": "0.924133215092881436494207941684" + }, + "normalized_paid_upper": "301799425626816616565648528109053583391672575624975869940741583241797183286245900040809945102717848691873044685714521183696004886382003883466377478245092103887149130513292792459855142440109413906745988535460631248884298173458126368768624796293092869362168408912319796533556160583862533407322260438866742613153280686291990643354490224551943523228527424469436028309041589787129548101074311423426114310610596031813033352108087503397245815968572344741673665372616954254810895105816503554164534346982552051911285959875500423372269822385628835948047846968612629126601819504076701291377728006835633485157565813415491483591792647779464628140235411130837708133364924768325881139107648021966692253445739473110504978176401317390484720917763472170087399053284025621752849515588491115354784312114796037285675219539609263405190913495242614266526211760606148610764084636759992186514237315506545921016082951398642312212707669421504838229936571461184333857636630398207131411209275958949082326107455705488444588407064614885594862057760009464516285110015266189625072421731933680573645919460633395409485478933665135896635962123550978028198469956423067761387237891161248504060152572651764417043315553904788275940972822138283460482007536285039454333744430731010515968501887788002878120512905009639562367117756114778018290345960701258650801580441748371168100479507364802657842858038646646132252116044115722627476253140838312498329226086525341379050630911210225440926822289249592206382470693285625307402300632605045915432124015120531477460701485675348813313885703492348411977021656461528309955456511882087030695278147846402385996123408872905124876546080259052247878909372748370715537990123188801158439727097722818570075649321843091996462220691948638857990271688415748735990268957977072732719576542723594407150217919974318537795754697935266273409814901132885468100151160477578371433469178015962157592357715183237537996405238471421253995257942319696663713231624595453865406519280636797623587967147499366372116604250177877350232354938419461919717913462777631887824492739295756328953000703580767618425429227902317519621684672164305220954227395374311394390766662610551662776418938907121788829304328236007254754887896625047228575905877802078036326720030589592784430857735637288740857800323458560625645576814021888519238251618574786255511355740282166374757739907368509692374989841088063538310820616230807172142631730012542741650950755936921860148020466043114790367272167323847793817214080973216016280043001603197094102740357442482718512416184262618729170472760291383183945838246607207075883495104473031191009853310272431836128093864425961960285207680233006875526939005517015421666422110223408105807078082966354186873810127771992121166952364000079535481712545174594176912418033247014664164087923589259194684161501915740939750272298890913108985116073608319238085545414021966707796667664104685841899011057001636482790107033732431277109770019130060803/301799425626816616565648529845974937944815051894051690978762384092651071733791400544223779188675124404964939420652553514371691594462731565362701221596944075970414919923705679731351465542931667718640049642675800787080143751194704833394906298369142073432910831262010426590186861749154179908411574113231672572966372132204254140406788574496687523121773223273561205706060999180253649895240463591521373941884928379468311822602267305210313029808605430276270859464408242137266147600281542509764490866872733814869265755573668184206249253804818806234177022023050318324179069634081698184562226242367189284290653858366844357064995434255662754964109401743584050877377982072823654546813687762053415767991835676908972484411802687249220074862434482317122967669594853039619546516648290956915120619910312259147367432595983533104214763043239332840699813803635175647107983702711177318479661755092806327303820459486955554182679993154524899690033687123749025519139617120077586998371850404134444543025454512996064110265401530200289011406317160469286026604301517738050883833554764477195873806709598811182733331928441223143245966718526066771068605429507569239764916787481398979640090556202007577051695852366563276928487596845559113100630566387530692975990303602409840762006824889598205522650767476422813262662025137933335219106350633039162417083941956249205076012623146660505533557514106674128434601134852410041770420781937212793121697833013827311362730333019447735915507411155709941930926854581553022326664936659984743653896215644952050264571313278922363996191900852720371161029018250204179101614398435883762221838974474583209730126140439193296893107513897909053079037323670095023326462298240771548906364884238837953832138365056531829616142272841702133540377763077289590017667822654200955684311615614595186713542250678596459308883989461551913012219059150603330361742791188416436064097825633679223209974049177769388910527361621178910291594922035887340641001575779165100246781536674763908800750248222145187352840886814240443765559148992592574268974714029190694975869924489993628084805552395236750972076774395957659218156211913892633901746817290549607750444826394738039679332657840364634104956758305703881175381851518145141602176210211784499685874388169629196526524143126819786740960461091777191172088541365869734486582222053658491447353751365842353859719912216320360603661511255069905351959649939313457549798697724744988726137001635158315200062295821547739449719235708303756939013671896447277339750127152765043300038718598211002277466117726369069447824711128691217006380427321985630637562900166643152513235723938573681192594114466746112926181119516469194722248009341745089341619987581379161700287398142484193742945932998500445175051473070287797224491404495415401701871488328989838760586862140667222881833650947961602792334897034684943242447463005821196364958455864860637688972943051516758104801022671940452512748911866926443784930454019244032", + "power": 1920, + "reserve": "1/100000000000000000000000000000", + "tail_decay": "31/32", + "tail_offset": "1/7", + "tested": "658789/200000000" + }, + "targets": { + "1": 460, + "145": 104, + "16": 104, + "17": 1768, + "2": 144, + "25": 416, + "3": 72, + "33": 416, + "4": 1926, + "5": 270, + "57": 416, + "6": 54, + "7": 162, + "73": 208, + "8": 702, + "9": 6534 + }, + "thin_queries": 17, + "whole_idle_jobs": 3120 + }, + "controls": { + "extra_gaussian_credit": "All main target phases and ranks", + "missing_boundary": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_cut": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_idle": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_idle_one": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_lambda": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_local": "Every native stage exactly once", + "missing_q_power": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_query": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_return": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "unearned_central_target": "Every independent reverse caller coefficient", + "unpaid_native_job": "All independent fields and paid calls", + "wrong_cut_sign": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient" + }, + "dual_pair": { + "cut_after": 328, + "cut_pairing": "1", + "input_pairing": "1", + "prefix_column": "P d = S b", + "prefix_row": "a P = S c" + }, + "physical": { + "central_square_columns": 53248, + "central_translations": 17, + "full_calls": 18, + "main_targets": { + "1": 208, + "145": 104, + "16": 104, + "17": 1768, + "25": 416, + "33": 416, + "57": 416, + "73": 208 + }, + "new_paid_jobs": 0, + "ordinary_normalizations": 34, + "physical_contacts": 7488, + "ports": 104, + "route_payload_sha256": "79930ec6c09a8e4930556c925c354bb5431203eaf069d9373f056049c061289b", + "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.", + "whole_idle_jobs": { + "16": 1872, + "24": 416, + "32": 416, + "56": 416 + } + }, + "reverse": { + "coefficients": 1225, + "rows": 35 + }, + "source_margin_first": { + "lower": "-1.293834964536877202313242336847", + "upper": "-1.293834964536877202313242336846" + }, + "source_margin_second": { + "lower": "-1.293834964536877202313242336847", + "upper": "-1.293834964536877202313242336846" + } + }, + "selected_frontier_changed": false, + "source_result_sha256": "4e16dd95b28722231e4ee44df3a8cbaa97f2ed1f241a0290fd057e4975fd443e", + "status": "PASS_GAUSSIAN_ROOT_RETIREMENT_KAPPA_00329394" +} diff --git a/research/gaussian-root-retirement/RETAINED.json b/research/gaussian-root-retirement/RETAINED.json new file mode 100644 index 0000000000..d4df076010 --- /dev/null +++ b/research/gaussian-root-retirement/RETAINED.json @@ -0,0 +1,211 @@ +{ + "native": { + "archive": "native-source.tar", + "archive_sha256": "2e4e49580c51758281bd9e4618f99d38f3a3622117d5c73bae0fce2db3616fa4", + "source_head": "44b0d0e8961201ac1656490b4384a7752e1cd9c5", + "files": [ + { + "path": "research/p104-scaled-transport-fusion/CONSTRUCTION.json", + "sha256": "c2fb3d5354092884e8445e23bf0f75f669e37b66c02ebb339f6d2b0c48cddc94", + "git_blob": "faa14e80841355f524094b81ce5321f8c51ef18d" + }, + { + "path": "research/p104-scaled-transport-fusion/NOTICE", + "sha256": "e1b36824e56639f42857d8799d5bfe581616d2bcd402b89be0ae8dda642caaa9", + "git_blob": "3d9b7e4c8b3a4b34cc65d00895940eea3b3a10b3" + }, + { + "path": "research/p104-scaled-transport-fusion/PRICING-EDITS.json", + "sha256": "9624db6e57e04edb857147f108eaf1d22df6c4b105917c6bcbfd119043844181", + "git_blob": "6a780250f4587904f0f34b1a81bafc74d6bb64ac" + }, + { + "path": "research/p104-scaled-transport-fusion/PROOF.md", + "sha256": "ab150f868d0f051937db6b6763b6dc922887e9229c43a0d63ababef76c208ed9", + "git_blob": "fb837600112a0241a6921b901b8b536284ce16da" + }, + { + "path": "research/p104-scaled-transport-fusion/README.md", + "sha256": "c646a4b1ce1887c0cd8a00912c2f27ac351b879e3d343388cccee21a2219db29", + "git_blob": "935119d860890f1bfc7a45c739c3419cb4d4db52" + }, + { + "path": "research/p104-scaled-transport-fusion/RESULT.json", + "sha256": "bdb9c8cd7c35f392f54afcba8edffab0cc5fedd95951c891b06950a337480c9e", + "git_blob": "a113037fe74b13a701b641b3e31fd845431a79a9" + }, + { + "path": "research/p104-scaled-transport-fusion/SOURCE.json", + "sha256": "42ced15b89a9b0ff85782cb9517ea771585ad2890d02291dd873ac052a50d0b6", + "git_blob": "b5e932efc94853da1061b51c4aef556952fec68c" + }, + { + "path": "research/p104-scaled-transport-fusion/SOURCES.json", + "sha256": "5c9e13ec8c1b6617c48f14010642174a5689b4bf362a92ab68a99ce938089232", + "git_blob": "d2ad6b7e335c98914d67864a9050939d501276ee" + }, + { + "path": "research/p104-scaled-transport-fusion/SPEC.json", + "sha256": "7aa9d66aea7b5766f93b4cd35b1fb1229ab4108bc557a96990a4b540f9b75d6e", + "git_blob": "aa4860d1a2d3b3f02061747c1bf45adb1cfec21b" + }, + { + "path": "research/p104-scaled-transport-fusion/TASK.json", + "sha256": "3d7f2622513878a0bf4a48bc486d62ff4f9a85d4b39a9af497bf394408a9467c", + "git_blob": "1976f845db3a86c2176bdfc2d3cf17846dbd9bb3" + }, + { + "path": "research/p104-scaled-transport-fusion/VALIDATION.md", + "sha256": "5996149ddaf7d290125a7c48597ce2e4360e70c2e696cf38113d30ab210b9dab", + "git_blob": "0bf1bfd940116da879b0cc05ee4fff067963cd00" + }, + { + "path": "research/p104-scaled-transport-fusion/VERIFY.json", + "sha256": "239d552716b04d8bc16253465863e1be7e8c418bd870089e0100cf391da48757", + "git_blob": "6514c9d43ecefe0f039b932a2c3c5af3d30254c3" + }, + { + "path": "research/p104-scaled-transport-fusion/WORD.json.gz", + "sha256": "15ca0c4ee15ad5a58dfc178d7b44d89ca202021c2907fbf9ef2ed50ba1ed8513", + "git_blob": "91baa371a7e5f40c7032a82fc4a64ee163601f40" + }, + { + "path": "research/p104-scaled-transport-fusion/construct.py", + "sha256": "7f78d4d470f5d58f35a6e7fb0a2f11f54b94ba615f5ed17454f579ad9aec3362", + "git_blob": "96f10e51d7853b3d6065403944f7cdefcc6180dc" + }, + { + "path": "research/p104-scaled-transport-fusion/fusion_support.py", + "sha256": "47d7916baba4fdfd3fa76cb59521171f88a8de84dd820deb94593943bb25d8b3", + "git_blob": "dc6d90e895d64cb438c7221f5769bbb1efe5893a" + }, + { + "path": "research/p104-scaled-transport-fusion/pricing.py", + "sha256": "51bb17ccecf975975851f71728ed0b1c2e4198a7921aa905077a2c2710a5d180", + "git_blob": "168fbfda19f5a11d20d39b68bfd23a14cd51788b" + }, + { + "path": "research/p104-scaled-transport-fusion/source.tar", + "sha256": "c201575d55d2a6a1adbed4c2cf28986b728c43394e464647efc152f6bfbe0f6e", + "git_blob": "6f4824c092c6ac8c590e87185e8615a3ed124df0" + }, + { + "path": "research/p104-scaled-transport-fusion/verify.py", + "sha256": "b1da424926c22eaa2845ea67a950c98b062a234824ca6dcc120299df3d032a56", + "git_blob": "658deaaf1894605028b97508f56fac66961e4573" + } + ] + }, + "engines": { + "archive": "engines.tar", + "archive_sha256": "cf1bd75c964d8d19ac867550f48424cba0187c4d6ca6b89ef1662bed738c390a", + "source_head": "dd1a979bfff090fa6559cc3b7d4e7f5ab24b4f80", + "files": [ + { + "path": "research/p104-complete-fast-replay/inputs/arithmetic/PROOF.md", + "sha256": "dec382f54ae6e4c555ca4586572d930ff93fde2233eebfd32c2adad17f24cff9", + "git_blob": "9e1e1bf3adb21d476857a6a627ba894c8a1f4c8b" + }, + { + "path": "research/p104-complete-fast-replay/inputs/arithmetic/README.md", + "sha256": "ebd4b600ca57c6091c8c08b23c6bb44742fa9ba24913138669137fab14271528", + "git_blob": "0bc3c4f82cfe254759505da739dc1ae3a62d4dfa" + }, + { + "path": "research/p104-complete-fast-replay/inputs/arithmetic/bounded.py", + "sha256": "b9860dc5096bc769c739179b9dc6de054c602dfb748453141a090e584ee3b566", + "git_blob": "a06a2567a09346c829bca9e872d6049999a31433" + }, + { + "path": "research/p104-complete-fast-replay/inputs/forward/NOTICE", + "sha256": "63c146302d0b4044c6b179b87f60393a6241fb6bed81800019b616f0ec6fe278", + "git_blob": "81ef73e31397afcc044ce9e104aad36411c8e573" + }, + { + "path": "research/p104-complete-fast-replay/inputs/forward/PROOF.md", + "sha256": "2505b029495e98062ddad3634e1c3e9efb80426be95d5095a2258c753e76b4a7", + "git_blob": "31665b73e927e53f6ebc29ac93999130a831219c" + }, + { + "path": "research/p104-complete-fast-replay/inputs/forward/README.md", + "sha256": "1da41525653baea1b7947c00a6afa219c95ea541810ca6ce11600567e235ae0c", + "git_blob": "f164698d89e31eb1af270569bd48ded07c142d2d" + }, + { + "path": "research/p104-complete-fast-replay/inputs/forward/driver.py", + "sha256": "6c433b76158508ff3103d8ff9608b88c8173a0ad4e9828ed4d21d7cccd1739d6", + "git_blob": "6c15db3f173fa60183574358ae9bb5d766c78467" + }, + { + "path": "research/p104-complete-fast-replay/inputs/forward/rows.py", + "sha256": "3c992c324d85fdc5ec3990bdc8f9589d228ae11e2047bdde0a9071484f8db6c5", + "git_blob": "a3db741e81ea9501620267fdaf364f165ab5221c" + }, + { + "path": "research/p104-complete-fast-replay/inputs/native/NOTICE", + "sha256": "972385d39f6484d4f1f2e11d7a1b3b39f3372f76696054877bd1a5b583cc74c0", + "git_blob": "86c2136ea9bb9dad1828a2989d55d452ae8722b5" + }, + { + "path": "research/p104-complete-fast-replay/inputs/native/PROOF.md", + "sha256": "cbbb85ef97ecac282fba6ef86fa697fad521b725eeecaa4d7fb7ea36a1609382", + "git_blob": "ad3b7421c1c08d14d6d5f8de94dc5efdd0b48a9a" + }, + { + "path": "research/p104-complete-fast-replay/inputs/native/README.md", + "sha256": "1686fede0ccea33957fa7745986818498c167c6ed560db1a81e7fc7ec6d02857", + "git_blob": "86d508da7872336f3bdfd47403889df0802eea9a" + }, + { + "path": "research/p104-complete-fast-replay/inputs/native/inputs/fast_state.py", + "sha256": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5", + "git_blob": "5d546d8a05f6025d58a5133fa0d67ce134993013" + }, + { + "path": "research/p104-complete-fast-replay/inputs/native/native.py", + "sha256": "57de9b2f74b0c124ab3333eb94c131bd0d79cd1c0c859f88dd04e5267420ca07", + "git_blob": "32a6e1e8a530fbe10af35e65bf8ef0aa8d58febc" + }, + { + "path": "research/p104-complete-fast-replay/inputs/native/native_gray.py", + "sha256": "eab855749ef35a08c72550e97c5ef55f01fc0efb9e73a15005c040b8b0dd0bee", + "git_blob": "29b30ef027d8ede98d084ba99ec9e8b4971400eb" + }, + { + "path": "research/p104-complete-fast-replay/inputs/native/prefix_clifford.py", + "sha256": "699adb016d3dc751aec45ace32314090a9fb8bc7758a21ea30f8f3024ada1cb6", + "git_blob": "3224cad263cd82dccb087048721997820d134dea" + }, + { + "path": "research/p104-complete-fast-replay/inputs/native/state.py", + "sha256": "dfa59e6a174c46975ba2f613d2a6af022cfef0a2399a558ef68bd9f88157bf33", + "git_blob": "96a3132125e1b72df16892686f9b724aac14da62" + }, + { + "path": "research/p104-complete-fast-replay/inputs/pricing/BRACKET.json", + "sha256": "130365567ae587c92aeca91eff65b0fc0cb1129c613dee1b3a943a1b582136d8", + "git_blob": "f723652d62baecde34a77f5c482c47684bb11459" + }, + { + "path": "research/p104-complete-fast-replay/inputs/pricing/PROOF.md", + "sha256": "5032801b4820a068d27f972c7d3e18327c61c6c6f09a11ca9250bb31573cfdb1", + "git_blob": "6bf68c71d475236d8caa2c6ad462350c47039109" + }, + { + "path": "research/p104-complete-fast-replay/inputs/pricing/README.md", + "sha256": "e2a72fcc6f767fc283bccf2117618713ba855af80e8d0f29640a0932cbcffa8b", + "git_blob": "d0ec7c54995320a51376d1bc43ad463b9dd14d01" + }, + { + "path": "research/p104-complete-fast-replay/inputs/pricing/pricing_fast.py", + "sha256": "8855bf172357e55f2244cf16cb9ba570a427b8e04772d9d3998ab009d30ee584", + "git_blob": "9f2bb95aa442282ce9128fbfd14ebda116912783" + }, + { + "path": "research/p104-complete-fast-replay/inputs/pricing/root_interval.py", + "sha256": "b9257c99ec715a4f2112a228a6feb24e735039e8eca2fbbb5f5eb2e750236abc", + "git_blob": "930cf2212c4e751c91a516fd09ff4ca8b3cc0542" + } + ] + } +} diff --git a/research/gaussian-root-retirement/SOURCE-DRIVER-EDITS.json b/research/gaussian-root-retirement/SOURCE-DRIVER-EDITS.json new file mode 100644 index 0000000000..908bdd419e --- /dev/null +++ b/research/gaussian-root-retirement/SOURCE-DRIVER-EDITS.json @@ -0,0 +1,18 @@ +[ + [ + "def run(write=False, build_only=False):", + "def run(write=False, build_only=False, services=None, extension=None):" + ], + [ + " L = local_module", + " L = local_module if services is None else services(local_module.ROOT, local_module)" + ], + [ + " return encode(dict(status=STATUS, conditional_kappa=str(price_module.KAPPA),", + " result = encode(dict(status=STATUS, conditional_kappa=str(price_module.KAPPA)," + ], + [ + " scope='Local conditional construction; no independent acceptance, materialized multiplier or selected-frontier change.'))", + " scope='Local conditional construction; no independent acceptance, materialized multiplier or selected-frontier change.'))\n need(result == read(HERE/'RESULT.json'), 'Every source result and control remains unchanged')\n if extension is None:\n return result\n return {'source':result,'candidate':extension.run(word, caller, local, native, L)}" + ] +] diff --git a/research/gaussian-root-retirement/SOURCES.json b/research/gaussian-root-retirement/SOURCES.json new file mode 100644 index 0000000000..99fcc686f8 --- /dev/null +++ b/research/gaussian-root-retirement/SOURCES.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a", + "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ], + "retained_predecessors": [ + { + "archive": "native-source.tar", + "manifest": "RETAINED.json", + "archive_sha256": "2e4e49580c51758281bd9e4618f99d38f3a3622117d5c73bae0fce2db3616fa4", + "source_head": "44b0d0e8961201ac1656490b4384a7752e1cd9c5", + "reason": "Exact standalone runtime sources and original notices; no side-branch history is needed." + }, + { + "archive": "engines.tar", + "manifest": "RETAINED.json", + "archive_sha256": "cf1bd75c964d8d19ac867550f48424cba0187c4d6ca6b89ef1662bed738c390a", + "source_head": "dd1a979bfff090fa6559cc3b7d4e7f5ab24b4f80", + "reason": "Exact standalone runtime sources and original notices; no side-branch history is needed." + } + ] +} diff --git a/research/gaussian-root-retirement/TASK.json b/research/gaussian-root-retirement/TASK.json new file mode 100644 index 0000000000..499fd760d6 --- /dev/null +++ b/research/gaussian-root-retirement/TASK.json @@ -0,0 +1,129 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 8, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "p104-side-correction", + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "A legal Gaussian retirement at event 328 in the PR6398 root, composed with the complete PR6529 native word.", + "scope_change_reason": "The explicit user task asks for a new caller beyond the old fixed-target ceiling. The root boundary changes; the native helper groups do not.", + "bottleneck_link": "Split one productive rank-17 target into independent ranks 1 and 16 without removing a charged native job.", + "budget_minutes": 60, + "stop_rule": "Reject the construction if the full-ring endpoint, physical maps, complete invoice, compiler or outer inequalities fail.", + "outcome": "completed", + "evidence": "RESULT.json; PROOF.md; CONTROLLER.json; WITNESS.json; VALIDATION.md", + "author": "Ali Romman with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in construction, exact arithmetic, verification, research and writing; no subagents.", + "open_questions": [ + { + "question": "Can a changed caller return a larger independent Gaussian factor?", + "why_it_matters": "The present fixed invoice cannot give a 1 percent gain over PR6529.", + "first_step": "Find exact prefix and suffix dual pairs, then price the complete changed caller.", + "blocked_by": "No larger exact caller is currently constructed." + }, + { + "question": "Can a repeated Gaussian-assisted interface close at a favorable complete cost?", + "why_it_matters": "A different interface could cross the current fixed-target limit.", + "first_step": "Supply exact state transitions, a closed endpoint and all native helper maps.", + "blocked_by": "The current small-state searches do not supply a cycle." + }, + { + "question": "Can an independent reviewer validate the new split?", + "why_it_matters": "Author checks are not independent scientific acceptance.", + "first_step": "Check both dual pairs, the two basis maps, and the 104 physical target normalizations.", + "blocked_by": "Independent review has not occurred." + } + ] +} diff --git a/research/gaussian-root-retirement/VALIDATION.md b/research/gaussian-root-retirement/VALIDATION.md new file mode 100644 index 0000000000..f5ded7bc5d --- /dev/null +++ b/research/gaussian-root-retirement/VALIDATION.md @@ -0,0 +1,30 @@ +# Validation record + +Local environment: CPython 3.12.13 on macOS. The complete registered normal +and optimized replays both passed on November 3, 2026 (UTC). + +```sh +python3.12 -B scripts/research_package.py --package research/gaussian-root-retirement --check-only +python3.12 -B scripts/research_package.py --package research/gaussian-root-retirement +``` + +Markers: `PASS_PACKAGE_METADATA_AND_PINS`, +`PASS_GAUSSIAN_ROOT_RETIREMENT_KAPPA_00329394`, and +`PASS_REGISTERED_RESEARCH_PACKAGE`. + +Coverage includes the full source regeneration and controls, all 799 native +columns, native absolute phases, all physical contacts, both complete caller +engines, the exact dual pairs and basis maps, two rational price engines, +the compiler and all outer predicates. No source receipt is used in place +of these checks. The source result must also match its frozen complete receipt. + +The committed-byte and file-mode checks passed. The official package export +passed its integrity and declared-input checks. Both normal and optimized +replays passed from a read-only export without Git or executables on PATH. +All 39 retained source files match their pinned Git objects. The selected +result file has SHA256 +`9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa`. +Hosted CI is pending. +The optional full-history preflight is not claimed in this shallow checkout. +No independent scientific review is claimed. The five source framework +assumptions remain. The selected frontier is unchanged. diff --git a/research/gaussian-root-retirement/VERIFY.json b/research/gaussian-root-retirement/VERIFY.json new file mode 100644 index 0000000000..6a88f9edc6 --- /dev/null +++ b/research/gaussian-root-retirement/VERIFY.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 590, + "checks": "Complete source regeneration and controls, all 799 native columns and phases, both 1225-coefficient caller engines, exact dual pairs and bases, full physical maps, two rational prices, compiler and all outer predicates." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 590, + "checks": "Complete source regeneration and controls, all 799 native columns and phases, both 1225-coefficient caller engines, exact dual pairs and bases, full physical maps, two rational prices, compiler and all outer predicates." + } + ] +} diff --git a/research/gaussian-root-retirement/WITNESS.json b/research/gaussian-root-retirement/WITNESS.json new file mode 100644 index 0000000000..be22af6322 --- /dev/null +++ b/research/gaussian-root-retirement/WITNESS.json @@ -0,0 +1,104 @@ +{ + "cut_after": 328, + "handoff_after": 344, + "pivot": 4, + "fresh": 34, + "boundary": [ + [ + "SCALE", + 4, + "-1" + ], + [ + "LAMBDA", + 4, + -1 + ], + [ + "ADD", + 21, + 4, + "1" + ], + [ + "LAMBDA", + 4, + 1 + ], + [ + "ADD", + 4, + 20, + "1" + ] + ], + "middle": [ + [ + "ADD", + 4, + 2, + "1" + ], + [ + "ADD", + 2, + 4, + "-1" + ], + [ + "ADD", + 4, + 2, + "1" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 21, + 4, + "1" + ], + [ + "ADD", + 4, + 1, + "1" + ], + [ + "LAMBDA", + 20, + 1 + ], + [ + "ADD", + 4, + 20, + "-1" + ], + [ + "LAMBDA", + 20, + -1 + ], + [ + "ADD", + 4, + 21, + "1" + ] + ], + "group": [ + 4, + 20, + 21 + ] +} diff --git a/research/gaussian-root-retirement/check_caller.py b/research/gaussian-root-retirement/check_caller.py new file mode 100644 index 0000000000..c4fba4d14c --- /dev/null +++ b/research/gaussian-root-retirement/check_caller.py @@ -0,0 +1,110 @@ +"""Check the caller by reverse rows and check both dual-pair identities. + +This engine uses one row or column at a time. It does not call the source +matrix replay. The exact coefficient ring comes from the retained source. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from algebra import Q, coefficient, accumulate, shifted, zmul, need + + +def scalar_step(value, event, width): + op = event[0] + if op == 'SCALE': + return {key:zmul(coefficient(event[-1]),c) for key,c in value.items()} + if op == 'Q_POWER': + return shifted([value],(event[-1],)+(0,)*(width-1))[0] + if op == 'LAMBDA': + out = {} + accumulate(out,value,(Q(1,2),Q(event[-1],2))) + accumulate(out,shifted([value],(2,)+(0,)*(width-1))[0],(Q(1,2),Q(-event[-1],2))) + return out + raise ValueError('Scalar opcode') + + +def apply(vector, event, width, reverse=False): + op = event[0] + if op in ('SCALE','Q_POWER','LAMBDA'): + r=event[1] + vector[r]=scalar_step(vector[r],event,width) + elif op == 'SWAP': + a,b=event[1:] + vector[a],vector[b]=vector[b],vector[a] + elif op in ('ADD','QUERY','LOCAL'): + if op == 'LOCAL': + stage,src,dst=event[1:] + exponent,c=-1,coefficient(1) + term=(0,)+tuple(int(i==stage)for i in range(width-1)) + if reverse: + for r in (src,dst):vector[r]=shifted([vector[r]],term)[0] + else: + dst,src=event[1:3] + exponent,c=(0,coefficient(event[3]))if op=='ADD' else(event[3],coefficient(1)) + a,b=(src,dst)if reverse else(dst,src) + accumulate(vector[a],shifted([vector[b]],(exponent,)+(0,)*(width-1))[0],c) + if op == 'LOCAL' and not reverse: + for r in (src,dst):vector[r]=shifted([vector[r]],term)[0] + elif op in ('IDLE','IDLE_ONE'): + roles,stages=(event[1:3],event[3])if op=='IDLE' else([event[1]],event[2]) + term=(0,)+tuple(int(i in stages)for i in range(width-1)) + for r in roles:vector[r]=shifted([vector[r]],term)[0] + else: + raise ValueError('Caller opcode') + + +def transpose(word): + n,width=word['roles'],word['stages']+2 + zero=(0,)*width + for output in range(n): + vector=[{}for _ in range(n)] + vector[output]={zero:coefficient(1)} + for event in reversed(word['events']):apply(vector,event,width,True) + expected=[{}for _ in range(n)] + d=word['diagonal'][output] + expected[output]={(d[0]%4,*d[1:]):coefficient(1)} + need(vector==expected,'Every independent reverse caller coefficient') + return {'rows':n,'coefficients':n*n} + + +def product(a,b,width): + out={} + for key,c in a.items(): + accumulate(out,shifted([b],key)[0],c) + return out + + +def dual_pair(source, boundary, middle): + n,width=source['roles'],source['stages']+2 + zero=(0,)*width + one={zero:coefficient(1)} + lam=scalar_step(one,['LAMBDA',0,1],width) + inv=scalar_step(one,['LAMBDA',0,-1],width) + def vec(entries): + out=[{}for _ in range(n)] + for r,value in entries.items():out[r]=value if isinstance(value,dict)else{zero:coefficient(value)} + return out + neg=lambda value:{k:zmul(coefficient(-1),c)for k,c in value.items()} + a=vec({1:1,2:-2,20:neg(lam),21:1}) + b=vec({2:-1,21:-1}) + c=vec({20:1,4:-1}) + d=vec({21:neg(inv),4:-1}) + s=shifted([lam],(-1,)+(0,)*(width-1))[0] + for events,left,right in ((boundary,c,d),(middle,a,b)): + column=[dict(v)for v in right] + for event in events:apply(column,event,width) + unit=vec({4:1}) + need(column==unit,'The basis sends the dual column to the pivot') + row=vec({4:1}) + for event in reversed(events):apply(row,event,width,True) + need(row==left,'The pivot row is the declared dual functional') + for x,y in ((a,b),(c,d)): + value={} + for u,v in zip(x,y):accumulate(value,product(u,v,width)) + need(value==one,'Unit dual pairing') + column=[dict(v)for v in d] + for event in source['events'][:329]:apply(column,event,width) + need(column==[product(s,v,width)for v in b],'Prefix times d equals S times b') + row=[dict(v)for v in a] + for event in reversed(source['events'][:329]):apply(row,event,width,True) + need(row==[product(s,v,width)for v in c],'a times prefix equals S times c') + return {'cut_after':328,'input_pairing':'1','cut_pairing':'1', + 'prefix_column':'P d = S b','prefix_row':'a P = S c'} diff --git a/research/gaussian-root-retirement/engines.tar b/research/gaussian-root-retirement/engines.tar new file mode 100644 index 0000000000..3c3aa95bd7 Binary files /dev/null and b/research/gaussian-root-retirement/engines.tar differ diff --git a/research/gaussian-root-retirement/native-source.tar b/research/gaussian-root-retirement/native-source.tar new file mode 100644 index 0000000000..be0b75f926 Binary files /dev/null and b/research/gaussian-root-retirement/native-source.tar differ diff --git a/research/gaussian-root-retirement/physical.py b/research/gaussian-root-retirement/physical.py new file mode 100644 index 0000000000..ff34477215 --- /dev/null +++ b/research/gaussian-root-retirement/physical.py @@ -0,0 +1,89 @@ +"""Bind the mixed root to native phases and every whole Gaussian job. + +Adapted from Ali Romman's PR5544 physical checker. The Clifford recipes, +phase interpreter and local interface retain their predecessor credit. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +import json + + +def physical(word, local, L): + need = L.need + N = L.load(L.ROOT/'research/pr4359-p7-padding/native_inventory.py', 'productive_p104_phase_polynomial') + source = L.read(L.ROOT/'research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json') + recipes = {r['q']:r for r in source['recipes']} + dimension = word['ambient_rank'] + axes = tuple(1 << i for i in range(dimension)) + def completed(stage): + return N.norm((axis,1) for axis in axes[:9+8*stage]) + contacts, squares, target_profile = [], 0, Counter() + idle_jobs = Counter() + for _,stage,x,y in (e for e in word['events'] if e[0] == 'LOCAL'): + spectator = N.norm((axis,1) for axis in axes[9:9+8*stage]) + for q in local['ports']: + basis = recipes[q]['idle_children'][0]['orthogonal_axes'][:8] + need(all((x&q).bit_count()%2 == 0 for x in basis), 'Fresh-block basis fixes central port') + need(all((a&b).bit_count()%2 == int(i==j) for i,a in enumerate(basis) for j,b in enumerate(basis)), 'Actual orthonormal basis') + swaps = [] if stage == 0 else [b ^ axes[9+8*(stage-1)+i] for i,b in enumerate(basis)] + route = tuple(e ^ N.act(swaps,sum(((e&v).bit_count()%2) << i for i,v in enumerate(swaps))) for e in axes) + need(all(N.act(route,route[i]) == axes[i] for i in range(dimension)), 'Route inverse') + need(all((a&b).bit_count()%2 == int(i==j) for i,a in enumerate(route) for j,b in enumerate(route)), 'Orthogonal physical route') + need(N.act(route,q) == q, 'Route preserves Q') + raw_x = N.norm([(q,1)]) if stage == 0 else completed(stage-1) + raw_y = () if stage == 0 else N.norm(list(raw_x)+[(q,-1)]) + entry_x, entry_y = N.norm(list(spectator)+[(q,1)]), spectator + out0 = N.norm(list(spectator)+[(axis,1) for axis in axes[:9]]) + exit_x, exit_y = out0, N.norm(list(out0)+[(q,-1)]) + out_x, out_y = completed(stage), N.norm(list(completed(stage))+[(q,-1)]) + maps = [N.contact(a,b,route,dimension) for a,b in [(raw_x,entry_x),(raw_y,entry_y),(exit_x,out_x),(exit_y,out_y)]] + delta = N.norm([(axis,1) for axis in axes[:9]]+[(q,-1)]) if stage == 0 else N.norm((axis,1) for axis in axes[9+8*(stage-1):9+8*stage]) + for incoming,outgoing in [(raw_x,out_x),(raw_y,out_y)]: + need(N.polynomial(N.norm(list(outgoing)+[(a,-c) for a,c in incoming]),dimension) == N.polynomial(delta,dimension), 'Actual diagonal D_s') + cross = N.norm(list(out_y)+[(a,-c) for a,c in raw_x]) + need(N.polynomial(cross,dimension) == N.polynomial(N.norm(list(delta)+[(q,-1)]),dimension), 'Actual cross term D_s Q^-1') + need(sum(route[i] != axes[i] for i in range(dimension)) <= 17 and all(m['translation'].bit_count() <= 17 and m['inverse_translation'].bit_count() <= 17 for m in maps), 'Fixed seventeen-axis route allowance') + contacts.append([stage,q,maps]) + for q in local['ports']: + # Multiply the Gaussian pair twice with exact real and imaginary parts. + a,b = (Q(1,2),Q(1,2)), (Q(1,2),Q(-1,2)) + mul = lambda z,w: (z[0]*w[0]-z[1]*w[1],z[0]*w[1]+z[1]*w[0]) + plus = lambda z,w: (z[0]+w[0],z[1]+w[1]) + diagonal,off = plus(mul(a,a),mul(b,b)), plus(mul(a,b),mul(b,a)) + need(diagonal == (0,0) and off == (1,0), 'Q^2 is translation with phase +1') + for address in range(512): + need({address:diagonal,address^q:off}[address^q] == (1,0), 'Every central square column') + squares += 1 + for term in word['diagonal']: + qp,selected = term[0],term[1:] + physical = N.norm([(q,qp)]+[(axis,1) for s,yes in enumerate(selected) if yes for axis in (axes[:9] if s == 0 else axes[9+8*(s-1):9+8*s])]+[(q,-1)]*selected[0]) + need(qp in (-1, 0, 1) and not (qp == 0 and selected[0]), 'Declared central phase and fresh-stage target') + positive = list(axes[:9]) if selected[0] else ([q] if qp else []) + positive += [axis for s in range(1,len(selected)) if selected[s] for axis in axes[9+8*(s-1):9+8*s]] + need(N.polynomial(physical,dimension) == N.polynomial(N.norm([(x,1) for x in positive]+[(q,2)]*(qp == -1)),dimension), 'Full main output phase and rank') + target_profile[len(positive)] += 1 + for e in word['events']: + if e[0] not in ('IDLE', 'IDLE_ONE'): + continue + stages = e[3] if e[0] == 'IDLE' else e[2] + need(len(stages) == len(set(stages)), 'Whole idle has no repeated stage') + for q in local['ports']: + positive, physical = [], [] + for stage in stages: + if stage == 0: + positive += recipes[q]['idle_children'][0]['orthogonal_axes'][:8] + physical += [(x,1) for x in axes[:9]]+[(q,-1)] + else: + block = axes[9+8*(stage-1):9+8*stage] + positive += block + physical += [(x,1) for x in block] + need(len(positive) == 8*len(stages), 'All idle Gaussian axes') + need(all((a&b).bit_count()%2 == int(i==j) for i,a in enumerate(positive) for j,b in enumerate(positive)), 'Independent orthonormal idle axes') + N.contact(N.norm(physical),N.norm((x,1) for x in positive),axes,dimension) + idle_jobs[len(positive)] += 2 if e[0] == 'IDLE' else 1 + return {'ports':104,'full_calls':len(contacts)//104,'physical_contacts':4*len(contacts),'central_square_columns':squares, + 'main_targets':dict(target_profile),'whole_idle_jobs':dict(idle_jobs),'route_payload_sha256':sha256(json.dumps(contacts,separators=(',',':')).encode()).hexdigest(), + 'central_translations':sum(e[0] == 'Q_POWER' for e in word['events']), + 'ordinary_normalizations':sum(e[0] == 'LAMBDA' for e in word['events']),'new_paid_jobs':0,'tensor_rule':'Factorwise native maps; scalar signs stay outside the tensor power.'} diff --git a/research/gaussian-root-retirement/pricing.py b/research/gaussian-root-retirement/pricing.py new file mode 100644 index 0000000000..67a331348d --- /dev/null +++ b/research/gaussian-root-retirement/pricing.py @@ -0,0 +1,186 @@ +"""Check the complete mixed-projector-root invoice and outer transfer. + +The interval and compiler bounds are by zxv and Cao Yifan. The productive +recursion is by Jacob Alan Sussman. The source price adapter is by Ali Romman. +The source lifts and tree invoice are by Ali Romman, with OpenAI Codex +assistance. This adapter keeps the root and changes the native source invoice. +It includes all nine output contractions and their productive target debits. +The original sources retain their credit. Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +from controller import formula_invoice, need + +KAPPA = Q('0.00329394') +TESTED = Q('0.003293945') +PREVIOUS = Q('0.003288299') + + +def encode(value): + if isinstance(value, Q): + return str(value) + if isinstance(value, dict): + return {str(k): encode(v) for k, v in value.items()} + if isinstance(value, (tuple, list)): + return [encode(v) for v in value] + return value + + +def assemble(local, native, word, physical): + paid, targets = Counter(), Counter() + counts = Counter(e[0] for e in word['events']) + need(local['helpers'] == native['helpers'], 'All source helper targets have native maps') + idle = Counter() + for event in word['events']: + if event[0] == 'LOCAL': + paid.update(local['paid']) + targets.update(local['helpers']) + elif event[0] == 'QUERY': + paid[1] += 104 + elif event[0] in ('IDLE', 'IDLE_ONE'): + rank = 8*len(event[3] if event[0] == 'IDLE' else event[2]) + count = 208 if event[0] == 'IDLE' else 104 + paid[rank] += count + idle[rank] += count + main = Counter() + for term in word['diagonal']: + main[int(term[0] % 2)+8*sum(term[1:])] += 104 + targets.update(main) + need(main == physical['main_targets'], 'All main target phases and ranks') + need(idle == physical['whole_idle_jobs'], 'All paired and individual whole idle jobs') + expected_targets, expected_paid = formula_invoice(local) + expected_targets.update({1:104,16:104,17:-104}) + need((targets, paid) == (expected_targets, expected_paid), 'Independent tree, retirement delta and emitted-event counts') + need((counts['LOCAL'], counts['QUERY'], counts['IDLE']) == (18, 17, 14) and counts['IDLE_ONE'] == 2 and counts['LAMBDA'] == 34, 'Complete caller census') + need((sum(targets.values()), sum(paid.values())) == (13756, 67096), 'All independent fields and paid calls') + need(sum(r*n for r, n in targets.items())-sum(r*n for r, n in paid.items()) == 760, 'Complete rank-mass surplus') + need((max(targets), max(paid)) == (145, 56), 'Maximum target and paid ranks') + return targets, paid, counts + + +def run(local, native, word, physical, L): + T, P, counts = assemble(local, native, word, physical) + E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py', 'balanced_intervals') + other = L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py', 'balanced_second_intervals') + def margin(k): + a, b = E.moment(T, 1-k), E.moment(P, 1-k) + return a[0]-b[1], a[1]-b[0] + from root_interval import construct + bracket, _ = construct(E, T, P) + lower, upper = Q(bracket['lower'], bracket['grid']), Q(bracket['upper'], bracket['grid']) + signed = Counter(T) + signed.subtract(P) + cap, derivative_upper = Q('.0034'), Q(0) + for rank, count in signed.items(): + logarithm = E.log_bounds(rank) + a = E.mul(E.power(rank, 1-cap), logarithm)[0] + b = rank*logarithm[1] + derivative_upper -= count*(a if count >= 0 else b) + need(derivative_upper < 0, 'Unique raw crossing below the BIT cap') + need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure') + endpoints = {} + for label, k in [('lower', lower), ('upper', upper)]: + tl, th = other.moment(T, k) + pl, ph = other.moment(P, k) + second = (tl-ph, th-pl) + first = margin(k) + need(max(first[0], second[0]) <= min(first[1], second[1]), + 'Both rational engines agree at the raw endpoint') + need(second[0] > 0 if label == 'lower' else second[1] < 0, + 'The second engine certifies both raw endpoint signs') + endpoints[label] = {'first': E.display(first), 'second': E.display(second)} + need(PREVIOUS < KAPPA < TESTED < lower, 'The claim and tested saving are below the raw crossing') + t, offset, power, cutoff, floor = 1-TESTED, Q(1, 7), 1920, 12, 13 + target, paid = E.moment(T, t), E.moment(P, t) + tl, th = other.moment(T, TESTED) + pl, ph = other.moment(P, TESTED) + need(tl > ph and max(tl, target[0]) <= min(th, target[1]) + and max(pl, paid[0]) <= min(ph, paid[1]), 'Two independent rational moment engines') + alpha = E.divide(paid, target) + gamma = E.divide(E.moment(P, t+offset), E.mul(E.power(cutoff, offset), target)) + delta = E.divide((Q(sum(T.values())*floor),)*2, E.mul(E.power(cutoff, TESTED), target)) + reserve, decay = Q(1, 10**29), Q(31, 32) + need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All charged tail ratios') + need(power % 128 == 0 and decay**128 < Q(1, 16), 'The previous block estimate applies') + coarse_tail = 4*Q(1, 16)**(power//128) + need(1/(1+power*reserve)+coarse_tail > 1, 'The coarse tail bound cannot fund this claim') + exact_tail = 4*decay**power + normalized = 1/(1+power*reserve)+exact_tail + need(normalized < 1 and cutoff**64 < floor**63, 'Completion, splitting and rounding') + theta, logarithm_power = Q(63, 64), 2100 + # Keep each exponential inside the retained engine's proved domain. + half = E.power(145, Q(power, 2)*TESTED) + factor = E.mul(half, half) + eta = E.scale(E.divide((Q(1), Q(1)), factor), t) + need(2*(cutoff**power)**64 <= (145**power)**63 + and eta[0] > theta**logarithm_power, 'Shifted exits and complement capacity') + need(factor[1] < 2**logarithm_power, 'Compiler initial range') + gap = (TESTED-KAPPA)/7 + need(gap.numerator == 1, 'Exact compiler integer grid') + step = gap.denominator + def wins(j): + return (step*j+1)**logarithm_power < 2**j + left, right = 1, 2 + while not wins(right): + left, right = right, 2*right + while right-left > 1: + middle = (left+right)//2 + if wins(middle): + right = middle + else: + left = middle + H = step*right + need(H > 8*power and wins(right) and not wins(right-1), 'Uniform threshold and adjacent-grid rejection') + local_routes = (sum(local['paid'].values())+native['helper_normalizers'] + +native['main_adapters']+4*104+4*local['owned_lifetimes'])*1000 + need(local['real_scalar_allowance']+local_routes < 10**7, 'Every local ordinary operation is funded') + raw = 18*10**7 + 17*1664 + 32*35*104*len(word['events']) + 35*104*(26+1000) + need(all(abs(Q(e[-1])) <= 16 for e in word['events'] if e[0] in ('ADD', 'SCALE')), + 'Every emitted scalar coefficient has the declared growth bound') + need(all(Q(e[-1]).denominator & (Q(e[-1]).denominator-1) == 0 + for e in word['events'] if e[0] in ('ADD', 'SCALE')), + 'Every emitted rational scalar is dyadic') + need(raw < 10**9, 'Complete ordinary-work budget') + bit = L.read(L.ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT'] + atom = Q(bit['atom']) + ordinary = (1-atom)*Q(bit['after_cover']) + atom*Q('.0000384599') + admitted = Q(bit['admitted']) + need(atom > ordinary > admitted > TESTED and atom < 1-ordinary, 'Retained BIT admission and stock') + outer_module = L.load(L.ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py', 'balanced_outer') + params = {'kappa': KAPPA, 'tested_saving': TESTED, 'complex_uniform_saving': KAPPA+6*gap, + 'b': KAPPA+5*gap, 'a': KAPPA+4*gap, 'q': KAPPA+3*gap, 'bit_saving': admitted, + 'epsilon': 1-gap, 'beta': 1-3*gap, 'r0': gap/10, 'stop': gap, 'layout': gap, 'd': gap} + outer = outer_module.ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear'] = params['beta']*(1-atom) + need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Full outer predicate inventory') + need(all(x > 0 for key in ('strict_checks', 'functional_checks') for x in outer[key].values()), 'Every outer inequality is strict') + old_completion = E.divide((Q(sum(T.values())*17),)*2, E.mul(E.power(16, TESTED), target)) + need(old_completion[0] > 1, 'The old completion cutoff does not fund the new inventory') + bad = outer_module.ledger(dict(params, bit_saving=Q('.0027'))) + need(any(x <= 0 for x in bad['strict_checks'].values()), 'Insufficient BIT saving rejected') + return encode({'kappa': KAPPA, 'kappa_decimal': '0.00329394', 'previous_fixed_root': PREVIOUS, + 'refinement_kind': 'Independent Gaussian retirement changes the complete productive profile.', + 'gain': KAPPA-PREVIOUS, 'relative_gain_percent': 100*(KAPPA/PREVIOUS-1), + 'raw_root_interval': [lower, upper], 'raw_headroom': [lower-KAPPA, upper-KAPPA], + 'raw_endpoint_margins': endpoints, + 'derivative_upper': derivative_upper, 'margin_at_previous': E.display(margin(PREVIOUS)), + 'targets': T, 'paid': P, 'productive_fields': sum(T.values()), 'paid_calls': sum(P.values()), + 'rank_mass_surplus': 760, 'full_forward_calls': 18, 'thin_queries': 17, + 'whole_idle_jobs': 3120, 'strictification': { + 'tested': TESTED, 'power': power, 'cutoff': cutoff, 'floor': floor, + 'tail_offset': offset, 'reserve': reserve, 'tail_decay': decay, + 'exact_tail_upper': exact_tail, 'coarse_tail_upper': coarse_tail, + 'alpha': E.display(alpha), 'gamma': E.display(gamma), 'delta': E.display(delta), + 'normalized_paid_upper': normalized}, + 'compiler': {'theta': theta, 'logarithm_power': logarithm_power, 'eta': E.display(eta), + 'gap': gap, 'H': H, 'N': '2^'+str(H), 'integer_test_exponent': right, + 'uniform_saving': params['complex_uniform_saving'], 'word_materialized': False}, + 'nonrecursive': {'local_scalar': local['real_scalar_allowance'], 'local_routes': local_routes, + 'raw_scalar_upper': raw, 'raw_budget': 10**9, + 'peak_owned_fields': local['peak_owned_fields'], + 'scalar_growth_bound': 'At most 2^(10^9 + R*f), where R is the full paid rank mass.', + 'paid_rank_mass': sum(r*n for r, n in P.items())}, + 'ordinary_BIT': bit, 'outer': outer, + 'negative_controls': {'old_completion': 'Cutoff16 and floor17 give a ratio above one.', + 'old_BIT': 'An outer inequality fails at BIT saving0.0027.', + 'coarse_tail': 'The block tail bound cannot fund this near-limit claim.'}}) diff --git a/research/gaussian-root-retirement/retirement.py b/research/gaussian-root-retirement/retirement.py new file mode 100644 index 0000000000..d73b60727e --- /dev/null +++ b/research/gaussian-root-retirement/retirement.py @@ -0,0 +1,56 @@ +"""Return one Gaussian component before the two-stage suffix. + +The word and binary suppliers are from PR6398. The independent boundary +uses the PR5599 dual-pair method. All extra operations are ordinary. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from copy import deepcopy +from fractions import Fraction as Q + +G = [['SCALE',4,'-1'],['LAMBDA',4,-1],['ADD',21,4,'1'], + ['LAMBDA',4,1],['ADD',4,20,'1']] +J = [['ADD',4,2,'1'],['ADD',2,4,'-1'],['ADD',4,2,'1'], + ['SCALE',2,'-1'],['SCALE',4,'-1'],['ADD',21,4,'1'], + ['ADD',4,1,'1'],['LAMBDA',20,1],['ADD',4,20,'-1'], + ['LAMBDA',20,-1],['ADD',4,21,'1']] + + +def inverse(events): + out = deepcopy(list(reversed(events))) + for e in out: + e[-1] = (-e[-1] if e[0] == 'LAMBDA' else + str(1/Q(e[-1]) if e[0] == 'SCALE' else -Q(e[-1]))) + return out + + +def construct(source): + word = deepcopy(source) + if word['roles'] != 34 or word['stages'] != 18 or word['events'][328] != ['QUERY',20,21,-1]: + raise ValueError('Exact source boundary') + group, pivot, fresh, cut = (4,20,21),4,34,328 + if len({tuple(word['diagonal'][r][1:])for r in group}) != 1: + raise ValueError('Equal stage targets on the boundary group') + normalized = deepcopy(word['events']) + for r in group: + if word['diagonal'][r][0] == 1: + normalized.append(['Q_POWER',r,-2]) + normalized.append(['LAMBDA',r,1]) + def rename(e): + e=deepcopy(e) + slots={'ADD':(1,2),'SWAP':(1,2),'SCALE':(1,),'LAMBDA':(1,), + 'Q_POWER':(1,),'QUERY':(1,2),'LOCAL':(2,3),'IDLE':(1,2),'IDLE_ONE':(1,)}[e[0]] + for at in slots: + if e[at] == pivot: + e[at] = fresh + return e + word['events'] = inverse(G)+normalized[:cut+1]+J + handoff = len(word['events'])-1 + word['events'] += [rename(e) for e in inverse(J)+normalized[cut+1:]+G] + word['events'] += [['LAMBDA',r,-1]for r in group] + word['roles'] += 1 + for r in group: + word['diagonal'][r][0] = -1 + word['diagonal'][pivot] = [-1]+[0]*(word['stages']+1) + word['diagonal'].append([0,*source['diagonal'][pivot][1:]]) + return word, {'cut_after':cut,'handoff_after':handoff,'pivot':pivot,'fresh':fresh, + 'boundary':G,'middle':J,'group':list(group)} diff --git a/research/gaussian-root-retirement/source_driver.py b/research/gaussian-root-retirement/source_driver.py new file mode 100644 index 0000000000..8b5d00c240 --- /dev/null +++ b/research/gaussian-root-retirement/source_driver.py @@ -0,0 +1,144 @@ +"""Check the complete conditional scaled-transport construction. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +The native, mixed caller, price and compiler sources keep their original credit. +""" +from collections import Counter +from copy import deepcopy +from hashlib import sha256 +import gzip +import json +import sys + +sys.dont_write_bytecode = True +from fusion_support import HERE, need, read, load, encode, source_context, reject, authenticate +from construct import construct + +STATUS = 'PASS_SCALED_TRANSPORT_FUSION_KAPPA_003288299' + + +def delta(after, before): + out = Counter(after) + out.subtract(before) + return {int(k): v for k, v in out.items() if v} + + +def run(write=False, build_only=False, services=None, extension=None): + with source_context() as (package, retained, local_module): + L = local_module if services is None else services(local_module.ROOT, local_module) + source = read(package/'WORD.json.gz') + source_result = read(package/'RESULT.json') + source_verifier = load(package/'verify.py', 'fusion_source_constructor_check') + # The retained build mode checks its full constructor chain and controls. + source_verifier.run(retained.parent/'source-rebuild', build_only=True) + word, construction = construct(source, read(HERE/'SPEC.json')) + need(len(word['program']) == 18493 and construction['correction_count'] == 569 + and len(construction['changed_full_rows']) == 28, 'Exact construction inventory') + need(all(word[k] == source[k] for k in word if k != 'program'), 'All public boundaries and native frames are unchanged') + if write: + payload = json.dumps(word, separators=(',', ':')).encode() + (HERE/'WORD.json.gz').write_bytes(gzip.compress(payload, mtime=0)) + (HERE/'CONSTRUCTION.json').write_text(json.dumps(encode(construction), sort_keys=True, indent=2)+'\n') + else: + need(word == read(HERE/'WORD.json.gz'), 'Exact regenerated word') + need(encode(construction) == read(HERE/'CONSTRUCTION.json'), 'Exact correction receipt') + before, local = L.replay(source), L.replay(word) + need(encode(before) == source_result['local'], 'Exact source local invoice') + need(delta(local['paid'], before['paid']) == {1: -2, 4: -2, 5: 2} + and local['helpers'] == before['helpers'], 'Complete local paid and productive changes') + need(tuple(local[k] for k in ('public_inputs', 'owned_fields', 'owned_lifetimes', + 'peak_owned_fields', 'real_scalar_allowance', 'paid_rank_mass')) + == (770, 29, 45, 13, 137218, 5925), 'Exact changed local inventory') + zero_module = load(package/'zero_scratch.py', 'fusion_zero_scratch') + obligations = [dict(field=782, frame=127, count=1)] + zero = zero_module.verify(word, obligations) + controls = {} + for role, receiver, frame in [(368, 782, 243), (336, 781, 240)]: + expected = ['ADD', receiver, role, '1', frame] + locations = [i for i, event in enumerate(word['program']) if event == expected] + need(len(locations) == 1, 'Unique new carrier injection') + for kind in ('drop', 'double', 'wrong_frame'): + bad = deepcopy(word) + if kind == 'drop': + del bad['program'][locations[0]] + elif kind == 'double': + bad['program'][locations[0]][3] = '2' + else: + bad['program'][locations[0]][-1] = 127 + controls[str(role)+'_injection_'+kind] = reject(lambda bad=bad: L.replay(bad)) + for index in (0, -1): + bad = deepcopy(word) + del bad['program'][construction['raw_event_count'] if index == 0 else index] + controls['correction_drop_'+str(index)] = reject(lambda bad=bad: L.replay(bad)) + bad = deepcopy(word) + position = next(i for i, event in enumerate(bad['program']) if event[0] == 'SCALE' and event[1] == 368 and event[-1] == 243) + bad['program'][position][-1] = 517 + controls['old_scale_frame'] = reject(lambda: L.replay(bad)) + pin = next(x for x in read(HERE/'SOURCE.json')['files'] if x['path'].endswith('p104-third-anchor-clean-mixed-root/WORD.json.gz')) + raw = (package/'WORD.json.gz').read_bytes() + controls['source_byte'] = reject(lambda: authenticate(bytes([raw[0]^1])+raw[1:], pin)) + need(construct(source, [])[0] == source, 'Empty-change source control') + print('PASS exact source rebuild, changed scalar word, lifetimes, zero cache and construction controls', flush=True) + if build_only: + return + tree = retained/'research/mixed-projector-query-root' + load(tree/'algebra.py', 'algebra') + controller = load(tree/'controller.py', 'controller') + caller = controller.construct() + need(encode(caller) == read(tree/'CONTROLLER.json'), 'Exact unchanged caller') + controller.replay(caller) + module = load(tree/'module_check.py', 'fusion_independent_module').run() + controls.update(controller.controls(caller)) + columns = L.reverse_columns(word) + need(columns['columns'] == 799 and columns['coefficients'] == 638401, 'All independent transpose columns') + print('PASS all 799 columns and complete mixed caller', flush=True) + native = L.native(word) + need(native['helpers'] == local['helpers'] and native['main_adapters'] == 208 + and native['helper_normalizers'] == 1124, 'All native targets and adapters') + physical = load(tree/'physical.py', 'fusion_physical').physical(caller, word, L) + need(physical['physical_contacts'] == 7488, 'All physical mixed contacts') + print('PASS native maps with absolute phases and all 7488 physical contacts', flush=True) + adapter = read(HERE/'PRICING-EDITS.json') + text = (package/'pricing.py').read_text() + need(sha256(text.encode()).hexdigest() == adapter['source_sha256'], 'Exact price source') + for before_text, after_text in adapter['edits']: + need(text.count(before_text) == 1, 'Unique declared price edit') + text = text.replace(before_text, after_text) + need(text == (HERE/'pricing.py').read_text(), 'Only declared price changes') + price_module = load(HERE/'pricing.py', 'fusion_price') + price = price_module.run(local, native, caller, physical, L) + T0, P0 = controller.formula_invoice(before) + T1, P1 = controller.formula_invoice(local) + need(T0 == T1 and delta(P1, P0) == {1: -36, 4: -36, 5: 36}, 'All eighteen native calls and target debits') + E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py', 'fusion_comparison_intervals') + other = L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py', 'fusion_comparison_second') + t0, p0 = E.moment(T0, 1-price_module.KAPPA), E.moment(P0, 1-price_module.KAPPA) + tl, th = other.moment(T0, price_module.KAPPA) + pl, ph = other.moment(P0, price_module.KAPPA) + need(t0[1] < p0[0] and th < pl, 'Both engines reject the old source at the new claim') + comparison = dict(previous='0.003287014', source_raw=source_result['complete_cost']['raw_root_interval'], + first=E.display((t0[0]-p0[1], t0[1]-p0[0])), second=E.display((tl-ph, th-pl))) + print('PASS both exact prices, complete compiler and outer inequalities, and strict source comparison', flush=True) + result = encode(dict(status=STATUS, conditional_kappa=str(price_module.KAPPA), + kappa_decimal='0.003288299', source_head=read(HERE/'SOURCE.json')['head'], + native_word_sha256=sha256((HERE/'WORD.json.gz').read_bytes()).hexdigest(), + local=local, construction=construction, columns=columns, native=native, + zero_cache=zero, caller_module=module, physical=physical, + complete_cost=price, comparison=comparison, controls=controls, + assumptions=['native_all_columns', 'owned_erasure', 'compiler', 'precision_tape', 'analytic_recovery'], + scope='Local conditional construction; no independent acceptance, materialized multiplier or selected-frontier change.')) + need(result == read(HERE/'RESULT.json'), 'Every source result and control remains unchanged') + if extension is None: + return result + return {'source':result,'candidate':extension.run(word, caller, local, native, L)} + + +if __name__ == '__main__': + write = '--write-result' in sys.argv + result = run(write=write, build_only='--build-only' in sys.argv) + if result is not None: + if write: + (HERE/'RESULT.json').write_text(json.dumps(result, sort_keys=True, indent=2)+'\n') + else: + need(result == read(HERE/'RESULT.json'), 'Exact complete receipt') + print(STATUS, flush=True) diff --git a/research/gaussian-root-retirement/verify.py b/research/gaussian-root-retirement/verify.py new file mode 100644 index 0000000000..aa7d1d8555 --- /dev/null +++ b/research/gaussian-root-retirement/verify.py @@ -0,0 +1,165 @@ +"""Replay the source and the independent Gaussian retirement. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +Retained authors and exact source paths are in RETAINED.json and NOTICE. +""" +from contextlib import contextmanager +from copy import deepcopy +from hashlib import sha1,sha256 +from pathlib import Path,PurePosixPath +from types import SimpleNamespace +import importlib.util +import json +import sys +import tarfile +import tempfile + +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +STATUS='PASS_GAUSSIAN_ROOT_RETIREMENT_KAPPA_00329394' + + +def need(ok,message): + if not ok:raise ValueError(message) + + +def read(path): + return json.loads(Path(path).read_bytes()) + + +def load(path,name): + spec=importlib.util.spec_from_file_location(name,path) + module=importlib.util.module_from_spec(spec) + sys.modules[name]=module + spec.loader.exec_module(module) + return module + + +def reject(action): + try:action() + except ValueError as error:return str(error) + raise ValueError('Invalid caller accepted') + + +def unpack(record,root): + archive=HERE/record['archive'] + need(sha256(archive.read_bytes()).hexdigest()==record['archive_sha256'],'Retained archive SHA256') + pins={p['path']:p for p in record['files']} + seen=set() + with tarfile.open(archive,'r:')as tar: + for member in tar.getmembers(): + path=PurePosixPath(member.name) + need(member.isfile()and not path.is_absolute()and'..'not in path.parts + and member.name in pins and member.name not in seen,'Declared regular source member') + seen.add(member.name) + data=tar.extractfile(member).read();pin=pins[member.name] + need(sha256(data).hexdigest()==pin['sha256']and + sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest()==pin['git_blob'], + 'Exact source SHA256 and Git blob') + target=root/member.name + target.parent.mkdir(parents=True,exist_ok=True);target.write_bytes(data) + need(seen==set(pins),'Complete retained inventory') + + +def adapter(source,target,edits): + text=source.read_text() + for before,after in read(HERE/edits): + need(text.count(before)==1,'Unique declared adapter edit') + text=text.replace(before,after) + need(text==target.read_text(),'Every other source byte remains unchanged') + + +class Candidate: + def run(self,native_word,old_caller,local,native,L): + controller=sys.modules['controller'] + make=load(HERE/'retirement.py','retirement_constructor') + checks=load(HERE/'check_caller.py','retirement_independent') + word,witness=make.construct(old_caller) + forward=controller.replay(word) + reverse=checks.transpose(word) + pair=checks.dual_pair(old_caller,make.G,make.J) + controls=controller.controls(word) + for label,index in [('boundary',0),('cut',witness['handoff_after']),('return',len(word['events'])-1)]: + bad=deepcopy(word);del bad['events'][index] + controls['missing_'+label]=reject(lambda bad=bad:controller.replay(bad)) + bad=deepcopy(word);bad['diagonal'][-1][0]=-1 + controls['unearned_central_target']=reject(lambda:checks.transpose(bad)) + bad=deepcopy(word) + bad['events'][witness['handoff_after']][-1]='-1' + controls['wrong_cut_sign']=reject(lambda:controller.replay(bad)) + # The handoff changes one role name. Compare the ordered stage/rank jobs. + def jobs(caller): + return [(e[0],e[1]if e[0]=='LOCAL' else e[3]if e[0]=='QUERY' else + tuple(e[3]if e[0]=='IDLE' else e[2]))for e in caller['events']if e[0]in('LOCAL','QUERY','IDLE','IDLE_ONE')] + need(jobs(old_caller)==jobs(word),'Every paid stage, query sign and whole idle is retained') + physical=load(HERE/'physical.py','retirement_physical').physical(word,native_word,L) + price_module=load(HERE/'pricing.py','retirement_price') + bound=price_module.run(local,native,word,physical,L) + T0,P0=controller.formula_invoice(local) + E=L.load(L.ROOT/'research/higher-moment-strictification/verify.py','retirement_comparison') + other=L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','retirement_second_comparison') + first=E.moment(T0,1-price_module.KAPPA),E.moment(P0,1-price_module.KAPPA) + tl,th=other.moment(T0,price_module.KAPPA);pl,ph=other.moment(P0,price_module.KAPPA) + need(first[0][1]