diff --git a/artifacts/meltassist-h2-shared-miss-true-tail-review-2026-11-19/review.json b/artifacts/meltassist-h2-shared-miss-true-tail-review-2026-11-19/review.json new file mode 100644 index 000000000..94f859c81 --- /dev/null +++ b/artifacts/meltassist-h2-shared-miss-true-tail-review-2026-11-19/review.json @@ -0,0 +1,146 @@ +{ + "verdict": "PASS", + "review_scope": "combined preregistration alignment and second-delivery receipts", + "commit": "40f9e4ce5dc2f572296e63ea92d8317fb6234765", + "prereg_commit": "d62b919e95b9f774e3283b503aa699c23f86c104", + "first_pass_sha256": "7029a6e6e13a96c70dfe746c9acfc1e4d7554483ed532328664db130f89864c7", + "output_sha256": { + "execution-contract.json": "e1cb1aca39795a91a6821d9a99474f03d1997d254a91fc04c54598ae3bc63c8b", + "result.json": "d17960b76a517ab7caa4d42dc625433a9e46dbf22918376e3b999c4e325a33fc", + "by-part.jsonl": "5ad31d76899b83249234d892de127921707bc88cdd410c099331bdc88aa88dd0", + "target-access.jsonl": "6b876370ca65d8c022ed1cfd6650a9a58b653f00b9dfe14c74f1273953e000b7" + }, + "logged_test_role_reads": 552, + "unique_target_paths": 552, + "worker_cpu_seconds_reported": 108.968858, + "gpu_seconds_reported": 0, + "review_gpu_seconds": 0, + "peak_gap_available_parts": [ + 7, + 126 + ], + "peak_gap_undefined_draws": 3, + "first_pass_retained": true, + "metrics": { + "late_tail_component_count": { + "effect": -0.6332892639887464, + "interval": [ + -1.8208353782049862, + 0.8416048783524798 + ], + "defined_draws": 2000 + }, + "late_tail_major_component_count": { + "effect": 0.012490876998649147, + "interval": [ + -0.21713923794912235, + 0.29694792310863716 + ], + "defined_draws": 2000 + }, + "late_tail_component_depth": { + "effect": -0.011517223119892214, + "interval": [ + -0.03031041365292009, + 0.005860196035534359 + ], + "defined_draws": 2000 + }, + "late_tail_component_depth_max": { + "effect": -0.013240506155263149, + "interval": [ + -0.032416667566644346, + 0.004446669557345236 + ], + "defined_draws": 2000 + }, + "late_tail_component_depth_mass_coverage": { + "effect": 2.220446049250313e-16, + "interval": [ + 0.0, + 3.3306690738754696e-16 + ], + "defined_draws": 2000 + }, + "near_tie": { + "effect": 0.008530329773853096, + "interval": [ + -0.1462894328528212, + 0.18266800797319258 + ], + "defined_draws": 2000 + }, + "major_component_peak_gap": { + "effect": 0.0010579767673941957, + "interval": [ + -0.0003834745408383054, + 0.003777150877967427 + ], + "defined_draws": 1997 + }, + "L_tail_raw": { + "effect": -24.603945402695572, + "interval": [ + -67.26551031066093, + 14.879149125944844 + ], + "defined_draws": 2000 + }, + "L_tail_over_Rg": { + "effect": -0.3459706867525525, + "interval": [ + -0.858381885776507, + 0.1837576695335972 + ], + "defined_draws": 2000 + }, + "tail_unreachable_mass_fraction": { + "effect": 0.0, + "interval": [ + 0.0, + 0.0 + ], + "defined_draws": 2000 + }, + "L_tail_to_h_g": { + "effect": 5.918973515651231, + "interval": [ + -10.813075649143387, + 23.143737958073928 + ], + "defined_draws": 2000 + }, + "surface_area_raw_squared": { + "effect": 10459.644391839593, + "interval": [ + -10829.687449348967, + 36582.90373494066 + ], + "defined_draws": 2000 + }, + "sqrt_lambda2_over_lambda1": { + "effect": 0.05710513918047988, + "interval": [ + -0.03872110401469038, + 0.1514347293797875 + ], + "defined_draws": 2000 + }, + "sqrt_lambda3_over_lambda1": { + "effect": 0.019991941583703265, + "interval": [ + -0.07354533431634322, + 0.12313356689180666 + ], + "defined_draws": 2000 + }, + "physical_branch_count_and_length": null, + "physical_flow_length_to_wall_thickness": null, + "semantic_family_type": null + }, + "scientific_arrays_opened_by_reviewer": 0, + "limits": [ + "Application-level access logs, not independent operating-system traces.", + "Intervals are descriptive and do not establish equivalence or a causal mechanism." + ] +} diff --git a/artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/contract.json b/artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/contract.json new file mode 100644 index 000000000..d255e8f25 --- /dev/null +++ b/artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/contract.json @@ -0,0 +1,769 @@ +{ + "mode": "measurement", + "ruling": "h-f84547d7", + "retry": false, + "evaluate_other_models": false, + "measurement_allowed_heldout_labels": false, + "gpu_uuid": "GPU-f1c9fd5a-e917-56e0-21fb-24035ba44a36", + "limits": { + "gpu_wall_seconds": 3600, + "cleanup_seconds": 60, + "idle_wait_seconds": 60, + "cpu_seconds": 3500, + "rss_bytes": 12884901888, + "recorded_vram_bytes": 15032385536, + "device_vram_bytes": 16106127360, + "disk_bytes": 2147483648, + "torch_threads": 1, + "max_processes": 1 + }, + "protocol": { + "model": "NeurIPS 2023 supplement SDFFNOGNO decoder", + "seeds": [ + 0, + 1, + 2 + ], + "grid": [ + 64, + 64, + 64 + ], + "modes": [ + 24, + 24, + 24 + ], + "hidden_channels": 32, + "radius": 0.05, + "epochs_per_seed": 100, + "batch_size": 1, + "learning_rate": 0.001, + "bounds_expansion": 0.01, + "pressure_epsilon": 1e-06, + "optimizer": "Adam", + "weight_decay": 0.0001, + "lr_step_epochs": 50, + "lr_gamma": 0.5, + "pressure_training_transform": "scalar Gaussian on the 500 learning cases", + "metric": "per-case L2(predicted minus true decoded pressure) / L2(true decoded pressure)", + "report": "equal mean over 111 cases for each seed, then equal mean over the three seeds", + "acceptance_percent": [ + 6.62, + 7.62 + ], + "paper_reference_percent": 7.12, + "checkpoint_epoch": 100, + "heldout_access_after_all_checkpoints_frozen": true + }, + "environment": { + "python": "/home/frank14f/optane/MeltMind/data/track-b-gino-shapenet611-2026-11-19/runtime/bin/python", + "python_version": "3.10", + "torch_cuda": "11.6", + "neuralop_commit": "fbdc7f872792b75b84545c2f374e7a881c72a718", + "neuralop_file_sha256": { + "utils.py": "84554eed45ac415ab52f79e456eab70ba204e7ab7539c2f2841955a9145220b4", + "models/__init__.py": "c67679f1f8f90e1ab4eb4c2aa916aeaedf1b175d795fed03b8d4f7210883ebae", + "models/tfno.py": "d74b5805b69a64bf33e3ff5186709c75bd431a56c9548f06fb9635a859d849e4", + "models/spectral_convolution.py": "ccecf80806d93e8f35713ac6ab2c3b61c11739f5fcb8c0ba7397b7d4eb5a5d45" + }, + "package_versions": { + "torch": "1.13.1+cu116", + "open3d": "0.17.0", + "numpy": "1.24.3", + "torch-scatter": "2.1.1+pt113cu116", + "torch-sparse": "0.6.17+pt113cu116", + "torch-geometric": "2.3.1", + "tensorly": "0.8.1", + "tensorly-torch": "0.4.0" + } + }, + "comparison_contract": "/home/frank14f/optane/MeltMind/artifacts/track-b-gino-shapenet611-measurement-2026-11-19/comparison-contract.json", + "comparison_contract_sha256": "503f6c8ab1217d66b44e0d127555cfad5da4cd8a17b336299095c3cfd13041d7", + "code_sha256": { + "/home/frank14f/optane/MeltMind/tools/freeze_g1_components.py": "d0cee60d95243ac2c59ef3f2244ba818315718c4e3d1895f2f9f064f1f7f5ecd", + "/home/frank14f/optane/MeltMind/tools/gre24_models.py": "53b6fee8b700b9b982b06d29908ce2ce23e0c57512c46dbf74b2aade79e3ac3a", + "/home/frank14f/optane/MeltMind/tools/phase2_gate_outcome_review.py": "915617aeb8292d03c654e637bc34a014c254fd178a773f135d1806c4b41372a8", + "/home/frank14f/optane/MeltMind/tools/phase2_h1_worker_v2.py": "1543df85b615bb69b79bacd572074a7c77ae19dab110197601573a7e5805ed20", + "/home/frank14f/optane/MeltMind/tools/phase2_home_freeze_io.py": "bf09204b85ed2a7038acdd202257f618474d1110a9d6d772f105a3ffb334d3ff", + "/home/frank14f/optane/MeltMind/tools/phase2_local_freeze_io.py": "60adf3382577613c5234f5cf30779336b9951b66e90c075cb7cd0adab9cc42dd", + "/home/frank14f/optane/MeltMind/tools/phase2_residual_math.py": "ffbd9624dec79bdaabf95244fe87209055908f31a977e73ea4377045d6f8fe62", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_common.py": "4e25effe8326ff8c7c3f751590315040209af054b32b0505dc3c6b001589db32", + "/home/frank14f/optane/MeltMind/tools/phase3_seed1_v2_common.py": "25ca6be14027369393bd3616209b08f30e25892cccca83300483c5a116e8d75d", + "/home/frank14f/optane/MeltMind/tools/phase3_shared_capacity.py": "7c07b0aaf1bc4e6a980d016defcac326c3bd871134d2583bb4dcd88bb34728f8", + "/home/frank14f/optane/MeltMind/tools/prepare_track_b_gino_shapenet.py": "557ad56277d7e85c6b5cc358eb151632d1757f5883f429988d36022d0d407550", + "/home/frank14f/optane/MeltMind/tools/s2_gpu_idle_gate.py": "e2b1613e7e6ea398a8d555220a9365a1ad998ab4ef4b2bf8ec7cc4e31f8b4b9f", + "/home/frank14f/optane/MeltMind/tools/s2_main_memory_guard.py": "e094f5443e11518efe9018215c11718a8e18aa462a977bf43e974b2d0b2aebb1", + "/home/frank14f/optane/MeltMind/tools/s2_pilot_train.py": "e9cceead51a5cc092aad23409ad98909c84a62e7e10571e750d1e9be1ad3b948", + "/home/frank14f/optane/MeltMind/tools/s2_precision_continuation_guard.py": "01235d897c7c03e5ffa109c58b14f5d24d128e8f1ba873e1f76cfb14e02f7a7f", + "/home/frank14f/optane/MeltMind/tools/s2_recovery_gpu_supervisor.py": "689c0f3179e4fcd362e546d90214829a9e4f8739abdbdf74b560763e5a392f15", + "/home/frank14f/optane/MeltMind/tools/s2_recovery_monitoring.py": "442c2a9c75e8c00b30a8f2e91cb52d87c466b19a80aea9128b10c021e61b922e", + "/home/frank14f/optane/MeltMind/tools/track_a_h2_common.py": "79918e7de887d1f0a2de5523156b27d00dc2d85ac930a07efc34d817d904fe65", + "/home/frank14f/optane/MeltMind/tools/track_a_h2_prepare.py": "f657be036dc48fc5936f56c4b8510a4b295d4787af6877cc5ccaad663107be17", + "/home/frank14f/optane/MeltMind/tools/track_b_gino_shapenet_entry.py": "e86d955c36e291e6bbef67947de663b24c8d66c5d72d9d28e4193fb8a3051ee2", + "/home/frank14f/optane/MeltMind/tools/track_b_gino_shapenet_worker.py": "7211be211c29472fd9be35a6bcb1f56025de4a63f36852bfafa10df97c003ff3", + "/home/frank14f/optane/MeltMind/tools/track_b_gino_import_checked_entry.py": "199d833f40339feb0433611ba27302416a280452f8918715e6ef95cb93c38721", + "/home/frank14f/optane/MeltMind/tools/track_b_gino_import_checked_worker.py": "3acf742dd4549e9f5491e10af5bb0b4acf00e2f47e91753100b5998cfcc61852", + "/home/frank14f/optane/MeltMind/tools/prepare_track_b_gino_import_checked.py": "fef485dd0c233c76a336239d5f29cbf44ac0fb62a6a297dff34293b23a1b75fe", + "/home/frank14f/optane/MeltMind/tools/track_b_gino_paper_keyword_patch.py": "c61e2ed7d099eb125386857bf4d7ccdbfc3af522f80edb4f01b450cee91c0b95" + }, + "paper_data": { + "path": "/home/frank14f/optane/MeltMind/data/track-b-gino-shapenet611-2026-11-19/paper-car-pressure-data.zip", + "sha256": "b5f9e2b407d54e034596384253fb58196933c46f6b5b586383508da54475f89d" + }, + "paper_supplement": { + "path": "/home/frank14f/optane/MeltMind/data/track-b-gino-shapenet611-2026-11-19/paper-neurips-supplement.zip", + "sha256": "48cdae80ac2781e27ac00e10a37124711d6bb305593559002bda0527d11a533d" + }, + "paper_code_zip_sha256": "347a6f097e2b9958d1ab87930fa1d6227b793a9d213e12418ce9a157e83dce04", + "split_receipt": { + "path": "/home/frank14f/optane/MeltMind/artifacts/track-b-gino-shapenet611-2026-11-19/paper-split.json", + "sha256": "5a96c25c2ec24cfc1e2264d4ebd0879c658c0f168e22711b576bf303151b8601" + }, + "mapping_audit": { + "path": "/home/frank14f/optane/MeltMind/artifacts/track-b-gino-shapenet611-2026-11-19/paper-mapping-audit.json", + "sha256": "055d008a02494acd29df36c41c8e68db931a027f5635e8f5f765a96a54c62289" + }, + "split": { + "train": [ + 1, + 2, + 4, + 5, + 6, + 7, + 8, + 10, + 12, + 13, + 17, + 18, + 21, + 22, + 23, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 34, + 35, + 39, + 40, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 54, + 55, + 56, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 67, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 83, + 84, + 85, + 86, + 87, + 88, + 90, + 91, + 92, + 94, + 95, + 96, + 97, + 100, + 101, + 102, + 105, + 106, + 107, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 133, + 134, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 165, + 166, + 170, + 172, + 173, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 186, + 190, + 191, + 192, + 193, + 195, + 196, + 198, + 199, + 200, + 201, + 202, + 203, + 205, + 207, + 210, + 211, + 212, + 213, + 214, + 215, + 217, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 241, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 251, + 252, + 253, + 255, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 264, + 266, + 267, + 268, + 269, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 285, + 286, + 289, + 290, + 291, + 292, + 293, + 294, + 295, + 296, + 297, + 298, + 299, + 300, + 301, + 302, + 304, + 305, + 306, + 308, + 309, + 310, + 311, + 312, + 313, + 314, + 315, + 319, + 320, + 321, + 322, + 323, + 324, + 325, + 327, + 328, + 329, + 331, + 332, + 333, + 334, + 335, + 337, + 338, + 339, + 340, + 341, + 344, + 345, + 347, + 348, + 349, + 350, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 360, + 362, + 364, + 365, + 366, + 367, + 369, + 371, + 372, + 373, + 374, + 375, + 376, + 378, + 379, + 380, + 381, + 384, + 385, + 389, + 392, + 393, + 397, + 398, + 399, + 401, + 402, + 403, + 404, + 405, + 407, + 408, + 410, + 412, + 413, + 414, + 415, + 417, + 418, + 419, + 420, + 422, + 424, + 425, + 427, + 430, + 431, + 433, + 435, + 436, + 437, + 439, + 440, + 443, + 444, + 446, + 447, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 459, + 460, + 462, + 463, + 464, + 465, + 466, + 467, + 468, + 469, + 470, + 472, + 473, + 474, + 475, + 476, + 478, + 479, + 480, + 482, + 483, + 486, + 487, + 488, + 490, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 501, + 502, + 503, + 504, + 505, + 507, + 508, + 509, + 511, + 512, + 513, + 514, + 515, + 516, + 518, + 519, + 521, + 522, + 523, + 524, + 525, + 527, + 529, + 530, + 532, + 533, + 536, + 538, + 539, + 540, + 542, + 543, + 545, + 547, + 548, + 549, + 550, + 551, + 552, + 553, + 554, + 555, + 560, + 561, + 562, + 564, + 565, + 566, + 567, + 568, + 569, + 572, + 573, + 574, + 576, + 577, + 579, + 581, + 582, + 583, + 584, + 587, + 588, + 589, + 591, + 593, + 594, + 595, + 596, + 597, + 598, + 600, + 602, + 604, + 608, + 610, + 611, + 612, + 613, + 615, + 616, + 617, + 618, + 620, + 621, + 622, + 623, + 625, + 626, + 627, + 628, + 629, + 630, + 631, + 632, + 633, + 634, + 635, + 636, + 638, + 639, + 640, + 641, + 642, + 643, + 644, + 645, + 646, + 647, + 648, + 649, + 651, + 652, + 654, + 655, + 656, + 657 + ], + "test": [ + 658, + 659, + 660, + 662, + 663, + 664, + 665, + 666, + 667, + 668, + 672, + 673, + 674, + 675, + 676, + 677, + 678, + 679, + 681, + 683, + 684, + 686, + 687, + 688, + 689, + 690, + 691, + 692, + 693, + 695, + 696, + 697, + 700, + 701, + 702, + 703, + 704, + 705, + 708, + 709, + 710, + 711, + 712, + 713, + 715, + 717, + 718, + 719, + 721, + 722, + 723, + 724, + 725, + 726, + 727, + 729, + 730, + 731, + 733, + 734, + 735, + 736, + 737, + 738, + 739, + 740, + 741, + 743, + 744, + 745, + 746, + 747, + 748, + 749, + 750, + 751, + 752, + 753, + 757, + 758, + 760, + 762, + 763, + 764, + 765, + 766, + 767, + 768, + 769, + 770, + 771, + 772, + 773, + 775, + 776, + 777, + 778, + 779, + 781, + 782, + 783, + 784, + 785, + 787, + 789, + 790, + 791, + 792, + 793, + 795, + 797 + ], + "raw_global_bounds": [ + [ + -0.90252799, + 0.0066688, + -2.85272002 + ], + [ + 0.90253001, + 1.95825005, + 2.86385012 + ] + ] + }, + "environment_ruling": "h-0d21f3bd", + "environment_acceptance": { + "path": "/home/frank14f/optane/MeltMind/artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/cpu-environment-acceptance.json", + "sha256": "093e646890929af6f520eb5eecf8c751025c0a24b8b5689094b1a0ae4da08dc3" + }, + "paper_compatibility": { + "handoff": "h-b8508140", + "identity": "supplement code + 2-keyword patch", + "patch_path": "/home/frank14f/optane/MeltMind/artifacts/track-b-paper-keyword-compatibility-2026-11-19/two-keyword-patch.json", + "patch_sha256": "7307ba49f83bfc46c5decf803a993a41ed602d987de65714958e738d2f52f077", + "search_path": "/home/frank14f/optane/MeltMind/artifacts/track-b-paper-keyword-compatibility-2026-11-19/keyword-search.json", + "search_sha256": "77a897bf534a9a0e9e6a7c072b4f914168648eadc2af3493b70d63d0b715b3d0" + } +} diff --git a/artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/cpu-environment-acceptance.json b/artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/cpu-environment-acceptance.json new file mode 100644 index 000000000..855597d94 --- /dev/null +++ b/artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/cpu-environment-acceptance.json @@ -0,0 +1,577 @@ +{ + "status": "PASS", + "environment_ruling": "h-0d21f3bd", + "original_contract_sha256": "139fec49b7e4627b55ad12f3a129bec75ecc2446811c23a24f376dae207094aa", + "comparison_contract_sha256": "503f6c8ab1217d66b44e0d127555cfad5da4cd8a17b336299095c3cfd13041d7", + "interpreter_path": "/home/frank14f/optane/MeltMind/data/track-b-gino-shapenet611-2026-11-19/runtime/bin/python", + "interpreter_resolved_path": "/home/frank14f/anaconda3/envs/pycuda_3_10/bin/python3.10", + "interpreter_sha256": "cd4a09f01b941a4de48669ffe81e055d001c79b44409ddb14781f437b8ec3f45", + "pyvenv_cfg_sha256": "72e12f7677894067dff4da25bf6cb6b3ae6ab32a56ba4cc4b90ba5aa671494cb", + "package_versions": { + "torch": "1.13.1+cu116", + "open3d": "0.17.0", + "numpy": "1.24.3", + "torch-scatter": "2.1.1+pt113cu116", + "torch-sparse": "0.6.17+pt113cu116", + "torch-geometric": "2.3.1", + "tensorly": "0.8.1", + "tensorly-torch": "0.4.0" + }, + "neuralop_commit": "fbdc7f872792b75b84545c2f374e7a881c72a718", + "installed_distributions": [ + [ + "ConfigArgParse", + "1.10.1" + ], + [ + "Flask", + "2.2.5" + ], + [ + "GitPython", + "3.2.1" + ], + [ + "Jinja2", + "3.1.6" + ], + [ + "Markdown", + "3.10.3" + ], + [ + "MarkupSafe", + "3.0.4" + ], + [ + "PyYAML", + "6.0.3" + ], + [ + "Pygments", + "2.21.0" + ], + [ + "Werkzeug", + "2.2.3" + ], + [ + "absl-py", + "2.5.1" + ], + [ + "addict", + "2.4.0" + ], + [ + "ansi2html", + "1.9.5" + ], + [ + "appdirs", + "1.4.4" + ], + [ + "asciitree", + "1.0.0" + ], + [ + "asttokens", + "3.0.2" + ], + [ + "attrs", + "26.1.0" + ], + [ + "certifi", + "2026.10.23" + ], + [ + "cffi", + "2.1.1" + ], + [ + "charset-normalizer", + "3.5.2" + ], + [ + "click", + "8.5.1" + ], + [ + "cloudpickle", + "3.1.3" + ], + [ + "comm", + "0.2.3" + ], + [ + "configmypy", + "0.2.0" + ], + [ + "contourpy", + "1.3.2" + ], + [ + "cryptography", + "50.0.2" + ], + [ + "cycler", + "0.12.1" + ], + [ + "dash", + "2.11.1" + ], + [ + "dash-core-components", + "2.0.0" + ], + [ + "dash-html-components", + "2.0.0" + ], + [ + "dash-table", + "5.0.0" + ], + [ + "decorator", + "5.3.1" + ], + [ + "docker-pycreds", + "0.4.0" + ], + [ + "entrypoints", + "0.4.2" + ], + [ + "exceptiongroup", + "1.3.1" + ], + [ + "executing", + "2.3.0" + ], + [ + "fasteners", + "0.20" + ], + [ + "fastjsonschema", + "2.22.3" + ], + [ + "fonttools", + "4.65.0" + ], + [ + "gitdb", + "4.0.12" + ], + [ + "google-auth", + "2.62.2" + ], + [ + "google-auth-oauthlib", + "1.0.0" + ], + [ + "grpcio", + "1.60.2" + ], + [ + "h5py", + "3.8.0" + ], + [ + "idna", + "3.20" + ], + [ + "iniconfig", + "2.3.1" + ], + [ + "ipython", + "8.39.0" + ], + [ + "ipywidgets", + "8.1.9" + ], + [ + "itsdangerous", + "2.2.0" + ], + [ + "jedi", + "0.20.1" + ], + [ + "joblib", + "1.6.0" + ], + [ + "jsonschema", + "4.26.0" + ], + [ + "jsonschema-specifications", + "2025.9.1" + ], + [ + "jupyter_core", + "5.9.1" + ], + [ + "jupyterlab_widgets", + "3.0.17" + ], + [ + "kiwisolver", + "1.5.1" + ], + [ + "markdown-it-py", + "4.3.0" + ], + [ + "matplotlib", + "3.9.4" + ], + [ + "matplotlib-inline", + "0.2.2" + ], + [ + "mdurl", + "0.1.2" + ], + [ + "meshio", + "5.3.5" + ], + [ + "narwhals", + "2.29.0" + ], + [ + "nbformat", + "5.7.0" + ], + [ + "nest-asyncio", + "1.6.0" + ], + [ + "neuraloperator", + "0.2.1" + ], + [ + "nose", + "1.3.7" + ], + [ + "numcodecs", + "0.11.0" + ], + [ + "numpy", + "1.24.3" + ], + [ + "oauthlib", + "4.0.1" + ], + [ + "open3d", + "0.17.0" + ], + [ + "opt_einsum", + "3.4.0" + ], + [ + "packaging", + "26.3" + ], + [ + "pandas", + "2.2.3" + ], + [ + "parso", + "0.8.7" + ], + [ + "pathtools", + "0.1.2" + ], + [ + "pexpect", + "4.9.0" + ], + [ + "pillow", + "12.3.0" + ], + [ + "pip", + "23.0.1" + ], + [ + "platformdirs", + "4.12.4" + ], + [ + "plotly", + "6.1.2" + ], + [ + "pluggy", + "1.7.0" + ], + [ + "prompt_toolkit", + "3.0.53" + ], + [ + "protobuf", + "4.25.9" + ], + [ + "psutil", + "7.2.2" + ], + [ + "ptyprocess", + "0.7.0" + ], + [ + "pure_eval", + "0.2.4" + ], + [ + "pyasn1", + "0.6.5" + ], + [ + "pyasn1_modules", + "0.4.2" + ], + [ + "pycparser", + "3.11" + ], + [ + "pyparsing", + "3.3.3" + ], + [ + "pyquaternion", + "0.9.9" + ], + [ + "pytest", + "9.2.0" + ], + [ + "pytest-mock", + "3.17.0" + ], + [ + "python-dateutil", + "3.0.0" + ], + [ + "pytz", + "2026.6" + ], + [ + "referencing", + "0.37.0" + ], + [ + "requests", + "2.34.2" + ], + [ + "requests-oauthlib", + "2.0.0" + ], + [ + "retrying", + "1.4.2" + ], + [ + "rich", + "15.0.0" + ], + [ + "rpds-py", + "0.30.0" + ], + [ + "ruamel.yaml", + "0.19.1" + ], + [ + "scikit-learn", + "1.5.2" + ], + [ + "scipy", + "1.15.3" + ], + [ + "sentry-sdk", + "2.75.0" + ], + [ + "setproctitle", + "1.3.8" + ], + [ + "setuptools", + "65.5.0" + ], + [ + "six", + "1.17.0" + ], + [ + "smmap", + "5.0.3" + ], + [ + "stack-data", + "0.6.3" + ], + [ + "tensorboard", + "2.12.3" + ], + [ + "tensorboard-data-server", + "0.7.2" + ], + [ + "tensorly", + "0.8.1" + ], + [ + "tensorly-torch", + "0.4.0" + ], + [ + "threadpoolctl", + "3.8.0" + ], + [ + "tomli", + "2.5.0" + ], + [ + "torch", + "1.13.1+cu116" + ], + [ + "torch-scatter", + "2.1.1+pt113cu116" + ], + [ + "torch-sparse", + "0.6.17+pt113cu116" + ], + [ + "torch_geometric", + "2.3.1" + ], + [ + "torchtyping", + "0.1.5" + ], + [ + "torchvision", + "0.14.1+cu116" + ], + [ + "tqdm", + "4.70.1" + ], + [ + "traitlets", + "5.16.1" + ], + [ + "typeguard", + "2.13.3" + ], + [ + "typing_extensions", + "4.16.0" + ], + [ + "tzdata", + "2026.6" + ], + [ + "urllib3", + "2.8.0" + ], + [ + "wandb", + "0.15.3" + ], + [ + "wcwidth", + "0.9.4" + ], + [ + "wheel", + "0.45.1" + ], + [ + "widgetsnbextension", + "4.0.16" + ], + [ + "zarr", + "2.16.1" + ] + ], + "torch_cuda_build": "11.6", + "cuda_visible_devices": "", + "scientific_training": false, + "paper_compatibility": { + "handoff": "h-b8508140", + "identity": "supplement code + 2-keyword patch", + "patch_path": "/home/frank14f/optane/MeltMind/artifacts/track-b-paper-keyword-compatibility-2026-11-19/two-keyword-patch.json", + "patch_sha256": "7307ba49f83bfc46c5decf803a993a41ed602d987de65714958e738d2f52f077", + "search_path": "/home/frank14f/optane/MeltMind/artifacts/track-b-paper-keyword-compatibility-2026-11-19/keyword-search.json", + "search_sha256": "77a897bf534a9a0e9e6a7c072b4f914168648eadc2af3493b70d63d0b715b3d0" + }, + "patched_decoder_file_sha256": "764ffb67c302337cb7b98cff166357127033ef84bd4230ca002706ac5e5246b5", + "paper_decoder_cpu_forward": true, + "paper_loader_learning_only": true, + "paper_metric_cpu": true, + "audited_learning_cases": [ + 1 + ], + "heldout_target_reads": 0, + "full_decoder_cpu_parameters": 23413729, + "synthetic_decoder_output_shape": [ + 1, + 1, + 3 + ], + "cpu_metric": 0.6000000238418579 +} diff --git a/artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/environment-prerequisite-cpu-replay.json b/artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/environment-prerequisite-cpu-replay.json new file mode 100644 index 000000000..30ed094da --- /dev/null +++ b/artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/environment-prerequisite-cpu-replay.json @@ -0,0 +1,30 @@ +{ + "status": "PASS", + "actual_contract_sha256": "ab97357150578ea649140a5be01ed5639edcd998874d3788dc9bf8a42acac28e", + "cpu_receipt_sha256": "093e646890929af6f520eb5eecf8c751025c0a24b8b5689094b1a0ae4da08dc3", + "cases": { + "missing": { + "error": "[Errno 2] No such file or directory: '/tmp/track-b-runtime-gate-o0x445jw/absent.json'", + "passed_to_review": 0 + }, + "bad_receipt_sha": { + "error": "Pinned file mismatch: /home/frank14f/optane/MeltMind/artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/cpu-environment-acceptance.json", + "passed_to_review": 0 + }, + "bad_interpreter_path": { + "error": "Matching CPU acceptance and isolated interpreter are required", + "passed_to_review": 0 + }, + "bad_interpreter_sha": { + "error": "Matching CPU acceptance and isolated interpreter are required", + "passed_to_review": 0 + }, + "accepted_receipt_before_review": { + "error": "Independent review absent", + "passed_to_review": 1 + } + }, + "real_gpu_queries": 0, + "real_workers": 0, + "started_records_written": 0 +} diff --git a/artifacts/track-b-paper-keyword-compatibility-2026-11-19/cpu-accept.log b/artifacts/track-b-paper-keyword-compatibility-2026-11-19/cpu-accept.log new file mode 100644 index 000000000..822402a65 --- /dev/null +++ b/artifacts/track-b-paper-keyword-compatibility-2026-11-19/cpu-accept.log @@ -0,0 +1,4 @@ +/home/frank14f/.config/matplotlib is not a writable directory +Matplotlib created a temporary cache directory at /tmp/matplotlib-r2_82jcl because there was an issue with the default path (/home/frank14f/.config/matplotlib); it is highly recommended to set the MPLCONFIGDIR environment variable to a writable directory, in particular to speed up the import of Matplotlib and to better support multiprocessing. +Padding inputs of resolution=torch.Size([8, 8, 8]) with padding=[1, 1, 1], one-sided +PASS 093e646890929af6f520eb5eecf8c751025c0a24b8b5689094b1a0ae4da08dc3 diff --git a/artifacts/track-b-paper-keyword-compatibility-2026-11-19/keyword-search.json b/artifacts/track-b-paper-keyword-compatibility-2026-11-19/keyword-search.json new file mode 100644 index 000000000..99c47ec31 --- /dev/null +++ b/artifacts/track-b-paper-keyword-compatibility-2026-11-19/keyword-search.json @@ -0,0 +1,64 @@ +{ + "status": "NO_ALTERNATE_INTERFACE", + "handoff": "h-b8508140", + "nested_archive_sha256": "347a6f097e2b9958d1ab87930fa1d6227b793a9d213e12418ce9a157e83dce04", + "outer_file_search": [ + { + "member": "GINO-supp/.DS_Store", + "occurrences": 0 + }, + { + "member": "GINO-supp/GINO-supp.pdf", + "occurrences": 0 + } + ], + "nested_non_mac_members_scanned": 51, + "python_members_parsed": 29, + "accepting_function_signatures": [], + "keyword_matches": [ + { + "member": "GINO-submission/src/networks/SDFFNOGNO.py", + "line": 196, + "text": "inp_features=grid_sdf, outp_features=vert_sdf, neighbors=neighbors" + }, + { + "member": "GINO-submission/src/networks/neighbor_ops.py", + "line": 37, + "text": "inp_features: [N,C]" + }, + { + "member": "GINO-submission/src/networks/neighbor_ops.py", + "line": 66, + "text": "inp_features: [N,C]" + }, + { + "member": "GINO-submission/src/networks/neighbor_ops.py", + "line": 67, + "text": "outp_features: [M,C]" + }, + { + "member": "GINO-submission/src/networks/neighbor_ops.py", + "line": 156, + "text": "inp_features: [N,C]" + }, + { + "member": "GINO-submission/src/networks/neighbor_ops.py", + "line": 157, + "text": "outp_features: [M,C]" + }, + { + "member": "GINO-submission/src/networks/neighbor_ops.py", + "line": 189, + "text": "inp_features = torch.randn([self.N, 8]).to(self.device)" + }, + { + "member": "GINO-submission/src/networks/neighbor_ops.py", + "line": 194, + "text": "out_features = pool(inp_features, neighbors)" + } + ], + "neuraloperator_commit": "fbdc7f872792b75b84545c2f374e7a881c72a718", + "neuraloperator_git_grep_exit": 1, + "neuraloperator_matches": [], + "interpretation": "One caller, five documentation lines and two test-local uses. No alternative receiving signature or kwargs implementation." +} diff --git a/artifacts/track-b-paper-keyword-compatibility-2026-11-19/two-keyword-patch.json b/artifacts/track-b-paper-keyword-compatibility-2026-11-19/two-keyword-patch.json new file mode 100644 index 000000000..ec0a87aba --- /dev/null +++ b/artifacts/track-b-paper-keyword-compatibility-2026-11-19/two-keyword-patch.json @@ -0,0 +1,20 @@ +{ + "handoff": "h-b8508140", + "citation": "1795070737.734989", + "identity": "supplement code + 2-keyword patch", + "nested_archive_sha256": "347a6f097e2b9958d1ab87930fa1d6227b793a9d213e12418ce9a157e83dce04", + "target": "src/networks/SDFFNOGNO.py", + "original_file_sha256": "1de585ec85bab7d6bd872b91b363ebedfb0af1c3264f392e6b38a7a70a15d7e4", + "patched_file_sha256": "764ffb67c302337cb7b98cff166357127033ef84bd4230ca002706ac5e5246b5", + "neighbor_ops_file_sha256": "cb0f2a4c449def344cecec0d933228a68ab705df819366c9fcf603ef101b2273", + "changes": [ + [ + "inp_features=grid_sdf", + "in_features=grid_sdf" + ], + [ + "outp_features=vert_sdf", + "out_features=vert_sdf" + ] + ] +} diff --git a/docs/track-b-gino-isolated-cpu-acceptance-2026-11-19.md b/docs/track-b-gino-isolated-cpu-acceptance-2026-11-19.md new file mode 100644 index 000000000..8b4d3ad80 --- /dev/null +++ b/docs/track-b-gino-isolated-cpu-acceptance-2026-11-19.md @@ -0,0 +1,15 @@ +# Track B|GINO 隔离环境 CPU 验收 + +**隔离环境通过实际 CPU 验收,复现身份为 “supplement code + 2-keyword patch”。** 原附包未改。依赖以项目 venv 的实际解释器安装,系统包保持原样。Torch 1.13.1+cu116、Open3D 0.17.0 和论文所用 NeuralOperator VCS 提交均已核对。`pip check` 通过,验收 CPU 进程显式隐藏 CUDA。 [原测量协议](track-b-gino-shapenet611-entry-2026-11-19.md) + +原实现真实前向到达邻域卷积时,调用者传入 `inp_features`、`outp_features`,原邻域层定义只接收 `in_features`、`out_features`,返回 TypeError。依 Claude h-b8508140,在原完整补充包(PDF 和嵌套代码)、29 个 Python 成员的语法树与固定 NeuralOperator 树搜索。附件的八处匹配是该调用、五处注释行和两处测试局部用法。未定位接收旧名的变体。只在校验后的临时解包中更正这两个关键字,并核对补丁后文件 SHA-256。测量和验收使用同一临时适配。 [原失败](../artifacts/track-b-paper-interface-blocked-2026-11-19/failure.json) · [Claude 裁决](https://arcticnimbus.slack.com/archives/C0C78UFKGRM/p1795070737734989) · [搜索审计](../artifacts/track-b-paper-keyword-compatibility-2026-11-19/keyword-search.json) · [精确补丁](../artifacts/track-b-paper-keyword-compatibility-2026-11-19/two-keyword-patch.json) + +| 实际检查 | 结果 | +| --- | --- | +| 原加载器 | 学习件 1 的 PLY、压力文件与保留压力向量按原映射核验。3,586 个保留节点,2³ SDF 可计算。 | +| 原配置 decoder | 64³ 论文配置 CPU 实例化,23,413,729 参数。 | +| CPU 前向 | 8³ 合成输入走原 FFT、邻居查找和卷积,输出形状 `[1, 1, 3]` 且全有限。 | +| 解码后相对 L2 | 原论文指标和入口公式在同一合成断言一致,为 `0.6000000238`。 | +| 启动前置 | 回执缺失、SHA 错误、解释器路径或 SHA 错误均在独立评审及 `started.json` 前拒绝。正确回执进入独立评审检查,尚未派发。 | + +原合同仅增环境、论文兼容补丁和实现哈希绑定。训练/独立评分 500/111、测量 3,600 GPU-s 帽、GPU1、100 轮三种子比较协议和 6.62%–7.62% 接受区间都沿用原值。111 个留出压力目标读入 0,GPU 用量 0,测量工人 0。若后续结果未达区间,原补充包和论文实际运行版本可能有差异,保留为候选解释。MeltAssist 本轮窄审搜索、补丁与 CPU 证据,GPU1 现有 1b 独占。 [真实 CPU 回执](../artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/cpu-environment-acceptance.json) · [启动前置回执](../artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/environment-prerequisite-cpu-replay.json) · [新合同](../artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/contract.json) diff --git a/tools/prepare_track_b_gino_import_checked.py b/tools/prepare_track_b_gino_import_checked.py new file mode 100644 index 000000000..5ba2dcf54 --- /dev/null +++ b/tools/prepare_track_b_gino_import_checked.py @@ -0,0 +1,194 @@ +"""CPU accept the pinned paper environment, then bind the measurement prerequisite.""" + +import argparse +from copy import deepcopy +import hashlib +from importlib import metadata +from pathlib import Path +import os +import sys +from tempfile import TemporaryDirectory +from unittest.mock import patch +from zipfile import ZipFile + +import track_b_gino_import_checked_entry as entry +import track_b_gino_paper_keyword_patch as compatibility +import track_b_gino_shapenet_entry as legacy +from track_b_gino_shapenet_worker import paper_model, test_environment + + +BASE_CONTRACT = legacy.MEASUREMENT_ROOT / "contract.json" +ACCEPTANCE = entry.ROOT / "cpu-environment-acceptance.json" + + +def accept(): + if os.environ.get("CUDA_VISIBLE_DEVICES") != "": + raise PermissionError("The acceptance interpreter must have an empty CUDA mask") + c = legacy.contract(legacy.checked(BASE_CONTRACT, entry.ORIGINAL_CONTRACT)) + c["paper_compatibility"] = compatibility.patch_binding() + patch = compatibility.patch_identity(c) + python = Path(sys.executable).absolute() + prefix = python.parent.parent + if str(python) != c["environment"]["python"] or Path(sys.prefix).absolute() != prefix: + raise PermissionError("Use the exact isolated interpreter in the measurement contract") + cfg = prefix / "pyvenv.cfg" + if "include-system-site-packages = false" not in cfg.read_text(): + raise PermissionError("System Python packages must be excluded") + test_environment(c) + + import numpy as np + import torch + + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.manual_seed(0) + learning_case = c["split"]["train"][0] + if learning_case in c["split"]["test"]: + raise PermissionError("Acceptance must only open a learning case") + audit = legacy.read(c["mapping_audit"]["path"]) + row = next(r for r in audit["rows"] if r["case"] == learning_case) + if row["split"] != "train": + raise PermissionError("Source audit must identify the same learning role") + + with TemporaryDirectory(prefix="track-b-paper-import-") as temporary: + root = Path(temporary) + compatibility.extract_patched_paper_code(c, root) + from neuralop.utils import UnitGaussianNormalizer + from src.data.cfd_datamodule import CFDSDFDataModule + from src.losses import LpLoss + + # Exercise the original loader on exactly one audited learning case. + local = root / "data" + local.mkdir() + with ZipFile(c["paper_data"]["path"]) as archive: + for field, name in (("mesh", f"mesh_{learning_case:03d}.ply"), + ("pressure", f"press_{learning_case:03d}.npy")): + payload = archive.read(f"car-pressure-data/data/{name}") + if hashlib.sha256(payload).hexdigest() != row[field + "_sha256"]: + raise ValueError("Learning file differs from the paper mapping audit") + (local / name).write_bytes(payload) + loader = object.__new__(CFDSDFDataModule) + pressure = loader.load_pressure(root, learning_case) + mesh_path = local / f"mesh_{learning_case:03d}.ply" + axis = [np.linspace(a, b, 2) for a, b in zip(*c["split"]["raw_global_bounds"])] + grid = np.stack(np.meshgrid(*axis, indexing="ij"), axis=-1).astype(np.float32) + sdf, vertices, _ = loader.sdf_vertices_closest_from_mesh(mesh_path, grid, False) + if (pressure.shape != (3586,) or vertices.shape != (3586, 3) or sdf.shape != (2, 2, 2) + or not np.isfinite(sdf).all() + or hashlib.sha256(np.asarray(pressure, dtype=" 1e-6 or abs(entry_metric - original_metric) > 1e-6: + raise ValueError("Decoded relative L2 differs from the original paper metric") + + entry.ROOT.mkdir(exist_ok=True) + if ACCEPTANCE.exists(): + raise FileExistsError("The acceptance receipt is immutable") + receipt = dict( + status="PASS", environment_ruling="h-0d21f3bd", + original_contract_sha256=entry.ORIGINAL_CONTRACT, + comparison_contract_sha256=c["comparison_contract_sha256"], + interpreter_path=str(python), interpreter_resolved_path=str(python.resolve(strict=True)), + interpreter_sha256=legacy.sha(python), pyvenv_cfg_sha256=legacy.sha(cfg), + package_versions=c["environment"]["package_versions"], neuralop_commit=c["environment"]["neuralop_commit"], + installed_distributions=sorted((d.metadata["Name"], d.version) for d in metadata.distributions()), + torch_cuda_build=torch.version.cuda, cuda_visible_devices="", scientific_training=False, + paper_compatibility=c["paper_compatibility"], patched_decoder_file_sha256=patch["patched_file_sha256"], + paper_decoder_cpu_forward=True, paper_loader_learning_only=True, paper_metric_cpu=True, + audited_learning_cases=[learning_case], heldout_target_reads=0, + full_decoder_cpu_parameters=parameters, synthetic_decoder_output_shape=list(output.shape), + cpu_metric=entry_metric) + legacy.save(ACCEPTANCE, receipt) + print(f"PASS {legacy.sha(ACCEPTANCE)}") + + +def gate_replay(path): + c = entry.contract(path) + receipt = entry.accepted_environment(c) + outcomes = {} + for case in ("missing", "bad_receipt_sha", "bad_interpreter_path", "bad_interpreter_sha", + "accepted_receipt_before_review"): + with TemporaryDirectory(prefix="track-b-runtime-gate-") as directory: + temp = Path(directory) + probe = deepcopy(c) + if case == "missing": + probe["environment_acceptance"]["path"] = str(temp / "absent.json") + elif case == "bad_receipt_sha": + probe["environment_acceptance"]["sha256"] = "0" * 64 + elif case in ("bad_interpreter_path", "bad_interpreter_sha"): + fake = temp / "wrong-interpreter.json" + field, value = (("interpreter_path", str(temp / "unaccepted-python")) + if case == "bad_interpreter_path" else ("interpreter_sha256", "0" * 64)) + legacy.save(fake, dict(receipt, **{field: value})) + probe["environment_acceptance"] = dict(path=str(fake), sha256=legacy.sha(fake)) + legacy.save(temp / "contract.json", probe) + with (patch.object(entry, "ROOT", temp), + patch.object(legacy, "validate_review", side_effect=PermissionError("Independent review absent")) as review, + patch.object(entry, "dispatch_guard", side_effect=AssertionError("Can't dispatch without prerequisites")) as dispatch): + try: + entry.run(temp) + except (FileNotFoundError, PermissionError, ValueError) as exc: + outcomes[case] = dict(error=str(exc), passed_to_review=review.call_count) + else: + raise AssertionError(f"Expected the entry to stop: {case}") + if dispatch.call_count or (temp / "started.json").exists(): + raise AssertionError("Unverified environment consumed the sole attempt") + if review.call_count != (1 if case == "accepted_receipt_before_review" else 0): + raise AssertionError("CPU acceptance must precede runtime review and start") + return dict(status="PASS", actual_contract_sha256=legacy.sha(path), + cpu_receipt_sha256=c["environment_acceptance"]["sha256"], cases=outcomes, + real_gpu_queries=0, real_workers=0, started_records_written=0) + + +def bind(): + if not ACCEPTANCE.is_file(): + raise FileNotFoundError("Actual isolated CPU acceptance must finish first") + old = legacy.contract(legacy.checked(BASE_CONTRACT, entry.ORIGINAL_CONTRACT)) + new = deepcopy(old) + new["environment_ruling"] = "h-0d21f3bd" + new["environment_acceptance"] = dict(path=str(ACCEPTANCE), sha256=legacy.sha(ACCEPTANCE)) + new["paper_compatibility"] = compatibility.patch_binding() + for p in (entry.__file__, entry.WORKER, __file__, compatibility.__file__): + new["code_sha256"][str(Path(p).resolve())] = legacy.sha(p) + entry.accepted_environment(new) + path = entry.ROOT / "contract.json" + if path.exists(): + raise FileExistsError("Contract is already frozen") + legacy.save(path, new) + proof = gate_replay(path) + legacy.save(entry.ROOT / "environment-prerequisite-cpu-replay.json", proof) + print(proof) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("mode", choices=("accept", "bind")) + args = parser.parse_args() + {"accept": accept, "bind": bind}[args.mode]() diff --git a/tools/track_b_gino_import_checked_entry.py b/tools/track_b_gino_import_checked_entry.py new file mode 100644 index 000000000..c0108f391 --- /dev/null +++ b/tools/track_b_gino_import_checked_entry.py @@ -0,0 +1,113 @@ +"""Add the reviewed CPU acceptance prerequisite to the fixed measurement entry.""" + +import argparse +import fcntl +from pathlib import Path +import os +import signal +from types import FunctionType + +import track_b_gino_shapenet_entry as legacy +from track_b_gino_paper_keyword_patch import patch_identity +from track_b_gino_shapenet_entry import checked, read, save, sha, process_identity + + +ROOT = legacy.MEASUREMENT_ROOT.with_name("track-b-gino-shapenet611-import-checked-2026-11-19") +ORIGINAL_CONTRACT = "139fec49b7e4627b55ad12f3a129bec75ecc2446811c23a24f376dae207094aa" +WORKER = Path(__file__).with_name("track_b_gino_import_checked_worker.py").resolve() + + +def contract(path): + c = legacy.contract(path) + if c["mode"] != "measurement" or c["environment_ruling"] != "h-0d21f3bd": + raise PermissionError("Only the reviewed measurement environment delta is supported") + return c + + +def accepted_environment(c): + patch = patch_identity(c) + pin = c["environment_acceptance"] + receipt = read(checked(pin["path"], pin["sha256"])) + python = Path(c["environment"]["python"]) + cfg = python.parent.parent / "pyvenv.cfg" + if (receipt["status"] != "PASS" or receipt["environment_ruling"] != c["environment_ruling"] + or receipt["original_contract_sha256"] != ORIGINAL_CONTRACT + or receipt["comparison_contract_sha256"] != c["comparison_contract_sha256"] + or receipt["paper_compatibility"] != c["paper_compatibility"] + or receipt["patched_decoder_file_sha256"] != patch["patched_file_sha256"] + or receipt["cuda_visible_devices"] != "" or receipt["scientific_training"] is not False + or receipt["heldout_target_reads"] != 0 or receipt["paper_decoder_cpu_forward"] is not True + or receipt["paper_loader_learning_only"] is not True or receipt["paper_metric_cpu"] is not True + or receipt["audited_learning_cases"] != [c["split"]["train"][0]] + or receipt["package_versions"] != c["environment"]["package_versions"] + or receipt["neuralop_commit"] != c["environment"]["neuralop_commit"] + or receipt["torch_cuda_build"] != c["environment"]["torch_cuda"] + or receipt["interpreter_path"] != str(python) + or receipt["interpreter_resolved_path"] != str(python.resolve(strict=True)) + or receipt["interpreter_sha256"] != sha(python) + or receipt["pyvenv_cfg_sha256"] != sha(cfg) + or not os.access(python, os.X_OK)): + raise PermissionError("Matching CPU acceptance and isolated interpreter are required") + return receipt + + +def dispatch_guard(root, path): + def supervise(command, *args, **kwargs): + if Path(command[1]).name != "track_b_gino_shapenet_worker.py": + raise RuntimeError("Unexpected source worker route") + # The original guard's monitor closes over this exact command list. + # Select the checked wrapper before the shared supervisor can spawn. + command[1] = str(WORKER) + return legacy.supervise(command, *args, **kwargs) + + namespace = dict(legacy.dispatch_guard.__globals__, contract=contract, supervise=supervise) + return FunctionType(legacy.dispatch_guard.__code__, namespace, legacy.dispatch_guard.__name__)(root, path) + + +def authorized_child(root): + root = Path(root).resolve() + if root != ROOT: + raise PermissionError("Only the new fixed measurement root") + c = contract(root / "contract.json") + accepted_environment(c) + namespace = dict(legacy.authorized_child.__globals__, MEASUREMENT_ROOT=ROOT, contract=contract) + return FunctionType(legacy.authorized_child.__code__, namespace, legacy.authorized_child.__name__)(root) + + +def run(root): + root = Path(root).resolve() + if root != ROOT: + raise PermissionError("Only the new fixed measurement root") + path = root / "contract.json" + c = contract(path) + accepted_environment(c) + legacy.validate_review(root) + authorization = read(root / "stage-authorization.json") + if (authorization["contract_sha256"] != sha(path) or authorization["decision"] != "APPROVED" + or authorization["mode"] != "measurement"): + raise PermissionError("Exact stage authorization is required") + with (root / "entry.lock").open("a") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + if (root / "started.json").exists() or (legacy.MEASUREMENT_ROOT / "started.json").exists(): + raise FileExistsError("The measurement attempt already has a start record") + environment = accepted_environment(c) + save(root / "started.json", dict( + coordinator=process_identity(os.getpid()), contract_sha256=sha(path), + cpu_acceptance_sha256=c["environment_acceptance"]["sha256"], + interpreter_path=environment["interpreter_path"], interpreter_sha256=environment["interpreter_sha256"])) + + def request_stop(signum, _frame): + raise KeyboardInterrupt(signal.Signals(signum).name) + + handler = signal.signal(signal.SIGTERM, request_stop) + try: + return dispatch_guard(root, path) + finally: + signal.signal(signal.SIGTERM, handler) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("root", type=Path) + args = parser.parse_args() + raise SystemExit(run(args.root)) diff --git a/tools/track_b_gino_import_checked_worker.py b/tools/track_b_gino_import_checked_worker.py new file mode 100644 index 000000000..40e5e38a0 --- /dev/null +++ b/tools/track_b_gino_import_checked_worker.py @@ -0,0 +1,21 @@ +"""Route the verified measurement to the original scientific worker.""" + +import argparse +from pathlib import Path +import sys +from types import FunctionType + +from track_b_gino_import_checked_entry import authorized_child +from track_b_gino_paper_keyword_patch import extract_patched_paper_code +from track_b_gino_shapenet_worker import work + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("root", type=Path) + root = parser.parse_args().root.resolve() + c = authorized_child(root) + if str(Path(sys.executable).absolute()) != c["environment"]["python"]: + raise PermissionError("The worker did not start with the accepted interpreter") + namespace = dict(work.__globals__, extract_paper_code=extract_patched_paper_code) + FunctionType(work.__code__, namespace, work.__name__)(root, c) diff --git a/tools/track_b_gino_paper_keyword_patch.py b/tools/track_b_gino_paper_keyword_patch.py new file mode 100644 index 000000000..4e0305d09 --- /dev/null +++ b/tools/track_b_gino_paper_keyword_patch.py @@ -0,0 +1,49 @@ +"""Apply the two reviewed keyword names only to a verified temporary unpack.""" + +from pathlib import Path + +from track_b_gino_shapenet_entry import BASE, checked, read, sha +from track_b_gino_shapenet_worker import extract_paper_code + + +EVIDENCE = BASE / "artifacts/track-b-paper-keyword-compatibility-2026-11-19" +PATCH_SHA = "7307ba49f83bfc46c5decf803a993a41ed602d987de65714958e738d2f52f077" +SEARCH_SHA = "77a897bf534a9a0e9e6a7c072b4f914168648eadc2af3493b70d63d0b715b3d0" + + +def patch_binding(): + return dict(handoff="h-b8508140", identity="supplement code + 2-keyword patch", + patch_path=str(EVIDENCE / "two-keyword-patch.json"), patch_sha256=PATCH_SHA, + search_path=str(EVIDENCE / "keyword-search.json"), search_sha256=SEARCH_SHA) + + +def patch_identity(c): + pin = c["paper_compatibility"] + if pin != patch_binding(): + raise PermissionError("The exact keyword patch and archive search are required") + patch = read(checked(pin["patch_path"], pin["patch_sha256"])) + search = read(checked(pin["search_path"], pin["search_sha256"])) + if (patch["nested_archive_sha256"] != c["paper_code_zip_sha256"] + or search["nested_archive_sha256"] != c["paper_code_zip_sha256"] + or search["neuraloperator_commit"] != c["environment"]["neuralop_commit"] + or search["status"] != "NO_ALTERNATE_INTERFACE" + or search["accepting_function_signatures"] or search["neuraloperator_matches"]): + raise ValueError("Alternative interface audit or source archive identity differs") + return patch + + +def extract_patched_paper_code(c, directory): + patch = patch_identity(c) + extract_paper_code(c, directory) + target = Path(directory) / patch["target"] + original = checked(target, patch["original_file_sha256"]) + checked(target.with_name("neighbor_ops.py"), patch["neighbor_ops_file_sha256"]) + source = original.read_bytes() + for before, after in patch["changes"]: + old, new = before.encode("ascii"), after.encode("ascii") + if source.count(old) != 1: + raise ValueError("The original keyword must occur exactly once") + source = source.replace(old, new) + original.write_bytes(source) + if sha(original) != patch["patched_file_sha256"]: + raise ValueError("Supplement decoder differs from the reviewed two-keyword patch")