Add DENIM capability extension v4

Add 1,000 long-cycle, full-3D, AgentFEM-derived and discretization/observation trajectories with checksums and quality evidence.

DENIM_CAPABILITY_V4_SHA256SUMS

@@ -0,0 +1,17 @@
+79265c6bbe4fbeef4f9f8f2923bbf57392e9d08b15ade2c382e9d4dbc358bc1c  README.md
+43127dea2e4c342ac230cc941358f70b50f8d9b57af7955c6e1ad185b45ddc77  artifacts/t2_denim_capability_v4/QUALITY_REPORT.md
+fa15c3bb35e7ad34cdabfff5bfceae32fb4503529ba95c9ea5bc861a3077c652  artifacts/t2_denim_capability_v4/audit.json
+40dbfe5ac92c84acf207ecf0748cbaf1575fbbb471a7839dac9d1d90dc9606c6  artifacts/t2_denim_capability_v4/capability_extension_preview.png
+4ea985601b0e596d41ed3df747b86b15483deb6b4e249b44b3bca09739ca1add  artifacts/t2_denim_capability_v4/capability_summary.json
+cc39a7c9fcd1756f80deb5eaacf97082e83c6c1c073657b451c68f1cafba5125  artifacts/t2_denim_capability_v4/quality.json
+ac79f463be9a13c7d8382b8ac2465f333bbae65d07c94d0034e5e869bbe55604  configs/t2_denim_capability_v4.json
+b6f797a38bfdfa964093fccc844c5ce6a548d630d30cf7f90c152d3cc5990c97  data/t2_denim_capability_v4/README.md
+d41b5f62b89f0bd5ad29b6682093add0eeaf0a30fbfd76d7e62f310c039c32f1  data/t2_denim_capability_v4/cohort.h5
+49b454971df8f9b0d4f9311baad211d154240a2c7ced6c4cf6e98b893ca9cc2f  data/t2_denim_capability_v4/index.csv
+4a1f97a775d7168f068f2d6e5b21c27a0f1a872b5fe0de63b2f1ce71c713f972  data/t2_denim_capability_v4/index.jsonl
+cc39a7c9fcd1756f80deb5eaacf97082e83c6c1c073657b451c68f1cafba5125  data/t2_denim_capability_v4/manifest.json
+4f2f33836b38188f5f0d6c5a309b0764a3eaa1893b2a1b387e4ca56ced9ab9a9  data/t2_denim_capability_v4/structure_bases.npz
+3af402ecc46919436ec2dea1c07426dff8e6782fb10a4dd681e1d3683d89e799  docs/T2_DENIM_CAPABILITY_V4.md
+1fbc923311b7279b10f7db38c7e4e720a9f027b38eca4fb52e34b95b01d6429c  src/analyze_t2_denim_capability_v4.py
+038c9018d5c8c154f5cbd2cb00cccca6df7ea18eb97bde7b73e7086524104f7d  src/generate_t2_denim_capability_v4.py
+5b6ba71f89aa9b3967327954a7fab047fdbbce270278520802dee99912a43073  tests/test_t2_denim_capability_v4.py

README.md

@@ -35,8 +35,11 @@ repository contains four related, explicitly separated research protocols.
   two-memory DENIM model must learn the missing internal-variable closure.
 - **T2 DENIM boundary v1:** 500 additional trajectories for training-density,
   path, amplitude, long-history and integration-resolution boundaries.
+- **T2 DENIM capability v4:** 1,000 trajectories for 100-cycle horizons,
+  full six-component loading, AgentFEM-derived structural paths and paired
+  discretization/noisy-observation tests.
 
-The repository therefore contains **2,660 complete trajectories**.  Releases
+The repository now contains **3,660 complete trajectories**. The original 2,660-role protocol remains frozen; the v4 extension has separate train/validation/test roles and does not retroactively alter published scores.  Releases
 are used as a staged evidence chain; they are not presented as 2,660
 exchangeable samples from one training distribution.
 
@@ -107,6 +110,25 @@ Expanded-DENIM RMSE on matched 61/121/481/961-state histories was
 - Full metrics: `artifacts/t2_denim_boundary_v1/model_metrics.json`
 - All-data usage: `docs/T2_ALL_DATA_STAGE_SUMMARY.md`
 
+
+## DENIM capability extension v4
+
+![Capability extension preview](artifacts/t2_denim_capability_v4/capability_extension_preview.png)
+
+The v4 increment adds 1,000 complete trajectories: 300 long-cycle, 300 full
+six-component non-proportional, 200 AgentFEM-derived local structural paths and
+200 matched discretization/observation trajectories. The 100-cycle histories
+contain 2,001 accepted material states. Fifty continuous paths are integrated
+at 61, 121, 241 and 481 states and carry explicit group IDs; noisy and sparse
+observations are fields paired with clean truth, not separately counted cases.
+
+The structure-derived cohort uses local strain bases from twelve AgentFEM
+linear-elastic unit-load solves on four perforated/notched plates, followed by
+nonlinear reference-material replay. It does not claim coupled elastoplastic
+redistribution. See `data/t2_denim_capability_v4/README.md` for the exact
+protocol and `artifacts/t2_denim_capability_v4/capability_summary.json` for
+machine-readable boundary statistics.
+
 ## AgentFEM runtime validation
 
 The expanded DENIM checkpoint is also available as a checksum-authenticated

artifacts/t2_denim_capability_v4/QUALITY_REPORT.md

@@ -0,0 +1,51 @@
+# DENIM能力边界扩展v4质量报告
+
+## 数据规模
+
+- 新增完整轨迹：1,000条；
+- 长循环：300条，其中训练10/25循环、验证50循环、测试100循环；
+- 完整三维非比例加载：300条，覆盖六个路径族；
+- AgentFEM结构来源路径：200条，来自4个几何、12次单位载荷有限元求解；
+- 步长与观测鲁棒性：200条，即50个连续路径分别采用61/121/241/481个状态点；
+- 正式HDF5大小：111,577,525 bytes；
+- 生成时间：450.10 s；AgentFEM提交`40c965225fc3b8d12a93a68e0d6b01dd35d47d82`。
+
+## 数据完整性和物理门
+
+- 1,000/1,000轨迹组完整，case ID全部唯一；
+- 缺失必需字段：0；非有限数组：0；
+- 最大屈服面相对残差：`9.35e-11`；
+- 塑性应变最大绝对迹：`1.84e-17`；
+- PEEQ最小增量：0；
+- 每条轨迹至少包含35个塑性增量；
+- HDF5 SHA-256：`d41b5f62b89f0bd5ad29b6682093add0eeaf0a30fbfd76d7e62f310c039c32f1`。
+
+## 能力边界统计
+
+完整三维队列的中位活跃Voigt分量数为6，83.33%的轨迹六个分量均有显著变化；
+仅三剪切旋转族按设计只激活三个剪切分量。长循环测试包含80条100循环、每条
+2,001状态的轨迹，终态PEEQ中位值为2.308，属于主动施加的严苛累积塑性压力测试。
+
+以481点轨迹为参考，配对路径的应力RMSE中位值分别为：61点2.641 MPa、
+121点1.221 MPa、241点0.431 MPa。该结果说明时间步离散误差不可忽略，也使
+数据能够区分模型误差和参考积分误差。
+
+观测协议实际保留17.4%—73.6%的状态点，中位保留率43.1%；应变噪声相对RMSE
+中位值为0.184%，应力噪声RMSE中位值为0.886 MPa。干净真值、带噪观测和掩码
+同时保存，噪声副本不计作新的物理轨迹。
+
+## 结构来源说明
+
+结构路径来自两种孔径的中心孔板和两种缺口深度的双边缺口板。每个结构由
+AgentFEM求解右侧拉伸、右侧剪切和顶部拉伸三个线弹性单位载荷工况，保留50个
+DG0局部应变探针，再组合加载系数并通过隐藏参考材料回放。
+
+这种方法提供有限元几何和边界条件产生的局部多轴路径，同时保持生成成本可控。
+它是单向结构路径提取，不包含塑性变形引起的全局应力重分布，因此不能表述为
+200个完整非线性结构有限元算例。
+
+## 结论
+
+本批数据通过完整性和材料积分物理门，并补齐长期状态、六分量加载、结构局部路径、
+时间离散及不完整观测五类边界。它可直接作为独立测试协议，也可使用明确标记的
+训练/验证子集扩展后续条件化DENIM；既有2,660条冻结协议和已发布模型成绩不改变。

artifacts/t2_denim_capability_v4/audit.json

@@ -0,0 +1,11 @@
+{
+  "case_id_unique": true,
+  "data_sha256_matches_manifest": true,
+  "grouped_resolution_protocol": true,
+  "hdf5_group_count": 1000,
+  "missing_required_fields": [],
+  "nonfinite_required_field_count": 0,
+  "passed": true,
+  "sample_count": 1000,
+  "structure_group_count": 4
+}

artifacts/t2_denim_capability_v4/capability_summary.json

@@ -0,0 +1,86 @@
+{
+  "cohort_counts": {
+    "discretization_and_observation": 200,
+    "full_3d_nonproportional": 300,
+    "long_cycle": 300,
+    "structure_derived": 200
+  },
+  "full_3d_component_coverage": {
+    "all_six_components_active_fraction": 0.8333333333333334,
+    "median_active_voigt_components": 6.0,
+    "minimum_active_voigt_components": 3
+  },
+  "long_cycle_final_peeq": {
+    "test_long_cycle_ood": {
+      "count": 80,
+      "maximum": 5.581917596143634,
+      "median": 2.3076562056597267
+    },
+    "train_long_cycle": {
+      "count": 180,
+      "maximum": 1.4800164833029583,
+      "median": 0.32780349102780304
+    },
+    "validation_long_cycle": {
+      "count": 40,
+      "maximum": 2.9068227791273844,
+      "median": 1.2485704946120229
+    }
+  },
+  "matched_resolution_stress_rmse_mpa_against_481": {
+    "121": {
+      "maximum": 2.406609951745476,
+      "median": 1.2205367812383774
+    },
+    "241": {
+      "maximum": 0.8241333324801416,
+      "median": 0.4308617630836392
+    },
+    "481": {
+      "maximum": 0.0,
+      "median": 0.0
+    },
+    "61": {
+      "maximum": 9.097942729314207,
+      "median": 2.6405965053574985
+    }
+  },
+  "observation_protocol": {
+    "relative_strain_noise_rmse_median": 0.0018371038946513683,
+    "retained_fraction_maximum": 0.7355371900826446,
+    "retained_fraction_median": 0.43064366791262304,
+    "retained_fraction_minimum": 0.17427385892116182,
+    "stress_noise_rmse_mpa_median": 0.8856837636279857
+  },
+  "quality": {
+    "all_finite_failures": 0,
+    "maximum_plastic_strain_trace": 1.8431436932253575e-17,
+    "maximum_yield_surface_relative_residual": 9.34668949672154e-11,
+    "minimum_peeq_increment": 0.0,
+    "minimum_plastic_step_count": 35
+  },
+  "sample_count": 1000,
+  "schema": "agentfem.physics-data.denim-capability-extension.analysis",
+  "structure_derived": {
+    "central_hole_r018": {
+      "maximum_absolute_stress_mpa": 2306.726179813209,
+      "maximum_peeq": 0.06563635906127516,
+      "trajectory_count": 50
+    },
+    "central_hole_r026": {
+      "maximum_absolute_stress_mpa": 1988.2837702754796,
+      "maximum_peeq": 0.049314129288541834,
+      "trajectory_count": 50
+    },
+    "double_notch_r016": {
+      "maximum_absolute_stress_mpa": 2415.98591600656,
+      "maximum_peeq": 0.057808976722212205,
+      "trajectory_count": 50
+    },
+    "double_notch_r024": {
+      "maximum_absolute_stress_mpa": 2633.793143427893,
+      "maximum_peeq": 0.06691511987967692,
+      "trajectory_count": 50
+    }
+  }
+}

artifacts/t2_denim_capability_v4/quality.json

@@ -0,0 +1,71 @@
+{
+  "agentfem_commit": "40c965225fc3b8d12a93a68e0d6b01dd35d47d82",
+  "cohort_counts": {
+    "discretization_and_observation": 200,
+    "full_3d_nonproportional": 300,
+    "long_cycle": 300,
+    "structure_derived": 200
+  },
+  "complete_release": true,
+  "counting_rule": "One sample is one complete trajectory. Observation noise/masks are fields, not extra samples. Matched resolutions are explicitly grouped.",
+  "data_bytes": 111577525,
+  "data_sha256": "d41b5f62b89f0bd5ad29b6682093add0eeaf0a30fbfd76d7e62f310c039c32f1",
+  "generation_seconds": 450.09614487504587,
+  "group_count": 654,
+  "index_csv_sha256": "49b454971df8f9b0d4f9311baad211d154240a2c7ced6c4cf6e98b893ca9cc2f",
+  "index_jsonl_sha256": "4a1f97a775d7168f068f2d6e5b21c27a0f1a872b5fe0de63b2f1ce71c713f972",
+  "path_family_counts": {
+    "biaxial_torsion_reversal": 50,
+    "fe_random_load_blocks": 40,
+    "fe_reversed_mixed_cycle": 40,
+    "fe_rotating_load_vector": 40,
+    "fe_tension_bending_sequence": 40,
+    "fe_tension_shear_lissajous": 40,
+    "hydro_deviatoric_sequence": 50,
+    "nonproportional_square": 99,
+    "orthogonal_cross": 24,
+    "out_of_phase_lissajous": 99,
+    "principal_axis_rotation_3d": 50,
+    "proportional_axial_cycle": 103,
+    "proportional_shear_cycle": 28,
+    "random_direction_blocks": 24,
+    "rotating_principal_cycle": 24,
+    "sequential_axial_shear": 99,
+    "six_component_random_blocks": 50,
+    "three_shear_rotation": 50,
+    "triaxial_phase_lissajous": 50
+  },
+  "point_count_distribution": {
+    "1001": 40,
+    "121": 50,
+    "2001": 80,
+    "201": 90,
+    "241": 550,
+    "481": 50,
+    "501": 90,
+    "61": 50
+  },
+  "quality": {
+    "all_finite_failures": 0,
+    "maximum_plastic_strain_trace": 1.8431436932253575e-17,
+    "maximum_yield_surface_relative_residual": 9.34668949672154e-11,
+    "minimum_peeq_increment": 0.0,
+    "minimum_plastic_step_count": 35
+  },
+  "reference_material": "hidden three-memory Chaboche with tabulated isotropic hardening",
+  "sample_count": 1000,
+  "schema": "agentfem.physics-data.denim-capability-extension",
+  "schema_version": "4.0.0",
+  "split_counts": {
+    "test_discretization_observation": 200,
+    "test_full_3d_ood": 100,
+    "test_long_cycle_ood": 80,
+    "test_structure_derived": 200,
+    "train_full_3d": 144,
+    "train_long_cycle": 180,
+    "validation_full_3d": 56,
+    "validation_long_cycle": 40
+  },
+  "structure_bases_sha256": "4f2f33836b38188f5f0d6c5a309b0764a3eaa1893b2a1b387e4ca56ced9ab9a9",
+  "structure_fidelity": "AgentFEM linear-elastic unit-load strain bases with one-way nonlinear material replay; no coupled elastoplastic redistribution claim"
+}

configs/t2_denim_capability_v4.json

@@ -0,0 +1,49 @@
+{
+  "schema": "agentfem.physics-data.denim-capability-extension",
+  "schema_version": "4.0.0",
+  "seed": 20260925,
+  "sample_count": 1000,
+  "cohorts": {
+    "long_cycle": 300,
+    "full_3d_nonproportional": 300,
+    "structure_derived": 200,
+    "discretization_and_observation": 200
+  },
+  "long_cycle": {
+    "train": {"count": 180, "cycle_counts": [10, 25], "increments_per_cycle": 20},
+    "validation": {"count": 40, "cycle_counts": [50], "increments_per_cycle": 20},
+    "test": {"count": 80, "cycle_counts": [100], "increments_per_cycle": 20}
+  },
+  "full_3d_nonproportional": {
+    "points_per_trajectory": 241,
+    "families": [
+      "triaxial_phase_lissajous",
+      "principal_axis_rotation_3d",
+      "three_shear_rotation",
+      "hydro_deviatoric_sequence",
+      "six_component_random_blocks",
+      "biaxial_torsion_reversal"
+    ],
+    "samples_per_family": 50
+  },
+  "structure_derived": {
+    "points_per_trajectory": 241,
+    "structures": [
+      {"name": "central_hole_r018", "kind": "central_hole", "radius": 0.18},
+      {"name": "central_hole_r026", "kind": "central_hole", "radius": 0.26},
+      {"name": "double_notch_r016", "kind": "double_edge_notch", "radius": 0.16},
+      {"name": "double_notch_r024", "kind": "double_edge_notch", "radius": 0.24}
+    ],
+    "probe_trajectories_per_structure": 50,
+    "load_modes": ["right_tension", "right_shear", "top_tension"],
+    "source_model": "AgentFEM linear-elastic unit-load basis followed by nonlinear reference-material replay"
+  },
+  "discretization_and_observation": {
+    "matched_path_groups": 50,
+    "resolutions": [61, 121, 241, 481],
+    "strain_noise_fraction_range": [0.0005, 0.003],
+    "stress_noise_fraction_range": [0.0005, 0.005],
+    "observation_keep_fraction_range": [0.2, 0.65]
+  },
+  "scope": "Synthetic small-strain, rate-independent material histories from a fixed hidden three-memory tabulated-hardening reference. Structure-derived histories use AgentFEM linear-elastic unit-load bases and one-way constitutive replay; they are not coupled nonlinear structural solutions."
+}

data/t2_denim_capability_v4/README.md

@@ -0,0 +1,56 @@
+# DENIM Capability Extension v4
+
+This increment adds 1,000 complete trajectories to the staged AgentFEM
+Material Loading Memory dataset. It targets capability boundaries that were
+underrepresented in the frozen 2,660-trajectory release.
+
+## Cohorts
+
+| Cohort | Trajectories | Purpose |
+|---|---:|---|
+| Long-cycle | 300 | 10, 25, 50 and held-out 100-cycle state evolution |
+| Full 3D non-proportional | 300 | Six Voigt components, rotating axes, hydrostatic/deviatoric sequencing and random blocks |
+| Structure-derived | 200 | Local histories from four AgentFEM perforated/notched plate unit-load bases |
+| Discretization and observation | 200 | 50 paths at 61/121/241/481 states with clean truth plus noisy sparse observations |
+
+One sample is one complete trajectory. Noise and observation masks are stored
+as additional fields and are not counted as separate physical samples.
+Matched time resolutions share an explicit `group_id` and must remain together
+when constructing evaluation protocols.
+
+## Structure-derived fidelity
+
+AgentFEM solves three linear-elastic unit-load cases on each of four 2D
+structures. Local DG0 strain bases are superposed under time-dependent load
+coefficients and replayed through the hidden nonlinear reference material.
+These are genuine finite-element-derived local path shapes, but they do not
+include coupled elastoplastic stress redistribution. They are therefore a
+bridge between hand-designed material-point paths and global nonlinear FEM,
+not a substitute for the latter.
+
+## Main files
+
+- `cohort.h5`: lossless trajectories and provenance fields;
+- `index.jsonl` and `index.csv`: viewer-friendly trajectory metadata;
+- `manifest.json`: counts, hashes, physical quality gates and AgentFEM commit;
+- `structure_bases.npz`: the four groups of AgentFEM local strain bases;
+- `configs/t2_denim_capability_v4.json`: frozen design;
+- `src/generate_t2_denim_capability_v4.py`: complete generator;
+- `src/analyze_t2_denim_capability_v4.py`: paired-resolution and observation audit.
+
+## Fields
+
+Every trajectory contains tensor-shear Voigt arrays in the order
+`xx, yy, zz, xy, yz, xz`: total strain, stress, plastic strain, two visible
+memory channels, three reference memory channels, PEEQ, plastic increment,
+isotropic radius and normalized history coordinate. Observation trajectories
+also contain `observed_strain`, `observed_stress_pa`, and `observation_mask`.
+Structure-derived trajectories additionally retain the source coordinate,
+cell index, three local unit-load strain bases and load-mode coefficients.
+
+## Scope
+
+The data are synthetic, small-strain and rate-independent. The reference is a
+fixed three-memory Chaboche-type material with tabulated isotropic hardening.
+The release is not experimental calibration, fatigue-life data, damage data,
+finite-strain plasticity, or a certified material card.

data/t2_denim_capability_v4/cohort.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d41b5f62b89f0bd5ad29b6682093add0eeaf0a30fbfd76d7e62f310c039c32f1
+size 111577525

data/t2_denim_capability_v4/manifest.json

@@ -0,0 +1,71 @@
+{
+  "agentfem_commit": "40c965225fc3b8d12a93a68e0d6b01dd35d47d82",
+  "cohort_counts": {
+    "discretization_and_observation": 200,
+    "full_3d_nonproportional": 300,
+    "long_cycle": 300,
+    "structure_derived": 200
+  },
+  "complete_release": true,
+  "counting_rule": "One sample is one complete trajectory. Observation noise/masks are fields, not extra samples. Matched resolutions are explicitly grouped.",
+  "data_bytes": 111577525,
+  "data_sha256": "d41b5f62b89f0bd5ad29b6682093add0eeaf0a30fbfd76d7e62f310c039c32f1",
+  "generation_seconds": 450.09614487504587,
+  "group_count": 654,
+  "index_csv_sha256": "49b454971df8f9b0d4f9311baad211d154240a2c7ced6c4cf6e98b893ca9cc2f",
+  "index_jsonl_sha256": "4a1f97a775d7168f068f2d6e5b21c27a0f1a872b5fe0de63b2f1ce71c713f972",
+  "path_family_counts": {
+    "biaxial_torsion_reversal": 50,
+    "fe_random_load_blocks": 40,
+    "fe_reversed_mixed_cycle": 40,
+    "fe_rotating_load_vector": 40,
+    "fe_tension_bending_sequence": 40,
+    "fe_tension_shear_lissajous": 40,
+    "hydro_deviatoric_sequence": 50,
+    "nonproportional_square": 99,
+    "orthogonal_cross": 24,
+    "out_of_phase_lissajous": 99,
+    "principal_axis_rotation_3d": 50,
+    "proportional_axial_cycle": 103,
+    "proportional_shear_cycle": 28,
+    "random_direction_blocks": 24,
+    "rotating_principal_cycle": 24,
+    "sequential_axial_shear": 99,
+    "six_component_random_blocks": 50,
+    "three_shear_rotation": 50,
+    "triaxial_phase_lissajous": 50
+  },
+  "point_count_distribution": {
+    "1001": 40,
+    "121": 50,
+    "2001": 80,
+    "201": 90,
+    "241": 550,
+    "481": 50,
+    "501": 90,
+    "61": 50
+  },
+  "quality": {
+    "all_finite_failures": 0,
+    "maximum_plastic_strain_trace": 1.8431436932253575e-17,
+    "maximum_yield_surface_relative_residual": 9.34668949672154e-11,
+    "minimum_peeq_increment": 0.0,
+    "minimum_plastic_step_count": 35
+  },
+  "reference_material": "hidden three-memory Chaboche with tabulated isotropic hardening",
+  "sample_count": 1000,
+  "schema": "agentfem.physics-data.denim-capability-extension",
+  "schema_version": "4.0.0",
+  "split_counts": {
+    "test_discretization_observation": 200,
+    "test_full_3d_ood": 100,
+    "test_long_cycle_ood": 80,
+    "test_structure_derived": 200,
+    "train_full_3d": 144,
+    "train_long_cycle": 180,
+    "validation_full_3d": 56,
+    "validation_long_cycle": 40
+  },
+  "structure_bases_sha256": "4f2f33836b38188f5f0d6c5a309b0764a3eaa1893b2a1b387e4ca56ced9ab9a9",
+  "structure_fidelity": "AgentFEM linear-elastic unit-load strain bases with one-way nonlinear material replay; no coupled elastoplastic redistribution claim"
+}

data/t2_denim_capability_v4/structure_bases.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f2f33836b38188f5f0d6c5a309b0764a3eaa1893b2a1b387e4ca56ced9ab9a9
+size 23114

docs/T2_DENIM_CAPABILITY_V4.md

@@ -0,0 +1,27 @@
+# DENIM能力边界扩展v4
+
+现有2,660条冻结数据已能支撑材料记忆、路径OOD、不完备物理闭合和少样本材料适配。
+本次新增1,000条，目标从“增加同类曲线”转向补齐明确的工程边界。
+
+| 新增队列 | 数量 | 核心价值 |
+|---|---:|---|
+| 长循环 | 300 | 训练10/25循环，验证50循环，冻结测试100循环 |
+| 六分量非比例加载 | 300 | 主轴旋转、三剪切旋转、静水—偏应变切换和六分量随机块 |
+| 结构来源路径 | 200 | 4个带孔/缺口几何的局部有限元应变路径 |
+| 步长与观测鲁棒性 | 200 | 50条路径的4种积分分辨率，并保存带噪稀疏观测 |
+
+数据总量由2,660条增至3,660条。原条件化DENIM v2的1,484/407/769角色继续冻结；
+本批独立提供324条训练、96条验证和580条边界测试轨迹，后续模型升级应明确区分
+“原协议成绩”和“吸收v4训练子集后的新协议成绩”。
+
+本批最重要的新信息不是数量，而是：100循环的长期演化、六维路径几何、由结构
+有限元产生的局部加载形状、积分步长误差以及现实观测中的噪声和缺失。结构来源
+队列采用AgentFEM线弹性单位载荷基加非线性材料回放，未声称包含耦合塑性重分布。
+
+机器证据：
+
+- `data/t2_denim_capability_v4/manifest.json`
+- `artifacts/t2_denim_capability_v4/quality.json`
+- `artifacts/t2_denim_capability_v4/audit.json`
+- `artifacts/t2_denim_capability_v4/capability_summary.json`
+- `artifacts/t2_denim_capability_v4/capability_extension_preview.png`

src/analyze_t2_denim_capability_v4.py

@@ -0,0 +1,184 @@
+"""Analyze and visualize DENIM capability-extension v4 without model claims."""
+
+from __future__ import annotations
+
+import json
+from collections import defaultdict
+from pathlib import Path
+
+import h5py
+import matplotlib.pyplot as plt
+import numpy as np
+
+from src.generate_t2_denim_capability_v4 import (
+    ARTIFACT_DIR,
+    DATA_PATH,
+    INDEX_PATH,
+    MANIFEST_PATH,
+    _write_json,
+)
+
+
+ROOT = Path(__file__).resolve().parents[1]
+SUMMARY_PATH = ARTIFACT_DIR / "capability_summary.json"
+PREVIEW_PATH = ARTIFACT_DIR / "capability_extension_preview.png"
+
+
+def _rmse(left: np.ndarray, right: np.ndarray) -> float:
+    return float(np.sqrt(np.mean(np.square(np.asarray(left) - np.asarray(right)))))
+
+
+def analyze() -> dict[str, object]:
+    rows = [json.loads(line) for line in INDEX_PATH.read_text(encoding="utf-8").splitlines() if line]
+    manifest = json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
+    by_group: dict[str, list[tuple[int, dict[str, object]]]] = defaultdict(list)
+    for index, row in enumerate(rows):
+        by_group[str(row["group_id"])].append((index, row))
+
+    resolution_errors: dict[int, list[float]] = defaultdict(list)
+    active_components = []
+    observation_keep = []
+    strain_noise = []
+    stress_noise_mpa = []
+    structure_metrics: dict[str, dict[str, float | int]] = {}
+    long_metrics: dict[str, list[float]] = defaultdict(list)
+
+    with h5py.File(DATA_PATH, "r") as h5:
+        for group_id, members in by_group.items():
+            if not group_id.startswith("matched-resolution-"):
+                continue
+            reference_index, _ = next((item for item in members if int(item[1]["points"]) == 481))
+            reference = h5[f"{reference_index:05d}"]
+            reference_time = reference["time_coordinate"][...]
+            reference_stress = reference["stress_pa"][...]
+            for index, row in members:
+                points = int(row["points"])
+                group = h5[f"{index:05d}"]
+                time = group["time_coordinate"][...]
+                stress = group["stress_pa"][...]
+                interpolated = np.column_stack(
+                    [np.interp(time, reference_time, reference_stress[:, component]) for component in range(6)]
+                )
+                resolution_errors[points].append(_rmse(stress, interpolated) / 1.0e6)
+                mask = group["observation_mask"][...].astype(bool)
+                observation_keep.append(float(mask.mean()))
+                strain_noise.append(
+                    _rmse(group["observed_strain"][...], group["strain"][...])
+                    / max(float(np.max(np.abs(group["strain"][...]))), 1.0e-15)
+                )
+                stress_noise_mpa.append(
+                    _rmse(group["observed_stress_pa"][...], group["stress_pa"][...]) / 1.0e6
+                )
+
+        for index, row in enumerate(rows):
+            group = h5[f"{index:05d}"]
+            cohort = str(row["cohort"])
+            if cohort == "full_3d_nonproportional":
+                strain = group["strain"][...]
+                maxima = np.max(np.abs(strain), axis=0)
+                threshold = 0.01 * max(float(maxima.max()), 1.0e-15)
+                active_components.append(int(np.count_nonzero(maxima > threshold)))
+            elif cohort == "structure_derived":
+                entry = structure_metrics.setdefault(
+                    str(row["group_id"]),
+                    {"trajectory_count": 0, "maximum_peeq": 0.0, "maximum_absolute_stress_mpa": 0.0},
+                )
+                entry["trajectory_count"] = int(entry["trajectory_count"]) + 1
+                entry["maximum_peeq"] = max(float(entry["maximum_peeq"]), float(np.max(group["peeq"][...])))
+                entry["maximum_absolute_stress_mpa"] = max(
+                    float(entry["maximum_absolute_stress_mpa"]),
+                    float(np.max(np.abs(group["stress_pa"][...]))) / 1.0e6,
+                )
+            elif cohort == "long_cycle":
+                long_metrics[str(row["split"])].append(float(group["peeq"][-1]))
+
+    summary: dict[str, object] = {
+        "schema": "agentfem.physics-data.denim-capability-extension.analysis",
+        "sample_count": len(rows),
+        "cohort_counts": manifest["cohort_counts"],
+        "quality": manifest["quality"],
+        "long_cycle_final_peeq": {
+            split: {
+                "count": len(values),
+                "median": float(np.median(values)),
+                "maximum": float(np.max(values)),
+            }
+            for split, values in sorted(long_metrics.items())
+        },
+        "full_3d_component_coverage": {
+            "minimum_active_voigt_components": int(min(active_components)),
+            "median_active_voigt_components": float(np.median(active_components)),
+            "all_six_components_active_fraction": float(np.mean(np.asarray(active_components) == 6)),
+        },
+        "structure_derived": structure_metrics,
+        "matched_resolution_stress_rmse_mpa_against_481": {
+            str(points): {
+                "median": float(np.median(values)),
+                "maximum": float(np.max(values)),
+            }
+            for points, values in sorted(resolution_errors.items())
+        },
+        "observation_protocol": {
+            "retained_fraction_minimum": float(np.min(observation_keep)),
+            "retained_fraction_median": float(np.median(observation_keep)),
+            "retained_fraction_maximum": float(np.max(observation_keep)),
+            "relative_strain_noise_rmse_median": float(np.median(strain_noise)),
+            "stress_noise_rmse_mpa_median": float(np.median(stress_noise_mpa)),
+        },
+    }
+    _write_json(SUMMARY_PATH, summary)
+    return summary
+
+
+def plot() -> Path:
+    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
+    with h5py.File(DATA_PATH, "r") as h5:
+        long = h5["00299"]
+        full3d = h5["00300"]
+        structural = h5["00600"]
+        observed = h5["00801"]
+
+        figure, axes = plt.subplots(2, 2, figsize=(13.0, 8.2), constrained_layout=True)
+
+        axes[0, 0].plot(long["time_coordinate"][...], long["stress_pa"][:, 0] / 1.0e6, lw=1.0, color="#1f6feb")
+        axes[0, 0].set_title("100-cycle long-horizon response")
+        axes[0, 0].set_xlabel("normalized history coordinate")
+        axes[0, 0].set_ylabel(r"$\sigma_{xx}$ (MPa)")
+
+        strain = full3d["strain"][...]
+        labels = ("xx", "yy", "zz", "xy", "yz", "xz")
+        for component, label in enumerate(labels):
+            axes[0, 1].plot(full3d["time_coordinate"][...], 100.0 * strain[:, component], lw=1.1, label=label)
+        axes[0, 1].set_title("Full six-component non-proportional path")
+        axes[0, 1].set_xlabel("normalized history coordinate")
+        axes[0, 1].set_ylabel("tensor strain (%)")
+        axes[0, 1].legend(ncol=3, fontsize=8, frameon=False)
+
+        axes[1, 0].plot(100.0 * structural["strain"][:, 0], structural["stress_pa"][:, 0] / 1.0e6, lw=1.5, color="#d97706")
+        axes[1, 0].set_title("AgentFEM-derived local structural path")
+        axes[1, 0].set_xlabel(r"$\varepsilon_{xx}$ (%)")
+        axes[1, 0].set_ylabel(r"$\sigma_{xx}$ (MPa)")
+
+        time = observed["time_coordinate"][...]
+        mask = observed["observation_mask"][...].astype(bool)
+        axes[1, 1].plot(time, observed["stress_pa"][:, 0] / 1.0e6, lw=1.5, color="#22c55e", label="clean truth")
+        axes[1, 1].scatter(
+            time[mask], observed["observed_stress_pa"][mask, 0] / 1.0e6,
+            s=10, alpha=0.65, color="#ef4444", label="noisy sparse observation",
+        )
+        axes[1, 1].set_title("Paired observation robustness protocol")
+        axes[1, 1].set_xlabel("normalized history coordinate")
+        axes[1, 1].set_ylabel(r"$\sigma_{xx}$ (MPa)")
+        axes[1, 1].legend(frameon=False, fontsize=8)
+
+        for axis in axes.ravel():
+            axis.grid(alpha=0.20)
+        figure.suptitle("AgentFEM DENIM capability extension v4", fontsize=16, fontweight="bold")
+        figure.savefig(PREVIEW_PATH, dpi=180)
+        plt.close(figure)
+    return PREVIEW_PATH
+
+
+if __name__ == "__main__":
+    print(json.dumps(analyze(), indent=2, sort_keys=True))
+    print(plot())

src/generate_t2_denim_capability_v4.py

@@ -0,0 +1,824 @@
+"""Generate the 1,000-trajectory DENIM capability extension v4.
+
+The extension targets four gaps left by the frozen 2,660-trajectory release:
+long-cycle state drift, full six-component loading, finite-element-derived local
+paths, and paired time-discretization/observation robustness.  Existing data
+and splits are never overwritten.  One sample remains one complete history.
+
+The structure-derived cohort is deliberately explicit about its fidelity: an
+AgentFEM linear-elastic solve supplies three local unit-load strain bases for
+four perforated/notched plates.  Time-dependent load coefficients are then
+superposed and replayed through the same nonlinear hidden reference material
+used by the DENIM closure study.  This produces genuine FE-derived local path
+shapes without claiming fully coupled elastoplastic redistribution.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import math
+import os
+import subprocess
+import time
+from collections import Counter
+from pathlib import Path
+from typing import Iterable
+
+import h5py
+import numpy as np
+
+from src.generate_t2_denim_boundary_v1 import quality as boundary_quality
+from src.generate_t2_graybox_closure import MATERIAL, material
+from src.t2_multiaxial_ood_v2 import PATH_FAMILIES, strain_history, tensor_to_voigt
+
+
+ROOT = Path(__file__).resolve().parents[1]
+CONFIG_PATH = ROOT / "configs" / "t2_denim_capability_v4.json"
+DATA_DIR = ROOT / "data" / "t2_denim_capability_v4"
+DATA_PATH = DATA_DIR / "cohort.h5"
+INDEX_PATH = DATA_DIR / "index.jsonl"
+INDEX_CSV_PATH = DATA_DIR / "index.csv"
+MANIFEST_PATH = DATA_DIR / "manifest.json"
+STRUCTURE_BASIS_PATH = DATA_DIR / "structure_bases.npz"
+ARTIFACT_DIR = ROOT / "artifacts" / "t2_denim_capability_v4"
+AGENTFEM_ROOT = Path("/Users/luo/Desktop/开发环境/fenicsx-code/agentfem")
+
+FULL_3D_FAMILIES = (
+    "triaxial_phase_lissajous",
+    "principal_axis_rotation_3d",
+    "three_shear_rotation",
+    "hydro_deviatoric_sequence",
+    "six_component_random_blocks",
+    "biaxial_torsion_reversal",
+)
+RESOLUTIONS = (61, 121, 241, 481)
+STRUCTURE_SPECS = (
+    ("central_hole_r018", "central_hole", 0.18),
+    ("central_hole_r026", "central_hole", 0.26),
+    ("double_notch_r016", "double_edge_notch", 0.16),
+    ("double_notch_r024", "double_edge_notch", 0.24),
+)
+
+
+def load_config() -> dict[str, object]:
+    return json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _write_json(path: Path, value: object) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    os.replace(temporary, path)
+
+
+def _polyline(anchors: np.ndarray, count: int) -> np.ndarray:
+    anchors = np.asarray(anchors, dtype=float)
+    distances = np.linalg.norm(np.diff(anchors, axis=0), axis=1)
+    cumulative = np.concatenate(([0.0], np.cumsum(distances)))
+    if cumulative[-1] <= 0.0:
+        return np.repeat(anchors[:1], count, axis=0)
+    target = np.linspace(0.0, cumulative[-1], count)
+    return np.column_stack(
+        [np.interp(target, cumulative, anchors[:, column]) for column in range(anchors.shape[1])]
+    )
+
+
+def _symmetric_from_voigt(values: np.ndarray) -> np.ndarray:
+    selected = np.asarray(values, dtype=float)
+    tensor = np.zeros((*selected.shape[:-1], 3, 3), dtype=float)
+    tensor[..., 0, 0] = selected[..., 0]
+    tensor[..., 1, 1] = selected[..., 1]
+    tensor[..., 2, 2] = selected[..., 2]
+    tensor[..., 0, 1] = tensor[..., 1, 0] = selected[..., 3]
+    tensor[..., 1, 2] = tensor[..., 2, 1] = selected[..., 4]
+    tensor[..., 0, 2] = tensor[..., 2, 0] = selected[..., 5]
+    return tensor
+
+
+def _equivalent_strain(strains: np.ndarray) -> np.ndarray:
+    selected = np.asarray(strains, dtype=float)
+    trace = np.trace(selected, axis1=-2, axis2=-1)[..., None, None]
+    dev = selected - trace / 3.0 * np.eye(3)
+    return np.sqrt(np.maximum(2.0 / 3.0 * np.sum(dev * dev, axis=(-2, -1)), 0.0))
+
+
+def _scale_history(strains: np.ndarray, amplitude: float) -> np.ndarray:
+    selected = np.asarray(strains, dtype=float)
+    selected = 0.5 * (selected + np.swapaxes(selected, -1, -2))
+    scale = float(np.max(_equivalent_strain(selected)))
+    if scale <= np.finfo(float).eps:
+        raise ValueError("History has zero equivalent-strain amplitude.")
+    return selected * (float(amplitude) / scale)
+
+
+def _base_parameters(
+    *, index: int, family: str, amplitude: float, seed: int, points: int
+) -> dict[str, object]:
+    rng = np.random.default_rng(seed)
+    return {
+        **MATERIAL,
+        "case_id": f"denim-capability-v4-{index:05d}",
+        "material_model": "hidden_three_memory_tabulated_hardening",
+        "path_family": family,
+        "path_seed": int(seed),
+        "path_shape_a": float(rng.random()),
+        "path_shape_b": float(rng.random()),
+        "path_shape_c": float(rng.random()),
+        "yield_design_coordinate": float(rng.random()),
+        "maximum_equivalent_strain": float(amplitude),
+        "points": int(points),
+    }
+
+
+def design(seed: int = 20260925) -> list[dict[str, object]]:
+    """Create exactly 1,000 deterministic records with frozen cohort roles."""
+
+    rng = np.random.default_rng(seed)
+    rows: list[dict[str, object]] = []
+
+    # 300 long-cycle histories. Training sees 10/25 cycles, validation 50,
+    # and the frozen test remains a true 100-cycle horizon extrapolation.
+    long_roles = (
+        (180, "train_long_cycle", (10, 25)),
+        (40, "validation_long_cycle", (50,)),
+        (80, "test_long_cycle_ood", (100,)),
+    )
+    for count, split, cycle_options in long_roles:
+        for local in range(count):
+            cycles = int(cycle_options[local % len(cycle_options)])
+            points = cycles * 20 + 1
+            family = PATH_FAMILIES[(len(rows) + local) % len(PATH_FAMILIES)]
+            row = _base_parameters(
+                index=len(rows),
+                family=family,
+                amplitude=float(rng.uniform(0.003, 0.010)),
+                seed=int(seed + len(rows) * 104729),
+                points=points,
+            )
+            row.update(
+                cohort="long_cycle",
+                split=split,
+                group_id=row["case_id"],
+                cycle_count=cycles,
+                increments_per_cycle=20,
+                observation_protocol="clean",
+            )
+            rows.append(row)
+
+    # 300 full six-component histories. Four families are available to train,
+    # principal-axis rotation validates, and random six-component blocks are
+    # held out as a shape-OOD family.
+    for family in FULL_3D_FAMILIES:
+        for local in range(50):
+            if family in FULL_3D_FAMILIES[:4]:
+                split = "train_full_3d" if local < 36 else "validation_full_3d"
+            elif family == "principal_axis_rotation_3d":
+                split = "validation_full_3d"
+            else:
+                split = "test_full_3d_ood"
+            row = _base_parameters(
+                index=len(rows),
+                family=family,
+                amplitude=float(rng.uniform(0.003, 0.014)),
+                seed=int(seed + len(rows) * 130363),
+                points=241,
+            )
+            row.update(
+                cohort="full_3d_nonproportional",
+                split=split,
+                group_id=row["case_id"],
+                cycle_count=1,
+                observation_protocol="clean",
+            )
+            rows.append(row)
+
+    # 200 structure-derived probe histories, 50 from each FE source group.
+    for structure_name, structure_kind, radius in STRUCTURE_SPECS:
+        for probe_index in range(50):
+            family = (
+                "fe_tension_shear_lissajous",
+                "fe_tension_bending_sequence",
+                "fe_reversed_mixed_cycle",
+                "fe_random_load_blocks",
+                "fe_rotating_load_vector",
+            )[probe_index % 5]
+            row = _base_parameters(
+                index=len(rows),
+                family=family,
+                amplitude=float(rng.uniform(0.003, 0.012)),
+                seed=int(seed + len(rows) * 15485863),
+                points=241,
+            )
+            row.update(
+                cohort="structure_derived",
+                split="test_structure_derived",
+                group_id=structure_name,
+                structure_name=structure_name,
+                structure_kind=structure_kind,
+                structure_radius=float(radius),
+                probe_index=int(probe_index),
+                cycle_count=1,
+                observation_protocol="clean",
+            )
+            rows.append(row)
+
+    # 50 unique continuous paths at four matched resolutions = 200 records.
+    # Noise and sparse observation masks are fields, not extra fake samples.
+    for matched_index in range(50):
+        family = PATH_FAMILIES[matched_index % len(PATH_FAMILIES)]
+        shared_seed = int(seed + 900_000 + matched_index * 32452843)
+        shared_rng = np.random.default_rng(shared_seed)
+        amplitude = float(shared_rng.uniform(0.003, 0.012))
+        shared_shapes = shared_rng.random(3)
+        for points in RESOLUTIONS:
+            row = _base_parameters(
+                index=len(rows),
+                family=family,
+                amplitude=amplitude,
+                seed=shared_seed,
+                points=points,
+            )
+            row["path_shape_a"], row["path_shape_b"], row["path_shape_c"] = (
+                float(value) for value in shared_shapes
+            )
+            row.update(
+                cohort="discretization_and_observation",
+                split="test_discretization_observation",
+                group_id=f"matched-resolution-{matched_index:03d}",
+                matched_path_id=f"matched-resolution-{matched_index:03d}",
+                cycle_count=1,
+                observation_protocol="noisy_sparse_paired",
+                strain_noise_fraction=float(shared_rng.uniform(0.0005, 0.0030)),
+                stress_noise_fraction=float(shared_rng.uniform(0.0005, 0.0050)),
+                observation_keep_fraction=float(shared_rng.uniform(0.20, 0.65)),
+            )
+            rows.append(row)
+
+    if len(rows) != 1000:
+        raise RuntimeError(f"Capability extension must contain 1,000 rows, got {len(rows)}.")
+    if len({str(row["case_id"]) for row in rows}) != len(rows):
+        raise RuntimeError("Case IDs are not unique.")
+    return rows
+
+
+def _long_cycle_history(row: dict[str, object]) -> np.ndarray:
+    cycles = int(row["cycle_count"])
+    per_cycle = int(row["increments_per_cycle"]) + 1
+    _, one_cycle = strain_history(row, points=per_cycle)
+    pieces = [one_cycle]
+    pieces.extend(one_cycle[1:] for _ in range(cycles - 1))
+    history = np.concatenate(pieces, axis=0)
+    if len(history) != int(row["points"]):
+        raise RuntimeError("Long-cycle path length does not match the design.")
+    return history
+
+
+def _rotation(axis: np.ndarray, angle: np.ndarray) -> np.ndarray:
+    axis = np.asarray(axis, dtype=float)
+    axis /= np.linalg.norm(axis)
+    cross = np.asarray(
+        ((0.0, -axis[2], axis[1]), (axis[2], 0.0, -axis[0]), (-axis[1], axis[0], 0.0))
+    )
+    outer = np.outer(axis, axis)
+    rotations = []
+    for value in np.asarray(angle, dtype=float):
+        rotations.append(
+            np.cos(value) * np.eye(3)
+            + (1.0 - np.cos(value)) * outer
+            + np.sin(value) * cross
+        )
+    return np.asarray(rotations)
+
+
+def _full_3d_history(row: dict[str, object]) -> np.ndarray:
+    count = int(row["points"])
+    time_coordinate = np.linspace(0.0, 1.0, count)
+    phase = 2.0 * np.pi * time_coordinate
+    family = str(row["path_family"])
+    a = float(row["path_shape_a"])
+    b = float(row["path_shape_b"])
+    c = float(row["path_shape_c"])
+    rng = np.random.default_rng(int(row["path_seed"]))
+
+    if family == "triaxial_phase_lissajous":
+        values = np.column_stack(
+            (
+                np.sin(phase),
+                0.75 * np.sin(2.0 * phase + 0.3 + a),
+                0.55 * np.sin(3.0 * phase + 0.7 + b),
+                0.45 * np.sin(phase + np.pi / 3.0),
+                0.35 * np.sin(2.0 * phase + np.pi / 5.0),
+                0.30 * np.sin(3.0 * phase + np.pi / 7.0),
+            )
+        )
+        return _scale_history(_symmetric_from_voigt(values), float(row["maximum_equivalent_strain"]))
+
+    if family == "principal_axis_rotation_3d":
+        principal = np.column_stack(
+            (
+                np.sin(phase),
+                -0.55 * np.sin(phase),
+                -0.45 * np.sin(phase),
+            )
+        )
+        rotations = _rotation(np.asarray((1.0, 1.0 + a, 0.5 + b)), 2.0 * phase)
+        diagonal = np.asarray([np.diag(value) for value in principal])
+        tensors = np.einsum("nij,njk,nlk->nil", rotations, diagonal, rotations)
+        return _scale_history(tensors, float(row["maximum_equivalent_strain"]))
+
+    if family == "three_shear_rotation":
+        values = np.column_stack(
+            (
+                np.zeros(count),
+                np.zeros(count),
+                np.zeros(count),
+                np.sin(phase),
+                np.sin(phase + 2.0 * np.pi / 3.0),
+                np.sin(phase + 4.0 * np.pi / 3.0),
+            )
+        )
+        return _scale_history(_symmetric_from_voigt(values), float(row["maximum_equivalent_strain"]))
+
+    if family == "hydro_deviatoric_sequence":
+        amplitude = 0.6 + 0.4 * a
+        anchors = np.asarray(
+            (
+                (0, 0, 0, 0, 0, 0),
+                (1, 1, 1, 0, 0, 0),
+                (1 + amplitude, 1 - amplitude, 1, 0, 0, 0),
+                (-0.7, -0.7, -0.7, 0.6, 0, 0),
+                (0.8, -0.4, -0.4, 0, 0.55, 0.35),
+                (0, 0, 0, 0, 0, 0),
+            ),
+            dtype=float,
+        )
+        return _scale_history(_symmetric_from_voigt(_polyline(anchors, count)), float(row["maximum_equivalent_strain"]))
+
+    if family == "six_component_random_blocks":
+        directions = rng.normal(size=(9, 6))
+        directions /= np.linalg.norm(directions, axis=1, keepdims=True)
+        directions[1::2] *= -1.0
+        directions[:, :3] += 0.15 * rng.normal(size=(9, 1))
+        anchors = np.vstack((np.zeros(6), directions, np.zeros(6)))
+        return _scale_history(_symmetric_from_voigt(_polyline(anchors, count)), float(row["maximum_equivalent_strain"]))
+
+    if family == "biaxial_torsion_reversal":
+        ratio = 0.4 + 0.4 * c
+        anchors = np.asarray(
+            (
+                (0, 0, 0, 0, 0, 0),
+                (1, -0.4, 0, ratio, 0, 0),
+                (-0.8, 0.5, 0, ratio, 0.5, 0),
+                (0.6, 0.2, -0.5, -ratio, 0, 0.45),
+                (-0.5, -0.3, 0.4, 0, -0.55, -0.25),
+                (0, 0, 0, 0, 0, 0),
+            ),
+            dtype=float,
+        )
+        return _scale_history(_symmetric_from_voigt(_polyline(anchors, count)), float(row["maximum_equivalent_strain"]))
+
+    raise ValueError(f"Unknown full-3D family: {family}")
+
+
+def _load_coefficients(row: dict[str, object]) -> np.ndarray:
+    count = int(row["points"])
+    t = np.linspace(0.0, 1.0, count)
+    phase = 2.0 * np.pi * t
+    family = str(row["path_family"])
+    rng = np.random.default_rng(int(row["path_seed"]))
+    if family == "fe_tension_shear_lissajous":
+        return np.column_stack((np.sin(phase), 0.75 * np.sin(2.0 * phase + 0.4), 0.35 * np.sin(phase + 1.1)))
+    if family == "fe_tension_bending_sequence":
+        return _polyline(np.asarray(((0, 0, 0), (1, 0, 0), (0.6, 0, 0.8), (-0.5, 0.7, 0.6), (0, 0, 0))), count)
+    if family == "fe_reversed_mixed_cycle":
+        return _polyline(np.asarray(((0, 0, 0), (1, 0.4, 0), (-0.8, 0.4, 0.5), (0.7, -0.6, -0.4), (-0.4, 0.3, 0.7), (0, 0, 0))), count)
+    if family == "fe_random_load_blocks":
+        anchors = rng.normal(size=(8, 3))
+        anchors /= np.maximum(np.linalg.norm(anchors, axis=1, keepdims=True), 1.0e-15)
+        anchors[1::2] *= -1.0
+        return _polyline(np.vstack((np.zeros(3), anchors, np.zeros(3))), count)
+    if family == "fe_rotating_load_vector":
+        return np.column_stack((np.sin(phase), np.cos(phase) - 1.0, 0.6 * np.sin(2.0 * phase)))
+    raise ValueError(f"Unknown FE load-coefficient family: {family}")
+
+
+def _make_gmsh_domain(kind: str, radius: float):
+    import gmsh
+
+    from agentfem import mesh
+
+    if not gmsh.isInitialized():
+        gmsh.initialize()
+    gmsh.clear()
+    gmsh.option.setNumber("General.Terminal", 0)
+    gmsh.model.add(f"denim_v4_{kind}_{radius:.3f}")
+    length, height = 2.0, 1.0
+    plate = gmsh.model.occ.addRectangle(0.0, 0.0, 0.0, length, height)
+    if kind == "central_hole":
+        tool = gmsh.model.occ.addDisk(1.0, 0.5, 0.0, radius, radius)
+        surfaces, _ = gmsh.model.occ.cut([(2, plate)], [(2, tool)])
+    elif kind == "double_edge_notch":
+        lower = gmsh.model.occ.addDisk(1.0, 0.0, 0.0, radius, radius)
+        upper = gmsh.model.occ.addDisk(1.0, 1.0, 0.0, radius, radius)
+        surfaces, _ = gmsh.model.occ.cut([(2, plate)], [(2, lower), (2, upper)])
+    else:
+        raise ValueError(f"Unknown structure kind: {kind}")
+    gmsh.model.occ.synchronize()
+    gmsh.model.addPhysicalGroup(2, [tag for _, tag in surfaces], 1)
+    gmsh.option.setNumber("Mesh.MeshSizeMin", 0.045)
+    gmsh.option.setNumber("Mesh.MeshSizeMax", 0.10)
+    gmsh.model.mesh.generate(2)
+    return mesh.import_gmsh_model(gmsh.model, gdim=2).domain
+
+
+def _solve_unit_strain(domain, *, traction: tuple[float, float], side: str) -> tuple[np.ndarray, np.ndarray]:
+    from agentfem import constitutive, fields, mesh, models, studies
+    from agentfem.solvers import LinearSolverOptions
+
+    model = models.create(
+        study=studies.static_solid(dimension=2, assumption="plane_stress"),
+        mesh=domain,
+    )
+    displacement = model.field(fields.displacement(domain, degree=1))
+    model.material(constitutive.isotropic_elastic(young=190.0e9, poisson=0.30, density=7800.0))
+    left = mesh.boundary(domain, lambda x: np.isclose(x[0], 0.0), tag=101)
+    model.fix(displacement, on=left, value=0.0)
+    if side == "right":
+        boundary = mesh.boundary(domain, lambda x: np.isclose(x[0], 2.0), tag=102)
+    elif side == "top":
+        boundary = mesh.boundary(domain, lambda x: np.isclose(x[1], 1.0), tag=103)
+    else:
+        raise ValueError(f"Unknown loaded side: {side}")
+    model.traction(traction, on=boundary)
+    result = model.step(
+        target=displacement,
+        solver_options=LinearSolverOptions(ksp_type="preonly", pc_type="lu"),
+    ).solve_result(field_variables=("E",))
+    result.verify("engineering").require()
+    field = result.fields["E"].field
+    coordinates = field.function_space.tabulate_dof_coordinates()
+    raw = np.asarray(field.x.array, dtype=float).reshape((-1, 4))
+    tensor = np.zeros((len(raw), 3, 3), dtype=float)
+    tensor[:, 0, 0] = raw[:, 0]
+    tensor[:, 0, 1] = tensor[:, 1, 0] = 0.5 * (raw[:, 1] + raw[:, 2])
+    tensor[:, 1, 1] = raw[:, 3]
+    return np.asarray(coordinates, dtype=float), tensor
+
+
+def build_structure_bases(*, force: bool = False) -> dict[str, dict[str, np.ndarray]]:
+    """Solve 12 AgentFEM unit-load cases and retain 50 probe bases per structure."""
+
+    if STRUCTURE_BASIS_PATH.exists() and not force:
+        loaded = np.load(STRUCTURE_BASIS_PATH, allow_pickle=False)
+        result: dict[str, dict[str, np.ndarray]] = {}
+        for name, _, _ in STRUCTURE_SPECS:
+            result[name] = {
+                "coordinates": loaded[f"{name}__coordinates"],
+                "basis": loaded[f"{name}__basis"],
+                "cell_indices": loaded[f"{name}__cell_indices"],
+            }
+        return result
+
+    collected: dict[str, np.ndarray] = {}
+    result = {}
+    for name, kind, radius in STRUCTURE_SPECS:
+        domain = _make_gmsh_domain(kind, radius)
+        mode_outputs = (
+            _solve_unit_strain(domain, traction=(1.0e6, 0.0), side="right"),
+            _solve_unit_strain(domain, traction=(0.0, 1.0e6), side="right"),
+            _solve_unit_strain(domain, traction=(0.0, 1.0e6), side="top"),
+        )
+        coordinates = mode_outputs[0][0]
+        if any(not np.allclose(coordinates, item[0]) for item in mode_outputs[1:]):
+            raise RuntimeError("DG0 strain-field coordinates changed between unit-load modes.")
+        bases = np.stack([item[1] for item in mode_outputs], axis=1)
+        score = np.linalg.norm(bases.reshape((len(bases), -1)), axis=1)
+        valid = np.flatnonzero(score > np.quantile(score, 0.20))
+        order = valid[np.argsort(score[valid])]
+        positions = np.linspace(0, len(order) - 1, 50).round().astype(int)
+        selected = order[positions]
+        selected_coordinates = coordinates[selected]
+        selected_bases = bases[selected]
+        result[name] = {
+            "coordinates": selected_coordinates,
+            "basis": selected_bases,
+            "cell_indices": selected.astype(np.int64),
+        }
+        collected[f"{name}__coordinates"] = selected_coordinates
+        collected[f"{name}__basis"] = selected_bases
+        collected[f"{name}__cell_indices"] = selected.astype(np.int64)
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(STRUCTURE_BASIS_PATH, **collected)
+    return result
+
+
+def _structure_history(row: dict[str, object], bases: dict[str, dict[str, np.ndarray]]) -> tuple[np.ndarray, dict[str, np.ndarray]]:
+    source = bases[str(row["structure_name"])]
+    probe = int(row["probe_index"])
+    basis = source["basis"][probe]
+    coefficients = _load_coefficients(row)
+    strains = np.einsum("nm,mij->nij", coefficients, basis)
+    strains = _scale_history(strains, float(row["maximum_equivalent_strain"]))
+    metadata = {
+        "source_strain_basis": tensor_to_voigt(basis),
+        "load_mode_coefficients": coefficients,
+        "source_coordinate": source["coordinates"][probe],
+        "source_cell_index": np.asarray([source["cell_indices"][probe]], dtype=np.int64),
+    }
+    return strains, metadata
+
+
+def _standard_history(row: dict[str, object]) -> np.ndarray:
+    _, strains = strain_history(row, points=int(row["points"]))
+    return strains
+
+
+def _integrate_reference(strains: np.ndarray) -> dict[str, np.ndarray]:
+    law = material()
+    count = len(strains)
+    stress = np.empty_like(strains)
+    plastic = np.empty_like(strains)
+    peeq = np.empty(count)
+    increment = np.empty(count)
+    truth_memories = np.empty((count, 3, 3, 3))
+    latent_memories = np.empty((count, 2, 3, 3))
+    radius = np.empty(count)
+    state = None
+    for point, strain in enumerate(strains):
+        update = law.update(strain, state, linearization="none")
+        state = update.state
+        stress[point] = update.stress
+        plastic[point] = state.plastic_strain
+        peeq[point] = state.equivalent_plastic_strain
+        increment[point] = update.plastic_multiplier_increment
+        truth_memories[point] = state.backstresses
+        latent_memories[point, 0] = state.backstresses[0]
+        latent_memories[point, 1] = state.backstresses[1] + state.backstresses[2]
+        radius[point] = law.current_yield_stress(peeq[point]) - law.yield_stress
+    return {
+        "strain": tensor_to_voigt(strains),
+        "stress_pa": tensor_to_voigt(stress),
+        "plastic_strain": tensor_to_voigt(plastic),
+        "peeq": peeq,
+        "plastic_increment": increment,
+        "memories_pa": tensor_to_voigt(latent_memories),
+        "truth_memories_pa": tensor_to_voigt(truth_memories),
+        "isotropic_radius_pa": radius,
+        "time_coordinate": np.linspace(0.0, 1.0, count),
+    }
+
+
+def _add_observations(row: dict[str, object], arrays: dict[str, np.ndarray]) -> None:
+    if row["cohort"] != "discretization_and_observation":
+        return
+    rng = np.random.default_rng(int(row["path_seed"]) + int(row["points"]) * 1009)
+    strain = arrays["strain"]
+    stress = arrays["stress_pa"]
+    strain_scale = max(float(np.max(np.abs(strain))), 1.0e-12)
+    stress_scale = max(float(np.max(np.abs(stress))), 1.0)
+    observed_strain = strain + rng.normal(
+        scale=float(row["strain_noise_fraction"]) * strain_scale,
+        size=strain.shape,
+    )
+    observed_stress = stress + rng.normal(
+        scale=float(row["stress_noise_fraction"]) * stress_scale,
+        size=stress.shape,
+    )
+    keep = float(row["observation_keep_fraction"])
+    mask = rng.random(len(strain)) < keep
+    mask[0] = True
+    mask[-1] = True
+    arrays["observed_strain"] = observed_strain
+    arrays["observed_stress_pa"] = observed_stress
+    arrays["observation_mask"] = mask.astype(np.uint8)
+
+
+def solve_row(row: dict[str, object], bases: dict[str, dict[str, np.ndarray]]) -> tuple[dict[str, np.ndarray], dict[str, float | bool]]:
+    cohort = str(row["cohort"])
+    extras: dict[str, np.ndarray] = {}
+    if cohort == "long_cycle":
+        strains = _long_cycle_history(row)
+    elif cohort == "full_3d_nonproportional":
+        strains = _full_3d_history(row)
+    elif cohort == "structure_derived":
+        strains, extras = _structure_history(row, bases)
+    elif cohort == "discretization_and_observation":
+        strains = _standard_history(row)
+    else:
+        raise ValueError(f"Unknown cohort: {cohort}")
+    arrays = _integrate_reference(strains)
+    arrays.update(extras)
+    _add_observations(row, arrays)
+    metrics = boundary_quality(arrays)
+    metrics["maximum_equivalent_total_strain"] = float(np.max(_equivalent_strain(strains)))
+    metrics["trajectory_point_count"] = int(len(strains))
+    metrics["plastic_step_count"] = int(np.count_nonzero(arrays["plastic_increment"] > 1.0e-12))
+    return arrays, metrics
+
+
+def _agentfem_commit() -> str:
+    return subprocess.run(
+        ("git", "rev-parse", "HEAD"),
+        cwd=AGENTFEM_ROOT,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+
+
+def _record(row: dict[str, object], metrics: dict[str, float | bool]) -> dict[str, object]:
+    return {
+        "sample_id": str(row["case_id"]),
+        "cohort": str(row["cohort"]),
+        "split": str(row["split"]),
+        "group_id": str(row["group_id"]),
+        "path_family": str(row["path_family"]),
+        "points": int(row["points"]),
+        "cycle_count": int(row["cycle_count"]),
+        "maximum_equivalent_strain": float(row["maximum_equivalent_strain"]),
+        "all_finite": bool(metrics["all_finite"]),
+        "plastic_step_count": int(metrics["plastic_step_count"]),
+        "maximum_absolute_stress_pa": float(metrics["maximum_absolute_stress_pa"]),
+        "maximum_peeq": float(metrics["maximum_peeq"]),
+        "maximum_yield_surface_relative_residual": float(metrics["maximum_yield_surface_relative_residual"]),
+        "minimum_peeq_increment": float(metrics["minimum_peeq_increment"]),
+        "maximum_plastic_strain_trace": float(metrics["maximum_plastic_strain_trace"]),
+        "observation_protocol": str(row["observation_protocol"]),
+    }
+
+
+def generate(*, force: bool = False, limit: int | None = None) -> dict[str, object]:
+    rows = design()
+    if limit is not None:
+        rows = rows[: int(limit)]
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
+    if DATA_PATH.exists() and not force:
+        raise FileExistsError(f"{DATA_PATH} exists; pass --force to replace it.")
+    need_structures = any(row["cohort"] == "structure_derived" for row in rows)
+    bases = build_structure_bases(force=force) if need_structures else {}
+    temporary = DATA_PATH.with_suffix(".h5.tmp")
+    records: list[dict[str, object]] = []
+    started = time.perf_counter()
+    with h5py.File(temporary, "w") as h5:
+        h5.attrs["schema"] = "agentfem.physics-data.denim-capability-extension"
+        h5.attrs["schema_version"] = "4.0.0"
+        h5.attrs["material_json"] = json.dumps(MATERIAL, sort_keys=True)
+        h5.attrs["scope"] = str(load_config()["scope"])
+        for index, row in enumerate(rows):
+            arrays, metrics = solve_row(row, bases)
+            if not bool(metrics["all_finite"]):
+                raise RuntimeError(f"Non-finite trajectory at index {index}.")
+            if float(metrics["minimum_peeq_increment"]) < -1.0e-12:
+                raise RuntimeError(f"PEEQ decreased at index {index}.")
+            if float(metrics["maximum_yield_surface_relative_residual"]) > 1.0e-8:
+                raise RuntimeError(f"Yield residual failed at index {index}.")
+            group = h5.create_group(f"{index:05d}")
+            for key in (
+                "case_id",
+                "cohort",
+                "split",
+                "group_id",
+                "path_family",
+                "observation_protocol",
+            ):
+                group.attrs[key] = str(row[key])
+            group.attrs["points"] = int(row["points"])
+            group.attrs["cycle_count"] = int(row["cycle_count"])
+            group.attrs["parameters_json"] = json.dumps(row, sort_keys=True)
+            group.attrs["quality_json"] = json.dumps(metrics, sort_keys=True)
+            for name, value in arrays.items():
+                group.create_dataset(name, data=value, compression="gzip", shuffle=True)
+            records.append(_record(row, metrics))
+            if (index + 1) % 50 == 0 or index + 1 == len(rows):
+                print(f"generated {index + 1}/{len(rows)}", flush=True)
+    os.replace(temporary, DATA_PATH)
+    INDEX_PATH.write_text(
+        "".join(json.dumps(record, sort_keys=True) + "\n" for record in records),
+        encoding="utf-8",
+    )
+    with INDEX_CSV_PATH.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=list(records[0]))
+        writer.writeheader()
+        writer.writerows(records)
+    manifest: dict[str, object] = {
+        "schema": "agentfem.physics-data.denim-capability-extension",
+        "schema_version": "4.0.0",
+        "sample_count": len(records),
+        "complete_release": len(records) == 1000,
+        "cohort_counts": dict(sorted(Counter(record["cohort"] for record in records).items())),
+        "split_counts": dict(sorted(Counter(record["split"] for record in records).items())),
+        "path_family_counts": dict(sorted(Counter(record["path_family"] for record in records).items())),
+        "point_count_distribution": dict(sorted(Counter(str(record["points"]) for record in records).items())),
+        "group_count": len({record["group_id"] for record in records}),
+        "data_sha256": _sha256(DATA_PATH),
+        "index_jsonl_sha256": _sha256(INDEX_PATH),
+        "index_csv_sha256": _sha256(INDEX_CSV_PATH),
+        "structure_bases_sha256": _sha256(STRUCTURE_BASIS_PATH) if STRUCTURE_BASIS_PATH.exists() else None,
+        "data_bytes": DATA_PATH.stat().st_size,
+        "generation_seconds": time.perf_counter() - started,
+        "agentfem_commit": _agentfem_commit(),
+        "reference_material": "hidden three-memory Chaboche with tabulated isotropic hardening",
+        "quality": {
+            "all_finite_failures": sum(not bool(record["all_finite"]) for record in records),
+            "maximum_yield_surface_relative_residual": max(float(record["maximum_yield_surface_relative_residual"]) for record in records),
+            "minimum_peeq_increment": min(float(record["minimum_peeq_increment"]) for record in records),
+            "maximum_plastic_strain_trace": max(float(record["maximum_plastic_strain_trace"]) for record in records),
+            "minimum_plastic_step_count": min(int(record["plastic_step_count"]) for record in records),
+        },
+        "structure_fidelity": "AgentFEM linear-elastic unit-load strain bases with one-way nonlinear material replay; no coupled elastoplastic redistribution claim",
+        "counting_rule": "One sample is one complete trajectory. Observation noise/masks are fields, not extra samples. Matched resolutions are explicitly grouped.",
+    }
+    _write_json(MANIFEST_PATH, manifest)
+    _write_json(ARTIFACT_DIR / "quality.json", manifest)
+    return manifest
+
+
+def audit() -> dict[str, object]:
+    manifest = json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
+    rows = [json.loads(line) for line in INDEX_PATH.read_text(encoding="utf-8").splitlines() if line]
+    with h5py.File(DATA_PATH, "r") as h5:
+        groups = list(h5.keys())
+        finite_failures = 0
+        missing = []
+        for group_name in groups:
+            group = h5[group_name]
+            required = (
+                "strain",
+                "stress_pa",
+                "plastic_strain",
+                "peeq",
+                "plastic_increment",
+                "memories_pa",
+                "truth_memories_pa",
+                "isotropic_radius_pa",
+                "time_coordinate",
+            )
+            for name in required:
+                if name not in group:
+                    missing.append(f"{group_name}:{name}")
+                elif not np.isfinite(group[name][...]).all():
+                    finite_failures += 1
+            if group.attrs["cohort"] == "discretization_and_observation":
+                for name in ("observed_strain", "observed_stress_pa", "observation_mask"):
+                    if name not in group:
+                        missing.append(f"{group_name}:{name}")
+            if group.attrs["cohort"] == "structure_derived":
+                for name in ("source_strain_basis", "load_mode_coefficients", "source_coordinate"):
+                    if name not in group:
+                        missing.append(f"{group_name}:{name}")
+    audit_result = {
+        "sample_count": len(rows),
+        "hdf5_group_count": len(groups),
+        "case_id_unique": len({row["sample_id"] for row in rows}) == len(rows),
+        "missing_required_fields": missing,
+        "nonfinite_required_field_count": finite_failures,
+        "data_sha256_matches_manifest": _sha256(DATA_PATH) == manifest["data_sha256"],
+        "grouped_resolution_protocol": all(
+            len([row for row in rows if row["group_id"] == group_id]) == 4
+            for group_id in {row["group_id"] for row in rows if row["cohort"] == "discretization_and_observation"}
+        ),
+        "structure_group_count": len({row["group_id"] for row in rows if row["cohort"] == "structure_derived"}),
+    }
+    audit_result["passed"] = bool(
+        audit_result["sample_count"] == 1000
+        and audit_result["hdf5_group_count"] == 1000
+        and audit_result["case_id_unique"]
+        and not audit_result["missing_required_fields"]
+        and audit_result["nonfinite_required_field_count"] == 0
+        and audit_result["data_sha256_matches_manifest"]
+        and audit_result["grouped_resolution_protocol"]
+        and audit_result["structure_group_count"] == 4
+    )
+    _write_json(ARTIFACT_DIR / "audit.json", audit_result)
+    return audit_result
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--force", action="store_true")
+    parser.add_argument("--limit", type=int)
+    parser.add_argument("--audit-only", action="store_true")
+    args = parser.parse_args()
+    if args.audit_only:
+        report = audit()
+    else:
+        report = generate(force=args.force, limit=args.limit)
+        if args.limit is None:
+            report = {"generation": report, "audit": audit()}
+    print(json.dumps(report, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

tests/test_t2_denim_capability_v4.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections import Counter, defaultdict
+
+import numpy as np
+
+from src.generate_t2_denim_capability_v4 import (
+    FULL_3D_FAMILIES,
+    RESOLUTIONS,
+    design,
+    solve_row,
+)
+
+
+def test_v4_design_counts_and_unique_ids():
+    rows = design()
+    assert len(rows) == 1000
+    assert len({row["case_id"] for row in rows}) == 1000
+    assert Counter(row["cohort"] for row in rows) == {
+        "long_cycle": 300,
+        "full_3d_nonproportional": 300,
+        "structure_derived": 200,
+        "discretization_and_observation": 200,
+    }
+    assert Counter(row["path_family"] for row in rows if row["cohort"] == "full_3d_nonproportional") == {
+        family: 50 for family in FULL_3D_FAMILIES
+    }
+
+
+def test_v4_resolution_groups_are_complete_and_isolated():
+    rows = [row for row in design() if row["cohort"] == "discretization_and_observation"]
+    grouped = defaultdict(list)
+    for row in rows:
+        grouped[row["group_id"]].append(row)
+    assert len(grouped) == 50
+    for values in grouped.values():
+        assert tuple(sorted(row["points"] for row in values)) == RESOLUTIONS
+        assert len({row["split"] for row in values}) == 1
+        assert len({row["path_seed"] for row in values}) == 1
+        assert len({row["maximum_equivalent_strain"] for row in values}) == 1
+
+
+def test_v4_long_cycle_split_is_true_horizon_ood():
+    rows = [row for row in design() if row["cohort"] == "long_cycle"]
+    assert {row["cycle_count"] for row in rows if row["split"] == "train_long_cycle"} == {10, 25}
+    assert {row["cycle_count"] for row in rows if row["split"] == "validation_long_cycle"} == {50}
+    assert {row["cycle_count"] for row in rows if row["split"] == "test_long_cycle_ood"} == {100}
+
+
+def test_v4_material_point_smoke_without_structure_solver():
+    rows = design()
+    selected = (
+        next(row for row in rows if row["cohort"] == "long_cycle"),
+        next(row for row in rows if row["cohort"] == "full_3d_nonproportional"),
+        next(row for row in rows if row["cohort"] == "discretization_and_observation"),
+    )
+    for row in selected:
+        arrays, metrics = solve_row(row, {})
+        assert metrics["all_finite"]
+        assert metrics["minimum_peeq_increment"] >= -1.0e-12
+        assert metrics["maximum_yield_surface_relative_residual"] < 1.0e-8
+        assert arrays["strain"].shape == (row["points"], 6)
+        assert arrays["stress_pa"].shape == (row["points"], 6)
+    observed, _ = solve_row(selected[-1], {})
+    assert observed["observation_mask"].dtype == np.uint8
+    assert observed["observation_mask"][0] == 1
+    assert observed["observation_mask"][-1] == 1
+
+
+def test_every_full_3d_family_is_symmetric_and_integrable():
+    rows = [row for row in design() if row["cohort"] == "full_3d_nonproportional"]
+    for family in FULL_3D_FAMILIES:
+        row = next(value for value in rows if value["path_family"] == family)
+        arrays, metrics = solve_row(row, {})
+        strain = arrays["strain"]
+        assert np.isfinite(strain).all()
+        assert metrics["all_finite"]
+        assert metrics["maximum_yield_surface_relative_residual"] < 1.0e-8