From f122d255c4cdb0714c079d8e91b76bd7a34da23e Mon Sep 17 00:00:00 2001 From: Figo Lam Date: Fri, 16 Oct 2026 09:09:37 +0000 Subject: [PATCH] Prove conditional native terminal source-response factorization --- .../INDEPENDENT.json | 1468 ++++++ .../centre-native-terminal-factor/NATIVE.json | 53 + .../centre-native-terminal-factor/README.md | 253 + .../centre-native-terminal-factor/RESULT.json | 4572 +++++++++++++++++ .../SOURCES.json | 104 + .../centre-native-terminal-factor/TASK.json | 96 + .../VALIDATION.md | 168 + .../centre-native-terminal-factor/VERIFY.json | 53 + .../independent_terminal.py | 393 ++ .../native_boundary.py | 190 + .../centre-native-terminal-factor/source.py | 44 + .../centre-native-terminal-factor/verify.py | 175 + 12 files changed, 7569 insertions(+) create mode 100644 research/centre-native-terminal-factor/INDEPENDENT.json create mode 100644 research/centre-native-terminal-factor/NATIVE.json create mode 100644 research/centre-native-terminal-factor/README.md create mode 100644 research/centre-native-terminal-factor/RESULT.json create mode 100644 research/centre-native-terminal-factor/SOURCES.json create mode 100644 research/centre-native-terminal-factor/TASK.json create mode 100644 research/centre-native-terminal-factor/VALIDATION.md create mode 100644 research/centre-native-terminal-factor/VERIFY.json create mode 100644 research/centre-native-terminal-factor/independent_terminal.py create mode 100644 research/centre-native-terminal-factor/native_boundary.py create mode 100644 research/centre-native-terminal-factor/source.py create mode 100644 research/centre-native-terminal-factor/verify.py diff --git a/research/centre-native-terminal-factor/INDEPENDENT.json b/research/centre-native-terminal-factor/INDEPENDENT.json new file mode 100644 index 0000000000..20057a9205 --- /dev/null +++ b/research/centre-native-terminal-factor/INDEPENDENT.json @@ -0,0 +1,1468 @@ +{ + "archive_sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6", + "call8_live_helpers": [ + [ + 311, + 348 + ], + [ + 327, + 347 + ], + [ + 472, + 346 + ], + [ + 473, + 345 + ], + [ + 474, + 344 + ], + [ + 475, + 343 + ], + [ + 476, + 342 + ], + [ + 477, + 341 + ], + [ + 486, + 340 + ], + [ + 487, + 339 + ], + [ + 488, + 338 + ], + [ + 489, + 337 + ], + [ + 496, + 336 + ], + [ + 654, + 447 + ], + [ + 655, + 446 + ] + ], + "centre_rows": [ + { + "0": "1", + "10": "1", + "100": "1", + "101": "1", + "102": "1", + "103": "1", + "107": "1", + "108": "1", + "109": "1", + "11": "1", + "12": "1", + "17": "1", + "18": "1", + "19": "1", + "2": "1", + "22": "1", + "225": "1", + "226": "-1", + "227": "2", + "229": "1", + "23": "1", + "230": "1", + "233": "1", + "234": "-1", + "235": "2", + "237": "1", + "238": "1", + "24": "1", + "240": "1", + "241": "1", + "242": "1", + "243": "2", + "245": "1", + "246": "1", + "249": "1", + "25": "1", + "250": "-1", + "251": "2", + "253": "1", + "254": "1", + "256": "1", + "257": "1", + "258": "1", + "259": "2", + "261": "1", + "262": "1", + "265": "1", + "266": "-1", + "267": "2", + "269": "1", + "27": "1", + "270": "1", + "272": "1", + "276": "1", + "280": "-1", + "283": "2", + "286": "1", + "287": "-2", + "288": "1", + "292": "1", + "296": "-1", + "299": "2", + "302": "1", + "303": "-2", + "304": "1", + "308": "1", + "31": "1", + "312": "-1", + "315": "2", + "318": "1", + "319": "-2", + "32": "1", + "320": "1", + "324": "1", + "33": "1", + "331": "2", + "334": "1", + "335": "-1", + "34": "1", + "35": "1", + "38": "1", + "39": "1", + "40": "1", + "45": "1", + "48": "1", + "49": "1", + "50": "1", + "54": "1", + "55": "1", + "56": "1", + "57": "1", + "61": "1", + "62": "1", + "63": "1", + "7": "1", + "70": "1", + "71": "1", + "72": "1", + "76": "1", + "77": "1", + "79": "1", + "81": "1", + "85": "1", + "87": "1", + "89": "1", + "9": "1", + "90": "1", + "91": "1", + "92": "1", + "94": "1", + "98": "1" + }, + { + "0": "1", + "1": "1", + "10": "-1", + "11": "-1", + "2": "1", + "224": "2", + "225": "-1", + "226": "1", + "229": "1", + "230": "1", + "233": "-1", + "234": "-1", + "237": "-1", + "238": "1", + "239": "-2", + "240": "1", + "241": "-1", + "242": "1", + "245": "1", + "246": "1", + "249": "-1", + "25": "1", + "250": "-1", + "253": "-1", + "254": "1", + "255": "-2", + "256": "1", + "257": "-1", + "258": "1", + "26": "1", + "261": "1", + "262": "1", + "265": "-1", + "266": "-1", + "269": "-1", + "27": "1", + "270": "1", + "271": "-2", + "28": "1", + "29": "1", + "3": "1", + "30": "1", + "336": "1", + "340": "1", + "347": "2", + "350": "1", + "351": "-1", + "352": "1", + "356": "1", + "363": "2", + "366": "1", + "367": "-1", + "368": "1", + "372": "1", + "379": "2", + "382": "1", + "383": "-1", + "384": "1", + "388": "1", + "395": "2", + "398": "1", + "399": "-1", + "4": "1", + "5": "1", + "57": "-1", + "58": "1", + "59": "1", + "6": "1", + "60": "1", + "61": "-1", + "62": "-1", + "63": "-1", + "64": "1", + "65": "1", + "66": "1", + "67": "1", + "68": "1", + "69": "1", + "7": "-1", + "70": "1", + "71": "1", + "72": "1", + "73": "1", + "74": "1", + "75": "1", + "76": "1", + "79": "-1", + "8": "1", + "80": "1", + "81": "-1", + "82": "1", + "83": "1", + "84": "1", + "86": "1", + "87": "1", + "88": "1", + "89": "1", + "9": "-1", + "90": "1", + "91": "1", + "92": "-1", + "93": "1", + "94": "-1", + "95": "1", + "96": "1", + "97": "1" + }, + { + "0": "1", + "1": "1", + "100": "1", + "101": "1", + "102": "1", + "103": "-1", + "104": "1", + "105": "1", + "106": "1", + "12": "1", + "13": "1", + "14": "1", + "15": "1", + "16": "1", + "17": "-1", + "18": "-1", + "19": "-1", + "224": "2", + "225": "-1", + "226": "-1", + "227": "2", + "229": "-1", + "230": "-1", + "233": "1", + "234": "1", + "237": "-1", + "238": "-1", + "27": "-1", + "272": "1", + "276": "1", + "28": "-1", + "280": "-1", + "283": "-2", + "286": "1", + "287": "-2", + "288": "1", + "29": "-1", + "292": "1", + "296": "-1", + "299": "-2", + "30": "-1", + "302": "1", + "303": "-2", + "31": "1", + "336": "1", + "340": "1", + "347": "-2", + "350": "1", + "351": "-1", + "352": "1", + "356": "1", + "363": "-2", + "366": "1", + "367": "-1", + "38": "-1", + "39": "-1", + "40": "-1", + "400": "1", + "401": "1", + "402": "-1", + "403": "2", + "405": "1", + "406": "1", + "409": "1", + "41": "1", + "410": "-1", + "411": "2", + "413": "1", + "414": "1", + "416": "1", + "417": "1", + "418": "-1", + "419": "2", + "42": "1", + "421": "1", + "422": "1", + "425": "1", + "426": "-1", + "427": "2", + "429": "1", + "43": "1", + "430": "1", + "44": "1", + "51": "1", + "52": "1", + "53": "1", + "54": "1", + "55": "1", + "56": "1", + "57": "1", + "58": "-1", + "59": "-1", + "6": "1", + "60": "-1", + "7": "-1", + "73": "1", + "74": "1", + "75": "1", + "76": "1", + "77": "-1", + "78": "1", + "81": "-1", + "82": "1", + "83": "1", + "84": "1", + "86": "-1", + "87": "-1", + "92": "1", + "93": "-1", + "99": "1" + }, + { + "0": "1", + "104": "-1", + "105": "-1", + "106": "-1", + "107": "-1", + "108": "-1", + "109": "-1", + "13": "1", + "14": "1", + "15": "1", + "16": "-1", + "22": "-1", + "225": "1", + "226": "-1", + "229": "1", + "23": "-1", + "230": "-1", + "233": "1", + "234": "1", + "235": "-2", + "237": "1", + "238": "1", + "239": "-2", + "24": "-1", + "26": "-1", + "27": "-1", + "3": "1", + "304": "1", + "308": "1", + "312": "-1", + "315": "-2", + "318": "1", + "319": "-2", + "32": "1", + "320": "1", + "324": "1", + "33": "1", + "331": "-2", + "334": "1", + "335": "-1", + "34": "1", + "35": "-1", + "368": "1", + "372": "1", + "379": "-2", + "382": "1", + "383": "-1", + "384": "1", + "388": "1", + "395": "-2", + "398": "1", + "399": "-1", + "4": "1", + "400": "1", + "401": "-1", + "402": "1", + "405": "1", + "406": "1", + "409": "-1", + "41": "-1", + "410": "-1", + "413": "-1", + "414": "1", + "415": "-2", + "416": "1", + "417": "-1", + "418": "1", + "42": "-1", + "421": "1", + "422": "1", + "425": "-1", + "426": "-1", + "429": "-1", + "43": "-1", + "430": "1", + "431": "-2", + "44": "-1", + "45": "-1", + "48": "1", + "49": "1", + "5": "1", + "50": "1", + "51": "1", + "52": "1", + "53": "1", + "57": "-1", + "64": "-1", + "65": "-1", + "66": "-1", + "67": "1", + "68": "1", + "69": "1", + "7": "1", + "76": "-1", + "78": "1", + "8": "-1", + "80": "1", + "81": "-1", + "85": "1", + "87": "1", + "88": "1", + "92": "1", + "95": "-1", + "96": "-1", + "97": "-1", + "98": "1", + "99": "1" + }, + { + "1": "-1", + "10": "-1", + "100": "1", + "103": "1", + "105": "-1", + "106": "-1", + "107": "1", + "11": "-1", + "110": "1", + "111": "1", + "12": "1", + "14": "1", + "15": "1", + "17": "1", + "20": "1", + "21": "1", + "24": "-1", + "240": "1", + "241": "-1", + "242": "1", + "243": "2", + "245": "-1", + "246": "-1", + "249": "1", + "250": "1", + "253": "-1", + "254": "-1", + "26": "-1", + "272": "1", + "276": "-1", + "28": "-1", + "280": "-1", + "286": "-1", + "287": "-2", + "3": "-1", + "304": "1", + "308": "-1", + "31": "-1", + "312": "-1", + "318": "-1", + "319": "-2", + "32": "-1", + "336": "1", + "340": "-1", + "35": "-1", + "350": "-1", + "351": "-1", + "36": "1", + "368": "1", + "37": "1", + "372": "-1", + "38": "-1", + "382": "-1", + "383": "-1", + "400": "1", + "401": "-1", + "402": "-1", + "403": "2", + "405": "-1", + "406": "-1", + "409": "1", + "41": "1", + "410": "1", + "413": "-1", + "414": "-1", + "42": "1", + "433": "1", + "434": "-1", + "435": "2", + "437": "1", + "438": "1", + "441": "1", + "442": "-1", + "443": "2", + "445": "1", + "446": "1", + "45": "1", + "46": "1", + "47": "1", + "48": "1", + "52": "-1", + "53": "-1", + "56": "-1", + "58": "1", + "6": "1", + "62": "1", + "63": "1", + "66": "-1", + "67": "1", + "70": "1", + "71": "1", + "75": "-1", + "77": "-1", + "8": "1", + "80": "1", + "82": "1", + "85": "-1", + "86": "-1", + "88": "-1", + "90": "-1", + "91": "-1", + "93": "1", + "95": "1", + "98": "1" + }, + { + "10": "1", + "101": "1", + "102": "-1", + "105": "1", + "106": "-1", + "108": "1", + "109": "-1", + "11": "-1", + "110": "-1", + "111": "1", + "14": "-1", + "15": "1", + "18": "1", + "19": "-1", + "20": "-1", + "21": "1", + "22": "1", + "23": "-1", + "240": "1", + "241": "1", + "242": "-1", + "245": "1", + "246": "-1", + "249": "1", + "250": "1", + "251": "-2", + "253": "1", + "254": "1", + "255": "-2", + "288": "1", + "29": "-1", + "292": "-1", + "296": "-1", + "30": "1", + "302": "-1", + "303": "-2", + "320": "1", + "324": "-1", + "33": "-1", + "334": "-1", + "335": "-1", + "34": "1", + "352": "1", + "356": "-1", + "36": "1", + "366": "-1", + "367": "-1", + "37": "-1", + "384": "1", + "388": "-1", + "39": "-1", + "398": "-1", + "399": "-1", + "4": "-1", + "40": "1", + "400": "1", + "401": "1", + "402": "-1", + "405": "1", + "406": "-1", + "409": "1", + "41": "1", + "410": "1", + "411": "-2", + "413": "1", + "414": "1", + "415": "-2", + "42": "-1", + "432": "2", + "433": "-1", + "434": "1", + "437": "1", + "438": "1", + "441": "-1", + "442": "-1", + "445": "-1", + "446": "1", + "447": "-2", + "46": "-1", + "47": "1", + "49": "1", + "5": "1", + "50": "-1", + "52": "1", + "53": "-1", + "54": "1", + "55": "-1", + "59": "1", + "60": "-1", + "62": "-1", + "63": "1", + "64": "1", + "65": "-1", + "68": "1", + "69": "-1", + "70": "1", + "71": "-1", + "73": "1", + "74": "-1", + "83": "1", + "84": "-1", + "90": "1", + "91": "-1", + "96": "1", + "97": "-1" + }, + { + "100": "-1", + "103": "1", + "104": "-1", + "108": "1", + "109": "1", + "110": "-1", + "111": "-1", + "12": "1", + "13": "1", + "16": "1", + "17": "-1", + "2": "1", + "20": "1", + "21": "1", + "22": "-1", + "23": "-1", + "25": "-1", + "256": "1", + "257": "-1", + "258": "1", + "259": "2", + "26": "-1", + "261": "-1", + "262": "-1", + "265": "1", + "266": "1", + "269": "-1", + "270": "-1", + "272": "-1", + "276": "1", + "280": "1", + "286": "1", + "287": "-2", + "29": "-1", + "3": "1", + "30": "-1", + "31": "-1", + "320": "-1", + "324": "1", + "33": "-1", + "334": "1", + "335": "-3", + "34": "-1", + "352": "-1", + "356": "1", + "36": "1", + "366": "1", + "367": "-3", + "368": "-1", + "37": "1", + "372": "1", + "38": "1", + "382": "1", + "383": "-3", + "416": "1", + "417": "-1", + "418": "-1", + "419": "2", + "421": "-1", + "422": "-1", + "425": "1", + "426": "1", + "429": "-1", + "43": "1", + "430": "-1", + "432": "2", + "433": "-1", + "434": "-1", + "435": "2", + "437": "-1", + "438": "-1", + "44": "-1", + "441": "1", + "442": "1", + "445": "-1", + "446": "-1", + "46": "-1", + "47": "-1", + "49": "1", + "50": "1", + "51": "-1", + "56": "1", + "59": "1", + "60": "1", + "61": "1", + "66": "1", + "67": "-1", + "72": "1", + "73": "-1", + "74": "-1", + "77": "-1", + "78": "1", + "79": "-1", + "8": "1", + "80": "1", + "83": "1", + "84": "1", + "88": "-1", + "89": "-1", + "9": "-1", + "94": "1", + "95": "-1", + "99": "-1" + }, + { + "1": "-1", + "101": "1", + "102": "1", + "104": "-1", + "107": "-1", + "110": "-1", + "111": "-1", + "13": "1", + "16": "-1", + "18": "1", + "19": "1", + "2": "-1", + "20": "-1", + "21": "-1", + "24": "1", + "25": "1", + "256": "1", + "257": "1", + "258": "-1", + "261": "1", + "262": "-1", + "265": "1", + "266": "1", + "267": "-2", + "269": "1", + "270": "1", + "271": "-2", + "28": "1", + "288": "-1", + "292": "1", + "296": "1", + "302": "1", + "303": "-2", + "304": "-1", + "308": "1", + "312": "1", + "318": "1", + "319": "-2", + "32": "1", + "336": "-1", + "340": "1", + "35": "-1", + "350": "1", + "351": "-3", + "36": "1", + "37": "1", + "384": "-1", + "388": "1", + "39": "-1", + "398": "1", + "399": "-3", + "4": "-1", + "40": "-1", + "416": "1", + "417": "1", + "418": "-1", + "421": "1", + "422": "-1", + "425": "1", + "426": "1", + "427": "-2", + "429": "1", + "43": "1", + "430": "1", + "431": "-2", + "433": "1", + "434": "-1", + "437": "1", + "438": "-1", + "44": "1", + "441": "1", + "442": "1", + "443": "-2", + "445": "1", + "446": "1", + "447": "-2", + "45": "1", + "46": "1", + "47": "1", + "48": "-1", + "5": "-1", + "51": "-1", + "54": "-1", + "55": "-1", + "58": "-1", + "6": "1", + "61": "1", + "64": "-1", + "65": "-1", + "68": "1", + "69": "1", + "72": "1", + "75": "1", + "78": "-1", + "79": "1", + "82": "-1", + "85": "-1", + "86": "-1", + "89": "-1", + "9": "-1", + "93": "1", + "94": "-1", + "96": "1", + "97": "1", + "98": "1", + "99": "1" + } + ], + "centre_rows_sha256": "78a8599e7dac0229f8912c070e5e8db0127d5949e3f85fed0acc62762e591483", + "common_frame_scalar_events": { + "backward": 19693, + "forward": 19693 + }, + "controls": [ + "nonconstant_cancellation", + "root_square", + "wrong_phase_detected", + "unequal_side_translation_detected", + "omitted_B1_detected", + "reversed_B1_sign_detected", + "same_frame_helper_contamination_detected", + "pre_wrapper_contamination_rejected" + ], + "f2_helper_zero_columns": 99, + "f2_live_helpers": [ + [ + 523, + 445 + ], + [ + 524, + 444 + ], + [ + 525, + 443 + ], + [ + 526, + 442 + ], + [ + 527, + 441 + ], + [ + 528, + 440 + ], + [ + 529, + 439 + ], + [ + 534, + 438 + ], + [ + 535, + 437 + ], + [ + 536, + 436 + ], + [ + 537, + 435 + ], + [ + 538, + 434 + ], + [ + 539, + 433 + ], + [ + 540, + 432 + ], + [ + 541, + 431 + ], + [ + 544, + 430 + ], + [ + 545, + 429 + ], + [ + 550, + 428 + ], + [ + 551, + 427 + ], + [ + 552, + 426 + ], + [ + 553, + 425 + ], + [ + 559, + 424 + ], + [ + 561, + 423 + ], + [ + 562, + 422 + ], + [ + 563, + 421 + ], + [ + 564, + 420 + ], + [ + 565, + 419 + ], + [ + 569, + 418 + ], + [ + 571, + 417 + ], + [ + 572, + 416 + ], + [ + 573, + 415 + ], + [ + 574, + 414 + ], + [ + 575, + 413 + ], + [ + 576, + 412 + ], + [ + 577, + 411 + ], + [ + 578, + 410 + ], + [ + 579, + 409 + ], + [ + 580, + 408 + ], + [ + 581, + 407 + ], + [ + 582, + 406 + ], + [ + 583, + 405 + ], + [ + 592, + 404 + ], + [ + 593, + 403 + ], + [ + 594, + 402 + ], + [ + 596, + 401 + ], + [ + 600, + 400 + ], + [ + 601, + 399 + ], + [ + 602, + 398 + ], + [ + 604, + 397 + ], + [ + 608, + 396 + ], + [ + 609, + 395 + ], + [ + 610, + 394 + ], + [ + 612, + 393 + ], + [ + 616, + 392 + ], + [ + 617, + 391 + ], + [ + 618, + 390 + ], + [ + 620, + 389 + ], + [ + 624, + 388 + ], + [ + 625, + 387 + ], + [ + 626, + 386 + ], + [ + 628, + 385 + ], + [ + 632, + 384 + ], + [ + 633, + 383 + ], + [ + 634, + 382 + ], + [ + 636, + 381 + ], + [ + 640, + 380 + ], + [ + 641, + 379 + ], + [ + 642, + 378 + ], + [ + 644, + 377 + ], + [ + 648, + 376 + ], + [ + 649, + 375 + ], + [ + 650, + 374 + ], + [ + 652, + 373 + ], + [ + 654, + 447 + ], + [ + 655, + 446 + ], + [ + 656, + 372 + ], + [ + 657, + 371 + ], + [ + 658, + 370 + ], + [ + 660, + 369 + ], + [ + 664, + 368 + ], + [ + 665, + 367 + ], + [ + 666, + 366 + ], + [ + 668, + 365 + ], + [ + 672, + 364 + ], + [ + 673, + 363 + ], + [ + 674, + 362 + ], + [ + 676, + 361 + ], + [ + 680, + 360 + ], + [ + 681, + 359 + ], + [ + 682, + 358 + ], + [ + 684, + 357 + ], + [ + 688, + 356 + ], + [ + 689, + 355 + ], + [ + 690, + 354 + ], + [ + 692, + 353 + ], + [ + 696, + 352 + ], + [ + 697, + 351 + ], + [ + 698, + 350 + ], + [ + 700, + 349 + ] + ], + "f2_target_zero_columns": 112, + "first_stage_q_routes": 112, + "helper_contamination": { + "destination": 334, + "event_index": 8107, + "nonzero_coefficients": { + "0": "1", + "3": "1", + "5": "-1", + "6": "1" + }, + "placement": "immediately after phase A marker, after all entry/residual adapters", + "source": 572 + }, + "member_sha256": { + "global": "2acf02b418078e37090495c601fe550448751d4f35912757b13a1f778efc7760", + "phases": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "programs": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a", + "word": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + "reverse_adjoint_endpoint_rows": { + "backward": 704, + "forward": 704 + }, + "schedule_events": 19, + "scope": "Independent scalar adjoints, supports and primitive controls; universal native factorization uses the written common-frame/endpoint proof. No full native rank, dirty-offset implementation, child saving, or supplier claim.", + "source_support_trace": [ + { + "kind": "local_cover_sweep", + "live_families": 224, + "time": 0 + }, + { + "kind": "local_cover_sweep", + "live_families": 224, + "time": 1 + }, + { + "kind": "local_cover_sweep", + "live_families": 224, + "time": 2 + }, + { + "kind": "local_cover_sweep", + "live_families": 224, + "time": 3 + }, + { + "kind": "local_cover_sweep", + "live_families": 112, + "time": 4 + }, + { + "kind": "idle_cover_sweep", + "live_families": 112, + "time": 4 + }, + { + "kind": "bridge", + "live_families": 224, + "time": 4 + }, + { + "kind": "local_cover_sweep", + "live_families": 224, + "time": 5 + }, + { + "kind": "idle_cover_sweep", + "live_families": 224, + "time": 5 + }, + { + "kind": "bridge", + "live_families": 224, + "time": 5 + }, + { + "kind": "local_cover_sweep", + "live_families": 224, + "time": 6 + }, + { + "kind": "local_cover_sweep", + "live_families": 224, + "time": 7 + }, + { + "kind": "local_cover_sweep", + "live_families": 224, + "time": 8 + }, + { + "kind": "idle_cover_sweep", + "live_families": 224, + "time": 8 + }, + { + "kind": "bridge", + "live_families": 224, + "time": 8 + }, + { + "kind": "local_cover_sweep", + "live_families": 224, + "time": 9 + }, + { + "kind": "idle_cover_sweep", + "live_families": 224, + "time": 9 + }, + { + "kind": "bridge", + "live_families": 224, + "time": 9 + } + ], + "status": "PASS_INDEPENDENT_TERMINAL_ADJOINT_CONDITIONAL_NATIVE_LIFT" +} diff --git a/research/centre-native-terminal-factor/NATIVE.json b/research/centre-native-terminal-factor/NATIVE.json new file mode 100644 index 0000000000..a6eccbb233 --- /dev/null +++ b/research/centre-native-terminal-factor/NATIVE.json @@ -0,0 +1,53 @@ +{ + "archive_sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6", + "credited_clifford_kernel_sha256": "d5e42ddabd141b7bfbd70fe13908f3c3a06aeccebeab90623596bfb1988b97fb", + "direct_character_equality_checks_s0_s1": 2420992, + "exact_boundary_operator_identities": 4032, + "exact_local_endpoint_label_comparisons": 448, + "m": 73, + "members": { + "phases": [ + "candidate/strict/global/base/work/complex-nine-native/DATA-PHASES.json", + "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + ], + "programs": [ + "candidate/strict/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz", + "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a" + ], + "recipes": [ + "candidate/strict/global/base/providers/gauge44/CLIFFORD-RECIPES.json", + "d0768f2164d5f64a2fdbec422f1cfde4e400818792f1904ca541958377243731" + ], + "template": [ + "candidate/strict/global/hosted/GLOBAL-TEMPLATE.json.gz", + "2acf02b418078e37090495c601fe550448751d4f35912757b13a1f778efc7760" + ], + "word": [ + "candidate/strict/global/base/providers/gauge44/CANONICAL-WORD.json.gz", + "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + ] + }, + "phase_registry_sha256": "4c5469c073b10e1315be57fd17f905069a87385efc0a1b9a236f30f390d352d6", + "ports": 112, + "rejected_fault_instances": { + "omit_entry": 1792, + "omit_exit": 1792, + "unrouted_translation": 1792, + "wrong_Y_sign": 1008 + }, + "scalar_endpoint_binding": { + "backward": { + "endpoint": "(D-T,T,h)", + "events": 24767, + "ordinary_rows": 704 + }, + "forward": { + "endpoint": "(D,T+D,h)", + "events": 24767, + "ordinary_rows": 704 + } + }, + "scope": "Exact Fourier polynomial boundary phases plus scalar sign binding; inherits complete local native common-frame factorization and physical cover/view semantics.", + "stages": 9, + "status": "PASS_SELECTED_NATIVE_BOUNDARY_PHASES" +} diff --git a/research/centre-native-terminal-factor/README.md b/research/centre-native-terminal-factor/README.md new file mode 100644 index 0000000000..fa3eea91d0 --- /dev/null +++ b/research/centre-native-terminal-factor/README.md @@ -0,0 +1,253 @@ +# Native terminal source-response factorization + +The selected F0→F2 two-centre-ablation terminal residual factors through the +first eight **complete native centre fields**, conditional on the retained +native common-frame and cover/local-view contracts. This supplies the native +upper-factorization left open by [PR #2564](https://github.com/CrocSwap/integer-mult-bounds/pull/2564) +and its [scalar terminal quotient](../centre-terminal-source-quotient/README.md). +It does **not** transfer that package's sharp scalar rank or scalar decoder to +the native space. There is no new supplier, saved child, cost profile or κ. + +The scientific baseline is canonical main +`a1bfbc677fdcbc2a27a9b3bf6c78cac8fd6da9e2` (priority revision 5). +[SOURCES.json](SOURCES.json) pins every live proof input and selected archive +member. The selected dimensions are 112 ports, 480 helpers, 704 ordinary local +roles, 73 axes and 144 calls. Historical geometry notes describe 120 ports; +the executable evidence uses the selected 112-port data throughout. + +## Exact claim + +Fix an admitted common native payload depth, all cover owners and arbitrary +spectator indices. Let `F` be the selected chronological prefix ending after +the **complete** time-10 call. It contains 11 local sweeps, four idle sweeps and +four bridges. Let `A` be the same prefix with the eight private centre values +replaced by zero immediately before their centre transports in each of calls +0 and 10 (both forward). Keep every other preparation, scatter, continuation +and cleanup. This ablation is a diagnostic linear map, not a free legal child. + +Vary only the original 112 X0 source families `d`; hold all other ordinary +and private initial contents `h` fixed (the same `h` in both executions), +allowing arbitrary correlated dirt. +Define + +``` +E_D d = (F-A)(d,h) - (F-A)(0,h). +P_D d = first eight pre-transport centre-field responses to (d,0). +``` + +Any fixed invertible normalization of each first field gives the same claim. +Under the inherited contracts identified below, + +``` +ker(P_D) ⊆ ker(E_D), hence E_D = L_native P_D. +``` + +This is a statement about eight full fields indexed by cover owner, payload +and spectators, not eight scalars or eight paid recursive children. `L_native` +is an unpriced linear map on `image(P_D)`. Its definition does not provide +`(F-A)(0,h)` or subtract the dirt contribution in an actually saved transcript. +It asserts no sharp native rank or injectivity of the ablated continuation. + +## Proof + +### 1. Exact local endpoints and the inherited view contract + +The [whole-payload audit](../centre-native-observation-dimension/PROOF.md) +establishes native common-frame conjugation of the selected local word: +`diag(L_final) (S ⊗ I) diag(L_initial^-1)`. Every scalar operation is in a +common frame, with conversions and endpoint/residual adapters explicitly +included. The ordinary scalar endpoints are + +``` +S_forward(D,T,H) = (D,T+D,H), +S_backward(D,T,H) = (D-T,T,H). +``` + +In particular, complete helper endpoint blocks are diagonal: helpers neither +receive source response nor feed it into data or another helper. A helper's +physical endpoint frame may change; we never assume its payload is unchanged. +`verify.py` rechecks both 24,767-event words, all 704 ordinary columns, all +2,896 native conversion recipes, 224 endpoint adapters and 36 residual wrappers. +It uses the authenticated retained audit and credited exact Clifford kernel. + +The global step inherits the declared complete native local-view/cover +covariance and common exterior embedding from the pinned native-lift, +whole-payload and hosting proofs. The Lean `Stream.lean` conjugation and unit-row +identities explain the zero-block inference; Lean is not newly built here. +This package does not independently rebuild the physical stream compiler. +All statements below are conditional on that explicitly retained interface. + +### 2. Native F0/B1 cancellation at every physical owner + +Write `C_a` for the translation root with Fourier multiplier +`i^parity(a·u)` and `T_b` for translation with multiplier +`i^(2 parity(b·u))`. For port normal `q`, define + +``` +X_-1 = C_q, Y_-1 = I, +X_s = product(i=0..8+8s) C_ei, +Y_s = X_s C_q^-1, E_s = product(i=9..8+8s) C_ei. +``` + +The actual route `rho_s` exchanges the port's eight q-perpendicular chart +axes with exterior block s, fixes q, and is an orthogonal involution; `rho_0=I`. +Stored entry/exit translations are in the routed physical owner's coordinates. +If these are `a_X,a_Y,b_X,b_Y`, their local vectors are therefore `rho_s a` +and `rho_s b`. The exact selected identities are + +``` +T_(rho a_X) rho(X_(s-1)) = C_q E_s, +T_(rho a_Y) rho(Y_(s-1)) = E_s, +T_(rho b_X) (F9 E_s) = rho(X_s), +T_(rho b_Y) (F9 C_q^-1 E_s) = rho(Y_s). +``` + +Here `rho(B)` means conjugation by the coordinate permutation. The local +endpoint labels are exactly `(C_q,I)` on input and `(F9,F9 C_q^-1)` on output. +Thus the physical data matrices before the exterior factor is attached are + +``` +forward = [[F9 C_q^-1, 0], [F9 C_q^-2, F9 C_q^-1]], +backward = [[F9 C_q^-1, -F9], [0, F9 C_q^-1]]. +``` + +They are not bare scalar shears. `native_boundary.py` proves the displayed +translation identities by equality of every coefficient of their degree-at-most-2 +Fourier phase polynomials over Z/4, for all 112 ports and nine stages. Literal +parity evaluation on zero, singleton and pair characters separately checks the +polynomial implementation at stages 0/1. The check binds all four local labels +by exact 512-column operator comparisons, including global phase. + +For physical owner `g`, put `G_Xs(g)=P_g X_s P_g^-1` and similarly `G_Ys(g)`. +Encode arbitrary normalized fields `(u,v)` as +`(G_Xprev(g)u,G_Yprev(g)v)`. Both data sides of a port read the same physical +owner `g=d rho_s(p)`. The four identities and local common-frame theorem give + +``` +forward: (G_Xs(g)u, G_Ys(g)(v+u)), +backward: (G_Xs(g)(u-v), G_Ys(g)v). +``` + +Each route is bijective. This argument is per physical owner and does not +commute maps at different owners. All equalities tensor with the common +exterior factor and spectators, so they hold for arbitrary admitted payloads. +Initially a source-only difference has `(u,0)`, since `C_q` is invertible. +F0 leaves `(u,u)` in these normalized frames; B1 leaves `(0,u)`. Therefore +**every X0 source response vanishes after B1**, not merely constant payloads. + +### 3. The complete chronology makes the normal F2 centre response zero + +The source-bound 19-event prefix is recorded in [RESULT.json](RESULT.json). +After F0 the possible live source-response families are X0=`0..111` and +Y0=`112..223`. Calls 1–3 touch neither as data or helpers. After complete B1 +(time 4), only Y0 is live. The actual replica-zero bridge +`X0 += X1; Y1 -= Y0` adds possible response on Y1=`336..447`; its X inputs +are zero. Idle sweeps transform payloads within each family and preserve this +support upper bound. The other three bridges touch other replicas. + +Calls 5–9 have no live data inputs. Time 8 touches 15 live Y1 families as +helpers; its diagonal helper endpoint can change their native frames but +cannot spread response to another family. At F2 the live input roles are +all 112 Y0 targets and exactly 99 Y1 helpers. Each of the eight forward +pre-centre rows has coefficient **zero on every one of these 211 roles**. +The primary checks all 1,688 coefficients. The independent checker derives +the rows backwards through literal events, rather than propagating them forward. + +Under common-frame conjugation a role contributes a block of the form +`L_cut [a_(k,r) L_start(r)^-1 W_r input_r]`, with entry wrappers and local-view +maps absorbed in `W_r`. An exact scalar coefficient `a_(k,r)=0` kills the whole +native block, whatever that helper's current payload or frame. No equality of +nonzero scalar rows across distinct charts is inferred. Hence the original +F2 pre-transport source response is identically zero on all eight fields. + +### 4. Kernel inclusion concerns complete terminal outputs + +For a source difference `d` with `P_D d=0`, the first ablation changes no +centre response. The full and ablated source-response runs therefore agree +through all first-call continuations and intervening events. At F2 the full +run's centre response is zero by step 3, so the second ablation changes +nothing either. Every remaining continuation and cleanup agrees. Thus +`E_D d=0`. We compare complete chronological maps, not a sum of instantaneous +scatter increments. + +All operations are linear, so fixed arbitrary dirt cancels in the difference +used to define `E_D`. Kernel inclusion defines `L_native` on `image(P_D)` by +`L_native(P_D d)=E_D d`; it is well-defined. Finite-dimensional linear algebra +can extend it outside that image if desired. The first-cut scalar minor at +ports `[0,1,2,3,4,5,6,12]` has determinant 32 (recorded exactly); invertible +input/carrier frames give an abstract right inverse per owner. This is an +existence construction, with no implementation or cost claim. + +## Evidence and reproduction + +From the repository root, using Python 3.12 and its standard library: + +```sh +python3 scripts/research_package.py --package research/centre-native-terminal-factor --check-only +python3.12 scripts/research_package.py --package research/centre-native-terminal-factor +``` + +The three registered commands compare their entire deterministic typed JSON +receipts, fail on source drift, and use explicit `-I -O -B`. Proof checks use +exceptions rather than removable assertions. The primary compiles authenticated +predecessor source directly. [VALIDATION.md](VALIDATION.md) records actual runs, +controls, portable replay, review findings and unrun obligations. + +`independent_terminal.py` was written by a separate Codex agent without reading +the primary implementation. It imports no predecessor checker or Clifford +kernel: it independently derives 1,408 ordinary endpoint rows and eight +centre rows by reverse adjoints, verifies the literal chronology, routes and +common frames, and checks exact Gaussian-dyadic boundary primitives. It shares +the selected archive and written native-view premise. `native_boundary.py` +has a separately derived 73-axis phase evaluator but shares the credited +Clifford kernel for its local-label comparisons. This is independent AI +checking with declared shared assumptions, not independent human review or a +formal verification of the global compiler. + +Controls break B1 cancellation, introduce a legal same-frame live-helper ADD, +omit bridges, corrupt common frames or adapter phases, and omit/misroute native +boundary translations. Support controls demonstrate failure of the sufficient +zero-demand criterion, not full native terminal counterexamples for mutated +programs. Receipt and source-byte controls address reproduction separately. + +## Open next questions + +The selected two-call centre bill remains 16 H8 children (rank mass 128), plus the +original COPY/ADD/CLEAR and all other charges. Eight complete saved fields do +not imply eight children, a cheap residual consumer, restored dirty storage, +free catch-up or an improved precision envelope. PR #2895's retained-array +catch-up analysis is relevant navigation, not a premise invalidated here. +The family expansion gate permits retaining this scoped information lemma; +it does not authorize another unpriced construction search. + +The next useful question is an **actual paid decoder for the dirty terminal +residual**. First specify a legal consumer of the saved fields, its dirty +offset and restoration path, and cancel common work against the original +invoice before evaluating any saving. Observation, transport, return, +precision and storage remain payable. A sharp native quotient would be useful +only if a concrete consumer needs it. [TASK.json](TASK.json) records this +handoff and the bounded task refinement. + +## Credit and coordination + +Direct predecessor: ywz65, PR #2564, scalar terminal source quotient. This +work relies on the retained whole-payload observation audit; the selected +chronological census of Sagar Thakrar (PR #2199); commdata2338's native lift +(PR #2048); Aaron Wang/navinor's native quarter-query control (PR #2391); +ywz65's owner observation floor (PR #2461); and the selected word, native +recipes, hosting and geometry lineage credited in those packages. Sagar +Thakrar's exact Clifford code is reused unchanged and source-authenticated. +Adam Gall's earlier dirty-centre work (#1918), DreamingOfClouds' common-frame +proof, icekylinx's compiler work, and the selected construction/replay work of +Rohan Arun, Jeremy Kothe and Hao Yan provide context; their claims are not +reassigned to this package. Existing source notices and licenses are retained. + +The canonical [reservation](https://github.com/CrocSwap/integer-mult-bounds/discussions/1884#discussioncomment-18967805) was posted by DLamdata in Discussion #1884. +The lead's earlier API attempt was denied write access and created no post. +PR #2880 was read for continuity and preserved unchanged; its encoded-bank +audit is not a dependency of this contribution. Overlap searches cover PR +bodies and Discussion text, not all diffs, and cannot prove novelty. + +New package: DLamdata with substantial OpenAI Codex assistance, including the +lead and two bounded native agents. Apache-2.0. No external Claude or human +review is claimed. diff --git a/research/centre-native-terminal-factor/RESULT.json b/research/centre-native-terminal-factor/RESULT.json new file mode 100644 index 0000000000..a1756fc0ab --- /dev/null +++ b/research/centre-native-terminal-factor/RESULT.json @@ -0,0 +1,4572 @@ +{ + "causal_support": { + "bridges": 4, + "calls": 11, + "f2_live_helpers": 99, + "f2_live_roles": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 523, + 524, + 525, + 526, + 527, + 528, + 529, + 534, + 535, + 536, + 537, + 538, + 539, + 540, + 541, + 544, + 545, + 550, + 551, + 552, + 553, + 559, + 561, + 562, + 563, + 564, + 565, + 569, + 571, + 572, + 573, + 574, + 575, + 576, + 577, + 578, + 579, + 580, + 581, + 582, + 583, + 592, + 593, + 594, + 596, + 600, + 601, + 602, + 604, + 608, + 609, + 610, + 612, + 616, + 617, + 618, + 620, + 624, + 625, + 626, + 628, + 632, + 633, + 634, + 636, + 640, + 641, + 642, + 644, + 648, + 649, + 650, + 652, + 654, + 655, + 656, + 657, + 658, + 660, + 664, + 665, + 666, + 668, + 672, + 673, + 674, + 676, + 680, + 681, + 682, + 684, + 688, + 689, + 690, + 692, + 696, + 697, + 698, + 700 + ], + "f2_live_targets": 112, + "idle_sweeps": 4, + "live_helper_occurrences": [ + [ + 0, + 0 + ], + [ + 1, + 0 + ], + [ + 2, + 0 + ], + [ + 3, + 0 + ], + [ + 4, + 0 + ], + [ + 5, + 0 + ], + [ + 6, + 0 + ], + [ + 7, + 0 + ], + [ + 8, + 15 + ], + [ + 9, + 0 + ], + [ + 10, + 99 + ] + ], + "prefix_events": 19, + "support_history": [ + { + "kind": "local_cover_sweep", + "live_families": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223 + ], + "position": 0, + "time": 0 + }, + { + "kind": "local_cover_sweep", + "live_families": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223 + ], + "position": 1, + "time": 1 + }, + { + "kind": "local_cover_sweep", + "live_families": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223 + ], + "position": 2, + "time": 2 + }, + { + "kind": "local_cover_sweep", + "live_families": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223 + ], + "position": 3, + "time": 3 + }, + { + "kind": "local_cover_sweep", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223 + ], + "position": 4, + "time": 4 + }, + { + "kind": "idle_cover_sweep", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223 + ], + "position": 5, + "time": 4 + }, + { + "kind": "bridge", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447 + ], + "position": 6, + "time": 4 + }, + { + "kind": "local_cover_sweep", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447 + ], + "position": 7, + "time": 5 + }, + { + "kind": "idle_cover_sweep", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447 + ], + "position": 8, + "time": 5 + }, + { + "kind": "bridge", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447 + ], + "position": 9, + "time": 5 + }, + { + "kind": "local_cover_sweep", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447 + ], + "position": 10, + "time": 6 + }, + { + "kind": "local_cover_sweep", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447 + ], + "position": 11, + "time": 7 + }, + { + "kind": "local_cover_sweep", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447 + ], + "position": 12, + "time": 8 + }, + { + "kind": "idle_cover_sweep", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447 + ], + "position": 13, + "time": 8 + }, + { + "kind": "bridge", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447 + ], + "position": 14, + "time": 8 + }, + { + "kind": "local_cover_sweep", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447 + ], + "position": 15, + "time": 9 + }, + { + "kind": "idle_cover_sweep", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447 + ], + "position": 16, + "time": 9 + }, + { + "kind": "bridge", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447 + ], + "position": 17, + "time": 9 + }, + { + "kind": "local_cover_sweep", + "live_families": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447 + ], + "position": 18, + "time": 10 + } + ], + "zero_cut_coefficients_checked": 1688 + }, + "controls": { + "omit_B1_cancellation": "later centre has source-dependent input coefficient", + "omit_bridges": "complete causal support", + "read_a_live_helper": "later centre has source-dependent input coefficient", + "reverse_one_backward_ADD": "complete scalar endpoint", + "wrong_adapter_global_phase": "full exact operator differs", + "wrong_native_common_frame": "common frame" + }, + "first_cut_determinant": "32", + "first_cut_inverse": [ + [ + "3/4", + "0", + "0", + "1/4", + "-1/4", + "0", + "-1/2", + "1/4" + ], + [ + "-1/4", + "0", + "1/2", + "-1/4", + "-1/4", + "0", + "0", + "-1/4" + ], + [ + "1/2", + "1/2", + "-1/2", + "-1/2", + "0", + "0", + "0", + "0" + ], + [ + "-1/4", + "0", + "0", + "1/4", + "-1/4", + "0", + "1/2", + "1/4" + ], + [ + "-1/4", + "0", + "0", + "1/4", + "1/4", + "-1/2", + "0", + "-1/4" + ], + [ + "-1/4", + "0", + "0", + "1/4", + "1/4", + "1/2", + "0", + "-1/4" + ], + [ + "-1/4", + "1/2", + "0", + "-1/4", + "1/4", + "0", + "0", + "1/4" + ], + [ + "-1/4", + "-1/2", + "1/2", + "1/4", + "1/4", + "0", + "1/2", + "-1/4" + ] + ], + "first_cut_pivots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 12 + ], + "local_audits": { + "backward": { + "bill": { + "add": 184, + "clear": 16, + "rank8": 8 + }, + "conversions": 1570, + "events": 24767, + "scalar_columns": 704 + }, + "forward": { + "bill": { + "add": 176, + "clear": 16, + "copy": 8, + "rank8": 8 + }, + "conversions": 1570, + "events": 24767, + "scalar_columns": 704 + } + }, + "native_operator_checks": { + "endpoint_adapter_identities": 224, + "input_twist_inverses": 8, + "invertible_wrapper_records": 36, + "operator_columns": 512, + "used_child_keys_sha256": "5a757d555a469931b9146dda36b6fcb6a45cd22fbdec783282b5169d9232f89a", + "used_child_recipes": 2896 + }, + "scientific_base": "a1bfbc677fdcbc2a27a9b3bf6c78cac8fd6da9e2", + "scope": "Premises for source-response kernel inclusion through eight full native fields. Global view/hosting semantics inherited; boundary phases separately checked. No sharp terminal rank, paid decoder, full dirty residual or new kappa.", + "status": "PASS_CENTRE_NATIVE_TERMINAL_PREMISES" +} diff --git a/research/centre-native-terminal-factor/SOURCES.json b/research/centre-native-terminal-factor/SOURCES.json new file mode 100644 index 0000000000..fa49967ecc --- /dev/null +++ b/research/centre-native-terminal-factor/SOURCES.json @@ -0,0 +1,104 @@ +{ + "schema_version": 1, + "base_commit": "a1bfbc677fdcbc2a27a9b3bf6c78cac8fd6da9e2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "889b95d936746df124872133ae1e7cc339adcb92", + "sha256": "7d185cd8c2af35988d638d969748ad7b670f902606444dbfc748e4402c340df6" + }, + { + "path": "research/centre-native-observation-dimension/PROOF.md", + "usage": "input", + "git_blob": "ffe657f7e8a691b3dc3db5910cab8594b8b49285", + "sha256": "5f81f76cbb61e5d66ded17423045d02f959f182ada6158fd6428b3a909943b29" + }, + { + "path": "research/centre-native-observation-dimension/audit.py", + "usage": "input", + "git_blob": "4b278162f4559e137432d43b9d3a9b8e25e4ce0c", + "sha256": "53ffe63d58a1981fad536fd801ea68785b1c6065709d40486e989c30194e20fd" + }, + { + "path": "research/centre-terminal-source-quotient/README.md", + "usage": "input", + "git_blob": "a934696c4a1982bfddfaffaf8ba60407214eac6a", + "sha256": "c8b2099a313d57d4882e8103f3a51aff7760a31311c0ab31734e97f44e74ecb7" + }, + { + "path": "research/community-frontier1094-audit/selected-replay.tar.gz", + "usage": "input", + "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f", + "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" + }, + { + "path": "research/e8-lemma-g-lean/LemmaG/Stream.lean", + "usage": "input", + "git_blob": "e89897190307a6f3fcfb858f8de00cc5a7f49b3e", + "sha256": "7138f4b859d0574a803e99401f05ef5e0ec9eeac0eb480775cd9b86595c365f8" + }, + { + "path": "research/frontier1094-recipes-exact-seed76/clifford.py", + "usage": "input", + "git_blob": "6f1e6a38febde7eb7a7341d317522e6650d84408", + "sha256": "d5e42ddabd141b7bfbd70fe13908f3c3a06aeccebeab90623596bfb1988b97fb" + }, + { + "path": "research/idle-axis-hosting/PROOF.md", + "usage": "input", + "git_blob": "4468a00349b4f68dce103e785a8392099435e1d6", + "sha256": "cfe34bf0b64259661312dae22c3a23adc5bf6f6326951eee5c1488ccfc347542" + }, + { + "path": "research/selected-centre-native-lift/README.md", + "usage": "input", + "git_blob": "98721e3eb4b955129321078f09c4b1b3b2ef5ae0", + "sha256": "aa50f2984b8f0af8781e1b0295f907606b1031bc284a396b683f3e5506148595" + }, + { + "path": "research/selected-centre-native-lift/verify.py", + "usage": "input", + "git_blob": "1382ea4e21ce801190e218b317512809bc96f042", + "sha256": "c6d2a9cae5cbcc5f9bdff02f22d58ed2ae96914a41219027175e49eb07d94a32" + }, + { + "path": "research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt", + "usage": "input", + "git_blob": "c4150cb693414c098690eae79b3aea5f47c184ff", + "sha256": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2" + } + ], + "archive_members": { + "word": { + "path": "candidate/strict/global/base/providers/gauge44/CANONICAL-WORD.json.gz", + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + "programs": { + "path": "candidate/strict/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz", + "sha256": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a" + }, + "recipes": { + "path": "candidate/strict/global/base/providers/gauge44/CLIFFORD-RECIPES.json", + "sha256": "d0768f2164d5f64a2fdbec422f1cfde4e400818792f1904ca541958377243731" + }, + "residuals": { + "path": "candidate/strict/global/base/providers/gauge44/RESIDUAL-ADAPTERS.json", + "sha256": "383f40aadd00a4ac700dfd0d4c22d6c6c0be9a9863116e4d69c7acd23bafae0c" + }, + "template": { + "path": "candidate/strict/global/hosted/GLOBAL-TEMPLATE.json.gz", + "sha256": "2acf02b418078e37090495c601fe550448751d4f35912757b13a1f778efc7760" + }, + "phases": { + "path": "candidate/strict/global/base/work/complex-nine-native/DATA-PHASES.json", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + } + } +} diff --git a/research/centre-native-terminal-factor/TASK.json b/research/centre-native-terminal-factor/TASK.json new file mode 100644 index 0000000000..f1d92b1f43 --- /dev/null +++ b/research/centre-native-terminal-factor/TASK.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "task_id": "centre-path-sharing", + "priority_revision": 5, + "base_commit": "a1bfbc677fdcbc2a27a9b3bf6c78cac8fd6da9e2", + "original_card": { + "id": "centre-path-sharing", + "question": "Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt", + "certificates/selected-result.json" + ], + "methods": [ + "Derive a fully charged favorable relaxation for sharing one centre path across k calls, including restoration, hosting and precision.", + "Prove a lower bound on copied information per call for the selected decoder contract." + ], + "acceptance_gate": "Show the changed centre charge and copy profile per call with every added restoration or hosting cost charged, and its ceiling via ceiling.ceiling(centre=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write the per-call centre charge and copy children for sharing across k = 2 calls, charge the sharing overhead, and screen it; stop this route if even the ideal sharing gains under 10%. Ideal budgets: free 2.80x, shared by two 1.90x (levers.py).", + "bottleneck_link": "The centre path consumes 64 of about 99.6 unpaid coordinates per call, i.e. about 64% of the raw deficit.", + "allowed_variations": [ + "One sharing pattern across a fixed number of calls.", + "One reduced copied-total contract for the existing decoder.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Removing copies without a replacement contract for the decoder's copied totals.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "centre path", + "copied totals", + "private temporary", + "shared centre", + "batching" + ] + }, + "scope_status": "refined", + "actual_scope": "Conditional native source-response upper-factorization for the selected complete F0-to-F2 two-centre-ablation prefix through the first eight full centre fields.", + "scope_change_reason": "After bounded task selection and overlap inspection, use the centre-path-sharing scoped-local-result allowance to resolve the native upper-factorization explicitly left open by PR2564. This does not meet the paid replacement-supplier acceptance gate or claim a cost saving.", + "bottleneck_link": "Determines whether eight first observations contain the native source-response information required by this terminal residual; a paid dirty decoder, restoration and budget remain separate obligations for reducing the unchanged centre bill.", + "budget_minutes": 60, + "stop_rule": "One selected 19-event prefix; prove or refute kernel inclusion with exact native boundary, source-support and independent adjoint checks. Stop after proof, controls and review; no expanded source-count, rank census or supplier search.", + "outcome": "partial", + "evidence": "README conditional proof; RESULT.json authenticates complete common-frame/local-operator and causal-support premises; NATIVE.json checks signed 73-axis boundaries; INDEPENDENT.json derives rows by reverse adjoints. VALIDATION.md separates proof assumptions, local replay and review from unrun physical/compiler/cost obligations.", + "author": "DLamdata, with OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance: lead proof/integration, one native-boundary source-audit and skeptical-review agent, and one independent reverse-adjoint/contract agent. At most two active subagents, no nested agents. Shared archive and native-view premise; boundary/primary share credited Clifford code. Not independent human or formal global verification.", + "open_questions": [ + { + "question": "Can a legal, fully charged consumer reconstruct the dirty terminal residual from these saved native fields while improving the selected invoice?", + "why_it_matters": "Existence of an information factorization neither evaluates its decoder nor removes the dirty offset, catch-up, observation or restoration charges.", + "first_step": "Specify the exact saved dirty fields and output contract, write a concrete consumer and offset/restoration program, cancel common work against the original complete prefix, and screen the resulting full profile before further construction.", + "blocked_by": "No paid L_native implementation or dirty-offset interface is supplied; selected coverage, hosting and precision obligations remain." + } + ], + "selection": { + "original_nonce": "22e41620c062c0ed4433943f8b2ace29", + "original_track": "recursive-interfaces", + "original_suggestions": [ + "joint-query-controller", + "connector-alphabet-change", + "coverage-law-change" + ], + "override": "Scoped centre-path-sharing terminal gap selected after source audit; initial joint-query/local-control mechanisms already heavily covered. No unrelated search." + }, + "coordination": { + "reservation": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1884#discussioncomment-18967805", + "posted_by": "DLamdata manually; initial lead API request forbidden", + "initial_overlap_utc": "2026-10-16 08:33 UTC", + "coverage": { + "open_prs": 488, + "closed_prs": 2103, + "discussion_records": 1558, + "local_notes": 2586 + }, + "limitations": "Cached bodies and Discussion text, not all PR diffs. Prepublication refresh recorded in VALIDATION.md." + }, + "family_gate": { + "restriction_changed": "Information needed at the full terminal cut, rather than exact per-call copied-total equality. Native extension of PR2564 scalar source quotient.", + "favorable_budget": "Unchanged eight H8 children/rank mass64 per call; sixteen/rank mass128 for the two calls. The card control gives shared-by-two ideal 1.90x and free-centre ideal2.80x only as planning relaxations.", + "new_paid_obligations": "Native residual consumer, dirty offset, observations, storage/catch-up, return, restoration, precision and hosting.", + "discriminating_evidence": "Exact signed native boundary phases plus complete 19-event support and zero-block argument; independent reverse adjoints and mutation controls.", + "decision": "Retain bounded conditional information lemma; do not expand a construction or claim supplier admission." + } +} diff --git a/research/centre-native-terminal-factor/VALIDATION.md b/research/centre-native-terminal-factor/VALIDATION.md new file mode 100644 index 0000000000..a043351b9c --- /dev/null +++ b/research/centre-native-terminal-factor/VALIDATION.md @@ -0,0 +1,168 @@ +# Validation and limits + +Scientific inputs: canonical main `a1bfbc677fdcbc2a27a9b3bf6c78cac8fd6da9e2`. +Integration base: `ba3de47290c3882cbbe406db1f657578f7ecda69`, fetched on +2026-10-16 at the verification checkpoint. The five intervening commits add +CI matrix batching and unrelated retained-review evidence. The contribution +branch was fast-forwarded before final replay to use the current runner. +AGENTS, autoresearch, CONTRIBUTING, priority revision 5, selected-result record, +family-status guidance and **all live package inputs** were unchanged. +SOURCES/TASK retain the original scientific and catalogue pins. + +A final prepublication fetch found upstream +`d08a1e413c881ae3ff6a1a8b0c7d042b093517b6`. Its additional floor/three-register reviews do not touch this package, +its inputs, relevant guidance, selected record or replay runner. No further +rebase or scientific rerun is needed solely for those unrelated changes. + +Environment: Linux x86_64, kernel 6.18.44, glibc 2.41; CPython 3.12.14. +The package uses only the standard library. Existing environment dependencies +and managed Git authentication were preserved; no installation was needed. +Exact rational, integer, Gaussian-dyadic and Z/4 arithmetic is used. No floating +point numerical evidence is used for the theorem. + +## Commands and scope + +The registered invocation is: + +```sh +python3.12 -B scripts/research_package.py --package research/centre-native-terminal-factor +``` + +Final registered replay passed in 100.148 seconds, including all three +receipt comparisons and metadata/source pins. Its three sequential commands, +each explicitly optimized to ensure essential +checks survive `-O`, are: + +```sh +python3.12 -I -O -B research/centre-native-terminal-factor/verify.py +python3.12 -I -O -B research/centre-native-terminal-factor/native_boundary.py +python3.12 -I -O -B research/centre-native-terminal-factor/independent_terminal.py +``` + +| Check | Exact evidence | +|---|---| +| Primary | Both 24,767-event complete local words; 704 ordinary columns each; 2,896 conversion recipes, 224 endpoint adapters, 36 residual wrappers; literal 19-event prefix; all 1,688 demanded zero coefficients; determinant-32 first-cut minor; six semantic controls | +| Native boundary | 4,032 signed 73-axis boundary identities; 2,420,992 direct determining-character comparisons at stages 0/1; 448 complete 512-column local-label comparisons; two signed scalar endpoints | +| Independent adjoint | 1,408 reverse-derived ordinary endpoint rows and eight pre-centre rows; literal 19-event schedule; 112 target and 99 helper zero columns; 112 stage-one routes; 15 intervening live helper touches; independent exact native primitive controls | + +The independent centre-row hash remains +`78a8599e7dac0229f8912c070e5e8db0127d5949e3f85fed0acc62762e591483`. +All three commands compare complete deterministic JSON receipts; integral +values are not accepted as floats or booleans. The primary authenticates each +input by SHA256 and Git-blob hash before compiling predecessor bytes. Both +other checkers independently authenticate the archive and unique regular +full-path members. The boundary checker authenticates the shared Clifford +kernel before compiling it. The registered runner isolates Python bytecode +caches; the credited predecessor modules are compiled directly from their +hashed source bytes. + +Before the investigation, environment `pip check`, `make selected-record-check` +and `python scripts/research_baseline.py` passed. These establish dependency +and selected-record binding/arithmetic, not a new proof or full replay. +The task-card ceiling control passed with +`kappa <= 0.0016872026453254019`; its lever table gave ideal shared-by-two +1.90x and free-centre 2.80x planning budgets. Neither number is a new result +of this package or an admitted saving. + +## Independent and skeptical review + +Two bounded Codex agents were used, with no nested delegation. The reverse- +adjoint agent derived its verdict without reading the primary implementation. +It then compared the written proof. The boundary agent subsequently reviewed +the lead proof/loader/causal check and the other agent's code; it did not count +review of its own boundary code as independent verification. Both share the +selected archive and inherited native-view premise; the primary and boundary +checker share Sagar Thakrar's exact Clifford kernel. The independent executable +imports neither that kernel nor the primary/retained audit. + +The reviews found no gap in the stated conditional kernel inclusion, paired +fixed-dirt difference, owner/gauge argument, helper zero-block argument or +per-owner abstract right inverse. Two concrete findings were resolved: + +1. **Cost unit:** eight H8 children/rank mass 64 are charged per call; sixteen/ + 128 are for the two ablated calls together. README/TASK now say this. +2. **Mutation-control legality:** a proposed ADD from live helper 572 to role + 334 initially ran before entry adapters. Though both integer start-frame + IDs were zero, helper 572 had a nontrivial residual pre-wrapper. That + placement was not a same-native-frame operation. The corrected ADD runs at + event 8107 immediately after the phase-A marker and all entry adapters. + Independent conversion-readiness checks now reject the old placement. + A separate source-authenticated retained extended-label diagnostic rejects + the old placement at `common frame`; the corrected one passes frame checks + and reaches the intended `complete scalar endpoint` rejection. Its helper + column is exactly `(1,0,0,1,0,-1,1,0)`. The source-sign mutation was also + moved after its entry conversion. Original centre rows and theorem are + unchanged. The affected independent receipt was regenerated and replayed. The skeptical + reviewer inspected the correction and closed both findings; no material + review issue remains within the stated scope. + +These are AI reviews and exact finite/source checks supporting the written +conditional proof, not independent human review or formal global verification. + +## Portability and failure controls + +A minimal export contained this package and precisely the declared live input +files, with no `.git`. All source files were chmod 0444 and directories 0555. +Direct commands were launched from unrelated `/tmp`, with `-I -O -B`, and +compared the existing receipts without regeneration. The primary passed in +57.959 seconds and the boundary checker in 16.336 seconds. The corrected +independent command passed in 25.446 seconds. Changing the recorded helper +count from integer `99` to floating `99.0` failed with `complete independent +receipt mismatch` (28.297 seconds); the original receipt was restored. +The generic metadata launcher itself needs Git provenance; this export tests +the mathematical commands, not an undocumented Git-free metadata mode. + +Changing one byte of the credited local audit in that export caused the +primary to fail with `source SHA256` before compiling it. The original bytes +were restored. Native phase controls detect omitted entry/exit correction, +unrouted entry translations and the wrong inverse-Y sign; the primary catches +an actual global-phase adapter fault and a wrong common-frame event. Other +controls omit B1/bridges, reverse a backward sign or inject a live helper. +Support-control failure means the sufficient zero-demand premise fails; it +is not advertised as a full mutated native terminal counterexample. + +Default verification is read-only. Receipt generation is an explicit +`--write NEW_PATH` mode that refuses existing destinations. All generated +receipts were inspected; only this new package is in the contribution diff. +Private prompts, session logs and reviewer working notes stay outside Git. +Publication uses `scripts/check_research_commit.py` to compare the checked +working bytes with the exact commit before pushing; its result and the final +SHA are recorded in the PR/handoff. + +## Overlap and publication boundary + +Initial full overlap at 08:32–08:33 UTC covered 488 open PRs, 2,103 closed PRs, +1,558 Discussion records and 2,586 local records. A 09:03–09:04 refresh covered +491 open and 2,106 closed PRs and 2,588 local records. The full Discussion +refresh returned HTTP 503 and retained the earlier complete snapshot. A +separate successful live read inspected the 60 most recently updated +Discussion bodies (not the entire board's replies) and the latest 30 comments +in #1884, including the donor's reservation. PR search covers titles/bodies, +not every diff; no match is not a novelty certificate. + +Direct predecessor PR #2564 at +`64f940a8ee305a1b69f7db329f1ffa232e53c2ad` supplies the explicit native terminal +question. PR #2391's quarter-query counterexample is a different contract. +PR #2895 was rechecked open at `7324b2526182206904f75e4037014bcc2f0be4f5`; +its retained-array/catch-up limitation is not invalidated by this unpriced +factorization and is not used as a theorem dependency. Newer inspected work +on ordinary interchange, native BIT payload peaks, mixed BIT targets and +F-star cancellation lines does not claim this native terminal lemma. + +Previous PR #2880 was rechecked open, unmerged, non-draft at unchanged head +`3091cfbd61005b3e5daa7dbfcf3377597924552d`. This assignment never changed that +branch, package, PR state or checks. Its encoded-bank audit is outside scope. +The donor posted the [reservation](https://github.com/CrocSwap/integer-mult-bounds/discussions/1884#discussioncomment-18967805) +at 08:44 UTC. The lead's initial Discussion write was forbidden; no retrospective +reservation is claimed. Remote CI is reported separately in the PR/handoff. + +## Unrun obligations + +No full selected-construction cold replay, full physical native compiler build, +new Lean build, sharp native terminal rank, cost/precision recomputation, +paid decoder or dirty-offset/restoration construction was performed. No +selected source, cost profile, exponent record or existing package changed. +The result is conditional on the declared inherited full-space native-view +and hosting interface, and leaves all affordability and full dirty-consumer +obligations open. The next step is the concrete paid consumer described in +README/TASK, not a larger unpriced information census. diff --git a/research/centre-native-terminal-factor/VERIFY.json b/research/centre-native-terminal-factor/VERIFY.json new file mode 100644 index 0000000000..4e23306e08 --- /dev/null +++ b/research/centre-native-terminal-factor/VERIFY.json @@ -0,0 +1,53 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/centre-native-observation-dimension/PROOF.md", + "research/centre-native-observation-dimension/audit.py", + "research/centre-terminal-source-quotient/README.md", + "research/community-frontier1094-audit/selected-replay.tar.gz", + "research/e8-lemma-g-lean/LemmaG/Stream.lean", + "research/frontier1094-recipes-exact-seed76/clifford.py", + "research/idle-axis-hosting/PROOF.md", + "research/selected-centre-native-lift/README.md", + "research/selected-centre-native-lift/verify.py", + "research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Authenticated native recipes/adapters and both complete local words; full chronological support; first-cut minor; six semantic controls; exact RESULT receipt." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/native_boundary.py" + ], + "timeout_seconds": 120, + "checks": "All signed 73-axis boundary phase identities, exact local endpoint labels, both scalar endpoints and omitted/misrouted/wrong-sign controls; exact NATIVE receipt." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/independent_terminal.py" + ], + "timeout_seconds": 180, + "checks": "Independent reverse adjoints, common frames, literal 19-event schedule and native primitive controls; exact INDEPENDENT receipt." + } + ] +} diff --git a/research/centre-native-terminal-factor/independent_terminal.py b/research/centre-native-terminal-factor/independent_terminal.py new file mode 100644 index 0000000000..68d09991ae --- /dev/null +++ b/research/centre-native-terminal-factor/independent_terminal.py @@ -0,0 +1,393 @@ +#!/usr/bin/env python3 +"""Independent adjoint audit of the selected first terminal quotient. + +This checker does not import a primary checker. It consumes the same immutable +selected archive. Native lifting is the conditional argument in the accompanying +review, using exact recipes and the retained common-frame embedding semantics. +Prepared with substantial OpenAI Codex assistance; Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +import argparse +import copy +import gzip +import hashlib +import json +from pathlib import Path +import tarfile + +HERE = Path(__file__).resolve().parent +ARCHIVE = "research/community-frontier1094-audit/selected-replay.tar.gz" +ARCHIVE_SHA = "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" +PINS = { + "global": ("candidate/strict/global/hosted/GLOBAL-TEMPLATE.json.gz", "2acf02b418078e37090495c601fe550448751d4f35912757b13a1f778efc7760"), + "word": ("candidate/strict/global/base/providers/gauge44/CANONICAL-WORD.json.gz", "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219"), + "programs": ("candidate/strict/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz", "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a"), + "phases": ("candidate/strict/global/base/work/complex-nine-native/DATA-PHASES.json", "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa"), +} + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def load(root): + path = root / ARCHIVE + need(sha(path.read_bytes()) == ARCHIVE_SHA, "immutable archive hash") + result = {} + with tarfile.open(path) as archive: + members = archive.getmembers() + for key, (name, digest) in PINS.items(): + matches = [m for m in members if m.name == name] + need(len(matches) == 1 and matches[0].isfile(), "unique member " + key) + raw = archive.extractfile(matches[0]).read() + need(sha(raw) == digest, "member bytes " + key) + result[key] = json.loads(gzip.decompress(raw) if name.endswith(".gz") else raw) + return result + + +def increment(row, role, value): + value += row.get(role, Q(0)) + if value: + row[role] = value + else: + row.pop(role, None) + + +def adjoint(program, stop, output): + """Pull one output functional backwards through the literal scalar prefix. + + Native relabels are identities only in the moving-frame representation; + scalar coefficient zeros lift using common-frame conjugation, not by + assuming the physical relabels act identically. + """ + row = {output: Q(1)} + for event in reversed(program[:stop]): + tag = event[0] + if tag != "scalar": + need(tag in {"phase", "center", "climb", "adapter", "residual_adapter"}, "known event") + continue + op = event[1] + kind, dst = op[0], tuple(op[1]) + a = row.get(dst, Q(0)) + if kind == "clear": + row.pop(dst, None) + elif kind == "copy": + row.pop(dst, None) + if a: + increment(row, tuple(op[2]), a) + elif kind == "scale": + if a: + row[dst] = a * Q(op[2], op[3]) + elif kind == "add": + need(dst != tuple(op[2]), "no aliasing self ADD") + if a: + increment(row, tuple(op[2]), a * Q(op[3], op[4])) + else: + raise ValueError("unknown scalar operation") + need(all(kind == "L" for kind, _ in row), "no uncleared private input dependence") + return {r: v for (_, r), v in row.items() if v} + + +def cut_rows(program): + result = {} + for pos, event in enumerate(program): + if event[0] == "center": + k = event[1] + need(k not in result and event[4] == 8, "one rank-eight event per channel") + result[k] = adjoint(program, pos, ("C", k)) + need(set(result) == set(range(8)), "all eight cuts") + return [result[k] for k in range(8)] + + +def check_common_frames(program, word): + current = {("L", r): f for r, f in enumerate(word["start"])} + # A numerical start-frame ID is insufficient before a source conversion + # or residual pre-wrapper. Those physical boundary labels are distinct. + wrapped = {r for r in range(224, 704) + if (word["start"][r], word["final"][r]) != (0, 1)} + canonical = {("L", r) for r in range(112, 704) if r not in wrapped} + checked = 0 + for event in program: + tag = event[0] + if tag == "climb": + role, old, new = event[2:5] + need(("L", role) in canonical, "climb before canonical conversion") + need(current["L", role] == old, "climb starts in current frame") + current["L", role] = new + elif tag == "center": + k, old, new = event[1:4] + need(("C", k) in canonical, "centre canonical conversion") + need(current["C", k] == old, "centre starts in current frame") + current["C", k] = new + elif tag == "scalar": + op, frame = event[1:3] + kind, dst = op[0], tuple(op[1]) + if kind == "clear": + need(dst[0] == "C", "only private CLEAR") + current[dst] = frame + canonical.add(dst) + else: + need(dst in canonical, "scalar destination before/after canonical conversion") + need(current[dst] == frame, "destination scalar frame") + if kind in ("copy", "add"): + need(tuple(op[2]) in canonical, "scalar source before/after canonical conversion") + need(current[tuple(op[2])] == frame, "source scalar frame") + checked += 1 + elif tag == "adapter": + direction, role = event[1:3] + if direction == "old_to_new": + canonical.add(("L", role)) + elif 112 <= role < 224: + canonical.discard(("L", role)) + elif tag == "residual_adapter": + direction, role = event[1:3] + if direction == "pre": + canonical.add(("L", role)) + else: + canonical.discard(("L", role)) + need([current["L", r] for r in range(704)] == word["final"], "all terminal frames") + return checked + + +def check_endpoints(program, backward): + """704 independent reverse functional pulls, not forward row propagation.""" + for r in range(704): + expected = {r: Q(1)} + if backward and r < 112: + expected[r + 112] = Q(-1) + elif not backward and 112 <= r < 224: + expected[r - 112] = Q(1) + need(adjoint(program, len(program), ("L", r)) == expected, "complete endpoint " + str(r)) + return 704 + + +def multiply(columns, x): + out = 0 + for i, col in enumerate(columns): + if (x >> i) & 1: + out ^= col + return out + + +def check_routes(phases): + """Reconstruct all 112 stage-one involutions and the needed side alignment.""" + identity = [1 << i for i in range(73)] + for record in phases["recipes"]: + b = record["idle_children"][0]["orthogonal_axes"][:8] + basis = [record["q"]] + b + need(all(((x & y).bit_count() & 1) == (i == j) + for i, x in enumerate(basis) for j, y in enumerate(basis)), "port orthogonal basis") + swaps = [x ^ (1 << (9 + i)) for i, x in enumerate(b)] + rho = [x ^ multiply(swaps, sum(((x & z).bit_count() & 1) << i + for i, z in enumerate(swaps))) for x in identity] + need(multiply(rho, record["q"]) == record["q"], "route fixes q") + need(all(multiply(rho, multiply(rho, x)) == x for x in identity), "route involution") + for a in record["stage_alignment"][:3]: + need(a["entry_X"] == a["entry_Y"] and a["exit_X"] == a["exit_Y"], "same-side translations") + return len(phases["recipes"]) + + +def schedule_inputs(data): + global_ = data["global"] + key = lambda c: (c["time"], c["replica"], c["stage"], c["provider_id"]) + calls = {key(c): c for c in global_["calls"]} + schedule = global_["execution_schedule"] + finish = next(i for i, e in enumerate(schedule) + if e["kind"] == "local_cover_sweep" and e["time"] == 10) + prefix = schedule[:finish + 1] + need(finish == 18 and Counter(e["kind"] for e in prefix) == + {"local_cover_sweep": 11, "idle_cover_sweep": 4, "bridge": 4}, "exact observation boundary") + selected = [] + for e in prefix: + if e["kind"] != "local_cover_sweep": + continue + c = calls[key(e)] + need(len(c["owners"]) == len({f for f, _ in c["owners"]}) == 704, "injective family map") + raw = json.dumps(data["programs"][c["orientation"]], sort_keys=True, separators=(",", ":")).encode() + need(sha(raw) == c["local_program_sha256"], "bound program for call") + selected.append(c) + need([c["time"] for c in selected] == list(range(11)), "chronological call census") + for i, stage, orientation in ((0, 0, "forward"), (4, 1, "backward"), (10, 2, "forward")): + c = selected[i] + need((c["stage"], c["replica"], c["pair"], c["orientation"]) == + (stage, 0, 0, orientation), "selected invocation") + need(c["owners"][:224] == [[r, [1, stage, r % 112]] for r in range(224)], "data view binding") + for c in selected: + if c["time"] not in (0, 4, 10): + need(not ({f for f, _ in c["owners"]} & set(range(224))), "other calls cannot touch X0/Y0") + return prefix, selected + + +def response_support(prefix, calls, backward_mode="normal"): + """Family support only, conditional on the written native B1 cancellation. + + Complete helpers have unit rows, so arbitrary native wrappers can change + their payload without changing family support. The special B1 cancellation + is valid because Y=C_q^-1 X, same data routes, and common phase alignment; + it is not inferred merely from support sets. + """ + live = set(range(112)) + trace = [] + call8_helpers = [] + for e in prefix: + kind = e["kind"] + if kind == "local_cover_sweep": + c = calls[e["time"]] + families = [f for f, _ in c["owners"]] + if c["time"] == 10: + return live, trace, call8_helpers + if c["time"] == 4: + need(set(range(224)) <= live, "paired F0 response present") + if backward_mode == "normal": + live -= set(range(112)) + else: + need(backward_mode in ("omitted", "reversed_sign"), "known B1 mutation") + else: + source = families[:112] if c["orientation"] == "forward" else families[112:224] + target = families[112:224] if c["orientation"] == "forward" else families[:112] + live.update(t for s, t in zip(source, target) if s in live) + if c["time"] == 8: + call8_helpers = [(r, f) for r, f in enumerate(families) if r >= 224 and f in live] + need(not (set(families[:224]) & live), "call8 response only on helper inputs") + elif kind == "idle_cover_sweep": + need(e["pair"] == 1 and e["child_indices"] == [0, 2], "declared prefix idle children") + # A unary native operation cannot create response on a zero family. + elif kind == "bridge": + need(e["src"] == 1 and e["dst"] == 0 and e["coefficient"] == 1, "bridge algebra binding") + base = 896 * e["replica"] + for p in range(112): + if base + 224 + p in live: + live.add(base + p) + if base + 112 + p in live: + live.add(base + 336 + p) + else: + raise ValueError("unsupported prefix event") + trace.append(dict(kind=kind, time=e["time"], live_families=len(live))) + raise ValueError("missing terminal call") + + +def zero_demand(rows, roles): + return all(not row.get(r, 0) for row in rows for r in roles) + + +def root(v, q, sign=1): + # Exact Gaussian pairs; independent primitive, no Clifford-kernel import. + out = [] + for x, (a, b) in enumerate(v): + c, d = v[x ^ q] + out.append(((a - sign*b + c + sign*d)/2, + (b + sign*a + d - sign*c)/2)) + return out + + +def shift(v, q): + return [v[x ^ q] for x in range(len(v))] + + +def minus(a, b): + return [(x-u, y-v) for (x, y), (u, v) in zip(a, b)] + + +def operator_controls(q): + v = [(Q(i == 0), Q(0)) for i in range(512)] + x = root(v, q, -1) + y = root(x, q, -1) + for axis in range(9): + x, y = root(x, 1 << axis), root(y, 1 << axis) + zero = [(Q(0), Q(0))] * 512 + need(minus(root(x, q, -1), y) == zero, "nonconstant boundary cancellation") + need(root(root(v, q), q) == shift(v, q), "Cq square equals translation") + wrong_phase = [(-b, a) for a, b in y] + need(minus(root(x, q, -1), wrong_phase) != zero, "wrong phase detected") + need(minus(root(x, q, -1), shift(y, 1)) != zero, "unequal side translation detected") + return ["nonconstant_cancellation", "root_square", "wrong_phase_detected", "unequal_side_translation_detected"] + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--root", type=Path, default=HERE.parents[1]) + parser.add_argument("--write", type=Path) + args = parser.parse_args() + if args.write and args.write.exists(): + raise FileExistsError(args.write) + data = load(args.root) + word, programs = data["word"], data["programs"] + need((word["v"], word["R"], word["h"]) == (112, 480, 9), "word dimensions") + frames = {name: check_common_frames(programs[name], word) for name in ("forward", "backward")} + endpoints = {name: check_endpoints(programs[name], name == "backward") for name in ("forward", "backward")} + rows = cut_rows(programs["forward"]) + prefix, calls = schedule_inputs(data) + routes = check_routes(data["phases"]) + live, trace, call8 = response_support(prefix, calls) + need(live == set(range(112, 224)) | set(range(336, 448)), "all possible live response families before F2") + f2 = calls[10] + inputs = [(r, f) for r, (f, _) in enumerate(f2["owners"]) if f in live] + targets = [r for r, _ in inputs if r < 224] + helpers = [r for r, _ in inputs if r >= 224] + need(targets == list(range(112, 224)) and len(helpers) == 99, "112 targets and 99 helper inputs") + need(zero_demand(rows, targets + helpers), "native-zero coefficient criterion") + need(len(call8) == 15, "call8 retains fifteen helper responses") + for mutation in ("omitted", "reversed_sign"): + changed, _, _ = response_support(prefix, calls, mutation) + roles = [r for r, (f, _) in enumerate(f2["owners"]) if f in changed] + need(not zero_demand(rows, roles), "B1 mutation must destroy zero-demand guarantee: " + mutation) + # Independently realize the sign change as conjugation by -1 on source 0. + # This keeps every other endpoint unchanged and changes X0-Y0 to X0+Y0. + plus_word = copy.deepcopy(programs["backward"]) + plus_at = plus_word.index(["phase", "A"]) + 1 + plus_word.insert(plus_at, ["scalar", ["scale", ["L", 0], -1, 1], word["start"][0]]) + plus_word.append(["scalar", ["scale", ["L", 0], -1, 1], word["final"][0]]) + check_common_frames(plus_word, word) + need(adjoint(plus_word, len(plus_word), ("L", 0)) == {0: Q(1), 112: Q(1)}, + "literal sign-conjugated B1 endpoint") + need(any(row.get(0) for row in rows), "changed port0 source reaches a second query") + # A legal same-frame cold-helper injection contaminates a demanded row. + h = next(r for r in helpers if word["start"][r] == 0) + r = next(r for row in rows for r in row if r >= 224 and word["start"][r] == 0) + changed = copy.deepcopy(programs["forward"]) + insert_at = changed.index(["phase", "A"]) + 1 + changed.insert(insert_at, ["scalar", ["add", ["L", r], ["L", h], 1, 1], 0]) + check_common_frames(changed, word) + mutated_rows = cut_rows(changed) + need(not zero_demand(mutated_rows, targets + helpers), "same-frame helper contamination detected") + # The earlier diagnostic placement before adapters must fail closed: h + # still has its noncanonical residual input label at that boundary. + before_conversion = copy.deepcopy(programs["forward"]) + before_conversion.insert(1, ["scalar", ["add", ["L", r], ["L", h], 1, 1], 0]) + try: + check_common_frames(before_conversion, word) + except ValueError as error: + need("canonical conversion" in str(error), "wrong pre-wrapper rejection") + else: + raise ValueError("pre-wrapper scalar contamination accepted") + controls = operator_controls(word["ports"][0]) + encoded = [{str(r): str(v) for r, v in sorted(row.items())} for row in rows] + result = dict(status="PASS_INDEPENDENT_TERMINAL_ADJOINT_CONDITIONAL_NATIVE_LIFT", + archive_sha256=ARCHIVE_SHA, member_sha256={k: v[1] for k, v in PINS.items()}, + reverse_adjoint_endpoint_rows=endpoints, common_frame_scalar_events=frames, + centre_rows=encoded, centre_rows_sha256=sha(json.dumps(encoded, sort_keys=True, separators=(",", ":")).encode()), + schedule_events=len(prefix), source_support_trace=trace, first_stage_q_routes=routes, + f2_target_zero_columns=len(targets), f2_helper_zero_columns=len(helpers), + call8_live_helpers=call8, f2_live_helpers=[(r, f) for r, f in inputs if r >= 224], + controls=controls + ["omitted_B1_detected", "reversed_B1_sign_detected", "same_frame_helper_contamination_detected", "pre_wrapper_contamination_rejected"], + helper_contamination=dict(source=h, destination=r, event_index=insert_at, + placement="immediately after phase A marker, after all entry/residual adapters", + nonzero_coefficients={str(k): str(row[h]) for k, row in enumerate(mutated_rows) if row.get(h)}), + scope="Independent scalar adjoints, supports and primitive controls; universal native factorization uses the written common-frame/endpoint proof. No full native rank, dirty-offset implementation, child saving, or supplier claim.") + if args.write: + with args.write.open("x", encoding="utf-8", newline="\n") as out: + out.write(json.dumps(result, sort_keys=True, indent=2)+"\n") + else: + expected=json.loads((HERE/"INDEPENDENT.json").read_bytes()) + need(json.dumps(expected,sort_keys=True)==json.dumps(result,sort_keys=True), "complete independent receipt mismatch") + print("PASS_INDEPENDENT_TERMINAL_ADJOINT_CONDITIONAL_NATIVE_LIFT endpoints=1408 cuts=8 live_helpers=99") + + +if __name__ == "__main__": + main() diff --git a/research/centre-native-terminal-factor/native_boundary.py b/research/centre-native-terminal-factor/native_boundary.py new file mode 100644 index 0000000000..787cdfe2e8 --- /dev/null +++ b/research/centre-native-terminal-factor/native_boundary.py @@ -0,0 +1,190 @@ +#!/usr/bin/env python3 +"""Exact selected boundary phases; DLamdata with Codex assistance, Apache-2.0. +Independent phase derivation; credited exact Clifford kernel for local labels. +""" +from pathlib import Path +import gzip, hashlib, json, tarfile, types, argparse +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +ARCHIVE='research/community-frontier1094-audit/selected-replay.tar.gz' +ARCHIVE_SHA='f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6' +MEMBERS={ + 'phases':('candidate/strict/global/base/work/complex-nine-native/DATA-PHASES.json','c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa'), + 'template':('candidate/strict/global/hosted/GLOBAL-TEMPLATE.json.gz','2acf02b418078e37090495c601fe550448751d4f35912757b13a1f778efc7760'), + 'word':('candidate/strict/global/base/providers/gauge44/CANONICAL-WORD.json.gz','16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219'), + 'recipes':('candidate/strict/global/base/providers/gauge44/CLIFFORD-RECIPES.json','d0768f2164d5f64a2fdbec422f1cfde4e400818792f1904ca541958377243731'), + 'programs':('candidate/strict/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz','241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a')} +M=73 + +def require(ok,msg): + if not ok: raise ValueError(msg) + +def digest(raw):return hashlib.sha256(raw).hexdigest() + +def load(): + raw=(ROOT/ARCHIVE).read_bytes();require(digest(raw)==ARCHIVE_SHA,'archive drift') + out={} + with tarfile.open(ROOT/ARCHIVE,'r:gz') as tar: + for key,(name,sha) in MEMBERS.items(): + matches=[m for m in tar.getmembers() if m.name==name] + require(len(matches)==1 and matches[0].isfile(),'unique regular archive member') + data=tar.extractfile(matches[0]).read();require(digest(data)==sha,'member drift '+key) + out[key]=json.loads(gzip.decompress(data) if name.endswith('.gz') else data) + return out + +def bits(v): + out=[] + while v: + b=v&-v;out.append(b.bit_length()-1);v-=b + return out + +def apply(cols,x): + value=0 + for i in bits(x):value^=cols[i] + return value + +def route(q,basis,s): + cols=[1<i) + for i in bits(translation):linear[i]=(linear[i]+2)%4 + return tuple(linear),tuple(cross) + +def literal(lines,translation,u): + return (sum(sign*((axis&u).bit_count()%2) for axis,sign in lines) + +2*((translation&u).bit_count()%2))%4 + +def evaluate_signature(sig,u): + linear,cross=sig + return (sum(linear[i] for i in bits(u))+2*sum((cross[i]&u).bit_count()%2 for i in bits(u)))%4 + +def coordinate(lo,hi):return [(1<0 for v in faults.values()),'ineffective phase fault') + # Authenticate the literal direction: exact scalar endpoints, no inherited verifier import. + from fractions import Fraction as Q + scalar_checks={} + for orientation,program in d['programs'].items(): + if orientation not in ('forward','backward'):continue + state={('L',i):{i:Q(1)} for i in range(704)} + for event in program: + if event[0]!='scalar':continue + op=event[1];kind=op[0];dst=tuple(op[1]) + if kind=='clear':state[dst]={} + elif kind=='copy':state[dst]=dict(state[tuple(op[2])]) + elif kind=='scale':state[dst]={i:v*Q(op[2],op[3]) for i,v in state[dst].items() if v*Q(op[2],op[3])} + elif kind=='add': + src=tuple(op[2]);factor=Q(op[3],op[4]);require(dst!=src,'self add') + for i,v in state[src].items(): + value=state[dst].get(i,Q(0))+factor*v + if value:state[dst][i]=value + else:state[dst].pop(i,None) + else:raise ValueError('scalar opcode') + for i in range(704): + want={i:Q(1)} + if orientation=='forward' and 112<=i<224:want[i-112]=Q(1) + if orientation=='backward' and i<112:want[i+112]=Q(-1) + require(state['L',i]==want,'signed local endpoint '+orientation) + require(all(not row for key,row in state.items() if key[0]!='L'),'private scalar exit') + scalar_checks[orientation]={'events':len(program),'ordinary_rows':704,'endpoint':'(D,T+D,h)' if orientation=='forward' else '(D-T,T,h)'} + # Bind all four exact local endpoint labels, using the explicitly credited + # authenticated Clifford equality kernel (this is not a new kernel proof). + kernel_path=ROOT/'research/frontier1094-recipes-exact-seed76/clifford.py' + kernel_raw=kernel_path.read_bytes() + require(digest(kernel_raw)=='d5e42ddabd141b7bfbd70fe13908f3c3a06aeccebeab90623596bfb1988b97fb','kernel drift') + C=types.ModuleType('pinned_boundary_clifford');C.__file__=str(kernel_path) + exec(compile(kernel_raw,str(kernel_path),'exec'),C.__dict__) + word=d['word'];require((word['h'],word['v'],word['R'])==(9,112,480),'word dimensions') + require(list(word['ports'])==[r['q'] for r in p['recipes']],'phase/word normals') + adapters={(r['role'],r['port']):r for r in d['recipes']['endpoint_adapters']} + label_checks=0 + for port,q in enumerate(word['ports']): + before_x=C.canonical_frame(word['frames'][word['start'][port]])+C.adjoint(C.monomial(adapters['source',port]['left'])) + before_y=C.canonical_frame(word['frames'][word['start'][112+port]]) + after_x=C.canonical_frame(word['frames'][word['final'][port]]) + after_y=C.canonical_frame(word['frames'][word['final'][112+port]])+C.adjoint(C.monomial(adapters['target',port]['left'])) + for actual,expected in [(before_x,[('C',q,1)]),(before_y,[]),(after_x,C.fourier(9)),(after_y,[('C',q,-1)]+C.fourier(9))]: + require(C.same_operator(actual,expected),'exact signed local endpoint label') + label_checks+=1 + return {'status':'PASS_SELECTED_NATIVE_BOUNDARY_PHASES','archive_sha256':ARCHIVE_SHA,'members':MEMBERS,'m':M,'ports':112,'stages':9,'exact_boundary_operator_identities':identities,'direct_character_equality_checks_s0_s1':literal_checks,'rejected_fault_instances':faults,'scalar_endpoint_binding':scalar_checks,'exact_local_endpoint_label_comparisons':label_checks,'credited_clifford_kernel_sha256':digest(kernel_raw),'phase_registry_sha256':digest(json.dumps(records,sort_keys=True,separators=(',',':')).encode()),'scope':'Exact Fourier polynomial boundary phases plus scalar sign binding; inherits complete local native common-frame factorization and physical cover/view semantics.'} +if __name__=='__main__': + parser=argparse.ArgumentParser();parser.add_argument('--write',type=Path);args=parser.parse_args() + if args.write and args.write.exists():raise FileExistsError(args.write) + result=check() + if args.write: + with args.write.open('x',encoding='utf-8',newline='\n') as out:out.write(json.dumps(result,indent=2,sort_keys=True)+'\n') + else: + expected=json.loads((HERE/'NATIVE.json').read_bytes()) + require(json.dumps(expected,sort_keys=True)==json.dumps(result,sort_keys=True),'complete native receipt mismatch') + print('PASS_SELECTED_NATIVE_BOUNDARY_PHASES identities=4032 determining_characters=2420992 local_labels=448') diff --git a/research/centre-native-terminal-factor/source.py b/research/centre-native-terminal-factor/source.py new file mode 100644 index 0000000000..4d80dff832 --- /dev/null +++ b/research/centre-native-terminal-factor/source.py @@ -0,0 +1,44 @@ +"""Authenticate retained inputs before decoding/compiling; DLamdata/Codex, Apache-2.0.""" +from pathlib import Path +import gzip, hashlib, io, json, sys, tarfile, types +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +ARCHIVE = 'research/community-frontier1094-audit/selected-replay.tar.gz' + +def need(condition, reason): + if not condition: + raise ValueError(reason) + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + +def load(): + manifest = json.loads((HERE / 'SOURCES.json').read_bytes()) + authenticated = {} + for entry in manifest['files']: + if entry['usage'] != 'input': + continue + raw = (ROOT / entry['path']).read_bytes() + need(digest(raw) == entry['sha256'], 'source SHA256: ' + entry['path']) + blob = hashlib.sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() + need(blob == entry['git_blob'], 'source Git blob: ' + entry['path']) + authenticated[entry['path']] = raw + data = {} + with tarfile.open(fileobj=io.BytesIO(authenticated[ARCHIVE]), mode='r:gz') as archive: + for key, pin in manifest['archive_members'].items(): + matches = [m for m in archive.getmembers() if m.name == pin['path']] + need(len(matches) == 1 and matches[0].isfile(), 'unique regular archive member') + raw = archive.extractfile(matches[0]).read() + need(digest(raw) == pin['sha256'], 'archive member SHA256: ' + key) + data[key] = json.loads(gzip.decompress(raw) if pin['path'].endswith('.gz') else raw) + def module(name, path): + # Compile authenticated source directly; never read a predecessor .pyc. + mod = types.ModuleType(name) + mod.__file__ = str(ROOT / path) + sys.modules[name] = mod + exec(compile(authenticated[path], mod.__file__, 'exec'), mod.__dict__) + return mod + return data, module diff --git a/research/centre-native-terminal-factor/verify.py b/research/centre-native-terminal-factor/verify.py new file mode 100644 index 0000000000..a3c9401b06 --- /dev/null +++ b/research/centre-native-terminal-factor/verify.py @@ -0,0 +1,175 @@ +#!/usr/bin/env python3 +"""Source-bound premises of the native two-ablation kernel inclusion. + +Native recipe checks reuse credited PR2048 code and Sagar Thakrar's kernel; +the extended-label audit is credited to the retained whole-payload audit. +New causal-support argument/check: DLamdata with Codex, Apache-2.0. +""" +from pathlib import Path +import argparse, json, sys +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from source import HERE, canonical, digest, load, need + +def prefix(data): + key = lambda e: (e['time'], e['replica'], e['stage'], e['provider_id']) + callmap = {key(c): c for c in data['template']['calls']} + need(len(callmap) == 144, 'selected call inventory') + events, calls = [], [] + for event in data['template']['execution_schedule']: + events.append(event) + if event['kind'] == 'local_cover_sweep': + call = callmap[key(event)] + calls.append(call) + ow = call['owners'] + need(len(ow) == len({entry[0] for entry in ow}) == 704, 'injective family map') + need(digest(canonical(data['programs'][call['orientation']])) == + call['local_program_sha256'], 'call/program binding') + if call['time'] == 10: + break + need([c['time'] for c in calls] == list(range(11)), 'first eleven chronological calls') + need(Counter(e['kind'] for e in events) == + Counter(local_cover_sweep=11, bridge=4, idle_cover_sweep=4), 'complete prefix inventory') + need([(calls[i]['replica'], calls[i]['stage'], calls[i]['orientation']) for i in (0,4,10)] == + [(0,0,'forward'), (0,1,'backward'), (0,2,'forward')], 'selected f0/b1/f2 binding') + for index, stage in ((0,0), (4,1), (10,2)): + need(calls[index]['owners'][:224] == [[p,[1,stage,p%112]] for p in range(224)], + 'same physical data families and side-equal routes') + return events, calls + +def causal_support(events, calls, forward_cuts, cancellation=True): + """Upper supports of arbitrary native fields, never projected scalar values. + + Only the separately proved F0/B1 signed-gauge cancellation removes support. + Helpers and idle maps retain support; bridges take unions. A coefficient + zero in a common-frame row is a zero native block, including its input map. + """ + live = set(range(112)) + history, helper_occurrences = [], [] + last_input = None + for position, event in enumerate(events): + kind = event['kind'] + if kind == 'local_cover_sweep': + call = calls[event['time']] + owners = [r[0] for r in call['owners']] + source, target, helpers = set(owners[:112]), set(owners[112:224]), set(owners[224:]) + helper_occurrences.append([call['time'], len(live & helpers)]) + if call['time'] == 0: + need(live == source, 'first source-only input') + live |= target + elif call['time'] == 4: + need(live == source | target, 'F0/B1 uninterrupted source response') + need(call['orientation'] == 'backward', 'cancelling orientation') + if cancellation: + live -= source + elif call['time'] == 10: + last_input = [i for i,family in enumerate(owners) if family in live] + need(not [(k,i) for k,row in enumerate(forward_cuts) + for i in last_input if row.get(i,0)], + 'later centre has source-dependent input coefficient') + else: + need(not live & (source | target), 'intervening call has live data') + # Complete local endpoints have no off-diagonal helper blocks. + elif kind == 'bridge': + base = 896*event['replica'] + src, dst = base+224*event['src'], base+224*event['dst'] + need(event['coefficient'] in (-1,1), 'signed bridge') + before = set(live) + for p in range(112): + if src+p in before: + live.add(dst+p) + if dst+112+p in before: + live.add(src+112+p) + elif kind == 'idle_cover_sweep': + # Invertible coordinate factors act within each existing family. + pass + else: + raise ValueError('unknown prefix event') + history.append({'position':position,'kind':kind,'time':event.get('time'), + 'live_families':sorted(live)}) + need(last_input is not None, 'f2 reached') + need(live == set(range(112,224)) | set(range(336,448)), 'complete causal support') + need(len(last_input)==211 and sum(i>=224 for i in last_input)==99, 'live incidence') + return {'prefix_events':len(events),'calls':len(calls),'bridges':4,'idle_sweeps':4, + 'f2_live_roles':last_input,'f2_live_targets':112,'f2_live_helpers':99, + 'zero_cut_coefficients_checked':8*len(last_input), + 'live_helper_occurrences':helper_occurrences,'support_history':history} + +def run(): + data, module = load() + audit = module('credited_extended_label_audit', + 'research/centre-native-observation-dimension/audit.py').audit + native = module('credited_selected_native_checks', + 'research/selected-centre-native-lift/verify.py') + C = module('credited_exact_clifford','research/frontier1094-recipes-exact-seed76/clifford.py') + word, programs = data['word'], data['programs'] + audits = {o:audit(word,programs[o],o) for o in ('forward','backward')} + merged = {'edges':set().union(*(a['edges'] for a in audits.values())), + 'wrapped':set().union(*(a['wrapped'] for a in audits.values()))} + native_receipt, _, adapters = native.check_operators( + word,data['recipes'],data['residuals'],merged,C) + events,calls = prefix(data) + causal = causal_support(events,calls,audits['forward']['cuts']) + pivots = [0,1,2,3,4,5,6,12] + matrix = [[row.get(p,Q(0)) for p in pivots] for row in audits['forward']['cuts']] + inv,det = native.inverse_and_det(matrix) + need(det==32,'credited first-transcript minor') + controls = {} + def rejects(name, action, expected): + try: + action() + except ValueError as error: + need(expected in str(error),'wrong failure '+name+': '+str(error)) + controls[name]=str(error) + else: + raise ValueError('ineffective control: '+name) + rejects('omit_B1_cancellation',lambda:causal_support(events,calls,audits['forward']['cuts'],False), + 'later centre has source-dependent input coefficient') + bad_cuts=deepcopy(audits['forward']['cuts']) + live_helper=next(i for i in causal['f2_live_roles'] if i>=224) + bad_cuts[0][live_helper]=Q(1) + rejects('read_a_live_helper',lambda:causal_support(events,calls,bad_cuts), + 'later centre has source-dependent input coefficient') + rejects('omit_bridges',lambda:causal_support([e for e in events if e['kind']!='bridge'], + calls,audits['forward']['cuts']),'complete causal support') + bad=deepcopy(programs['backward']) + operation=next(e for e in bad if e[0]=='scalar' and e[1][0]=='add') + operation[1][3]*=-1 + rejects('reverse_one_backward_ADD',lambda:audit(word,bad,'backward'),'complete scalar endpoint') + bad=deepcopy(programs['forward']) + event=next(e for e in bad if e[0]=='scalar' and e[1][0]=='add' and e[2]!=0) + event[2]=0 + rejects('wrong_native_common_frame',lambda:audit(word,bad,'forward'),'common frame') + record=deepcopy(adapters['source',0]['left']);record['phase']=(record['phase']+1)%4 + need(not C.same_operator([('C',word['ports'][0],1)]+C.monomial(record), + C.canonical_frame(word['frames'][word['start'][0]])),'global phase fault') + controls['wrong_adapter_global_phase']='full exact operator differs' + return {'status':'PASS_CENTRE_NATIVE_TERMINAL_PREMISES', + 'scientific_base':'a1bfbc677fdcbc2a27a9b3bf6c78cac8fd6da9e2', + 'local_audits':{o:{k:a[k] for k in ('events','scalar_columns','bill','conversions')} + for o,a in audits.items()}, + 'native_operator_checks':native_receipt,'causal_support':causal, + 'first_cut_pivots':pivots,'first_cut_determinant':str(det), + 'first_cut_inverse':[[str(x) for x in row] for row in inv],'controls':controls, + 'scope':'Premises for source-response kernel inclusion through eight full native fields. ' + 'Global view/hosting semantics inherited; boundary phases separately checked. ' + 'No sharp terminal rank, paid decoder, full dirty residual or new kappa.'} + +def main(): + parser=argparse.ArgumentParser();parser.add_argument('--write',type=Path);args=parser.parse_args() + if args.write and args.write.exists(): + raise FileExistsError(args.write) + result=run() + if args.write: + with args.write.open('x',encoding='utf-8',newline='\n') as out: + out.write(json.dumps(result,indent=2,sort_keys=True)+'\n') + else: + expected=json.loads((HERE/'RESULT.json').read_bytes()) + need(canonical(expected)==canonical(result),'complete receipt mismatch') + print('PASS_CENTRE_NATIVE_TERMINAL_PREMISES calls=11 events=19 live_helpers=99 ' + 'native_recipes=2896 factor_fields=8 controls=6 no_new_kappa') + +if __name__=='__main__': + main()