diff --git a/research/p104-split-block-composition/.gitattributes b/research/p104-split-block-composition/.gitattributes new file mode 100644 index 0000000000..7467454cb8 --- /dev/null +++ b/research/p104-split-block-composition/.gitattributes @@ -0,0 +1 @@ +source/** -text diff --git a/research/p104-split-block-composition/CHECKS-EDITS.json b/research/p104-split-block-composition/CHECKS-EDITS.json new file mode 100644 index 0000000000..3ec14cd95d --- /dev/null +++ b/research/p104-split-block-composition/CHECKS-EDITS.json @@ -0,0 +1,10 @@ +[ + [ + "Counter({1:2219,2:454,3:492,4:92,5:175,6:6,7:15})", + "Counter({1:2220,2:454,3:492,4:93,5:174,6:6,7:15})" + ], + [ + "Counter({1:25,2:5,4:91,5:6,7:6,8:38,9:388})", + "Counter({1:24,2:5,4:92,5:7,7:6,8:37,9:388})" + ] +] diff --git a/research/p104-split-block-composition/DIRECT-SOURCES.json b/research/p104-split-block-composition/DIRECT-SOURCES.json new file mode 100644 index 0000000000..1b5081ce17 --- /dev/null +++ b/research/p104-split-block-composition/DIRECT-SOURCES.json @@ -0,0 +1,58 @@ +[ + { + "local_path": "source/pr5739/construct.py", + "path": "research/p104-block-reframe-r22/construct.py", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/construct.py", + "git_blob": "ca59c61f8a1d25f490675cfc3c7faf343c26d159", + "sha256": "a84324082bd1724a59d1c4b3470be3b6889ca584bcbc4c2135d9c8dd100e5957" + }, + { + "local_path": "source/pr5739/verify.py", + "path": "research/p104-block-reframe-r22/verify.py", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/verify.py", + "git_blob": "b214cdd26b939ca6d48d7bea8a8835d6e54be005", + "sha256": "219b7bce638f2bc765c8ad90c30fbb7009ede9acf297ed86372b9b6539b28ac6" + }, + { + "local_path": "source/pr5739/pricing.py", + "path": "research/p104-block-reframe-r22/pricing.py", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/pricing.py", + "git_blob": "9f233cf78ec515f7a1e8f934dd987804e5efa12b", + "sha256": "69910e0989d17551dbce2bf31ee6cc28990b8fa0d46a68c78897e290fbe99753" + }, + { + "local_path": "source/pr5739/EDITS.json", + "path": "research/p104-block-reframe-r22/EDITS.json", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/EDITS.json", + "git_blob": "54f7b233d7bf97df2ac8a6167348db0f04ad0ab2", + "sha256": "1545d726fed269dd7d6fa59ff6744211a105aff5be99c5acf6b0e72c4977b3ea" + }, + { + "local_path": "source/pr5739/WORD.json.gz", + "path": "research/p104-block-reframe-r22/WORD.json.gz", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/WORD.json.gz", + "git_blob": "4c7fb353c686fbf14ccd332ba398168573f0fdfa", + "sha256": "88865e48e5cfe3bfcf28d6343cb166e98785a98dd102601d98870b068b125a85" + }, + { + "local_path": "source/pr5739/README.md", + "path": "research/p104-block-reframe-r22/README.md", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/README.md", + "git_blob": "a05f31f7935be93d062868186414c969ac7325fe", + "sha256": "6bf3745c39efb6efae3f251af3f2cf4b9a4daab74e66f4d1920024cc13112e6a" + }, + { + "local_path": "source/pr5739/NOTICE", + "path": "research/p104-block-reframe-r22/NOTICE", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/NOTICE", + "git_blob": "36c1b859be8f5c1325811e633ac51149e1cd7bc0", + "sha256": "a252225cb4d9c61fc94b5b7f638600393a859e47750cfea7688c75b1f6610077" + }, + { + "local_path": "source/pr5739/RESULT.json", + "path": "research/p104-block-reframe-r22/RESULT.json", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/RESULT.json", + "git_blob": "02fe0978d02f46ccfd26ed0a0563eea9eec34b61", + "sha256": "af9e2c9adb6d67ddbbb34a4917b4594151e94904987d362a133748695a91e098" + } +] diff --git a/research/p104-split-block-composition/HUNKS.json b/research/p104-split-block-composition/HUNKS.json new file mode 100644 index 0000000000..bf90ff3d03 --- /dev/null +++ b/research/p104-split-block-composition/HUNKS.json @@ -0,0 +1,42 @@ +[ + { + "index": 12274, + "new_length": 109, + "old_length": 104 + }, + { + "index": 12871, + "new_length": 0, + "old_length": 1 + }, + { + "index": 12884, + "new_length": 0, + "old_length": 1 + }, + { + "index": 12897, + "new_length": 0, + "old_length": 1 + }, + { + "index": 12909, + "new_length": 2, + "old_length": 1 + }, + { + "index": 20806, + "new_length": 1, + "old_length": 2 + }, + { + "index": 20851, + "new_length": 0, + "old_length": 1 + }, + { + "index": 22170, + "new_length": 1, + "old_length": 1 + } +] diff --git a/research/p104-split-block-composition/INTERVAL.json b/research/p104-split-block-composition/INTERVAL.json new file mode 100644 index 0000000000..54d2df0837 --- /dev/null +++ b/research/p104-split-block-composition/INTERVAL.json @@ -0,0 +1,5335 @@ +{ + "lower": [ + 0, + 45, + 75, + 102, + 137, + 164, + 194, + 239, + 265, + 292, + 322, + 367, + 384, + 429, + 459, + 486 + ], + "paid_formula": "8 H_(d-3) + 7 H_(9-d) + H_(8-d), with H_0 = 0", + "subspaces": [ + [ + 0, + 45, + 75, + 102, + 137, + 164, + 194, + 239, + 265, + 292, + 322, + 367, + 384, + 429, + 459, + 486 + ], + [ + 0, + 3, + 45, + 46, + 72, + 75, + 101, + 102, + 137, + 138, + 164, + 167, + 193, + 194, + 236, + 239, + 265, + 266, + 292, + 295, + 321, + 322, + 364, + 367, + 384, + 387, + 429, + 430, + 456, + 459, + 485, + 486 + ], + [ + 0, + 5, + 40, + 45, + 75, + 78, + 99, + 102, + 137, + 140, + 161, + 164, + 194, + 199, + 234, + 239, + 265, + 268, + 289, + 292, + 322, + 327, + 362, + 367, + 384, + 389, + 424, + 429, + 459, + 462, + 483, + 486 + ], + [ + 0, + 6, + 43, + 45, + 75, + 77, + 96, + 102, + 137, + 143, + 162, + 164, + 194, + 196, + 233, + 239, + 265, + 271, + 290, + 292, + 322, + 324, + 361, + 367, + 384, + 390, + 427, + 429, + 459, + 461, + 480, + 486 + ], + [ + 0, + 9, + 36, + 45, + 66, + 75, + 102, + 111, + 128, + 137, + 164, + 173, + 194, + 203, + 230, + 239, + 256, + 265, + 292, + 301, + 322, + 331, + 358, + 367, + 384, + 393, + 420, + 429, + 450, + 459, + 486, + 495 + ], + [ + 0, + 10, + 39, + 45, + 65, + 75, + 102, + 108, + 131, + 137, + 164, + 174, + 194, + 200, + 229, + 239, + 259, + 265, + 292, + 302, + 322, + 328, + 357, + 367, + 384, + 394, + 423, + 429, + 449, + 459, + 486, + 492 + ], + [ + 0, + 12, + 33, + 45, + 71, + 75, + 102, + 106, + 133, + 137, + 164, + 168, + 194, + 206, + 227, + 239, + 261, + 265, + 292, + 296, + 322, + 334, + 355, + 367, + 384, + 396, + 417, + 429, + 455, + 459, + 486, + 490 + ], + [ + 0, + 15, + 34, + 45, + 68, + 75, + 102, + 105, + 134, + 137, + 164, + 171, + 194, + 205, + 224, + 239, + 262, + 265, + 292, + 299, + 322, + 333, + 352, + 367, + 384, + 399, + 418, + 429, + 452, + 459, + 486, + 489 + ], + [ + 0, + 17, + 45, + 60, + 75, + 90, + 102, + 119, + 137, + 152, + 164, + 181, + 194, + 211, + 239, + 254, + 265, + 280, + 292, + 309, + 322, + 339, + 367, + 382, + 384, + 401, + 429, + 444, + 459, + 474, + 486, + 503 + ], + [ + 0, + 18, + 45, + 63, + 75, + 89, + 102, + 116, + 137, + 155, + 164, + 182, + 194, + 208, + 239, + 253, + 265, + 283, + 292, + 310, + 322, + 336, + 367, + 381, + 384, + 402, + 429, + 447, + 459, + 473, + 486, + 500 + ], + [ + 0, + 20, + 45, + 57, + 75, + 95, + 102, + 114, + 137, + 157, + 164, + 176, + 194, + 214, + 239, + 251, + 265, + 285, + 292, + 304, + 322, + 342, + 367, + 379, + 384, + 404, + 429, + 441, + 459, + 479, + 486, + 498 + ], + [ + 0, + 23, + 45, + 58, + 75, + 92, + 102, + 113, + 137, + 158, + 164, + 179, + 194, + 213, + 239, + 248, + 265, + 286, + 292, + 307, + 322, + 341, + 367, + 376, + 384, + 407, + 429, + 442, + 459, + 476, + 486, + 497 + ], + [ + 0, + 24, + 45, + 53, + 75, + 83, + 102, + 126, + 137, + 145, + 164, + 188, + 194, + 218, + 239, + 247, + 265, + 273, + 292, + 316, + 322, + 346, + 367, + 375, + 384, + 408, + 429, + 437, + 459, + 467, + 486, + 510 + ], + [ + 0, + 27, + 45, + 54, + 75, + 80, + 102, + 125, + 137, + 146, + 164, + 191, + 194, + 217, + 239, + 244, + 265, + 274, + 292, + 319, + 322, + 345, + 367, + 372, + 384, + 411, + 429, + 438, + 459, + 464, + 486, + 509 + ], + [ + 0, + 29, + 45, + 48, + 75, + 86, + 102, + 123, + 137, + 148, + 164, + 185, + 194, + 223, + 239, + 242, + 265, + 276, + 292, + 313, + 322, + 351, + 367, + 370, + 384, + 413, + 429, + 432, + 459, + 470, + 486, + 507 + ], + [ + 0, + 30, + 45, + 51, + 75, + 85, + 102, + 120, + 137, + 151, + 164, + 186, + 194, + 220, + 239, + 241, + 265, + 279, + 292, + 314, + 322, + 348, + 367, + 369, + 384, + 414, + 429, + 435, + 459, + 469, + 486, + 504 + ], + [ + 0, + 3, + 5, + 6, + 40, + 43, + 45, + 46, + 72, + 75, + 77, + 78, + 96, + 99, + 101, + 102, + 137, + 138, + 140, + 143, + 161, + 162, + 164, + 167, + 193, + 194, + 196, + 199, + 233, + 234, + 236, + 239, + 265, + 266, + 268, + 271, + 289, + 290, + 292, + 295, + 321, + 322, + 324, + 327, + 361, + 362, + 364, + 367, + 384, + 387, + 389, + 390, + 424, + 427, + 429, + 430, + 456, + 459, + 461, + 462, + 480, + 483, + 485, + 486 + ], + [ + 0, + 3, + 9, + 10, + 36, + 39, + 45, + 46, + 65, + 66, + 72, + 75, + 101, + 102, + 108, + 111, + 128, + 131, + 137, + 138, + 164, + 167, + 173, + 174, + 193, + 194, + 200, + 203, + 229, + 230, + 236, + 239, + 256, + 259, + 265, + 266, + 292, + 295, + 301, + 302, + 321, + 322, + 328, + 331, + 357, + 358, + 364, + 367, + 384, + 387, + 393, + 394, + 420, + 423, + 429, + 430, + 449, + 450, + 456, + 459, + 485, + 486, + 492, + 495 + ], + [ + 0, + 3, + 12, + 15, + 33, + 34, + 45, + 46, + 68, + 71, + 72, + 75, + 101, + 102, + 105, + 106, + 133, + 134, + 137, + 138, + 164, + 167, + 168, + 171, + 193, + 194, + 205, + 206, + 224, + 227, + 236, + 239, + 261, + 262, + 265, + 266, + 292, + 295, + 296, + 299, + 321, + 322, + 333, + 334, + 352, + 355, + 364, + 367, + 384, + 387, + 396, + 399, + 417, + 418, + 429, + 430, + 452, + 455, + 456, + 459, + 485, + 486, + 489, + 490 + ], + [ + 0, + 3, + 17, + 18, + 45, + 46, + 60, + 63, + 72, + 75, + 89, + 90, + 101, + 102, + 116, + 119, + 137, + 138, + 152, + 155, + 164, + 167, + 181, + 182, + 193, + 194, + 208, + 211, + 236, + 239, + 253, + 254, + 265, + 266, + 280, + 283, + 292, + 295, + 309, + 310, + 321, + 322, + 336, + 339, + 364, + 367, + 381, + 382, + 384, + 387, + 401, + 402, + 429, + 430, + 444, + 447, + 456, + 459, + 473, + 474, + 485, + 486, + 500, + 503 + ], + [ + 0, + 3, + 20, + 23, + 45, + 46, + 57, + 58, + 72, + 75, + 92, + 95, + 101, + 102, + 113, + 114, + 137, + 138, + 157, + 158, + 164, + 167, + 176, + 179, + 193, + 194, + 213, + 214, + 236, + 239, + 248, + 251, + 265, + 266, + 285, + 286, + 292, + 295, + 304, + 307, + 321, + 322, + 341, + 342, + 364, + 367, + 376, + 379, + 384, + 387, + 404, + 407, + 429, + 430, + 441, + 442, + 456, + 459, + 476, + 479, + 485, + 486, + 497, + 498 + ], + [ + 0, + 3, + 24, + 27, + 45, + 46, + 53, + 54, + 72, + 75, + 80, + 83, + 101, + 102, + 125, + 126, + 137, + 138, + 145, + 146, + 164, + 167, + 188, + 191, + 193, + 194, + 217, + 218, + 236, + 239, + 244, + 247, + 265, + 266, + 273, + 274, + 292, + 295, + 316, + 319, + 321, + 322, + 345, + 346, + 364, + 367, + 372, + 375, + 384, + 387, + 408, + 411, + 429, + 430, + 437, + 438, + 456, + 459, + 464, + 467, + 485, + 486, + 509, + 510 + ], + [ + 0, + 3, + 29, + 30, + 45, + 46, + 48, + 51, + 72, + 75, + 85, + 86, + 101, + 102, + 120, + 123, + 137, + 138, + 148, + 151, + 164, + 167, + 185, + 186, + 193, + 194, + 220, + 223, + 236, + 239, + 241, + 242, + 265, + 266, + 276, + 279, + 292, + 295, + 313, + 314, + 321, + 322, + 348, + 351, + 364, + 367, + 369, + 370, + 384, + 387, + 413, + 414, + 429, + 430, + 432, + 435, + 456, + 459, + 469, + 470, + 485, + 486, + 504, + 507 + ], + [ + 0, + 5, + 9, + 12, + 33, + 36, + 40, + 45, + 66, + 71, + 75, + 78, + 99, + 102, + 106, + 111, + 128, + 133, + 137, + 140, + 161, + 164, + 168, + 173, + 194, + 199, + 203, + 206, + 227, + 230, + 234, + 239, + 256, + 261, + 265, + 268, + 289, + 292, + 296, + 301, + 322, + 327, + 331, + 334, + 355, + 358, + 362, + 367, + 384, + 389, + 393, + 396, + 417, + 420, + 424, + 429, + 450, + 455, + 459, + 462, + 483, + 486, + 490, + 495 + ], + [ + 0, + 5, + 10, + 15, + 34, + 39, + 40, + 45, + 65, + 68, + 75, + 78, + 99, + 102, + 105, + 108, + 131, + 134, + 137, + 140, + 161, + 164, + 171, + 174, + 194, + 199, + 200, + 205, + 224, + 229, + 234, + 239, + 259, + 262, + 265, + 268, + 289, + 292, + 299, + 302, + 322, + 327, + 328, + 333, + 352, + 357, + 362, + 367, + 384, + 389, + 394, + 399, + 418, + 423, + 424, + 429, + 449, + 452, + 459, + 462, + 483, + 486, + 489, + 492 + ], + [ + 0, + 5, + 17, + 20, + 40, + 45, + 57, + 60, + 75, + 78, + 90, + 95, + 99, + 102, + 114, + 119, + 137, + 140, + 152, + 157, + 161, + 164, + 176, + 181, + 194, + 199, + 211, + 214, + 234, + 239, + 251, + 254, + 265, + 268, + 280, + 285, + 289, + 292, + 304, + 309, + 322, + 327, + 339, + 342, + 362, + 367, + 379, + 382, + 384, + 389, + 401, + 404, + 424, + 429, + 441, + 444, + 459, + 462, + 474, + 479, + 483, + 486, + 498, + 503 + ], + [ + 0, + 5, + 18, + 23, + 40, + 45, + 58, + 63, + 75, + 78, + 89, + 92, + 99, + 102, + 113, + 116, + 137, + 140, + 155, + 158, + 161, + 164, + 179, + 182, + 194, + 199, + 208, + 213, + 234, + 239, + 248, + 253, + 265, + 268, + 283, + 286, + 289, + 292, + 307, + 310, + 322, + 327, + 336, + 341, + 362, + 367, + 376, + 381, + 384, + 389, + 402, + 407, + 424, + 429, + 442, + 447, + 459, + 462, + 473, + 476, + 483, + 486, + 497, + 500 + ], + [ + 0, + 5, + 24, + 29, + 40, + 45, + 48, + 53, + 75, + 78, + 83, + 86, + 99, + 102, + 123, + 126, + 137, + 140, + 145, + 148, + 161, + 164, + 185, + 188, + 194, + 199, + 218, + 223, + 234, + 239, + 242, + 247, + 265, + 268, + 273, + 276, + 289, + 292, + 313, + 316, + 322, + 327, + 346, + 351, + 362, + 367, + 370, + 375, + 384, + 389, + 408, + 413, + 424, + 429, + 432, + 437, + 459, + 462, + 467, + 470, + 483, + 486, + 507, + 510 + ], + [ + 0, + 5, + 27, + 30, + 40, + 45, + 51, + 54, + 75, + 78, + 80, + 85, + 99, + 102, + 120, + 125, + 137, + 140, + 146, + 151, + 161, + 164, + 186, + 191, + 194, + 199, + 217, + 220, + 234, + 239, + 241, + 244, + 265, + 268, + 274, + 279, + 289, + 292, + 314, + 319, + 322, + 327, + 345, + 348, + 362, + 367, + 369, + 372, + 384, + 389, + 411, + 414, + 424, + 429, + 435, + 438, + 459, + 462, + 464, + 469, + 483, + 486, + 504, + 509 + ], + [ + 0, + 6, + 9, + 15, + 34, + 36, + 43, + 45, + 66, + 68, + 75, + 77, + 96, + 102, + 105, + 111, + 128, + 134, + 137, + 143, + 162, + 164, + 171, + 173, + 194, + 196, + 203, + 205, + 224, + 230, + 233, + 239, + 256, + 262, + 265, + 271, + 290, + 292, + 299, + 301, + 322, + 324, + 331, + 333, + 352, + 358, + 361, + 367, + 384, + 390, + 393, + 399, + 418, + 420, + 427, + 429, + 450, + 452, + 459, + 461, + 480, + 486, + 489, + 495 + ], + [ + 0, + 6, + 10, + 12, + 33, + 39, + 43, + 45, + 65, + 71, + 75, + 77, + 96, + 102, + 106, + 108, + 131, + 133, + 137, + 143, + 162, + 164, + 168, + 174, + 194, + 196, + 200, + 206, + 227, + 229, + 233, + 239, + 259, + 261, + 265, + 271, + 290, + 292, + 296, + 302, + 322, + 324, + 328, + 334, + 355, + 357, + 361, + 367, + 384, + 390, + 394, + 396, + 417, + 423, + 427, + 429, + 449, + 455, + 459, + 461, + 480, + 486, + 490, + 492 + ], + [ + 0, + 6, + 17, + 23, + 43, + 45, + 58, + 60, + 75, + 77, + 90, + 92, + 96, + 102, + 113, + 119, + 137, + 143, + 152, + 158, + 162, + 164, + 179, + 181, + 194, + 196, + 211, + 213, + 233, + 239, + 248, + 254, + 265, + 271, + 280, + 286, + 290, + 292, + 307, + 309, + 322, + 324, + 339, + 341, + 361, + 367, + 376, + 382, + 384, + 390, + 401, + 407, + 427, + 429, + 442, + 444, + 459, + 461, + 474, + 476, + 480, + 486, + 497, + 503 + ], + [ + 0, + 6, + 18, + 20, + 43, + 45, + 57, + 63, + 75, + 77, + 89, + 95, + 96, + 102, + 114, + 116, + 137, + 143, + 155, + 157, + 162, + 164, + 176, + 182, + 194, + 196, + 208, + 214, + 233, + 239, + 251, + 253, + 265, + 271, + 283, + 285, + 290, + 292, + 304, + 310, + 322, + 324, + 336, + 342, + 361, + 367, + 379, + 381, + 384, + 390, + 402, + 404, + 427, + 429, + 441, + 447, + 459, + 461, + 473, + 479, + 480, + 486, + 498, + 500 + ], + [ + 0, + 6, + 24, + 30, + 43, + 45, + 51, + 53, + 75, + 77, + 83, + 85, + 96, + 102, + 120, + 126, + 137, + 143, + 145, + 151, + 162, + 164, + 186, + 188, + 194, + 196, + 218, + 220, + 233, + 239, + 241, + 247, + 265, + 271, + 273, + 279, + 290, + 292, + 314, + 316, + 322, + 324, + 346, + 348, + 361, + 367, + 369, + 375, + 384, + 390, + 408, + 414, + 427, + 429, + 435, + 437, + 459, + 461, + 467, + 469, + 480, + 486, + 504, + 510 + ], + [ + 0, + 6, + 27, + 29, + 43, + 45, + 48, + 54, + 75, + 77, + 80, + 86, + 96, + 102, + 123, + 125, + 137, + 143, + 146, + 148, + 162, + 164, + 185, + 191, + 194, + 196, + 217, + 223, + 233, + 239, + 242, + 244, + 265, + 271, + 274, + 276, + 290, + 292, + 313, + 319, + 322, + 324, + 345, + 351, + 361, + 367, + 370, + 372, + 384, + 390, + 411, + 413, + 427, + 429, + 432, + 438, + 459, + 461, + 464, + 470, + 480, + 486, + 507, + 509 + ], + [ + 0, + 9, + 17, + 24, + 36, + 45, + 53, + 60, + 66, + 75, + 83, + 90, + 102, + 111, + 119, + 126, + 128, + 137, + 145, + 152, + 164, + 173, + 181, + 188, + 194, + 203, + 211, + 218, + 230, + 239, + 247, + 254, + 256, + 265, + 273, + 280, + 292, + 301, + 309, + 316, + 322, + 331, + 339, + 346, + 358, + 367, + 375, + 382, + 384, + 393, + 401, + 408, + 420, + 429, + 437, + 444, + 450, + 459, + 467, + 474, + 486, + 495, + 503, + 510 + ], + [ + 0, + 9, + 18, + 27, + 36, + 45, + 54, + 63, + 66, + 75, + 80, + 89, + 102, + 111, + 116, + 125, + 128, + 137, + 146, + 155, + 164, + 173, + 182, + 191, + 194, + 203, + 208, + 217, + 230, + 239, + 244, + 253, + 256, + 265, + 274, + 283, + 292, + 301, + 310, + 319, + 322, + 331, + 336, + 345, + 358, + 367, + 372, + 381, + 384, + 393, + 402, + 411, + 420, + 429, + 438, + 447, + 450, + 459, + 464, + 473, + 486, + 495, + 500, + 509 + ], + [ + 0, + 9, + 20, + 29, + 36, + 45, + 48, + 57, + 66, + 75, + 86, + 95, + 102, + 111, + 114, + 123, + 128, + 137, + 148, + 157, + 164, + 173, + 176, + 185, + 194, + 203, + 214, + 223, + 230, + 239, + 242, + 251, + 256, + 265, + 276, + 285, + 292, + 301, + 304, + 313, + 322, + 331, + 342, + 351, + 358, + 367, + 370, + 379, + 384, + 393, + 404, + 413, + 420, + 429, + 432, + 441, + 450, + 459, + 470, + 479, + 486, + 495, + 498, + 507 + ], + [ + 0, + 9, + 23, + 30, + 36, + 45, + 51, + 58, + 66, + 75, + 85, + 92, + 102, + 111, + 113, + 120, + 128, + 137, + 151, + 158, + 164, + 173, + 179, + 186, + 194, + 203, + 213, + 220, + 230, + 239, + 241, + 248, + 256, + 265, + 279, + 286, + 292, + 301, + 307, + 314, + 322, + 331, + 341, + 348, + 358, + 367, + 369, + 376, + 384, + 393, + 407, + 414, + 420, + 429, + 435, + 442, + 450, + 459, + 469, + 476, + 486, + 495, + 497, + 504 + ], + [ + 0, + 10, + 17, + 27, + 39, + 45, + 54, + 60, + 65, + 75, + 80, + 90, + 102, + 108, + 119, + 125, + 131, + 137, + 146, + 152, + 164, + 174, + 181, + 191, + 194, + 200, + 211, + 217, + 229, + 239, + 244, + 254, + 259, + 265, + 274, + 280, + 292, + 302, + 309, + 319, + 322, + 328, + 339, + 345, + 357, + 367, + 372, + 382, + 384, + 394, + 401, + 411, + 423, + 429, + 438, + 444, + 449, + 459, + 464, + 474, + 486, + 492, + 503, + 509 + ], + [ + 0, + 10, + 18, + 24, + 39, + 45, + 53, + 63, + 65, + 75, + 83, + 89, + 102, + 108, + 116, + 126, + 131, + 137, + 145, + 155, + 164, + 174, + 182, + 188, + 194, + 200, + 208, + 218, + 229, + 239, + 247, + 253, + 259, + 265, + 273, + 283, + 292, + 302, + 310, + 316, + 322, + 328, + 336, + 346, + 357, + 367, + 375, + 381, + 384, + 394, + 402, + 408, + 423, + 429, + 437, + 447, + 449, + 459, + 467, + 473, + 486, + 492, + 500, + 510 + ], + [ + 0, + 10, + 20, + 30, + 39, + 45, + 51, + 57, + 65, + 75, + 85, + 95, + 102, + 108, + 114, + 120, + 131, + 137, + 151, + 157, + 164, + 174, + 176, + 186, + 194, + 200, + 214, + 220, + 229, + 239, + 241, + 251, + 259, + 265, + 279, + 285, + 292, + 302, + 304, + 314, + 322, + 328, + 342, + 348, + 357, + 367, + 369, + 379, + 384, + 394, + 404, + 414, + 423, + 429, + 435, + 441, + 449, + 459, + 469, + 479, + 486, + 492, + 498, + 504 + ], + [ + 0, + 10, + 23, + 29, + 39, + 45, + 48, + 58, + 65, + 75, + 86, + 92, + 102, + 108, + 113, + 123, + 131, + 137, + 148, + 158, + 164, + 174, + 179, + 185, + 194, + 200, + 213, + 223, + 229, + 239, + 242, + 248, + 259, + 265, + 276, + 286, + 292, + 302, + 307, + 313, + 322, + 328, + 341, + 351, + 357, + 367, + 370, + 376, + 384, + 394, + 407, + 413, + 423, + 429, + 432, + 442, + 449, + 459, + 470, + 476, + 486, + 492, + 497, + 507 + ], + [ + 0, + 12, + 17, + 29, + 33, + 45, + 48, + 60, + 71, + 75, + 86, + 90, + 102, + 106, + 119, + 123, + 133, + 137, + 148, + 152, + 164, + 168, + 181, + 185, + 194, + 206, + 211, + 223, + 227, + 239, + 242, + 254, + 261, + 265, + 276, + 280, + 292, + 296, + 309, + 313, + 322, + 334, + 339, + 351, + 355, + 367, + 370, + 382, + 384, + 396, + 401, + 413, + 417, + 429, + 432, + 444, + 455, + 459, + 470, + 474, + 486, + 490, + 503, + 507 + ], + [ + 0, + 12, + 18, + 30, + 33, + 45, + 51, + 63, + 71, + 75, + 85, + 89, + 102, + 106, + 116, + 120, + 133, + 137, + 151, + 155, + 164, + 168, + 182, + 186, + 194, + 206, + 208, + 220, + 227, + 239, + 241, + 253, + 261, + 265, + 279, + 283, + 292, + 296, + 310, + 314, + 322, + 334, + 336, + 348, + 355, + 367, + 369, + 381, + 384, + 396, + 402, + 414, + 417, + 429, + 435, + 447, + 455, + 459, + 469, + 473, + 486, + 490, + 500, + 504 + ], + [ + 0, + 12, + 20, + 24, + 33, + 45, + 53, + 57, + 71, + 75, + 83, + 95, + 102, + 106, + 114, + 126, + 133, + 137, + 145, + 157, + 164, + 168, + 176, + 188, + 194, + 206, + 214, + 218, + 227, + 239, + 247, + 251, + 261, + 265, + 273, + 285, + 292, + 296, + 304, + 316, + 322, + 334, + 342, + 346, + 355, + 367, + 375, + 379, + 384, + 396, + 404, + 408, + 417, + 429, + 437, + 441, + 455, + 459, + 467, + 479, + 486, + 490, + 498, + 510 + ], + [ + 0, + 12, + 23, + 27, + 33, + 45, + 54, + 58, + 71, + 75, + 80, + 92, + 102, + 106, + 113, + 125, + 133, + 137, + 146, + 158, + 164, + 168, + 179, + 191, + 194, + 206, + 213, + 217, + 227, + 239, + 244, + 248, + 261, + 265, + 274, + 286, + 292, + 296, + 307, + 319, + 322, + 334, + 341, + 345, + 355, + 367, + 372, + 376, + 384, + 396, + 407, + 411, + 417, + 429, + 438, + 442, + 455, + 459, + 464, + 476, + 486, + 490, + 497, + 509 + ], + [ + 0, + 15, + 17, + 30, + 34, + 45, + 51, + 60, + 68, + 75, + 85, + 90, + 102, + 105, + 119, + 120, + 134, + 137, + 151, + 152, + 164, + 171, + 181, + 186, + 194, + 205, + 211, + 220, + 224, + 239, + 241, + 254, + 262, + 265, + 279, + 280, + 292, + 299, + 309, + 314, + 322, + 333, + 339, + 348, + 352, + 367, + 369, + 382, + 384, + 399, + 401, + 414, + 418, + 429, + 435, + 444, + 452, + 459, + 469, + 474, + 486, + 489, + 503, + 504 + ], + [ + 0, + 15, + 18, + 29, + 34, + 45, + 48, + 63, + 68, + 75, + 86, + 89, + 102, + 105, + 116, + 123, + 134, + 137, + 148, + 155, + 164, + 171, + 182, + 185, + 194, + 205, + 208, + 223, + 224, + 239, + 242, + 253, + 262, + 265, + 276, + 283, + 292, + 299, + 310, + 313, + 322, + 333, + 336, + 351, + 352, + 367, + 370, + 381, + 384, + 399, + 402, + 413, + 418, + 429, + 432, + 447, + 452, + 459, + 470, + 473, + 486, + 489, + 500, + 507 + ], + [ + 0, + 15, + 20, + 27, + 34, + 45, + 54, + 57, + 68, + 75, + 80, + 95, + 102, + 105, + 114, + 125, + 134, + 137, + 146, + 157, + 164, + 171, + 176, + 191, + 194, + 205, + 214, + 217, + 224, + 239, + 244, + 251, + 262, + 265, + 274, + 285, + 292, + 299, + 304, + 319, + 322, + 333, + 342, + 345, + 352, + 367, + 372, + 379, + 384, + 399, + 404, + 411, + 418, + 429, + 438, + 441, + 452, + 459, + 464, + 479, + 486, + 489, + 498, + 509 + ], + [ + 0, + 15, + 23, + 24, + 34, + 45, + 53, + 58, + 68, + 75, + 83, + 92, + 102, + 105, + 113, + 126, + 134, + 137, + 145, + 158, + 164, + 171, + 179, + 188, + 194, + 205, + 213, + 218, + 224, + 239, + 247, + 248, + 262, + 265, + 273, + 286, + 292, + 299, + 307, + 316, + 322, + 333, + 341, + 346, + 352, + 367, + 375, + 376, + 384, + 399, + 407, + 408, + 418, + 429, + 437, + 442, + 452, + 459, + 467, + 476, + 486, + 489, + 497, + 510 + ], + [ + 0, + 3, + 5, + 6, + 9, + 10, + 12, + 15, + 33, + 34, + 36, + 39, + 40, + 43, + 45, + 46, + 65, + 66, + 68, + 71, + 72, + 75, + 77, + 78, + 96, + 99, + 101, + 102, + 105, + 106, + 108, + 111, + 128, + 131, + 133, + 134, + 137, + 138, + 140, + 143, + 161, + 162, + 164, + 167, + 168, + 171, + 173, + 174, + 193, + 194, + 196, + 199, + 200, + 203, + 205, + 206, + 224, + 227, + 229, + 230, + 233, + 234, + 236, + 239, + 256, + 259, + 261, + 262, + 265, + 266, + 268, + 271, + 289, + 290, + 292, + 295, + 296, + 299, + 301, + 302, + 321, + 322, + 324, + 327, + 328, + 331, + 333, + 334, + 352, + 355, + 357, + 358, + 361, + 362, + 364, + 367, + 384, + 387, + 389, + 390, + 393, + 394, + 396, + 399, + 417, + 418, + 420, + 423, + 424, + 427, + 429, + 430, + 449, + 450, + 452, + 455, + 456, + 459, + 461, + 462, + 480, + 483, + 485, + 486, + 489, + 490, + 492, + 495 + ], + [ + 0, + 3, + 5, + 6, + 17, + 18, + 20, + 23, + 40, + 43, + 45, + 46, + 57, + 58, + 60, + 63, + 72, + 75, + 77, + 78, + 89, + 90, + 92, + 95, + 96, + 99, + 101, + 102, + 113, + 114, + 116, + 119, + 137, + 138, + 140, + 143, + 152, + 155, + 157, + 158, + 161, + 162, + 164, + 167, + 176, + 179, + 181, + 182, + 193, + 194, + 196, + 199, + 208, + 211, + 213, + 214, + 233, + 234, + 236, + 239, + 248, + 251, + 253, + 254, + 265, + 266, + 268, + 271, + 280, + 283, + 285, + 286, + 289, + 290, + 292, + 295, + 304, + 307, + 309, + 310, + 321, + 322, + 324, + 327, + 336, + 339, + 341, + 342, + 361, + 362, + 364, + 367, + 376, + 379, + 381, + 382, + 384, + 387, + 389, + 390, + 401, + 402, + 404, + 407, + 424, + 427, + 429, + 430, + 441, + 442, + 444, + 447, + 456, + 459, + 461, + 462, + 473, + 474, + 476, + 479, + 480, + 483, + 485, + 486, + 497, + 498, + 500, + 503 + ], + [ + 0, + 3, + 5, + 6, + 24, + 27, + 29, + 30, + 40, + 43, + 45, + 46, + 48, + 51, + 53, + 54, + 72, + 75, + 77, + 78, + 80, + 83, + 85, + 86, + 96, + 99, + 101, + 102, + 120, + 123, + 125, + 126, + 137, + 138, + 140, + 143, + 145, + 146, + 148, + 151, + 161, + 162, + 164, + 167, + 185, + 186, + 188, + 191, + 193, + 194, + 196, + 199, + 217, + 218, + 220, + 223, + 233, + 234, + 236, + 239, + 241, + 242, + 244, + 247, + 265, + 266, + 268, + 271, + 273, + 274, + 276, + 279, + 289, + 290, + 292, + 295, + 313, + 314, + 316, + 319, + 321, + 322, + 324, + 327, + 345, + 346, + 348, + 351, + 361, + 362, + 364, + 367, + 369, + 370, + 372, + 375, + 384, + 387, + 389, + 390, + 408, + 411, + 413, + 414, + 424, + 427, + 429, + 430, + 432, + 435, + 437, + 438, + 456, + 459, + 461, + 462, + 464, + 467, + 469, + 470, + 480, + 483, + 485, + 486, + 504, + 507, + 509, + 510 + ], + [ + 0, + 3, + 9, + 10, + 17, + 18, + 24, + 27, + 36, + 39, + 45, + 46, + 53, + 54, + 60, + 63, + 65, + 66, + 72, + 75, + 80, + 83, + 89, + 90, + 101, + 102, + 108, + 111, + 116, + 119, + 125, + 126, + 128, + 131, + 137, + 138, + 145, + 146, + 152, + 155, + 164, + 167, + 173, + 174, + 181, + 182, + 188, + 191, + 193, + 194, + 200, + 203, + 208, + 211, + 217, + 218, + 229, + 230, + 236, + 239, + 244, + 247, + 253, + 254, + 256, + 259, + 265, + 266, + 273, + 274, + 280, + 283, + 292, + 295, + 301, + 302, + 309, + 310, + 316, + 319, + 321, + 322, + 328, + 331, + 336, + 339, + 345, + 346, + 357, + 358, + 364, + 367, + 372, + 375, + 381, + 382, + 384, + 387, + 393, + 394, + 401, + 402, + 408, + 411, + 420, + 423, + 429, + 430, + 437, + 438, + 444, + 447, + 449, + 450, + 456, + 459, + 464, + 467, + 473, + 474, + 485, + 486, + 492, + 495, + 500, + 503, + 509, + 510 + ], + [ + 0, + 3, + 9, + 10, + 20, + 23, + 29, + 30, + 36, + 39, + 45, + 46, + 48, + 51, + 57, + 58, + 65, + 66, + 72, + 75, + 85, + 86, + 92, + 95, + 101, + 102, + 108, + 111, + 113, + 114, + 120, + 123, + 128, + 131, + 137, + 138, + 148, + 151, + 157, + 158, + 164, + 167, + 173, + 174, + 176, + 179, + 185, + 186, + 193, + 194, + 200, + 203, + 213, + 214, + 220, + 223, + 229, + 230, + 236, + 239, + 241, + 242, + 248, + 251, + 256, + 259, + 265, + 266, + 276, + 279, + 285, + 286, + 292, + 295, + 301, + 302, + 304, + 307, + 313, + 314, + 321, + 322, + 328, + 331, + 341, + 342, + 348, + 351, + 357, + 358, + 364, + 367, + 369, + 370, + 376, + 379, + 384, + 387, + 393, + 394, + 404, + 407, + 413, + 414, + 420, + 423, + 429, + 430, + 432, + 435, + 441, + 442, + 449, + 450, + 456, + 459, + 469, + 470, + 476, + 479, + 485, + 486, + 492, + 495, + 497, + 498, + 504, + 507 + ], + [ + 0, + 3, + 12, + 15, + 17, + 18, + 29, + 30, + 33, + 34, + 45, + 46, + 48, + 51, + 60, + 63, + 68, + 71, + 72, + 75, + 85, + 86, + 89, + 90, + 101, + 102, + 105, + 106, + 116, + 119, + 120, + 123, + 133, + 134, + 137, + 138, + 148, + 151, + 152, + 155, + 164, + 167, + 168, + 171, + 181, + 182, + 185, + 186, + 193, + 194, + 205, + 206, + 208, + 211, + 220, + 223, + 224, + 227, + 236, + 239, + 241, + 242, + 253, + 254, + 261, + 262, + 265, + 266, + 276, + 279, + 280, + 283, + 292, + 295, + 296, + 299, + 309, + 310, + 313, + 314, + 321, + 322, + 333, + 334, + 336, + 339, + 348, + 351, + 352, + 355, + 364, + 367, + 369, + 370, + 381, + 382, + 384, + 387, + 396, + 399, + 401, + 402, + 413, + 414, + 417, + 418, + 429, + 430, + 432, + 435, + 444, + 447, + 452, + 455, + 456, + 459, + 469, + 470, + 473, + 474, + 485, + 486, + 489, + 490, + 500, + 503, + 504, + 507 + ], + [ + 0, + 3, + 12, + 15, + 20, + 23, + 24, + 27, + 33, + 34, + 45, + 46, + 53, + 54, + 57, + 58, + 68, + 71, + 72, + 75, + 80, + 83, + 92, + 95, + 101, + 102, + 105, + 106, + 113, + 114, + 125, + 126, + 133, + 134, + 137, + 138, + 145, + 146, + 157, + 158, + 164, + 167, + 168, + 171, + 176, + 179, + 188, + 191, + 193, + 194, + 205, + 206, + 213, + 214, + 217, + 218, + 224, + 227, + 236, + 239, + 244, + 247, + 248, + 251, + 261, + 262, + 265, + 266, + 273, + 274, + 285, + 286, + 292, + 295, + 296, + 299, + 304, + 307, + 316, + 319, + 321, + 322, + 333, + 334, + 341, + 342, + 345, + 346, + 352, + 355, + 364, + 367, + 372, + 375, + 376, + 379, + 384, + 387, + 396, + 399, + 404, + 407, + 408, + 411, + 417, + 418, + 429, + 430, + 437, + 438, + 441, + 442, + 452, + 455, + 456, + 459, + 464, + 467, + 476, + 479, + 485, + 486, + 489, + 490, + 497, + 498, + 509, + 510 + ], + [ + 0, + 5, + 9, + 12, + 17, + 20, + 24, + 29, + 33, + 36, + 40, + 45, + 48, + 53, + 57, + 60, + 66, + 71, + 75, + 78, + 83, + 86, + 90, + 95, + 99, + 102, + 106, + 111, + 114, + 119, + 123, + 126, + 128, + 133, + 137, + 140, + 145, + 148, + 152, + 157, + 161, + 164, + 168, + 173, + 176, + 181, + 185, + 188, + 194, + 199, + 203, + 206, + 211, + 214, + 218, + 223, + 227, + 230, + 234, + 239, + 242, + 247, + 251, + 254, + 256, + 261, + 265, + 268, + 273, + 276, + 280, + 285, + 289, + 292, + 296, + 301, + 304, + 309, + 313, + 316, + 322, + 327, + 331, + 334, + 339, + 342, + 346, + 351, + 355, + 358, + 362, + 367, + 370, + 375, + 379, + 382, + 384, + 389, + 393, + 396, + 401, + 404, + 408, + 413, + 417, + 420, + 424, + 429, + 432, + 437, + 441, + 444, + 450, + 455, + 459, + 462, + 467, + 470, + 474, + 479, + 483, + 486, + 490, + 495, + 498, + 503, + 507, + 510 + ], + [ + 0, + 5, + 9, + 12, + 18, + 23, + 27, + 30, + 33, + 36, + 40, + 45, + 51, + 54, + 58, + 63, + 66, + 71, + 75, + 78, + 80, + 85, + 89, + 92, + 99, + 102, + 106, + 111, + 113, + 116, + 120, + 125, + 128, + 133, + 137, + 140, + 146, + 151, + 155, + 158, + 161, + 164, + 168, + 173, + 179, + 182, + 186, + 191, + 194, + 199, + 203, + 206, + 208, + 213, + 217, + 220, + 227, + 230, + 234, + 239, + 241, + 244, + 248, + 253, + 256, + 261, + 265, + 268, + 274, + 279, + 283, + 286, + 289, + 292, + 296, + 301, + 307, + 310, + 314, + 319, + 322, + 327, + 331, + 334, + 336, + 341, + 345, + 348, + 355, + 358, + 362, + 367, + 369, + 372, + 376, + 381, + 384, + 389, + 393, + 396, + 402, + 407, + 411, + 414, + 417, + 420, + 424, + 429, + 435, + 438, + 442, + 447, + 450, + 455, + 459, + 462, + 464, + 469, + 473, + 476, + 483, + 486, + 490, + 495, + 497, + 500, + 504, + 509 + ], + [ + 0, + 5, + 10, + 15, + 17, + 20, + 27, + 30, + 34, + 39, + 40, + 45, + 51, + 54, + 57, + 60, + 65, + 68, + 75, + 78, + 80, + 85, + 90, + 95, + 99, + 102, + 105, + 108, + 114, + 119, + 120, + 125, + 131, + 134, + 137, + 140, + 146, + 151, + 152, + 157, + 161, + 164, + 171, + 174, + 176, + 181, + 186, + 191, + 194, + 199, + 200, + 205, + 211, + 214, + 217, + 220, + 224, + 229, + 234, + 239, + 241, + 244, + 251, + 254, + 259, + 262, + 265, + 268, + 274, + 279, + 280, + 285, + 289, + 292, + 299, + 302, + 304, + 309, + 314, + 319, + 322, + 327, + 328, + 333, + 339, + 342, + 345, + 348, + 352, + 357, + 362, + 367, + 369, + 372, + 379, + 382, + 384, + 389, + 394, + 399, + 401, + 404, + 411, + 414, + 418, + 423, + 424, + 429, + 435, + 438, + 441, + 444, + 449, + 452, + 459, + 462, + 464, + 469, + 474, + 479, + 483, + 486, + 489, + 492, + 498, + 503, + 504, + 509 + ], + [ + 0, + 5, + 10, + 15, + 18, + 23, + 24, + 29, + 34, + 39, + 40, + 45, + 48, + 53, + 58, + 63, + 65, + 68, + 75, + 78, + 83, + 86, + 89, + 92, + 99, + 102, + 105, + 108, + 113, + 116, + 123, + 126, + 131, + 134, + 137, + 140, + 145, + 148, + 155, + 158, + 161, + 164, + 171, + 174, + 179, + 182, + 185, + 188, + 194, + 199, + 200, + 205, + 208, + 213, + 218, + 223, + 224, + 229, + 234, + 239, + 242, + 247, + 248, + 253, + 259, + 262, + 265, + 268, + 273, + 276, + 283, + 286, + 289, + 292, + 299, + 302, + 307, + 310, + 313, + 316, + 322, + 327, + 328, + 333, + 336, + 341, + 346, + 351, + 352, + 357, + 362, + 367, + 370, + 375, + 376, + 381, + 384, + 389, + 394, + 399, + 402, + 407, + 408, + 413, + 418, + 423, + 424, + 429, + 432, + 437, + 442, + 447, + 449, + 452, + 459, + 462, + 467, + 470, + 473, + 476, + 483, + 486, + 489, + 492, + 497, + 500, + 507, + 510 + ], + [ + 0, + 6, + 9, + 15, + 17, + 23, + 24, + 30, + 34, + 36, + 43, + 45, + 51, + 53, + 58, + 60, + 66, + 68, + 75, + 77, + 83, + 85, + 90, + 92, + 96, + 102, + 105, + 111, + 113, + 119, + 120, + 126, + 128, + 134, + 137, + 143, + 145, + 151, + 152, + 158, + 162, + 164, + 171, + 173, + 179, + 181, + 186, + 188, + 194, + 196, + 203, + 205, + 211, + 213, + 218, + 220, + 224, + 230, + 233, + 239, + 241, + 247, + 248, + 254, + 256, + 262, + 265, + 271, + 273, + 279, + 280, + 286, + 290, + 292, + 299, + 301, + 307, + 309, + 314, + 316, + 322, + 324, + 331, + 333, + 339, + 341, + 346, + 348, + 352, + 358, + 361, + 367, + 369, + 375, + 376, + 382, + 384, + 390, + 393, + 399, + 401, + 407, + 408, + 414, + 418, + 420, + 427, + 429, + 435, + 437, + 442, + 444, + 450, + 452, + 459, + 461, + 467, + 469, + 474, + 476, + 480, + 486, + 489, + 495, + 497, + 503, + 504, + 510 + ], + [ + 0, + 6, + 9, + 15, + 18, + 20, + 27, + 29, + 34, + 36, + 43, + 45, + 48, + 54, + 57, + 63, + 66, + 68, + 75, + 77, + 80, + 86, + 89, + 95, + 96, + 102, + 105, + 111, + 114, + 116, + 123, + 125, + 128, + 134, + 137, + 143, + 146, + 148, + 155, + 157, + 162, + 164, + 171, + 173, + 176, + 182, + 185, + 191, + 194, + 196, + 203, + 205, + 208, + 214, + 217, + 223, + 224, + 230, + 233, + 239, + 242, + 244, + 251, + 253, + 256, + 262, + 265, + 271, + 274, + 276, + 283, + 285, + 290, + 292, + 299, + 301, + 304, + 310, + 313, + 319, + 322, + 324, + 331, + 333, + 336, + 342, + 345, + 351, + 352, + 358, + 361, + 367, + 370, + 372, + 379, + 381, + 384, + 390, + 393, + 399, + 402, + 404, + 411, + 413, + 418, + 420, + 427, + 429, + 432, + 438, + 441, + 447, + 450, + 452, + 459, + 461, + 464, + 470, + 473, + 479, + 480, + 486, + 489, + 495, + 498, + 500, + 507, + 509 + ], + [ + 0, + 6, + 10, + 12, + 17, + 23, + 27, + 29, + 33, + 39, + 43, + 45, + 48, + 54, + 58, + 60, + 65, + 71, + 75, + 77, + 80, + 86, + 90, + 92, + 96, + 102, + 106, + 108, + 113, + 119, + 123, + 125, + 131, + 133, + 137, + 143, + 146, + 148, + 152, + 158, + 162, + 164, + 168, + 174, + 179, + 181, + 185, + 191, + 194, + 196, + 200, + 206, + 211, + 213, + 217, + 223, + 227, + 229, + 233, + 239, + 242, + 244, + 248, + 254, + 259, + 261, + 265, + 271, + 274, + 276, + 280, + 286, + 290, + 292, + 296, + 302, + 307, + 309, + 313, + 319, + 322, + 324, + 328, + 334, + 339, + 341, + 345, + 351, + 355, + 357, + 361, + 367, + 370, + 372, + 376, + 382, + 384, + 390, + 394, + 396, + 401, + 407, + 411, + 413, + 417, + 423, + 427, + 429, + 432, + 438, + 442, + 444, + 449, + 455, + 459, + 461, + 464, + 470, + 474, + 476, + 480, + 486, + 490, + 492, + 497, + 503, + 507, + 509 + ], + [ + 0, + 6, + 10, + 12, + 18, + 20, + 24, + 30, + 33, + 39, + 43, + 45, + 51, + 53, + 57, + 63, + 65, + 71, + 75, + 77, + 83, + 85, + 89, + 95, + 96, + 102, + 106, + 108, + 114, + 116, + 120, + 126, + 131, + 133, + 137, + 143, + 145, + 151, + 155, + 157, + 162, + 164, + 168, + 174, + 176, + 182, + 186, + 188, + 194, + 196, + 200, + 206, + 208, + 214, + 218, + 220, + 227, + 229, + 233, + 239, + 241, + 247, + 251, + 253, + 259, + 261, + 265, + 271, + 273, + 279, + 283, + 285, + 290, + 292, + 296, + 302, + 304, + 310, + 314, + 316, + 322, + 324, + 328, + 334, + 336, + 342, + 346, + 348, + 355, + 357, + 361, + 367, + 369, + 375, + 379, + 381, + 384, + 390, + 394, + 396, + 402, + 404, + 408, + 414, + 417, + 423, + 427, + 429, + 435, + 437, + 441, + 447, + 449, + 455, + 459, + 461, + 467, + 469, + 473, + 479, + 480, + 486, + 490, + 492, + 498, + 500, + 504, + 510 + ], + [ + 0, + 3, + 5, + 6, + 9, + 10, + 12, + 15, + 17, + 18, + 20, + 23, + 24, + 27, + 29, + 30, + 33, + 34, + 36, + 39, + 40, + 43, + 45, + 46, + 48, + 51, + 53, + 54, + 57, + 58, + 60, + 63, + 65, + 66, + 68, + 71, + 72, + 75, + 77, + 78, + 80, + 83, + 85, + 86, + 89, + 90, + 92, + 95, + 96, + 99, + 101, + 102, + 105, + 106, + 108, + 111, + 113, + 114, + 116, + 119, + 120, + 123, + 125, + 126, + 128, + 131, + 133, + 134, + 137, + 138, + 140, + 143, + 145, + 146, + 148, + 151, + 152, + 155, + 157, + 158, + 161, + 162, + 164, + 167, + 168, + 171, + 173, + 174, + 176, + 179, + 181, + 182, + 185, + 186, + 188, + 191, + 193, + 194, + 196, + 199, + 200, + 203, + 205, + 206, + 208, + 211, + 213, + 214, + 217, + 218, + 220, + 223, + 224, + 227, + 229, + 230, + 233, + 234, + 236, + 239, + 241, + 242, + 244, + 247, + 248, + 251, + 253, + 254, + 256, + 259, + 261, + 262, + 265, + 266, + 268, + 271, + 273, + 274, + 276, + 279, + 280, + 283, + 285, + 286, + 289, + 290, + 292, + 295, + 296, + 299, + 301, + 302, + 304, + 307, + 309, + 310, + 313, + 314, + 316, + 319, + 321, + 322, + 324, + 327, + 328, + 331, + 333, + 334, + 336, + 339, + 341, + 342, + 345, + 346, + 348, + 351, + 352, + 355, + 357, + 358, + 361, + 362, + 364, + 367, + 369, + 370, + 372, + 375, + 376, + 379, + 381, + 382, + 384, + 387, + 389, + 390, + 393, + 394, + 396, + 399, + 401, + 402, + 404, + 407, + 408, + 411, + 413, + 414, + 417, + 418, + 420, + 423, + 424, + 427, + 429, + 430, + 432, + 435, + 437, + 438, + 441, + 442, + 444, + 447, + 449, + 450, + 452, + 455, + 456, + 459, + 461, + 462, + 464, + 467, + 469, + 470, + 473, + 474, + 476, + 479, + 480, + 483, + 485, + 486, + 489, + 490, + 492, + 495, + 497, + 498, + 500, + 503, + 504, + 507, + 509, + 510 + ] + ], + "subspaces_by_rank": { + "4": 1, + "5": 15, + "6": 35, + "7": 15, + "8": 1 + }, + "target_formula": "H_d + H_(9-d)", + "upper": [ + 0, + 3, + 5, + 6, + 9, + 10, + 12, + 15, + 17, + 18, + 20, + 23, + 24, + 27, + 29, + 30, + 33, + 34, + 36, + 39, + 40, + 43, + 45, + 46, + 48, + 51, + 53, + 54, + 57, + 58, + 60, + 63, + 65, + 66, + 68, + 71, + 72, + 75, + 77, + 78, + 80, + 83, + 85, + 86, + 89, + 90, + 92, + 95, + 96, + 99, + 101, + 102, + 105, + 106, + 108, + 111, + 113, + 114, + 116, + 119, + 120, + 123, + 125, + 126, + 128, + 131, + 133, + 134, + 137, + 138, + 140, + 143, + 145, + 146, + 148, + 151, + 152, + 155, + 157, + 158, + 161, + 162, + 164, + 167, + 168, + 171, + 173, + 174, + 176, + 179, + 181, + 182, + 185, + 186, + 188, + 191, + 193, + 194, + 196, + 199, + 200, + 203, + 205, + 206, + 208, + 211, + 213, + 214, + 217, + 218, + 220, + 223, + 224, + 227, + 229, + 230, + 233, + 234, + 236, + 239, + 241, + 242, + 244, + 247, + 248, + 251, + 253, + 254, + 256, + 259, + 261, + 262, + 265, + 266, + 268, + 271, + 273, + 274, + 276, + 279, + 280, + 283, + 285, + 286, + 289, + 290, + 292, + 295, + 296, + 299, + 301, + 302, + 304, + 307, + 309, + 310, + 313, + 314, + 316, + 319, + 321, + 322, + 324, + 327, + 328, + 331, + 333, + 334, + 336, + 339, + 341, + 342, + 345, + 346, + 348, + 351, + 352, + 355, + 357, + 358, + 361, + 362, + 364, + 367, + 369, + 370, + 372, + 375, + 376, + 379, + 381, + 382, + 384, + 387, + 389, + 390, + 393, + 394, + 396, + 399, + 401, + 402, + 404, + 407, + 408, + 411, + 413, + 414, + 417, + 418, + 420, + 423, + 424, + 427, + 429, + 430, + 432, + 435, + 437, + 438, + 441, + 442, + 444, + 447, + 449, + 450, + 452, + 455, + 456, + 459, + 461, + 462, + 464, + 467, + 469, + 470, + 473, + 474, + 476, + 479, + 480, + 483, + 485, + 486, + 489, + 490, + 492, + 495, + 497, + 498, + 500, + 503, + 504, + 507, + 509, + 510 + ] +} diff --git a/research/p104-split-block-composition/NOTICE b/research/p104-split-block-composition/NOTICE new file mode 100644 index 0000000000..0c26c16517 --- /dev/null +++ b/research/p104-split-block-composition/NOTICE @@ -0,0 +1,57 @@ +The published PR5756 composition and conditional kappa .00311313795 are by Joel Pulikkan (GamingPuzzled), with Claude Opus 5.5 assistance. This package independently reproduces that word. It claims no new composition or kappa. + +New all-canonical-chart optimization proof and source-bound audit: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. No subagents. + +The block reframe and edit list are by Joel Pulikkan (GamingPuzzled), with Claude Opus 5.5 assistance, PR5739. The distinct-boundary helper split is by flyingviper, with OpenAI Codex assistance, PR5718. The retained source exports keep all predecessor notices. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +The seventeen paid splits are a released verification/completion checkpoint from Discussion5645 at d12c769799573058248ae986d6e8fd036522f020. Their construction overlaps the earlier Discussion5600 paid-meeting claim, which has priority. Both are by Ali Romman with substantial OpenAI Codex assistance. This package claims neither split discovery nor the broader meeting search. + +The final immediate source is Ali Romman PR5751, with substantial OpenAI Codex assistance, which completes the earlier Discussion5600 paid-meeting claim. It supersedes the seventeen-split checkpoint. All 23 splits and their completion parameters are retained. No split discovery is claimed by this block-composition package. diff --git a/research/p104-split-block-composition/PRICING-EDITS.json b/research/p104-split-block-composition/PRICING-EDITS.json new file mode 100644 index 0000000000..04b6deced1 --- /dev/null +++ b/research/p104-split-block-composition/PRICING-EDITS.json @@ -0,0 +1,22 @@ +[ + [ + "KAPPA, TESTED = Q('.00311301600'), Q('.003113016005')", + "KAPPA, TESTED = Q('.00311313795'), Q('.003113137955')" + ], + [ + "PREVIOUS = Q('.00311024570')", + "PREVIOUS = Q('.00311301600')" + ], + [ + "sum(paid.values()) == 66834", + "sum(paid.values()) == 66852" + ], + [ + "'kappa_decimal':'0.00311301600'", + "'kappa_decimal':'0.00311313795'" + ], + [ + "'previous_pr5718'", + "'previous_pr5751'" + ] +] diff --git a/research/p104-split-block-composition/README.md b/research/p104-split-block-composition/README.md new file mode 100644 index 0000000000..ffab04070e --- /dev/null +++ b/research/p104-split-block-composition/README.md @@ -0,0 +1,228 @@ +# Exact block-chart optimum and PR5756 audit + +This package proves a fixed-block optimum for **all 8,283,458 canonical +subspaces of F2^9**. It also independently reproduces the complete word and +conditional saving **κ = .00311313795** published in PR5756. The composition +and saving belong to PR5756. This package adds the optimization theorem and +source-bound audit. It does not change the selected frontier. + +The rank-four chart is the unique optimum for every `0 < C <= .01`, and in +fact up to a formal tariff switch near `.124775`. At the published κ, a change +to even one of the 18 independent local block charts exceeds the complete +caller's margin. Thus a larger gain needs a different scalar assignment, +several intermediate charts, or a changed helper contract. More precision in +the same root is not a new result. + +## Exact source audit + +PR5756 is frozen at `a1b338e5d9271b541f2a198f4fc19cefc565feed`. +The independently constructed word equals its word after removal of only the +schema label. The local, native, physical and complete-price receipts agree. +The correct complete count is **13390 productive fields and 66852 paid calls**. +The 12958 fields in the PR body at audit time are stale prose; its JSON agrees +with 13390. + +The immediate source is PR5751 at +`8483f9a679d06c1e270141dbc686a7e76e7a7522`. It supplies all 23 paid meeting +splits and retains flyingviper's PR5718. The exact eight block edits are from +Joel Pulikkan / GamingPuzzled's PR5739 at +`b93d749a0a895d260e87887170af5162bda461a4`. Each source run occurs once in the +PR5751 word, and chart 1090 is free. `construct.py` checks these facts before +it applies the edits. It also reproduces PR5739 on that source's PR5713 word. +The older seventeen-split checkpoint remains frozen as provenance and is +not imported by the final verifier. No helper-split discovery is claimed. + +The final word has 767 public inputs, nine owned labels, eleven owned +lifetimes, peak owned storage two and scalar allowance 224138. Its local +profiles are: + +| Kind | Exact profile | +| --- | --- | +| Paid | 2220 H1 + 454 H2 + 492 H3 + 93 H4 + 174 H5 + 6 H6 + 15 H7 | +| Helpers | 24 H1 + 5 H2 + 92 H4 + 7 H5 + 6 H7 + 37 H8 + 388 H9 | + +The complete caller has 18 local calls, 15 query shears, 3120 whole idle jobs +and rank-mass surplus 760. Its raw crossing is strictly inside +`(.00311313797336, .00311313797337)`. The published value leaves between +2.336e-11 and 2.337e-11 below that ceiling. The retained compiler and outer +checks pass under the same five inherited framework assumptions. + +## Native rank formula + +Let W be a binary subspace of dimension r in V = F2^9. The source canonical +Gaussian chart has the Pauli image space + +``` +L(W) = {(x,z): x in W and z+x in W_perp}. +``` + +Here is a derivation from the source chart. Extend the basis of W to an +invertible matrix G. Let E select its first r columns, and put +`Q = I + G^-T G^-1`. The source chart is `K F_r K^-1`, where +`K = D_Q P_G`. Its image of a Z vector satisfies +`x = G E G^T z` and `z_out+x = G^-T (I+E) G^T z`. These vectors lie in W +and its orthogonal complement. The image has dimension nine, so this gives +the entire stated space. The source F_r is its Gaussian rotation; the proof +uses its actual Pauli action. + +For any A and B, the intersection of these image spaces has dimension +`dim(A intersect B) + 9 - dim(A+B)`. Therefore the native rank is + +``` +d(A,B) = dim A + dim B - 2 dim(A intersect B). +``` + +`optimal_tariff.py` checks the formula against the actual native engine on +134 source-derived representatives and all 2412 boundary ranks. This is a +check of the general algebraic proof, not an enumeration of every subspace. +Phases do not change ranks. The selected complete word receives a separate +full phase replay. + +## The 67 nested charts + +Keep the scalar assignment, all other charts and both changed helper endpoints +fixed. The eight incoming spaces U_i have dimension three. Their sum L has +dimension four. The outgoing spaces are seven copies of V and one space U +of dimension eight, with `L <= U <= V`. The original nested contract is +`L <= F <= U`. Its 67 choices have rank counts 1, 15, 35, 15 and 1. +The changed helpers run from zero to F and from F to V. For d = dim F, + +``` +P_d = 8 H_(d-3) + 7 H_(9-d) + H_(8-d) +T_d = H_d + H_(9-d) +S_d = T_d - P_d, H_r = r^(1-C), H_0 = 0. +``` + +An identity boundary is omitted and has zero recursive cost. All scalar +operations assigned to F use the same chart. `native_interval.py` checks all +1206 native boundary ranks and rejects a rank-three nested relaxation. + +The paid profile at rank four strictly majorizes the profiles at ranks five, +six and seven. Their target profiles majorize the rank-four target profile. +`TARIFF.json` gives every integer balancing transfer. Concavity proves that +rank four strictly wins over these three ranks for `0 < C < 1`. +The remaining difference is + +``` +S_4 - S_8 = 2*5^(1-C) - 8^(1-C) - 2. +``` + +Its derivative divided by `5^(1-C)` strictly decreases. Exact endpoint signs +prove one maximum and one interior zero. The zero lies in +`(.14739606083204, .14739606083205)`. Below it rank four wins; above it rank +eight wins. At zero all 67 charts tie by rank mass. At the switch only the two +endpoint charts tie. At C = 1 the rank-eight chart wins. + +The complete caller's five raw crossing intervals are: + +| Rank | Number of charts | Raw crossing interval | +| --- | --- | --- | +| 4 | 1 | (.00311313797336, .00311313797337) | +| 5 | 15 | (.00311114702998, .00311114702999) | +| 6 | 35 | (.00311049778387, .00311049778388) | +| 7 | 15 | (.00311102091727, .00311102091728) | +| 8 | 1 | (.00311301604454, .00311301604455) | + +Exact interval arithmetic also proves a negative whole-invoice derivative +on `[0,.0034]`. Each stated raw crossing is unique in that interval. + +## All canonical charts + +Now permit any single canonical subspace F of V. Charge every incoming, +outgoing and helper rank, even for a nonnested transition. This is a broader, +optimistic recursive tariff model. It does not supply physical admission for +every such choice. + +For f = dim F <= 8, choose an f-dimensional F' inside U such that +`F' intersect L` contains `F intersect L` and has dimension `min(f,4)`. +This is possible by basis extension inside L and then U. It cannot increase +any incoming rank or the outgoing rank to U. It leaves both helper ranks and +all seven outgoing ranks to V unchanged. If f >= 4, it reduces the problem +to the 67 nested charts. If f <= 3, it reduces the problem to F' inside L. + +All 67 subspaces of L are enumerated. For ranks 0, 1, 2 and 3, the largest +numbers h of incoming spaces that contain F' are respectively 8, 4, 2 and 1. +Every other incoming intersection has dimension f-1. Thus the best profiles +at these four ranks are + +``` +P_f = h H_(3-f) + (8-h) H_(5-f) + 7 H_(9-f) + H_(8-f) +T_f = H_f + H_(9-f). +``` + +Rank nine has one chart, V, with `P_9 = 8 H_6 + H_1` and `T_9 = H_9`. +Explicit positive decompositions in TARIFF.json prove `S_9 > S_f` for every +f from zero to three and every `0 <= C <= 1`. They use monotonicity and +`3 H_2 >= H_6`, which follows from concavity. Only ranks four, eight and +nine remain. + +Write t = 1-C. The remaining two differences are + +``` +S_9 - S_4 = 9^t - 8*6^t + 6*5^t + 7 +S_9 - S_8 = 9^t - 8^t - 8*6^t + 8*5^t + 5. +``` + +Both strictly increase with C. Divide their t derivatives by `6^t` and bound +the positive convex exponential sums by their endpoint maxima. For the +second difference, also use `(4/3)^t log(8) >= log(8)`. The four strict +rational log bounds are in TARIFF.json. Both differences start at -2 and end +positive, so each has one zero. Their zero intervals are +`(.12413664498287,.12413664498288)` for rank nine versus eight and +`(.12477498342317,.12477498342318)` for rank nine versus four. Both precede +the nested switch. Rank eight therefore never wins the global envelope. + +Let C_g be the unique root in the stated rank-nine versus rank-four interval. +The complete global classification is: + +- At C = 0, the 67 nested charts tie and all other charts lose. +- For `0 < C < C_g`, the unique optimum is L, of rank four. +- At C = C_g, L and V tie. +- Above that switch through C = 1, the unique optimum is V, of rank nine. + +The switch is a block tariff threshold, not a multiplication exponent. +The Gaussian binomial count gives 8,283,458 subspaces. The proof covers all +of them by the reduction; it does not claim that all were enumerated. + +## Complete-caller consequence + +At κ = .00311313795, the full raw margin is less than .000005666. Every +alternative best-rank chart has a per-local loss greater than .0016427276. +A rank-four chart other than L increases at least one boundary rank by two; +its loss is at least `9^(1-κ)-7^(1-κ)`, which is also greater than the full +margin. The lower-rank charts are dominated by rank nine. Therefore a change +to any one local chart already makes the raw margin negative. Additivity +extends this conclusion to every mixture of independent chart choices across +the 18 copies. Shared queries, changed helper fields and cross-call corrections +are outside this fixed contract. + +## Verification and limits + +Run `python3.12 -B scripts/research_package.py --package +research/p104-split-block-composition` from the repository root. VERIFY.json +registers normal and optimized runs of the primary verifier, native interval +check and global optimizer. VALIDATION.md records the exact runs and export +checks. The primary replay checks all 776 arbitrary scalar inputs, separate +transpose audits, owned lifetimes, 2927 distinct native maps with phases, +the complete physical caller, both moment engines, compiler, 54 strict and +four functional outer checks. Source authentication has actual byte-corruption +controls. Retained archives and notices are unchanged. + +The result does not cover arbitrary Clifford coframes, different scalar +assignments, multiple intermediate charts, shared helper inputs, changed +chronology or unpriced corrections. Five inherited all-size assumptions, +independent scientific review and hosted CI remain separate obligations. +The optional full-history ancestry preflight was not run in this shallow +checkout. No selected-frontier change, merge or closure is performed. + +## Open next questions + +1. Can a different scalar allocation or several intermediate charts improve + the complete signed invoice? Name the changed boundary contract first. +2. Can shared queries or a changed helper contract beat the independent-copy + bound? Charge the added native maps, restoration and owned operations. +3. Does an independent reviewer accept the source word, the chart reduction + and the inherited all-size assumptions? + +Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. +All predecessor credit is retained in NOTICE and frozen source archives. diff --git a/research/p104-split-block-composition/RESULT.json b/research/p104-split-block-composition/RESULT.json new file mode 100644 index 0000000000..e1cd453666 --- /dev/null +++ b/research/p104-split-block-composition/RESULT.json @@ -0,0 +1,452 @@ +{ + "complete_cost": { + "compiler": { + "H": 80511200000000000, + "N": "2^80511200000000000", + "eta": { + "lower": "0.000000128387229643834457871291", + "upper": "0.000000128387229643834457871292" + }, + "gap": "1/1400000000000", + "integer_test_exponent": 57508, + "logarithm_power": 1024, + "theta": "63/64", + "uniform_saving": "272399571/87500000000", + "word_materialized": false + }, + "full_forward_calls": 18, + "gain": "2439/20000000000", + "kappa": "62262759/20000000000", + "kappa_decimal": "0.00311313795", + "margin_at_previous": { + "lower": "0.029578770580357904755090866637", + "upper": "0.029578770580357904755090866638" + }, + "negative_controls": { + "old_BIT": "Rejected by outer inequalities", + "old_cutoff": "Rejected by completion-tail ratio greater than one", + "source_completion": "Rejected at cutoff17, floor18 and decay39/40", + "source_offset": "Rejected at cutoff16 with tail offset1/5" + }, + "nonrecursive": { + "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.", + "local_paid_rank_mass": 5987, + "local_routes": 5240000, + "local_scalar": 224138, + "peak_owned_fields": 2, + "raw_budget": 1000000000, + "raw_scalar_upper": 184647552, + "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word." + }, + "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": "348599999999253/350000000000000", + "fixed_halo_explicit_metadata_branch": "26950000000001/350000000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799999997009/1400000000000000", + "new_semantic_group_guard": "3/1400000000000" + }, + "margins": { + "boundary_algebraic_matrix": "6101750387595641606867/1960000000000000000000000", + "fused_gaussian": "6101750387586924820601/1960000000000000000000000", + "global_coordinate_router": "2179196567/700000000000", + "group_bit_router": "3050875194493462410299/980000000000000000000000", + "group_scans": "699999999999/700000000000", + "main_transform": "6101750386195641606867/1960000000000000000000000", + "microbox_face_corrections": "26950000000001/350000000000", + "polynomial_products": "1399999999999/1400000000000", + "sparse_union_movement": "802351750387595641606867/1960000000000000000000000" + }, + "parameters": { + "a": "2179196567/700000000000", + "b": "871678627/280000000000", + "beta": "1399999999997/1400000000000", + "bit_saving": "17/5000", + "cap_xi": "1782351750386195641606867/1960000000000000000000000", + "complex_uniform_saving": "272399571/87500000000", + "d": "1/1400000000000", + "epsilon": "1399999999999/1400000000000", + "kappa": "62262759/20000000000", + "lambda_": "398754744819/400000000000", + "lambda_prime": "1395641606867/1400000000000", + "layout": "1/1400000000000", + "q": "4358393133/1400000000000", + "r0": "1/14000000000000", + "stop": "1/1400000000000", + "tested_saving": "622627591/200000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "200803433/700000000000", + "actual_logarithmic_gamma_guard": "1/1400000000000", + "actual_logarithmic_group_guard": "177648249615904358393133/980000000000000000000000", + "alpha_logarithm_absorption": "1/14000000000000", + "boundary_algebraic_matrix_above_kappa": "5595641606867/1960000000000000000000000", + "cap_above_band": "802351750386195641606867/1960000000000000000000000", + "cap_below_cell": "177648249612404358393133/1960000000000000000000000", + "cap_below_phase_cell_power": "2137648249613804358393133/1960000000000000000000000", + "complex_above_effective": "1/1400000000000", + "complex_below_one_over_32": "7878321373/280000000000", + "complex_endpoint": "1/700000000000", + "epsilon_below_one": "1/1400000000000", + "epsilon_positive": "1399999999999/1400000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "5586924820601/1960000000000000000000000", + "gaussian_above_main": "695641606867/980000000000000000000000", + "global_coordinate_router_above_kappa": "1/350000000000", + "global_gamma_power_slack": "9/14000000000000", + "group_below_dimension": "1/700000000000", + "group_bit_router_above_kappa": "3493462410299/980000000000000000000000", + "group_gauge_power_slack": "177648249615834358393133/980000000000000000000000", + "group_key_fits_record": "1/700000000000", + "group_positive": "1399999999997/1400000000000", + "group_scans_above_kappa": "348910401717/350000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "691083765400418148631/500000000000000000000000", + "lambda_above_internal": "1/2800000000000", + "lambda_above_sigma": "3/2800000000000", + "lambda_above_tau": "1/2800000000000", + "lambda_prime_above_lambda": "1/2800000000000", + "lambda_prime_above_leaf": "559128321373/392000000000000000000000", + "leaf_saving_above_effective": "279128321373/392000000000000000000000", + "main_transform_above_kappa": "4195641606867/1960000000000000000000000", + "membership_arithmetic_fits_record": "1/1400000000000", + "microbox_face_corrections_above_kappa": "53897820803437/700000000000", + "microbox_halo_volume": "110600000000003/1400000000000", + "new_complex_uniform_saving_above_b": "1/1400000000000", + "new_semantic_guard_with_C1_one": "1/1400000000000", + "polynomial_products_above_kappa": "1395641606869/1400000000000", + "positive_layout_slack": "1/1400000000000", + "q_below_effective": "1/1400000000000", + "q_below_internal": "1/1400000000000", + "q_below_leaf": "559128321373/392000000000000000000000", + "q_positive": "4358393133/1400000000000", + "short_record_fallback": "279128321373/280000000000", + "source_axis_superpolynomial": "1/1400000000000", + "sparse_union_movement_above_kappa": "796250000005595641606867/1960000000000000000000000", + "stop_below_one": "1399999999999/1400000000000", + "stop_positive": "1/1400000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000000", + "union_tag_work_per_visit_fits_record": "3/1400000000000" + } + }, + "paid": { + "1": 41520, + "16": 416, + "2": 8172, + "24": 416, + "3": 8856, + "32": 416, + "4": 1674, + "40": 416, + "48": 416, + "5": 3132, + "56": 416, + "6": 108, + "64": 416, + "7": 270, + "72": 208 + }, + "paid_calls": 66852, + "previous_pr5751": "389127/125000000", + "productive_fields": 13390, + "query_shears": 15, + "rank_mass_surplus": 760, + "raw_ceiling": { + "derivative_upper": "-738596154004511222636095493817850924833979710424488126325902089/3138550867693340381917894711603833208051177722232017256448", + "interval": [ + "0", + "17/5000" + ] + }, + "raw_headroom": [ + "73/3125000000000", + "2337/100000000000000" + ], + "raw_root_interval": [ + "38914224667/12500000000000", + "311313797337/100000000000000" + ], + "relative_gain_percent": "4065/1037672", + "strictification": { + "alpha": { + "lower": "0.999999999981368230437503066447", + "upper": "0.999999999981368230437503066448" + }, + "cutoff": 16, + "delta": { + "lower": "0.944337257529929949513398128117", + "upper": "0.944337257529929949513398128118" + }, + "floor": 17, + "gamma": { + "lower": "0.975484709128690914856977434634", + "upper": "0.975484709128690914856977434635" + }, + "normalized_paid_upper": "1048576000976562501/1048576001073741824", + "power": 1024, + "reserve": "1/1000000000000", + "tail_block": 128, + "tail_decay": "125/128", + "tail_offset": "1/7", + "tested": "622627591/200000000000" + }, + "targets": { + "1": 432, + "145": 208, + "17": 416, + "2": 90, + "25": 416, + "33": 416, + "4": 1656, + "41": 416, + "49": 416, + "5": 126, + "57": 416, + "65": 416, + "7": 108, + "73": 208, + "8": 666, + "9": 6984 + }, + "whole_idle_jobs": 3120 + }, + "fixed_block_ranks": { + "4": { + "complete_paid_calls": 66852, + "derivative_upper": "-738596154004511222636095493817850924833979710424488126325902089/3138550867693340381917894711603833208051177722232017256448", + "local_changed_paid": { + "1": 8, + "4": 1, + "5": 7 + }, + "local_changed_targets": { + "4": 1, + "5": 1 + }, + "raw_root_interval": [ + "38914224667/12500000000000", + "311313797337/100000000000000" + ] + }, + "5": { + "complete_paid_calls": 66852, + "derivative_upper": "-739086129718245697295730769958875565098498550208567749918299421/3138550867693340381917894711603833208051177722232017256448", + "local_changed_paid": { + "2": 8, + "3": 1, + "4": 7 + }, + "local_changed_targets": { + "4": 1, + "5": 1 + }, + "raw_root_interval": [ + "155557351499/50000000000000", + "311114702999/100000000000000" + ] + }, + "6": { + "complete_paid_calls": 66852, + "derivative_upper": "-739246155128773337977230892868294350115283688821838589758756349/3138550867693340381917894711603833208051177722232017256448", + "local_changed_paid": { + "2": 1, + "3": 15 + }, + "local_changed_targets": { + "3": 1, + "6": 1 + }, + "raw_root_interval": [ + "311049778387/100000000000000", + "77762444597/25000000000000" + ] + }, + "7": { + "complete_paid_calls": 66852, + "derivative_upper": "-184779332151582770167735746269779332902096199221049103902545447/784637716923335095479473677900958302012794430558004314112", + "local_changed_paid": { + "1": 1, + "2": 7, + "4": 8 + }, + "local_changed_targets": { + "2": 1, + "7": 1 + }, + "raw_root_interval": [ + "311102091727/100000000000000", + "19443880733/6250000000000" + ] + }, + "8": { + "complete_paid_calls": 66834, + "derivative_upper": "-46163756548475525683286882541938968496286769063021259273845235/196159429230833773869868419475239575503198607639501078528", + "local_changed_paid": { + "1": 7, + "5": 8 + }, + "local_changed_targets": { + "1": 1, + "8": 1 + }, + "raw_root_interval": [ + "155650802227/50000000000000", + "62260320891/20000000000000" + ] + } + }, + "independent_literal_audit": { + "columns": 776, + "owned_lifetimes": 11, + "owned_peak": 2, + "paid": { + "1": 2220, + "2": 454, + "3": 492, + "4": 93, + "5": 174, + "6": 6, + "7": 15 + }, + "scalar": 224138, + "status": "PASS_ALL_SCALAR_INPUTS_FRAMES_OWNERSHIP_INVOICES", + "targets": { + "1": 24, + "2": 5, + "4": 92, + "5": 7, + "7": 6, + "8": 37, + "9": 388 + } + }, + "independent_transpose": { + "columns": 776, + "status": "PASS_ALL_TRANSPOSE_COLUMNS" + }, + "local": { + "endpoint_coefficients": 602176, + "helpers": { + "1": 24, + "2": 5, + "4": 92, + "5": 7, + "7": 6, + "8": 37, + "9": 388 + }, + "owned_fields": 9, + "owned_lifetimes": 11, + "paid": { + "1": 2220, + "2": 454, + "3": 492, + "4": 93, + "5": 174, + "6": 6, + "7": 15 + }, + "paid_rank_mass": 5987, + "peak_owned_fields": 2, + "public_inputs": 767, + "real_scalar_allowance": 224138 + }, + "native": { + "distinct_maps": 2927, + "helper_normalizers": 1118, + "helpers": { + "1": 24, + "2": 5, + "4": 92, + "5": 7, + "7": 6, + "8": 37, + "9": 388 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "b566ac8ebfb9df3d4c8a7be449c749283ec70dedbdaad7f943c264c692da544a", + "wrong_phase_rejected": true + }, + "negative_controls": { + "extra_target": "Every productive helper has a native target", + "illegal_rank_three_frame": "Strict native containment", + "missing_central_translation": "Rejected by the complete Laurent endpoint", + "old_helper_start": "Scalar destination coframe", + "old_scalar_chart": "Scalar destination coframe", + "omit_added_query": "Scalar destination coframe", + "omit_cut_projection": "Exact arbitrary-input endpoint row 146", + "omit_fresh_injection": "Exact arbitrary-input endpoint row 146", + "omit_initial_basis": "Exact arbitrary-input endpoint row 126", + "omit_owned_label_shift": "Owned INIT uses an inactive owned label", + "omit_retirement": "Exact arbitrary-input endpoint row 146", + "omit_terminal_inverse": "Exact arbitrary-input endpoint row 126", + "retain_uncharged_H9_target": "All declared final charts and owned exits", + "unpaid_query": "Complete field and call counts", + "wrong_fresh_input_frame": "Scalar source coframe" + }, + "physical_caller": { + "central_square_columns": 53248, + "full_calls": 18, + "main_targets": { + "145": 208, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "73": 208 + }, + "new_paid_jobs": 0, + "physical_contacts": 7488, + "ports": 104, + "route_payload_sha256": "7f4f0ca768ffbc4f93dcff575592c4c67411f46b4289e45b73f715a2ad47b142", + "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.", + "whole_idle_jobs": { + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416, + "64": 416, + "72": 208 + }, + "wrapper_sites": [ + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31 + ] + }, + "separate_columns": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 602176, + "columns": 776 + }, + "status": "PASS_P104_SPLIT_BLOCK_KAPPA_00311313795" +} diff --git a/research/p104-split-block-composition/SOURCE-CONTROLS.json b/research/p104-split-block-composition/SOURCE-CONTROLS.json new file mode 100644 index 0000000000..42093b9dfc --- /dev/null +++ b/research/p104-split-block-composition/SOURCE-CONTROLS.json @@ -0,0 +1,11 @@ +{ + "source/pr5739/construct.py": "Exact direct source SHA256", + "source/pr5739/verify.py": "Exact direct source SHA256", + "source/pr5739/pricing.py": "Exact direct source SHA256", + "source/pr5739/EDITS.json": "Exact direct source SHA256", + "source/pr5739/WORD.json.gz": "Exact direct source SHA256", + "source/pr5739/README.md": "Exact direct source SHA256", + "source/pr5739/NOTICE": "Exact direct source SHA256", + "source/pr5739/RESULT.json": "Exact direct source SHA256", + "source/pr5751-source.tar": "Exact predecessor archive SHA256" +} diff --git a/research/p104-split-block-composition/SOURCES.json b/research/p104-split-block-composition/SOURCES.json new file mode 100644 index 0000000000..204ee762e0 --- /dev/null +++ b/research/p104-split-block-composition/SOURCES.json @@ -0,0 +1,794 @@ +{ + "schema_version": 1, + "base_commit": "553d26d796fde9871ff2661a49ac7732e945410f", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8", + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/p104-split-block-composition/source/pr5739/EDITS.json", + "pin": "head:700a41e17e7eb7267b72596febfeac71255951dd:research/p104-split-block-composition/source/pr5739/EDITS.json", + "git_blob": "54f7b233d7bf97df2ac8a6167348db0f04ad0ab2", + "sha256": "1545d726fed269dd7d6fa59ff6744211a105aff5be99c5acf6b0e72c4977b3ea", + "usage": "provenance" + }, + { + "path": "research/p104-split-block-composition/source/pr5739/NOTICE", + "pin": "head:700a41e17e7eb7267b72596febfeac71255951dd:research/p104-split-block-composition/source/pr5739/NOTICE", + "git_blob": "36c1b859be8f5c1325811e633ac51149e1cd7bc0", + "sha256": "a252225cb4d9c61fc94b5b7f638600393a859e47750cfea7688c75b1f6610077", + "usage": "provenance" + }, + { + "path": "research/p104-split-block-composition/source/pr5739/README.md", + "pin": "head:700a41e17e7eb7267b72596febfeac71255951dd:research/p104-split-block-composition/source/pr5739/README.md", + "git_blob": "a05f31f7935be93d062868186414c969ac7325fe", + "sha256": "6bf3745c39efb6efae3f251af3f2cf4b9a4daab74e66f4d1920024cc13112e6a", + "usage": "provenance" + }, + { + "path": "research/p104-split-block-composition/source/pr5739/RESULT.json", + "pin": "head:700a41e17e7eb7267b72596febfeac71255951dd:research/p104-split-block-composition/source/pr5739/RESULT.json", + "git_blob": "02fe0978d02f46ccfd26ed0a0563eea9eec34b61", + "sha256": "af9e2c9adb6d67ddbbb34a4917b4594151e94904987d362a133748695a91e098", + "usage": "provenance" + }, + { + "path": "research/p104-split-block-composition/source/pr5739/WORD.json.gz", + "pin": "head:700a41e17e7eb7267b72596febfeac71255951dd:research/p104-split-block-composition/source/pr5739/WORD.json.gz", + "git_blob": "4c7fb353c686fbf14ccd332ba398168573f0fdfa", + "sha256": "88865e48e5cfe3bfcf28d6343cb166e98785a98dd102601d98870b068b125a85", + "usage": "provenance" + }, + { + "path": "research/p104-split-block-composition/source/pr5739/construct.py", + "pin": "head:700a41e17e7eb7267b72596febfeac71255951dd:research/p104-split-block-composition/source/pr5739/construct.py", + "git_blob": "ca59c61f8a1d25f490675cfc3c7faf343c26d159", + "sha256": "a84324082bd1724a59d1c4b3470be3b6889ca584bcbc4c2135d9c8dd100e5957", + "usage": "provenance" + }, + { + "path": "research/p104-split-block-composition/source/pr5739/pricing.py", + "pin": "head:700a41e17e7eb7267b72596febfeac71255951dd:research/p104-split-block-composition/source/pr5739/pricing.py", + "git_blob": "9f233cf78ec515f7a1e8f934dd987804e5efa12b", + "sha256": "69910e0989d17551dbce2bf31ee6cc28990b8fa0d46a68c78897e290fbe99753", + "usage": "provenance" + }, + { + "path": "research/p104-split-block-composition/source/pr5739/verify.py", + "pin": "head:700a41e17e7eb7267b72596febfeac71255951dd:research/p104-split-block-composition/source/pr5739/verify.py", + "git_blob": "b214cdd26b939ca6d48d7bea8a8835d6e54be005", + "sha256": "219b7bce638f2bc765c8ad90c30fbb7009ede9acf297ed86372b9b6539b28ac6", + "usage": "provenance" + }, + { + "path": "research/p104-split-block-composition/source/seventeen-source.tar", + "pin": "head:700a41e17e7eb7267b72596febfeac71255951dd:research/p104-split-block-composition/source/seventeen-source.tar", + "git_blob": "272c171a82a2cf0e192e6df6a163ff12ccb574d7", + "sha256": "2aa12ed3ca66eb5842074db15903d72f6f8208a74e8d7a5cf951c1fff63196bc", + "usage": "provenance" + }, + { + "path": "research/p104-split-block-composition/source/pr5751-source.tar", + "pin": "head:cfa65140fd13b9f63b5168c7cdaac442063fbcd5:research/p104-split-block-composition/source/pr5751-source.tar", + "git_blob": "89ac4dba7a4e814ffc4737f7af2f8e22fdb117d8", + "sha256": "5a3046462b06c108e2853898c9daf4b466bc46f47e5f77983515b6e5e7ed5023", + "usage": "provenance" + }, + { + "path": "research/p104-split-block-composition/source/pr5756/WORD.json.gz", + "pin": "head:dc7ed01f85d7eb2ec4de7fcbed6240cb5a89b676:research/p104-split-block-composition/source/pr5756/WORD.json.gz", + "usage": "provenance", + "git_blob": "156ff6d62780383467d195dce3728b7a434190b1", + "sha256": "a767dc298dee729d73389cd9240922e28024452d76442931396fb8307763752c" + }, + { + "path": "research/p104-split-block-composition/source/pr5756/RESULT.json", + "pin": "head:dc7ed01f85d7eb2ec4de7fcbed6240cb5a89b676:research/p104-split-block-composition/source/pr5756/RESULT.json", + "usage": "provenance", + "git_blob": "9d47144bd99dc57d799345c940232eb26afdc33c", + "sha256": "062fb71b92ca620cbea4a4469458ede513e4dc1039bfa783e06ed11f51335a9e" + } + ], + "direct_sources": [ + { + "local_path": "source/pr5739/construct.py", + "path": "research/p104-block-reframe-r22/construct.py", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/construct.py", + "git_blob": "ca59c61f8a1d25f490675cfc3c7faf343c26d159", + "sha256": "a84324082bd1724a59d1c4b3470be3b6889ca584bcbc4c2135d9c8dd100e5957" + }, + { + "local_path": "source/pr5739/verify.py", + "path": "research/p104-block-reframe-r22/verify.py", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/verify.py", + "git_blob": "b214cdd26b939ca6d48d7bea8a8835d6e54be005", + "sha256": "219b7bce638f2bc765c8ad90c30fbb7009ede9acf297ed86372b9b6539b28ac6" + }, + { + "local_path": "source/pr5739/pricing.py", + "path": "research/p104-block-reframe-r22/pricing.py", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/pricing.py", + "git_blob": "9f233cf78ec515f7a1e8f934dd987804e5efa12b", + "sha256": "69910e0989d17551dbce2bf31ee6cc28990b8fa0d46a68c78897e290fbe99753" + }, + { + "local_path": "source/pr5739/EDITS.json", + "path": "research/p104-block-reframe-r22/EDITS.json", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/EDITS.json", + "git_blob": "54f7b233d7bf97df2ac8a6167348db0f04ad0ab2", + "sha256": "1545d726fed269dd7d6fa59ff6744211a105aff5be99c5acf6b0e72c4977b3ea" + }, + { + "local_path": "source/pr5739/WORD.json.gz", + "path": "research/p104-block-reframe-r22/WORD.json.gz", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/WORD.json.gz", + "git_blob": "4c7fb353c686fbf14ccd332ba398168573f0fdfa", + "sha256": "88865e48e5cfe3bfcf28d6343cb166e98785a98dd102601d98870b068b125a85" + }, + { + "local_path": "source/pr5739/README.md", + "path": "research/p104-block-reframe-r22/README.md", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/README.md", + "git_blob": "a05f31f7935be93d062868186414c969ac7325fe", + "sha256": "6bf3745c39efb6efae3f251af3f2cf4b9a4daab74e66f4d1920024cc13112e6a" + }, + { + "local_path": "source/pr5739/NOTICE", + "path": "research/p104-block-reframe-r22/NOTICE", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/NOTICE", + "git_blob": "36c1b859be8f5c1325811e633ac51149e1cd7bc0", + "sha256": "a252225cb4d9c61fc94b5b7f638600393a859e47750cfea7688c75b1f6610077" + }, + { + "local_path": "source/pr5739/RESULT.json", + "path": "research/p104-block-reframe-r22/RESULT.json", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/RESULT.json", + "git_blob": "02fe0978d02f46ccfd26ed0a0563eea9eec34b61", + "sha256": "af9e2c9adb6d67ddbbb34a4917b4594151e94904987d362a133748695a91e098" + } + ], + "source_export": { + "local_path": "source/pr5751-source.tar", + "commit": "8483f9a679d06c1e270141dbc686a7e76e7a7522", + "package": "research/p104-paid-meeting-splits", + "files": 20, + "sha256": "5a3046462b06c108e2853898c9daf4b466bc46f47e5f77983515b6e5e7ed5023", + "git_blob": "89ac4dba7a4e814ffc4737f7af2f8e22fdb117d8" + }, + "archived_files": [ + { + "path": "research/p104-paid-meeting-splits/LOCAL-EDITS.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/LOCAL-EDITS.json", + "sha256": "3105be46bae1692f887172f38e0adbbe93b935298052f281c7beab6ffe86ab7f" + }, + { + "path": "research/p104-paid-meeting-splits/NOTICE", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/NOTICE", + "sha256": "0fad3a4a6fe3a273ec8ad0831a5bd8041077f30738fb0108a86a87ad1f68b0e7" + }, + { + "path": "research/p104-paid-meeting-splits/PLAN.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/PLAN.json", + "sha256": "9bf29e526b25efa0402dc08634b5f97ab5c7b4daaf4a38847d56411ee50838a4" + }, + { + "path": "research/p104-paid-meeting-splits/PRICING-EDITS.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/PRICING-EDITS.json", + "sha256": "98ac83c1983efe0dd83559ec6c47805ae2e5915916ccc854d5f5f7aa94ea3eaf" + }, + { + "path": "research/p104-paid-meeting-splits/PROOF.md", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/PROOF.md", + "sha256": "954373d136c719a7ef76da4cd4f871c83949bef6c54615625a709ae9f11a3132" + }, + { + "path": "research/p104-paid-meeting-splits/README.md", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/README.md", + "sha256": "b5a7593b6d614021e1c5601fae8f1a7b7c96f6f2ab7d187540eb9b4704e008ae" + }, + { + "path": "research/p104-paid-meeting-splits/RESULT.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/RESULT.json", + "sha256": "81f98f32d4b9bea858d11c91253e95dc1983b718cc3c5781235c6ded1c574b19" + }, + { + "path": "research/p104-paid-meeting-splits/SOURCES.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/SOURCES.json", + "sha256": "4f36521f71edabeb785eaba789fcdaf1d8e6409ae542099c64eb17b5c06b379d" + }, + { + "path": "research/p104-paid-meeting-splits/TASK.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/TASK.json", + "sha256": "c9fc8e6ef49b1a346038ab1ed63367ae3d140aa6323783bbcfd1ee683f5163ff" + }, + { + "path": "research/p104-paid-meeting-splits/VALIDATION.md", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/VALIDATION.md", + "sha256": "b8a09e7e2ab78c092cf54cd59ede87a5978a6c8908ea96c48f20bbf03091471e" + }, + { + "path": "research/p104-paid-meeting-splits/VERIFY.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/VERIFY.json", + "sha256": "eee6981e3c3243dd69d19c68042e6087dc97780016a6aa56a74fb438af1f9fd5" + }, + { + "path": "research/p104-paid-meeting-splits/WITNESS.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/WITNESS.json", + "sha256": "092c1cbed4ea349b5704b73ecbcccdd9c8d0fe50818c9bb7d94018c972e2960f" + }, + { + "path": "research/p104-paid-meeting-splits/WORD.json.gz", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/WORD.json.gz", + "sha256": "fb60e34238a57a147f53aadb1af1209a562e2dcd18b05a29557df452cfe83133" + }, + { + "path": "research/p104-paid-meeting-splits/checks.py", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/checks.py", + "sha256": "8606a679843d3806eecb3843805b5547d23e3ffbe4b6cd2328297d3458084cd9" + }, + { + "path": "research/p104-paid-meeting-splits/construct.py", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/construct.py", + "sha256": "fafcd4b56a4dbbcaf4671d3bc9906f7c2d19c93b5ccf7b9bdade79f0dec52077" + }, + { + "path": "research/p104-paid-meeting-splits/inputs/pr5718-source.tar", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/inputs/pr5718-source.tar", + "sha256": "2ed859e3cad00ed9ece1bb58792e78a623d49cd37eeca9f6b49c3c7345415f75" + }, + { + "path": "research/p104-paid-meeting-splits/local.py", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/local.py", + "sha256": "fc7c7293f7cffb8a9074e65b926e1782f2ebce2991c9ea75d42b94e888052689" + }, + { + "path": "research/p104-paid-meeting-splits/pricing.py", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/pricing.py", + "sha256": "c1723babfaacb4ef8ca274e22dbefc499ab92fcd9fda616e29bf9693dc81516a" + }, + { + "path": "research/p104-paid-meeting-splits/sources.py", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/sources.py", + "sha256": "2a55921f944c1592a7ec23a593aa4dd1c8eae9ac9e8fb5b95ec7a58421a735d3" + }, + { + "path": "research/p104-paid-meeting-splits/verify.py", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/verify.py", + "sha256": "3046d474a6b8bed658efa7928ddf0458ee348c7c583d82d347f8007d47b1d78a" + } + ], + "original_git_sources": [ + { + "path": "research/p104-block-reframe-r22/construct.py", + "usage": "provenance", + "git_blob": "ca59c61f8a1d25f490675cfc3c7faf343c26d159", + "sha256": "a84324082bd1724a59d1c4b3470be3b6889ca584bcbc4c2135d9c8dd100e5957", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/construct.py" + }, + { + "path": "research/p104-block-reframe-r22/verify.py", + "usage": "provenance", + "git_blob": "b214cdd26b939ca6d48d7bea8a8835d6e54be005", + "sha256": "219b7bce638f2bc765c8ad90c30fbb7009ede9acf297ed86372b9b6539b28ac6", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/verify.py" + }, + { + "path": "research/p104-block-reframe-r22/pricing.py", + "usage": "provenance", + "git_blob": "9f233cf78ec515f7a1e8f934dd987804e5efa12b", + "sha256": "69910e0989d17551dbce2bf31ee6cc28990b8fa0d46a68c78897e290fbe99753", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/pricing.py" + }, + { + "path": "research/p104-block-reframe-r22/EDITS.json", + "usage": "provenance", + "git_blob": "54f7b233d7bf97df2ac8a6167348db0f04ad0ab2", + "sha256": "1545d726fed269dd7d6fa59ff6744211a105aff5be99c5acf6b0e72c4977b3ea", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/EDITS.json" + }, + { + "path": "research/p104-block-reframe-r22/WORD.json.gz", + "usage": "provenance", + "git_blob": "4c7fb353c686fbf14ccd332ba398168573f0fdfa", + "sha256": "88865e48e5cfe3bfcf28d6343cb166e98785a98dd102601d98870b068b125a85", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/WORD.json.gz" + }, + { + "path": "research/p104-block-reframe-r22/README.md", + "usage": "provenance", + "git_blob": "a05f31f7935be93d062868186414c969ac7325fe", + "sha256": "6bf3745c39efb6efae3f251af3f2cf4b9a4daab74e66f4d1920024cc13112e6a", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/README.md" + }, + { + "path": "research/p104-block-reframe-r22/NOTICE", + "usage": "provenance", + "git_blob": "36c1b859be8f5c1325811e633ac51149e1cd7bc0", + "sha256": "a252225cb4d9c61fc94b5b7f638600393a859e47750cfea7688c75b1f6610077", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/NOTICE" + }, + { + "path": "research/p104-block-reframe-r22/RESULT.json", + "usage": "provenance", + "git_blob": "02fe0978d02f46ccfd26ed0a0563eea9eec34b61", + "sha256": "af9e2c9adb6d67ddbbb34a4917b4594151e94904987d362a133748695a91e098", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/RESULT.json" + }, + { + "path": "research/p104-paid-meeting-splits/LOCAL-EDITS.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/LOCAL-EDITS.json", + "sha256": "3105be46bae1692f887172f38e0adbbe93b935298052f281c7beab6ffe86ab7f", + "git_blob": "600aaf354645f6e938a1a24e74f66fc7d00cf6d4", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/NOTICE", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/NOTICE", + "sha256": "0fad3a4a6fe3a273ec8ad0831a5bd8041077f30738fb0108a86a87ad1f68b0e7", + "git_blob": "faf2c1bfc83394f038a077b19710d0c05d865788", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/PLAN.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/PLAN.json", + "sha256": "9bf29e526b25efa0402dc08634b5f97ab5c7b4daaf4a38847d56411ee50838a4", + "git_blob": "84ad2a32d40fa512067767ce1e28b7a122862744", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/PRICING-EDITS.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/PRICING-EDITS.json", + "sha256": "98ac83c1983efe0dd83559ec6c47805ae2e5915916ccc854d5f5f7aa94ea3eaf", + "git_blob": "a5e6c4ec220b6951490a021d7d667a1dd738f90c", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/PROOF.md", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/PROOF.md", + "sha256": "954373d136c719a7ef76da4cd4f871c83949bef6c54615625a709ae9f11a3132", + "git_blob": "b98dddcb5bc30f924753e9015280f26897dfcdaf", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/README.md", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/README.md", + "sha256": "b5a7593b6d614021e1c5601fae8f1a7b7c96f6f2ab7d187540eb9b4704e008ae", + "git_blob": "b4bd9cd66b6d37c397992c1f56d3098d06332bb9", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/RESULT.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/RESULT.json", + "sha256": "81f98f32d4b9bea858d11c91253e95dc1983b718cc3c5781235c6ded1c574b19", + "git_blob": "6c7d00db30625b7ed4b53fb83a2db82178700ee7", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/SOURCES.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/SOURCES.json", + "sha256": "4f36521f71edabeb785eaba789fcdaf1d8e6409ae542099c64eb17b5c06b379d", + "git_blob": "54d6e538fc2f77e71778d53cfb40a3737c972f96", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/TASK.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/TASK.json", + "sha256": "c9fc8e6ef49b1a346038ab1ed63367ae3d140aa6323783bbcfd1ee683f5163ff", + "git_blob": "16d9a33696f1957a6914300b054e6788dd0e5c48", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/VALIDATION.md", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/VALIDATION.md", + "sha256": "b8a09e7e2ab78c092cf54cd59ede87a5978a6c8908ea96c48f20bbf03091471e", + "git_blob": "0f1a7eae6a8681f6c2b397ec357b83f9335c959c", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/VERIFY.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/VERIFY.json", + "sha256": "eee6981e3c3243dd69d19c68042e6087dc97780016a6aa56a74fb438af1f9fd5", + "git_blob": "5550c891e8c17cdefe14b5dd585f4bfeaf887943", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/WITNESS.json", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/WITNESS.json", + "sha256": "092c1cbed4ea349b5704b73ecbcccdd9c8d0fe50818c9bb7d94018c972e2960f", + "git_blob": "55cb6e33f496e6fd2f665d33b04cdc0a2f81bfab", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/WORD.json.gz", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/WORD.json.gz", + "sha256": "fb60e34238a57a147f53aadb1af1209a562e2dcd18b05a29557df452cfe83133", + "git_blob": "d0c700d03eebc367ebb4c50d7b3d46355070e231", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/checks.py", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/checks.py", + "sha256": "8606a679843d3806eecb3843805b5547d23e3ffbe4b6cd2328297d3458084cd9", + "git_blob": "978ea2d805a43953a8c792d0399f2ab5866b0c61", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/construct.py", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/construct.py", + "sha256": "fafcd4b56a4dbbcaf4671d3bc9906f7c2d19c93b5ccf7b9bdade79f0dec52077", + "git_blob": "d70a68ea49423a9b6e92504b42c7447f9b6622f5", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/inputs/pr5718-source.tar", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/inputs/pr5718-source.tar", + "sha256": "2ed859e3cad00ed9ece1bb58792e78a623d49cd37eeca9f6b49c3c7345415f75", + "git_blob": "55423a4a2c22d45e1ec1a8bfd77b65bfcba0e170", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/local.py", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/local.py", + "sha256": "fc7c7293f7cffb8a9074e65b926e1782f2ebce2991c9ea75d42b94e888052689", + "git_blob": "c181baa903d671744a35f8d7749b74ab548086fe", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/pricing.py", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/pricing.py", + "sha256": "c1723babfaacb4ef8ca274e22dbefc499ab92fcd9fda616e29bf9693dc81516a", + "git_blob": "a9e4194e7bb26ceb32bf7aa75a979eea79d3e5cc", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/sources.py", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/sources.py", + "sha256": "2a55921f944c1592a7ec23a593aa4dd1c8eae9ac9e8fb5b95ec7a58421a735d3", + "git_blob": "d49da9f7ae96f7cd151fa37b56766657879ee403", + "usage": "provenance" + }, + { + "path": "research/p104-paid-meeting-splits/verify.py", + "pin": "head:8483f9a679d06c1e270141dbc686a7e76e7a7522:research/p104-paid-meeting-splits/verify.py", + "sha256": "3046d474a6b8bed658efa7928ddf0458ee348c7c583d82d347f8007d47b1d78a", + "git_blob": "e4d661529ba2990590816af0b569d5b0fadaaf63", + "usage": "provenance" + }, + { + "path": "research/p104-block-reframe-r22/WORD.json.gz", + "pin": "head:a1b338e5d9271b541f2a198f4fc19cefc565feed:research/p104-block-reframe-r22/WORD.json.gz", + "usage": "provenance", + "git_blob": "156ff6d62780383467d195dce3728b7a434190b1", + "sha256": "a767dc298dee729d73389cd9240922e28024452d76442931396fb8307763752c" + }, + { + "path": "research/p104-block-reframe-r22/RESULT.json", + "pin": "head:a1b338e5d9271b541f2a198f4fc19cefc565feed:research/p104-block-reframe-r22/RESULT.json", + "usage": "provenance", + "git_blob": "9d47144bd99dc57d799345c940232eb26afdc33c", + "sha256": "062fb71b92ca620cbea4a4469458ede513e4dc1039bfa783e06ed11f51335a9e" + } + ], + "previous_source_export": { + "local_path": "source/seventeen-source.tar", + "commit": "d12c769799573058248ae986d6e8fd036522f020", + "package": "research/p104-paid-helper-subdivisions", + "files": 19, + "sha256": "2aa12ed3ca66eb5842074db15903d72f6f8208a74e8d7a5cf951c1fff63196bc", + "git_blob": "272c171a82a2cf0e192e6df6a163ff12ccb574d7" + }, + "previous_archived_files": [ + { + "path": "research/p104-paid-helper-subdivisions/LOCAL-EDITS.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/LOCAL-EDITS.json", + "sha256": "9f7fbf1bee58d005d5b6b09b2c66c5de52fcb7331e9d289ee7201fcb73044435" + }, + { + "path": "research/p104-paid-helper-subdivisions/NOTICE", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/NOTICE", + "sha256": "ee2ae592ad4c60bd5c34c27776418bb331e049b0c6b164fcfa5119184fdabcde" + }, + { + "path": "research/p104-paid-helper-subdivisions/PLAN.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/PLAN.json", + "sha256": "9c6b855b7a4e1c281a11511ae78a6fa1643a09f7f0d04730b5e0622a760895ce" + }, + { + "path": "research/p104-paid-helper-subdivisions/PRICING-EDITS.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/PRICING-EDITS.json", + "sha256": "b6f77098ff3bf31b48b4aea3f0ed661f1b4d5a46e4596f244e63cd69bda5312c" + }, + { + "path": "research/p104-paid-helper-subdivisions/PROOF.md", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/PROOF.md", + "sha256": "b90ef77b0b1d0ebd848d88ad0fb2d7eb7fdbe68e6cc7f61337da2cc0bf2bd0de" + }, + { + "path": "research/p104-paid-helper-subdivisions/README.md", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/README.md", + "sha256": "b3d5148ae1791977c86467cc4aae3d4d125f2ed9ca0244c6ff15721af851afba" + }, + { + "path": "research/p104-paid-helper-subdivisions/RESULT.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/RESULT.json", + "sha256": "52a63ed93b06508afb75be47cc6f74f97e2a3fa64368960a6bfed5ff0b874d69" + }, + { + "path": "research/p104-paid-helper-subdivisions/SOURCES.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/SOURCES.json", + "sha256": "11c30e9b1f138c66172ef9d8a72b81142c469049af45805612c998e0647c6f5e" + }, + { + "path": "research/p104-paid-helper-subdivisions/TASK.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/TASK.json", + "sha256": "7e7bf3e8d7edb3ab1e9512b5250844edd9f00dff384595542de6b189ff4ecd28" + }, + { + "path": "research/p104-paid-helper-subdivisions/VALIDATION.md", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/VALIDATION.md", + "sha256": "53395d4bbd7faf6d90a4bd4d0058d1841c0f5984bbba589dac9f6b5a5dbabb39" + }, + { + "path": "research/p104-paid-helper-subdivisions/VERIFY.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/VERIFY.json", + "sha256": "7e3430f21a8b06010b7f9ee1d182ff9311780fcda28d4d4c83115d192c1576a7" + }, + { + "path": "research/p104-paid-helper-subdivisions/WITNESS.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/WITNESS.json", + "sha256": "370022af5c049012f81ba7bd383f27ae17ee490b4383890f2d60dcc27cadba2c" + }, + { + "path": "research/p104-paid-helper-subdivisions/WORD.json.gz", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/WORD.json.gz", + "sha256": "6f23bca255124806afc2df56d0677e66105ea9062076b54c23b589fe51bb20ca" + }, + { + "path": "research/p104-paid-helper-subdivisions/construct.py", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/construct.py", + "sha256": "c8b4dd562613269d5994ce96e66f91d9c26eb1fc01286526e6cb56e705068a0b" + }, + { + "path": "research/p104-paid-helper-subdivisions/inputs/pr5718-source.tar", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/inputs/pr5718-source.tar", + "sha256": "2ed859e3cad00ed9ece1bb58792e78a623d49cd37eeca9f6b49c3c7345415f75" + }, + { + "path": "research/p104-paid-helper-subdivisions/local.py", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/local.py", + "sha256": "c5d6b73e4c9c5b5968d7df5b5a92be9f8c463a746fc3610bbfa9b55bbd9163d9" + }, + { + "path": "research/p104-paid-helper-subdivisions/pricing.py", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/pricing.py", + "sha256": "90fb0b10edf018fbb74a1fcd67c1e3d636397495a0f3b9ca7379b8a6b8a0cc6e" + }, + { + "path": "research/p104-paid-helper-subdivisions/sources.py", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/sources.py", + "sha256": "a4eef07116570a7162608e4a2b2c4ae99ccedbd3c8b0f8f1a99c406d6371df91" + }, + { + "path": "research/p104-paid-helper-subdivisions/verify.py", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/verify.py", + "sha256": "cd927cddf265679470f05e8815aba16ba825917ebbc0ab50b289d36a0f0393bc" + } + ], + "previous_original_git_sources": [ + { + "path": "research/p104-block-reframe-r22/construct.py", + "usage": "provenance", + "git_blob": "ca59c61f8a1d25f490675cfc3c7faf343c26d159", + "sha256": "a84324082bd1724a59d1c4b3470be3b6889ca584bcbc4c2135d9c8dd100e5957", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/construct.py" + }, + { + "path": "research/p104-block-reframe-r22/verify.py", + "usage": "provenance", + "git_blob": "b214cdd26b939ca6d48d7bea8a8835d6e54be005", + "sha256": "219b7bce638f2bc765c8ad90c30fbb7009ede9acf297ed86372b9b6539b28ac6", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/verify.py" + }, + { + "path": "research/p104-block-reframe-r22/pricing.py", + "usage": "provenance", + "git_blob": "9f233cf78ec515f7a1e8f934dd987804e5efa12b", + "sha256": "69910e0989d17551dbce2bf31ee6cc28990b8fa0d46a68c78897e290fbe99753", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/pricing.py" + }, + { + "path": "research/p104-block-reframe-r22/EDITS.json", + "usage": "provenance", + "git_blob": "54f7b233d7bf97df2ac8a6167348db0f04ad0ab2", + "sha256": "1545d726fed269dd7d6fa59ff6744211a105aff5be99c5acf6b0e72c4977b3ea", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/EDITS.json" + }, + { + "path": "research/p104-block-reframe-r22/WORD.json.gz", + "usage": "provenance", + "git_blob": "4c7fb353c686fbf14ccd332ba398168573f0fdfa", + "sha256": "88865e48e5cfe3bfcf28d6343cb166e98785a98dd102601d98870b068b125a85", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/WORD.json.gz" + }, + { + "path": "research/p104-block-reframe-r22/README.md", + "usage": "provenance", + "git_blob": "a05f31f7935be93d062868186414c969ac7325fe", + "sha256": "6bf3745c39efb6efae3f251af3f2cf4b9a4daab74e66f4d1920024cc13112e6a", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/README.md" + }, + { + "path": "research/p104-block-reframe-r22/NOTICE", + "usage": "provenance", + "git_blob": "36c1b859be8f5c1325811e633ac51149e1cd7bc0", + "sha256": "a252225cb4d9c61fc94b5b7f638600393a859e47750cfea7688c75b1f6610077", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/NOTICE" + }, + { + "path": "research/p104-block-reframe-r22/RESULT.json", + "usage": "provenance", + "git_blob": "02fe0978d02f46ccfd26ed0a0563eea9eec34b61", + "sha256": "af9e2c9adb6d67ddbbb34a4917b4594151e94904987d362a133748695a91e098", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/RESULT.json" + }, + { + "path": "research/p104-paid-helper-subdivisions/LOCAL-EDITS.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/LOCAL-EDITS.json", + "sha256": "9f7fbf1bee58d005d5b6b09b2c66c5de52fcb7331e9d289ee7201fcb73044435", + "git_blob": "52fb2ddd938c43d49daa9afa7478620faed311c5", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/NOTICE", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/NOTICE", + "sha256": "ee2ae592ad4c60bd5c34c27776418bb331e049b0c6b164fcfa5119184fdabcde", + "git_blob": "b6fbb2b7cb4201774213d056a63f9ed34aca1d20", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/PLAN.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/PLAN.json", + "sha256": "9c6b855b7a4e1c281a11511ae78a6fa1643a09f7f0d04730b5e0622a760895ce", + "git_blob": "08178a5e758bbf580f53d4797230c17980866def", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/PRICING-EDITS.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/PRICING-EDITS.json", + "sha256": "b6f77098ff3bf31b48b4aea3f0ed661f1b4d5a46e4596f244e63cd69bda5312c", + "git_blob": "eac1985d38f0d27e0980b0c1ec1663ef31f64850", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/PROOF.md", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/PROOF.md", + "sha256": "b90ef77b0b1d0ebd848d88ad0fb2d7eb7fdbe68e6cc7f61337da2cc0bf2bd0de", + "git_blob": "4aba5f2caa8e5aeaa87312cb4605f1e4842d5349", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/README.md", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/README.md", + "sha256": "b3d5148ae1791977c86467cc4aae3d4d125f2ed9ca0244c6ff15721af851afba", + "git_blob": "ed14003d728ebd1584d5a0b43ba19ecde085d2f6", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/RESULT.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/RESULT.json", + "sha256": "52a63ed93b06508afb75be47cc6f74f97e2a3fa64368960a6bfed5ff0b874d69", + "git_blob": "e4dcc7f25049a80cbe054734aeae61be8a386b1e", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/SOURCES.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/SOURCES.json", + "sha256": "11c30e9b1f138c66172ef9d8a72b81142c469049af45805612c998e0647c6f5e", + "git_blob": "723cd954715d4937ae0738f7c754964ea69e4bdc", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/TASK.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/TASK.json", + "sha256": "7e7bf3e8d7edb3ab1e9512b5250844edd9f00dff384595542de6b189ff4ecd28", + "git_blob": "6dc1cd48ba5f75f16483692e979c7d2704541035", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/VALIDATION.md", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/VALIDATION.md", + "sha256": "53395d4bbd7faf6d90a4bd4d0058d1841c0f5984bbba589dac9f6b5a5dbabb39", + "git_blob": "7a0cddd70f4850f852c65cfde45599debd01d1c1", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/VERIFY.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/VERIFY.json", + "sha256": "7e3430f21a8b06010b7f9ee1d182ff9311780fcda28d4d4c83115d192c1576a7", + "git_blob": "b0ae31d922325915b57f31a37854f63352970fc4", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/WITNESS.json", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/WITNESS.json", + "sha256": "370022af5c049012f81ba7bd383f27ae17ee490b4383890f2d60dcc27cadba2c", + "git_blob": "0647863b56089d2493c56ae404f58a5bd0277e34", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/WORD.json.gz", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/WORD.json.gz", + "sha256": "6f23bca255124806afc2df56d0677e66105ea9062076b54c23b589fe51bb20ca", + "git_blob": "b348816f0ecfb9fecdd4d6471f95542ad0c3c497", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/construct.py", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/construct.py", + "sha256": "c8b4dd562613269d5994ce96e66f91d9c26eb1fc01286526e6cb56e705068a0b", + "git_blob": "10c0a8f27615158b5d46eb54f1b6f4c93a0ce00a", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/inputs/pr5718-source.tar", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/inputs/pr5718-source.tar", + "sha256": "2ed859e3cad00ed9ece1bb58792e78a623d49cd37eeca9f6b49c3c7345415f75", + "git_blob": "55423a4a2c22d45e1ec1a8bfd77b65bfcba0e170", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/local.py", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/local.py", + "sha256": "c5d6b73e4c9c5b5968d7df5b5a92be9f8c463a746fc3610bbfa9b55bbd9163d9", + "git_blob": "017f68ac65a31eb31c593d8f6b4923da11b779b8", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/pricing.py", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/pricing.py", + "sha256": "90fb0b10edf018fbb74a1fcd67c1e3d636397495a0f3b9ca7379b8a6b8a0cc6e", + "git_blob": "f9540cbe6159bb57e6453160fb75304e349139af", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/sources.py", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/sources.py", + "sha256": "a4eef07116570a7162608e4a2b2c4ae99ccedbd3c8b0f8f1a99c406d6371df91", + "git_blob": "b08c72921fb3723b6c0f8726310dde57af6ce0a9", + "usage": "provenance" + }, + { + "path": "research/p104-paid-helper-subdivisions/verify.py", + "pin": "head:d12c769799573058248ae986d6e8fd036522f020:research/p104-paid-helper-subdivisions/verify.py", + "sha256": "cd927cddf265679470f05e8815aba16ba825917ebbc0ab50b289d36a0f0393bc", + "git_blob": "4050592751afe7679459a8ba3d8c95339fabb256", + "usage": "provenance" + } + ], + "audit_sources": [ + { + "local_path": "source/pr5756/WORD.json.gz", + "path": "research/p104-block-reframe-r22/WORD.json.gz", + "pin": "head:a1b338e5d9271b541f2a198f4fc19cefc565feed:research/p104-block-reframe-r22/WORD.json.gz", + "git_blob": "156ff6d62780383467d195dce3728b7a434190b1", + "sha256": "a767dc298dee729d73389cd9240922e28024452d76442931396fb8307763752c" + }, + { + "local_path": "source/pr5756/RESULT.json", + "path": "research/p104-block-reframe-r22/RESULT.json", + "pin": "head:a1b338e5d9271b541f2a198f4fc19cefc565feed:research/p104-block-reframe-r22/RESULT.json", + "git_blob": "9d47144bd99dc57d799345c940232eb26afdc33c", + "sha256": "062fb71b92ca620cbea4a4469458ede513e4dc1039bfa783e06ed11f51335a9e" + } + ] +} diff --git a/research/p104-split-block-composition/TARIFF.json b/research/p104-split-block-composition/TARIFF.json new file mode 100644 index 0000000000..26d44e66f2 --- /dev/null +++ b/research/p104-split-block-composition/TARIFF.json @@ -0,0 +1,1830 @@ +{ + "canonical_word_sha256_without_schema": "d7e2545841218f0964b8ffded1a4f123c6bf36eed2d537cdfef2ad6503192d21", + "classification": { + "0=n and charts[dst] is None,'Owned INIT uses an inactive owned label') + active.add(dst);unwritten.add(dst);charts[dst]=e[2];values[dst]={} + lifetimes+=1;peak=max(peak,len(active));scalar+=2 + elif op=='CLEAR': + need(dst in active and charts[dst]==e[2],'Matching owned CLEAR') + active.remove(dst);unwritten.discard(dst);charts[dst]=None;values[dst]={};scalar+=2 + elif op=='MOVE': + _,_,a,b,private=e + need(charts[dst]==a and private==(dst in active),'MOVE source and ownership') + need(frames[b]=0,'Every sorted prefix inequality') + return differences + + +def balance(a,b): + current,steps = list(a),[] + while current!=b: + i = next(i for i,(x,y) in enumerate(zip(current,b)) if x!=y) + need(current[i]>b[i],'First unequal prefix has excess') + j = next(j for j in range(i+1,len(b)) if current[j]=current[j]+2,'Strict balancing transfer') + before = current[:] + current[i]-=1 + current[j]+=1 + current.sort(reverse=True) + need(sum(x*x for x in current)0 and a>0,'Positive coefficient and rank') + total[a]+=m + if kind=='positive':positive=True + elif kind=='difference':need(a>b>0,'Monotone power difference');total[b]-=m + else:need(kind=='subadditive' and m*a==b,'Exact equal-summand subadditivity');total[b]-=1 + expected=signed(best[9]);expected.subtract(signed(best[d])) + need(positive and +total==+expected and -total==-expected,'Exact strict global dominance certificate') + return best,{'lower_space_incidence':hist,'subspaces_by_dimension':counts, + 'total_subspaces':sum(counts),'native_representatives':134,'native_rank_checks':checked, + 'small_rank_dominance_certificates':certificates} + + +def run(): + pins = read(HERE/'SOURCES.json') + for row in pins['audit_sources']: + raw = (HERE/row['local_path']).read_bytes() + need(sha256(raw).hexdigest()==row['sha256'] + and sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()==row['git_blob'], + 'Exact PR5756 audit source') + word = read(HERE/'WORD.json.gz') + published = read(HERE/'source/pr5756/WORD.json.gz') + a,b = dict(word),dict(published) + a.pop('schema');b.pop('schema') + need(a==b,'Same complete PR5756 word, apart from schema label') + canonical_hash = sha256(json.dumps(a,sort_keys=True,separators=(',',':')).encode()).hexdigest() + own,other = read(HERE/'RESULT.json'),read(HERE/'source/pr5756/RESULT.json') + keys = ['kappa','kappa_decimal','raw_root_interval','targets','paid','productive_fields', + 'paid_calls','rank_mass_surplus','strictification','compiler','outer','ordinary_BIT','nonrecursive'] + for key in keys: + need(own['complete_cost'][key]==other['complete_cost'][key],'Same complete invoice field: '+key) + need(own['local']==other['local'] and own['native']==other['native'] + and own['physical_caller']==other['physical'],'Same local, native and physical receipts') + spaces = interval(word) + p4,t4 = profiles(4) + witnesses = {} + for d in (5,6,7): + pd,td = profiles(d) + paid = majorizes(p4,pd) + targets = majorizes(td,t4) + need(max(paid)>0,'Strict paid majorization') + witnesses[d] = {'paid_prefix_differences':paid,'target_prefix_differences':targets, + 'paid_balancing_transfers':balance(p4,pd), + 'target_balancing_transfers':balance(td,t4)} + # After equal terms cancel, the rank-four minus rank-eight margin is D(C). + def signed(d): + p,t = profiles(d) + out = Counter(t) + out.subtract(p) + return out + delta = signed(4) + delta.subtract(signed(8)) + need({r:c for r,c in delta.items() if c}=={1:-2,5:2,8:-1},'Exact two-chart power difference') + with ExitStack() as contexts: + cursor,_ = contexts.enter_context(sources()) + for depth in range(5): + cursor,root = contexts.enter_context(load(cursor/'sources.py','tariff_source_'+str(depth)).sources()) + E = load(root/'research/higher-moment-strictification/verify.py','block_tariff_intervals') + def D(c): + a,b = E.power(5,1-c),E.power(8,1-c) + return 2*a[0]-b[1]-2,2*a[1]-b[0]-2 + l5,l8 = E.log_bounds(5),E.log_bounds(8) + d0 = 8*l8[0]-10*l5[1],8*l8[1]-10*l5[0] + d1 = l8[0]-2*l5[1],l8[1]-2*l5[0] + need(d0[0]>0 and d1[1]<0,'Opposite strict derivative signs at the endpoints') + # D'(C)/5^(1-C) = (8/5)^(1-C) log(8) - 2 log(5). + # It strictly decreases. Thus D has one maximum and one interior zero. + need(2*5-8-2==0 and 2-1-2==-1,'Exact endpoint values D(0), D(1)') + grid = 10**14 + lo,hi = grid//10,grid//5 + need(D(Q(lo,grid))[0]>0 and D(Q(hi,grid))[1]<0,'Initial strict root bracket') + while hi-lo>1: + mid = (lo+hi)//2 + if D(Q(mid,grid))[0]>0: + lo = mid + else: + hi = mid + low,high = Q(lo,grid),Q(hi,grid) + need(D(low)[0]>0 and D(high)[1]<0,'Strict rational switch enclosure') + need(Q('.0034')0,'Current admitted BIT band lies in rank-four regime') + need(D(Q(1,10))[0]>0 and D(Q(1,5))[1]<0,'Reject either chart as a universal winner') + C=load(root/'research/p104-native-channel/vendor/clifford_exact.py','global_block_native') + best,global_data=global_profiles(word,C) + l6,l9=E.log_bounds(6),E.log_bounds(9) + derivative_gaps={ + '9_vs_4_t0':8*l6[0]-l9[1]-6*l5[1], + '9_vs_4_t1':8*l6[0]-Q(3,2)*l9[1]-5*l5[1], + '9_vs_8_t0':8*l6[0]+l8[0]-l9[1]-8*l5[1], + '9_vs_8_t1':8*l6[0]+l8[0]-Q(3,2)*l9[1]-Q(20,3)*l5[1]} + need(min(derivative_gaps.values())>0,'Convex endpoint bounds prove both global differences strictly increase in C') + def difference(positive,negative,c): + a,b=E.moment(positive,1-c),E.moment(negative,1-c) + return a[0]-b[1],a[1]-b[0] + def global_margin(d,c): + p9,t9=best[9];pd,td=best[d] + pos=Counter(t9);pos.update(pd);neg=Counter(p9);neg.update(td) + return difference(pos,neg,c) + def increasing_root(d): + a,b=0,grid + need(global_margin(d,Q(0))[1]<0 and global_margin(d,Q(1))[0]>0,'Strict global endpoint signs') + while b-a>1: + m=(a+b)//2;value=global_margin(d,Q(m,grid)) + if value[0]>0:b=m + else:need(value[1]<0,'Root comparison resolves exactly');a=m + result=[Q(a,grid),Q(b,grid)] + need(global_margin(d,result[0])[1]<0 and global_margin(d,result[1])[0]>0,'Exact global root bracket') + return result + switch94,switch98=increasing_root(4),increasing_root(8) + need(switch98[1] 1: + m=(lo+hi)//2 + if margin(Q(m,grid))[0] > 0: + lo=m + else: + hi=m + lower,upper = Q(lo,grid),Q(hi,grid) + signed = Counter(T) + signed.subtract(P) + cap = Q('.0034') + derivative_upper = Q(0) + for rank, count in signed.items(): + logarithm = E.log_bounds(rank) + low = E.mul(E.power(rank, 1-cap), logarithm)[0] + high = rank*logarithm[1] + derivative_upper -= count*(low if count >= 0 else high) + L.need(derivative_upper < 0, 'Unique raw crossing below the retained BIT cap') + L.need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure') + L.need(PREVIOUS < KAPPA < TESTED < lower and margin(PREVIOUS)[0] > 0, 'Changed complete bill improves the source claim') + t,u,v,c,b = 1-TESTED,Q(1,7),1024,16,17 + target,paid = E.moment(T,t),E.moment(P,t) + tl,th = other.moment(T,TESTED) + pl,ph = other.moment(P,TESTED) + L.need(tl > ph and max(tl,target[0]) <= min(th,target[1]) and max(pl,paid[0]) <= min(ph,paid[1]), 'Two exact moment engines') + alpha = E.divide(paid,target) + gamma = E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target)) + delta = E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,TESTED),target)) + reserve,decay = Q(1,10**12),Q(125,128) + L.need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All three charged tail ratios') + L.need(decay**128 < Q(1,16), 'Both tail decay blocks') + normalized = 1/(1+v*reserve)+Q(4,2**32) + L.need(normalized < 1 and c**64 < b**63, 'Full completion, splitting and rounding charges') + theta,power = Q(63,64),1024 + eta = E.scale(E.power(145,-v*TESTED),t) + L.need(2*(c**v)**64 <= (145**v)**63 and eta[0] > theta**power, 'Shifted exits and complement capacity') + L.need(E.power(145,v*TESTED)[1] < 2**power, 'Compiler initial range') + gap = (TESTED-KAPPA)/7 + L.need(gap.numerator == 1, 'Exact compiler integer grid') + step = gap.denominator + def wins(j): + return (step*j+1)**power < 2**j + left,right=1,2 + while not wins(right): + left,right=right,2*right + while right-left > 1: + m=(left+right)//2 + if wins(m): + right=m + else: + left=m + H=step*right + L.need(H > 8*v and wins(right) and not wins(right-1), 'Finite uniform threshold with predecessor rejection') + local_routes = (sum(local['paid'].values())+native['helper_normalizers']+native['main_adapters']+4*104+4*local['owned_lifetimes'])*1000 + L.need(local['real_scalar_allowance']+local_routes < 10**7, 'Every local scalar, route and owned operation is funded') + boundary = sum(len(word['boundaries'][side+'_program']) for side in ('left','right')) + raw = 18*10**7 + 15*1664 + 32*104*(len(word['physical_events'])+boundary) + raw += 32*104*(26+1000) + L.need(raw < 10**9, 'Complete nonrecursive raw bound') + 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']) + L.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','p104_productive_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) + L.need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete outer predicate inventory') + L.need(all(x > 0 for key in ('strict_checks','functional_checks') for x in outer[key].values()), 'All outer inequalities strict') + wrong_cutoff = E.divide((Q(sum(T.values())*21),)*2,E.mul(E.power(20,TESTED),target)) + L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory') + old_completion = E.divide((Q(sum(T.values())*18),)*2,E.mul(E.power(17,TESTED),target)) + L.need(old_completion[0] > Q(39,40), 'PR5718 completion-tail bound fails with the new target count') + old_offset = E.divide(E.moment(P,t+Q(1,5)),E.mul(E.power(16,Q(1,5)),target)) + L.need(old_offset[0] > decay, 'The old tail offset fails at the new cutoff') + bad=outer_module.ledger(dict(params,bit_saving=Q('.0027'))) + L.need(any(x <= 0 for x in bad['strict_checks'].values()), 'Insufficient BIT contract rejected') + return encode({'kappa':KAPPA,'kappa_decimal':'0.00311313795','previous_pr5751':PREVIOUS,'gain':KAPPA-PREVIOUS, + 'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper], + 'raw_headroom':[lower-KAPPA,upper-KAPPA], + 'raw_ceiling':{'interval':[Q(0),cap],'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,'query_shears':15,'whole_idle_jobs':3120, + 'strictification':{'tested':TESTED,'power':v,'cutoff':c,'floor':b,'tail_offset':u,'reserve':reserve,'tail_decay':decay,'tail_block':128, + 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta),'normalized_paid_upper':normalized}, + 'compiler':{'theta':theta,'logarithm_power':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'], + 'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.', + 'local_paid_rank_mass':local['paid_rank_mass'], + 'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word.'}, + 'ordinary_BIT':bit,'outer':outer, + 'negative_controls':{'source_completion':'Rejected at cutoff17, floor18 and decay39/40', + 'source_offset':'Rejected at cutoff16 with tail offset1/5', + 'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}}) diff --git a/research/p104-split-block-composition/source/pr5739/EDITS.json b/research/p104-split-block-composition/source/pr5739/EDITS.json new file mode 100644 index 0000000000..54f7b233d7 --- /dev/null +++ b/research/p104-split-block-composition/source/pr5739/EDITS.json @@ -0,0 +1 @@ +{"frames":[[265,194,164,75]],"initial":{"741":[477,1090]},"final":{"405":[477,1090]},"program":[[[["MOVE",42,476,477,false],["MOVE",41,475,477,false],["ADD",42,41,"1",477],["ADD",41,42,"-1",477],["ADD",42,41,"1",477],["SCALE",41,"-1",477],["SCALE",41,"-2",477],["MOVE",400,470,477,false],["ADD",400,41,"-1",477],["MOVE",401,472,477,false],["ADD",401,41,"-1",477],["SCALE",42,"-2",477],["MOVE",106,474,477,false],["ADD",106,42,"1/2",477],["MOVE",403,471,477,false],["ADD",403,42,"-1",477],["MOVE",405,469,477,false],["ADD",405,106,"1",477],["ADD",106,405,"-1",477],["ADD",405,106,"1",477],["SCALE",106,"-1",477],["ADD",41,405,"-2",477],["ADD",405,42,"-1",477],["ADD",405,403,"-1/2",477],["ADD",741,403,"1/2",477],["ADD",741,42,"1",477],["ADD",41,741,"2",477],["MOVE",410,473,477,false],["ADD",410,400,"1",477],["ADD",400,410,"-1",477],["ADD",410,400,"1",477],["SCALE",400,"-1",477],["SCALE",400,"-2",477],["ADD",403,401,"1",477],["ADD",401,403,"-1",477],["ADD",403,401,"1",477],["SCALE",401,"-1",477],["ADD",42,401,"1",477],["ADD",741,401,"1/2",477],["ADD",41,403,"1",477],["ADD",400,403,"1",477],["ADD",410,403,"-2",477],["ADD",410,741,"1",477],["ADD",741,410,"-1",477],["ADD",410,741,"1",477],["SCALE",741,"-1",477],["SCALE",741,"-1/2",477],["ADD",41,741,"-1",477],["ADD",400,741,"-1",477],["ADD",403,741,"-1",477],["ADD",42,410,"-1",477],["ADD",106,410,"-1",477],["ADD",401,410,"-1",477],["ADD",741,410,"1",477],["ADD",403,410,"1",477],["ADD",401,410,"-1",477],["SCALE",410,"2",477],["ADD",403,741,"1",477],["ADD",106,741,"1",477],["ADD",42,741,"-1",477],["ADD",410,741,"1",477],["ADD",741,410,"-1",477],["ADD",410,741,"1",477],["SCALE",741,"-1",477],["ADD",410,403,"-1/2",477],["ADD",741,403,"-1",477],["ADD",401,403,"1",477],["ADD",400,403,"1/2",477],["ADD",106,403,"-1/2",477],["ADD",42,403,"1/2",477],["ADD",41,403,"-1/2",477],["SCALE",403,"-1/2",477],["ADD",741,401,"1",477],["ADD",403,401,"1/2",477],["ADD",400,401,"-1/2",477],["ADD",106,401,"1/2",477],["ADD",42,401,"1/2",477],["ADD",41,401,"1/2",477],["SCALE",401,"-2",477],["ADD",106,400,"1",477],["ADD",42,400,"1",477],["ADD",41,400,"-1",477],["SCALE",400,"2",477],["ADD",401,400,"1",477],["ADD",400,401,"-1",477],["ADD",401,400,"1",477],["SCALE",400,"-1",477],["ADD",403,106,"1/2",477],["ADD",401,106,"-1",477],["ADD",41,106,"1",477],["SCALE",106,"-2",477],["ADD",403,42,"1/2",477],["ADD",401,42,"-1",477],["ADD",41,42,"1",477],["SCALE",42,"-2",477],["ADD",400,42,"1",477],["ADD",42,400,"-1",477],["ADD",400,42,"1",477],["SCALE",42,"-1",477],["ADD",403,41,"-1/2",477],["ADD",401,41,"1",477],["ADD",400,41,"1",477],["ADD",106,41,"1",477],["ADD",42,41,"1",477]],[["MOVE",42,476,1090,false],["MOVE",41,475,1090,false],["ADD",42,41,"1",1090],["ADD",41,42,"-1",1090],["ADD",42,41,"1",1090],["SCALE",41,"-1",1090],["SCALE",41,"-2",1090],["MOVE",400,470,1090,false],["ADD",400,41,"-1",1090],["MOVE",401,472,1090,false],["ADD",401,41,"-1",1090],["SCALE",42,"-2",1090],["MOVE",106,474,1090,false],["ADD",106,42,"1/2",1090],["MOVE",403,471,1090,false],["ADD",403,42,"-1",1090],["MOVE",405,469,1090,false],["ADD",405,106,"1",1090],["ADD",106,405,"-1",1090],["ADD",405,106,"1",1090],["SCALE",106,"-1",1090],["ADD",41,405,"-2",1090],["ADD",405,42,"-1",1090],["ADD",405,403,"-1/2",1090],["ADD",741,403,"1/2",1090],["ADD",741,42,"1",1090],["ADD",41,741,"2",1090],["MOVE",410,473,1090,false],["ADD",410,400,"1",1090],["ADD",400,410,"-1",1090],["ADD",410,400,"1",1090],["SCALE",400,"-1",1090],["SCALE",400,"-2",1090],["ADD",403,401,"1",1090],["ADD",401,403,"-1",1090],["ADD",403,401,"1",1090],["SCALE",401,"-1",1090],["ADD",42,401,"1",1090],["ADD",741,401,"1/2",1090],["ADD",41,403,"1",1090],["ADD",400,403,"1",1090],["ADD",410,403,"-2",1090],["ADD",410,741,"1",1090],["ADD",741,410,"-1",1090],["ADD",410,741,"1",1090],["SCALE",741,"-1",1090],["SCALE",741,"-1/2",1090],["ADD",41,741,"-1",1090],["ADD",400,741,"-1",1090],["ADD",403,741,"-1",1090],["ADD",42,410,"-1",1090],["ADD",106,410,"-1",1090],["ADD",401,410,"-1",1090],["ADD",741,410,"1",1090],["ADD",403,410,"1",1090],["ADD",401,410,"-1",1090],["SCALE",410,"2",1090],["ADD",403,741,"1",1090],["ADD",106,741,"1",1090],["ADD",42,741,"-1",1090],["ADD",410,741,"1",1090],["ADD",741,410,"-1",1090],["ADD",410,741,"1",1090],["SCALE",741,"-1",1090],["ADD",410,403,"-1/2",1090],["ADD",741,403,"-1",1090],["ADD",401,403,"1",1090],["ADD",400,403,"1/2",1090],["ADD",106,403,"-1/2",1090],["ADD",42,403,"1/2",1090],["ADD",41,403,"-1/2",1090],["SCALE",403,"-1/2",1090],["ADD",741,401,"1",1090],["ADD",403,401,"1/2",1090],["ADD",400,401,"-1/2",1090],["ADD",106,401,"1/2",1090],["ADD",42,401,"1/2",1090],["ADD",41,401,"1/2",1090],["SCALE",401,"-2",1090],["ADD",106,400,"1",1090],["ADD",42,400,"1",1090],["ADD",41,400,"-1",1090],["SCALE",400,"2",1090],["ADD",401,400,"1",1090],["ADD",400,401,"-1",1090],["ADD",401,400,"1",1090],["SCALE",400,"-1",1090],["ADD",41,106,"1",1090],["ADD",403,42,"1/2",1090],["MOVE",403,1090,127,false],["MOVE",106,1090,127,false],["ADD",403,106,"1/2",127],["ADD",401,42,"-1",1090],["MOVE",401,1090,127,false],["ADD",401,106,"-1",127],["SCALE",106,"-2",127],["ADD",41,42,"1",1090],["SCALE",42,"-2",1090],["ADD",400,42,"1",1090],["ADD",42,400,"-1",1090],["ADD",400,42,"1",1090],["MOVE",42,1090,127,false],["SCALE",42,"-1",127],["ADD",400,41,"1",1090],["MOVE",41,1090,127,false],["ADD",403,41,"-1/2",127],["ADD",401,41,"1",127],["ADD",106,41,"1",127],["ADD",42,41,"1",127]]],[[["MOVE",41,477,127,false]],[]],[[["MOVE",42,477,127,false]],[]],[[["MOVE",106,477,127,false]],[]],[[["ADD",240,65,"1",477]],[["ADD",240,65,"1",477],["MOVE",400,1090,477,false]]],[[["MOVE",401,477,127,false],["MOVE",410,477,127,false]],[["MOVE",410,1090,127,false]]],[[["MOVE",403,477,127,false]],[]],[[["MOVE",741,477,127,false]],[["MOVE",741,1090,127,false]]]]} \ No newline at end of file diff --git a/research/p104-split-block-composition/source/pr5739/NOTICE b/research/p104-split-block-composition/source/pr5739/NOTICE new file mode 100644 index 0000000000..36c1b859be --- /dev/null +++ b/research/p104-split-block-composition/source/pr5739/NOTICE @@ -0,0 +1,44 @@ +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. diff --git a/research/p104-split-block-composition/source/pr5739/README.md b/research/p104-split-block-composition/source/pr5739/README.md new file mode 100644 index 0000000000..a05f31f793 --- /dev/null +++ b/research/p104-split-block-composition/source/pr5739/README.md @@ -0,0 +1,67 @@ +# One block moved from a dim-8 chart to a new dim-4 chart on PR5713's P104 word: conditional kappa .00310927386 + +Complete conditional kappa **.00310927386** (claim line, tested at .003109273865). The exact raw crossing is in +(0.00310927387521, 0.00310927387522). That is **+1.216e-7** over the raw crossing 0.0031091522456 of +[PR5713](https://github.com/CrocSwap/integer-mult-bounds/pull/5713) (Ali Romman, claim .00310915222), the newest +P104 head when this was written. + +**Conditional on** exactly the assumptions of PR5713 and its inherited P104 line, including free helper endpoints +(PR5561, audited in PR5567). This word changes one helper start and one helper final. The selected record is not changed. +No independent human or proof-kernel acceptance is claimed. + +## What changes + +The change is a large-neighbourhood step of R22's exact reorder+re-frame MIP. All scalar operations outside one +window of about 1,000 consecutive operations are pinned. Inside the window, every chart within dimension gap 4 of +the operation's bounds is allowed. One window of the sweep over PR5684's word found this step. It applies unchanged +to PR5713's word, because PR5713 only edits contacts elsewhere. + +- 96 scalar operations on registers 41, 42, 106, 400, 401, 403, 405, 410 and 741 used to run on chart 477 + (dim 8). In the new word: + - 88 of them run on a new chart 1090 = span[265, 194, 164, 75] (dim 4); + - 8 of them run on chart 127 (dim 9). +- Helper 741 now starts on 1090 instead of 477. +- Helper 405 now ends on 1090 instead of 477. +- No scalar instruction, coefficient, order, owned lifetime, main endpoint or port changes. + +Per local call: paid MOVE jobs H1 +1, H4 +1, H5 -1 (66348 -> 66366 paid calls in all); helper credits +H1 -1, H4 +1, H5 +1, H8 -1. The moment gain comes from the helper credits. The rank-mass surplus is unchanged at 760, +and there are still 12958 productive fields. + +## Check + +``` +python3 -W error -B research/p104-block-reframe-r22/verify.py # compares with RESULT.json +python3 -W error -B research/p104-block-reframe-r22/verify.py --write # regenerates RESULT.json +``` + +`verify.py` runs these checks: + +1. **Source pin.** It pins PR5713's `WORD.json.gz` (SHA256). +2. **Regeneration.** It regenerates `WORD.json.gz` from that word with `construct.py` and `EDITS.json`. Each hunk + replaces one unique event run, and hunks are disjoint. It also appends one chart and changes two helper endpoints. +3. **Boundary.** Existing charts are unchanged, only free helper endpoints change, and every other word field is + unchanged. +4. **Order.** The scalar order is trace-equivalent: every dependent pair keeps its order. +5. **PR5713's own stack.** It runs PR5713's unmodified stack through its three nested source exports: + - exact replay; + - every dense transpose column; + - every native map and phase; + - the complete physical caller; + - PR5713's `pricing.py`, where only the four literals in `LITERALS` change: claim/tested kappa, previous claim + and the paid-call total. +6. **Controls.** Six controls are rejected: + - old helper start; + - block op on the old chart; + - missing block MOVE; + - unpaid query; + - extra target credit; + - read swapped after a dependent write. + +## Attribution + +All retained checkers, words and pricing are by the PR5713 authors and their sources; see `NOTICE`. +PR5713 itself builds on our PR5684. R22 search tools are on branch `r22-p104-reframe-optimum`. The +large-neighbourhood windows are set with `WIN=lo:hi` in `poset104.domains`. + +Joel Pulikkan (GamingPuzzled) with Claude Opus 5.5 (Anthropic) via Claude Code. Apache-2.0. diff --git a/research/p104-split-block-composition/source/pr5739/RESULT.json b/research/p104-split-block-composition/source/pr5739/RESULT.json new file mode 100644 index 0000000000..02fe0978d0 --- /dev/null +++ b/research/p104-split-block-composition/source/pr5739/RESULT.json @@ -0,0 +1,1398 @@ +{ + "changed_charts": [ + [ + 11349, + [ + "ADD", + 42, + 41, + "1" + ], + 477, + 1090 + ], + [ + 11350, + [ + "ADD", + 41, + 42, + "-1" + ], + 477, + 1090 + ], + [ + 11351, + [ + "ADD", + 42, + 41, + "1" + ], + 477, + 1090 + ], + [ + 11352, + [ + "SCALE", + 41, + "-1" + ], + 477, + 1090 + ], + [ + 11353, + [ + "SCALE", + 41, + "-2" + ], + 477, + 1090 + ], + [ + 11354, + [ + "ADD", + 400, + 41, + "-1" + ], + 477, + 1090 + ], + [ + 11355, + [ + "ADD", + 401, + 41, + "-1" + ], + 477, + 1090 + ], + [ + 11356, + [ + "SCALE", + 42, + "-2" + ], + 477, + 1090 + ], + [ + 11357, + [ + "ADD", + 106, + 42, + "1/2" + ], + 477, + 1090 + ], + [ + 11358, + [ + "ADD", + 403, + 42, + "-1" + ], + 477, + 1090 + ], + [ + 11359, + [ + "ADD", + 405, + 106, + "1" + ], + 477, + 1090 + ], + [ + 11360, + [ + "ADD", + 106, + 405, + "-1" + ], + 477, + 1090 + ], + [ + 11361, + [ + "ADD", + 405, + 106, + "1" + ], + 477, + 1090 + ], + [ + 11362, + [ + "SCALE", + 106, + "-1" + ], + 477, + 1090 + ], + [ + 11363, + [ + "ADD", + 41, + 405, + "-2" + ], + 477, + 1090 + ], + [ + 11364, + [ + "ADD", + 405, + 42, + "-1" + ], + 477, + 1090 + ], + [ + 11365, + [ + "ADD", + 405, + 403, + "-1/2" + ], + 477, + 1090 + ], + [ + 11366, + [ + "ADD", + 741, + 403, + "1/2" + ], + 477, + 1090 + ], + [ + 11367, + [ + "ADD", + 741, + 42, + "1" + ], + 477, + 1090 + ], + [ + 11368, + [ + "ADD", + 41, + 741, + "2" + ], + 477, + 1090 + ], + [ + 11369, + [ + "ADD", + 410, + 400, + "1" + ], + 477, + 1090 + ], + [ + 11370, + [ + "ADD", + 400, + 410, + "-1" + ], + 477, + 1090 + ], + [ + 11371, + [ + "ADD", + 410, + 400, + "1" + ], + 477, + 1090 + ], + [ + 11372, + [ + "SCALE", + 400, + "-1" + ], + 477, + 1090 + ], + [ + 11373, + [ + "SCALE", + 400, + "-2" + ], + 477, + 1090 + ], + [ + 11374, + [ + "ADD", + 403, + 401, + "1" + ], + 477, + 1090 + ], + [ + 11375, + [ + "ADD", + 401, + 403, + "-1" + ], + 477, + 1090 + ], + [ + 11376, + [ + "ADD", + 403, + 401, + "1" + ], + 477, + 1090 + ], + [ + 11377, + [ + "SCALE", + 401, + "-1" + ], + 477, + 1090 + ], + [ + 11378, + [ + "ADD", + 42, + 401, + "1" + ], + 477, + 1090 + ], + [ + 11379, + [ + "ADD", + 741, + 401, + "1/2" + ], + 477, + 1090 + ], + [ + 11380, + [ + "ADD", + 41, + 403, + "1" + ], + 477, + 1090 + ], + [ + 11381, + [ + "ADD", + 400, + 403, + "1" + ], + 477, + 1090 + ], + [ + 11382, + [ + "ADD", + 410, + 403, + "-2" + ], + 477, + 1090 + ], + [ + 11383, + [ + "ADD", + 410, + 741, + "1" + ], + 477, + 1090 + ], + [ + 11384, + [ + "ADD", + 741, + 410, + "-1" + ], + 477, + 1090 + ], + [ + 11385, + [ + "ADD", + 410, + 741, + "1" + ], + 477, + 1090 + ], + [ + 11386, + [ + "SCALE", + 741, + "-1" + ], + 477, + 1090 + ], + [ + 11387, + [ + "SCALE", + 741, + "-1/2" + ], + 477, + 1090 + ], + [ + 11388, + [ + "ADD", + 41, + 741, + "-1" + ], + 477, + 1090 + ], + [ + 11389, + [ + "ADD", + 400, + 741, + "-1" + ], + 477, + 1090 + ], + [ + 11390, + [ + "ADD", + 403, + 741, + "-1" + ], + 477, + 1090 + ], + [ + 11391, + [ + "ADD", + 42, + 410, + "-1" + ], + 477, + 1090 + ], + [ + 11392, + [ + "ADD", + 106, + 410, + "-1" + ], + 477, + 1090 + ], + [ + 11393, + [ + "ADD", + 401, + 410, + "-1" + ], + 477, + 1090 + ], + [ + 11394, + [ + "ADD", + 741, + 410, + "1" + ], + 477, + 1090 + ], + [ + 11395, + [ + "ADD", + 403, + 410, + "1" + ], + 477, + 1090 + ], + [ + 11396, + [ + "ADD", + 401, + 410, + "-1" + ], + 477, + 1090 + ], + [ + 11397, + [ + "SCALE", + 410, + "2" + ], + 477, + 1090 + ], + [ + 11398, + [ + "ADD", + 403, + 741, + "1" + ], + 477, + 1090 + ], + [ + 11399, + [ + "ADD", + 106, + 741, + "1" + ], + 477, + 1090 + ], + [ + 11400, + [ + "ADD", + 42, + 741, + "-1" + ], + 477, + 1090 + ], + [ + 11401, + [ + "ADD", + 410, + 741, + "1" + ], + 477, + 1090 + ], + [ + 11402, + [ + "ADD", + 741, + 410, + "-1" + ], + 477, + 1090 + ], + [ + 11403, + [ + "ADD", + 410, + 741, + "1" + ], + 477, + 1090 + ], + [ + 11404, + [ + "SCALE", + 741, + "-1" + ], + 477, + 1090 + ], + [ + 11405, + [ + "ADD", + 410, + 403, + "-1/2" + ], + 477, + 1090 + ], + [ + 11406, + [ + "ADD", + 741, + 403, + "-1" + ], + 477, + 1090 + ], + [ + 11407, + [ + "ADD", + 401, + 403, + "1" + ], + 477, + 1090 + ], + [ + 11408, + [ + "ADD", + 400, + 403, + "1/2" + ], + 477, + 1090 + ], + [ + 11409, + [ + "ADD", + 106, + 403, + "-1/2" + ], + 477, + 1090 + ], + [ + 11410, + [ + "ADD", + 42, + 403, + "1/2" + ], + 477, + 1090 + ], + [ + 11411, + [ + "ADD", + 41, + 403, + "-1/2" + ], + 477, + 1090 + ], + [ + 11412, + [ + "SCALE", + 403, + "-1/2" + ], + 477, + 1090 + ], + [ + 11413, + [ + "ADD", + 741, + 401, + "1" + ], + 477, + 1090 + ], + [ + 11414, + [ + "ADD", + 403, + 401, + "1/2" + ], + 477, + 1090 + ], + [ + 11415, + [ + "ADD", + 400, + 401, + "-1/2" + ], + 477, + 1090 + ], + [ + 11416, + [ + "ADD", + 106, + 401, + "1/2" + ], + 477, + 1090 + ], + [ + 11417, + [ + "ADD", + 42, + 401, + "1/2" + ], + 477, + 1090 + ], + [ + 11418, + [ + "ADD", + 41, + 401, + "1/2" + ], + 477, + 1090 + ], + [ + 11419, + [ + "SCALE", + 401, + "-2" + ], + 477, + 1090 + ], + [ + 11420, + [ + "ADD", + 106, + 400, + "1" + ], + 477, + 1090 + ], + [ + 11421, + [ + "ADD", + 42, + 400, + "1" + ], + 477, + 1090 + ], + [ + 11422, + [ + "ADD", + 41, + 400, + "-1" + ], + 477, + 1090 + ], + [ + 11423, + [ + "SCALE", + 400, + "2" + ], + 477, + 1090 + ], + [ + 11424, + [ + "ADD", + 401, + 400, + "1" + ], + 477, + 1090 + ], + [ + 11425, + [ + "ADD", + 400, + 401, + "-1" + ], + 477, + 1090 + ], + [ + 11426, + [ + "ADD", + 401, + 400, + "1" + ], + 477, + 1090 + ], + [ + 11427, + [ + "SCALE", + 400, + "-1" + ], + 477, + 1090 + ], + [ + 11428, + [ + "ADD", + 403, + 106, + "1/2" + ], + 477, + 127 + ], + [ + 11429, + [ + "ADD", + 401, + 106, + "-1" + ], + 477, + 127 + ], + [ + 11430, + [ + "ADD", + 41, + 106, + "1" + ], + 477, + 1090 + ], + [ + 11431, + [ + "SCALE", + 106, + "-2" + ], + 477, + 127 + ], + [ + 11432, + [ + "ADD", + 403, + 42, + "1/2" + ], + 477, + 1090 + ], + [ + 11433, + [ + "ADD", + 401, + 42, + "-1" + ], + 477, + 1090 + ], + [ + 11434, + [ + "ADD", + 41, + 42, + "1" + ], + 477, + 1090 + ], + [ + 11435, + [ + "SCALE", + 42, + "-2" + ], + 477, + 1090 + ], + [ + 11436, + [ + "ADD", + 400, + 42, + "1" + ], + 477, + 1090 + ], + [ + 11437, + [ + "ADD", + 42, + 400, + "-1" + ], + 477, + 1090 + ], + [ + 11438, + [ + "ADD", + 400, + 42, + "1" + ], + 477, + 1090 + ], + [ + 11439, + [ + "SCALE", + 42, + "-1" + ], + 477, + 127 + ], + [ + 11440, + [ + "ADD", + 403, + 41, + "-1/2" + ], + 477, + 127 + ], + [ + 11441, + [ + "ADD", + 401, + 41, + "1" + ], + 477, + 127 + ], + [ + 11442, + [ + "ADD", + 400, + 41, + "1" + ], + 477, + 1090 + ], + [ + 11443, + [ + "ADD", + 106, + 41, + "1" + ], + 477, + 127 + ], + [ + 11444, + [ + "ADD", + 42, + 41, + "1" + ], + 477, + 127 + ] + ], + "complete_cost": { + "compiler": { + "H": 80511200000000000, + "N": "2^80511200000000000", + "eta": { + "lower": "0.000000130941005892862380983466", + "upper": "0.000000130941005892862380983467" + }, + "gap": "1/1400000000000", + "integer_test_exponent": 57508, + "logarithm_power": 1024, + "theta": "63/64", + "uniform_saving": "435298341/140000000000", + "word_materialized": false + }, + "full_forward_calls": 18, + "gain": "3041/25000000000", + "kappa": "155463693/50000000000", + "kappa_decimal": "0.00310927386", + "margin_at_previous": { + "lower": "0.029538423950217770836372331151", + "upper": "0.029538423950217770836372331152" + }, + "negative_controls": { + "old_BIT": "Rejected by outer inequalities", + "old_cutoff": "Rejected by completion-tail ratio greater than one" + }, + "nonrecursive": { + "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.", + "local_paid_rank_mass": 5987, + "local_routes": 5165000, + "local_scalar": 220326, + "peak_owned_fields": 2, + "raw_budget": 1000000000, + "raw_scalar_upper": 184647552, + "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word." + }, + "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": "348599999999253/350000000000000", + "fixed_halo_explicit_metadata_branch": "26950000000001/350000000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799999997009/1400000000000000", + "new_semantic_group_guard": "3/1400000000000" + }, + "margins": { + "boundary_algebraic_matrix": "6094176771195647016593/1960000000000000000000000", + "fused_gaussian": "6094176771186941049779/1960000000000000000000000", + "global_coordinate_router": "272061463/87500000000", + "group_bit_router": "380886048286683815611/122500000000000000000000", + "group_scans": "699999999999/700000000000", + "main_transform": "6094176769795647016593/1960000000000000000000000", + "microbox_face_corrections": "26950000000001/350000000000", + "polynomial_products": "1399999999999/1400000000000", + "sparse_union_movement": "802344176771195647016593/1960000000000000000000000" + }, + "parameters": { + "a": "272061463/87500000000", + "b": "4352983409/1400000000000", + "beta": "1399999999997/1400000000000", + "bit_saving": "17/5000", + "cap_xi": "1782344176769795647016593/1960000000000000000000000", + "complex_uniform_saving": "435298341/140000000000", + "d": "1/1400000000000", + "epsilon": "1399999999999/1400000000000", + "kappa": "155463693/50000000000", + "lambda_": "79751258091/80000000000", + "lambda_prime": "1395647016593/1400000000000", + "layout": "1/1400000000000", + "q": "4352983407/1400000000000", + "r0": "1/14000000000000", + "stop": "1/1400000000000", + "tested_saving": "621854773/200000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "25438537/87500000000", + "actual_logarithmic_gamma_guard": "1/1400000000000", + "actual_logarithmic_group_guard": "177655823232304352983407/980000000000000000000000", + "alpha_logarithm_absorption": "1/14000000000000", + "boundary_algebraic_matrix_above_kappa": "5595647016593/1960000000000000000000000", + "cap_above_band": "802344176769795647016593/1960000000000000000000000", + "cap_below_cell": "177655823228804352983407/1960000000000000000000000", + "cap_below_phase_cell_power": "2137655823230204352983407/1960000000000000000000000", + "complex_above_effective": "1/1400000000000", + "complex_below_one_over_32": "39397016591/1400000000000", + "complex_endpoint": "1/700000000000", + "epsilon_below_one": "1/1400000000000", + "epsilon_positive": "1399999999999/1400000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "5586941049779/1960000000000000000000000", + "gaussian_above_main": "695647016593/980000000000000000000000", + "global_coordinate_router_above_kappa": "1/350000000000", + "global_gamma_power_slack": "9/14000000000000", + "group_below_dimension": "1/700000000000", + "group_bit_router_above_kappa": "436683815611/122500000000000000000000", + "group_gauge_power_slack": "177655823232234352983407/980000000000000000000000", + "group_key_fits_record": "1/700000000000", + "group_positive": "1399999999997/1400000000000", + "group_scans_above_kappa": "697823508297/700000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "689151720400418148631/500000000000000000000000", + "lambda_above_internal": "1/2800000000000", + "lambda_above_sigma": "3/2800000000000", + "lambda_above_tau": "1/2800000000000", + "lambda_prime_above_lambda": "1/2800000000000", + "lambda_prime_above_leaf": "2795647016591/1960000000000000000000000", + "leaf_saving_above_effective": "1395647016591/1960000000000000000000000", + "main_transform_above_kappa": "4195647016593/1960000000000000000000000", + "membership_arithmetic_fits_record": "1/1400000000000", + "microbox_face_corrections_above_kappa": "538978235083/7000000000", + "microbox_halo_volume": "110600000000003/1400000000000", + "new_complex_uniform_saving_above_b": "1/1400000000000", + "new_semantic_guard_with_C1_one": "1/1400000000000", + "polynomial_products_above_kappa": "279129403319/280000000000", + "positive_layout_slack": "1/1400000000000", + "q_below_effective": "1/1400000000000", + "q_below_internal": "1/1400000000000", + "q_below_leaf": "2795647016591/1960000000000000000000000", + "q_positive": "4352983407/1400000000000", + "short_record_fallback": "1395647016591/1400000000000", + "source_axis_superpolynomial": "1/1400000000000", + "sparse_union_movement_above_kappa": "796250000005595647016593/1960000000000000000000000", + "stop_below_one": "1399999999999/1400000000000", + "stop_positive": "1/1400000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000000", + "union_tag_work_per_visit_fits_record": "3/1400000000000" + } + }, + "paid": { + "1": 40890, + "16": 416, + "2": 8262, + "24": 416, + "3": 8910, + "32": 416, + "4": 1674, + "40": 416, + "48": 416, + "5": 2844, + "56": 416, + "6": 396, + "64": 416, + "7": 270, + "72": 208 + }, + "paid_calls": 66366, + "previous_open_pr5660": "155457611/50000000000", + "productive_fields": 12958, + "query_shears": 15, + "rank_mass_surplus": 760, + "raw_ceiling": { + "derivative_upper": "-184875946608214952994698474609300303078340465646268258464787663/784637716923335095479473677900958302012794430558004314112", + "interval": [ + "0", + "17/5000" + ] + }, + "raw_headroom": [ + "1521/100000000000000", + "761/50000000000000" + ], + "raw_root_interval": [ + "310927387521/100000000000000", + "155463693761/50000000000000" + ], + "relative_gain_percent": "608200/155457611", + "strictification": { + "alpha": { + "lower": "0.999999999989619742858683178514", + "upper": "0.999999999989619742858683178515" + }, + "cutoff": 17, + "delta": { + "lower": "0.967459815568044692665878627648", + "upper": "0.967459815568044692665878627649" + }, + "floor": 18, + "gamma": { + "lower": "0.968237083035846424139840039367", + "upper": "0.968237083035846424139840039368" + }, + "normalized_paid_upper": "1048576000976562501/1048576001073741824", + "power": 1024, + "reserve": "1/1000000000000", + "tail_block": 128, + "tail_decay": "39/40", + "tail_offset": "1/5", + "tested": "621854773/200000000000" + }, + "targets": { + "1": 18, + "145": 208, + "17": 416, + "2": 72, + "25": 416, + "33": 416, + "4": 1656, + "41": 416, + "49": 416, + "5": 126, + "57": 416, + "65": 416, + "7": 90, + "73": 208, + "8": 252, + "9": 7416 + }, + "whole_idle_jobs": 3120 + }, + "controls": { + "block_op_on_old_chart": "Scalar destination and coefficient", + "extra_target_credit": "Every productive helper has a native target", + "missing_block_move": "Scalar destination and coefficient", + "old_helper_start": "Scalar destination and coefficient", + "read_after_write": "Dependent operations keep their order", + "unpaid_query": "Complete field and call counts" + }, + "global_paid_delta": { + "1": 18, + "4": 18, + "5": -18 + }, + "helper_credit_delta": { + "1": -1, + "4": 1, + "5": 1, + "8": -1 + }, + "helper_finals": { + "405": [ + 477, + 1090 + ] + }, + "helper_starts": { + "741": [ + 477, + 1090 + ] + }, + "local": { + "endpoint_coefficients": 565504, + "helpers": { + "1": 1, + "2": 4, + "4": 92, + "5": 7, + "7": 5, + "8": 14, + "9": 412 + }, + "owned_fields": 9, + "owned_lifetimes": 11, + "paid": { + "1": 2185, + "2": 459, + "3": 495, + "4": 93, + "5": 158, + "6": 22, + "7": 15 + }, + "paid_rank_mass": 5987, + "peak_owned_fields": 2, + "public_inputs": 743, + "real_scalar_allowance": 220326 + }, + "local_paid_delta": { + "1": 1, + "4": 1, + "5": -1 + }, + "native": { + "distinct_maps": 2919, + "helper_normalizers": 1070, + "helpers": { + "1": 1, + "2": 4, + "4": 92, + "5": 7, + "7": 5, + "8": 14, + "9": 412 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "54871ccb2fd4524d1d55422bad3306004c04117e48105f50ada0f48d705184ce", + "wrong_phase_rejected": true + }, + "physical": { + "central_square_columns": 53248, + "full_calls": 18, + "main_targets": { + "145": 208, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "73": 208 + }, + "new_paid_jobs": 0, + "physical_contacts": 7488, + "ports": 104, + "route_payload_sha256": "7f4f0ca768ffbc4f93dcff575592c4c67411f46b4289e45b73f715a2ad47b142", + "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.", + "whole_idle_jobs": { + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416, + "64": 416, + "72": 208 + }, + "wrapper_sites": [ + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31 + ] + }, + "source": { + "pr5713": "a5348f7143f95fe0046b92b96172e30763c7d731" + }, + "status": "PASS_P104_R22_REFRAME_KAPPA_00310927386", + "transpose": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 565504, + "columns": 752 + } +} diff --git a/research/p104-split-block-composition/source/pr5739/WORD.json.gz b/research/p104-split-block-composition/source/pr5739/WORD.json.gz new file mode 100644 index 0000000000..4c7fb353c6 Binary files /dev/null and b/research/p104-split-block-composition/source/pr5739/WORD.json.gz differ diff --git a/research/p104-split-block-composition/source/pr5739/construct.py b/research/p104-split-block-composition/source/pr5739/construct.py new file mode 100644 index 0000000000..ca59c61f8a --- /dev/null +++ b/research/p104-split-block-composition/source/pr5739/construct.py @@ -0,0 +1,35 @@ +"""Construct the R22 word from the source P104 word and EDITS.json. + +Joel Pulikkan (GamingPuzzled) with Claude Opus 5.5 (Anthropic) via Claude Code. Apache-2.0. + +EDITS.json lists appended charts, changed helper start/final charts, and program hunks. +Each hunk replaces one exact run of source events that occurs exactly once; hunks may not overlap. +""" +from copy import deepcopy +from pathlib import Path +import json + +EDITS = json.loads((Path(__file__).resolve().parent/'EDITS.json').read_text()) + + +def locate(program, run): + hits = [i for i in range(len(program) - len(run) + 1) if program[i:i+len(run)] == run] + assert len(hits) == 1, ('unique source run', run[:2], hits) + return hits[0] + + +def construct(base, schema='p104-r22-reframe/1'): + word = deepcopy(base) + word['frames'] += deepcopy(EDITS['frames']) + for key in ('initial', 'final'): + for r, (old, new) in EDITS[key].items(): + assert word[key][int(r)] == old, ('source chart', key, r) + word[key][int(r)] = new + program = word['program'] + spots = sorted((locate(program, old), old, new) for old, new in EDITS['program']) + for (i, old, _), (j, _, _) in zip(spots, spots[1:]): + assert i + len(old) <= j, 'Disjoint hunks' + for i, old, new in reversed(spots): + program[i:i+len(old)] = deepcopy(new) + word['schema'] = schema + return word diff --git a/research/p104-split-block-composition/source/pr5739/pricing.py b/research/p104-split-block-composition/source/pr5739/pricing.py new file mode 100644 index 0000000000..9f233cf78e --- /dev/null +++ b/research/p104-split-block-composition/source/pr5739/pricing.py @@ -0,0 +1,177 @@ +"""Complete mixed-target price, compiler and outer transfer. + +The interval and compiler bounds follow zxv and Cao Yifan. The productive +recursion is by Jacob Alan Sussman. The controller is by Cinna Davis. +Adapted from Ali Romman's PR5544/5545 for the two coupled contact changes. +Successor choices were prepared for thu-nmrc with OpenAI Codex assistance. +Helper-subspace targets were added by Ali Romman with OpenAI Codex assistance. +The source commuting-contact construction is by Pierre-Loic Doulcet (hexapode) in PR5565. +The source coupled-frame change is by Ali Romman with OpenAI Codex in PR5601. +Five fixed boundary relations are from Ali Romman's PR5602. +The shared and delayed relays are from flyingviper's PR5605 and PR5612. The preparation is from +Scratch-net's PR5606. Their costs and target debit are included. +Ali Romman's complete caller/price proof and all predecessor credit are retained. +The paid A2 change is from zxv PR5643. The three helper relations are from +Ali Romman PR5644. The four-gate change is by Ali Romman with Codex assistance. +The four interior basis changes are by Ali Romman with Codex assistance. +Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +import local as L + +KAPPA, TESTED = Q('.00310927386'), Q('.003109273865') +PREVIOUS = Q('.00310915222') + + +def encode(x): + if isinstance(x,Q): + return str(x) + if isinstance(x,dict): + return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)): + return [encode(v) for v in x] + return x + + +def assemble(local, native, word, physical): + paid, targets = Counter(), Counter() + counts = Counter() + L.need(local['helpers'] == native['helpers'], 'Every productive helper has a native target') + for e in word['physical_events']: + counts[e[0]] += 1 + if e[0] == 'LOCAL': + L.need(e[3] is False, 'Every source invocation is forward') + paid.update(local['paid']) + targets.update(local['helpers']) + elif e[0] == 'QUERY_SHEAR': + paid[1] += 104 + elif e[0] == 'IDLE': + paid[8*len(e[2])] += 208 + main = Counter() + idle = Counter({8*len(e[2]):0 for e in word['physical_events'] if e[0] == 'IDLE'}) + for e in word['physical_events']: + if e[0] == 'IDLE': + idle[8*len(e[2])] += 208 + L.need(idle == physical['whole_idle_jobs'], 'Every whole idle has a native Gaussian and full rank') + for term in word['diagonal']: + main[1+8*sum(term[1:])] += 104 + L.need(main == physical['main_targets'], 'Every main target has its full native phase') + targets.update(main) + L.need(counts['LOCAL'] == 18 and counts['QUERY_SHEAR'] == counts['IDLE'] == 15, 'Complete call census') + # Recount by the two path lengths, without using emitted main diagonals. + second_t = Counter({r:18*n for r,n in local['helpers'].items()}) + second_p = Counter({r:18*n for r,n in local['paid'].items()}) + second_t[145] += 208 + second_p[1] += 15*104 + for length in (7,8): + for j in range(1,length+1): + second_t[1+8*(j+1)] += 208 + second_p[8*(j+1)] += 208 + L.need((targets,paid) == (second_t,second_p), 'Independent full invoice') + L.need(max(targets) == 145 and max(paid) == 72, 'Maximum recursive ranks') + L.need(sum(targets.values()) == 12958 and sum(paid.values()) == 66366, 'Complete field and call counts') + L.need(sum(r*n for r,n in targets.items())-sum(r*n for r,n in paid.items()) == 760, 'Complete rank surplus') + return targets,paid,counts + + +def run(local,native,word,physical): + T,P,counts = assemble(local,native,word,physical) + E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py','p104_productive_intervals') + other = L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','p104_productive_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] + lo,hi,grid = 0,10**12,10**14 + while hi-lo > 1: + m=(lo+hi)//2 + if margin(Q(m,grid))[0] > 0: + lo=m + else: + hi=m + lower,upper = Q(lo,grid),Q(hi,grid) + signed = Counter(T) + signed.subtract(P) + cap = Q('.0034') + derivative_upper = Q(0) + for rank, count in signed.items(): + logarithm = E.log_bounds(rank) + low = E.mul(E.power(rank, 1-cap), logarithm)[0] + high = rank*logarithm[1] + derivative_upper -= count*(low if count >= 0 else high) + L.need(derivative_upper < 0, 'Unique raw crossing below the retained BIT cap') + L.need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure') + L.need(PREVIOUS < KAPPA < TESTED < lower and margin(PREVIOUS)[0] > 0, 'Changed complete bill improves the source claim') + t,u,v,c,b = 1-TESTED,Q(1,5),1024,17,18 + target,paid = E.moment(T,t),E.moment(P,t) + tl,th = other.moment(T,TESTED) + pl,ph = other.moment(P,TESTED) + L.need(tl > ph and max(tl,target[0]) <= min(th,target[1]) and max(pl,paid[0]) <= min(ph,paid[1]), 'Two exact moment engines') + alpha = E.divide(paid,target) + gamma = E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target)) + delta = E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,TESTED),target)) + reserve,decay = Q(1,10**12),Q(39,40) + L.need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All three charged tail ratios') + L.need(decay**128 < Q(1,16), 'Both tail decay blocks') + normalized = 1/(1+v*reserve)+Q(4,2**32) + L.need(normalized < 1 and c**64 < b**63, 'Full completion, splitting and rounding charges') + theta,power = Q(63,64),1024 + eta = E.scale(E.power(145,-v*TESTED),t) + L.need(2*(c**v)**64 <= (145**v)**63 and eta[0] > theta**power, 'Shifted exits and complement capacity') + L.need(E.power(145,v*TESTED)[1] < 2**power, 'Compiler initial range') + gap = (TESTED-KAPPA)/7 + L.need(gap.numerator == 1, 'Exact compiler integer grid') + step = gap.denominator + def wins(j): + return (step*j+1)**power < 2**j + left,right=1,2 + while not wins(right): + left,right=right,2*right + while right-left > 1: + m=(left+right)//2 + if wins(m): + right=m + else: + left=m + H=step*right + L.need(H > 8*v and wins(right) and not wins(right-1), 'Finite uniform threshold with predecessor rejection') + local_routes = (sum(local['paid'].values())+native['helper_normalizers']+native['main_adapters']+4*104+4*local['owned_lifetimes'])*1000 + L.need(local['real_scalar_allowance']+local_routes < 10**7, 'Every local scalar, route and owned operation is funded') + boundary = sum(len(word['boundaries'][side+'_program']) for side in ('left','right')) + raw = 18*10**7 + 15*1664 + 32*104*(len(word['physical_events'])+boundary) + raw += 32*104*(26+1000) + L.need(raw < 10**9, 'Complete nonrecursive raw bound') + 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']) + L.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','p104_productive_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) + L.need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete outer predicate inventory') + L.need(all(x > 0 for key in ('strict_checks','functional_checks') for x in outer[key].values()), 'All outer inequalities strict') + wrong_cutoff = E.divide((Q(sum(T.values())*21),)*2,E.mul(E.power(20,TESTED),target)) + L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory') + bad=outer_module.ledger(dict(params,bit_saving=Q('.0027'))) + L.need(any(x <= 0 for x in bad['strict_checks'].values()), 'Insufficient BIT contract rejected') + return encode({'kappa':KAPPA,'kappa_decimal':'0.00310927386','previous_open_pr5660':PREVIOUS,'gain':KAPPA-PREVIOUS, + 'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper], + 'raw_headroom':[lower-KAPPA,upper-KAPPA], + 'raw_ceiling':{'interval':[Q(0),cap],'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,'query_shears':15,'whole_idle_jobs':3120, + 'strictification':{'tested':TESTED,'power':v,'cutoff':c,'floor':b,'tail_offset':u,'reserve':reserve,'tail_decay':decay,'tail_block':128, + 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta),'normalized_paid_upper':normalized}, + 'compiler':{'theta':theta,'logarithm_power':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'], + 'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.', + 'local_paid_rank_mass':local['paid_rank_mass'], + 'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word.'}, + 'ordinary_BIT':bit,'outer':outer, + 'negative_controls':{'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}}) diff --git a/research/p104-split-block-composition/source/pr5739/verify.py b/research/p104-split-block-composition/source/pr5739/verify.py new file mode 100644 index 0000000000..b214cdd26b --- /dev/null +++ b/research/p104-split-block-composition/source/pr5739/verify.py @@ -0,0 +1,194 @@ +"""Check the R22 reorder+reframe word on PR5713's P104 word on PR5713's own complete stack. + +Joel Pulikkan (GamingPuzzled) with Claude Opus 5.5 (Anthropic) via Claude Code. Apache-2.0. +Every retained checker is loaded unmodified from ../p104-temporal-updates (Ali Romman, zxv and +the contributors listed in its NOTICE); only the four declared pricing literals change. +""" +from collections import Counter, defaultdict +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse, gzip, importlib.util, json, sys, tempfile + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +BASE = HERE.parent/'p104-temporal-updates' +sys.path.insert(0, str(HERE)) +from construct import construct + +PINS = { # PR5713 head a5348f7143f95fe0046b92b96172e30763c7d731 + 'WORD.json.gz': '9fd67dd89ed24a644257cd9aef06934ed4c6fbe0441804684a968868f2ef66a8', +} +PUBLIC = 743 +PARENT_KAPPA = Q('.00310915222') +LITERALS = [ + ("KAPPA, TESTED = Q('155457611/50000000000'), Q('124366089/40000000000')", "KAPPA, TESTED = Q('.00310927386'), Q('.003109273865')"), + ("PREVIOUS = Q('.00310871312')", "PREVIOUS = Q('.00310915222')"), + ("sum(paid.values()) == 66348", "sum(paid.values()) == 66366"), + ("'kappa_decimal':'0.00310915222'", "'kappa_decimal':'0.00310927386'"), +] +STATUS = 'PASS_P104_R22_REFRAME_KAPPA_00310927386' + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +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 read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + + +def kinds(e): + """(register, type) per touched register; T/T and S/S commute exactly, everything else conflicts. + Owned registers keep every operation exclusive; INIT/CLEAR also share the owned-lifetime token.""" + op = e[0] + if op == 'ADD': + out = [(e[1], 'T'), (e[2], 'S')] + elif op == 'COPY': + out = [(e[1], 'X'), (e[2], 'S')] + elif op in ('INIT', 'CLEAR'): + return [(e[1], 'X'), ('owned-lifetime', 'X')] + else: + out = [(e[1], 'X')] + return [(r, 'X' if r >= PUBLIC else t) for r, t in out] + + +def strip(e): + return tuple(e[:2]) if e[0] in ('INIT', 'CLEAR') else tuple(e[:-1]) + + +def trace_equivalent(old, new): + """Every scalar/owned operation appears once more; every dependent pair keeps its order.""" + need(Counter(map(strip, old)) == Counter(map(strip, new)), 'Same multiset of scalar and owned operations') + slots = defaultdict(list) + for j, e in enumerate(new): + slots[strip(e)].append(j) + for v in slots.values(): + v.reverse() + match = [slots[strip(e)].pop() for e in old] + groups = defaultdict(list) + for i, e in enumerate(old): + for r, t in kinds(e): + g = groups[r] + if g and g[-1][0] == t and t != 'X': + g[-1][1].append(i) + else: + g.append([t, [i]]) + for g in groups.values(): + for (_, a), (_, b) in zip(g, g[1:]): + need(max(match[i] for i in a) < min(match[i] for i in b), 'Dependent operations keep their order') + return match + + +def changes(a, b): + d = Counter(a); d.subtract(b); return {str(r): c for r, c in sorted(d.items()) if c} + + +def reject(f): + try: + f() + except (ValueError, AssertionError, KeyError, IndexError) as e: + return str(e) or type(e).__name__ + raise ValueError('Malformed control accepted') + + +def run(): + for name, digest in PINS.items(): + need(sha256((BASE/name).read_bytes()).hexdigest() == digest, 'Exact PR5713 source ' + name) + base, word = read(BASE/'WORD.json.gz'), read(HERE/'WORD.json.gz') + need(construct(base) == word, 'Exact regeneration from PR5713') + for key in base: + if key not in ('program', 'initial', 'final', 'frames', 'schema'): + need(word[key] == base[key], 'Unchanged word field ' + key) + need(word['frames'][:len(base['frames'])] == base['frames'], 'Existing charts unchanged') + starts = {str(r): [a, b] for r, (a, b) in enumerate(zip(base['initial'], word['initial'])) if a != b} + finals = {str(r): [a, b] for r, (a, b) in enumerate(zip(base['final'], word['final'])) if a != b} + need(starts == {'741': [477, 1090]} and finals == {'405': [477, 1090]}, 'Exact changed helper endpoints') + main = set(base['live']) | {r + 112 for r in base['live']} + need(all(int(r) not in main for r in list(starts) + list(finals)), 'Only free helper endpoints change') + scalar = lambda w: [e for e in w['program'] if e[0] != 'MOVE'] + match = trace_equivalent(scalar(base), scalar(word)) + old = scalar(base) + charts = [[i, old[i][:-1], old[i][-1], scalar(word)[match[i]][-1]] for i in range(len(old)) + if scalar(word)[match[i]] != old[i]] + print('PASS source pin, regeneration, trace equivalence; changed charts', charts, flush=True) + + sys.path.insert(0, str(BASE)) + S = load(BASE/'sources.py', 'r22_sources') + original = (BASE/'pricing.py').read_text() + for before, after in LITERALS: + need(original.count(before) == 1, 'Unique pricing literal ' + before); original = original.replace(before, after) + need((HERE/'pricing.py').read_text() == original, 'Only declared pricing literals change') + with S.sources() as (parent, _), load(parent/'sources.py', 'r22_parent_sources').sources() as (prior, _), \ + load(prior/'sources.py', 'r22_prior_sources').sources() as (stack, framework): + L = load(stack/'local.py', 'local') + L.ROOT = framework + parent_local, local = L.replay(base), L.replay(word) + need(parent_local['real_scalar_allowance'] == local['real_scalar_allowance'], 'Same scalar allowance') + paid_delta = changes(local['paid'], parent_local['paid']) + helper_delta = changes(local['helpers'], parent_local['helpers']) + need(paid_delta == {'1': 1, '4': 1, '5': -1} and helper_delta == {'1': -1, '4': 1, '5': 1, '8': -1}, + 'Exact local invoice change') + print('PASS exact local replay', local['paid'], local['helpers'], flush=True) + transpose = L.reverse_columns(word) + print('PASS every dense transpose column', transpose['columns'], flush=True) + native = L.native(word) + print('PASS every native map and exact phase', native['distinct_maps'], flush=True) + C = load(framework/'research/p104-productive-controller/caller.py', 'r22_caller') + caller = C.construct() + need(caller == read(framework/'research/p104-productive-controller/CONTROLLER.json'), 'Exact retained caller') + physical = C.physical(caller, word) + print('PASS full physical caller', flush=True) + P = load(HERE/'pricing.py', 'r22_pricing') + price = P.run(local, native, caller, physical) + print('PASS complete pricing', price['raw_root_interval'], flush=True) + lo = Q(price['raw_root_interval'][0]) + need(lo > PARENT_KAPPA, 'Strict raw gain over PR5713 claim') + controls = {} + bad = deepcopy(word); bad['initial'][741] = 477 + controls['old_helper_start'] = reject(lambda: L.replay(bad)) + bad = deepcopy(word); i = bad['program'].index(['ADD', 42, 41, '1', 1090]); bad['program'][i][-1] = 477 + controls['block_op_on_old_chart'] = reject(lambda: L.replay(bad)) + bad = deepcopy(word); i = next(k for k, e in enumerate(bad['program']) if e[0] == 'MOVE' and e[3] == 1090) + bad['program'].pop(i) + controls['missing_block_move'] = reject(lambda: L.replay(bad)) + bad = deepcopy(local); bad['paid'][1] -= 1 + controls['unpaid_query'] = reject(lambda: P.assemble(bad, native, caller, physical)) + bad = deepcopy(local); bad['helpers'][9] += 1 + controls['extra_target_credit'] = reject(lambda: P.assemble(bad, native, caller, physical)) + bad = scalar(word) + i, j = bad.index(['ADD', 42, 41, '1', 1090]), bad.index(['ADD', 41, 42, '-1', 1090]) + bad[i], bad[j] = bad[j], bad[i] + controls['read_after_write'] = reject(lambda: trace_equivalent(scalar(base), bad)) + return P.encode({'status': STATUS, 'source': {'pr5713': 'a5348f7143f95fe0046b92b96172e30763c7d731'}, + 'helper_starts': starts, 'helper_finals': finals, 'changed_charts': charts, 'local': local, + 'local_paid_delta': paid_delta, 'helper_credit_delta': helper_delta, + 'global_paid_delta': {r: 18*n for r, n in paid_delta.items()}, + 'transpose': transpose, 'native': native, 'physical': physical, + 'complete_cost': price, 'controls': controls}) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__); ap.add_argument('--write', action='store_true') + args = ap.parse_args() + with tempfile.TemporaryDirectory(prefix='p104-r22-bytecode-') as cache: + sys.pycache_prefix = cache; result = run() + target = HERE/'RESULT.json' + if args.write: + target.write_text(json.dumps(result, sort_keys=True, indent=2) + '\n') + else: + need(read(target) == result, 'Exact saved complete receipt') + print(result['status'], flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/p104-split-block-composition/source/pr5751-source.tar b/research/p104-split-block-composition/source/pr5751-source.tar new file mode 100644 index 0000000000..89ac4dba7a Binary files /dev/null and b/research/p104-split-block-composition/source/pr5751-source.tar differ diff --git a/research/p104-split-block-composition/source/pr5756/RESULT.json b/research/p104-split-block-composition/source/pr5756/RESULT.json new file mode 100644 index 0000000000..9d47144bd9 --- /dev/null +++ b/research/p104-split-block-composition/source/pr5756/RESULT.json @@ -0,0 +1,1400 @@ +{ + "changed_charts": [ + [ + 11545, + [ + "ADD", + 42, + 41, + "1" + ], + 477, + 1090 + ], + [ + 11546, + [ + "ADD", + 41, + 42, + "-1" + ], + 477, + 1090 + ], + [ + 11547, + [ + "ADD", + 42, + 41, + "1" + ], + 477, + 1090 + ], + [ + 11548, + [ + "SCALE", + 41, + "-1" + ], + 477, + 1090 + ], + [ + 11549, + [ + "SCALE", + 41, + "-2" + ], + 477, + 1090 + ], + [ + 11550, + [ + "ADD", + 400, + 41, + "-1" + ], + 477, + 1090 + ], + [ + 11551, + [ + "ADD", + 401, + 41, + "-1" + ], + 477, + 1090 + ], + [ + 11552, + [ + "SCALE", + 42, + "-2" + ], + 477, + 1090 + ], + [ + 11553, + [ + "ADD", + 106, + 42, + "1/2" + ], + 477, + 1090 + ], + [ + 11554, + [ + "ADD", + 403, + 42, + "-1" + ], + 477, + 1090 + ], + [ + 11555, + [ + "ADD", + 405, + 106, + "1" + ], + 477, + 1090 + ], + [ + 11556, + [ + "ADD", + 106, + 405, + "-1" + ], + 477, + 1090 + ], + [ + 11557, + [ + "ADD", + 405, + 106, + "1" + ], + 477, + 1090 + ], + [ + 11558, + [ + "SCALE", + 106, + "-1" + ], + 477, + 1090 + ], + [ + 11559, + [ + "ADD", + 41, + 405, + "-2" + ], + 477, + 1090 + ], + [ + 11560, + [ + "ADD", + 405, + 42, + "-1" + ], + 477, + 1090 + ], + [ + 11561, + [ + "ADD", + 405, + 403, + "-1/2" + ], + 477, + 1090 + ], + [ + 11562, + [ + "ADD", + 741, + 403, + "1/2" + ], + 477, + 1090 + ], + [ + 11563, + [ + "ADD", + 741, + 42, + "1" + ], + 477, + 1090 + ], + [ + 11564, + [ + "ADD", + 41, + 741, + "2" + ], + 477, + 1090 + ], + [ + 11565, + [ + "ADD", + 410, + 400, + "1" + ], + 477, + 1090 + ], + [ + 11566, + [ + "ADD", + 400, + 410, + "-1" + ], + 477, + 1090 + ], + [ + 11567, + [ + "ADD", + 410, + 400, + "1" + ], + 477, + 1090 + ], + [ + 11568, + [ + "SCALE", + 400, + "-1" + ], + 477, + 1090 + ], + [ + 11569, + [ + "SCALE", + 400, + "-2" + ], + 477, + 1090 + ], + [ + 11570, + [ + "ADD", + 403, + 401, + "1" + ], + 477, + 1090 + ], + [ + 11571, + [ + "ADD", + 401, + 403, + "-1" + ], + 477, + 1090 + ], + [ + 11572, + [ + "ADD", + 403, + 401, + "1" + ], + 477, + 1090 + ], + [ + 11573, + [ + "SCALE", + 401, + "-1" + ], + 477, + 1090 + ], + [ + 11574, + [ + "ADD", + 42, + 401, + "1" + ], + 477, + 1090 + ], + [ + 11575, + [ + "ADD", + 741, + 401, + "1/2" + ], + 477, + 1090 + ], + [ + 11576, + [ + "ADD", + 41, + 403, + "1" + ], + 477, + 1090 + ], + [ + 11577, + [ + "ADD", + 400, + 403, + "1" + ], + 477, + 1090 + ], + [ + 11578, + [ + "ADD", + 410, + 403, + "-2" + ], + 477, + 1090 + ], + [ + 11579, + [ + "ADD", + 410, + 741, + "1" + ], + 477, + 1090 + ], + [ + 11580, + [ + "ADD", + 741, + 410, + "-1" + ], + 477, + 1090 + ], + [ + 11581, + [ + "ADD", + 410, + 741, + "1" + ], + 477, + 1090 + ], + [ + 11582, + [ + "SCALE", + 741, + "-1" + ], + 477, + 1090 + ], + [ + 11583, + [ + "SCALE", + 741, + "-1/2" + ], + 477, + 1090 + ], + [ + 11584, + [ + "ADD", + 41, + 741, + "-1" + ], + 477, + 1090 + ], + [ + 11585, + [ + "ADD", + 400, + 741, + "-1" + ], + 477, + 1090 + ], + [ + 11586, + [ + "ADD", + 403, + 741, + "-1" + ], + 477, + 1090 + ], + [ + 11587, + [ + "ADD", + 42, + 410, + "-1" + ], + 477, + 1090 + ], + [ + 11588, + [ + "ADD", + 106, + 410, + "-1" + ], + 477, + 1090 + ], + [ + 11589, + [ + "ADD", + 401, + 410, + "-1" + ], + 477, + 1090 + ], + [ + 11590, + [ + "ADD", + 741, + 410, + "1" + ], + 477, + 1090 + ], + [ + 11591, + [ + "ADD", + 403, + 410, + "1" + ], + 477, + 1090 + ], + [ + 11592, + [ + "ADD", + 401, + 410, + "-1" + ], + 477, + 1090 + ], + [ + 11593, + [ + "SCALE", + 410, + "2" + ], + 477, + 1090 + ], + [ + 11594, + [ + "ADD", + 403, + 741, + "1" + ], + 477, + 1090 + ], + [ + 11595, + [ + "ADD", + 106, + 741, + "1" + ], + 477, + 1090 + ], + [ + 11596, + [ + "ADD", + 42, + 741, + "-1" + ], + 477, + 1090 + ], + [ + 11597, + [ + "ADD", + 410, + 741, + "1" + ], + 477, + 1090 + ], + [ + 11598, + [ + "ADD", + 741, + 410, + "-1" + ], + 477, + 1090 + ], + [ + 11599, + [ + "ADD", + 410, + 741, + "1" + ], + 477, + 1090 + ], + [ + 11600, + [ + "SCALE", + 741, + "-1" + ], + 477, + 1090 + ], + [ + 11601, + [ + "ADD", + 410, + 403, + "-1/2" + ], + 477, + 1090 + ], + [ + 11602, + [ + "ADD", + 741, + 403, + "-1" + ], + 477, + 1090 + ], + [ + 11603, + [ + "ADD", + 401, + 403, + "1" + ], + 477, + 1090 + ], + [ + 11604, + [ + "ADD", + 400, + 403, + "1/2" + ], + 477, + 1090 + ], + [ + 11605, + [ + "ADD", + 106, + 403, + "-1/2" + ], + 477, + 1090 + ], + [ + 11606, + [ + "ADD", + 42, + 403, + "1/2" + ], + 477, + 1090 + ], + [ + 11607, + [ + "ADD", + 41, + 403, + "-1/2" + ], + 477, + 1090 + ], + [ + 11608, + [ + "SCALE", + 403, + "-1/2" + ], + 477, + 1090 + ], + [ + 11609, + [ + "ADD", + 741, + 401, + "1" + ], + 477, + 1090 + ], + [ + 11610, + [ + "ADD", + 403, + 401, + "1/2" + ], + 477, + 1090 + ], + [ + 11611, + [ + "ADD", + 400, + 401, + "-1/2" + ], + 477, + 1090 + ], + [ + 11612, + [ + "ADD", + 106, + 401, + "1/2" + ], + 477, + 1090 + ], + [ + 11613, + [ + "ADD", + 42, + 401, + "1/2" + ], + 477, + 1090 + ], + [ + 11614, + [ + "ADD", + 41, + 401, + "1/2" + ], + 477, + 1090 + ], + [ + 11615, + [ + "SCALE", + 401, + "-2" + ], + 477, + 1090 + ], + [ + 11616, + [ + "ADD", + 106, + 400, + "1" + ], + 477, + 1090 + ], + [ + 11617, + [ + "ADD", + 42, + 400, + "1" + ], + 477, + 1090 + ], + [ + 11618, + [ + "ADD", + 41, + 400, + "-1" + ], + 477, + 1090 + ], + [ + 11619, + [ + "SCALE", + 400, + "2" + ], + 477, + 1090 + ], + [ + 11620, + [ + "ADD", + 401, + 400, + "1" + ], + 477, + 1090 + ], + [ + 11621, + [ + "ADD", + 400, + 401, + "-1" + ], + 477, + 1090 + ], + [ + 11622, + [ + "ADD", + 401, + 400, + "1" + ], + 477, + 1090 + ], + [ + 11623, + [ + "SCALE", + 400, + "-1" + ], + 477, + 1090 + ], + [ + 11624, + [ + "ADD", + 403, + 106, + "1/2" + ], + 477, + 127 + ], + [ + 11625, + [ + "ADD", + 401, + 106, + "-1" + ], + 477, + 127 + ], + [ + 11626, + [ + "ADD", + 41, + 106, + "1" + ], + 477, + 1090 + ], + [ + 11627, + [ + "SCALE", + 106, + "-2" + ], + 477, + 127 + ], + [ + 11628, + [ + "ADD", + 403, + 42, + "1/2" + ], + 477, + 1090 + ], + [ + 11629, + [ + "ADD", + 401, + 42, + "-1" + ], + 477, + 1090 + ], + [ + 11630, + [ + "ADD", + 41, + 42, + "1" + ], + 477, + 1090 + ], + [ + 11631, + [ + "SCALE", + 42, + "-2" + ], + 477, + 1090 + ], + [ + 11632, + [ + "ADD", + 400, + 42, + "1" + ], + 477, + 1090 + ], + [ + 11633, + [ + "ADD", + 42, + 400, + "-1" + ], + 477, + 1090 + ], + [ + 11634, + [ + "ADD", + 400, + 42, + "1" + ], + 477, + 1090 + ], + [ + 11635, + [ + "SCALE", + 42, + "-1" + ], + 477, + 127 + ], + [ + 11636, + [ + "ADD", + 403, + 41, + "-1/2" + ], + 477, + 127 + ], + [ + 11637, + [ + "ADD", + 401, + 41, + "1" + ], + 477, + 127 + ], + [ + 11638, + [ + "ADD", + 400, + 41, + "1" + ], + 477, + 1090 + ], + [ + 11639, + [ + "ADD", + 106, + 41, + "1" + ], + 477, + 127 + ], + [ + 11640, + [ + "ADD", + 42, + 41, + "1" + ], + 477, + 127 + ] + ], + "complete_cost": { + "compiler": { + "H": 80511200000000000, + "N": "2^80511200000000000", + "eta": { + "lower": "0.000000128387229643834457871291", + "upper": "0.000000128387229643834457871292" + }, + "gap": "1/1400000000000", + "integer_test_exponent": 57508, + "logarithm_power": 1024, + "theta": "63/64", + "uniform_saving": "272399571/87500000000", + "word_materialized": false + }, + "full_forward_calls": 18, + "gain": "2439/20000000000", + "kappa": "62262759/20000000000", + "kappa_decimal": "0.00311313795", + "margin_at_previous": { + "lower": "0.029578770580357904755090866637", + "upper": "0.029578770580357904755090866638" + }, + "negative_controls": { + "old_BIT": "Rejected by outer inequalities", + "old_cutoff": "Rejected by completion-tail ratio greater than one", + "source_completion": "Rejected at cutoff17, floor18 and decay39/40", + "source_offset": "Rejected at cutoff16 with tail offset1/5" + }, + "nonrecursive": { + "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.", + "local_paid_rank_mass": 5987, + "local_routes": 5240000, + "local_scalar": 224138, + "peak_owned_fields": 2, + "raw_budget": 1000000000, + "raw_scalar_upper": 184647552, + "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word." + }, + "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": "348599999999253/350000000000000", + "fixed_halo_explicit_metadata_branch": "26950000000001/350000000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799999997009/1400000000000000", + "new_semantic_group_guard": "3/1400000000000" + }, + "margins": { + "boundary_algebraic_matrix": "6101750387595641606867/1960000000000000000000000", + "fused_gaussian": "6101750387586924820601/1960000000000000000000000", + "global_coordinate_router": "2179196567/700000000000", + "group_bit_router": "3050875194493462410299/980000000000000000000000", + "group_scans": "699999999999/700000000000", + "main_transform": "6101750386195641606867/1960000000000000000000000", + "microbox_face_corrections": "26950000000001/350000000000", + "polynomial_products": "1399999999999/1400000000000", + "sparse_union_movement": "802351750387595641606867/1960000000000000000000000" + }, + "parameters": { + "a": "2179196567/700000000000", + "b": "871678627/280000000000", + "beta": "1399999999997/1400000000000", + "bit_saving": "17/5000", + "cap_xi": "1782351750386195641606867/1960000000000000000000000", + "complex_uniform_saving": "272399571/87500000000", + "d": "1/1400000000000", + "epsilon": "1399999999999/1400000000000", + "kappa": "62262759/20000000000", + "lambda_": "398754744819/400000000000", + "lambda_prime": "1395641606867/1400000000000", + "layout": "1/1400000000000", + "q": "4358393133/1400000000000", + "r0": "1/14000000000000", + "stop": "1/1400000000000", + "tested_saving": "622627591/200000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "200803433/700000000000", + "actual_logarithmic_gamma_guard": "1/1400000000000", + "actual_logarithmic_group_guard": "177648249615904358393133/980000000000000000000000", + "alpha_logarithm_absorption": "1/14000000000000", + "boundary_algebraic_matrix_above_kappa": "5595641606867/1960000000000000000000000", + "cap_above_band": "802351750386195641606867/1960000000000000000000000", + "cap_below_cell": "177648249612404358393133/1960000000000000000000000", + "cap_below_phase_cell_power": "2137648249613804358393133/1960000000000000000000000", + "complex_above_effective": "1/1400000000000", + "complex_below_one_over_32": "7878321373/280000000000", + "complex_endpoint": "1/700000000000", + "epsilon_below_one": "1/1400000000000", + "epsilon_positive": "1399999999999/1400000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "5586924820601/1960000000000000000000000", + "gaussian_above_main": "695641606867/980000000000000000000000", + "global_coordinate_router_above_kappa": "1/350000000000", + "global_gamma_power_slack": "9/14000000000000", + "group_below_dimension": "1/700000000000", + "group_bit_router_above_kappa": "3493462410299/980000000000000000000000", + "group_gauge_power_slack": "177648249615834358393133/980000000000000000000000", + "group_key_fits_record": "1/700000000000", + "group_positive": "1399999999997/1400000000000", + "group_scans_above_kappa": "348910401717/350000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "691083765400418148631/500000000000000000000000", + "lambda_above_internal": "1/2800000000000", + "lambda_above_sigma": "3/2800000000000", + "lambda_above_tau": "1/2800000000000", + "lambda_prime_above_lambda": "1/2800000000000", + "lambda_prime_above_leaf": "559128321373/392000000000000000000000", + "leaf_saving_above_effective": "279128321373/392000000000000000000000", + "main_transform_above_kappa": "4195641606867/1960000000000000000000000", + "membership_arithmetic_fits_record": "1/1400000000000", + "microbox_face_corrections_above_kappa": "53897820803437/700000000000", + "microbox_halo_volume": "110600000000003/1400000000000", + "new_complex_uniform_saving_above_b": "1/1400000000000", + "new_semantic_guard_with_C1_one": "1/1400000000000", + "polynomial_products_above_kappa": "1395641606869/1400000000000", + "positive_layout_slack": "1/1400000000000", + "q_below_effective": "1/1400000000000", + "q_below_internal": "1/1400000000000", + "q_below_leaf": "559128321373/392000000000000000000000", + "q_positive": "4358393133/1400000000000", + "short_record_fallback": "279128321373/280000000000", + "source_axis_superpolynomial": "1/1400000000000", + "sparse_union_movement_above_kappa": "796250000005595641606867/1960000000000000000000000", + "stop_below_one": "1399999999999/1400000000000", + "stop_positive": "1/1400000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000000", + "union_tag_work_per_visit_fits_record": "3/1400000000000" + } + }, + "paid": { + "1": 41520, + "16": 416, + "2": 8172, + "24": 416, + "3": 8856, + "32": 416, + "4": 1674, + "40": 416, + "48": 416, + "5": 3132, + "56": 416, + "6": 108, + "64": 416, + "7": 270, + "72": 208 + }, + "paid_calls": 66852, + "previous_pr5718": "389127/125000000", + "productive_fields": 13390, + "query_shears": 15, + "rank_mass_surplus": 760, + "raw_ceiling": { + "derivative_upper": "-738596154004511222636095493817850924833979710424488126325902089/3138550867693340381917894711603833208051177722232017256448", + "interval": [ + "0", + "17/5000" + ] + }, + "raw_headroom": [ + "73/3125000000000", + "2337/100000000000000" + ], + "raw_root_interval": [ + "38914224667/12500000000000", + "311313797337/100000000000000" + ], + "relative_gain_percent": "4065/1037672", + "strictification": { + "alpha": { + "lower": "0.999999999981368230437503066447", + "upper": "0.999999999981368230437503066448" + }, + "cutoff": 16, + "delta": { + "lower": "0.944337257529929949513398128117", + "upper": "0.944337257529929949513398128118" + }, + "floor": 17, + "gamma": { + "lower": "0.975484709128690914856977434634", + "upper": "0.975484709128690914856977434635" + }, + "normalized_paid_upper": "1048576000976562501/1048576001073741824", + "power": 1024, + "reserve": "1/1000000000000", + "tail_block": 128, + "tail_decay": "125/128", + "tail_offset": "1/7", + "tested": "622627591/200000000000" + }, + "targets": { + "1": 432, + "145": 208, + "17": 416, + "2": 90, + "25": 416, + "33": 416, + "4": 1656, + "41": 416, + "49": 416, + "5": 126, + "57": 416, + "65": 416, + "7": 108, + "73": 208, + "8": 666, + "9": 6984 + }, + "whole_idle_jobs": 3120 + }, + "controls": { + "block_op_on_old_chart": "Scalar destination and coefficient", + "extra_target_credit": "Every productive helper has a native target", + "missing_block_move": "Scalar destination and coefficient", + "old_helper_start": "Scalar destination and coefficient", + "read_after_write": "Dependent operations keep their order", + "unpaid_query": "Complete field and call counts" + }, + "global_paid_delta": { + "1": 18, + "4": 18, + "5": -18 + }, + "helper_credit_delta": { + "1": -1, + "4": 1, + "5": 1, + "8": -1 + }, + "helper_finals": { + "405": [ + 477, + 1090 + ] + }, + "helper_starts": { + "741": [ + 477, + 1090 + ] + }, + "local": { + "endpoint_coefficients": 602176, + "helpers": { + "1": 24, + "2": 5, + "4": 92, + "5": 7, + "7": 6, + "8": 37, + "9": 388 + }, + "owned_fields": 9, + "owned_lifetimes": 11, + "paid": { + "1": 2220, + "2": 454, + "3": 492, + "4": 93, + "5": 174, + "6": 6, + "7": 15 + }, + "paid_rank_mass": 5987, + "peak_owned_fields": 2, + "public_inputs": 767, + "real_scalar_allowance": 224138 + }, + "local_paid_delta": { + "1": 1, + "4": 1, + "5": -1 + }, + "native": { + "distinct_maps": 2927, + "helper_normalizers": 1118, + "helpers": { + "1": 24, + "2": 5, + "4": 92, + "5": 7, + "7": 6, + "8": 37, + "9": 388 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "b566ac8ebfb9df3d4c8a7be449c749283ec70dedbdaad7f943c264c692da544a", + "wrong_phase_rejected": true + }, + "physical": { + "central_square_columns": 53248, + "full_calls": 18, + "main_targets": { + "145": 208, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "73": 208 + }, + "new_paid_jobs": 0, + "physical_contacts": 7488, + "ports": 104, + "route_payload_sha256": "7f4f0ca768ffbc4f93dcff575592c4c67411f46b4289e45b73f715a2ad47b142", + "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.", + "whole_idle_jobs": { + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416, + "64": 416, + "72": 208 + }, + "wrapper_sites": [ + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31 + ] + }, + "source": { + "pr5751": "8483f9a679d06c1e270141dbc686a7e76e7a7522" + }, + "status": "PASS_P104_R22_REFRAME_KAPPA_00311313795", + "transpose": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 602176, + "columns": 776 + } +} diff --git a/research/p104-split-block-composition/source/pr5756/WORD.json.gz b/research/p104-split-block-composition/source/pr5756/WORD.json.gz new file mode 100644 index 0000000000..156ff6d627 Binary files /dev/null and b/research/p104-split-block-composition/source/pr5756/WORD.json.gz differ diff --git a/research/p104-split-block-composition/source/seventeen-source.tar b/research/p104-split-block-composition/source/seventeen-source.tar new file mode 100644 index 0000000000..272c171a82 Binary files /dev/null and b/research/p104-split-block-composition/source/seventeen-source.tar differ diff --git a/research/p104-split-block-composition/sources.py b/research/p104-split-block-composition/sources.py new file mode 100644 index 0000000000..60208f5f11 --- /dev/null +++ b/research/p104-split-block-composition/sources.py @@ -0,0 +1,73 @@ +"""Authenticate the retained PR5751 export before any source import. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +Rebound to the public PR5751 checkpoint by Ali Romman with substantial OpenAI Codex assistance. +The archive checks follow the repository exporter and flyingviper's PR5613. +""" +from contextlib import contextmanager +from hashlib import sha1, sha256 +from pathlib import Path, PurePosixPath +import importlib.util +import io +import json +import sys +import tarfile +import tempfile + +HERE = Path(__file__).resolve().parent + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +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 + + +@contextmanager +def sources(): + pins = json.loads((HERE/'SOURCES.json').read_bytes()) + for row in pins['direct_sources']: + payload = (HERE/row['local_path']).read_bytes() + need(sha256(payload).hexdigest() == row['sha256'], 'Exact direct source SHA256') + need(sha1(b'blob '+str(len(payload)).encode()+b'\0'+payload).hexdigest() == row['git_blob'], + 'Exact direct source Git blob') + pin = pins['source_export'] + raw = (HERE/pin['local_path']).read_bytes() + need(sha256(raw).hexdigest() == pin['sha256'], 'Exact predecessor archive SHA256') + need(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == pin['git_blob'], + 'Exact retained archive Git blob') + with tempfile.TemporaryDirectory(prefix='p104-paid-main-source-') as directory: + root, names = Path(directory), set() + with tarfile.open(fileobj=io.BytesIO(raw), mode='r:') as bundle: + for member in bundle.getmembers(): + path = PurePosixPath(member.name) + need(member.isfile() and not path.is_absolute() and '..' not in path.parts + and '\\' not in member.name and ':' not in member.name, + 'Regular relative source path') + need(member.name not in names, 'Unique source path') + names.add(member.name) + target = root.joinpath(*path.parts) + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(bundle.extractfile(member).read()) + manifest = json.loads((root/'.research-export.json').read_bytes()) + need(manifest['commit'] == pin['commit'] and manifest['package'] == pin['package'] + and len(manifest['files']) == pin['files'], 'Exact source commit and inventory') + need(names == {'.research-export.json'} | {r['path'] for r in manifest['files']}, + 'No missing or additional source payload') + origins = {row['path']: row for row in pins['archived_files']} + for row in manifest['files']: + origin = origins[row['path']] + need(origin['pin'] == 'head:'+pin['commit']+':'+row['path'] + and origin['sha256'] == row['sha256'], + 'Export payload has an exact source pin') + payload = (root/row['path']).read_bytes() + need(len(payload) == row['size'] and sha256(payload).hexdigest() == row['sha256'], + 'Authenticated payload: '+row['path']) + yield root/pin['package'], root diff --git a/research/p104-split-block-composition/verify.py b/research/p104-split-block-composition/verify.py new file mode 100644 index 0000000000..8fa19c489d --- /dev/null +++ b/research/p104-split-block-composition/verify.py @@ -0,0 +1,183 @@ +"""Verify the composed word, the complete caller, and the fixed-block optimum. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The source exports retain the construction, verifier, and compiler notices. +""" +import argparse +from collections import Counter +from contextlib import ExitStack +from copy import deepcopy +from fractions import Fraction as Q +import gzip +import json +from pathlib import Path +import sys +import tempfile + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +from sources import sources, load, need +import construct +import checks + + +def reject(action): + try: + action() + except (ValueError, AssertionError) as error: + return str(error) + raise ValueError('Invalid candidate accepted') + + +def derived(parent, filename, editfile): + text = (parent/filename).read_text() + for before, after in json.loads((HERE/editfile).read_bytes()): + need(text.count(before) == 1, 'One declared source edit') + text = text.replace(before, after) + need(text == (HERE/filename).read_text(), 'Only declared source edits: '+filename) + + +def optimality(local, native, caller, physical, price, P, root): + T, paid, _ = P.assemble(local, native, caller, physical) + E = load(root/'research/higher-moment-strictification/verify.py', 'block_interval_engine') + def parts(d): + p = Counter({d-3: 8}) + p[9-d] += 7 + p[8-d] += 1 + p.pop(0, None) + return Counter([d,9-d]), p + t4, p4 = parts(4) + result = {} + for d in range(4,9): + td, pd = parts(d) + td.subtract(t4) + pd.subtract(p4) + t, p = T.copy(), paid.copy() + for r, n in td.items(): + t[r] += 18*n + for r, n in pd.items(): + p[r] += 18*n + need(min(t.values()) >= 0 and min(p.values()) >= 0, 'Nonnegative complete interval bill') + def margin(k): + a, b = E.moment(t,1-k), E.moment(p,1-k) + return a[0]-b[1], a[1]-b[0] + lo, hi, grid = 0, 10**12, 10**14 + while hi-lo > 1: + m = (lo+hi)//2 + if margin(Q(m,grid))[0] > 0: + lo = m + else: + hi = m + low, high = Q(lo,grid), Q(hi,grid) + need(margin(low)[0] > 0 and margin(high)[1] < 0, 'Exact rank-specific crossing') + signed = Counter(t) + signed.subtract(p) + derivative = Q(0) + for r, n in signed.items(): + logs = E.log_bounds(r) + a = E.mul(E.power(r,1-Q('.0034')),logs)[0] + b = r*logs[1] + derivative -= n*(a if n >= 0 else b) + need(derivative < 0, 'Unique crossing throughout the declared kappa interval') + if d != 4: + need(high < P.KAPPA, 'Certified rank-four saving exceeds every other rank ceiling') + result[d] = {'raw_root_interval': [low,high], 'derivative_upper': derivative, + 'local_changed_paid': parts(d)[1], 'local_changed_targets': parts(d)[0], + 'complete_paid_calls': sum(p.values())} + need(result[4]['raw_root_interval'] == list(map(Q,price['raw_root_interval'])), 'Same optimal complete bill') + return result + + +def local_envelope_edits(parent): + rows = json.loads((parent/'LOCAL-EDITS.json').read_bytes()) + need(rows == [["735 <= public <= 750", "public == 767"]], 'Exact inherited finite envelope edits') + return rows + + +def run(): + with ExitStack() as contexts: + parent, _ = contexts.enter_context(sources()) + derived(parent,'pricing.py','PRICING-EDITS.json') + cursor = parent + predecessor = None + split = None + for depth in range(5): + cursor, root = contexts.enter_context(load(cursor/'sources.py','block_sources_'+str(depth)).sources()) + if depth == 0: + split = cursor + if depth == 1: + predecessor = cursor + derived(parent,'checks.py','CHECKS-EDITS.json') + local_text = (cursor/'local.py').read_text() + for before, after in local_envelope_edits(parent): + need(local_text.count(before) == 1, 'One declared source envelope edit') + local_text = local_text.replace(before,after) + need(local_text == (parent/'local.py').read_text(), 'Only the published exact public-count change') + L = load(parent/'local.py','local') + L.ROOT = root + source = L.read(parent/'WORD.json.gz') + word, hunks = construct.construct(source) + old_reframe, _ = construct.construct(L.read(predecessor/'WORD.json.gz')) + retained = L.read(HERE/'source/pr5739/WORD.json.gz') + old_reframe['schema'] = retained['schema'] + need(old_reframe == retained, 'Exact published R22 construction on its own source') + interval = construct.interval(word) + independent = checks.audit(word) + transpose = checks.transpose_audit(word) + controls = checks.negative_controls(word) + local = L.replay(word) + columns = L.reverse_columns(word) + need(local['public_inputs'] == 767 and local['owned_fields'] == 9 + and local['owned_lifetimes'] == 11 and local['peak_owned_fields'] == 2, + 'Exact public and owned inventory') + print('PASS all 776 scalar inputs, both transpose checks, 67 legal block subspaces',flush=True) + native = L.native(word) + C = load(root/'research/p104-productive-controller/caller.py','block_caller') + caller = C.construct() + need(caller == L.read(root/'research/p104-productive-controller/CONTROLLER.json'),'Exact physical caller') + physical = C.physical(caller,word) + print('PASS native maps, absolute phases and full physical caller',flush=True) + P = load(HERE/'pricing.py','block_price') + price = P.run(local,native,caller,physical) + ranking = optimality(local,native,caller,physical,price,P,root) + controls.update(C.controls(caller)) + bad = deepcopy(word); bad['initial'][741] = 477 + controls['old_helper_start'] = reject(lambda: checks.audit(bad)) + bad = deepcopy(word); next(e for e in bad['program'] if e == ['ADD',42,41,'1',1090])[-1] = 477 + controls['old_scalar_chart'] = reject(lambda: checks.audit(bad)) + bad = deepcopy(word); bad['frames'][1090].pop() + controls['illegal_rank_three_frame'] = reject(lambda: checks.audit(bad)) + bad = deepcopy(local); bad['paid'][1] -= 1 + controls['unpaid_query'] = reject(lambda: P.assemble(bad,native,caller,physical)) + bad = deepcopy(local); bad['helpers'][9] += 1 + controls['extra_target'] = reject(lambda: P.assemble(bad,native,caller,physical)) + print('PASS full invoice, two moment engines, compiler, outer predicates and fixed-block optimum',flush=True) + return P.encode({'status':'PASS_P104_SPLIT_BLOCK_KAPPA_00311313795', + 'local':local,'independent_literal_audit':independent,'independent_transpose':transpose, + 'separate_columns':columns,'native':native,'physical_caller':physical, + 'complete_cost':price,'fixed_block_ranks':ranking,'negative_controls':controls}), interval, hunks, word + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write',action='store_true') + args = parser.parse_args() + with tempfile.TemporaryDirectory(prefix='p104-split-block-cache-') as cache: + sys.pycache_prefix = cache + result, interval, hunks, word = run() + values = {'RESULT.json':result,'INTERVAL.json':interval,'HUNKS.json':hunks,'WORD.json.gz':word} + for name, value in values.items(): + value = json.loads(json.dumps(value)) + path = HERE/name + if args.write: + raw = (json.dumps(value,sort_keys=True,indent=2)+'\n').encode() + path.write_bytes(gzip.compress(raw,mtime=0) if name.endswith('.gz') else raw) + else: + raw = path.read_bytes() + need(json.loads(gzip.decompress(raw) if name.endswith('.gz') else raw) == value,'Exact retained output: '+name) + print(result['status']) + + +if __name__ == '__main__': + main()