Add DENIM incomplete-physics closure dataset and evidence

Adds the 128-trajectory three-memory-to-two-memory closure cohort, DENIM versus GRU/J2 metrics, time-step and structural deployment gates, figures, source and reproducibility documentation.

DENIM_REPRODUCE.md

@@ -0,0 +1,16 @@
+# Reproduce DENIM closure v1
+
+From the AgentFEM-Physics-Data project root with the configured `fenicsx-env`:
+
+```bash
+python -m src.generate_t2_graybox_closure --count-per-family 16 --force
+python -m src.train_t2_graybox_closure
+python -m src.validate_t2_graybox_closure
+python -m src.plot_t2_graybox_closure
+python -m pytest -q tests/test_t2_graybox_discrete_energy.py tests/test_t2_graybox_closure.py
+```
+
+The data were generated with AgentFEM commit
+`e76f2a96f58cc12f47fd6fae996c22fdca300ed1`. Reproducing generation therefore
+requires AgentFEM and its FEniCSx environment. Loading the published DENIM
+weights only requires PyTorch and the included core implementation.

DENIM_START_HERE.md

@@ -0,0 +1,29 @@
+# DENIM incomplete-physics closure
+
+DENIM is the **Discrete-Energy Neural Internal-variable Model** developed in
+the AgentFEM material-loading-memory study.
+
+This increment contains 128 complete multiaxial trajectories, each with 241
+ordered states. Training uses five path families (80 trajectories), validation
+uses rotating-principal loading (16), and test fully withholds out-of-phase
+Lissajous and random-direction-block loading (32).
+
+The reference is intentionally richer than the learned model:
+
+- reference: three kinematic memories plus tabulated isotropic hardening;
+- DENIM: two tensor memories plus a learned monotone saturating hardening law;
+- known to DENIM: isotropic elasticity, J2 geometry and initial yield stress;
+- hidden: reference hardening table, recovery parameters and update equations.
+
+Start with:
+
+- `data/t2_graybox_closure_v1/manifest.json`
+- `artifacts/t2_graybox_closure_v1/model_metrics.json`
+- `artifacts/t2_graybox_closure_v1/deployment_validation.json`
+- `docs/T2_GRAYBOX_CLOSURE_RESULTS.md`
+
+The HDF5 groups store strain, stress, plastic strain, PEEQ, plastic increments,
+the three reference memories and the two-channel closure state. SI units and
+Voigt order `xx, yy, zz, xy, yz, xz` with tensor shear are used throughout.
+
+Data are CC BY 4.0. Included code uses the repository code license.

README.md

@@ -30,9 +30,40 @@ repository now contains two compatible releases.
 - **T2 multiaxial v2:** 1,024 independently generated J2 and Chaboche
   trajectories in the complete five-dimensional deviatoric strain space,
   with ID, path-OOD and parameter-OOD splits.
+- **T2 DENIM closure v1:** 128 multiaxial trajectories from a deliberately
+  richer three-memory, tabulated-hardening reference material. The published
+  two-memory DENIM model must learn the missing internal-variable closure.
 
-Start with `T2_V2_START_HERE.md` for the research extension or `START_HERE.md`
-for the original v1 release.
+Start with `DENIM_START_HERE.md` for the incomplete-physics study,
+`T2_V2_START_HERE.md` for the multiaxial benchmark, or `START_HERE.md` for the
+original v1 release.
+
+## DENIM incomplete-physics closure
+
+![DENIM closure summary](artifacts/t2_graybox_closure_v1/closure_summary.png)
+
+DENIM stands for **Discrete-Energy Neural Internal-variable Model**. The
+reference material contains three kinematic memory channels and a non-
+exponential tabulated isotropic-hardening curve. DENIM retains only two memory
+channels and receives none of the reference hardening equations or parameters.
+
+Held-out non-proportional path results:
+
+| Model | Test RMSE | Test R2 |
+|---|---:|---:|
+| Incomplete J2, no learned hardening | 59.541 MPa | 0.730208 |
+| GRU | 76.988 MPa | 0.548933 |
+| **DENIM** | **1.136 MPa** | **0.999902** |
+
+The 918-parameter DENIM also passed coarse/fine increment checks and three
+notched-bar deployment gates. Cyclic and monotonic reaction relative-L2 errors
+were 0.636% and 0.500%; the severe cyclic stress test required one global
+trust-region fallback. This remains a fixed synthetic material study with
+internal-state supervision, not an experimental calibration or a certified
+production material.
+
+The standalone weights and model card are published at
+[HaomingLuo/AgentFEM-DENIM](https://huggingface.co/HaomingLuo/AgentFEM-DENIM).
 
 ## Multiaxial v2 at a glance
 
@@ -82,6 +113,8 @@ misspecified physical models.
 - Manuscript roadmap: `docs/T2_MULTIAXIAL_RESEARCH_MEMO.md`
 - Literature map: `docs/T2_MULTIAXIAL_LITERATURE.md`
 - Commands: `T2_V2_REPRODUCE.md`
+- DENIM data and evidence: `DENIM_START_HERE.md`
+- DENIM reproduction: `DENIM_REPRODUCE.md`
 
 The data were generated with AgentFEM commit
 `058faecc05aeda143d014fd229401003a9258bbb` (`0.3.7.dev0`). All quantities use

SHA256SUMS

@@ -1,120 +1,23 @@
-4a8e89fe65965e0b5ab34a6a1b8faa412666e426ce92500dba6af0c8f3e0ca0b  CODE_LICENSE
-cdd59472c82b98d55f37288e0dd5994059194134fba6568029052eeff64faee4  DATA_LICENSE.md
-882fd0ac467a25c367798249f997bcc5460be8c5041b720f5e52809140ef8f60  KNOWN_LIMITATIONS.md
-a0cbfe8420f8e7b9f27a5ec84c3b661a181112db356a8f0c4b4cb5dac66e7df5  PAPER_ROADMAP.md
-2ff89e3e5cf36e56bfd986ba3dcc3837a07bb06153944455cc2fd532aefb34d2  README.md
-5884a4ae4cb5fd092b6dec45bd61107cf2365fa0500e4c1ff34a051583a16148  REPRODUCE.md
-e552710f9fea8e21877e2011a457f75c790968fd5dbfd1549f066aa567875ea4  START_HERE.md
-9e62aabbc8bd24dd38539b03bf5f9c1e73507bb9a9d1b73c37c0d3ca6b2f7f14  T2_V2_REPRODUCE.md
-c1329e03b40e57f66370343bf3f8a078149fefc28fbfbab80ee00412124571f7  T2_V2_START_HERE.md
-b06a19ffe36df25bbeedf35ccb8df9a9afff6df28870a354bf5c0dfc245fd948  artifacts/t2_material_loading_memory_v1/QUALITY_REPORT.md
-d19cc739e61edff4182ed700e924af7b051f24d37f07fbfa6581eff5e589483a  artifacts/t2_material_loading_memory_v1/baseline_metrics.json
-0537f7cd76aae72abfa644761b8eec2f58903e66b8b2c040354f71650cfe0615  artifacts/t2_material_loading_memory_v1/baseline_models.pt
-9fc457b15d4e838a7dffd1d98d92fc002ee7d4e44f919c5ce1cf37e1bad75e8b  artifacts/t2_material_loading_memory_v1/baseline_predictions.png
-d671538e1fe482de5ee12496185a7c2f65363d1376af4174016a902b1d8cb24d  artifacts/t2_material_loading_memory_v1/hysteresis_preview.png
-4986bb10e002c1c2c1648b8ff3ee20676b2982215494e7f7eafaabdf7eeda298  artifacts/t2_material_loading_memory_v1/quality.json
-722c22826844dd451b28d938f72c09f0ee17a13cb7f599a8c9691570167273ad  artifacts/t2_multiaxial_ood_v2/QUALITY_REPORT.md
-54b95a1e83f0836a460370420e0eaed8653818f56252b5e2745739c42137be42  artifacts/t2_multiaxial_ood_v2/model_metrics.json
-934b3cb6c5092849141f18ae7914ad58463b4f99ce4accd3a8d8eb390fca9a95  artifacts/t2_multiaxial_ood_v2/model_protocol_comparison.png
-19f8bfeb1b19ac5836bdb1e8b2f857ed05a25d6904427333fe156582d209ade9  artifacts/t2_multiaxial_ood_v2/multiaxial_hysteresis_preview.png
-7aae708be60dbb7a41b3c16068fd4eebc8cf4c5cabfe8f09ec417843f252bb18  artifacts/t2_multiaxial_ood_v2/physics_integrator_summary.json
-f70ebec439c8972772649e621c18def3f94c9fe6b832d4e8e9cf8801ebffa0c0  artifacts/t2_multiaxial_ood_v2/quality.json
-69b803b9a1449bda3e8208fe27bcc1e868e4408b8582c2fb9c56a128922e971c  artifacts/t2_multiaxial_ood_v2/structural_validation/mild_id/notched_bar_comparison.png
-8eb1650c1358f618f02bd51e668c23dfe57f12555a9f8c8fa97df25f3c9cd889  artifacts/t2_multiaxial_ood_v2/structural_validation/mild_id/notched_bar_results.npz
-3f13f49c24a0fd69e82710001a99aed812faceca330c11dedce6e2e48d511aaa  artifacts/t2_multiaxial_ood_v2/structural_validation/mild_id/structural_validation.json
-d7af84c60b140016d5abba35454a63d84bd58584911d0496760d35b9f276c01f  artifacts/t2_multiaxial_ood_v2/structural_validation/moderate_ood/notched_bar_comparison.png
-ded38f99016820dacb06d1a325b7cf6fd13a1d7053020803ff6c45ec2c2ec268  artifacts/t2_multiaxial_ood_v2/structural_validation/moderate_ood/notched_bar_results.npz
-9b2d02481d691954fa2622cbf9608a3bc68858ccec44732b69b5bfea0c347f5e  artifacts/t2_multiaxial_ood_v2/structural_validation/moderate_ood/structural_validation.json
-740e645838d4b3276169a72e304aee7cab054dab8a63edb60d5867a87d63af57  artifacts/t2_multiaxial_ood_v2/structural_validation/severe_ood/notched_bar_comparison.png
-999ef1d758cedec3d918662f223448826ff037b86423821f99d7f3e8bb959d51  artifacts/t2_multiaxial_ood_v2/structural_validation/severe_ood/notched_bar_results.npz
-21491c8fe4848c20149f2f25b4baad4bda35f5806fd002606bbbf2b0798a4c3f  artifacts/t2_multiaxial_ood_v2/structural_validation/severe_ood/structural_validation.json
-2929ddd73ad5e2bb1258aa5501c89a41c2c1ce3548c5a9a84aa133e12b4ab1c2  artifacts/t2_multiaxial_ood_v2/training_summary.json
-5054d2c6e6d289c928e91c67b1c2535b7fc765d00ed7e05c39ec364c35981851  configs/t2_material_loading_memory_pilot.json
-50eb2dee418aba303e20ba6c219fb7d201d0a5a2391b933da2f3651e767191f5  configs/t2_material_loading_memory_v1.json
-622237a1fe57b695ccdfc5b9d2a28d82d4e6be051be5443cd89537a0a091cbf6  configs/t2_multiaxial_ood_v2.json
-d2523144f022f78b71c0f5b006c03a393123dc8bcad190e23375a994a248330d  data/t2_material_loading_memory_v1/design.jsonl
-86ce6e7fa60f668736906c7158dfe0d5e3a8d40ca8a7e8d4e93df1d6a9afadfd  data/t2_material_loading_memory_v1/index.jsonl
-0c863700bb310edbe6363ad3ca143015279226b7d1af9db25599ae79f7beb297  data/t2_material_loading_memory_v1/manifest.json
-bf77420e04584151af10ea6e503fe4ab09946aa8c52d097ac8d4c902362387d3  data/t2_material_loading_memory_v1/shards/part-00000.h5
-7278e897caf225f3cb3a6e34e65881fc2c87f310f730245ab4bffb54ace475b3  data/t2_material_loading_memory_v1/shards/part-00001.h5
-952b90eed1ce3ac288487cf31180384fc12f79aa03d95e4885bfd73b85c9a46d  data/t2_material_loading_memory_v1/shards/part-00002.h5
-5de72c7a4aba0594945cb381c33696c25c58c6f72c873098852ce68e0f447094  data/t2_material_loading_memory_v1/shards/part-00003.h5
-37edc592132c17f9c0e0f186cf2f0fab60d7abf6135ed31834003ed3d6595801  data/t2_material_loading_memory_v1/shards/part-00004.h5
-7039ab13425efac4e7bbdd415d31a5276acd3617a22163ad563c6817fca7360e  data/t2_material_loading_memory_v1/shards/part-00005.h5
-67739a62d001131729ce506bb575a48555dd7dbbf393ac5a30cacf5094636854  data/t2_material_loading_memory_v1/shards/part-00006.h5
-37d8caa79a1cb672288f38e1625b4837671bfb9210416b10ce4a60ad5a912ef8  data/t2_material_loading_memory_v1/shards/part-00007.h5
-c0915b6d8bed2c3bd2d5ae156ff42e6c491b81eb6fc797614c6124f7485b1184  data/t2_multiaxial_ood_v2/README.md
-6eee820f46b173f927de5b5033a18b2e9e76c03f019c43f8fc505248b875a312  data/t2_multiaxial_ood_v2/design.jsonl
-a13c1a19098d42d8729184b975e96bbf911c340367c5b46d9aa87887b22268ba  data/t2_multiaxial_ood_v2/index.jsonl
-99793bdd23bb2abebc8d84ab2e2b7875d6c48c1ca62287d4cd83bff38dec83b6  data/t2_multiaxial_ood_v2/manifest.json
-16456ca1050a8afff4b687610d0af7b952dcd2b82149ad61a13e7f1296daa1d4  data/t2_multiaxial_ood_v2/shards/part-00000.h5
-3d56b126367a7cc2e7c7adeca5ae7badaafc91ad4130d5cab444a18c81ec3b10  data/t2_multiaxial_ood_v2/shards/part-00001.h5
-7742b2533ae3a7c2f5018e83abfa44c236caed8c11766d357f56dc92b136f84c  data/t2_multiaxial_ood_v2/shards/part-00002.h5
-189d2ef804c3639fb85a58bddacc982e2d7634add25f0ea214c2652f69193aa6  data/t2_multiaxial_ood_v2/shards/part-00003.h5
-364cdd35f7d8280992267ceda7c4313a197811f8df408763c1f60a144a2a0c59  data/t2_multiaxial_ood_v2/shards/part-00004.h5
-bf3abef7c1a1c1686725014f5be2b49189bca023014d889d418c8950a7699e80  data/t2_multiaxial_ood_v2/shards/part-00005.h5
-27fd47d03fff7ca8e394be61d4a4af2366de9d38ed695e47cbb2ae1fa8c90af7  data/t2_multiaxial_ood_v2/shards/part-00006.h5
-9d1b9d2bc4770cd67516b2f56ba56ae951d6d072a0f0286efccd18c6e94a686e  data/t2_multiaxial_ood_v2/shards/part-00007.h5
-961e1520be9d9f6277423f5f2d422ccc9fde1a7c680d65a66724107edad43365  docs/T2_MULTIAXIAL_LITERATURE.md
-46dd7c86bf01b1faffb6216b171452ead2fc5c449512e34683f21ed6c907fd01  docs/T2_MULTIAXIAL_RESEARCH_MEMO.md
-bcb156b8ecc18d5f222e9671dcf792a142fa7969b0eb9455591506a66ed21c36  environment-reproduce.yml
-f841ccfb11c917545824bb4aaae605f39ce16aa1441f2a6ca182b5c8951c193a  environment-use.yml
-2b0b7be156eae06668a54ab20ad40a7b16dc0d3ce27083096003f188a64054bd  models/t2_multiaxial_ood_v2/README.md
-c078b5514c8fc2245be0dcb5a7051a9e229f4168dc4ace5753ef8bbc6dd775d4  models/t2_multiaxial_ood_v2/id_causal_tcn.pt
-a28b9731ef309c31d721086e5c4d44a4fcedebb3f2284d42dbfc4ca99bee1678  models/t2_multiaxial_ood_v2/id_causal_tcn_history.json
-b346b3f373d5bea97febc396cb0f4f4c8db59041c97dcea345e975624605d0fb  models/t2_multiaxial_ood_v2/id_gru.pt
-5dbe2d240055d660b1f2b65d6b795c14d6164674a907af066454d8730dc5927a  models/t2_multiaxial_ood_v2/id_gru_history.json
-c058e02c5283f9367b97c68bcdcf66d9319462a2d60b23e7587162a09cd1da5b  models/t2_multiaxial_ood_v2/id_lstm.pt
-f297cf91466d3fe8f8efb48ff38f55b74c3f95e80a3d32cc5b38dcd5e6ba373d  models/t2_multiaxial_ood_v2/id_lstm_history.json
-4c682f1bc1ec6c8d2db5f542367fbd6daa4922ef566387d2f35974fbd669027b  models/t2_multiaxial_ood_v2/id_normalization.json
-e46c537a2963fbe6bea4c215f4118ca0b496ebfda8f5e2c0cf31a5ba455b0430  models/t2_multiaxial_ood_v2/id_physics_integrator_nn.pt
-b535a1dd4e4682a96a9d5d5b9e3405ef16b058956763f66125bc3f03d76010f6  models/t2_multiaxial_ood_v2/id_physics_integrator_nn_history.json
-600e6e021e63990c005cab724397d42eaf49b3c0f06a3e6974bf44c6fe542498  models/t2_multiaxial_ood_v2/id_physics_state_gru.pt
-56e443773f51c475d624041e169eb170a6552e357e905f56cfd84d727d881ebd  models/t2_multiaxial_ood_v2/id_physics_state_gru_history.json
-e46bcadac4daaee66b2efdba5f790e9e28a330036172aa65ae1f4cc14df4d47a  models/t2_multiaxial_ood_v2/id_pointwise_mlp.pt
-0e14ef379256b97176cf73fd4c83754d8ef956de4ef51f3b3d096478096a8f7c  models/t2_multiaxial_ood_v2/id_pointwise_mlp_history.json
-ced5a5222c7656c1347b8f8c7380f050ef9d2f758e8548e0ce28b69bdc65c6b5  models/t2_multiaxial_ood_v2/parameter_ood_causal_tcn.pt
-55b6f565a9a5b0b61bbba3a7dcc0572c8572f19939b07a036e791b4e60a76153  models/t2_multiaxial_ood_v2/parameter_ood_causal_tcn_history.json
-da578b8b562530dbe6425caaa9cdbab2230957161258c11a7a2b9a204d1ab029  models/t2_multiaxial_ood_v2/parameter_ood_gru.pt
-f5c785caf4fa75943b3451aeb051a375ca5a1b00abaed603a3e4ee15c50ef254  models/t2_multiaxial_ood_v2/parameter_ood_gru_history.json
-c267359a397e0c27ee11a4f220c2ec8eef8390e70389e92bcb0f4d1507dbed52  models/t2_multiaxial_ood_v2/parameter_ood_lstm.pt
-700b2a2035da1090f74a4355678c7970f63b98582674cc720cb80bb130b2ac56  models/t2_multiaxial_ood_v2/parameter_ood_lstm_history.json
-1526e6ab0f9c5a9641bf50443445cb072ace38536610bc7c1762bb751e71873e  models/t2_multiaxial_ood_v2/parameter_ood_normalization.json
-cf8f6a75d1356e08ccf2439f93f49c4dc629456974eeba1159572f198755313c  models/t2_multiaxial_ood_v2/parameter_ood_physics_integrator_nn.pt
-6137632878dd2ec15cf356ebe0dd486bb708453c8a241cee96d782579bc8e612  models/t2_multiaxial_ood_v2/parameter_ood_physics_integrator_nn_history.json
-59db7abe20857c7dcbe157b9d702bc71958771692fe0ea9f391dde8efeca74ea  models/t2_multiaxial_ood_v2/parameter_ood_physics_state_gru.pt
-7fb343b9efdbaca64e9e06ecd52df7900c248c99c9782aed393537d49bbbee86  models/t2_multiaxial_ood_v2/parameter_ood_physics_state_gru_history.json
-bfd9dd42ffb36a38c6591ed5c68eaef47e19c580b83669ca68c5ac8bc1eaaf30  models/t2_multiaxial_ood_v2/parameter_ood_pointwise_mlp.pt
-230bedd7aab23020f42f956b3ba550fbb43e0da8a4adfad04d9baa954a3b91bd  models/t2_multiaxial_ood_v2/parameter_ood_pointwise_mlp_history.json
-4f57c8c7cd668fec6224689574a744d5ed27f9ce3d6ba89388a2b869d12d85b4  models/t2_multiaxial_ood_v2/path_ood_causal_tcn.pt
-522fc250a90575319caef23831bbef3a26fa5b2d3fc6f6c457a7c13bb1e44cf0  models/t2_multiaxial_ood_v2/path_ood_causal_tcn_history.json
-db6dd4f4f314cefc83a0cb2317bd22dc571ad49ce8945d968bcf6a9d4039618a  models/t2_multiaxial_ood_v2/path_ood_gru.pt
-d41faf4dab2173f672dae3d899ce00f15c372f4ee32e2aa0303a496fe3b451a1  models/t2_multiaxial_ood_v2/path_ood_gru_history.json
-ee2a768fa9e4cbb291e2bd39f20366da297a3f18765d7f3b5b87c93dae5bb51b  models/t2_multiaxial_ood_v2/path_ood_lstm.pt
-255dfbf87c1a6cd1d87dba06d4ecdba36522a99831928ae9ac3d8ef91d9cf904  models/t2_multiaxial_ood_v2/path_ood_lstm_history.json
-99754f29cc5cc085716ccc1549c897d833589d17bd343c4da732f375257a7082  models/t2_multiaxial_ood_v2/path_ood_normalization.json
-8177fdd618367c478b1108ec0fad90be44a18df9ff1f9af3b719722ffa3a8e28  models/t2_multiaxial_ood_v2/path_ood_physics_integrator_nn.pt
-7ba19d106d92a0c6308c3cfae0bb0ebc1cbeea0924e1c967ac82e8a85f768de3  models/t2_multiaxial_ood_v2/path_ood_physics_integrator_nn_history.json
-14cb4597811838917c98e148fd1570881d4383771b897257e7bacc6ca0e724c8  models/t2_multiaxial_ood_v2/path_ood_physics_state_gru.pt
-d88b52443a7c0074516eddf5860c40cd40b488d872b905bac49c08f7980e2869  models/t2_multiaxial_ood_v2/path_ood_physics_state_gru_history.json
-e4bb90d495371ab8bc8bb5883cc5bcc6ececd3f62372b221ca6b4e98558d86fe  models/t2_multiaxial_ood_v2/path_ood_pointwise_mlp.pt
-5356d05b393fe7f8a09bd00c28466c965f7c2260b7b6ae05a11c59d75b0b54c9  models/t2_multiaxial_ood_v2/path_ood_pointwise_mlp_history.json
-9098c128e0b540ab83b1f1323d1c3b437a8130a8a88309684fd931c09ca6d4fe  reproduce_t2_v1.sh
-d36bef7aa852e850a524e22f4b9689325b40320ad3046004d2f31df4c7605e26  src/baseline_t2_material_loading_memory.py
-21158e37d8742b20ef5817bb314fb0dfe926f9633b82087a063447d8e863f9fe  src/load_t2_material_loading_memory.py
-229915f1d28cceb7e63eb9795b0e9e640eae8c4ff38052c3374a5ef7d89ffd3b  src/package_t2_material_loading_memory_v1.py
-3521afa9ce4ebb5a9c2cdcf869612989057f9ba7e4b44101facda95d2764e09a  src/package_t2_multiaxial_release.py
-f6d80c48d66c2d5e14fdccff65d9fecd8a632f5322f68eb5f9ec23679b8f67ed  src/structural_validate_t2_models.py
-79eddf3174eb343ef1e8dc4aef2df0a7be62819a03c594aaa22886fd49f57c2d  src/t2_material_loading_memory.py
-604bc6283e7a461073d03a3b69440873d46809baf9e2ca4c79dfbeaa0704a5d7  src/t2_material_loading_memory_v1.py
-ee8a54ed0243c0d834554c7cb728a496ab6df74308a20f9663c34a3e9b882eb0  src/t2_multiaxial_ood_v2.py
-27653364825e5f6d64edb91c7669c40257ecfa839bdcc987f6150b7376706b9a  src/train_t2_multiaxial_models.py
-50b761b008c07ae8419db652a37270ebe15d5c9b7168d87cef1f836c9acc245f  src/train_t2_physics_integrator.py
-2efb9502d85dde486939d02613e13fe6d254e8c6e74e2d82f2eb3201c01d1ac7  src/verify_t2_download.py
-79319ee3dc4c32abc5b9cf68ce5efd226c82d36c43cd74a26a7f49dddffe9154  src/verify_t2_multiaxial_download.py
-05c9cc11d32f54c88d3769b394b15f14bc283dc1f10b33b187b9e59166c676d6  tests/test_t2_material_loading_memory.py
-de16ddbac7c1e9dd020d2fff57da76d56ffd4ba2ce3b1ef61b41f02295c89e5a  tests/test_t2_material_loading_memory_v1.py
-f851886f02ce4e30c24881ef167ebb0462616a18d486ccf4d384afe61146dab2  tests/test_t2_multiaxial_models.py
-f135a64d401ca69f2774fca56d187b3570b733e339f272f13b6a06d3fc0d1d20  tests/test_t2_multiaxial_ood_v2.py
-b2753c68fb0b1819f281828cc84e741566453e70019243acedf51dd07ed997d3  tests/test_t2_physics_integrator.py
-5e391f7cdcdf4ba800bb87d6d1c2db58131303f91376df1aad78bcc2eb47149c  tests/test_t2_structural_validation.py
+4a8e89fe65965e0b5ab34a6a1b8faa412666e426ce92500dba6af0c8f3e0ca0b  ./CODE_LICENSE
+cdd59472c82b98d55f37288e0dd5994059194134fba6568029052eeff64faee4  ./DATA_LICENSE.md
+e05c7afc635aa69f6e617b2ad756ab6a5b3db1fff38c537d389aa8dfcdcbc2b8  ./DENIM_REPRODUCE.md
+f4ee1edcdc64d659819fc747eefa7a2982785c81b07dd2ee75b49d9a8584c4d8  ./DENIM_START_HERE.md
+1f5f037829b9ab33e7c9277e8c881eed5b68d488f5c462843d28bdd24009e382  ./README.md
+5d83466373c7eea5391f03cc2b391f9da78e752f9f9c8811debead910e9638b8  ./artifacts/t2_graybox_closure_v1/closure_summary.png
+f04ca496825ec0c84c11cc284d640aa0e195a21c89cd262065ddaddb9fedd2dc  ./artifacts/t2_graybox_closure_v1/deployment_validation.json
+7b5f00ce4b68f9caf3bd05842d2163317a1a8b4250a519ac3d26fecd3cc3616e  ./artifacts/t2_graybox_closure_v1/model_metrics.json
+62c3839ce60377947ecc095ea9165d85a47a529a9d4817bfa97091c9a1ea4b72  ./artifacts/t2_graybox_closure_v1/structural_reaction_comparison.png
+1789c8070f012c57d02c106dfa4c9193d162d96d0124a02cb8ad48046632d86f  ./data/t2_graybox_closure_v1/cohort.h5
+7cc21cbffa2a12740d16c37bc2250120c4bd68161bad20bf75fbfa8ae26c3c7e  ./data/t2_graybox_closure_v1/manifest.json
+31157d577ae53f2f8a3eb4dc86cd7fd7d753edee4dcf26ffc12359ed2c98e531  ./docs/T2_GRAYBOX_CLOSURE_RESULTS.md
+e5186581f3cda7806128858de98160e59198136bb2e6c171c91ee3fc7b0a6644  ./docs/T2_GRAYBOX_RESEARCH_DESIGN.md
+fd22c6c892549d4ee651477d57f1ffdccc3232ee8e9bd068b43b716635e3c866  ./src/generate_t2_graybox_closure.py
+d559606a3bbca6b9d1215a8d9a653fc1d2564f6338337dbc5623c8c3aca50d1c  ./src/generate_t2_graybox_cohort.py
+a4450ac5b1aad188b4a74d5b3b77988ef196efadcdcfa08d985fe99f9b8a4999  ./src/plot_t2_graybox_closure.py
+97c7683e8cd094299faf56bd6bfae208c9dbf279b237404b52c87877c242e815  ./src/t2_graybox_discrete_energy.py
+8a39134bad45d086e0966a93e7ed578fa1d6a8fd9c1eb4cfd3275c44b37b809a  ./src/train_t2_graybox_closure.py
+45efa5e68e3cd554da9194214e31079d8ce539cd252f2222101c957661a421c2  ./src/train_t2_graybox_discrete_energy.py
+2ef6ae3dd51da5ce1343a8b6622f35220260a1554aa19ce89815ec462a8229e9  ./src/validate_t2_graybox.py
+6e2fbbb2a498b104d479ba3cd2c37797aaae2268c5e4781c705f1817e264637d  ./src/validate_t2_graybox_closure.py
+32cbc95c13ee17a25eccd4f611a6fbf19a8fe17556bc7058dae3aca605aa8c00  ./tests/test_t2_graybox_closure.py
+81d3331a05ff897df65272927dab6214367567203f25b04869403ad5dd15ab33  ./tests/test_t2_graybox_discrete_energy.py

artifacts/t2_graybox_closure_v1/deployment_validation.json

@@ -0,0 +1,43 @@
+{
+  "scope": "reference has three memories and tabulated hardening; deployed DENRM has two memories and no access to the reference equations",
+  "time_discretization": {
+    "121": {
+      "trajectory_count": 8,
+      "rmse_mpa": 0.9438070587644558,
+      "mae_mpa": 0.5064686423720376,
+      "maximum_yield_residual_pa": 0.23421859741210938
+    },
+    "481": {
+      "trajectory_count": 8,
+      "rmse_mpa": 0.9584221120986024,
+      "mae_mpa": 0.5178831071589605,
+      "maximum_yield_residual_pa": 0.062465548515319824
+    },
+    "terminal_121_to_481_relative_change": 0.010678476861357365
+  },
+  "structure": {
+    "mild_cyclic": {
+      "reaction_relative_l2": 0.0063571165780202015,
+      "maximum_absolute_reaction_error": 3322117.808588028,
+      "maximum_newton_iterations": 39,
+      "mean_newton_iterations": 3.1728395061728394,
+      "trust_region_fallback_count": 0,
+      "trust_region_fallback_steps": [],
+      "elapsed_seconds": 32.52564716688357
+    },
+    "severe_monotonic": {
+      "reaction_relative_l2": 0.004998587374687885,
+      "maximum_absolute_reaction_error": 2280042.1006396413,
+      "maximum_newton_iterations": 4,
+      "mean_newton_iterations": 2.918032786885246,
+      "trust_region_fallback_count": 0,
+      "trust_region_fallback_steps": [],
+      "elapsed_seconds": 22.391408500028774
+    },
+    "severe_cyclic_stress_test": {
+      "passed": true,
+      "maximum_newton_iterations": 68,
+      "trust_region_fallback_count": 1
+    }
+  }
+}

artifacts/t2_graybox_closure_v1/model_metrics.json

@@ -0,0 +1,938 @@
+{
+  "scope": "out-of-template fixed material: three-memory tabulated reference; two-memory DENRM closure; reference equations and parameters hidden",
+  "training": {
+    "denrm": {
+      "training_seconds": 5.88968341704458,
+      "best_validation_loss": 0.001059024827554822,
+      "steps": 1600,
+      "history": [
+        {
+          "step": 0,
+          "training_loss": 0.38579270243644714,
+          "validation_loss": 0.3402066230773926,
+          "moduli_pa": [
+            36511551488.0,
+            4961107456.0
+          ],
+          "recovery_mean": [
+            53.978187561035156,
+            53.607749938964844
+          ]
+        },
+        {
+          "step": 25,
+          "training_loss": 0.362447053194046,
+          "validation_loss": 0.3224169611930847,
+          "moduli_pa": [
+            34367172608.0,
+            5155069952.0
+          ],
+          "recovery_mean": [
+            66.52778625488281,
+            42.87104034423828
+          ]
+        },
+        {
+          "step": 50,
+          "training_loss": 0.34120920300483704,
+          "validation_loss": 0.30471307039260864,
+          "moduli_pa": [
+            32751876096.0,
+            5379547136.0
+          ],
+          "recovery_mean": [
+            91.26919555664062,
+            24.301742553710938
+          ]
+        },
+        {
+          "step": 75,
+          "training_loss": 0.3269484341144562,
+          "validation_loss": 0.28713279962539673,
+          "moduli_pa": [
+            31651561472.0,
+            5652205056.0
+          ],
+          "recovery_mean": [
+            84.29915618896484,
+            20.22152328491211
+          ]
+        },
+        {
+          "step": 100,
+          "training_loss": 0.3009229302406311,
+          "validation_loss": 0.2689945101737976,
+          "moduli_pa": [
+            30809159680.0,
+            5966798336.0
+          ],
+          "recovery_mean": [
+            83.6806869506836,
+            18.058650970458984
+          ]
+        },
+        {
+          "step": 125,
+          "training_loss": 0.2786237597465515,
+          "validation_loss": 0.2504095137119293,
+          "moduli_pa": [
+            30237321216.0,
+            6323388416.0
+          ],
+          "recovery_mean": [
+            81.95033264160156,
+            18.312686920166016
+          ]
+        },
+        {
+          "step": 150,
+          "training_loss": 0.25676900148391724,
+          "validation_loss": 0.23147740960121155,
+          "moduli_pa": [
+            29915416576.0,
+            6708836864.0
+          ],
+          "recovery_mean": [
+            81.4782485961914,
+            15.426806449890137
+          ]
+        },
+        {
+          "step": 175,
+          "training_loss": 0.23221440613269806,
+          "validation_loss": 0.21231752634048462,
+          "moduli_pa": [
+            29674477568.0,
+            7121011200.0
+          ],
+          "recovery_mean": [
+            80.01480865478516,
+            13.733681678771973
+          ]
+        },
+        {
+          "step": 200,
+          "training_loss": 0.20759211480617523,
+          "validation_loss": 0.19307036697864532,
+          "moduli_pa": [
+            29439066112.0,
+            7553696768.0
+          ],
+          "recovery_mean": [
+            80.49824523925781,
+            13.581315040588379
+          ]
+        },
+        {
+          "step": 225,
+          "training_loss": 0.19005323946475983,
+          "validation_loss": 0.17390401661396027,
+          "moduli_pa": [
+            29217683456.0,
+            7999151616.0
+          ],
+          "recovery_mean": [
+            81.21581268310547,
+            13.737420082092285
+          ]
+        },
+        {
+          "step": 250,
+          "training_loss": 0.16811104118824005,
+          "validation_loss": 0.1550476849079132,
+          "moduli_pa": [
+            29005221888.0,
+            8453497344.0
+          ],
+          "recovery_mean": [
+            81.85221099853516,
+            13.336631774902344
+          ]
+        },
+        {
+          "step": 275,
+          "training_loss": 0.14668172597885132,
+          "validation_loss": 0.13673055171966553,
+          "moduli_pa": [
+            28820140032.0,
+            8907949056.0
+          ],
+          "recovery_mean": [
+            81.97718048095703,
+            12.545027732849121
+          ]
+        },
+        {
+          "step": 300,
+          "training_loss": 0.12552151083946228,
+          "validation_loss": 0.11921704560518265,
+          "moduli_pa": [
+            28673732608.0,
+            9357985792.0
+          ],
+          "recovery_mean": [
+            82.01515197753906,
+            11.597881317138672
+          ]
+        },
+        {
+          "step": 325,
+          "training_loss": 0.10822976380586624,
+          "validation_loss": 0.10272443294525146,
+          "moduli_pa": [
+            28560623616.0,
+            9795586048.0
+          ],
+          "recovery_mean": [
+            82.02208709716797,
+            10.332350730895996
+          ]
+        },
+        {
+          "step": 350,
+          "training_loss": 0.09075888991355896,
+          "validation_loss": 0.08739122003316879,
+          "moduli_pa": [
+            28471363584.0,
+            10213148672.0
+          ],
+          "recovery_mean": [
+            81.90467834472656,
+            9.32406997680664
+          ]
+        },
+        {
+          "step": 375,
+          "training_loss": 0.07610809057950974,
+          "validation_loss": 0.07339120656251907,
+          "moduli_pa": [
+            28399831040.0,
+            10600233984.0
+          ],
+          "recovery_mean": [
+            81.78054809570312,
+            8.494053840637207
+          ]
+        },
+        {
+          "step": 400,
+          "training_loss": 0.06161889061331749,
+          "validation_loss": 0.060893524438142776,
+          "moduli_pa": [
+            28341405696.0,
+            10953349120.0
+          ],
+          "recovery_mean": [
+            81.67314910888672,
+            7.281245231628418
+          ]
+        },
+        {
+          "step": 425,
+          "training_loss": 0.049724966287612915,
+          "validation_loss": 0.04988915100693703,
+          "moduli_pa": [
+            28292188160.0,
+            11269372928.0
+          ],
+          "recovery_mean": [
+            81.47404479980469,
+            6.630867004394531
+          ]
+        },
+        {
+          "step": 450,
+          "training_loss": 0.03952129930257797,
+          "validation_loss": 0.04041518270969391,
+          "moduli_pa": [
+            28249556992.0,
+            11541736448.0
+          ],
+          "recovery_mean": [
+            81.29922485351562,
+            6.021451473236084
+          ]
+        },
+        {
+          "step": 475,
+          "training_loss": 0.03089054673910141,
+          "validation_loss": 0.032407063990831375,
+          "moduli_pa": [
+            28213374976.0,
+            11774376960.0
+          ],
+          "recovery_mean": [
+            81.13003540039062,
+            5.364430904388428
+          ]
+        },
+        {
+          "step": 500,
+          "training_loss": 0.02404674142599106,
+          "validation_loss": 0.025776276364922523,
+          "moduli_pa": [
+            28182515712.0,
+            11968174080.0
+          ],
+          "recovery_mean": [
+            80.99635314941406,
+            4.950754642486572
+          ]
+        },
+        {
+          "step": 525,
+          "training_loss": 0.018640588968992233,
+          "validation_loss": 0.020371830090880394,
+          "moduli_pa": [
+            28155969536.0,
+            12126825472.0
+          ],
+          "recovery_mean": [
+            80.88662719726562,
+            4.511253833770752
+          ]
+        },
+        {
+          "step": 550,
+          "training_loss": 0.01432683877646923,
+          "validation_loss": 0.016041528433561325,
+          "moduli_pa": [
+            28133527552.0,
+            12256707584.0
+          ],
+          "recovery_mean": [
+            80.75028991699219,
+            4.252326488494873
+          ]
+        },
+        {
+          "step": 575,
+          "training_loss": 0.01105501875281334,
+          "validation_loss": 0.012632152996957302,
+          "moduli_pa": [
+            28114489344.0,
+            12360554496.0
+          ],
+          "recovery_mean": [
+            80.64956665039062,
+            4.030571937561035
+          ]
+        },
+        {
+          "step": 600,
+          "training_loss": 0.00851615983992815,
+          "validation_loss": 0.009983028285205364,
+          "moduli_pa": [
+            28099076096.0,
+            12442387456.0
+          ],
+          "recovery_mean": [
+            80.56149291992188,
+            3.8380002975463867
+          ]
+        },
+        {
+          "step": 625,
+          "training_loss": 0.006600786931812763,
+          "validation_loss": 0.007946695201098919,
+          "moduli_pa": [
+            28086566912.0,
+            12507003904.0
+          ],
+          "recovery_mean": [
+            80.49900817871094,
+            3.6947028636932373
+          ]
+        },
+        {
+          "step": 650,
+          "training_loss": 0.0053570871241390705,
+          "validation_loss": 0.0063914707861840725,
+          "moduli_pa": [
+            28075978752.0,
+            12558013440.0
+          ],
+          "recovery_mean": [
+            80.43580627441406,
+            3.6173617839813232
+          ]
+        },
+        {
+          "step": 675,
+          "training_loss": 0.004254811909049749,
+          "validation_loss": 0.005211687181144953,
+          "moduli_pa": [
+            28067526656.0,
+            12596985856.0
+          ],
+          "recovery_mean": [
+            80.38912963867188,
+            3.533376693725586
+          ]
+        },
+        {
+          "step": 700,
+          "training_loss": 0.003568624146282673,
+          "validation_loss": 0.004317067097872496,
+          "moduli_pa": [
+            28060622848.0,
+            12627590144.0
+          ],
+          "recovery_mean": [
+            80.34644317626953,
+            3.5010931491851807
+          ]
+        },
+        {
+          "step": 725,
+          "training_loss": 0.0030797154176980257,
+          "validation_loss": 0.003639265662059188,
+          "moduli_pa": [
+            28055009280.0,
+            12652579840.0
+          ],
+          "recovery_mean": [
+            80.31182098388672,
+            3.509168863296509
+          ]
+        },
+        {
+          "step": 750,
+          "training_loss": 0.0026616451796144247,
+          "validation_loss": 0.003123655915260315,
+          "moduli_pa": [
+            28050157568.0,
+            12671583232.0
+          ],
+          "recovery_mean": [
+            80.28031158447266,
+            3.511824369430542
+          ]
+        },
+        {
+          "step": 775,
+          "training_loss": 0.0023994487710297108,
+          "validation_loss": 0.0027253602165728807,
+          "moduli_pa": [
+            28046227456.0,
+            12685670400.0
+          ],
+          "recovery_mean": [
+            80.25259399414062,
+            3.5231423377990723
+          ]
+        },
+        {
+          "step": 800,
+          "training_loss": 0.0022111996077001095,
+          "validation_loss": 0.0024182889610528946,
+          "moduli_pa": [
+            28043079680.0,
+            12696512512.0
+          ],
+          "recovery_mean": [
+            80.24041748046875,
+            3.5388340950012207
+          ]
+        },
+        {
+          "step": 825,
+          "training_loss": 0.0019987437408417463,
+          "validation_loss": 0.0021795332431793213,
+          "moduli_pa": [
+            28040531968.0,
+            12704957440.0
+          ],
+          "recovery_mean": [
+            80.23200988769531,
+            3.5715126991271973
+          ]
+        },
+        {
+          "step": 850,
+          "training_loss": 0.002004354726523161,
+          "validation_loss": 0.001990213990211487,
+          "moduli_pa": [
+            28038168576.0,
+            12712061952.0
+          ],
+          "recovery_mean": [
+            80.20845794677734,
+            3.63393497467041
+          ]
+        },
+        {
+          "step": 875,
+          "training_loss": 0.0018554218113422394,
+          "validation_loss": 0.0018389651086181402,
+          "moduli_pa": [
+            28036198400.0,
+            12717541376.0
+          ],
+          "recovery_mean": [
+            80.20215606689453,
+            3.687563896179199
+          ]
+        },
+        {
+          "step": 900,
+          "training_loss": 0.0017452541505917907,
+          "validation_loss": 0.0017167719779536128,
+          "moduli_pa": [
+            28034633728.0,
+            12721585152.0
+          ],
+          "recovery_mean": [
+            80.1939926147461,
+            3.743239641189575
+          ]
+        },
+        {
+          "step": 925,
+          "training_loss": 0.001715177553705871,
+          "validation_loss": 0.0016167458379641175,
+          "moduli_pa": [
+            28033349632.0,
+            12725056512.0
+          ],
+          "recovery_mean": [
+            80.1828384399414,
+            3.8185606002807617
+          ]
+        },
+        {
+          "step": 950,
+          "training_loss": 0.0016669955803081393,
+          "validation_loss": 0.001535505405627191,
+          "moduli_pa": [
+            28032174080.0,
+            12727435264.0
+          ],
+          "recovery_mean": [
+            80.17253875732422,
+            3.88539719581604
+          ]
+        },
+        {
+          "step": 975,
+          "training_loss": 0.0016166572459042072,
+          "validation_loss": 0.0014670428354293108,
+          "moduli_pa": [
+            28031420416.0,
+            12729533440.0
+          ],
+          "recovery_mean": [
+            80.17072296142578,
+            3.940000057220459
+          ]
+        },
+        {
+          "step": 1000,
+          "training_loss": 0.0015592570416629314,
+          "validation_loss": 0.0014085541479289532,
+          "moduli_pa": [
+            28030697472.0,
+            12731159552.0
+          ],
+          "recovery_mean": [
+            80.168701171875,
+            3.995509386062622
+          ]
+        },
+        {
+          "step": 1025,
+          "training_loss": 0.001497658435255289,
+          "validation_loss": 0.0013588758883997798,
+          "moduli_pa": [
+            28029941760.0,
+            12732693504.0
+          ],
+          "recovery_mean": [
+            80.16358947753906,
+            4.0645270347595215
+          ]
+        },
+        {
+          "step": 1050,
+          "training_loss": 0.0014918273082002997,
+          "validation_loss": 0.0013167214347049594,
+          "moduli_pa": [
+            28029257728.0,
+            12734109696.0
+          ],
+          "recovery_mean": [
+            80.15717315673828,
+            4.141843318939209
+          ]
+        },
+        {
+          "step": 1075,
+          "training_loss": 0.0014394468162208796,
+          "validation_loss": 0.0012805506121367216,
+          "moduli_pa": [
+            28028692480.0,
+            12735278080.0
+          ],
+          "recovery_mean": [
+            80.15647888183594,
+            4.207617282867432
+          ]
+        },
+        {
+          "step": 1100,
+          "training_loss": 0.0014387787086889148,
+          "validation_loss": 0.00124912871979177,
+          "moduli_pa": [
+            28028207104.0,
+            12736008192.0
+          ],
+          "recovery_mean": [
+            80.15387725830078,
+            4.281273365020752
+          ]
+        },
+        {
+          "step": 1125,
+          "training_loss": 0.0014404304092749953,
+          "validation_loss": 0.0012217233888804913,
+          "moduli_pa": [
+            28027781120.0,
+            12736673792.0
+          ],
+          "recovery_mean": [
+            80.15155029296875,
+            4.345944881439209
+          ]
+        },
+        {
+          "step": 1150,
+          "training_loss": 0.001406863215379417,
+          "validation_loss": 0.0011979984119534492,
+          "moduli_pa": [
+            28027357184.0,
+            12737250304.0
+          ],
+          "recovery_mean": [
+            80.1491928100586,
+            4.400686740875244
+          ]
+        },
+        {
+          "step": 1175,
+          "training_loss": 0.0013912664726376534,
+          "validation_loss": 0.0011767047690227628,
+          "moduli_pa": [
+            28027031552.0,
+            12737569792.0
+          ],
+          "recovery_mean": [
+            80.15200805664062,
+            4.452568054199219
+          ]
+        },
+        {
+          "step": 1200,
+          "training_loss": 0.0013114067260175943,
+          "validation_loss": 0.0011584279127418995,
+          "moduli_pa": [
+            28026796032.0,
+            12738101248.0
+          ],
+          "recovery_mean": [
+            80.1464614868164,
+            4.505070686340332
+          ]
+        },
+        {
+          "step": 1225,
+          "training_loss": 0.0013662618584930897,
+          "validation_loss": 0.0011425709817558527,
+          "moduli_pa": [
+            28026439680.0,
+            12738462720.0
+          ],
+          "recovery_mean": [
+            80.1444320678711,
+            4.5508131980896
+          ]
+        },
+        {
+          "step": 1250,
+          "training_loss": 0.001352808903902769,
+          "validation_loss": 0.0011285572545602918,
+          "moduli_pa": [
+            28026210304.0,
+            12738686976.0
+          ],
+          "recovery_mean": [
+            80.14773559570312,
+            4.593008518218994
+          ]
+        },
+        {
+          "step": 1275,
+          "training_loss": 0.0013008920941501856,
+          "validation_loss": 0.0011164838215336204,
+          "moduli_pa": [
+            28026007552.0,
+            12738899968.0
+          ],
+          "recovery_mean": [
+            80.14260864257812,
+            4.6314473152160645
+          ]
+        },
+        {
+          "step": 1300,
+          "training_loss": 0.0013721792493015528,
+          "validation_loss": 0.001106198993511498,
+          "moduli_pa": [
+            28025753600.0,
+            12739145728.0
+          ],
+          "recovery_mean": [
+            80.14543914794922,
+            4.6689934730529785
+          ]
+        },
+        {
+          "step": 1325,
+          "training_loss": 0.0013383395271375775,
+          "validation_loss": 0.0010971891460940242,
+          "moduli_pa": [
+            28025583616.0,
+            12739411968.0
+          ],
+          "recovery_mean": [
+            80.14244079589844,
+            4.707152843475342
+          ]
+        },
+        {
+          "step": 1350,
+          "training_loss": 0.001375432126224041,
+          "validation_loss": 0.0010895031737163663,
+          "moduli_pa": [
+            28025454592.0,
+            12739528704.0
+          ],
+          "recovery_mean": [
+            80.14447784423828,
+            4.735220432281494
+          ]
+        },
+        {
+          "step": 1375,
+          "training_loss": 0.0013677821261808276,
+          "validation_loss": 0.0010831705294549465,
+          "moduli_pa": [
+            28025354240.0,
+            12739641344.0
+          ],
+          "recovery_mean": [
+            80.14130401611328,
+            4.761801719665527
+          ]
+        },
+        {
+          "step": 1400,
+          "training_loss": 0.001299329218454659,
+          "validation_loss": 0.0010778201976791024,
+          "moduli_pa": [
+            28025284608.0,
+            12739703808.0
+          ],
+          "recovery_mean": [
+            80.14286804199219,
+            4.782402515411377
+          ]
+        },
+        {
+          "step": 1425,
+          "training_loss": 0.0013210629113018513,
+          "validation_loss": 0.0010733811650425196,
+          "moduli_pa": [
+            28025257984.0,
+            12739722240.0
+          ],
+          "recovery_mean": [
+            80.14280700683594,
+            4.800633430480957
+          ]
+        },
+        {
+          "step": 1450,
+          "training_loss": 0.0013196938671171665,
+          "validation_loss": 0.001069833291694522,
+          "moduli_pa": [
+            28025192448.0,
+            12739804160.0
+          ],
+          "recovery_mean": [
+            80.14232635498047,
+            4.815746307373047
+          ]
+        },
+        {
+          "step": 1475,
+          "training_loss": 0.001338963396847248,
+          "validation_loss": 0.0010670004412531853,
+          "moduli_pa": [
+            28025122816.0,
+            12739866624.0
+          ],
+          "recovery_mean": [
+            80.1413345336914,
+            4.828505516052246
+          ]
+        },
+        {
+          "step": 1500,
+          "training_loss": 0.0012910541845485568,
+          "validation_loss": 0.0010647053131833673,
+          "moduli_pa": [
+            28025067520.0,
+            12739908608.0
+          ],
+          "recovery_mean": [
+            80.14176177978516,
+            4.839024543762207
+          ]
+        },
+        {
+          "step": 1525,
+          "training_loss": 0.0012954988051205873,
+          "validation_loss": 0.0010628391755744815,
+          "moduli_pa": [
+            28025024512.0,
+            12739956736.0
+          ],
+          "recovery_mean": [
+            80.14260864257812,
+            4.847418308258057
+          ]
+        },
+        {
+          "step": 1550,
+          "training_loss": 0.0013016999000683427,
+          "validation_loss": 0.001061332761310041,
+          "moduli_pa": [
+            28024995840.0,
+            12739997696.0
+          ],
+          "recovery_mean": [
+            80.14128112792969,
+            4.8541178703308105
+          ]
+        },
+        {
+          "step": 1575,
+          "training_loss": 0.0012788278982043266,
+          "validation_loss": 0.001060084905475378,
+          "moduli_pa": [
+            28024963072.0,
+            12740007936.0
+          ],
+          "recovery_mean": [
+            80.14088439941406,
+            4.859494686126709
+          ]
+        },
+        {
+          "step": 1599,
+          "training_loss": 0.0013084724778309464,
+          "validation_loss": 0.001059024827554822,
+          "moduli_pa": [
+            28024963072.0,
+            12740020224.0
+          ],
+          "recovery_mean": [
+            80.14115142822266,
+            4.864330768585205
+          ]
+        }
+      ]
+    },
+    "gru": {
+      "training_seconds": 12.37983391713351,
+      "best_validation_loss": 0.6981670260429382,
+      "epochs": 60
+    }
+  },
+  "models": {
+    "incomplete_j2": {
+      "train": {
+        "trajectory_count": 80,
+        "rmse_mpa": 51.314945220947266,
+        "mae_mpa": 27.921403884887695,
+        "r2": 0.7595025300979614
+      },
+      "validation": {
+        "trajectory_count": 16,
+        "rmse_mpa": 75.12889862060547,
+        "mae_mpa": 43.42414855957031,
+        "r2": 0.7140845060348511
+      },
+      "test": {
+        "trajectory_count": 32,
+        "rmse_mpa": 59.54129409790039,
+        "mae_mpa": 41.032962799072266,
+        "r2": 0.7302080392837524
+      },
+      "inference_seconds_all_trajectories": 2.0804422500077635
+    },
+    "gru": {
+      "train": {
+        "trajectory_count": 80,
+        "rmse_mpa": 23.556150436401367,
+        "mae_mpa": 14.713386535644531,
+        "r2": 0.9493206143379211
+      },
+      "validation": {
+        "trajectory_count": 16,
+        "rmse_mpa": 85.85247039794922,
+        "mae_mpa": 57.07228088378906,
+        "r2": 0.6266387701034546
+      },
+      "test": {
+        "trajectory_count": 32,
+        "rmse_mpa": 76.98819732666016,
+        "mae_mpa": 52.02629089355469,
+        "r2": 0.5489333271980286
+      },
+      "inference_seconds_all_trajectories": 0.06955916690640152
+    },
+    "denrm": {
+      "train": {
+        "trajectory_count": 80,
+        "rmse_mpa": 0.8718719482421875,
+        "mae_mpa": 0.4504835605621338,
+        "r2": 0.9999305605888367
+      },
+      "validation": {
+        "trajectory_count": 16,
+        "rmse_mpa": 1.9618406295776367,
+        "mae_mpa": 1.0055958032608032,
+        "r2": 0.9998050332069397
+      },
+      "test": {
+        "trajectory_count": 32,
+        "rmse_mpa": 1.135945200920105,
+        "mae_mpa": 0.6864870190620422,
+        "r2": 0.9999017715454102
+      },
+      "inference_seconds_all_trajectories": 10.250110333086923,
+      "maximum_yield_residual_pa": 96.0,
+      "maximum_plastic_trace": 6.51925802230835e-09,
+      "minimum_peeq_increment": 0.0,
+      "learned_moduli_pa": [
+        28024965120.0,
+        12740021248.0
+      ],
+      "minimum_reference_yield_dissipation": 0.0172310508787632,
+      "minimum_dynamic_recovery_dissipation": 4.376159267849289e-06,
+      "minimum_backward_euler_dissipation": -0.047634124755859375,
+      "maximum_energy_balance_relative_residual": 1.5819839518371737e-06
+    }
+  }
+}

data/t2_graybox_closure_v1/cohort.h5

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

data/t2_graybox_closure_v1/manifest.json

@@ -0,0 +1,39 @@
+{
+  "schema": "agentfem.physics-data.incomplete-physics-closure",
+  "schema_version": "1.0.0",
+  "sample_count": 128,
+  "count_per_family": 16,
+  "points_per_trajectory": 241,
+  "path_families": [
+    "proportional_axial_cycle",
+    "proportional_shear_cycle",
+    "sequential_axial_shear",
+    "orthogonal_cross",
+    "nonproportional_square",
+    "rotating_principal_cycle",
+    "out_of_phase_lissajous",
+    "random_direction_blocks"
+  ],
+  "splits": {
+    "train": 80,
+    "validation": 16,
+    "test": 32
+  },
+  "known_to_model": [
+    "young_pa",
+    "poisson",
+    "yield_stress_pa",
+    "J2_geometry"
+  ],
+  "hidden_from_model": [
+    "three_reference_memory_channels",
+    "all_reference_recovery_parameters",
+    "piecewise_linear_isotropic_hardening_table",
+    "reference_hardening_update_equations"
+  ],
+  "intentional_model_mismatch": "reference has three memories; DENRM has two and must close the lumped medium/slow state",
+  "ground_truth": "AgentFEM three-memory Chaboche with tabulated isotropic hardening",
+  "scope": "Out-of-template synthetic closure cohort; fixed material.",
+  "elapsed_seconds": 21.372640792047605,
+  "bytes": 10093525
+}

docs/T2_GRAYBOX_CLOSURE_RESULTS.md

@@ -0,0 +1,147 @@
+# T2真正不完备物理灰盒闭环：阶段结果
+
+## 结论
+
+本阶段已完成一条可复现的灰盒神经本构闭环，而不是增加一组黑箱网络对比。
+最终方法定名为 **DENIM（Discrete-Energy Neural Internal-variable Model，离散能量神经内变量模型）**。
+
+参考材料使用AgentFEM生成，包含三条运动硬化记忆通道和非指数、分段线性的各向同性
+硬化表；DENIM只保留两条记忆通道，且不知道参考硬化方程、表格和参数。第二、第三条
+参考记忆被合并为一个不完备状态，网络必须学习被删去自由度产生的有效闭合规律。
+
+在完整留出的两类非比例多轴路径上，DENIM应力RMSE为 **1.136 MPa**、
+`R2=0.999902`；相同数据上的GRU为 **76.988 MPa**、`R2=0.548933`，
+不含硬化学习的J2骨架为 **59.541 MPa**、`R2=0.730208`。这说明结果不依赖
+提出模型与三通道参考模型同构。
+
+## 架构选择
+
+保留的物理：小应变各向同性弹性、J2屈服几何、关联流动、塑性不可压缩、非负塑性
+乘子、PEEQ单调、弹性预测—隐式塑性校正和状态提交/回滚。
+
+学习的未知物理：
+
+- 零点锚定的各向同性硬化函数；采用正权重饱和指数混合和非负线性尾项，结构上保证
+  `R(0)=0`和`dR/dp>=0`，并能表达Voce型及表格型饱和硬化；
+- 两条无迹张量记忆的正生产模量；
+- 由客观张量不变量、流动方向投影、PEEQ和反向加载指标驱动的非负动态恢复率。
+
+网络只表示硬化闭合项，弹性、屈服几何、流动方向和局部隐式积分不交给网络猜测。
+最终DENIM仅 **918** 个可训练参数，GRU为 **49,254** 个参数。
+
+## 数据与划分
+
+- 128条独立多轴轨迹，每条241个状态点；
+- 训练80条：比例轴向、比例剪切、顺序轴剪、正交交叉和非比例方形路径；
+- 验证16条：旋转主方向路径；
+- 测试32条：完整留出的异相Lissajous和随机方向块；
+- 模型只知道`E`、`nu`、初始屈服应力和J2骨架；
+- 参考模型的三通道参数、表格硬化数据和更新方程全部隐藏。
+
+数据由AgentFEM提交`e76f2a96f58cc12f47fd6fae996c22fdca300ed1`生成。
+
+## 核心结果
+
+| 模型 | 训练RMSE / MPa | 验证RMSE / MPa | 未见路径测试RMSE / MPa | 测试R2 |
+|---|---:|---:|---:|---:|
+| 不完备J2，无硬化学习 | 51.315 | 75.129 | 59.541 | 0.730208 |
+| GRU | 23.556 | 85.852 | 76.988 | 0.548933 |
+| DENIM | **0.872** | **1.962** | **1.136** | **0.999902** |
+
+DENIM相比GRU将未见路径RMSE降低 **98.52%**，相比不完备J2降低 **98.09%**。
+训练用时5.89 s，GRU训练用时12.38 s。材料点推理方面，DENIM需要执行局部隐式
+返回映射，128条轨迹用时10.25 s；GRU直接前向推理为0.070 s。该结果体现了可信
+约束和速度之间的真实代价，后续应通过矢量化、隐式微分和编译优化缩小差距。
+
+## 物理与数值门槛
+
+- 最大屈服一致性残差：96 Pa；
+- 最大塑性应变迹：`6.52e-9`；
+- 最小PEEQ增量：0；
+- 最小动态恢复耗散：`4.38e-6 J/m3`；
+- 离散能量余额最大相对残差：`1.58e-6`；
+- 后向欧拉耗散最小值为`-4.76e-2 J/m3`，属于单精度分账舍入量，正式论文应以
+  双精度重算并给出相对容差，不应直接宣称严格机器零负值。
+
+初版返回映射曾在粗时间步的近90度正交换向中数值爆炸。根因是直接对包含大剪切
+模量项的流动方向做固定点迭代，且根区间未闭合时仍接受状态。现已解析消去该大项，
+使用单调的标量一致性方程并扩大根区间。修正后：
+
+- 121点粗时间步RMSE：0.944 MPa；
+- 481点细时间步RMSE：0.958 MPa；
+- 两种离散下精度基本一致；最大屈服残差均小于0.25 Pa；
+- 121点与481点终态相对变化约1.07%，其中包含参考积分自身的离散差异。
+
+## 结构有限元部署
+
+DENIM作为材料更新嵌入12单元变截面杆的全局平衡迭代，并与AgentFEM原生三通道
+表格硬化材料对照：
+
+| 结构门槛 | 反力相对L2误差 | 最大Newton迭代 | 回退 |
+|---|---:|---:|---:|
+| 轻缺口循环加载 | **0.636%** | 39 | 0 |
+| 强缺口单调加载 | **0.500%** | 4 | 0 |
+| 强缺口循环压力测试 | 通过 | 68 | 1次信赖域回退 |
+
+强缺口循环工况通过，但一次回退说明当前有限差分方向切线在完全换向附近仍不够理想。
+论文升级应实现由局部隐式残量Jacobian得到的一致算法切线，并与固定旧状态有限差分
+逐点核验。
+
+## 科研价值与文章定位
+
+当前工作已经形成一篇论文的核心方法和主要数值证据：
+
+1. 不是轨迹到应力的黑箱映射，而是只学习未知硬化闭合项；
+2. 参考模型三条记忆、学习模型两条记忆，验证了不完备状态下的有效闭合；
+3. 物理约束由架构保证，不依赖损失惩罚；
+4. 粗细时间步、离散能量和结构Newton共同验证；
+5. 过程中暴露并修正了非比例大转向下返回映射失稳，形成可讨论的数值贡献。
+
+仅凭当前合成固定材料结果，适合形成高质量计算力学/工程AI论文初稿，尚不足以稳妥
+宣称CMAME/IJNME级完成稿。提升到更高水平至少还需要：
+
+- 一组公开实验多轴循环数据，或自有实验数据；
+- 从当前内部状态监督推进到应力—应变主监督，内部状态仅用于诊断或教师蒸馏；
+- 自动/隐式一致切线和二维或三维积分点部署；
+- 多随机种子、噪声与数据稀缺性统计，不需要海选更多网络；
+- 与经标定经典模型比较，而不只比较无硬化J2和GRU。
+
+建议论文题目：
+
+> **From trajectory fitting to deployable constitutive closure: a discrete-energy neural return map for path-dependent plasticity**
+
+## 与文献的关系
+
+- [Masi et al., TANN, JMPS 2021](https://doi.org/10.1016/j.jmps.2020.104277)：
+  将热力学结构嵌入神经本构；
+- [Vlassis and Sun, CMAME 2021](https://doi.org/10.1016/j.cma.2021.113695)：
+  Sobolev/level-set方法学习可解释塑性硬化，并比较GRU等黑箱模型；
+- [Meyer and Ekre, JMPS 2023](https://doi.org/10.1016/j.jmps.2023.105416)：
+  神经网络只表示未知演化律，并从实验中发现可解释方程；
+- [Bleyer, CMAME 2025](https://doi.org/10.1016/j.cma.2025.118145)：
+  将塑性更新写成隐式优化层并使用隐式微分；
+- [Masi, CMAME 2026](https://doi.org/10.1016/j.cma.2026.119260)：
+  以凸自由能和半正定传输算子实施硬热力学约束。
+
+DENIM不把“物理神经本构”本身视为新概念。可主张的组合创新是：面向不完备硬化
+状态的紧凑闭合、可审计离散能量分账、非比例粗时间步稳定返回映射，以及从材料点到
+结构Newton的统一部署证据。
+
+## 可复现资产
+
+- 数据：`data/t2_graybox_closure_v1/cohort.h5`
+- 数据清单：`data/t2_graybox_closure_v1/manifest.json`
+- DENIM权重：`models/t2_graybox_closure_v1/denrm.pt`（发布时文件名为`denim.pt`）
+- GRU权重：`models/t2_graybox_closure_v1/gru.pt`
+- 模型指标：`artifacts/t2_graybox_closure_v1/model_metrics.json`
+- 部署指标：`artifacts/t2_graybox_closure_v1/deployment_validation.json`
+- 总结图：`artifacts/t2_graybox_closure_v1/closure_summary.png`
+- 结构反力图：`artifacts/t2_graybox_closure_v1/structural_reaction_comparison.png`
+- 核心实现：`src/t2_graybox_discrete_energy.py`
+- 数据生成：`src/generate_t2_graybox_closure.py`
+- 训练：`src/train_t2_graybox_closure.py`
+- 部署验证：`src/validate_t2_graybox_closure.py`
+- 回归测试：`tests/test_t2_graybox_closure.py`及`tests/test_t2_graybox_discrete_energy.py`
+
+复现顺序：生成数据、训练、部署验证、绘图。所有产物均写入本项目目录，未修改
+AgentFEM核心代码。

docs/T2_GRAYBOX_RESEARCH_DESIGN.md

@@ -0,0 +1,152 @@
+# T2灰盒神经本构主线：离散能量约束的神经硬化返回映射
+
+## 研究问题
+
+材料点随机留出精度不能回答未知加载路径、时间步变化和结构有限元收敛问题。
+现有白盒物理积分网络直接使用J2/Chaboche硬化公式，适合作为算法积分上限，
+不能证明神经网络能够学习未知本构演化。下一阶段只保留可靠的力学骨架，让
+网络学习未知硬化记忆，并检验该模型能否从材料点进入结构Newton求解。
+
+核心问题为：
+
+> 在不提供Chaboche硬化演化公式的条件下，能否从有限的多轴应力—应变历程中
+> 学得紧凑、客观、耗散可接受的硬化记忆，并在未见路径、改变时间步和非均匀
+> 结构中保持精度与求解稳定性？
+
+## 文献判断
+
+现有重要路线包括：
+
+1. TANN从自由能和耗散出发，将热力学关系嵌入网络；
+2. Sobolev/level-set方法学习屈服面与硬化并控制函数导数；
+3. Meyer—Ekre方法将神经网络嵌入标准耗散材料结构，学习并进一步识别未知演化律；
+4. 隐式层方法把塑性更新写成可微凸优化层；
+5. 2026年的hard-thermodynamic与thermodynamic-hierarchy工作进一步比较自由能、
+   耗散势、传输算子和神经ODE等框架。
+
+因此，本项目不把“热力学神经网络”“神经返回映射”或“学习演化律”本身作为
+新的概念。可形成差异的部分是：以一个明确不完备的J2骨架为起点，把未知硬化
+学习、后向欧拉离散能量分账、时间步OOD、一致算法切线及结构Newton门统一在
+同一条可复现的AgentFEM工作流中。
+
+## 唯一主架构
+
+定名为 **DENIM（Discrete-Energy Neural Internal-variable Model，离散能量神经内变量模型）**。
+名称指向“离散能量＋可学习内变量”的方法范式；当前实例限定为小应变J2循环塑性，不把名称扩张为所有材料模型的通用解。
+
+### 保留的已知物理
+
+- 小应变各向同性线弹性；
+- J2屈服几何；
+- 关联流动方向；
+- 塑性不可压缩；
+- 非负塑性乘子与PEEQ单调；
+- 弹性预测—隐式塑性校正；
+- 接受状态的commit/rollback语义。
+
+### 故意移除的物理
+
+- Voce指数型各向同性硬化公式；
+- 固定Armstrong—Frederick动态恢复公式；
+- 数据生成器中的Chaboche参数及其更新方程。
+
+### 神经硬化状态
+
+状态为塑性应变、PEEQ、标量各向同性硬化量和两个无迹二阶记忆张量。两个张量
+表示快、慢两类方向记忆，但不向网络提供Chaboche的解析更新。
+
+各向同性硬化使用零点锚定的单调神经函数
+
+`R_theta(p) >= 0, dR_theta/dp >= 0, R_theta(0)=0`。
+
+张量记忆采用客观的后向欧拉更新。网络只读取张量不变量、与当前流动方向的
+投影、PEEQ和反向加载指标，输出非负动态恢复率；生产模量保持为正的可学习
+材料常数。经典双背应力Chaboche是该模型的一个特例，但网络也可表达随状态和
+方向历史变化的恢复规律。
+
+### 离散能量
+
+每个接受增量显式记录：
+
+- 塑性功；
+- 各向同性硬化储能变化；
+- 运动硬化储能变化；
+- 初始屈服耗散；
+- 动态恢复耗散；
+- 后向欧拉数值耗散；
+- 离散能量余额。
+
+正参数化和单调硬化保证关键耗散通道非负；训练、验证和结构部署均使用同一
+分账定义。连续热力学正确但离散积分失真的模型不能通过时间步门。
+
+### 一致切线
+
+局部塑性校正写成隐式残量。训练阶段可使用可微固定点/隐式微分，部署阶段由
+局部残量的Jacobian得到算法切线，并以固定旧状态的有限差分独立核验。结构门
+同时报告反力误差、Newton迭代、cutback和回退，不以材料点RMSE替代稳定性。
+
+## 数据设计
+
+不重新海选网络，只增加一组面向演化发现的固定材料队列：
+
+1. 已知`E, nu, sigma_y`，隐藏所有硬化公式与硬化参数；
+2. 训练路径使用比例、剪切、顺序轴剪、正交和方形非比例加载；
+3. 验证留出旋转主方向；
+4. 测试完整留出Lissajous和随机五维方向块；
+5. 对同一连续路径随机改变离散步长，形成时间步OOD；
+6. 第一真值为AgentFEM组合硬化，用于验证能否恢复已知规律；
+7. 第二真值使用非指数表格硬化和多时间尺度记忆，避免提出模型与生成器同构；
+8. 最后增加公开OFHC铜/316钢路径或实验数据，不把合成结果冒充实验发现。
+
+## 最小对照组
+
+只保留三个必要对照，不重新训练一排相似网络：
+
+1. 现有GRU：代表黑箱历史模型；
+2. 不含硬化的J2骨架：代表物理不完备但没有学习；
+3. DENIM：本文方法。
+
+现有白盒物理积分网络只作为不可超越的“知道真公式”参考上限，不参与公平的
+未知物理排名。
+
+## 成功门槛
+
+DENIM必须同时满足：
+
+- 路径OOD应力RMSE显著低于GRU；
+- PEEQ、塑性不可压缩和客观性零违例；
+- 离散能量余额达到数值积分容差，耗散通道无负值；
+- 241、121及非均匀时间步下终态和历程保持自洽；
+- 算法切线与固定旧状态有限差分一致；
+- 二维或三维非均匀结构中达到可接受反力误差，并稳定完成全局Newton；
+- 公开路径/实验对照不劣于经标定的经典基线。
+
+若DENIM不能超过GRU，应保留失败结果并检查信息不足、状态维数、离散更新和
+训练路径覆盖，不通过增删测试集制造胜出。
+
+## 论文主线
+
+建议题目方向：
+
+**From trajectory fitting to deployable constitutive discovery: a discrete-energy neural return map for path-dependent plasticity**
+
+文章的核心贡献不是新网络名称，而是证明：未知硬化可以在保留少量可靠物理的
+条件下学习；连续层面的物理约束仍不够，离散能量、时间步一致性、算法切线和
+结构平衡必须共同构成神经本构的可信验证链。
+
+## 主要文献入口
+
+- Masi et al., Thermodynamics-based Artificial Neural Networks, JMPS 2021,
+  https://doi.org/10.1016/j.jmps.2020.104277
+- Vlassis and Sun, Sobolev training of thermodynamic-informed neural networks,
+  CMAME 2021, https://doi.org/10.1016/j.cma.2021.113695
+- Meyer and Ekre, Thermodynamically consistent neural network plasticity
+  modeling and discovery of evolution laws, JMPS 2023,
+  https://doi.org/10.1016/j.jmps.2023.105416
+- Bleyer, Learning elastoplasticity with implicit layers, CMAME 2025,
+  https://doi.org/10.1016/j.cma.2025.118145
+- Masi, Learning inelastic constitutive models from stress-strain data under
+  hard thermodynamic constraints, CMAME 2026,
+  https://doi.org/10.1016/j.cma.2026.119260
+- Jones and Fuhg, A hierarchy of thermodynamics learning frameworks for
+  inelastic constitutive modeling, arXiv:2603.02645

src/generate_t2_graybox_closure.py

@@ -0,0 +1,178 @@
+"""Generate the out-of-template cohort for incomplete-physics closure.
+
+The reference material has three kinematic time scales and a piecewise-linear
+isotropic hardening curve.  DENRM is deliberately restricted to two memory
+channels and is not given either reference evolution law.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import time
+from pathlib import Path
+
+import h5py
+import numpy as np
+
+from agentfem import constitutive
+
+from src.generate_t2_graybox_cohort import design, split_for_family
+from src.t2_multiaxial_ood_v2 import PATH_FAMILIES, strain_history, tensor_to_voigt
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA_DIR = ROOT / "data" / "t2_graybox_closure_v1"
+DATA_PATH = DATA_DIR / "cohort.h5"
+MANIFEST_PATH = DATA_DIR / "manifest.json"
+
+MATERIAL = {
+    "young_pa": 190.0e9,
+    "poisson": 0.30,
+    "yield_stress_pa": 280.0e6,
+    "backstress_c1_pa": 28.0e9,
+    "backstress_gamma1": 80.0,
+    "backstress_c2_pa": 10.0e9,
+    "backstress_gamma2": 12.0,
+    "backstress_c3_pa": 3.0e9,
+    "backstress_gamma3": 1.5,
+    "hardening_peeq": (0.0, 0.002, 0.006, 0.015, 0.030, 0.060, 0.100),
+    "hardening_stress_pa": (
+        280.0e6,
+        301.0e6,
+        324.0e6,
+        345.0e6,
+        358.0e6,
+        370.0e6,
+        378.0e6,
+    ),
+}
+
+
+def closure_design(count_per_family: int = 16) -> list[dict[str, object]]:
+    rows = design(count_per_family)
+    for row in rows:
+        row.update(MATERIAL)
+        row["material_model"] = "hidden_three_memory_tabulated_hardening"
+    return rows
+
+
+def material() -> constitutive.ChabocheCombinedHardening:
+    hardening = constitutive.TabulatedIsotropicHardening(
+        equivalent_plastic_strain=tuple(MATERIAL["hardening_peeq"]),
+        yield_stress=tuple(MATERIAL["hardening_stress_pa"]),
+        extrapolation="constant",
+    )
+    return constitutive.chaboche(
+        young=float(MATERIAL["young_pa"]),
+        poisson=float(MATERIAL["poisson"]),
+        yield_stress=float(MATERIAL["yield_stress_pa"]),
+        backstresses=(
+            (float(MATERIAL["backstress_c1_pa"]), float(MATERIAL["backstress_gamma1"])),
+            (float(MATERIAL["backstress_c2_pa"]), float(MATERIAL["backstress_gamma2"])),
+            (float(MATERIAL["backstress_c3_pa"]), float(MATERIAL["backstress_gamma3"])),
+        ),
+        isotropic_hardening=hardening,
+        name="hidden three-memory tabulated reference",
+    )
+
+
+def solve(parameters: dict[str, object], *, points: int | None = None) -> dict[str, np.ndarray]:
+    law = material()
+    coordinates, strains = strain_history(parameters, points=points)
+    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 index, strain in enumerate(strains):
+        update = law.update(strain, state, linearization="none")
+        state = update.state
+        stress[index] = update.stress
+        plastic[index] = state.plastic_strain
+        peeq[index] = state.equivalent_plastic_strain
+        increment[index] = update.plastic_multiplier_increment
+        truth_memories[index] = state.backstresses
+        # The two-channel closure sees one fast state and one deliberately
+        # unresolved aggregate of the medium and slow reference mechanisms.
+        latent_memories[index, 0] = state.backstresses[0]
+        latent_memories[index, 1] = state.backstresses[1] + state.backstresses[2]
+        radius[index] = law.current_yield_stress(peeq[index]) - 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,
+        "path_coordinates": coordinates,
+    }
+
+
+def generate(count_per_family: int = 16, *, force: bool = False) -> dict[str, object]:
+    rows = closure_design(count_per_family)
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    if DATA_PATH.exists() and not force:
+        raise FileExistsError(f"{DATA_PATH} already exists; pass --force to replace it.")
+    temporary = DATA_PATH.with_suffix(".h5.tmp")
+    started = time.perf_counter()
+    with h5py.File(temporary, "w") as h5:
+        h5.attrs["schema"] = "agentfem.physics-data.incomplete-physics-closure"
+        h5.attrs["schema_version"] = "1.0.0"
+        h5.attrs["material_json"] = json.dumps(MATERIAL, sort_keys=True)
+        for index, row in enumerate(rows):
+            group = h5.create_group(f"{index:05d}")
+            group.attrs["path_family"] = str(row["path_family"])
+            group.attrs["split"] = split_for_family(str(row["path_family"]))
+            group.attrs["parameters_json"] = json.dumps(row, sort_keys=True)
+            for name, value in solve(row).items():
+                group.create_dataset(name, data=value, compression="gzip", shuffle=True)
+    temporary.replace(DATA_PATH)
+    manifest = {
+        "schema": "agentfem.physics-data.incomplete-physics-closure",
+        "schema_version": "1.0.0",
+        "sample_count": len(rows),
+        "count_per_family": count_per_family,
+        "points_per_trajectory": 241,
+        "path_families": list(PATH_FAMILIES),
+        "splits": {
+            "train": 5 * count_per_family,
+            "validation": count_per_family,
+            "test": 2 * count_per_family,
+        },
+        "known_to_model": ["young_pa", "poisson", "yield_stress_pa", "J2_geometry"],
+        "hidden_from_model": [
+            "three_reference_memory_channels",
+            "all_reference_recovery_parameters",
+            "piecewise_linear_isotropic_hardening_table",
+            "reference_hardening_update_equations",
+        ],
+        "intentional_model_mismatch": (
+            "reference has three memories; DENRM has two and must close the lumped medium/slow state"
+        ),
+        "ground_truth": "AgentFEM three-memory Chaboche with tabulated isotropic hardening",
+        "scope": "Out-of-template synthetic closure cohort; fixed material.",
+        "elapsed_seconds": time.perf_counter() - started,
+        "bytes": DATA_PATH.stat().st_size,
+    }
+    MANIFEST_PATH.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(manifest, indent=2))
+    return manifest
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--count-per-family", type=int, default=16)
+    parser.add_argument("--force", action="store_true")
+    args = parser.parse_args()
+    generate(args.count_per_family, force=args.force)
+
+
+if __name__ == "__main__":
+    main()

src/generate_t2_graybox_cohort.py

@@ -0,0 +1,183 @@
+"""Generate the fixed-material cohort for T2 gray-box hardening discovery."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import time
+from pathlib import Path
+
+import h5py
+import numpy as np
+
+from agentfem import constitutive
+
+from src.t2_multiaxial_ood_v2 import (
+    PATH_FAMILIES,
+    design_parameters,
+    strain_history,
+    tensor_to_voigt,
+)
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA_DIR = ROOT / "data" / "t2_graybox_hardening_v1"
+DATA_PATH = DATA_DIR / "cohort.h5"
+MANIFEST_PATH = DATA_DIR / "manifest.json"
+
+MATERIAL = {
+    "young_pa": 190.0e9,
+    "poisson": 0.30,
+    "yield_stress_pa": 280.0e6,
+    "backstress_c1_pa": 35.0e9,
+    "backstress_gamma1": 60.0,
+    "backstress_c2_pa": 8.0e9,
+    "backstress_gamma2": 8.0,
+    "isotropic_saturation_pa": 70.0e6,
+    "isotropic_rate": 8.0,
+}
+
+
+def design(count_per_family: int = 32) -> list[dict[str, object]]:
+    if count_per_family < 4 or count_per_family > 64:
+        raise ValueError("count_per_family must be between 4 and 64.")
+    source = design_parameters()
+    rows: list[dict[str, object]] = []
+    for family_index, family in enumerate(PATH_FAMILIES):
+        start = 512 + family_index * 64
+        for replicate in range(count_per_family):
+            row = dict(source[start + replicate])
+            row.update(MATERIAL)
+            row["material_model"] = "hidden_combined_hardening"
+            row["path_family"] = family
+            row["replicate"] = replicate
+            row["hardening_modulus_pa"] = 0.0
+            rows.append(row)
+    return rows
+
+
+def split_for_family(family: str) -> str:
+    if family in {
+        "proportional_axial_cycle",
+        "proportional_shear_cycle",
+        "sequential_axial_shear",
+        "orthogonal_cross",
+        "nonproportional_square",
+    }:
+        return "train"
+    if family == "rotating_principal_cycle":
+        return "validation"
+    return "test"
+
+
+def solve(
+    parameters: dict[str, object], *, points: int | None = None
+) -> dict[str, np.ndarray]:
+    law = constitutive.chaboche(
+        young=float(parameters["young_pa"]),
+        poisson=float(parameters["poisson"]),
+        yield_stress=float(parameters["yield_stress_pa"]),
+        backstresses=(
+            (
+                float(parameters["backstress_c1_pa"]),
+                float(parameters["backstress_gamma1"]),
+            ),
+            (
+                float(parameters["backstress_c2_pa"]),
+                float(parameters["backstress_gamma2"]),
+            ),
+        ),
+        isotropic_saturation=float(parameters["isotropic_saturation_pa"]),
+        isotropic_rate=float(parameters["isotropic_rate"]),
+    )
+    coordinates, strains = strain_history(parameters, points=points)
+    count = len(strains)
+    stress = np.empty_like(strains)
+    plastic = np.empty_like(strains)
+    peeq = np.empty(count)
+    increment = np.empty(count)
+    memories = np.empty((count, 2, 3, 3))
+    radius = np.empty(count)
+    state = None
+    for index, strain in enumerate(strains):
+        update = law.update(strain, state, linearization="none")
+        state = update.state
+        stress[index] = update.stress
+        plastic[index] = state.plastic_strain
+        peeq[index] = state.equivalent_plastic_strain
+        increment[index] = update.plastic_multiplier_increment
+        memories[index] = state.backstresses
+        radius[index] = law.current_yield_stress(peeq[index]) - 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(memories),
+        "isotropic_radius_pa": radius,
+        "path_coordinates": coordinates,
+    }
+
+
+def generate(count_per_family: int = 32, *, force: bool = False) -> dict[str, object]:
+    rows = design(count_per_family)
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    if DATA_PATH.exists() and not force:
+        raise FileExistsError(f"{DATA_PATH} already exists; pass --force to replace it.")
+    temporary = DATA_PATH.with_suffix(".h5.tmp")
+    started = time.perf_counter()
+    with h5py.File(temporary, "w") as h5:
+        h5.attrs["schema"] = "agentfem.physics-data.graybox-hardening"
+        h5.attrs["schema_version"] = "1.0.0-pilot"
+        h5.attrs["material_json"] = json.dumps(MATERIAL, sort_keys=True)
+        for index, row in enumerate(rows):
+            group = h5.create_group(f"{index:05d}")
+            group.attrs["path_family"] = str(row["path_family"])
+            group.attrs["split"] = split_for_family(str(row["path_family"]))
+            group.attrs["parameters_json"] = json.dumps(row, sort_keys=True)
+            for name, value in solve(row).items():
+                group.create_dataset(name, data=value, compression="gzip", shuffle=True)
+    temporary.replace(DATA_PATH)
+    manifest = {
+        "schema": "agentfem.physics-data.graybox-hardening",
+        "schema_version": "1.0.0-pilot",
+        "sample_count": len(rows),
+        "count_per_family": count_per_family,
+        "points_per_trajectory": 241,
+        "path_families": list(PATH_FAMILIES),
+        "splits": {
+            "train": 5 * count_per_family,
+            "validation": count_per_family,
+            "test": 2 * count_per_family,
+        },
+        "known_to_model": ["young_pa", "poisson", "yield_stress_pa"],
+        "hidden_from_model": [
+            "backstress_c1_pa",
+            "backstress_gamma1",
+            "backstress_c2_pa",
+            "backstress_gamma2",
+            "isotropic_saturation_pa",
+            "isotropic_rate",
+            "hardening_update_equations",
+        ],
+        "ground_truth": "AgentFEM Chaboche combined hardening",
+        "scope": "Fixed synthetic material; controlled recovery-of-known-law cohort.",
+        "elapsed_seconds": time.perf_counter() - started,
+        "bytes": DATA_PATH.stat().st_size,
+    }
+    MANIFEST_PATH.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(manifest, indent=2))
+    return manifest
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--count-per-family", type=int, default=32)
+    parser.add_argument("--force", action="store_true")
+    args = parser.parse_args()
+    generate(args.count_per_family, force=args.force)
+
+
+if __name__ == "__main__":
+    main()

src/plot_t2_graybox_closure.py

@@ -0,0 +1,133 @@
+"""Create compact paper-ready figures for the incomplete-physics closure."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+
+from src import t2_graybox_discrete_energy as graybox
+from src.generate_t2_graybox_closure import MATERIAL
+from src.train_t2_graybox_discrete_energy import load_cohort
+from src.train_t2_multiaxial_models import RecurrentStress
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA = ROOT / "data" / "t2_graybox_closure_v1" / "cohort.h5"
+MODELS = ROOT / "models" / "t2_graybox_closure_v1"
+ARTIFACTS = ROOT / "artifacts" / "t2_graybox_closure_v1"
+
+
+def main() -> None:
+    cohort = load_cohort(DATA)
+    denrm_checkpoint = torch.load(MODELS / "denrm.pt", map_location="cpu", weights_only=False)
+    denrm = graybox.NeuralHardeningLaw(channels=2)
+    denrm.load_state_dict(denrm_checkpoint["state_dict"])
+    denrm.eval()
+    gru_checkpoint = torch.load(MODELS / "gru.pt", map_location="cpu", weights_only=False)
+    gru = RecurrentStress(6, cell="gru", hidden=72)
+    gru.load_state_dict(gru_checkpoint["state_dict"])
+    gru.eval()
+    norm = gru_checkpoint["normalization"]
+    with torch.no_grad():
+        denrm_stress = graybox.rollout(
+            cohort.strain,
+            torch.full((len(cohort.strain),), float(MATERIAL["young_pa"])),
+            torch.full((len(cohort.strain),), float(MATERIAL["poisson"])),
+            torch.full((len(cohort.strain),), float(MATERIAL["yield_stress_pa"])),
+            denrm,
+            bisection_iterations=24,
+        )["stress"]
+        gru_stress = (
+            gru((cohort.strain - norm["strain_mean"]) / norm["strain_std"])
+            * norm["stress_std"]
+            + norm["stress_mean"]
+        )
+
+    metrics = json.loads((ARTIFACTS / "model_metrics.json").read_text())
+    figure, axes = plt.subplots(2, 2, figsize=(11.0, 7.8), constrained_layout=True)
+    colors = {"truth": "#1f2937", "denrm": "#e11d48", "gru": "#2563eb"}
+    component_labels = ("xx", "yy", "zz", "xy", "yz", "xz")
+    for axis, family in zip(
+        axes[0], ("out_of_phase_lissajous", "random_direction_blocks"), strict=True
+    ):
+        index = next(i for i, value in enumerate(cohort.families) if value == family)
+        strain = cohort.strain[index].numpy()
+        component = int(np.argmax(np.ptp(strain, axis=0)))
+        x = 100.0 * strain[:, component]
+        axis.plot(
+            x,
+            cohort.stress[index, :, component].numpy() / 1.0e6,
+            color=colors["truth"],
+            linewidth=2.1,
+            label="AgentFEM reference",
+        )
+        axis.plot(
+            x,
+            denrm_stress[index, :, component].numpy() / 1.0e6,
+            "--",
+            color=colors["denrm"],
+            linewidth=1.8,
+            label="DENIM (2-state closure)",
+        )
+        axis.plot(
+            x,
+            gru_stress[index, :, component].numpy() / 1.0e6,
+            color=colors["gru"],
+            linewidth=1.1,
+            alpha=0.85,
+            label="GRU",
+        )
+        axis.set_title(family.replace("_", " "))
+        axis.set_xlabel(f"strain {component_labels[component]} (%)")
+        axis.set_ylabel(f"stress {component_labels[component]} (MPa)")
+        axis.grid(alpha=0.22)
+    axes[0, 0].legend(frameon=False, fontsize=8)
+
+    names = ("Incomplete J2", "GRU", "DENIM")
+    keys = ("incomplete_j2", "gru", "denrm")
+    rmse = [metrics["models"][key]["test"]["rmse_mpa"] for key in keys]
+    bars = axes[1, 0].bar(
+        names, rmse, color=("#9ca3af", colors["gru"], colors["denrm"])
+    )
+    axes[1, 0].bar_label(bars, fmt="%.2f")
+    axes[1, 0].set_ylabel("held-out path RMSE (MPa)")
+    axes[1, 0].set_title("unseen loading-path accuracy")
+    axes[1, 0].grid(axis="y", alpha=0.22)
+
+    peeq = np.linspace(0.0, 0.10, 250)
+    with torch.no_grad():
+        learned = denrm.isotropic(
+            torch.tensor(peeq, dtype=torch.float32),
+            torch.full((len(peeq),), float(MATERIAL["yield_stress_pa"])),
+        ).numpy()
+    reference = np.interp(
+        peeq,
+        np.asarray(MATERIAL["hardening_peeq"]),
+        np.asarray(MATERIAL["hardening_stress_pa"]),
+    ) - float(MATERIAL["yield_stress_pa"])
+    axes[1, 1].plot(peeq, reference / 1.0e6, color=colors["truth"], linewidth=2.1, label="hidden table")
+    axes[1, 1].plot(peeq, learned / 1.0e6, "--", color=colors["denrm"], linewidth=1.8, label="learned monotone law")
+    axes[1, 1].set_xlabel("equivalent plastic strain")
+    axes[1, 1].set_ylabel("isotropic hardening radius (MPa)")
+    axes[1, 1].set_title("unknown hardening-law recovery")
+    axes[1, 1].grid(alpha=0.22)
+    axes[1, 1].legend(frameon=False, fontsize=8)
+
+    figure.suptitle(
+        "Incomplete-physics closure: 3-state tabulated reference → 2-state DENIM",
+        fontsize=13,
+    )
+    ARTIFACTS.mkdir(parents=True, exist_ok=True)
+    figure.savefig(ARTIFACTS / "closure_summary.png", dpi=220)
+    plt.close(figure)
+
+
+if __name__ == "__main__":
+    main()

src/t2_graybox_discrete_energy.py

@@ -0,0 +1,531 @@
+"""Core assets for a discrete-energy neural hardening return map.
+
+This module deliberately keeps elasticity and J2 kinematics explicit while
+leaving the isotropic hardening curve and state-dependent dynamic recovery to
+small neural functions.  It is the constitutive core of the T2 gray-box study,
+not yet an AgentFEM material provider.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+
+VOIGT_WEIGHTS = torch.tensor((1.0, 1.0, 1.0, 2.0, 2.0, 2.0))
+
+
+def double_contract(left: torch.Tensor, right: torch.Tensor) -> torch.Tensor:
+    weights = VOIGT_WEIGHTS.to(dtype=left.dtype, device=left.device)
+    return (left * right * weights).sum(dim=-1)
+
+
+def deviatoric(value: torch.Tensor) -> torch.Tensor:
+    mean = value[..., :3].mean(dim=-1, keepdim=True)
+    return torch.cat((value[..., :3] - mean, value[..., 3:]), dim=-1)
+
+
+def von_mises(value: torch.Tensor) -> torch.Tensor:
+    selected = deviatoric(value)
+    return torch.sqrt(torch.clamp(1.5 * double_contract(selected, selected), min=0.0))
+
+
+def elastic_stress(
+    strain: torch.Tensor,
+    plastic_strain: torch.Tensor,
+    young: torch.Tensor,
+    poisson: torch.Tensor,
+) -> torch.Tensor:
+    elastic = strain - plastic_strain
+    shear = young / (2.0 * (1.0 + poisson))
+    bulk = young / (3.0 * (1.0 - 2.0 * poisson))
+    trace = elastic[..., :3].sum(dim=-1)
+    mean = trace / 3.0
+    normal = (
+        2.0 * shear[..., None] * (elastic[..., :3] - mean[..., None])
+        + bulk[..., None] * trace[..., None]
+    )
+    return torch.cat((normal, 2.0 * shear[..., None] * elastic[..., 3:]), dim=-1)
+
+
+class MonotoneIsotropicHardening(nn.Module):
+    """Zero-anchored monotone saturating hardening curve.
+
+    A positive mixture of exponential saturation modes represents Voce-like
+    and tabulated concave hardening while a nonnegative linear tail permits
+    continued hardening.  Positivity makes monotonicity structural rather than
+    a soft training penalty.
+    """
+
+    def __init__(self, neurons: int = 12, plastic_scale: float = 0.01):
+        super().__init__()
+        self.plastic_scale = float(plastic_scale)
+        self.raw_weight = nn.Parameter(torch.full((neurons,), -5.0))
+        self.raw_slope = nn.Parameter(torch.linspace(-1.5, 1.5, neurons))
+        self.raw_linear = nn.Parameter(torch.tensor(-5.0))
+
+    def _positive_parameters(self) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        weight = F.softplus(self.raw_weight)
+        slope = F.softplus(self.raw_slope) + 1.0e-6
+        linear = F.softplus(self.raw_linear)
+        return weight, slope, linear
+
+    def forward(self, peeq: torch.Tensor, stress_scale: torch.Tensor) -> torch.Tensor:
+        weight, slope, linear = self._positive_parameters()
+        coordinate = peeq[..., None] / self.plastic_scale
+        saturation = -torch.expm1(-slope * coordinate)
+        dimensionless = linear * coordinate.squeeze(-1) + (
+            weight * saturation
+        ).sum(dim=-1)
+        return stress_scale * dimensionless
+
+    def derivative(self, peeq: torch.Tensor, stress_scale: torch.Tensor) -> torch.Tensor:
+        weight, slope, linear = self._positive_parameters()
+        coordinate = peeq[..., None] / self.plastic_scale
+        value = linear + (
+            weight * slope * torch.exp(-slope * coordinate)
+        ).sum(dim=-1)
+        return stress_scale * value / self.plastic_scale
+
+    def stored_energy(self, peeq: torch.Tensor, stress_scale: torch.Tensor) -> torch.Tensor:
+        coordinate = torch.linspace(
+            0.0, 1.0, 65, dtype=peeq.dtype, device=peeq.device
+        )
+        points = peeq[..., None] * coordinate
+        values = self.forward(points, stress_scale[..., None])
+        return torch.trapezoid(values, points, dim=-1)
+
+
+class ObjectiveRecoveryNetwork(nn.Module):
+    """Positive recovery rates from objective scalar state descriptors."""
+
+    def __init__(self, channels: int = 2, hidden: int = 24):
+        super().__init__()
+        self.channels = int(channels)
+        input_size = 3 + 3 * self.channels
+        self.network = nn.Sequential(
+            nn.Linear(input_size, hidden),
+            nn.SiLU(),
+            nn.Linear(hidden, hidden),
+            nn.SiLU(),
+            nn.Linear(hidden, self.channels),
+        )
+        nn.init.zeros_(self.network[-1].weight)
+        nn.init.constant_(self.network[-1].bias, -1.0)
+
+    def features(
+        self,
+        peeq: torch.Tensor,
+        isotropic_radius: torch.Tensor,
+        flow_direction: torch.Tensor,
+        memories: torch.Tensor,
+        stress_scale: torch.Tensor,
+        reversal: torch.Tensor,
+    ) -> torch.Tensor:
+        scale = stress_scale.clamp_min(1.0)
+        norms = torch.sqrt(
+            torch.clamp(double_contract(memories, memories), min=0.0)
+        ) / scale[..., None]
+        projections = double_contract(memories, flow_direction[..., None, :]) / scale[..., None]
+        cross = torch.zeros_like(norms)
+        if self.channels > 1:
+            for index in range(self.channels):
+                other = (index + 1) % self.channels
+                cross[..., index] = double_contract(
+                    memories[..., index, :], memories[..., other, :]
+                ) / scale.square()
+        scalars = torch.stack(
+            (peeq / 0.02, isotropic_radius / scale, reversal), dim=-1
+        )
+        return torch.cat((scalars, norms, projections, cross), dim=-1)
+
+    def forward(
+        self,
+        peeq: torch.Tensor,
+        isotropic_radius: torch.Tensor,
+        flow_direction: torch.Tensor,
+        memories: torch.Tensor,
+        stress_scale: torch.Tensor,
+        reversal: torch.Tensor,
+    ) -> torch.Tensor:
+        values = self.features(
+            peeq,
+            isotropic_radius,
+            flow_direction,
+            memories,
+            stress_scale,
+            reversal,
+        )
+        return 200.0 * torch.sigmoid(self.network(values)) + 1.0e-6
+
+
+@dataclass
+class GrayboxState:
+    plastic_strain: torch.Tensor
+    peeq: torch.Tensor
+    memories: torch.Tensor
+    previous_flow: torch.Tensor
+
+    @property
+    def backstress(self) -> torch.Tensor:
+        return self.memories.sum(dim=-2)
+
+
+def initial_state(
+    batch: int,
+    *,
+    channels: int = 2,
+    dtype: torch.dtype = torch.float32,
+    device: torch.device | str = "cpu",
+) -> GrayboxState:
+    tensor = torch.zeros((batch, 6), dtype=dtype, device=device)
+    memories = torch.zeros((batch, channels, 6), dtype=dtype, device=device)
+    return GrayboxState(
+        plastic_strain=tensor,
+        peeq=torch.zeros(batch, dtype=dtype, device=device),
+        memories=memories,
+        previous_flow=tensor.clone(),
+    )
+
+
+class NeuralHardeningLaw(nn.Module):
+    """Unknown hardening law embedded in a known J2 state representation."""
+
+    def __init__(self, channels: int = 2):
+        super().__init__()
+        self.channels = int(channels)
+        self.raw_moduli = nn.Parameter(torch.linspace(2.0, 0.0, channels))
+        self.log_total_modulus_ratio = nn.Parameter(torch.tensor(5.0))
+        self.isotropic = MonotoneIsotropicHardening()
+        self.recovery = ObjectiveRecoveryNetwork(channels=channels)
+
+    def moduli(self, stress_scale: torch.Tensor) -> torch.Tensor:
+        fractions = torch.softmax(self.raw_moduli, dim=0)
+        total = torch.exp(self.log_total_modulus_ratio).clamp(max=500.0)
+        return total * stress_scale[..., None] * fractions
+
+    def update_memories(
+        self,
+        state: GrayboxState,
+        flow_direction: torch.Tensor,
+        increment: torch.Tensor,
+        stress_scale: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        isotropic = self.isotropic(state.peeq, stress_scale)
+        old_norm = torch.sqrt(
+            torch.clamp(double_contract(state.previous_flow, state.previous_flow), min=0.0)
+        )
+        current_norm = torch.sqrt(
+            torch.clamp(double_contract(flow_direction, flow_direction), min=0.0)
+        )
+        reversal = double_contract(state.previous_flow, flow_direction) / (
+            old_norm * current_norm
+        ).clamp_min(1.0e-12)
+        recovery = self.recovery(
+            state.peeq,
+            isotropic,
+            flow_direction,
+            state.memories,
+            stress_scale,
+            reversal,
+        )
+        moduli = self.moduli(stress_scale)
+        numerator = state.memories + (
+            (2.0 / 3.0)
+            * moduli[..., :, None]
+            * increment[..., None, None]
+            * flow_direction[..., None, :]
+        )
+        denominator = 1.0 + recovery * increment[..., None]
+        updated = numerator / denominator[..., None]
+        return updated, recovery, moduli
+
+
+def _candidate_update(
+    trial_deviatoric: torch.Tensor,
+    state: GrayboxState,
+    increment: torch.Tensor,
+    shear: torch.Tensor,
+    yield_stress: torch.Tensor,
+    law: NeuralHardeningLaw,
+    *,
+    direction_iterations: int = 6,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    shifted_trial = trial_deviatoric - state.backstress
+    direction = 1.5 * shifted_trial / von_mises(shifted_trial).clamp_min(1.0)[..., None]
+    recovery = moduli = None
+    memories = state.memories
+    # For a fixed plastic increment the Armstrong--Frederick-type backward
+    # Euler update can be rearranged before finding the direction.  Removing
+    # the large term proportional to G*increment avoids the oscillatory vector
+    # fixed point that occurs when a coarse increment rotates the loading path
+    # by nearly 90 degrees.
+    for _ in range(direction_iterations):
+        memories, recovery, moduli = law.update_memories(
+            state, direction, increment, yield_stress
+        )
+        denominator = 1.0 + recovery * increment[..., None]
+        effective_trial = trial_deviatoric - (
+            state.memories / denominator[..., None]
+        ).sum(dim=-2)
+        direction = (
+            1.5
+            * effective_trial
+            / von_mises(effective_trial).clamp_min(1.0)[..., None]
+        )
+    memories, recovery, moduli = law.update_memories(
+        state, direction, increment, yield_stress
+    )
+    denominator = 1.0 + recovery * increment[..., None]
+    effective_trial = trial_deviatoric - (
+        state.memories / denominator[..., None]
+    ).sum(dim=-2)
+    radius = yield_stress + law.isotropic(state.peeq + increment, yield_stress)
+    effective_plastic_modulus = 3.0 * shear + (moduli / denominator).sum(dim=-1)
+    # Signed consistency equation.  Unlike taking von Mises of an overshot
+    # trial state, this remains monotone after the root and therefore supplies
+    # a valid bracket for bisection.
+    residual = (
+        von_mises(effective_trial)
+        - effective_plastic_modulus * increment
+        - radius
+    )
+    return residual, direction, memories, recovery, moduli
+
+
+def advance(
+    strain: torch.Tensor,
+    state: GrayboxState,
+    young: torch.Tensor,
+    poisson: torch.Tensor,
+    yield_stress: torch.Tensor,
+    law: NeuralHardeningLaw,
+    *,
+    bisection_iterations: int = 28,
+    direction_iterations: int = 6,
+) -> tuple[torch.Tensor, GrayboxState, dict[str, torch.Tensor]]:
+    """Accept one strain-driven increment using a bracketed neural return map."""
+
+    trial = elastic_stress(strain, state.plastic_strain, young, poisson)
+    trial_deviatoric = deviatoric(trial)
+    shifted_trial = trial_deviatoric - state.backstress
+    old_radius = yield_stress + law.isotropic(state.peeq, yield_stress)
+    trial_function = von_mises(shifted_trial) - old_radius
+    plastic = trial_function > yield_stress.clamp_min(1.0) * 1.0e-12
+    shear = young / (2.0 * (1.0 + poisson))
+    lower = torch.zeros_like(trial_function)
+    upper = 2.0 * F.relu(trial_function) / (3.0 * shear).clamp_min(1.0) + 1.0e-14
+    # Large non-proportional increments can rotate the flow direction almost
+    # orthogonally.  A fixed four-doubling bracket silently failed in that
+    # regime and accepted a positive consistency residual.  Expand until the
+    # monotone hardening return is safely bracketed over a much wider range.
+    for _ in range(16):
+        residual, *_ = _candidate_update(
+            trial_deviatoric,
+            state,
+            upper,
+            shear,
+            yield_stress,
+            law,
+            direction_iterations=direction_iterations,
+        )
+        upper = torch.where(plastic & (residual > 0.0), 2.0 * upper, upper)
+    for _ in range(bisection_iterations):
+        middle = 0.5 * (lower + upper)
+        residual, *_ = _candidate_update(
+            trial_deviatoric,
+            state,
+            middle,
+            shear,
+            yield_stress,
+            law,
+            direction_iterations=direction_iterations,
+        )
+        lower = torch.where(plastic & (residual > 0.0), middle, lower)
+        upper = torch.where(plastic & (residual <= 0.0), middle, upper)
+    increment = torch.where(plastic, 0.5 * (lower + upper), torch.zeros_like(lower))
+    residual, direction, memories, recovery, moduli = _candidate_update(
+        trial_deviatoric,
+        state,
+        increment,
+        shear,
+        yield_stress,
+        law,
+        direction_iterations=direction_iterations,
+    )
+    direction = torch.where(plastic[..., None], direction, torch.zeros_like(direction))
+    memories = torch.where(
+        plastic[..., None, None], memories, state.memories
+    )
+    updated = GrayboxState(
+        plastic_strain=state.plastic_strain + increment[..., None] * direction,
+        peeq=state.peeq + increment,
+        memories=memories,
+        previous_flow=torch.where(
+            plastic[..., None], direction, state.previous_flow
+        ),
+    )
+    stress = elastic_stress(strain, updated.plastic_strain, young, poisson)
+    return stress, updated, {
+        "plastic_increment": increment,
+        "yield_residual": torch.where(plastic, residual, torch.zeros_like(residual)),
+        "recovery": recovery,
+        "moduli": moduli,
+        "plastic": plastic,
+    }
+
+
+def rollout(
+    strain: torch.Tensor,
+    young: torch.Tensor,
+    poisson: torch.Tensor,
+    yield_stress: torch.Tensor,
+    law: NeuralHardeningLaw,
+    *,
+    bisection_iterations: int = 28,
+) -> dict[str, torch.Tensor]:
+    """Integrate a batch of complete strain histories."""
+
+    batch, points, _ = strain.shape
+    state = initial_state(
+        batch,
+        channels=law.channels,
+        dtype=strain.dtype,
+        device=strain.device,
+    )
+    stresses = []
+    plastics = []
+    peeqs = []
+    memories = []
+    increments = []
+    residuals = []
+    recoveries = []
+    moduli_history = []
+    for point in range(points):
+        stress, state, diagnostics = advance(
+            strain[:, point],
+            state,
+            young,
+            poisson,
+            yield_stress,
+            law,
+            bisection_iterations=bisection_iterations,
+        )
+        stresses.append(stress)
+        plastics.append(state.plastic_strain)
+        peeqs.append(state.peeq)
+        memories.append(state.memories)
+        increments.append(diagnostics["plastic_increment"])
+        residuals.append(diagnostics["yield_residual"])
+        recoveries.append(diagnostics["recovery"])
+        moduli_history.append(diagnostics["moduli"])
+    return {
+        "stress": torch.stack(stresses, dim=1),
+        "plastic_strain": torch.stack(plastics, dim=1),
+        "peeq": torch.stack(peeqs, dim=1),
+        "memories": torch.stack(memories, dim=1),
+        "plastic_increment": torch.stack(increments, dim=1),
+        "yield_residual": torch.stack(residuals, dim=1),
+        "recovery": torch.stack(recoveries, dim=1),
+        "moduli": torch.stack(moduli_history, dim=1),
+    }
+
+
+def discrete_energy_ledger(
+    result: dict[str, torch.Tensor],
+    yield_stress: torch.Tensor,
+    law: NeuralHardeningLaw,
+) -> dict[str, torch.Tensor]:
+    """Partition accepted plastic work using the implemented BE update."""
+
+    plastic = result["plastic_strain"]
+    memories = result["memories"]
+    peeq = result["peeq"]
+    increment = result["plastic_increment"]
+    stress = result["stress"]
+    old_plastic = torch.cat((torch.zeros_like(plastic[:, :1]), plastic[:, :-1]), dim=1)
+    old_memories = torch.cat((torch.zeros_like(memories[:, :1]), memories[:, :-1]), dim=1)
+    plastic_work = double_contract(stress, plastic - old_plastic)
+    stress_scale = yield_stress[:, None].expand_as(peeq)
+    isotropic_energy = law.isotropic.stored_energy(peeq, stress_scale)
+    old_isotropic = torch.cat(
+        (torch.zeros_like(isotropic_energy[:, :1]), isotropic_energy[:, :-1]), dim=1
+    )
+    isotropic_change = isotropic_energy - old_isotropic
+    moduli = result["moduli"]
+    kinematic_energy = (
+        3.0 * double_contract(memories, memories) / (4.0 * moduli)
+    ).sum(dim=-1)
+    old_kinematic = torch.cat(
+        (torch.zeros_like(kinematic_energy[:, :1]), kinematic_energy[:, :-1]), dim=1
+    )
+    kinematic_change = kinematic_energy - old_kinematic
+    reference = yield_stress[:, None] * increment
+    dynamic_recovery = (
+        3.0
+        * result["recovery"]
+        * double_contract(memories, memories)
+        * increment[..., None]
+        / (2.0 * moduli)
+    ).sum(dim=-1)
+    memory_increment = memories - old_memories
+    backward_euler = (
+        3.0 * double_contract(memory_increment, memory_increment) / (4.0 * moduli)
+    ).sum(dim=-1)
+    isotropic_radius = law.isotropic(peeq, stress_scale)
+    backward_euler = backward_euler + isotropic_radius * increment - isotropic_change
+    balance = (
+        plastic_work
+        - isotropic_change
+        - kinematic_change
+        - reference
+        - dynamic_recovery
+        - backward_euler
+    )
+    active = increment > 0.0
+    zero = torch.zeros_like(balance)
+    channels = {
+        "plastic_work": plastic_work,
+        "isotropic_stored_energy_change": isotropic_change,
+        "kinematic_stored_energy_change": kinematic_change,
+        "reference_yield_dissipation": reference,
+        "dynamic_recovery_dissipation": dynamic_recovery,
+        "backward_euler_dissipation": backward_euler,
+        "balance_residual": balance,
+    }
+    return {
+        name: torch.where(active, value, zero) for name, value in channels.items()
+    }
+
+
+def hard_constraint_diagnostics(state: GrayboxState) -> dict[str, torch.Tensor]:
+    return {
+        "maximum_plastic_trace": state.plastic_strain[..., :3].sum(dim=-1).abs(),
+        "minimum_peeq": state.peeq,
+        "maximum_memory_trace": state.memories[..., :3].sum(dim=-1).abs(),
+    }
+
+
+__all__ = [
+    "GrayboxState",
+    "MonotoneIsotropicHardening",
+    "NeuralHardeningLaw",
+    "ObjectiveRecoveryNetwork",
+    "advance",
+    "deviatoric",
+    "double_contract",
+    "discrete_energy_ledger",
+    "elastic_stress",
+    "hard_constraint_diagnostics",
+    "initial_state",
+    "rollout",
+    "von_mises",
+]
+
+# Public research name.  Keep the descriptive class name for readable source
+# and expose DENIM as the stable method alias used by the model card and demo.
+DENIM = NeuralHardeningLaw
+__all__.append("DENIM")

src/train_t2_graybox_closure.py

@@ -0,0 +1,24 @@
+"""Train DENRM on the intentionally mismatched incomplete-physics cohort."""
+
+from pathlib import Path
+
+from src.generate_t2_graybox_closure import DATA_PATH, MATERIAL
+from src.train_t2_graybox_discrete_energy import run
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+if __name__ == "__main__":
+    run(
+        graybox_steps=1600,
+        gru_epochs=60,
+        data_path=DATA_PATH,
+        material=MATERIAL,
+        model_dir=ROOT / "models" / "t2_graybox_closure_v1",
+        artifact_dir=ROOT / "artifacts" / "t2_graybox_closure_v1",
+        scope=(
+            "out-of-template fixed material: three-memory tabulated reference; "
+            "two-memory DENRM closure; reference equations and parameters hidden"
+        ),
+    )

src/train_t2_graybox_discrete_energy.py

@@ -0,0 +1,428 @@
+"""Train and evaluate the single T2 gray-box hardening architecture.
+
+The neural hardening law is initialized from accepted internal-state
+transitions produced by high-fidelity simulation.  The formulas and parameters
+of the generating hardening law are never passed to the model.  A stress-only
+variant is a later promotion gate; this first controlled study asks whether the
+unknown evolution can be recovered and deployed through an independent return
+map.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+import h5py
+import numpy as np
+import torch
+from torch import nn
+
+from agentfem import constitutive
+
+from src import t2_graybox_discrete_energy as graybox
+from src.generate_t2_graybox_cohort import DATA_PATH, MATERIAL
+from src.train_t2_multiaxial_models import RecurrentStress
+
+
+ROOT = Path(__file__).resolve().parents[1]
+MODEL_DIR = ROOT / "models" / "t2_graybox_hardening_v1"
+ARTIFACT_DIR = ROOT / "artifacts" / "t2_graybox_hardening_v1"
+METRICS_PATH = ARTIFACT_DIR / "model_metrics.json"
+
+
+@dataclass
+class Cohort:
+    strain: torch.Tensor
+    stress: torch.Tensor
+    plastic: torch.Tensor
+    peeq: torch.Tensor
+    increment: torch.Tensor
+    memories: torch.Tensor
+    radius: torch.Tensor
+    splits: tuple[str, ...]
+    families: tuple[str, ...]
+
+
+def load_cohort(data_path: Path = DATA_PATH) -> Cohort:
+    arrays: dict[str, list[np.ndarray]] = {
+        name: []
+        for name in (
+            "strain",
+            "stress_pa",
+            "plastic_strain",
+            "peeq",
+            "plastic_increment",
+            "memories_pa",
+            "isotropic_radius_pa",
+        )
+    }
+    splits: list[str] = []
+    families: list[str] = []
+    with h5py.File(data_path, "r") as h5:
+        for name in sorted(h5):
+            group = h5[name]
+            for field in arrays:
+                arrays[field].append(group[field][...])
+            splits.append(str(group.attrs["split"]))
+            families.append(str(group.attrs["path_family"]))
+    tensor = lambda name: torch.tensor(np.stack(arrays[name]), dtype=torch.float32)
+    return Cohort(
+        strain=tensor("strain"),
+        stress=tensor("stress_pa"),
+        plastic=tensor("plastic_strain"),
+        peeq=tensor("peeq"),
+        increment=tensor("plastic_increment"),
+        memories=tensor("memories_pa"),
+        radius=tensor("isotropic_radius_pa"),
+        splits=tuple(splits),
+        families=tuple(families),
+    )
+
+
+def mask(cohort: Cohort, split: str) -> torch.Tensor:
+    return torch.tensor([value == split for value in cohort.splits], dtype=torch.bool)
+
+
+def transition_data(cohort: Cohort, selected: torch.Tensor) -> dict[str, torch.Tensor]:
+    plastic_increment = cohort.increment[selected, 1:]
+    active = plastic_increment > 1.0e-11
+    old_plastic = cohort.plastic[selected, :-1]
+    new_plastic = cohort.plastic[selected, 1:]
+    flow = (new_plastic - old_plastic) / plastic_increment.clamp_min(1.0e-14)[..., None]
+    previous_increment = cohort.increment[selected, :-1]
+    previous_plastic = torch.cat(
+        (torch.zeros_like(old_plastic[:, :1]), old_plastic[:, :-1]), dim=1
+    )
+    previous_flow = (old_plastic - previous_plastic) / previous_increment.clamp_min(1.0e-14)[..., None]
+    previous_flow = torch.where(
+        (previous_increment > 1.0e-11)[..., None],
+        previous_flow,
+        torch.zeros_like(previous_flow),
+    )
+    result = {
+        "increment": plastic_increment[active],
+        "flow": flow[active],
+        "previous_flow": previous_flow[active],
+        "old_peeq": cohort.peeq[selected, :-1][active],
+        "new_peeq": cohort.peeq[selected, 1:][active],
+        "old_memories": cohort.memories[selected, :-1][active],
+        "new_memories": cohort.memories[selected, 1:][active],
+        "new_radius": cohort.radius[selected, 1:][active],
+    }
+    return result
+
+
+def train_graybox(
+    cohort: Cohort,
+    *,
+    steps: int = 1200,
+    batch_size: int = 4096,
+    material: dict[str, float] = MATERIAL,
+) -> tuple[graybox.NeuralHardeningLaw, dict[str, object]]:
+    training = transition_data(cohort, mask(cohort, "train"))
+    validation = transition_data(cohort, mask(cohort, "validation"))
+    model = graybox.NeuralHardeningLaw(channels=2)
+    optimizer = torch.optim.Adam(model.parameters(), lr=2.0e-3)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, steps, eta_min=2.0e-5)
+    generator = torch.Generator().manual_seed(20260925)
+    yield_stress = float(material["yield_stress_pa"])
+
+    def objective(data: dict[str, torch.Tensor], indices: torch.Tensor | None = None):
+        selected = data if indices is None else {key: value[indices] for key, value in data.items()}
+        count = len(selected["increment"])
+        scale = torch.full((count,), yield_stress)
+        state = graybox.GrayboxState(
+            plastic_strain=torch.zeros((count, 6)),
+            peeq=selected["old_peeq"],
+            memories=selected["old_memories"],
+            previous_flow=selected["previous_flow"],
+        )
+        predicted, recovery, moduli = model.update_memories(
+            state, selected["flow"], selected["increment"], scale
+        )
+        predicted_radius = model.isotropic(selected["new_peeq"], scale)
+        memory_state = ((predicted - selected["new_memories"]) / yield_stress).square().mean()
+        memory_increment = (
+            (
+                (predicted - state.memories)
+                - (selected["new_memories"] - state.memories)
+            )
+            / 5.0e6
+        ).square().mean()
+        radius = ((predicted_radius - selected["new_radius"]) / 70.0e6).square().mean()
+        loss = memory_state + memory_increment + radius
+        return loss, {
+            "memory_state": memory_state,
+            "memory_increment": memory_increment,
+            "radius": radius,
+            "recovery_mean": recovery.mean(dim=0),
+            "moduli": moduli.mean(dim=0),
+        }
+
+    started = time.perf_counter()
+    best_loss = float("inf")
+    best_state = None
+    history = []
+    for step in range(steps):
+        indices = torch.randint(
+            len(training["increment"]),
+            (min(batch_size, len(training["increment"])),),
+            generator=generator,
+        )
+        optimizer.zero_grad()
+        loss, diagnostics = objective(training, indices)
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), 10.0)
+        optimizer.step()
+        scheduler.step()
+        if step % 25 == 0 or step + 1 == steps:
+            with torch.no_grad():
+                validation_loss, validation_diagnostics = objective(validation)
+            value = float(validation_loss)
+            history.append(
+                {
+                    "step": step,
+                    "training_loss": float(loss.detach()),
+                    "validation_loss": value,
+                    "moduli_pa": validation_diagnostics["moduli"].tolist(),
+                    "recovery_mean": validation_diagnostics["recovery_mean"].tolist(),
+                }
+            )
+            if value < best_loss:
+                best_loss = value
+                best_state = {key: value.detach().clone() for key, value in model.state_dict().items()}
+    if best_state is None:
+        raise RuntimeError("Gray-box training did not produce a checkpoint.")
+    model.load_state_dict(best_state)
+    model.eval()
+    return model, {
+        "training_seconds": time.perf_counter() - started,
+        "best_validation_loss": best_loss,
+        "steps": steps,
+        "history": history,
+    }
+
+
+def train_gru(
+    cohort: Cohort,
+    *,
+    epochs: int = 60,
+) -> tuple[nn.Module, dict[str, object], dict[str, torch.Tensor]]:
+    train = mask(cohort, "train")
+    validation = mask(cohort, "validation")
+    strain_mean = cohort.strain[train].mean(dim=(0, 1), keepdim=True)
+    strain_std = cohort.strain[train].std(dim=(0, 1), keepdim=True).clamp_min(1.0e-6)
+    stress_mean = cohort.stress[train].mean(dim=(0, 1), keepdim=True)
+    stress_std = cohort.stress[train].std(dim=(0, 1), keepdim=True).clamp_min(1.0e6)
+    inputs = (cohort.strain - strain_mean) / strain_std
+    targets = (cohort.stress - stress_mean) / stress_std
+    model = RecurrentStress(6, cell="gru", hidden=72)
+    optimizer = torch.optim.AdamW(model.parameters(), lr=2.0e-3, weight_decay=1.0e-5)
+    generator = torch.Generator().manual_seed(20260925)
+    train_indices = torch.where(train)[0]
+    best_loss = float("inf")
+    best_state = None
+    started = time.perf_counter()
+    for _ in range(epochs):
+        shuffled = train_indices[torch.randperm(len(train_indices), generator=generator)]
+        model.train()
+        for start in range(0, len(shuffled), 16):
+            selected = shuffled[start : start + 16]
+            optimizer.zero_grad()
+            loss = (model(inputs[selected]) - targets[selected]).square().mean()
+            loss.backward()
+            optimizer.step()
+        model.eval()
+        with torch.no_grad():
+            value = float((model(inputs[validation]) - targets[validation]).square().mean())
+        if value < best_loss:
+            best_loss = value
+            best_state = {key: value.detach().clone() for key, value in model.state_dict().items()}
+    if best_state is None:
+        raise RuntimeError("GRU training did not produce a checkpoint.")
+    model.load_state_dict(best_state)
+    model.eval()
+    return model, {
+        "training_seconds": time.perf_counter() - started,
+        "best_validation_loss": best_loss,
+        "epochs": epochs,
+    }, {
+        "strain_mean": strain_mean,
+        "strain_std": strain_std,
+        "stress_mean": stress_mean,
+        "stress_std": stress_std,
+    }
+
+
+def _voigt_to_tensor(value: np.ndarray) -> np.ndarray:
+    tensor = np.zeros((3, 3), dtype=float)
+    tensor[(0, 1, 2, 0, 1, 0), (0, 1, 2, 1, 2, 2)] = value
+    tensor[(1, 2, 2), (0, 1, 0)] = value[[3, 4, 5]]
+    return tensor
+
+
+def no_hardening_response(
+    cohort: Cohort, material: dict[str, float] = MATERIAL
+) -> torch.Tensor:
+    law = constitutive.J2LinearIsotropicHardening(
+        young=float(material["young_pa"]),
+        poisson=float(material["poisson"]),
+        yield_stress=float(material["yield_stress_pa"]),
+        hardening_modulus=0.0,
+    )
+    result = np.empty_like(cohort.stress.numpy())
+    for case in range(len(cohort.strain)):
+        state = None
+        for point, strain in enumerate(cohort.strain[case].numpy()):
+            update = law.update(_voigt_to_tensor(strain), state, linearization="none")
+            state = update.state
+            tensor = update.stress
+            result[case, point] = tensor[(0, 1, 2, 0, 1, 0), (0, 1, 2, 1, 2, 2)]
+    return torch.tensor(result)
+
+
+def stress_metrics(
+    prediction: torch.Tensor,
+    reference: torch.Tensor,
+    selected: torch.Tensor,
+) -> dict[str, float | int]:
+    error = prediction[selected] - reference[selected]
+    denominator = ((reference[selected] - reference[selected].mean()).square().sum()).clamp_min(1.0)
+    return {
+        "trajectory_count": int(selected.sum()),
+        "rmse_mpa": float(torch.sqrt(error.square().mean()) / 1.0e6),
+        "mae_mpa": float(error.abs().mean() / 1.0e6),
+        "r2": float(1.0 - error.square().sum() / denominator),
+    }
+
+
+def run(
+    *,
+    graybox_steps: int = 1200,
+    gru_epochs: int = 60,
+    data_path: Path = DATA_PATH,
+    material: dict[str, float] = MATERIAL,
+    model_dir: Path = MODEL_DIR,
+    artifact_dir: Path = ARTIFACT_DIR,
+    scope: str = "fixed synthetic material; hardening parameters and formulas hidden from learned models",
+) -> dict[str, object]:
+    random.seed(20260925)
+    np.random.seed(20260925)
+    torch.manual_seed(20260925)
+    cohort = load_cohort(data_path)
+    graybox_model, graybox_training = train_graybox(
+        cohort, steps=graybox_steps, material=material
+    )
+    gru_model, gru_training, normalization = train_gru(cohort, epochs=gru_epochs)
+    with torch.no_grad():
+        started = time.perf_counter()
+        graybox_result = graybox.rollout(
+            cohort.strain,
+            torch.full((len(cohort.strain),), float(material["young_pa"])),
+            torch.full((len(cohort.strain),), float(material["poisson"])),
+            torch.full((len(cohort.strain),), float(material["yield_stress_pa"])),
+            graybox_model,
+            bisection_iterations=24,
+        )
+        graybox_inference = time.perf_counter() - started
+        started = time.perf_counter()
+        gru_prediction = (
+            gru_model(
+                (cohort.strain - normalization["strain_mean"])
+                / normalization["strain_std"]
+            )
+            * normalization["stress_std"]
+            + normalization["stress_mean"]
+        )
+        gru_inference = time.perf_counter() - started
+    started = time.perf_counter()
+    incomplete_prediction = no_hardening_response(cohort, material)
+    incomplete_inference = time.perf_counter() - started
+
+    metrics: dict[str, object] = {
+        "scope": scope,
+        "training": {
+            "denrm": graybox_training,
+            "gru": gru_training,
+        },
+        "models": {},
+    }
+    for name, prediction, seconds in (
+        ("incomplete_j2", incomplete_prediction, incomplete_inference),
+        ("gru", gru_prediction, gru_inference),
+        ("denrm", graybox_result["stress"], graybox_inference),
+    ):
+        metrics["models"][name] = {
+            split: stress_metrics(prediction, cohort.stress, mask(cohort, split))
+            for split in ("train", "validation", "test")
+        }
+        metrics["models"][name]["inference_seconds_all_trajectories"] = seconds
+    active = graybox_result["plastic_increment"] > 1.0e-11
+    ledger = graybox.discrete_energy_ledger(
+        graybox_result,
+        torch.full((len(cohort.strain),), float(material["yield_stress_pa"])),
+        graybox_model,
+    )
+    energy_scale = ledger["plastic_work"][active].abs().max().clamp_min(1.0)
+    metrics["models"]["denrm"].update(
+        maximum_yield_residual_pa=float(graybox_result["yield_residual"][active].abs().max()),
+        maximum_plastic_trace=float(
+            graybox_result["plastic_strain"][..., :3].sum(dim=-1).abs().max()
+        ),
+        minimum_peeq_increment=float(
+            torch.diff(graybox_result["peeq"], dim=1).min()
+        ),
+        learned_moduli_pa=(
+            graybox_model.moduli(torch.tensor(float(material["yield_stress_pa"])))
+            .detach()
+            .tolist()
+        ),
+        minimum_reference_yield_dissipation=float(
+            ledger["reference_yield_dissipation"][active].min()
+        ),
+        minimum_dynamic_recovery_dissipation=float(
+            ledger["dynamic_recovery_dissipation"][active].min()
+        ),
+        minimum_backward_euler_dissipation=float(
+            ledger["backward_euler_dissipation"][active].min().detach()
+        ),
+        maximum_energy_balance_relative_residual=float(
+            (
+                ledger["balance_residual"][active].abs().max() / energy_scale
+            ).detach()
+        ),
+    )
+    model_dir.mkdir(parents=True, exist_ok=True)
+    artifact_dir.mkdir(parents=True, exist_ok=True)
+    torch.save(
+        {"state_dict": graybox_model.state_dict(), "material_known": {
+            key: material[key] for key in ("young_pa", "poisson", "yield_stress_pa")
+        }},
+        model_dir / "denrm.pt",
+    )
+    torch.save(
+        {"state_dict": gru_model.state_dict(), "normalization": normalization},
+        model_dir / "gru.pt",
+    )
+    (artifact_dir / "model_metrics.json").write_text(
+        json.dumps(metrics, indent=2) + "\n", encoding="utf-8"
+    )
+    print(json.dumps({"models": metrics["models"]}, indent=2))
+    return metrics
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--graybox-steps", type=int, default=1200)
+    parser.add_argument("--gru-epochs", type=int, default=60)
+    args = parser.parse_args()
+    run(graybox_steps=args.graybox_steps, gru_epochs=args.gru_epochs)
+
+
+if __name__ == "__main__":
+    main()

src/validate_t2_graybox.py

@@ -0,0 +1,411 @@
+"""Time-discretization and structural deployment gates for T2 DENRM."""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+from scipy.optimize import least_squares
+
+from src import structural_validate_t2_models as structure
+from src import t2_graybox_discrete_energy as graybox
+from src.generate_t2_graybox_cohort import MATERIAL, design, solve
+
+
+ROOT = Path(__file__).resolve().parents[1]
+MODEL_PATH = ROOT / "models" / "t2_graybox_hardening_v1" / "denrm.pt"
+ARTIFACT_DIR = ROOT / "artifacts" / "t2_graybox_hardening_v1"
+OUTPUT = ARTIFACT_DIR / "deployment_validation.json"
+BASIS = torch.tensor((1.0, -0.5, -0.5, 0.0, 0.0, 0.0), dtype=torch.float64)
+
+
+def load_model(model_path: Path = MODEL_PATH) -> graybox.NeuralHardeningLaw:
+    checkpoint = torch.load(model_path, map_location="cpu", weights_only=False)
+    model = graybox.NeuralHardeningLaw(channels=2).double()
+    model.load_state_dict(checkpoint["state_dict"])
+    model.eval()
+    return model
+
+
+def _rollout(
+    model: graybox.NeuralHardeningLaw,
+    strain: np.ndarray,
+    material: dict[str, object] = MATERIAL,
+) -> dict[str, torch.Tensor]:
+    selected = torch.tensor(strain, dtype=torch.float64)
+    batch = len(selected)
+    with torch.no_grad():
+        return graybox.rollout(
+            selected,
+            torch.full((batch,), float(material["young_pa"]), dtype=torch.float64),
+            torch.full((batch,), float(material["poisson"]), dtype=torch.float64),
+            torch.full((batch,), float(material["yield_stress_pa"]), dtype=torch.float64),
+            model,
+            bisection_iterations=30,
+        )
+
+
+def time_discretization_gate(
+    model: graybox.NeuralHardeningLaw,
+    *,
+    rows: list[dict[str, object]] | None = None,
+    solve_function=solve,
+    material: dict[str, object] = MATERIAL,
+) -> dict[str, object]:
+    rows = design(4) if rows is None else rows
+    selected = [rows[index] for index in range(0, len(rows), 4)]
+    result: dict[str, object] = {}
+    predictions: dict[int, dict[str, torch.Tensor]] = {}
+    references: dict[int, np.ndarray] = {}
+    for points in (121, 481):
+        solved = [solve_function(row, points=points) for row in selected]
+        strain = np.stack([case["strain"] for case in solved])
+        reference = np.stack([case["stress_pa"] for case in solved])
+        prediction = _rollout(model, strain, material)
+        error = prediction["stress"].numpy() - reference
+        active = prediction["plastic_increment"] > 1.0e-11
+        predictions[points] = prediction
+        references[points] = reference
+        result[str(points)] = {
+            "trajectory_count": len(selected),
+            "rmse_mpa": float(np.sqrt(np.mean(error**2)) / 1.0e6),
+            "mae_mpa": float(np.mean(np.abs(error)) / 1.0e6),
+            "maximum_yield_residual_pa": float(
+                prediction["yield_residual"][active].abs().max()
+            ),
+        }
+    coarse_terminal = predictions[121]["stress"][:, -1]
+    fine_terminal = predictions[481]["stress"][:, -1]
+    reference_scale = torch.tensor(references[481][:, -1]).norm().clamp_min(1.0)
+    result["terminal_121_to_481_relative_change"] = float(
+        (coarse_terminal - fine_terminal).norm() / reference_scale
+    )
+    return result
+
+
+def _response(
+    model: graybox.NeuralHardeningLaw,
+    old_state: graybox.GrayboxState,
+    scalar_strain: float,
+) -> tuple[float, float, graybox.GrayboxState]:
+    def evaluate(value: float):
+        strain = (float(value) * BASIS).reshape(1, 6)
+        with torch.no_grad():
+            return graybox.advance(
+                strain,
+                old_state,
+                torch.tensor((float(MATERIAL["young_pa"]),), dtype=torch.float64),
+                torch.tensor((float(MATERIAL["poisson"]),), dtype=torch.float64),
+                torch.tensor((float(MATERIAL["yield_stress_pa"]),), dtype=torch.float64),
+                model,
+                bisection_iterations=30,
+            )
+
+    stress, state, _ = evaluate(scalar_strain)
+    generalized = float(graybox.double_contract(stress[0], BASIS))
+    step = 1.0e-7 * max(1.0, abs(scalar_strain) / 0.005)
+    upper, _, _ = evaluate(scalar_strain + step)
+    lower, _, _ = evaluate(scalar_strain - step)
+    tangent = float(
+        (graybox.double_contract(upper[0], BASIS) - graybox.double_contract(lower[0], BASIS))
+        / (2.0 * step)
+    )
+    return generalized, tangent, state
+
+
+def _batch_response(
+    model: graybox.NeuralHardeningLaw,
+    old_state: graybox.GrayboxState,
+    scalar_strain: np.ndarray,
+    material: dict[str, object] = MATERIAL,
+) -> tuple[np.ndarray, np.ndarray, graybox.GrayboxState]:
+    """Evaluate every element in one batched constitutive call.
+
+    The global bar problem has independent quadrature-point states, which map
+    directly to DENRM's batch dimension.  Batching preserves the local return
+    map while avoiding thousands of tiny Python/PyTorch calls.
+    """
+
+    values = torch.as_tensor(scalar_strain, dtype=torch.float64)
+    batch = len(values)
+    young = torch.full((batch,), float(material["young_pa"]), dtype=torch.float64)
+    poisson = torch.full((batch,), float(material["poisson"]), dtype=torch.float64)
+    yield_stress = torch.full(
+        (batch,), float(material["yield_stress_pa"]), dtype=torch.float64
+    )
+
+    def evaluate(selected: torch.Tensor):
+        strain = selected[:, None] * BASIS[None, :]
+        return graybox.advance(
+            strain,
+            old_state,
+            young,
+            poisson,
+            yield_stress,
+            model,
+            bisection_iterations=30,
+        )
+
+    with torch.no_grad():
+        stress, state, _ = evaluate(values)
+        generalized = graybox.double_contract(stress, BASIS)
+        step = 1.0e-7 * torch.maximum(
+            torch.ones_like(values), values.abs() / 0.005
+        )
+        upper, _, _ = evaluate(values + step)
+        lower, _, _ = evaluate(values - step)
+        tangent = (
+            graybox.double_contract(upper, BASIS)
+            - graybox.double_contract(lower, BASIS)
+        ) / (2.0 * step)
+    return generalized.numpy(), tangent.numpy(), state
+
+
+def solve_structure(
+    model: graybox.NeuralHardeningLaw,
+    displacement: np.ndarray,
+    *,
+    elements: int = 12,
+    notch_depth: float,
+    material: dict[str, object] = MATERIAL,
+) -> dict[str, np.ndarray | float]:
+    nodes, area = structure.geometry(elements, notch_depth)
+    lengths = np.diff(nodes)
+    states = graybox.initial_state(elements, channels=2, dtype=torch.float64)
+    u = np.zeros(elements + 1)
+    reactions = []
+    iterations = []
+    trust_region_fallback_steps: list[int] = []
+    started = time.perf_counter()
+    for step_index, end_value in enumerate(displacement):
+        if step_index > 0:
+            u += np.linspace(0.0, end_value - u[-1], elements + 1)
+        u[0] = 0.0
+        u[-1] = end_value
+        accepted = None
+        for iteration in range(60):
+            internal = np.zeros(elements + 1)
+            stiffness = np.zeros((elements + 1, elements + 1))
+            strains = np.diff(u) / lengths
+            current_stress, current_tangent, trial_states = _batch_response(
+                model, states, strains, material
+            )
+            for element in range(elements):
+                stress = current_stress[element]
+                tangent = float(np.clip(current_tangent[element], 1.0e7, 4.0e11))
+                b = np.asarray((-1.0 / lengths[element], 1.0 / lengths[element]))
+                dofs = (element, element + 1)
+                internal[list(dofs)] += area[element] * stress * b * lengths[element]
+                stiffness[np.ix_(dofs, dofs)] += (
+                    area[element] * tangent * np.outer(b, b) * lengths[element]
+                )
+            residual = internal[1:-1]
+            scale = max(float(np.linalg.norm(internal)), 1.0)
+            # The local law is solved tightly, but its scalar tangent is a
+            # finite-difference directional derivative across an active-set
+            # switch.  Use an engineering equilibrium tolerance and a bounded
+            # Newton correction, matching the deployment gate used for the
+            # other learned constitutive models in this project.
+            if np.linalg.norm(residual) <= 2.0e-6 * scale + 1.0e2:
+                accepted = trial_states
+                break
+            increment = np.linalg.solve(stiffness[1:-1, 1:-1], residual)
+            maximum = 0.20 * max(abs(end_value), 1.0e-5)
+            norm_increment = np.max(np.abs(increment))
+            if norm_increment > maximum:
+                increment *= maximum / norm_increment
+            u[1:-1] -= increment
+        if accepted is None:
+            # Reversal points can place several integration points on different
+            # sides of the elastic/plastic active-set switch.  Recover the same
+            # FE equilibrium with a bounded trust-region solve; the local
+            # constitutive law and its committed state remain unchanged.
+            end_fixed = float(end_value)
+
+            # In a one-dimensional bar, equilibrium is equivalently expressed
+            # by a single constant axial force.  Solving for all element
+            # strains plus that force avoids poor conditioning in nodal
+            # coordinates at a displacement reversal.
+            def force_compatibility(unknown: np.ndarray) -> np.ndarray:
+                candidate_strain = unknown[:-1]
+                force_scaled = unknown[-1]
+                candidate_stress, _, _ = _batch_response(
+                    model, states, candidate_strain, material
+                )
+                force_balance = area * candidate_stress / 1.0e8 - force_scaled
+                compatibility = (
+                    np.dot(lengths, candidate_strain) - end_fixed
+                ) / 0.005
+                return np.concatenate((force_balance, (compatibility,)))
+
+            def force_compatibility_jacobian(unknown: np.ndarray) -> np.ndarray:
+                candidate_strain = unknown[:-1]
+                _, candidate_tangent, _ = _batch_response(
+                    model, states, candidate_strain, material
+                )
+                candidate_tangent = np.clip(candidate_tangent, 1.0e7, 4.0e11)
+                jacobian = np.zeros((elements + 1, elements + 1))
+                jacobian[np.arange(elements), np.arange(elements)] = (
+                    area * candidate_tangent / 1.0e8
+                )
+                jacobian[:elements, -1] = -1.0
+                jacobian[-1, :elements] = lengths / 0.005
+                return jacobian
+
+            initial_strain = np.diff(u) / lengths
+            initial_force = float(internal[-1]) / 1.0e8
+            recovered = least_squares(
+                force_compatibility,
+                np.concatenate((initial_strain, (initial_force,))),
+                method="trf",
+                jac=force_compatibility_jacobian,
+                x_scale=np.concatenate((np.full(elements, 0.005), (1.0,))),
+                max_nfev=120,
+                xtol=1.0e-12,
+                ftol=1.0e-12,
+                gtol=1.0e-12,
+            )
+            if recovered.success:
+                strains = recovered.x[:-1]
+                u = np.concatenate(((0.0,), np.cumsum(lengths * strains)))
+                current_stress, _, trial_states = _batch_response(
+                    model, states, strains, material
+                )
+                internal = np.zeros(elements + 1)
+                for element in range(elements):
+                    b = np.asarray((-1.0 / lengths[element], 1.0 / lengths[element]))
+                    dofs = (element, element + 1)
+                    internal[list(dofs)] += (
+                        area[element]
+                        * current_stress[element]
+                        * b
+                        * lengths[element]
+                    )
+                residual = internal[1:-1]
+                scale = max(float(np.linalg.norm(internal)), 1.0)
+                if np.linalg.norm(residual) <= 2.0e-6 * scale + 1.0e2:
+                    accepted = trial_states
+                    iteration = 60 + int(recovered.nfev)
+                    trust_region_fallback_steps.append(step_index)
+        if accepted is None:
+            raise RuntimeError(
+                f"DENRM structural solve failed at step {step_index}; "
+                f"max_abs_element_strain={float(np.max(np.abs(strains))):.6g}."
+            )
+        states = accepted
+        reactions.append(float(internal[-1]))
+        iterations.append(iteration + 1)
+    return {
+        "reaction": np.asarray(reactions),
+        "iterations": np.asarray(iterations),
+        "trust_region_fallback_steps": trust_region_fallback_steps,
+        "elapsed_seconds": time.perf_counter() - started,
+    }
+
+
+def structural_gate(
+    model: graybox.NeuralHardeningLaw,
+    *,
+    material: dict[str, object] = MATERIAL,
+    native_law_factory=structure.material,
+    artifact_dir: Path = ARTIFACT_DIR,
+) -> dict[str, object]:
+    result: dict[str, object] = {}
+    figure, axes = plt.subplots(1, 2, figsize=(10.0, 4.2), constrained_layout=True)
+    cases = (
+        ("mild_cyclic", 0.12, structure.load_history(points=81)),
+        ("severe_monotonic", 0.42, np.linspace(0.0, 0.0065, 61)),
+    )
+    for axis, (name, depth, displacement) in zip(
+        axes,
+        cases,
+        strict=True,
+    ):
+        reference = structure.solve_native(
+            12,
+            displacement,
+            notch_depth=depth,
+            law_factory=native_law_factory,
+        )
+        learned = solve_structure(
+            model, displacement, notch_depth=depth, material=material
+        )
+        difference = learned["reaction"] - reference["reaction"]
+        relative = float(
+            np.linalg.norm(difference) / max(np.linalg.norm(reference["reaction"]), 1.0)
+        )
+        result[name] = {
+            "reaction_relative_l2": relative,
+            "maximum_absolute_reaction_error": float(np.max(np.abs(difference))),
+            "maximum_newton_iterations": int(np.max(learned["iterations"])),
+            "mean_newton_iterations": float(np.mean(learned["iterations"])),
+            "trust_region_fallback_count": len(
+                learned["trust_region_fallback_steps"]
+            ),
+            "trust_region_fallback_steps": list(
+                learned["trust_region_fallback_steps"]
+            ),
+            "elapsed_seconds": float(learned["elapsed_seconds"]),
+        }
+        axis.plot(displacement, reference["reaction"], label="AgentFEM reference")
+        axis.plot(displacement, learned["reaction"], "--", label="DENRM")
+        axis.set_title(name.replace("_", " "))
+        axis.set_xlabel("prescribed end displacement")
+        axis.set_ylabel("reaction")
+        axis.grid(alpha=0.2)
+    axes[0].legend(frameon=False)
+    artifact_dir.mkdir(parents=True, exist_ok=True)
+    figure.savefig(artifact_dir / "structural_reaction_comparison.png", dpi=190)
+    plt.close(figure)
+
+    # Deliberately retain a stronger cyclic extrapolation as a falsification
+    # gate.  It currently exceeds the training strain envelope during reversal;
+    # recording the failure is more informative than silently shrinking it.
+    try:
+        severe_cyclic = solve_structure(
+            model,
+            structure.load_history(points=81),
+            notch_depth=0.42,
+            material=material,
+        )
+        result["severe_cyclic_stress_test"] = {
+            "passed": True,
+            "maximum_newton_iterations": int(
+                np.max(severe_cyclic["iterations"])
+            ),
+            "trust_region_fallback_count": len(
+                severe_cyclic["trust_region_fallback_steps"]
+            ),
+        }
+    except RuntimeError as error:
+        result["severe_cyclic_stress_test"] = {
+            "passed": False,
+            "failure": str(error),
+            "interpretation": (
+                "strong cyclic localization leaves the present training envelope; "
+                "this is a declared promotion-gate failure, not a successful deployment"
+            ),
+        }
+    return result
+
+
+def main() -> None:
+    model = load_model()
+    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
+    result = {
+        "time_discretization": time_discretization_gate(model),
+        "structure": structural_gate(model),
+    }
+    OUTPUT.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

src/validate_t2_graybox_closure.py

@@ -0,0 +1,46 @@
+"""Promotion gates for the out-of-template incomplete-physics closure."""
+
+import json
+from pathlib import Path
+
+from src.generate_t2_graybox_closure import MATERIAL, closure_design, material, solve
+from src.validate_t2_graybox import (
+    load_model,
+    structural_gate,
+    time_discretization_gate,
+)
+
+
+ROOT = Path(__file__).resolve().parents[1]
+MODEL_PATH = ROOT / "models" / "t2_graybox_closure_v1" / "denrm.pt"
+ARTIFACT_DIR = ROOT / "artifacts" / "t2_graybox_closure_v1"
+OUTPUT = ARTIFACT_DIR / "deployment_validation.json"
+
+
+def main() -> None:
+    model = load_model(MODEL_PATH)
+    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
+    result = {
+        "scope": (
+            "reference has three memories and tabulated hardening; deployed DENRM "
+            "has two memories and no access to the reference equations"
+        ),
+        "time_discretization": time_discretization_gate(
+            model,
+            rows=closure_design(4),
+            solve_function=solve,
+            material=MATERIAL,
+        ),
+        "structure": structural_gate(
+            model,
+            material=MATERIAL,
+            native_law_factory=material,
+            artifact_dir=ARTIFACT_DIR,
+        ),
+    }
+    OUTPUT.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

tests/test_t2_graybox_closure.py

@@ -0,0 +1,25 @@
+import numpy as np
+
+from src.generate_t2_graybox_closure import closure_design, material, solve
+
+
+def test_reference_is_intentionally_richer_than_closure_state():
+    law = material()
+    assert law.backstress_count == 3
+    assert law.isotropic_hardening is not None
+    assert len(law.isotropic_hardening.equivalent_plastic_strain) == 7
+
+
+def test_closure_cohort_preserves_total_reference_backstress():
+    row = closure_design(4)[0]
+    nine_points = 9
+    result = solve(row, points=nine_points)
+    assert result["strain"].shape == (nine_points, 6)
+    assert result["truth_memories_pa"].shape == (nine_points, 3, 6)
+    assert result["memories_pa"].shape == (nine_points, 2, 6)
+    np.testing.assert_allclose(
+        result["memories_pa"].sum(axis=1),
+        result["truth_memories_pa"].sum(axis=1),
+        rtol=1.0e-12,
+        atol=1.0e-5,
+    )

tests/test_t2_graybox_discrete_energy.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import torch
+
+from src import t2_graybox_discrete_energy as subject
+
+
+def test_monotone_hardening_is_zero_anchored_and_nondecreasing() -> None:
+    model = subject.MonotoneIsotropicHardening().double()
+    peeq = torch.linspace(0.0, 0.03, 101, dtype=torch.float64)
+    scale = torch.full_like(peeq, 300.0e6)
+    radius = model(peeq, scale)
+    assert abs(float(radius[0].detach())) < 1.0e-8
+    assert torch.all(radius[1:] >= radius[:-1])
+    assert torch.all(model.derivative(peeq, scale) > 0.0)
+
+
+def test_recovery_is_positive_and_objective_under_basis_rotation() -> None:
+    torch.manual_seed(7)
+    model = subject.ObjectiveRecoveryNetwork(channels=2).double()
+    memories = subject.deviatoric(torch.randn(4, 2, 6, dtype=torch.float64))
+    flow = subject.deviatoric(torch.randn(4, 6, dtype=torch.float64))
+    peeq = torch.linspace(0.0, 0.02, 4, dtype=torch.float64)
+    radius = torch.linspace(0.0, 80.0e6, 4, dtype=torch.float64)
+    scale = torch.full((4,), 280.0e6, dtype=torch.float64)
+    reversal = torch.linspace(-1.0, 1.0, 4, dtype=torch.float64)
+    result = model(peeq, radius, flow, memories, scale, reversal)
+    assert torch.all(result > 0.0)
+
+    def as_matrix(value: torch.Tensor) -> torch.Tensor:
+        tensor = torch.zeros((*value.shape[:-1], 3, 3), dtype=value.dtype)
+        tensor[..., 0, 0] = value[..., 0]
+        tensor[..., 1, 1] = value[..., 1]
+        tensor[..., 2, 2] = value[..., 2]
+        tensor[..., 0, 1] = tensor[..., 1, 0] = value[..., 3]
+        tensor[..., 1, 2] = tensor[..., 2, 1] = value[..., 4]
+        tensor[..., 0, 2] = tensor[..., 2, 0] = value[..., 5]
+        return tensor
+
+    def as_voigt(value: torch.Tensor) -> torch.Tensor:
+        return value[..., (0, 1, 2, 0, 1, 0), (0, 1, 2, 1, 2, 2)]
+
+    rotation, _ = torch.linalg.qr(torch.randn(3, 3, dtype=torch.float64))
+    rotated_flow = as_voigt(
+        torch.einsum("ij,bjk,lk->bil", rotation, as_matrix(flow), rotation)
+    )
+    rotated_memories = as_voigt(
+        torch.einsum("ij,bcjk,lk->bcil", rotation, as_matrix(memories), rotation)
+    )
+    rotated = model(
+        peeq, radius, rotated_flow, rotated_memories, scale, reversal
+    )
+    torch.testing.assert_close(rotated, result, rtol=1.0e-12, atol=1.0e-12)
+
+
+def test_memory_update_preserves_deviatoric_state_and_nonnegative_rates() -> None:
+    law = subject.NeuralHardeningLaw(channels=2).double()
+    state = subject.initial_state(3, channels=2, dtype=torch.float64)
+    flow = subject.deviatoric(torch.randn(3, 6, dtype=torch.float64))
+    increment = torch.tensor((0.0, 1.0e-4, 5.0e-4), dtype=torch.float64)
+    scale = torch.full((3,), 280.0e6, dtype=torch.float64)
+    memories, recovery, moduli = law.update_memories(
+        state, flow, increment, scale
+    )
+    assert torch.all(recovery > 0.0)
+    assert torch.all(moduli > 0.0)
+    assert torch.max(torch.abs(memories[..., :3].sum(dim=-1))) < 1.0e-8
+    assert torch.count_nonzero(memories[0]) == 0
+
+
+def test_elastic_stress_recovers_zero_for_zero_elastic_strain() -> None:
+    strain = torch.randn(5, 6, dtype=torch.float64)
+    stress = subject.elastic_stress(
+        strain,
+        strain,
+        torch.full((5,), 200.0e9, dtype=torch.float64),
+        torch.full((5,), 0.3, dtype=torch.float64),
+    )
+    assert torch.count_nonzero(stress) == 0
+
+
+def test_neural_return_map_closes_yield_surface_and_state_constraints() -> None:
+    law = subject.NeuralHardeningLaw(channels=2).double()
+    strain = torch.zeros((2, 25, 6), dtype=torch.float64)
+    axial = torch.linspace(0.0, 0.009, 25, dtype=torch.float64)
+    strain[:, :, 0] = axial
+    strain[:, :, 1] = -0.5 * axial
+    strain[:, :, 2] = -0.5 * axial
+    result = subject.rollout(
+        strain,
+        torch.full((2,), 190.0e9, dtype=torch.float64),
+        torch.full((2,), 0.3, dtype=torch.float64),
+        torch.full((2,), 280.0e6, dtype=torch.float64),
+        law,
+    )
+    assert torch.isfinite(result["stress"]).all()
+    assert torch.all(result["peeq"][:, 1:] >= result["peeq"][:, :-1])
+    assert torch.max(torch.abs(result["plastic_strain"][..., :3].sum(-1))) < 1.0e-10
+    active = result["plastic_increment"] > 1.0e-12
+    assert torch.max(torch.abs(result["yield_residual"][active])) < 20.0
+    ledger = subject.discrete_energy_ledger(
+        result,
+        torch.full((2,), 280.0e6, dtype=torch.float64),
+        law,
+    )
+    scale = ledger["plastic_work"][active].abs().max()
+    assert ledger["reference_yield_dissipation"][active].min() >= 0.0
+    assert ledger["dynamic_recovery_dissipation"][active].min() >= 0.0
+    assert ledger["backward_euler_dissipation"][active].min() >= -1.0e-8 * scale
+    assert ledger["balance_residual"][active].abs().max() < 1.0e-8 * scale