Implement bounded O1 geometry preparation with METIS and synthetic acceptance

This commit is contained in:
Frank14f committed 2026-11-17 04:52:02 +08:00
1 parent 7f820b76ea
commit afec2dce6a
34 files changed
+124863

No files matched your search

@@ -0,0 +1,5 @@
{
"pid": 4,
"unix": 1794861812.1813242,
"guard_pid": 3
}
@@ -0,0 +1,17 @@
test_boundary_blending_matches_independent_sums (__main__.O1Acceptance) ... ok
test_csr_and_raw_identity_ignore_traversal_order (__main__.O1Acceptance) ... ok
test_exact_diameter_not_bounding_box (__main__.O1Acceptance) ... ok
test_fixed_ufactor_and_physical_volume_reachable (__main__.O1Acceptance) ... ok
test_full_component_intersection_and_budget_reservation (__main__.O1Acceptance) ... ok
test_multicomponent_and_duplicate_tets_fail (__main__.O1Acceptance) ... ok
test_numbering_invariance_and_interface_identity (__main__.O1Acceptance) ... ok
test_physical_and_pair_matching_hard_limits (__main__.O1Acceptance) ... ok
test_quantization_positive_bounded_and_invalid_rejected (__main__.O1Acceptance) ... ok
test_same_seed_same_input_twice_exact (__main__.O1Acceptance) ... ok
test_true_constant_field_objective_and_readout (__main__.O1Acceptance) ... ok
test_whole_triples_shuffle_only_within_volume_strata (__main__.O1Acceptance) ... ok
----------------------------------------------------------------------
Ran 12 tests in 0.228s
OK
@@ -0,0 +1,20 @@
{
"status": "PASS",
"returncode": 0,
"stop_reason": null,
"cpu_seconds": 0.55848,
"wall_seconds": 0.7173578730435111,
"peak_tree_rss_bytes": 65089536,
"peak_process_count": 1,
"monitor_errors": [],
"max_poll_gap_seconds": 0.31313438300276175,
"reaped_orphan_cpu_seconds": 0.0,
"limits": {
"cpu_seconds": 600,
"wall_seconds": 900,
"rss_bytes": 8589934592,
"disk_bytes": 107374182400
},
"retry": false,
"gpu_visible": false
}
@@ -0,0 +1,13 @@
{
"command": [
"/home/frank14f/optane/MeltMind/artifacts/gre24-reproduction-2026-11-15/environment/venv/bin/python",
"tools/test_o1_partition.py"
],
"limits": {
"cpu_seconds": 600,
"wall_seconds": 900,
"rss_bytes": 8589934592,
"disk_bytes": 107374182400
},
"unix": 1794861812.1801677
}
@@ -0,0 +1,14 @@
{
"tools/o1_partition.py": "5e7dbf97604b9ea9646113a9847e7232020e5f9248fad388177c32ae2a7117da",
"tools/o1_prepare.py": "1a695477ee6605d75e7e991205e3e6a49a0907a7733491af8d2771c7bc6a5c23",
"tools/run_o1_prepare.py": "dbc2ad9739552982af0b5031bea915bd620ecc6391f4cda2f80b26c1d8cd7190",
"tools/prepare_o1_queue.py": "69f8131dfd7d1a4df8462a897b4e93699acd724a3f351d6b341ae7c8cf708801",
"tools/test_o1_partition.py": "1c3f07c5ee52caeb163fe4df8c45ad23085e784b701c55618c7cee851c4832a3",
"tools/test_o1_preparation.py": "a9a31519093bfc0b93341ec909acc07b5b9f3200053859f6360117cc9a1df84f",
"tools/audit_samples.py": "a3daf70ec3bcb77bf46d9dc4887d552cf7c422117880a169969780012278cd70",
"tools/gre24_features.py": "92bca4d348f31246c2e931949e2ca38103881b1b784a621a42044db56a460026",
"tools/boundary_distance.py": "a45c1cbce92521a96eb814913b4f465b926c0b3883932ab0b7c37d11db113ed7",
"tools/r4bc_guard.py": "437a756ddf10b125dce450f463e76e28df52724f8c5766e0a989dfa536805628",
"tools/s2_recovery_supervisor.py": "f563ca3c2665f5baf0c04f296616e4640423a59b815fbb00479af0f29e57a919",
"tools/s2_recovery_monitoring.py": "442c2a9c75e8c00b30a8f2e91cb52d87c466b19a80aea9128b10c021e61b922e"
}
@@ -0,0 +1,5 @@
{
"pid": 4,
"unix": 1794862122.7137883,
"guard_pid": 3
}
@@ -0,0 +1,23 @@
test_boundary_blending_matches_independent_sums (test_o1_partition.O1Acceptance) ... ok
test_csr_and_raw_identity_ignore_traversal_order (test_o1_partition.O1Acceptance) ... ok
test_exact_diameter_not_bounding_box (test_o1_partition.O1Acceptance) ... ok
test_fixed_ufactor_and_physical_volume_reachable (test_o1_partition.O1Acceptance) ... ok
test_full_component_intersection_and_budget_reservation (test_o1_partition.O1Acceptance) ... ok
test_multicomponent_and_duplicate_tets_fail (test_o1_partition.O1Acceptance) ... ok
test_numbering_invariance_and_interface_identity (test_o1_partition.O1Acceptance) ... ok
test_physical_and_pair_matching_hard_limits (test_o1_partition.O1Acceptance) ... ok
test_quantization_positive_bounded_and_invalid_rejected (test_o1_partition.O1Acceptance) ... ok
test_same_seed_same_input_twice_exact (test_o1_partition.O1Acceptance) ... ok
test_true_constant_field_objective_and_readout (test_o1_partition.O1Acceptance) ... ok
test_whole_triples_shuffle_only_within_volume_strata (test_o1_partition.O1Acceptance) ... ok
test_cost_checkpoint_no_complete_library_is_not_extrapolated (test_o1_preparation.PreparationAcceptance) ... ok
test_field_section_before_geometry_refused (test_o1_preparation.PreparationAcceptance) ... ok
test_frozen_feature_mutation_is_global_input_failure (test_o1_preparation.PreparationAcceptance) ... ok
test_full_32_seed_prepare_without_any_labels_or_model (test_o1_preparation.PreparationAcceptance) ... ok
test_input_alignment_preserves_queries_and_whole_features (test_o1_preparation.PreparationAcceptance) ... ok
test_mixed_cell_ids_and_no_pointdata_decode (test_o1_preparation.PreparationAcceptance) ... ok
----------------------------------------------------------------------
Ran 18 tests in 0.534s
OK
@@ -0,0 +1,20 @@
{
"status": "PASS",
"returncode": 0,
"stop_reason": null,
"cpu_seconds": 1.706611,
"wall_seconds": 1.8242901329649612,
"peak_tree_rss_bytes": 117878784,
"peak_process_count": 1,
"monitor_errors": [],
"max_poll_gap_seconds": 0.21151106397155672,
"reaped_orphan_cpu_seconds": 0.0,
"limits": {
"cpu_seconds": 600,
"wall_seconds": 900,
"rss_bytes": 8589934592,
"disk_bytes": 107374182400
},
"retry": false,
"gpu_visible": false
}
@@ -0,0 +1,20 @@
{
"command": [
"/home/frank14f/optane/MeltMind/artifacts/gre24-reproduction-2026-11-15/environment/venv/bin/python",
"-m",
"unittest",
"discover",
"-s",
"tools",
"-p",
"test_o1_*.py",
"-v"
],
"limits": {
"cpu_seconds": 600,
"wall_seconds": 900,
"rss_bytes": 8589934592,
"disk_bytes": 107374182400
},
"unix": 1794862122.7096314
}
@@ -0,0 +1,88 @@
{
"pid": 35,
"seed": 0,
"synthetic_only": true,
"labels_sha256": "d6bc159d24b84d4892dec845aab1e886469414fb9c5e051f2096dc8109ede630",
"graph_sha256": {
"xadj": "2eab3ba8a03e31f3e6334cc6b348795f29f8de3fd6b3f79cab6099e9d0fb185f",
"adjncy": "6159888bba452d6a94224a8364c10eb3ca3a20ef90dbb4f22889b82f18ef6472",
"vwgt": "61b1a68a3c71ccad4b021206a2d0163230cd972ee27ee6c4d2a2d892c3fe3813",
"adjwgt": "85c47a53f039f50d5ad22b7e751146c15dc1e1775e5245a10b1e5b05544ad49e"
},
"options": [
-1,
0,
1,
4,
1,
0,
10,
1,
0,
0,
0,
1,
-1,
-1,
-1,
-1,
50,
0,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1
],
"metrics": {
"fractions": [
0.12239583333333316,
0.12499999999999982,
0.12499999999999982,
0.12499999999999982,
0.12499999999999982,
0.12499999999999982,
0.12499999999999982,
0.1276041666666665
],
"cut_area": 80.41421356237309,
"diameters": [
4.898979485566356,
4.898979485566356,
4.898979485566356,
4.898979485566356,
4.898979485566356,
4.898979485566356,
4.898979485566356,
5.385164807134504
],
"hull_vertices": [
8,
8,
8,
8,
10,
8,
8,
8
],
"fraction_margin_min": 0.0036458333333331677
}
}
@@ -0,0 +1,5 @@
{
"pid": 35,
"unix": 1794862224.7588055,
"guard_pid": 3
}
Whitespace-only changes.
@@ -0,0 +1,20 @@
{
"status": "PASS",
"returncode": 0,
"stop_reason": null,
"cpu_seconds": 0.35664399999999996,
"wall_seconds": 0.40856259601423517,
"peak_tree_rss_bytes": 110075904,
"peak_process_count": 1,
"monitor_errors": [],
"max_poll_gap_seconds": 0.2015311330324039,
"reaped_orphan_cpu_seconds": 0.0,
"limits": {
"cpu_seconds": 600,
"wall_seconds": 900,
"rss_bytes": 8589934592,
"disk_bytes": 107374182400
},
"retry": false,
"gpu_visible": false
}
@@ -0,0 +1,14 @@
{
"command": [
"/home/frank14f/optane/MeltMind/artifacts/gre24-reproduction-2026-11-15/environment/venv/bin/python",
"tools/o1_determinism_probe.py",
"artifacts/o1-acceptance-2026-11-17/attempt-003/determinism.json"
],
"limits": {
"cpu_seconds": 600,
"wall_seconds": 900,
"rss_bytes": 8589934592,
"disk_bytes": 107374182400
},
"unix": 1794862224.7537086
}
@@ -0,0 +1,15 @@
{
"tools/o1_partition.py": "5e7dbf97604b9ea9646113a9847e7232020e5f9248fad388177c32ae2a7117da",
"tools/o1_prepare.py": "1a695477ee6605d75e7e991205e3e6a49a0907a7733491af8d2771c7bc6a5c23",
"tools/run_o1_prepare.py": "dbc2ad9739552982af0b5031bea915bd620ecc6391f4cda2f80b26c1d8cd7190",
"tools/prepare_o1_queue.py": "fc83cf63a4c0d5654d0019c8fe357e26d68ddb0a678caed23e8bf08d15528358",
"tools/test_o1_partition.py": "1c3f07c5ee52caeb163fe4df8c45ad23085e784b701c55618c7cee851c4832a3",
"tools/test_o1_preparation.py": "a9a31519093bfc0b93341ec909acc07b5b9f3200053859f6360117cc9a1df84f",
"tools/o1_determinism_probe.py": "21d6f2f7302311e83e3f4c08c3c82735a5c54a5ed0fb84d30b5022d0683d82ee",
"tools/audit_samples.py": "a3daf70ec3bcb77bf46d9dc4887d552cf7c422117880a169969780012278cd70",
"tools/gre24_features.py": "92bca4d348f31246c2e931949e2ca38103881b1b784a621a42044db56a460026",
"tools/boundary_distance.py": "a45c1cbce92521a96eb814913b4f465b926c0b3883932ab0b7c37d11db113ed7",
"tools/r4bc_guard.py": "437a756ddf10b125dce450f463e76e28df52724f8c5766e0a989dfa536805628",
"tools/s2_recovery_supervisor.py": "f563ca3c2665f5baf0c04f296616e4640423a59b815fbb00479af0f29e57a919",
"tools/s2_recovery_monitoring.py": "442c2a9c75e8c00b30a8f2e91cb52d87c466b19a80aea9128b10c021e61b922e"
}
@@ -0,0 +1,88 @@
{
"pid": 36,
"seed": 0,
"synthetic_only": true,
"labels_sha256": "d6bc159d24b84d4892dec845aab1e886469414fb9c5e051f2096dc8109ede630",
"graph_sha256": {
"xadj": "2eab3ba8a03e31f3e6334cc6b348795f29f8de3fd6b3f79cab6099e9d0fb185f",
"adjncy": "6159888bba452d6a94224a8364c10eb3ca3a20ef90dbb4f22889b82f18ef6472",
"vwgt": "61b1a68a3c71ccad4b021206a2d0163230cd972ee27ee6c4d2a2d892c3fe3813",
"adjwgt": "85c47a53f039f50d5ad22b7e751146c15dc1e1775e5245a10b1e5b05544ad49e"
},
"options": [
-1,
0,
1,
4,
1,
0,
10,
1,
0,
0,
0,
1,
-1,
-1,
-1,
-1,
50,
0,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1
],
"metrics": {
"fractions": [
0.12239583333333316,
0.12499999999999982,
0.12499999999999982,
0.12499999999999982,
0.12499999999999982,
0.12499999999999982,
0.12499999999999982,
0.1276041666666665
],
"cut_area": 80.41421356237309,
"diameters": [
4.898979485566356,
4.898979485566356,
4.898979485566356,
4.898979485566356,
4.898979485566356,
4.898979485566356,
4.898979485566356,
5.385164807134504
],
"hull_vertices": [
8,
8,
8,
8,
10,
8,
8,
8
],
"fraction_margin_min": 0.0036458333333331677
}
}
@@ -0,0 +1,5 @@
{
"pid": 36,
"unix": 1794862225.1677938,
"guard_pid": 3
}
Whitespace-only changes.
@@ -0,0 +1,20 @@
{
"status": "PASS",
"returncode": 0,
"stop_reason": null,
"cpu_seconds": 0.36186,
"wall_seconds": 0.4070741069735959,
"peak_tree_rss_bytes": 110075904,
"peak_process_count": 1,
"monitor_errors": [],
"max_poll_gap_seconds": 0.20114544703392312,
"reaped_orphan_cpu_seconds": 0.0,
"limits": {
"cpu_seconds": 600,
"wall_seconds": 900,
"rss_bytes": 8589934592,
"disk_bytes": 107374182400
},
"retry": false,
"gpu_visible": false
}
@@ -0,0 +1,14 @@
{
"command": [
"/home/frank14f/optane/MeltMind/artifacts/gre24-reproduction-2026-11-15/environment/venv/bin/python",
"tools/o1_determinism_probe.py",
"artifacts/o1-acceptance-2026-11-17/attempt-004/determinism.json"
],
"limits": {
"cpu_seconds": 600,
"wall_seconds": 900,
"rss_bytes": 8589934592,
"disk_bytes": 107374182400
},
"unix": 1794862225.163758
}
@@ -0,0 +1,21 @@
{
"status": "PASS",
"processes": [
35,
36
],
"seed": 0,
"labels_sha256": "d6bc159d24b84d4892dec845aab1e886469414fb9c5e051f2096dc8109ede630",
"ufactor": 50,
"fractions": [
0.12239583333333316,
0.12499999999999982,
0.12499999999999982,
0.12499999999999982,
0.12499999999999982,
0.12499999999999982,
0.12499999999999982,
0.1276041666666665
],
"same_graph_labels_metrics_options": true
}
@@ -0,0 +1,17 @@
{
"checked_at": "2026-11-17T04:49:33.831138+08:00",
"cpu0_to7_percent": [
0.0,
0.5,
0.5,
0.0,
2.5,
1.5,
0.0,
0.0
],
"available_memory_bytes": 58892644352,
"existing_o1_coordinators": [],
"r4bc_pid_exists": true,
"read_only": true
}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,10 @@
{
"status": "READY_FOR_GEOMETRY_PREPARATION_NO_FITS",
"parts": 617,
"dispatch": 611,
"metadata_excluded": 6,
"contract_sha256": "7d86aaac26320ec657972212e359e2f59d1958081dd3703f815f1aceb127eb18",
"initial_preparation_cpu_seconds": 62.983595,
"metadata_cpu_seconds_within_60_reserve": 0.261308938,
"prelaunch_previous_contract_sha256": "387373cb282b61dd5963c6d19d9639ace3f57003fac173558ff49bd1e60d3fc5"
}
@@ -185,3 +185,6 @@ Claude1794860233.507079/h-b390ef26已实读并落实至docs/o1-execution-contrac
Horsea已有libmetis5/dev 5.1.0.dfsg-7build2,动态加载/符号/默认选项PASS;无Python wrapper或gpmetis命令不等于无引擎。锁库d0ad5290/头20826dae,拟独立ctypes适配,不安装。该结果只证明库可用;未写适配器、未做分区合成、未生成真实分区/拟合/评分。总40workerCPUh分12h准备/24h拟合/4hpost;准备可用闲置0–7,拟合须等R4bc真实队列终态。合同版本纳入一次主审,不设重复用户go;原执行pins不动。
同次04:32只读R4bc551PASS+原job90失败=552终态,521868及4guard/worker仍在;fit64512.334535CPU秒,setup99.840649,活动树采样另列,无新失败/globalstop/monitorerror。原post余14053.129613不重开。合同/可用性与原始快照交Claude,本条不是O1实际启动或已完成试验的声明。
O1准备实现接续(2026-11-17):已实读Claude1794861463,同意7f820b76为一次主审,接受既有METIS/ctypes不安装。三项强制合成及完整18项PASS,两个新进程seed0图/标签/指标逐字一致;总合成CPU2.983595进入准备12h一次。新独立准备实现及合同7d86aaac,不改R4bc pins,无模型/评分/自动拟合入口。611候选/6既有缺特征保留,原617/209分母,前十3/4/6/8/9/11/21/23/24/30顺序成本门;通过后4worker0/2/4/6,初始62.983595CPU秒。真实启动须查新started/progress,本文本不是已运行声明。Claude已将7%平台明确收窄到已测试因素/模型家族,保留此界限。详见docs/o1-preparation-implementation-2026-11-17.md。
@@ -0,0 +1,19 @@
# O1 无标签准备实现与合成验收
2026-11-17,MeltAstra。已实读 Claude `1794861463.486809`:`7f820b76` 是一次主审;接受既有 METIS5.1.0 ctypes,无安装;真实件前核同seed重放、固定ufactor可达体积区间及CSR/raw-ID不依赖遍历顺序。原“约7%平台”只限已测试因素/模型家族,不是一般误差下界。
本次新增独立 `o1_partition.py`、`o1_prepare.py`、`run_o1_prepare.py`、`prepare_o1_queue.py`,未改 R4bc 或历史固定源。实现限于无标签几何候选/选择/读出、受守卫的唯一准备队列及共同域冻结;没有模型训练/测试评分实现或自动拟合入口。下一学习阶段仍受 R4bc 原队列真实结束的依赖约束。
库/头文件继续锁 d0ad5290/20826dae,整数/real为32位。同seed同输入两次分区逐项相同;改变节点顺序、单元顺序及tet顶点遍历后,canonical mesh、CSR、权重、分区完全一致。另在两个新进程重复seed0,图/选项/标签/指标全部一致,标签SHA `d6bc159d24b84d4892dec845aab1e886469414fb9c5e051f2096dc8109ede630`。该进程PID是合成执行环境内PID,不冒称Horsea生产worker。
ufactor固定50、contig1;合成箱体实物体积份额0.1223958333…至0.1276041667…,落在[0.11875,0.13125]。这是“固定设置可达”的合成证据,不声称真实件必然通过;真实件逐区硬检验,不修复、不换G或seed。原物理匹配及单线程约束不改。
完整18项合成PASS,包括一次混合VTU的完整32seed准备、字段段拒绝/毒化Fill_time未解码、原始mixed-cell编号、源/缓存节点和tet重排对齐、查询/counts保留、19列原文件未变、哈希变异全局拒绝、精确直径、共同域、匹配互检与预算预留。合成中T=G=C被保留且未再抽;每个候选保存数组/回执。所有验收在 `artifacts/o1-acceptance-2026-11-17`,4次guard均PASS,CPU分别0.558480、1.706611、0.356644、0.361860秒,总2.983595秒;首次12项及之后18项保留,后两次为新进程确定性探针,无失败被抹去。
原S2几何缓存不含原VTU cell ID。实现仅读源VTU Points/Cells并在字段段前停止,恢复实际混合网格cell编号,与冻结缓存点/单元逐项核对;不使用tet缓存行号冒充源ID。case数值ID指文件名首个下划线前的原数字前缀,例如 `00000003_...` 对应3;617件前缀唯一已在元数据准备检查。分层shuffle沿合同 `SeedSequence([2026111701, numeric_case])`,没有Python随机hash。
准备根 `artifacts/o1-preparation-2026-11-17`,617/209原分母,6件既有v5全特征缺失保留,611件进入实际准备候选;全组件交集在全部终态后冻结,不提前拿R4bc552名单替代。前十件固定3/4/6/8/9/11/21/23/24/30,依原数字ID排序,单进程顺序测量;至少一件完整32候选才可估计全部候选成本,以完整样本最大CPU/tet率投影余件,成本门失败即停。通过后最多四worker0/2/4/6、协调1;每件1800CPU/1800wall/8GiB、准备43200CPU秒、全局36GiB/100GiB,零重试。metadata排除不是科学计算失败;G失败/匹配失败为INELIGIBLE,guard资源失败原样保留。
完整准备合同SHA `7d86aaac26320ec657972212e359e2f59d1958081dd3703f815f1aceb127eb18`,初始费用62.983595秒=60工程预留+全部新合成,之后实际worker累计一次。跨进程补充验收前、尚未发布/启动的合同387373cb版本单独保存在 `contract-before-cross-process-acceptance.json`,不冒称运行源。当前contract固定全部源与包身份;启动需额外launch-freeze记录固定Git SHA。
04:49只读资源检查:0–7核两秒窗口0–2.5%使用,可用内存58,892,644,352 B,无O1协调进程;R4bc原521868仍存在。此文是实现/验收和启动前证据,尚不以它证明真实worker已运行,实际启动另记PID/服务/首件进度。
+18
View File
@@ -0,0 +1,18 @@
"""Synthetic partition fingerprint from one fresh process, never real data."""
import argparse
import hashlib
import json
import os
from pathlib import Path
from test_o1_partition import box
from o1_partition import canonical_mesh, graph, Metis, partition_metrics
if __name__=='__main__':
p=argparse.ArgumentParser();p.add_argument('output',type=Path);a=p.parse_args()
mesh=canonical_mesh(*box());g=graph(mesh);labels,call=Metis().partition(g,mesh['raw_cells'],0)
record=dict(pid=os.getpid(),seed=0,synthetic_only=True,labels_sha256=hashlib.sha256(labels.tobytes()).hexdigest(),
graph_sha256={k:hashlib.sha256(g[k].tobytes()).hexdigest() for k in ['xadj','adjncy','vwgt','adjwgt']},
options=call['options'],metrics=partition_metrics(mesh,g,labels))
a.output.write_text(json.dumps(record,indent=2)+'\n')
+292
View File
@@ -0,0 +1,292 @@
"""O1 fixed METIS geometry library and label-free regional readout.
No label loader, model, geometry-dependent seed search or partition repair.
"""
import ctypes
import hashlib
from pathlib import Path
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import connected_components
from scipy.spatial import ConvexHull, distance
LIBRARY = '/usr/lib/x86_64-linux-gnu/libmetis.so.5.1.0'
LIBRARY_SHA = 'd0ad52903eee2ae1f79540a9de989acd7ddccff1b7499bbcb466184c15cbc4f7'
HEADER_SHA = '20826dae4a5ff3fce9ad5fd0cf28ed0f8899e1cbdab1e318dfb33c8123840616'
K = 8
Q = 2**26
# metis.h 5.1.0 enumeration indices; all unspecified options retain -1.
FIXED_OPTIONS = {1: 0, 2: 1, 3: 4, 4: 1, 5: 0, 6: 10, 7: 1,
9: 0, 10: 0, 11: 1, 16: 50, 17: 0}
class InputViolation(ValueError):
"""Frozen identity/hash/role mismatch: stop the whole queue."""
class GeometryFailure(ValueError):
"""A preserved local preparation or scope failure."""
def sha(path):
h = hashlib.sha256()
with Path(path).open('rb') as f:
for chunk in iter(lambda: f.read(4*2**20), b''):
h.update(chunk)
return h.hexdigest()
def checked(path, digest):
if sha(path) != digest:
raise InputViolation('Pinned hash changed: '+str(path))
return Path(path)
def quantize(a):
a = np.asarray(a, dtype=np.float64)
if a.ndim != 1 or not 0 < len(a) <= Q or not np.isfinite(a).all() or np.any(a <= 0):
raise GeometryFailure('INT_WEIGHT_RANGE')
total = a.sum(dtype=np.float64)
if not np.isfinite(total) or total <= 0:
raise GeometryFailure('INT_WEIGHT_RANGE')
fraction = a/total
weights = 1 + np.floor(Q*fraction).astype(np.int64)
if weights.sum() > 2*Q or weights.max() > np.iinfo(np.int32).max:
raise GeometryFailure('INT_WEIGHT_RANGE')
error = np.abs(weights/weights.sum() - fraction)
return weights.astype(np.int32), dict(L1=float(error.sum()), max_absolute=float(error.max()))
def canonical_mesh(points, tets, raw_nodes, raw_cells):
x = np.asarray(points, dtype=np.float64)
t = np.asarray(tets)
rn, rc = np.asarray(raw_nodes), np.asarray(raw_cells)
if (x.ndim != 2 or x.shape[1] != 3 or not np.isfinite(x).all() or
t.ndim != 2 or t.shape[1] != 4 or t.dtype.kind not in 'iu' or
rn.shape != (len(x),) or rc.shape != (len(t),) or
rn.dtype.kind not in 'iu' or rc.dtype.kind not in 'iu' or
len(t) < K or len(np.unique(rn)) != len(rn) or
len(np.unique(rc)) != len(rc) or np.any(rn < 0) or np.any(rc < 0)):
raise GeometryFailure('INVALID_MESH_IDENTITY')
if t.min() < 0 or t.max() >= len(x):
raise GeometryFailure('TET_INDEX_RANGE')
node_order, cell_order = np.argsort(rn, kind='stable'), np.argsort(rc, kind='stable')
inverse = np.empty(len(x), dtype=np.int64); inverse[node_order] = np.arange(len(x))
t = np.sort(inverse[t[cell_order]], axis=1)
x, rn, rc = x[node_order], rn[node_order], rc[cell_order]
if np.any(np.diff(t, axis=1) == 0) or len(np.unique(t, axis=0)) != len(t):
raise GeometryFailure('DUPLICATE_OR_INVALID_TET')
if not np.array_equal(np.unique(t), np.arange(len(x))):
raise GeometryFailure('UNREFERENCED_NODE')
cells = x[t]
volume = np.abs(np.linalg.det(cells[:, 1:]-cells[:, :1]))/6
if not np.isfinite(volume).all() or np.any(volume <= 0):
raise GeometryFailure('DEGENERATE_VOLUME')
return dict(points=x, tets=t, raw_nodes=rn, raw_cells=rc, volume=volume,
node_order=node_order, cell_order=cell_order)
def graph(mesh):
x, t = mesh['points'], mesh['tets']
face_pattern = np.array([[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3]])
faces = t[:, face_pattern].reshape(-1, 3) # canonical t already sorted
owners = np.repeat(np.arange(len(t)), 4)
order = np.lexsort((faces[:, 2], faces[:, 1], faces[:, 0]))
faces, owners = faces[order], owners[order]
starts = np.r_[0, np.flatnonzero(np.any(faces[1:] != faces[:-1], axis=1))+1]
counts = np.diff(np.r_[starts, len(faces)])
if np.any(counts > 2):
raise GeometryFailure('NONMANIFOLD_FACE')
idx = starts[counts == 2]
face = faces[idx]
edges = np.sort(np.column_stack((owners[idx], owners[idx+1])), axis=1)
if not len(edges):
raise GeometryFailure('MULTICOMPONENT_SCOPE')
vertices = x[face]
area = np.linalg.norm(np.cross(vertices[:, 1]-vertices[:, 0],
vertices[:, 2]-vertices[:, 0]), axis=1)/2
if not np.isfinite(area).all() or np.any(area <= 0):
raise GeometryFailure('DEGENERATE_FACE')
vwgt, ve = quantize(mesh['volume']); ewgt, ee = quantize(area)
directed = np.concatenate((edges, edges[:, ::-1]))
weights = np.tile(ewgt, 2)
order = np.lexsort((directed[:, 1], directed[:, 0]))
directed, weights = directed[order], weights[order]
offsets = np.r_[0, np.cumsum(np.bincount(directed[:, 0], minlength=len(t)))]
if len(t) >= 2**31 or offsets[-1] >= 2**31 or weights.astype(np.int64).sum() > 4*Q:
raise GeometryFailure('CSR_OR_WEIGHT_OVERFLOW')
adjacency = csr_matrix((np.ones(len(directed)), directed[:, 1], offsets), shape=(len(t), len(t)))
nc = connected_components(adjacency, directed=False, return_labels=False)
if nc != 1:
raise GeometryFailure('MULTICOMPONENT_SCOPE')
return dict(xadj=offsets.astype(np.int32), adjncy=directed[:, 1].astype(np.int32),
vwgt=vwgt, adjwgt=weights.astype(np.int32), edges=edges,
faces_raw=mesh['raw_nodes'][face], area=area,
quantization=dict(volume=ve, face_area=ee), adjacency=adjacency)
def canonical_labels(labels, raw_cells):
labels = np.asarray(labels)
if labels.shape != np.asarray(raw_cells).shape or labels.dtype.kind not in 'iu':
raise GeometryFailure('PARTITION_SHAPE')
unique = np.unique(labels)
regions = sorted(unique, key=lambda r: int(np.min(raw_cells[labels == r])))
out = np.empty(len(labels), dtype=np.int32)
for i, r in enumerate(regions):
out[labels == r] = i
return out
class Metis:
def __init__(self):
checked(LIBRARY, LIBRARY_SHA); checked('/usr/include/metis.h', HEADER_SHA)
self.lib = ctypes.CDLL(LIBRARY)
self.i = ctypes.c_int32; self.r = ctypes.c_float
self.ip = ctypes.POINTER(self.i); self.rp = ctypes.POINTER(self.r)
self.lib.METIS_SetDefaultOptions.argtypes = [self.ip]
self.lib.METIS_SetDefaultOptions.restype = ctypes.c_int
self.lib.METIS_PartGraphKway.argtypes = [self.ip]*8+[self.rp]*2+[self.ip]*3
self.lib.METIS_PartGraphKway.restype = ctypes.c_int
def options(self, seed):
if seed not in range(32):
raise ValueError('Only fixed seeds 0..31')
options = np.empty(40, dtype=np.int32)
if self.lib.METIS_SetDefaultOptions(options.ctypes.data_as(self.ip)) != 1:
raise InputViolation('Default options initialization failed')
for k, v in FIXED_OPTIONS.items(): options[k] = v
options[8] = seed
return options
def partition(self, g, raw_cells, seed):
n, ncon, k, cut = self.i(len(raw_cells)), self.i(1), self.i(K), self.i()
options = self.options(seed)
part = np.empty(n.value, dtype=np.int32)
target = np.full(K, 1/K, dtype=np.float32)
arrays = [np.ascontiguousarray(g[key], dtype=np.int32) for key in ['xadj', 'adjncy', 'vwgt', 'adjwgt']]
ptr = [a.ctypes.data_as(self.ip) for a in arrays]
code = self.lib.METIS_PartGraphKway(ctypes.byref(n), ctypes.byref(ncon),
ptr[0], ptr[1], ptr[2], None, ptr[3], ctypes.byref(k),
target.ctypes.data_as(self.rp), None, options.ctypes.data_as(self.ip),
ctypes.byref(cut), part.ctypes.data_as(self.ip))
if code != 1:
raise GeometryFailure('METIS_RETURN_'+str(code))
if np.any(part < 0) or np.any(part >= K):
raise GeometryFailure('METIS_LABEL_RANGE')
return canonical_labels(part, raw_cells), dict(returncode=code, integer_cut=cut.value, options=options.tolist())
def diameter(points, block=256):
x = np.asarray(points, dtype=np.float64)
if len(x) < 4:
raise GeometryFailure('DEGENERATE_REGION')
# No QJ/random perturbation. Region includes positive-volume tets -> 3D.
hull = ConvexHull(x)
vertices = x[hull.vertices]
best = 0.
for i in range(0, len(vertices), block):
for j in range(i, len(vertices), block):
best = max(best, float(distance.cdist(vertices[i:i+block], vertices[j:j+block], 'sqeuclidean').max()))
return float(np.sqrt(best)), len(vertices)
def partition_metrics(mesh, g, labels):
if not np.array_equal(np.unique(labels), np.arange(K)):
raise GeometryFailure('NOT_EIGHT_NONEMPTY')
volume = np.bincount(labels, weights=mesh['volume'], minlength=K)
fractions = volume/mesh['volume'].sum()
if np.any(fractions < .95/K) or np.any(fractions > 1.05/K):
raise GeometryFailure('PHYSICAL_VOLUME_BALANCE')
diameters, hull_counts = [], []
for r in range(K):
ids = np.flatnonzero(labels == r)
if connected_components(g['adjacency'][ids][:, ids], directed=False, return_labels=False) != 1:
raise GeometryFailure('REGION_DISCONNECTED')
nodes = np.unique(mesh['tets'][ids])
d, h = diameter(mesh['points'][nodes]); diameters.append(d); hull_counts.append(h)
interface = labels[g['edges'][:, 0]] != labels[g['edges'][:, 1]]
cut = float(g['area'][interface].sum())
if cut <= 0 or not np.isfinite(cut):
raise GeometryFailure('DEGENERATE_CUT')
return dict(fractions=sorted(fractions.tolist()), cut_area=cut,
diameters=sorted(diameters), hull_vertices=hull_counts,
fraction_margin_min=float(min(fractions.min()-.95/K, 1.05/K-fractions.max())))
def match(a, b, mutual=False):
av, bv = np.array(a['fractions']), np.array(b['fractions'])
ad, bd = np.array(a['diameters']), np.array(b['diameters'])
area_den = min(a['cut_area'], b['cut_area']) if mutual else b['cut_area']
diam_den = np.minimum(ad, bd) if mutual else bd
dv = float(K*np.abs(av-bv).max())
da = float(abs(a['cut_area']-b['cut_area'])/area_den)
dd = float((np.abs(ad-bd)/diam_den).max())
return dict(passed=bool(dv <= .025 and da <= .05 and dd <= .05),
scaled_volume_max=dv, cut_area_relative=da, diameter_relative_max=dd)
def type_fields(features, tets):
f = np.asarray(features, dtype=np.float64)
if f.ndim != 2 or f.shape[1] != 19 or not np.isfinite(f).all():
raise InputViolation('Invalid frozen 19-column features')
s = np.empty((len(f), 3, 3))
for col, i, j in [(13,0,0),(14,0,1),(15,0,2),(16,1,1),(17,1,2),(18,2,2)]:
s[:, i, j] = s[:, j, i] = f[:, col]
eig = np.linalg.eigvalsh(s)[:, ::-1]
z = np.column_stack((f[:, 9], eig[:, 0]-eig[:, 1], eig[:, 1]-eig[:, 2]))
return z[tets].mean(axis=1), f[:, [0, 9]][tets].mean(axis=1)
def shuffle_type(z, volume, raw_cells, numeric_case):
if not isinstance(numeric_case, int) or numeric_case < 0:
raise InputViolation('Numeric original case prefix required')
order = np.lexsort((raw_cells, volume))
rng = np.random.Generator(np.random.PCG64(np.random.SeedSequence([2026111701, numeric_case])))
perm = np.arange(len(z))
for ids in np.array_split(order, 10):
perm[ids] = rng.permutation(ids)
return z[perm], perm
def regional_mean(values, volume, labels):
result = np.zeros((K, values.shape[1]))
sums = np.bincount(labels, weights=volume, minlength=K)
if np.any(sums <= 0): raise GeometryFailure('EMPTY_REGION')
for j in range(values.shape[1]):
result[:, j] = np.bincount(labels, weights=volume*values[:, j], minlength=K)/sums
return result
def objective(z, volume, labels):
mean = regional_mean(z, volume, labels)
value = float(np.sum(volume*np.sum((z-mean[labels])**2, axis=1))/volume.sum())
if not np.isfinite(value): raise GeometryFailure('NONFINITE_OBJECTIVE')
return value
def readout(tets, volume, tet_values, labels, node_count):
means = regional_mean(tet_values, volume, labels)
denominator = np.bincount(tets.ravel(), weights=np.repeat(volume, 4), minlength=node_count)
if np.any(denominator <= 0): raise GeometryFailure('UNSUPPORTED_NODE')
out = np.empty((node_count, tet_values.shape[1]))
for j in range(out.shape[1]):
out[:, j] = np.bincount(tets.ravel(), weights=np.repeat(volume*means[labels, j], 4),
minlength=node_count)/denominator
return out
def interface_difference(a, b, g):
edges = g['edges']
ai, bi = a[edges[:, 0]] != a[edges[:, 1]], b[edges[:, 0]] != b[edges[:, 1]]
union = float(g['area'][ai | bi].sum())
return dict(value=float(g['area'][ai ^ bi].sum()/union) if union else 0., empty_union=not bool(union))
def common_roster(parts, results):
bad = {p['component_id'] for p in parts if results.get(p['case'], {}).get('status') != 'PASS'}
return [p for p in parts if p['component_id'] not in bad], sorted(bad)
def can_reserve(spent, active, cap=43200., per_job=1800.):
return bool(np.isfinite(spent) and spent >= 0 and spent+(active+1)*per_job <= cap)
+209
View File
@@ -0,0 +1,209 @@
"""One O1 preparation attempt: immutable geometry/features only, no labels."""
import argparse
import json
import os
from pathlib import Path
import time
import traceback
from xml.etree import ElementTree as ET
from zipfile import ZipFile
import numpy as np
from scipy.spatial import QhullError
from audit_samples import decode_array
from gre24_features import COLUMNS
from o1_partition import (Metis, InputViolation, GeometryFailure, checked, sha,
canonical_mesh, graph, partition_metrics, match, type_fields, shuffle_type,
objective, readout, interface_difference)
from s2_recovery_supervisor import save
def read(path):
return json.loads(Path(path).read_text())
def contract(root):
c = read(Path(root)/'contract.json')
for p, h in c['source_sha256'].items(): checked(p, h)
for p, h in c['code_sha256'].items(): checked(p, h)
stat = Path(c['archive']).stat(); old = c['archive_stat']
if (stat.st_size, stat.st_mtime_ns, stat.st_ino) != (old['bytes'], old['mtime_ns'], old['inode']):
raise InputViolation('Frozen source archive stat changed')
return c
def source_geometry(archive, case):
"""Stop before field arrays; keep actual mixed-VTU cell IDs."""
stack = []; cells = {}; points = None; decoded = []
with ZipFile(archive) as z, z.open(case+'_sim.vtu') as stream:
for event, element in ET.iterparse(stream, events=('start', 'end')):
if event == 'start':
stack.append(element.tag)
if element.tag == 'VTKFile':
if element.get('byte_order') != 'LittleEndian' or element.get('compressor') != 'vtkZLibDataCompressor':
raise InputViolation('Unsupported source encoding')
header = element.get('header_type', 'UInt32')
if element.tag in ('PointData', 'CellData'):
raise InputViolation('Refuse source field section')
else:
if element.tag == 'DataArray':
parent = stack[-2]
if parent == 'Points':
points = decode_array(element, header).copy(); decoded.append('Points')
elif parent == 'Cells':
name = element.get('Name')
if name not in ('connectivity', 'offsets', 'types'):
raise InputViolation('Unexpected Cells array')
cells[name] = decode_array(element, header).copy(); decoded.append(name)
element.clear()
if points is not None and all(k in cells for k in ('connectivity', 'offsets', 'types')):
break
stack.pop()
if points is None or set(cells) != {'connectivity', 'offsets', 'types'}:
raise InputViolation('Missing geometry before field section')
offsets = np.r_[0, cells['offsets']]
ids = np.flatnonzero(cells['types'] == 10)
if not len(ids) or np.any(np.diff(offsets)[ids] != 4):
raise GeometryFailure('INVALID_SOURCE_TET')
raw_tets = cells['connectivity'][offsets[ids, None]+np.arange(4)]
raw_nodes = np.unique(raw_tets)
t = np.searchsorted(raw_nodes, raw_tets)
return canonical_mesh(points[raw_nodes], t, raw_nodes, ids), decoded
def load_inputs(c, row):
v, p = row['v5_cache'], row['preparation']
vr, pr = Path(v['output']), Path(p['preparation_root'])
files = {}
def check(path, digest):
checked(path, digest); files[str(path)] = digest; return path
old = read(check(pr/'result.json', p['result_sha256']))
new = read(check(vr/'result.json', v['result_sha256']))
if old['case'] != row['case'] or new['case'] != row['case'] or new['status'] != 'PASS':
raise InputViolation('Preparation identity/status')
if new['features']['columns'] != list(COLUMNS) or new['t_scale_seconds'] != p['t_set'] or v['t_scale_seconds'] != p['t_set']:
raise InputViolation('Frozen feature columns/clock')
mesh, decoded = source_geometry(c['archive'], row['case'])
with np.load(check(pr/'geometry.npz', p['output_sha256']['geometry.npz']), allow_pickle=False) as z:
if not np.array_equal(z['raw_node_ids'], mesh['raw_nodes']) or not np.array_equal(z['points_raw'], mesh['points']):
raise InputViolation('Source/cache raw node coordinates')
t = np.sort(z['tetra'], axis=1); expected = mesh['tets']
order = lambda a: np.lexsort(tuple(a[:, i] for i in (3, 2, 1, 0)))
if not np.array_equal(t[order(t)], expected[order(expected)]):
raise InputViolation('Source/cache tetrahedra differ')
raw = np.load(check(vr/'raw_ids.npy', v['output_sha256']['raw_ids.npy']), allow_pickle=False)
if not np.array_equal(raw, mesh['raw_nodes']): raise InputViolation('Feature raw IDs differ')
features = np.load(check(vr/'features.npy', v['output_sha256']['features.npy']), allow_pickle=False)
if features.shape != (len(raw), 19) or not np.isfinite(features).all():
raise InputViolation('Invalid feature coverage/values')
with np.load(check(pr/'queries.npz', p['output_sha256']['queries.npz']), allow_pickle=False) as z:
keep = z['eligible_s2']; queries = z['raw_node_ids'][keep]; counts = z['multiplicity'][keep]
qi = np.searchsorted(raw, queries)
if (not len(qi) or np.any(qi >= len(raw)) or np.any(np.diff(queries) <= 0) or
np.any(counts <= 0) or not np.array_equal(raw[qi], queries)):
raise InputViolation('Query identity/multiplicity')
return mesh, features, dict(indices=qi, raw_ids=queries, counts=counts), dict(files=files, decoded_geometry_arrays=decoded,
labels_decoded=[], label_cache_opened=False, raw_cells_are_original_VTU_indices=True)
def difference(a, b):
d = np.abs(a-b)
return [dict(median=float(np.median(d[:, j])), p95=float(np.quantile(d[:, j], .95)),
nonzero_fraction=float(np.count_nonzero(d[:, j])/len(d))) for j in range(2)]
def prepare(root, index):
root = Path(root); c = contract(root); row = c['parts'][index]
dest = root/'parts'/row['case']/'output'; dest.mkdir(parents=True, exist_ok=False)
start = time.process_time(); wall = time.monotonic(); stage = 'INPUTS'; candidates = []
def progress(**kw):
save(dest/'progress.json', dict(stage=stage, case=row['case'], pid=os.getpid(),
cpu_seconds=time.process_time()-start, wall_seconds=time.monotonic()-wall, **kw))
try:
progress(); mesh, features, queries, provenance = load_inputs(c, row)
save(dest/'input-provenance.json', provenance)
stage = 'GEOMETRY_LIBRARY'; progress(tets=len(mesh['tets']))
g = graph(mesh); engine = Metis()
np.savez_compressed(dest/'graph.npz', **{k:g[k] for k in ('xadj','adjncy','vwgt','adjwgt','edges','faces_raw','area')},
raw_nodes=mesh['raw_nodes'], raw_cells=mesh['raw_cells'], volume=mesh['volume'])
save(dest/'graph.json', dict(nodes=len(mesh['points']), tets=len(mesh['tets']), faces=len(g['area']),
quantization=g['quantization'], graph_sha256=sha(dest/'graph.npz')))
reference = None; seen = {}; legal = []
for seed in range(32):
before = time.process_time(); rec = dict(seed=seed)
progress(seed=seed, tets=len(mesh['tets']), candidates_terminal=len(candidates))
try:
labels, call = engine.partition(g, mesh['raw_cells'], seed); rec.update(call)
path = dest/f'partition-{seed:02d}.npz'
np.savez_compressed(path, labels=labels)
rec.update(path=str(path), sha256=sha(path))
digest = __import__('hashlib').sha256(labels.tobytes()).hexdigest()
rec['canonical_label_sha256'] = digest
if digest in seen:
rec.update(status='DUPLICATE', earliest_seed=seen[digest])
else:
seen[digest] = seed
rec['physical_fractions'] = (np.bincount(labels, weights=mesh['volume'], minlength=8)/mesh['volume'].sum()).tolist()
metrics = partition_metrics(mesh, g, labels); rec['metrics'] = metrics
if seed == 0: reference = metrics
rec['matching_G'] = match(metrics, reference)
rec['status'] = 'LEGAL' if rec['matching_G']['passed'] else 'MATCH_FAIL'
if rec['status'] == 'LEGAL': legal.append(rec)
except (GeometryFailure, QhullError) as error:
rec.update(status='CANDIDATE_FAILED', cause=type(error).__name__, message=str(error))
rec['cpu_seconds'] = time.process_time()-before
candidates.append(rec); save(dest/'candidate-records.json', candidates)
if seed == 0 and rec['status'] != 'LEGAL':
raise GeometryFailure('G_SEED0_INVALID')
stage = 'TYPE_SELECTION'; progress(tets=len(mesh['tets']), candidates_terminal=32)
z, b = type_fields(features, mesh['tets'])
shuffled, permutation = shuffle_type(z, mesh['volume'], mesh['raw_cells'], row['numeric_case'])
np.save(dest/'shuffle-permutation.npy', permutation)
for rec in legal:
with np.load(rec['path'], allow_pickle=False) as source: labels = source['labels']
rec['J_true'] = objective(z, mesh['volume'], labels)
rec['J_shuffled'] = objective(shuffled, mesh['volume'], labels)
selected = dict(G=legal[0], T=min(legal, key=lambda r:(r['J_true'],r['seed'])),
C=min(legal, key=lambda r:(r['J_shuffled'],r['seed'])))
mutual = match(selected['T']['metrics'], selected['C']['metrics'], mutual=True)
save(dest/'selection.json', dict(seeds={a:r['seed'] for a,r in selected.items()}, mutual=mutual,
legal_candidates=legal, shuffle_sha256=sha(dest/'shuffle-permutation.npy'),
z_min=z.min(axis=0).tolist(), z_max=z.max(axis=0).tolist()))
if not mutual['passed']: raise GeometryFailure('T_C_MUTUAL_MATCH_FAIL')
stage = 'READOUT'; progress(tets=len(mesh['tets']), candidates_terminal=32)
fields = {}; labels_by_arm = {}
for arm, rec in selected.items():
with np.load(rec['path'], allow_pickle=False) as source: labels = source['labels']
labels_by_arm[arm] = labels
fields[arm] = readout(mesh['tets'], mesh['volume'], b, labels, len(features))
if not np.isfinite(fields[arm]).all(): raise GeometryFailure('NONFINITE_READOUT')
np.save(dest/(arm+'-extra.npy'), fields[arm])
qi = queries['indices']; diagnostics = {}
for arm in ('G', 'C'):
diagnostics['T/'+arm] = dict(interface=interface_difference(labels_by_arm['T'], labels_by_arm[arm], g),
float64=difference(fields['T'][qi], fields[arm][qi]),
float32=difference(fields['T'][qi].astype(np.float32), fields[arm][qi].astype(np.float32)))
np.savez_compressed(dest/'queries.npz', **queries)
save(dest/'result.json', dict(status='PASS',case=row['case'],nodes=len(features),tets=len(mesh['tets']),
faces=len(g['area']),candidate_calls=32,unique_candidates=len(seen),legal_candidates=len(legal),
seeds={a:r['seed'] for a,r in selected.items()},diagnostics=diagnostics,
output_sha256={p.name:sha(p) for p in dest.iterdir() if p.suffix in ('.npz','.npy')},
input_provenance_sha256=sha(dest/'input-provenance.json'), selection_sha256=sha(dest/'selection.json'),
cpu_seconds=time.process_time()-start,wall_seconds=time.monotonic()-wall,
original_features_unchanged=True,labels_decoded=[],label_cache_opened=False,model_fit=False))
stage = 'COMPLETE'; progress(tets=len(mesh['tets']), candidates_terminal=32); return 0
except GeometryFailure as error:
save(dest/'result.json', dict(status='INELIGIBLE',case=row['case'],reason=str(error),stage=stage,
candidate_calls=len(candidates),tets=row['tets'],cpu_seconds=time.process_time()-start,
labels_decoded=[],label_cache_opened=False,model_fit=False))
return 0 # completed eligibility measurement, not a valid part
except Exception as error:
save(dest/'failure.json', dict(case=row['case'],type=type(error).__name__,message=str(error),
stage=stage,global_stop=True,traceback=traceback.format_exc(),labels_decoded=[]))
return 1
if __name__ == '__main__':
p=argparse.ArgumentParser();p.add_argument('root',type=Path);p.add_argument('index',type=int)
a=p.parse_args();raise SystemExit(prepare(a.root,a.index))
+63
View File
@@ -0,0 +1,63 @@
"""Metadata-only O1 contract creation after synthetic acceptance; never launch."""
import argparse
import json
from pathlib import Path
import time
from o1_partition import sha, checked, InputViolation
from o1_prepare import read
from s2_recovery_supervisor import save
CODE=['o1_partition.py','o1_prepare.py','run_o1_prepare.py','prepare_o1_queue.py',
'test_o1_partition.py','test_o1_preparation.py','o1_determinism_probe.py','audit_samples.py','gre24_features.py',
'boundary_distance.py','r4bc_guard.py','s2_recovery_supervisor.py','s2_recovery_monitoring.py']
def prepare(root):
start=time.process_time()
if root.exists():raise FileExistsError('Existing O1 execution root; inspect instead of replacing')
planpath=Path('artifacts/o1-planning-2026-11-17/contract-plan.json');plan=read(planpath)
checked(plan['authoritative_contract'],plan['contract_sha256'])
sources=dict(plan['sources_sha256']);sources[str(planpath)]=sha(planpath)
sources[plan['authoritative_contract']]=plan['contract_sha256']
for p,h in sources.items():checked(p,h)
roster=read('artifacts/s2-main-preparation-2026-11-15/final-roster.json')
successful=read('artifacts/gre24-reproduction-2026-11-15/v5-models-continuation-2026-11-16/preparation-freeze.json')['successful']
original=Path('artifacts/gre24-reproduction-2026-11-15/v5-protocol/contract.json')
sources[str(original)]=sha(original);archive=read(original)
parts=[];metadata_cpu=[]
for r in sorted((r for r in roster['parts'] if r['included']),key=lambda r:int(r['case'].split('_',1)[0])):
row=dict(r); row['numeric_case']=int(row['case'].split('_',1)[0]);p=row['preparation']
resultpath=Path(p['preparation_root'])/'result.json';old=read(checked(resultpath,p['result_sha256']))
row['tets']=old['tets']; row['v5_cache']=successful.get(row['case'])
row['metadata_failure']=None if row['v5_cache'] else 'PREEXISTING_V5_FULL_FEATURE_UNAVAILABLE'
parts.append(row)
if len(parts)!=617 or len({p['component_id'] for p in parts})!=209 or len({p['numeric_case'] for p in parts})!=617:
raise InputViolation('Original roster identity changed')
receipts=sorted(Path('artifacts/o1-acceptance-2026-11-17').glob('attempt-*/worker.receipt.json'))
acceptance=[dict(path=str(p),sha256=sha(p),**read(p)) for p in receipts]
if not acceptance or acceptance[-1]['status']!='PASS':raise ValueError('No final synthetic acceptance')
accepted=read(receipts[-1].parent/'accepted-source.json')
for p,h in accepted.items():checked(p,h)
code={str(Path('tools')/n):sha(Path('tools')/n) for n in CODE}
if accepted!=code:raise ValueError('Accepted source manifest incomplete')
spent=60+sum(a['cpu_seconds'] for a in acceptance)
if time.process_time()-start>60:raise ValueError('Metadata engineering reserve exceeded')
dispatch=[i for i,p in enumerate(parts) if not p['metadata_failure']]
c=dict(version='O1-GEOMETRY-PREPARATION-v1',parts=parts,dispatch=dispatch,first_ten=dispatch[:10],
source_sha256=sources,code_sha256=code,archive=archive['archive'],archive_stat=archive['archive_stat'],
main_review=['1794860233.507079','1794861463.486809'],contract_commit='7f820b76ea6d64b3a9f8a595bc04c8434ec00ae9',
worker_cpus=[0,2,4,6],coordinator_cpu=1,limits=plan['limits'],
part_limits=dict(cpu_seconds=1800,wall_seconds=1800,rss_bytes=8*2**30,disk_bytes=100*2**30),
initial_preparation_cpu_seconds=spent,acceptance=acceptance,
prepared_without_label_values=True,fit_launch=False)
root.mkdir(parents=True)
save(root/'contract.json',c)
save(root/'prepared.json',dict(status='READY_FOR_GEOMETRY_PREPARATION_NO_FITS',parts=617,dispatch=len(dispatch),
metadata_excluded=617-len(dispatch),contract_sha256=sha(root/'contract.json'),
initial_preparation_cpu_seconds=spent,metadata_cpu_seconds_within_60_reserve=time.process_time()-start))
print(str(root),sha(root/'contract.json'))
if __name__=='__main__':
p=argparse.ArgumentParser();p.add_argument('root',type=Path);a=p.parse_args();prepare(a.root)
+210
View File
@@ -0,0 +1,210 @@
"""Single O1 geometry queue with first-ten gate and bounded, non-retry attempts."""
import argparse
import fcntl
import json
import math
import os
from pathlib import Path
import signal
import subprocess
import sys
import time
import psutil
from o1_partition import checked, sha, common_roster, can_reserve, InputViolation
from o1_prepare import contract, read
from r4bc_guard import supervise
from s2_recovery_supervisor import save, tree_usage
from s2_recovery_monitoring import disk_usage
def part_dir(root, c, index):
return Path(root)/'parts'/c['parts'][index]['case']
def guard(root, index, slot):
c = contract(root); os.sched_setaffinity(0, [c['worker_cpus'][slot]])
dest = part_dir(root, c, index)
receipt = supervise([sys.executable, 'tools/o1_prepare.py', str(root), str(index)], dest,
c['part_limits'], global_stop=root/'global-stop.json')
output = dest/'output/result.json'; failure = dest/'output/failure.json'
failed = read(failure) if failure.exists() else None
unexplained = receipt['status'] != 'PASS' and not receipt['stop_reason'] and failed is None
global_failure = bool(receipt['monitor_errors']) or bool(failed and failed['global_stop']) or unexplained
if receipt['status'] == 'PASS' and not output.exists():
receipt.update(status='FAILED', stop_reason='MISSING_RESULT'); global_failure = True
record = dict(index=index,case=c['parts'][index]['case'],worker=receipt,
result_path=str(output) if output.exists() else None,
result_sha256=sha(output) if output.exists() else None,
global_failure=global_failure,guard_cpu_seconds=time.process_time())
save(dest/'guard-result.json', record)
return 0 if receipt['status'] == 'PASS' else 1
def cost_check(c, records):
by = {r['index']:r for r in records}
samples = []; rows = []
for i in c['first_ten']:
r = by.get(i)
if r is None:
return dict(passed=False, reason='FIRST_TEN_INCOMPLETE')
result = read(checked(r['result_path'],r['result_sha256'])) if r['result_path'] else {}
rows.append(dict(case=r['case'],worker_status=r['worker']['status'],
part_status=result.get('status'),reason=result.get('reason'),
cpu_seconds=r['worker']['cpu_seconds'],tets=c['parts'][i]['tets'],
candidate_calls=result.get('candidate_calls',0)))
if r['worker']['status']=='PASS' and result.get('candidate_calls')==32:
samples.append(r['worker']['cpu_seconds']/c['parts'][i]['tets'])
spent = c['initial_preparation_cpu_seconds']+sum(r['worker']['cpu_seconds'] for r in records)
if not samples:
return dict(passed=False,reason='NO_COMPLETE_32_SEED_COST_SAMPLE',samples=rows,spent_cpu_seconds=spent)
rate = max(samples)
remaining = sum(c['parts'][i]['tets'] for i in c['dispatch'] if i not in by)*rate
return dict(passed=bool(spent+remaining <= c['limits']['preparation_cpu_seconds']),
reason='PROJECTED_WITHIN_CAP' if spent+remaining <= c['limits']['preparation_cpu_seconds'] else 'COST_PROJECTION_STOP',
samples=rows,measured_max_cpu_per_tet=rate,remaining_projected_cpu_seconds=remaining,
spent_cpu_seconds=spent,total_projected_cpu_seconds=spent+remaining,
method='Maximum measured complete-32-candidate CPU/tet times remaining tet counts; heuristic only; hard guards remain authoritative.')
def freeze_results(root, c, records, complete):
results = {p['case']:dict(status='INELIGIBLE',reason=p['metadata_failure']) for p in c['parts'] if p.get('metadata_failure')}
for r in records:
if r['worker']['status']=='PASS':
result = read(checked(r['result_path'],r['result_sha256']))
else:
result = dict(status='WORKER_FAILED',reason=r['worker']['stop_reason'])
results[r['case']] = result
for p in c['parts']:
results.setdefault(p['case'],dict(status='NEVER_ATTEMPTED'))
save(root/'all-part-results.json',results)
if not complete:
return None
kept, bad = common_roster(c['parts'],results)
groups = sorted({p['component_id'] for p in kept})
strengths = {}
for group in groups:
rows = [results[p['case']] for p in kept if p['component_id']==group]
strengths[group] = {key:sum(r['diagnostics'][key]['interface']['value'] for r in rows)/len(rows) for key in ['T/G','T/C']}
strong = sum(v['T/G']>=.1 and v['T/C']>=.1 for v in strengths.values())
output = dict(status='GEOMETRY_COMMON_ROSTER_FROZEN_NO_FITS',original_parts=617,original_components=209,
parts=kept,paired_components=groups,excluded_components=bad,
component_interface_strength=strengths,strong_components=strong,
coverage_gate=len(groups)>=168,intervention_gate=strong>=math.ceil(.7*len(groups)) if groups else False,
retained_parts=len(kept),retained_nodes=sum(p['nodes'] for p in kept),
all_part_results_sha256=sha(root/'all-part-results.json'),
results={r['case']:dict(path=r['result_path'],sha256=r['result_sha256']) for r in records},
fit_started=False,labels_read=False)
save(root/'common-roster.json',output)
return sha(root/'common-roster.json')
def run(root):
root = Path(root)
with (root/'queue.lock').open('a') as lock:
fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB)
return locked(root)
def locked(root):
c=contract(root); launch=read(root/'launch-freeze.json')
checked(root/'contract.json',launch['contract_sha256'])
if (root/'started.json').exists(): raise FileExistsError('O1 queue already attempted; no restart')
os.sched_setaffinity(0,[1]); start=time.monotonic()
save(root/'started.json',dict(pid=os.getpid(),unix=time.time(),contract_sha256=sha(root/'contract.json'),
implementation_commit=launch['implementation_commit'],cpu_affinity=sorted(os.sched_getaffinity(0)),
mode='GEOMETRY_PREPARATION_ONLY',fit_started=False))
active={};records=[];cursor=0;gate=False;cut=None;reason=None;errors=[];accounting=True;requested=[None]
def interrupt(sig,frame): requested[0]='COORDINATOR_SIGNAL_'+str(sig)
for s in (signal.SIGTERM,signal.SIGINT): signal.signal(s,interrupt)
env=dict(os.environ,OMP_NUM_THREADS='1',OPENBLAS_NUM_THREADS='1',MKL_NUM_THREADS='1',NUMEXPR_NUM_THREADS='1',CUDA_VISIBLE_DEVICES='')
try:
while True:
for slot,item in list(active.items()):
if item['process'].poll() is None: continue
path=part_dir(root,c,item['index'])/'guard-result.json'
if not path.exists():
accounting=False; reason='MISSING_GUARD_RECEIPT'
else:
r=read(path)
if not math.isfinite(r['worker']['cpu_seconds']) or r['worker']['cpu_seconds']<0:
accounting=False;reason='INVALID_ACCOUNTING'
records.append(r)
if r['global_failure']: reason='WORKER_GLOBAL_FAILURE'
item['log'].close();del active[slot]
spent=c['initial_preparation_cpu_seconds']+sum(r['worker']['cpu_seconds'] for r in records)
reason=reason or requested[0]
try:
usage=[tree_usage(item['process'].pid) for item in active.values()]
live=sum(u[0] for u in usage);rss=sum(u[1] for u in usage)+psutil.Process().memory_info().rss
disk=disk_usage(root);available=psutil.virtual_memory().available
if live+spent>c['limits']['preparation_cpu_seconds']: reason='GLOBAL_PREPARATION_CPU_LIMIT'
if rss>c['limits']['total_rss_bytes']: reason='GLOBAL_RSS_LIMIT'
if disk>=c['limits']['disk_bytes']: reason='GLOBAL_DISK_LIMIT'
except Exception as exc:
errors.append(dict(type=type(exc).__name__,message=str(exc)));reason='GLOBAL_MONITOR_ERROR'
live=rss=disk=available=0
if not gate and not active and len(records)==len(c['first_ten']) and not reason and not cut:
check=cost_check(c,records);save(root/'first-ten-cost-check.json',check)
gate=check['passed']
if not gate: cut=check['reason']
waiting=None
if not reason and not cut:
while cursor<len(c['dispatch']) and len(active)<(4 if gate else 1):
if not gate and cursor>=len(c['first_ten']):break
if not can_reserve(spent,len(active),c['limits']['preparation_cpu_seconds']):
if not active: cut='NOT_RUN_BUDGET'
else: waiting='WAIT_ACTIVE_BUDGET_SETTLEMENT'
break
if available<10*2**30: waiting='WAIT_AVAILABLE_MEMORY';break
contract(root)
index=c['dispatch'][cursor];slot=next(i for i in range(4) if i not in active)
dest=part_dir(root,c,index);dest.mkdir(parents=True,exist_ok=True)
if (dest/'worker.started.json').exists(): raise InputViolation('Attempt already exists')
log=(dest/'guard.log').open('x')
proc=subprocess.Popen([sys.executable,'tools/run_o1_prepare.py','guard',str(root),str(index),str(slot)],
stdout=log,stderr=subprocess.STDOUT,env=env,start_new_session=True)
active[slot]=dict(process=proc,index=index,log=log);cursor+=1;available-=8*2**30
if reason:
if not (root/'global-stop.json').exists():save(root/'global-stop.json',dict(reason=reason,unix=time.time()))
for item in active.values():
if not item.get('stop_sent'):
try:item['process'].send_signal(signal.SIGTERM)
except ProcessLookupError:pass
item['stop_sent']=True
save(root/'progress.json',dict(terminal_attempts=len(records),metadata_excluded=sum(bool(p.get('metadata_failure')) for p in c['parts']),
active={str(s):dict(index=v['index'],case=c['parts'][v['index']]['case'],guard_pid=v['process'].pid) for s,v in active.items()},
preparation_cpu_seconds=spent,live_guard_and_worker_cpu_seconds=live,reserved_active_cpu_seconds=len(active)*1800,
total_rss_bytes=rss,disk_bytes=disk,first_ten_gate_passed=gate,cut=cut,global_stop=reason,waiting=waiting,
monitor_errors=errors,wall_seconds=time.monotonic()-start,fit_started=False))
if not active and (reason or cut or cursor==len(c['dispatch'])):break
time.sleep(.2)
except Exception as exc:
reason='COORDINATOR_EXCEPTION'
save(root/'coordinator-failure.json',dict(type=type(exc).__name__,message=str(exc)))
save(root/'global-stop.json',dict(reason=reason))
finally:
for item in active.values():
try:item['process'].send_signal(signal.SIGTERM)
except ProcessLookupError:pass
for item in active.values():
item['process'].wait();item['log'].close();p=part_dir(root,c,item['index'])/'guard-result.json'
if p.exists():records.append(read(p))
else:accounting=False
complete=not reason and not cut and accounting and len(records)==len(c['dispatch'])
roster_hash=freeze_results(root,c,records,complete)
save(root/'complete.json',dict(status='PREPARATION_COMPLETE' if complete else 'PREPARATION_STOPPED',
global_stop=reason,cut=cut,accounting_complete=accounting,records=records,
never_attempted=[c['parts'][i]['case'] for i in c['dispatch'][cursor:]],
preparation_cpu_seconds=c['initial_preparation_cpu_seconds']+sum(r['worker']['cpu_seconds'] for r in records),
guard_cpu_seconds=sum(r.get('guard_cpu_seconds',0) for r in records),coordinator_cpu_seconds=time.process_time(),
common_roster_sha256=roster_hash,monitor_errors=errors,fit_started=False,new_label_decodes=0,
next='No auto fit launch; R4bc terminal dependency and model implementation still required'))
return 0 if complete else 1
if __name__=='__main__':
p=argparse.ArgumentParser();p.add_argument('mode',choices=['run','guard']);p.add_argument('root',type=Path)
p.add_argument('index',type=int,nargs='?');p.add_argument('slot',type=int,nargs='?');a=p.parse_args()
raise SystemExit(run(a.root) if a.mode=='run' else guard(a.root,a.index,a.slot))
+136
View File
@@ -0,0 +1,136 @@
"""Synthetic acceptance for the fixed O1 geometry intervention; no real data."""
import itertools
import unittest
import numpy as np
from scipy.spatial.distance import pdist
from o1_partition import (Metis, canonical_mesh, graph, canonical_labels, quantize,
partition_metrics, match, diameter, shuffle_type, readout, objective,
interface_difference, common_roster, can_reserve, GeometryFailure, InputViolation)
def box(nx=8, ny=4, nz=4):
points = np.array(list(itertools.product(range(nx+1), range(ny+1), range(nz+1))), dtype=float)
lookup = {tuple(p): i for i, p in enumerate(points)}
tets = []
for low in itertools.product(range(nx), range(ny), range(nz)):
for perm in itertools.permutations(range(3)):
p = np.array(low); cell = [lookup[tuple(p)]]
for axis in perm:
p = p.copy(); p[axis] += 1; cell.append(lookup[tuple(p)])
tets.append(cell)
return points, np.array(tets), np.arange(len(points))*3+11, np.arange(len(tets))*7+5
class O1Acceptance(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.source = box(); cls.mesh = canonical_mesh(*cls.source)
cls.g = graph(cls.mesh); cls.engine = Metis()
cls.labels, cls.call = cls.engine.partition(cls.g, cls.mesh['raw_cells'], 0)
def test_same_seed_same_input_twice_exact(self):
again, receipt = self.engine.partition(self.g, self.mesh['raw_cells'], 0)
np.testing.assert_array_equal(self.labels, again)
self.assertEqual(self.call, receipt)
def test_fixed_ufactor_and_physical_volume_reachable(self):
self.assertEqual(self.call['options'][16], 50)
self.assertEqual(self.call['options'][11], 1)
m = partition_metrics(self.mesh, self.g, self.labels)
self.assertGreaterEqual(min(m['fractions']), .95/8)
self.assertLessEqual(max(m['fractions']), 1.05/8)
self.assertEqual(len(m['diameters']), 8)
def test_csr_and_raw_identity_ignore_traversal_order(self):
x, t, rn, rc = self.source
rng = np.random.default_rng(31)
no, co = rng.permutation(len(x)), rng.permutation(len(t))
inverse = np.empty(len(x), dtype=int); inverse[no] = np.arange(len(x))
moved = canonical_mesh(x[no], inverse[t[co, ::-1]], rn[no], rc[co])
changed = graph(moved)
for key in ['points', 'tets', 'raw_nodes', 'raw_cells', 'volume']:
np.testing.assert_array_equal(self.mesh[key], moved[key])
for key in ['xadj', 'adjncy', 'vwgt', 'adjwgt', 'edges', 'area', 'faces_raw']:
np.testing.assert_array_equal(self.g[key], changed[key])
labels, _ = self.engine.partition(changed, moved['raw_cells'], 0)
np.testing.assert_array_equal(self.labels, labels)
def test_numbering_invariance_and_interface_identity(self):
relabeled = np.array([4, 6, 0, 7, 1, 3, 2, 5])[self.labels]
np.testing.assert_array_equal(canonical_labels(relabeled, self.mesh['raw_cells']), self.labels)
self.assertEqual(interface_difference(self.labels, relabeled, self.g)['value'], 0)
b = self.mesh['points'][self.mesh['tets']].mean(axis=1)[:, :2]
a = readout(self.mesh['tets'], self.mesh['volume'], b, self.labels, len(self.mesh['points']))
c = readout(self.mesh['tets'], self.mesh['volume'], b, relabeled, len(self.mesh['points']))
np.testing.assert_array_equal(a, c)
def test_boundary_blending_matches_independent_sums(self):
t, v, labels = self.mesh['tets'], self.mesh['volume'], self.labels
b = np.column_stack((np.arange(len(t))*.01, np.arange(len(t))*.02))
out = readout(t, v, b, labels, len(self.mesh['points']))
for node in [0, 34, 100, len(out)-1]:
incident = np.flatnonzero(np.any(t == node, axis=1)); expected = np.zeros(2)
for k in incident:
r = np.flatnonzero(labels == labels[k])
expected += v[k]*np.average(b[r], weights=v[r], axis=0)
expected /= v[incident].sum()
np.testing.assert_allclose(out[node], expected, rtol=1e-14, atol=1e-14)
def test_quantization_positive_bounded_and_invalid_rejected(self):
a = np.array([1e-20, 1., 20.]); w, e = quantize(a)
self.assertGreater(w.min(), 0); self.assertLessEqual(int(w.astype(np.int64).sum()), 2*2**26)
self.assertGreaterEqual(e['L1'], 0)
with self.assertRaises(GeometryFailure): quantize(np.array([0., 1.]))
def test_exact_diameter_not_bounding_box(self):
points = np.array([[0,0,0],[1,0,0],[0,1,0],[0,0,1],[.1,.1,.1]], dtype=float)
d, n = diameter(points, block=2)
self.assertEqual(d, float(pdist(points).max()))
self.assertNotEqual(d, np.sqrt(3)); self.assertEqual(n, 4)
def test_whole_triples_shuffle_only_within_volume_strata(self):
n = 103; z = np.arange(n*3).reshape(n, 3); volume = np.repeat(np.arange(11)+1, 10)[:n]
raw = np.arange(n)[::-1]
a, perm = shuffle_type(z, volume, raw, 3)
b, p2 = shuffle_type(z, volume, raw, 3)
np.testing.assert_array_equal(a, z[perm]); np.testing.assert_array_equal(a, b)
np.testing.assert_array_equal(perm, p2)
for ids in np.array_split(np.lexsort((raw, volume)), 10):
self.assertEqual(set(ids), set(perm[ids]))
with self.assertRaises(InputViolation): shuffle_type(z, volume, raw, '3')
def test_true_constant_field_objective_and_readout(self):
z = np.ones((len(self.labels), 3))*.125
self.assertAlmostEqual(objective(z, self.mesh['volume'], self.labels), 0., places=25)
out = readout(self.mesh['tets'], self.mesh['volume'], z, self.labels, len(self.mesh['points']))
np.testing.assert_allclose(out, .125, atol=1e-15)
def test_physical_and_pair_matching_hard_limits(self):
m = dict(fractions=[.125]*8, cut_area=10., diameters=[2.]*8)
self.assertTrue(match(m, m)['passed'])
self.assertFalse(match(dict(m, cut_area=10.51), m)['passed'])
self.assertFalse(match(dict(m, diameters=[2.101]*8), m)['passed'])
self.assertFalse(match(dict(m, fractions=[.12]*8), m)['passed'])
a, b = dict(m, cut_area=10.49), dict(m, cut_area=9.51)
self.assertTrue(match(a, m)['passed']); self.assertTrue(match(b, m)['passed'])
self.assertFalse(match(a, b, mutual=True)['passed'])
def test_multicomponent_and_duplicate_tets_fail(self):
x, t, rn, rc = self.source
with self.assertRaises(GeometryFailure):
canonical_mesh(x, np.vstack([t, t[:1]]), rn, np.r_[rc, rc.max()+1])
x2 = np.vstack([x, x+100]); t2 = np.vstack([t, t+len(x)])
with self.assertRaisesRegex(GeometryFailure, 'MULTICOMPONENT_SCOPE'):
graph(canonical_mesh(x2, t2, np.arange(len(x2)), np.arange(len(t2))))
def test_full_component_intersection_and_budget_reservation(self):
parts = [{'case':'a','component_id':'X'},{'case':'b','component_id':'X'},{'case':'c','component_id':'Y'}]
rows, excluded = common_roster(parts, {'a':{'status':'PASS'},'b':{'status':'FAIL'},'c':{'status':'PASS'}})
self.assertEqual(rows, parts[2:]); self.assertEqual(excluded, ['X'])
self.assertTrue(can_reserve(36000, 3)); self.assertFalse(can_reserve(36000.1, 3))
self.assertFalse(can_reserve(float('nan'), 0))
if __name__ == '__main__': unittest.main(verbosity=2)
+130
View File
@@ -0,0 +1,130 @@
"""Synthetic mixed-VTU ingestion and complete 32-seed preparation acceptance."""
import base64
import json
from pathlib import Path
import tempfile
import unittest
from unittest.mock import patch
from xml.etree import ElementTree as ET
from zipfile import ZipFile
import zlib
import numpy as np
from test_o1_partition import box
from o1_partition import sha, InputViolation
from o1_prepare import prepare, source_geometry, load_inputs
from run_o1_prepare import cost_check
from gre24_features import COLUMNS
def save(path, value):
Path(path).write_text(json.dumps(value))
def array(parent, name, values, dtype, components=1):
a = np.asarray(values)
data = a.tobytes(); compressed = zlib.compress(data)
header = np.array([1,len(data),len(data),len(compressed)],dtype='<u4').tobytes()
e=ET.SubElement(parent,'DataArray',Name=name,type=dtype,format='binary',NumberOfComponents=str(components))
e.text=(base64.b64encode(header)+base64.b64encode(compressed)).decode()
def fixture(root):
x,t,_,_=box();case='00000003_synthetic_step_002'
tree=ET.Element('VTKFile',byte_order='LittleEndian',compressor='vtkZLibDataCompressor',header_type='UInt32')
piece=ET.SubElement(ET.SubElement(tree,'UnstructuredGrid'),'Piece',NumberOfPoints=str(len(x)),NumberOfCells=str(len(t)+1))
array(ET.SubElement(piece,'Points'),'Points',x.astype('<f8'),'Float64',3)
cells=ET.SubElement(piece,'Cells')
# A non-tet first cell forces actual VTU tet IDs to start at 1.
array(cells,'connectivity',np.r_[t[0,:3],t.ravel()].astype('<i8'),'Int64')
array(cells,'offsets',np.r_[3,3+4*np.arange(1,len(t)+1)].astype('<i8'),'Int64')
array(cells,'types',np.r_[5,np.full(len(t),10)].astype('u1'),'UInt8')
poison=ET.SubElement(ET.SubElement(piece,'PointData'),'DataArray',Name='Fill_time',type='Float64',format='binary')
poison.text='THIS MUST NEVER BE DECODED'
archive=root/'source.zip'
with ZipFile(archive,'w') as z:z.writestr(case+'_sim.vtu',ET.tostring(tree))
pr=root/'old';vr=root/'v5';pr.mkdir();vr.mkdir()
np.savez(pr/'geometry.npz',points_raw=x,tetra=t[::-1,::-1],raw_node_ids=np.arange(len(x)))
queries=np.array([1,3,8]);counts=np.array([4,2,1])
np.savez(pr/'queries.npz',eligible_s2=np.ones(3,dtype=bool),raw_node_ids=queries,multiplicity=counts)
features=np.zeros((len(x),19));features[:,0]=x[:,0]/8
np.save(vr/'features.npy',features);np.save(vr/'raw_ids.npy',np.arange(len(x)))
save(pr/'result.json',dict(case=case,status='PASS'))
save(vr/'result.json',dict(case=case,status='PASS',t_scale_seconds=.4,features=dict(columns=list(COLUMNS))))
row=dict(case=case,numeric_case=3,tets=len(t),nodes=len(x),component_id='synthetic',
preparation=dict(preparation_root=str(pr),t_set=.4,result_sha256=sha(pr/'result.json'),
output_sha256={p.name:sha(p) for p in pr.glob('*.npz')}),
v5_cache=dict(output=str(vr),t_scale_seconds=.4,result_sha256=sha(vr/'result.json'),
output_sha256={p.name:sha(p) for p in vr.glob('*.npy')}))
st=archive.stat();c=dict(parts=[row],archive=str(archive),archive_stat=dict(bytes=st.st_size,mtime_ns=st.st_mtime_ns,inode=st.st_ino),
source_sha256={},code_sha256={})
save(root/'contract.json',c)
return c,row,x,t
class PreparationAcceptance(unittest.TestCase):
def setUp(self):
self.temp=tempfile.TemporaryDirectory();self.root=Path(self.temp.name)
self.c,self.row,self.x,self.t=fixture(self.root)
def tearDown(self):self.temp.cleanup()
def test_mixed_cell_ids_and_no_pointdata_decode(self):
mesh,decoded=source_geometry(self.c['archive'],self.row['case'])
np.testing.assert_array_equal(mesh['raw_cells'],np.arange(1,len(self.t)+1))
self.assertEqual(decoded,['Points','connectivity','offsets','types'])
np.testing.assert_array_equal(mesh['points'],self.x)
def test_field_section_before_geometry_refused(self):
p=self.root/'bad.zip'
xml='<VTKFile byte_order="LittleEndian" compressor="vtkZLibDataCompressor"><PointData/></VTKFile>'
with ZipFile(p,'w') as z:z.writestr(self.row['case']+'_sim.vtu',xml)
with self.assertRaises(InputViolation):source_geometry(p,self.row['case'])
def test_full_32_seed_prepare_without_any_labels_or_model(self):
before=sha(Path(self.row['v5_cache']['output'])/'features.npy')
original=np.load;opened=[]
def tracked(path,*a,**kw):
opened.append(str(path))
if any(name in str(path) for name in ['target.npy','seconds.npy','label-index']):
raise AssertionError('Label read forbidden')
return original(path,*a,**kw)
with patch('numpy.load',side_effect=tracked):
self.assertEqual(prepare(self.root,0),0)
dest=self.root/'parts'/self.row['case']/'output'
result=json.loads((dest/'result.json').read_text())
self.assertEqual(result['status'],'PASS');self.assertEqual(result['candidate_calls'],32)
self.assertFalse(result['model_fit']);self.assertFalse(result['label_cache_opened'])
self.assertEqual(result['labels_decoded'],[])
self.assertEqual(sha(Path(self.row['v5_cache']['output'])/'features.npy'),before)
self.assertEqual(len(list(dest.glob('partition-*.npz'))),32)
self.assertEqual(result['seeds'],dict(G=0,T=0,C=0))
with self.assertRaises(FileExistsError):prepare(self.root,0)
def test_frozen_feature_mutation_is_global_input_failure(self):
p=Path(self.row['v5_cache']['output'])/'features.npy'
with p.open('ab') as f:f.write(b'changed')
self.assertEqual(prepare(self.root,0),1)
failure=json.loads((self.root/'parts'/self.row['case']/'output/failure.json').read_text())
self.assertTrue(failure['global_stop']);self.assertEqual(failure['type'],'InputViolation')
def test_input_alignment_preserves_queries_and_whole_features(self):
mesh,f,q,provenance=load_inputs(self.c,self.row)
np.testing.assert_array_equal(q['raw_ids'],[1,3,8]);np.testing.assert_array_equal(q['counts'],[4,2,1])
np.testing.assert_array_equal(f[:,0],self.x[:,0]/8)
self.assertEqual(provenance['labels_decoded'],[])
def test_cost_checkpoint_no_complete_library_is_not_extrapolated(self):
p=self.root/'measurement.json';save(p,dict(status='INELIGIBLE',candidate_calls=1))
c=dict(first_ten=[0],dispatch=[0,1],parts=[{'tets':100},{'tets':1000}],
initial_preparation_cpu_seconds=60,limits=dict(preparation_cpu_seconds=43200))
records=[dict(index=0,case='synthetic',result_path=str(p),result_sha256=sha(p),worker=dict(status='PASS',cpu_seconds=5))]
self.assertFalse(cost_check(c,records)['passed'])
save(p,dict(status='PASS',candidate_calls=32));records[0]['result_sha256']=sha(p)
result=cost_check(c,records);self.assertTrue(result['passed'])
self.assertEqual(result['total_projected_cpu_seconds'],115)
c['limits']['preparation_cpu_seconds']=100
self.assertFalse(cost_check(c,records)['passed'])
if __name__=='__main__':unittest.main(verbosity=2)