diff --git a/research/p104-helper-split-on-retirement-tree/ADAPTERS.json b/research/p104-helper-split-on-retirement-tree/ADAPTERS.json new file mode 100644 index 0000000000..e5ae35abcd --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/ADAPTERS.json @@ -0,0 +1,76 @@ +{ + "driver": [ + [ + "def run(write=False):", + "def run(write=False, extension=None):" + ], + [ + "result=driver.run(services=services,extension=candidate)", + "result=driver.run(services=services,extension=candidate if extension is None else extension(candidate))" + ] + ], + "controller": [ + [ + "def construct():", + "def construct(data=None):" + ], + [ + " data = json.loads((HERE/'ROOT.json').read_text())", + " if data is None:\n data = json.loads((HERE/'ROOT.json').read_text())" + ] + ], + "pricing": [ + [ + "from controller import formula_invoice, need", + "from tree_invoice import formula_invoice, need" + ], + [ + "KAPPA = Q('0.00329394')", + "KAPPA = Q('0.00329760')" + ], + [ + "TESTED = Q('0.003293945')", + "TESTED = Q('0.003297605')" + ], + [ + "PREVIOUS = Q('0.003288299')", + "PREVIOUS = Q('0.00329700')" + ], + [ + "expected_targets.update({1:104,16:104,17:-104})", + "expected_targets.update({1:104,40:104,41:-104})" + ], + [ + "Independent tree, retirement delta and emitted-event counts", + "Independent rebalanced tree, retirement delta and emitted-event counts" + ], + [ + "'kappa_decimal': '0.00329394'", + "'kappa_decimal': '0.00329760'" + ], + [ + "Independent Gaussian retirement changes the complete productive profile.", + "Cut one public helper register of the native word in two and hand its tail to a new public register, under the rebalanced retirement caller." + ], + [ + "It includes all nine output contractions and their productive target debits.", + "It includes all nine output contractions and their productive target debits.\nThis adaptation prices the native word with one public helper register cut in two." + ], + [ + "reserve, decay = Q(1, 10**29), Q(31, 32)", + "reserve, decay = Q(1, 10**27), Q(33, 34)" + ], + [ + "need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All charged tail ratios')", + "need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All charged tail ratios')\n need(delta[0] > Q(31, 32), 'The source tail decay does not fund this tree')" + ], + [ + "'negative_controls': {'old_completion':", + "'negative_controls': {'old_tail_decay': 'The source tail decay 31/32 is below the new completion ratio.',\n 'old_completion':" + ], + [ + "This adapter keeps the root and changes the native source invoice.", + "This adapter keeps the native word and the retirement identity." + ] + ] +} diff --git a/research/p104-helper-split-on-retirement-tree/CONTROLLER.json b/research/p104-helper-split-on-retirement-tree/CONTROLLER.json new file mode 100644 index 0000000000..a29bd24a25 --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/CONTROLLER.json @@ -0,0 +1,4414 @@ +{ + "schema": "mixed-projector-query-root/2", + "roles": 35, + "stages": 18, + "ambient_rank": 153, + "nodes": [ + { + "roles": [ + 6, + 7 + ], + "stages": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "exponent": 1 + }, + { + "roles": [ + 8, + 9 + ], + "stages": [ + 1, + 2, + 3 + ], + "exponent": -1 + }, + { + "roles": [ + 10, + 11 + ], + "stages": [ + 2, + 3 + ], + "exponent": -1 + }, + { + "roles": [ + 12, + 13 + ], + "stages": [ + 4, + 5, + 6, + 7 + ], + "exponent": 1 + }, + { + "roles": [ + 14, + 15 + ], + "stages": [ + 4, + 5 + ], + "exponent": -1 + }, + { + "roles": [ + 16, + 17 + ], + "stages": [ + 6, + 7 + ], + "exponent": 1 + }, + { + "roles": [ + 18, + 19 + ], + "stages": [ + 8, + 9 + ], + "exponent": 1 + }, + { + "roles": [ + 20, + 21 + ], + "stages": [ + 10, + 11, + 12, + 13, + 14 + ], + "exponent": 1 + }, + { + "roles": [ + 22, + 23 + ], + "stages": [ + 10, + 11 + ], + "exponent": -1 + }, + { + "roles": [ + 24, + 25 + ], + "stages": [ + 12, + 13, + 14 + ], + "exponent": 1 + }, + { + "roles": [ + 26, + 27 + ], + "stages": [ + 13, + 14 + ], + "exponent": 1 + }, + { + "roles": [ + 28, + 29 + ], + "stages": [ + 15, + 16, + 17, + 18 + ], + "exponent": 1 + }, + { + "roles": [ + 30, + 31 + ], + "stages": [ + 15, + 16 + ], + "exponent": -1 + }, + { + "roles": [ + 32, + 33 + ], + "stages": [ + 17, + 18 + ], + "exponent": 1 + } + ], + "events": [ + [ + "ADD", + 4, + 20, + "-1" + ], + [ + "LAMBDA", + 4, + -1 + ], + [ + "ADD", + 21, + 4, + "-1" + ], + [ + "LAMBDA", + 4, + 1 + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 4, + 5, + "-3" + ], + [ + "ADD", + 3, + 5, + "1" + ], + [ + "ADD", + 2, + 5, + "-3" + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 0, + 5, + "2" + ], + [ + "ADD", + 2, + 4, + "-2" + ], + [ + "ADD", + 0, + 4, + "1" + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 5, + 3, + "2" + ], + [ + "ADD", + 2, + 3, + "-2" + ], + [ + "ADD", + 0, + 3, + "1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 5, + 2, + "1" + ], + [ + "ADD", + 0, + 2, + "1/2" + ], + [ + "SCALE", + 2, + "-1/2" + ], + [ + "ADD", + 4, + 1, + "-1" + ], + [ + "ADD", + 3, + 1, + "1" + ], + [ + "ADD", + 2, + 1, + "-1/2" + ], + [ + "ADD", + 0, + 1, + "-1/2" + ], + [ + "ADD", + 4, + 0, + "2" + ], + [ + "ADD", + 3, + 0, + "-2" + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "ADD", + 1, + 0, + "-2" + ], + [ + "SCALE", + 0, + "2" + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 0, + 5, + "-2" + ], + [ + "ADD", + 1, + 4, + "1" + ], + [ + "ADD", + 0, + 4, + "-2" + ], + [ + "ADD", + 1, + 3, + "1" + ], + [ + "ADD", + 0, + 3, + "-3" + ], + [ + "ADD", + 1, + 2, + "1" + ], + [ + "ADD", + 0, + 2, + "-2" + ], + [ + "ADD", + 4, + 1, + "2" + ], + [ + "ADD", + 3, + 1, + "-2" + ], + [ + "ADD", + 2, + 1, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "SWAP", + 0, + 7 + ], + [ + "SWAP", + 1, + 6 + ], + [ + "SWAP", + 6, + 7 + ], + [ + "ADD", + 0, + 6, + 1 + ], + [ + "ADD", + 7, + 1, + -1 + ], + [ + "QUERY", + 6, + 7, + -1 + ], + [ + "ADD", + 7, + 1, + 1 + ], + [ + "ADD", + 0, + 6, + -1 + ], + [ + "IDLE", + 6, + 7, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 1, + 9 + ], + [ + "SWAP", + 0, + 8 + ], + [ + "SWAP", + 8, + 9 + ], + [ + "ADD", + 1, + 8, + 1 + ], + [ + "ADD", + 9, + 0, + -1 + ], + [ + "QUERY", + 8, + 9, + 1 + ], + [ + "ADD", + 9, + 0, + 1 + ], + [ + "ADD", + 1, + 8, + -1 + ], + [ + "IDLE", + 8, + 9, + [ + 1, + 2, + 3 + ] + ], + [ + "SCALE", + 0, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 1, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "SCALE", + 0, + -1 + ], + [ + "SWAP", + 1, + 11 + ], + [ + "SWAP", + 0, + 10 + ], + [ + "SWAP", + 10, + 11 + ], + [ + "ADD", + 1, + 10, + 1 + ], + [ + "ADD", + 11, + 0, + -1 + ], + [ + "QUERY", + 10, + 11, + 1 + ], + [ + "ADD", + 11, + 0, + 1 + ], + [ + "ADD", + 1, + 10, + -1 + ], + [ + "IDLE", + 10, + 11, + [ + 2, + 3 + ] + ], + [ + "SCALE", + 0, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 2, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "SCALE", + 0, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 3, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "ADD", + 1, + 10, + 1 + ], + [ + "SCALE", + 10, + -1 + ], + [ + "ADD", + 10, + 1, + 1 + ], + [ + "SWAP", + 0, + 11 + ], + [ + "SCALE", + 11, + -1 + ], + [ + "ADD", + 11, + 0, + 1 + ], + [ + "ADD", + 1, + 8, + 1 + ], + [ + "SCALE", + 8, + -1 + ], + [ + "ADD", + 8, + 1, + 1 + ], + [ + "SWAP", + 0, + 9 + ], + [ + "SCALE", + 9, + -1 + ], + [ + "ADD", + 9, + 0, + 1 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 13 + ], + [ + "SWAP", + 1, + 12 + ], + [ + "SWAP", + 12, + 13 + ], + [ + "ADD", + 0, + 12, + 1 + ], + [ + "ADD", + 13, + 1, + -1 + ], + [ + "QUERY", + 12, + 13, + -1 + ], + [ + "ADD", + 13, + 1, + 1 + ], + [ + "ADD", + 0, + 12, + -1 + ], + [ + "IDLE", + 12, + 13, + [ + 4, + 5, + 6, + 7 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 1, + 15 + ], + [ + "SWAP", + 0, + 14 + ], + [ + "SWAP", + 14, + 15 + ], + [ + "ADD", + 1, + 14, + 1 + ], + [ + "ADD", + 15, + 0, + -1 + ], + [ + "QUERY", + 14, + 15, + 1 + ], + [ + "ADD", + 15, + 0, + 1 + ], + [ + "ADD", + 1, + 14, + -1 + ], + [ + "IDLE", + 14, + 15, + [ + 4, + 5 + ] + ], + [ + "SCALE", + 0, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 4, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "SCALE", + 0, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 5, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "ADD", + 1, + 14, + 1 + ], + [ + "SCALE", + 14, + -1 + ], + [ + "ADD", + 14, + 1, + 1 + ], + [ + "SWAP", + 0, + 15 + ], + [ + "SCALE", + 15, + -1 + ], + [ + "ADD", + 15, + 0, + 1 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 17 + ], + [ + "SWAP", + 1, + 16 + ], + [ + "SWAP", + 16, + 17 + ], + [ + "ADD", + 0, + 16, + 1 + ], + [ + "ADD", + 17, + 1, + -1 + ], + [ + "QUERY", + 16, + 17, + -1 + ], + [ + "ADD", + 17, + 1, + 1 + ], + [ + "ADD", + 0, + 16, + -1 + ], + [ + "IDLE", + 16, + 17, + [ + 6, + 7 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 6, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 7, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "ADD", + 0, + 16, + 1 + ], + [ + "SCALE", + 16, + -1 + ], + [ + "ADD", + 16, + 0, + 1 + ], + [ + "SWAP", + 1, + 17 + ], + [ + "SCALE", + 17, + -1 + ], + [ + "ADD", + 17, + 1, + 1 + ], + [ + "ADD", + 0, + 12, + 1 + ], + [ + "SCALE", + 12, + -1 + ], + [ + "ADD", + 12, + 0, + 1 + ], + [ + "SWAP", + 1, + 13 + ], + [ + "SCALE", + 13, + -1 + ], + [ + "ADD", + 13, + 1, + 1 + ], + [ + "ADD", + 0, + 6, + 1 + ], + [ + "SCALE", + 6, + -1 + ], + [ + "ADD", + 6, + 0, + 1 + ], + [ + "SWAP", + 1, + 7 + ], + [ + "SCALE", + 7, + -1 + ], + [ + "ADD", + 7, + 1, + 1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + -1 + ], + [ + "ADD", + 4, + 5, + "-2" + ], + [ + "ADD", + 3, + 5, + "2" + ], + [ + "ADD", + 2, + 5, + "-1" + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 0, + 5, + "2" + ], + [ + "ADD", + 3, + 4, + "1/2" + ], + [ + "ADD", + 2, + 4, + "-1/2" + ], + [ + "ADD", + 1, + 4, + "1/2" + ], + [ + "ADD", + 0, + 4, + "3/2" + ], + [ + "SCALE", + 4, + "1/2" + ], + [ + "ADD", + 4, + 3, + "3" + ], + [ + "ADD", + 2, + 3, + "-1" + ], + [ + "ADD", + 1, + 3, + "1" + ], + [ + "ADD", + 0, + 3, + "5" + ], + [ + "SCALE", + 3, + "-2" + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 4, + 2, + "-1" + ], + [ + "ADD", + 3, + 2, + "1" + ], + [ + "ADD", + 1, + 2, + "1/2" + ], + [ + "ADD", + 0, + 2, + "2" + ], + [ + "SCALE", + 2, + "1/2" + ], + [ + "ADD", + 4, + 1, + "2" + ], + [ + "ADD", + 3, + 1, + "-2" + ], + [ + "ADD", + 2, + 1, + "1" + ], + [ + "SCALE", + 1, + "-2" + ], + [ + "ADD", + 2, + 5, + "1" + ], + [ + "ADD", + 2, + 4, + "1" + ], + [ + "ADD", + 2, + 3, + "2" + ], + [ + "ADD", + 1, + 3, + "-1" + ], + [ + "ADD", + 0, + 3, + "1" + ], + [ + "ADD", + 4, + 2, + "2" + ], + [ + "ADD", + 3, + 2, + "-2" + ], + [ + "ADD", + 0, + 2, + "-1" + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "SWAP", + 0, + 19 + ], + [ + "SWAP", + 1, + 18 + ], + [ + "SWAP", + 18, + 19 + ], + [ + "ADD", + 0, + 18, + 1 + ], + [ + "ADD", + 19, + 1, + -1 + ], + [ + "QUERY", + 18, + 19, + -1 + ], + [ + "ADD", + 19, + 1, + 1 + ], + [ + "ADD", + 0, + 18, + -1 + ], + [ + "IDLE", + 18, + 19, + [ + 8, + 9 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 8, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 9, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "ADD", + 0, + 18, + 1 + ], + [ + "SCALE", + 18, + -1 + ], + [ + "ADD", + 18, + 0, + 1 + ], + [ + "SWAP", + 1, + 19 + ], + [ + "SCALE", + 19, + -1 + ], + [ + "ADD", + 19, + 1, + 1 + ], + [ + "IDLE_ONE", + 2, + [ + 8, + 9 + ] + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + -1 + ], + [ + "ADD", + 4, + 5, + "-2" + ], + [ + "ADD", + 3, + 5, + "2" + ], + [ + "ADD", + 2, + 5, + "-1" + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 3, + 4, + "3/4" + ], + [ + "ADD", + 2, + 4, + "-1/2" + ], + [ + "ADD", + 1, + 4, + "1/4" + ], + [ + "ADD", + 0, + 4, + "1/4" + ], + [ + "SCALE", + 4, + "1/4" + ], + [ + "ADD", + 4, + 3, + "-3" + ], + [ + "ADD", + 2, + 3, + "2" + ], + [ + "ADD", + 1, + 3, + "1" + ], + [ + "ADD", + 0, + 3, + "-3" + ], + [ + "SCALE", + 3, + "4" + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 4, + 2, + "-2" + ], + [ + "ADD", + 3, + 2, + "2" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "ADD", + 0, + 2, + "2" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "SWAP", + 0, + 1 + ], + [ + "ADD", + 0, + 5, + "-1" + ], + [ + "ADD", + 0, + 4, + "-1" + ], + [ + "ADD", + 0, + 3, + "-1" + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + -1 + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 1, + 4, + "1" + ], + [ + "ADD", + 1, + 3, + "1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "SWAP", + 0, + 2 + ], + [ + "ADD", + 0, + 5, + "-1" + ], + [ + "ADD", + 0, + 4, + "-1" + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + -1 + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 1, + 4, + "1" + ], + [ + "ADD", + 1, + 3, + "-1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "SWAP", + 1, + 3 + ], + [ + "SWAP", + 0, + 3 + ], + [ + "ADD", + 0, + 5, + "-1" + ], + [ + "ADD", + 0, + 3, + "1" + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + -1 + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 1, + 4, + "-1" + ], + [ + "ADD", + 1, + 3, + "-1" + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SWAP", + 2, + 4 + ], + [ + "SWAP", + 1, + 4 + ], + [ + "SWAP", + 0, + 4 + ], + [ + "ADD", + 2, + 4, + "1" + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 2, + 3, + "3/2" + ], + [ + "ADD", + 0, + 3, + "-1/2" + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 5, + 2, + "2" + ], + [ + "ADD", + 4, + 2, + "-2" + ], + [ + "ADD", + 1, + 2, + "-2" + ], + [ + "ADD", + 0, + 2, + "3" + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "SWAP", + 1, + 3 + ], + [ + "ADD", + 5, + 0, + "-2" + ], + [ + "ADD", + 4, + 0, + "2" + ], + [ + "ADD", + 3, + 0, + "2" + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "SWAP", + 0, + 21 + ], + [ + "SWAP", + 1, + 20 + ], + [ + "SWAP", + 20, + 21 + ], + [ + "ADD", + 0, + 20, + 1 + ], + [ + "ADD", + 21, + 1, + -1 + ], + [ + "QUERY", + 20, + 21, + -1 + ], + [ + "ADD", + 4, + 2, + "1" + ], + [ + "ADD", + 2, + 4, + "-1" + ], + [ + "ADD", + 4, + 2, + "1" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 21, + 4, + "1" + ], + [ + "ADD", + 4, + 1, + "1" + ], + [ + "LAMBDA", + 20, + 1 + ], + [ + "ADD", + 4, + 20, + "-1" + ], + [ + "LAMBDA", + 20, + -1 + ], + [ + "ADD", + 4, + 21, + "1" + ], + [ + "ADD", + 34, + 21, + "-1" + ], + [ + "LAMBDA", + 20, + 1 + ], + [ + "ADD", + 34, + 20, + "1" + ], + [ + "LAMBDA", + 20, + -1 + ], + [ + "ADD", + 34, + 1, + "-1" + ], + [ + "ADD", + 21, + 34, + "-1" + ], + [ + "SCALE", + 34, + "-1" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "ADD", + 34, + 2, + "-1" + ], + [ + "ADD", + 2, + 34, + "1" + ], + [ + "ADD", + 34, + 2, + "-1" + ], + [ + "ADD", + 21, + 1, + 1 + ], + [ + "ADD", + 0, + 20, + -1 + ], + [ + "IDLE", + 20, + 21, + [ + 10, + 11, + 12, + 13, + 14 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 1, + 23 + ], + [ + "SWAP", + 0, + 22 + ], + [ + "SWAP", + 22, + 23 + ], + [ + "ADD", + 1, + 22, + 1 + ], + [ + "ADD", + 23, + 0, + -1 + ], + [ + "QUERY", + 22, + 23, + 1 + ], + [ + "ADD", + 23, + 0, + 1 + ], + [ + "ADD", + 1, + 22, + -1 + ], + [ + "IDLE", + 22, + 23, + [ + 10, + 11 + ] + ], + [ + "SCALE", + 0, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 10, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "SCALE", + 0, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 11, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "ADD", + 1, + 22, + 1 + ], + [ + "SCALE", + 22, + -1 + ], + [ + "ADD", + 22, + 1, + 1 + ], + [ + "SWAP", + 0, + 23 + ], + [ + "SCALE", + 23, + -1 + ], + [ + "ADD", + 23, + 0, + 1 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 25 + ], + [ + "SWAP", + 1, + 24 + ], + [ + "SWAP", + 24, + 25 + ], + [ + "ADD", + 0, + 24, + 1 + ], + [ + "ADD", + 25, + 1, + -1 + ], + [ + "QUERY", + 24, + 25, + -1 + ], + [ + "ADD", + 25, + 1, + 1 + ], + [ + "ADD", + 0, + 24, + -1 + ], + [ + "IDLE", + 24, + 25, + [ + 12, + 13, + 14 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 12, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 27 + ], + [ + "SWAP", + 1, + 26 + ], + [ + "SWAP", + 26, + 27 + ], + [ + "ADD", + 0, + 26, + 1 + ], + [ + "ADD", + 27, + 1, + -1 + ], + [ + "QUERY", + 26, + 27, + -1 + ], + [ + "ADD", + 27, + 1, + 1 + ], + [ + "ADD", + 0, + 26, + -1 + ], + [ + "IDLE", + 26, + 27, + [ + 13, + 14 + ] + ], + [ + "SCALE", + 1, + -1 + ], + [ + "Q_POWER", + 1, + -2 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "LOCAL", + 13, + 1, + 0 + ], + [ + "SWAP", + 1, + 0 + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "SCALE", + 1, + -1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LOCAL", + 14, + 0, + 1 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "ADD", + 0, + 26, + 1 + ], + [ + "SCALE", + 26, + -1 + ], + [ + "ADD", + 26, + 0, + 1 + ], + [ + "SWAP", + 1, + 27 + ], + [ + "SCALE", + 27, + -1 + ], + [ + "ADD", + 27, + 1, + 1 + ], + [ + "ADD", + 0, + 24, + 1 + ], + [ + "SCALE", + 24, + -1 + ], + [ + "ADD", + 24, + 0, + 1 + ], + [ + "SWAP", + 1, + 25 + ], + [ + "SCALE", + 25, + -1 + ], + [ + "ADD", + 25, + 1, + 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, + 12, + 13, + 14 + ] + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + -1 + ], + [ + "ADD", + 34, + 5, + "1" + ], + [ + "ADD", + 3, + 5, + "1" + ], + [ + "ADD", + 1, + 5, + "1/2" + ], + [ + "SCALE", + 5, + "-1/2" + ], + [ + "ADD", + 5, + 34, + "1/2" + ], + [ + "ADD", + 3, + 34, + "-1" + ], + [ + "ADD", + 2, + 34, + "-1" + ], + [ + "ADD", + 1, + 34, + "-3/2" + ], + [ + "ADD", + 34, + 3, + "1" + ], + [ + "ADD", + 2, + 3, + "1/2" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "ADD", + 5, + 1, + "2" + ], + [ + "ADD", + 34, + 1, + "2" + ], + [ + "ADD", + 3, + 1, + "-2" + ], + [ + "ADD", + 2, + 1, + "1" + ], + [ + "SCALE", + 1, + "-2" + ], + [ + "SWAP", + 0, + 5 + ], + [ + "ADD", + 2, + 5, + "1" + ], + [ + "ADD", + 2, + 34, + "1" + ], + [ + "ADD", + 2, + 3, + "3/2" + ], + [ + "ADD", + 0, + 3, + "-1/2" + ], + [ + "ADD", + 5, + 2, + "-2" + ], + [ + "ADD", + 34, + 2, + "2" + ], + [ + "ADD", + 3, + 2, + "-2" + ], + [ + "ADD", + 1, + 2, + "-2" + ], + [ + "ADD", + 0, + 2, + "3" + ], + [ + "SCALE", + 2, + "2" + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "ADD", + 34, + 0, + "-2" + ], + [ + "ADD", + 3, + 0, + "2" + ], + [ + "ADD", + 2, + 0, + "2" + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "SWAP", + 0, + 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 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + -1 + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 0, + 5, + "2" + ], + [ + "SCALE", + 5, + "-1" + ], + [ + "ADD", + 5, + 34, + "-2" + ], + [ + "ADD", + 1, + 34, + "1" + ], + [ + "ADD", + 0, + 34, + "2" + ], + [ + "ADD", + 5, + 3, + "-2" + ], + [ + "ADD", + 34, + 3, + "1" + ], + [ + "ADD", + 2, + 3, + "-3/2" + ], + [ + "ADD", + 1, + 3, + "1/2" + ], + [ + "ADD", + 0, + 3, + "2" + ], + [ + "SCALE", + 3, + "1/2" + ], + [ + "ADD", + 5, + 2, + "1" + ], + [ + "ADD", + 34, + 2, + "1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "ADD", + 0, + 2, + "-1" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 5, + 1, + "2" + ], + [ + "ADD", + 0, + 1, + "-2" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "ADD", + 5, + 0, + "1" + ], + [ + "ADD", + 34, + 0, + "-1" + ], + [ + "ADD", + 3, + 0, + "1" + ], + [ + "ADD", + 2, + 0, + "-1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 2, + 5, + "1" + ], + [ + "SCALE", + 5, + "-1" + ], + [ + "ADD", + 3, + 34, + "1" + ], + [ + "ADD", + 2, + 34, + "-1/2" + ], + [ + "ADD", + 1, + 34, + "1/2" + ], + [ + "SCALE", + 34, + "-1/2" + ], + [ + "SWAP", + 34, + 5 + ], + [ + "ADD", + 5, + 3, + "1/2" + ], + [ + "ADD", + 2, + 3, + "3/2" + ], + [ + "ADD", + 1, + 3, + "-1/2" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 5, + 2, + "1" + ], + [ + "ADD", + 34, + 2, + "2" + ], + [ + "ADD", + 1, + 2, + "1" + ], + [ + "ADD", + 0, + 2, + "-2" + ], + [ + "SCALE", + 2, + "2" + ], + [ + "ADD", + 5, + 1, + "-1" + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LAMBDA", + 2, + -1 + ], + [ + "LAMBDA", + 3, + -1 + ], + [ + "LAMBDA", + 34, + -1 + ], + [ + "LAMBDA", + 5, + -1 + ], + [ + "LAMBDA", + 34, + 1 + ], + [ + "LAMBDA", + 20, + 1 + ], + [ + "Q_POWER", + 21, + -2 + ], + [ + "LAMBDA", + 21, + 1 + ], + [ + "SCALE", + 34, + "-1" + ], + [ + "LAMBDA", + 34, + -1 + ], + [ + "ADD", + 21, + 34, + "1" + ], + [ + "LAMBDA", + 34, + 1 + ], + [ + "ADD", + 34, + 20, + "1" + ], + [ + "LAMBDA", + 4, + -1 + ], + [ + "LAMBDA", + 20, + -1 + ], + [ + "LAMBDA", + 21, + -1 + ] + ], + "diagonal": [ + [ + -1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 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, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ] + ] +} diff --git a/research/p104-helper-split-on-retirement-tree/NOTICE b/research/p104-helper-split-on-retirement-tree/NOTICE new file mode 100644 index 0000000000..ab5a95e5cb --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/NOTICE @@ -0,0 +1,31 @@ +Paid-job merges in the PR6529 native word, price and integration: +DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. Apache-2.0. +No independent scientific acceptance is claimed. + +Caller, retirement-aware tree allocation, proof and checks (PR6551): +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +The executable source is retained in source.tar from original head +775722aa94a5e85b05d1d704d7dca10cbf016f0c (PR6545), with the PR6529 layer +edited as described in README.md. +RETAINED.json binds original paths, Git blobs and SHA256 values. Original +source headers and notices remain; the PR6529 verifier, pricing and word are +edited as described in README.md. ADAPTERS.json records +all changes to the source drivers, constructor and price. Runtime driver +and constructor copies are created in a private temporary directory. + +PR6545: independent Gaussian retirement, exact dual pairs and complete caller. +PR5599/5602/5611/5615: causal handoff, productive helper and basis methods. +PR6348/6398: binary query suppliers and the six-field mixed root. +PR6529: scaled transport fusion and the complete native word. +PR6524: explicit complete replay interfaces. + +Credit Rohan Arun's PR6399/6417, Erwan L.'s PR6453, DreamingOfClouds' PR6375, +PR6353/6372 and all retained native predecessors. Native work retains +Cinna Davis, David Arias, Gareth Davidson and their predecessors. Productive +recursion retains Jacob Alan Sussman's credit. Price and interval work +retains zxv, Cao Yifan, ywz65 and Nick Petalas's credit. + +Other retained contributors include Mason Hale, Pierre-Loic Doulcet and +Chris R / Clear1nsight. The source archive and its nested notices retain +the complete native, helper, compiler and analytic source attribution. diff --git a/research/p104-helper-split-on-retirement-tree/PROOF.md b/research/p104-helper-split-on-retirement-tree/PROOF.md new file mode 100644 index 0000000000..07eecf1bb4 --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/PROOF.md @@ -0,0 +1,140 @@ +# Splitting a public helper register: exact invoice delta + +## 1. Source and what changes + +The comparison is PR6621: the PR6551 caller (the PR6545 Gaussian retirement +and the PR6398 mixed root with child trees `(7,2,5,4)`) with the PR6621 +native word, itself the PR6529 word with three compensated rewrites. The +caller, the trees, the dual pairs and the retirement proof of PR6551 are +unchanged and retained in `source.tar`. In particular the unchanged prefix +through event 328 and the equal-target argument of PR6551 section 2 apply +without modification, because the caller sees the native word only through +its public boundary. + +Only the native word changes, by one exact rewrite with its own +compensation (README.md gives the events). + +- Public helper register 607 is cut at frame 115: `final[607]` changes from + 127 to 115. +- Its tail, the frames 115 to 127, moves to a new public register 770 with + `initial[770] = 115` and `final[770] = 127`. The verifier requires every + other initial and final frame to be unchanged apart from the shift of the + owned registers by one place, and the other fields of the word to be equal. +- Three compensating ADDs are placed in frame 3 at the start and three in + frame 127 at the end. + +The verifier regenerates the PR6529 word from its retained construction and +compares it with `BASEWORD.json.gz` before it substitutes `WORD.json.gz`. The +edited word is then replayed against all 800 columns, the owned lifetimes (47 +lifetimes, peak 14), the helper maps, the absolute phases and the 7,488 +caller contacts. + +## 2. Exact profile delta + +Let H_r denote one Gaussian target or paid job of rank r. The native word is +called 18 times. From the replay in RESULT.json the edited word's local +profile differs from the PR6621 word's as follows, per call. + +```text +paid {2:+1, 4:+1, 6:-1} +targets {4:+1, 5:+1, 9:-1} +``` + +One rank-9 helper target is replaced by two targets of ranks 4 and 5, and +one rank-6 paid job by two paid jobs of ranks 2 and 4. Each replacement +preserves the rank mass (9 = 4 + 5 and 6 = 2 + 4). The complete invoice +changes by 18 times these counts: + +```text +Delta T = 18 H4 + 18 H5 - 18 H9, +Delta P = 18 H2 + 18 H4 - 18 H6. +``` + +The caller side of the invoice is identical, so these are the only changes +against PR6621. The checks in `pricing.py` confirm that the complete profile +is exactly the PR6621 profile plus this delta: productive fields rise from +13,756 to 13,774, paid jobs from 67,042 to 67,060, and the target minus paid +rank mass stays 760 (each of the two masses is unchanged per call). + +## 3. Why the gain is positive + +The signed gain is `Delta(T-P) = Delta T - Delta P`: + +```text +Delta(T-P) = 18 * [ (H5 + H6) - (H2 + H9) ]. +``` + +Take `H_r = r^t` with `0 < t < 1`. Then `f(x) = x^t` has the strictly +decreasing derivative `f'(x) = t x^(t-1)`. Hence + +```text +(H6 - H2) - (H9 - H5) = integral over [2,6] of ( f'(x) - f'(x+3) ) dx > 0, +``` + +which is `(H5 + H6) - (H2 + H9) > 0`. This is an exact all-exponent +comparison. It does not depend on the tested saving. + +Equivalently, the pair of ranks `{2, 9}` has the same sum 11 as `{5, 6}` and +majorizes it, so every strictly concave sum is larger on `{5, 6}`: the +gaining side holds two jobs of middle rank instead of one short and one long. + +## 4. Costs that are charged + +The new word has 18,577 events (16 more than before). The owned inventory +has 29 labels and 47 lifetimes with peak 14, there are 771 public registers, +and the local scalar allowance is 137,990 (was 137,866). The rank mass of +local paid and target jobs is 5,924, as before. The full ordinary-work upper +bound stays below the retained 10^9 allowance. The edit adds no unpaid +channel, helper, copy or restoration. The erasure obligations are those of +PR6621 (one shadow register, erased in frame 127 while nonzero, covered by +the same `owned_erasure` assumption), renumbered by the shift. + +### Declared package-local bounds + +Two inventory literals of the retained local and forward replay sources +bound the word. They are verifier literals from earlier packages, not SPEC. +They are changed by exact text replacement, each required to occur exactly +once in each unpacked source: + +```text +767 <= public <= 770 becomes 767 <= public <= 771 +0 < peak <= 13 becomes 0 < peak <= 14 +``` + +The edit needs the first because it adds a public register to the 770 of the +base word, and the second because the owned peak of the edited word is 14. +The retained sources are not otherwise changed. + +## 5. Conditional numerical result + +The new claimed saving is 0.00329760. The tested saving is 0.003297605. Two +rational engines certify a positive complete moment at the tested saving and +both signs of the raw root enclosure in RESULT.json. The raw crossing is +0.0032976213479979, above PR6621's 0.0032970138574525 by 6.075e-7. A +negative derivative bound gives a unique crossing below the retained BIT +cap. Both engines reject the full PR6621 invoice at the new claim. + +The retained completion tails, the integer compiler threshold and all 54 +strict plus four functional outer predicates are evaluated with the new +profiles. The completion ratio `delta` is enclosed in +`(0.970282747194658038492971336484, 0.970282747194658038492971336485)`. +As in PR6551 and PR6621, the source tail decay 31/32 is below it, and the +decay 97/100 of PR6621 is now below it as well, so the decay of this package +is 33/34 = 0.970588..., with reserve 10^(-27) at power 1920. The strict +checks are: + +- `delta` upper bound 0.970283 is below 33/34 (the charged ratio test); +- `delta` lower bound exceeds 31/32, so the source decay still does not fund + the tree; +- `gamma`, enclosed near 0.9206, and `alpha`, below 1 minus the reserve, are + also below the decay; +- `(33/34)^128 < 1/16` (about 0.0219), the block estimate used for power + 1920 = 15 * 128. + +The tail decay enters only these tail estimates. It does not enter the +crossing, so the claimed κ does not depend on it. The conditional bound has +the same form `O(n (log n)^(1-kappa))` with `kappa = 0.00329760` under the +five source framework assumptions. + +No global optimum over words or callers, unconditional multiplication +theorem, independent review or selected-frontier change is claimed. diff --git a/research/p104-helper-split-on-retirement-tree/README.md b/research/p104-helper-split-on-retirement-tree/README.md new file mode 100644 index 0000000000..e96c4ce269 --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/README.md @@ -0,0 +1,176 @@ +# Split a public helper register of the native word under the rebalanced retirement + +The complete conditional bound is **κ = 0.00329760**. The increment over +[PR6621](https://github.com/CrocSwap/integer-mult-bounds/pull/6621), +κ = 0.00329700, is **0.00000060**. The exact raw crossings are +0.0032976213479979 here and 0.0032970138574525 in PR6621, a difference of +6.075e-7 (0.01843%). This comparison excludes all inherited gains. The +selected frontier is unchanged. + +Keep the PR6621 package: the PR6551 caller with the PR6545 retirement +identity and the child trees `(7,2,5,4)`, and the PR6621 native word. The +caller, trees and root are unchanged. Only the native word changes, by one +exact rewrite. Public helper register 607 is cut at frame 115. Its tail, the +part of its life from frame 115 to frame 127, moves to a new public register +770. Three compensating ADDs at the start of the program and three at the end +keep the arbitrary-input identity. One long helper thus becomes two shorter +ones. Per native call the paid and target profile changes by + +```text +paid {2:+1, 4:+1, 6:-1} +targets {4:+1, 5:+1, 9:-1} +``` + +The complete signed invoice (targets minus paid jobs) improves by + +```text +18 * (H5 + H6 - H2 - H9). +``` + +For `H_r = r^t`, with `0 < t < 1`, this is positive by concavity: see +PROOF.md. The construction and its complete invoice change; the old invoice +is not priced more finely. No optimum over all words or callers is claimed. + +## The edit to the PR6621 word + +- **Cut.** Register 607 keeps its life through frame 115 (`final[607]` changes + from 127 to 115). A new public register 770 starts at frame 115 and ends at + frame 127 (`initial[770] = 115`, `final[770] = 127`). The owned registers, + numbered from 770, shift up by one. The tail additions of frames 115 to 127 go to + register 770 instead of 607. +- **Start.** Three ADDs in frame 3, at the start of the program, add + `-r607/2`, `-r607` and `r607/4` to registers 173, 611 and 704. +- **End.** Three ADDs in frame 127, at the end of the program, add `r770/2`, + `r770` and `-r770/4` to the same registers. With the start ADDs they + compensate the cut; the verifier replays the edited word against all 800 + independent columns. +- **Frame 115.** An owned scratch register (795) is created and cleared in + frame 115, and the existing move of register 3 into register 611 follows + the cut. + +The new word has 18,577 events (PR6621: 18,561), one more public register +and one more owned lifetime. The erasure obligation list is unchanged: it +holds the one shadow register of PR6621, renumbered by the shift. + +### Declared package-local bounds + +The new public register and the longer owned peak need two inventory +literals to move. These are verifier literals inherited from earlier +packages. They are not part of SPEC. The verifier changes each by an exact, +counted text replacement in the unpacked retained source, in two places (the +local replay and the forward replay): + +| Literal | Before | After | +|---|---|---| +| public registers, `767 <= public <= 770` | 770 | 771 | +| owned peak, `0 < peak <= 13` | 13 | 14 | + +The tail decay of the outer completion test also changes, from 97/100 to +33/34. The new delta ratio is above 97/100, so the old value no longer +suffices. The check keeps all charged ratios strict: the upper bound of delta +is 0.970283, below 33/34 = 0.970588; its lower bound still exceeds 31/32; +and `(33/34)^128 < 1/16`. See PROOF.md section 5. + +| Complete inventory | PR6621 | This package | +|---|---:|---:| +| Native calls / thin queries | 18 / 17 | 18 / 17 | +| Native program events | 18,561 | 18,577 | +| Public registers | 770 | 771 | +| Owned lifetimes (peak) | 46 (13) | 47 (14) | +| Local scalar allowance | 137,866 | 137,990 | +| Native columns | 799 | 800 | +| Independent caller fields per port | 35 | 35 | +| Productive fields, including native helpers | 13,756 | 13,774 | +| Paid Gaussian jobs | 67,042 | 67,060 | +| Caller events | 611 | 611 | +| Rank-mass surplus | 760 | 760 | + +Read [PROOF.md](PROOF.md) for the exact delta. [ROOT.json](ROOT.json) gives +the unchanged trees. [CONTROLLER.json](CONTROLLER.json) contains every caller +event. [WITNESS.json](WITNESS.json) contains the unchanged retirement bases +and cut. [RESULT.json](RESULT.json) records both rational price engines, the +compiler, the physical maps and all outer inequalities. + +## Verification + +Use CPython 3.12 with its standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/p104-helper-split-on-retirement-tree +``` + +The registered hook runs normal and optimized checks. A direct run is +`python3.12 -I -B research/p104-helper-split-on-retirement-tree/verify.py`. +The result marker is `PASS_HELPER_SPLIT_KAPPA_00329760`. +See [VALIDATION.md](VALIDATION.md) for checks that have run and their limits. + +The two rational engines enclose the raw crossing in +`(0.00329762134799792561521137, 0.00329762134799792561521138)`. The claimed +saving is 0.00329760 and the tested saving 0.003297605, both below the raw +crossing. As in PR6551 and PR6621, the old completion decay does not +suffice; the check uses decay 33/34 and reserve 10^(-27) with power 1920 and +the full tail and compiler tests. + +The verifier first regenerates the PR6529 word from its retained +construction and compares it with the base word. It then substitutes the +edited word and checks the declared public boundaries, its 800 columns, owned +lifetimes, helper maps, absolute phases and all 7,488 caller contacts, with +the base-word local profile replaced by the new one. The correction-drop +controls run on the edited word and must be rejected. It then replays the +PR6551 caller: full forward and reverse polynomial checks, the same two dual +pairs, physical target checks and a separate invoice count. Both rational +engines reject PR6621's claim at the new claim. Deletion, sign, target and +unpaid-job controls must fail. + +[source.tar](source.tar) retains the PR6545 package with its nested PR6529 +and PR6524 source archives. The PR6529 layer has the edited verifier, the +edited word `WORD.json.gz`, the base word `BASEWORD.json.gz` and the edited +pricing. The word retained here is the complete edited word, which contains +the PR6621 rewrites and this cut. [RETAINED.json](RETAINED.json) binds all +outer source files by path, Git blob and SHA256, and each nested manifest is +regenerated for the edited files. Replay needs neither network access nor +side branch Git objects. + +[ADAPTERS.json](ADAPTERS.json) declares each driver, constructor and price +edit inherited from PR6621, with the new claim constants and tail decay. + +## Scope and coordination + +This contribution is a further κ improvement on the PR6621 construction. +The task and changed premise are in [TASK.json](TASK.json). The caller, the +trees, the retirement identity and the root are PR6551's and are not claimed +here. Only the native word and its price change. + +The five inherited assumptions remain: `native_all_columns`, `owned_erasure`, +`compiler`, `precision_tape` and `analytic_recovery`. This is an +author-checked conditional construction. It is not independent scientific +acceptance, a materialized uniform word or a complete rounded integer +multiplier. No PR merge, closure or selected-result change is included. + +## Open next questions + +- Can an independent reviewer confirm the cut, its six compensating ADDs, the + two declared package-local bounds and the complete invoice delta? Start + with the delta in PROOF.md, then compare `BASEWORD.json.gz` with + `WORD.json.gz` in the PR6529 layer. +- Can other long public helpers be cut in the same way, or the native word be + rebuilt for the new profile? An edited word must supply its full + arbitrary-input endpoint and every paid job. + +The structured questions are in [TASK.json](TASK.json). + +## Credit + +Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude +Code. Apache-2.0. + +The base is PR6621 (DreamingOfClouds), which merged paid jobs in the native +word under PR6551. Its lineage is credited as PR6621 credits it: the caller, +trees and package it extends are PR6551 (Ali Romman). Credit PR6545 for +independent Gaussian retirement, PR6529 for the native word and its scaled +transport fusions, PR6453 (Erwan L.) for the underlying compensated native +word, PR6398 and PR6399 for the binary suppliers and mixed root, and PR6524 +for explicit replay services. PR5599/5602/5611/5615, PR6348, Rohan Arun's +PR6417, DreamingOfClouds' PR6375 and all retained predecessors keep their +credit. See [NOTICE](NOTICE) and the original archived notices for the +native, interval, compiler and analytic contributors. diff --git a/research/p104-helper-split-on-retirement-tree/RESULT.json b/research/p104-helper-split-on-retirement-tree/RESULT.json new file mode 100644 index 0000000000..eed7b8fc8d --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/RESULT.json @@ -0,0 +1,356 @@ +{ + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "candidate": { + "caller": { + "coefficients": 1225, + "event_sha256": "5f0fd5f0f8fabcc568a32c60093a0496e90409e855a47a33e33d7a74c2194d47", + "events": 611, + "inputs": 35, + "native_stages": 18 + }, + "changes": { + "gain_formula": "208*(H41-H40-H57+H56)", + "paid": { + "16": -104, + "40": 312, + "56": -208 + }, + "rank_mass_change": -832, + "signed": { + "40": -208, + "41": 208, + "56": 208, + "57": -208 + }, + "targets": { + "16": -104, + "40": 104, + "41": 208, + "57": -208 + } + }, + "child_sizes": [ + 7, + 2, + 5, + 4 + ], + "complete_cost": { + "compiler": { + "H": 138100200000000, + "N": "2^138100200000000", + "eta": { + "lower": "0.000000000000020609937477408384", + "upper": "0.000000000000020609937477408385" + }, + "gap": "1/1400000000", + "integer_test_exponent": 98643, + "logarithm_power": 2100, + "theta": "63/64", + "uniform_saving": "2308323/700000000", + "word_materialized": false + }, + "derivative_upper": "-709194778809244132783181370602332732873303501116392636897858347/3138550867693340381917894711603833208051177722232017256448", + "full_forward_calls": 18, + "gain": "3/5000000", + "kappa": "2061/625000", + "kappa_decimal": "0.00329760", + "margin_at_previous": { + "lower": "0.142252610585421995157617933902", + "upper": "0.142252610585421995157617933903" + }, + "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.", + "old_tail_decay": "The source tail decay 31/32 is below the new completion ratio." + }, + "nonrecursive": { + "local_routes": 5392000, + "local_scalar": 137990, + "paid_rank_mass": 184112, + "peak_owned_fields": 14, + "raw_budget": 1000000000, + "raw_scalar_upper": 254932208, + "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": "6463301595383357/1960000000000000000", + "fused_gaussian": "6463301586150071/1960000000000000000", + "global_coordinate_router": "1154161/350000000", + "group_bit_router": "1615825746537517/490000000000000000", + "group_scans": "699999999/700000000", + "main_transform": "6463300195383357/1960000000000000000", + "microbox_face_corrections": "26950000001/350000000", + "polynomial_products": "1399999999/1400000000", + "sparse_union_movement": "802713301595383357/1960000000000000000" + }, + "parameters": { + "a": "1154161/350000000", + "b": "923329/280000000", + "beta": "1399999997/1400000000", + "bit_saving": "17/5000", + "cap_xi": "1782713300195383357/1960000000000000000", + "complex_uniform_saving": "2308323/700000000", + "d": "1/1400000000", + "epsilon": "1399999999/1400000000", + "kappa": "2061/625000", + "lambda_": "398680959/400000000", + "lambda_prime": "1395383357/1400000000", + "layout": "1/1400000000", + "q": "4616643/1400000000", + "r0": "1/14000000000", + "stop": "1/1400000000", + "tested_saving": "659521/200000000" + }, + "strict_checks": { + "actual_bit_above_effective": "35839/350000000", + "actual_logarithmic_gamma_guard": "1/1400000000", + "actual_logarithmic_group_guard": "177286701904616643/980000000000000000", + "alpha_logarithm_absorption": "1/14000000000", + "boundary_algebraic_matrix_above_kappa": "5595383357/1960000000000000000", + "cap_above_band": "802713300195383357/1960000000000000000", + "cap_below_cell": "177286698404616643/1960000000000000000", + "cap_below_phase_cell_power": "2137286699804616643/1960000000000000000", + "complex_above_effective": "1/1400000000", + "complex_below_one_over_32": "7826671/280000000", + "complex_endpoint": "1/700000000", + "epsilon_below_one": "1/1400000000", + "epsilon_positive": "1399999999/1400000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "5586150071/1960000000000000000", + "gaussian_above_main": "695383357/980000000000000000", + "global_coordinate_router_above_kappa": "1/350000000", + "global_gamma_power_slack": "9/14000000000", + "group_below_dimension": "1/700000000", + "group_bit_router_above_kappa": "1746537517/490000000000000000", + "group_gauge_power_slack": "177286701834616643/980000000000000000", + "group_key_fits_record": "1/700000000", + "group_positive": "1399999997/1400000000", + "group_scans_above_kappa": "697691679/700000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "783314790400418148631/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": "559076671/392000000000000000", + "leaf_saving_above_effective": "279076671/392000000000000000", + "main_transform_above_kappa": "4195383357/1960000000000000000", + "membership_arithmetic_fits_record": "1/1400000000", + "microbox_face_corrections_above_kappa": "26948845841/350000000", + "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": "1395383359/1400000000", + "positive_layout_slack": "1/1400000000", + "q_below_effective": "1/1400000000", + "q_below_internal": "1/1400000000", + "q_below_leaf": "559076671/392000000000000000", + "q_positive": "4616643/1400000000", + "short_record_fallback": "279076671/280000000", + "source_axis_superpolynomial": "1/1400000000", + "sparse_union_movement_above_kappa": "796250005595383357/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": 1768, + "2": 8172, + "24": 416, + "3": 8820, + "32": 416, + "4": 1962, + "40": 312, + "5": 2736, + "56": 208, + "6": 144, + "7": 162, + "8": 18 + }, + "paid_calls": 67060, + "previous_fixed_root": "3297/1000000", + "productive_fields": 13774, + "rank_mass_surplus": 760, + "raw_endpoint_margins": { + "lower": { + "first": { + "lower": "0.000000000000000000000142008392", + "upper": "0.000000000000000000000142008393" + }, + "second": { + "lower": "0.000000000000000000000142008392", + "upper": "0.000000000000000000000142008393" + } + }, + "upper": { + "first": { + "lower": "-0.000000000000000000002147408055", + "upper": "-0.000000000000000000002147408054" + }, + "second": { + "lower": "-0.000000000000000000002147408055", + "upper": "-0.000000000000000000002147408054" + } + } + }, + "raw_headroom": [ + "2134799792561521137/100000000000000000000000000", + "1067399896280760569/50000000000000000000000000" + ], + "raw_root_interval": [ + "329762134799792561521137/100000000000000000000000000", + "164881067399896280760569/50000000000000000000000000" + ], + "refinement_kind": "Cut one public helper register of the native word in two and hand its tail to a new public register, under the rebalanced retirement caller.", + "relative_gain_percent": "20/1099", + "strictification": { + "alpha": { + "lower": "0.999999979552369986484943071971", + "upper": "0.999999979552369986484943071972" + }, + "coarse_tail_upper": "1/288230376151711744", + "cutoff": 12, + "delta": { + "lower": "0.970282747194658038492971336484", + "upper": "0.970282747194658038492971336485" + }, + "exact_tail_upper": "352179899788724620129627904923511615566683157714090403522562598009296248858581691186280210885470166925031817304177954077695188042222749926825489930992150381962319864381218203218534231894097364163053899346004728659092862203863172568317511434802735896051702758840491954139580270606814045535791572422922577909751902024280403153080401804813962119482388554139573122797275506022815932622589346038876772914109815154083542641530277891043447552727299412147665117083205645765918788557531363198034852502245756250654969647785513874920978343088309200427540396611019256045168407246051810635818268187714364601331421384676018058794291946836316706095038865708723120769713436485054370226587544393021972104395240129661254786712457295752138578549617351522111156750971091435691572971829443929913332609452899772808838090546515390902198962565413078048192384476120050317277612755687256012485542619418075653282082117134800721379107774559213272428312499189733458253219289680148472961146758117442913951218567420696829559547185713522381710892000178039811210792133563210695052408878703068838721503612017530019699716305847402438195125610108870582653715340404641227330210149665684173815919963148008424839863205566688745205742793738759421246133709520348156002451745959337967096202339062259613306089988038174840514901641355788600844939298472289931683335707718591917193092392208618702256172220282635390699863266191592509033203621192871168394914003059950547100202387463495609704782297086541740192388294119621736623831765127986331584009376322001226813984818780966941998102989373043494032498406335312251237557853372884156122036750652618710053612778692037445591362705053200859016207451692255853517561942615887463166931571260423753913367897314080469738368191957751590192321600585728553196067701896789125408206719453519567048109057718818309936543189421136748812513967291393193102861176994575699876705411983773729742184590591835220562837229954312807698958719720540515403903593589983852278204277058536261199052779331423844558853445886378748628591313226736570259038764609079527637533262205492201049552954554125880936466240547653285159114290276211171291015784491249601233506434883719834415463918721834233838850959673002444979187390754459194968448846797618610381758879684202913971900910081491166255975296728762011446087567592906049267284074773879625620043105423844207763946766423346978524012472036986850560593001040092290495442247541398577990852559264676044666963824905798365923052387678593052704257299897443827124207197600817235797504195262511851529836898202130950978777528358340607627952060625211724006272132218215705856260861645754196133432499233487707627741403103586283369809102567721543949083235164394534983864808827933393327770044458138039899503259517775264902276997543291495316575773246895465933259820701231567768841976168065406963179714611864772310553920224121262321047830594726871731240181883170089071818115088260785668417514399326725172715569491865601/687797716782660529910014054369194812144598851784747293640396216729388895999305939788606725860063062604698588486469601165489654330831447201346340171172419615799180705729739454278113010230442532344331662079178771142453631236621745063148322952742835187498690207520528976061773068737767739418846246111109352463885340395153052244606226202613454552545704398654492816329011712358949360672742304089064892177906204366349169299628231937326341431545629807600258975673328951049098758302988055725887061539767522526926675317304892966038402997332741389617943753109297286754583363331646230170557908516089225916475901578864442836502229369775445591507032646522998292357314193406724177526187276360166914965513569419053349072936969417171461690363705488473263925383525527229173892803529098811554000732575674495150604894930105394045282517068155397926687667207286509083822634071635349647406380260028212322883348002546006887810882646331168551617183590191986005626843044878413415897297880224866715225705352399860646341191243462738385112910807222561215529605461945087790900148955134765499125814991131410034957571533360965625894099717141804362118949807020947581811485842630932914243217001763491029842195164203248031130866709248476167404010283471051494974325320122324711564951515143402365647877201887222562070242221348800137638996513234299138706759272399667498230936853983706104947176622147853632005373123167127209858314336741871385578482926351861712294722706720160652221294568601876725646947581405193485853770453102646702732546074044836856809843689809216831006945414556516990739247663089405698871421167329151774251051839798996924995468400721734658446139981327793243635333016019883776278129077986880653249668974366610095004662043597384844208059079203416481510446024932724352686591274810417583328930411676945012683875522038751010322221370257105263613525959623907568749083593330678651183517044755154758340096150041798064564094812347057312024438352000137708360919849403866209902409868555655930618461856147856919898637337494782850239140366565720422225233139415352165457490893471910077640123931098478114122723293537832297800796940701885833871535892122175277368012626311594220832732003723165217867857402773258593878363559726456635834292536152702455259326642610660754047346249540062754111135661455479912142417120926079910997321024493845336377817389668901993267004916983454962935393517910414812243527689897882807998814235758183996935650232827466191176018508406633543247273890422044969779476441886699900963411067558329504352965513562763797585916575730976354720220340382855577995868549072267112855798466185886327850232041130793760523560135191320218817625607972554336488662738196256399483064581364878300538656613629344157828703990195119186900298741776826238595102867633660831151736069622013874974635480336588588656487945212379086451870383856606916525882136608770599690348389083207026112636522000587990729213051618153605266038013910629831872865188143291559126530015729939113836544", + "floor": 13, + "gamma": { + "lower": "0.920633033824571104436939136149", + "upper": "0.920633033824571104436939136150" + }, + "normalized_paid_upper": "1074683932472907077984397510232960313858154658458325628999384585442492961979941569770457448154879648064301710866966149114789150327697514662813313416963317074645514379763820636671191644390331022234437202104341124030358958188594807489240076538747035214711855631339721990982947518393275315415033810330936294648288469904177295760545654565537810393751357544754720753402733701252215424548606107240589220340291886486665589293695238496526354780442054284176938850338628250344139124248294622238701941140436870442327544050043686384101740421316587643650203947013902994980518714862329874388349230233308358640280772451155240457467578402527502097571098470077346027707184754872617073105052772108290429128194600622618112332750590942572874120082959980267185216517271384432833332691453056021032346467298593352431873912217566667267137278518249286019106464015690693173046862210237574649347329136708589669271110913590311441214774156183215512886230741490722128914084829024938269621734098323779305269722815291351476281704812108423761852071651819583232345992048046628593025828326405912460901331062465333529566955655311059794486295795356961713213221343413095540608274232855637437587270880456774732781165455124508097854140098008450469409374477171152767325679076010670715745446774506157658918942760232947393253277275524395131726307135302325292613114707863679033862924455364118917175250956107934133098273555969309734198039975802295980990522842977541629120279623830480411132081221011847537544425611309254626530375870408709381819826340652767766126382730551423296870653066090589171419887349293559254323397900556553855160780188852176085655919253563845972098946832063009759740674430165455884396995009515418377967538496215412233124022409012046599315055463282178600324587151419421838751600783802993493728191391871587760853321139168135802858484771073354280208104146462233373869769589062068914844373015896955905832805471371824284058834593555329966016668375622613526699474799978229028006933676640674252100277456471421052085298914912400521679589554751044515531715784044091235640879687043814971939135785697871365692146524662267055922050659678346129996195270199786826189117830679506580499474316685123206084242214799290075105584594780459374313567870420412193064209024615418111650320613989502906406095407950504641691526635150316702354201458782225627896227937523364461369388932251802456567448641778705809926437491858221285589371285234298657772268348473109486150927306963975089122809441649394238268172723351325234531692038559690097470524275673677456904617914661328273517914748925757794033943047819894934438990914943478446744381345889955697961978746816052979790126118062964985673015959365993271043556636832228330865874138088514618281514061600484772883137042271937058072019373831421355331813432711903850819382695970272199042557809598761895575112799989335849135992913122814668983380289403900867634302536580085701535804837003112344173232752066357658254478973643474764428476014303112448952799542675518146708475596803/1074683932472907077984399023345017241957525435955830753897555522436225504240796452108348197323036533237660910330286332010265398987689595660907152986419898144027823891723231414568398976027183646006381056337747521237680831802207714197482681974554389845701892894219684753602082915973384654428875444867814576528039100906164977460254620097604708197509396941576252865877738437674054339529608837174300970876060462549332844225345646120685507534297945459071216628513871122903639610625345857058551680952161662912490107844473514562002585463358360335956935229442269008778205359036956562533356995806479410433184107890701240199712482817978870330058248016880294158145077948295946096379544691255341024806147530779099938427208911255038666051240508636647726397796829727412049627297290367469634813666327901985969254810330487405219239384733677599576631615858936374909666645799931855683599720624196296660554173473118915846841472784936458499922512792322917127297597109173291538297544818380488877780412305018422934508256995026585926320862159858982287480163873021621340965129331214456927647458624089693583917702898321482184689635680748669398707736755769382021993532985960253741347771999712982626927172673718580339115068759786236621312859460523645706325885524721982774974721665387526563298942822803330683441850414489105876728618262655256450629724280114020168883254954627357987982458164916583251126710346478502708964512167278543541348009147367794151074660964699030074680909647608552544305312259829320627276693273815629688600060802006416896705488962965123432958922639775627225680567494413440074037567791694788915484365113949434682760742129283229800812868707229879108384183175951012383814307590353549080353936606835062234086744192127836918905377325241469044514604538134619411322243398229352272124511828019051013571305489976783484463508942653293090649165278576466347486233955157064264196951629680709301942353784991443741345673164580727175432378617284652210485873338008596953385640502377760603189976357460632104309412695221166647069416518670950644075477497757587455688596196749277742369190014814052469046988066524656260748087588016577228921168233831720976545021343219542336576975859855324587701189690029227722430596665644796813266863722829276765712605381956765886306344292886275885280911613062935982910789084853984227373050528022996116330072663320732846015704316238817386292532172749774094495400821645995618742583973955232188860377485235623198264519726336063393722438981839970485181061682269639861390239131489215510651211505175021108716507708476191242541737039597939033547608768586438512403919091021094604067326131662263808477046261932561234283821583137521724724191981308474541855297874370836933360849407989594341242251600649714617564190270138261583162408931573820379153303394092999580630361393234128535817387338300783332346813444239783944208950194062355631836918935588920804612793636671085985135473731062931009992156584374513966762167654587934793024698768173594295244277379590047189817341509632", + "power": 1920, + "reserve": "1/1000000000000000000000000000", + "tail_decay": "33/34", + "tail_offset": "1/7", + "tested": "659521/200000000" + }, + "targets": { + "1": 460, + "145": 104, + "17": 1768, + "2": 144, + "25": 416, + "3": 72, + "33": 416, + "4": 1944, + "40": 104, + "41": 208, + "5": 288, + "57": 208, + "6": 54, + "7": 162, + "73": 208, + "8": 720, + "9": 6498 + }, + "thin_queries": 17, + "whole_idle_jobs": 3120 + }, + "controls": { + "extra_gaussian_credit": "All main target phases and ranks", + "missing_boundary": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_cut": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_idle": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_idle_one": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_lambda": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_local": "Every native stage exactly once", + "missing_q_power": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_query": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_return": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "unearned_central_target": "Every independent reverse caller coefficient", + "unpaid_native_job": "All independent fields and paid calls", + "wrong_cut_sign": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient" + }, + "dual_pair": { + "cut_after": 328, + "cut_pairing": "1", + "input_pairing": "1", + "prefix_column": "P d = S b", + "prefix_row": "a P = S c" + }, + "internal_node_sizes": { + "2": 8, + "3": 2, + "4": 2, + "5": 1, + "7": 1 + }, + "physical": { + "central_square_columns": 53248, + "central_translations": 19, + "full_calls": 18, + "main_targets": { + "1": 208, + "145": 104, + "17": 1768, + "25": 416, + "33": 416, + "40": 104, + "41": 208, + "57": 208, + "73": 208 + }, + "new_paid_jobs": 0, + "ordinary_normalizations": 34, + "physical_contacts": 7488, + "ports": 104, + "route_payload_sha256": "79930ec6c09a8e4930556c925c354bb5431203eaf069d9373f056049c061289b", + "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.", + "whole_idle_jobs": { + "16": 1768, + "24": 416, + "32": 416, + "40": 312, + "56": 208 + } + }, + "reverse": { + "coefficients": 1225, + "rows": 35 + }, + "source_margin_first": { + "lower": "-0.219846206376178945224581646134", + "upper": "-0.219846206376178945224581646133" + }, + "source_margin_second": { + "lower": "-0.219846206376178945224581646134", + "upper": "-0.219846206376178945224581646133" + } + }, + "selected_frontier_changed": false, + "source_head": "775722aa94a5e85b05d1d704d7dca10cbf016f0c", + "source_result_sha256": "f3ec0defa39b094f4e18f9b8d6c7afdcd1453e1a88741e4d42da09bd4bf49755", + "status": "PASS_HELPER_SPLIT_KAPPA_00329760" +} diff --git a/research/p104-helper-split-on-retirement-tree/RETAINED.json b/research/p104-helper-split-on-retirement-tree/RETAINED.json new file mode 100644 index 0000000000..18af383629 --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/RETAINED.json @@ -0,0 +1,122 @@ +{ + "archive": "source.tar", + "archive_sha256": "be2180627c3a9ffc0176434b578659c5769c8546e3ee67dcee55c632646ebe93", + "source_head": "775722aa94a5e85b05d1d704d7dca10cbf016f0c", + "files": [ + { + "path": "research/gaussian-root-retirement/CONTROLLER.json", + "sha256": "e5c873568b52aab82fc01670de3037b1ba4bedbcb15366f0e5fb38cd786714ed", + "git_blob": "1214da51217560152888b37effb10002500ea1eb" + }, + { + "path": "research/gaussian-root-retirement/NOTICE", + "sha256": "9df9f97f29a84a99c318d554fc533376f6d98d4bebdf15018c9eca4b7f65ca74", + "git_blob": "6b0ca905ea6ce9ec5c89f13a0922dfe3c58ad4c2" + }, + { + "path": "research/gaussian-root-retirement/PHYSICAL-EDITS.json", + "sha256": "daf9c31f88476d70612e75a3fb58bb7fdcdc9fd01e8c9bc4b80059c23b2fc2d5", + "git_blob": "022a1d6af0dce0e39fa9b0f2feaf96391849a6d7" + }, + { + "path": "research/gaussian-root-retirement/PRICING-EDITS.json", + "sha256": "4e0a406f54bd40d0c3b50d92abc26a1772f5573aa6cc4f80ae947ae7dc0ac551", + "git_blob": "6e16b59c3d4f12dd47637bf4b68215878b585852" + }, + { + "path": "research/gaussian-root-retirement/PROOF.md", + "sha256": "71ff2a7d4b3ce464648b88e81c34919e922bb0f2be4c3387ffef6afc0bcc09d8", + "git_blob": "3901c21d02846019f2bee5d6c536d638e126f881" + }, + { + "path": "research/gaussian-root-retirement/README.md", + "sha256": "0dfac5187e92f1c770655007c5cad99d984c1b8e83c6155e42d189e2a8930f05", + "git_blob": "da18f0d8ab9eb2a39fb4064929425e8edd8f62bf" + }, + { + "path": "research/gaussian-root-retirement/RESEARCH.md", + "sha256": "82ea845d37ddf68b3e26ec93296db89cc69662e0bf700b45479fe0f606ec5854", + "git_blob": "9a58dd93f7584787376732978b31b86024bfcfdf" + }, + { + "path": "research/gaussian-root-retirement/RESULT.json", + "sha256": "f3ec0defa39b094f4e18f9b8d6c7afdcd1453e1a88741e4d42da09bd4bf49755", + "git_blob": "20582ebaacd22e01f1bacffbc2645dca3a99a2df" + }, + { + "path": "research/gaussian-root-retirement/RETAINED.json", + "sha256": "d6aa62ef940300a15cc1d56b5cc39919fc5513e879d5e6e48510b827cfc8f57d", + "git_blob": "bcb5811cb248bd0e281ea380fab5c620a26a626a" + }, + { + "path": "research/gaussian-root-retirement/SOURCE-DRIVER-EDITS.json", + "sha256": "1dba1cabc7f7cbe2c0baca51656e806f3f113b6984b41ae18895498495efaa53", + "git_blob": "908bdd419eab3c3b4a846b7052dcde337aad50a1" + }, + { + "path": "research/gaussian-root-retirement/SOURCES.json", + "sha256": "eca5b93ae492675171000312a41ef7746b7eab42a31950295ad41f7e766be5a5", + "git_blob": "99fcc686f87592eedfd74c32f33a1c112b9c1806" + }, + { + "path": "research/gaussian-root-retirement/TASK.json", + "sha256": "76fa8d87541dc127b173dc7d02cf769841024c8018088031dbac9263666a5481", + "git_blob": "499fd760d6e124252ca23746536118540e56d232" + }, + { + "path": "research/gaussian-root-retirement/VALIDATION.md", + "sha256": "2a5efe20c305d83e1e92840485c3e800438b1e86399de9f7c0d4e7ff51d6b848", + "git_blob": "f5ded7bc5d7ade97e21e84daff5dad0ea273f3f1" + }, + { + "path": "research/gaussian-root-retirement/VERIFY.json", + "sha256": "4a67965c6daeb7b23d248275efa8cb7c70ac5370d89648cc902c6cb25ea8f05e", + "git_blob": "6a88f9edc6f025825e4302e6908bf837811a9065" + }, + { + "path": "research/gaussian-root-retirement/WITNESS.json", + "sha256": "2d9377bd4bd3cdf2f4fa2e7d705613fbcee4f42f95c8bc40de90244a4fedda33", + "git_blob": "be22af6322b8bf04ab34d671d7c359b261f249b9" + }, + { + "path": "research/gaussian-root-retirement/check_caller.py", + "sha256": "78d65ec0b9f9eb8b5b310ba40acfe229e33bd69ffc47eb20d0eaa9037e43bd14", + "git_blob": "c4fba4d14c94e2dfd85e704ab64283c53fd5ad3a" + }, + { + "path": "research/gaussian-root-retirement/engines.tar", + "sha256": "cf1bd75c964d8d19ac867550f48424cba0187c4d6ca6b89ef1662bed738c390a", + "git_blob": "3c3aa95bd71ffd665e187efb071985e770434021" + }, + { + "path": "research/gaussian-root-retirement/native-source.tar", + "sha256": "67af9dd68c9f151b24b4a247b078e65770c64abc3d463fac1269b6d7e03f72a8", + "git_blob": "941d8643fc7393e90e78e62dedaf1e57ce78d46a" + }, + { + "path": "research/gaussian-root-retirement/physical.py", + "sha256": "8bff8960ec863c86ed656b0c18e0387bca3d640a34b6c265639eab61a8a6018c", + "git_blob": "ff344772157f43a225b0c1d18c65298a01bc67a3" + }, + { + "path": "research/gaussian-root-retirement/pricing.py", + "sha256": "07712d9086a80e1c6b6be9069746b07a8caac7ff37f4506a8528d898b315d22a", + "git_blob": "8e1b076160945f6c3cfe6e1b2dd1bd124c1e98f4" + }, + { + "path": "research/gaussian-root-retirement/retirement.py", + "sha256": "e435a216b4ce876fa5303c0839ac16b6bcf8b7be502b33b13d058862c1b505f0", + "git_blob": "d73b60727ee39a6e217d1599c9bc4e03e2d64834" + }, + { + "path": "research/gaussian-root-retirement/source_driver.py", + "sha256": "31df5f5982515cc7ed2ec8daeedbe19e463f1dd6576269ec0e11d7082e20cf47", + "git_blob": "613079ca3be27442b8014b762e5999b4ae36b42d" + }, + { + "path": "research/gaussian-root-retirement/verify.py", + "sha256": "ce0995de7823ad0699b708e7cf166b29a5b1b0d5ae19edfa8638ce348fc88ba7", + "git_blob": "af0aece38469764e0f0d0f5366590042857f1bac" + } + ] +} diff --git a/research/p104-helper-split-on-retirement-tree/ROOT.json b/research/p104-helper-split-on-retirement-tree/ROOT.json new file mode 100644 index 0000000000..258f48e43f --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/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, + 5, + 4 + ] +} diff --git a/research/p104-helper-split-on-retirement-tree/SOURCES.json b/research/p104-helper-split-on-retirement-tree/SOURCES.json new file mode 100644 index 0000000000..a1946e70e1 --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/SOURCES.json @@ -0,0 +1,27 @@ +{ + "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": "source.tar", + "archive_sha256": "2481af235a2673c5f3ce1de0391027046eebd356615d09147f8034076eed7135", + "source_head": "775722aa94a5e85b05d1d704d7dca10cbf016f0c", + "manifest": "RETAINED.json", + "reason": "Exact executable source, proofs and notices. Nested native and replay sources retain their manifests; no side-branch history is needed." + } + ] +} diff --git a/research/p104-helper-split-on-retirement-tree/TASK.json b/research/p104-helper-split-on-retirement-tree/TASK.json new file mode 100644 index 0000000000..e9dd78a7cb --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/TASK.json @@ -0,0 +1,123 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 8, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "p104-side-correction", + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Cut public helper register 607 of the native word at frame 115 and move its tail to a new public register 770, with three compensating ADDs at the start and three at the end, under the PR6551 caller: PR6545 independent retirement and child trees (7,2,5,4). Base: PR6621.", + "scope_change_reason": "The explicit user asks for another complete kappa improvement of any size. The PR6551 caller and trees stay fixed; the native word of PR6621 changes by one compensated cut of a public helper register into two shorter ones.", + "bottleneck_link": "The exact complete signed gain over PR6621 is 18*(H5+H6-H2-H9). Every native, query, idle and ordinary operation remains charged.", + "budget_minutes": 180, + "stop_rule": "Reject any edit that fails the full arbitrary-input identity, physical maps, complete invoice, compiler or outer checks. The user requires a verified improvement before completion.", + "outcome": "completed", + "evidence": "PROOF.md; ROOT.json; CONTROLLER.json; WITNESS.json; RESULT.json; VALIDATION.md", + "author": "DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code", + "ai_assistance": "Claude Opus 5.5 (Anthropic), via Claude Code, in construction, exact arithmetic, verification and writing. Builds on the PR6621 package and the PR6551 package of Ali Romman.", + "open_questions": [ + { + "question": "Can an independent reviewer validate the helper-register cut and the complete invoice delta?", + "why_it_matters": "Author checks do not establish independent scientific acceptance.", + "first_step": "Check the profile delta in PROOF.md, compare BASEWORD.json.gz with WORD.json.gz in the PR6529 layer, then replay the registered package.", + "blocked_by": "Independent review has not occurred." + }, + { + "question": "Can further public helper registers be cut, or the native word rebuilt for the new profile?", + "why_it_matters": "The present result is a small improvement for one fixed construction.", + "first_step": "Supply a full arbitrary-input endpoint and every paid job before claiming a new bound.", + "blocked_by": "This package does not supply a global optimization theorem." + } + ] +} diff --git a/research/p104-helper-split-on-retirement-tree/VALIDATION.md b/research/p104-helper-split-on-retirement-tree/VALIDATION.md new file mode 100644 index 0000000000..86ecafad3a --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/VALIDATION.md @@ -0,0 +1,43 @@ +# Validation record + +Environment: CPython 3.12 on macOS, November 3, 2026 (UTC). + +The complete direct generation run, the replays and the registered hook run +from the repository root: + +```sh +python3.12 -I -B research/p104-helper-split-on-retirement-tree/verify.py --write-result +python3.12 -I -B research/p104-helper-split-on-retirement-tree/verify.py +python3.12 -I -O -B research/p104-helper-split-on-retirement-tree/verify.py +python3.12 -B scripts/research_package.py --package research/p104-helper-split-on-retirement-tree +``` + +Marker: `PASS_HELPER_SPLIT_KAPPA_00329760`. Normal and optimized replay both +exit 0 and print it from a fresh copy of the package. The registered hook +(`scripts/research_package.py`) is run from the repository root when the +package is placed there. + +Coverage is that of PR6621, with the native layer replaced by the edited +word: full PR6529 regeneration compared with `BASEWORD.json.gz`, the edited +word's declared public boundaries, its 800 native columns, owned lifetimes, +helper maps and absolute phases, all 7,488 physical contacts, the PR6545 +caller replay, both 1,225-coefficient caller engines, the dual pairs, the +exact complete invoice, both rational price engines, the compiler and all 58 +outer predicates. Every retained source receipt is checked after its +scientific checks. + +The two correction-drop controls and the injection controls run on the +edited word, and each must be rejected. Dropping the first event after the +raw construction is rejected by the row check ("All public and owned rows") +and dropping the final event by the exit check ("All public and owned +exits"), with the same messages as for the PR6621 word. The local profile checks compare the edited word with the +base word and require exactly the deltas in the verifier. The pricing check +requires 67,060 paid jobs and 13,774 productive fields. + +Two verifier literals of the retained sources are changed, as declared in +README.md and PROOF.md: public registers 770 to 771 and owned peak 13 to 14. +The tail decay of the completion test is 33/34. + +Not claimed: hosted CI, independent scientific review, the optional +full-history preflight, formal-kernel verification or a materialized +multiplier. All five source framework assumptions remain. diff --git a/research/p104-helper-split-on-retirement-tree/VERIFY.json b/research/p104-helper-split-on-retirement-tree/VERIFY.json new file mode 100644 index 0000000000..754aa34727 --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/VERIFY.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 590, + "checks": "Complete native source and PR6545 regeneration, all 800 native columns and phases, both 1225-coefficient new caller engines, fixed dual pairs, all physical maps, exact invoice delta, two rational prices, compiler and all outer predicates." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 590, + "checks": "Complete native source and PR6545 regeneration, all 800 native columns and phases, both 1225-coefficient new caller engines, fixed dual pairs, all physical maps, exact invoice delta, two rational prices, compiler and all outer predicates." + } + ] +} diff --git a/research/p104-helper-split-on-retirement-tree/WITNESS.json b/research/p104-helper-split-on-retirement-tree/WITNESS.json new file mode 100644 index 0000000000..be22af6322 --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/WITNESS.json @@ -0,0 +1,104 @@ +{ + "cut_after": 328, + "handoff_after": 344, + "pivot": 4, + "fresh": 34, + "boundary": [ + [ + "SCALE", + 4, + "-1" + ], + [ + "LAMBDA", + 4, + -1 + ], + [ + "ADD", + 21, + 4, + "1" + ], + [ + "LAMBDA", + 4, + 1 + ], + [ + "ADD", + 4, + 20, + "1" + ] + ], + "middle": [ + [ + "ADD", + 4, + 2, + "1" + ], + [ + "ADD", + 2, + 4, + "-1" + ], + [ + "ADD", + 4, + 2, + "1" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 21, + 4, + "1" + ], + [ + "ADD", + 4, + 1, + "1" + ], + [ + "LAMBDA", + 20, + 1 + ], + [ + "ADD", + 4, + 20, + "-1" + ], + [ + "LAMBDA", + 20, + -1 + ], + [ + "ADD", + 4, + 21, + "1" + ] + ], + "group": [ + 4, + 20, + 21 + ] +} diff --git a/research/p104-helper-split-on-retirement-tree/invoice.py b/research/p104-helper-split-on-retirement-tree/invoice.py new file mode 100644 index 0000000000..86ce75eb55 --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/invoice.py @@ -0,0 +1,48 @@ +"""Price the fixed (7,2,5,4) tree before its Gaussian retirement. + +The binary supplier and mixed root are from PR6348 and PR6398. The +independent retirement is from PR6545. All source authors keep their credit. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from collections import Counter + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +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 + # The four trees have fourteen internal nodes. + for size, count in {2: 8, 3: 2, 4: 2, 5: 1, 7: 1}.items(): + targets[1+8*size] += 208*count + paid[8*size] += 208*count + for rank, count in {145: 1, 73: 2, 1: 1, 17: 1, 41: 1}.items(): + targets[rank] += 104*count + paid[16] += 104 + paid[40] += 104 + return targets, paid + + +def difference(after, before): + out = Counter({int(k): v for k, v in after.items()}) + out.subtract({int(k): v for k, v in before.items()}) + return {rank: count for rank, count in out.items() if count} + + +def compare(after, before): + targets = difference(after['targets'], before['targets']) + paid = difference(after['paid'], before['paid']) + need(targets == {16: -104, 40: 104, 41: 208, 57: -208}, + 'Complete productive change from PR6545') + need(paid == {16: -104, 40: 312, 56: -208}, + 'Complete paid change from PR6545') + signed = difference(targets, paid) + need(signed == {40: -208, 41: 208, 56: 208, 57: -208}, + 'Exact two-interval concave difference') + return {'targets': targets, 'paid': paid, 'signed': signed, + 'gain_formula': '208*(H41-H40-H57+H56)', + 'rank_mass_change': sum(r*n for r, n in targets.items())} diff --git a/research/p104-helper-split-on-retirement-tree/pricing.py b/research/p104-helper-split-on-retirement-tree/pricing.py new file mode 100644 index 0000000000..6c2eb8b2da --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/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 native word and the retirement identity. +It includes all nine output contractions and their productive target debits. +This adaptation prices the native word with one public helper register cut in two. +The original sources retain their credit. Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +from tree_invoice import formula_invoice, need + +KAPPA = Q('0.00329760') +TESTED = Q('0.003297605') +PREVIOUS = Q('0.00329700') + + +def encode(value): + if isinstance(value, Q): + return str(value) + if isinstance(value, dict): + return {str(k): encode(v) for k, v in value.items()} + if isinstance(value, (tuple, list)): + return [encode(v) for v in value] + return value + + +def assemble(local, native, word, physical): + paid, targets = Counter(), Counter() + counts = Counter(e[0] for e in word['events']) + need(local['helpers'] == native['helpers'], 'All source helper targets have native maps') + idle = Counter() + for event in word['events']: + if event[0] == 'LOCAL': + paid.update(local['paid']) + targets.update(local['helpers']) + elif event[0] == 'QUERY': + paid[1] += 104 + elif event[0] in ('IDLE', 'IDLE_ONE'): + rank = 8*len(event[3] if event[0] == 'IDLE' else event[2]) + count = 208 if event[0] == 'IDLE' else 104 + paid[rank] += count + idle[rank] += count + main = Counter() + for term in word['diagonal']: + main[int(term[0] % 2)+8*sum(term[1:])] += 104 + targets.update(main) + need(main == physical['main_targets'], 'All main target phases and ranks') + need(idle == physical['whole_idle_jobs'], 'All paired and individual whole idle jobs') + expected_targets, expected_paid = formula_invoice(local) + expected_targets.update({1:104,40:104,41:-104}) + need((targets, paid) == (expected_targets, expected_paid), 'Independent rebalanced tree, retirement delta and emitted-event counts') + need((counts['LOCAL'], counts['QUERY'], counts['IDLE']) == (18, 17, 14) and counts['IDLE_ONE'] == 2 and counts['LAMBDA'] == 34, 'Complete caller census') + need((sum(targets.values()), sum(paid.values())) == (13774, 67060), 'All independent fields and paid calls') + need(sum(r*n for r, n in targets.items())-sum(r*n for r, n in paid.items()) == 760, 'Complete rank-mass surplus') + need((max(targets), max(paid)) == (145, 56), 'Maximum target and paid ranks') + return targets, paid, counts + + +def run(local, native, word, physical, L): + T, P, counts = assemble(local, native, word, physical) + E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py', 'balanced_intervals') + other = L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py', 'balanced_second_intervals') + def margin(k): + a, b = E.moment(T, 1-k), E.moment(P, 1-k) + return a[0]-b[1], a[1]-b[0] + from root_interval import construct + bracket, _ = construct(E, T, P) + lower, upper = Q(bracket['lower'], bracket['grid']), Q(bracket['upper'], bracket['grid']) + signed = Counter(T) + signed.subtract(P) + cap, derivative_upper = Q('.0034'), Q(0) + for rank, count in signed.items(): + logarithm = E.log_bounds(rank) + a = E.mul(E.power(rank, 1-cap), logarithm)[0] + b = rank*logarithm[1] + derivative_upper -= count*(a if count >= 0 else b) + need(derivative_upper < 0, 'Unique raw crossing below the BIT cap') + need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure') + endpoints = {} + for label, k in [('lower', lower), ('upper', upper)]: + tl, th = other.moment(T, k) + pl, ph = other.moment(P, k) + second = (tl-ph, th-pl) + first = margin(k) + need(max(first[0], second[0]) <= min(first[1], second[1]), + 'Both rational engines agree at the raw endpoint') + need(second[0] > 0 if label == 'lower' else second[1] < 0, + 'The second engine certifies both raw endpoint signs') + endpoints[label] = {'first': E.display(first), 'second': E.display(second)} + need(PREVIOUS < KAPPA < TESTED < lower, 'The claim and tested saving are below the raw crossing') + t, offset, power, cutoff, floor = 1-TESTED, Q(1, 7), 1920, 12, 13 + target, paid = E.moment(T, t), E.moment(P, t) + tl, th = other.moment(T, TESTED) + pl, ph = other.moment(P, TESTED) + need(tl > ph and max(tl, target[0]) <= min(th, target[1]) + and max(pl, paid[0]) <= min(ph, paid[1]), 'Two independent rational moment engines') + alpha = E.divide(paid, target) + gamma = E.divide(E.moment(P, t+offset), E.mul(E.power(cutoff, offset), target)) + delta = E.divide((Q(sum(T.values())*floor),)*2, E.mul(E.power(cutoff, TESTED), target)) + reserve, decay = Q(1, 10**27), Q(33, 34) + need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All charged tail ratios') + need(delta[0] > Q(31, 32), 'The source tail decay does not fund this tree') + need(power % 128 == 0 and decay**128 < Q(1, 16), 'The previous block estimate applies') + coarse_tail = 4*Q(1, 16)**(power//128) + need(1/(1+power*reserve)+coarse_tail > 1, 'The coarse tail bound cannot fund this claim') + exact_tail = 4*decay**power + normalized = 1/(1+power*reserve)+exact_tail + need(normalized < 1 and cutoff**64 < floor**63, 'Completion, splitting and rounding') + theta, logarithm_power = Q(63, 64), 2100 + # Keep each exponential inside the retained engine's proved domain. + half = E.power(145, Q(power, 2)*TESTED) + factor = E.mul(half, half) + eta = E.scale(E.divide((Q(1), Q(1)), factor), t) + need(2*(cutoff**power)**64 <= (145**power)**63 + and eta[0] > theta**logarithm_power, 'Shifted exits and complement capacity') + need(factor[1] < 2**logarithm_power, 'Compiler initial range') + gap = (TESTED-KAPPA)/7 + need(gap.numerator == 1, 'Exact compiler integer grid') + step = gap.denominator + def wins(j): + return (step*j+1)**logarithm_power < 2**j + left, right = 1, 2 + while not wins(right): + left, right = right, 2*right + while right-left > 1: + middle = (left+right)//2 + if wins(middle): + right = middle + else: + left = middle + H = step*right + need(H > 8*power and wins(right) and not wins(right-1), 'Uniform threshold and adjacent-grid rejection') + local_routes = (sum(local['paid'].values())+native['helper_normalizers'] + +native['main_adapters']+4*104+4*local['owned_lifetimes'])*1000 + need(local['real_scalar_allowance']+local_routes < 10**7, 'Every local ordinary operation is funded') + raw = 18*10**7 + 17*1664 + 32*35*104*len(word['events']) + 35*104*(26+1000) + need(all(abs(Q(e[-1])) <= 16 for e in word['events'] if e[0] in ('ADD', 'SCALE')), + 'Every emitted scalar coefficient has the declared growth bound') + need(all(Q(e[-1]).denominator & (Q(e[-1]).denominator-1) == 0 + for e in word['events'] if e[0] in ('ADD', 'SCALE')), + 'Every emitted rational scalar is dyadic') + need(raw < 10**9, 'Complete ordinary-work budget') + bit = L.read(L.ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT'] + atom = Q(bit['atom']) + ordinary = (1-atom)*Q(bit['after_cover']) + atom*Q('.0000384599') + admitted = Q(bit['admitted']) + need(atom > ordinary > admitted > TESTED and atom < 1-ordinary, 'Retained BIT admission and stock') + outer_module = L.load(L.ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py', 'balanced_outer') + params = {'kappa': KAPPA, 'tested_saving': TESTED, 'complex_uniform_saving': KAPPA+6*gap, + 'b': KAPPA+5*gap, 'a': KAPPA+4*gap, 'q': KAPPA+3*gap, 'bit_saving': admitted, + 'epsilon': 1-gap, 'beta': 1-3*gap, 'r0': gap/10, 'stop': gap, 'layout': gap, 'd': gap} + outer = outer_module.ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear'] = params['beta']*(1-atom) + need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Full outer predicate inventory') + need(all(x > 0 for key in ('strict_checks', 'functional_checks') for x in outer[key].values()), 'Every outer inequality is strict') + old_completion = E.divide((Q(sum(T.values())*17),)*2, E.mul(E.power(16, TESTED), target)) + need(old_completion[0] > 1, 'The old completion cutoff does not fund the new inventory') + bad = outer_module.ledger(dict(params, bit_saving=Q('.0027'))) + need(any(x <= 0 for x in bad['strict_checks'].values()), 'Insufficient BIT saving rejected') + return encode({'kappa': KAPPA, 'kappa_decimal': '0.00329760', 'previous_fixed_root': PREVIOUS, + 'refinement_kind': 'Cut one public helper register of the native word in two and hand its tail to a new public register, under the rebalanced retirement caller.', + '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_tail_decay': 'The source tail decay 31/32 is below the new completion ratio.', + '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/p104-helper-split-on-retirement-tree/source.tar b/research/p104-helper-split-on-retirement-tree/source.tar new file mode 100644 index 0000000000..80fd2423e2 Binary files /dev/null and b/research/p104-helper-split-on-retirement-tree/source.tar differ diff --git a/research/p104-helper-split-on-retirement-tree/verify.py b/research/p104-helper-split-on-retirement-tree/verify.py new file mode 100644 index 0000000000..3e180baa60 --- /dev/null +++ b/research/p104-helper-split-on-retirement-tree/verify.py @@ -0,0 +1,201 @@ +"""Replay the retained source, the helper-split native word and the rebalanced retirement caller. + +The archive checks and explicit extension use the PR6545 verifier. Native, +caller, phase, interval and compiler sources keep their original credit. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from collections import Counter +from copy import deepcopy +from hashlib import sha1, sha256 +from pathlib import Path, PurePosixPath +import importlib.util +import json +import sys +import tarfile +import tempfile + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +STATUS = 'PASS_HELPER_SPLIT_KAPPA_00329760' + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def read(path): + return json.loads(Path(path).read_bytes()) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def reject(action): + try: + action() + except ValueError as error: + return str(error) + raise ValueError('Invalid candidate accepted') + + +def unpack(record, root): + archive = HERE/record['archive'] + need(sha256(archive.read_bytes()).hexdigest() == record['archive_sha256'], + 'Exact retained archive') + pins = {p['path']: p for p in record['files']} + seen = set() + with tarfile.open(archive, 'r:') as tar: + for member in tar.getmembers(): + path = PurePosixPath(member.name) + need(member.isfile() and not path.is_absolute() and '..' not in path.parts + and member.name in pins and member.name not in seen, + 'Declared regular source member') + seen.add(member.name) + data = tar.extractfile(member).read() + pin = pins[member.name] + need(sha256(data).hexdigest() == pin['sha256'] and + sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() == pin['git_blob'], + 'Exact source SHA256 and Git blob') + target = root/member.name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(data) + need(seen == set(pins), 'Complete retained inventory') + + +def adapted(source, kind): + text = source.read_text() + for before, after in read(HERE/'ADAPTERS.json')[kind]: + need(text.count(before) == 1, 'Unique declared '+kind+' edit') + text = text.replace(before, after) + return text + + +class Extension: + def __init__(self, source_candidate, source, temporary, write): + self.source_candidate = source_candidate + self.source = source + self.temporary = temporary + self.write = write + + def run(self, native_word, old_caller, local, native, L): + # The source runs all its checks and compares its frozen caller receipt. + source_result = self.source_candidate.run(native_word, old_caller, local, native, L) + controller = sys.modules['controller'] + original = Path(controller.__file__) + constructor_path = self.temporary/'tree_constructor.py' + constructor_path.write_text(adapted(original, 'controller')) + constructor = load(constructor_path, 'tree_constructor') + data = read(HERE/'ROOT.json') + original_data = read(original.with_name('ROOT.json')) + need({k: v for k, v in data.items() if k not in ('children', 'child_sizes')} == + {k: v for k, v in original_data.items() if k not in ('children', 'child_sizes')}, + 'Only the child trees and their size declaration change') + need(data['child_sizes'] == [7, 2, 5, 4], 'Declared child allocation') + base = constructor.construct(data) + controller.replay(base) + need(base['events'][:329] == old_caller['events'][:329], + 'The complete source prefix through the retirement cut is unchanged') + sizes = Counter(len(node['stages']) for node in base['nodes']) + need(sizes == {2: 8, 3: 2, 4: 2, 5: 1, 7: 1}, 'Every binary supplier size') + make = load(self.source/'retirement.py', 'tree_retirement') + checks = load(self.source/'check_caller.py', 'tree_independent') + word, witness = make.construct(base) + forward = controller.replay(word) + reverse = checks.transpose(word) + pair = checks.dual_pair(base, make.G, make.J) + controls = controller.controls(word) + for label, index in [('boundary', 0), ('cut', witness['handoff_after']), + ('return', len(word['events'])-1)]: + bad = deepcopy(word) + del bad['events'][index] + controls['missing_'+label] = reject(lambda bad=bad: controller.replay(bad)) + bad = deepcopy(word) + bad['diagonal'][-1][0] = -1 + controls['unearned_central_target'] = reject(lambda: checks.transpose(bad)) + bad = deepcopy(word) + bad['events'][witness['handoff_after']][-1] = '-1' + controls['wrong_cut_sign'] = reject(lambda: controller.replay(bad)) + + def jobs(caller): + return [(e[0], e[1] if e[0] == 'LOCAL' else e[3] if e[0] == 'QUERY' else + tuple(e[3] if e[0] == 'IDLE' else e[2])) + for e in caller['events'] if e[0] in ('LOCAL', 'QUERY', 'IDLE', 'IDLE_ONE')] + + need(jobs(base) == jobs(word), 'Retirement keeps every rebalanced paid job') + physical = load(self.source/'physical.py', 'tree_physical').physical(word, native_word, L) + invoice = load(HERE/'invoice.py', 'tree_invoice') + need(adapted(self.source/'pricing.py', 'pricing') == (HERE/'pricing.py').read_text(), + 'Every price edit is declared') + price = load(HERE/'pricing.py', 'tree_price') + bound = price.run(local, native, word, physical, L) + changes = invoice.compare(bound, source_result['complete_cost']) + old_T = {int(k): v for k, v in source_result['complete_cost']['targets'].items()} + old_P = {int(k): v for k, v in source_result['complete_cost']['paid'].items()} + E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py', 'tree_comparison') + other = L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py', 'tree_second_comparison') + first = E.moment(old_T, 1-price.KAPPA), E.moment(old_P, 1-price.KAPPA) + tl, th = other.moment(old_T, price.KAPPA) + pl, ph = other.moment(old_P, price.KAPPA) + need(first[0][1] < first[1][0] and th < pl, + 'Both rational engines reject PR6545 at the new claim') + bad = deepcopy(local) + bad['paid'][1] -= 1 + controls['unpaid_native_job'] = reject(lambda: price.assemble(bad, native, word, physical)) + bad = deepcopy(physical) + bad['main_targets'][1] += 104 + controls['extra_gaussian_credit'] = reject(lambda: price.assemble(local, native, word, bad)) + for name, value in [('CONTROLLER.json', word), ('WITNESS.json', witness)]: + if self.write: + (HERE/name).write_text(json.dumps(value, indent=2)+'\n') + else: + need(value == read(HERE/name), 'Exact '+name) + print('PASS rebalanced caller, independent reverse rows, dual pairs, physical maps and complete price', flush=True) + candidate = price.encode(dict(caller=forward, reverse=reverse, dual_pair=pair, + child_sizes=data['child_sizes'], internal_node_sizes=dict(sizes), + physical=physical, complete_cost=bound, changes=changes, controls=controls, + source_margin_first=E.display((first[0][0]-first[1][1], first[0][1]-first[1][0])), + source_margin_second=E.display((tl-ph, th-pl)))) + return {'source': source_result, 'candidate': candidate} + + +def run(write=False): + with tempfile.TemporaryDirectory(prefix='helper-split-') as directory: + root = Path(directory) + old_cache = sys.pycache_prefix + sys.pycache_prefix = str(root/'bytecode') + try: + pins = read(HERE/'RETAINED.json') + unpack(pins, root) + source = root/'research/gaussian-root-retirement' + # The two edits add one explicit extension parameter. They do not + # remove or alter a source check, price, receipt or archive. + driver_path = source/'tree_extension_driver.py' + driver_path.write_text(adapted(source/'verify.py', 'driver')) + driver = load(driver_path, 'tree_source_driver') + result = driver.run(extension=lambda candidate: Extension(candidate, source, root, write)) + candidate = result['candidate']['candidate'] + result['candidate'] = result['candidate']['source'] + need(result == read(source/'RESULT.json'), 'Every PR6545 result and control is unchanged') + return {'status': STATUS, 'source_head': pins['source_head'], + 'source_result_sha256': sha256((source/'RESULT.json').read_bytes()).hexdigest(), + 'candidate': candidate, 'assumptions': result['assumptions'], + 'selected_frontier_changed': False} + finally: + sys.pycache_prefix = old_cache + + +if __name__ == '__main__': + need(sys.argv[1:] in ([], ['--write-result']), 'Only --write-result is supported') + write = bool(sys.argv[1:]) + result = run(write) + if write: + (HERE/'RESULT.json').write_text(json.dumps(result, sort_keys=True, indent=2)+'\n') + else: + need(result == read(HERE/'RESULT.json'), 'Exact complete scientific receipt') + print(STATUS, flush=True)