diff --git a/research/mixed-projector-query-root/CONTROLLER.json b/research/mixed-projector-query-root/CONTROLLER.json new file mode 100644 index 0000000000..4f7d7a2f13 --- /dev/null +++ b/research/mixed-projector-query-root/CONTROLLER.json @@ -0,0 +1,4170 @@ +{ + "ambient_rank": 153, + "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, + 1, + 1, + 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 + ] + ], + "events": [ + [ + "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", + 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", + 4, + 5, + "1" + ], + [ + "ADD", + 3, + 5, + "1" + ], + [ + "ADD", + 1, + 5, + "1/2" + ], + [ + "SCALE", + 5, + "-1/2" + ], + [ + "ADD", + 5, + 4, + "1/2" + ], + [ + "ADD", + 3, + 4, + "-1" + ], + [ + "ADD", + 2, + 4, + "-1" + ], + [ + "ADD", + 1, + 4, + "-3/2" + ], + [ + "ADD", + 4, + 3, + "1" + ], + [ + "ADD", + 2, + 3, + "1/2" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "ADD", + 5, + 1, + "2" + ], + [ + "ADD", + 4, + 1, + "2" + ], + [ + "ADD", + 3, + 1, + "-2" + ], + [ + "ADD", + 2, + 1, + "1" + ], + [ + "SCALE", + 1, + "-2" + ], + [ + "SWAP", + 0, + 5 + ], + [ + "ADD", + 2, + 5, + "1" + ], + [ + "ADD", + 2, + 4, + "1" + ], + [ + "ADD", + 2, + 3, + "3/2" + ], + [ + "ADD", + 0, + 3, + "-1/2" + ], + [ + "ADD", + 5, + 2, + "-2" + ], + [ + "ADD", + 4, + 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", + 4, + 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, + 4, + "-2" + ], + [ + "ADD", + 1, + 4, + "1" + ], + [ + "ADD", + 0, + 4, + "2" + ], + [ + "ADD", + 5, + 3, + "-2" + ], + [ + "ADD", + 4, + 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", + 4, + 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", + 4, + 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, + 4, + "1" + ], + [ + "ADD", + 2, + 4, + "-1/2" + ], + [ + "ADD", + 1, + 4, + "1/2" + ], + [ + "SCALE", + 4, + "-1/2" + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 5, + 3, + "1/2" + ], + [ + "ADD", + 2, + 3, + "3/2" + ], + [ + "ADD", + 1, + 3, + "-1/2" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 5, + 2, + "1" + ], + [ + "ADD", + 4, + 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", + 4, + -1 + ], + [ + "LAMBDA", + 5, + -1 + ] + ], + "nodes": [ + { + "exponent": 1, + "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 + ] + } + ], + "roles": 34, + "schema": "mixed-projector-query-root/2", + "stages": 18 +} diff --git a/research/mixed-projector-query-root/NOTICE b/research/mixed-projector-query-root/NOTICE new file mode 100644 index 0000000000..03e4ac5937 --- /dev/null +++ b/research/mixed-projector-query-root/NOTICE @@ -0,0 +1,287 @@ +Mixed projector query root +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. No subagents. + +The new contribution is the normalized six-field root, its weighted binary +children, exact complete caller, full invoice and conditional bound. +The shortest central-involution query tuple is from the credited +five-call-projector-rigidity package by Ali Romman with OpenAI Codex. +The binary query extension is PR6348. The unchanged native source is PR6349. +The simple normalization identity is not claimed as a new general algebra theorem. +The native construction, scalar compression and inherited proof engines are +predecessor work. Their exact source notices follow. + +Source: research/balanced-query-tree/NOTICE + +Binary query-tree caller + +New construction, proof and code: Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. No subagents. + +Cinna Davis supplies the productive path caller, query thinning and exact Laurent factorization. Ali Romman supplies the all-forward P104 binding in PR5544 and the retained-operand word in PR6167. The native word and interval/compiler lineage remain predecessor work. The new contribution is the four-field query extension, its tree composition, complete invoice and conditional price. + +The authenticated PR6167 notice follows. + +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. + +Source: research/p104-native-input-lifting/NOTICE + +Native helper input lifting +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author checks. + +The direct source is PR6314 at 36533d4d1b4e2dd8672427461b12de3001b85810, +by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. +It compresses the scalar word of PR6167 without a kappa change. +The four native input lifts and their complete conditional price are new here. +The basis identity is elementary linear algebra; no new general theorem +for that identity is claimed. + +The PR6167 source notice follows unchanged. Its nested source archive also +retains the earlier notices. + +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. diff --git a/research/mixed-projector-query-root/PROOF.md b/research/mixed-projector-query-root/PROOF.md new file mode 100644 index 0000000000..510bf9dba0 --- /dev/null +++ b/research/mixed-projector-query-root/PROOF.md @@ -0,0 +1,222 @@ +# A mixed projector root for independent Gaussian outputs + +This construction changes the caller. It keeps the complete PR6349 native +source. Four binary query suppliers, with 7, 2, 2 and 7 native leaves, enter +a six-field root. The root has three thin queries and two individual +whole idle jobs. It gives six independent Gaussian outputs. The child +suppliers give another 28 independent main outputs. + +The conditional claim is kappa 0.00328467. The five inherited framework +assumptions remain. This is not an unconditional multiplication theorem, +a materialized uniform word or an independent scientific review. + +## 1. An ordinary normalization of the native query + +Write q = Q^-1 for the actual common central Gaussian. The native checker +verifies Q^2 = Q^-2 = X with absolute phase +1. X is an ordinary translation +and X^2 = I. These identities hold under the retained tensor implementation. +Define + +```text +lambda = (1+i)I/2 + (1-i)X/2, +lambda^-1 = (1-i)I/2 + (1+i)X/2, +S = lambda q. +``` + +Then lambda^2 = X, S^2 = I, and lambda^-1 S = q. All these operators commute +with the fresh stage products D. The normalization is applied to the complete +field, using its global translation X. Its scalar coefficients stay outside +tensor powers. In general S is not the tensor power of the one-column S. + +The translation has disjoint two-address orbits. On one orbit lambda has +matrix [[a,b],[b,a]], where a=(1+i)/2 and b=(1-i)/2. Four ordinary complex +scalar operations implement it in place: + +```text +x <- x - i*y +x <- a*x +y <- (1+i)*y +y <- y - i*x. +``` + +Conjugate each coefficient to implement the inverse. No owned field, paid +Gaussian job or productive input is added. The pair map is unitary; each +displayed operation has growth at most two in the maximum norm. There are +four operations per address pair. A loop over the existing translation +pairs has linear data work. The ordinary-work bill below includes these +operations and translations. + +A child supplies D U(q), where U(q)=I+q E01, on two arbitrary fields. +Conjugation by diag(lambda,1), followed by U(-1), gives +D U(S-1). A thin query has the same conversion and retains its paid H1 +charge. Thus the central-involution root below has an actual native +implementation. Its output S is converted back to q by lambda^-1. + +## 2. The six-field root + +Use the shortest-query normal form from +`research/five-call-projector-rigidity/PROOF.md`. For i=0,...,5 set u_i=e_i. +Set u_6=(-1,1,-1,1,-1,1), and (v_i)_j=sign(i-j). Let R_i=u_i v_i. +Each R_i is square-zero and has rank one. Direct exact multiplication gives + +```text +(I-2R_6) ... (I-2R_0) = -I_6. +``` + +`ROOT.json` specifies an invertible rational basis F, four stage projectors +P_i, and their native two-field bases C_i. Full sites are 0, 1, 5 and 6. +Sites 2, 3 and 4 are thin. In F coordinates the four projector masks are + +| Site | Output coordinates in the stage | Rank | Native leaves | Extra whole idles | +| --- | --- | ---: | ---: | --- | +| 0 | 0,1 | 2 | 7 | none | +| 1 | 0,1,5 | 3 | 2 | one H16 | +| 5 | 0,2,4 | 3 | 2 | one H16 | +| 6 | 0,2 | 2 | 7 | none | + +The exact checker verifies P_i^2=P_i, P_i R_i=R_i P_i=R_i and pairwise +commutation of the four P_i. It also verifies that P_i commutes with the +query prefix (I-2R_i)...(I-2R_0). These conditions permit each independent +stage factor to move past its own query prefix. The two central characters +then give the same diagonal stage product, with scalar factor +1 or -1. +The checker also multiplies every independent stage coefficient directly. + +At a full site, C_i takes R_i to E01 and P_i to diag(I_r,0). Apply the child +supplier to the first two coordinates. Apply D_i separately to each of the +remaining r-2 coordinates. These are exactly the charged whole idle jobs. +All basis changes are emitted as rational ADD, SCALE and SWAP operations. +At a thin site, the corresponding C_i converts one paid query to R_i. + +Apply F at entry and F^-1 at exit. Apply lambda^-1 to all six root outputs. +Their independent stage supports are + +```text +ABCD, AB, CD, empty, C, B. +``` + +For child sizes 7,2,2,7, the six Gaussian ranks are 145,73,73,1,17,17. +No root input is owned or initialized. The scalar basis maps are invertible. + +## 3. Binary children and full endpoint + +PR6348 supplies the unchanged four-field binary query extension. Each node +combines two query suppliers, one paid thin query and two whole idle jobs. +It returns another query supplier and two independent Gaussian outputs. +Its separate Laurent checker is replayed here under its source hash. + +The four child trees have 18 native leaves and 14 binary nodes. Their node +size counts are {2:8,3:2,4:2,7:2}. The root adds three thin queries. +The complete caller has 34 main fields per port, 18 distinct native stages, +17 thin queries, 14 paired whole idles and two individual whole idles. +Its 570 literal instructions include all basis maps and 20 normalizations. + +The full replay uses exact coefficients in Q(i)[Q,D_1,...,D_18]/(Q^4-1). +It checks all 1,156 input/output entries. Stage variables remain distinct. +It checks the complete Gaussian endpoint, not only the S=+1 and S=-1 cases. +Missing native calls, thin queries, paired idles, individual idles, +normalizations and central translations are rejected. + +Each native call receives 562 independent helper inputs. These are separate +from all main fields and from every other call's helpers. There are +18*562+34*104=13,652 productive fields. Calls execute in sequence. The 29 +owned labels, 32 native lifetimes and peak 13 fields remain as in PR6349. +Thin-query storage is reused between calls. Normalization adds no storage. + +The physical checker verifies all 7,488 native contacts, their absolute +phases, every output Gaussian and every paired or individual idle. The +fresh stage axes are orthonormal and fix the central port. The source word +receives its complete arbitrary-input, dense-transpose and native replay. + +## 4. Complete price and outer transfer + +The complete invoice has 66,988 paid jobs and 13,652 productive jobs. +Paid rank mass is 185,340; productive rank mass is 186,100. The surplus is +760. The maximum target rank is 145 and maximum paid rank is 56. The +emitted-event count agrees with a separate fixed-tree and root count. + +The strict raw crossing is in (0.00328468791927,0.00328468791928), between +adjacent points on the 10^-14 grid. `RESULT.json` records both rational +moment engines, completion, compiler and outer ledger. The claim is +0.00328467; the tested +saving is 0.003284675. The completion uses power 1024, cutoff 12, floor 13, +offset 1/7, reserve 10^-12 and decay 31/32. The logarithm power is 1100. +All local native, route and scalar costs remain charged. The new caller +uses a conservative 32 real scalar units per field per instruction, +including the normalization. Its complete ordinary bound is below 10^9. +The retained admitted BIT saving is .0034. All 54 strict and four functional +outer predicates must pass. + +The comparison is PR6353's published conditional .00315057. The present +source is PR6349; it does not consume PR6353's output-contracted word. +The source-relative gain is from the new caller, not new digits of an old +crossing. PR6353 and PR6350 retain their separate construction credit. + +The basis search checked 241,886,080 bounded bases modulo 65521. It found +695 support patterns. Floating searches selected the rank 2,3,3,2 pattern. +The exact rational checker then verified the chosen basis and every stage +coefficient. This finite search does not prove a global basis optimum. +The new child-size search selected 7,2,2,7. Section 5 gives an exact ceiling +for all binary children of this fixed root. + +## 5. A ceiling for every binary child size of this root + +This statement keeps the root and the PR6349 native source fixed. It permits +all positive integer child sizes and all binary tree shapes. Let H(r)=r^t, +t=1-kappa, and let L be the native paid-minus-helper moment per port. +Let C(n) be the minimum binary-node cost for n leaves. Then + +```text +C(1)=0, +C(n)=min_{1 <= a < n} (C(a)+C(n-a)+2H(8n)+1-2H(8n+1)). +``` + +For a pair with total n, the best root contribution is + +```text +G(n)=max_{1 <= b < n} + (H(8n+1)-n L-C(n-b)-C(b)+H(8b+1)-H(8b)). +``` + +For four positive children, with pair totals x and y, the complete margin +per port is H(8(x+y)+1)+G(x)+G(y)-2. The two pairs contain all root outputs, +three thin queries, both individual idles and every binary-node job. + +At kappa .00328469, `ceiling.py` uses rational outward intervals. It checks +all 4,851 binary splits below 100 leaves and all 4,656 root pair choices with +four through 99 leaves. Every margin upper bound is strictly negative. + +For larger totals f, concavity gives C(n) >= -(n-1) and +H(8b+1)-H(8b) <= H(9)-H(8). Jensen's inequality gives the upper bound + +```text +B(f)=H(8f+1)+2H(4f+1)-f(L-1)+2(H(9)-H(8))-6. +``` + +The checker proves B(100)<0 and B'(100)<0 with rational intervals. Since +t is strictly between zero and one, B' decreases. Thus B(f)<0 for every +real f>=100. No larger binary tree is omitted. + +The native deficit L has strictly positive derivative throughout +0<=kappa<=.0034. The checker proves this with an interval lower bound above +42. Each binary-node cost increases with kappa, while each positive H term +and each increment H(r+1)-H(r) decreases. Thus every root margin decreases +throughout the retained BIT admission range. Failure at .00328469 also +excludes every larger saving in that range. + +This fixed root cannot reach .00328469 with the retained native source. +The claim .00328467 is within .00000002 of that ceiling. This is a scoped +ceiling, not a bound for other roots, source words or query interfaces. + +## Scope and open next questions + +The inherited assumptions are native_all_columns, owned_erasure, compiler, +precision_tape and analytic_recovery. Finite operator and compiler checks +do not discharge their full quantified statements. The large uniform word +and rounded multiplier are not materialized. No global optimality or +practical speedup is claimed. The selected frontier stays unchanged. + +An independent reviewer should first check the global-field normalization, +the two charged rank-three projectors, and input independence. +Then replay the exact source and complete invoice. A later improvement can +change this root or combine it with a verified source, but must include +every changed productive debit, ordinary operation and compiler cost. diff --git a/research/mixed-projector-query-root/README.md b/research/mixed-projector-query-root/README.md new file mode 100644 index 0000000000..c0bd64269b --- /dev/null +++ b/research/mixed-projector-query-root/README.md @@ -0,0 +1,63 @@ +# Conditional kappa 0.00328467 from a mixed projector root + +This caller gives conditional **kappa 0.00328467**, an increase of +**0.00013410 (about 4.26 percent)** over PR6353's .00315057. It keeps the +PR6349 native source and combines four PR6348 binary query suppliers in a +new six-field root. The selected frontier stays unchanged. + +The root permits paid stage projectors of ranks two and three. An +ordinary translation-based normalization supplies its central involution +and restores Gaussian outputs. The literal caller includes every +normalization, basis change, native call, thin query and complementary idle. +It has 18 native calls, 34 main fields per port and 66,988 paid jobs. + +An exact check bounds all binary child sizes for this fixed root below +.00328469. The new claim is within .00000002 of that scoped ceiling. It is +.1485 percent above the earlier local .00327980 root. + +Start with [PROOF.md](PROOF.md), [ROOT.json](ROOT.json), the literal +[CONTROLLER.json](CONTROLLER.json) and [RESULT.json](RESULT.json). +[VALIDATION.md](VALIDATION.md) states which checks actually ran. + +```sh +python3.12 -B scripts/research_package.py --package research/mixed-projector-query-root +python3.12 -I -B research/mixed-projector-query-root/verify.py +python3.12 -I -O -B research/mixed-projector-query-root/verify.py +``` + +Expected marker: `PASS_MIXED_PROJECTOR_QUERY_ROOT_KAPPA_00328467`. +The registered verifier uses only the Python standard library. + +Five inherited framework assumptions remain. The uniform word and rounded +multiplier are not materialized. Author replay and hosted CI do not replace +independent scientific review or formal-kernel acceptance. No global +optimum or practical runtime improvement is claimed. + +The [final source composition](../mixed-root-contact-composition/README.md) +gives 0.00328621476572836015146308 after the PR6353, PR6372 and PR6375 source changes. This package retains +the separate root construction and its original source for review. The +[headroom proof](../mixed-projector-root-headroom/PROOF.md) now classifies +the full minimum-idle family. Historical validation receipts retain the +publication status at the time they were made. + +## Open next questions + +- Independently check the normalization on the complete field, the four + projectors, all arbitrary inputs and the complete paid bill. +- Test a different root or a verified improved source only with a new full + invoice, native binding, compiler and outer replay. + +[TASK.json](TASK.json) gives concrete first checks and remaining obligations. + +## Attribution and coordination + +New root, normalization, complete caller and verification: Ali Romman with +substantial OpenAI Codex assistance; no subagents. The query normal form, +PR6348 binary module and PR6349 source retain their separate credit. +Cinna Davis supplies the native query and thin-query interface. +DreamingOfClouds supplies PR6314's source compression with Claude Opus 5.5 +assistance. [NOTICE](NOTICE) retains the full native, helper, compiler, BIT +and outer lineage. Apache-2.0. + +[Canonical investigation](https://github.com/CrocSwap/integer-mult-bounds/discussions/5600#discussioncomment-19209322). +The source and owned-word searches in adjacent Discussions were excluded. diff --git a/research/mixed-projector-query-root/RESULT.json b/research/mixed-projector-query-root/RESULT.json new file mode 100644 index 0000000000..7ffa8fadc0 --- /dev/null +++ b/research/mixed-projector-query-root/RESULT.json @@ -0,0 +1,435 @@ +{ + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "binary_module": { + "coefficients": 16, + "identity": "L S A B Idle S^-1 C R = D_A D_B (U(q) direct-sum q direct-sum q^-1)", + "missing_idle_rejected": true, + "variables": [ + "q", + "D_A", + "D_B" + ] + }, + "caller": { + "coefficients": 1156, + "event_sha256": "be648c29aa09c0f068a3b5b5120d1eb1f782e49f4523b4c6d62843750517bdea", + "events": 570, + "inputs": 34, + "native_stages": 18 + }, + "columns": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 638401, + "columns": 799 + }, + "fixed_root_ceiling": { + "admitted_saving_cap": "17/5000", + "binary_split_checks": 4851, + "ceiling": "328469/100000000", + "finite_margin_upper": "-750506598129274945514234334134410155551008660593345983/163204645120053699859730525003399326818661241556064897335296", + "finite_pair_checks": 4656, + "first_tail_total": 100, + "native_derivative_lower": "86198265613857174984961926826035460452887338210852170396752075072748738729212441010936924815282480413581462223705108297/2048904322212512919038510085207467917864146442064203226733311257020777532117854951793541845254015613321944655495954432", + "scope": "All positive integer child sizes and all binary tree shapes for this fixed root and PR6349 source.", + "tail_derivative_upper": "-3877624858468274458330205673541784769862279749592609108719814384627637/65526869021507960560806630452021083966851011811312001361243013120000000", + "tail_margin_upper": "-151099573163525840514660484867817751572373987297076544356433/81602322560026849929865262501699663409330620778032448667648" + }, + "lifted_directions": [ + { + "basis": [ + 52 + ], + "departure_response": { + "496": "1", + "639": "-1", + "643": "-1/2" + }, + "frame": 595, + "input_direction": { + "496": "1", + "639": "-1", + "643": "-1/2" + }, + "primary": 496 + }, + { + "basis": [ + 82 + ], + "departure_response": { + "198": "1", + "648": "-1", + "649": "1" + }, + "frame": 597, + "input_direction": { + "648": "-1", + "649": "1" + }, + "primary": 649 + }, + { + "basis": [ + 51 + ], + "departure_response": { + "179": "1/2", + "663": "1", + "665": "-1" + }, + "frame": 105, + "input_direction": { + "663": "1", + "665": "-1" + }, + "primary": 663 + }, + { + "basis": [ + 30, + 42, + 384 + ], + "departure_response": { + "508": "1", + "631": "-1", + "635": "-1/2" + }, + "frame": 1093, + "input_direction": { + "508": "1", + "631": "-1", + "635": "-1/2" + }, + "primary": 508 + } + ], + "local": { + "endpoint_coefficients": 638401, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 14, + "6": 3, + "7": 9, + "8": 22, + "9": 381 + }, + "owned_fields": 29, + "owned_lifetimes": 32, + "paid": { + "1": 2217, + "2": 457, + "3": 497, + "4": 100, + "5": 161, + "6": 8, + "7": 9, + "8": 1 + }, + "paid_rank_mass": 5946, + "peak_owned_fields": 13, + "public_inputs": 770, + "real_scalar_allowance": 127088 + }, + "native": { + "distinct_maps": 2930, + "helper_normalizers": 1124, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 14, + "6": 3, + "7": 9, + "8": 22, + "9": 381 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "18631697cf96cfcd625fd0210939bc40f095657324730955d15719b9c7385513", + "wrong_phase_rejected": true + }, + "negative_controls": { + "changed_ceiling_root": "The ceiling uses the actual paired root masks", + "missing_carrier_move": "Scalar destination and coefficient", + "missing_first_carrier_subtraction": "All public and owned rows", + "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_output_basis": "All public and owned rows", + "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_second_carrier_subtraction": "All public and owned rows", + "old_input_chart": "Common scalar chart", + "wrong_649_injection": "All public and owned rows", + "wrong_663_injection": "All public and owned rows", + "wrong_intersection": "Nested chronological transport" + }, + "physical": { + "central_square_columns": 53248, + "central_translations": 16, + "full_calls": 18, + "main_targets": { + "1": 104, + "145": 104, + "17": 1872, + "25": 416, + "33": 416, + "57": 416, + "73": 208 + }, + "new_paid_jobs": 0, + "ordinary_normalizations": 20, + "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 + } + }, + "price": { + "compiler": { + "H": 70855400000000, + "N": "2^70855400000000", + "eta": { + "lower": "0.000000053554294001314085839719", + "upper": "0.000000053554294001314085839720" + }, + "gap": "1/1400000000", + "integer_test_exponent": 50611, + "logarithm_power": 1100, + "theta": "63/64", + "uniform_saving": "287409/87500000", + "word_materialized": false + }, + "derivative_upper": "-88879058930240593538878666108991983162882356258539092284847813/392318858461667547739736838950479151006397215279002157056", + "full_forward_calls": 18, + "gain": "1341/10000000", + "kappa": "328467/100000000", + "kappa_decimal": "0.00328467", + "margin_at_previous": { + "lower": "30.835026124181562841635714475041", + "upper": "30.835026124181562841635714475042" + }, + "negative_controls": { + "old_BIT": "An outer inequality fails at BIT saving0.0027.", + "old_completion": "Cutoff16 and floor17 give a ratio above one." + }, + "nonrecursive": { + "local_routes": 5326000, + "local_scalar": 127088, + "paid_rank_mass": 185340, + "peak_owned_fields": 13, + "raw_budget": 1000000000, + "raw_scalar_upper": 248152864, + "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": "6437958795401459/1960000000000000000", + "fused_gaussian": "6437958786204377/1960000000000000000", + "global_coordinate_router": "2299271/700000000", + "group_bit_router": "3218980093102187/980000000000000000", + "group_scans": "699999999/700000000", + "main_transform": "6437957395401459/1960000000000000000", + "microbox_face_corrections": "26950000001/350000000", + "polynomial_products": "1399999999/1400000000", + "sparse_union_movement": "802687958795401459/1960000000000000000" + }, + "parameters": { + "a": "2299271/700000000", + "b": "4598543/1400000000", + "beta": "1399999997/1400000000", + "bit_saving": "17/5000", + "cap_xi": "1782687957395401459/1960000000000000000", + "complex_uniform_saving": "287409/87500000", + "d": "1/1400000000", + "epsilon": "1399999999/1400000000", + "kappa": "328467/100000000", + "lambda_": "398686131/400000000", + "lambda_prime": "1395401459/1400000000", + "layout": "1/1400000000", + "q": "4598541/1400000000", + "r0": "1/14000000000", + "stop": "1/1400000000", + "tested_saving": "131387/40000000" + }, + "strict_checks": { + "actual_bit_above_effective": "80729/700000000", + "actual_logarithmic_gamma_guard": "1/1400000000", + "actual_logarithmic_group_guard": "177312044704598541/980000000000000000", + "alpha_logarithm_absorption": "1/14000000000", + "boundary_algebraic_matrix_above_kappa": "5595401459/1960000000000000000", + "cap_above_band": "802687957395401459/1960000000000000000", + "cap_below_cell": "177312041204598541/1960000000000000000", + "cap_below_phase_cell_power": "2137312042604598541/1960000000000000000", + "complex_above_effective": "1/1400000000", + "complex_below_one_over_32": "39151457/1400000000", + "complex_endpoint": "1/700000000", + "epsilon_below_one": "1/1400000000", + "epsilon_positive": "1399999999/1400000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "5586204377/1960000000000000000", + "gaussian_above_main": "695401459/980000000000000000", + "global_coordinate_router_above_kappa": "1/350000000", + "global_gamma_power_slack": "9/14000000000", + "group_below_dimension": "1/700000000", + "group_bit_router_above_kappa": "3493102187/980000000000000000", + "group_gauge_power_slack": "177312044634598541/980000000000000000", + "group_key_fits_record": "1/700000000", + "group_positive": "1399999997/1400000000", + "group_scans_above_kappa": "69770073/70000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "776849790400418148631/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": "2795401457/1960000000000000000", + "leaf_saving_above_effective": "1395401457/1960000000000000000", + "main_transform_above_kappa": "4195401459/1960000000000000000", + "membership_arithmetic_fits_record": "1/1400000000", + "microbox_face_corrections_above_kappa": "53897700733/700000000", + "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": "1395401461/1400000000", + "positive_layout_slack": "1/1400000000", + "q_below_effective": "1/1400000000", + "q_below_internal": "1/1400000000", + "q_below_leaf": "2795401457/1960000000000000000", + "q_positive": "4598541/1400000000", + "short_record_fallback": "1395401457/1400000000", + "source_axis_superpolynomial": "1/1400000000", + "sparse_union_movement_above_kappa": "796250005595401459/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": 41674, + "16": 1872, + "2": 8226, + "24": 416, + "3": 8946, + "32": 416, + "4": 1800, + "5": 2898, + "56": 416, + "6": 144, + "7": 162, + "8": 18 + }, + "paid_calls": 66988, + "previous_pr6353": "315057/100000000", + "productive_fields": 13652, + "rank_mass_surplus": 760, + "raw_headroom": [ + "1791927/100000000000000", + "223991/12500000000000" + ], + "raw_root_interval": [ + "328468791927/100000000000000", + "41058598991/12500000000000" + ], + "relative_gain_percent": "447000/105019", + "strictification": { + "alpha": { + "lower": "0.999999983883647043526813312973", + "upper": "0.999999983883647043526813312974" + }, + "cutoff": 12, + "delta": { + "lower": "0.955396196009635532136372107420", + "upper": "0.955396196009635532136372107421" + }, + "floor": 13, + "gamma": { + "lower": "0.924233987161773495066939289639", + "upper": "0.924233987161773495066939289640" + }, + "normalized_paid_upper": "1048576000976562501/1048576001073741824", + "power": 1024, + "reserve": "1/1000000000000", + "tail_block": 128, + "tail_decay": "31/32", + "tail_offset": "1/7", + "tested": "131387/40000000" + }, + "targets": { + "1": 356, + "145": 104, + "17": 1872, + "2": 144, + "25": 416, + "3": 72, + "33": 416, + "4": 1926, + "5": 252, + "57": 416, + "6": 54, + "7": 162, + "73": 208, + "8": 396, + "9": 6858 + }, + "thin_queries": 17, + "whole_idle_jobs": 3120 + }, + "root": { + "actual_tensor_gaussian_columns": 14, + "fields": 6, + "full_sites": 4, + "gaussian_characters": 4, + "normalization_growth_per_operation_upper": 2, + "ordinary_normalization_operations_per_pair": 4, + "owned_normalization_fields": 0, + "polynomial_coefficients": 1152, + "stage_ranks": [ + 2, + 3, + 3, + 2 + ], + "tensor_rule": "Normalize the complete field with its global Q squared translation; scalar coefficients stay outside tensor powers.", + "thin_sites": 3, + "wrong_tensor_normalization_rejected": true + }, + "selected_frontier_changed": false, + "source_inputs": 17, + "status": "PASS_MIXED_PROJECTOR_QUERY_ROOT_KAPPA_00328467" +} diff --git a/research/mixed-projector-query-root/ROOT.json b/research/mixed-projector-query-root/ROOT.json new file mode 100644 index 0000000000..b59f1ea89a --- /dev/null +++ b/research/mixed-projector-query-root/ROOT.json @@ -0,0 +1,1319 @@ +{ + "status": "PASS_EXACT_MIXED_ROOT_AND_NORMALIZATION", + "fields": 6, + "full_sites": [ + 0, + 1, + 5, + 6 + ], + "thin_sites": [ + 2, + 3, + 4 + ], + "input_basis": [ + [ + "2", + "-1", + "1", + "0", + "0", + "0" + ], + [ + "-2", + "2", + "-1", + "0", + "0", + "1" + ], + [ + "1", + "-1", + "0", + "1", + "1", + "-1" + ], + [ + "-2", + "2", + "-1", + "0", + "0", + "2" + ], + [ + "2", + "-2", + "1", + "-1", + "0", + "-2" + ], + [ + "0", + "0", + "1", + "0", + "-1", + "0" + ] + ], + "output_basis": [ + [ + "1", + "1", + "-1", + "-2", + "-1", + "-1" + ], + [ + "1", + "2", + "0", + "-1", + "0", + "0" + ], + [ + "0", + "0", + "2", + "3", + "2", + "2" + ], + [ + "0", + "0", + "0", + "-1", + "-1", + "0" + ], + [ + "0", + "0", + "2", + "3", + "2", + "1" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "0" + ] + ], + "sites": [ + { + "site": 0, + "full": true, + "stage_rank": 2, + "support": [ + 0, + 1 + ], + "basis": [ + [ + "1", + "0", + "2", + "3", + "2", + "2" + ], + [ + "0", + "-2", + "-1", + "-1", + "-1", + "-1" + ], + [ + "0", + "1", + "1", + "0", + "0", + "0" + ], + [ + "0", + "-2", + "0", + "1", + "0", + "0" + ], + [ + "0", + "2", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + "inverse": [ + [ + "1", + "0", + "-2", + "-3", + "-2", + "-2" + ], + [ + "0", + "-1", + "-1", + "-1", + "-1", + "-1" + ], + [ + "0", + "1", + "2", + "1", + "1", + "1" + ], + [ + "0", + "-2", + "-2", + "-1", + "-2", + "-2" + ], + [ + "0", + "2", + "2", + "2", + "3", + "2" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + "projector": [ + [ + "1", + "0", + "-2", + "-3", + "-2", + "-2" + ], + [ + "0", + "2", + "2", + "2", + "2", + "2" + ], + [ + "0", + "-1", + "-1", + "-1", + "-1", + "-1" + ], + [ + "0", + "2", + "2", + "2", + "2", + "2" + ], + [ + "0", + "-2", + "-2", + "-2", + "-2", + "-2" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "site": 1, + "full": true, + "stage_rank": 3, + "support": [ + 0, + 1, + 5 + ], + "basis": [ + [ + "0", + "1", + "-1", + "-1", + "0", + "0" + ], + [ + "1", + "0", + "2", + "1", + "0", + "0" + ], + [ + "0", + "0", + "-1", + "-2", + "-1", + "-1" + ], + [ + "0", + "0", + "2", + "1", + "0", + "0" + ], + [ + "0", + "0", + "-2", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + "inverse": [ + [ + "0", + "1", + "0", + "-1", + "0", + "0" + ], + [ + "1", + "0", + "-1", + "-1", + "-1", + "-1" + ], + [ + "0", + "0", + "1", + "2", + "1", + "1" + ], + [ + "0", + "0", + "-2", + "-3", + "-2", + "-2" + ], + [ + "0", + "0", + "2", + "4", + "3", + "2" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + "projector": [ + [ + "1", + "0", + "-2", + "-3", + "-2", + "-2" + ], + [ + "0", + "1", + "2", + "3", + "2", + "2" + ], + [ + "0", + "0", + "-1", + "-2", + "-1", + "-1" + ], + [ + "0", + "0", + "2", + "4", + "2", + "2" + ], + [ + "0", + "0", + "-2", + "-4", + "-2", + "-2" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "site": 2, + "full": false, + "stage_rank": 2, + "support": [], + "basis": [ + [ + "0", + "1", + "-1", + "1", + "1", + "1" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + "inverse": [ + [ + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "1", + "1", + "0", + "-1", + "-1", + "-1" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + "projector": [ + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "site": 3, + "full": false, + "stage_rank": 2, + "support": [], + "basis": [ + [ + "0", + "1", + "-1", + "-1", + "1", + "1" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + "inverse": [ + [ + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "1", + "1", + "1", + "0", + "-1", + "-1" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + "projector": [ + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "site": 4, + "full": false, + "stage_rank": 2, + "support": [], + "basis": [ + [ + "0", + "1", + "-1", + "-1", + "-1", + "1" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + "inverse": [ + [ + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "1", + "1", + "1", + "1", + "0", + "-1" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + "projector": [ + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "site": 5, + "full": true, + "stage_rank": 3, + "support": [ + 0, + 2, + 4 + ], + "basis": [ + [ + "0", + "2", + "-2", + "-1", + "1/2", + "0" + ], + [ + "0", + "-2", + "2", + "1", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "-3/2", + "-1" + ], + [ + "0", + "-2", + "2", + "0", + "1", + "0" + ], + [ + "0", + "2", + "-2", + "0", + "0", + "1" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0" + ] + ], + "inverse": [ + [ + "0", + "0", + "0", + "0", + "0", + "1" + ], + [ + "1", + "1", + "1", + "1", + "1", + "0" + ], + [ + "0", + "0", + "1", + "3/2", + "1", + "0" + ], + [ + "2", + "3", + "0", + "-1", + "0", + "0" + ], + [ + "2", + "2", + "0", + "0", + "0", + "0" + ], + [ + "-2", + "-2", + "0", + "1", + "1", + "0" + ] + ], + "projector": [ + [ + "2", + "2", + "0", + "-1", + "0", + "0" + ], + [ + "-2", + "-2", + "0", + "1", + "0", + "0" + ], + [ + "1", + "1", + "1", + "1", + "1", + "0" + ], + [ + "-2", + "-2", + "0", + "1", + "0", + "0" + ], + [ + "2", + "2", + "0", + "-1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1" + ] + ] + }, + { + "site": 6, + "full": true, + "stage_rank": 2, + "support": [ + 0, + 2 + ], + "basis": [ + [ + "-1", + "2", + "-1", + "1/2", + "0", + "0" + ], + [ + "1", + "-2", + "1", + "0", + "0", + "0" + ], + [ + "-1", + "1", + "0", + "-3/2", + "-1", + "-1" + ], + [ + "1", + "-2", + "0", + "1", + "0", + "0" + ], + [ + "-1", + "2", + "0", + "0", + "1", + "0" + ], + [ + "1", + "0", + "0", + "0", + "0", + "1" + ] + ], + "inverse": [ + [ + "0", + "0", + "2", + "3", + "2", + "2" + ], + [ + "1", + "1", + "1", + "1", + "1", + "1" + ], + [ + "2", + "3", + "0", + "-1", + "0", + "0" + ], + [ + "2", + "2", + "0", + "0", + "0", + "0" + ], + [ + "-2", + "-2", + "0", + "1", + "1", + "0" + ], + [ + "0", + "0", + "-2", + "-3", + "-2", + "-1" + ] + ], + "projector": [ + [ + "2", + "2", + "0", + "-1", + "0", + "0" + ], + [ + "-2", + "-2", + "0", + "1", + "0", + "0" + ], + [ + "1", + "1", + "-1", + "-2", + "-1", + "-1" + ], + [ + "-2", + "-2", + "0", + "1", + "0", + "0" + ], + [ + "2", + "2", + "0", + "-1", + "0", + "0" + ], + [ + "0", + "0", + "2", + "3", + "2", + "2" + ] + ] + } + ], + "masks": [ + [ + 1, + 1, + 1, + 1 + ], + [ + 1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 1, + 0, + 0 + ] + ], + "independent_stage_coefficients": 1152, + "normalization": "lambda=(1+i)/2+(1-i)*q^2/2; q^4=1", + "scope": "Exact rational root and Gaussian normalization; full caller costs not certified", + "schema": "mixed-projector-query-root/2", + "children": [ + [ + [ + 1, + [ + 1, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 1, + 1 + ] + ] + ], + [ + 1, + 1 + ], + [ + 1, + 1 + ], + [ + [ + 1, + [ + 1, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 1, + 1 + ] + ] + ] + ], + "child_sizes": [ + 7, + 2, + 2, + 7 + ] +} diff --git a/research/mixed-projector-query-root/SEARCH.md b/research/mixed-projector-query-root/SEARCH.md new file mode 100644 index 0000000000..1363fb04c5 --- /dev/null +++ b/research/mixed-projector-query-root/SEARCH.md @@ -0,0 +1,73 @@ +# Search scope and fixed-root limit + +The new bound uses the explicit rational root in ROOT.json. Its acceptance +does not depend on a heuristic search or on a modular zero test. + +## Basis catalogue + +The search kept rank-two projectors at query sites zero and six. Their +intersection has one dimension. Write u for (-1,1,-1,1,-1,1). Let K be the +four-dimensional space of vectors whose first coordinate and coordinate +sum are zero. For z in K and three independent columns d1,d2,d3 in K, use + +```text +F = [e0-u-z, u+z, e0-z, d1, d2, d3]. +``` + +In the four coordinates of K, z ranged over the nonzero vectors in +{-1,0,1}^4. Each d column ranged over primitive integer vectors in +{-2,-1,0,1,2}^4, with first nonzero coordinate positive. The search used +each unordered triple of d columns. Singular F matrices were excluded. + +The enumeration checked 241,886,080 invertible bases modulo 65521. It found +695 distinct seven-site support patterns. Floating child-size searches +selected a pattern with full-site ranks 2,3,3,2. The rational reconstruction +then checked its exact projectors, native query planes and all independent +stage coefficients. The selected F has determinant one. Its inverse and +native basis data have dyadic coefficients. + +This is a bounded catalogue. It does not cover all rational bases, larger +roots, noncommuting stage families or other query words. Floating searches +over the catalogue do not prove that each pattern's price is optimal. +An additional integer-program screen checked 88 price-equivalence classes +from this catalogue, with native totals below 100. It found no better +candidate. The floating solver reported 47 completed optima and 41 time +limits with unresolved bounds. This is not an exact exclusion certificate. + +## Child sizes + +The two-pair score separates the four child sizes into two sums. A floating +dynamic program tested all totals through 200 and all binary child splits. +It selected 7,2,2,7. The complete exact caller and invoice use those trees. + +The separate rational checker ceiling.py covers all positive integer child +sizes and all binary tree shapes for this fixed root and native source. +It checks every total below 100 and proves a decreasing negative bound for +all larger totals. Its ceiling is .00328469. The claim is .00328467. +PROOF.md states the full argument and its restrictions. + +## Other local searches + +- Structured roots through 20 fields did not improve the retained price. + A later eight-field family kept the four stage ranks 2,3,3,2. Its 582,240 + bounded bases gave 351 support patterns. The price search recovered the + six-field bound and did not improve it. A separate pair-decomposition + search then tested all child totals through 200 for each of nine possible + added-stage support types, including thin anchor choices. Every best + floating margin stayed negative at .00328469. This is a bounded price + screen, not an exact exclusion theorem. +- Braid moves on longer query words did not give a favorable complete bill + in the tested finite domains. +- Two- and four-copy coupled bases did not improve the scalar construction + in 14,000 proposed moves per coupling size. +- An internal-query extension of the earlier root has two exact shared + idle subspaces. Its complete proposed price still loses to the binary + supplier. The screen tested all child tuples through 48 per child. + +These are search outcomes, not general impossibility results. The local +scripts, output files and logs remain in work/new-route-20261101. They are +outside the registered mathematical replay. The complete positive word, +source pins, exact bound and fixed-root ceiling are in this package. + +The selected frontier is unchanged. The donor's local publication hold +remains in effect. No result from another investigation is claimed here. diff --git a/research/mixed-projector-query-root/SOURCES.json b/research/mixed-projector-query-root/SOURCES.json new file mode 100644 index 0000000000..41c7fb59bf --- /dev/null +++ b/research/mixed-projector-query-root/SOURCES.json @@ -0,0 +1,132 @@ +{ + "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" + }, + { + "path": "research/balanced-query-tree/CONTROLLER.json", + "usage": "input", + "git_blob": "1f2e375b24aba5fb25580dfea7fab7a2049f3eb8", + "sha256": "6fd67eaabe659956d6694471d3fd7d2824c0a4a79cf3b8f22922f7189b11b91f" + }, + { + "path": "research/balanced-query-tree/RESULT.json", + "usage": "input", + "git_blob": "61ab6b26ff40168fb0982167ac67ef4607f27717", + "sha256": "f64a30b23a92e12e5e23c3d4400e139f20cf75bb2743d15c85b89ca1839a9408" + }, + { + "path": "research/balanced-query-tree/controller.py", + "usage": "input", + "git_blob": "3b4bf82eba05d57ef4bb1fd934e8ca65780425c1", + "sha256": "8067ade84815b54d539cbaef9885db9fa4d7a23fdde2e683451d317038a8477c" + }, + { + "path": "research/balanced-query-tree/module_check.py", + "usage": "input", + "git_blob": "f394d40ea2e0777f77910cc5a4b1d151c1228cbc", + "sha256": "a30e70fe1313f125b276ec97e05c779ff80b6d1aa9f6ba918a61bfb9bb5a2eda" + }, + { + "path": "research/balanced-query-tree/physical.py", + "usage": "input", + "git_blob": "84cf2a35241ab1bbc845a29f5048481aa5c93244", + "sha256": "3288421e7c3ca7116c96996984983ff44e2b601e38f808c4b46e518fbda9851b" + }, + { + "path": "research/balanced-query-tree/pricing.py", + "usage": "input", + "git_blob": "970fdcad6eca99087af2c901939b3813f3eb1f5d", + "sha256": "2e9a3d6aef8933ff7be3cc9dac22cd72bff2bb9985c2c53bb0affa5dfc2175b1" + }, + { + "path": "research/p104-frontier-compression-2/WORD.json.gz", + "usage": "input", + "git_blob": "cb3aed1d5604eb290f18759b37becaad428ac27a", + "sha256": "889f0f5d193d993dabee1e20dcfbcf63f9d88cfe5bd6973d564276c744d1e190" + }, + { + "path": "research/p104-native-input-lifting/RESULT.json", + "usage": "input", + "git_blob": "467f941331b78519fc7c7d5fc5e8ffbe7d7d7193", + "sha256": "b55049edcaaf6a9d57201a95df3e2ac8e06bc882eaf8f99a5bff16448bc58b8d" + }, + { + "path": "research/p104-native-input-lifting/SOURCES.json", + "usage": "input", + "git_blob": "bc7876a86e355ea59619916aeb60c422d9cb16b7", + "sha256": "8da6d980d4d62482c7184b14134eb7485fc9b4807b72fc25d462391e9f7739fa" + }, + { + "path": "research/p104-native-input-lifting/WORD.json.gz", + "usage": "input", + "git_blob": "f21f7ac451c3f2e1ae8d5ca1dcad839a0b0d844f", + "sha256": "1415a62059ed62d0b4657db91f7ec01b23c117f5f2744746d93c880bd777be92" + }, + { + "path": "research/p104-native-input-lifting/construct.py", + "usage": "input", + "git_blob": "1a8a1e9881610c3bdb6af78c1c21d2b2f9a85147", + "sha256": "a672603103aaeab3b705a765ff6af08ef2819dcac0f9a2bd6faa8a7e5443135d" + }, + { + "path": "research/p104-native-input-lifting/support.py", + "usage": "input", + "git_blob": "b528d2a451e0d1e398938e7a0ccb8ee5a87dcabe", + "sha256": "9c83cba72a6b52c3815c03898e96619364c5ef66b8d30b96fc58a99fcba3be50" + }, + { + "path": "research/p104-native-input-lifting/verify.py", + "usage": "input", + "git_blob": "70b3beae8f2279e67d39e308886083fe38eb2d7f", + "sha256": "1d3a5cc1a0a3ccc68ec16e02611a8a51bc29550b0875ce8e6045d5da37af65a7" + }, + { + "path": "research/p104-retained-operand-descent/SOURCES.json", + "usage": "input", + "git_blob": "0c574b6026a7239aac7365c433d3760928748edb", + "sha256": "7c7b6fac64005eb8932283a902069d672d98c52bda2b63cc7eaa4a2cac13ce8f" + }, + { + "path": "research/p104-retained-operand-descent/inputs/pr5827-source.tar", + "usage": "input", + "git_blob": "1e10936044959f81a4c5fcd5bdb7b9e4c060ec8e", + "sha256": "7af5908a4d83e83e28f59523fd7494841f669b7295311cfdbc3027fa65c5826d" + }, + { + "path": "research/p104-retained-operand-descent/pricing.py", + "usage": "input", + "git_blob": "cd8220ca7a393f03341f08a93b9d1287f0bb3689", + "sha256": "bba1611b05b6cc35279aa1667dcc62ce0e7f27f0ba21f20eb68244fa772e0ae7" + }, + { + "path": "research/p104-retained-operand-descent/sources.py", + "usage": "input", + "git_blob": "bef6542243a082755a881dff42097434e6370609", + "sha256": "a62fefda1709614157ba440d38c164c366a8b3322ab8f866b6b4bd47b9d83dbc" + }, + { + "path": "research/five-call-projector-rigidity/PROOF.md", + "usage": "provenance", + "git_blob": "04db617a97bf941fe277e834d2b2e18d6b735a22", + "sha256": "f917d2a88433e2c8a3ba48f76453a77af4cfed9cabff32ea8b60ce5abbab869c" + }, + { + "path": "research/five-call-projector-rigidity/README.md", + "usage": "provenance", + "git_blob": "e1784eb4cd40e4c6b0bdc2d916ce2fe364496bba", + "sha256": "807974f124ac0e1efc17af00dabff456f0b33c8186ae7246b4c96a8aca540a9b" + } + ] +} diff --git a/research/mixed-projector-query-root/TASK.json b/research/mixed-projector-query-root/TASK.json new file mode 100644 index 0000000000..40fa090d04 --- /dev/null +++ b/research/mixed-projector-query-root/TASK.json @@ -0,0 +1,91 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 8, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "joint-query-controller", + "question": "Can a changed query demand or caller remove real work while satisfying native chronology and restoration?", + "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" + ], + "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": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "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": "Choose an exact caller and a new demand/interface hypothesis. Read the scoped #5617/#5631/#5649/#5747 and #5720/#5745 objections before rebuilding an excluded schedule. Compare the complete matched source/consumer protocols including all retained helper outputs. For an active-mode injection, first check #5745: its canonical delivery claim repays the eight removed centre jobs. Audit that exact claim or change its channel/feedback hypothesis; do not repeat the same free-injection search. Stop if the full favorable budget fails or the required restored output is unobservable.", + "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": [ + "query demand", + "active mode", + "5720", + "5745", + "5747", + "caller" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "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": "refined", + "scope_change_reason": "Use a paid rank 2,3,3,2 root with binary children 7,2,2,7 and a whole-field central-involution normalization. Prove a fixed-root ceiling over all binary child sizes. The native source word remains fixed.", + "actual_scope": "Complete source-bound caller at conditional kappa 0.00328467, including all main fields, independent helpers, native phases, idle jobs, ordinary normalization, compiler and outer costs.", + "bottleneck_link": "Complex supplier; changes the full signed target and paid moment while retaining admitted BIT .0034.", + "outcome": "completed", + "evidence": "PROOF.md, ROOT.json, CONTROLLER.json, RESULT.json, ceiling.py, SEARCH.md and VALIDATION.md.", + "coordination": "https://github.com/CrocSwap/integer-mult-bounds/discussions/5600#discussioncomment-19209322", + "stop_rule": "Require exact arbitrary-input and native identities, global normalization, a complete invoice, both rational engines, compiler and outer checks before a kappa claim.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance; no subagents. All checks are author checks.", + "budget_minutes": null, + "open_questions": [ + { + "question": "Does independent review confirm the complete global-field normalization and mixed root?", + "why_it_matters": "The new mechanism uses a non-tensor normalization outside the native tensor word.", + "first_step": "Check PROOF.md section 1, module_check.py and the exact Q(i)[Q,D]/(Q^4-1) full caller replay.", + "blocked_by": "Independent review has not occurred." + }, + { + "question": "Can a verified improved source or changed root improve the complete price?", + "why_it_matters": "This construction is not a global optimum.", + "first_step": "Bind an exact source and all changed target debits; compare the complete invoice before native and compiler replay.", + "blocked_by": "Exact arbitrary-input and native source checks for any changed source." + } + ] +} diff --git a/research/mixed-projector-query-root/VALIDATION.md b/research/mixed-projector-query-root/VALIDATION.md new file mode 100644 index 0000000000..ed82c4208c --- /dev/null +++ b/research/mixed-projector-query-root/VALIDATION.md @@ -0,0 +1,102 @@ +# Validation record + +## Current local .00328467 revision + +The rank 2,3,3,2 root has passed its complete author build. The result covers +all 570 caller events, 1,156 caller coefficients, 799 source input columns, +the separate 638,401-coefficient transpose, native absolute phases and all +7,488 physical contacts. Both rational price engines, the completion, +compiler, 54 strict outer predicates and four functional predicates pass. +The complete ordinary-work upper bound is 248,152,864, below 10^9. + +The exact raw crossing is strictly in +(.00328468791927,.00328468791928). The claimed saving is .00328467. +The complete invoice has 66,988 paid jobs, 13,652 productive fields and rank +surplus 760. No new owned field is added. Every emitted rational scalar is +dyadic and has magnitude at most five. + +The all-size fixed-root ceiling uses a separate rational dynamic program. +It checks 4,851 binary splits and 4,656 pair totals below 100 leaves. A +negative decreasing bound covers all larger totals. A separate derivative +bound above 42 proves monotonicity throughout the retained BIT range. +Changing a root mask is rejected before the ceiling calculation. + +The complete registered normal and optimized replays passed, including the +saving-range monotonicity check and wrong-root ceiling control. The local +scientific commit is 52e87e4971a85a8f098fadb967dc75bee9f76c65. All 35 package +and declared-input files passed the committed-byte and owner-execute checks. +The official export passed integrity and coverage checks for all 17 inputs. + +The export SHA256 is +95f881c6250350dc19e3571a5f67a452237e100d4e561c73ac79361af933674b. +Its optimized verifier passed with empty PATH in a Git-free, read-only tree. +All 36 exported file hashes and all path modes stayed unchanged. An actual +source-word corruption failed its SHA256 gate. Swapping root input-basis +rows and regenerating the matching caller failed the inverse-basis check. +Both controls restored and rechecked every original byte and mode. + +The first extraction command requested gzip for the exporter's plain tar +file. Extraction stopped before a verifier ran. The archive was renamed +with its actual .tar format and extracted with automatic format detection. +The subsequent sealed replay and corruption controls passed. This setup +failure did not change the exported bytes or scientific claim. + +Discovery also replayed all 695 retained modular support patterns with a +separate NumPy implementation. This checks the retained representatives, +not a second complete 241,886,080-basis enumeration or a global optimum. + +Canonical main was refreshed and remains +7c49fe32c55de02c2c873655c804b16e4c3fef0a. Live PR and adjacent Discussion +checks found separate PR6353 audits and no new overlapping root claim. +The selected record SHA256 is still +9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa. + +The five framework assumptions remain. The uniform word and rounded +multiplier are not materialized. Hosted CI, independent scientific review +and full source-history ancestry are not claimed. The local publication +hold remains in effect; no push or PR has occurred. + +# Earlier local .00327980 checkpoint + +This file records author checks. Independent scientific review and hosted CI +are separate checks. Do not infer their completion from a local pass. + +The exact root and ordinary normalization, all four Gaussian characters, +the 543-event complete caller and its six deletion controls passed locally. +The final normal author build passed the complete unchanged source, native +phases, 7,488 physical contacts, both rational price engines, compiler and +all 58 outer predicates at kappa 0.00327980. The actual one-, two- and +three-column Gaussian checks also passed. A two-column counterexample +rejects tensoring the one-column normalization in place of the required +global normalization. + +Environment: macOS 26.6.1 arm64, CPython 3.12.13. Published replay uses the +standard library. Discovery used NumPy, SciPy and SymPy; those searches are +not proof dependencies and are not part of the registered replay. + +The registered normal and optimized commands both passed, including the +exact retained receipt and all rejection controls. Metadata and source-pin +checks passed. The selected record retains SHA256 +`9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa`. + +The user instructed that this result stay local until they authorize a PR. +No branch push, PR or hosted CI is planned under that instruction. + +Local science commit: `1d49e6c75e608dd29c4fb2794463c8dc36df037f`. +The committed-byte check passed for all 33 package and declared-input files, +including owner-execute bits. The official export and all 17 declared-input +coverage checks passed. Export SHA256: +`f7d2893c8d93e8e55484383169ed798c4562b833fb4c5e87e7b59576e5a3101c`. + +The optimized verifier passed from that Git-free export with empty PATH and +all files and directories read-only. All 34 file hashes and modes were +unchanged after replay. Corrupting the source word was rejected at its SHA256 +guard. Changing the root basis and regenerating the matching literal caller +was rejected at the exact inverse-basis check. All original export bytes and +modes were restored and compared with the initial snapshot. + +The source-history preflight stopped with `source-history check requires +full Git history`. No missing ancestry was fetched. All declared source pins +use the canonical base, which is an ancestor of the local science commit. +This limitation does not affect the successful sealed export replay. +Independent scientific review remains open. diff --git a/research/mixed-projector-query-root/VERIFY.json b/research/mixed-projector-query-root/VERIFY.json new file mode 100644 index 0000000000..955f1be6cd --- /dev/null +++ b/research/mixed-projector-query-root/VERIFY.json @@ -0,0 +1,48 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/balanced-query-tree/CONTROLLER.json", + "research/balanced-query-tree/RESULT.json", + "research/balanced-query-tree/controller.py", + "research/balanced-query-tree/module_check.py", + "research/balanced-query-tree/physical.py", + "research/balanced-query-tree/pricing.py", + "research/p104-frontier-compression-2/WORD.json.gz", + "research/p104-native-input-lifting/RESULT.json", + "research/p104-native-input-lifting/SOURCES.json", + "research/p104-native-input-lifting/WORD.json.gz", + "research/p104-native-input-lifting/construct.py", + "research/p104-native-input-lifting/support.py", + "research/p104-native-input-lifting/verify.py", + "research/p104-retained-operand-descent/SOURCES.json", + "research/p104-retained-operand-descent/inputs/pr5827-source.tar", + "research/p104-retained-operand-descent/pricing.py", + "research/p104-retained-operand-descent/sources.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 590, + "checks": "Authenticate the unchanged native source; check the exact root, global normalization, all native input columns, physical caller, complete invoice, both interval engines, compiler, outer ledger and fixed-root ceiling for all binary child sizes." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 590, + "checks": "Repeat the complete source-bound scientific receipt and semantic rejection controls with assertions disabled." + } + ] +} diff --git a/research/mixed-projector-query-root/algebra.py b/research/mixed-projector-query-root/algebra.py new file mode 100644 index 0000000000..a06d6f6416 --- /dev/null +++ b/research/mixed-projector-query-root/algebra.py @@ -0,0 +1,74 @@ +"""Exact rational matrices and coefficients in Q(i). + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from fractions import Fraction as Q + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def matrix(rows): + return [[Q(x) for x in row] for row in rows] + + +def eye(n): + return matrix([[int(i == j) for j in range(n)] for i in range(n)]) + + +def multiply(a, b): + return [[sum(x*y for x, y in zip(row, column)) for column in zip(*b)] for row in a] + + +def add(a, b, scale=1): + return [[x+scale*y for x, y in zip(row, other)] for row, other in zip(a, b)] + + +def inverse(a): + n = len(a) + rows = [row[:] + identity for row, identity in zip(a, eye(n))] + for j in range(n): + k = next((k for k in range(j, n) if rows[k][j]), None) + need(k is not None, 'Nonsingular rational matrix') + rows[j], rows[k] = rows[k], rows[j] + v = rows[j][j] + rows[j] = [x/v for x in rows[j]] + for k in range(n): + if k != j: + v = rows[k][j] + rows[k] = [x-v*y for x, y in zip(rows[k], rows[j])] + return [row[n:] for row in rows] + + +def coefficient(x): + return (Q(x), Q(0)) + + +def zadd(a, b): + return a[0]+b[0], a[1]+b[1] + + +def zmul(a, b): + return a[0]*b[0]-a[1]*b[1], a[0]*b[1]+a[1]*b[0] + + +def accumulate(dst, src, c=(Q(1), Q(0))): + for key, value in src.items(): + value = zadd(dst.get(key, (Q(0), Q(0))), zmul(c, value)) + if value != (0, 0): + dst[key] = value + else: + dst.pop(key, None) + + +def shifted(row, term): + result = [] + for cell in row: + target = {} + for key, value in cell.items(): + new = ((key[0]+term[0]) % 4,) + tuple(a+b for a, b in zip(key[1:], term[1:])) + accumulate(target, {new: value}) + result.append(target) + return result diff --git a/research/mixed-projector-query-root/ceiling.py b/research/mixed-projector-query-root/ceiling.py new file mode 100644 index 0000000000..93f626e821 --- /dev/null +++ b/research/mixed-projector-query-root/ceiling.py @@ -0,0 +1,66 @@ +"""Bound every binary-child size for the rank 2,3,3,2 root. + +The native source stays fixed. Other roots and native sources are outside +this claim. All arithmetic in this checker uses rational intervals. +""" +from fractions import Fraction as Q + +CEILING=Q('.00328469') +BIT_CAP=Q('.0034') +TAIL=100 + + +def run(local,E,root): + def need(ok,message): + if not ok:raise ValueError(message) + need(00,'The native deficit increases throughout the admitted range') + h={r:E.power(r,t) for r in range(1,8*TAIL+2)} + lower=[Q(0)]*TAIL + upper=[Q(0)]*TAIL + split_checks=0 + for n in range(2,TAIL): + node_lower=2*h[8*n][0]+1-2*h[8*n+1][1] + node_upper=2*h[8*n][1]+1-2*h[8*n+1][0] + lower[n]=min(lower[a]+lower[n-a]+node_lower for a in range(1,n)) + upper[n]=min(upper[a]+upper[n-a]+node_upper for a in range(1,n)) + need(lower[n]<=upper[n],'Binary subtree interval') + split_checks+=n-1 + pairs={} + for n in range(2,TAIL-1): + pairs[n]=max(h[8*n+1][1]-n*native_lower-lower[n-b]-lower[b] + +h[8*b+1][1]-h[8*b][0] for b in range(1,n)) + margins=[] + for n in range(4,TAIL): + for a in range(2,n-1): + margins.append(h[8*n+1][1]+pairs[a]+pairs[n-a]-2) + finite_upper=max(margins) + need(finite_upper<0,'Every finite child sum fails at the ceiling') + # Every binary node costs at least -1 by concavity. For total n, + # Jensen bounds the two pair outputs and each added increment is at + # most H9-H8. The resulting upper bound is decreasing for n >= TAIL. + tail_upper=(h[8*TAIL+1][1]+2*h[4*TAIL+1][1]-TAIL*(native_lower-1) + +2*(h[9][1]-h[8][0])-6) + derivative_upper=(8*t*(h[8*TAIL+1][1]/(8*TAIL+1) + +h[4*TAIL+1][1]/(4*TAIL+1))-(native_lower-1)) + need(tail_upper<0 and derivative_upper<0,'All larger child sums fail') + return {'ceiling':str(CEILING),'first_tail_total':TAIL,'binary_split_checks':split_checks, + 'admitted_saving_cap':str(BIT_CAP),'native_derivative_lower':str(derivative_lower), + 'finite_pair_checks':len(margins),'finite_margin_upper':str(finite_upper), + 'tail_margin_upper':str(tail_upper),'tail_derivative_upper':str(derivative_upper), + 'scope':'All positive integer child sizes and all binary tree shapes for this fixed root and PR6349 source.'} + + diff --git a/research/mixed-projector-query-root/controller.py b/research/mixed-projector-query-root/controller.py new file mode 100644 index 0000000000..393524f903 --- /dev/null +++ b/research/mixed-projector-query-root/controller.py @@ -0,0 +1,223 @@ +"""Emit the mixed projector root and its paid binary query suppliers. + +The binary child emitter is adapted from PR6348. Cinna Davis supplies the +native and thin-query interface. Ali Romman with OpenAI Codex assistance. +Apache-2.0. All ordinary normalization occurs outside tensor powers. +""" +from collections import Counter +from copy import deepcopy +from hashlib import sha256 +from pathlib import Path +import json + +from algebra import Q, accumulate, coefficient, eye, matrix, need, shifted, zmul + +HERE = Path(__file__).resolve().parent + + +def construct(): + data = json.loads((HERE/'ROOT.json').read_text()) + events, targets, nodes = [], {}, [] + stage, next_role = 0, 6 + + def emit(op, *args): + events.append([op, *args]) + + def mix(rows): + a = matrix(rows) + ops = [] + for j in range(6): + # A unit in the dyadic ring keeps every emitted scale dyadic. + pivots = [k for k in range(j, 6) if a[k][j] + and abs(a[k][j].numerator) & (abs(a[k][j].numerator)-1) == 0] + need(pivots, 'Each declared basis has a dyadic unit pivot') + k = pivots[0] + if k != j: + a[j], a[k] = a[k], a[j] + ops.append(['SWAP', j, k]) + c = 1/a[j][j] + if c != 1: + a[j] = [x*c for x in a[j]] + ops.append(['SCALE', j, str(c)]) + for k in range(6): + if k != j and a[k][j]: + c = -a[k][j] + a[k] = [x+c*y for x, y in zip(a[k], a[j])] + ops.append(['ADD', k, j, str(c)]) + need(a == eye(6), 'Complete scalar basis elimination') + for e in reversed(ops): + if e[0] == 'SCALE': + e[-1] = str(1/Q(e[-1])) + elif e[0] == 'ADD': + e[-1] = str(-Q(e[-1])) + emit(*e) + + def label(tree): + nonlocal stage + if tree == 1: + stage += 1 + return {'stage': stage, 'stages': [stage]} + left, right = map(label, tree) + return {'left': left, 'right': right, 'stages': left['stages']+right['stages']} + + roots = [label(t) for t in data['children']] + + def supplier(tree, x, y, exponent): + nonlocal next_role + if 'stage' in tree: + if exponent == -1: + emit('Q_POWER', x, -2) + emit('SWAP', x, y) + emit('LOCAL', tree['stage'], x, y) + emit('SWAP', x, y) + if exponent == -1: + emit('Q_POWER', x, 2) + return + a, b = next_role, next_role+1 + next_role += 2 + stages = tree['stages'] + nodes.append({'roles': [a, b], 'stages': stages, 'exponent': exponent}) + emit('SWAP', x, b) + emit('SWAP', y, a) + emit('SWAP', a, b) + emit('ADD', x, a, 1) + emit('ADD', b, y, -1) + emit('QUERY', a, b, -exponent) + emit('ADD', b, y, 1) + emit('ADD', x, a, -1) + emit('IDLE', a, b, stages) + emit('SCALE', y, -1) + supplier(tree['left'], y, x, -exponent) + emit('SCALE', y, -1) + supplier(tree['right'], x, y, exponent) + emit('ADD', x, a, 1) + emit('SCALE', a, -1) + emit('ADD', a, x, 1) + emit('SWAP', y, b) + emit('SCALE', b, -1) + emit('ADD', b, y, 1) + targets[a], targets[b] = (-exponent, stages), (exponent, stages) + + mix(data['input_basis']) + full_index = 0 + for site in data['sites']: + mix(site['inverse']) + # lambda=(1+i)/2+(1-i)*q^2/2, q=Q^-1. Its square is q^2. + emit('LAMBDA', 0, -1) + if site['full']: + tree = roots[full_index] + full_index += 1 + supplier(tree, 0, 1, 1) + for r in range(2, site['stage_rank']): + emit('IDLE_ONE', r, tree['stages']) + else: + emit('QUERY', 0, 1, -1) + emit('LAMBDA', 0, 1) + emit('ADD', 0, 1, -1) + mix(site['basis']) + mix(data['output_basis']) + for r, mask in enumerate(data['masks']): + emit('LAMBDA', r, -1) + selected = [s for bit, tree in zip(mask, roots) if bit for s in tree['stages']] + targets[r] = (-1, selected) + need(stage == 18 and next_role == 34, 'Complete mixed-root dimensions') + diagonal = [[targets[r][0], 0]+[int(s in targets[r][1]) for s in range(1, stage+1)] + for r in range(next_role)] + return {'schema': 'mixed-projector-query-root/2', 'roles': next_role, + 'stages': stage, 'ambient_rank': 9+8*stage, 'nodes': nodes, + 'events': events, 'diagonal': diagonal} + + +def replay(word): + n, width = word['roles'], word['stages']+2 + zero = (0,)*width + rows = [[{zero: coefficient(1)} if i == j else {} for j in range(n)] for i in range(n)] + seen = [] + for event in word['events']: + op = event[0] + if op == 'ADD': + _, dst, src, c = event + for a, b in zip(rows[dst], rows[src]): + accumulate(a, b, coefficient(c)) + elif op == 'SCALE': + _, dst, c = event + rows[dst] = [{key: zmul(coefficient(c), value) for key, value in cell.items()} + for cell in rows[dst]] + elif op == 'SWAP': + _, a, b = event + rows[a], rows[b] = rows[b], rows[a] + elif op in ('LOCAL', 'QUERY'): + if op == 'LOCAL': + _, stage, src, dst = event + exponent = -1 + seen.append(stage) + else: + _, dst, src, exponent = event + term = (exponent,)+(0,)*(width-1) + for a, b in zip(rows[dst], shifted(rows[src], term)): + accumulate(a, b) + if op == 'LOCAL': + term = (0,)+tuple(int(s == stage) for s in range(width-1)) + for r in (src, dst): + rows[r] = shifted(rows[r], term) + elif op == 'Q_POWER': + _, r, exponent = event + need(exponent in (-2, 2), 'Only even powers are ordinary translations') + rows[r] = shifted(rows[r], (exponent,)+(0,)*(width-1)) + elif op == 'LAMBDA': + _, r, sign = event + need(sign in (-1, 1), 'Unitary normalization or its inverse') + old = rows[r] + other = shifted(old, (2,)+(0,)*(width-1)) + rows[r] = [{} for _ in range(n)] + for dst, a, b in zip(rows[r], old, other): + accumulate(dst, a, (Q(1,2), Q(sign,2))) + accumulate(dst, b, (Q(1,2), Q(-sign,2))) + elif op in ('IDLE', 'IDLE_ONE'): + roles, stages = (event[1:3], event[3]) if op == 'IDLE' else ([event[1]], event[2]) + need(len(stages) == len(set(stages)), 'Distinct whole-idle stages') + term = (0,)+tuple(int(s in stages) for s in range(width-1)) + for r in roles: + rows[r] = shifted(rows[r], term) + else: + raise ValueError('Unknown caller opcode: '+op) + expected = [[{(word['diagonal'][i][0] % 4,)+tuple(word['diagonal'][i][1:]): coefficient(1)} + if i == j else {} for j in range(n)] for i in range(n)] + need(sorted(seen) == list(range(1, word['stages']+1)), 'Every native stage exactly once') + need(rows == expected, 'Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient') + return {'inputs': n, 'coefficients': n*n, 'native_stages': len(seen), + 'events': len(word['events']), 'event_sha256': sha256(json.dumps(word['events'],separators=(',',':')).encode()).hexdigest()} + + +def controls(word): + result = {} + for op in ['LOCAL', 'QUERY', 'IDLE', 'IDLE_ONE', 'LAMBDA', 'Q_POWER']: + bad = deepcopy(word) + del bad['events'][next(i for i,e in enumerate(bad['events']) if e[0] == op)] + try: + replay(bad) + except ValueError as error: + result['missing_'+op.lower()] = str(error) + else: + raise ValueError('Mutation accepted: '+op) + return result + + +def formula_invoice(local): + targets = Counter({r: 18*n for r,n in local['helpers'].items()}) + paid = Counter({r: 18*n for r,n in local['paid'].items()}) + paid[1] += 17*104 + # Four child trees: 7, 2, 2 and 7 leaves. + for size, count in {2:8, 3:2, 4:2, 7:2}.items(): + targets[1+8*size] += 208*count + paid[8*size] += 208*count + for rank,count in {145:1,73:2,1:1,17:2}.items(): + targets[rank] += 104*count + paid[16] += 208 + return targets, paid + + +if __name__ == '__main__': + word = construct() + print(replay(word)) + print(controls(word)) diff --git a/research/mixed-projector-query-root/module_check.py b/research/mixed-projector-query-root/module_check.py new file mode 100644 index 0000000000..8631a48310 --- /dev/null +++ b/research/mixed-projector-query-root/module_check.py @@ -0,0 +1,149 @@ +"""Check the root independently of the emitted caller. + +The shortest-query tuple is from five-call-projector-rigidity. The chosen +stage projectors, normalization and mixed root are new here. Ali Romman, +with substantial OpenAI Codex assistance. Apache-2.0. +""" +from pathlib import Path +import json + +from algebra import Q, add, eye, inverse, matrix, multiply, need, zadd, zmul + +HERE = Path(__file__).resolve().parent + + +def run(): + d = json.loads((HERE/'ROOT.json').read_text()) + n, identity = 6, eye(6) + zero = [[Q(0)]*n for _ in range(n)] + f, fi = matrix(d['input_basis']), matrix(d['output_basis']) + need(multiply(f, fi) == multiply(fi, f) == identity, 'Root bases are inverses') + prefix, projectors, queries = identity, [], [] + for i, site in enumerate(d['sites']): + u = [int(j == i) for j in range(n)] if i < n else [-(-1)**j for j in range(n)] + v = [int(i > j)-int(i < j) for j in range(n)] + r = matrix([[x*y for y in v] for x in u]) + need(multiply(r, r) == zero, 'Square-zero query') + prefix = multiply(add(identity, r, -2), prefix) + c, ci = matrix(site['basis']), matrix(site['inverse']) + need(multiply(c, ci) == multiply(ci, c) == identity, 'Each native basis has an inverse') + e = [[Q(0)]*n for _ in range(n)] + e[0][1] = Q(1) + need(multiply(multiply(c,e),ci) == r, 'Actual native two-field query plane') + p = matrix(site['projector']) + if site['full']: + support = site['support'] + diagonal = [[int(j == k and j in support) for k in range(n)] for j in range(n)] + need(p == multiply(multiply(f,diagonal),fi), 'Independent output stage mask') + size = site['stage_rank'] + physical = [[int(j == k and j < size) for k in range(n)] for j in range(n)] + need(p == multiply(multiply(c,physical),ci), 'Every complementary idle is included') + need(multiply(p,p) == p and multiply(p,r) == multiply(r,p) == r, 'Stage projector') + need(multiply(p,prefix) == multiply(prefix,p), 'Chronological commutation') + for old in projectors: + need(multiply(p,old) == multiply(old,p), 'Independent stages commute') + projectors.append(p) + else: + need(p == zero, 'Thin sites have no free diagonal supplier') + queries.append(r) + need(prefix == [[-x for x in row] for row in identity], 'All minus-character outputs') + masks = [[int(j in s['support']) for s in d['sites'] if s['full']] for j in range(n)] + need(masks == d['masks'], 'Declared full-site masks') + expected = {} + for j,bits in enumerate(masks): + mask = sum(bit << i for i,bit in enumerate(bits)) + expected.setdefault(mask, [[Q(0)]*n for _ in range(n)])[j][j] = Q(1) + for sign in (1,-1): + word, stage = {0: identity}, 0 + for r,site in zip(queries,d['sites']): + next_word = {} + p = matrix(site['projector']) + for mask,old in word.items(): + a = multiply(add(identity,r,sign-1),old) + if site['full']: + next_word[mask] = multiply(add(identity,p,-1),a) + next_word[mask | (1 << stage)] = multiply(p,a) + else: + next_word[mask] = a + word = {k:a for k,a in next_word.items() if a != zero} + stage += int(site['full']) + actual = {k:multiply(multiply(fi,a),f) for k,a in word.items()} + need(actual == {k:[[sign*x for x in row] for row in a] for k,a in expected.items()}, + 'Every independent full-stage polynomial coefficient') + # The four ordinary operations act on each pair of translated addresses. + # No whole field is copied or initialized for this normalization. + pair_matrices = [] + for sign in (1,-1): + a, b = (Q(1,2),Q(sign,2)), (Q(1,2),Q(-sign,2)) + columns = [] + for column in (0,1): + x,y = (Q(int(column == 0)),Q(0)), (Q(int(column == 1)),Q(0)) + x = zadd(x,zmul((Q(0),Q(-sign)),y)) + x = zmul(a,x) + y = zmul((Q(1),Q(sign)),y) + y = zadd(y,zmul((Q(0),Q(-sign)),x)) + columns.append([x,y]) + m = list(map(list,zip(*columns))) + need(m == [[a,b],[b,a]], 'Four-operation ordinary normalization') + pair_matrices.append(m) + def zmat(a,b): + return [[zadd(zmul(a[i][0],b[0][j]),zmul(a[i][1],b[1][j])) for j in range(2)] for i in range(2)] + need(zmat(*pair_matrices) == [[(1,0),(0,0)],[(0,0),(1,0)]], 'Normalization inverse') + need(zmat(pair_matrices[0],pair_matrices[0]) == [[(0,0),(1,0)],[(1,0),(0,0)]], + 'Normalization square is the ordinary translation') + for q in [(1,0),(-1,0),(0,1),(0,-1)]: + square = zmul(q,q) + lam = zadd((Q(1,2),Q(1,2)),zmul((Q(1,2),Q(-1,2)),square)) + lam_inv = zadd((Q(1,2),Q(-1,2)),zmul((Q(1,2),Q(1,2)),square)) + s = zmul(lam,q) + need(zmul(s,s) == (1,0) and zmul(lam_inv,s) == q, 'All four Gaussian characters') + def dense_product(a,b): + size = len(a) + out = [[(Q(0),Q(0)) for _ in range(size)] for _ in range(size)] + for i in range(size): + for j in range(size): + for k in range(size): + out[i][j] = zadd(out[i][j],zmul(a[i][k],b[k][j])) + return out + tensor_columns = 0 + wrong_tensor_rejected = False + for width in (1,2,3): + size = 1 << width + ident = [[(Q(int(i == j)),Q(0)) for j in range(size)] for i in range(size)] + gaussian,normalizer,restore = [],[],[] + for i in range(size): + row,norm,back = [],[],[] + for j in range(size): + value = (Q(1),Q(0)) + for bit in range(width): + c = (Q(1,2),Q(1 if (i^j)&(1 << bit) else -1,2)) + value = zmul(value,c) + row.append(value) + norm.append((Q(1,2),Q(1,2)) if i == j else + (Q(1,2),Q(-1,2)) if i^j == size-1 else (Q(0),Q(0))) + back.append((Q(1,2),Q(-1,2)) if i == j else + (Q(1,2),Q(1,2)) if i^j == size-1 else (Q(0),Q(0))) + gaussian.append(row) + normalizer.append(norm) + restore.append(back) + normalized = dense_product(normalizer,gaussian) + need(dense_product(normalized,normalized) == ident, 'Actual tensor Gaussian normalizes to an involution') + need(dense_product(restore,normalized) == gaussian, 'Actual tensor Gaussian is restored') + if width == 1: + need(normalized == ident, 'One-column normalization positive control') + if width == 2: + need(normalized != ident and dense_product(restore,ident) != gaussian, + 'Tensoring the one-column normalization is rejected') + wrong_tensor_rejected = True + tensor_columns += size + return {'fields':n,'full_sites':4,'thin_sites':3,'stage_ranks':[2,3,3,2], + 'polynomial_coefficients':2*16*n*n,'gaussian_characters':4, + 'actual_tensor_gaussian_columns':tensor_columns, + 'wrong_tensor_normalization_rejected':wrong_tensor_rejected, + 'ordinary_normalization_operations_per_pair':4,'owned_normalization_fields':0, + 'normalization_growth_per_operation_upper':2, + 'tensor_rule':'Normalize the complete field with its global Q squared translation; scalar coefficients stay outside tensor powers.'} + + +if __name__ == '__main__': + print(run()) diff --git a/research/mixed-projector-query-root/physical.py b/research/mixed-projector-query-root/physical.py new file mode 100644 index 0000000000..b63471439e --- /dev/null +++ b/research/mixed-projector-query-root/physical.py @@ -0,0 +1,88 @@ +"""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]) + positive = list(axes[:9]) if selected[0] else [q] + 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/mixed-projector-query-root/pricing.py b/research/mixed-projector-query-root/pricing.py new file mode 100644 index 0000000000..6c9f0db0f4 --- /dev/null +++ b/research/mixed-projector-query-root/pricing.py @@ -0,0 +1,170 @@ +"""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 file counts the new root, individual idles and ordinary normalization. +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.00328467') +TESTED = Q('0.003284675') +PREVIOUS = Q('0.00315057') + + +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[1+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') + need((targets, paid) == formula_invoice(local), 'Independent tree and emitted-event counts') + need((counts['LOCAL'], counts['QUERY'], counts['IDLE']) == (18, 17, 14) and counts['IDLE_ONE'] == 2 and counts['LAMBDA'] == 20, 'Complete caller census') + need((sum(targets.values()), sum(paid.values())) == (13652, 66988), '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] + low, high, grid = 0, 10**12, 10**14 + while high-low > 1: + middle = (low+high)//2 + if margin(Q(middle, grid))[0] > 0: + low = middle + else: + high = middle + lower, upper = Q(low, grid), Q(high, 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') + need(PREVIOUS < KAPPA < TESTED < lower, 'The mixed root improves the published PR6353 claim') + t, offset, power, cutoff, floor = 1-TESTED, Q(1, 7), 1024, 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**12), Q(31, 32) + need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All charged tail ratios') + need(decay**128 < Q(1, 16), 'Both tail decay blocks') + normalized = 1/(1+power*reserve)+Q(4, 2**32) + need(normalized < 1 and cutoff**64 < floor**63, 'Completion, splitting and rounding') + theta, logarithm_power = Q(63, 64), 1100 + # 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*34*104*len(word['events']) + 34*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.00328467', 'previous_pr6353': PREVIOUS, + 'gain': KAPPA-PREVIOUS, 'relative_gain_percent': 100*(KAPPA/PREVIOUS-1), + 'raw_root_interval': [lower, upper], 'raw_headroom': [lower-KAPPA, upper-KAPPA], + '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, 'tail_block': 128, + '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.'}}) diff --git a/research/mixed-projector-query-root/verify.py b/research/mixed-projector-query-root/verify.py new file mode 100644 index 0000000000..8c1306a2aa --- /dev/null +++ b/research/mixed-projector-query-root/verify.py @@ -0,0 +1,111 @@ +"""Replay the exact source, mixed root, physical caller and complete bound. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +Predecessor authors and proof engines retain their credit in NOTICE. +""" +from hashlib import sha1, sha256 +from pathlib import Path +import gzip +import importlib.util +import json +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +LIFT = ROOT/'research/p104-native-input-lifting' +TREE = ROOT/'research/balanced-query-tree' +STATUS = 'PASS_MIXED_PROJECTOR_QUERY_ROOT_KAPPA_00328467' + + +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 authenticate(): + pins = [p for p in read(HERE/'SOURCES.json')['files'] if p['usage'] == 'input'] + for pin in pins: + raw = (ROOT/pin['path']).read_bytes() + need(sha256(raw).hexdigest() == pin['sha256'], 'Source SHA256: '+pin['path']) + need(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == pin['git_blob'], + 'Source Git blob: '+pin['path']) + need(len(pins) == 17, 'Complete live source inventory') + return len(pins) + + +def run(): + sources = authenticate() + load(HERE/'algebra.py', 'algebra') + controller = load(HERE/'controller.py', 'controller') + module = load(HERE/'module_check.py', 'mixed_root_module') + physical = load(HERE/'physical.py', 'mixed_root_physical') + price = load(HERE/'pricing.py', 'mixed_root_price') + ceiling = load(HERE/'ceiling.py', 'mixed_root_ceiling') + support = load(LIFT/'support.py', 'support') + constructor = load(LIFT/'construct.py', 'mixed_source_constructor') + lift_checks = load(LIFT/'verify.py', 'mixed_source_checks') + binary = load(TREE/'module_check.py', 'mixed_binary_module') + source = json.loads(gzip.decompress(support.inputs()[support.WORD])) + local_word = constructor.construct(source) + need(constructor.payload(local_word) == gzip.decompress((LIFT/'WORD.json.gz').read_bytes()), + 'Every unchanged lifted source byte') + word = controller.construct() + need(word == read(HERE/'CONTROLLER.json'), 'Every emitted caller event') + root_check, binary_check = module.run(), binary.run() + caller = controller.replay(word) + controls = controller.controls(word) + print('PASS exact root, ordinary normalization, binary children, full caller and controls', flush=True) + with support.checkers() as (L, root): + directions = lift_checks.preparation(L, source, local_word) + local = L.replay(local_word) + need(price.encode(local) == read(LIFT/'RESULT.json')['local'], 'Complete unchanged local receipt') + controls.update(lift_checks.word_controls(L, local_word)) + columns = L.reverse_columns(local_word) + need(columns['columns'] == 799 and columns['coefficients'] == 638401, 'Every arbitrary source input') + print('PASS source arbitrary inputs, preparation, ownership and dense transpose', flush=True) + native = L.native(local_word) + maps = physical.physical(word, local_word, L) + need(maps['full_calls'] == 18 and maps['physical_contacts'] == 7488, 'Every native contact') + print('PASS native absolute phases, whole idles and physical caller', flush=True) + result_price = price.run(local, native, word, maps, L) + intervals = L.load(L.ROOT/'research/higher-moment-strictification/verify.py', 'mixed_ceiling_intervals') + fixed_ceiling = ceiling.run(local, intervals, read(HERE/'ROOT.json')) + bad_root = read(HERE/'ROOT.json') + bad_root['masks'][3][0] = 1 + try: + ceiling.run(local, intervals, bad_root) + except ValueError as error: + controls['changed_ceiling_root'] = str(error) + else: + raise ValueError('A changed root entered the fixed-root ceiling') + print('PASS complete invoice, both rational price engines, compiler and outer predicates', flush=True) + return price.encode({'status':STATUS, 'source_inputs':sources, 'root':root_check, + 'binary_module':binary_check, 'caller':caller, + 'local':local, 'lifted_directions':directions, 'columns':columns, + 'native':native, 'physical':maps, 'price':result_price, 'fixed_root_ceiling':fixed_ceiling, + 'negative_controls':controls, + 'assumptions':['native_all_columns','owned_erasure','compiler', + 'precision_tape','analytic_recovery'], + 'selected_frontier_changed':False}) + + +if __name__ == '__main__': + result = run() + if sys.argv[1:] == ['--write-result']: + (HERE/'RESULT.json').write_text(json.dumps(result,sort_keys=True,indent=2)+'\n') + else: + need(not sys.argv[1:], 'Only --write-result is supported') + need(result == read(HERE/'RESULT.json'), 'Exact retained scientific receipt') + print(STATUS, flush=True) diff --git a/research/mixed-projector-root-headroom/BOUNDARY-MODULES.md b/research/mixed-projector-root-headroom/BOUNDARY-MODULES.md new file mode 100644 index 0000000000..6ce704166b --- /dev/null +++ b/research/mixed-projector-root-headroom/BOUNDARY-MODULES.md @@ -0,0 +1,188 @@ +# Helper consumption and a five-call border + +These are exact module results. They do not increase the complete kappa. +The all-size price exclusions use the PR6375 native invoice and the +fixed saving kappa=0.00328621476572836015146308, with H(x)=x^(1-kappa). +They do not assert a loss for every concave tariff. The separate formal +border crossing below varies kappa and does not include recovery costs. +The source-bound prices use the final PR6375 composition at 0.00328621476572836015146308. +The native caller and recursive precision transfer for these changed +interfaces have not been constructed. + +## 1. A three-field module that consumes one helper + +The module has three full sites with stage ranks 2,3,2. The middle site +uses one independent B*S Gaussian output in addition to its two-field +query. There is no extra thin query or idle. In the basis + +```text +F = [[ 0, 1,-1], + [-1,-1, 0], + [ 1, 1, 1]], +``` + +the endpoint is S diag(ABC,AB,BC). `boundary_modules.py` gives the three +projectors, rank-one queries and the middle Gaussian selector. It checks +both central characters and every stage coefficient. Each stage occurs +once, so each entry has degree at most one in each of A,B,C. Equality at +the two nodes 1 and 2 for each variable proves the polynomial identity. + +The consumed output must be debited. With child sizes a,b,c and n=a+b+c, +the optimistic signed invoice is + +```text +H(8n+1)+H(8(a+b)+1)+H(8(b+c)+1)-H(8b+1) + -nL-C(a)-C(b)-C(c). +``` + +Here L includes every paid native call minus every retained helper, per +port, and C is the minimum complete binary-node bill. The subtraction of +H(8b+1) removes the consumed helper from the independent outputs. This +price already gives the module a matching helper; it does not assert +that a complete physical source supplies that interface. + +`boundary_prices.py` checks every positive triple with n<100, up to the +exchange of a and c. It uses outward rational bounds and a 2^40 integer +grid. All upper bounds are negative. For n>=100, C(a)+C(b)+C(c)>=-(n-3). +Jensen bounds the two pair outputs by 2H(4(n+b)+1). The difference +2H(4(n+b)+1)-H(8b+1) decreases with b=100, +Jensen and C(a)+C(b)+C(c)>=-(n-3) give + +```text +margin <= H(8n+1)+3H(8n/3+1)-n(L-1)-7. +``` + +This concave bound and its derivative are negative at 100. Thus the +direct two-query recovery loses for all sizes, not only the earlier +bounded numerical search. Other recovery methods are not excluded. + +## 4. Why the star has no exact five-call endpoint + +Fix four fields, three rank-one square-zero full queries on the three +distinct star supports above, and two rank-one central reflections. +Allow any order and arbitrary scalar coefficients in characteristic +other than two. If the endpoint at S=-1 were -I_4, the chronological +identity would give U(I+2L)^(-1)V=I_4. Hence + +```text +Z=I+2L-VU +``` + +has rank one. At each of the three full sites its diagonal entry is one. +Writing Z=xy forces, for the three full sites i=2 is even. +Permit any number s of arbitrary extra inputs. Use exactly r+1 rank-one +square-zero queries. Keep independent forward stage variables and scalar +bases independent of S and those variables. The coefficients commute +with these operators. Require the endpoint +diag(S I_r,I_s) diag(product_i D_i^epsilon_ji), with epsilon_ji in {0,1}, +after constant boundary changes independent of S and the D_i. Each stage +acts only at its own full site. +Each stage dimension outside its two-field query plane has a paid whole +idle. No helper output is consumed. Under this contract, the extra outputs +without S cannot improve the signed price over the r active fields alone. + +Write U for the query columns, V for the rows, G=VU, and L for its strict +lower part. The chronological expansion gives + +```text +U A V = E, A=(I+2L)^(-1), E=(I-J)/2=diag(I_r,0_s). +``` + +Both U and V have rank at least r. They cannot both have rank r+1: an +injective U, invertible A and surjective V would give rank r+1 to their +product. Thus at least one has rank r. + +Suppose rank(U)=r. Its image equals im(E), so every query column lies in +the active space. All queries have zero lower blocks. Their active blocks +therefore multiply to -I_r. Let V_a be the restriction of V to that space. +Then U_a A V_a=I_r. The matrix A V_a U_a is an idempotent of rank r on +r+1 coordinates. Consequently + +```text +Z=I+2L-V_a U_a +``` + +has rank one and diagonal entries one. All its off-diagonal factorizations +are nonzero. They give the usual shortest-query Gram normal form. In +particular, no active query disappears. Each active query remains a +nonzero rank-one square-zero operator. If rank(V)=r, apply the same +argument to the reversed transpose word. This covers both possible cases. + +At S=1, the first derivative in each independent stage variable identifies +its projector P_i with an output mask. At S=-1 the constant endpoint is J +in the same output basis. Thus every P_i commutes with J and splits into +active and inactive blocks. The active block contains both the query +column and row; it has rank at least two. Compression therefore preserves +a legal active query and all active stage incidences. Compression is valid +here because all queries have the same one-sided block containment. It +would not be valid for unrestricted cross-block queries. + +On an inactive output, let the incident child sizes be n_1,...,n_k. Its +productive rank is 8(n_1+...+n_k), without the extra central rank one. +It pays each of the whole idles 8n_j. For H(x)=x^t, 0=2 with x+y+e<100. This covers every positive five-child tuple below +100 and every binary shape through the exact binary cost recurrence. +There is no solver relaxation or time limit. + +The interval engine gives rational bounds for each H value and L. The +replay rounds lower bounds down and upper bounds up onto a 2^40 integer +grid. It uses lower binary costs, lower paid idles and native charges, +and upper productive terms. Every resulting maximum is an upper bound. +Python integers cannot overflow. The finite maxima are strictly negative. + +For n>=100, each binary node costs at least -1, so the five child bills +are at least -(n-5). Put Delta=H(9)-H(8) and +K=H(17)-2H(8)+2Delta. Concavity gives these upper bounds: + +```text +mask 39: +H(8n+1)+2H(4n+5)-H(8)+3Delta-n(L-1)-7; + +masks 43,45,51,53: +H(8n+1)+2H(4n+1)+K-n(L-1)-7; + +masks 46,54: +3H(16n/3+1)+K-n(L-1)-7. +``` + +For mask 39, apply Jensen to the two pair outputs. The remaining +e-dependent part 2H(4(n+e)+1)-H(8e) decreases for 1<=e=1, then note that both +H(8e+9)-H(8e) and H(8e+1)-H(8e) decrease with e. In the middle group, +Jensen bounds the two pair outputs by 2H(4n+1). In the last group, the +first three output degrees sum to 2n, so Jensen gives 3H(16n/3+1). + +Each displayed bound is concave in n. The replay checks its value and +derivative are strictly negative at 100. Thus all larger totals lose. +This replaces the seven time-limited numerical searches with a complete +exact price exclusion for their specified support family. Other roots +remain open. + +## Open next questions + +- Test five-full roots with only one rank-two projector. The seven-mask + proof does not cover their supports. +- Construct a different child interface with a full native invoice. +- Supply a complete recovery and precision proof for the five-call + border before applying its favorable formal price. + +Ali Romman with substantial OpenAI Codex assistance; no subagents. +The chronological identity and shortest-query normal form retain the +credit in PROOF.md. The interval engine is by zxv and its predecessors. diff --git a/research/mixed-projector-root-headroom/NOTICE b/research/mixed-projector-root-headroom/NOTICE new file mode 100644 index 0000000000..081d5cea14 --- /dev/null +++ b/research/mixed-projector-root-headroom/NOTICE @@ -0,0 +1,29 @@ +Mixed-projector root headroom +Copyright 2026 Ali Romman. Apache-2.0. + +New work: the rank-two support bound, complete free-parameter six-field +minimum-idle classification, larger-family price reduction, idle rank +floors, all-width normalization proof and exact replay. +Ali Romman with substantial OpenAI Codex assistance. No subagents. +These are author checks, not independent human review. + +The shortest-query normal form and exact projector method are retained +from five-call-projector-rigidity, by Ali Romman with OpenAI Codex +assistance. The mixed root and complete PR6353 composition are separate +packages in this contribution. The new argument does not claim their +construction or source mechanisms again. + +Cinna Davis supplies the productive controller and query caller lineage. +PR6348 supplies the binary query module. PR6349 supplies native input +lifts. PR6353 supplies nine native output contractions. DreamingOfClouds, +flyingviper, Joel Pulikkan, thu-nmrc, Gareth Davidson, David Arias, +Jacob Alan Sussman, zxv, Cao Yifan and all retained native, helper, +geometry, recursion, compiler, BIT and analytic authors keep their credit. +The complete predecessor notices remain in the root and composition +packages and their unchanged source archives. + +The extension prices use zxv's exact interval engine. The final input +invoice includes DreamingOfClouds' PR6375 shared-carrier lifts, prepared +with Claude Opus 5.5 assistance. PR4623 and Discussion4611 supply the +prior scalar-filtration and finite-approximation context for the border; +their recursive precision obligation is not discharged here. diff --git a/research/mixed-projector-root-headroom/PROOF.md b/research/mixed-projector-root-headroom/PROOF.md new file mode 100644 index 0000000000..f910b5fbf9 --- /dev/null +++ b/research/mixed-projector-root-headroom/PROOF.md @@ -0,0 +1,405 @@ +# The minimum-idle mixed root and its limits + +The first source-bound instance has conditional kappa **0.00328551** +with PR6353. This note +does not add a new kappa increment. It proves that the ceiling 0.00328554 +applies to a larger class than the fixed root in the source package. + +Work over a commutative field of characteristic zero, unless stated +otherwise. The scalar basis coefficients are independent of the central +involution S and all stage variables; they commute with these operators. +There are six arbitrary main +fields, seven rank-one square-zero queries, four full child suppliers, +and at most two extra whole idle jobs at the root. Each child can be any +positive-size binary tree from PR6348, with the PR6353 native source. +There is no initialized extra main field. A full stage acts once on each +field in its projector image. Every field beyond its native two-field +query plane needs one charged whole idle of that same stage product. + +The required endpoint, after constant entrance and exit changes, is + +```text +S diag(product_i D_i^epsilon_ji), epsilon_ji in {0,1}. +``` + +Every one of the six outputs contains S. Each stage variable D_i is +independent and occurs only at its own full site. The constant boundary +changes are independent of S and the D_i. Thus at D_i=1 the endpoint +is S I_6. These assumptions define the independent Gaussian endpoint +used below. Commutation alone does not imply coefficient independence. +The complete-field normalization is a separate ordinary wrapper. Its +translation X=q^2 supplies S=lambda*q; it does not make the root's +scalar bases depend on S or on a stage variable. + +**Theorem.** Every such root with an independent Gaussian endpoint has, +up to stage and output names, the output supports + +```text +ABCD, AB, CD, empty, B, C. +``` + +It has two rank-two endpoint stages and two rank-three interior stages. +Thus its recursive paid/productive price pattern is that of the existing +mixed root. This does not give a uniform ordinary-operation budget over +all scalar bases. Omitting further ordinary costs only favors a competing +root, so the recursive price still gives a valid exclusion. No +positive binary child sizes or binary tree shapes reach 0.00328554 under +the fixed PR6353 source and the admitted saving range through 0.0034. + +The claim 0.00328551 is 0.00000003 below this ceiling. More +idles, more queries, different field counts, different query or source +interfaces, and noncommuting ordinary coefficients are outside this +theorem. So are stage-dependent or S-dependent scalar bases and outputs +that omit S. For example, a six-field seven-query endpoint with central +part diag(-I_4,+I_2) is not covered. The separate active-space extension +uses exactly r+1 queries for r active fields, so it does not cover that +seven-query example either. This is not a global optimum for kappa. + +## 1. Why the normal form and projector tests apply + +Move all invertible constant scalar maps to the final boundary. At stage +variables equal to one, remove their total product there. A full site has +the form + +```text +(I+(D_i-1)P_i) (I+(S-1)R_i), +P_i^2=P_i, R_i=u_i v_i, v_i u_i=0, P_i R_i=R_i P_i=R_i. +``` + +A thin site has only the second factor. At S=-1 put T_i=I-2R_i and +B_i=T_i ... T_0. The complete endpoint at stage variables equal to one +requires T_6 ... T_0=-I_6. + +The shortest-query classification in the pinned +`five-call-projector-rigidity/PROOF.md`, section 1, permits the basis + +```text +u_i=e_i for i=0,...,5, +u_6=(-1,1,-1,1,-1,1), +(v_i)_j=sign(i-j). +``` + +It is a complete normal form, not a sampled query tuple. The proof uses +the chronological identity + +```text +T_6 ... T_0 = I-2U(I+2L)^(-1)V, +G=VU, and L is the strict lower part of G. +``` + +The matrix I+2L-G has rank one and diagonal entries one. Rescaling the +query factors gives G_ij=sign(i-j). The same argument applies to n+1 +queries on any even n fields. + +The independent Gaussian endpoint forces the full P_i to commute. +Indeed, its first derivative in each independent D_i at S=1 and all +D_j=1 identifies P_i with a diagonal zero-one mask in one common basis. +At S=-1 the corresponding derivative is -B_i^(-1)P_i B_i. Equality with +the Gaussian endpoint therefore gives [P_i,B_i]=0. These are necessary +conditions, not extra restrictions introduced for the search. They are +also sufficient for the formal endpoint once the masks and query tuple +are fixed. + +## 2. At most two rank-two full stages, in every even dimension n>=4 + +Any ordered four-site principal Gram matrix has determinant one. Hence +any three query columns are independent, and so are their three rows. +The principal three-site Gram matrix is singular, with rank two. + +Commuting idempotents have a common diagonal basis over the original +field: repeatedly split the space into each image and kernel. Suppose +three full projectors have rank two. Their supports are three two-element +sets. Any two supports intersect because each off-diagonal Gram entry +is nonzero. + +If their union has at most three coordinates, independence of the three +columns and rows makes their Gram matrix invertible. This contradicts +the preceding rank-two Gram calculation. Otherwise the supports are +three distinct arms of a star, with one common coordinate. Every cross +pairing then passes through that coordinate. The two directed products +around the triple are equal. But in the ordered Gram normal form they are + +```text +G_ij G_jk G_ki = 1, +G_ik G_kj G_ji = -1, i= a+c-g. +``` + +On im(P), the row map C has rank c and kernel dimension r-c. The +intersection of im(A) with that kernel has dimension a-g. This proves +the inequality. It explains why column containment alone is insufficient. + +Start from A=u_i and C=v_i and close under B_i. Exact rational elimination +gives the following necessary projector ranks: + +| Site | 0 | 1 | 2 | 3 | 4 | 5 | 6 | +| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | +| Rank lower bound | 2 | 2 | 4 | 2 | 4 | 2 | 2 | + +At sites 1,3,5 the closed column and row dimensions and pairing rank are +all two. A rank-two projector there is therefore unique: +P=A(CA)^(-1)C. Closing each other site's spaces under this P as well as +its own B_j gives: + +| Fixed rank-two site | 0 | 1 | 2 | 3 | 4 | 5 | 6 | +| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | +| 1 | 2 | 2 | 4 | 4 | 6 | 4 | 4 | +| 3 | 4 | 4 | 4 | 2 | 4 | 4 | 4 | +| 5 | 4 | 4 | 6 | 4 | 4 | 2 | 2 | + +The replay reconstructs all these spaces from the canonical queries. The +tables hold for every projector, not only for bounded rational entries. + +Four full stages and at most two extra idles must have ranks 2,2,3,3. +Section 2 excludes three or more rank-two stages. The table excludes a +rank-two interior site in this configuration. Thus the rank-two sites +are 0 and 6. If these projectors are equal, they are the unique rank-two +projector that contains u_0,u_6 and v_0,v_6. The same closure test gives +interior lower bounds 4,4,6,4,4. Therefore the endpoints must be distinct. +Their common image has dimension one, since disjoint images would make +G_06 zero. + +## 4. Retain the free parameter in the endpoint basis + +Let a span the common endpoint image and normalize it by a=P_6 e_0. +Then sum(a)=1. Put r=-v_0 a, which is nonzero because v_0 u_6=-1. +There is a vector z in + +```text +K={x: x_0=0 and sum(x)=0} +``` + +such that + +```text +a=e_0+r u_6-z, +b=e_0-a=-r u_6+z, +c=e_0-z, +e_0=a+b, u_6=(a-c)/r. +``` + +In these coordinates the endpoint masks are {a,b} and {a,c}. Their +common kernel H has dimension three and lies in K. Moreover K is the +direct sum of the line through z and H. This gives the complete endpoint +chart with r free and nonzero. The earlier bounded basis search used +r=-1. Fixing that value would not prove the present classification. + +An interior rank-three stage can occur only at 1,3,5 by section 3. +Its image must intersect both endpoint supports. Its possible masks on +the first three coordinates are a, ab, ac, abc, or bc, with the remaining +rank supplied in H. The following tests exclude a, abc and bc. + +* For mask a, the vector w=e_0-r u_6=b+c is in the kernel. But + v_i w=1+r. This forces r=-1. At that value v_i B_i w=2, another + contradiction because the kernel is invariant under B_i. +* For mask abc, the image contains e_0,u_6,u_i and the row space contains + v_0,v_6,v_i. Close both under B_i. The rank lower bounds are 4,6,4 + at sites 1,3,5. None permits rank three. +* For mask bc, the image contains w,u_i and their B_i images. At site 3 + the four columns [w,u_i,B_i w,B_i u_i] have the minor -4r on rows + 0,1,3,4. It is nonzero. At sites 1 and 5 their invariant span has + dimension three for every nonzero r. Take A=[w,u_i,B_i w]. A minor + is 2r^2 at site 1 and 2 at site 5. The replay checks B_i A=A M_i(r) + as an identity in Q[r,r^-1]. It also checks v_i A equals row 0 of A. + Since b=e_0-a is in this image, v_i a=a_0=1-r. The mask kills a, + so v_i a=0 and r=1. At this exceptional value + e_0=(w-B_i w)/2 lies in the image. Thus a=e_0-b lies in the image + as well as the kernel. This contradicts sum(a)=1. + +This leaves only masks ab+h and ac+h, where h is one line in H. +Call them L and R. The exceptional value r=1 is explicitly checked; +generic elimination without that check would leave a gap. + +## 5. Only one L and one R are possible + +Write w_0=e_0+u_6. Column containment and the endpoint coordinates give +the required H lines at a rank-three site i: + +```text +L: d_i=e_i-w_0+z/r, v_i z=1, +R: d_i=e_i-w_0+z, v_i z=-r. +``` + +These lines are nonzero. The rank-one projectors on H commute. Any two +are either equal or have zero product. + +Two equal L lines give the same rank-three projector. It would contain +three query columns and rows from sites 0,i,j, which section 2 excludes +in dimension three. Equal R lines fail in the same way with site 6. +For two distinct L lines, cross pairing must vanish in both directions. +The sum of those two equations is 2/r=0, which is impossible. For two +distinct R lines the sum is -2r=0. Thus there is at most one of each type. + +An L line and an R line cannot be equal either. Apply their two query +rows to their two required H vectors. If the L site is earlier, the +determinant of this two-by-two pairing matrix is -1. If it is later, +the determinant is 3. Both are nonzero in characteristic zero. Thus the +lines are independent. Cross pairing then requires the L site to precede +the R site; the opposite order gives a forbidden entry 2. + +Consequently, the four-full, two-idle root has the masks + +```text +site 0: {a,b}, +earlier rank-three site: {a,b,h_L}, +later rank-three site: {a,c,h_R}, +site 6: {a,c}. +``` + +The two H lines are distinct and leave one unused H coordinate. This is +exactly the six output supports in the theorem. Different allowable site +locations, the free parameter r, and different scalar bases cannot change +this price pattern. + +There is an explicit positive algebraic family for every r!=0. With +w_0=e_0+u_6, set + +```text +z=(r+1)w_0-r e_1-e_5+e_2-e_3, +F=[a,b,c,e_3-e_4,d_R,d_L], +d_L=e_1-w_0+z/r, d_R=e_5-w_0+z. +``` + +Use the same four masks at sites 0,1,5,6. The replay checks a displayed +inverse of F, every projector identity, all pairwise commutators and +the prefix commutators as exact Laurent identities for all r!=0. Thus +the entire parameter family has the same endpoint and price pattern. +This supplies an algebraic positive control outside r=-1. It does not +replace the physical caller at the published source basis or certify +one uniform ordinary-cost bound over unbounded parameter values. + +The same proof excludes three rank-three interiors whenever both +endpoints have rank two. Combining this fact, section 2 and the exact +rank tables gives the following lower bounds. The replay enumerates all +site rank assignments from {thin,2,3,4,5,6}; this is a complete finite +list of rank possibilities, not a coefficient search. + +| Number of full stages | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | +| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | +| Required extra whole idles, at least | 0 | 0 | 0 | 1 | 2 | 4 | 6 | 8 | + +The existing four-full root attains its two-idle bound. The table does not +claim constructions that attain the other entries. + +## 6. Transfer of the exact price ceiling + +Let H(r)=r^(1-kappa), let L be the complete PR6353 paid-minus-helper +moment per port, and let C(n) be the minimum cost of all binary trees +with n native leaves. The separately registered composition replay uses + +```text +C(1)=0, +C(n)=min_a [C(a)+C(n-a)+2H(8n)+1-2H(8n+1)], +G(n)=max_b [H(8n+1)-nL-C(n-b)-C(b)+H(8b+1)-H(8b)]. +``` + +The complete margin for any root in the classified family is + +```text +H(8(x+y)+1)+G(x)+G(y)-2. +``` + +This includes every native target debit, every binary-node job, the +three root thin queries and both individual whole idles. The proof above +shows why the formula applies to every root in the family, not just the +displayed source basis. + +At 0.00328554, the composition replay checks 4,851 rational interval +binary splits and 4,656 root pair choices below total size 100. All fail. +For every larger size f, concavity gives the upper bound + +```text +H(8f+1)+2H(4f+1)-f(L-1)+2(H(9)-H(8))-6. +``` + +Its value and derivative at 100 are strictly negative, and its derivative +decreases. The native deficit derivative is positive through the admitted +cap 0.0034. Thus the full infinite size range is excluded. The headroom +replay authenticates that numerical receipt; the composition replay +recomputes its interval bounds. Neither substitutes a numerical optimizer +for a proof. + +## 7. The normalization is a whole-field identity at every width + +The native phase checker gives q^2=X and X^2=I, with X an ordinary binary +translation. Define + +```text +lambda=((1+i)I+(1-i)X)/2, +lambda^-1=((1-i)I+(1+i)X)/2, +S=lambda q. +``` + +Polynomial multiplication gives lambda^2=X, lambda^-1 lambda=I, +S^2=I and lambda^-1 S=q. These are identities for any operator with +the stated relations. They therefore hold at every tensor width after +the native q and the global X have been formed. Scalar coefficients stay +outside the tensor power. The proof does not infer an all-width statement +from a bounded collection of dense matrices. + +On a nonzero binary translation x -> x xor t, choose one nonzero bit of +t. The addresses with that bit zero give exactly one representative per +pair. On each pair the four operations in the root proof implement +[[a,b],[b,a]], with a=(1+i)/2 and b=(1-i)/2. Conjugating the coefficients +implements the inverse. No field is initialized or copied. The map is +unitary; each scalar operation has maximum-norm growth at most two. +Address generation and scalar operations remain in the inherited route +and ordinary-work bill. This is not a new precision-tape admission. + +There is a simple reason to keep the global rule. On two one-column +characters q=-i, the separate normalized characters are both +1. The +two-column q is -1, whose global normalized character is -1. Tensoring +the one-column normalization would therefore implement the wrong operator. + +## Verification scope + +`verify.py` uses only rational arithmetic and finite Laurent polynomials. +It rebuilds the query tuples, Gram identities, invariant image and row +spaces, free-parameter identities, exceptional case, line constraints, +rank floors and normalization identities. Its normal and optimized runs +must reproduce `RESULT.json`. The source root is a positive construction +at the lower bound. Removing the three-interior restriction lowers the +five-full bound to three, which checks that this restriction is needed. + +These are author checks and a written proof. They are not independent +human review or formal-kernel acceptance. The complete conditional kappa +still has five inherited framework assumptions. No selected-frontier +change or general impossibility statement follows. + +`caller_reverse.py` supplies an additional author implementation of the +actual 570-event caller. It propagates one output functional backward at +each of Q=1,-1,i,-i, with exact rational complex coefficients and formal +independent stage monomials. The source checker instead propagates a +matrix forward in the quotient Q^4=1. Since Q^4-1 has four distinct roots +over Q(i), the four character checks establish the full quotient-ring +identity. Every one of the 1,156 matrix entries is checked at all four +characters. Six omitted-operation controls and a nonzero off-diagonal +output are rejected. This is not independent human review and does not +replace the physical, native, price or compiler checks. + +Prepared by Ali Romman with substantial OpenAI Codex assistance. The +shortest-query normal form, native word, binary module, source contraction, +and compiler retain their source attribution. Apache-2.0. diff --git a/research/mixed-projector-root-headroom/README.md b/research/mixed-projector-root-headroom/README.md new file mode 100644 index 0000000000..8d1b76060e --- /dev/null +++ b/research/mixed-projector-root-headroom/README.md @@ -0,0 +1,105 @@ +# How far the minimum-idle mixed root can go + +With the original PR6353 source, the complete conditional result is +**kappa 0.00328551**. This companion +proves that its ceiling **0.00328554** covers every six-field, seven-query +root in the following class: all six outputs contain the central +involution, four independent forward stages act at distinct sites, +and at most two extra whole idle jobs are paid. Scalar bases are arbitrary +but independent of the central and stage variables. All positive binary +child sizes and shapes are permitted. +The native source stays fixed at PR6353. This is a new structural result, +not a further kappa increment. + +The [final source composition](../mixed-root-contact-composition/README.md) +refines the complete claim to 0.00328621476572836015146308 with the +same invoice. Its [exact raw optimum](../mixed-root-contact-composition/OPTIMALITY.md) +is less than 2e-26 above that claim. The former exclusion bound +0.00328623 is replaced by the exact raw limit. The classification itself does not depend on the +native source profile. This package retains the first source-bound price +example in its exact receipt. + +The proof also shows that at most two full projectors can have rank two +in any shortest-query root on an even number of fields at least four. +On six fields, five, six and seven full stages need at least four, six +and eight extra idle jobs, respectively. The all-width normalization +argument keeps scalar coefficients outside tensor powers. + +Read [the proof](PROOF.md) before interpreting the finite replay. Its +free endpoint parameter is retained. The source ceiling applies only +after the output pattern is classified. The separate +[complete composition](../mixed-root-source-composition/README.md) +checks the native source, full caller, price, compiler and outer ledger. + +## Replay + +Use Python 3.12 and its standard library: + +```sh +python3 -I -B research/mixed-projector-root-headroom/verify.py +python3 -I -O -B research/mixed-projector-root-headroom/verify.py +``` + +The live inputs are pinned and declared in `SOURCES.json` and +`VERIFY.json`. They are reachable ancestors of this contribution. +`RESULT.json` records the exact structural checks. The complete price +ceiling is recomputed by the separately registered composition package. +This replay authenticates that receipt and proves the larger domain to +which it applies. It does not rerun the native word. The extension prices are recomputed +with the pinned rational interval engine and final native invoice. +A separate reverse-functional engine checks all 1,156 formal caller +entries through four exact central characters and rejects seven omitted +operation or off-diagonal controls. It uses no source replay code. + +The result remains author-checked and conditional. It does not prove a +global optimum, a practical speedup, a materialized uniform algorithm, +the five framework assumptions or independent scientific acceptance. +The selected frontier stays unchanged. + +## Search beyond the proved class + +The [extension proof](EXTENSIONS.md) adds two results. A shortest-query +root with extra outputs that omit the central transform reduces to its +active fields; their additional productive price cannot exceed their paid +idles. This result requires exactly r+1 queries on r active fields. It +does not cover seven queries on four active fields. Also, every rank-four +fifth-stage extension that retains the two +rank-two endpoints and two rank-three stages loses for all positive binary +child sizes and shapes. All seven possible masks are covered. The proof +uses integer dynamic programming below total 100 and a concave bound for +the unbounded tail. It is replayed for both the old PR6353 profile and the +final PR6375 profile. + +This exact result supersedes the earlier seven time-limited integer runs. +Their original SEARCH.json is preserved as discovery history, not as the +proof. The optional search_next_cost.py still reproduces that old model; +its NumPy and SciPy dependencies are not needed by registered replay. + +The [boundary module proof](BOUNDARY-MODULES.md) records the exact +three-field helper-consuming module and five-call reflection border. +Their replays need only the standard library. Both the helper module and +the border with its two direct corrections lose for every binary child +size and shape. The uncorrected border has a favorable formal limit +price, but two nonzero endpoint errors remain. Its precision and recovery +obligations are explicit. It is not another kappa improvement. + +The wider bounded searches in the +[source search note](../mixed-projector-query-root/SEARCH.md) also remain +bounded evidence. The proof here does not convert their failures into +a global ceiling. No new positive candidate was withheld from the claim. + +## Open next questions + +- Independently review the endpoint parameter, the r=1 exceptional case, + the rank-three line classification and the transfer to the price ceiling. +- Test five-full roots with only one rank-two projector, or a different + field count. The exact seven-mask exclusion does not cover them. +- Develop a complete recovery and precision construction for the border. + Both direct corrections lose; a different method remains open. +- Change the query count, child contract or native source. Each change + needs an exact arbitrary-input endpoint and a complete new invoice. +- Extend the structural argument to other field counts or coupled queries. + The six-field rank table is not a theorem for those models. + +New proof and code: Ali Romman with substantial OpenAI Codex assistance; +no subagents. Apache-2.0. See `NOTICE` for predecessor credit. diff --git a/research/mixed-projector-root-headroom/RESULT.json b/research/mixed-projector-root-headroom/RESULT.json new file mode 100644 index 0000000000..1a889970ab --- /dev/null +++ b/research/mixed-projector-root-headroom/RESULT.json @@ -0,0 +1,567 @@ +{ + "status": "PASS_MIXED_ROOT_MINIMUM_IDLE_CLASSIFICATION", + "structure": { + "rank_two_support_cases": { + "small_union": 34, + "star": 4 + }, + "single_site_rank_data": [ + [ + 1, + 1, + 0, + 2 + ], + [ + 2, + 2, + 2, + 2 + ], + [ + 2, + 2, + 0, + 4 + ], + [ + 2, + 2, + 2, + 2 + ], + [ + 2, + 2, + 0, + 4 + ], + [ + 2, + 2, + 2, + 2 + ], + [ + 1, + 1, + 0, + 2 + ] + ], + "interior_rank_two_forces": { + "1": [ + 2, + 2, + 4, + 4, + 6, + 4, + 4 + ], + "3": [ + 4, + 4, + 4, + 2, + 4, + 4, + 4 + ], + "5": [ + 4, + 4, + 6, + 4, + 4, + 2, + 2 + ] + }, + "coincident_endpoint_rank_lower": [ + 2, + 4, + 4, + 6, + 4, + 4, + 2 + ], + "rank_three_mask_checks": [ + { + "site": 1, + "bc_rejection": "r=1, then a lies in both image and kernel", + "abc_rank_lower": 4 + }, + { + "site": 3, + "bc_rejection": "minor -4r", + "abc_rank_lower": 6 + }, + { + "site": 5, + "bc_rejection": "r=1, then a lies in both image and kernel", + "abc_rank_lower": 4 + } + ], + "shared_LR_line_determinants": [ + -1, + 3 + ], + "idle_lower_by_full_count": [ + 0, + 0, + 0, + 1, + 2, + 4, + 6, + 8 + ], + "positive_family": "An explicit invertible root for every nonzero r, with sites 0,1,5,6 and the classified masks.", + "parameter_ring": "Q[r,r^-1]; r is not fixed to -1", + "scope": "Shortest rank-one square-zero queries; every output contains S; scalar bases independent of S and the independent forward stage variables; characteristic zero for the six-field classification." + }, + "normalization": { + "formal_identity": "lambda^2=X, S^2=I, lambda^-1*S=q whenever q^2=X and X^2=I", + "characters": 4, + "translation_pairs_checked": 2667, + "tensor_of_one_column_normalizers_rejected": true, + "scope": "The polynomial identity proves all widths; the address enumeration is a finite control." + }, + "central_free_extension": { + "coupled_examples": [ + { + "active_fields": 2, + "inactive_fields": 1, + "query_count": 3, + "ranks_U_V": [ + 2, + 3 + ] + }, + { + "active_fields": 2, + "inactive_fields": 3, + "query_count": 3, + "ranks_U_V": [ + 2, + 3 + ] + }, + { + "active_fields": 4, + "inactive_fields": 1, + "query_count": 5, + "ranks_U_V": [ + 4, + 5 + ] + }, + { + "active_fields": 4, + "inactive_fields": 3, + "query_count": 5, + "ranks_U_V": [ + 4, + 5 + ] + }, + { + "active_fields": 6, + "inactive_fields": 1, + "query_count": 7, + "ranks_U_V": [ + 6, + 7 + ] + }, + { + "active_fields": 6, + "inactive_fields": 3, + "query_count": 7, + "ranks_U_V": [ + 6, + 7 + ] + }, + { + "active_fields": 8, + "inactive_fields": 1, + "query_count": 9, + "ranks_U_V": [ + 8, + 9 + ] + }, + { + "active_fields": 8, + "inactive_fields": 3, + "query_count": 9, + "ranks_U_V": [ + 8, + 9 + ] + } + ], + "dual_examples": 8, + "claim": "r+1 square-zero queries with endpoint diag(-I_r,+I_s) reduce to an r-field shortest tuple; extra central-free outputs have no positive signed price.", + "scope": "The rank proof and tariff argument in EXTENSIONS.md are quantified. These exact examples are controls, not the universal proof." + }, + "rank_four_extension_price": { + "saving": "164277/50000000", + "integer_grid": 1099511627776, + "tail_start": 100, + "finite": [ + { + "mask": 39, + "finite_margin_upper": "-71975364453/1099511627776", + "maximizing_upper_bound_children": [ + 4, + 4, + 4, + 4, + 1 + ], + "pair_total_checks": 147440, + "direct_small_tuple_controls": 252 + }, + { + "mask": 43, + "finite_margin_upper": "-23742046189/1099511627776", + "maximizing_upper_bound_children": [ + 7, + 7, + 1, + 2, + 1 + ], + "pair_total_checks": 147440, + "direct_small_tuple_controls": 252 + }, + { + "mask": 45, + "finite_margin_upper": "-22358867141/1099511627776", + "maximizing_upper_bound_children": [ + 8, + 4, + 1, + 4, + 1 + ], + "pair_total_checks": 147440, + "direct_small_tuple_controls": 252 + }, + { + "mask": 46, + "finite_margin_upper": "-1022010163/274877906944", + "maximizing_upper_bound_children": [ + 6, + 4, + 1, + 4, + 4 + ], + "pair_total_checks": 147440, + "direct_small_tuple_controls": 252 + }, + { + "mask": 51, + "finite_margin_upper": "-22358867141/1099511627776", + "maximizing_upper_bound_children": [ + 4, + 8, + 4, + 1, + 1 + ], + "pair_total_checks": 147440, + "direct_small_tuple_controls": 252 + }, + { + "mask": 53, + "finite_margin_upper": "-23742046189/1099511627776", + "maximizing_upper_bound_children": [ + 7, + 7, + 2, + 1, + 1 + ], + "pair_total_checks": 147440, + "direct_small_tuple_controls": 252 + }, + { + "mask": 54, + "finite_margin_upper": "-1022010163/274877906944", + "maximizing_upper_bound_children": [ + 4, + 6, + 4, + 1, + 4 + ], + "pair_total_checks": 147440, + "direct_small_tuple_controls": 252 + } + ], + "tail_upper": [ + "-324954806678705699100822048081314818741465240413198002428639/163204645120053699859730525003399326818661241556064897335296", + "-310408283364938930223984816297491362859941248112919692548223/163204645120053699859730525003399326818661241556064897335296", + "-261173963815445499538663765993358631374561995559361465354591/163204645120053699859730525003399326818661241556064897335296" + ], + "tail_derivative_upper": [ + "-218620581957907649166633190548982949571567552854086201983799974313903/3676694645845209757152491733592205459486652782430224515281715200000000", + "-1212374402678709925753322157077533054142098874263059860209298677722997/20477146569221237675252072016256588739640941191035000425388441600000000", + "-820384910581897619893352672361849588799138354372768740583834081987/14599165520504803620264957119444705406825556373569867769446400000000" + ], + "scope": "All positive binary child sizes and all binary tree shapes for the seven rank-four extensions of the fixed two-endpoint, two-rank-three stage support pattern. No other support family is excluded." + }, + "boundary_modules": { + "helper_module": { + "characters_and_stage_nodes": 16, + "stage_degree_per_variable": 1, + "output_masks": [ + "ABC", + "AB", + "BC" + ], + "consumed_output": "B*S Gaussian" + }, + "reflection_border": { + "characters_and_stage_nodes": 54, + "stage_Laurent_exponents_in_inverse_checks": [ + -1, + 0, + 1 + ], + "formal_parameter_ring": "Q[e,e^-1]", + "full_sites": [ + 0, + 2, + 4 + ], + "paid_reflection_sites": [ + 1, + 3 + ], + "endpoint": "S diag(ABC,A,B,C)+(1-S)(-e*C*E03+e^2*E12)", + "exact_correction_extra_queries": 2, + "rejected_controls": 2 + }, + "scope": "Exact module identities and inverse checks only. No physical caller, precision transfer or kappa gain." + }, + "latest_source_extensions": { + "source_head": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "rank_four_extension_price": { + "saving": "82155369143209003786577/25000000000000000000000000", + "integer_grid": 1099511627776, + "tail_start": 100, + "finite": [ + { + "mask": 39, + "finite_margin_upper": "-71952823681/1099511627776", + "maximizing_upper_bound_children": [ + 4, + 4, + 4, + 4, + 1 + ], + "pair_total_checks": 147440, + "direct_small_tuple_controls": 252 + }, + { + "mask": 43, + "finite_margin_upper": "-23720642479/1099511627776", + "maximizing_upper_bound_children": [ + 7, + 7, + 1, + 2, + 1 + ], + "pair_total_checks": 147440, + "direct_small_tuple_controls": 252 + }, + { + "mask": 45, + "finite_margin_upper": "-1396073983/68719476736", + "maximizing_upper_bound_children": [ + 8, + 4, + 1, + 4, + 1 + ], + "pair_total_checks": 147440, + "direct_small_tuple_controls": 252 + }, + { + "mask": 46, + "finite_margin_upper": "-1018404213/274877906944", + "maximizing_upper_bound_children": [ + 6, + 4, + 1, + 4, + 4 + ], + "pair_total_checks": 147440, + "direct_small_tuple_controls": 252 + }, + { + "mask": 51, + "finite_margin_upper": "-1396073983/68719476736", + "maximizing_upper_bound_children": [ + 4, + 8, + 4, + 1, + 1 + ], + "pair_total_checks": 147440, + "direct_small_tuple_controls": 252 + }, + { + "mask": 53, + "finite_margin_upper": "-23720642479/1099511627776", + "maximizing_upper_bound_children": [ + 7, + 7, + 2, + 1, + 1 + ], + "pair_total_checks": 147440, + "direct_small_tuple_controls": 252 + }, + { + "mask": 54, + "finite_margin_upper": "-1018404213/274877906944", + "maximizing_upper_bound_children": [ + 4, + 6, + 4, + 1, + 4 + ], + "pair_total_checks": 147440, + "direct_small_tuple_controls": 252 + } + ], + "tail_upper": [ + "-20321733313226227259430810402894591457248431136114472786817/10200290320003356241233157812712457926166327597254056083456", + "-155299136971599079717785930971125411543085094016440386073801/81602322560026849929865262501699663409330620778032448667648", + "-130677043302220187618063209378611840863966122892718534442025/81602322560026849929865262501699663409330620778032448667648" + ], + "tail_derivative_upper": [ + "-18225055454644605049111296063257789674073380519824776411369912010463388992975650914681/306391220487100813096040977799350454957221065202518709606809600000000000000000000000000", + "-1212819375728205318079045804990780748826986153312450554969763713957035914763964374429989/20477146569221237675252072016256588739640941191035000425388441600000000000000000000000000", + "-5744853586168107226579815081985771889758626785014988898328762672420219834172315800903/102194158643533625341854699836112937847778894614989074386124800000000000000000000000000" + ], + "scope": "All positive binary child sizes and all binary tree shapes for the seven rank-four extensions of the fixed two-endpoint, two-rank-three stage support pattern. No other support family is excluded." + }, + "boundary_prices": { + "saving": "82155369143209003786577/25000000000000000000000000", + "integer_grid": 1099511627776, + "tail_start": 100, + "helper_module": { + "finite_triples": 79625, + "children": [ + 8, + 1, + 8 + ], + "finite_margin_upper": "-22819734251/274877906944", + "tail_upper": "-159221856455415610343433510809296137450957025550811595366495/81602322560026849929865262501699663409330620778032448667648", + "tail_derivative_upper": "-18225055454644605049111296063257789674073380519824776411369912010463388992975650914681/306391220487100813096040977799350454957221065202518709606809600000000000000000000000000", + "scope": "All positive binary child sizes and shapes for the three-field module, with its consumed middle helper debited." + }, + "corrected_border": { + "finite_triples": 27353, + "children": [ + 7, + 8, + 8 + ], + "finite_margin_upper": "-496895116511/274877906944", + "tail_upper": "-229053687529721869045124084762990390885269443472292116387871/81602322560026849929865262501699663409330620778032448667648", + "tail_derivative_upper": "-8010110937868606017424999039790088935233316307476301849944885224593001834446164045009021/164021433367427968610747270115252276887099010238415015876178739200000000000000000000000000", + "scope": "All positive binary child sizes and shapes for the star border with both direct rank-one corrections paid. Other recovery methods are not excluded." + }, + "formal_border": { + "children": [ + 6, + 6, + 6 + ], + "raw_crossing": [ + "21036367199/6250000000000", + "67316375037/20000000000000" + ], + "one_percent_goal": "8297692283464109382444277/2500000000000000000000000000", + "margin_at_goal": [ + "32910140615335309496998768392589861444212706801285513232089/3138550867693340381917894711603833208051177722232017256448", + "32910140615335309496998768392589861444212706801285570407603/3138550867693340381917894711603833208051177722232017256448" + ], + "paid_jobs": 67150, + "productive_fields": 13652, + "paid": { + "1": 42034, + "2": 8154, + "3": 8838, + "4": 1962, + "5": 2718, + "6": 144, + "7": 162, + "8": 18, + "16": 1872, + "32": 624, + "48": 624 + }, + "targets": { + "1": 252, + "2": 144, + "3": 72, + "4": 1926, + "5": 270, + "6": 54, + "7": 162, + "8": 684, + "9": 6552, + "145": 104, + "49": 936, + "33": 624, + "17": 1872 + }, + "recovery_charges_included": false, + "is_kappa_result": false + } + } + }, + "separate_reverse_caller": { + "status": "PASS_REVERSE_CHARACTER_CALLER", + "events": 570, + "matrix_entries": 1156, + "central_characters": 4, + "formal_stage_polynomials_checked": 4624, + "endpoint_digest": "8f6ed8e5a21778bac6db50149e217a63670c0f02657dd94772ae502fcc79bbe2", + "controls": { + "missing_local": "rejected", + "missing_query": "rejected", + "missing_idle": "rejected", + "missing_idle_one": "rejected", + "missing_lambda": "rejected", + "missing_q_power": "rejected", + "off_diagonal_output": "rejected" + }, + "scope": "All formal caller coefficients. No physical native, price or compiler check is supplied by this engine." + }, + "inherited_complete_claim": "0.00328551", + "broader_family_ceiling": "0.00328554", + "ceiling_evidence": "Authenticated composition receipt and its separately registered full replay; no price engine is replaced here.", + "ceiling_scope": "Six-field seven-query roots with S on every output, constant scalar bases independent of S and all stage variables, four distinct independent forward full stages and at most two extra whole idles; all positive binary child sizes and shapes; fixed PR6353 source.", + "new_kappa_increment": false, + "selected_frontier_changed": false +} diff --git a/research/mixed-projector-root-headroom/SEARCH.json b/research/mixed-projector-root-headroom/SEARCH.json new file mode 100644 index 0000000000..2e3e6d5e16 --- /dev/null +++ b/research/mixed-projector-root-headroom/SEARCH.json @@ -0,0 +1,164 @@ +{ + "saving": 0.00328554, + "tail_start": 200, + "scope": "Floating integer solve; time limits are not exclusions. No rational dual certificate.", + "records": [ + { + "masks": [ + 3, + 5, + 11, + 21, + 39 + ], + "status": 1, + "weights": [ + 4.0, + 4.0, + 4.0, + 4.0, + 1.0 + ], + "mip_dual_bound": -2.193356703815116, + "message": "Time limit reached. (HiGHS Status 13: Time limit reached)", + "incumbent_margin_float": -0.0654602126831314, + "relaxation_margin_upper_float": 0.19335670381511605, + "time_limit_seconds": 20 + }, + { + "masks": [ + 3, + 5, + 11, + 21, + 43 + ], + "status": 1, + "weights": [ + 7.0, + 6.999999999993567, + 1.0, + 2.0, + 1.0 + ], + "mip_dual_bound": -2.3840273440340938, + "message": "Time limit reached. (HiGHS Status 13: Time limit reached)", + "incumbent_margin_float": -0.021593265203311063, + "relaxation_margin_upper_float": 0.3840273440340938, + "time_limit_seconds": 20 + }, + { + "masks": [ + 3, + 5, + 11, + 21, + 45 + ], + "status": 1, + "weights": [ + 8.0, + 4.0, + 1.0, + 4.0, + 1.0 + ], + "mip_dual_bound": -4.0903996968066565, + "message": "Time limit reached. (HiGHS Status 13: Time limit reached)", + "incumbent_margin_float": -0.02033427125925158, + "relaxation_margin_upper_float": 2.0903996968066565, + "time_limit_seconds": 20 + }, + { + "masks": [ + 3, + 5, + 11, + 21, + 46 + ], + "status": 1, + "weights": [ + 8.0, + 4.0, + 1.0, + 3.9999999999895883, + 1.0 + ], + "mip_dual_bound": -4.41680414761554, + "message": "Time limit reached. (HiGHS Status 13: Time limit reached)", + "incumbent_margin_float": -0.004718600316671484, + "relaxation_margin_upper_float": 2.41680414761554, + "time_limit_seconds": 20 + }, + { + "masks": [ + 3, + 5, + 11, + 21, + 51 + ], + "status": 1, + "weights": [ + 4.0, + 8.0, + 3.9999999999922746, + 1.0, + 1.0 + ], + "mip_dual_bound": -4.0903996968066565, + "message": "Time limit reached. (HiGHS Status 13: Time limit reached)", + "incumbent_margin_float": -0.020335271174246827, + "relaxation_margin_upper_float": 2.0903996968066565, + "time_limit_seconds": 20 + }, + { + "masks": [ + 3, + 5, + 11, + 21, + 53 + ], + "status": 1, + "weights": [ + 7.0, + 6.999999999248349, + 2.0, + 1.0, + 1.0 + ], + "mip_dual_bound": -4.12449147344805, + "message": "Time limit reached. (HiGHS Status 13: Time limit reached)", + "incumbent_margin_float": -0.02159325335263773, + "relaxation_margin_upper_float": 2.1244914734480496, + "time_limit_seconds": 20 + }, + { + "masks": [ + 3, + 5, + 11, + 21, + 54 + ], + "status": 1, + "weights": [ + 4.0, + 7.999999999988322, + 4.000000000000001, + 1.0, + 1.0 + ], + "mip_dual_bound": -4.41680414761554, + "message": "Time limit reached. (HiGHS Status 13: Time limit reached)", + "incumbent_margin_float": -0.004718600277932028, + "relaxation_margin_upper_float": 2.41680414761554, + "time_limit_seconds": 20 + } + ], + "command": "python3 -B research/mixed-projector-root-headroom/search_next_cost.py --output /tmp/mixed-root-next-cost.json", + "note": "The public script uses the same model and reads the authenticated native profile. It replaces the local import and output path. Time-limited optimizer output need not be byte-identical.", + "public_search_script_sha256": "855c19815d41403a0ed9d23bc8272f317487d1bf3ebe5d8d82942108f54aebc0" +} diff --git a/research/mixed-projector-root-headroom/SOURCES.json b/research/mixed-projector-root-headroom/SOURCES.json new file mode 100644 index 0000000000..6f39b680e9 --- /dev/null +++ b/research/mixed-projector-root-headroom/SOURCES.json @@ -0,0 +1,58 @@ +{ + "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" + }, + { + "path": "research/five-call-projector-rigidity/PROOF.md", + "usage": "provenance", + "git_blob": "04db617a97bf941fe277e834d2b2e18d6b735a22", + "sha256": "f917d2a88433e2c8a3ba48f76453a77af4cfed9cabff32ea8b60ce5abbab869c" + }, + { + "path": "research/mixed-projector-query-root/ROOT.json", + "usage": "input", + "git_blob": "b59f1ea89aca17f0a76131743c12f2c724421df8", + "sha256": "2f25684c24ae0e1d10d4f8f29430aed3cef584f82c8ae840e82be0a72baa048d", + "pin": "head:52e87e4971a85a8f098fadb967dc75bee9f76c65:research/mixed-projector-query-root/ROOT.json" + }, + { + "path": "research/mixed-root-source-composition/RESULT.json", + "usage": "input", + "git_blob": "cc266a2e5c577ec5551230286fbeeff2938eef78", + "sha256": "9e41c15bd1f4e95b899d37672002e1fcf20cbf98a00b0ae007c389f3e1752c04", + "pin": "head:24f03629fc2a939ea0c6c015017bf1cdc07e06cd:research/mixed-root-source-composition/RESULT.json" + }, + { + "path": "research/mixed-projector-query-root/CONTROLLER.json", + "usage": "input", + "git_blob": "4f7d7a2f13b13966b10c7b583d28d1bed210364c", + "sha256": "4aa7ee4e1bc4853200cf97474695054057cc354bc1778f35b6554a365aac412c", + "pin": "head:52e87e4971a85a8f098fadb967dc75bee9f76c65:research/mixed-projector-query-root/CONTROLLER.json" + }, + { + "path": "research/higher-moment-strictification/verify.py", + "usage": "input", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + { + "path": "research/mixed-root-contact-composition/RESULT.json", + "usage": "input", + "pin": "head:fc261729c664cabe376c6d630a88d3d82199b72c:research/mixed-root-contact-composition/RESULT.json", + "git_blob": "be12d2101b76b3b81f1fa1be2c73b4aaa6796899", + "sha256": "621c943f72f94b4fe168a1e1ad10edc637cfe7221690d131b33ecbda4601b53c" + } + ] +} diff --git a/research/mixed-projector-root-headroom/TASK.json b/research/mixed-projector-root-headroom/TASK.json new file mode 100644 index 0000000000..69680e73eb --- /dev/null +++ b/research/mixed-projector-root-headroom/TASK.json @@ -0,0 +1,97 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 8, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "joint-query-controller", + "question": "Can a changed query demand or caller remove real work while satisfying native chronology and restoration?", + "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" + ], + "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": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "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": "Choose an exact caller and a new demand/interface hypothesis. Read the scoped #5617/#5631/#5649/#5747 and #5720/#5745 objections before rebuilding an excluded schedule. Compare the complete matched source/consumer protocols including all retained helper outputs. For an active-mode injection, first check #5745: its canonical delivery claim repays the eight removed centre jobs. Audit that exact claim or change its channel/feedback hypothesis; do not repeat the same free-injection search. Stop if the full favorable budget fails or the required restored output is unobservable.", + "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": [ + "query demand", + "active mode", + "5720", + "5745", + "5747", + "caller" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "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": "refined", + "scope_change_reason": "After the minimum-idle ceiling, test extra central-free outputs, one charged rank-four fifth stage, consumed helper outputs and a paid-reflection border. Replace earlier bounded price screens with exact all-size bounds where possible.", + "actual_scope": "Exact minimum-idle classification, active-space reduction, all-size price exclusion of seven rank-four extensions, exact helper and border identities, and all-size helper/direct-recovery price limits. No extra kappa claim.", + "bottleneck_link": "Complex supplier; changes the full signed target and paid moment while retaining admitted BIT .0034.", + "outcome": "completed", + "evidence": "PROOF.md, EXTENSIONS.md, BOUNDARY-MODULES.md, exact replay and RESULT.json.", + "coordination": "https://github.com/CrocSwap/integer-mult-bounds/discussions/5600#discussioncomment-19209322", + "stop_rule": "Require exact rank calculations, all-parameter identities and a source-bound price reduction. Keep incomplete numerical searches separate.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance; no subagents. All checks are author checks.", + "budget_minutes": null, + "open_questions": [ + { + "question": "Can a five-full root with only one rank-two projector beat the complete price?", + "why_it_matters": "The seven-mask exclusion retains both rank-two endpoints.", + "first_step": "Find an exact compatible projector tuple and price its full signed invoice.", + "blocked_by": "No complete improved word in this class has been found." + }, + { + "question": "Does independent review confirm the free-parameter classification?", + "why_it_matters": "This extends a fixed-root ceiling to a full algebraic family.", + "first_step": "Check PROOF.md sections 3 through 6 and the exact Laurent identities.", + "blocked_by": "Independent review has not occurred." + }, + { + "question": "Can the five-call border receive an affordable complete recovery and precision transfer?", + "why_it_matters": "Its diagonal-limit price is favorable, but it is not an exact native caller.", + "first_step": "Preserve arbitrary inputs and both orientations while charging amplified coefficients, recursive precision and recovery.", + "blocked_by": "The two direct corrections lose for all binary child sizes." + } + ] +} diff --git a/research/mixed-projector-root-headroom/VERIFY.json b/research/mixed-projector-root-headroom/VERIFY.json new file mode 100644 index 0000000000..47dde16656 --- /dev/null +++ b/research/mixed-projector-root-headroom/VERIFY.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/mixed-projector-query-root/ROOT.json", + "research/mixed-root-source-composition/RESULT.json", + "research/mixed-projector-query-root/CONTROLLER.json", + "research/higher-moment-strictification/verify.py", + "research/mixed-root-contact-composition/RESULT.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact rank tables, all-parameter Laurent identities, support restrictions, idle floors, normalization and authenticated price reduction. Separate reverse caller replay through all four central characters and seven rejecting controls. Active-space reduction controls and exact all-size price exclusion for seven fifth-stage masks. Exact helper-consuming and border module identities, all-binary-size price exclusions and clearly separate formal limit price." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "The same complete structural receipt with assertions disabled. Separate reverse caller replay through all four central characters and seven rejecting controls. Active-space reduction controls and exact all-size price exclusion for seven fifth-stage masks. Exact helper-consuming and border module identities, all-binary-size price exclusions and clearly separate formal limit price." + } + ] +} diff --git a/research/mixed-projector-root-headroom/boundary_modules.py b/research/mixed-projector-root-headroom/boundary_modules.py new file mode 100644 index 0000000000..58648d360e --- /dev/null +++ b/research/mixed-projector-root-headroom/boundary_modules.py @@ -0,0 +1,107 @@ +"""Check the helper-consuming module and the five-call border exactly. + +Stage interpolation proves the stated bounded-degree identities. The +parameter e stays formal in Q[e,e^-1]; it is never rounded or sampled. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from fractions import Fraction as Q +from itertools import product + + +def run(A): + need, eye, mul, add, transpose = A.need, A.eye, A.mul, A.add, A.transpose + def diagonal(values): + return [[x if i == j else 0 for j in range(len(values))] for i, x in enumerate(values)] + def equal(a, b): + return all(x == y for row, other in zip(a, b) for x, y in zip(row, other)) + + identity = eye(3) + projectors = [[[1, 1, 1], [0, 1, 0], [0, -1, 0]], identity, + [[0, -1, -1], [1, 2, 1], [-1, -1, 0]]] + columns = [[[1], [0], [0]], [[0], [1], [0]], [[-1], [1], [0]]] + rows = [[[0, -1, 0]], [[1, 0, 0]], [[1, 1, 0]]] + queries = [mul(u, v) for u, v in zip(columns, rows)] + selectors = [diagonal([0, 0, 0]), diagonal([0, 0, 1]), diagonal([0, 0, 0])] + basis = [[0, 1, -1], [-1, -1, 0], [1, 1, 1]] + basis_inverse = A.inverse(basis) + for i, p in enumerate(projectors): + need(mul(p, p) == p and mul(p, queries[i]) == queries[i] + and mul(queries[i], p) == queries[i], 'Helper module query and stage support') + need(mul(p, selectors[i]) == selectors[i] and mul(selectors[i], p) == selectors[i] + and mul(queries[i], selectors[i]) == diagonal([0, 0, 0]) + and mul(selectors[i], queries[i]) == diagonal([0, 0, 0]), 'Disjoint consumed Gaussian selector') + need(all(mul(p, q) == mul(q, p) for q in projectors), 'Helper stage projectors commute') + helper_checks = 0 + for a, b, c in product((1, 2), repeat=3): + target = diagonal([a*b*c, a*b, b*c]) + for sign in (1, -1): + word = eye(3) + for i, stage in enumerate((a, b, c)): + query = add(identity, add(queries[i], selectors[i]), sign-1) + word = mul(mul(add(identity, projectors[i], stage-1), query), word) + need(mul(mul(basis_inverse, word), basis) == [[sign*x for x in row] for row in target], + 'Every coefficient of the multilinear helper endpoint') + helper_checks += 1 + + identity = eye(4) + e, ei = A.Laurent({1: 1}), A.Laurent({-1: 1}) + u = [[[1], [0], [0], [0]], [[-ei], [1], [0], [0]], + [[-e], [0], [1], [0]], [[-e], [0], [1], [-1]], [[1], [0], [0], [ei]]] + v = [[[0, ei, 0, 0]], [[0, 1, -e*e, 0]], [[-ei, 0, -1, 0]], + [[-ei, 0, 0, 0]], [[-1, 0, 0, e]]] + matrices = [mul(x, y) for x, y in zip(u, v)] + masks = [diagonal([1, 1, 0, 0]), diagonal([1, 0, 1, 0]), diagonal([1, 0, 0, 1])] + wrapper, wrapper_inverse = diagonal([e, 1, e*e, e*e]), diagonal([ei, 1, ei*ei, ei*ei]) + for i, matrix in enumerate(matrices): + need(equal(mul(v[i], u[i]), [[i % 2]]), 'Nilpotent full query or rank-one central reflection') + at_one = [[sum(x.terms.values()) if isinstance(x, A.Laurent) else x for x in row] for row in matrix] + need(equal(matrix, mul(mul(wrapper_inverse, at_one), wrapper)), 'One global scalar wrapper') + if i % 2 == 0: + p = masks[i//2] + need(equal(mul(p, matrix), matrix) and equal(mul(matrix, p), matrix), 'Border query support') + + def word(sign, stages, correct=False, factors=matrices): + out = eye(4) + for i, matrix in enumerate(factors): + out = mul(add(identity, matrix, sign-1), out) + if i % 2 == 0: + out = mul(add(identity, masks[i//2], stages[i//2]-1), out) + if correct and i == 1: + correction = eye(4) + correction[1][2] = e*e*(sign-1) + out = mul(correction, out) + if correct: + correction = eye(4) + correction[0][3] = e*(sign-1) + out = mul(correction, out) + return out + + border_checks = 0 + for stages in product((1, 2, 3), repeat=3): + a, b, c = stages + target = diagonal([a*b*c, a, b, c]) + inverse = diagonal([Q(1, a*b*c), Q(1, a), Q(1, b), Q(1, c)]) + for sign in (1, -1): + error = diagonal([0, 0, 0, 0]) + error[0][3], error[1][2] = -(1-sign)*c*e, (1-sign)*e*e + out = word(sign, stages) + signed = [[sign*x for x in row] for row in target] + need(equal(out, add(signed, error)), 'All forward Laurent coefficients') + reverse = add([[sign*x for x in row] for row in inverse], mul(mul(inverse, error), inverse), -1) + need(equal(mul(out, reverse), identity) and equal(mul(reverse, out), identity), 'Both inverse endpoint identities') + need(equal(mul(mul(error, inverse), error), diagonal([0, 0, 0, 0])), 'The two error paths do not compose') + need(equal(word(sign, stages, True), signed), 'Two paid corrections restore the exact endpoint') + border_checks += 1 + bad = list(matrices) + bad[1] = mul(u[1], [[0, 1, 0, 0]]) + need(not equal(word(-1, (1, 2, 3), factors=bad), word(-1, (1, 2, 3))), 'Missing input correction rejected') + need(not equal(word(-1, (1, 1, 1)), [[-x for x in row] for row in identity]), 'The border is not an exact caller') + return {'helper_module': {'characters_and_stage_nodes': helper_checks, 'stage_degree_per_variable': 1, + 'output_masks': ['ABC', 'AB', 'BC'], 'consumed_output': 'B*S Gaussian'}, + 'reflection_border': {'characters_and_stage_nodes': border_checks, + 'stage_Laurent_exponents_in_inverse_checks': [-1, 0, 1], + 'formal_parameter_ring': 'Q[e,e^-1]', 'full_sites': [0, 2, 4], + 'paid_reflection_sites': [1, 3], + 'endpoint': 'S diag(ABC,A,B,C)+(1-S)(-e*C*E03+e^2*E12)', + 'exact_correction_extra_queries': 2, 'rejected_controls': 2}, + 'scope': 'Exact module identities and inverse checks only. No physical caller, precision transfer or kappa gain.'} diff --git a/research/mixed-projector-root-headroom/boundary_prices.py b/research/mixed-projector-root-headroom/boundary_prices.py new file mode 100644 index 0000000000..b861a5a276 --- /dev/null +++ b/research/mixed-projector-root-headroom/boundary_prices.py @@ -0,0 +1,90 @@ +"""Price two boundary extensions with every helper and idle charged. + +The helper module and the directly corrected border lose for all binary +child sizes. The uncorrected border price is not a kappa result. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q + + +def run(local, E, saving): + def need(ok, message): + if not ok: + raise ValueError(message) + tail, grid, t = 100, 2**40, 1-saving + paid = {int(r): c for r, c in local['paid'].items()} + helpers = {int(r): c for r, c in local['helpers'].items()} + native = (E.moment(paid, t)[0]-E.moment(helpers, t)[1])/104 + down = lambda x: (x*grid).__floor__() + up = lambda x: -(-x*grid).__floor__() + H = lambda r: E.power(r, t) + high = [grid]+[up(H(8*n+1)[1]) for n in range(1, tail)] + low = [grid]+[down(H(8*n+1)[0]) for n in range(1, tail)] + idle = [0]+[down(H(8*n)[0]) for n in range(1, tail)] + costs = [0]*tail + for n in range(2, tail): + node = 2*idle[n]+grid-2*high[n] + costs[n] = min(costs[a]+costs[n-a]+node for a in range(1, n)) + deficit = down(native) + helper_best = corrected_best = None + helper_count = corrected_count = 0 + for n in range(3, tail): + for b in range(1, n-1): + for a in range(1, (n-b)//2+1): + c = n-a-b + value = high[n]+high[a+b]+high[b+c]-low[b]-n*deficit-costs[a]-costs[b]-costs[c] + helper_count += 1 + if helper_best is None or value > helper_best: + helper_best, helper_children = value, [a, b, c] + for a in range(1, n//3+1): + for b in range(a, (n-a)//2+1): + c = n-a-b + value = high[n]+high[a]+high[b]+high[c]-n*deficit-costs[a]-costs[b]-costs[c]-4*grid + corrected_count += 1 + if corrected_best is None or value > corrected_best: + corrected_best, corrected_children = value, [a, b, c] + need(helper_best < 0 and corrected_best < 0, 'Every finite triple loses with all required charges') + n = tail + helper_tail = H(8*n+1)[1]+2*H(4*n+5)[1]-H(9)[0]-n*(native-1)-3 + helper_slope = 8*t*(H(8*n+1)[1]/(8*n+1)+H(4*n+5)[1]/(4*n+5))-(native-1) + third = E.divide(H(8*n+3), H(3))[1] + corrected_tail = H(8*n+1)[1]+3*third-n*(native-1)-7 + corrected_slope = 8*t*(H(8*n+1)[1]/(8*n+1)+third/Q(8*n+3, 3))-(native-1) + need(max(helper_tail, helper_slope, corrected_tail, corrected_slope) < 0, + 'Both all-size tails are negative and decreasing') + + # This is the diagonal limit of a fixed [6,6,6] border, not its finite word. + targets = Counter({r: 18*c for r, c in helpers.items()}) + invoice = Counter({r: 18*c for r, c in paid.items()}) + targets.update({145: 104, 49: 936, 33: 624, 17: 1872}) + invoice.update({1: 1768, 16: 1872, 32: 624, 48: 624}) + def margin(k): + a, b = E.moment(targets, 1-k), E.moment(invoice, 1-k) + return a[0]-b[1], a[1]-b[0] + lower, upper, denominator = 0, 10**12, 10**14 + while upper-lower > 1: + mid = (lower+upper)//2 + if margin(Q(mid, denominator))[0] > 0: + lower = mid + else: + upper = mid + bracket = [Q(lower, denominator), Q(upper, denominator)] + need(margin(bracket[0])[0] > 0 and margin(bracket[1])[1] < 0, 'Strict formal invoice crossing enclosure') + goal = Q(101, 100)*saving + need(margin(goal)[0] > 0, 'The uncorrected formal price exceeds the one-percent goal') + return {'saving': str(saving), 'integer_grid': grid, 'tail_start': tail, + 'helper_module': {'finite_triples': helper_count, 'children': helper_children, + 'finite_margin_upper': str(Q(helper_best, grid)), + 'tail_upper': str(helper_tail), 'tail_derivative_upper': str(helper_slope), + 'scope': 'All positive binary child sizes and shapes for the three-field module, with its consumed middle helper debited.'}, + 'corrected_border': {'finite_triples': corrected_count, 'children': corrected_children, + 'finite_margin_upper': str(Q(corrected_best, grid)), + 'tail_upper': str(corrected_tail), 'tail_derivative_upper': str(corrected_slope), + 'scope': 'All positive binary child sizes and shapes for the star border with both direct rank-one corrections paid. Other recovery methods are not excluded.'}, + 'formal_border': {'children': [6, 6, 6], 'raw_crossing': list(map(str, bracket)), + 'one_percent_goal': str(goal), 'margin_at_goal': list(map(str, margin(goal))), + 'paid_jobs': sum(invoice.values()), 'productive_fields': sum(targets.values()), + 'paid': {str(r): c for r, c in invoice.items()}, + 'targets': {str(r): c for r, c in targets.items()}, + 'recovery_charges_included': False, 'is_kappa_result': False}} diff --git a/research/mixed-projector-root-headroom/caller_reverse.py b/research/mixed-projector-root-headroom/caller_reverse.py new file mode 100644 index 0000000000..be84e58dc5 --- /dev/null +++ b/research/mixed-projector-root-headroom/caller_reverse.py @@ -0,0 +1,133 @@ +"""Check the 570-event caller by reverse output functionals. + +The source engine propagates a matrix forward in Q(i)[Q,D]/(Q^4-1). +This engine uses four exact Q characters and separate reverse rows. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha256 +import json + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def add(a, b): + return a[0]+b[0], a[1]+b[1] + + +def multiply(a, b): + return a[0]*b[0]-a[1]*b[1], a[0]*b[1]+a[1]*b[0] + + +def power(q, exponent): + out = (Q(1), Q(0)) + for _ in range(exponent % 4): + out = multiply(out, q) + return out + + +def accumulate(dst, src, coefficient=(Q(1), Q(0))): + for monomial, value in src.items(): + value = add(dst.get(monomial, (Q(0), Q(0))), multiply(coefficient, value)) + if value == (0, 0): + dst.pop(monomial, None) + else: + dst[monomial] = value + + +def scaled(poly, coefficient): + return {monomial: multiply(value, coefficient) for monomial, value in poly.items()} + + +def stages(poly, selected, count): + need(len(selected) == len(set(selected)) and all(1 <= x <= count for x in selected), + 'Every formal stage is distinct and within the declared range') + delta = tuple(int(i in selected) for i in range(1, count+1)) + return {tuple(x+y for x, y in zip(monomial, delta)): value for monomial, value in poly.items()} + + +def check(word): + n, count = word['roles'], word['stages'] + need(sorted(e[1] for e in word['events'] if e[0] == 'LOCAL') == list(range(1, count+1)), + 'Every native stage occurs exactly once') + digest = sha256() + for character in ((1, 0), (-1, 0), (0, 1), (0, -1)): + q = tuple(Q(x) for x in character) + for output in range(n): + row = [{} for _ in range(n)] + row[output][(0,)*count] = (Q(1), Q(0)) + for event in reversed(word['events']): + op = event[0] + if op == 'ADD': + _, dst, src, coefficient = event + accumulate(row[src], row[dst], (Q(coefficient), Q(0))) + elif op == 'SCALE': + _, dst, coefficient = event + row[dst] = scaled(row[dst], (Q(coefficient), Q(0))) + elif op == 'SWAP': + _, a, b = event + row[a], row[b] = row[b], row[a] + elif op == 'LOCAL': + _, stage, src, dst = event + row[src] = stages(row[src], [stage], count) + row[dst] = stages(row[dst], [stage], count) + accumulate(row[src], row[dst], power(q, -1)) + elif op == 'QUERY': + _, dst, src, exponent = event + accumulate(row[src], row[dst], power(q, exponent)) + elif op == 'Q_POWER': + _, role, exponent = event + need(exponent in (-2, 2), 'An ordinary translation uses an even central power') + row[role] = scaled(row[role], power(q, exponent)) + elif op == 'LAMBDA': + _, role, sign = event + need(sign in (-1, 1), 'The normalizer sign is specified') + a = (Q(1, 2), Q(sign, 2)) + b = (Q(1, 2), Q(-sign, 2)) + row[role] = scaled(row[role], add(a, multiply(b, power(q, 2)))) + elif op == 'IDLE': + _, a, b, selected = event + row[a], row[b] = stages(row[a], selected, count), stages(row[b], selected, count) + elif op == 'IDLE_ONE': + _, role, selected = event + row[role] = stages(row[role], selected, count) + else: + raise ValueError('Unknown caller operation: '+op) + diagonal = word['diagonal'][output] + need(len(diagonal) == count+2 and diagonal[1] == 0, 'The unused stage-zero exponent is zero') + expected = [{} for _ in range(n)] + expected[output] = {tuple(diagonal[2:]): power(q, diagonal[0])} + need(row == expected, 'Complete reverse-functional endpoint, character '+str(character)+', output '+str(output)) + digest.update(json.dumps([character, output, diagonal], separators=(',', ':')).encode()) + return digest.hexdigest() + + +def run(word): + digest = check(word) + controls = {} + for op in ('LOCAL', 'QUERY', 'IDLE', 'IDLE_ONE', 'LAMBDA', 'Q_POWER'): + bad = deepcopy(word) + del bad['events'][next(i for i, event in enumerate(bad['events']) if event[0] == op)] + try: + check(bad) + except ValueError: + controls['missing_'+op.lower()] = 'rejected' + else: + raise ValueError('The reverse engine accepted an omitted '+op) + bad = deepcopy(word) + bad['events'].append(['ADD', 0, 1, '1']) + try: + check(bad) + except ValueError: + controls['off_diagonal_output'] = 'rejected' + else: + raise ValueError('The reverse engine accepted an off-diagonal output') + return {'status': 'PASS_REVERSE_CHARACTER_CALLER', 'events': len(word['events']), + 'matrix_entries': word['roles']**2, 'central_characters': 4, + 'formal_stage_polynomials_checked': 4*word['roles']**2, + 'endpoint_digest': digest, 'controls': controls, + 'scope': 'All formal caller coefficients. No physical native, price or compiler check is supplied by this engine.'} diff --git a/research/mixed-projector-root-headroom/next_cost_ceiling.py b/research/mixed-projector-root-headroom/next_cost_ceiling.py new file mode 100644 index 0000000000..5e78e9de9c --- /dev/null +++ b/research/mixed-projector-root-headroom/next_cost_ceiling.py @@ -0,0 +1,111 @@ +"""Bound the seven rank-four extensions of the classified mixed root. + +All arithmetic is rational or integer. Integer table entries are outward +bounds, not rounded observations. The interval engine is by zxv. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from fractions import Fraction as Q +from functools import reduce +from itertools import combinations, product + +TAIL = 100 +GRID = 2**40 + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def admissible(masks): + if any(not a & b for a, b in combinations(masks, 2)): + return False + for a, b, c in combinations(masks, 3): + if (a | b | c).bit_count() < 4: + return False + if a & b == a & c == b & c and (a & b).bit_count() == 1: + return False + return all(reduce(int.__or__, group).bit_count() >= 6 + for group in combinations(masks, 5)) + + +def run(local, E, saving): + t = 1-saving + paid = {int(r): c for r, c in local['paid'].items()} + helpers = {int(r): c for r, c in local['helpers'].items()} + native = (E.moment(paid, t)[0]-E.moment(helpers, t)[1])/104 + # Floor lower bounds and ceil upper bounds. Python integers do not overflow. + def down(x): + return (x*GRID).__floor__() + def up(x): + return -(-x*GRID).__floor__() + powers = {r: E.power(r, t) for r in range(1, 8*TAIL+2)} + h = [GRID]+[up(powers[8*n+1][1]) for n in range(1, TAIL)] + idle = [0]+[down(powers[8*n][0]) for n in range(1, TAIL)] + deficit = down(native) + costs = [0]*TAIL + for n in range(2, TAIL): + node = 2*idle[n]+GRID-2*h[n] + costs[n] = min(costs[a]+costs[n-a]+node for a in range(1, n)) + masks = [extra for extra in range(64) if extra.bit_count() == 4 + and admissible([3, 5, 11, 21, extra])] + need(masks == [39, 43, 45, 46, 51, 53, 54], 'Complete support inventory') + records = [] + for mask in masks: + best, witness, checks, small_best = None, None, 0, None + for e in range(1, TAIL-4): + pairs = [] + for pair_bit, single_bit in ((1, 3), (2, 4)): + table = {} + for size in range(2, TAIL-e-1): + candidates = [(h[c+((mask >> single_bit) & 1)*e]-idle[c] + -costs[c]-costs[size-c], c) for c in range(1, size)] + value, child = max(candidates) + table[size] = (h[size+((mask >> pair_bit) & 1)*e]+value, child) + pairs.append(table) + for left in range(2, TAIL-e-1): + for right in range(2, TAIL-e-left): + total = left+right+e + value = (h[left+right+(mask & 1)*e]+pairs[0][left][0]+pairs[1][right][0] + +h[e]-2*idle[e]-costs[e]-total*deficit-2*GRID) + checks += 1 + if total <= 10: + small_best = value if small_best is None else max(small_best, value) + if best is None or value > best: + c, d = pairs[0][left][1], pairs[1][right][1] + best, witness = value, [left-c, right-d, c, d, e] + need(best < 0, 'Every positive child tuple below the tail loses') + brute = [] + for sizes in product(range(1, 7), repeat=5): + if sum(sizes) > 10: + continue + degrees = [sum(size*((support >> j) & 1) + for size, support in zip(sizes, (3, 5, 11, 21, mask))) + for j in range(6)] + a, b, c, d, e = sizes + brute.append(sum(h[q] for q in degrees)-sum(sizes)*deficit + -sum(costs[q] for q in sizes)-idle[c]-idle[d]-2*idle[e]-2*GRID) + need(small_best == max(brute), 'The pair recurrence equals direct five-child enumeration') + records.append({'mask': mask, 'finite_margin_upper': str(Q(best, GRID)), + 'maximizing_upper_bound_children': witness, 'pair_total_checks': checks, + 'direct_small_tuple_controls': len(brute)}) + + # Each binary node is at least -1. Concavity gives the three tail + # bounds in EXTENSIONS.md; each has a negative and decreasing derivative. + H = lambda r: E.power(r, t) + inc = H(9)[1]-H(8)[0] + single = H(17)[1]-2*H(8)[0]+2*inc + n = TAIL + tail39 = H(8*n+1)[1]+2*H(4*n+5)[1]-H(8)[0]+3*inc-n*(native-1)-7 + tail43 = H(8*n+1)[1]+2*H(4*n+1)[1]+single-n*(native-1)-7 + rational_h = E.divide(H(16*n+3), H(3))[1] + tail46 = 3*rational_h+single-n*(native-1)-7 + slope39 = 8*t*(H(8*n+1)[1]/(8*n+1)+H(4*n+5)[1]/(4*n+5))-(native-1) + slope43 = 8*t*(H(8*n+1)[1]/(8*n+1)+H(4*n+1)[1]/(4*n+1))-(native-1) + slope46 = 16*t*rational_h/Q(16*n+3, 3)-(native-1) + need(max(tail39, tail43, tail46, slope39, slope43, slope46) < 0, + 'The three concave tails are negative and decreasing') + return {'saving': str(saving), 'integer_grid': GRID, 'tail_start': TAIL, + 'finite': records, 'tail_upper': list(map(str, (tail39, tail43, tail46))), + 'tail_derivative_upper': list(map(str, (slope39, slope43, slope46))), + 'scope': 'All positive binary child sizes and all binary tree shapes for the seven rank-four extensions of the fixed two-endpoint, two-rank-three stage support pattern. No other support family is excluded.'} diff --git a/research/mixed-projector-root-headroom/search_next_cost.py b/research/mixed-projector-root-headroom/search_next_cost.py new file mode 100644 index 0000000000..ce969b109d --- /dev/null +++ b/research/mixed-projector-root-headroom/search_next_cost.py @@ -0,0 +1,76 @@ +"""Screen the next root cost level with a bounded integer search. + +All prices and solver bounds here are floating discovery evidence. +The registered exact proof does not execute this optional search. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +import json +from pathlib import Path +import numpy as np +from scipy.optimize import Bounds, LinearConstraint, milp +from scipy.sparse import csr_matrix, vstack +from functools import reduce +from itertools import combinations +import argparse + +from verify import read_inputs + +def admissible(masks): + if any(not a & b for a,b in combinations(masks,2)): + return False + for a,b,c in combinations(masks,3): + if (a|b|c).bit_count()<4: + return False + if a&b == a&c == b&c and (a&b).bit_count()==1: + return False + return all(reduce(int.__or__, group).bit_count()>=6 for group in combinations(masks,5)) + +parser=argparse.ArgumentParser(description=__doc__) +parser.add_argument('--output',type=Path,required=True) +args=parser.parse_args() +local=read_inputs()['research/mixed-root-source-composition/RESULT.json']['local'] +PAID={int(r):n for r,n in local['paid'].items()} +HELPERS={int(r):n for r,n in local['helpers'].items()} + +K=.00328554 +T=1-K +BOUND=200 +sizes=np.arange(1,BOUND) +cost=np.zeros(BOUND) +for n in range(2,BOUND): + cost[n]=min(cost[a]+cost[n-a] for a in range(1,n))+2*(8*n)**T+1-2*(8*n+1)**T +deficit=(sum(c*r**T for r,c in PAID.items())-sum(c*r**T for r,c in HELPERS.items()))/104 +rows=[] +for extra in range(64): + masks=[3,5,11,21,extra] + if extra.bit_count()!=4 or not admissible(masks):continue + support=np.array([[(mask>>j)&1 for j in range(6)] for mask in masks]) + n=len(sizes);nv=5*n+6 + objective=np.zeros(nv) + for i,mask in enumerate(masks): + objective[i*n:(i+1)*n]=sizes*deficit+cost[1:]+(mask.bit_count()-2)*(8*sizes)**T + objective[-6:]=-1 + equality=np.zeros((5,nv)) + for i in range(5):equality[i,i*n:(i+1)*n]=1 + constraints=[];bounds=[] + total=np.zeros((1,nv));total[0,:5*n]=np.tile(sizes,5) + constraints.append(csr_matrix(total));bounds.append(BOUND-1) + grid=np.arange(BOUND) + slopes=8*T*(1+8*grid)**(-K) + intercepts=(1+8*grid)**T-slopes*grid + for j in range(6): + degree=np.zeros(nv) + for i in range(5):degree[i*n:(i+1)*n]=support[i,j]*sizes + tangents=-slopes[:,None]*degree[None,:] + tangents[:,5*n+j]=1 + constraints.append(csr_matrix(tangents));bounds.extend(intercepts) + result=milp(objective,integrality=np.r_[np.ones(5*n),np.zeros(6)],bounds=Bounds(np.zeros(nv),np.full(nv,np.inf)), + constraints=[LinearConstraint(vstack(constraints,format='csc'),np.full(len(bounds),-np.inf),np.array(bounds)), + LinearConstraint(csr_matrix(equality),np.ones(5),np.ones(5))], + options={'time_limit':20.,'mip_rel_gap':1e-9}) + record={'masks':masks,'status':result.status,'incumbent_margin_float':-result.fun-2, + 'weights':(result.x[:5*n].reshape(5,n)@sizes).tolist(), + 'mip_dual_bound':result.mip_dual_bound,'message':result.message} + rows.append(record) + print('MASK',extra,record['incumbent_margin_float'],record['weights'],flush=True) +args.output.write_text(json.dumps({'saving':K,'tail_start':BOUND,'scope':'Floating integer solve; time limits are not exclusions. No rational dual certificate.','records':rows},indent=2)+'\n') diff --git a/research/mixed-projector-root-headroom/verify.py b/research/mixed-projector-root-headroom/verify.py new file mode 100644 index 0000000000..6f6d7c0772 --- /dev/null +++ b/research/mixed-projector-root-headroom/verify.py @@ -0,0 +1,436 @@ +"""Check the exact linear algebra used in the mixed-root headroom proof. + +The written proof supplies the quantified arguments. This replay checks +their finite matrices and identities, with no numerical search inputs. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from fractions import Fraction as Q +from hashlib import sha256 +from itertools import combinations, combinations_with_replacement, permutations, product +from pathlib import Path +import json +import importlib.util +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +class Laurent: + """A finite rational Laurent polynomial in the endpoint parameter r.""" + def __init__(self, terms): + self.terms = {k: Q(v) for k, v in terms.items() if v} + + @staticmethod + def cast(value): + return value if isinstance(value, Laurent) else Laurent({0: value}) + + def __add__(self, other): + out = dict(self.terms) + for k, v in self.cast(other).terms.items(): + out[k] = out.get(k, 0)+v + return Laurent(out) + + __radd__ = __add__ + + def __neg__(self): + return Laurent({k: -v for k, v in self.terms.items()}) + + def __sub__(self, other): + return self+-self.cast(other) + + def __rsub__(self, other): + return self.cast(other)+-self + + def __mul__(self, other): + out = {} + for a, x in self.terms.items(): + for b, y in self.cast(other).terms.items(): + out[a+b] = out.get(a+b, 0)+x*y + return Laurent(out) + + __rmul__ = __mul__ + + def __eq__(self, other): + return self.terms == self.cast(other).terms + + +def eye(n): + return [[Q(i == j) for j in range(n)] for i in range(n)] + + +def transpose(a): + return [list(row) for row in zip(*a)] + + +def mul(a, b): + return [[sum(x*y for x, y in zip(row, col)) for col in zip(*b)] for row in a] + + +def add(a, b, factor=1): + return [[x+factor*y for x, y in zip(row, other)] for row, other in zip(a, b)] + + +def hcat(*matrices): + return [sum((list(m[i]) for m in matrices), []) for i in range(len(matrices[0]))] + + +def rref(a): + out = [[Q(x) for x in row] for row in a] + pivots = [] + for col in range(len(out[0])): + pos = next((i for i in range(len(pivots), len(out)) if out[i][col]), None) + if pos is None: + continue + row = len(pivots) + out[row], out[pos] = out[pos], out[row] + scale = out[row][col] + out[row] = [x/scale for x in out[row]] + for i in range(len(out)): + if i != row: + scale = out[i][col] + out[i] = [x-scale*y for x, y in zip(out[i], out[row])] + pivots.append(col) + return out, pivots + + +def rank(a): + return len(rref(a)[1]) + + +def columns(a): + return [[row[j] for j in rref(a)[1]] for row in a] + + +def rows(a): + return transpose(columns(transpose(a))) + + +def inverse(a): + n = len(a) + out, pivots = rref(hcat(a, eye(n))) + need(pivots == list(range(n)), 'Invertible rational matrix') + return [row[n:] for row in out] + + +def determinant(a): + n = len(a) + out = 0 + for order in permutations(range(n)): + term = (-1)**sum(order[i] > order[j] for i in range(n) for j in range(i+1, n)) + for i, j in enumerate(order): + term *= a[i][j] + out += term + return out + + +def canonical(n): + identity, prefix = eye(n), eye(n) + us, vs, prefixes = [], [], [] + for i in range(n+1): + u = [[Q(j == i)] for j in range(n)] if i < n else [[Q(-(-1)**j)] for j in range(n)] + v = [[Q((i > j)-(i < j)) for j in range(n)]] + query = mul(u, v) + need(mul(v, u) == [[0]], 'Every canonical query is square-zero') + prefix = mul(add(identity, query, -2), prefix) + us.append(u); vs.append(v); prefixes.append(prefix) + need(prefix == [[-x for x in row] for row in identity], 'Complete canonical minus endpoint') + return us, vs, prefixes + + +def closure(u, v, operators): + a, b = columns(u), rows(v) + while True: + aa = columns(hcat(a, *(mul(p, a) for p in operators))) + bb = rows(b+sum((mul(b, p) for p in operators), [])) + if len(aa[0]) == len(a[0]) and len(bb) == len(b): + break + a, b = aa, bb + dims = [len(a[0]), len(b), rank(mul(b, a))] + return a, b, dims, dims[0]+dims[1]-dims[2] + + +def structural_checks(): + g = [[Q((i > j)-(i < j)) for j in range(4)] for i in range(4)] + need(determinant(g) == 1, 'Every ordered four-site Gram minor is invertible') + need(determinant([row[:3] for row in g[:3]]) == 0, 'The three-site Gram minor is singular') + need(g[0][1]*g[1][2]*g[2][0] == 1 and g[0][2]*g[2][1]*g[1][0] == -1, + 'The two directed triple products have opposite signs') + small, star = 0, 0 + supports = [set(c) for c in combinations(range(4), 2)] + for triple in combinations_with_replacement(supports, 3): + a, b, c = triple + if not (a & b and a & c and b & c): + continue + if len(a | b | c) <= 3: + small += 1 + else: + need(a & b == a & c == b & c and len(a & b) == 1, + 'Three intersecting two-sets are small or a three-arm star') + star += 1 + u, v, prefix = canonical(6) + basic, unique = [], {} + for i in range(7): + a, b, dims, lower = closure(u[i], v[i], [prefix[i]]) + basic.append(dims+[lower]) + if dims == [2, 2, 2]: + p = mul(mul(a, inverse(mul(b, a))), b) + need(mul(p, p) == p and mul(p, prefix[i]) == mul(prefix[i], p), 'Unique rank-two interior projector') + unique[i] = p + need([x[-1] for x in basic] == [2, 2, 4, 2, 4, 2, 2], 'Exact single-site rank bounds') + conditional = {str(i): [closure(u[j], v[j], [prefix[j], p])[3] for j in range(7)] + for i, p in unique.items()} + expected = {'1': [2, 2, 4, 4, 6, 4, 4], '3': [4, 4, 4, 2, 4, 4, 4], + '5': [4, 4, 6, 4, 4, 2, 2]} + need(conditional == expected, 'All ranks forced by an interior rank-two site') + a, b = hcat(u[0], u[6]), v[0]+v[6] + coincident = mul(mul(a, inverse(mul(b, a))), b) + same = [closure(u[j], v[j], [prefix[j], coincident])[3] for j in range(7)] + need(same == [2, 4, 4, 6, 4, 4, 2], 'Coincident endpoint projectors allow no rank-three interior') + + # All computations below take place in Q[r,r^-1]. No parameter is sampled. + r, ri = Laurent({1: 1}), Laurent({-1: 1}) + e0, un = u[0], u[6] + w = add(e0, un, -r) + mask_checks = [] + for i in (1, 3, 5): + need(mul(v[i], w) == [[1+r]], 'An a-only mask first forces r=-1') + wminus = add(e0, un) + need(mul(mul(v[i], prefix[i]), wminus) == [[2]], 'The a-only exceptional parameter also fails') + abc = closure(hcat(e0, un, u[i]), v[0]+v[6]+v[i], [prefix[i]]) + need(abc[3] >= 4, 'The abc mask cannot have rank three') + a = hcat(w, u[i], mul(prefix[i], w)) + if i == 3: + four = hcat(a, mul(prefix[i], u[i])) + need(determinant([four[j] for j in (0, 1, 3, 4)]) == -4*r, + 'The bc mask has a nonzero four-dimensional minor') + mask_checks.append({'site': i, 'bc_rejection': 'minor -4r', 'abc_rank_lower': abc[3]}) + continue + if i == 1: + minor = determinant([a[j] for j in (0, 1, 2)]) + need(minor == 2*r*r, 'The site-one image has dimension three for every nonzero r') + action = [[0, ri, 1-2*ri], [0, -1-2*ri, 4*ri], [1, -ri, 2*ri]] + else: + need(determinant([a[j] for j in (0, 1, 5)]) == 2, 'The site-five image has dimension three') + action = [[0, 1, -1], [0, -1, 0], [1, 1, -2]] + need(mul(prefix[i], a) == mul(a, action), 'Complete invariant image, with the parameter retained') + need(mul(v[i], a) == [a[0]], 'The bc equations force a0=0, hence r=1') + at_one = hcat(add(e0, un, -1), u[i], mul(prefix[i], add(e0, un, -1))) + need(mul(at_one, [[Q(1, 2)], [0], [Q(-1, 2)]]) == e0, + 'At r=1 the image contains e0 and b, so it cannot kill the nonzero a') + mask_checks.append({'site': i, 'bc_rejection': 'r=1, then a lies in both image and kernel', + 'abc_rank_lower': abc[3]}) + # Two rank-three stages use one line each in the common endpoint kernel. + # Equal L lines or equal R lines would contain three query pairs in rank 3. + # Distinct same-type lines would instead force the following nonzero sums. + need(((-1+ri)+(1+ri)) == 2*ri and ((-1-r)+(1-r)) == -2*r, + 'Distinct L,L and R,R lines cannot satisfy their cross pairings') + shared = [] + for sign in (-1, 1): + pairings = [[ri, sign+1], [-sign-1, -r]] + value = determinant(pairings) + need(value == (-1 if sign == -1 else 3), 'L and R lines are always distinct in characteristic zero') + shared.append(-1 if sign == -1 else 3) + + # A positive family retains every nonzero value of r, not only r=-1. + w0 = add(e0, un) + z = add(add(add(add(w0, w0, r), u[1], -r), u[5], -1), add(u[2], u[3], -1)) + aa = add(add(e0, un, r), z, -1) + bb, cc = add(e0, aa, -1), add(e0, z, -1) + left, right = add(add(u[1], w0, -1), z, ri), add(add(u[5], w0, -1), z) + f = hcat(aa, bb, cc, add(u[3], u[4], -1), right, left) + fi = [[1,1,0,1,1,ri], [1,1-ri,-ri,1-ri,1-ri,0], + [0,0,1,0,0,1-ri], [0,0,1,1,0,0], [0,0,1,0,0,1], + [0,1,1,1-r,1-r,0]] + need(mul(f, fi) == mul(fi, f) == eye(6), 'All-parameter positive family has an exact inverse') + family = [] + for site, support in [(0, [0,1]), (1, [0,1,5]), (5, [0,2,4]), (6, [0,2])]: + mask = [[int(j == k and j in support) for k in range(6)] for j in range(6)] + p = mul(mul(f, mask), fi) + query = mul(u[site], v[site]) + need(mul(p, p) == p and mul(p, query) == mul(query, p) == query, + 'Every member of the positive family has compatible full projectors') + need(mul(p, prefix[site]) == mul(prefix[site], p), 'Every positive-family prefix commutes') + need(all(mul(p, old) == mul(old, p) for old in family), 'Every positive-family stage pair commutes') + family.append(p) + + def floors(limit_rank_three): + out = [None]*8 + for ranks in product((0, 2, 3, 4, 5, 6), repeat=7): + full = sum(x != 0 for x in ranks) + if sum(x == 2 for x in ranks) > 2: + continue + if any(x and x < basic[i][-1] for i, x in enumerate(ranks)): + continue + if any(ranks[i] == 2 and any(x and x < conditional[str(i)][j] for j, x in enumerate(ranks)) + for i in (1, 3, 5)): + continue + if limit_rank_three and ranks[0] == ranks[6] == 2 and sum(x == 3 for x in ranks) > 2: + continue + idle = sum(max(0, x-2) for x in ranks) + if out[full] is None or idle < out[full]: + out[full] = idle + return out + lower = floors(True) + need(lower == [0, 0, 0, 1, 2, 4, 6, 8], 'All full-site counts obey the stated idle lower bounds') + need(floors(False)[5] == 3, 'The three-interior exclusion is needed for the five-full bound') + return {'rank_two_support_cases': {'small_union': small, 'star': star}, + 'single_site_rank_data': basic, 'interior_rank_two_forces': conditional, + 'coincident_endpoint_rank_lower': same, 'rank_three_mask_checks': mask_checks, + 'shared_LR_line_determinants': shared, 'idle_lower_by_full_count': lower, + 'positive_family': 'An explicit invertible root for every nonzero r, with sites 0,1,5,6 and the classified masks.', + 'parameter_ring': 'Q[r,r^-1]; r is not fixed to -1', + 'scope': 'Shortest rank-one square-zero queries; every output contains S; scalar bases independent of S and the independent forward stage variables; characteristic zero for the six-field classification.'} + + +def normalization_checks(): + def zadd(a, b): + return a[0]+b[0], a[1]+b[1] + def zmul(a, b): + return a[0]*b[0]-a[1]*b[1], a[0]*b[1]+a[1]*b[0] + one, zero = (Q(1), Q(0)), (Q(0), Q(0)) + a, b = (Q(1, 2), Q(1, 2)), (Q(1, 2), Q(-1, 2)) + need(zadd(zmul(a, a), zmul(b, b)) == zero and zmul((2, 0), zmul(a, b)) == one, + 'lambda squared equals X in the polynomial ring modulo X squared minus one') + need(zadd(zmul(a, b), zmul(b, a)) == one and zadd(zmul(a, a), zmul(b, b)) == zero, + 'The conjugate normalizer is the inverse') + for q in (one, (-1, 0), (0, 1), (0, -1)): + lam = zadd(a, zmul(b, zmul(q, q))) + s = zmul(lam, q) + need(zmul(s, s) == one and zmul(zadd(b, zmul(a, zmul(q, q))), s) == q, + 'All four central characters normalize and restore') + # Two one-column characters q=-i give S=1 separately, but S=-1 globally. + local = zmul(zadd(a, zmul(b, (-1, 0))), (0, -1)) + global_s = zmul(zadd(a, b), (-1, 0)) + need(local == one and global_s == (-1, 0) and zmul(local, local) != global_s, + 'Tensoring the one-column normalizer is not the global normalization') + pair_checks = 0 + for width in range(1, 7): + size = 1 << width + for shift in range(1, size): + pivot = shift & -shift + pairs = [(x, x ^ shift) for x in range(size) if not x & pivot] + need(sorted(x for pair in pairs for x in pair) == list(range(size)), + 'Each nonzero binary translation is partitioned into disjoint pairs') + pair_checks += len(pairs) + return {'formal_identity': 'lambda^2=X, S^2=I, lambda^-1*S=q whenever q^2=X and X^2=I', + 'characters': 4, 'translation_pairs_checked': pair_checks, + 'tensor_of_one_column_normalizers_rejected': True, + 'scope': 'The polynomial identity proves all widths; the address enumeration is a finite control.'} + + +def central_free_checks(): + """Check coupled examples for the active-space reduction in EXTENSIONS.md.""" + examples = [] + for active in (2, 4, 6, 8): + us, vs, _ = canonical(active) + for inactive in (1, 3): + size = active+inactive + extended_u = [u+[[Q(0)] for _ in range(inactive)] for u in us] + extended_v = [v[0]+[Q(j+2) for j in range(inactive)] for v in vs] + matrices = [mul(u, [v]) for u, v in zip(extended_u, extended_v)] + endpoint = eye(size) + for matrix in matrices: + need(rank(matrix) == 1 and rank(mul(matrix, matrix)) == 0, + 'Every coupled example has rank-one square-zero queries') + endpoint = mul(add(eye(size), matrix, -2), endpoint) + expected = [[Q((-1 if i < active else 1) if i == j else 0) + for j in range(size)] for i in range(size)] + need(endpoint == expected, 'The coupled inactive inputs cancel at the endpoint') + U = hcat(*extended_u) + V = extended_v + need(rank(U) == active and rank(V) == active+1, + 'The column-contained example need not have contained query rows') + G = mul(V, U) + lower = [[G[i][j] if i > j else Q(0) for j in range(active+1)] + for i in range(active+1)] + Z = add(add(eye(active+1), lower, 2), G, -1) + need(rank(Z) == 1 and all(Z[i][i] == 1 for i in range(active+1)), + 'The compressed shortest tuple has a rank-one defect') + dual = eye(size) + for matrix in reversed(matrices): + dual = mul(add(eye(size), transpose(matrix), -2), dual) + need(dual == expected, 'Reverse transpose gives the row-contained case') + need(any(matrices[0][i][j] for i in range(active) for j in range(active, size)), + 'An individual query need not preserve the inactive eigenspace') + examples.append({'active_fields': active, 'inactive_fields': inactive, + 'query_count': active+1, 'ranks_U_V': [rank(U), rank(V)]}) + # Compression is not a homomorphism without the one-sided containment. + a, b = eye(3), eye(3) + a[0][2], b[2][0] = 1, 1 + need(mul(a, b)[0][0] != 1, 'Unrestricted cross-block cancellation cannot be compressed') + return {'coupled_examples': examples, 'dual_examples': len(examples), + 'claim': 'r+1 square-zero queries with endpoint diag(-I_r,+I_s) reduce to an r-field shortest tuple; extra central-free outputs have no positive signed price.', + 'scope': 'The rank proof and tariff argument in EXTENSIONS.md are quantified. These exact examples are controls, not the universal proof.'} + + +def read_inputs(): + sources = json.loads((HERE/'SOURCES.json').read_text()) + out = {} + for pin in sources['files']: + if pin['usage'] == 'input': + data = (ROOT/pin['path']).read_bytes() + need(sha256(data).hexdigest() == pin['sha256'], 'Exact input bytes: '+pin['path']) + if pin['path'].endswith('.json'): + out[pin['path']] = json.loads(data) + return out + + +def run(): + data = read_inputs() + root = data['research/mixed-projector-query-root/ROOT.json'] + receipt = data['research/mixed-root-source-composition/RESULT.json'] + need([s['stage_rank'] for s in root['sites'] if s['full']] == [2, 3, 3, 2], 'The actual root attains the two-idle floor') + need(root['masks'] == [[1,1,1,1],[1,1,0,0],[0,0,1,1],[0,0,0,0],[0,0,1,0],[0,1,0,0]], + 'The actual root has the classified stage supports') + ceiling = receipt['fixed_root_ceiling'] + need(Q(ceiling['ceiling']) == Q('.00328554') and Q(ceiling['finite_margin_upper']) < 0 + and Q(ceiling['tail_margin_upper']) < 0 and Q(ceiling['tail_derivative_upper']) < 0, + 'The complete composition supplies the stated authenticated price ceiling') + need(receipt['price']['kappa_decimal'] == '0.00328551', 'Exact complete conditional result') + spec = importlib.util.spec_from_file_location('mixed_root_reverse_caller', HERE/'caller_reverse.py') + reverse = importlib.util.module_from_spec(spec) + spec.loader.exec_module(reverse) + caller = reverse.run(data['research/mixed-projector-query-root/CONTROLLER.json']) + def module(path, name): + spec = importlib.util.spec_from_file_location(name, path) + loaded = importlib.util.module_from_spec(spec) + spec.loader.exec_module(loaded) + return loaded + E = module(ROOT/'research/higher-moment-strictification/verify.py', 'headroom_intervals') + next_cost = module(HERE/'next_cost_ceiling.py', 'headroom_next_cost') + extension_price = next_cost.run(receipt['local'], E, Q('.00328554')) + boundary = module(HERE/'boundary_modules.py', 'headroom_boundary_modules') + current = data['research/mixed-root-contact-composition/RESULT.json'] + saving = Q(current['price']['kappa_decimal']) + need(saving == Q('.00328621476572836015146308'), 'Exact latest complete composition claim') + latest_extension = next_cost.run(current['local'], E, saving) + boundary_price = module(HERE/'boundary_prices.py', 'headroom_boundary_prices') + return {'status': 'PASS_MIXED_ROOT_MINIMUM_IDLE_CLASSIFICATION', + 'structure': structural_checks(), 'normalization': normalization_checks(), + 'central_free_extension': central_free_checks(), + 'rank_four_extension_price': extension_price, + 'boundary_modules': boundary.run(sys.modules[__name__]), + 'latest_source_extensions': {'source_head': current['source_head'], + 'rank_four_extension_price': latest_extension, + 'boundary_prices': boundary_price.run(current['local'], E, saving)}, + 'separate_reverse_caller': caller, + 'inherited_complete_claim': '0.00328551', 'broader_family_ceiling': '0.00328554', + 'ceiling_evidence': 'Authenticated composition receipt and its separately registered full replay; no price engine is replaced here.', + 'ceiling_scope': 'Six-field seven-query roots with S on every output, constant scalar bases independent of S and all stage variables, four distinct independent forward full stages and at most two extra whole idles; all positive binary child sizes and shapes; fixed PR6353 source.', + 'new_kappa_increment': False, 'selected_frontier_changed': False} + + +if __name__ == '__main__': + result = run() + if sys.argv[1:] == ['--write-result']: + (HERE/'RESULT.json').write_text(json.dumps(result, indent=2)+'\n') + else: + need(not sys.argv[1:], 'No unrecognized verifier arguments') + need(result == json.loads((HERE/'RESULT.json').read_text()), 'Exact scientific receipt') + print(result['status']) diff --git a/research/mixed-root-contact-composition/CEILING-EDITS.json b/research/mixed-root-contact-composition/CEILING-EDITS.json new file mode 100644 index 0000000000..b5746884c3 --- /dev/null +++ b/research/mixed-root-contact-composition/CEILING-EDITS.json @@ -0,0 +1,10 @@ +[ + [ + "CEILING=Q('.00328554')", + "CEILING=Q('.00328621476572836015146310')" + ], + [ + "PR6353 source.", + "PR6375 source." + ] +] diff --git a/research/mixed-root-contact-composition/CONTACT-INPUTS.json b/research/mixed-root-contact-composition/CONTACT-INPUTS.json new file mode 100644 index 0000000000..af637a1cb5 --- /dev/null +++ b/research/mixed-root-contact-composition/CONTACT-INPUTS.json @@ -0,0 +1,54 @@ +{ + "source_head": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "archive_sha256": "4f41c4d246b354132d032546037d866a5199f7a3ea015915bf748a8d323cefb8", + "files": [ + { + "path": "research/p104-contact-block-contraction/construct.py", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "d92f1f92e705eafdda770ec19b958084584420a8", + "sha256": "e18f0221827628e38674dc71198a95ccebc401476328e3db7569b84e4b7be969" + }, + { + "path": "research/p104-contact-block-contraction/WORD.json.gz", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "0af79e58172f85c302c35b193205c0b185b09393", + "sha256": "e3b6f1c25d672b8c85433be97ebad77ae6a6972352ce2ff63507d30835fcb491" + }, + { + "path": "research/p104-contact-block-contraction/BASIS.json", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "efa2be3e34cab2d15ceaf33ff43eab70ff4c12e6", + "sha256": "28d01a60c1780dc61373a13ac70654c140fa20519abdac0dd78f24c8343a002f" + }, + { + "path": "research/p104-contact-block-contraction/RESULT.json", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "66166eebc2305939214abbc00b254048374458eb", + "sha256": "36e6daa172d5eacc0803e2f3276a68681728dbf59f97b5fb7e7fa120f4d857ec" + }, + { + "path": "research/p104-contact-block-contraction/NOTICE", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "9af7effd3a0ff5218d94331567022fd179a1e8fa", + "sha256": "f13f42a39d4614b26d9871f5bc8fcb76e60cb44b4df8762cd51e505b43723e46" + }, + { + "path": "research/p104-contact-block-contraction/PROOF.md", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "3a670ce4c0ae727b4d3cd3604d67d45b189da3c7", + "sha256": "4d02ec61147085ed88c11340b369729c943b954a0cc41a9995ffc07d24f1a285" + }, + { + "path": "research/p104-contact-block-contraction/inputs/pr6353-WORD.json.gz", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "03ea7690285d4cda72815f962d5710ab96e08490", + "sha256": "0c83c1f1dee8c9442558719510a61b89f38c2dbfc8fb565ba035660d2a68d928" + }, + { + "path": "research/p104-contact-block-contraction/inputs/pr6353-construct.py", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "fff6cfb443b8ad59c2b8ab8f1e8eb01017576d8a", + "sha256": "a6ed00edd11b902c25d345ba2b44063cd68ebe787fe92067b65d26c8e2dc9248" + } + ] +} diff --git a/research/mixed-root-contact-composition/LIFT-INPUTS.json b/research/mixed-root-contact-composition/LIFT-INPUTS.json new file mode 100644 index 0000000000..e53fd2bdb5 --- /dev/null +++ b/research/mixed-root-contact-composition/LIFT-INPUTS.json @@ -0,0 +1,48 @@ +{ + "source_head": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "files": [ + { + "path": "research/p104-shared-carrier-lifts/construct.py", + "commit": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "git_blob": "c099995bef0e224cbb0ec61c06ed3d0b4d478b33", + "sha256": "fe7dc1d9aa55da393465388ee90faaa687b1e5be48dfa816a421069fa3d2de08" + }, + { + "path": "research/p104-shared-carrier-lifts/LIFTS.json", + "commit": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "git_blob": "2ee8cb78fd149f9aca8dd953c650b92495a56266", + "sha256": "38960b70a074888a2aeaf3b543629a7ae747c0c5d4f5c853371a6e7c483766c5" + }, + { + "path": "research/p104-shared-carrier-lifts/WORD.json.gz", + "commit": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "git_blob": "b1cfd03abe9128cf5a3908fbd82652e5e8a2e292", + "sha256": "9e31463a785c18a70f6ae6ef3d04a6560dbb965517109390fe820f9fac3371b3" + }, + { + "path": "research/p104-shared-carrier-lifts/RESULT.json", + "commit": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "git_blob": "662ccefa5c7171e81691d4d4cb2573a685f4b74d", + "sha256": "2b4a20110448e11b548e7a3bc995be906c6d214559a1f336e462658b942e986e" + }, + { + "path": "research/p104-shared-carrier-lifts/NOTICE", + "commit": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "git_blob": "638a187d1417bda8976e945a2aeaed116a090e37", + "sha256": "91f24d68004688bc0a56303a48edcb5ddabd66bfc2326950603bf98dec245bbe" + }, + { + "path": "research/p104-shared-carrier-lifts/PROOF.md", + "commit": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "git_blob": "bd20fcaf2078691d914d6afbc5cb06a75f47770d", + "sha256": "769e0f87e6b85c557b48135d2d898bb485cf77ce9925540e0a3740e6283f41af" + }, + { + "path": "research/p104-shared-carrier-lifts/inputs/pr6372-WORD.json.gz", + "commit": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "git_blob": "0af79e58172f85c302c35b193205c0b185b09393", + "sha256": "e3b6f1c25d672b8c85433be97ebad77ae6a6972352ce2ff63507d30835fcb491" + } + ], + "archive_sha256": "d9e6d7525c1b2d196c5c2db8f65b3b04c503faa3911e6c0ce83a83fc5d394b8a" +} diff --git a/research/mixed-root-contact-composition/NOTICE b/research/mixed-root-contact-composition/NOTICE new file mode 100644 index 0000000000..4e3b429712 --- /dev/null +++ b/research/mixed-root-contact-composition/NOTICE @@ -0,0 +1,312 @@ +The final source additionally consumes PR6375 at +247b5c319b9f58fe9ee61dbf80697f8a9a429831. The shared-carrier input lifts +are by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. +Their exact notice is retained in lift-source.tar. Apache-2.0. + +Mixed root and PR6372 source composition + +New composition and complete checks: Ali Romman with substantial OpenAI +Codex assistance. No subagents. Apache-2.0. The mixed root, prior adapter +and source mechanisms retain their separate credit. + +Exact PR6372 source notice follows. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +No subagents. Apache-2.0. + +PR6353 supplies the word, joint basis construction and native transpose. +Exact head: db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3. +The source files in inputs are unchanged. The complete predecessor notice follows. + +Joint native output contraction +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author checks. + +PR6349 supplies the exact native input-lift source. PR6348 supplies the fixed +binary query-tree caller and price engine. PR6350, by Ali Romman with OpenAI +Codex assistance, supplies the released composition control and its prior +conditional claim. Its source and caller are recounted here from main; no +pending PR6350 code is imported. Cinna Davis supplies the productive caller, +thin-query interface and exact Laurent factorization. + +The new result is the explicit nine-helper joint output contraction, its +literal forward word and complete conditional price. The input/departure basis +identity is elementary linear algebra. No new general linear algebra theorem, +native duality theorem or caller construction is claimed. + +The exact PR6349 and PR6348 notices follow. Their nested source archive retains +all earlier native, helper, recursion, compiler, BIT and analytic attribution. + +Native helper input lifting +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author checks. + +The direct source is PR6314 at 36533d4d1b4e2dd8672427461b12de3001b85810, +by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. +It compresses the scalar word of PR6167 without a kappa change. +The four native input lifts and their complete conditional price are new here. +The basis identity is elementary linear algebra; no new general theorem +for that identity is claimed. + +The PR6167 source notice follows unchanged. Its nested source archive also +retains the earlier notices. + +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. + +Binary query-tree caller + +New construction, proof and code: Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. No subagents. + +Cinna Davis supplies the productive path caller, query thinning and exact Laurent factorization. Ali Romman supplies the all-forward P104 binding in PR5544 and the retained-operand word in PR6167. The native word and interval/compiler lineage remain predecessor work. The new contribution is the four-field query extension, its tree composition, complete invoice and conditional price. + +The authenticated PR6167 notice follows. + +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. diff --git a/research/mixed-root-contact-composition/OPTIMALITY.md b/research/mixed-root-contact-composition/OPTIMALITY.md new file mode 100644 index 0000000000..b642edef62 --- /dev/null +++ b/research/mixed-root-contact-composition/OPTIMALITY.md @@ -0,0 +1,193 @@ +# Exact raw limit of the fixed mixed-root family + +The old value 0.00328623 was a strict exclusion bound. It was not a +feasible target. The exact raw funding limit is the unique zero k* of +the signed invoice below. Two rational engines enclose it in + +```text +0.00328621476572836015146309 < k* < 0.00328621476572836015146310. +``` + +The complete conditional claim is +**kappa = 0.00328621476572836015146308**. Thus + +```text +10^-26 < k* - kappa < 2*10^-26. +``` + +This last change refines the completion and compiler parameters. It +does not change the source, caller, paid profile or productive profile. +It is not a new construction step under the repository's hill-climbing +rule. The earlier mixed-root construction supplies the four-percent gain. + +## Scope + +Fix the exact PR6375 source and its complete helper interface. Consider +the classified six-field, seven-query roots with four independent forward +full stages at distinct sites and at most two extra whole idles. Every +output must contain the central involution S. Scalar bases must be +independent of S and all stage variables. Permit every positive binary +child size and every binary tree shape. The +[classification proof](../mixed-projector-root-headroom/PROOF.md) reduces +every such root to the same priced output pattern. The saving range is +0 <= k <= 0.0034, as in the retained BIT admission. +`SOURCES.json` pins the exact classification proof at local commit +`e87c230f231441e2b53dec846ae9496c8c8d5121`. Its structural statement +does not depend on the native source price. + +This is the exact raw limit in that domain. It does not bound changed +sources, more costly roots, different queries, different child contracts +or all multiplication algorithms. The five inherited framework assumptions +remain. Exact equality at k* has no complete strict certificate here. +The family comparison fixes the recursive paid/productive invoice. It +does not assert equal ordinary-operation costs for all scalar bases. +Omitting extra ordinary work favors competitors and preserves the upper +bound. The complete ordinary budget is checked for the actual chosen word. + +## The signed invoice + +Put H(r)=r^(1-k). The productive moment minus the paid moment is + +```text +F(k) = 104 H(145) + 208 H(73) + + 416 [H(57)-H(56) + H(33)-H(32) + H(25)-H(24)] + + 1872 [H(17)-H(16)] + 6552 H(9) + 666 H(8) + - 90 H(6) - 2448 H(5) - 36 H(4) + - 8766 H(3) - 8010 H(2) - 41678 H(1). +``` + +This bill includes all 18 native calls, all helper target debits, the +root queries and idles, and every binary node. `optimality.py` constructs +it from the literal child trees and compares it with the separate event +invoice. The complete native and caller replay remains in `verify.py`. + +`pricing.py` bounds F' strictly below zero on the entire admitted range. +Both rational engines give a positive lower bound for F at the lower +endpoint above and a negative upper bound at the upper endpoint. Hence +F has exactly one zero in that interval. This argument does not depend +on a floating-point root finder. + +## Why no other child bill has a later crossing + +Let L(k) be the native paid moment minus the native helper moment, +divided by 104. For a binary child, define its minimum net cost by + +```text +C(1) = 0 +d(n) = 2 H(8n) + 1 - 2 H(8n+1) +C(n) = d(n) + min [C(a) + C(n-a)], 1 <= a < n. +``` + +The two root pairs can be priced separately. For a pair with total n, +let + +```text +G(n) = H(8n+1) - n L + + max [H(8b+1) - H(8b) - C(n-b) - C(b)], 1 <= b < n. +``` + +The complete per-port margin at total N and pair totals x,N-x is +H(8N+1)+G(x)+G(N-x)-2. The terms H(8b) charge the actual whole idles; +they are not fixed at the winning child size. + +At the lower bracket endpoint, the exact recurrence gives these results: + +| Competing choice | Outward upper bound or strict gap | +| --- | ---: | +| All 4,655 pair-total choices below N=100 other than (9,9) | Margin < -0.0010068 per port | +| Any split of a nine-leaf pair other than (7,2) | Margin < -0.00004433 per port, even with the other pair optimal | +| Any other seven-leaf tree histogram | Additional cost > 0.0014247 throughout the bracket | + +There are 11 distinct internal-node histograms for seven-leaf binary +trees. The selected histogram is {2:3, 3:1, 4:1, 7:1}. Different planar +trees can have this same histogram and bill; no unique tree shape is +claimed. The two-leaf tree has only one histogram. Thus the selected +tree bills are optimal at those sizes. + +These comparisons extend in the required direction. The checker proves +L' > 0 on the admitted range. Each H(r), r>1, decreases with k. The +increment H(r+1)-H(r) also decreases: its derivative is +r^(1-k) log(r) - (r+1)^(1-k) log(r+1), which is negative for r>=1. +Each d(n), and therefore each fixed tree cost, increases. A minimum over +these increasing tree costs is increasing. Thus a competing profile +that loses at the lower endpoint also loses at every larger admitted k. +The interval comparison of all 11 histograms retains their signed +differences; it does not subtract two separately rounded optima. + +To prove dominance across the bracket, one further comparison is needed. +The selected margin becomes negative above its zero, so negativity of +the alternatives alone does not prove that it is larger there. Since +F decreases, F(upper)/104 bounds the selected per-port margin from below +throughout the bracket. Each competing margin is bounded from above +by its bound at the lower endpoint. The replay compares these rational +bounds directly, including the infinite tail below, and proves a gap +greater than 0.00004433 per port. Together with the histogram comparisons, +this proves that sizes 7,2,2,7 and their selected tree bills maximize the +margin throughout the bracket. + +For N>=100, concavity gives the bound + +```text +H(8N+1) + 2 H(4N+1) - N(L-1) + 2[H(9)-H(8)] - 6. +``` + +This follows from d(n)>=-1, the N-4 internal child nodes, and Jensen's +inequality for the pair outputs. The same exact endpoint and derivative +checks exclude this whole tail at both bracket endpoints. Concavity in +N makes its derivative nonincreasing. The monotonicity in k above then +excludes all larger savings. The separate `ceiling.py` recurrence also +checks every finite pair choice at the upper bracket endpoint. + +It follows that the largest raw crossing in the whole stated family is +exactly k*, the zero of the displayed invoice. This is stronger than +giving a nearby numerical exclusion bound. + +## A complete point immediately below the bracket + +Use tested saving 0.003286214765728360151463085, tensor power 1920, +cutoff 12, floor 13, moment offset 1/7, reserve 10^-29, and decay 31/32. +For the three retained ratios alpha, gamma and delta, exact intervals +give alpha < 1-reserve and gamma,delta < 31/32. The complete normalized +paid bound is + +```text +1 / (1 + 1920 * 10^-29) + 4 * (31/32)^1920 < 1. +``` + +The first term bounds alpha^1920 by Bernoulli's inequality. The second +term charges both completion and splitting tails. The older estimate +(31/32)^128 < 1/16 gives a bound that is too loose at this precision. +The new check uses the exact rational power, and rejects that coarse +bound as insufficient. No paid tail term is removed. + +The compiler uses logarithm power 2100. All source work, routes, ordinary +operations, BIT stock and 54 strict plus four functional outer conditions +remain charged. Both interval engines check the tested saving and both +raw bracket endpoints. `RESULT.json` records every exact parameter and +the very large integer threshold. No uniform word is materialized. + +The two tail ratios stay below 31/32 throughout the raw bracket. For +each k 1, 'The coarse tail bound cannot fund this claim')\n exact_tail = 4*decay**power\n normalized = 1/(1+power*reserve)+exact_tail" + ], + [ + "theta, logarithm_power = Q(63, 64), 1100", + "theta, logarithm_power = Q(63, 64), 2100" + ], + [ + "'gain': KAPPA-PREVIOUS,", + "'refinement_kind': 'Same complete invoice; finer strictification and compiler parameters.',\n 'gain': KAPPA-PREVIOUS," + ], + [ + "'tail_offset': offset, 'reserve': reserve, 'tail_decay': decay, 'tail_block': 128,", + "'tail_offset': offset, 'reserve': reserve, 'tail_decay': decay,\n 'exact_tail_upper': exact_tail, 'coarse_tail_upper': coarse_tail," + ], + [ + "'old_BIT': 'An outer inequality fails at BIT saving0.0027.'", + "'old_BIT': 'An outer inequality fails at BIT saving0.0027.',\n 'coarse_tail': 'The block tail bound cannot fund this near-limit claim.'" + ], + [ + " need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure')", + " need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure')\n endpoints = {}\n for label, k in [('lower', lower), ('upper', upper)]:\n tl, th = other.moment(T, k)\n pl, ph = other.moment(P, k)\n second = (tl-ph, th-pl)\n first = margin(k)\n need(max(first[0], second[0]) <= min(first[1], second[1]),\n 'Both rational engines agree at the raw endpoint')\n need(second[0] > 0 if label == 'lower' else second[1] < 0,\n 'The second engine certifies both raw endpoint signs')\n endpoints[label] = {'first': E.display(first), 'second': E.display(second)}" + ], + [ + "'raw_root_interval': [lower, upper], 'raw_headroom': [lower-KAPPA, upper-KAPPA],", + "'raw_root_interval': [lower, upper], 'raw_headroom': [lower-KAPPA, upper-KAPPA],\n 'raw_endpoint_margins': endpoints," + ] +] diff --git a/research/mixed-root-contact-composition/PROOF.md b/research/mixed-root-contact-composition/PROOF.md new file mode 100644 index 0000000000..49a3bb14e2 --- /dev/null +++ b/research/mixed-root-contact-composition/PROOF.md @@ -0,0 +1,153 @@ +# Complete composition with the contact and shared-carrier sources + +The conditional claim is kappa 0.00328621476572836015146308. The final source is PR6375 at +`247b5c319b9f58fe9ee61dbf80697f8a9a429831`. It uses PR6372 at +`b556600ffe14be72406b03a47c661f3c7f1aff06`. The root and all four binary +children remain unchanged. This proof retains the five assumptions +native_all_columns, owned_erasure, compiler, precision_tape and +analytic_recovery. It does not establish an unconditional theorem. + +## Source reconstruction and interface + +The complete retained PR6353 word and basis constructor are byte-equal +to the two inputs retained by PR6372. The new constructor rebuilds the +published PR6372 word and rational witness. The only changed public +output frames are helpers 224 and 227. Both move to frame 245. The main +interface, native frames and caller word stay unchanged. + +Next, the exact shared-carrier constructor and LIFTS.json from PR6375 +rebuild its published word from the authenticated PR6372 input. Only six +initial frames change: helpers 520 and 655 start at frame 106, while +544, 671, 472 and 624 start at frame 105. Their first-destination delivery +and final restoration use three shared carrier rows. The complete final +frames are unchanged. This source construction is by DreamingOfClouds, +with Claude Opus 5.5 assistance. The replay checks every changed input. +No new owned label or lifetime is added by these lifts. + +The source has 770 independent public inputs, 29 owned labels, 43 owned +lifetimes and peak ownership 13. Both lifetimes added by PR6372 are charged. +The replay checks all 799 scalar columns and 638,401 separate reverse +coefficients, absolute native phases and all 7,488 caller contacts. +The 562 independent helpers at each native call remain separate from +every other call and from the caller's main fields. + +The six-field root, whole-field normalization, all paired and individual +idles and every one of the 570 caller events are replayed. No old physical +receipt is substituted for the new source check. The unchanged binary +module is also checked from its exact retained bytes. + +## Signed change and complete bill + +Write H(r)=r^(1-kappa). At one native call, PR6372 changes the paid bill by + +```text +2H4-2H5 +``` + +and the productive helper bill by + +```text +2H8-2H9. +``` + +Their signed margin change is + +```text +2[(H5-H4)-(H9-H8)] > 0 +``` + +for every strictly concave power tariff. The construction and this source +gain belong to PR6372. The present contribution binds them to the mixed +root and checks the complete result. There are exactly 18 copies of both +changes. Omitting either productive debit is rejected. + +The shared-carrier step then changes the per-call paid bill by +6H1-3H3+3H4-3H5 and the productive bill by 6H8-6H9. Both changes +occur at all 18 calls. Unlike the contact contraction, this source change +is not positive for every concave tariff. Its signed gain is zero at +linear cost and negative for some smaller powers. The two interval +engines check the actual exponent used here. All six entrance reversions, +a missing delivery, a missing restoration and a wrong response sign are +rejected. These lifts receive their source credit; they are not a new +root construction. + +The complete caller has 67,150 paid jobs and 13,652 productive fields. +Paid rank mass is 184,980 and productive rank mass is 185,740. Their +difference is 760. All 17 thin queries, 14 paired whole idles, two +individual whole idles and 20 ordinary normalizations remain charged. + +Two rational moment engines check the tested saving +0.003286214765728360151463085 and both endpoints of the strict raw bracket +`(0.00328621476572836015146309, 0.00328621476572836015146310)`. The native word has 17,768 events. +Both earlier sources, PR6353 and PR6372, have a strictly negative +margin with this caller at the new claim. Completion, the compiler integer grid, ordinary work, all 54 +strict and four functional outer conditions are recomputed. The BIT +admission remains 0.0034. `RESULT.json` records the exact crossing and +all completion and compiler parameters. +The source ordinary allowance is 129,670 scalar units plus 5,379,000 +route units. It is below the retained 10^7 local budget. The complete +caller ordinary bound remains 248,152,864, below 10^9. The compiler +logarithm power is 2100. `RESULT.json` gives its exact threshold. These +large constants do not establish a practical speedup. + +The price and ceiling programs are exact declared adaptations of the +preceding composition. `PRICING-EDITS.json` and `CEILING-EDITS.json` list +every permitted edit. All old source bytes are authenticated before use. +No interval inequality or native check is weakened. + +## What is now maximized + +The [exact optimum proof](OPTIMALITY.md) identifies the raw family limit +as the unique zero of the complete signed invoice. All alternative child +size profiles lose at the lower bracket endpoint. All 11 seven-leaf tree +histograms are compared across the bracket. The all-size tail excludes +all larger totals. Thus the 7,2,2,7 profile attains the largest raw crossing +in the stated family, not merely the best point found in a bounded search. + +The complete conditional claim is between 1e-26 and 2e-26 below that +crossing. Completion uses power 1920, reserve 1e-29 and the exact tail +4*(31/32)^1920. The older block bound is too loose at this precision. +The source, caller and signed bill are unchanged. At the raw crossing, +paid and productive moments are equal; this strict funding argument does +not certify equality. More digits are not a new construction gain. + +The separate `mixed-projector-root-headroom` proof shows that every +six-field, seven-query root in its stated class has this same priced +output pattern. The class requires S on all six outputs, scalar bases +independent of S and all stage variables, four independent forward full +stages at distinct sites, and at most two extra whole idles. Its argument +does not depend on the native profile. The recalculated ceiling therefore +applies to that whole family with PR6375 as the fixed source. + +This does not maximize all possible callers or integer-multiplication +algorithms. More idles, changed query counts or field counts, coupled +queries, changed child contracts and changed sources remain outside the +ceiling. Variable-dependent bases and mixed central endpoints are also +outside this classification. The last source composition added +0.00000036, or 0.0109561 percent, +over the preceding local 0.00328584 result. This parameter refinement adds +about 0.000449325 percent over 0.00328620 with the same invoice. The full +mixed-root contribution is about 4.28455 percent above PR6375's published +complete claim. These are different comparisons. + +## Verification and attribution + +The registered replay reconstructs the source, checks its arbitrary +inputs and all phases, replays the caller and both prices, and checks +every compiler and outer condition. It also rejects omitted source +operations, both missing target debits, damaged retained files and +incorrect paid or productive counts. These checks remain active under +optimized Python. The separate headroom package checks the formal caller +again by reverse output functionals at all four central characters. + +All checks are author checks. Independent scientific review, formal-kernel +acceptance and the five framework assumptions remain open. The selected +frontier is unchanged. The separate [PR6376 scalar audit](https://github.com/CrocSwap/integer-mult-bounds/pull/6376) +checks the earlier PR6372 boundary only. Its forward CLEAR rows are +nonzero; neither that audit nor this composition discharges the inherited +owned_erasure premise. + +The root, binary query module, source contractions and native/compiler/BIT +engines retain their predecessor credit. The exact PR6372 and PR6375 notices and all +prior source notices are retained in the two source archives. New composition: Ali Romman with +substantial OpenAI Codex assistance; no subagents. Apache-2.0. diff --git a/research/mixed-root-contact-composition/README.md b/research/mixed-root-contact-composition/README.md new file mode 100644 index 0000000000..8d96c455cb --- /dev/null +++ b/research/mixed-root-contact-composition/README.md @@ -0,0 +1,86 @@ +# Conditional kappa 0.00328621476572836015146308 from the mixed root and PR6375 + +Publication of this reviewed contribution was authorized on 2026-11-02. +The [publication description](PR-DRAFT.md) states the complete result and +review path. Historical validation records retain their original status; +the contribution PR records the current hosted CI result. + +This is the final source composition in the mixed-root contribution. +It claims **kappa 0.00328621476572836015146308**, about **4.28455 percent above PR6375's +0.00315120**. The last source composition added 0.00000036 over the local +0.00328584 result. The final parameter refinement adds about 1.47657e-8 +over 0.00328620 with the same complete invoice. Most of the complete gain comes from the new caller; +the native source changes retain their credit in PR6375, PR6372 and PR6353. + +The fixed caller has four binary children of sizes 7,2,2,7, 18 native +calls, 34 main fields per port and 570 literal events. It pays all native +maps, target debits, thin queries, paired and individual idles, basis +changes, normalizations, owned lifetimes and outer costs. + +The selected frontier stays unchanged. Five inherited framework +assumptions remain. No materialized uniform word, rounded multiplier, +practical speedup, independent scientific acceptance or formal-kernel +acceptance is claimed. + +## Review path + +1. Read the [root proof](../mixed-projector-query-root/PROOF.md) for the + construction and whole-field normalization. Its original source is + PR6349 and its separate conditional claim is 0.00328467. +2. The [PR6353 composition](../mixed-root-source-composition/PROOF.md) + gives the complete intermediate claim 0.00328551 and retains the + complete executable source closure. +3. [This proof](PROOF.md) consumes the exact published PR6375 word. It + charges all 18 copies of the new signed change and checks the final + complete result in `RESULT.json`. +4. The [headroom proof](../mixed-projector-root-headroom/PROOF.md) + classifies every minimum-idle root in this six-field family. With + the new source, the [exact raw optimum](OPTIMALITY.md) lies in + (0.00328621476572836015146309, 0.00328621476572836015146310). The complete claim is + less than 2e-26 below it; exact equality has no strict certificate here. + It also includes a separate reverse replay of all formal coefficients + of the actual 570-event caller. + +The new structural proof is supplementary evidence, not another kappa +increment. It permits arbitrary constant scalar bases and all binary +child sizes and shapes. All six outputs must contain S, and the bases +must be independent of S and all stage variables. Roots with mixed +central endpoints, more idles or a different interface are excluded. + +## Replay + +Use Python 3.12 and its standard library: + +```sh +python3 -B scripts/research_package.py --package research/mixed-root-contact-composition +python3 -I -B research/mixed-root-contact-composition/verify.py +python3 -I -O -B research/mixed-root-contact-composition/verify.py +``` + +The exact PR6375 head is +`247b5c319b9f58fe9ee61dbf80697f8a9a429831`. Its seven retained files are in +`lift-source.tar`, with original path, commit, Git blob and SHA256 in +`LIFT-INPUTS.json`. The eight exact PR6372 files remain in +`contact-source.tar`, bound by `CONTACT-INPUTS.json`. The six live files from the preceding composition +are also pinned and declared. No network fetch or separate-branch Git +object is needed by the direct replay. All earlier source archives stay intact. + +See the [final author review](REVIEW.md) for repaired proof gaps and +research coverage, and [current validation](VALIDATION.md) for executed +checks and their limits. The [earlier publication receipt](../mixed-root-source-composition/PUBLICATION.md) +remains a historical checkpoint. Source receipts retain the status +at the time they were made; publication does not alter frozen evidence. + +## Open next questions + +- Independently review the mixed-root identity, the global normalization + and the complete native-to-caller binding. +- Check all target debits from PR6353 and PR6375 before reviewing the + moment and compiler calculations. They occur at all 18 native calls. +- Review the free-parameter classification. A larger root gain must + leave the proved minimum-idle family or change the fixed source. +- Develop an exact higher-cost root or a different child interface with + a favorable complete invoice. The bounded searches do not exclude them. + +Ali Romman with substantial OpenAI Codex assistance; no subagents. +Apache-2.0. All predecessor credit remains in `NOTICE` and the archives. diff --git a/research/mixed-root-contact-composition/RESEARCH-MAP.md b/research/mixed-root-contact-composition/RESEARCH-MAP.md new file mode 100644 index 0000000000..5a78ca64c2 --- /dev/null +++ b/research/mixed-root-contact-composition/RESEARCH-MAP.md @@ -0,0 +1,177 @@ +# Review map for the mixed-root contribution + +This map separates the new caller, later source compositions, exact +limits and exploratory evidence. Publication was authorized on 2026-11-02. +The earlier local checkpoints remain part of the evidence history. A source +mechanism from another PR is credited to that PR, not claimed as new here. + +## Numerical progression + +| Checkpoint | Complete conditional kappa | What changed | +| --- | ---: | --- | +| First mixed root, commit 1d49e6c75 | 0.00327980 | New six-field mixed full/thin caller with paid higher-rank projectors | +| Optimized root, commit 52e87e497 | 0.00328467 | Ranks 2,3,3,2 and children 7,2,2,7; all-size fixed-root ceiling | +| PR6353 composition, commit 24f03629f | 0.00328551 | Nine native output contractions, with all productive debits | +| PR6372 composition, commit 7c71f5999 | 0.00328584 | Two more source contractions at all 18 calls | +| PR6375 composition, commit 3e6d2b839 | 0.00328620 | Six shared-carrier input lifts at all 18 calls | +| Exact raw-limit refinement | 0.00328621476572836015146308 | Same invoice; exact optimum proof, tighter completion and compiler parameters | + +The final caller gain over the pinned PR6375 claim 0.00315120 is about +4.284551 percent. The increase from the first local mixed root is about +0.195584 percent. The last source composition added 0.0109561 percent. +The final parameter refinement adds about 0.000449325 percent over +0.00328620; it changes no construction or invoice. These are different +comparisons. None is a wall-clock speedup. + +## Earlier published work from this investigation + +These checkpoints precede the new mixed root. Their linked packages +remain the evidence for their own results. They are not new files or +extra gains in this contribution. The source notices also retain the +native advances from other investigations. + +| Checkpoint | Result | Useful step retained here | +| --- | --- | --- | +| [PR5580](https://github.com/CrocSwap/integer-mult-bounds/pull/5580), head `6efa248cf456d6101d757e9d09ba29711d18a13a` | Conditional kappa 0.00308189 | One contact replaces two rank-three transports by ranks two and four, with fixed targets | +| [PR5751](https://github.com/CrocSwap/integer-mult-bounds/pull/5751), head `8483f9a679d06c1e270141dbc686a7e76e7a7522` | Conditional kappa 0.00311301600 | Paid intermediate meetings create 23 independent helper splits; all 27 added local queries are charged | +| [PR5786](https://github.com/CrocSwap/integer-mult-bounds/pull/5786), head `6b936acd68a7e0f9062037900f0fe9bc4b6fdd25` | Conditional kappa 0.00312265044 | Three asynchronous helper exchanges use a retained buffer and four paid subdivisions | +| [PR6171](https://github.com/CrocSwap/integer-mult-bounds/pull/6171), head `343232cdf5273d1f77569de390f0977b46916644` | Scoped all-width proof; no kappa | With fixed repeated public and productive boundaries, one coordinate flag and concavity reduce the contact-graph price to one copy | +| [PR6350](https://github.com/CrocSwap/integer-mult-bounds/pull/6350), head `466c812fe729ed540265eeaeabc5e4a71d3440c5` | Conditional kappa 0.00314980 | Complete composition of PR6349 input lifts and the PR6348 binary query tree, with four helper debits at each of 19 calls | + +PR6171 credits Cinna Davis's PR5140 Clifford projection inequality. +Its theorem excludes changed scalar words, variable productive boundaries +and fixed internal operator equations. It is not a P104 optimum. PR6350 +keeps both source constructions unchanged. These distinctions explain why +the later mixed-root caller is a new route rather than another contact edit. + +## Review the positive result in this order + +1. [Root and normalization](../mixed-projector-query-root/PROOF.md). + Check the seven-query endpoint, four independent stage projectors, + complete-field normalization and all Gaussian outputs. +2. [Literal root and caller](../mixed-projector-query-root/ROOT.json), + [controller](../mixed-projector-query-root/CONTROLLER.json). + Check the 570 events and the matched 7,2,2,7 child trees. +3. [PR6353 composition](../mixed-root-source-composition/PROOF.md). + This retains the exact original root and executable native closure. +4. [Final composition](PROOF.md). Check both source reconstructions, + all six changed helper inputs, every productive debit and all 18 + copies of each source change before reading the scalar moments. +5. [Exact raw limit](OPTIMALITY.md). Check the signed invoice, all-size + comparisons and every competing seven-leaf tree histogram. The complete + point is less than 2e-26 below the raw limit; equality is not certified. +6. [Final receipt](RESULT.json). Check native phases and physical + contacts, both price engines, ordinary costs, completion, compiler + and all outer inequalities. Read [validation](VALIDATION.md) for + what was actually run. + +## Exact structural and supplementary results + +| Result | Evidence | Limit | +| --- | --- | --- | +| Exact raw optimum and strict approach | [OPTIMALITY.md](OPTIMALITY.md) | Fixed PR6375 source and classified root family; no endpoint-equality certificate | +| Minimum-idle family classification | [PROOF.md](../mixed-projector-root-headroom/PROOF.md) | S on all six outputs; scalar bases independent of S and stages; seven square-zero queries, four distinct independent forward full stages, at most two extra whole idles | +| General rank-two restriction and six-field idle floors | Same proof | Stated constant scalar model; no universal lower bound for other interfaces | +| All-width normalization and its tensor counterexample | Same proof and exact replay | Uses the actual binary translation relation q squared equals X | +| Separate reverse caller | [caller_reverse.py](../mixed-projector-root-headroom/caller_reverse.py) | Formal endpoint; native maps, price and compiler remain separate checks | +| Extra central-free fields give no price gain | [EXTENSIONS.md](../mixed-projector-root-headroom/EXTENSIONS.md) | Exactly r+1 square-zero queries on r active fields; paid idles | +| Seven rank-four fifth-stage patterns all lose | Same extension proof | Retains two rank-two endpoints and two rank-three stages; all binary sizes and shapes | +| Three-field helper module and all-size price exclusion | [BOUNDARY-MODULES.md](../mixed-projector-root-headroom/BOUNDARY-MODULES.md) | One matching middle helper is consumed and debited; no complete physical caller | +| Five-call border, inverse formula and exact-star obstruction | Same boundary proof | Two nonzero errors remain; direct recovery loses for all binary sizes | + +The uncorrected border's fixed 6,6,6 formal invoice has crossing +(0.00336581875184,0.00336581875185) with PR6375. It is excluded from the +complete-kappa table. A new recursive precision and recovery construction +must pay its remaining costs before that number can support a kappa claim. + +## Other research retained as bounded evidence + +The earlier source-word work is retained in the +[canonical finding](https://github.com/CrocSwap/integer-mult-bounds/discussions/5600#discussioncomment-19209322) +and local research records. It includes the following results and limits. + +| Route | Result and scope | +| --- | --- | +| Retirement and query replacement | 20,327 anchor evaluations found no qualifying gain on the stated PR5684 source; finite search only | +| Coupled boundaries and changed scalar stops | Nine apparent protected-block repairs lose an arbitrary public input; exact null witnesses reject them, as detailed below | +| Coupled frame searches | Two-copy lines and heights, single Clifford directions and 25 plane models found no gain in their rounded models; no exact global price lower bound | +| Unpaired six-field and residual-query callers | Exact formal endpoints exist, but their proposed complete prices lose; a residual query prevents the proposed whole-idle merge | +| Full suppliers at internal binary nodes | Numerical search through 150 stages keeps the published binary tree; no all-size exclusion | +| Causal public and transposed prefixes | Four feasible public-prefix words lose; none of 712 constructed transposed candidates has feasible frames | +| Owned terminal prefixes | All 16 modular endpoint survivors fail the frame constraints; six reserved-role variants were excluded from the search | +| Private historical reconstruction and capture | No cheaper reconstruction at 24 unprotected owned moves; 135 intermediate hyperplanes fail membership; the general modular search is not a rational impossibility proof | +| Ten-term decoder | One factorization and orientation has copied-rank cost 72 on P104; other orientations and complete physical implementations remain open | + +For the nine changed-word failures, the sources are PR6167 at +`564a076b113621a93edc4e39968ee4e4a8c9caf0` and PR6169 at +`66f4d2d7f8269fb058c3759c019e677516891082`. Each changed 22,704-event +scalar word sends a nonzero public input vector to zero, although the +required target does not. With e_j the public coordinate vectors, the +inputs are `2e173-2e469-2e471+4e549-e703-e704` for case 0, +`e585-e769` for cases 1 through 7, and `e585` for case 8. Invertible +entrance and exit bases preserve rank, so they cannot repair these nine +words. The retained `replay_null.py` checks the exact edits and vectors +on all 799 scalar coordinates, with a live-input rejection control. +This is a source-specific rejection, not a full native or compiler check. +The old local archive and receipt remain separate; they are not inputs +to the new registered kappa replay. Other changes to the word remain open. + +The [original search note](../mixed-projector-query-root/SEARCH.md) +records the finite basis catalogue, child-size discovery, structured +larger roots, braid moves, coupled copies and internal-query tests. +The original scripts and logs remain in the local work directories. +They are not required to accept the exact positive result. + +The later local searches also covered common advancing stages, period +two and three stage hypotheses, nested ten-field bases, coincident +endpoint projectors, helper-reflection interfaces and a fixed triangle +query tuple. No better complete caller emerged. An early period-three +candidate used a stage-dependent basis and was rejected. The original +fixed-parameter fifth-stage test was replaced by the all-parameter +classification; its narrower scope is not used as a universal proof. + +The old seven-mask integer solver timed out with positive upper bounds. +Its retained receipt is now discovery history. The new exact recurrence +and tail proof supply the exclusion. Similarly, the direct border +correction was first tested only through child size 64; the new exact +bound covers all positive sizes and shapes. The fixed triangle tuple +check does not exclude all triangles. + +These bounded searches are not converted into global impossibility +claims. The useful identities and all-size bounds are now in registered +replays; raw exploratory logs are kept separate from acceptance evidence. + +## Open next questions + +- Independently review the conditional construction and structural proofs. +- Test five-full roots with only one rank-two projector, other field or + query counts, or a new child interface with a full invoice. +- Find an affordable border recovery and prove its recursive precision + transfer in the actual chronological compiler. + +## Adjacent work at the final review + +The review read the following open PR descriptions and exact heads. These +are scope and attribution checks, not reviews of their mathematical proofs. +None of their code is imported into this result. + +- Nick Petalas's [PR6391](https://github.com/CrocSwap/integer-mult-bounds/pull/6391), + head `e384ae7181f085f92d21e3578976e3231c76e26d`, prices signed idle + completion for ABC,ABC,AB,AB,BC,BC. It credits the released overlapping + AB/BC proposal from this investigation. It supplies no operator word. + Its three-stage target differs from this four-stage mixed root. +- Nick Petalas's [PR6384](https://github.com/CrocSwap/integer-mult-bounds/pull/6384), + head `9a8eac9de8bf60cd573edbb6ea835e0febd49e89`, gives a source-rank + sensitive mirror criterion for a conditional capped-flow compiler, + with a critical-root corollary for its stated contracts. It does not + certify this native source at k*. The nonattainment statement here + concerns this package's strict completion argument, not every compiler. +- Nick Petalas's [PR6390](https://github.com/CrocSwap/integer-mult-bounds/pull/6390), + head `f9e68f40b0da7236a7fad415f7172218c0666d27`, sharpens the direct + higher-moment split coefficient. It may reduce completion constants. + The conservative tail used here remains fully charged and strict; + a sharper split coefficient does not change this raw signed invoice. + +No selected-frontier change, merge or closure is part of this contribution. +Prepared by Ali Romman with +substantial OpenAI Codex assistance; no subagents. Apache-2.0. diff --git a/research/mixed-root-contact-composition/RESULT.json b/research/mixed-root-contact-composition/RESULT.json new file mode 100644 index 0000000000..be12d2101b --- /dev/null +++ b/research/mixed-root-contact-composition/RESULT.json @@ -0,0 +1,498 @@ +{ + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "binary": { + "coefficients": 16, + "identity": "L S A B Idle S^-1 C R = D_A D_B (U(q) direct-sum q direct-sum q^-1)", + "missing_idle_rejected": true, + "variables": [ + "q", + "D_A", + "D_B" + ] + }, + "caller": { + "coefficients": 1156, + "event_sha256": "be648c29aa09c0f068a3b5b5120d1eb1f782e49f4523b4c6d62843750517bdea", + "events": 570, + "inputs": 34, + "native_stages": 18 + }, + "columns": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 638401, + "columns": 799 + }, + "contact_source_head": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "controls": { + "damaged_research/p104-contact-block-contraction/BASIS.json": "Exact source SHA256: research/p104-contact-block-contraction/BASIS.json", + "damaged_research/p104-contact-block-contraction/NOTICE": "Exact source SHA256: research/p104-contact-block-contraction/NOTICE", + "damaged_research/p104-contact-block-contraction/PROOF.md": "Exact source SHA256: research/p104-contact-block-contraction/PROOF.md", + "damaged_research/p104-contact-block-contraction/RESULT.json": "Exact source SHA256: research/p104-contact-block-contraction/RESULT.json", + "damaged_research/p104-contact-block-contraction/WORD.json.gz": "Exact source SHA256: research/p104-contact-block-contraction/WORD.json.gz", + "damaged_research/p104-contact-block-contraction/construct.py": "Exact source SHA256: research/p104-contact-block-contraction/construct.py", + "damaged_research/p104-contact-block-contraction/inputs/pr6353-WORD.json.gz": "Exact source SHA256: research/p104-contact-block-contraction/inputs/pr6353-WORD.json.gz", + "damaged_research/p104-contact-block-contraction/inputs/pr6353-construct.py": "Exact source SHA256: research/p104-contact-block-contraction/inputs/pr6353-construct.py", + "damaged_research/p104-shared-carrier-lifts/LIFTS.json": "Exact source SHA256: research/p104-shared-carrier-lifts/LIFTS.json", + "damaged_research/p104-shared-carrier-lifts/NOTICE": "Exact source SHA256: research/p104-shared-carrier-lifts/NOTICE", + "damaged_research/p104-shared-carrier-lifts/PROOF.md": "Exact source SHA256: research/p104-shared-carrier-lifts/PROOF.md", + "damaged_research/p104-shared-carrier-lifts/RESULT.json": "Exact source SHA256: research/p104-shared-carrier-lifts/RESULT.json", + "damaged_research/p104-shared-carrier-lifts/WORD.json.gz": "Exact source SHA256: research/p104-shared-carrier-lifts/WORD.json.gz", + "damaged_research/p104-shared-carrier-lifts/construct.py": "Exact source SHA256: research/p104-shared-carrier-lifts/construct.py", + "damaged_research/p104-shared-carrier-lifts/inputs/pr6372-WORD.json.gz": "Exact source SHA256: research/p104-shared-carrier-lifts/inputs/pr6372-WORD.json.gz", + "first_lift_delivery": "All public and owned rows", + "last_lift_restore": "All public and owned rows", + "lift_response_sign": "All public and owned rows", + "missing_departure_basis": "All public and owned rows", + "missing_departure_inverse": "All public and owned rows", + "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_input_basis": "All public and owned rows", + "missing_input_correction": "All public and owned rows", + "missing_lambda": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_local": "Every native stage exactly once", + "missing_native_move": "Scalar destination and coefficient", + "missing_output_basis": "All public and owned rows", + "missing_output_correction": "All public and owned rows", + "missing_productive_debit": "All source helper targets have native maps", + "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_response": "All public and owned rows", + "missing_target_224": "All public and owned exits", + "missing_target_227": "All public and owned exits", + "missing_temporary_clear": "Scalar destination and coefficient", + "old_entrance_472": "Common scalar chart", + "old_entrance_520": "Common scalar chart", + "old_entrance_544": "Common scalar chart", + "old_entrance_624": "Common scalar chart", + "old_entrance_655": "Common scalar chart", + "old_entrance_671": "Common scalar chart", + "unpaid_native_move": "All independent fields and paid calls" + }, + "fixed_root_ceiling": { + "admitted_saving_cap": "17/5000", + "binary_split_checks": 4851, + "ceiling": "32862147657283601514631/10000000000000000000000000", + "finite_margin_upper": "-6527039332418184339015402951951839525/326409290240107399719461050006798653637322483112129794670592", + "finite_pair_checks": 4656, + "first_tail_total": 100, + "native_derivative_lower": "86090083256538702783244087644124346134578003527805299758509044352709856725086450055486661885342093126567137211366659267/2048904322212512919038510085207467917864146442064203226733311257020777532117854951793541845254015613321944655495954432", + "scope": "All positive integer child sizes and all binary tree shapes for this fixed root and PR6375 source.", + "tail_derivative_upper": "-215612333462792056547397343938407895404584315871663362184364306687376197353445352058659/3640381612305997808933701691778949109269500656184000075624611840000000000000000000000000", + "tail_margin_upper": "-302669528663079740144033662430286325431402316858105929255045/163204645120053699859730525003399326818661241556064897335296" + }, + "gain_over_pr6375": "3375369143209003786577/25000000000000000000000000", + "immediate_source_margin_upper": "-259918532464632736108796703442815743985223955544406661797/3138550867693340381917894711603833208051177722232017256448", + "lift_paid_delta": { + "1": 6, + "3": -3, + "4": 3, + "5": -3 + }, + "lift_target_delta": { + "8": 6, + "9": -6 + }, + "local": { + "endpoint_coefficients": 638401, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 15, + "6": 3, + "7": 9, + "8": 38, + "9": 364 + }, + "owned_fields": 29, + "owned_lifetimes": 43, + "paid": { + "1": 2237, + "2": 453, + "3": 491, + "4": 109, + "5": 151, + "6": 8, + "7": 9, + "8": 1 + }, + "paid_rank_mass": 5926, + "peak_owned_fields": 13, + "public_inputs": 770, + "real_scalar_allowance": 129670 + }, + "native": { + "distinct_maps": 2941, + "helper_normalizers": 1124, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 15, + "6": 3, + "7": 9, + "8": 38, + "9": 364 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "cc31dd00f0db04d7fdb4f860c264ec534fe4790f7adb8fd02fd93f1a8a2059e0", + "wrong_phase_rejected": true + }, + "native_events": 17768, + "paid_delta": { + "1": 6, + "3": -3, + "4": 5, + "5": -5 + }, + "physical": { + "central_square_columns": 53248, + "central_translations": 16, + "full_calls": 18, + "main_targets": { + "1": 104, + "145": 104, + "17": 1872, + "25": 416, + "33": 416, + "57": 416, + "73": 208 + }, + "new_paid_jobs": 0, + "ordinary_normalizations": 20, + "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 + } + }, + "price": { + "compiler": { + "H": 317427600000000000000000000000000, + "N": "2^317427600000000000000000000000000", + "eta": { + "lower": "0.000000000000022979952894151607", + "upper": "0.000000000000022979952894151608" + }, + "gap": "1/1400000000000000000000000000", + "integer_test_exponent": 226734, + "logarithm_power": 2100, + "theta": "63/64", + "uniform_saving": "2300350336009852106024159/700000000000000000000000000", + "word_materialized": false + }, + "derivative_upper": "-177683760993455684326832397037859249221501509146420924227601237/784637716923335095479473677900958302012794430558004314112", + "full_forward_calls": 18, + "gain": "369143209003786577/25000000000000000000000000", + "kappa": "82155369143209003786577/25000000000000000000000000", + "kappa_decimal": "0.00328621476572836015146308", + "margin_at_previous": { + "lower": "0.003392307759472651826068180441", + "upper": "0.003392307759472651826068180442" + }, + "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": 5379000, + "local_scalar": 129670, + "paid_rank_mass": 184980, + "peak_owned_fields": 13, + "raw_budget": 1000000000, + "raw_scalar_upper": 248152864, + "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": "348599999999999999999999999253/350000000000000000000000000000", + "fixed_halo_explicit_metadata_branch": "26950000000000000000000000001/350000000000000000000000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799999999999999999999997009/1400000000000000000000000000000", + "new_semantic_group_guard": "3/1400000000000000000000000000" + }, + "margins": { + "boundary_algebraic_matrix": "1288196188165517179373528479079859865596059157590337/392000000000000000000000000000000000000000000000000000", + "fused_gaussian": "1288196188165517179373528477239579596788177472771011/392000000000000000000000000000000000000000000000000000", + "global_coordinate_router": "1150175168004926053012079/350000000000000000000000000", + "group_bit_router": "1610245235206896474216910946549474495985221840963763/490000000000000000000000000000000000000000000000000000", + "group_scans": "699999999999999999999999999/700000000000000000000000000", + "main_transform": "1288196188165517179373528199079859865596059157590337/392000000000000000000000000000000000000000000000000000", + "microbox_face_corrections": "26950000000000000000000000001/350000000000000000000000000", + "polynomial_products": "1399999999999999999999999999/1400000000000000000000000000", + "sparse_union_movement": "160538196188165517179373528479079859865596059157590337/392000000000000000000000000000000000000000000000000000" + }, + "parameters": { + "a": "1150175168004926053012079/350000000000000000000000000", + "b": "4600700672019704212048317/1400000000000000000000000000", + "beta": "1399999999999999999999999997/1400000000000000000000000000", + "bit_saving": "17/5000", + "cap_xi": "356538196188165517179373528199079859865596059157590337/392000000000000000000000000000000000000000000000000000", + "complex_uniform_saving": "2300350336009852106024159/700000000000000000000000000", + "d": "1/1400000000000000000000000000", + "epsilon": "1399999999999999999999999999/1400000000000000000000000000", + "kappa": "82155369143209003786577/25000000000000000000000000", + "lambda_": "398685514093708655939414767/400000000000000000000000000", + "lambda_prime": "279079859865596059157590337/280000000000000000000000000", + "layout": "1/1400000000000000000000000000", + "q": "920140134403940842409663/280000000000000000000000000", + "r0": "1/14000000000000000000000000000", + "stop": "1/1400000000000000000000000000", + "tested_saving": "657242953145672030292617/200000000000000000000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "39824831995073946987921/350000000000000000000000000", + "actual_logarithmic_gamma_guard": "1/1400000000000000000000000000", + "actual_logarithmic_group_guard": "35461803811834482820626472220920140134403940842409663/196000000000000000000000000000000000000000000000000000", + "alpha_logarithm_absorption": "1/14000000000000000000000000000", + "boundary_algebraic_matrix_above_kappa": "1119079859865596059157590337/392000000000000000000000000000000000000000000000000000", + "cap_above_band": "160538196188165517179373528199079859865596059157590337/392000000000000000000000000000000000000000000000000000", + "cap_below_cell": "35461803811834482820626471520920140134403940842409663/392000000000000000000000000000000000000000000000000000", + "cap_below_phase_cell_power": "427461803811834482820626471800920140134403940842409663/392000000000000000000000000000000000000000000000000000", + "complex_above_effective": "1/1400000000000000000000000000", + "complex_below_one_over_32": "39149299327980295787951683/1400000000000000000000000000", + "complex_endpoint": "1/700000000000000000000000000", + "epsilon_below_one": "1/1400000000000000000000000000", + "epsilon_positive": "1399999999999999999999999999/1400000000000000000000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "1117239579596788177472771011/392000000000000000000000000000000000000000000000000000", + "gaussian_above_main": "139079859865596059157590337/196000000000000000000000000000000000000000000000000000", + "global_coordinate_router_above_kappa": "1/350000000000000000000000000", + "global_gamma_power_slack": "9/14000000000000000000000000000", + "group_below_dimension": "1/700000000000000000000000000", + "group_bit_router_above_kappa": "1746549474495985221840963763/490000000000000000000000000000000000000000000000000000", + "group_gauge_power_slack": "35461803811834482820626472206920140134403940842409663/196000000000000000000000000000000000000000000000000000", + "group_key_fits_record": "1/700000000000000000000000000", + "group_positive": "1399999999999999999999999997/1400000000000000000000000000", + "group_scans_above_kappa": "697699649663990147893975843/700000000000000000000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "38881108663229911218127/25000000000000000000000000", + "lambda_above_internal": "1/2800000000000000000000000000", + "lambda_above_sigma": "3/2800000000000000000000000000", + "lambda_above_tau": "1/2800000000000000000000000000", + "lambda_prime_above_lambda": "1/2800000000000000000000000000", + "lambda_prime_above_leaf": "2795399299327980295787951683/1960000000000000000000000000000000000000000000000000000", + "leaf_saving_above_effective": "1395399299327980295787951683/1960000000000000000000000000000000000000000000000000000", + "main_transform_above_kappa": "839079859865596059157590337/392000000000000000000000000000000000000000000000000000", + "membership_arithmetic_fits_record": "1/1400000000000000000000000000", + "microbox_face_corrections_above_kappa": "26948849824831995073946987923/350000000000000000000000000", + "microbox_halo_volume": "110600000000000000000000000003/1400000000000000000000000000", + "new_complex_uniform_saving_above_b": "1/1400000000000000000000000000", + "new_semantic_guard_with_C1_one": "1/1400000000000000000000000000", + "polynomial_products_above_kappa": "1395399299327980295787951687/1400000000000000000000000000", + "positive_layout_slack": "1/1400000000000000000000000000", + "q_below_effective": "1/1400000000000000000000000000", + "q_below_internal": "1/1400000000000000000000000000", + "q_below_leaf": "2795399299327980295787951683/1960000000000000000000000000000000000000000000000000000", + "q_positive": "920140134403940842409663/280000000000000000000000000", + "short_record_fallback": "1395399299327980295787951683/1400000000000000000000000000", + "source_axis_superpolynomial": "1/1400000000000000000000000000", + "sparse_union_movement_above_kappa": "159250000000000000000000001119079859865596059157590337/392000000000000000000000000000000000000000000000000000", + "stop_below_one": "1399999999999999999999999999/1400000000000000000000000000", + "stop_positive": "1/1400000000000000000000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000000000000000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000000000000000000000", + "union_tag_work_per_visit_fits_record": "3/1400000000000000000000000000" + } + }, + "paid": { + "1": 42034, + "16": 1872, + "2": 8154, + "24": 416, + "3": 8838, + "32": 416, + "4": 1962, + "5": 2718, + "56": 416, + "6": 144, + "7": 162, + "8": 18 + }, + "paid_calls": 67150, + "previous_fixed_root": "16431/5000000", + "productive_fields": 13652, + "rank_mass_surplus": 760, + "raw_endpoint_margins": { + "lower": { + "first": { + "lower": "0.000000000000000000000217785079", + "upper": "0.000000000000000000000217785080" + }, + "second": { + "lower": "0.000000000000000000000217785079", + "upper": "0.000000000000000000000217785080" + } + }, + "upper": { + "first": { + "lower": "-0.000000000000000000002079634713", + "upper": "-0.000000000000000000002079634712" + }, + "second": { + "lower": "-0.000000000000000000002079634713", + "upper": "-0.000000000000000000002079634712" + } + } + }, + "raw_headroom": [ + "1/100000000000000000000000000", + "1/50000000000000000000000000" + ], + "raw_root_interval": [ + "328621476572836015146309/100000000000000000000000000", + "32862147657283601514631/10000000000000000000000000" + ], + "refinement_kind": "Same complete invoice; finer strictification and compiler parameters.", + "relative_gain_percent": "369143209003786577/821550000000000000000", + "strictification": { + "alpha": { + "lower": "0.999999999999999999999999992569", + "upper": "0.999999999999999999999999992570" + }, + "coarse_tail_upper": "1/288230376151711744", + "cutoff": 12, + "delta": { + "lower": "0.957248382250720020032251696120", + "upper": "0.957248382250720020032251696121" + }, + "exact_tail_upper": "25968816751883113995464804882194607929411683780884226645678925307002110843550133104420123760101479474839221201004686329940160027670126004133743828536680673994452725629745611397250341115761363323607003552687034005960488068717359911143395851784415362067355137094922219194655890106807315973377901994681558011665956719293922523423896736235903448997789236780141543787761778864696595800906890151999691226382701024017325569269316595526470733042482962997961321816289689038860231064735268262348181833735526073481800371738520564423855188853455070167523225315015758774805697502433771984614850668873883495604089682521242370834384375582830712704865727861176177048771394427407255002047824069363883041195805737568221434593424664912374095681332409910102117819689183603716909776665801384439952751837667700413070379263323130466094707734337887831258005980440847552037834301818581649745499092009029235117704964733313829410497453470070887466638307413753043426496924817422338541543232280481901189410625113352540990925659205592694157405025696376596135904922863017205099824220302784597597394276398809139342815771451800330237414693097687353116020292427829621137741888194987614319546272900374357630911060621372780363425799229823027419399322430473329066822665185057155378959634917707139348139444417502434894646589809020275954413976196338353104990927739225086991331116260532892993604070852131850799788364871935788080589906984695519250577337599768456831251607249423700889021932369256023863626543373232166438214597277750913930476188423662975734340573982417743812475341013829410134208659166050139798547596876083645842576454904158460099622845601362359202659966547393643799328843973215865146723977900950651432448361170601246192090126412244869008028749978164391847944132606805504798364996996014218459024410664453957811779516913670216928724470380796391020353614030246272618410655142564538377734059025000305119155917226445867387899027040451866939956717377831530119449900953585057952699220008085352148706159738644321313531284032818479141559396247029143750425762501948430437369399481810562584909868262778814839240692102964314788286773148559517247633145270422345099190454145942630831266195509922086728349392801157236390281356642879102356486891062424937470616665957496696759574300833108099958404347149016512657584919622710050001356487455986180867964952023672761039188124022692190974214751766725701356295495524587296011840901864611875504808599874948117351460747134887391055383954183357815228423956967508253485665094444536753140118928942192591489028112227793683148117180821470944630106089051895287977293005179296095836333159834273766684727267011939930469961979884670796085309878886992937168024435902854601180811049624073160626754017381247943964404431354002824473361814782176441811959489344592309505051971888333364522225539320640095711622097910757473509357949732179456944382304691192060425703256673043353601/1931516324011626346020150553929126181823590488535040186824856567180029479223493376445786096950954795100702784533083281033646760271068018983122291972202644881704691011563710483989867650744695251376055025107666230739164093587389628866535770117611912392089755082590080472028477987071289165684289011377905352698232800507758208042820675070709030399021754206793830358905406733535942588887996076001927509337965834979072536427646331464401971792582375342958569384054354332096896759837269698218889565287567707539585095032991822857620010464317015726455734074643321122388044097708028635229432698100703335425310388288440000351711930613276786493722293418289870150700918405798037757934100708219508469592822795997483826085672921016197325327430119841909503482096760772795264133044082205866449934298354644012164798932775556083457809449912592220889802005953323685819720454613153020534455067493961231922206456679179219662713499049824991117775198073492812006682664088284693545727589314279309950009246830913459976142947529615742696134568887882410861948007763929800878314246201090904986140186077798864508547948608132255423035988434446214058699770626557465193128157512845357439793247851632224246499990611115646221003615087011758590423628181610786764420573006921761893949737802418426782447136548014140198447242737897751623530788833864390071832506056728849302290191408954510946220861486311039370054837095614883730158737099345289640173098512240742485291913040000974074836991713791813260339229632451698438087840996110693416312325768841145996367942811788448367825625035192908389092377054549306070546491079416016630873092882144703817485287986047453762937574793229088607594726623087172119290857442922186749727030568744100000419699941602816789656590538128654775884335322288115044042902368007647928447785494309683729219830178145535848830929931533192822883913681010006628877851664234722515418098809600795075237161618710226944692109669822041946629850162941173319519204709693533513108874099949758590208958136931346480022816743599142611017726137114510998217900038246478615246956350952278485410366122587953267937544436255099465307497011848059680873269896755574862120101016159541436240691657472394148008527677335225016052476207952397501417607437147877605303564057067564064530504494183216739444916912001687735183605267399161590281721705618193211199161475332334316832897783160549981482614788840809957569982115145402182575160480094711317055554905021931999461941405791251356057108718863869053217661463840775172788114991998596171377364481496742568202736663003363999728620841731079859176245940071187874843669264882594126717901436208421673886795099603467547525863026278936933835810347290598467230778790873267966902348777280946055188109006665306325326165168038148974262863542508287344559517219458554951908638902157539612839480289421087336446182774503962079866786903470546386259662184092799534574936219344193317288975481261643484673081344", + "floor": 13, + "gamma": { + "lower": "0.924056325562645239412345490543", + "upper": "0.924056325562645239412345490544" + }, + "normalized_paid_upper": "301799425626816616565648528109053583391672575624975869940741583241797183286245900040809945102717848691873044685714521183696004886382003883466377478245092103887149130513292792459855142440109413906745988535460631248884298173458126368768624796293092869362168408912319796533556160583862533407322260438866742613153280686291990643354490224551943523228527424469436028309041589787129548101074311423426114310610596031813033352108087503397245815968572344741673665372616954254810895105816503554164534346982552051911285959875500423372269822385628835948047846968612629126601819504076701291377728006835633485157565813415491483591792647779464628140235411130837708133364924768325881139107648021966692253445739473110504978176401317390484720917763472170087399053284025621752849515588491115354784312114796037285675219539609263405190913495242614266526211760606148610764084636759992186514237315506545921016082951398642312212707669421504838229936571461184333857636630398207131411209275958949082326107455705488444588407064614885594862057760009464516285110015266189625072421731933680573645919460633395409485478933665135896635962123550978028198469956423067761387237891161248504060152572651764417043315553904788275940972822138283460482007536285039454333744430731010515968501887788002878120512905009639562367117756114778018290345960701258650801580441748371168100479507364802657842858038646646132252116044115722627476253140838312498329226086525341379050630911210225440926822289249592206382470693285625307402300632605045915432124015120531477460701485675348813313885703492348411977021656461528309955456511882087030695278147846402385996123408872905124876546080259052247878909372748370715537990123188801158439727097722818570075649321843091996462220691948638857990271688415748735990268957977072732719576542723594407150217919974318537795754697935266273409814901132885468100151160477578371433469178015962157592357715183237537996405238471421253995257942319696663713231624595453865406519280636797623587967147499366372116604250177877350232354938419461919717913462777631887824492739295756328953000703580767618425429227902317519621684672164305220954227395374311394390766662610551662776418938907121788829304328236007254754887896625047228575905877802078036326720030589592784430857735637288740857800323458560625645576814021888519238251618574786255511355740282166374757739907368509692374989841088063538310820616230807172142631730012542741650950755936921860148020466043114790367272167323847793817214080973216016280043001603197094102740357442482718512416184262618729170472760291383183945838246607207075883495104473031191009853310272431836128093864425961960285207680233006875526939005517015421666422110223408105807078082966354186873810127771992121166952364000079535481712545174594176912418033247014664164087923589259194684161501915740939750272298890913108985116073608319238085545414021966707796667664104685841899011057001636482790107033732431277109770019130060803/301799425626816616565648529845974937944815051894051690978762384092651071733791400544223779188675124404964939420652553514371691594462731565362701221596944075970414919923705679731351465542931667718640049642675800787080143751194704833394906298369142073432910831262010426590186861749154179908411574113231672572966372132204254140406788574496687523121773223273561205706060999180253649895240463591521373941884928379468311822602267305210313029808605430276270859464408242137266147600281542509764490866872733814869265755573668184206249253804818806234177022023050318324179069634081698184562226242367189284290653858366844357064995434255662754964109401743584050877377982072823654546813687762053415767991835676908972484411802687249220074862434482317122967669594853039619546516648290956915120619910312259147367432595983533104214763043239332840699813803635175647107983702711177318479661755092806327303820459486955554182679993154524899690033687123749025519139617120077586998371850404134444543025454512996064110265401530200289011406317160469286026604301517738050883833554764477195873806709598811182733331928441223143245966718526066771068605429507569239764916787481398979640090556202007577051695852366563276928487596845559113100630566387530692975990303602409840762006824889598205522650767476422813262662025137933335219106350633039162417083941956249205076012623146660505533557514106674128434601134852410041770420781937212793121697833013827311362730333019447735915507411155709941930926854581553022326664936659984743653896215644952050264571313278922363996191900852720371161029018250204179101614398435883762221838974474583209730126140439193296893107513897909053079037323670095023326462298240771548906364884238837953832138365056531829616142272841702133540377763077289590017667822654200955684311615614595186713542250678596459308883989461551913012219059150603330361742791188416436064097825633679223209974049177769388910527361621178910291594922035887340641001575779165100246781536674763908800750248222145187352840886814240443765559148992592574268974714029190694975869924489993628084805552395236750972076774395957659218156211913892633901746817290549607750444826394738039679332657840364634104956758305703881175381851518145141602176210211784499685874388169629196526524143126819786740960461091777191172088541365869734486582222053658491447353751365842353859719912216320360603661511255069905351959649939313457549798697724744988726137001635158315200062295821547739449719235708303756939013671896447277339750127152765043300038718598211002277466117726369069447824711128691217006380427321985630637562900166643152513235723938573681192594114466746112926181119516469194722248009341745089341619987581379161700287398142484193742945932998500445175051473070287797224491404495415401701871488328989838760586862140667222881833650947961602792334897034684943242447463005821196364958455864860637688972943051516758104801022671940452512748911866926443784930454019244032", + "power": 1920, + "reserve": "1/100000000000000000000000000000", + "tail_decay": "31/32", + "tail_offset": "1/7", + "tested": "657242953145672030292617/200000000000000000000000000" + }, + "targets": { + "1": 356, + "145": 104, + "17": 1872, + "2": 144, + "25": 416, + "3": 72, + "33": 416, + "4": 1926, + "5": 270, + "57": 416, + "6": 54, + "7": 162, + "73": 208, + "8": 684, + "9": 6552 + }, + "thin_queries": 17, + "whole_idle_jobs": 3120 + }, + "prior_source_margin_upper": "-494431738852733860160625375187485047155589466552987117427/3138550867693340381917894711603833208051177722232017256448", + "raw_optimality": { + "certified_kappa_distance_upper": "1/50000000000000000000000000", + "lower_endpoint_tail_derivative_upper": "-2425638751456410636158155864644325160477772930092507518372866628520074812349834450754483/40954293138442475350504144032513177479281882382070000850776883200000000000000000000000000", + "lower_endpoint_tail_margin_upper": "-151334764331539870072005260405846188849785275992960950294577/81602322560026849929865262501699663409330620778032448667648", + "minimum_alternative_tree_cost_gap": "2235851046446919124101317406304064312790521250945764685/1569275433846670190958947355801916604025588861116008628224", + "minimum_size_profile_margin_gap": "14472794033883433065907589746016340854280764262874989079/326409290240107399719461050006798653637322483112129794670592", + "other_nine_leaf_split_margin_upper": "-3618198508470858268108657269608631298324041803724885069/81602322560026849929865262501699663409330620778032448667648", + "other_pair_total_checks": 4655, + "other_pair_total_margin_upper": "-164318042130818734205658871801729589939366105662110267847/163204645120053699859730525003399326818661241556064897335296", + "other_size_profile_margin_upper_on_bracket": "-3618198508470858268108657269608631298324041803724885069/81602322560026849929865262501699663409330620778032448667648", + "raw_limit_interval": [ + "328621476572836015146309/100000000000000000000000000", + "32862147657283601514631/10000000000000000000000000" + ], + "scope": "Fixed PR6375 source; six fields with S on every output, constant scalar bases independent of S and all stage variables, seven square-zero queries, four distinct independent forward full stages and at most two extra whole idles; every positive binary child size and binary tree shape; admitted saving range through .0034.", + "selected_per_port_margin_lower_on_bracket": "-6527039332418184339015402952024551197/326409290240107399719461050006798653637322483112129794670592", + "selected_seven_leaf_histogram": { + "2": 3, + "3": 1, + "4": 1, + "7": 1 + }, + "seven_leaf_histograms": 11, + "signed_invoice": { + "1": -41678, + "145": 104, + "16": -1872, + "17": 1872, + "2": -8010, + "24": -416, + "25": 416, + "3": -8766, + "32": -416, + "33": 416, + "4": -36, + "5": -2448, + "56": -416, + "57": 416, + "6": -90, + "73": 208, + "8": 666, + "9": 6552 + }, + "statement": "The exact family raw-funding supremum is the unique zero of the displayed signed invoice. At that zero the raw paid and productive moments are equal, so the strict compiler does not certify equality.", + "uniform_tail_delta_upper": "3496455225855653296339217460406544001835165903382562806420395660105956858559119475235679158925977644133898554603846238208/3652610221847176533903701006325614864185116251128151092511899219484291710160773591773659726550708062256846427479211745667", + "uniform_tail_gamma_upper": "1591486092595755002849201667864393463931761203231280454401826443528395058882597597535393334282206221959298686689357070336/1722282558508239116681146556917648442459425036100134342894275702295944228202509273793883266552950986504559706837544355757", + "unique_selected_sizes_up_to_pair_exchange": [ + 7, + 2, + 2, + 7 + ] + }, + "relative_gain_over_pr6375_percent": "3375369143209003786577/787800000000000000000", + "root": { + "actual_tensor_gaussian_columns": 14, + "fields": 6, + "full_sites": 4, + "gaussian_characters": 4, + "normalization_growth_per_operation_upper": 2, + "ordinary_normalization_operations_per_pair": 4, + "owned_normalization_fields": 0, + "polynomial_coefficients": 1152, + "stage_ranks": [ + 2, + 3, + 3, + 2 + ], + "tensor_rule": "Normalize the complete field with its global Q squared translation; scalar coefficients stay outside tensor powers.", + "thin_sites": 3, + "wrong_tensor_normalization_rejected": true + }, + "root_source": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "selected_frontier_changed": false, + "source_head": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "status": "PASS_MIXED_ROOT_CONTACT_COMPOSITION_KAPPA_00328621476572836015146308", + "target_delta": { + "8": 8, + "9": -8 + } +} diff --git a/research/mixed-root-contact-composition/REVIEW.md b/research/mixed-root-contact-composition/REVIEW.md new file mode 100644 index 0000000000..152de2e9f3 --- /dev/null +++ b/research/mixed-root-contact-composition/REVIEW.md @@ -0,0 +1,119 @@ +# Final author review + +The reviewed claim remains **kappa 0.00328621476572836015146308**, +about **4.284550829 percent** above pinned PR6375. This review changes +no native word, caller, invoice, completion parameter or compiler +parameter. At this review checkpoint, the selected frontier was unchanged +and the publication hold was in force. Publication was authorized afterward; +hosted CI is reported in the contribution PR. This is a further author +review, not independent scientific acceptance. + +## Gaps found and repaired + +| Finding | Repair | Effect on the result | +| --- | --- | --- | +| The family statement did not say that every output contains S | The theorem now requires endpoint S times a diagonal forward-stage mask on all six arbitrary fields | The positive root is in the stated class; mixed central endpoints are outside it | +| Commutation was stated without coefficient independence | The theorem now requires scalar bases independent of S and all stage variables | This justifies the derivative and common-basis arguments; variable-dependent bases are not excluded by the theorem | +| The family statement called the shared recursive bill the complete price | It now distinguishes the recursive invoice from the ordinary work of an arbitrary scalar basis | The ceiling still holds when extra ordinary work is omitted in favor of competitors; the actual word has its own complete ordinary budget | +| Negative competing margins did not by themselves prove dominance above the selected zero | A new rational guard compares the selected margin at the upper endpoint with every competing bound at the lower endpoint, including the infinite tail | A strict gap greater than 0.00004433 per port proves dominance throughout the bracket; the previous raw-crossing conclusion and kappa stay unchanged | +| The research map omitted earlier published results and exact rejection evidence | It now links five earlier PRs, records the nine null-input witnesses, and states the limits of the earlier search routes | Historical results receive credit without becoming new gains or premises of this construction | + +The clarified proof is pinned by exact commit, Git blob and SHA256 in +`SOURCES.json`. The complete receipt records the new profile comparison. +The supplementary package binds that revised receipt. Frozen source +archives and their original notices are unchanged. + +## Proof audit coverage + +The review traced the root-to-bound argument and the supplementary +claims in the linked proof files. + +- The normalization uses q^2=X, X^2=I and lambda^2=X. Its coefficients + act outside tensor powers. The four in-place scalar operations give + the stated whole-field map and its inverse without a recursive job. +- The shortest-query normal form uses all six central outputs. The + projector derivative test requires constant bases. The rank-two + restriction uses independent query columns and rows, not only column + containment. The endpoint parameter and its r=1 case remain covered. +- The complete invoice is assembled from the native word and emitted + caller. A separate sum uses the root masks and literal binary trees. + Every changed helper target is debited at all 18 native calls. +- The binary recurrence includes each whole idle at its actual child + rank. Monotonicity in k extends the finite exclusions in the needed + direction. The concave tail and its negative derivative cover every + total at least 100. The new comparison closes the stronger claim of + dominance on the whole bracket. +- The active-space argument needs exactly r+1 queries on r active + fields. It uses a common one-sided block containment. It does not + permit arbitrary cross-block query compression. The seven fifth-stage + masks retain two rank-two and two rank-three stages; other support + families remain open. + All-size extension and boundary price exclusions state their exact + tested savings. They are not claims for every concave tariff. +- The helper-module invoice includes the consumed helper debit. The + reflection border keeps both error entries. Its inverse uses the + stated nilpotent remainder identity. The five-call star obstruction + does not exclude triangle supports or larger query counts. Direct + correction is charged before the all-size price exclusion. +- The exact raw zero is a price limit. Strict completion below it pays + both tails. The compiler and outer transfer use the retained five + assumptions. No proof of endpoint equality, recursive border recovery + or physical erasure permission is supplied by these calculations. + +The proof audit is distinct from the finite replay. Exact matrix checks +corroborate the written quantified arguments; they do not replace them. +The price engines retain their predecessor authors' credit. This review +runs them as author-side checks. The separate reverse caller is another +implementation by the contribution's author. These runs do not constitute +independent human review. + +## Research and attribution audit + +The review compared the retained investigation checkpoints and research +notes with the package proofs, receipts and commit progression. A second +pass checked the public heads and descriptions of PR5580, PR5751, PR5786, +PR6171 and PR6350. The [research map](RESEARCH-MAP.md) gives their exact +heads, results and contribution boundaries. It also distinguishes the +original root, each source composition and the final parameter refinement. + +The nine null witnesses are useful exact negative evidence. Their +preserved local source files and narrow replay are separate from this +portable package. Earlier rounded, modular and time-limited searches +are labelled as bounded evidence. No failed search is used to prove a +universal obstruction. The uncorrected border price is excluded from +all complete-kappa tables. + +The final overlap pass read recent open PRs and active Discussion +comments. PR6391 concerns the released three-stage overlapping proposal; +PR6384 and PR6390 change separate compiler bounds. Their descriptions +were checked for scope and attribution. Their proofs were not audited +or used as new premises. Public snapshots do not cover unpublished work. + +## Verification and remaining obligations + +[VALIDATION.md](VALIDATION.md) and `VALIDATION.json` record the actual +registered runs, exported bytes, isolated process checks and document +review for this revision. The receipt comparison against the preceding +science result preserves every existing numerical field. Only the +optimality scope and three explicit comparison bounds are added there. + +The five assumptions are native_all_columns, owned_erasure, compiler, +precision_tape and analytic_recovery. They are not discharged. Hosted +CI, independent scientific review and formal proof-kernel review remain +unrun for this local contribution. The uniform word and rounded +multiplier are not materialized. Full-history ancestry checking is +unavailable in the shallow checkout; exact pins and source bytes are +checked. The exact family limit is not a global algorithmic ceiling. + +## Open next questions + +- Obtain independent review of the scoped classification and complete + native-to-caller proof before scientific acceptance. +- For a larger raw crossing, change a stated source or root hypothesis + and supply the complete new invoice. The present fixed family is exhausted. +- Assess different recovery or compiler methods under their own full + contracts. A formal border price or a compiler lemma alone is not a + complete kappa result. + +Ali Romman with substantial OpenAI Codex assistance; no subagents. +Apache-2.0. All retained source notices remain in force. diff --git a/research/mixed-root-contact-composition/SOURCES.json b/research/mixed-root-contact-composition/SOURCES.json new file mode 100644 index 0000000000..6a9f9904d0 --- /dev/null +++ b/research/mixed-root-contact-composition/SOURCES.json @@ -0,0 +1,83 @@ +{ + "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" + }, + { + "path": "research/mixed-root-source-composition/verify.py", + "usage": "input", + "git_blob": "e99f66fe38d35691fe72494ab876c8c73b5e4238", + "sha256": "3982ebe36924342345763cac8dc5fde50f23deccced56c528c6087d40e3034c4", + "pin": "head:24f03629fc2a939ea0c6c015017bf1cdc07e06cd:research/mixed-root-source-composition/verify.py" + }, + { + "path": "research/mixed-root-source-composition/INPUTS.json", + "usage": "input", + "git_blob": "0af459cf4ebe12bed27b6294bc1515dd37da62bf", + "sha256": "703ad732a3ec59b257477cc91e1bc340ce8c14942714828ce060eeeb878c6f7d", + "pin": "head:24f03629fc2a939ea0c6c015017bf1cdc07e06cd:research/mixed-root-source-composition/INPUTS.json" + }, + { + "path": "research/mixed-root-source-composition/sources.tar", + "usage": "input", + "git_blob": "9969dc140de46e7a9224947ea5b751e3486ff9eb", + "sha256": "6d05208f4fa1d98b4b63a8b2d9366576313a1f1466232a6a4f1a286de23c292b", + "pin": "head:24f03629fc2a939ea0c6c015017bf1cdc07e06cd:research/mixed-root-source-composition/sources.tar" + }, + { + "path": "research/mixed-root-source-composition/pricing.py", + "usage": "input", + "git_blob": "0ba26a7e590215a0b5646af603b4a1fe3ed6856d", + "sha256": "41fcff7b5375bd166048f10b3504d3080d37fadc51c723f2e98873fb9eb88069", + "pin": "head:24f03629fc2a939ea0c6c015017bf1cdc07e06cd:research/mixed-root-source-composition/pricing.py" + }, + { + "path": "research/mixed-root-source-composition/ceiling.py", + "usage": "input", + "git_blob": "66fa8646d1165b917f4ac92b54c5598e9ee51681", + "sha256": "c57bd8730a6e394e7f99e468ab913945bba03d68aa32f6d80bca8f68610cc920", + "pin": "head:24f03629fc2a939ea0c6c015017bf1cdc07e06cd:research/mixed-root-source-composition/ceiling.py" + }, + { + "path": "research/mixed-root-source-composition/RESULT.json", + "usage": "input", + "git_blob": "cc266a2e5c577ec5551230286fbeeff2938eef78", + "sha256": "9e41c15bd1f4e95b899d37672002e1fcf20cbf98a00b0ae007c389f3e1752c04", + "pin": "head:24f03629fc2a939ea0c6c015017bf1cdc07e06cd:research/mixed-root-source-composition/RESULT.json" + }, + { + "path": "research/mixed-projector-root-headroom/PROOF.md", + "usage": "provenance", + "pin": "head:e87c230f231441e2b53dec846ae9496c8c8d5121:research/mixed-projector-root-headroom/PROOF.md", + "git_blob": "f910b5fbf9a9d519fa7d7c7503de51df5a796368", + "sha256": "68be52ab098ff9dd6edfe938e5bf36d14d5f49aa1cac94a3d0784566c05363e9" + } + ], + "retained_predecessors": [ + { + "archive": "contact-source.tar", + "manifest": "CONTACT-INPUTS.json", + "archive_sha256": "4f41c4d246b354132d032546037d866a5199f7a3ea015915bf748a8d323cefb8", + "source_head": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "reason": "PR6372 is a separate pending source. Its exact constructor, word, witness, result and notices are retained. Runtime does not fetch it." + }, + { + "archive": "lift-source.tar", + "manifest": "LIFT-INPUTS.json", + "archive_sha256": "d9e6d7525c1b2d196c5c2db8f65b3b04c503faa3911e6c0ce83a83fc5d394b8a", + "source_head": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "reason": "PR6375 by DreamingOfClouds supplies the six shared-carrier lifts. Its exact word, constructor, lift data, source receipt, proof, notice and PR6372 input are retained. No runtime fetch." + } + ] +} diff --git a/research/mixed-root-contact-composition/TASK.json b/research/mixed-root-contact-composition/TASK.json new file mode 100644 index 0000000000..d7b27a71bb --- /dev/null +++ b/research/mixed-root-contact-composition/TASK.json @@ -0,0 +1,91 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 8, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "joint-query-controller", + "question": "Can a changed query demand or caller remove real work while satisfying native chronology and restoration?", + "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" + ], + "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": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "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": "Choose an exact caller and a new demand/interface hypothesis. Read the scoped #5617/#5631/#5649/#5747 and #5720/#5745 objections before rebuilding an excluded schedule. Compare the complete matched source/consumer protocols including all retained helper outputs. For an active-mode injection, first check #5745: its canonical delivery claim repays the eight removed centre jobs. Audit that exact claim or change its channel/feedback hypothesis; do not repeat the same free-injection search. Stop if the full favorable budget fails or the required restored output is unobservable.", + "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": [ + "query demand", + "active mode", + "5720", + "5745", + "5747", + "caller" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "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": "Compose the exact PR6372 contact contraction and PR6375 shared-carrier lifts with the mixed projector root, with complete native, caller, signed invoice, compiler and outer checks. Identify the exact raw family optimum and refine the same invoice to a complete point less than 2e-26 below it.", + "scope_change_reason": "The live overlap refresh found PR6375. Its unchanged main interface permits composition; all six changed helper entrances must be checked. The source construction remains credited to its author. The donor then asked to reach the proved ceiling. The exact raw zero replaces the earlier loose exclusion bound; the final parameter refinement is not a new construction step.", + "bottleneck_link": "The complex supplier binds. The source change reduces the full signed cost at every one of the eighteen native calls.", + "stop_rule": "Reject any changed root event, missing target debit, native phase failure, incomplete source closure, failed interval or compiler/outer bound. No PR or push before donor approval.", + "outcome": "completed", + "evidence": "PROOF.md, OPTIMALITY.md, RESULT.json, both retained source manifests and registered replay.", + "author": "Ali Romman with substantial OpenAI Codex assistance; no subagents", + "ai_assistance": "Substantial OpenAI Codex assistance; no subagents.", + "open_questions": [ + { + "question": "Can an independent reviewer confirm the complete contracted-source and mixed-root composition?", + "why_it_matters": "Both source mechanisms and the composition remain conditional and author checked.", + "first_step": "Check the exact source deltas at all eighteen calls, then replay the fixed root and native physical contacts.", + "blocked_by": "No scientific review is claimed by the local author replay." + }, + { + "question": "Can a new mechanism improve materially on the frozen mixed root?", + "why_it_matters": "The composition increment is small; most of the combined gain is inherited from the new root.", + "first_step": "Use a fresh overlap check and a favorable complete invoice before expanding a new caller.", + "blocked_by": "The present package changes no root or source construction." + } + ], + "publication_status": "LOCAL_ONLY_USER_REQUIRES_EXPLICIT_PR_PERMISSION", + "larger_user_objective": "The complete mixed-root contribution gains about 4.28455 percent over PR6375. The last source composition added 0.0109561 percent over its immediate local predecessor. The final parameter refinement adds about 0.000449325 percent over 0.00328620 with the same invoice." +} diff --git a/research/mixed-root-contact-composition/VALIDATION.json b/research/mixed-root-contact-composition/VALIDATION.json new file mode 100644 index 0000000000..cc34a8ffb9 --- /dev/null +++ b/research/mixed-root-contact-composition/VALIDATION.json @@ -0,0 +1,298 @@ +{ + "publication_status": "LOCAL_ONLY_NO_PUSH_NO_PR", + "scientific_commit": "caad1122970c14621fb60a6fd4866d136974229b", + "composition_scientific_commit": "fc261729c664cabe376c6d630a88d3d82199b72c", + "earlier_validation_commit": "7302dde9480571439b2646420155de1a6b8a83f9", + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "environment": { + "python": "3.12.13", + "os": "macOS 26.6.1 arm64", + "scientific_dependencies": "standard library only" + }, + "kappa": "82155369143209003786577/25000000000000000000000000", + "kappa_decimal": "0.00328621476572836015146308", + "exact_raw_limit_interval": [ + "328621476572836015146309/100000000000000000000000000", + "32862147657283601514631/10000000000000000000000000" + ], + "raw_limit_distance_upper": "1/50000000000000000000000000", + "same_invoice_comparison": { + "prior_scientific_commit": "3e6d2b83934abbd73d56383cafd3c9ba2d81866e", + "unchanged_fields": [ + "source_head", + "contact_source_head", + "root_source", + "native_events", + "root", + "binary", + "caller", + "local", + "columns", + "native", + "physical", + "paid_delta", + "target_delta", + "lift_paid_delta", + "lift_target_delta", + "assumptions", + "selected_frontier_changed" + ], + "unchanged_price_fields": [ + "paid", + "targets", + "nonrecursive" + ], + "result": "PASS_SAME_COMPLETE_INVOICE" + }, + "registered": { + "composition": { + "status": "PASS_NORMAL_AND_OPTIMIZED", + "sha256": "7c05dd956843cc2c548b06fbcf2b6b1f0e8a284c8448a4d070d7fa5eec1e295f", + "transcript": "CHECK Exact PR6372 and PR6375 reconstruction, all six changed helper inputs, all native columns and phases, unchanged mixed caller, complete paid and productive deltas, two-engine price, compiler, outer ledger and all-binary-size ceiling. The exact raw family supremum, every competing size profile, all seven-leaf tree histograms, exact completion tails and a 10^-26 crossing bracket.\nPASS exact source reconstruction, root, normalization and complete caller\nPASS source inputs, dense transpose, native phases, physical caller and owned controls\nPASS both prices, complete compiler and outer ledger, source controls and exact raw family limit\nPASS_MIXED_ROOT_CONTACT_COMPOSITION_KAPPA_00328621476572836015146308\nCHECK The same complete conditional result and source/semantic controls with assertions disabled.\nPASS exact source reconstruction, root, normalization and complete caller\nPASS source inputs, dense transpose, native phases, physical caller and owned controls\nPASS both prices, complete compiler and outer ledger, source controls and exact raw family limit\nPASS_MIXED_ROOT_CONTACT_COMPOSITION_KAPPA_00328621476572836015146308\nPASS_REGISTERED_RESEARCH_PACKAGE research/mixed-root-contact-composition outcome=completed\n" + }, + "headroom": { + "status": "PASS_NORMAL_AND_OPTIMIZED", + "sha256": "1a84ad6d2f1a541194a253a3189f547296218ee600c5f0cb514eee7a60cead0d", + "transcript": "CHECK Exact rank tables, all-parameter Laurent identities, support restrictions, idle floors, normalization and authenticated price reduction. Separate reverse caller replay through all four central characters and seven rejecting controls. Active-space reduction controls and exact all-size price exclusion for seven fifth-stage masks. Exact helper-consuming and border module identities, all-binary-size price exclusions and clearly separate formal limit price.\nPASS_MIXED_ROOT_MINIMUM_IDLE_CLASSIFICATION\nCHECK The same complete structural receipt with assertions disabled. Separate reverse caller replay through all four central characters and seven rejecting controls. Active-space reduction controls and exact all-size price exclusion for seven fifth-stage masks. Exact helper-consuming and border module identities, all-binary-size price exclusions and clearly separate formal limit price.\nPASS_MIXED_ROOT_MINIMUM_IDLE_CLASSIFICATION\nPASS_REGISTERED_RESEARCH_PACKAGE research/mixed-projector-root-headroom outcome=completed\n" + } + }, + "sealed": [ + { + "package": "mixed-projector-root-headroom", + "archive_sha256": "6ca9f13475ddf0bf9c6367fce66d2d1d023ffdad0ab29daa80a0f9b9960e7f98", + "export_files": 22, + "elapsed_seconds": 12.327521875005914, + "exit_code": 0, + "probes": { + "live_read": "PASS", + "export_write": "PASS", + "network": "PASS", + "git_absent": "PASS" + }, + "bytes_and_modes_unchanged": true, + "marker": "PASS_MIXED_ROOT_MINIMUM_IDLE_CLASSIFICATION" + }, + { + "package": "mixed-root-contact-composition", + "archive_sha256": "2d5069303abb88edc43a914e17f95c21ec9a3937a5f060b5e51aaa9221d9d125", + "export_files": 30, + "elapsed_seconds": 103.15824504099146, + "exit_code": 0, + "probes": { + "live_read": "PASS", + "export_write": "PASS", + "network": "PASS", + "git_absent": "PASS" + }, + "bytes_and_modes_unchanged": true, + "marker": "PASS_MIXED_ROOT_CONTACT_COMPOSITION_KAPPA_00328621476572836015146308" + } + ], + "process_controls": [ + { + "control": "non_dominant_profile_bound", + "exit_code": 1, + "error": "ValueError: The selected profile dominates every other size profile throughout the bracket", + "adapter_updated_to_reach_math_guard": false, + "sandboxed": true, + "mutation": { + "file": "optimality.py", + "before": "competitor_upper = max(other_totals, other_split, tail_upper)", + "after": "competitor_upper = selected_lower+Q(1, 10**30)" + }, + "command": [ + "python3.12", + "-I", + "-O", + "-B", + "research/mixed-root-contact-composition/verify.py" + ] + } + ], + "export_and_commit_checks": { + "scientific_commit": "caad1122970c14621fb60a6fd4866d136974229b", + "committed_bytes_and_modes": "PASS", + "official_export_and_hash_inventory": "PASS", + "package_and_input_file_counts": { + "mixed-root-contact-composition": 29, + "mixed-projector-root-headroom": 21 + } + }, + "main_refresh_utc_minute": "2026-11-02T20:20Z", + "overlap": { + "prior_full_open_pr_list_count": 327, + "current_delta": "GitHub connector: ten latest updated open PRs at the final check, plus exact descriptions/heads of relevant PR6384, PR6390 and PR6391. Earlier in this review: six latest updated Discussions with two recent comments each. Five historical PR heads were checked for research coverage.", + "delta_read_utc": "2026-11-02 20:20:08 UTC", + "findings": "PR6391 prices a different released three-stage overlap proposal. PR6384/6390 give separate compiler lemmas and are not new premises here. New PR6394 concerns fixed-prefix tails, PR6395 concerns retained-engine runtime, and PR6396 concerns a G20 bank census. No overlapping mixed-root claim was found in this bounded refresh.", + "coverage_limits": "Non-atomic public snapshots. Unpublished work and arbitrary unseen diffs are not covered." + }, + "initial_failures": [ + "The first detailed endpoint receipt exceeded Python's integer-to-string digit limit. Reporting now uses the retained engine's outward 30-place decimal intervals. All calculations and strict comparisons remain exact fractions; no interpreter limit was disabled.", + "The default sandbox denied a localhost preview listener. The preview then used a permitted temporary loopback-only listener for generated HTML; no package or science code changed." + ], + "draft_review": { + "renderer": "markdown-it-py 3.0.0", + "documents": 10, + "relative_links_checked": 34, + "all_targets_exist": true, + "visual_review": "Local in-app browser review of the PR draft, proof scope, review report, research tables and optimum proof; not hosted GitHub rendering." + }, + "limits": [ + "The exact raw limit is a supremum; equality is not certified by this strict funding argument.", + "The final refinement changes no complete invoice and is not a new construction step.", + "Hosted CI has not run for the local branch.", + "No independent human or proof-kernel acceptance is claimed.", + "Five framework assumptions remain.", + "Full-history source ancestry preflight was not run in this shallow checkout; exact declared object pins, retained archives and committed bytes were checked.", + "The uniform word and rounded multiplier are not materialized.", + "No global optimum over different sources or callers, or practical speedup, is claimed.", + "Family scope requires S on all six outputs and constant scalar bases independent of S and the stage variables; fixed-source recursive price limits do not cover other contracts." + ], + "selected_record_sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa", + "historical_exports": { + "scientific_commit": "6b7df03f879e3dd2e2e59a90a274d5be6ab66f01", + "sealed": [ + { + "package": "mixed-projector-root-headroom", + "archive_sha256": "5e0fc984266ba3f746bff76d33d8520739759ca8b697504f40aeb18f2033d028", + "export_files": 22, + "elapsed_seconds": 7.0359561660006875, + "exit_code": 0, + "probes": { + "live_read": "PASS", + "export_write": "PASS", + "network": "PASS", + "git_absent": "PASS" + }, + "bytes_and_modes_unchanged": true, + "marker": "PASS_MIXED_ROOT_MINIMUM_IDLE_CLASSIFICATION" + }, + { + "package": "mixed-root-contact-composition", + "archive_sha256": "7edcde1bc52affd10bbc06eff54e89f053f06747764612eb381a5c4623cec704", + "export_files": 29, + "elapsed_seconds": 80.99347900001158, + "exit_code": 0, + "probes": { + "live_read": "PASS", + "export_write": "PASS", + "network": "PASS", + "git_absent": "PASS" + }, + "bytes_and_modes_unchanged": true, + "marker": "PASS_MIXED_ROOT_CONTACT_COMPOSITION_KAPPA_00328621476572836015146308" + } + ] + }, + "historical_process_controls": { + "scientific_commit": "6b7df03f879e3dd2e2e59a90a274d5be6ab66f01", + "controls": [ + { + "control": "damaged_lift_archive", + "exit_code": 1, + "error": "ValueError: Exact retained source archive", + "adapter_updated_to_reach_math_guard": false, + "sandboxed": true, + "mutation": { + "file": "lift-source.tar", + "operation": "Replace the first byte with its XOR with 1." + }, + "command": [ + "python3.12", + "-I", + "-O", + "-B", + "research/mixed-root-contact-composition/verify.py" + ] + }, + { + "control": "ceiling_claimed_as_feasible", + "exit_code": 1, + "error": "ValueError: The claim and tested saving are below the raw crossing", + "adapter_updated_to_reach_math_guard": true, + "sandboxed": true, + "mutation": { + "file": "pricing.py", + "before": "KAPPA = Q('0.00328621476572836015146308')", + "after": "KAPPA = Q('0.00328621476572836015146310')" + }, + "command": [ + "python3.12", + "-I", + "-O", + "-B", + "research/mixed-root-contact-composition/verify.py" + ], + "declaration_edit": "Apply the same replacement to the after string in PRICING-EDITS.json." + }, + { + "control": "coarse_tail_used_for_completion", + "exit_code": 1, + "error": "ValueError: Completion, splitting and rounding", + "adapter_updated_to_reach_math_guard": true, + "sandboxed": true, + "mutation": { + "file": "pricing.py", + "before": "normalized = 1/(1+power*reserve)+exact_tail", + "after": "normalized = 1/(1+power*reserve)+coarse_tail" + }, + "command": [ + "python3.12", + "-I", + "-O", + "-B", + "research/mixed-root-contact-composition/verify.py" + ], + "declaration_edit": "Apply the same replacement to the after string in PRICING-EDITS.json." + }, + { + "control": "missing_root_query_debit", + "exit_code": 1, + "error": "ValueError: The root and literal child histograms give the complete signed invoice", + "adapter_updated_to_reach_math_guard": false, + "sandboxed": true, + "mutation": { + "file": "optimality.py", + "before": "invoice[1] -= 3*104", + "after": "invoice[1] -= 2*104" + }, + "command": [ + "python3.12", + "-I", + "-O", + "-B", + "research/mixed-root-contact-composition/verify.py" + ] + } + ] + }, + "classification_proof_commit": "e87c230f231441e2b53dec846ae9496c8c8d5121", + "proof_review": { + "record": "REVIEW.md", + "science_comparison": { + "comparison_commit": "7302dde9480571439b2646420155de1a6b8a83f9", + "only_changed_result_section": [ + "raw_optimality" + ], + "all_prior_numeric_fields_unchanged": true, + "new_optimality_keys": [ + "minimum_size_profile_margin_gap", + "other_size_profile_margin_upper_on_bracket", + "selected_per_port_margin_lower_on_bracket" + ], + "minimum_profile_gap": "14472794033883433065907589746016340854280764262874989079/326409290240107399719461050006798653637322483112129794670592", + "minimum_profile_gap_decimal": "4.4339405974741756e-05", + "kappa": "0.00328621476572836015146308", + "relative_gain_over_pr6375_percent": "4.284550829155882", + "selected_record_sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa" + }, + "scope_repairs": [ + "Every output contains S; scalar bases are independent of S and the stage variables.", + "The family price is its recursive invoice, not a uniform ordinary budget over every basis.", + "Supplementary all-size exclusions state their fixed tested savings." + ], + "new_guard": "Strict selected-versus-competing profile comparison throughout the raw bracket.", + "historical_null_replay": "PASS_NINE_EXACT_NULL_INPUTS: 9 changed words, 9 source controls, 9 rejection controls", + "historical_null_scope": "Optimized exact replay of nine changed words, nine source controls and nine rejection controls only; the local archive is not a new package input." + } +} diff --git a/research/mixed-root-contact-composition/VALIDATION.md b/research/mixed-root-contact-composition/VALIDATION.md new file mode 100644 index 0000000000..21d513e664 --- /dev/null +++ b/research/mixed-root-contact-composition/VALIDATION.md @@ -0,0 +1,144 @@ +# Historical local proof-review validation + +This record describes the checks before publication was authorized on +2026-11-02. Later hosted evidence is recorded in the contribution PR. + +The complete conditional claim remains **0.00328621476572836015146308**, +strictly between 1e-26 and 2e-26 below the exact raw family limit. The +selected record is unchanged. No branch push or PR has been made. +[REVIEW.md](REVIEW.md) records the proof repairs and research coverage. + +## Exact revisions + +- Clarified classification proof: `e87c230f231441e2b53dec846ae9496c8c8d5121`. +- Complete receipt and new dominance check: `fc261729c664cabe376c6d630a88d3d82199b72c`. +- Repinned supplementary inputs and both scientific exports: + `caad1122970c14621fb60a6fd4866d136974229b`. + +Later changes record validation and clarify prose only. They do not +change executable code, source pins or scientific receipts. The earlier +raw-limit validation remains at `7302dde9480571439b2646420155de1a6b8a83f9`. +Its exports and four process controls remain historical evidence in +`VALIDATION.json`; they are not presented as fresh runs of this revision. + +The environment is CPython 3.12.13 on macOS 26.6.1 arm64. Registered +science checks use only the standard library. Optional old discovery +scripts have separate numerical dependencies and are not replay inputs. + +## Executed scientific checks + +Both revised packages pass registered normal and optimized Python: + +```sh +python3.12 -B scripts/research_package.py --package research/mixed-root-contact-composition +python3.12 -B scripts/research_package.py --package research/mixed-projector-root-headroom +``` + +The complete composition checks all 799 native columns, 638,401 reverse +coefficients, absolute phases and 7,488 physical caller contacts. Both +rational engines certify the tested saving and both strict raw endpoint +signs. Completion, compiler, ordinary costs and all 54 strict plus four +functional outer predicates pass. Forty-three registered source, invoice +and semantic controls reject. + +The optimum replay checks 4,655 competing pair-total choices, the other +nine-leaf splits, all 11 seven-leaf tree histograms, and the unbounded +concave tail from total 100. The new direct comparison proves a gap +above 0.00004433 per port between the selected lower margin bound and +all competing size-profile upper bounds throughout the raw bracket. +Every old numerical receipt field is unchanged. Only the optimality +scope and three comparison bounds are added to that receipt section. +The native word, caller, invoice and all completion/compiler parameters +are unchanged by this review. + +The supplementary replay checks the classification, whole-field +normalization, 4,624 reverse-caller polynomials and seven controls, +active-space reduction, all seven fifth-stage prices, and both boundary +modules and their all-size price bounds at the stated savings. Its live +input now binds the revised complete receipt. The border's uncorrected +formal price remains outside every complete-kappa claim. + +The historical null-witness replay also passed again under optimized +Python: nine changed words, nine source controls and nine rejection +controls. This is a narrow check of preserved local evidence. It does +not rerun the full old native supplier or add it to the new package. +The original root and PR6353 scientific bytes are unchanged; their +historical heavy replays were not repeated. + +## Committed exports and process control + +All four contribution packages pass metadata, exact pins, committed-byte +and executable-mode checks. Both revised official exports pass their +inventory and hash checks at the scientific commit above. + +| Package | Export SHA256 | Isolated optimized replay | +| --- | --- | ---: | +| mixed-projector-root-headroom | `6ca9f13475ddf0bf9c6367fce66d2d1d023ffdad0ab29daa80a0f9b9960e7f98` | 12.33 s | +| mixed-root-contact-composition | `2d5069303abb88edc43a914e17f95c21ec9a3937a5f060b5e51aaa9221d9d125` | 103.16 s | + +The OS denies network access, reads from both live checkouts, and writes +into the exports. Separate probes confirm each restriction. PATH is +empty and Git is absent. All 22 headroom files and 30 composition files +retain their bytes and modes, including one export receipt per package. +The times describe these local checks, not algorithmic speedups. + +One further exported optimized process replaces the competing bound by +`selected_lower+Q(1,10**30)`. It rejects at the new mathematical guard: + +```text +ValueError: The selected profile dominates every other size profile throughout the bracket +``` + +The process reaches that guard after the source, native, caller and +price checks. This checks the distinction between negative competing +margins and actual dominance above the raw zero. The four earlier +archive, endpoint, coarse-tail and root-query mutations remain recorded +at their original scientific commit and were not repeated. + +## Research, documents and freshness + +The review compared retained investigation checkpoints and research +notes against the proof packages and commit progression. A separate +public-source pass checked the exact heads of PR5580, PR5751, PR5786, +PR6171 and PR6350. The research map now includes those earlier results, +the nine null witnesses, and the bounded source, caller and border routes. +Published predecessors, new construction, parameter refinements and +failed searches remain distinct. + +Ten Markdown documents were rendered with markdown-it-py 3.0.0. All +34 relative link targets exist. The revised draft, proof scope, review +report, research tables and exact-optimum argument were inspected in +a local in-app browser. This is a format check, not hosted rendering +or theorem acceptance. + +Canonical main was fetched again at 20:20 UTC on 2026-11-02 and remains +`7c49fe32c55de02c2c873655c804b16e4c3fef0a`, priority revision 8. No relevant +guidance changed. The final PR delta read the ten latest updated open +PRs. Earlier in this review, six recently updated Discussions and their +two latest comments were read. The relevant exact PR6384, PR6390 and +PR6391 descriptions were checked for scope and attribution. Their +compiler and three-stage overlap results are not premises here. New +PR6394--6396 concern fixed-prefix tails, verifier runtime and G20 bank +ranks. No conflicting mixed-root claim was found in this bounded check. +Unpublished work, non-atomic snapshots and unseen diffs remain limits. + +## Remaining obligations + +The assumptions native_all_columns, owned_erasure, compiler, +precision_tape and analytic_recovery remain. The earlier PR6376 scalar +audit has nonzero forward CLEAR rows and does not establish physical +erasure permission. Independent human review, formal-kernel acceptance +and hosted CI remain unrun for this local contribution. The uniform +word and rounded multiplier are not materialized. No practical speedup, +endpoint-equality certificate or global kappa optimum is claimed. + +The checkout is shallow. Full-history ancestry preflight was not run; +exact declared object pins, retained archives and committed bytes were +checked. The exported verifiers fetched no source. No fragile workaround +was added: the new acceptance check is a direct exact inequality. + +Selected record SHA256: +`9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa`. + +Ali Romman with substantial OpenAI Codex assistance; no subagents. +Apache-2.0. All predecessor credit remains in the source notices. diff --git a/research/mixed-root-contact-composition/VERIFY.json b/research/mixed-root-contact-composition/VERIFY.json new file mode 100644 index 0000000000..76a6d82384 --- /dev/null +++ b/research/mixed-root-contact-composition/VERIFY.json @@ -0,0 +1,37 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/mixed-root-source-composition/verify.py", + "research/mixed-root-source-composition/INPUTS.json", + "research/mixed-root-source-composition/sources.tar", + "research/mixed-root-source-composition/pricing.py", + "research/mixed-root-source-composition/ceiling.py", + "research/mixed-root-source-composition/RESULT.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 590, + "checks": "Exact PR6372 and PR6375 reconstruction, all six changed helper inputs, all native columns and phases, unchanged mixed caller, complete paid and productive deltas, two-engine price, compiler, outer ledger and all-binary-size ceiling. The exact raw family supremum, every competing size profile, all seven-leaf tree histograms, exact completion tails and a 10^-26 crossing bracket." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 590, + "checks": "The same complete conditional result and source/semantic controls with assertions disabled." + } + ] +} diff --git a/research/mixed-root-contact-composition/ceiling.py b/research/mixed-root-contact-composition/ceiling.py new file mode 100644 index 0000000000..2d053ff88d --- /dev/null +++ b/research/mixed-root-contact-composition/ceiling.py @@ -0,0 +1,65 @@ +"""Bound every binary-child size for the rank 2,3,3,2 root. + +Adapted from the prior fixed-root ceiling by Ali Romman with OpenAI Codex. +The contracted native source stays fixed. Other roots and sources are outside +this claim. All arithmetic in this checker uses rational intervals. +""" +from fractions import Fraction as Q + +CEILING=Q('.00328621476572836015146310') +BIT_CAP=Q('.0034') +TAIL=100 + + +def run(local,E,root): + def need(ok,message): + if not ok:raise ValueError(message) + need(00,'The native deficit increases throughout the admitted range') + h={r:E.power(r,t) for r in range(1,8*TAIL+2)} + lower=[Q(0)]*TAIL + upper=[Q(0)]*TAIL + split_checks=0 + for n in range(2,TAIL): + node_lower=2*h[8*n][0]+1-2*h[8*n+1][1] + node_upper=2*h[8*n][1]+1-2*h[8*n+1][0] + lower[n]=min(lower[a]+lower[n-a]+node_lower for a in range(1,n)) + upper[n]=min(upper[a]+upper[n-a]+node_upper for a in range(1,n)) + need(lower[n]<=upper[n],'Binary subtree interval') + split_checks+=n-1 + pairs={} + for n in range(2,TAIL-1): + pairs[n]=max(h[8*n+1][1]-n*native_lower-lower[n-b]-lower[b] + +h[8*b+1][1]-h[8*b][0] for b in range(1,n)) + margins=[] + for n in range(4,TAIL): + for a in range(2,n-1): + margins.append(h[8*n+1][1]+pairs[a]+pairs[n-a]-2) + finite_upper=max(margins) + need(finite_upper<0,'Every finite child sum fails at the ceiling') + # Every binary node costs at least -1 by concavity. For total n, + # Jensen bounds the two pair outputs and each added increment is at + # most H9-H8. The resulting upper bound is decreasing for n >= TAIL. + tail_upper=(h[8*TAIL+1][1]+2*h[4*TAIL+1][1]-TAIL*(native_lower-1) + +2*(h[9][1]-h[8][0])-6) + derivative_upper=(8*t*(h[8*TAIL+1][1]/(8*TAIL+1) + +h[4*TAIL+1][1]/(4*TAIL+1))-(native_lower-1)) + need(tail_upper<0 and derivative_upper<0,'All larger child sums fail') + return {'ceiling':str(CEILING),'first_tail_total':TAIL,'binary_split_checks':split_checks, + 'admitted_saving_cap':str(BIT_CAP),'native_derivative_lower':str(derivative_lower), + 'finite_pair_checks':len(margins),'finite_margin_upper':str(finite_upper), + 'tail_margin_upper':str(tail_upper),'tail_derivative_upper':str(derivative_upper), + 'scope':'All positive integer child sizes and all binary tree shapes for this fixed root and PR6375 source.'} diff --git a/research/mixed-root-contact-composition/contact-source.tar b/research/mixed-root-contact-composition/contact-source.tar new file mode 100644 index 0000000000..acc7a9c585 Binary files /dev/null and b/research/mixed-root-contact-composition/contact-source.tar differ diff --git a/research/mixed-root-contact-composition/lift-source.tar b/research/mixed-root-contact-composition/lift-source.tar new file mode 100644 index 0000000000..31307130da Binary files /dev/null and b/research/mixed-root-contact-composition/lift-source.tar differ diff --git a/research/mixed-root-contact-composition/optimality.py b/research/mixed-root-contact-composition/optimality.py new file mode 100644 index 0000000000..0d463e3741 --- /dev/null +++ b/research/mixed-root-contact-composition/optimality.py @@ -0,0 +1,145 @@ +"""Identify the exact raw funding limit of the classified mixed root. + +All prices use rational intervals. The selected binary tree histograms +are checked against every alternative at their sizes. Larger child sizes +use the separate all-size ceiling proof. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def tree_histogram(tree): + if tree == 1: + return 1, Counter() + need(isinstance(tree, list) and len(tree) == 2, 'A literal binary child') + a, left = tree_histogram(tree[0]) + b, right = tree_histogram(tree[1]) + return a+b, left+right+Counter({a+b: 1}) + + +def run(local, E, root, price, ceiling): + lower, upper = map(Q, price['raw_root_interval']) + need(Q(ceiling['ceiling']) == upper and Q(ceiling['finite_margin_upper']) < 0 + and Q(ceiling['tail_margin_upper']) < 0 and Q(ceiling['tail_derivative_upper']) < 0, + 'The all-size exclusion is at the refined crossing upper endpoint') + need(upper-lower == Q(1, 10**26), 'The exact raw bracket has width 10^-26') + need(lower-Q(price['kappa']) == Q(1, 10**26), 'The certified claim is one grid step below the bracket') + paid = {int(r): c for r, c in local['paid'].items()} + helpers = {int(r): c for r, c in local['helpers'].items()} + targets = {int(r): c for r, c in price['targets'].items()} + calls = {int(r): c for r, c in price['paid'].items()} + raw = Counter(targets) + raw.subtract(calls) + raw = {r: c for r, c in raw.items() if c} + tree_data = [tree_histogram(tree) for tree in root['children']] + sizes = [n for n, _ in tree_data] + need(sizes == [7, 2, 2, 7], 'The candidate uses the actual optimized children') + invoice = Counter({r: 18*c for r, c in helpers.items()}) + invoice.subtract({r: 18*c for r, c in paid.items()}) + for mask in root['masks']: + invoice[8*sum(n*b for n, b in zip(sizes, mask))+1] += 104 + invoice[1] -= 3*104 + invoice[16] -= 2*104 + for _, histogram in tree_data: + for n, count in histogram.items(): + invoice[8*n+1] += 2*104*count + invoice[8*n] -= 2*104*count + invoice[1] -= 104*count + need({r: c for r, c in invoice.items() if c} == raw, + 'The root and literal child histograms give the complete signed invoice') + def margin(k): + a, b = E.moment(targets, 1-k), E.moment(calls, 1-k) + return a[0]-b[1], a[1]-b[0] + need(margin(lower)[0] > 0 and margin(upper)[1] < 0 and Q(price['derivative_upper']) < 0, + 'The literal invoice has exactly one crossing in the refined interval') + + h = {r: E.power(r, 1-lower) for r in range(1, 802)} + native = (E.moment(paid, 1-lower)[0]-E.moment(helpers, 1-lower)[1])/104 + costs = [Q(0)]*100 + for n in range(2, 100): + node = 2*h[8*n][0]+1-2*h[8*n+1][1] + costs[n] = min(costs[a]+costs[n-a]+node for a in range(1, n)) + pairs = {} + nine = [] + for n in range(2, 99): + values = [h[8*n+1][1]-n*native-costs[n-b]-costs[b] + +h[8*b+1][1]-h[8*b][0] for b in range(1, n)] + pairs[n] = max(values) + if n == 9: + nine = values + alternatives = [h[8*n+1][1]+pairs[x]+pairs[n-x]-2 + for n in range(4, 100) for x in range(2, n-1) + if (x, n-x) != (9, 9)] + other_totals = max(alternatives) + other_split = h[145][1]+pairs[9]+max(value for b, value in enumerate(nine, 1) if b != 2)-2 + need(other_totals < 0 and other_split < 0, + 'Every different child-size profile already loses at the lower endpoint') + tail_upper = h[801][1]+2*h[401][1]-100*(native-1)+2*(h[9][1]-h[8][0])-6 + tail_derivative = 8*(1-lower)*(h[801][1]/801+h[401][1]/401)-(native-1) + need(tail_upper < 0 and tail_derivative < 0, + 'Every total at least 100 already loses at the lower endpoint') + # The selected margin can be negative above its zero. Negative + # competitor margins alone would not prove dominance there. + selected_lower = margin(upper)[0]/104 + competitor_upper = max(other_totals, other_split, tail_upper) + profile_gap = selected_lower-competitor_upper + need(profile_gap > 0, + 'The selected profile dominates every other size profile throughout the bracket') + + # Distinct tree shapes with the same node-size histogram have the same + # invoice. Enumerate histograms, including every split, through size seven. + histograms = {1: {tuple([0]*8)}} + for n in range(2, 8): + histograms[n] = set() + for a in range(1, n): + for left in histograms[a]: + for right in histograms[n-a]: + histograms[n].add(tuple(x+y+(j == n) for j, (x, y) in enumerate(zip(left, right)))) + node_interval = {} + for n in range(2, 8): + a, b = E.power(8*n, 1-lower), E.power(8*n+1, 1-lower) + c, d = E.power(8*n, 1-upper), E.power(8*n+1, 1-upper) + node_interval[n] = (2*a[0]+1-2*b[1], 2*c[1]+1-2*d[0]) + need(node_interval[n][0] <= node_interval[n][1], 'Increasing binary-node cost on the interval') + gaps = [] + selected = tree_data[0][1] + need(tree_data[3][1] == selected and len(histograms[2]) == 1, 'The symmetric children have identical bills') + selected_tuple = tuple(selected[j] for j in range(8)) + need(selected_tuple in histograms[7], 'The selected tree histogram is present') + for histogram in histograms[7]-{selected_tuple}: + difference = [x-y for x, y in zip(histogram, selected_tuple)] + gap = sum(c*node_interval[n][0 if c >= 0 else 1] + for n, c in enumerate(difference) if c) + need(gap > 0, 'Every other seven-leaf tree bill is larger throughout the bracket') + gaps.append(gap) + + # A constructive strictifier is available arbitrarily near the raw + # crossing: alpha<1 below it; these two tail bounds hold on the full + # bracket. This statement is about the finite supplier, not a new + # outer-endpoint certificate at the crossing itself. + target_lower = E.moment(targets, 1-upper)[0] + gamma_upper = E.moment(calls, 1-lower+Q(1, 7))[1]/(E.power(12, Q(1, 7))[0]*target_lower) + delta_upper = Q(sum(targets.values())*13)/(E.power(12, lower)[0]*target_lower) + need(gamma_upper < Q(31, 32) and delta_upper < Q(31, 32), 'Both tails are uniformly below one near the limit') + return {'raw_limit_interval': list(map(str, (lower, upper))), + 'signed_invoice': {str(r): c for r, c in sorted(raw.items())}, + 'unique_selected_sizes_up_to_pair_exchange': sizes, + 'other_pair_total_checks': len(alternatives), 'other_pair_total_margin_upper': str(other_totals), + 'other_nine_leaf_split_margin_upper': str(other_split), + 'lower_endpoint_tail_margin_upper': str(tail_upper), + 'lower_endpoint_tail_derivative_upper': str(tail_derivative), + 'selected_per_port_margin_lower_on_bracket': str(selected_lower), + 'other_size_profile_margin_upper_on_bracket': str(competitor_upper), + 'minimum_size_profile_margin_gap': str(profile_gap), + 'seven_leaf_histograms': len(histograms[7]), 'selected_seven_leaf_histogram': dict(selected), + 'minimum_alternative_tree_cost_gap': str(min(gaps)), + 'uniform_tail_gamma_upper': str(gamma_upper), 'uniform_tail_delta_upper': str(delta_upper), + 'certified_kappa_distance_upper': str(upper-Q(price['kappa'])), + 'statement': 'The exact family raw-funding supremum is the unique zero of the displayed signed invoice. At that zero the raw paid and productive moments are equal, so the strict compiler does not certify equality.', + 'scope': 'Fixed PR6375 source; six fields with S on every output, constant scalar bases independent of S and all stage variables, seven square-zero queries, four distinct independent forward full stages and at most two extra whole idles; every positive binary child size and binary tree shape; admitted saving range through .0034.'} diff --git a/research/mixed-root-contact-composition/pricing.py b/research/mixed-root-contact-composition/pricing.py new file mode 100644 index 0000000000..9be37522db --- /dev/null +++ b/research/mixed-root-contact-composition/pricing.py @@ -0,0 +1,189 @@ +"""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.00328621476572836015146308') +TESTED = Q('0.003286214765728360151463085') +PREVIOUS = Q('0.00328620') + + +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[1+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') + need((targets, paid) == formula_invoice(local), 'Independent tree and emitted-event counts') + need((counts['LOCAL'], counts['QUERY'], counts['IDLE']) == (18, 17, 14) and counts['IDLE_ONE'] == 2 and counts['LAMBDA'] == 20, 'Complete caller census') + need((sum(targets.values()), sum(paid.values())) == (13652, 67150), '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] + low, high, grid = 0, 10**24, 10**26 + while high-low > 1: + middle = (low+high)//2 + if margin(Q(middle, grid))[0] > 0: + low = middle + else: + high = middle + lower, upper = Q(low, grid), Q(high, 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*34*104*len(word['events']) + 34*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.00328621476572836015146308', 'previous_fixed_root': PREVIOUS, + 'refinement_kind': 'Same complete invoice; finer strictification and compiler parameters.', + '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/mixed-root-contact-composition/verify.py b/research/mixed-root-contact-composition/verify.py new file mode 100644 index 0000000000..daac398755 --- /dev/null +++ b/research/mixed-root-contact-composition/verify.py @@ -0,0 +1,233 @@ +"""Compose the fixed mixed root with the exact PR6372 and PR6375 words. + +The source constructors and proof engines retain their original notices. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha1, sha256 +from pathlib import Path, PurePosixPath +import gzip +import importlib.util +import json +import sys +import tarfile +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +PREVIOUS = ROOT/'research/mixed-root-source-composition' +CONTACT = 'research/p104-contact-block-contraction/' +LIFT = 'research/p104-shared-carrier-lifts/' +STATUS = 'PASS_MIXED_ROOT_CONTACT_COMPOSITION_KAPPA_00328621476572836015146308' + + +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 authenticate(data, pin): + need(sha256(data).hexdigest() == pin['sha256'], 'Exact source SHA256: '+pin['path']) + need(sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() == pin['git_blob'], + 'Exact source Git blob: '+pin['path']) + + +def reject(action): + try: + action() + except ValueError as error: + return str(error) + raise ValueError('Invalid control accepted') + + +def delta(after, before): + result = Counter(after) + result.subtract(before) + return {r: n for r, n in result.items() if n} + + +def retained_source(root, manifest_name, archive_name, count): + manifest = read(HERE/manifest_name) + archive = HERE/archive_name + need(sha256(archive.read_bytes()).hexdigest() == manifest['archive_sha256'], 'Exact retained source archive') + pins = {p['path']: p for p in manifest['files']} + need(len(pins) == len(manifest['files']) == count, 'Exact retained source inventory') + with tarfile.open(archive, 'r:') as tar: + members = tar.getmembers() + need(len(members) == count and {m.name for m in members} == set(pins), 'Every retained source file') + for member in members: + path = PurePosixPath(member.name) + need(member.isfile() and not path.is_absolute() and '..' not in path.parts, 'Regular relative retained path') + data = tar.extractfile(member).read() + authenticate(data, pins[member.name]) + target = root/member.name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(data) + return manifest + + +def run(): + live = read(HERE/'SOURCES.json')['files'] + for pin in live: + if pin['usage'] == 'input': + authenticate((ROOT/pin['path']).read_bytes(), pin) + previous = load(PREVIOUS/'verify.py', 'prior_mixed_composition') + for filename, edits in [('pricing.py', 'PRICING-EDITS.json'), ('ceiling.py', 'CEILING-EDITS.json')]: + text = (PREVIOUS/filename).read_text() + for before, after in read(HERE/edits): + need(text.count(before) == 1, 'One occurrence of each declared '+filename+' edit') + text = text.replace(before, after) + need(text == (HERE/filename).read_text(), 'Exact declared '+filename+' adapter') + with previous.sources() as (root, old_manifest): + manifest = retained_source(root, 'CONTACT-INPUTS.json', 'contact-source.tar', 8) + lift_manifest = retained_source(root, 'LIFT-INPUTS.json', 'lift-source.tar', 7) + original = root/previous.ROOT_SOURCE + joint = root/previous.CONTRACT_SOURCE + new = root/CONTACT + load(original/'algebra.py', 'algebra') + controller = load(original/'controller.py', 'controller') + physical = load(original/'physical.py', 'contact_root_physical') + module = load(original/'module_check.py', 'contact_root_module') + binary = load(root/'research/balanced-query-tree/module_check.py', 'contact_root_binary') + support = load(joint/'support.py', 'support') + legacy = load(joint/'construct.py', 'legacy_basis') + constructor = load(new/'construct.py', 'contact_root_constructor') + need((joint/'construct.py').read_bytes() == (new/'inputs/pr6353-construct.py').read_bytes(), + 'The exact retained PR6353 basis constructor') + need((joint/'WORD.json.gz').read_bytes() == (new/'inputs/pr6353-WORD.json.gz').read_bytes(), + 'The exact retained PR6353 native word') + old_word = json.loads(gzip.decompress((joint/'WORD.json.gz').read_bytes())) + native_word, witness = constructor.construct(old_word) + need(native_word == json.loads(gzip.decompress((new/'WORD.json.gz').read_bytes())), 'Every rebuilt PR6372 native word field') + need(legacy.encode(witness) == read(new/'BASIS.json'), 'Every new rational basis witness') + need(all(native_word[k] == value for k, value in old_word.items() if k not in ('program', 'final')), + 'Unchanged native interface, inputs and frames') + need({r: native_word['final'][r] for r in range(770) if native_word['final'][r] != old_word['final'][r]} + == {224: 245, 227: 245}, 'Only the two declared helper outputs change') + contact_word = native_word + lifted = root/LIFT + need((new/'WORD.json.gz').read_bytes() == (lifted/'inputs/pr6372-WORD.json.gz').read_bytes(), + 'Exact retained input to the shared-carrier constructor') + lifts = load(lifted/'construct.py', 'mixed_shared_carrier_constructor') + native_word = lifts.construct(contact_word, read(lifted/'LIFTS.json')) + need(native_word == json.loads(gzip.decompress((lifted/'WORD.json.gz').read_bytes())), + 'Every reconstructed PR6375 native word field') + need(all(native_word[k] == value for k, value in contact_word.items() if k not in ('program', 'initial')), + 'Unchanged lifted interface, frames and final outputs') + need({r: native_word['initial'][r] for r in range(770) + if native_word['initial'][r] != contact_word['initial'][r]} + == {520: 106, 655: 106, 544: 105, 671: 105, 472: 105, 624: 105}, + 'Exactly six changed input frames') + caller = controller.construct() + need(caller == read(original/'CONTROLLER.json'), 'Every unchanged mixed caller event') + root_result, binary_result = module.run(), binary.run() + caller_result = controller.replay(caller) + controls = controller.controls(caller) + price = load(HERE/'pricing.py', 'contact_root_price') + ceiling = load(HERE/'ceiling.py', 'contact_root_ceiling') + optimality = load(HERE/'optimality.py', 'contact_root_optimality') + print('PASS exact source reconstruction, root, normalization and complete caller', flush=True) + with support.checkers() as (L, frozen): + old, contact, local = L.replay(old_word), L.replay(contact_word), L.replay(native_word) + need(price.encode(contact) == read(new/'RESULT.json')['local'], 'Published PR6372 local receipt') + need(price.encode(local) == read(lifted/'RESULT.json')['local'], 'Published PR6375 local receipt') + need(price.encode(old) == read(PREVIOUS/'RESULT.json')['local'], 'Prior complete composition source') + pd, td = delta(local['paid'], old['paid']), delta(local['helpers'], old['helpers']) + need(delta(contact['paid'], old['paid']) == {4: 2, 5: -2} + and delta(contact['helpers'], old['helpers']) == {8: 2, 9: -2}, 'Exact contact changes') + lift_pd, lift_td = delta(local['paid'], contact['paid']), delta(local['helpers'], contact['helpers']) + need(lift_pd == {1: 6, 3: -3, 4: 3, 5: -3} and lift_td == {8: 6, 9: -6}, + 'Exact signed shared-carrier changes') + need((local['public_inputs'], local['owned_fields'], local['owned_lifetimes'], local['peak_owned_fields']) + == (770, 29, 43, 13), 'All inputs and both new owned lifetimes') + for label, index in witness['control_indices'].items(): + bad = deepcopy(contact_word) + del bad['program'][index] + controls['missing_'+label] = reject(lambda: L.replay(bad)) + for role in (224, 227): + bad = deepcopy(native_word) + bad['final'][role] = old_word['final'][role] + controls['missing_target_'+str(role)] = reject(lambda: L.replay(bad)) + for role in (520, 655, 544, 671, 472, 624): + bad = deepcopy(native_word) + bad['initial'][role] = contact_word['initial'][role] + controls['old_entrance_'+str(role)] = reject(lambda: L.replay(bad)) + source_events = {tuple(e) for e in contact_word['program']} + new_adds = [i for i, e in enumerate(native_word['program']) + if e[0] == 'ADD' and tuple(e) not in source_events] + for label, index in [('first_lift_delivery', new_adds[0]), ('last_lift_restore', new_adds[-1])]: + bad = deepcopy(native_word) + del bad['program'][index] + controls[label] = reject(lambda: L.replay(bad)) + bad = deepcopy(native_word) + bad['program'][new_adds[0]][3] = str(-Q(bad['program'][new_adds[0]][3])) + controls['lift_response_sign'] = reject(lambda: L.replay(bad)) + columns = L.reverse_columns(native_word) + need(columns['columns'] == 799 and columns['coefficients'] == 638401, 'All independent native columns') + native = L.native(native_word) + maps = physical.physical(caller, native_word, L) + need(maps['full_calls'] == 18 and maps['physical_contacts'] == 7488, 'All physical caller contacts') + print('PASS source inputs, dense transpose, native phases, physical caller and owned controls', flush=True) + bound = price.run(local, native, caller, maps, L) + old_targets, old_paid = controller.formula_invoice(old) + need(delta({int(r): n for r, n in bound['paid'].items()}, old_paid) == {r: 18*n for r, n in pd.items()}, + 'All eighteen paid changes') + need(delta({int(r): n for r, n in bound['targets'].items()}, old_targets) == {r: 18*n for r, n in td.items()}, + 'All eighteen productive target debits') + E = load(frozen/'research/higher-moment-strictification/verify.py', 'contact_root_comparison') + fixed_ceiling = ceiling.run(local, E, read(original/'ROOT.json')) + optimum = optimality.run(local, E, read(original/'ROOT.json'), bound, fixed_ceiling) + old_margin = E.moment(old_targets, 1-price.KAPPA)[1]-E.moment(old_paid, 1-price.KAPPA)[0] + need(old_margin < 0, 'The previous source fails at the new complete claim') + contact_targets, contact_paid = controller.formula_invoice(contact) + contact_margin = E.moment(contact_targets, 1-price.KAPPA)[1]-E.moment(contact_paid, 1-price.KAPPA)[0] + need(contact_margin < 0, 'The immediate PR6372 composition fails at the new complete claim') + bad = deepcopy(local); bad['paid'][4] -= 1 + controls['unpaid_native_move'] = reject(lambda: price.assemble(bad, native, caller, maps)) + bad = deepcopy(local); bad['helpers'][9] += 1; bad['helpers'][8] -= 1 + controls['missing_productive_debit'] = reject(lambda: price.assemble(bad, native, caller, maps)) + for pin in manifest['files']+lift_manifest['files']: + data = (root/pin['path']).read_bytes() + controls['damaged_'+pin['path']] = reject(lambda data=data, pin=pin: authenticate(bytes([data[0]^1])+data[1:], pin)) + print('PASS both prices, complete compiler and outer ledger, source controls and exact raw family limit', flush=True) + return price.encode({'status': STATUS, 'source_head': lift_manifest['source_head'], + 'contact_source_head': manifest['source_head'], + 'root_source': old_manifest['root_head'], 'native_events': len(native_word['program']), + 'root': root_result, 'binary': binary_result, 'caller': caller_result, + 'local': local, 'paid_delta': pd, 'target_delta': td, 'columns': columns, + 'lift_paid_delta': lift_pd, 'lift_target_delta': lift_td, + 'native': native, 'physical': maps, 'price': bound, 'fixed_root_ceiling': fixed_ceiling, + 'raw_optimality': optimum, + 'prior_source_margin_upper': old_margin, 'controls': controls, + 'immediate_source_margin_upper': contact_margin, + 'gain_over_pr6375': price.KAPPA-Q('.00315120'), + 'relative_gain_over_pr6375_percent': 100*(price.KAPPA/Q('.00315120')-1), + 'assumptions': ['native_all_columns','owned_erasure','compiler','precision_tape','analytic_recovery'], + 'selected_frontier_changed': False}) + + +if __name__ == '__main__': + sys.dont_write_bytecode = True + with tempfile.TemporaryDirectory(prefix='mixed-contact-cache-') as cache: + sys.pycache_prefix = cache + result = run() + if sys.argv[1:] == ['--write-result']: + (HERE/'RESULT.json').write_text(json.dumps(result, sort_keys=True, indent=2)+'\n') + else: + need(not sys.argv[1:], 'Only --write-result is supported') + need(result == read(HERE/'RESULT.json'), 'Exact complete scientific receipt') + print(STATUS, flush=True) diff --git a/research/mixed-root-source-composition/CEILING-EDITS.json b/research/mixed-root-source-composition/CEILING-EDITS.json new file mode 100644 index 0000000000..872ed925cb --- /dev/null +++ b/research/mixed-root-source-composition/CEILING-EDITS.json @@ -0,0 +1,18 @@ +[ + [ + "CEILING=Q('.00328469')", + "CEILING=Q('.00328554')" + ], + [ + "this fixed root and PR6349 source.", + "this fixed root and PR6353 source." + ], + [ + "The native source stays fixed. Other roots and native sources are outside", + "Adapted from the prior fixed-root ceiling by Ali Romman with OpenAI Codex.\nThe contracted native source stays fixed. Other roots and sources are outside" + ], + [ + "source.'}\n\n\n", + "source.'}\n" + ] +] diff --git a/research/mixed-root-source-composition/INPUTS.json b/research/mixed-root-source-composition/INPUTS.json new file mode 100644 index 0000000000..0af459cf4e --- /dev/null +++ b/research/mixed-root-source-composition/INPUTS.json @@ -0,0 +1,236 @@ +{ + "schema": 1, + "archive_sha256": "6d05208f4fa1d98b4b63a8b2d9366576313a1f1466232a6a4f1a286de23c292b", + "root_head": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "contract_head": "db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3", + "files": [ + { + "path": "research/balanced-query-tree/CONTROLLER.json", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "6fd67eaabe659956d6694471d3fd7d2824c0a4a79cf3b8f22922f7189b11b91f", + "git_blob": "1f2e375b24aba5fb25580dfea7fab7a2049f3eb8" + }, + { + "path": "research/balanced-query-tree/RESULT.json", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "f64a30b23a92e12e5e23c3d4400e139f20cf75bb2743d15c85b89ca1839a9408", + "git_blob": "61ab6b26ff40168fb0982167ac67ef4607f27717" + }, + { + "path": "research/balanced-query-tree/controller.py", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "8067ade84815b54d539cbaef9885db9fa4d7a23fdde2e683451d317038a8477c", + "git_blob": "3b4bf82eba05d57ef4bb1fd934e8ca65780425c1" + }, + { + "path": "research/balanced-query-tree/module_check.py", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "a30e70fe1313f125b276ec97e05c779ff80b6d1aa9f6ba918a61bfb9bb5a2eda", + "git_blob": "f394d40ea2e0777f77910cc5a4b1d151c1228cbc" + }, + { + "path": "research/balanced-query-tree/physical.py", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "3288421e7c3ca7116c96996984983ff44e2b601e38f808c4b46e518fbda9851b", + "git_blob": "84cf2a35241ab1bbc845a29f5048481aa5c93244" + }, + { + "path": "research/balanced-query-tree/pricing.py", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "2e9a3d6aef8933ff7be3cc9dac22cd72bff2bb9985c2c53bb0affa5dfc2175b1", + "git_blob": "970fdcad6eca99087af2c901939b3813f3eb1f5d" + }, + { + "path": "research/mixed-projector-query-root/CONTROLLER.json", + "head": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "sha256": "4aa7ee4e1bc4853200cf97474695054057cc354bc1778f35b6554a365aac412c", + "git_blob": "4f7d7a2f13b13966b10c7b583d28d1bed210364c" + }, + { + "path": "research/mixed-projector-query-root/NOTICE", + "head": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "sha256": "b6026dd901f3cb2e6ec6d5f7b32a38aa998005c8a1df93392151ca1766d45b33", + "git_blob": "03e4ac5937424ed9f0ae0e4b33d6b0df0c9ec8d9" + }, + { + "path": "research/mixed-projector-query-root/PROOF.md", + "head": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "sha256": "bfbe0b872f6ff14c858bff47c6e3ac0bb8e43bc8eeaec20253744e3f44720fcd", + "git_blob": "510bf9dba012949ea0f37d9e087ce8778b1951d0" + }, + { + "path": "research/mixed-projector-query-root/RESULT.json", + "head": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "sha256": "38b31c5e452a0da4be773faf88302f8eb3a2508e13ec0930e79e13f39d744e30", + "git_blob": "7ffa8fadc0b769e2808f087522f4aa3042634964" + }, + { + "path": "research/mixed-projector-query-root/ROOT.json", + "head": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "sha256": "2f25684c24ae0e1d10d4f8f29430aed3cef584f82c8ae840e82be0a72baa048d", + "git_blob": "b59f1ea89aca17f0a76131743c12f2c724421df8" + }, + { + "path": "research/mixed-projector-query-root/SOURCES.json", + "head": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "sha256": "3a4f98c44ceeaa006d8959bae9e0a5756202bc1c658a1ba5f52ac089746a522e", + "git_blob": "41c7fb59bf3da888f4468799325988d5a119049f" + }, + { + "path": "research/mixed-projector-query-root/algebra.py", + "head": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "sha256": "02eb3380715294334710edd3273f267dc048264555bd60fefb86022bc9eda835", + "git_blob": "a06d6f641685e96b2f150ea6b741930a9ec037f8" + }, + { + "path": "research/mixed-projector-query-root/ceiling.py", + "head": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "sha256": "db1a80bac1ec210505fdb20248dc5f4e95bbc5e989d9f41bb72a5b7ef25964bb", + "git_blob": "93f626e8216598d56ab91b7f05c468479bdc7be9" + }, + { + "path": "research/mixed-projector-query-root/controller.py", + "head": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "sha256": "e5671c66a4091f1b482a750baf5bedf9ac0750e577efbe3c5b3d2860d2fa8edc", + "git_blob": "393524f903b44be54884475d11200f06ce1dfddb" + }, + { + "path": "research/mixed-projector-query-root/module_check.py", + "head": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "sha256": "30c1f9330e512b098b0f231b3ee419018e7a8e452af6c4b5a49edd5c181bc3ea", + "git_blob": "8631a483107f8f7617d1f8e9b708b32b56e7ec43" + }, + { + "path": "research/mixed-projector-query-root/physical.py", + "head": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "sha256": "182af90219e645a4a63e1db93dc199c446014bd525a0c2c1cb57ace3e52232bb", + "git_blob": "b63471439e99f3f5f405e4229b2cacf23eb819bb" + }, + { + "path": "research/mixed-projector-query-root/pricing.py", + "head": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "sha256": "149dce607d1ed70ed78e3e83448ead90a4007675da9bcc46ef3fd60c72a86159", + "git_blob": "6c9f0db0f426193c7b10d1f71a08f963b449514e" + }, + { + "path": "research/p104-frontier-compression-2/WORD.json.gz", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "889f0f5d193d993dabee1e20dcfbcf63f9d88cfe5bd6973d564276c744d1e190", + "git_blob": "cb3aed1d5604eb290f18759b37becaad428ac27a" + }, + { + "path": "research/p104-joint-output-contraction/BASIS.json", + "head": "db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3", + "sha256": "e7bd061436c5fdbd1b968f9252cc79efda04320cf3c027a6fdcdf14ff4c9d2d3", + "git_blob": "b35a19d4ec44aa365501ef0299a4b11f9cba3e00" + }, + { + "path": "research/p104-joint-output-contraction/NOTICE", + "head": "db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3", + "sha256": "6c5f4a452f7d65ef8ca0980992dce279938b0a1139f6c067f91de78bf8ecb7bd", + "git_blob": "e6cae17f778e8e31b7c294ff2890c545978931c0" + }, + { + "path": "research/p104-joint-output-contraction/PROOF.md", + "head": "db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3", + "sha256": "cd400ad5d82d316e469bd5df81e4fc26faf1ba0aaa385a5f9964ec4786a9de5d", + "git_blob": "d27ef41f57d7d75293515e56dc5c21c3e6cff0d7" + }, + { + "path": "research/p104-joint-output-contraction/RESULT.json", + "head": "db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3", + "sha256": "4c9b2d2b4f0df1ed852250b6815fce62a174ce297fed04801298183afd55c7b7", + "git_blob": "f5fc1f595607837531d0aee8c6835f55a2e2ab98" + }, + { + "path": "research/p104-joint-output-contraction/SOURCES.json", + "head": "db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3", + "sha256": "5f8f43de403ef1b993f0ba5c5f57318e74a0fef30ab6aa4034300c0c3f88c62c", + "git_blob": "016b3dbf700dfbe324d10588ec6ae4936e4e33b6" + }, + { + "path": "research/p104-joint-output-contraction/WORD.json.gz", + "head": "db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3", + "sha256": "0c83c1f1dee8c9442558719510a61b89f38c2dbfc8fb565ba035660d2a68d928", + "git_blob": "03ea7690285d4cda72815f962d5710ab96e08490" + }, + { + "path": "research/p104-joint-output-contraction/construct.py", + "head": "db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3", + "sha256": "a6ed00edd11b902c25d345ba2b44063cd68ebe787fe92067b65d26c8e2dc9248", + "git_blob": "fff6cfb443b8ad59c2b8ab8f1e8eb01017576d8a" + }, + { + "path": "research/p104-joint-output-contraction/support.py", + "head": "db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3", + "sha256": "f45dc66ef11dea42c718202b0acb0887fcac8f1ab230b065c797573be3d059d5", + "git_blob": "09211b22de86394543e3f843c19c395db6da3bfb" + }, + { + "path": "research/p104-joint-output-contraction/verify.py", + "head": "db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3", + "sha256": "3550a869aac12411f0032ef9176e00bef387d02ba5af6a809df3fb290b29d9a4", + "git_blob": "a1db44f537d5945ddd8b4169f1b10a19677322d4" + }, + { + "path": "research/p104-native-input-lifting/RESULT.json", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "b55049edcaaf6a9d57201a95df3e2ac8e06bc882eaf8f99a5bff16448bc58b8d", + "git_blob": "467f941331b78519fc7c7d5fc5e8ffbe7d7d7193" + }, + { + "path": "research/p104-native-input-lifting/SOURCES.json", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "8da6d980d4d62482c7184b14134eb7485fc9b4807b72fc25d462391e9f7739fa", + "git_blob": "bc7876a86e355ea59619916aeb60c422d9cb16b7" + }, + { + "path": "research/p104-native-input-lifting/WORD.json.gz", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "1415a62059ed62d0b4657db91f7ec01b23c117f5f2744746d93c880bd777be92", + "git_blob": "f21f7ac451c3f2e1ae8d5ca1dcad839a0b0d844f" + }, + { + "path": "research/p104-native-input-lifting/construct.py", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "a672603103aaeab3b705a765ff6af08ef2819dcac0f9a2bd6faa8a7e5443135d", + "git_blob": "1a8a1e9881610c3bdb6af78c1c21d2b2f9a85147" + }, + { + "path": "research/p104-native-input-lifting/support.py", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "9c83cba72a6b52c3815c03898e96619364c5ef66b8d30b96fc58a99fcba3be50", + "git_blob": "b528d2a451e0d1e398938e7a0ccb8ee5a87dcabe" + }, + { + "path": "research/p104-native-input-lifting/verify.py", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "1d3a5cc1a0a3ccc68ec16e02611a8a51bc29550b0875ce8e6045d5da37af65a7", + "git_blob": "70b3beae8f2279e67d39e308886083fe38eb2d7f" + }, + { + "path": "research/p104-retained-operand-descent/SOURCES.json", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "7c7b6fac64005eb8932283a902069d672d98c52bda2b63cc7eaa4a2cac13ce8f", + "git_blob": "0c574b6026a7239aac7365c433d3760928748edb" + }, + { + "path": "research/p104-retained-operand-descent/inputs/pr5827-source.tar", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "7af5908a4d83e83e28f59523fd7494841f669b7295311cfdbc3027fa65c5826d", + "git_blob": "1e10936044959f81a4c5fcd5bdb7b9e4c060ec8e" + }, + { + "path": "research/p104-retained-operand-descent/pricing.py", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "bba1611b05b6cc35279aa1667dcc62ce0e7f27f0ba21f20eb68244fa772e0ae7", + "git_blob": "cd8220ca7a393f03341f08a93b9d1287f0bb3689" + }, + { + "path": "research/p104-retained-operand-descent/sources.py", + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "sha256": "a62fefda1709614157ba440d38c164c366a8b3322ab8f866b6b4bd47b9d83dbc", + "git_blob": "bef6542243a082755a881dff42097434e6370609" + } + ] +} diff --git a/research/mixed-root-source-composition/NOTICE b/research/mixed-root-source-composition/NOTICE new file mode 100644 index 0000000000..d41e004301 --- /dev/null +++ b/research/mixed-root-source-composition/NOTICE @@ -0,0 +1,590 @@ +Current mixed-root and contracted-source composition +Ali Romman with substantial OpenAI Codex assistance; no subagents. Apache-2.0. +The earlier local contracted-mixed-query-local package supplies the adapter. +The present package changes its frozen root and complete bound. + +Local contracted-source and mixed-root composition +Ali Romman, with substantial OpenAI Codex assistance; no subagents. +Apache-2.0. Neither source construction is claimed as new here. + +Mixed projector query root +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. No subagents. + +The new contribution is the normalized six-field root, its weighted binary +children, exact complete caller, full invoice and conditional bound. +The shortest central-involution query tuple is from the credited +five-call-projector-rigidity package by Ali Romman with OpenAI Codex. +The binary query extension is PR6348. The unchanged native source is PR6349. +The simple normalization identity is not claimed as a new general algebra theorem. +The native construction, scalar compression and inherited proof engines are +predecessor work. Their exact source notices follow. + +Source: research/balanced-query-tree/NOTICE + +Binary query-tree caller + +New construction, proof and code: Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. No subagents. + +Cinna Davis supplies the productive path caller, query thinning and exact Laurent factorization. Ali Romman supplies the all-forward P104 binding in PR5544 and the retained-operand word in PR6167. The native word and interval/compiler lineage remain predecessor work. The new contribution is the four-field query extension, its tree composition, complete invoice and conditional price. + +The authenticated PR6167 notice follows. + +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. + +Source: research/p104-native-input-lifting/NOTICE + +Native helper input lifting +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author checks. + +The direct source is PR6314 at 36533d4d1b4e2dd8672427461b12de3001b85810, +by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. +It compresses the scalar word of PR6167 without a kappa change. +The four native input lifts and their complete conditional price are new here. +The basis identity is elementary linear algebra; no new general theorem +for that identity is claimed. + +The PR6167 source notice follows unchanged. Its nested source archive also +retains the earlier notices. + +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. + + +Joint native output contraction +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author checks. + +PR6349 supplies the exact native input-lift source. PR6348 supplies the fixed +binary query-tree caller and price engine. PR6350, by Ali Romman with OpenAI +Codex assistance, supplies the released composition control and its prior +conditional claim. Its source and caller are recounted here from main; no +pending PR6350 code is imported. Cinna Davis supplies the productive caller, +thin-query interface and exact Laurent factorization. + +The new result is the explicit nine-helper joint output contraction, its +literal forward word and complete conditional price. The input/departure basis +identity is elementary linear algebra. No new general linear algebra theorem, +native duality theorem or caller construction is claimed. + +The exact PR6349 and PR6348 notices follow. Their nested source archive retains +all earlier native, helper, recursion, compiler, BIT and analytic attribution. + +Native helper input lifting +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author checks. + +The direct source is PR6314 at 36533d4d1b4e2dd8672427461b12de3001b85810, +by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. +It compresses the scalar word of PR6167 without a kappa change. +The four native input lifts and their complete conditional price are new here. +The basis identity is elementary linear algebra; no new general theorem +for that identity is claimed. + +The PR6167 source notice follows unchanged. Its nested source archive also +retains the earlier notices. + +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. + +Binary query-tree caller + +New construction, proof and code: Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. No subagents. + +Cinna Davis supplies the productive path caller, query thinning and exact Laurent factorization. Ali Romman supplies the all-forward P104 binding in PR5544 and the retained-operand word in PR6167. The native word and interval/compiler lineage remain predecessor work. The new contribution is the four-field query extension, its tree composition, complete invoice and conditional price. + +The authenticated PR6167 notice follows. + +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. diff --git a/research/mixed-root-source-composition/PRICING-EDITS.json b/research/mixed-root-source-composition/PRICING-EDITS.json new file mode 100644 index 0000000000..c0c62b4b5a --- /dev/null +++ b/research/mixed-root-source-composition/PRICING-EDITS.json @@ -0,0 +1,30 @@ +[ + [ + "KAPPA = Q('0.00328467')", + "KAPPA = Q('0.00328551')" + ], + [ + "TESTED = Q('0.003284675')", + "TESTED = Q('0.003285515')" + ], + [ + "PREVIOUS = Q('0.00315057')", + "PREVIOUS = Q('0.00328467')" + ], + [ + "(13652, 66988)", + "(13652, 67096)" + ], + [ + "The mixed root improves the published PR6353 claim", + "The composed source improves the fixed root claim" + ], + [ + "'kappa_decimal': '0.00328467', 'previous_pr6353': PREVIOUS", + "'kappa_decimal': '0.00328551', 'previous_fixed_root': PREVIOUS" + ], + [ + "This file counts the new root, individual idles and ordinary normalization.", + "This adapter keeps the root and changes the native source invoice.\nIt includes all nine output contractions and their productive target debits." + ] +] diff --git a/research/mixed-root-source-composition/PROOF.md b/research/mixed-root-source-composition/PROOF.md new file mode 100644 index 0000000000..e8fc7988be --- /dev/null +++ b/research/mixed-root-source-composition/PROOF.md @@ -0,0 +1,115 @@ +# Complete composition of the root and contracted native source + +The new conditional claim is kappa 0.00328551. The proof uses the five +inherited assumptions: native_all_columns, owned_erasure, compiler, +precision_tape and analytic_recovery. No unconditional theorem is claimed. + +## Exact source and interface + +The root source is local commit 52e87e4971a85a8f098fadb967dc75bee9f76c65. +Its four binary children have 7, 2, 2 and 7 leaves. Its full projector ranks +are 2, 3, 3 and 2. The constructor emits the same 570 instructions and +34 independent main fields per port. The replay checks all 1,156 endpoint +coefficients in the declared Laurent ring, including all normalizations. + +PR6353 at db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3 changes nine helper +outputs. It keeps the native main interface D U(q). The source constructor +rebuilds every byte of its 17,657-event word and every joint-basis witness. +Its complete scalar replay checks all independent public inputs and owned +lifetimes. The separate dense reverse replay checks 799 columns and +638,401 coefficients. The native phase checker then verifies the actual +word. The caller checker binds all 7,488 physical native contacts and all +paired and individual whole idle jobs. + +The local source has 29 owned labels, 41 lifetimes and peak ownership 13. +All 562 helper inputs per native call remain independent. They are separate +from the caller inputs and from the helpers in other calls. + +## Complete invoice + +Write H(r)=r^(1-kappa). Relative to PR6349, one contracted native call has +the paid change + +```text +14 H1 - 4 H2 - 3 H3 + 4 H4 - 5 H5 +``` + +and the productive helper change + +```text +H5 + 8 H8 - 9 H9. +``` + +The checker reconstructs these two changes from the exact words. It then +requires exactly 18 copies of each change in the complete caller bill. +No target debit is omitted. The emitted instructions and a separate formula +give the same invoice. + +There are 67,096 paid jobs and 13,652 productive fields. Paid rank mass is +185,124 and productive rank mass is 185,884. Their difference is 760. +The maximum paid rank is 56; the maximum productive rank is 145. All +17 thin queries, 14 paired whole idles and two individual whole idles are +charged. All 20 ordinary normalizations remain in the caller. + +Two rational moment engines give a strict raw crossing in +(0.00328552920257, 0.00328552920258). The unchanged-source caller has a +strict negative margin at the new claim. Its old crossing is separately +checked in (0.00328468791927, 0.00328468791928). + +## Completion, compiler and outer transfer + +The tested saving is 0.003285515. Completion uses power 1024, cutoff 12, +floor 13, offset 1/7, reserve 10^-12 and decay 31/32. Both moment engines, +all completion ratios and the exact compiler integer grid must pass. + +The complete ordinary allowance is 248,152,864, below the retained budget +of 10^9. It includes source scalar work, native routes, the changed owned +lifetimes, every caller basis operation and every normalization. The BIT +admission remains 0.0034. All 54 strict and four functional outer predicates +are positive. The large uniform word is not materialized. + +The checker also rejects 53 controls, including a missing paid native job, +a missing helper target debit, damaged source bytes and the inherited +native, caller and source-semantic faults. Verification under optimized +Python keeps these checks active. + +## Ceiling for all binary child sizes + +The fixed-root ceiling is recalculated with the contracted source. At +kappa 0.00328554, rational outward intervals check all 4,851 binary splits +and all 4,656 root pair choices with total size below 100. Every margin +upper bound is negative; the largest is below -0.00002385 per port. + +For all larger totals, the same concavity argument as the root source +gives a decreasing upper bound. Its value at 100 is below -1.853 and +its derivative is below -0.0592. The native deficit derivative stays +above 42.04 throughout the admitted range. Thus larger child sizes, +other binary tree shapes and larger savings up to 0.0034 cannot pass +for this fixed root and PR6353 source. + +The claimed saving is within 0.00000003 of this ceiling. This is a scoped +ceiling. It does not limit a changed root, native source or query interface. + +## Scope and open next questions + +This composition adds 0.0255733 percent over the previous local root. +The complete contribution, including that new root, is 4.28303 percent +above PR6353. The composition increment and the full caller gain are +separate comparisons. Neither proves global optimality, a practical +speedup, all five framework assumptions or independent scientific +acceptance. The selected frontier stays unchanged. + +The companion `mixed-projector-root-headroom/PROOF.md` extends the same +0.00328554 ceiling to every six-field, seven-query root with four full +stages and at most two extra whole idles. It retains arbitrary scalar +bases and the free endpoint parameter. The numeric ceiling here is +unchanged; the companion proves the larger domain where it applies. + +The next review should check the exact source closure and all 18 productive +debits before it checks the outer inequalities. A larger construction must +change the source or caller and supply a new complete identity and bill. + +Credit stays with the two source packages, the earlier local composition +adapter and all native, helper, caller, recursion, compiler, BIT and analytic +authors in `NOTICE`. New composition and checks: Ali Romman with substantial +OpenAI Codex assistance; no subagents. Apache-2.0. diff --git a/research/mixed-root-source-composition/PUBLICATION.json b/research/mixed-root-source-composition/PUBLICATION.json new file mode 100644 index 0000000000..7645bc0207 --- /dev/null +++ b/research/mixed-root-source-composition/PUBLICATION.json @@ -0,0 +1,73 @@ +{ + "scientific_commit": "7c71f599984e53993fd2d5e8bd832193b8a09fd5", + "environment": { + "python": "3.12.13", + "platform": "macOS 26.6.1 arm64", + "scientific_dependencies": "standard library" + }, + "sealed_exports": [ + { + "package": "mixed-projector-root-headroom", + "archive_sha256": "7a27326b98fd7ede2716de311b4828a8cf302f11eeafe58d00e2ff126d751062", + "export_files": 15, + "elapsed_seconds": 0.9113524159984081, + "exit_code": 0, + "probes": { + "live_read": "PASS", + "export_write": "PASS", + "network": "PASS", + "git_absent": "PASS" + }, + "bytes_and_modes_unchanged": true, + "marker": "PASS_MIXED_ROOT_MINIMUM_IDLE_CLASSIFICATION" + }, + { + "package": "mixed-root-contact-composition", + "archive_sha256": "aebe48e545fd9bbf37442e7b1f46c84e523b7ad4a628ad62fe991025cbc98b07", + "export_files": 21, + "elapsed_seconds": 64.88803258400003, + "exit_code": 0, + "probes": { + "live_read": "PASS", + "export_write": "PASS", + "network": "PASS", + "git_absent": "PASS" + }, + "bytes_and_modes_unchanged": true, + "marker": "PASS_MIXED_ROOT_CONTACT_COMPOSITION_KAPPA_00328584" + } + ], + "process_controls": [ + { + "control": "damaged_contact_archive", + "exit_code": 1, + "error": "ValueError: Exact PR6372 archive" + }, + { + "control": "changed_claim", + "exit_code": 1, + "error": "ValueError: Exact declared pricing.py adapter" + }, + { + "control": "wrong_parameter_inverse", + "exit_code": 1, + "error": "ValueError: Complete invariant image, with the parameter retained" + } + ], + "registered_logs": { + "root-registered.log": "65941491489e589d2e494936d5f5c3f9325bfb21a287f9f895b0e95a0da4c439", + "composition-registered.log": "744528aa5ad99491c6b4cb896aedf42e64c12f6db742079ed2b73a3f7695ac1d", + "headroom-registered-final.log": "0fb5f4d9f867ccb1a673fb467f498df29f03ea6f9ce2fa1629cf9697f7251427", + "contact-registered.log": "9dd461397d33969759c75b1f898bc30b354635ba2b861c657c3b2e00e60c3a2e" + }, + "selected_record_sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa", + "hosted_status_at_record": "pending", + "independent_acceptance": false, + "publication_hold": { + "status": "keep_local", + "instruction": "Do not open the PR.", + "branch_pushed": false, + "pull_request_opened": false, + "hosted_ci_run": false + } +} diff --git a/research/mixed-root-source-composition/PUBLICATION.md b/research/mixed-root-source-composition/PUBLICATION.md new file mode 100644 index 0000000000..5485a1a099 --- /dev/null +++ b/research/mixed-root-source-composition/PUBLICATION.md @@ -0,0 +1,95 @@ +The current result is **0.00328621476572836015146308**. See the [current validation](../mixed-root-contact-composition/VALIDATION.md) and [local PR draft](../mixed-root-contact-composition/PR-DRAFT.md). The older scientific receipts below remain unchanged. + +# Earlier verification checkpoint and publication hold + +The donor instructed this chat not to open the PR. This branch has not +been pushed and no PR has been opened. Keep the contribution local until +the donor gives new publication instructions. Hosted CI has not run. + +At this earlier checkpoint the complete conditional claim was 0.00328584, about 4.28358 percent +above PR6372 at 0.00315087. The final source composition adds 0.0100441 +percent over the previous local 0.00328551 result. The original mixed-root +construction supplies most of the full gain. The structural proof adds +no numerical kappa increment. + +Canonical main was refreshed during research and before submission. It +remains 7c49fe32c55de02c2c873655c804b16e4c3fef0a. Priority revision 8 and +the selected record are unchanged. The selected record SHA256 remains +9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa. +The complete open-PR check grew from 323 to 326 records. The new PR6372 +source was then read, pinned and composed. Current adjacent Discussion +scopes concern separate native-source audits and source-level work. +Arbitrary unseen diffs and unpublished work remain coverage limits. + +## Author replay + +CPython 3.12.13, macOS 26.6.1 arm64. All four scientific packages need +only the Python standard library. The optional headroom discovery script +uses NumPy 2.5.4 and SciPy 1.18.1 and is not an acceptance command. + +The original root and PR6353 composition passed fresh registered normal +and optimized runs in this publication session. The headroom proof and +separate reverse caller also passed both modes. Adding the reverse engine +first changed the expected receipt; the stale receipt was rejected. After +regeneration, the full registered headroom replay passed. + +The final PR6372 composition passed a direct complete replay and both +registered normal and optimized commands. All four packages passed their +registered scientific checks in this publication session. +The final receipt has all 799 native columns, 638401 separate reverse +coefficients, all native phases, 7488 physical caller contacts, both +rational prices, the compiler, 54 strict and four functional outer checks, +27 rejecting controls, and the all-binary-size ceiling 0.00328587. +The separate reverse caller checks 4624 formal stage polynomials through +all four central characters and rejects seven controls. + +The exact root crossing is (0.00328585433547,0.00328585433548). The complete +ordinary bound is 248152864, below 10^9. The five framework assumptions +remain. The uniform word and rounded multiplier are not materialized. + +## Source and review boundaries + +PR6372 is retained at b556600ffe14be72406b03a47c661f3c7f1aff06, including +its exact constructor, word, witness, source receipt, proof and notice. +The root and PR6353 composition remain available at their original exact +source commits. Frozen archives and all source notices are unchanged. +Every live package input has an exact pin and a VERIFY.json declaration. + +The new structural proof retains all nonzero endpoint parameters. It +classifies the minimum-idle family and proves the larger idle lower +bounds. The next-cost-level search has seven time-limited integer runs; +all retained candidate margins are negative, but their upper bounds +remain positive. No global search exclusion follows. + +Hosted CI and independent scientific review are separate gates. Hosted +replay was not run at this checkpoint. No PR exists for this branch. Independent scientific acceptance is not claimed. +No merge, closure or selected-frontier change is authorized or performed. + +## Committed exports and isolated replays + +Scientific commit: `7c71f599984e53993fd2d5e8bd832193b8a09fd5`. +All four packages passed metadata, source pins and committed-byte checks. +The two new packages were exported with the official exporter from this +commit and passed its exact inventory and hash check. + +| Package | Export SHA256 | Sealed optimized replay | +| --- | --- | --- | +| mixed-projector-root-headroom | `7a27326b98fd7ede2716de311b4828a8cf302f11eeafe58d00e2ff126d751062` | passed, 0.91 seconds | +| mixed-root-contact-composition | `aebe48e545fd9bbf37442e7b1f46c84e523b7ad4a628ad62fe991025cbc98b07` | passed, 64.89 seconds | + +The OS denied network access, live-checkout reads and export writes. +Separate probes confirmed each denial with PermissionError. PATH was +empty and Git was absent. All 15 and 21 exported files, including the +export receipts, kept their bytes and modes. The original root and +PR6353 composition retain their earlier sealed receipts; their scientific +code and result bytes are unchanged. + +Three separate optimized-process controls were rejected: a damaged PR6372 +archive, a changed kappa literal and an incorrect Laurent-parameter inverse. +`PUBLICATION.json` retains these results and the registered log hashes. +The following commit adds only this verification record. + +Reproduce the committed export with the package exporter described in +`docs/research/package-export.md`, using the scientific commit above. +Run the documented direct verifier from the checked export. The generic +registered runner needs Git provenance; the direct exported replay does not. diff --git a/research/mixed-root-source-composition/README.md b/research/mixed-root-source-composition/README.md new file mode 100644 index 0000000000..263bbd2b86 --- /dev/null +++ b/research/mixed-root-source-composition/README.md @@ -0,0 +1,83 @@ +# Conditional kappa 0.00328551 from the mixed root and contracted source + +The complete conditional bound is **kappa 0.00328551**, an increase of +**0.00013494 (4.28303 percent)** over PR6353's 0.00315057. The new caller +supplies most of this gain. The final source composition adds 0.0255733 +percent over the preceding local root at 0.00328467. These comparisons +are separate; the full gain is not attributed to the composition step. + +This package combines the current mixed-projector root with PR6353's nine +native output contractions. It keeps the root, all four child trees and all +570 caller events unchanged. Each of the 18 native calls uses the contracted +source, with every productive target debit included. + +The subsequent [final source composition](../mixed-root-contact-composition/README.md) +is the final result in this contribution, at **0.00328621476572836015146308**. This package +retains the exact intermediate result and source closure for review. + +The exact raw crossing is in +`(0.00328552920257, 0.00328552920258)`. The full replay passes at the claim +above and tested saving 0.003285515. There are 67,096 paid jobs and 13,652 +independent productive fields. The complete rank-mass surplus remains 760. + +The five inherited framework assumptions remain. The checks are author +checks; independent scientific review remains open. The selected frontier +stays unchanged. Historical validation receipts retain their original +local-publication status. Current publication evidence is recorded in +`PUBLICATION.md`. + +## Review path and proved headroom + +1. The [root proof](../mixed-projector-query-root/PROOF.md) defines the + global normalization, projectors and literal 570-event caller. Its + source is PR6349. That package proves the separate 0.00328467 result. +2. [This composition proof](PROOF.md) binds the root to PR6353, including + all 18 copies of its paid change and productive target debits. It + supplies the final 0.00328551 result and complete source archive. +3. The [headroom proof](../mixed-projector-root-headroom/PROOF.md) classifies + every six-field, seven-query root with four full stages and at most + two extra whole idles. The ceiling 0.00328554 applies to this entire + class, with arbitrary scalar bases and all binary child sizes and shapes. + It also proves new idle lower bounds for more full stages. This is + supplementary proof, not an additional kappa increment. + +## Replay + +Use Python 3.12 and its standard library: + +```sh +python3 -I -B research/mixed-root-source-composition/verify.py +python3 -I -O -B research/mixed-root-source-composition/verify.py +``` + +The source archive is complete. The checker authenticates its 38 files +before it loads any predecessor code. It reconstructs the native word, +checks its arbitrary inputs and native phases, and checks the complete +caller, price, compiler and outer ledger. See `VALIDATION.md` for the +commands that were actually run and their limits. + +## Sources and credit + +The root is frozen at local commit +`52e87e4971a85a8f098fadb967dc75bee9f76c65`. The native source is +[PR6353](https://github.com/CrocSwap/integer-mult-bounds/pull/6353), exact +head `db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3`. Canonical main is +`7c49fe32c55de02c2c873655c804b16e4c3fef0a`. + +The earlier local `contracted-mixed-query-local` package supplied the +composition checker. This package changes its root input and price adapter. +It does not claim either source mechanism or that adapter as a new result. +All source notices are retained in `NOTICE` and the source archive. + +Ali Romman with substantial OpenAI Codex assistance; no subagents. +Apache-2.0. See `PROOF.md` for the complete scope. + +## Open next questions + +- Can an independent reviewer confirm the source and root composition, + including all target debits and the physical native contacts? +- Can a root outside the classified minimum-idle family or a different + source give a material gain? The complete claim is within 0.00000003 + of that family's ceiling. More idles, different query counts and + changed child interfaces remain possible routes. Numerical discovery + does not establish a global optimum. diff --git a/research/mixed-root-source-composition/RESULT.json b/research/mixed-root-source-composition/RESULT.json new file mode 100644 index 0000000000..cc266a2e5c --- /dev/null +++ b/research/mixed-root-source-composition/RESULT.json @@ -0,0 +1,425 @@ +{ + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "binary": { + "coefficients": 16, + "identity": "L S A B Idle S^-1 C R = D_A D_B (U(q) direct-sum q direct-sum q^-1)", + "missing_idle_rejected": true, + "variables": [ + "q", + "D_A", + "D_B" + ] + }, + "caller": { + "coefficients": 1156, + "event_sha256": "be648c29aa09c0f068a3b5b5120d1eb1f782e49f4523b4c6d62843750517bdea", + "events": 570, + "inputs": 34, + "native_stages": 18 + }, + "columns": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 638401, + "columns": 799 + }, + "contracted_source": "db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3", + "fixed_root_ceiling": { + "admitted_saving_cap": "17/5000", + "binary_split_checks": 4851, + "ceiling": "164277/50000000", + "finite_margin_upper": "-7787170321424434524363970551831346942375489097397016615/326409290240107399719461050006798653637322483112129794670592", + "finite_pair_checks": 4656, + "first_tail_total": 100, + "native_derivative_lower": "86138912185857402894129942396511331880097482936030575207057935126156899899547982742715512297768167758596705255686534371/2048904322212512919038510085207467917864146442064203226733311257020777532117854951793541845254015613321944655495954432", + "scope": "All positive integer child sizes and all binary tree shapes for this fixed root and PR6353 source.", + "tail_derivative_upper": "-1212374402678709925753322157077533054142098874263059860209298677722997/20477146569221237675252072016256588739640941191035000425388441600000000", + "tail_margin_upper": "-302481154036608143267296779618452642963157685887739205404201/163204645120053699859730525003399326818661241556064897335296" + }, + "gain_over_pr6353": "6747/50000000", + "local": { + "endpoint_coefficients": 638401, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 15, + "6": 3, + "7": 9, + "8": 30, + "9": 372 + }, + "owned_fields": 29, + "owned_lifetimes": 41, + "paid": { + "1": 2231, + "2": 453, + "3": 494, + "4": 104, + "5": 156, + "6": 8, + "7": 9, + "8": 1 + }, + "paid_rank_mass": 5934, + "peak_owned_fields": 13, + "public_inputs": 770, + "real_scalar_allowance": 128694 + }, + "native": { + "distinct_maps": 2932, + "helper_normalizers": 1124, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 15, + "6": 3, + "7": 9, + "8": 30, + "9": 372 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "d06140f989e8fcd952e76043386df1b04e4bde54afc1775b17db5300823af225", + "wrong_phase_rejected": true + }, + "negative_controls": { + "damaged_research/balanced-query-tree/CONTROLLER.json": "Source SHA256: research/balanced-query-tree/CONTROLLER.json", + "damaged_research/balanced-query-tree/RESULT.json": "Source SHA256: research/balanced-query-tree/RESULT.json", + "damaged_research/balanced-query-tree/controller.py": "Source SHA256: research/balanced-query-tree/controller.py", + "damaged_research/balanced-query-tree/module_check.py": "Source SHA256: research/balanced-query-tree/module_check.py", + "damaged_research/balanced-query-tree/physical.py": "Source SHA256: research/balanced-query-tree/physical.py", + "damaged_research/balanced-query-tree/pricing.py": "Source SHA256: research/balanced-query-tree/pricing.py", + "damaged_research/mixed-projector-query-root/CONTROLLER.json": "Source SHA256: research/mixed-projector-query-root/CONTROLLER.json", + "damaged_research/mixed-projector-query-root/NOTICE": "Source SHA256: research/mixed-projector-query-root/NOTICE", + "damaged_research/mixed-projector-query-root/PROOF.md": "Source SHA256: research/mixed-projector-query-root/PROOF.md", + "damaged_research/mixed-projector-query-root/RESULT.json": "Source SHA256: research/mixed-projector-query-root/RESULT.json", + "damaged_research/mixed-projector-query-root/ROOT.json": "Source SHA256: research/mixed-projector-query-root/ROOT.json", + "damaged_research/mixed-projector-query-root/SOURCES.json": "Source SHA256: research/mixed-projector-query-root/SOURCES.json", + "damaged_research/mixed-projector-query-root/algebra.py": "Source SHA256: research/mixed-projector-query-root/algebra.py", + "damaged_research/mixed-projector-query-root/ceiling.py": "Source SHA256: research/mixed-projector-query-root/ceiling.py", + "damaged_research/mixed-projector-query-root/controller.py": "Source SHA256: research/mixed-projector-query-root/controller.py", + "damaged_research/mixed-projector-query-root/module_check.py": "Source SHA256: research/mixed-projector-query-root/module_check.py", + "damaged_research/mixed-projector-query-root/physical.py": "Source SHA256: research/mixed-projector-query-root/physical.py", + "damaged_research/mixed-projector-query-root/pricing.py": "Source SHA256: research/mixed-projector-query-root/pricing.py", + "damaged_research/p104-frontier-compression-2/WORD.json.gz": "Source SHA256: research/p104-frontier-compression-2/WORD.json.gz", + "damaged_research/p104-joint-output-contraction/BASIS.json": "Source SHA256: research/p104-joint-output-contraction/BASIS.json", + "damaged_research/p104-joint-output-contraction/NOTICE": "Source SHA256: research/p104-joint-output-contraction/NOTICE", + "damaged_research/p104-joint-output-contraction/PROOF.md": "Source SHA256: research/p104-joint-output-contraction/PROOF.md", + "damaged_research/p104-joint-output-contraction/RESULT.json": "Source SHA256: research/p104-joint-output-contraction/RESULT.json", + "damaged_research/p104-joint-output-contraction/SOURCES.json": "Source SHA256: research/p104-joint-output-contraction/SOURCES.json", + "damaged_research/p104-joint-output-contraction/WORD.json.gz": "Source SHA256: research/p104-joint-output-contraction/WORD.json.gz", + "damaged_research/p104-joint-output-contraction/construct.py": "Source SHA256: research/p104-joint-output-contraction/construct.py", + "damaged_research/p104-joint-output-contraction/support.py": "Source SHA256: research/p104-joint-output-contraction/support.py", + "damaged_research/p104-joint-output-contraction/verify.py": "Source SHA256: research/p104-joint-output-contraction/verify.py", + "damaged_research/p104-native-input-lifting/RESULT.json": "Source SHA256: research/p104-native-input-lifting/RESULT.json", + "damaged_research/p104-native-input-lifting/SOURCES.json": "Source SHA256: research/p104-native-input-lifting/SOURCES.json", + "damaged_research/p104-native-input-lifting/WORD.json.gz": "Source SHA256: research/p104-native-input-lifting/WORD.json.gz", + "damaged_research/p104-native-input-lifting/construct.py": "Source SHA256: research/p104-native-input-lifting/construct.py", + "damaged_research/p104-native-input-lifting/support.py": "Source SHA256: research/p104-native-input-lifting/support.py", + "damaged_research/p104-native-input-lifting/verify.py": "Source SHA256: research/p104-native-input-lifting/verify.py", + "damaged_research/p104-retained-operand-descent/SOURCES.json": "Source SHA256: research/p104-retained-operand-descent/SOURCES.json", + "damaged_research/p104-retained-operand-descent/inputs/pr5827-source.tar": "Source SHA256: research/p104-retained-operand-descent/inputs/pr5827-source.tar", + "damaged_research/p104-retained-operand-descent/pricing.py": "Source SHA256: research/p104-retained-operand-descent/pricing.py", + "damaged_research/p104-retained-operand-descent/sources.py": "Source SHA256: research/p104-retained-operand-descent/sources.py", + "missing_departure_basis_inverse": "All public and owned rows", + "missing_dirty_carrier_subtraction": "All public and owned rows", + "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_input_basis": "All public and owned rows", + "missing_lambda": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_local": "Every native stage exactly once", + "missing_output_basis_inverse": "All public and owned rows", + "missing_output_target_debit": "All public and owned exits", + "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_target_debit": "All source helper targets have native maps", + "unpaid_native_move": "All independent fields and paid calls", + "wrong_output_subspace": "Nested chronological transport", + "wrong_temporary_frame": "Common scalar chart" + }, + "paid_delta": { + "1": 14, + "2": -4, + "3": -3, + "4": 4, + "5": -5 + }, + "physical": { + "central_square_columns": 53248, + "central_translations": 16, + "full_calls": 18, + "main_targets": { + "1": 104, + "145": 104, + "17": 1872, + "25": 416, + "33": 416, + "57": 416, + "73": 208 + }, + "new_paid_jobs": 0, + "ordinary_normalizations": 20, + "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 + } + }, + "price": { + "compiler": { + "H": 70855400000000, + "N": "2^70855400000000", + "eta": { + "lower": "0.000000053325484514377837655192", + "upper": "0.000000053325484514377837655193" + }, + "gap": "1/1400000000", + "integer_test_exponent": 50611, + "logarithm_power": 1100, + "theta": "63/64", + "uniform_saving": "114993/35000000", + "word_materialized": false + }, + "derivative_upper": "-710870644862992172687958825774804014933510538502192744525148441/3138550867693340381917894711603833208051177722232017256448", + "full_forward_calls": 18, + "gain": "21/25000000", + "kappa": "328551/100000000", + "kappa_decimal": "0.00328551", + "margin_at_previous": { + "lower": "0.197436126960496609424840071717", + "upper": "0.197436126960496609424840071718" + }, + "negative_controls": { + "old_BIT": "An outer inequality fails at BIT saving0.0027.", + "old_completion": "Cutoff16 and floor17 give a ratio above one." + }, + "nonrecursive": { + "local_routes": 5368000, + "local_scalar": 128694, + "paid_rank_mass": 185124, + "peak_owned_fields": 13, + "raw_budget": 1000000000, + "raw_scalar_upper": 248152864, + "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": "6439605195400283/1960000000000000000", + "fused_gaussian": "6439605186200849/1960000000000000000", + "global_coordinate_router": "2299859/700000000", + "group_bit_router": "3219803293100423/980000000000000000", + "group_scans": "699999999/700000000", + "main_transform": "6439603795400283/1960000000000000000", + "microbox_face_corrections": "26950000001/350000000", + "polynomial_products": "1399999999/1400000000", + "sparse_union_movement": "802689605195400283/1960000000000000000" + }, + "parameters": { + "a": "2299859/700000000", + "b": "4599719/1400000000", + "beta": "1399999997/1400000000", + "bit_saving": "17/5000", + "cap_xi": "1782689603795400283/1960000000000000000", + "complex_uniform_saving": "114993/35000000", + "d": "1/1400000000", + "epsilon": "1399999999/1400000000", + "kappa": "328551/100000000", + "lambda_": "79737159/80000000", + "lambda_prime": "1395400283/1400000000", + "layout": "1/1400000000", + "q": "4599717/1400000000", + "r0": "1/14000000000", + "stop": "1/1400000000", + "tested_saving": "657103/200000000" + }, + "strict_checks": { + "actual_bit_above_effective": "80141/700000000", + "actual_logarithmic_gamma_guard": "1/1400000000", + "actual_logarithmic_group_guard": "177310398304599717/980000000000000000", + "alpha_logarithm_absorption": "1/14000000000", + "boundary_algebraic_matrix_above_kappa": "5595400283/1960000000000000000", + "cap_above_band": "802689603795400283/1960000000000000000", + "cap_below_cell": "177310394804599717/1960000000000000000", + "cap_below_phase_cell_power": "2137310396204599717/1960000000000000000", + "complex_above_effective": "1/1400000000", + "complex_below_one_over_32": "39150281/1400000000", + "complex_endpoint": "1/700000000", + "epsilon_below_one": "1/1400000000", + "epsilon_positive": "1399999999/1400000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "5586200849/1960000000000000000", + "gaussian_above_main": "695400283/980000000000000000", + "global_coordinate_router_above_kappa": "1/350000000", + "global_gamma_power_slack": "9/14000000000", + "group_below_dimension": "1/700000000", + "group_bit_router_above_kappa": "3493100423/980000000000000000", + "group_gauge_power_slack": "177310398234599717/980000000000000000", + "group_key_fits_record": "1/700000000", + "group_positive": "1399999997/1400000000", + "group_scans_above_kappa": "348850071/350000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "777269790400418148631/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": "2795400281/1960000000000000000", + "leaf_saving_above_effective": "1395400281/1960000000000000000", + "main_transform_above_kappa": "4195400283/1960000000000000000", + "membership_arithmetic_fits_record": "1/1400000000", + "microbox_face_corrections_above_kappa": "10779540029/140000000", + "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": "279080057/280000000", + "positive_layout_slack": "1/1400000000", + "q_below_effective": "1/1400000000", + "q_below_internal": "1/1400000000", + "q_below_leaf": "2795400281/1960000000000000000", + "q_positive": "4599717/1400000000", + "short_record_fallback": "1395400281/1400000000", + "source_axis_superpolynomial": "1/1400000000", + "sparse_union_movement_above_kappa": "796250005595400283/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": 41926, + "16": 1872, + "2": 8154, + "24": 416, + "3": 8892, + "32": 416, + "4": 1872, + "5": 2808, + "56": 416, + "6": 144, + "7": 162, + "8": 18 + }, + "paid_calls": 67096, + "previous_fixed_root": "328467/100000000", + "productive_fields": 13652, + "rank_mass_surplus": 760, + "raw_headroom": [ + "1920257/100000000000000", + "960129/50000000000000" + ], + "raw_root_interval": [ + "328552920257/100000000000000", + "164276460129/50000000000000" + ], + "relative_gain_percent": "2800/109489", + "strictification": { + "alpha": { + "lower": "0.999999982266622986391739596247", + "upper": "0.999999982266622986391739596248" + }, + "cutoff": 12, + "delta": { + "lower": "0.956506703835386815484711005744", + "upper": "0.956506703835386815484711005745" + }, + "floor": 13, + "gamma": { + "lower": "0.924130040323360594316376926466", + "upper": "0.924130040323360594316376926467" + }, + "normalized_paid_upper": "1048576000976562501/1048576001073741824", + "power": 1024, + "reserve": "1/1000000000000", + "tail_block": 128, + "tail_decay": "31/32", + "tail_offset": "1/7", + "tested": "657103/200000000" + }, + "targets": { + "1": 356, + "145": 104, + "17": 1872, + "2": 144, + "25": 416, + "3": 72, + "33": 416, + "4": 1926, + "5": 270, + "57": 416, + "6": 54, + "7": 162, + "73": 208, + "8": 540, + "9": 6696 + }, + "thin_queries": 17, + "whole_idle_jobs": 3120 + }, + "published": false, + "relative_gain_over_pr6353_percent": "449800/105019", + "root": { + "actual_tensor_gaussian_columns": 14, + "fields": 6, + "full_sites": 4, + "gaussian_characters": 4, + "normalization_growth_per_operation_upper": 2, + "ordinary_normalization_operations_per_pair": 4, + "owned_normalization_fields": 0, + "polynomial_coefficients": 1152, + "stage_ranks": [ + 2, + 3, + 3, + 2 + ], + "tensor_rule": "Normalize the complete field with its global Q squared translation; scalar coefficients stay outside tensor powers.", + "thin_sites": 3, + "wrong_tensor_normalization_rejected": true + }, + "root_source": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "same_caller_old_margin_upper": "-593038642754718312398192639814955356406652249474950126421/3138550867693340381917894711603833208051177722232017256448", + "same_caller_old_root": [ + "328468791927/100000000000000", + "41058598991/12500000000000" + ], + "selected_frontier_changed": false, + "source_files": 38, + "status": "PASS_MIXED_ROOT_SOURCE_COMPOSITION_KAPPA_00328551", + "target_delta": { + "5": 1, + "8": 8, + "9": -9 + } +} diff --git a/research/mixed-root-source-composition/SOURCES.json b/research/mixed-root-source-composition/SOURCES.json new file mode 100644 index 0000000000..5a96638cb3 --- /dev/null +++ b/research/mixed-root-source-composition/SOURCES.json @@ -0,0 +1,33 @@ +{ + "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": "sources.tar", + "manifest": "INPUTS.json", + "archive_sha256": "6d05208f4fa1d98b4b63a8b2d9366576313a1f1466232a6a4f1a286de23c292b", + "reason": "The fixed root is local-only. The contracted source is a separate pending PR. Exact executable inputs and notices are retained; neither source commit is a runtime or publication-history dependency.", + "root_commit": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "contracted_commit": "db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3" + } + ], + "local_adapter_provenance": { + "package": "contracted-mixed-query-local", + "verify_sha256": "e4e400fe08115bec501c17cd03362a6a6d24b22bf6d1ac907126c0a83300cc3a", + "scope": "Local predecessor checker; attribution only. Exact executable sources are in sources.tar." + } +} diff --git a/research/mixed-root-source-composition/TASK.json b/research/mixed-root-source-composition/TASK.json new file mode 100644 index 0000000000..4a202c946a --- /dev/null +++ b/research/mixed-root-source-composition/TASK.json @@ -0,0 +1,91 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 8, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "joint-query-controller", + "question": "Can a changed query demand or caller remove real work while satisfying native chronology and restoration?", + "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" + ], + "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": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "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": "Choose an exact caller and a new demand/interface hypothesis. Read the scoped #5617/#5631/#5649/#5747 and #5720/#5745 objections before rebuilding an excluded schedule. Compare the complete matched source/consumer protocols including all retained helper outputs. For an active-mode injection, first check #5745: its canonical delivery claim repays the eight removed centre jobs. Audit that exact claim or change its channel/feedback hypothesis; do not repeat the same free-injection search. Stop if the full favorable budget fails or the required restored output is unobservable.", + "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": [ + "query demand", + "active mode", + "5720", + "5745", + "5747", + "caller" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "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": "Compose the current 7,2,2,7 mixed-projector root with the complete PR6353 source and verify its full conditional bound.", + "scope_change_reason": "The user requested a larger local result. This composition gives a small verified increment while distinct discovery routes continue.", + "bottleneck_link": "The complex supplier binds. The source change reduces the full signed cost at every one of the eighteen native calls.", + "stop_rule": "Reject any changed root event, missing target debit, native phase failure, incomplete source closure, failed interval or compiler/outer bound. No PR or push before donor approval.", + "outcome": "completed", + "evidence": "RESULT.json checks kappa .00328551, all native inputs and phases, 7488 contacts, both rational prices, the compiler and 58 outer predicates. The gain over the prior local .00328467 is .0255733 percent.", + "author": "Ali Romman with substantial OpenAI Codex assistance; no subagents", + "ai_assistance": "Substantial OpenAI Codex assistance; no subagents.", + "open_questions": [ + { + "question": "Can an independent reviewer confirm the complete contracted-source and mixed-root composition?", + "why_it_matters": "Both source mechanisms and the composition remain conditional and author checked.", + "first_step": "Check the exact source deltas at all eighteen calls, then replay the fixed root and native physical contacts.", + "blocked_by": "No scientific review is claimed by the local author replay." + }, + { + "question": "Can a new mechanism improve materially on the frozen mixed root?", + "why_it_matters": "The composition increment is small; most of the combined gain is inherited from the new root.", + "first_step": "Use a fresh overlap check and a favorable complete invoice before expanding a new caller.", + "blocked_by": "The present package changes no root or source construction." + } + ], + "publication_status": "LOCAL_ONLY_USER_REQUIRES_EXPLICIT_PR_PERMISSION", + "larger_user_objective": "Unmet: this scoped composition gains .0255733 percent, below one percent." +} diff --git a/research/mixed-root-source-composition/VALIDATION.json b/research/mixed-root-source-composition/VALIDATION.json new file mode 100644 index 0000000000..0494c26170 --- /dev/null +++ b/research/mixed-root-source-composition/VALIDATION.json @@ -0,0 +1,68 @@ +{ + "status": "PASS_READ_ONLY_GIT_FREE_NETWORK_DENIED_REPLAY", + "commit": "24f03629fc2a939ea0c6c015017bf1cdc07e06cd", + "archive_sha256": "19e4c2d34c2893049fa8dbf8c26a0f3c0bb2add8693000e4e5435583616df90a", + "export_path": "/private/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/sealed-root-composition-3t05jn4_", + "files_unchanged": 15, + "elapsed_seconds": 53.24608029099909, + "python": "Python 3.12.13", + "mode": "optimized", + "probes": [ + { + "probe": "live_checkout_read", + "exit_code": 1, + "error": "PermissionError: [Errno 1] Operation not permitted: '/Users/aliromman/.codex/worktrees/kappa-step-20261025/IntegerMultiplicationBounds/AGENTS.md'" + }, + { + "probe": "export_write", + "exit_code": 1, + "error": "PermissionError: [Errno 1] Operation not permitted: '/private/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/sealed-root-composition-3t05jn4_/deny-probe'" + }, + { + "probe": "network", + "exit_code": 1, + "error": "PermissionError: [Errno 1] Operation not permitted" + }, + { + "probe": "no_git", + "result": "PASS_NO_GIT_ON_PATH" + } + ], + "log": "/tmp/sealed-root-composition-20261102.log", + "process_controls": [ + { + "control": "archive", + "exit_code": 1, + "rejection": "Source archive hash" + }, + { + "control": "price", + "exit_code": 1, + "rejection": "Exact declared price adapter" + }, + { + "control": "ceiling", + "exit_code": 1, + "rejection": "Exact declared ceiling adapter" + } + ], + "selected_record_sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa", + "canonical_main": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "registered_log_sha256": "9ea75192298b5f537af35ff2e4e10475a4332440b827fcf5e4c204c98411b0a3", + "scientific_files": { + "SOURCES.json": "09d15c8038eca62a568aad3929f8bdedec186f5b4d32af6804bab5708b2bf029", + "PROOF.md": "8c7cecb7dcf75bafcb6dde7e76a452e193f73bbfb1ba3a6ed76290cf6108a3bb", + "VERIFY.json": "95c715237289e04e4a81a9d32d6dd6a60b1c6cff877c015cb09b8ff8fbd2514f", + "RESULT.json": "9e41c15bd1f4e95b899d37672002e1fcf20cbf98a00b0ae007c389f3e1752c04", + "ceiling.py": "c57bd8730a6e394e7f99e468ab913945bba03d68aa32f6d80bca8f68610cc920", + "TASK.json": "d770366c67ba4c4a75596ab235d67648064d08f993db24a818f0415f42565765", + "PRICING-EDITS.json": "e3f5de9a018ce9217463c81779319e76844a444c6b2c34a5ec52baa2001abe0f", + "NOTICE": "a8f3d0e1b368c213d7355bcad10cf3db55c5c1a475fdbad2a6a9282134aa9007", + "README.md": "947e43271ab920156c3cf77c0cf6bf27817e02affa339f18318201595e570231", + "INPUTS.json": "703ad732a3ec59b257477cc91e1bc340ce8c14942714828ce060eeeb878c6f7d", + "pricing.py": "41fcff7b5375bd166048f10b3504d3080d37fadc51c723f2e98873fb9eb88069", + "sources.tar": "6d05208f4fa1d98b4b63a8b2d9366576313a1f1466232a6a4f1a286de23c292b", + "verify.py": "3982ebe36924342345763cac8dc5fde50f23deccced56c528c6087d40e3034c4", + "CEILING-EDITS.json": "53d7f48c833c1132e246966cc520331daf78f2ce5ac3798d2c2b0fb1c1c38347" + } +} diff --git a/research/mixed-root-source-composition/VALIDATION.md b/research/mixed-root-source-composition/VALIDATION.md new file mode 100644 index 0000000000..b70cf48bcb --- /dev/null +++ b/research/mixed-root-source-composition/VALIDATION.md @@ -0,0 +1,76 @@ +# Local verification record + +The scientific commit is 24f03629fc2a939ea0c6c015017bf1cdc07e06cd. +The environment is CPython 3.12.13 on macOS arm64. The scientific package +needs only the standard library. Its archive has 38 authenticated source +files. The selected record remains unchanged. + +## Executed checks + +The direct replay constructed `RESULT.json` with the final bound and +changed-source ceiling. Both registered commands then passed: + +```sh +/tmp/kappa-1101-venv/bin/python -B scripts/research_package.py \ + --package research/mixed-root-source-composition +``` + +The runner executed normal and optimized Python. Both reported +`PASS_MIXED_ROOT_SOURCE_COMPOSITION_KAPPA_00328551`, followed by +`PASS_REGISTERED_RESEARCH_PACKAGE`. The result includes every native input +and phase, the caller, complete price, compiler, 58 outer predicates, +53 rejection controls and the ceiling for all binary child sizes. + +Three separate process controls changed the source archive, claim literal +and ceiling literal on temporary package copies. Each failed its declared +hash or exact-adapter gate under optimized Python. + +Metadata and source pins pass. `git diff --cached --check` passed before +the scientific commit. The byte preflight verified all 14 committed package +files. The official export passed its exact inventory and hash check: + +```sh +python3 -B scripts/check_research_commit.py \ + --package research/mixed-root-source-composition +python3 -B scripts/export_research_package.py export \ + --package research/mixed-root-source-composition \ + --ref 24f03629fc2a939ea0c6c015017bf1cdc07e06cd \ + --output /tmp/mixed-root-source-composition-20261102.tar +python3 -B scripts/export_research_package.py check \ + /tmp/mixed-root-source-composition-20261102.tar +``` + +The export SHA256 is +`19e4c2d34c2893049fa8dbf8c26a0f3c0bb2add8693000e4e5435583616df90a`. + +## Isolated replay + +The complete committed export passed an optimized replay with empty PATH. +An OS profile denied network access, reads from the live checkout and +writes to the export. Separate probes produced PermissionError for each +denied action. A further probe confirmed that Git was absent from PATH. +All 15 exported files, including the export receipt, retained their hashes +and modes. The replay took about 53.25 seconds. + +The committed ceiling adapter removes two inherited trailing blank lines +through a declared exact edit. This whitespace change followed registered +replay. The isolated replay checked the committed bytes and the complete +unchanged scientific receipt. No source assertion, interval condition or +compiler predicate was weakened. + +`VALIDATION.json` retains the isolated-run and process-control receipts. +The later validation-file commit changes documentation only. + +## Limits + +These are author checks. Hosted CI and independent scientific review have +not run for this local package. The five framework assumptions remain. +The uniform word, rounded multiplier and practical running time were not +tested. No full source-history ancestry check is claimed for the shallow +checkout; separate-branch executable inputs are retained in the archive. + +The final canonical-main refresh still gave +7c49fe32c55de02c2c873655c804b16e4c3fef0a. PR6353 remains open at the retained +db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3 head. No push, PR, merge, closure +or selected-frontier change was made. The larger requested gain remains +unmet; this package supplies only the stated composition increment. diff --git a/research/mixed-root-source-composition/VERIFY.json b/research/mixed-root-source-composition/VERIFY.json new file mode 100644 index 0000000000..67428eea2a --- /dev/null +++ b/research/mixed-root-source-composition/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": "Exact source reconstruction, all arbitrary inputs and phases, fixed caller, complete two-engine price, compiler, all outer predicates and a ceiling for all positive binary child sizes." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 590, + "checks": "The same complete conditional claim, all-child-size ceiling and rejecting controls under optimized Python." + } + ] +} diff --git a/research/mixed-root-source-composition/ceiling.py b/research/mixed-root-source-composition/ceiling.py new file mode 100644 index 0000000000..66fa8646d1 --- /dev/null +++ b/research/mixed-root-source-composition/ceiling.py @@ -0,0 +1,65 @@ +"""Bound every binary-child size for the rank 2,3,3,2 root. + +Adapted from the prior fixed-root ceiling by Ali Romman with OpenAI Codex. +The contracted native source stays fixed. Other roots and sources are outside +this claim. All arithmetic in this checker uses rational intervals. +""" +from fractions import Fraction as Q + +CEILING=Q('.00328554') +BIT_CAP=Q('.0034') +TAIL=100 + + +def run(local,E,root): + def need(ok,message): + if not ok:raise ValueError(message) + need(00,'The native deficit increases throughout the admitted range') + h={r:E.power(r,t) for r in range(1,8*TAIL+2)} + lower=[Q(0)]*TAIL + upper=[Q(0)]*TAIL + split_checks=0 + for n in range(2,TAIL): + node_lower=2*h[8*n][0]+1-2*h[8*n+1][1] + node_upper=2*h[8*n][1]+1-2*h[8*n+1][0] + lower[n]=min(lower[a]+lower[n-a]+node_lower for a in range(1,n)) + upper[n]=min(upper[a]+upper[n-a]+node_upper for a in range(1,n)) + need(lower[n]<=upper[n],'Binary subtree interval') + split_checks+=n-1 + pairs={} + for n in range(2,TAIL-1): + pairs[n]=max(h[8*n+1][1]-n*native_lower-lower[n-b]-lower[b] + +h[8*b+1][1]-h[8*b][0] for b in range(1,n)) + margins=[] + for n in range(4,TAIL): + for a in range(2,n-1): + margins.append(h[8*n+1][1]+pairs[a]+pairs[n-a]-2) + finite_upper=max(margins) + need(finite_upper<0,'Every finite child sum fails at the ceiling') + # Every binary node costs at least -1 by concavity. For total n, + # Jensen bounds the two pair outputs and each added increment is at + # most H9-H8. The resulting upper bound is decreasing for n >= TAIL. + tail_upper=(h[8*TAIL+1][1]+2*h[4*TAIL+1][1]-TAIL*(native_lower-1) + +2*(h[9][1]-h[8][0])-6) + derivative_upper=(8*t*(h[8*TAIL+1][1]/(8*TAIL+1) + +h[4*TAIL+1][1]/(4*TAIL+1))-(native_lower-1)) + need(tail_upper<0 and derivative_upper<0,'All larger child sums fail') + return {'ceiling':str(CEILING),'first_tail_total':TAIL,'binary_split_checks':split_checks, + 'admitted_saving_cap':str(BIT_CAP),'native_derivative_lower':str(derivative_lower), + 'finite_pair_checks':len(margins),'finite_margin_upper':str(finite_upper), + 'tail_margin_upper':str(tail_upper),'tail_derivative_upper':str(derivative_upper), + 'scope':'All positive integer child sizes and all binary tree shapes for this fixed root and PR6353 source.'} diff --git a/research/mixed-root-source-composition/pricing.py b/research/mixed-root-source-composition/pricing.py new file mode 100644 index 0000000000..0ba26a7e59 --- /dev/null +++ b/research/mixed-root-source-composition/pricing.py @@ -0,0 +1,171 @@ +"""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.00328551') +TESTED = Q('0.003285515') +PREVIOUS = Q('0.00328467') + + +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[1+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') + need((targets, paid) == formula_invoice(local), 'Independent tree and emitted-event counts') + need((counts['LOCAL'], counts['QUERY'], counts['IDLE']) == (18, 17, 14) and counts['IDLE_ONE'] == 2 and counts['LAMBDA'] == 20, 'Complete caller census') + need((sum(targets.values()), sum(paid.values())) == (13652, 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] + low, high, grid = 0, 10**12, 10**14 + while high-low > 1: + middle = (low+high)//2 + if margin(Q(middle, grid))[0] > 0: + low = middle + else: + high = middle + lower, upper = Q(low, grid), Q(high, 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') + need(PREVIOUS < KAPPA < TESTED < lower, 'The composed source improves the fixed root claim') + t, offset, power, cutoff, floor = 1-TESTED, Q(1, 7), 1024, 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**12), Q(31, 32) + need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All charged tail ratios') + need(decay**128 < Q(1, 16), 'Both tail decay blocks') + normalized = 1/(1+power*reserve)+Q(4, 2**32) + need(normalized < 1 and cutoff**64 < floor**63, 'Completion, splitting and rounding') + theta, logarithm_power = Q(63, 64), 1100 + # 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*34*104*len(word['events']) + 34*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.00328551', 'previous_fixed_root': PREVIOUS, + 'gain': KAPPA-PREVIOUS, 'relative_gain_percent': 100*(KAPPA/PREVIOUS-1), + 'raw_root_interval': [lower, upper], 'raw_headroom': [lower-KAPPA, upper-KAPPA], + '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, 'tail_block': 128, + '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.'}}) diff --git a/research/mixed-root-source-composition/sources.tar b/research/mixed-root-source-composition/sources.tar new file mode 100644 index 0000000000..9969dc140d Binary files /dev/null and b/research/mixed-root-source-composition/sources.tar differ diff --git a/research/mixed-root-source-composition/verify.py b/research/mixed-root-source-composition/verify.py new file mode 100644 index 0000000000..e99f66fe38 --- /dev/null +++ b/research/mixed-root-source-composition/verify.py @@ -0,0 +1,187 @@ +"""Check the fixed-root and contracted-source composition. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The earlier contracted-mixed-query-local package supplies this adapter. +All retained sources and proof engines keep their original notices. +""" +from collections import Counter +from copy import deepcopy +from contextlib import contextmanager +from fractions import Fraction as Q +from hashlib import sha1, sha256 +from pathlib import Path, PurePosixPath +import gzip +import importlib.util +import json +import sys +import tarfile +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT_SOURCE = 'research/mixed-projector-query-root/' +CONTRACT_SOURCE = 'research/p104-joint-output-contraction/' +STATUS = 'PASS_MIXED_ROOT_SOURCE_COMPOSITION_KAPPA_00328551' + + +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 authenticate(data, pin): + need(sha256(data).hexdigest() == pin['sha256'], 'Source SHA256: '+pin['path']) + blob = b'blob '+str(len(data)).encode()+b'\0'+data + need(sha1(blob).hexdigest() == pin['git_blob'], 'Source Git blob: '+pin['path']) + + +@contextmanager +def sources(): + manifest = read(HERE/'INPUTS.json') + archive = HERE/'sources.tar' + need(sha256(archive.read_bytes()).hexdigest() == manifest['archive_sha256'], 'Source archive hash') + pins = {p['path']:p for p in manifest['files']} + need(len(pins) == len(manifest['files']) == 38, 'Exact source inventory') + with tempfile.TemporaryDirectory(prefix='contracted-mixed-sources-') as temp: + root = Path(temp) + with tarfile.open(archive, 'r:') as tar: + members = tar.getmembers() + need(len(members) == len(pins) and {m.name for m in members} == set(pins), + 'No extra, missing or duplicate archive members') + for member in members: + path = PurePosixPath(member.name) + need(member.isfile() and not path.is_absolute() and '..' not in path.parts, + 'Regular relative source file') + data = tar.extractfile(member).read() + authenticate(data, pins[member.name]) + out = root/member.name + out.parent.mkdir(parents=True, exist_ok=True) + out.write_bytes(data) + yield root, manifest + + +def reject(action): + try: + action() + except ValueError as error: + return str(error) + raise ValueError('Invalid control accepted') + + +def delta(after, before): + out = Counter(after) + out.subtract(before) + return {r:n for r,n in out.items() if n} + + +def run(): + with sources() as (root, manifest): + source = root/ROOT_SOURCE + joint = root/CONTRACT_SOURCE + text = (source/'pricing.py').read_text() + for before, after in read(HERE/'PRICING-EDITS.json'): + need(text.count(before) == 1, 'One occurrence of each declared pricing edit') + text = text.replace(before, after) + need(text == (HERE/'pricing.py').read_text(), 'Exact declared price adapter') + text = (source/'ceiling.py').read_text() + for before, after in read(HERE/'CEILING-EDITS.json'): + need(text.count(before) == 1, 'One occurrence of each declared ceiling edit') + text = text.replace(before, after) + need(text == (HERE/'ceiling.py').read_text(), 'Exact declared ceiling adapter') + ceiling = load(HERE/'ceiling.py', 'composed_fixed_ceiling') + load(source/'algebra.py', 'algebra') + controller = load(source/'controller.py', 'controller') + module = load(source/'module_check.py', 'composed_root_module') + physical = load(source/'physical.py', 'composed_physical') + price = load(HERE/'pricing.py', 'composed_price') + support = load(joint/'support.py', 'support') + constructor = load(joint/'construct.py', 'construct') + checks = load(joint/'verify.py', 'composed_source_checks') + binary = load(root/'research/balanced-query-tree/module_check.py', 'composed_binary') + native_source = json.loads(gzip.decompress(support.inputs()[support.WORD])) + native_word, witness = constructor.construct(native_source) + need(constructor.payload(native_word) == gzip.decompress((joint/'WORD.json.gz').read_bytes()), + 'Every contracted native word byte') + need(constructor.encode(witness) == read(joint/'BASIS.json'), 'Every joint-basis witness') + word = controller.construct() + need(word == read(source/'CONTROLLER.json'), 'Every fixed root and child event') + root_check, binary_check = module.run(), binary.run() + caller = controller.replay(word) + controls = controller.controls(word) + print('PASS fixed root, normalization, binary children, complete caller and controls', flush=True) + with support.checkers() as (L, frozen): + old, local = L.replay(native_source), L.replay(native_word) + need(price.encode(local) == read(joint/'RESULT.json')['local'], 'Published contracted local receipt') + pd, td = delta(local['paid'], old['paid']), delta(local['helpers'], old['helpers']) + need(pd == {1:14,2:-4,3:-3,4:4,5:-5}, 'Exact paid source change') + need(td == {5:1,8:8,9:-9}, 'Exact productive target debit') + controls.update(checks.word_controls(L, native_word, witness)) + columns = L.reverse_columns(native_word) + need(columns['columns'] == 799 and columns['coefficients'] == 638401, 'All separate native columns') + print('PASS joint bases, arbitrary inputs, owned lifetimes and separate dense transpose', flush=True) + native = L.native(native_word) + maps = physical.physical(word, native_word, L) + need(maps['full_calls'] == 18 and maps['physical_contacts'] == 7488, 'Every physical caller contact') + print('PASS native absolute phases, all main contacts and whole idle jobs', flush=True) + bound = price.run(local, native, word, maps, L) + old_targets, old_paid = controller.formula_invoice(old) + targets = {int(r):n for r,n in bound['targets'].items()} + paid = {int(r):n for r,n in bound['paid'].items()} + need(delta(targets, old_targets) == {r:18*n for r,n in td.items()}, 'All eighteen target debits') + need(delta(paid, old_paid) == {r:18*n for r,n in pd.items()}, 'All eighteen paid changes') + E = L.load(frozen/'research/higher-moment-strictification/verify.py', 'composed_comparison') + def margin(t, p, k): + a,b = E.moment(t,1-k),E.moment(p,1-k) + return a[0]-b[1],a[1]-b[0] + fixed_ceiling = ceiling.run(local,E,read(source/'ROOT.json')) + old_upper = margin(old_targets,old_paid,price.KAPPA)[1] + need(old_upper < 0, 'Unchanged native source fails at the new claim') + old_root = [Q('0.00328468791927'),Q('0.00328468791928')] + need(margin(old_targets,old_paid,old_root[0])[0]>0 and + margin(old_targets,old_paid,old_root[1])[1]<0, 'Exact same-caller old crossing') + bad = deepcopy(local);bad['paid'][1]-=1 + controls['unpaid_native_move'] = reject(lambda:price.assemble(bad,native,word,maps)) + bad = deepcopy(local);bad['helpers'][9]+=1;bad['helpers'][8]-=1 + controls['missing_target_debit'] = reject(lambda:price.assemble(bad,native,word,maps)) + for pin in manifest['files']: + data = (root/pin['path']).read_bytes() + controls['damaged_'+pin['path']] = reject(lambda data=data,pin=pin:authenticate(bytes([data[0]^1])+data[1:],pin)) + print('PASS complete bill, both rational prices, compiler, outer checks and source controls', flush=True) + return price.encode(dict(status=STATUS,source_files=len(manifest['files']), + root_source=manifest['root_head'],contracted_source=manifest['contract_head'], + root=root_check,binary=binary_check,caller=caller,local=local,paid_delta=pd,target_delta=td, + fixed_root_ceiling=fixed_ceiling, + columns=columns,native=native,physical=maps,price=bound, + same_caller_old_root=old_root,same_caller_old_margin_upper=old_upper, + gain_over_pr6353=price.KAPPA-Q('.00315057'), + relative_gain_over_pr6353_percent=100*(price.KAPPA/Q('.00315057')-1), + negative_controls=controls, + assumptions=['native_all_columns','owned_erasure','compiler','precision_tape','analytic_recovery'], + selected_frontier_changed=False,published=False)) + + +def main(): + with tempfile.TemporaryDirectory(prefix='contracted-mixed-cache-') as cache: + sys.pycache_prefix=cache + result=run() + if sys.argv[1:]==['--write-result']: + (HERE/'RESULT.json').write_text(json.dumps(result,sort_keys=True,indent=2)+'\n') + else: + need(not sys.argv[1:], 'Only --write-result is supported') + need(result==read(HERE/'RESULT.json'), 'Exact retained scientific receipt') + print(STATUS,flush=True) + + +if __name__=='__main__': + main() diff --git a/research/mixed-root-third-anchor-composition/CEILING-EDITS.json b/research/mixed-root-third-anchor-composition/CEILING-EDITS.json new file mode 100644 index 0000000000..c0c92545b5 --- /dev/null +++ b/research/mixed-root-third-anchor-composition/CEILING-EDITS.json @@ -0,0 +1,10 @@ +[ + [ + "CEILING=Q('.00328554')", + "CEILING=Q('.00328637739144124222748804')" + ], + [ + "PR6353 source.", + "PR6375 source with the third group-1091 anchor." + ] +] \ No newline at end of file diff --git a/research/mixed-root-third-anchor-composition/CONTACT-INPUTS.json b/research/mixed-root-third-anchor-composition/CONTACT-INPUTS.json new file mode 100644 index 0000000000..af637a1cb5 --- /dev/null +++ b/research/mixed-root-third-anchor-composition/CONTACT-INPUTS.json @@ -0,0 +1,54 @@ +{ + "source_head": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "archive_sha256": "4f41c4d246b354132d032546037d866a5199f7a3ea015915bf748a8d323cefb8", + "files": [ + { + "path": "research/p104-contact-block-contraction/construct.py", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "d92f1f92e705eafdda770ec19b958084584420a8", + "sha256": "e18f0221827628e38674dc71198a95ccebc401476328e3db7569b84e4b7be969" + }, + { + "path": "research/p104-contact-block-contraction/WORD.json.gz", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "0af79e58172f85c302c35b193205c0b185b09393", + "sha256": "e3b6f1c25d672b8c85433be97ebad77ae6a6972352ce2ff63507d30835fcb491" + }, + { + "path": "research/p104-contact-block-contraction/BASIS.json", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "efa2be3e34cab2d15ceaf33ff43eab70ff4c12e6", + "sha256": "28d01a60c1780dc61373a13ac70654c140fa20519abdac0dd78f24c8343a002f" + }, + { + "path": "research/p104-contact-block-contraction/RESULT.json", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "66166eebc2305939214abbc00b254048374458eb", + "sha256": "36e6daa172d5eacc0803e2f3276a68681728dbf59f97b5fb7e7fa120f4d857ec" + }, + { + "path": "research/p104-contact-block-contraction/NOTICE", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "9af7effd3a0ff5218d94331567022fd179a1e8fa", + "sha256": "f13f42a39d4614b26d9871f5bc8fcb76e60cb44b4df8762cd51e505b43723e46" + }, + { + "path": "research/p104-contact-block-contraction/PROOF.md", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "3a670ce4c0ae727b4d3cd3604d67d45b189da3c7", + "sha256": "4d02ec61147085ed88c11340b369729c943b954a0cc41a9995ffc07d24f1a285" + }, + { + "path": "research/p104-contact-block-contraction/inputs/pr6353-WORD.json.gz", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "03ea7690285d4cda72815f962d5710ab96e08490", + "sha256": "0c83c1f1dee8c9442558719510a61b89f38c2dbfc8fb565ba035660d2a68d928" + }, + { + "path": "research/p104-contact-block-contraction/inputs/pr6353-construct.py", + "commit": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "git_blob": "fff6cfb443b8ad59c2b8ab8f1e8eb01017576d8a", + "sha256": "a6ed00edd11b902c25d345ba2b44063cd68ebe787fe92067b65d26c8e2dc9248" + } + ] +} diff --git a/research/mixed-root-third-anchor-composition/LIFT-INPUTS.json b/research/mixed-root-third-anchor-composition/LIFT-INPUTS.json new file mode 100644 index 0000000000..e53fd2bdb5 --- /dev/null +++ b/research/mixed-root-third-anchor-composition/LIFT-INPUTS.json @@ -0,0 +1,48 @@ +{ + "source_head": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "files": [ + { + "path": "research/p104-shared-carrier-lifts/construct.py", + "commit": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "git_blob": "c099995bef0e224cbb0ec61c06ed3d0b4d478b33", + "sha256": "fe7dc1d9aa55da393465388ee90faaa687b1e5be48dfa816a421069fa3d2de08" + }, + { + "path": "research/p104-shared-carrier-lifts/LIFTS.json", + "commit": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "git_blob": "2ee8cb78fd149f9aca8dd953c650b92495a56266", + "sha256": "38960b70a074888a2aeaf3b543629a7ae747c0c5d4f5c853371a6e7c483766c5" + }, + { + "path": "research/p104-shared-carrier-lifts/WORD.json.gz", + "commit": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "git_blob": "b1cfd03abe9128cf5a3908fbd82652e5e8a2e292", + "sha256": "9e31463a785c18a70f6ae6ef3d04a6560dbb965517109390fe820f9fac3371b3" + }, + { + "path": "research/p104-shared-carrier-lifts/RESULT.json", + "commit": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "git_blob": "662ccefa5c7171e81691d4d4cb2573a685f4b74d", + "sha256": "2b4a20110448e11b548e7a3bc995be906c6d214559a1f336e462658b942e986e" + }, + { + "path": "research/p104-shared-carrier-lifts/NOTICE", + "commit": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "git_blob": "638a187d1417bda8976e945a2aeaed116a090e37", + "sha256": "91f24d68004688bc0a56303a48edcb5ddabd66bfc2326950603bf98dec245bbe" + }, + { + "path": "research/p104-shared-carrier-lifts/PROOF.md", + "commit": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "git_blob": "bd20fcaf2078691d914d6afbc5cb06a75f47770d", + "sha256": "769e0f87e6b85c557b48135d2d898bb485cf77ce9925540e0a3740e6283f41af" + }, + { + "path": "research/p104-shared-carrier-lifts/inputs/pr6372-WORD.json.gz", + "commit": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "git_blob": "0af79e58172f85c302c35b193205c0b185b09393", + "sha256": "e3b6f1c25d672b8c85433be97ebad77ae6a6972352ce2ff63507d30835fcb491" + } + ], + "archive_sha256": "d9e6d7525c1b2d196c5c2db8f65b3b04c503faa3911e6c0ce83a83fc5d394b8a" +} diff --git a/research/mixed-root-third-anchor-composition/NOTICE b/research/mixed-root-third-anchor-composition/NOTICE new file mode 100644 index 0000000000..37f56b542a --- /dev/null +++ b/research/mixed-root-third-anchor-composition/NOTICE @@ -0,0 +1,320 @@ +New contribution: written by the Claude Sonnet 5.5 main session (Claude Code), with +orchestrated subagent assistance, for the user Erwan L. Apache-2.0. AI-assistance disclosure: +the third-anchor construction, the adapted verifier and this text were produced by AI assistants +under the user's direction; all new checks are author checks. + +Lineage (source, not authors of the new code): PR6398 (mixed-root contact composition, aliromman), +PR6375 (DreamingOfClouds), PR6372 and PR6353 (Ali Romman). The PR6398 notice follows byte for byte. + +The final source additionally consumes PR6375 at +247b5c319b9f58fe9ee61dbf80697f8a9a429831. The shared-carrier input lifts +are by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. +Their exact notice is retained in lift-source.tar. Apache-2.0. + +Mixed root and PR6372 source composition + +New composition and complete checks: Ali Romman with substantial OpenAI +Codex assistance. No subagents. Apache-2.0. The mixed root, prior adapter +and source mechanisms retain their separate credit. + +Exact PR6372 source notice follows. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +No subagents. Apache-2.0. + +PR6353 supplies the word, joint basis construction and native transpose. +Exact head: db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3. +The source files in inputs are unchanged. The complete predecessor notice follows. + +Joint native output contraction +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author checks. + +PR6349 supplies the exact native input-lift source. PR6348 supplies the fixed +binary query-tree caller and price engine. PR6350, by Ali Romman with OpenAI +Codex assistance, supplies the released composition control and its prior +conditional claim. Its source and caller are recounted here from main; no +pending PR6350 code is imported. Cinna Davis supplies the productive caller, +thin-query interface and exact Laurent factorization. + +The new result is the explicit nine-helper joint output contraction, its +literal forward word and complete conditional price. The input/departure basis +identity is elementary linear algebra. No new general linear algebra theorem, +native duality theorem or caller construction is claimed. + +The exact PR6349 and PR6348 notices follow. Their nested source archive retains +all earlier native, helper, recursion, compiler, BIT and analytic attribution. + +Native helper input lifting +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author checks. + +The direct source is PR6314 at 36533d4d1b4e2dd8672427461b12de3001b85810, +by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. +It compresses the scalar word of PR6167 without a kappa change. +The four native input lifts and their complete conditional price are new here. +The basis identity is elementary linear algebra; no new general theorem +for that identity is claimed. + +The PR6167 source notice follows unchanged. Its nested source archive also +retains the earlier notices. + +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. + +Binary query-tree caller + +New construction, proof and code: Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. No subagents. + +Cinna Davis supplies the productive path caller, query thinning and exact Laurent factorization. Ali Romman supplies the all-forward P104 binding in PR5544 and the retained-operand word in PR6167. The native word and interval/compiler lineage remain predecessor work. The new contribution is the four-field query extension, its tree composition, complete invoice and conditional price. + +The authenticated PR6167 notice follows. + +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. diff --git a/research/mixed-root-third-anchor-composition/PRICING-EDITS.json b/research/mixed-root-third-anchor-composition/PRICING-EDITS.json new file mode 100644 index 0000000000..179a655fa6 --- /dev/null +++ b/research/mixed-root-third-anchor-composition/PRICING-EDITS.json @@ -0,0 +1,66 @@ +[ + [ + "KAPPA = Q('0.00328551')", + "KAPPA = Q('0.00328637739144124222748802')" + ], + [ + "TESTED = Q('0.003285515')", + "TESTED = Q('0.003286377391441242227488025')" + ], + [ + "PREVIOUS = Q('0.00328467')", + "PREVIOUS = Q('0.00328621476572836015146308')" + ], + [ + "'kappa_decimal': '0.00328551'", + "'kappa_decimal': '0.00328637739144124222748802'" + ], + [ + "(13652, 67096)", + "(13652, 67150)" + ], + [ + "low, high, grid = 0, 10**12, 10**14", + "low, high, grid = 0, 10**24, 10**26" + ], + [ + "'The composed source improves the fixed root claim'", + "'The claim and tested saving are below the raw crossing'" + ], + [ + "1-TESTED, Q(1, 7), 1024, 12, 13", + "1-TESTED, Q(1, 7), 1920, 12, 13" + ], + [ + "reserve, decay = Q(1, 10**12), Q(31, 32)", + "reserve, decay = Q(1, 10**29), Q(31, 32)" + ], + [ + " need(decay**128 < Q(1, 16), 'Both tail decay blocks')\n normalized = 1/(1+power*reserve)+Q(4, 2**32)", + " need(power % 128 == 0 and decay**128 < Q(1, 16), 'The previous block estimate applies')\n coarse_tail = 4*Q(1, 16)**(power//128)\n need(1/(1+power*reserve)+coarse_tail > 1, 'The coarse tail bound cannot fund this claim')\n exact_tail = 4*decay**power\n normalized = 1/(1+power*reserve)+exact_tail" + ], + [ + "theta, logarithm_power = Q(63, 64), 1100", + "theta, logarithm_power = Q(63, 64), 2100" + ], + [ + "'gain': KAPPA-PREVIOUS,", + "'refinement_kind': 'Same complete invoice; finer strictification and compiler parameters.',\n 'gain': KAPPA-PREVIOUS," + ], + [ + "'tail_offset': offset, 'reserve': reserve, 'tail_decay': decay, 'tail_block': 128,", + "'tail_offset': offset, 'reserve': reserve, 'tail_decay': decay,\n 'exact_tail_upper': exact_tail, 'coarse_tail_upper': coarse_tail," + ], + [ + "'old_BIT': 'An outer inequality fails at BIT saving0.0027.'", + "'old_BIT': 'An outer inequality fails at BIT saving0.0027.',\n 'coarse_tail': 'The block tail bound cannot fund this near-limit claim.'" + ], + [ + " need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure')", + " need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure')\n endpoints = {}\n for label, k in [('lower', lower), ('upper', upper)]:\n tl, th = other.moment(T, k)\n pl, ph = other.moment(P, k)\n second = (tl-ph, th-pl)\n first = margin(k)\n need(max(first[0], second[0]) <= min(first[1], second[1]),\n 'Both rational engines agree at the raw endpoint')\n need(second[0] > 0 if label == 'lower' else second[1] < 0,\n 'The second engine certifies both raw endpoint signs')\n endpoints[label] = {'first': E.display(first), 'second': E.display(second)}" + ], + [ + "'raw_root_interval': [lower, upper], 'raw_headroom': [lower-KAPPA, upper-KAPPA],", + "'raw_root_interval': [lower, upper], 'raw_headroom': [lower-KAPPA, upper-KAPPA],\n 'raw_endpoint_margins': endpoints," + ] +] \ No newline at end of file diff --git a/research/mixed-root-third-anchor-composition/README.md b/research/mixed-root-third-anchor-composition/README.md new file mode 100644 index 0000000000..b180b8359c --- /dev/null +++ b/research/mixed-root-third-anchor-composition/README.md @@ -0,0 +1,125 @@ +# Conditional kappa 0.00328637739144124222748802: the PR6398 mixed root with a third group-1091 anchor + +This package replaces the PR6375 native word inside the PR6398 mixed-root +composition by the same word with one more helper anchor. It claims +**kappa 0.00328637739144124222748802**, conditional on the five inherited +framework assumptions listed below. That is **+1.626e-7** (**+0.00495 percent**) +over PR6398's 0.00328621476572836015146308, and about 4.2897 percent over PR6375's +0.00315120; almost all of the latter is inherited from the mixed root and the +PR6375 lifts. The exact raw crossing of this word with the unchanged caller lies in +(0.00328637739144124222748803, 0.00328637739144124222748804), as printed in +`RESULT.json` (`price.raw_root_interval`). All checks are author checks. + +This claim does not exceed the open draft PR6417 (0.003286849), which composes the +PR6399 native merge with the PR6398 root; this package is built on PR6398 alone and +is independent of PR6399. The third-anchor word edit touches registers and frames +disjoint from the PR6399 merge (group 1091 and frames 245/246, against role 400 and +frames 1090/477), so it can be stacked on it; that stack is a separate recompute. + +## What changes against PR6398 + +Only the native word changes. The mixed root, the six-field caller, the compiler +and the outer ledger are byte-for-byte the PR6398 ones. + +- `final[234]` goes from frame 127 to frame 246. Helper 234 is the third anchor of + group 1091, after anchors 224 and 227 (frame 245). +- Per native call the paid profile changes by +1 at rank 4 and -1 at rank 5, and the + productive profile by +1 at rank 8 and -1 at rank 9; the paid call count is unchanged. +- The word has 44 owned lifetimes (PR6375: 43) and real scalar allowance 131,052 + (PR6375: 129,670), that is 1,382 more units. Both are charged by the unchanged checkers. +- One new native chart (1091, 246) is checked; the native word has 2,942 distinct maps (PR6375: 2,941). + The helper and main-field normalizers (1,124 and 208) are unchanged. +- Paid mass 5,925 and helper mass 4,205 (PR6375: 5,926 and 4,206). + +## Construction + +On the transposed PR6353 word, group 1091 has joint capacity exactly 3 across the +entrance frames 245 and 246: the response-free input directions U_245 and U_246 each +have dimension 2, the helper-only departure functionals have dimension 7, and the joint +pairing rank is 3. A dyadic solution places anchors 224 and 227 at frame 245 and +anchor 234 at frame 246. It is stored in `SPEC.json` and rebuilt by `construct3.py`, +which generalizes the PR6372 contact-block constructor and reproduces the PR6372 word +exactly when given no spec. The PR6375 lift rounds are then re-applied unchanged. The +capacity computation is exploratory; acceptance rests on the exact replay of the final word. + +## Tariff scope + +Per call the third anchor changes the signed local invoice by (H5-H4)-(H9-H8) with +H(r) = r^t. This is positive for every strictly concave increasing H, in particular for +every t in (0,1), because increments of a strictly concave function decrease. It adds no +paid call. The word as a whole keeps the scope of PR6375: that word's six input lifts +add paid rank-1 calls and are positive only for power exponents of about 0.873 to 1, +and zero at linear cost. The claim is made at the stated exponent only and is not a claim +for every concave tariff. + +## Reproduce + +Python 3.12 and its standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/mixed-root-third-anchor-composition +python3.12 -I -B research/mixed-root-third-anchor-composition/verify.py +python3.12 -I -O -B research/mixed-root-third-anchor-composition/verify.py +``` + +`--build-only` runs the cheap rebuild and local-delta checks. `--write-result` +generates `RESULT.json`; the plain command compares against it. Direct runs on one Windows laptop +(CPython 3.12.10): `--write-result` 58m43s under heavy load, the plain comparison +(`-I -B`) 16m05s and the optimized run (`-I -O -B`) 12m50s, all exit 0, ending with +`PASS_MIXED_ROOT_THIRD_ANCHOR_KAPPA_00328637739144124222748802`. On slow hardware the +runs can exceed the 590 s per-command cap declared in `VERIFY.json`; that is a +timeout, not a failed check. The retained PR6372 and PR6375 sources +are in `contact-source.tar` and `lift-source.tar`, bound by `CONTACT-INPUTS.json` and +`LIFT-INPUTS.json`. Six live files of the preceding composition are pinned and declared; +see the source-pin note below. Exact packing-cap statement: PR6398 reports the all-binary-size +fixed-root ceiling (`fixed_root_ceiling` in RESULT.json) and no separate packing-cap +fraction; this package does the same, and its claim lies less than 2e-26 below the raw +optimum (`raw_optimality.certified_kappa_distance_upper`). + +## Scope and limits + +- Five inherited framework assumptions remain: native_all_columns, owned_erasure, + compiler, precision_tape and analytic_recovery. This is a conditional finite certificate. + It is not a proof of the multiplication theorem. +- It is not a runtime speedup, no materialized uniform word or rounded multiplier is + claimed, and the selected frontier is unchanged. +- The all-width native claims are inherited: native maps are checked at tensor width one and + extended by frame induction; the central query is made an involution through the + inherited normalization (Q^2 = X, a translation with absolute phase +1). +- The package consumes PR6375's native word construction with one more anchor, so it + inherits the PR6375 tariff scope above. +- Author replay only: not independently reviewed, and no formal-kernel acceptance. +- `RESULT.json` price field `refinement_kind` is a label inherited from PR6398 and does + not describe this word; the complete invoice and word are the ones listed above. +- The shadow rows for owned labels 779 to 781 are zero in the transposed preparation but + not at the forward CLEAR; this is the inherited `owned_erasure` obligation, as in PR6372. +- Source-pin note: the six live inputs from `mixed-root-source-composition` are pinned + with `head:24f03629fc2a939ea0c6c015017bf1cdc07e06cd` (the PR6398 head). A real-repository + submission needs that commit to be reachable, so the branch must be based on or contain + PR6398 (or those files must be committed first). + +## Open next questions + +- Independently review the third anchor: recompute dim U_245, dim U_246, dim L and the + pairing rank 3 in exact rationals, then replay the word and the new chart (1091, 246). +- Check whether other first-departure groups and entrance frames admit more anchors by the + same exact pairing-rank computation. Only group 1091 with frames 245 and 246 was examined. +- A larger gain needs a changed caller or root, or a new source construction. + +## Credit + +New composition, third-anchor construction and adapted verifier: Claude Sonnet 5.5 via +Claude Code, orchestrating subagents, for the user Erwan L. Substantial AI assistance; +Apache-2.0. + +Predecessors, with the exact wording and lists retained in `NOTICE` and the source archives: +Ali Romman (aliromman) with OpenAI Codex: PR6398 mixed-root composition, PR6353 joint +output contraction, PR6372 contact blocks, PR6348 query tree, PR6349 source, PR6167 +retained operands, PR5544; DreamingOfClouds with Claude Opus 5.5: PR6375 shared-carrier +lifts, PR6314 and PR6143/PR6144; Cinna Davis (productive caller, query thinning, +controller lineage); Mason Hale (PR5811); Pierre-Loic Doulcet (hexapode, PR5565); +Chris R / Clear1nsight (PR3998); Jacob Alan Sussman (productive recursion); zxv and Cao +Yifan (intervals, compiler, native and pricing lineage); Gareth Davidson, David Arias, +flyingviper, thu-nmrc, ToikY, Douglas Colkitt, Maxime Fleury, Tekalign and Nick Petalas +(source-history and replay controls). No Matarener work is credited here because none appears in the NOTICE chain +of the consumed sources. diff --git a/research/mixed-root-third-anchor-composition/RESULT.json b/research/mixed-root-third-anchor-composition/RESULT.json new file mode 100644 index 0000000000..0d58e43767 --- /dev/null +++ b/research/mixed-root-third-anchor-composition/RESULT.json @@ -0,0 +1,575 @@ +{ + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "binary": { + "coefficients": 16, + "identity": "L S A B Idle S^-1 C R = D_A D_B (U(q) direct-sum q direct-sum q^-1)", + "missing_idle_rejected": true, + "variables": [ + "q", + "D_A", + "D_B" + ] + }, + "caller": { + "coefficients": 1156, + "event_sha256": "be648c29aa09c0f068a3b5b5120d1eb1f782e49f4523b4c6d62843750517bdea", + "events": 570, + "inputs": 34, + "native_stages": 18 + }, + "columns": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 638401, + "columns": 799 + }, + "contact_source_head": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "controls": { + "damaged_research/p104-contact-block-contraction/BASIS.json": "Exact source SHA256: research/p104-contact-block-contraction/BASIS.json", + "damaged_research/p104-contact-block-contraction/NOTICE": "Exact source SHA256: research/p104-contact-block-contraction/NOTICE", + "damaged_research/p104-contact-block-contraction/PROOF.md": "Exact source SHA256: research/p104-contact-block-contraction/PROOF.md", + "damaged_research/p104-contact-block-contraction/RESULT.json": "Exact source SHA256: research/p104-contact-block-contraction/RESULT.json", + "damaged_research/p104-contact-block-contraction/WORD.json.gz": "Exact source SHA256: research/p104-contact-block-contraction/WORD.json.gz", + "damaged_research/p104-contact-block-contraction/construct.py": "Exact source SHA256: research/p104-contact-block-contraction/construct.py", + "damaged_research/p104-contact-block-contraction/inputs/pr6353-WORD.json.gz": "Exact source SHA256: research/p104-contact-block-contraction/inputs/pr6353-WORD.json.gz", + "damaged_research/p104-contact-block-contraction/inputs/pr6353-construct.py": "Exact source SHA256: research/p104-contact-block-contraction/inputs/pr6353-construct.py", + "damaged_research/p104-shared-carrier-lifts/LIFTS.json": "Exact source SHA256: research/p104-shared-carrier-lifts/LIFTS.json", + "damaged_research/p104-shared-carrier-lifts/NOTICE": "Exact source SHA256: research/p104-shared-carrier-lifts/NOTICE", + "damaged_research/p104-shared-carrier-lifts/PROOF.md": "Exact source SHA256: research/p104-shared-carrier-lifts/PROOF.md", + "damaged_research/p104-shared-carrier-lifts/RESULT.json": "Exact source SHA256: research/p104-shared-carrier-lifts/RESULT.json", + "damaged_research/p104-shared-carrier-lifts/WORD.json.gz": "Exact source SHA256: research/p104-shared-carrier-lifts/WORD.json.gz", + "damaged_research/p104-shared-carrier-lifts/construct.py": "Exact source SHA256: research/p104-shared-carrier-lifts/construct.py", + "damaged_research/p104-shared-carrier-lifts/inputs/pr6372-WORD.json.gz": "Exact source SHA256: research/p104-shared-carrier-lifts/inputs/pr6372-WORD.json.gz", + "first_lift_delivery": "All public and owned rows", + "last_lift_restore": "All public and owned rows", + "lift_response_sign": "All public and owned rows", + "missing_departure_basis": "All public and owned rows", + "missing_departure_inverse": "All public and owned rows", + "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_input_basis": "All public and owned rows", + "missing_input_correction": "All public and owned rows", + "missing_lambda": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_local": "Every native stage exactly once", + "missing_native_move": "Scalar destination and coefficient", + "missing_output_basis": "All public and owned rows", + "missing_output_correction": "All public and owned rows", + "missing_productive_debit": "All source helper targets have native maps", + "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_response": "All public and owned rows", + "missing_target_224": "All public and owned exits", + "missing_target_227": "All public and owned exits", + "missing_temporary_clear": "Scalar destination and coefficient", + "old_entrance_472": "Common scalar chart", + "old_entrance_520": "Common scalar chart", + "old_entrance_544": "Common scalar chart", + "old_entrance_624": "Common scalar chart", + "old_entrance_655": "Common scalar chart", + "old_entrance_671": "Common scalar chart", + "third_anchor_dyadic_restore_dropped": "All public and owned rows", + "third_anchor_entrance_reverted": "All public and owned exits", + "third_anchor_input_correction_dropped": "All public and owned rows", + "third_anchor_move_dropped": "Scalar destination and coefficient", + "third_anchor_response_doubled": "All public and owned rows", + "third_anchor_response_dropped": "All public and owned rows", + "third_anchor_wrong_entrance_245": "All public and owned exits", + "unpaid_native_move": "All independent fields and paid calls" + }, + "fixed_root_ceiling": { + "admitted_saving_cap": "17/5000", + "binary_split_checks": 4851, + "ceiling": "82159434786031055687201/25000000000000000000000000", + "finite_margin_upper": "-2494025952356536985394916348772758561/326409290240107399719461050006798653637322483112129794670592", + "finite_pair_checks": 4656, + "first_tail_total": 100, + "native_derivative_lower": "86078114961439134869143593729155304567640903859692066251706014335203407540415681249641342926192988363554053310211285183/2048904322212512919038510085207467917864146442064203226733311257020777532117854951793541845254015613321944655495954432", + "scope": "All positive integer child sizes and all binary tree shapes for this fixed root and PR6375 source with the third group-1091 anchor.", + "tail_derivative_upper": "-4851732637665930638094717034164841696171956007409382891521567776745600164251896486010731/81908586276884950701008288065026354958563764764140001701553766400000000000000000000000000", + "tail_margin_upper": "-302720141965947028477201115749301081231916708422400074612765/163204645120053699859730525003399326818661241556064897335296" + }, + "gain_over_pr6375": "6758869572062111374401/50000000000000000000000000", + "gain_over_pr6398": "8131285644103801247/50000000000000000000000000", + "immediate_source_margin_upper": "-188596675276364645816423803664749126022597173064223637795/1569275433846670190958947355801916604025588861116008628224", + "lift_paid_delta": { + "1": 6, + "3": -3, + "4": 3, + "5": -3 + }, + "lift_target_delta": { + "8": 6, + "9": -6 + }, + "local": { + "endpoint_coefficients": 638401, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 15, + "6": 3, + "7": 9, + "8": 39, + "9": 363 + }, + "owned_fields": 29, + "owned_lifetimes": 44, + "paid": { + "1": 2237, + "2": 453, + "3": 491, + "4": 110, + "5": 150, + "6": 8, + "7": 9, + "8": 1 + }, + "paid_rank_mass": 5925, + "peak_owned_fields": 13, + "public_inputs": 770, + "real_scalar_allowance": 131052 + }, + "native": { + "distinct_maps": 2942, + "helper_normalizers": 1124, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 15, + "6": 3, + "7": 9, + "8": 39, + "9": 363 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "74f3b409e76198e9b7491268c91c6aa433c7ba7d7b8c1f0c3d394a9154c527c6", + "wrong_phase_rejected": true + }, + "native_events": 17871, + "paid_delta": { + "1": 6, + "3": -3, + "4": 6, + "5": -6 + }, + "physical": { + "central_square_columns": 53248, + "central_translations": 16, + "full_calls": 18, + "main_targets": { + "1": 104, + "145": 104, + "17": 1872, + "25": 416, + "33": 416, + "57": 416, + "73": 208 + }, + "new_paid_jobs": 0, + "ordinary_normalizations": 20, + "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 + } + }, + "pr6375_local": { + "endpoint_coefficients": 638401, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 15, + "6": 3, + "7": 9, + "8": 38, + "9": 364 + }, + "owned_fields": 29, + "owned_lifetimes": 43, + "paid": { + "1": 2237, + "2": 453, + "3": 491, + "4": 109, + "5": 151, + "6": 8, + "7": 9, + "8": 1 + }, + "paid_rank_mass": 5926, + "peak_owned_fields": 13, + "public_inputs": 770, + "real_scalar_allowance": 129670 + }, + "pr6375_word_margin_upper": "-58631176046445983369977160775058458658399805731953662761/1569275433846670190958947355801916604025588861116008628224", + "price": { + "compiler": { + "H": 317427600000000000000000000000000, + "N": "2^317427600000000000000000000000000", + "eta": { + "lower": "0.000000000000022944267363882269", + "upper": "0.000000000000022944267363882270" + }, + "gap": "1/1400000000000000000000000000", + "integer_test_exponent": 226734, + "logarithm_power": 2100, + "theta": "63/64", + "uniform_saving": "2300464174008869559241617/700000000000000000000000000", + "word_materialized": false + }, + "derivative_upper": "-177675181026104758811663368061712570883996071259932110338179095/784637716923335095479473677900958302012794430558004314112", + "full_forward_calls": 18, + "gain": "8131285644103801247/50000000000000000000000000", + "kappa": "164318869572062111374401/50000000000000000000000000", + "kappa_decimal": "0.00328637739144124222748802", + "margin_at_previous": { + "lower": "0.037360109215061923558157562470", + "upper": "0.037360109215061923558157562471" + }, + "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": 5383000, + "local_scalar": 131052, + "paid_rank_mass": 184962, + "peak_owned_fields": 13, + "raw_budget": 1000000000, + "raw_scalar_upper": 248152864, + "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": "348599999999999999999999999253/350000000000000000000000000000", + "fixed_halo_explicit_metadata_branch": "26950000000000000000000000001/350000000000000000000000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799999999999999999999997009/1400000000000000000000000000000", + "new_semantic_group_guard": "3/1400000000000000000000000000" + }, + "margins": { + "boundary_algebraic_matrix": "6441299687224834765876524795399071651982260881516769/1960000000000000000000000000000000000000000000000000000", + "fused_gaussian": "6441299687224834765876524786197214955946782644550307/1960000000000000000000000000000000000000000000000000000", + "global_coordinate_router": "143779010875554347452601/43750000000000000000000000", + "group_bit_router": "201290615225776086433641443318662967373336957642197/61250000000000000000000000000000000000000000000000000", + "group_scans": "699999999999999999999999999/700000000000000000000000000", + "main_transform": "6441299687224834765876523395399071651982260881516769/1960000000000000000000000000000000000000000000000000000", + "microbox_face_corrections": "26950000000000000000000000001/350000000000000000000000000", + "polynomial_products": "1399999999999999999999999999/1400000000000000000000000000", + "sparse_union_movement": "802691299687224834765876524795399071651982260881516769/1960000000000000000000000000000000000000000000000000000" + }, + "parameters": { + "a": "143779010875554347452601/43750000000000000000000000", + "b": "4600928348017739118483233/1400000000000000000000000000", + "beta": "1399999999999999999999999997/1400000000000000000000000000", + "bit_saving": "17/5000", + "cap_xi": "1782691299687224834765876523395399071651982260881516769/1960000000000000000000000000000000000000000000000000000", + "complex_uniform_saving": "2300464174008869559241617/700000000000000000000000000", + "d": "1/1400000000000000000000000000", + "epsilon": "1399999999999999999999999999/1400000000000000000000000000", + "kappa": "164318869572062111374401/50000000000000000000000000", + "lambda_": "398685449043423503109004791/400000000000000000000000000", + "lambda_prime": "1395399071651982260881516769/1400000000000000000000000000", + "layout": "1/1400000000000000000000000000", + "q": "4600928348017739118483231/1400000000000000000000000000", + "r0": "1/14000000000000000000000000000", + "stop": "1/1400000000000000000000000000", + "tested_saving": "131455095657649689099521/40000000000000000000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "4970989124445652547399/43750000000000000000000000", + "actual_logarithmic_gamma_guard": "1/1400000000000000000000000000", + "actual_logarithmic_group_guard": "177308700312775165234123478704600928348017739118483231/980000000000000000000000000000000000000000000000000000", + "alpha_logarithm_absorption": "1/14000000000000000000000000000", + "boundary_algebraic_matrix_above_kappa": "5595399071651982260881516769/1960000000000000000000000000000000000000000000000000000", + "cap_above_band": "802691299687224834765876523395399071651982260881516769/1960000000000000000000000000000000000000000000000000000", + "cap_below_cell": "177308700312775165234123475204600928348017739118483231/1960000000000000000000000000000000000000000000000000000", + "cap_below_phase_cell_power": "2137308700312775165234123476604600928348017739118483231/1960000000000000000000000000000000000000000000000000000", + "complex_above_effective": "1/1400000000000000000000000000", + "complex_below_one_over_32": "39149071651982260881516767/1400000000000000000000000000", + "complex_endpoint": "1/700000000000000000000000000", + "epsilon_below_one": "1/1400000000000000000000000000", + "epsilon_positive": "1399999999999999999999999999/1400000000000000000000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "5586197214955946782644550307/1960000000000000000000000000000000000000000000000000000", + "gaussian_above_main": "695399071651982260881516769/980000000000000000000000000000000000000000000000000000", + "global_coordinate_router_above_kappa": "1/350000000000000000000000000", + "global_gamma_power_slack": "9/14000000000000000000000000000", + "group_below_dimension": "1/700000000000000000000000000", + "group_bit_router_above_kappa": "218318662967373336957642197/61250000000000000000000000000000000000000000000000000", + "group_gauge_power_slack": "177308700312775165234123478634600928348017739118483231/980000000000000000000000000000000000000000000000000000", + "group_key_fits_record": "1/700000000000000000000000000", + "group_positive": "1399999999999999999999999997/1400000000000000000000000000", + "group_scans_above_kappa": "139539907165198226088151677/140000000000000000000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "77770348612103926237501/50000000000000000000000000", + "lambda_above_internal": "1/2800000000000000000000000000", + "lambda_above_sigma": "3/2800000000000000000000000000", + "lambda_above_tau": "1/2800000000000000000000000000", + "lambda_prime_above_lambda": "1/2800000000000000000000000000", + "lambda_prime_above_leaf": "2795399071651982260881516767/1960000000000000000000000000000000000000000000000000000", + "leaf_saving_above_effective": "1395399071651982260881516767/1960000000000000000000000000000000000000000000000000000", + "main_transform_above_kappa": "4195399071651982260881516769/1960000000000000000000000000000000000000000000000000000", + "membership_arithmetic_fits_record": "1/1400000000000000000000000000", + "microbox_face_corrections_above_kappa": "13474424883956497782610189597/175000000000000000000000000", + "microbox_halo_volume": "110600000000000000000000000003/1400000000000000000000000000", + "new_complex_uniform_saving_above_b": "1/1400000000000000000000000000", + "new_semantic_guard_with_C1_one": "1/1400000000000000000000000000", + "polynomial_products_above_kappa": "1395399071651982260881516771/1400000000000000000000000000", + "positive_layout_slack": "1/1400000000000000000000000000", + "q_below_effective": "1/1400000000000000000000000000", + "q_below_internal": "1/1400000000000000000000000000", + "q_below_leaf": "2795399071651982260881516767/1960000000000000000000000000000000000000000000000000000", + "q_positive": "4600928348017739118483231/1400000000000000000000000000", + "short_record_fallback": "1395399071651982260881516767/1400000000000000000000000000", + "source_axis_superpolynomial": "1/1400000000000000000000000000", + "sparse_union_movement_above_kappa": "796250000000000000000000005595399071651982260881516769/1960000000000000000000000000000000000000000000000000000", + "stop_below_one": "1399999999999999999999999999/1400000000000000000000000000", + "stop_positive": "1/1400000000000000000000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000000000000000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000000000000000000000", + "union_tag_work_per_visit_fits_record": "3/1400000000000000000000000000" + } + }, + "paid": { + "1": 42034, + "16": 1872, + "2": 8154, + "24": 416, + "3": 8838, + "32": 416, + "4": 1980, + "5": 2700, + "56": 416, + "6": 144, + "7": 162, + "8": 18 + }, + "paid_calls": 67150, + "previous_fixed_root": "82155369143209003786577/25000000000000000000000000", + "productive_fields": 13652, + "rank_mass_surplus": 760, + "raw_endpoint_margins": { + "lower": { + "first": { + "lower": "0.000000000000000000001502663140", + "upper": "0.000000000000000000001502663141" + }, + "second": { + "lower": "0.000000000000000000001502663140", + "upper": "0.000000000000000000001502663141" + } + }, + "upper": { + "first": { + "lower": "-0.000000000000000000000794642515", + "upper": "-0.000000000000000000000794642514" + }, + "second": { + "lower": "-0.000000000000000000000794642515", + "upper": "-0.000000000000000000000794642514" + } + } + }, + "raw_headroom": [ + "1/100000000000000000000000000", + "1/50000000000000000000000000" + ], + "raw_root_interval": [ + "328637739144124222748803/100000000000000000000000000", + "82159434786031055687201/25000000000000000000000000" + ], + "refinement_kind": "Same complete invoice; finer strictification and compiler parameters.", + "relative_gain_percent": "406564282205190062350/82155369143209003786577", + "strictification": { + "alpha": { + "lower": "0.999999999999999999999999985580", + "upper": "0.999999999999999999999999985581" + }, + "coarse_tail_upper": "1/288230376151711744", + "cutoff": 12, + "delta": { + "lower": "0.957341212615259162381069346448", + "upper": "0.957341212615259162381069346449" + }, + "exact_tail_upper": "25968816751883113995464804882194607929411683780884226645678925307002110843550133104420123760101479474839221201004686329940160027670126004133743828536680673994452725629745611397250341115761363323607003552687034005960488068717359911143395851784415362067355137094922219194655890106807315973377901994681558011665956719293922523423896736235903448997789236780141543787761778864696595800906890151999691226382701024017325569269316595526470733042482962997961321816289689038860231064735268262348181833735526073481800371738520564423855188853455070167523225315015758774805697502433771984614850668873883495604089682521242370834384375582830712704865727861176177048771394427407255002047824069363883041195805737568221434593424664912374095681332409910102117819689183603716909776665801384439952751837667700413070379263323130466094707734337887831258005980440847552037834301818581649745499092009029235117704964733313829410497453470070887466638307413753043426496924817422338541543232280481901189410625113352540990925659205592694157405025696376596135904922863017205099824220302784597597394276398809139342815771451800330237414693097687353116020292427829621137741888194987614319546272900374357630911060621372780363425799229823027419399322430473329066822665185057155378959634917707139348139444417502434894646589809020275954413976196338353104990927739225086991331116260532892993604070852131850799788364871935788080589906984695519250577337599768456831251607249423700889021932369256023863626543373232166438214597277750913930476188423662975734340573982417743812475341013829410134208659166050139798547596876083645842576454904158460099622845601362359202659966547393643799328843973215865146723977900950651432448361170601246192090126412244869008028749978164391847944132606805504798364996996014218459024410664453957811779516913670216928724470380796391020353614030246272618410655142564538377734059025000305119155917226445867387899027040451866939956717377831530119449900953585057952699220008085352148706159738644321313531284032818479141559396247029143750425762501948430437369399481810562584909868262778814839240692102964314788286773148559517247633145270422345099190454145942630831266195509922086728349392801157236390281356642879102356486891062424937470616665957496696759574300833108099958404347149016512657584919622710050001356487455986180867964952023672761039188124022692190974214751766725701356295495524587296011840901864611875504808599874948117351460747134887391055383954183357815228423956967508253485665094444536753140118928942192591489028112227793683148117180821470944630106089051895287977293005179296095836333159834273766684727267011939930469961979884670796085309878886992937168024435902854601180811049624073160626754017381247943964404431354002824473361814782176441811959489344592309505051971888333364522225539320640095711622097910757473509357949732179456944382304691192060425703256673043353601/1931516324011626346020150553929126181823590488535040186824856567180029479223493376445786096950954795100702784533083281033646760271068018983122291972202644881704691011563710483989867650744695251376055025107666230739164093587389628866535770117611912392089755082590080472028477987071289165684289011377905352698232800507758208042820675070709030399021754206793830358905406733535942588887996076001927509337965834979072536427646331464401971792582375342958569384054354332096896759837269698218889565287567707539585095032991822857620010464317015726455734074643321122388044097708028635229432698100703335425310388288440000351711930613276786493722293418289870150700918405798037757934100708219508469592822795997483826085672921016197325327430119841909503482096760772795264133044082205866449934298354644012164798932775556083457809449912592220889802005953323685819720454613153020534455067493961231922206456679179219662713499049824991117775198073492812006682664088284693545727589314279309950009246830913459976142947529615742696134568887882410861948007763929800878314246201090904986140186077798864508547948608132255423035988434446214058699770626557465193128157512845357439793247851632224246499990611115646221003615087011758590423628181610786764420573006921761893949737802418426782447136548014140198447242737897751623530788833864390071832506056728849302290191408954510946220861486311039370054837095614883730158737099345289640173098512240742485291913040000974074836991713791813260339229632451698438087840996110693416312325768841145996367942811788448367825625035192908389092377054549306070546491079416016630873092882144703817485287986047453762937574793229088607594726623087172119290857442922186749727030568744100000419699941602816789656590538128654775884335322288115044042902368007647928447785494309683729219830178145535848830929931533192822883913681010006628877851664234722515418098809600795075237161618710226944692109669822041946629850162941173319519204709693533513108874099949758590208958136931346480022816743599142611017726137114510998217900038246478615246956350952278485410366122587953267937544436255099465307497011848059680873269896755574862120101016159541436240691657472394148008527677335225016052476207952397501417607437147877605303564057067564064530504494183216739444916912001687735183605267399161590281721705618193211199161475332334316832897783160549981482614788840809957569982115145402182575160480094711317055554905021931999461941405791251356057108718863869053217661463840775172788114991998596171377364481496742568202736663003363999728620841731079859176245940071187874843669264882594126717901436208421673886795099603467547525863026278936933835810347290598467230778790873267966902348777280946055188109006665306325326165168038148974262863542508287344559517219458554951908638902157539612839480289421087336446182774503962079866786903470546386259662184092799534574936219344193317288975481261643484673081344", + "floor": 13, + "gamma": { + "lower": "0.924049531043192148730641310187", + "upper": "0.924049531043192148730641310188" + }, + "normalized_paid_upper": "301799425626816616565648528109053583391672575624975869940741583241797183286245900040809945102717848691873044685714521183696004886382003883466377478245092103887149130513292792459855142440109413906745988535460631248884298173458126368768624796293092869362168408912319796533556160583862533407322260438866742613153280686291990643354490224551943523228527424469436028309041589787129548101074311423426114310610596031813033352108087503397245815968572344741673665372616954254810895105816503554164534346982552051911285959875500423372269822385628835948047846968612629126601819504076701291377728006835633485157565813415491483591792647779464628140235411130837708133364924768325881139107648021966692253445739473110504978176401317390484720917763472170087399053284025621752849515588491115354784312114796037285675219539609263405190913495242614266526211760606148610764084636759992186514237315506545921016082951398642312212707669421504838229936571461184333857636630398207131411209275958949082326107455705488444588407064614885594862057760009464516285110015266189625072421731933680573645919460633395409485478933665135896635962123550978028198469956423067761387237891161248504060152572651764417043315553904788275940972822138283460482007536285039454333744430731010515968501887788002878120512905009639562367117756114778018290345960701258650801580441748371168100479507364802657842858038646646132252116044115722627476253140838312498329226086525341379050630911210225440926822289249592206382470693285625307402300632605045915432124015120531477460701485675348813313885703492348411977021656461528309955456511882087030695278147846402385996123408872905124876546080259052247878909372748370715537990123188801158439727097722818570075649321843091996462220691948638857990271688415748735990268957977072732719576542723594407150217919974318537795754697935266273409814901132885468100151160477578371433469178015962157592357715183237537996405238471421253995257942319696663713231624595453865406519280636797623587967147499366372116604250177877350232354938419461919717913462777631887824492739295756328953000703580767618425429227902317519621684672164305220954227395374311394390766662610551662776418938907121788829304328236007254754887896625047228575905877802078036326720030589592784430857735637288740857800323458560625645576814021888519238251618574786255511355740282166374757739907368509692374989841088063538310820616230807172142631730012542741650950755936921860148020466043114790367272167323847793817214080973216016280043001603197094102740357442482718512416184262618729170472760291383183945838246607207075883495104473031191009853310272431836128093864425961960285207680233006875526939005517015421666422110223408105807078082966354186873810127771992121166952364000079535481712545174594176912418033247014664164087923589259194684161501915740939750272298890913108985116073608319238085545414021966707796667664104685841899011057001636482790107033732431277109770019130060803/301799425626816616565648529845974937944815051894051690978762384092651071733791400544223779188675124404964939420652553514371691594462731565362701221596944075970414919923705679731351465542931667718640049642675800787080143751194704833394906298369142073432910831262010426590186861749154179908411574113231672572966372132204254140406788574496687523121773223273561205706060999180253649895240463591521373941884928379468311822602267305210313029808605430276270859464408242137266147600281542509764490866872733814869265755573668184206249253804818806234177022023050318324179069634081698184562226242367189284290653858366844357064995434255662754964109401743584050877377982072823654546813687762053415767991835676908972484411802687249220074862434482317122967669594853039619546516648290956915120619910312259147367432595983533104214763043239332840699813803635175647107983702711177318479661755092806327303820459486955554182679993154524899690033687123749025519139617120077586998371850404134444543025454512996064110265401530200289011406317160469286026604301517738050883833554764477195873806709598811182733331928441223143245966718526066771068605429507569239764916787481398979640090556202007577051695852366563276928487596845559113100630566387530692975990303602409840762006824889598205522650767476422813262662025137933335219106350633039162417083941956249205076012623146660505533557514106674128434601134852410041770420781937212793121697833013827311362730333019447735915507411155709941930926854581553022326664936659984743653896215644952050264571313278922363996191900852720371161029018250204179101614398435883762221838974474583209730126140439193296893107513897909053079037323670095023326462298240771548906364884238837953832138365056531829616142272841702133540377763077289590017667822654200955684311615614595186713542250678596459308883989461551913012219059150603330361742791188416436064097825633679223209974049177769388910527361621178910291594922035887340641001575779165100246781536674763908800750248222145187352840886814240443765559148992592574268974714029190694975869924489993628084805552395236750972076774395957659218156211913892633901746817290549607750444826394738039679332657840364634104956758305703881175381851518145141602176210211784499685874388169629196526524143126819786740960461091777191172088541365869734486582222053658491447353751365842353859719912216320360603661511255069905351959649939313457549798697724744988726137001635158315200062295821547739449719235708303756939013671896447277339750127152765043300038718598211002277466117726369069447824711128691217006380427321985630637562900166643152513235723938573681192594114466746112926181119516469194722248009341745089341619987581379161700287398142484193742945932998500445175051473070287797224491404495415401701871488328989838760586862140667222881833650947961602792334897034684943242447463005821196364958455864860637688972943051516758104801022671940452512748911866926443784930454019244032", + "power": 1920, + "reserve": "1/100000000000000000000000000000", + "tail_decay": "31/32", + "tail_offset": "1/7", + "tested": "131455095657649689099521/40000000000000000000000000" + }, + "targets": { + "1": 356, + "145": 104, + "17": 1872, + "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 + }, + "prior_source_margin_upper": "-2389523651322317285689879066987476043936647593088491939/12259964326927110866866776217202473468949912977468817408", + "raw_optimality": { + "certified_kappa_distance_upper": "1/50000000000000000000000000", + "lower_endpoint_tail_derivative_upper": "-431265123348082723386185647101725618488076869157578327828199781549490307256569442284083/7280763224611995617867403383557898218539001312368000151249223680000000000000000000000000", + "lower_endpoint_tail_margin_upper": "-37840017745743378559647246891595424842864755315006600703261/20400580640006712482466315625424915852332655194508112166912", + "minimum_alternative_tree_cost_gap": "1117980010947569929798083684892593667792116149996251415/784637716923335095479473677900958302012794430558004314112", + "minimum_size_profile_margin_gap": "7236791733867099016295470196734942686516196850196193525/163204645120053699859730525003399326818661241556064897335296", + "other_nine_leaf_split_margin_upper": "-1809197933466774754385620793228302794803413756154535563/40801161280013424964932631250849831704665310389016224333824", + "other_pair_total_checks": 4655, + "other_pair_total_margin_upper": "-10298000780740024935081513470129431992426374485651569873/10200290320003356241233157812712457926166327597254056083456", + "other_size_profile_margin_upper_on_bracket": "-1809197933466774754385620793228302794803413756154535563/40801161280013424964932631250849831704665310389016224333824", + "raw_limit_interval": [ + "328637739144124222748803/100000000000000000000000000", + "82159434786031055687201/25000000000000000000000000" + ], + "scope": "Fixed PR6375 source; six fields with S on every output, constant scalar bases independent of S and all stage variables, seven square-zero queries, four distinct independent forward full stages and at most two extra whole idles; every positive binary child size and binary tree shape; admitted saving range through .0034.", + "selected_per_port_margin_lower_on_bracket": "-1247012976178268492697458174421948727/163204645120053699859730525003399326818661241556064897335296", + "selected_seven_leaf_histogram": { + "2": 3, + "3": 1, + "4": 1, + "7": 1 + }, + "seven_leaf_histograms": 11, + "signed_invoice": { + "1": -41678, + "145": 104, + "16": -1872, + "17": 1872, + "2": -8010, + "24": -416, + "25": 416, + "3": -8766, + "32": -416, + "33": 416, + "4": -54, + "5": -2430, + "56": -416, + "57": 416, + "6": -90, + "73": 208, + "8": 684, + "9": 6534 + }, + "statement": "The exact family raw-funding supremum is the unique zero of the displayed signed invoice. At that zero the raw paid and productive moments are equal, so the strict compiler does not certify equality.", + "uniform_tail_delta_upper": "874113806463913324084804365101636000458791475845640701605098915026489214639779868808919789731494411033474638650961559552/913064009932273056822684483903509461917231228641324957668258553958606702906914690454765126308782026149815134496056942995", + "uniform_tail_gamma_upper": "4773958281547551421705459884815200330691228309735867898721809603652629277077546273417456063198708775650342734823547731968/5166344574795748582482793236056609314489813589663106165569422783978826894811372686464314824508553774978720283837288452343", + "unique_selected_sizes_up_to_pair_exchange": [ + 7, + 2, + 2, + 7 + ] + }, + "relative_gain_over_pr6375_percent": "2252956524020703791467/525200000000000000000", + "root": { + "actual_tensor_gaussian_columns": 14, + "fields": 6, + "full_sites": 4, + "gaussian_characters": 4, + "normalization_growth_per_operation_upper": 2, + "ordinary_normalization_operations_per_pair": 4, + "owned_normalization_fields": 0, + "polynomial_coefficients": 1152, + "stage_ranks": [ + 2, + 3, + 3, + 2 + ], + "tensor_rule": "Normalize the complete field with its global Q squared translation; scalar coefficients stay outside tensor powers.", + "thin_sites": 3, + "wrong_tensor_normalization_rejected": true + }, + "root_source": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "selected_frontier_changed": false, + "source_head": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "status": "PASS_MIXED_ROOT_THIRD_ANCHOR_KAPPA_00328637739144124222748802", + "target_delta": { + "8": 9, + "9": -9 + }, + "third_paid_delta": { + "4": 1, + "5": -1 + }, + "third_target_delta": { + "8": 1, + "9": -1 + }, + "word3_local": { + "endpoint_coefficients": 638401, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 15, + "6": 3, + "7": 9, + "8": 33, + "9": 369 + }, + "owned_fields": 29, + "owned_lifetimes": 44, + "paid": { + "1": 2231, + "2": 453, + "3": 494, + "4": 107, + "5": 153, + "6": 8, + "7": 9, + "8": 1 + }, + "paid_rank_mass": 5931, + "peak_owned_fields": 13, + "public_inputs": 770, + "real_scalar_allowance": 131000 + } +} diff --git a/research/mixed-root-third-anchor-composition/SOURCES.json b/research/mixed-root-third-anchor-composition/SOURCES.json new file mode 100644 index 0000000000..6a9f9904d0 --- /dev/null +++ b/research/mixed-root-third-anchor-composition/SOURCES.json @@ -0,0 +1,83 @@ +{ + "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" + }, + { + "path": "research/mixed-root-source-composition/verify.py", + "usage": "input", + "git_blob": "e99f66fe38d35691fe72494ab876c8c73b5e4238", + "sha256": "3982ebe36924342345763cac8dc5fde50f23deccced56c528c6087d40e3034c4", + "pin": "head:24f03629fc2a939ea0c6c015017bf1cdc07e06cd:research/mixed-root-source-composition/verify.py" + }, + { + "path": "research/mixed-root-source-composition/INPUTS.json", + "usage": "input", + "git_blob": "0af459cf4ebe12bed27b6294bc1515dd37da62bf", + "sha256": "703ad732a3ec59b257477cc91e1bc340ce8c14942714828ce060eeeb878c6f7d", + "pin": "head:24f03629fc2a939ea0c6c015017bf1cdc07e06cd:research/mixed-root-source-composition/INPUTS.json" + }, + { + "path": "research/mixed-root-source-composition/sources.tar", + "usage": "input", + "git_blob": "9969dc140de46e7a9224947ea5b751e3486ff9eb", + "sha256": "6d05208f4fa1d98b4b63a8b2d9366576313a1f1466232a6a4f1a286de23c292b", + "pin": "head:24f03629fc2a939ea0c6c015017bf1cdc07e06cd:research/mixed-root-source-composition/sources.tar" + }, + { + "path": "research/mixed-root-source-composition/pricing.py", + "usage": "input", + "git_blob": "0ba26a7e590215a0b5646af603b4a1fe3ed6856d", + "sha256": "41fcff7b5375bd166048f10b3504d3080d37fadc51c723f2e98873fb9eb88069", + "pin": "head:24f03629fc2a939ea0c6c015017bf1cdc07e06cd:research/mixed-root-source-composition/pricing.py" + }, + { + "path": "research/mixed-root-source-composition/ceiling.py", + "usage": "input", + "git_blob": "66fa8646d1165b917f4ac92b54c5598e9ee51681", + "sha256": "c57bd8730a6e394e7f99e468ab913945bba03d68aa32f6d80bca8f68610cc920", + "pin": "head:24f03629fc2a939ea0c6c015017bf1cdc07e06cd:research/mixed-root-source-composition/ceiling.py" + }, + { + "path": "research/mixed-root-source-composition/RESULT.json", + "usage": "input", + "git_blob": "cc266a2e5c577ec5551230286fbeeff2938eef78", + "sha256": "9e41c15bd1f4e95b899d37672002e1fcf20cbf98a00b0ae007c389f3e1752c04", + "pin": "head:24f03629fc2a939ea0c6c015017bf1cdc07e06cd:research/mixed-root-source-composition/RESULT.json" + }, + { + "path": "research/mixed-projector-root-headroom/PROOF.md", + "usage": "provenance", + "pin": "head:e87c230f231441e2b53dec846ae9496c8c8d5121:research/mixed-projector-root-headroom/PROOF.md", + "git_blob": "f910b5fbf9a9d519fa7d7c7503de51df5a796368", + "sha256": "68be52ab098ff9dd6edfe938e5bf36d14d5f49aa1cac94a3d0784566c05363e9" + } + ], + "retained_predecessors": [ + { + "archive": "contact-source.tar", + "manifest": "CONTACT-INPUTS.json", + "archive_sha256": "4f41c4d246b354132d032546037d866a5199f7a3ea015915bf748a8d323cefb8", + "source_head": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "reason": "PR6372 is a separate pending source. Its exact constructor, word, witness, result and notices are retained. Runtime does not fetch it." + }, + { + "archive": "lift-source.tar", + "manifest": "LIFT-INPUTS.json", + "archive_sha256": "d9e6d7525c1b2d196c5c2db8f65b3b04c503faa3911e6c0ce83a83fc5d394b8a", + "source_head": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "reason": "PR6375 by DreamingOfClouds supplies the six shared-carrier lifts. Its exact word, constructor, lift data, source receipt, proof, notice and PR6372 input are retained. No runtime fetch." + } + ] +} diff --git a/research/mixed-root-third-anchor-composition/SPEC.json b/research/mixed-root-third-anchor-composition/SPEC.json new file mode 100644 index 0000000000..b5d28a35d3 --- /dev/null +++ b/research/mixed-root-third-anchor-composition/SPEC.json @@ -0,0 +1,73 @@ +{ + "anchors": [ + 224, + 227, + 234 + ], + "dirs": { + "224": { + "224": "1/2", + "227": "-1/2", + "228": "-1/2", + "229": "1/2", + "232": "1/2", + "233": "-1/2", + "238": "1/2", + "239": "-1/2", + "449": "1/2" + }, + "227": { + "224": "-1", + "227": "1/2", + "228": "1/2", + "229": "-1/2", + "232": "-1/2", + "233": "1/2", + "238": "-1/2", + "239": "1/2", + "449": "-1/2" + }, + "234": { + "224": "-1/2", + "230": "-1/2", + "231": "1/2", + "234": "1/2", + "235": "-1/2", + "236": "-1/2", + "237": "1/2" + } + }, + "entries": { + "224": 245, + "227": 245, + "234": 246 + }, + "lams": { + "224": { + "169": "2", + "193": "-6", + "204": "2", + "224": "-2", + "227": "2" + }, + "227": { + "193": "-4", + "204": "2", + "224": "-4", + "227": "2", + "229": "1/2", + "742": "1" + }, + "234": { + "169": "1/4", + "193": "1/4", + "204": "1/4", + "224": "15/4", + "227": "2", + "229": "1/2", + "234": "1", + "742": "1/2" + } + }, + "note": "dirs[a] is the new input direction u_a (helper coordinates); lams[a] gives the group-1091 row combination c_a that replaces row a. Pairing c_a.u_b = delta_ab." +} \ No newline at end of file diff --git a/research/mixed-root-third-anchor-composition/TASK.json b/research/mixed-root-third-anchor-composition/TASK.json new file mode 100644 index 0000000000..2dfc6ec5ff --- /dev/null +++ b/research/mixed-root-third-anchor-composition/TASK.json @@ -0,0 +1,97 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 8, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "joint-query-controller", + "question": "Can a changed query demand or caller remove real work while satisfying native chronology and restoration?", + "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" + ], + "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": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "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": "Choose an exact caller and a new demand/interface hypothesis. Read the scoped #5617/#5631/#5649/#5747 and #5720/#5745 objections before rebuilding an excluded schedule. Compare the complete matched source/consumer protocols including all retained helper outputs. For an active-mode injection, first check #5745: its canonical delivery claim repays the eight removed centre jobs. Audit that exact claim or change its channel/feedback hypothesis; do not repeat the same free-injection search. Stop if the full favorable budget fails or the required restored output is unobservable.", + "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": [ + "query demand", + "active mode", + "5720", + "5745", + "5747", + "caller" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "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": "Replace the PR6375 native word inside the PR6398 mixed-root composition by the same word with a third group-1091 helper anchor: helper 234 gets the entrance frame 246 (final[234] 127->246) next to the two PR6372 anchors 224 and 227 at frame 245. Per native call the paid profile changes by +1 at rank 4 and -1 at rank 5, the productive profile by +1 at rank 8 and -1 at rank 9. The word gains one owned lifetime (44) and 1,382 scalar allowance units and one native chart (1091,246). Mixed root and caller are unchanged. Complete native, caller, invoice, compiler and outer checks are re-run; the exact claim is 0.00328637739144124222748802.", + "scope_change_reason": "Refines PR6398: the contact-block source gains one more anchor. An exact joint-capacity computation on the transposed PR6353 word finds capacity exactly 3 in group 1091 across entrance frames 245 and 246 (U_245 and U_246 of dimension 2, helper functionals L of dimension 7, joint pairing rank 3). SPEC.json holds the dyadic solution. The mixed root and caller are untouched.", + "bottleneck_link": "The complex supplier binds. The third anchor reduces the full signed cost at every one of the eighteen native calls.", + "stop_rule": "Reject any changed root event, missing target debit, native phase failure, incomplete source closure, failed interval or compiler/outer bound. No PR or push before the user gives explicit permission.", + "outcome": "completed", + "evidence": "README.md, RESULT.json (generated by the final replay), both retained source manifests, SPEC.json and registered replay.", + "author": "Claude Sonnet 5.5 (Claude Code) with orchestrated subagents, for the user Erwan L. Apache-2.0.", + "ai_assistance": "Substantial AI assistance: Claude Sonnet 5.5 via Claude Code, orchestrating subagents, under the direction of the user Erwan L. All checks are author checks.", + "open_questions": [ + { + "question": "Can an independent reviewer confirm the third anchor: capacity exactly 3 in group 1091 across entrance frames 245 and 246, and the dyadic solution in SPEC.json?", + "why_it_matters": "The mechanism and its composition with the mixed root are conditional and author checked; the word adds one owned lifetime and 1,382 scalar allowance units.", + "first_step": "Recompute the zero-frame preparation of the transposed PR6353 word, dim U_245, dim U_246, dim L and the joint pairing rank in exact rationals, then replay the word and check the new native chart (1091,246).", + "blocked_by": "No independent scientific review is claimed by the local author replay." + }, + { + "question": "Is capacity 3 in group 1091 optimal, and do other group/entrance-frame pairs admit further anchors?", + "why_it_matters": "The joint rank is 3 for entrance frames 245 and 246 only; other frames and groups were not searched exhaustively.", + "first_step": "Run the same exact (U_F, L) pairing-rank computation for every first-departure group G and every entrance frame F contained in G.", + "blocked_by": "The enumeration is not part of this package." + }, + { + "question": "Can a changed caller or root convert the remaining native saving into a larger complete gain?", + "why_it_matters": "The increment of this package is small; most of the gain is inherited from the mixed root.", + "first_step": "Fresh overlap check, then a favorable complete invoice before building a new caller.", + "blocked_by": "The package changes neither root nor caller." + } + ], + "publication_status": "LOCAL_ONLY_USER_REQUIRES_EXPLICIT_PR_PERMISSION", + "larger_user_objective": "The third anchor adds about 1.626e-7 (0.00495 percent) over PR6398's 0.00328621476572836015146308 and about 4.2897 percent over PR6375's 0.00315120 in total; almost all of that total is inherited from the mixed root and the PR6375 lifts." +} diff --git a/research/mixed-root-third-anchor-composition/VERIFY.json b/research/mixed-root-third-anchor-composition/VERIFY.json new file mode 100644 index 0000000000..76a6d82384 --- /dev/null +++ b/research/mixed-root-third-anchor-composition/VERIFY.json @@ -0,0 +1,37 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/mixed-root-source-composition/verify.py", + "research/mixed-root-source-composition/INPUTS.json", + "research/mixed-root-source-composition/sources.tar", + "research/mixed-root-source-composition/pricing.py", + "research/mixed-root-source-composition/ceiling.py", + "research/mixed-root-source-composition/RESULT.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 590, + "checks": "Exact PR6372 and PR6375 reconstruction, all six changed helper inputs, all native columns and phases, unchanged mixed caller, complete paid and productive deltas, two-engine price, compiler, outer ledger and all-binary-size ceiling. The exact raw family supremum, every competing size profile, all seven-leaf tree histograms, exact completion tails and a 10^-26 crossing bracket." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 590, + "checks": "The same complete conditional result and source/semantic controls with assertions disabled." + } + ] +} diff --git a/research/mixed-root-third-anchor-composition/WORD.json.gz b/research/mixed-root-third-anchor-composition/WORD.json.gz new file mode 100644 index 0000000000..fcfcdc3379 Binary files /dev/null and b/research/mixed-root-third-anchor-composition/WORD.json.gz differ diff --git a/research/mixed-root-third-anchor-composition/ceiling.py b/research/mixed-root-third-anchor-composition/ceiling.py new file mode 100644 index 0000000000..6b1f0887b0 --- /dev/null +++ b/research/mixed-root-third-anchor-composition/ceiling.py @@ -0,0 +1,65 @@ +"""Bound every binary-child size for the rank 2,3,3,2 root. + +Adapted from the prior fixed-root ceiling by Ali Romman with OpenAI Codex. +The contracted native source stays fixed. Other roots and sources are outside +this claim. All arithmetic in this checker uses rational intervals. +""" +from fractions import Fraction as Q + +CEILING=Q('.00328637739144124222748804') +BIT_CAP=Q('.0034') +TAIL=100 + + +def run(local,E,root): + def need(ok,message): + if not ok:raise ValueError(message) + need(00,'The native deficit increases throughout the admitted range') + h={r:E.power(r,t) for r in range(1,8*TAIL+2)} + lower=[Q(0)]*TAIL + upper=[Q(0)]*TAIL + split_checks=0 + for n in range(2,TAIL): + node_lower=2*h[8*n][0]+1-2*h[8*n+1][1] + node_upper=2*h[8*n][1]+1-2*h[8*n+1][0] + lower[n]=min(lower[a]+lower[n-a]+node_lower for a in range(1,n)) + upper[n]=min(upper[a]+upper[n-a]+node_upper for a in range(1,n)) + need(lower[n]<=upper[n],'Binary subtree interval') + split_checks+=n-1 + pairs={} + for n in range(2,TAIL-1): + pairs[n]=max(h[8*n+1][1]-n*native_lower-lower[n-b]-lower[b] + +h[8*b+1][1]-h[8*b][0] for b in range(1,n)) + margins=[] + for n in range(4,TAIL): + for a in range(2,n-1): + margins.append(h[8*n+1][1]+pairs[a]+pairs[n-a]-2) + finite_upper=max(margins) + need(finite_upper<0,'Every finite child sum fails at the ceiling') + # Every binary node costs at least -1 by concavity. For total n, + # Jensen bounds the two pair outputs and each added increment is at + # most H9-H8. The resulting upper bound is decreasing for n >= TAIL. + tail_upper=(h[8*TAIL+1][1]+2*h[4*TAIL+1][1]-TAIL*(native_lower-1) + +2*(h[9][1]-h[8][0])-6) + derivative_upper=(8*t*(h[8*TAIL+1][1]/(8*TAIL+1) + +h[4*TAIL+1][1]/(4*TAIL+1))-(native_lower-1)) + need(tail_upper<0 and derivative_upper<0,'All larger child sums fail') + return {'ceiling':str(CEILING),'first_tail_total':TAIL,'binary_split_checks':split_checks, + 'admitted_saving_cap':str(BIT_CAP),'native_derivative_lower':str(derivative_lower), + 'finite_pair_checks':len(margins),'finite_margin_upper':str(finite_upper), + 'tail_margin_upper':str(tail_upper),'tail_derivative_upper':str(derivative_upper), + 'scope':'All positive integer child sizes and all binary tree shapes for this fixed root and PR6375 source with the third group-1091 anchor.'} diff --git a/research/mixed-root-third-anchor-composition/construct3.py b/research/mixed-root-third-anchor-composition/construct3.py new file mode 100644 index 0000000000..c134c1845b --- /dev/null +++ b/research/mixed-root-third-anchor-composition/construct3.py @@ -0,0 +1,160 @@ +"""Generalized joint contact-block contraction: k anchors with per-anchor entrance frames. + +Written by the main-session Claude (Sonnet 5.5, via Claude Code) with orchestrated +subagent assistance, for the user Erwan L. Apache-2.0. Not authored by any predecessor. +The structure follows research/p104-contact-block-contraction/construct.py (source and +lineage credits are in NOTICE). With spec=None it +reproduces the PR6372 word exactly (regression checked by verify.py); with the +SPEC.json spec it builds three anchors: 224 and 227 enter at frame 245, 234 at +frame 246. The legacy basis helpers are loaded from the pinned PR6353 source. +""" +from copy import deepcopy +from fractions import Fraction as Q +from collections import defaultdict +import sys + +# CANDIDATE CHANGE: the legacy basis module is the one already loaded and authenticated by the caller +LB = sys.modules['legacy_basis'] +transpose,add,apply,inverse,emit,span=LB.transpose,LB.add,LB.apply,LB.inverse,LB.emit,LB.span +ZERO,FULL=3,127 +from support import need + + +def load_spec(d): + """JSON spec (Fractions as strings) -> construct spec.""" + return {'anchors': [int(a) for a in d['anchors']], 'entries': {int(k): int(v) for k, v in d['entries'].items()}, + 'dirs': {int(a): {int(k): Q(x) for k, x in u.items()} for a, u in d['dirs'].items()}, + 'lams': {int(a): {int(k): Q(x) for k, x in u.items()} for a, u in d['lams'].items()}} +def elementary(T,roles): + """ops (ADD/SCALE/SWAP on `roles`) that map rows e_i -> rows T[i] (as combination of the row of roles[j]).""" + n=len(roles); M=[[Q(x) for x in r] for r in T]; ops=[] # E_k...E_1 M = I, record E as op on index + for c in range(n): + cand=[i for i in range(c,n) if M[i][c]!=0] + def pw2(x): + x=abs(Q(x)); return x.numerator&(x.numerator-1)==0 and x.denominator&(x.denominator-1)==0 + k=next((i for i in cand if pw2(M[i][c])),cand[0]) + if k!=c: + M[c],M[k]=M[k],M[c]; ops.append(('SWAP',c,k)) + if M[c][c]!=1: + f=M[c][c]; M[c]=[x/f for x in M[c]]; ops.append(('SCALE',c,1/f)) + for i in range(n): + if i!=c and M[i][c]!=0: + f=M[i][c]; M[i]=[x-f*y for x,y in zip(M[i],M[c])]; ops.append(('ADD',i,c,-f)) + out=[] + for op in reversed(ops): # F_1=E_n^{-1} ... ; SWAP is self-inverse + if op[0]=='SWAP': out.append(('SWAP',roles[op[1]],roles[op[2]])) + elif op[0]=='SCALE': out.append(('SCALE',roles[op[1]],1/Q(op[2]))) + else: out.append(('ADD',roles[op[1]],roles[op[2]],-Q(op[3]))) + return out +def ops_from_spec(spec): + """spec: anchors (list of roles), entries {role:frame}, dirs {role: {k: coeff}} (u_j), lams {role: {row: coeff}}""" + anchors=spec['anchors']; dirs=spec['dirs']; lams=spec['lams'] + # B0: first the non-anchor rows, then the anchor block + B0=[] + nonanch=sorted({k for u in dirs.values() for k in u if k not in anchors}) + for k in nonanch: + for a in anchors: + c=dirs[a].get(k,0) + if c: B0.append(('ADD',k,a,Q(c))) + T=[[Q(dirs[aj].get(ai,0)) for aj in anchors] for ai in anchors] # row i = B[a_i] = sum_j u_j[a_i] e_{a_j} + B0+=elementary(T,anchors) + Lam=[[Q(lams[ai].get(aj,0)) for aj in anchors] for ai in anchors] + Cops=elementary(Lam,anchors) + for ai in anchors: + for r,c in sorted(lams[ai].items()): + if r not in anchors and c: Cops.append(('ADD',ai,r,Q(c))) + return B0,Cops +def construct(source,spec=None): + w=transpose(source); out=deepcopy(w); N=w['public'] + if spec is None: + a,b=224,227; anchors=[a,b]; entries={a:245,b:245}; g=1091 + B0=[('ADD',a,b,Q(1)),('SCALE',b,Q(-2)),('ADD',b,a,Q(1)),('SCALE',a,Q(2))] + extra={228:1,229:-1,232:-1,233:1,238:-1,239:1,449:-1} + B0+=[('ADD',r,b,Q(c)) for r,c in extra.items()] + Cops=[('ADD',193,742,Q(1,2)),('ADD',169,742,Q(1,2)),('SWAP',a,193),('SWAP',b,169)] + else: + anchors=spec['anchors']; entries=spec['entries']; g=1091 + B0,Cops=ops_from_spec(spec) + shadow={a:N+9+i for i,a in enumerate(anchors)} + helpers={r for r in range(N) if r not in set(w['live'])|{s+112 for s in w['live']} and w['initial'][r]==ZERO and w['final'][r]==FULL} + zero=[e for e in w['program'] if e[0] in('ADD','COPY','SCALE','INIT','CLEAR') and e[-1]==ZERO] + need(not any(e[0]=='MOVE' and e[1]>=N and (e[2]==ZERO or e[3]==ZERO) for e in w['program']),'No owned transport through Z') + old_zero_owned={e[1] for e in zero if e[0]=='INIT'} + need(not old_zero_owned.intersection(shadow.values()),'Disjoint zero-register lifetimes') + first={e[1]:(i,e[3]) for i,e in enumerate(w['program']) if e[0]=='MOVE' and e[1] 0 and margin(upper)[1] < 0 and Q(price['derivative_upper']) < 0, + 'The literal invoice has exactly one crossing in the refined interval') + + h = {r: E.power(r, 1-lower) for r in range(1, 802)} + native = (E.moment(paid, 1-lower)[0]-E.moment(helpers, 1-lower)[1])/104 + costs = [Q(0)]*100 + for n in range(2, 100): + node = 2*h[8*n][0]+1-2*h[8*n+1][1] + costs[n] = min(costs[a]+costs[n-a]+node for a in range(1, n)) + pairs = {} + nine = [] + for n in range(2, 99): + values = [h[8*n+1][1]-n*native-costs[n-b]-costs[b] + +h[8*b+1][1]-h[8*b][0] for b in range(1, n)] + pairs[n] = max(values) + if n == 9: + nine = values + alternatives = [h[8*n+1][1]+pairs[x]+pairs[n-x]-2 + for n in range(4, 100) for x in range(2, n-1) + if (x, n-x) != (9, 9)] + other_totals = max(alternatives) + other_split = h[145][1]+pairs[9]+max(value for b, value in enumerate(nine, 1) if b != 2)-2 + need(other_totals < 0 and other_split < 0, + 'Every different child-size profile already loses at the lower endpoint') + tail_upper = h[801][1]+2*h[401][1]-100*(native-1)+2*(h[9][1]-h[8][0])-6 + tail_derivative = 8*(1-lower)*(h[801][1]/801+h[401][1]/401)-(native-1) + need(tail_upper < 0 and tail_derivative < 0, + 'Every total at least 100 already loses at the lower endpoint') + # The selected margin can be negative above its zero. Negative + # competitor margins alone would not prove dominance there. + selected_lower = margin(upper)[0]/104 + competitor_upper = max(other_totals, other_split, tail_upper) + profile_gap = selected_lower-competitor_upper + need(profile_gap > 0, + 'The selected profile dominates every other size profile throughout the bracket') + + # Distinct tree shapes with the same node-size histogram have the same + # invoice. Enumerate histograms, including every split, through size seven. + histograms = {1: {tuple([0]*8)}} + for n in range(2, 8): + histograms[n] = set() + for a in range(1, n): + for left in histograms[a]: + for right in histograms[n-a]: + histograms[n].add(tuple(x+y+(j == n) for j, (x, y) in enumerate(zip(left, right)))) + node_interval = {} + for n in range(2, 8): + a, b = E.power(8*n, 1-lower), E.power(8*n+1, 1-lower) + c, d = E.power(8*n, 1-upper), E.power(8*n+1, 1-upper) + node_interval[n] = (2*a[0]+1-2*b[1], 2*c[1]+1-2*d[0]) + need(node_interval[n][0] <= node_interval[n][1], 'Increasing binary-node cost on the interval') + gaps = [] + selected = tree_data[0][1] + need(tree_data[3][1] == selected and len(histograms[2]) == 1, 'The symmetric children have identical bills') + selected_tuple = tuple(selected[j] for j in range(8)) + need(selected_tuple in histograms[7], 'The selected tree histogram is present') + for histogram in histograms[7]-{selected_tuple}: + difference = [x-y for x, y in zip(histogram, selected_tuple)] + gap = sum(c*node_interval[n][0 if c >= 0 else 1] + for n, c in enumerate(difference) if c) + need(gap > 0, 'Every other seven-leaf tree bill is larger throughout the bracket') + gaps.append(gap) + + # A constructive strictifier is available arbitrarily near the raw + # crossing: alpha<1 below it; these two tail bounds hold on the full + # bracket. This statement is about the finite supplier, not a new + # outer-endpoint certificate at the crossing itself. + target_lower = E.moment(targets, 1-upper)[0] + gamma_upper = E.moment(calls, 1-lower+Q(1, 7))[1]/(E.power(12, Q(1, 7))[0]*target_lower) + delta_upper = Q(sum(targets.values())*13)/(E.power(12, lower)[0]*target_lower) + need(gamma_upper < Q(31, 32) and delta_upper < Q(31, 32), 'Both tails are uniformly below one near the limit') + return {'raw_limit_interval': list(map(str, (lower, upper))), + 'signed_invoice': {str(r): c for r, c in sorted(raw.items())}, + 'unique_selected_sizes_up_to_pair_exchange': sizes, + 'other_pair_total_checks': len(alternatives), 'other_pair_total_margin_upper': str(other_totals), + 'other_nine_leaf_split_margin_upper': str(other_split), + 'lower_endpoint_tail_margin_upper': str(tail_upper), + 'lower_endpoint_tail_derivative_upper': str(tail_derivative), + 'selected_per_port_margin_lower_on_bracket': str(selected_lower), + 'other_size_profile_margin_upper_on_bracket': str(competitor_upper), + 'minimum_size_profile_margin_gap': str(profile_gap), + 'seven_leaf_histograms': len(histograms[7]), 'selected_seven_leaf_histogram': dict(selected), + 'minimum_alternative_tree_cost_gap': str(min(gaps)), + 'uniform_tail_gamma_upper': str(gamma_upper), 'uniform_tail_delta_upper': str(delta_upper), + 'certified_kappa_distance_upper': str(upper-Q(price['kappa'])), + 'statement': 'The exact family raw-funding supremum is the unique zero of the displayed signed invoice. At that zero the raw paid and productive moments are equal, so the strict compiler does not certify equality.', + 'scope': 'Fixed PR6375 source; six fields with S on every output, constant scalar bases independent of S and all stage variables, seven square-zero queries, four distinct independent forward full stages and at most two extra whole idles; every positive binary child size and binary tree shape; admitted saving range through .0034.'} diff --git a/research/mixed-root-third-anchor-composition/pricing.py b/research/mixed-root-third-anchor-composition/pricing.py new file mode 100644 index 0000000000..8046adce58 --- /dev/null +++ b/research/mixed-root-third-anchor-composition/pricing.py @@ -0,0 +1,189 @@ +"""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.00328637739144124222748802') +TESTED = Q('0.003286377391441242227488025') +PREVIOUS = Q('0.00328621476572836015146308') + + +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[1+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') + need((targets, paid) == formula_invoice(local), 'Independent tree and emitted-event counts') + need((counts['LOCAL'], counts['QUERY'], counts['IDLE']) == (18, 17, 14) and counts['IDLE_ONE'] == 2 and counts['LAMBDA'] == 20, 'Complete caller census') + need((sum(targets.values()), sum(paid.values())) == (13652, 67150), '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] + low, high, grid = 0, 10**24, 10**26 + while high-low > 1: + middle = (low+high)//2 + if margin(Q(middle, grid))[0] > 0: + low = middle + else: + high = middle + lower, upper = Q(low, grid), Q(high, 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*34*104*len(word['events']) + 34*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.00328637739144124222748802', 'previous_fixed_root': PREVIOUS, + 'refinement_kind': 'Same complete invoice; finer strictification and compiler parameters.', + '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/mixed-root-third-anchor-composition/verify.py b/research/mixed-root-third-anchor-composition/verify.py new file mode 100644 index 0000000000..da1bd788d2 --- /dev/null +++ b/research/mixed-root-third-anchor-composition/verify.py @@ -0,0 +1,287 @@ +"""Compose the fixed mixed root with the PR6375 native word plus a third group-1091 anchor. + +Prepared by the Claude Sonnet 5.5 main session (Claude Code) with orchestrated subagent +assistance, for Erwan L. Apache-2.0. Adapted from the mixed-root contact composition verifier +(Ali Romman with OpenAI Codex); every change is marked CANDIDATE CHANGE. The source +constructors and proof engines retain their original notices. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha1, sha256 +from pathlib import Path, PurePosixPath +import gzip +import importlib.util +import json +import sys +import tarfile +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +PREVIOUS = ROOT/'research/mixed-root-source-composition' +CONTACT = 'research/p104-contact-block-contraction/' +LIFT = 'research/p104-shared-carrier-lifts/' +STATUS = 'PASS_MIXED_ROOT_THIRD_ANCHOR_KAPPA_00328637739144124222748802' # CANDIDATE CHANGE + + +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 authenticate(data, pin): + need(sha256(data).hexdigest() == pin['sha256'], 'Exact source SHA256: '+pin['path']) + need(sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() == pin['git_blob'], + 'Exact source Git blob: '+pin['path']) + + +def reject(action): + try: + action() + except ValueError as error: + return str(error) + raise ValueError('Invalid control accepted') + + +def delta(after, before): + result = Counter(after) + result.subtract(before) + return {r: n for r, n in result.items() if n} + + +def retained_source(root, manifest_name, archive_name, count): + manifest = read(HERE/manifest_name) + archive = HERE/archive_name + need(sha256(archive.read_bytes()).hexdigest() == manifest['archive_sha256'], 'Exact retained source archive') + pins = {p['path']: p for p in manifest['files']} + need(len(pins) == len(manifest['files']) == count, 'Exact retained source inventory') + with tarfile.open(archive, 'r:') as tar: + members = tar.getmembers() + need(len(members) == count and {m.name for m in members} == set(pins), 'Every retained source file') + for member in members: + path = PurePosixPath(member.name) + need(member.isfile() and not path.is_absolute() and '..' not in path.parts, 'Regular relative retained path') + data = tar.extractfile(member).read() + authenticate(data, pins[member.name]) + target = root/member.name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(data) + return manifest + + +def run(build_only=False): # CANDIDATE CHANGE: cheap build-only mode + live = read(HERE/'SOURCES.json')['files'] + for pin in live: + if pin['usage'] == 'input': + authenticate((ROOT/pin['path']).read_bytes(), pin) + previous = load(PREVIOUS/'verify.py', 'prior_mixed_composition') + for filename, edits in [('pricing.py', 'PRICING-EDITS.json'), ('ceiling.py', 'CEILING-EDITS.json')]: + text = (PREVIOUS/filename).read_text() + for before, after in read(HERE/edits): + need(text.count(before) == 1, 'One occurrence of each declared '+filename+' edit') + text = text.replace(before, after) + need(text == (HERE/filename).read_text(), 'Exact declared '+filename+' adapter') + with previous.sources() as (root, old_manifest): + manifest = retained_source(root, 'CONTACT-INPUTS.json', 'contact-source.tar', 8) + lift_manifest = retained_source(root, 'LIFT-INPUTS.json', 'lift-source.tar', 7) + original = root/previous.ROOT_SOURCE + joint = root/previous.CONTRACT_SOURCE + new = root/CONTACT + load(original/'algebra.py', 'algebra') + controller = load(original/'controller.py', 'controller') + physical = load(original/'physical.py', 'contact_root_physical') + module = load(original/'module_check.py', 'contact_root_module') + binary = load(root/'research/balanced-query-tree/module_check.py', 'contact_root_binary') + support = load(joint/'support.py', 'support') + legacy = load(joint/'construct.py', 'legacy_basis') + third = load(HERE/'construct3.py', 'third_constructor') # CANDIDATE CHANGE: k-anchor constructor (uses the loaded legacy basis) + constructor = load(new/'construct.py', 'contact_root_constructor') + need((joint/'construct.py').read_bytes() == (new/'inputs/pr6353-construct.py').read_bytes(), + 'The exact retained PR6353 basis constructor') + need((joint/'WORD.json.gz').read_bytes() == (new/'inputs/pr6353-WORD.json.gz').read_bytes(), + 'The exact retained PR6353 native word') + old_word = json.loads(gzip.decompress((joint/'WORD.json.gz').read_bytes())) + native_word, witness = constructor.construct(old_word) + need(native_word == json.loads(gzip.decompress((new/'WORD.json.gz').read_bytes())), 'Every rebuilt PR6372 native word field') + need(legacy.encode(witness) == read(new/'BASIS.json'), 'Every new rational basis witness') + need(all(native_word[k] == value for k, value in old_word.items() if k not in ('program', 'final')), + 'Unchanged native interface, inputs and frames') + need({r: native_word['final'][r] for r in range(770) if native_word['final'][r] != old_word['final'][r]} + == {224: 245, 227: 245}, 'Only the two declared helper outputs change') + contact_word = native_word + lifted = root/LIFT + need((new/'WORD.json.gz').read_bytes() == (lifted/'inputs/pr6372-WORD.json.gz').read_bytes(), + 'Exact retained input to the shared-carrier constructor') + lifts = load(lifted/'construct.py', 'mixed_shared_carrier_constructor') + native_word = lifts.construct(contact_word, read(lifted/'LIFTS.json')) + need(native_word == json.loads(gzip.decompress((lifted/'WORD.json.gz').read_bytes())), + 'Every reconstructed PR6375 native word field') + need(all(native_word[k] == value for k, value in contact_word.items() if k not in ('program', 'initial')), + 'Unchanged lifted interface, frames and final outputs') + need({r: native_word['initial'][r] for r in range(770) + if native_word['initial'][r] != contact_word['initial'][r]} + == {520: 106, 655: 106, 544: 105, 671: 105, 472: 105, 624: 105}, + 'Exactly six changed input frames') + # CANDIDATE CHANGE: `native_word` was the PR6375 word; it is kept as `predecessor_word`. The word used + # below is the third-anchor word: PR6353 -> three anchors (word3) -> the same PR6375 lift rounds. + predecessor_word = native_word + need(third.construct(old_word, None)[0] == contact_word, 'spec=None reproduces the PR6372 word exactly') + word3, _ = third.construct(old_word, third.load_spec(read(HERE/'SPEC.json'))) + native_word = lifts.construct(word3, read(lifted/'LIFTS.json')) + need(native_word == json.loads(gzip.decompress((HERE/'WORD.json.gz').read_bytes())), + 'Every rebuilt third-anchor native word field') + need(all(native_word[k] == predecessor_word[k] for k in native_word if k not in ('program', 'final')) + and {r for r in range(770) if native_word['final'][r] != predecessor_word['final'][r]} == {234} + and native_word['final'][234] == 246 and predecessor_word['final'][234] == 127, + 'Only the third anchor output frame differs from the PR6375 word') + caller = controller.construct() + need(caller == read(original/'CONTROLLER.json'), 'Every unchanged mixed caller event') + root_result, binary_result = module.run(), binary.run() + caller_result = controller.replay(caller) + controls = controller.controls(caller) + price = load(HERE/'pricing.py', 'contact_root_price') + ceiling = load(HERE/'ceiling.py', 'contact_root_ceiling') + optimality = load(HERE/'optimality.py', 'contact_root_optimality') + print('PASS exact source reconstruction, root, normalization and complete caller', flush=True) + with support.checkers() as (L, frozen): + old, contact, local = L.replay(old_word), L.replay(contact_word), L.replay(native_word) + pred, pre = L.replay(predecessor_word), L.replay(word3) # CANDIDATE CHANGE: PR6375 word and word3 + need(price.encode(contact) == read(new/'RESULT.json')['local'], 'Published PR6372 local receipt') + need(price.encode(pred) == read(lifted/'RESULT.json')['local'], 'Published PR6375 local receipt') # CANDIDATE CHANGE: predecessor + need(price.encode(old) == read(PREVIOUS/'RESULT.json')['local'], 'Prior complete composition source') + pd, td = delta(local['paid'], old['paid']), delta(local['helpers'], old['helpers']) + need(delta(contact['paid'], old['paid']) == {4: 2, 5: -2} + and delta(contact['helpers'], old['helpers']) == {8: 2, 9: -2}, 'Exact contact changes') + # CANDIDATE CHANGE: lifts are measured against word3; the third anchor against the PR6372 word and the PR6375 word + lift_pd, lift_td = delta(local['paid'], pre['paid']), delta(local['helpers'], pre['helpers']) + need(lift_pd == {1: 6, 3: -3, 4: 3, 5: -3} and lift_td == {8: 6, 9: -6}, + 'Exact signed shared-carrier changes') + third_pd, third_td = delta(pre['paid'], contact['paid']), delta(pre['helpers'], contact['helpers']) + need(third_pd == {4: 1, 5: -1} and third_td == {8: 1, 9: -1}, 'Exact third-anchor change') + need(delta(local['paid'], pred['paid']) == {4: 1, 5: -1} + and delta(local['helpers'], pred['helpers']) == {8: 1, 9: -1}, 'Exact change against the PR6375 word') + need((local['public_inputs'], local['owned_fields'], local['owned_lifetimes'], local['peak_owned_fields']) + == (770, 29, 44, 13), 'All inputs and all three new owned lifetimes') + need((local['real_scalar_allowance'], local['paid_rank_mass']) == (131052, 5925), 'Exact scalar allowance and paid mass') + for label, index in witness['control_indices'].items(): + bad = deepcopy(contact_word) + del bad['program'][index] + controls['missing_'+label] = reject(lambda: L.replay(bad)) + for role in (224, 227): + bad = deepcopy(native_word) + bad['final'][role] = old_word['final'][role] + controls['missing_target_'+str(role)] = reject(lambda: L.replay(bad)) + for role in (520, 655, 544, 671, 472, 624): + bad = deepcopy(native_word) + bad['initial'][role] = contact_word['initial'][role] + controls['old_entrance_'+str(role)] = reject(lambda: L.replay(bad)) + source_events = {tuple(e) for e in word3['program']} # CANDIDATE CHANGE: lift controls relative to word3 + new_adds = [i for i, e in enumerate(native_word['program']) + if e[0] == 'ADD' and tuple(e) not in source_events] + for label, index in [('first_lift_delivery', new_adds[0]), ('last_lift_restore', new_adds[-1])]: + bad = deepcopy(native_word) + del bad['program'][index] + controls[label] = reject(lambda: L.replay(bad)) + bad = deepcopy(native_word) + bad['program'][new_adds[0]][3] = str(-Q(bad['program'][new_adds[0]][3])) + controls['lift_response_sign'] = reject(lambda: L.replay(bad)) + # CANDIDATE CHANGE: controls specific to the third anchor 234 + events75 = {tuple(e) for e in predecessor_word['program']} + P3 = native_word['program'] + third_new = [i for i, e in enumerate(P3) if tuple(e) not in events75] + t_moves = [i for i in third_new if P3[i][0] == 'MOVE'] + t_246 = [i for i in third_new if P3[i][0] == 'ADD' and P3[i][-1] == 246] + t_in = [i for i in third_new if P3[i][0] == 'ADD' and P3[i][-1] == 3] + t_out = [i for i in third_new if P3[i][0] == 'ADD' and P3[i][-1] == 127] + need(t_moves and t_246 and t_in and t_out, 'Third-anchor events present') + for label, frame in [('wrong_entrance_245', 245), ('entrance_reverted', 127)]: + bad = deepcopy(native_word) + bad['final'][234] = frame + controls['third_anchor_' + label] = reject(lambda: L.replay(bad)) + for label, index in [('move_dropped', t_moves[0]), ('response_dropped', t_246[0]), + ('input_correction_dropped', t_in[0]), ('dyadic_restore_dropped', t_out[-1])]: + bad = deepcopy(native_word) + del bad['program'][index] + controls['third_anchor_' + label] = reject(lambda: L.replay(bad)) + bad = deepcopy(native_word) + bad['program'][t_246[0]][3] = str(2*Q(bad['program'][t_246[0]][3])) + controls['third_anchor_response_doubled'] = reject(lambda: L.replay(bad)) + if build_only: # CANDIDATE CHANGE: stop after the rebuild, local deltas and word controls + print('PASS third-anchor rebuild, local deltas, inventory and word controls', flush=True) + return None + columns = L.reverse_columns(native_word) + need(columns['columns'] == 799 and columns['coefficients'] == 638401, 'All independent native columns') + native = L.native(native_word) + maps = physical.physical(caller, native_word, L) + need(maps['full_calls'] == 18 and maps['physical_contacts'] == 7488, 'All physical caller contacts') + print('PASS source inputs, dense transpose, native phases, physical caller and owned controls', flush=True) + bound = price.run(local, native, caller, maps, L) + old_targets, old_paid = controller.formula_invoice(old) + need(delta({int(r): n for r, n in bound['paid'].items()}, old_paid) == {r: 18*n for r, n in pd.items()}, + 'All eighteen paid changes') + need(delta({int(r): n for r, n in bound['targets'].items()}, old_targets) == {r: 18*n for r, n in td.items()}, + 'All eighteen productive target debits') + E = load(frozen/'research/higher-moment-strictification/verify.py', 'contact_root_comparison') + fixed_ceiling = ceiling.run(local, E, read(original/'ROOT.json')) + optimum = optimality.run(local, E, read(original/'ROOT.json'), bound, fixed_ceiling) + old_margin = E.moment(old_targets, 1-price.KAPPA)[1]-E.moment(old_paid, 1-price.KAPPA)[0] + need(old_margin < 0, 'The previous source fails at the new complete claim') + contact_targets, contact_paid = controller.formula_invoice(contact) + contact_margin = E.moment(contact_targets, 1-price.KAPPA)[1]-E.moment(contact_paid, 1-price.KAPPA)[0] + need(contact_margin < 0, 'The immediate PR6372 composition fails at the new complete claim') + pred_targets, pred_paid = controller.formula_invoice(pred) # CANDIDATE CHANGE + pred_margin = E.moment(pred_targets, 1-price.KAPPA)[1]-E.moment(pred_paid, 1-price.KAPPA)[0] + need(pred_margin < 0, 'The PR6375 word with this same mixed caller fails the new claim') + bad = deepcopy(local); bad['paid'][4] -= 1 + controls['unpaid_native_move'] = reject(lambda: price.assemble(bad, native, caller, maps)) + bad = deepcopy(local); bad['helpers'][9] += 1; bad['helpers'][8] -= 1 + controls['missing_productive_debit'] = reject(lambda: price.assemble(bad, native, caller, maps)) + for pin in manifest['files']+lift_manifest['files']: + data = (root/pin['path']).read_bytes() + controls['damaged_'+pin['path']] = reject(lambda data=data, pin=pin: authenticate(bytes([data[0]^1])+data[1:], pin)) + print('PASS both prices, complete compiler and outer ledger, source controls and exact raw family limit', flush=True) + return price.encode({'status': STATUS, 'source_head': lift_manifest['source_head'], + 'contact_source_head': manifest['source_head'], + 'root_source': old_manifest['root_head'], 'native_events': len(native_word['program']), + 'root': root_result, 'binary': binary_result, 'caller': caller_result, + 'local': local, 'paid_delta': pd, 'target_delta': td, 'columns': columns, + 'lift_paid_delta': lift_pd, 'lift_target_delta': lift_td, + 'native': native, 'physical': maps, 'price': bound, 'fixed_root_ceiling': fixed_ceiling, + 'raw_optimality': optimum, + 'prior_source_margin_upper': old_margin, 'controls': controls, + 'immediate_source_margin_upper': contact_margin, 'pr6375_word_margin_upper': pred_margin, + 'third_paid_delta': third_pd, 'third_target_delta': third_td, 'pr6375_local': pred, 'word3_local': pre, # CANDIDATE CHANGE + 'gain_over_pr6398': price.KAPPA-Q('.00328621476572836015146308'), + 'gain_over_pr6375': price.KAPPA-Q('.00315120'), + 'relative_gain_over_pr6375_percent': 100*(price.KAPPA/Q('.00315120')-1), + 'assumptions': ['native_all_columns','owned_erasure','compiler','precision_tape','analytic_recovery'], + 'selected_frontier_changed': False}) + + +if __name__ == '__main__': + sys.dont_write_bytecode = True + with tempfile.TemporaryDirectory(prefix='mixed-contact-cache-') as cache: + sys.pycache_prefix = cache + result = run('--build-only' in sys.argv) + if result is None: + print(STATUS + '_BUILD', flush=True) + sys.exit(0) + if sys.argv[1:] == ['--write-result']: + (HERE/'RESULT.json').write_text(json.dumps(result, sort_keys=True, indent=2)+'\n') + else: + need(not sys.argv[1:], 'Only --write-result is supported') + need(result == read(HERE/'RESULT.json'), 'Exact complete scientific receipt') + print(STATUS, flush=True)