diff --git a/research/p104-paid-job-merges-on-retirement-tree/ADAPTERS.json b/research/p104-paid-job-merges-on-retirement-tree/ADAPTERS.json new file mode 100644 index 0000000000..c4930123a8 --- /dev/null +++ b/research/p104-paid-job-merges-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.00329700')" + ], + [ + "TESTED = Q('0.003293945')", + "TESTED = Q('0.003297005')" + ], + [ + "PREVIOUS = Q('0.003288299')", + "PREVIOUS = Q('0.00329492')" + ], + [ + "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.00329700'" + ], + [ + "Independent Gaussian retirement changes the complete productive profile.", + "Merge paid jobs of the PR6529 native word 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 merged paid jobs." + ], + [ + "reserve, decay = Q(1, 10**29), Q(31, 32)", + "reserve, decay = Q(1, 10**27), Q(97, 100)" + ], + [ + "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-paid-job-merges-on-retirement-tree/CONTROLLER.json b/research/p104-paid-job-merges-on-retirement-tree/CONTROLLER.json new file mode 100644 index 0000000000..a29bd24a25 --- /dev/null +++ b/research/p104-paid-job-merges-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-paid-job-merges-on-retirement-tree/NOTICE b/research/p104-paid-job-merges-on-retirement-tree/NOTICE new file mode 100644 index 0000000000..ab5a95e5cb --- /dev/null +++ b/research/p104-paid-job-merges-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-paid-job-merges-on-retirement-tree/PROOF.md b/research/p104-paid-job-merges-on-retirement-tree/PROOF.md new file mode 100644 index 0000000000..ec146769cb --- /dev/null +++ b/research/p104-paid-job-merges-on-retirement-tree/PROOF.md @@ -0,0 +1,117 @@ +# Paid-job merges in the native word: exact invoice delta + +## 1. Source and what changes + +The comparison is PR6551: the PR6545 Gaussian retirement, the PR6398 mixed +root with child trees `(7,2,5,4)`, and the exact PR6529 native word. 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. It is the PR6529 word with three edits, each +an exact rewrite with its own compensation (README.md lists them with event +numbers). + +- A merges the paid hops of the owned register 770 (frames 549, 553, 1047, + 593) into one hop from frame 549 to frame 593. The six rows that consumed + the intermediate values receive the same combination in frame 3 at the + start of the program, and two rows take compensating ADDs in frame 127. +- B re-bases the addition made to register 471, with its compensation in + frame 676. +- C moves the input of helper 435 from frame 127 to frame 246. The only + change at the public boundary is `final[435]` from 127 to 246, which the + verifier checks and allows explicitly. Its preparation is done in frame 3 and compensated + in frame 516, with a shadow register 783 created and cleared in frame 127. + +The verifier regenerates the PR6529 word from its retained construction and +compares it with `BASEWORD.json.gz` before it substitutes `WORD.json.gz`. The +new word is then replayed against all 799 columns, the owned lifetimes +(46 lifetimes, peak 13), the helper maps, the absolute phases and the 7,488 +caller contacts. The base-word positional controls run on the +base word. + +## 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 candidate local profile +differs from the base word's as follows, per call. + +```text +paid {1:-3, 3:-1, 4:+1, 5:-1, 6:+1} +targets {8:+1, 9:-1} +``` + +The edits A and B account for `paid {1:-3, 3:-1, 6:+1}`: three rank-1 jobs +and one rank-3 job become one rank-6 job, with the rank mass 3+3 = 6 +preserved. Edit C accounts for `targets {8:+1, 9:-1}` and +`paid {4:+1, 5:-1}`: one rank-9 target becomes rank 8 and one rank-5 job +rank 4. The complete invoice therefore changes by 18 times these counts: + +```text +Delta T = 18 H8 - 18 H9, +Delta P = -54 H1 - 18 H3 + 18 H4 - 18 H5 + 18 H6. +``` + +The caller side of the invoice is identical to PR6551, so these are the only +changes against it. The checks in `pricing.py` confirm that the complete +profile is exactly PR6551's plus this delta: productive fields 13,756 are +unchanged, paid jobs fall from 67,096 to 67,042, and the target minus paid +rank mass stays 760 (each of the two masses falls by 18). + +## 3. Why the gain is positive + +The signed gain is `Delta(T-P) = Delta T - Delta P`: + +```text +Delta(T-P) = 18 * [ (3 H1 + H3 - H6) + (H5 - H4) - (H9 - H8) ]. +``` + +Take `H_r = r^t` with `0 < t < 1`. + +1. The function is strictly concave with `H_0 = 0`, so it is strictly + subadditive. Since 1+1+1+3 = 6, `H1 + H1 + H1 + H3 > H6`: the merge of + edits A and B is positive. +2. The derivative `t r^(t-1)` strictly decreases. Hence + `H5 - H4 = integral over [4,5] > integral over [8,9] = H9 - H8`, and + edit C is positive. + +Each bracket is positive, so `Delta(T-P) > 0` for every exponent in the +stated domain. This is an exact all-exponent comparison. It does not +depend on the tested saving. + +Equivalently, the six ranks `{1,1,1,3,5,8}` on the gaining side have the +same sum 19 as `{4,6,9}` and are majorized by it, so every strictly concave +sum is larger on the first multiset. + +## 4. Costs that are charged + +The new word has 18,561 events (68 more than before). The owned inventory +has 29 labels and 46 lifetimes with peak 13, and the local scalar allowance +is 137,866 (was 137,218). The rank mass of local paid and target jobs is +5,924, as before. The full ordinary-work upper bound stays 254,932,208, below +the retained 10^9 allowance. The edits add no unpaid channel, helper, copy +or restoration. One shadow register (783) is nonzero when it is erased in +frame 127, like register 781 in PR6529, and is covered by the same +`owned_erasure` assumption. + +## 5. Conditional numerical result + +The new claimed saving is 0.00329700. The tested saving is 0.003297005. 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.0032970138574524603, above PR6551's 0.003294926110571363 by +0.0000020877468811. A negative derivative bound gives a unique crossing +below the retained BIT cap. Both engines reject the full PR6551 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. As in PR6551, the source tail decay 31/32 is below the completion +ratio, and the check uses decay 97/100 and reserve 10^(-27) at power 1920. +The conditional bound has the same form `O(n (log n)^(1-kappa))` with +`kappa = 0.00329700` 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-paid-job-merges-on-retirement-tree/README.md b/research/p104-paid-job-merges-on-retirement-tree/README.md new file mode 100644 index 0000000000..1215a4bc69 --- /dev/null +++ b/research/p104-paid-job-merges-on-retirement-tree/README.md @@ -0,0 +1,153 @@ +# Merge paid jobs in the native word under the rebalanced retirement + +The complete conditional bound is **κ = 0.00329700**. The increment over +[PR6551](https://github.com/CrocSwap/integer-mult-bounds/pull/6551), +κ = 0.00329492, is **0.00000208**, or **0.0631275%**. The exact raw crossings +are 0.0032970138574524603 here and 0.003294926110571363 in PR6551, a +difference of 0.0000020877468811 (0.0633625%). This comparison excludes all +inherited gains. The selected frontier is unchanged. + +Keep the PR6551 caller: the PR6545 retirement identity and the child trees +`(7,2,5,4)`, unchanged. Keep the PR6529 native word except for three edits. +Each edit is a legal rewrite of the word with its own compensation. Together +they change the native paid and target profile, per native call, by + +```text +paid {1:-3, 3:-1, 4:+1, 5:-1, 6:+1} +targets {8:+1, 9:-1} +``` + +The complete signed invoice (targets minus paid jobs) improves by + +```text +18 * (3 H1 + H3 + H5 + H8 - H4 - H6 - H9). +``` + +For `H_r = r^t`, with `0 < t < 1`, this is positive: 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 three edits to the PR6529 word + +Event numbers use the 18,493-event PR6529 word; the new word has 18,561. + +- **A. Merge three paid hops into one.** The single-use owned register 770 + is created at event 9191 and carried through frames 549, 553, 1047 and 593 + (events 9194, 9196 and 9200). Its value is added to rows 169, 206 and 471 + on the way (events 9195, 9198 and 10386). The new word moves it directly + from frame 549 to frame 593. Six rows (119, 169, 191, 193, 204, 206) receive + `r471 + r525/2 + 2 r704` as 18 ADDs in frame 3 at the start of the program, + and rows 9 and 61 receive ADDs from registers 471, 333, 525, 173 and 704 in + frame 127. The paid jobs of ranks 1, 1, 1 and 3 become one job of rank 6. +- **B. Re-base register 471's addition.** Register 471 now receives + `+r174` and `-r257/2` in frame 3 (events 2557 and 5664), compensated in + frame 676 by `-r174` and `-r265/2` on register 471 and `+2 r471` on + register 265 (events 9677 to 9679). This replaces the addition + `2 r770` to register 471 in frame 593 (event 10386). +- **C. Re-base the helper-435 input.** Helper 435 takes its input in frame + 246 instead of 127 (`final[435]` changes from 127 to 246). Its input rows + are prepared in frame 3, compensated in frame 516 by registers 37, 110 and + 435, and a clean shadow register 783 is created and cleared in frame 127. + One rank-9 helper target becomes rank 8, and one rank-5 paid job rank 4. + +In the new word the first 18 events belong to A and the next 15, ending with +`ADD 435 434` in frame 3, to C. The word has 69 more ADDs than before, three +fewer MOVEs and one more INIT/CLEAR pair (register 783). + +| Complete inventory | PR6551 | This package | +|---|---:|---:| +| Native calls / thin queries | 18 / 17 | 18 / 17 | +| Native program events | 18,493 | 18,561 | +| Owned lifetimes (peak) | 45 (13) | 46 (13) | +| Local scalar allowance | 137,218 | 137,866 | +| Independent caller fields per port | 35 | 35 | +| Productive fields, including native helpers | 13,756 | 13,756 | +| Paid Gaussian jobs | 67,096 | 67,042 | +| 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-paid-job-merges-on-retirement-tree +``` + +The registered hook runs normal and optimized checks. A direct run is +`python3.12 -I -B research/p104-paid-job-merges-on-retirement-tree/verify.py`. +The result marker is `PASS_PAID_JOB_MERGES_KAPPA_00329700`. +See [VALIDATION.md](VALIDATION.md) for checks that have run and their limits. + +The two rational engines enclose the raw crossing in +`(0.00329701385745246023380113, 0.00329701385745246023380114)`. The tested saving is 0.003297005. As in PR6551, +the old completion decay does not suffice; the check uses decay 97/100 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 its 799 columns, owned lifetimes, helper maps, +absolute phases and all 7,488 caller contacts, with the base-word local +profile replaced by the new one above. 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 +PR6551 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. [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 PR6551, with the new claim constants. + +## Scope and coordination + +This contribution is a further κ improvement on the PR6551 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`. The shadow register 783 +is erased in frame 127 while nonzero, as register 781 already is, so the +`owned_erasure` assumption now covers one more erasure. 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 three native edits 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 the remaining rank-6 and rank-9 paid and target jobs be merged + further, or the native word be rebuilt for the new profile? A candidate + must supply its full arbitrary-input endpoint and every paid job. + +The structured questions are in [TASK.json](TASK.json). + +## Credit + +Native-word edits, price and integration: DreamingOfClouds with Claude Opus +5.5 (Anthropic), via Claude Code. Apache-2.0. + +The caller, trees and package this 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-paid-job-merges-on-retirement-tree/RESULT.json b/research/p104-paid-job-merges-on-retirement-tree/RESULT.json new file mode 100644 index 0000000000..0c31219ecc --- /dev/null +++ b/research/p104-paid-job-merges-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.000000000000020728450160865176", + "upper": "0.000000000000020728450160865177" + }, + "gap": "1/1400000000", + "integer_test_exponent": 98643, + "logarithm_power": 2100, + "theta": "63/64", + "uniform_saving": "2307903/700000000", + "word_materialized": false + }, + "derivative_upper": "-177329997826592457813578232569671144674446300054171846052197941/784637716923335095479473677900958302012794430558004314112", + "full_forward_calls": 18, + "gain": "13/6250000", + "kappa": "3297/1000000", + "kappa_decimal": "0.00329700", + "margin_at_previous": { + "lower": "0.479461938479479626390628509501", + "upper": "0.479461938479479626390628509502" + }, + "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": 5385000, + "local_scalar": 137866, + "paid_rank_mass": 184112, + "peak_owned_fields": 13, + "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": "6462125595384197/1960000000000000000", + "fused_gaussian": "6462125586152591/1960000000000000000", + "global_coordinate_router": "1153951/350000000", + "group_bit_router": "1615531746538147/490000000000000000", + "group_scans": "699999999/700000000", + "main_transform": "6462124195384197/1960000000000000000", + "microbox_face_corrections": "26950000001/350000000", + "polynomial_products": "1399999999/1400000000", + "sparse_union_movement": "802712125595384197/1960000000000000000" + }, + "parameters": { + "a": "1153951/350000000", + "b": "923161/280000000", + "beta": "1399999997/1400000000", + "bit_saving": "17/5000", + "cap_xi": "1782712124195384197/1960000000000000000", + "complex_uniform_saving": "2307903/700000000", + "d": "1/1400000000", + "epsilon": "1399999999/1400000000", + "kappa": "3297/1000000", + "lambda_": "398681199/400000000", + "lambda_prime": "1395384197/1400000000", + "layout": "1/1400000000", + "q": "4615803/1400000000", + "r0": "1/14000000000", + "stop": "1/1400000000", + "tested_saving": "659401/200000000" + }, + "strict_checks": { + "actual_bit_above_effective": "36049/350000000", + "actual_logarithmic_gamma_guard": "1/1400000000", + "actual_logarithmic_group_guard": "177287877904615803/980000000000000000", + "alpha_logarithm_absorption": "1/14000000000", + "boundary_algebraic_matrix_above_kappa": "5595384197/1960000000000000000", + "cap_above_band": "802712124195384197/1960000000000000000", + "cap_below_cell": "177287874404615803/1960000000000000000", + "cap_below_phase_cell_power": "2137287875804615803/1960000000000000000", + "complex_above_effective": "1/1400000000", + "complex_below_one_over_32": "7826839/280000000", + "complex_endpoint": "1/700000000", + "epsilon_below_one": "1/1400000000", + "epsilon_positive": "1399999999/1400000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "5586152591/1960000000000000000", + "gaussian_above_main": "695384197/980000000000000000", + "global_coordinate_router_above_kappa": "1/350000000", + "global_gamma_power_slack": "9/14000000000", + "group_below_dimension": "1/700000000", + "group_bit_router_above_kappa": "1746538147/490000000000000000", + "group_gauge_power_slack": "177287877834615803/980000000000000000", + "group_key_fits_record": "1/700000000", + "group_positive": "1399999997/1400000000", + "group_scans_above_kappa": "697692099/700000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "783014790400418148631/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": "559076839/392000000000000000", + "leaf_saving_above_effective": "279076839/392000000000000000", + "main_transform_above_kappa": "4195384197/1960000000000000000", + "membership_arithmetic_fits_record": "1/1400000000", + "microbox_face_corrections_above_kappa": "26948846051/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": "1395384199/1400000000", + "positive_layout_slack": "1/1400000000", + "q_below_effective": "1/1400000000", + "q_below_internal": "1/1400000000", + "q_below_leaf": "559076839/392000000000000000", + "q_positive": "4615803/1400000000", + "short_record_fallback": "279076839/280000000", + "source_axis_superpolynomial": "1/1400000000", + "sparse_union_movement_above_kappa": "796250005595384197/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": 8154, + "24": 416, + "3": 8820, + "32": 416, + "4": 1944, + "40": 312, + "5": 2736, + "56": 208, + "6": 162, + "7": 162, + "8": 18 + }, + "paid_calls": 67042, + "previous_fixed_root": "82373/25000000", + "productive_fields": 13756, + "rank_mass_surplus": 760, + "raw_endpoint_margins": { + "lower": { + "first": { + "lower": "0.000000000000000000000106417147", + "upper": "0.000000000000000000000106417148" + }, + "second": { + "lower": "0.000000000000000000000106417147", + "upper": "0.000000000000000000000106417148" + } + }, + "upper": { + "first": { + "lower": "-0.000000000000000000002183423146", + "upper": "-0.000000000000000000002183423145" + }, + "second": { + "lower": "-0.000000000000000000002183423146", + "upper": "-0.000000000000000000002183423145" + } + } + }, + "raw_headroom": [ + "1385745246023380113/100000000000000000000000000", + "692872623011690057/50000000000000000000000000" + ], + "raw_root_interval": [ + "329701385745246023380113/100000000000000000000000000", + "164850692872623011690057/50000000000000000000000000" + ], + "refinement_kind": "Merge paid jobs of the PR6529 native word under the rebalanced retirement caller.", + "relative_gain_percent": "5200/82373", + "strictification": { + "alpha": { + "lower": "0.999999988919287126642134561886", + "upper": "0.999999988919287126642134561887" + }, + "coarse_tail_upper": "1/288230376151711744", + "cutoff": 12, + "delta": { + "lower": "0.969016392699313473432484405972", + "upper": "0.969016392699313473432484405973" + }, + "exact_tail_upper": "39969599002010972613129161210973172949410733177003411690426684526213836968758878797391548347223173595667172138052575859928005227509421714750019926032974740745071529681998713931077122801190049322408424126741469918556593037572867754249992641672856854609369173478215283833487874477290343616026308592460648764328713840255960447748667067563895479887232462427094824060970419086474287689570350601931914083794539365766437796217499624018198675036562447411330569251237600079811966374054817673732740450383406814418942802789463848847215173315276917830909102582882090163372994245975404789389241289780688053447072570439135155518685662971369877979052799764886888869764485519017485987236779269441494034519235481739619311831601808558899941230215791873256717258527543071038174074621445193491459127423148529371375350189706509020544499268493043577958937865369386632216992012800798785415482571993756465310640752164596809758721075916514862216412090691487963231443512999212689765099425261867533942168199982480733396033304202691714873444216202205396939268197621727372360601354238913012733649824901646038825182330745580912577361658945998632748836847971565345336334971770134349906398275029248759638556894170769282316278023904481205512070498495652140811741970864898878215956985024974775357004333161958447741852082217516791174525091648454194469119018668606991403218258965441098611146872174356258630128700632994276499088300124631333697171920866005767737761222937710312499773388543399125378849022547276862574195466789706566590853955975903380940923689711048897657126912082844163317970573412712828362120986107953658257973363645595823532281146484729002373678417604085878474290820113835159916505806591137178248347435512779360930783890773410253823131009214246998884883114852577699267694911948588242903439413628293029446726067562442586700828083821317994413297900875782734741805712811541207734890217364947639295590943134292837245171770081768072109403180385169712271697080056467111275968749718017429502706926859908792675888558383327740670604017735759918018653717373189688382355132692228436914059351280795483400381562640908613282111432735509158998811342740801271553027489016159725929704655924040058208738645307349598189796602667379460232381119322651255376499379610728959328590352430192586348998283294378793988772710423731874040192564787818085955068261236741489390888224907463904282656684267603072737085169238284320128310976388803765402124332072771416361729273657326591479175478393291352306076517398942716333969453084220370413778636177806997739568508792121391934125526363603468574453239891080649373292275796793970399320897658281573351050731556752227761069620715264311095529330498505069060136610815019739318660089618670269909191938507342969113263229225346082086538897559336328698488144536734672192842170097756470435041884077317802759550824576366430162023074704259070317168571191168683561876364037378224449267016595366378611459667210745353634036889672141598273751931847723651022524077225887566802816463614693421711673957439560066988115084503104812646993678386929087107437208694543477907287385175130897404598207065993471387751322067952714329323699847037780277383109479310109427315402363672606102852428957101353935950706358656071928174195020713372704649546654451872716254573234323933583189817975017508464300418896219147610746511667693877129621514943408178787903162195814059283404018770468361532715376260496133347013678381121056090004386054939259953278863370112500289261101712984241241098214000121553250032861487761811557287123258679141917454754891859014931182617029446781526205957260678367731488388405223844138320008772349444037935590132958751376073781390132227744431123859314951378774485956199764501296115004076548206080830919701987146057941745652410300034991263977498180528554535708975371227426506273031472006540140815152203456826135768084188057793652838401/250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "floor": 13, + "gamma": { + "lower": "0.920678987891398603441679340523", + "upper": "0.920678987891398603441679340524" + }, + "normalized_paid_upper": "390625000000000000000000062452498440642144708014434300942588766372109976551463685810542804408651273920819400977872934047115019866348640352191450658295169499885587024485918442205560679318515187901089441530239591448498062404955929401950317892643846479986090425369172392951553930402083537636399560388631978286596545892607639343195565294463454325715581553585279210107455205143968543538354281705941520003355799425855726775875178792036470061864852332094546146532729058017476579076069051083859812048431451168406328007646389623195311982619327579888414044216965133528552502342014431273211711023796236644318629691179634265063009725419059035018022562106689610476751747736555689624677968640945781864116515724076901958891481394267150555963499218981383579726377030147669607389297416272976695872766761747783697459618001120893441478354459048798689790188894233070949710087902048137472091969783896814844210371588169716282879444232421704898496517397613041810966003573167868677692093717138297541902221857546302207019422707107770901931533903864321305751931956775915858540792751179116597625929630433802894447578444933212884652403385592739444880840244067650115100412795307040547690083921639901378836424783313738116497338294866336652091365463328021434395920457102733528183461963365687899984168855224327435681191953918436515149520969949477869472085538681256956331408371990244973369430111936990557722400891197427208550432871928179670080098601359330838357884660623618034385984253002355934961298199132882729946535389097050285727969556553405984152128797028798749401839893037735381830299403622900513138331021992338100042848303994705397829166568467059201798130164065302480002996343124349823639303086527463120249627175745671112182518522617506137524865884574375760059936724994248933255988391336350180297846769954569013687269721886878943704275238190884557426599132221149012053598538072602661986988054666161735764433970190049869121022984053317984653038498777525592015549454204867137920728743015797771016877837986525642402999313401124856642608364380594730174524196805377800021887368445207662095377183950792759052247282883441641019498406933804473550639749314793920983661482569366800193329082448021777794168978183963779639430331922406701519291731817883716328661890068331450588664160977785121966904688555170314748357187803418524156185216407031930936324182848799097030500416278760102940627520716622696060666119241832804523543408424904872053009704111863013598293779653796634504476498196462569017500460770177338709958018995962283174145884188673646525599678120936182686629187036323598208318064353648656796011758989706392605456174904292210251990887022467892348742927966020118330721391335519795156343447862112776316199396740986459838200613570439004741792330359897992245250283523240418775289124367226150689629633985455340603310301986242178095258769522397319360081209468526224779081569332877878526469866378555425180842642770314117049208030399059352078715079077817839401152318474491722879538798295622737221147488691921244866300353791970190149087190966948703448749194954557973588441128586824830207919808579566259345017397861647768110825118420402770324436053654525797314119982444264962735541554096532521587093521148342566884966035202191677956542741287242686983691833987571983720819230701170166113259265884627271109579352239349684559947270154094796343194316817382028371672476449338610282437730079795504297854855143038343402337045625619081519759793470616630431629031894251877737040166494028958946519750331263127987276716827158495065905900069369269830922920880190270622531457726379899486867398591472775271711741601767661037920795185501034038501228208171961221980806774542774366073447397228852004726927759251523781926018367599933709978129316017327475171294802200379367145360152220074650199766112023790077864306766567019065950037395501715218801936332652303194136995706856758053989296912953038408866752564173380958515203/390625000000000000000000750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "power": 1920, + "reserve": "1/1000000000000000000000000000", + "tail_decay": "97/100", + "tail_offset": "1/7", + "tested": "659401/200000000" + }, + "targets": { + "1": 460, + "145": 104, + "17": 1768, + "2": 144, + "25": 416, + "3": 72, + "33": 416, + "4": 1926, + "40": 104, + "41": 208, + "5": 270, + "57": 208, + "6": 54, + "7": 162, + "73": 208, + "8": 720, + "9": 6516 + }, + "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.221520283237361776197662543960", + "upper": "-0.221520283237361776197662543959" + }, + "source_margin_second": { + "lower": "-0.221520283237361776197662543960", + "upper": "-0.221520283237361776197662543959" + } + }, + "selected_frontier_changed": false, + "source_head": "775722aa94a5e85b05d1d704d7dca10cbf016f0c", + "source_result_sha256": "020728f015b8493b975a6c3d25115e00cef1c4bb62c062148f546723c509b75d", + "status": "PASS_PAID_JOB_MERGES_KAPPA_00329700" +} diff --git a/research/p104-paid-job-merges-on-retirement-tree/RETAINED.json b/research/p104-paid-job-merges-on-retirement-tree/RETAINED.json new file mode 100644 index 0000000000..33b4354f5c --- /dev/null +++ b/research/p104-paid-job-merges-on-retirement-tree/RETAINED.json @@ -0,0 +1,122 @@ +{ + "archive": "source.tar", + "archive_sha256": "d04afb7cc96d0104dbf3a8142e1347ebfe240eba581210eca7ad877227078bd0", + "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": "96ccac1d1a300f42302920da94da9d90942e7bd0195dc4929812ff23a76b265f", + "git_blob": "40932c9b77a877ebe736fdb576ad69ddcc98acd8" + }, + { + "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": "020728f015b8493b975a6c3d25115e00cef1c4bb62c062148f546723c509b75d", + "git_blob": "7fd4f6775f55c47dc9ce18f13f50d07bd33d6ca0" + }, + { + "path": "research/gaussian-root-retirement/RETAINED.json", + "sha256": "01c5f75af5873d9db7c58a146b06102c4bc601ce08bcf23da0f4359ceedc6f62", + "git_blob": "57f9c08352e0e4030a9da307efcd19d38c74eb16" + }, + { + "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": "5d8a61b8194a00020e74b6cafa3303fe430c8dbe34e4c0cb6c2418a678b390c1", + "git_blob": "774511998f59db2279c03f8681f0fd38cbcf8f0d" + }, + { + "path": "research/gaussian-root-retirement/physical.py", + "sha256": "8bff8960ec863c86ed656b0c18e0387bca3d640a34b6c265639eab61a8a6018c", + "git_blob": "ff344772157f43a225b0c1d18c65298a01bc67a3" + }, + { + "path": "research/gaussian-root-retirement/pricing.py", + "sha256": "1f0155aac873ec7f1098638e69beddd62b9b7baf0888e8a9f217fc05a3110e7a", + "git_blob": "9a1317c6614351e9f8768c6122661b6edbbba36d" + }, + { + "path": "research/gaussian-root-retirement/retirement.py", + "sha256": "e435a216b4ce876fa5303c0839ac16b6bcf8b7be502b33b13d058862c1b505f0", + "git_blob": "d73b60727ee39a6e217d1599c9bc4e03e2d64834" + }, + { + "path": "research/gaussian-root-retirement/source_driver.py", + "sha256": "2e23581f469047863908bee71b8e01cdbcf4925ebcb1d872ab60ab69939b6335", + "git_blob": "c4c9aaa2de788aa4cd9c99941578163f6f576a0b" + }, + { + "path": "research/gaussian-root-retirement/verify.py", + "sha256": "5d41ab1f3d2ad48222ccb0a80be6c4b6c85bc4eef982090b3bed5154ef86c57a", + "git_blob": "aa7d1d8555b0a6e78053055c334f323364adb77a" + } + ] +} diff --git a/research/p104-paid-job-merges-on-retirement-tree/ROOT.json b/research/p104-paid-job-merges-on-retirement-tree/ROOT.json new file mode 100644 index 0000000000..258f48e43f --- /dev/null +++ b/research/p104-paid-job-merges-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-paid-job-merges-on-retirement-tree/SOURCES.json b/research/p104-paid-job-merges-on-retirement-tree/SOURCES.json new file mode 100644 index 0000000000..a1946e70e1 --- /dev/null +++ b/research/p104-paid-job-merges-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-paid-job-merges-on-retirement-tree/TASK.json b/research/p104-paid-job-merges-on-retirement-tree/TASK.json new file mode 100644 index 0000000000..9175648590 --- /dev/null +++ b/research/p104-paid-job-merges-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": "Merge paid jobs of the PR6529 native word through three exact edits, under the PR6551 caller: PR6545 independent retirement and child trees (7,2,5,4).", + "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 changes through three compensated edits that merge paid jobs.", + "bottleneck_link": "The exact complete signed gain over PR6551 is 18*(3*H1+H3+H5+H8-H4-H6-H9). Every native, query, idle and ordinary operation remains charged.", + "budget_minutes": 180, + "stop_rule": "Reject any candidate 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 PR6551 package of Ali Romman.", + "open_questions": [ + { + "question": "Can an independent reviewer validate the three native edits 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 paid jobs be merged, 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-paid-job-merges-on-retirement-tree/VALIDATION.md b/research/p104-paid-job-merges-on-retirement-tree/VALIDATION.md new file mode 100644 index 0000000000..ab4ece1a94 --- /dev/null +++ b/research/p104-paid-job-merges-on-retirement-tree/VALIDATION.md @@ -0,0 +1,33 @@ +# Validation record + +Environment: CPython 3.12 on macOS, November 3, 2026 (UTC). + +The complete direct generation run and the registered replay were run from +the repository root: + +```sh +python3.12 -I -B research/p104-paid-job-merges-on-retirement-tree/verify.py --write-result +python3.12 -I -B research/p104-paid-job-merges-on-retirement-tree/verify.py +python3.12 -I -O -B research/p104-paid-job-merges-on-retirement-tree/verify.py +python3.12 -B scripts/research_package.py --package research/p104-paid-job-merges-on-retirement-tree +``` + +Marker: `PASS_PAID_JOB_MERGES_KAPPA_00329700`. Normal and optimized replay both +passed, as did the registered hook. + +Coverage is that of PR6551, with the native layer replaced by the edited +word: full PR6529 regeneration compared with `BASEWORD.json.gz`, the edited +word's 799 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. The local profile checks compare the edited +word with the base word and require exactly the delta in README.md. The +pricing check requires 67,042 paid jobs and 13,756 productive fields. + +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-paid-job-merges-on-retirement-tree/VERIFY.json b/research/p104-paid-job-merges-on-retirement-tree/VERIFY.json new file mode 100644 index 0000000000..0dc18f4ed5 --- /dev/null +++ b/research/p104-paid-job-merges-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 799 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 799 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-paid-job-merges-on-retirement-tree/WITNESS.json b/research/p104-paid-job-merges-on-retirement-tree/WITNESS.json new file mode 100644 index 0000000000..be22af6322 --- /dev/null +++ b/research/p104-paid-job-merges-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-paid-job-merges-on-retirement-tree/invoice.py b/research/p104-paid-job-merges-on-retirement-tree/invoice.py new file mode 100644 index 0000000000..86ce75eb55 --- /dev/null +++ b/research/p104-paid-job-merges-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-paid-job-merges-on-retirement-tree/pricing.py b/research/p104-paid-job-merges-on-retirement-tree/pricing.py new file mode 100644 index 0000000000..00ab21632d --- /dev/null +++ b/research/p104-paid-job-merges-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 merged paid jobs. +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.00329700') +TESTED = Q('0.003297005') +PREVIOUS = Q('0.00329492') + + +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())) == (13756, 67042), '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(97, 100) + 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.00329700', 'previous_fixed_root': PREVIOUS, + 'refinement_kind': 'Merge paid jobs of the PR6529 native word 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-paid-job-merges-on-retirement-tree/source.tar b/research/p104-paid-job-merges-on-retirement-tree/source.tar new file mode 100644 index 0000000000..0c254b7879 Binary files /dev/null and b/research/p104-paid-job-merges-on-retirement-tree/source.tar differ diff --git a/research/p104-paid-job-merges-on-retirement-tree/verify.py b/research/p104-paid-job-merges-on-retirement-tree/verify.py new file mode 100644 index 0000000000..828a073c78 --- /dev/null +++ b/research/p104-paid-job-merges-on-retirement-tree/verify.py @@ -0,0 +1,201 @@ +"""Replay the retained source, the merged-paid-job 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_PAID_JOB_MERGES_KAPPA_00329700' + + +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='paid-job-merges-') 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)