Release frozen ModeBench Levels 1, 2 and 3 with verified splits and executable evaluation

CONTENT_SHA256.json

@@ -0,0 +1,1376 @@
+{
+  "files": [
+    {
+      "bytes": 2919,
+      "git_blob_sha1": "ac47b1381dfd276db6f7ae76c3fb85ca4abd7f38",
+      "path_in_repo": "EVALUATION.md",
+      "sha256": "22857d29101323623e3d8ba23e9ea5efb530706e02c62daf163ff924ddeb4d75"
+    },
+    {
+      "bytes": 778,
+      "git_blob_sha1": "09062826b28ccae4af267ea8f6dda72c4e3e1bd5",
+      "path_in_repo": "LICENSE_PROVENANCE.md",
+      "sha256": "b7b05e3788472a530d7b3528789c41c524c575004cf4e258dd4438a91ab3196d"
+    },
+    {
+      "bytes": 866,
+      "git_blob_sha1": "719fe37db1574d8e8a3389c5961c9b37b283d7a1",
+      "path_in_repo": "LOADER_VALIDATION.json",
+      "sha256": "71ef5258c2c1e25e8e681b7f8272134715cecfcd434182c8d14bdf52ee2b9d10"
+    },
+    {
+      "bytes": 280422,
+      "git_blob_sha1": "e6561ee03d20b803b9cb2a73a618aa9cc7796707",
+      "path_in_repo": "MANIFEST.json",
+      "sha256": "858f23b93bbc555a69f080dff59cd1f4ef62f05133e1dc3e616ad734e56f9a07"
+    },
+    {
+      "bytes": 1502,
+      "git_blob_sha1": "89920ef9e56164214c0f211d7e9ddcc70fb488fc",
+      "path_in_repo": "PROMPTS.md",
+      "sha256": "564623a9953728e2bff9df8a7fb0e07ce433d6c375d9d1a999a322118b062959"
+    },
+    {
+      "bytes": 9355,
+      "git_blob_sha1": "f1008a760e8a2c480105449ad2cd51f99dff4777",
+      "path_in_repo": "README.md",
+      "sha256": "97aba5563179bfbaffa4027eb12289c8093b3ec6574495ae423d24992dfa150d"
+    },
+    {
+      "bytes": 2430,
+      "git_blob_sha1": "6e4c10f02da9f24952462b4f2e909035847af2f2",
+      "path_in_repo": "SPLITS.md",
+      "sha256": "e8dfe2a3026382ff6c7d3a84b399824c1a36d180763aa4f99e6bed2b904c6563"
+    },
+    {
+      "bytes": 12448,
+      "git_blob_sha1": "2164c02230f3cdd416efec76c8fbebb6c5d2c79a",
+      "path_in_repo": "VALIDATION.json",
+      "sha256": "eb6d6fe6cbdb41d5963c17da012c16d03b7ac6a34cfeeaeb303c6f6b04841927"
+    },
+    {
+      "bytes": 71,
+      "git_blob_sha1": "13437e8afc6380b580b0dc8ed00c20798ad54c1c",
+      "path_in_repo": "code/oat_drgrpo/__init__.py",
+      "sha256": "3345b113aadcb190054dba65691d8c2aa51194979c5ead9d3aa87dabd27f8238"
+    },
+    {
+      "bytes": 8188,
+      "git_blob_sha1": "b6c40463ecd2992c71d2547d5f03906f64541b39",
+      "path_in_repo": "code/oat_drgrpo/ant_maze_worker_v10.py",
+      "sha256": "bebbff349fa31024ac87f1dd856050e7ef56c346babea735313fd36a5fe03ec6"
+    },
+    {
+      "bytes": 4163,
+      "git_blob_sha1": "b703dbcff59ca32229dab9285ce15598136f0c08",
+      "path_in_repo": "code/oat_drgrpo/ant_maze_worker_v11.py",
+      "sha256": "b7c2540239b1afb3454d83c7d5f7634bd1d994692e2fe6710ccdde63cc441e14"
+    },
+    {
+      "bytes": 9066,
+      "git_blob_sha1": "dcf98c2fed9dc9120a7bcd1b82dd428bf6aac9dc",
+      "path_in_repo": "code/oat_drgrpo/ant_maze_worker_v12.py",
+      "sha256": "84b4d11157951782cb253259ac5a8301491d020f716a84debcdb825bb902bb8b"
+    },
+    {
+      "bytes": 6087,
+      "git_blob_sha1": "129e24b2a95bdf64247b78d56d49544f0cee19f0",
+      "path_in_repo": "code/oat_drgrpo/ant_maze_worker_v5.py",
+      "sha256": "faa55c2035b26ba8eb20685a92535430505334e90569adaf3d803955a5680ea7"
+    },
+    {
+      "bytes": 6876,
+      "git_blob_sha1": "d7e707168626baf68a047835a9a3b5b8f37d089b",
+      "path_in_repo": "code/oat_drgrpo/ant_maze_worker_v8.py",
+      "sha256": "7f9ab36749115d062f0f49d833355fef9240a94555bdf5274bf7f4da70e573f8"
+    },
+    {
+      "bytes": 8847,
+      "git_blob_sha1": "ad2207840d75de00b39eda0e6435832f21cc447c",
+      "path_in_repo": "code/oat_drgrpo/ant_maze_worker_v9.py",
+      "sha256": "1a811aab3b61dd18c5de770086f090b67db01017bf08f4431a775ec497b1b0cc"
+    },
+    {
+      "bytes": 37065,
+      "git_blob_sha1": "527d0360b3de59fe9b5e18c244e167726118578d",
+      "path_in_repo": "code/oat_drgrpo/canonical_actions.py",
+      "sha256": "0fcbc0409ec89ce6dced35f1e3b5ae787076dfcc5aafdfa4194fee52c1aa187f"
+    },
+    {
+      "bytes": 69515,
+      "git_blob_sha1": "a8c9de23e450ab68e7ecb5c487fea2e3eaf40fca",
+      "path_in_repo": "code/oat_drgrpo/math_grader.py",
+      "sha256": "5bc8a2382ab30d9ccb2dfa4a9cbfb78be28187e1b5049063814cc262b5bac255"
+    },
+    {
+      "bytes": 17571,
+      "git_blob_sha1": "934d0b61350b9d75a780ab045ae2fe08e41e3bf3",
+      "path_in_repo": "code/oat_drgrpo/math_route.py",
+      "sha256": "0c430a9e8f4c215665b673d4fbca8e5e4db3dd050814fe30a2a07ac7750317cc"
+    },
+    {
+      "bytes": 31858,
+      "git_blob_sha1": "c8ae33d19bcc57f45ae54419f18df65794fb2cd6",
+      "path_in_repo": "code/oat_drgrpo/mathir.py",
+      "sha256": "1f35d72b68033e1a272305034ca15ab3a53a74edd93a838de831262c75b5825a"
+    },
+    {
+      "bytes": 20894,
+      "git_blob_sha1": "1d0b73feb7aca3393ef72cd0c8efd86e17e53def",
+      "path_in_repo": "code/oat_drgrpo/maze_modebench.py",
+      "sha256": "ee1557c7e229055d9b1235c53fe1ea0160aa9f2a69cc330a6f6ef7b8d9439b62"
+    },
+    {
+      "bytes": 5746,
+      "git_blob_sha1": "761c637e121198e41e9bc33bbb1aaf81f523d136",
+      "path_in_repo": "code/oat_drgrpo/maze_modebench_process.py",
+      "sha256": "c6e6b9093e9cf9bc537151313dfd9c7d650dcbbe254a4c1ef61d2c5b20b6c3d6"
+    },
+    {
+      "bytes": 6948,
+      "git_blob_sha1": "3ca827edab0e61cf99553fa5adfe4e610a75f1b7",
+      "path_in_repo": "code/oat_drgrpo/maze_modebench_worker.py",
+      "sha256": "2ee1fa9b1bbde5509c34eb42c2806bc215fba0bddd8d6ca9ce9e67648170f3a2"
+    },
+    {
+      "bytes": 2664,
+      "git_blob_sha1": "be2625c3af1d2745bb09afd5a82a7dcba522f4bd",
+      "path_in_repo": "code/oat_drgrpo/maze_runtime_identity.py",
+      "sha256": "5f3799be54aa693d957a7a0e23dd0f014e8c84715756e68b1263484289842112"
+    },
+    {
+      "bytes": 3146,
+      "git_blob_sha1": "913ae043739916add64523d5b524e4539469c690",
+      "path_in_repo": "code/oat_drgrpo/modebench_guided.py",
+      "sha256": "b1e744d18e186ab138469059a7557147a436c142eebf354b94138c0f6aa9534c"
+    },
+    {
+      "bytes": 13574,
+      "git_blob_sha1": "886b4a79de5cf0e05ab7a7482742c6b7e97c79d3",
+      "path_in_repo": "code/oat_drgrpo/pantry_plan.py",
+      "sha256": "dd246a0510fc5d2964794b6d228ff30cc682200cdc0073540bf45e3273666712"
+    },
+    {
+      "bytes": 6411,
+      "git_blob_sha1": "7326a50ad0f6142ee9d2f5fb70952ff46a990678",
+      "path_in_repo": "code/oat_drgrpo/pantry_support_action.py",
+      "sha256": "78c555485b1975fd17cc8ad30886f3665b41a4c6423b14ade9540136db212a6a"
+    },
+    {
+      "bytes": 8552,
+      "git_blob_sha1": "05a89956f9e8246b598719fd88bc865f6b9b8f45",
+      "path_in_repo": "code/oat_drgrpo/python_modebench.py",
+      "sha256": "0fa4a452d5935f3922ef3e2ffeacbc5d9f3ddb8defdcbb31c04050346313c726"
+    },
+    {
+      "bytes": 4570,
+      "git_blob_sha1": "8f3f3741ee282225fb6678c8342376a6275acea5",
+      "path_in_repo": "code/oat_drgrpo/python_modebench_process.py",
+      "sha256": "5b8471171f9ef433d111db19b39dba172482bfcc32e01897cf3382357096680e"
+    },
+    {
+      "bytes": 1200,
+      "git_blob_sha1": "738d25f77fabf9570432efccadba7ac4e55a4de6",
+      "path_in_repo": "code/oat_drgrpo/python_modebench_worker.py",
+      "sha256": "6595e9ea6a1786753734e8ddb03efd4d78ac7f6091e8dc3c6db312eef12db210"
+    },
+    {
+      "bytes": 19110,
+      "git_blob_sha1": "3d136b4ce41c9dcd45653db8e474ac6f6e1f9643",
+      "path_in_repo": "code/oat_drgrpo/templates.py",
+      "sha256": "6af7522ff71e02dbe46867a722288c0681f7136ca8d297b59c3c9a55fd30b123"
+    },
+    {
+      "bytes": 8432,
+      "git_blob_sha1": "a401ec339d4f01a15ac95bd5ef78e9455c23a673",
+      "path_in_repo": "data/level1_countdown/eval.parquet",
+      "sha256": "a1da95c1b5997a0c8d804c8bf7b607817b11bb8c7982b3d04bd4c345da7b9c33"
+    },
+    {
+      "bytes": 13725,
+      "git_blob_sha1": "fdeceaa2187186d504b743a86a1eee96768e303d",
+      "path_in_repo": "data/level1_countdown/train.parquet",
+      "sha256": "00054c212d28ccb103b982cb56de7c381691b91a8ee3af7d984c5e0d57fe74f1"
+    },
+    {
+      "bytes": 13112,
+      "git_blob_sha1": "83015c9011e65a5703107f0e08699bf8c5a268c1",
+      "path_in_repo": "data/level1_graph_coloring/eval.parquet",
+      "sha256": "5c009576b979ac78b9bf73c80790e0048a75f4c27c400569907f096e18a220fb"
+    },
+    {
+      "bytes": 22522,
+      "git_blob_sha1": "ab59a3c26fa48dd213ee22612d9a98c73a483e3c",
+      "path_in_repo": "data/level1_graph_coloring/train.parquet",
+      "sha256": "56266083798c5e86223e7705d3ed2b97d22dc8aba56814402a0c09afc9eddf30"
+    },
+    {
+      "bytes": 13015,
+      "git_blob_sha1": "e5d2aaf558802717ddb4aa9466a707244ba3c540",
+      "path_in_repo": "data/level1_graph_coloring_unique_answer/eval.parquet",
+      "sha256": "759ba48dbcd3fcd4f000449eed1b9e0ea55319dc9677f5150842180ea95893bf"
+    },
+    {
+      "bytes": 20812,
+      "git_blob_sha1": "acae2f38e3d448f0aafb70b9549a88d2d3ad8598",
+      "path_in_repo": "data/level1_mathir/eval.parquet",
+      "sha256": "fc0280c144e5c9c54624303cd508612dbbb3a0ef130dfee9a42fb8f9413e9902"
+    },
+    {
+      "bytes": 37345,
+      "git_blob_sha1": "3e8e4a9a352bde694a385000da38c9aafd20ce1e",
+      "path_in_repo": "data/level1_mathir/train.parquet",
+      "sha256": "aac7f11f814eb85769cd16fe8464d886cef3daade22d3d61de50385de9c0662a"
+    },
+    {
+      "bytes": 36731,
+      "git_blob_sha1": "4183df90f133ce99d5fe8bda1f2d8de9e972f727",
+      "path_in_repo": "data/level1_pantry_plan/dev.parquet",
+      "sha256": "0411b6d32ff14491d14ab5c9edf37a28e8d6fc9ad95ad3afc3f172ba7ec23319"
+    },
+    {
+      "bytes": 48960,
+      "git_blob_sha1": "eed241a0c7d6b95569f4dc4be7b56dd4b7e48165",
+      "path_in_repo": "data/level1_pantry_plan/eval.parquet",
+      "sha256": "2807515694c01108c5b8a616eded485a6ffded07fd1f9eb5fa0155cfeb7c2c34"
+    },
+    {
+      "bytes": 98671,
+      "git_blob_sha1": "6da3fc0a1e1df610b190620fba44dac0cf0fa06f",
+      "path_in_repo": "data/level1_pantry_plan/train.parquet",
+      "sha256": "eced2be5ca3fb8194703e8f9d7cfd5d29a1ee701369be14cd388d2004b80a8a3"
+    },
+    {
+      "bytes": 16281,
+      "git_blob_sha1": "cfd9c975bce895b1ac9d8e23fb3804518a30caaa",
+      "path_in_repo": "data/level1_python_factors/eval.parquet",
+      "sha256": "88a3f35b0f3e8e9b8ec4da5151ca7697afc79894c0507d00c258d4154983cea0"
+    },
+    {
+      "bytes": 31553,
+      "git_blob_sha1": "36d5f2b6a3bd731d93e1bb3f78c3b8e5e1ed6f62",
+      "path_in_repo": "data/level1_python_factors/train.parquet",
+      "sha256": "86e4abc2ff3f2efff47c67aaa3263af2fcb226adefcb8fa52e94ff3c15a94948"
+    },
+    {
+      "bytes": 8674,
+      "git_blob_sha1": "cf79ba519180e1c556c039c4c3179c1ec3395a2b",
+      "path_in_repo": "data/level2_countdown/dev.parquet",
+      "sha256": "2f9451228cfd2a49580d3c93b21f58685a477adf2a40d014f480a8f3cc91ef99"
+    },
+    {
+      "bytes": 8752,
+      "git_blob_sha1": "20240aac2147eae6bb47ba61f27fb858ff6f64e3",
+      "path_in_repo": "data/level2_countdown/eval.parquet",
+      "sha256": "50b90a6197ff1ac83ba0020239bb903bb597c334a27329d3e8703f163cf5d17c"
+    },
+    {
+      "bytes": 14452,
+      "git_blob_sha1": "53d155f2a232f9cb548a539f0a76412359b001f2",
+      "path_in_repo": "data/level2_countdown/train.parquet",
+      "sha256": "bd6a3645bd2e84e90478ddd9f4c4f4f69c28f41a6df7615acb91a9f92374db97"
+    },
+    {
+      "bytes": 13257,
+      "git_blob_sha1": "35d98a6485ec63a1fd73c3273e2548c51d60f9dd",
+      "path_in_repo": "data/level2_graph_coloring/dev.parquet",
+      "sha256": "9d32ed70ff3f002f35dd23b5197e4b06a477b08e4e418bc682675b1e0402ece7"
+    },
+    {
+      "bytes": 13086,
+      "git_blob_sha1": "5c2a1fc00d8c430167a3bfa2577ffaa1be6a3c3e",
+      "path_in_repo": "data/level2_graph_coloring/eval.parquet",
+      "sha256": "63e5f1b8f4b3db950022080c9971cec71c864d369f346f64aa9c303da5b1e33f"
+    },
+    {
+      "bytes": 23261,
+      "git_blob_sha1": "97cefe83f9d3e6f0bd5209cb6f8c05edda93968a",
+      "path_in_repo": "data/level2_graph_coloring/train.parquet",
+      "sha256": "bd250e096ea785d45e76d0de1c7d872ca8822e95181568cb8ae1b69a6b905fd8"
+    },
+    {
+      "bytes": 20318,
+      "git_blob_sha1": "958cdc0c99d63d212ca3deea980cbb02198c7715",
+      "path_in_repo": "data/level2_mathir/dev.parquet",
+      "sha256": "3dbbb10af2589e467ace24420fe67387fb299ba465a1180163a2b62910dd2fd4"
+    },
+    {
+      "bytes": 20588,
+      "git_blob_sha1": "8d21abc6a5a99e41b676e9eda5bf142884a8df5c",
+      "path_in_repo": "data/level2_mathir/eval.parquet",
+      "sha256": "646e8780fdfbad6ec5681fba1583dafc9ac6755200b2cb80f497dab75320819f"
+    },
+    {
+      "bytes": 37680,
+      "git_blob_sha1": "953a8006cc94ba05d16a30a96f43c996bd0a31d9",
+      "path_in_repo": "data/level2_mathir/train.parquet",
+      "sha256": "f32e8223d9335f2460182d21f5b787e3fb895162255d42a6995d5669a0750a54"
+    },
+    {
+      "bytes": 49384,
+      "git_blob_sha1": "d63caee7fb6d3dd8e349738b1e4f4baae623bcfe",
+      "path_in_repo": "data/level2_pantry_plan/dev.parquet",
+      "sha256": "1c33bea8878ea99b007399cdc9de1b69da8053d5f700728b4203f5bef49a7f76"
+    },
+    {
+      "bytes": 48888,
+      "git_blob_sha1": "6e0211e6619483c142b6004ea16fb7bf0c0043aa",
+      "path_in_repo": "data/level2_pantry_plan/eval.parquet",
+      "sha256": "94a1aac4a48bfd21e363433397fcd834bbd39c096551900f63b29dadc960905b"
+    },
+    {
+      "bytes": 96678,
+      "git_blob_sha1": "cee4689e5f96bc81b78bcd2d961b76d15e3a735c",
+      "path_in_repo": "data/level2_pantry_plan/train.parquet",
+      "sha256": "dd531d612bd8addef1f6a4da8f61cbf8c5068a8738b0f0033a310a292c89a9fe"
+    },
+    {
+      "bytes": 16949,
+      "git_blob_sha1": "65fa0921e42e8c740ab24e5f343ae21d01a7e0c6",
+      "path_in_repo": "data/level2_python_factors/dev.parquet",
+      "sha256": "70d3c17097338e96a5284dae841d0461173ad7c019c33b3c8dbbff990a70ccd3"
+    },
+    {
+      "bytes": 17020,
+      "git_blob_sha1": "95efdd0bf554b50a6e02e451cf84e8341285117c",
+      "path_in_repo": "data/level2_python_factors/eval.parquet",
+      "sha256": "3b6f96ca863cb4a5be793fd4e5e12337db48622faf3f70782553c37f64675a42"
+    },
+    {
+      "bytes": 33339,
+      "git_blob_sha1": "468ac2e9880eddaf0297f39d7f2e5f588358b84c",
+      "path_in_repo": "data/level2_python_factors/train.parquet",
+      "sha256": "3662ed77c4c9ab7e3b2fae14217b86b5f0939a27326a7edd139bb789bd84c5db"
+    },
+    {
+      "bytes": 15097,
+      "git_blob_sha1": "f89aa6748044731d032c00bf3cae7bd5ef4d866f",
+      "path_in_repo": "data/level3_countdown/dev.parquet",
+      "sha256": "c88bea04f663a199a26371a03f5b36c2a7d0ff70031286b308a51264984a35ae"
+    },
+    {
+      "bytes": 14941,
+      "git_blob_sha1": "53831ca966031f6397918813c682ea797fce3828",
+      "path_in_repo": "data/level3_countdown/eval.parquet",
+      "sha256": "b8c8540758fb32b8d49c0bc0f1c4337b6f29017f9f9fdcb618365d232a3e8c9a"
+    },
+    {
+      "bytes": 23693,
+      "git_blob_sha1": "a703c78d510255e92fed871ea2f52a7d3ecafecf",
+      "path_in_repo": "data/level3_countdown/train.parquet",
+      "sha256": "6003fd18559b3a1caaaed1a036d74badd61a4774346b480e49a00e28acbe7f02"
+    },
+    {
+      "bytes": 15287,
+      "git_blob_sha1": "13f5f88123cbf2a437231c414db672a6795f5558",
+      "path_in_repo": "data/level3_graph_coloring/dev.parquet",
+      "sha256": "a9a33bc4666a34184bea8bd3cb311fa00346811852ff466547d399327f93a9d2"
+    },
+    {
+      "bytes": 15173,
+      "git_blob_sha1": "7c9a96184999e44a8271887274e6e34fe51d2a08",
+      "path_in_repo": "data/level3_graph_coloring/eval.parquet",
+      "sha256": "dd4bc7dedf28e5d153c80046abd3f8e8a80a6adcdd11b80aa05dde3cd5378bc7"
+    },
+    {
+      "bytes": 23853,
+      "git_blob_sha1": "f05ab1bdf30cd5c7ee427ea25e7d1c8d4723eec3",
+      "path_in_repo": "data/level3_graph_coloring/train.parquet",
+      "sha256": "0f6d9e8a5196a9536a39b56583272584cb2722b8317466cc4cd4c52767edeed9"
+    },
+    {
+      "bytes": 24048,
+      "git_blob_sha1": "5da9121267611637c7ceaa62bf06ede3faaf26f7",
+      "path_in_repo": "data/level3_mathir/dev.parquet",
+      "sha256": "9bb2d32ceda8ef0fde17e3ce4ee934f5f2142aab871bd79755a96b563ca93e39"
+    },
+    {
+      "bytes": 24589,
+      "git_blob_sha1": "d416291875da5b3d0729f4b32d5f7b07254aa146",
+      "path_in_repo": "data/level3_mathir/eval.parquet",
+      "sha256": "9903ce6c9a612887787db2e803519fa715214e6733e2c684e85d1735c770d89a"
+    },
+    {
+      "bytes": 43948,
+      "git_blob_sha1": "505b77b364ca13b32af324353e0c19d4431a29b4",
+      "path_in_repo": "data/level3_mathir/train.parquet",
+      "sha256": "e07fe596001de4614d40bd73e5c2898ee32357e87c4c09863568015461f3c3fc"
+    },
+    {
+      "bytes": 59675,
+      "git_blob_sha1": "f443672f8041777b7d3b2063592c65899154c012",
+      "path_in_repo": "data/level3_pantry_plan/dev.parquet",
+      "sha256": "4e508afec73597913468094dc7aeac59735b3d0767b1700bddf07bd7e7e643e8"
+    },
+    {
+      "bytes": 59289,
+      "git_blob_sha1": "37a3a052529dd4cc66146e2bb2a13ee1badbe9eb",
+      "path_in_repo": "data/level3_pantry_plan/eval.parquet",
+      "sha256": "63840b51ead4a7799c1376e49739322f2a085beaef981389a5f077ff058757a7"
+    },
+    {
+      "bytes": 121812,
+      "git_blob_sha1": "03470cd851bd0e5cb80dbffc3ac2a2a3acf43150",
+      "path_in_repo": "data/level3_pantry_plan/train.parquet",
+      "sha256": "e97d3cda0e229934b32cd87a5a11627f124167918502ede632b7d6e3be56b255"
+    },
+    {
+      "bytes": 24170,
+      "git_blob_sha1": "a4cdf607f4a0dc6b502eae70e7b2da3de503da1a",
+      "path_in_repo": "data/level3_python_factors/dev.parquet",
+      "sha256": "1d72c49e9d43afa00b1b4c2f3b75bdbc9b753e4334d346b5283b7dadcdbdffe3"
+    },
+    {
+      "bytes": 24013,
+      "git_blob_sha1": "a512741389bb3d987e5c936c0ff5dbfd157c883a",
+      "path_in_repo": "data/level3_python_factors/eval.parquet",
+      "sha256": "77d32ab09bb2125206b5fe291251b74219130a1a89d79d2b2d93700305ee0f21"
+    },
+    {
+      "bytes": 41093,
+      "git_blob_sha1": "60efbfa212cf7076ddc4b1f8ba838f7a10336ef8",
+      "path_in_repo": "data/level3_python_factors/train.parquet",
+      "sha256": "cf5ee666dd126716d0a0cf68c9a74512bbb222ca68ad8839dcb276fab988e358"
+    },
+    {
+      "bytes": 11357,
+      "git_blob_sha1": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64",
+      "path_in_repo": "licenses/source_repository_APACHE_2.0.txt",
+      "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    },
+    {
+      "bytes": 1261933,
+      "git_blob_sha1": "6269793f92edd108cbab8bc7f994eae80028d269",
+      "path_in_repo": "provenance/confirmation_report.json",
+      "sha256": "b685cfa6b20d6f9b714239546a7946947af95af3d4e83ed8ab1b7ad96c453195"
+    },
+    {
+      "bytes": 3860,
+      "git_blob_sha1": "1cb5aaaef42fe9bf623444fb0e8d678870802242",
+      "path_in_repo": "provenance/e119_level2_qwen05b_factorial_20260901.md",
+      "sha256": "76c338cd34e92aae8310403fc2e26786b613280bec6a66dbf049acf24d321225"
+    },
+    {
+      "bytes": 9094,
+      "git_blob_sha1": "2d401ed9328f62690878a1fc47ad4ba852b1f5d6",
+      "path_in_repo": "provenance/e122_level3_factorial_20260909.md",
+      "sha256": "fd094df005e8df2110c33ba0d69e2bcbcd5e83b45ad86bc4271ac444b4f18bdb"
+    },
+    {
+      "bytes": 48308,
+      "git_blob_sha1": "5971aafb29ce14ec3ae59331c5772ea52ecd2b7f",
+      "path_in_repo": "provenance/pantry_ingredient_source.json",
+      "sha256": "ce86c69b5b36c047b256254820282d54ab45f0137d26295f0842646de3578226"
+    },
+    {
+      "bytes": 5708,
+      "git_blob_sha1": "89910c7e049b6d80a276bf3eaa98c9c125a18969",
+      "path_in_repo": "provenance/source_code/ops/check_paper_domain_prompts.py",
+      "sha256": "53a6b77703836ca9f92cd58cc6a9efc711e3c8a5466a4b6ab7d1b6214ccdfbff"
+    },
+    {
+      "bytes": 14400,
+      "git_blob_sha1": "6b5b4ddffb6a074f08ab9ed5ae824aaebd3aaf10",
+      "path_in_repo": "provenance/source_code/ops/evaluate_modebench_level2_viability.py",
+      "sha256": "f6c9de12ff86f079cbf4cdd8db37c2ee2a9a8ff069c84fa149dcb43da4b67e2f"
+    },
+    {
+      "bytes": 20188,
+      "git_blob_sha1": "32dee56c3d4b4163f7062eb9b991ba63da656141",
+      "path_in_repo": "provenance/source_code/ops/evaluate_modebench_level3.py",
+      "sha256": "df43446b3a748db7dd5b055b3a36bd7ad5db6e3fd2966960fee89669e03cf324"
+    },
+    {
+      "bytes": 20354,
+      "git_blob_sha1": "d4c76773cc52d97f4c4a98ae696a5dac7a113ef4",
+      "path_in_repo": "provenance/source_code/ops/evaluate_modebench_level3_independent.py",
+      "sha256": "faf980b6594a065fe5a475058a43862821be96dd7f19cfae00259684623b4ab7"
+    },
+    {
+      "bytes": 17616,
+      "git_blob_sha1": "dd7d6e4ba3152fd37bef173f5b0770c47d3a307d",
+      "path_in_repo": "provenance/source_code/ops/exp_scaling/materialize_modebench_harder_v2.py",
+      "sha256": "056ceee55fbff1a7288473c5f36c941de3de96908e93bb18b65668299473a676"
+    },
+    {
+      "bytes": 6236,
+      "git_blob_sha1": "1e0fa766b1eff11a81d94878aa7b98327ac095da",
+      "path_in_repo": "provenance/source_code/ops/exp_scaling/materialize_modebench_level3.py",
+      "sha256": "0a38e3695cd3b2c8e25367e50a16d5a0f98bcd48d1f52af344c8322b14c19d1b"
+    },
+    {
+      "bytes": 21494,
+      "git_blob_sha1": "3dca49050d4bcb45cd0cafcb199b2ed0330a51cf",
+      "path_in_repo": "provenance/source_code/ops/exp_scaling/modebench_level3_v3_common.py",
+      "sha256": "1cb2a47b7b1751da8229be7940bd932816daea09a56bae4b6d62cb2bef1e9522"
+    },
+    {
+      "bytes": 2492,
+      "git_blob_sha1": "afe1df64fbfae0d1c6e1c87941cc7c487f845db2",
+      "path_in_repo": "provenance/source_code/ops/modebench_independent_seeds.py",
+      "sha256": "a92a0f5441b5a22d6c9b5ccb72edf30fb22404acfc30b15efbd8ea4ee9104d92"
+    },
+    {
+      "bytes": 4703,
+      "git_blob_sha1": "7db25a627511310758bc0f08d360f9ae5f6bda54",
+      "path_in_repo": "provenance/source_code/tests/test_modebench_hf_release.py",
+      "sha256": "c944a8bcbbc171fbd4750c2a47fe3301df57388e5f6dbb04b4c114ed8d3d02c1"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/exact_countdown_easy3_probe/eval/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/exact_countdown_easy3_probe/eval/multi_answer/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "76c9388cc9deea0b527bcb3431734151604101d5",
+      "path_in_repo": "provenance/source_data/exact_countdown_easy3_probe/eval/multi_answer/state.json",
+      "sha256": "ae88b13d1684218849d4c235002b8f7f770599b34be92230195f616e3a25fde6"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/exact_countdown_easy3_probe/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/exact_countdown_easy3_probe/train/train/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "67858f3ed56a9481782b3ef9a00df41c3071dec2",
+      "path_in_repo": "provenance/source_data/exact_countdown_easy3_probe/train/train/state.json",
+      "sha256": "902d4a51a4dc5bd0b3c3984ae68bb0a29e7ac4ba95199d555d04e01d9121f299"
+    },
+    {
+      "bytes": 45,
+      "git_blob_sha1": "aa7c0f1e0ccb96d330850535916e18ee4bc36082",
+      "path_in_repo": "provenance/source_data/graph_coloring_modebench_v2/eval/dataset_dict.json",
+      "sha256": "81c8ff31a03c8612cebfb1c48127291d14558c7227ca25542d7b2bb226ed988c"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/graph_coloring_modebench_v2/eval/multi_answer/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "16d25a6197aea9df9d43bf5de62cb222a701ecb1",
+      "path_in_repo": "provenance/source_data/graph_coloring_modebench_v2/eval/multi_answer/state.json",
+      "sha256": "8008d939336a53476cdf6715afb460e831036b36efee3c61c065f0bc23904718"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/graph_coloring_modebench_v2/eval/unique_answer/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "b56860156dbefd057cfc78aed7afd93ddf28dd5e",
+      "path_in_repo": "provenance/source_data/graph_coloring_modebench_v2/eval/unique_answer/state.json",
+      "sha256": "79c6a7ccd0fbd2c2a98d14199217aebee651d320abe0133d5b147da842cdf5de"
+    },
+    {
+      "bytes": 1085,
+      "git_blob_sha1": "9bcc0f6dcf87f0a9a7ed1f5ead8e994960873784",
+      "path_in_repo": "provenance/source_data/graph_coloring_modebench_v2/identity.json",
+      "sha256": "6dfa0c5e3339feb2cd6199a808fd9d30a16ec181c89605a34c0b8ce4c12bf85a"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/graph_coloring_modebench_v2/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/graph_coloring_modebench_v2/train/train/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "3fe22da20625dff007474a2c75055c3ce71bdaf6",
+      "path_in_repo": "provenance/source_data/graph_coloring_modebench_v2/train/train/state.json",
+      "sha256": "cac8943c3972749dc2678275ec49afc6b6b4e50f4c33fbb6b00e15813a49f6f9"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/mathir_action_menu_v1/eval/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 559,
+      "git_blob_sha1": "c15fdbab4b5c6018a0638960fc92f250777ce2d9",
+      "path_in_repo": "provenance/source_data/mathir_action_menu_v1/eval/multi_answer/dataset_info.json",
+      "sha256": "524a7bcf8a0a2067c688f41612fbfce06a30c9ac3e3ef1472ef4b057609ccc27"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "1281fdfaf4f2046d8ad8adefb59fb1f53b53ecc7",
+      "path_in_repo": "provenance/source_data/mathir_action_menu_v1/eval/multi_answer/state.json",
+      "sha256": "d6765f2eb1fcb90fe917f82f593ab90c6ea99a1fd5f9beef1c8f0e5844ff62f0"
+    },
+    {
+      "bytes": 1289,
+      "git_blob_sha1": "c7213187024467b8b02ddc5325ae0e0599823ee2",
+      "path_in_repo": "provenance/source_data/mathir_action_menu_v1/identity.json",
+      "sha256": "a278cca1b222202a40616750e1e0c56799f02ded838eef51eeb3b097d75b103f"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/mathir_action_menu_v1/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 559,
+      "git_blob_sha1": "c15fdbab4b5c6018a0638960fc92f250777ce2d9",
+      "path_in_repo": "provenance/source_data/mathir_action_menu_v1/train/train/dataset_info.json",
+      "sha256": "524a7bcf8a0a2067c688f41612fbfce06a30c9ac3e3ef1472ef4b057609ccc27"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "76069e469a1c17b32053c56d352cd9f7d8bb1d18",
+      "path_in_repo": "provenance/source_data/mathir_action_menu_v1/train/train/state.json",
+      "sha256": "023c546290b2182a30761450cb650fb021e8144c752b6c7667beb10c58011efe"
+    },
+    {
+      "bytes": 31577,
+      "git_blob_sha1": "7523dd09f3eb166ddafd0c882fb8d52824d5f125",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/admission_fairness_report.json",
+      "sha256": "0070600d687715fadff0cdf920e8959aeb6bcb398c566047bcdc285a05a611cb"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/countdown/dev/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/countdown/dev/multi_answer/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "23c40b5235ab80a11a29ecf0909836707cdb4695",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/countdown/dev/multi_answer/state.json",
+      "sha256": "c2c852d47b4a21edbc86cacc47339f87d6b74006a6f3e7bba31bfb9362ac1532"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/countdown/eval/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/countdown/eval/multi_answer/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "a21ae45e27992d524e1c3963a4b1be6b3deeec9b",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/countdown/eval/multi_answer/state.json",
+      "sha256": "e7bd76961f10ef2ba7154a81636d97e08b91a6f58ad7c70f159ddbe1b5f54061"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/countdown/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/countdown/train/train/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "8650d0a35bc3bf9d04dac0904d0b0845598662f8",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/countdown/train/train/state.json",
+      "sha256": "f8f51e5c0788d05708a44fdbd16ace7b602cc6993b6f678296826f610ab6ab61"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/graph_coloring/dev/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/graph_coloring/dev/multi_answer/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "0bba9de9623af0576f2cd0b556a0f38eec7c2693",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/graph_coloring/dev/multi_answer/state.json",
+      "sha256": "6cf8a5162993168b51312bc9e2de58ada3a4cd8e23ff6109beaf25cbe9206681"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/graph_coloring/eval/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/graph_coloring/eval/multi_answer/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "c0bb6e49e58b98278c4671f4a12c5d254aa1677d",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/graph_coloring/eval/multi_answer/state.json",
+      "sha256": "d92e2d1f778196ca811c6b102212e72c8119b2d13b21611a04d39fe4e149bde9"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/graph_coloring/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/graph_coloring/train/train/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "2aa010d5067bc555d64b72123910d88708c57179",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/graph_coloring/train/train/state.json",
+      "sha256": "570d70eb1cdf7aee52dce77ca0febd3322ed2ac434df091e01fa13d03f41d022"
+    },
+    {
+      "bytes": 17289,
+      "git_blob_sha1": "0da053bd543463b777c61e4921c502568eb74e3e",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/identity.json",
+      "sha256": "2af80f4d31a44482574b314cc37ef84bde48c53ecc2ff78dadf97571f0d73fb2"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/mathir/dev/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 559,
+      "git_blob_sha1": "c15fdbab4b5c6018a0638960fc92f250777ce2d9",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/mathir/dev/multi_answer/dataset_info.json",
+      "sha256": "524a7bcf8a0a2067c688f41612fbfce06a30c9ac3e3ef1472ef4b057609ccc27"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "09207b5e91bd7f457902033de3562b99e0f89432",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/mathir/dev/multi_answer/state.json",
+      "sha256": "1d40e16033cad5ec2b8bef6ff61bd56a624a2d8c3ed95d0dba42b99e91212570"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/mathir/eval/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 559,
+      "git_blob_sha1": "c15fdbab4b5c6018a0638960fc92f250777ce2d9",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/mathir/eval/multi_answer/dataset_info.json",
+      "sha256": "524a7bcf8a0a2067c688f41612fbfce06a30c9ac3e3ef1472ef4b057609ccc27"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "09bca51c5a6d593e0e142960849ec071abc6228b",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/mathir/eval/multi_answer/state.json",
+      "sha256": "3ebd34460b5ba4802edf8b0c0540788c237739ffb7823de13fa7457917903602"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/mathir/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 559,
+      "git_blob_sha1": "c15fdbab4b5c6018a0638960fc92f250777ce2d9",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/mathir/train/train/dataset_info.json",
+      "sha256": "524a7bcf8a0a2067c688f41612fbfce06a30c9ac3e3ef1472ef4b057609ccc27"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "f1a71948cfd17b56ca96ed489ce7128595a22f46",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/mathir/train/train/state.json",
+      "sha256": "2f22359a66ab796dabdcd4531923d7e7b3842fd1cf120bb7d33bd5371ebc35e6"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/pantry/dev/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 649,
+      "git_blob_sha1": "424248b26b9785c58704f9c453d455f680b4adb7",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/pantry/dev/multi_answer/dataset_info.json",
+      "sha256": "321f2702833c5746cecdd10b289a15f8cc9396a4d5280e9126dc2ab83e8d2d4e"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "26fa98f9fb8b6e72a68c9cf5d0f387c84c5affdb",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/pantry/dev/multi_answer/state.json",
+      "sha256": "1b81977ac243d83e3bb5a6897ff5f07bfb62da185b72e8a9594163718cc5e5e2"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/pantry/eval/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 649,
+      "git_blob_sha1": "424248b26b9785c58704f9c453d455f680b4adb7",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/pantry/eval/multi_answer/dataset_info.json",
+      "sha256": "321f2702833c5746cecdd10b289a15f8cc9396a4d5280e9126dc2ab83e8d2d4e"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "e1a192d22c9794a83a935b82723ddcba2e7a6028",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/pantry/eval/multi_answer/state.json",
+      "sha256": "fea69ac923bc43715f875dc09d8de34b9ecc9e5aecd4f384e65b284ce3ebd9f9"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/pantry/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 649,
+      "git_blob_sha1": "424248b26b9785c58704f9c453d455f680b4adb7",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/pantry/train/train/dataset_info.json",
+      "sha256": "321f2702833c5746cecdd10b289a15f8cc9396a4d5280e9126dc2ab83e8d2d4e"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "ed4ffe9d6fd34cc4099b784e83c04c9b2ed4240d",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/pantry/train/train/state.json",
+      "sha256": "21515626c163d9096329d6024e6ab89cf5bbb4aca5756bc1b51993d05078b178"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/python_factors/dev/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/python_factors/dev/multi_answer/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "f60dd7f558f734bd98bfd171e5c93be94bec4aa2",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/python_factors/dev/multi_answer/state.json",
+      "sha256": "719a7b3ddac8a7309312fe43ecdf54eb5b2eec7f563e6414e5a1346de9beac21"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/python_factors/eval/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/python_factors/eval/multi_answer/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "94162f8b5becda0cda0dfb472195b45009c247ec",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/python_factors/eval/multi_answer/state.json",
+      "sha256": "eb72c5a66e49f1185ae8472ce438d526719e3326e88e149c7cc4be305941a4a4"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/python_factors/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/python_factors/train/train/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "37ecf9aaf2c6d8be06624ef8bc36840849da9dab",
+      "path_in_repo": "provenance/source_data/modebench_harder_v2_matched_r5/python_factors/train/train/state.json",
+      "sha256": "df0a77b8727e4bb1c0ac7d161cf9a5d33473554f7c45996122a62053791dba88"
+    },
+    {
+      "bytes": 102087,
+      "git_blob_sha1": "21cd00aab665038806cd9e00ac5caf776531d6e9",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/admission_fairness_report.json",
+      "sha256": "890d7697af7789e0ae53c803586ec7f722685b7eb2239643175a1933fa45650d"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/countdown/dev/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 1013,
+      "git_blob_sha1": "a31abca2d2dd2beeaca558871acae8b52e8233b4",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/countdown/dev/multi_answer/dataset_info.json",
+      "sha256": "3a6594fd03a6bc8adb72c5a7cc5f6a10821d8ac9bf8a65a1256ccef94dd5c2a5"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "99a749166f451b1b8c92523828f246943bed5dd5",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/countdown/dev/multi_answer/state.json",
+      "sha256": "f0b8587eaff77ff83a51fe26ddc5b4b7d58696860614f8f43efa33a44fda17af"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/countdown/eval/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 1013,
+      "git_blob_sha1": "2ef7fbf7ffc815c374b1f5660095e2715eddbab9",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/countdown/eval/multi_answer/dataset_info.json",
+      "sha256": "8f85bc4c3ca0dcf5c19d780d9a121e49060b05c72e651f660c4c3680d06204d7"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "53a4b0b1dfac15f4af186b83094c62e7dcf3d15b",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/countdown/eval/multi_answer/state.json",
+      "sha256": "b2cf11211c950d6f983c9d532f6916e47873c239d70f7d5760417bc401085b8a"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/countdown/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 1013,
+      "git_blob_sha1": "2ef7fbf7ffc815c374b1f5660095e2715eddbab9",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/countdown/train/train/dataset_info.json",
+      "sha256": "8f85bc4c3ca0dcf5c19d780d9a121e49060b05c72e651f660c4c3680d06204d7"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "5067e602c1c2a0d029d43b61b7d0f2eb48f10283",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/countdown/train/train/state.json",
+      "sha256": "ffdd91ceff679028c06c29124fae71d9bfb0ff0afecd46bb1fc48278723e9c1d"
+    },
+    {
+      "bytes": 2665,
+      "git_blob_sha1": "4ba06edc313683ce0193d71a14332671c4d77eee",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/frozen_recipes.json",
+      "sha256": "acad4298da776476717753fab0ab8e97f106c8fcafeea08e5ad8af028fe7247c"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/graph_coloring/dev/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 808,
+      "git_blob_sha1": "2549bb8086e6de5007fb4a21b072fb4529777963",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/graph_coloring/dev/multi_answer/dataset_info.json",
+      "sha256": "f3356c6d172e8d1f0772c9462d90dc00734f9a89ebb661bdf5b73347f5cb71be"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "aec3f600965d0ad6c2153d292c502eec5b6b2644",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/graph_coloring/dev/multi_answer/state.json",
+      "sha256": "0b60273ca14cfeeff2f722b4521bdd749799ec255a9b946cfac840559661ddce"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/graph_coloring/eval/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 808,
+      "git_blob_sha1": "429507300ad281830bc2c3022e8c8fc1da4a3f21",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/graph_coloring/eval/multi_answer/dataset_info.json",
+      "sha256": "ed0ebe33c51bf50ebac45608e82474d41763e6a4c232c71c92c959ad62299c50"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "e82447841c89d73d5e3fc811bbc709547c4bfa22",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/graph_coloring/eval/multi_answer/state.json",
+      "sha256": "583c1b187bcb3dee13ba83505bfac970da96ad675eb92827a2d7f066872b4baf"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/graph_coloring/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 808,
+      "git_blob_sha1": "429507300ad281830bc2c3022e8c8fc1da4a3f21",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/graph_coloring/train/train/dataset_info.json",
+      "sha256": "ed0ebe33c51bf50ebac45608e82474d41763e6a4c232c71c92c959ad62299c50"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "e0e953d2b1d99712aa9187f3d45d37aeb8d0280e",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/graph_coloring/train/train/state.json",
+      "sha256": "4f733150d04da4617e14dcd2344a7fe1a21d0044eea709b5aaf46d5f06345c25"
+    },
+    {
+      "bytes": 102087,
+      "git_blob_sha1": "21cd00aab665038806cd9e00ac5caf776531d6e9",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/identity.json",
+      "sha256": "890d7697af7789e0ae53c803586ec7f722685b7eb2239643175a1933fa45650d"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/mathir/dev/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 811,
+      "git_blob_sha1": "8a5fb1f670166a00a4c492ee97ec8b42acea981d",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/mathir/dev/multi_answer/dataset_info.json",
+      "sha256": "7de7a201f0c27522ef0306f466caabeebf42476d76b9ba5d4214ac0b9adfc8a7"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "0cb87778ad2fd52944bf5343ceaf236cd0c606b8",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/mathir/dev/multi_answer/state.json",
+      "sha256": "a11e139eebb288c8b0b4503ef35ad3160593854592a53178d151118fcb0017b8"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/mathir/eval/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 811,
+      "git_blob_sha1": "b702a40b8ce2f6595b05c83af835c647d81c0746",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/mathir/eval/multi_answer/dataset_info.json",
+      "sha256": "6503d6c0c800c1bc8396eade4e4ca6a19e6b5f1eea9f01961de8b410d67d42e3"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "4e8f65debe54495b8bfd81dfdde0e8bb15de8beb",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/mathir/eval/multi_answer/state.json",
+      "sha256": "4b5b80936c9edc263494c2534c4bdc53822ee949eaa2b87967b6e0ec1f0df5a8"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/mathir/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 811,
+      "git_blob_sha1": "b702a40b8ce2f6595b05c83af835c647d81c0746",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/mathir/train/train/dataset_info.json",
+      "sha256": "6503d6c0c800c1bc8396eade4e4ca6a19e6b5f1eea9f01961de8b410d67d42e3"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "3bce600ec9f6f4464d5a6efb1ea109be19af60ba",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/mathir/train/train/state.json",
+      "sha256": "663064b7b9daa57b7cf4befb7b461c89b129bab6bface6c7798fc1f62b885437"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/pantry/dev/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 919,
+      "git_blob_sha1": "ca417d0ed8497acf8cfda32b2c2df9c7d645ea5b",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/pantry/dev/multi_answer/dataset_info.json",
+      "sha256": "8841f8f126914011bc7e6d1d7657d87a65678798484494d69617b044dbd8d00b"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "cb2b94436144906106aeaf4e8715b4f800eb6d1c",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/pantry/dev/multi_answer/state.json",
+      "sha256": "cb5e971bf25432b52875b392ef05e5ebce2320eef1ac145c4fbc1bc1bca94b77"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/pantry/eval/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 919,
+      "git_blob_sha1": "faf81e7156ce692b6d3f6472b36acd15a48a1a2d",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/pantry/eval/multi_answer/dataset_info.json",
+      "sha256": "0e2d9c04883f0dfcbcd85d164bcd35dc8a0d4fb48edc81cfb58c2fc4ae89bdf3"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "5766e0623c5e450feccb6280d9154454fedf1b9b",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/pantry/eval/multi_answer/state.json",
+      "sha256": "989fa13aa124ef795ff9dacc10ec73ac0cb0fc3a1fbb1b07da8d8fdbf4f3151c"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/pantry/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 919,
+      "git_blob_sha1": "faf81e7156ce692b6d3f6472b36acd15a48a1a2d",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/pantry/train/train/dataset_info.json",
+      "sha256": "0e2d9c04883f0dfcbcd85d164bcd35dc8a0d4fb48edc81cfb58c2fc4ae89bdf3"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "2301e2ed1c70126c0f6f6286aa603f2edcb519db",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/pantry/train/train/state.json",
+      "sha256": "7c42b8ab5596c9f777aa680a0e48693e53a1bed2d44bc1bad2b6e3b7f764845f"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/python_factors/dev/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 1358,
+      "git_blob_sha1": "d741860906fe200c0868707574d339122f8b11a0",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/python_factors/dev/multi_answer/dataset_info.json",
+      "sha256": "d447829bd7c2170b5bb5421c63d65fb5670a84ddba74901f258602aee8d41937"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "40261b127ea8ae4d55f2abd836e9358a7bc5c549",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/python_factors/dev/multi_answer/state.json",
+      "sha256": "e82dc482efcfb4887aa58864624324fc5daf3708389fbcfaaec1ca653b8dfa08"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/python_factors/eval/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 1358,
+      "git_blob_sha1": "0c325aaefe491ea7455c04854946a32c07ab5fe4",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/python_factors/eval/multi_answer/dataset_info.json",
+      "sha256": "f580d477ab36046237210cb31bdf2538faed3fd4ecea7a7e6b4a31fdfe31d22d"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "5ce160543ade3771f7c7a51184c2fa0c3cecc932",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/python_factors/eval/multi_answer/state.json",
+      "sha256": "ac499fb4040a1643b309a259b880344749062c9c4f557e10021d35df411f8f8d"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/python_factors/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 1358,
+      "git_blob_sha1": "0c325aaefe491ea7455c04854946a32c07ab5fe4",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/python_factors/train/train/dataset_info.json",
+      "sha256": "f580d477ab36046237210cb31bdf2538faed3fd4ecea7a7e6b4a31fdfe31d22d"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "ee6a5faacb3b07faf1c3e121322c7a67a8c04c43",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/python_factors/train/train/state.json",
+      "sha256": "35bf814813678296c63255ab4ea2eb42d3655b2c48a919aeeb063d88c020f751"
+    },
+    {
+      "bytes": 46204,
+      "git_blob_sha1": "04a922f4f87be6bd518786552f7718e0f04c171a",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/recipes/countdown.json",
+      "sha256": "5db6913a1a7ed16e1eaca49f3fbd09f8494d46d118152f6b8f3a80a6d22f061e"
+    },
+    {
+      "bytes": 890069,
+      "git_blob_sha1": "c652b1e108c4ab80a608be8064715836a7a11d2d",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/recipes/graph_coloring.json",
+      "sha256": "75121d937b5724489ab15077d4885c6cf4a0c98e73d68fdcf41cb236941cd47b"
+    },
+    {
+      "bytes": 45940,
+      "git_blob_sha1": "8da31797d7e6a6c2f8367889550f787c6d76968d",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/recipes/mathir.json",
+      "sha256": "2ee513ecec4967478b7c88b8d5b87009efc50c9b6a1f73583975cf10d711e0cc"
+    },
+    {
+      "bytes": 52273,
+      "git_blob_sha1": "e1b3184c327ad284ca45a897bea7d44acb16e329",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/recipes/pantry.json",
+      "sha256": "4d7ec52ec2ccb10fd57d0301baa83cb3856fe93cde5e98e4d4a06acbd29837c4"
+    },
+    {
+      "bytes": 908705,
+      "git_blob_sha1": "d376a9bbe6ee884311515f74392f874e8ff1508a",
+      "path_in_repo": "provenance/source_data/modebench_level3_matched_v3/recipes/python_factors.json",
+      "sha256": "fb009b8f27a9f7f2c99dc609625748c6f11dd9d1e83e3550397a31af23c4ca3a"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/pantry_plan_modebench_v2/dev/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 649,
+      "git_blob_sha1": "424248b26b9785c58704f9c453d455f680b4adb7",
+      "path_in_repo": "provenance/source_data/pantry_plan_modebench_v2/dev/multi_answer/dataset_info.json",
+      "sha256": "321f2702833c5746cecdd10b289a15f8cc9396a4d5280e9126dc2ab83e8d2d4e"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "697efcd52101a8d0c3645bf6b9ae65b09b678774",
+      "path_in_repo": "provenance/source_data/pantry_plan_modebench_v2/dev/multi_answer/state.json",
+      "sha256": "64d90969f24740cc2f85f01762105dc5f54c0639965ee54752b33c83e259fbb4"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/pantry_plan_modebench_v2/eval/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 649,
+      "git_blob_sha1": "424248b26b9785c58704f9c453d455f680b4adb7",
+      "path_in_repo": "provenance/source_data/pantry_plan_modebench_v2/eval/multi_answer/dataset_info.json",
+      "sha256": "321f2702833c5746cecdd10b289a15f8cc9396a4d5280e9126dc2ab83e8d2d4e"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "e84759f9b035b95e2e5af9a61af3f10756411a01",
+      "path_in_repo": "provenance/source_data/pantry_plan_modebench_v2/eval/multi_answer/state.json",
+      "sha256": "bd466f2256b86708821c529099e6fa280bdc8092cce8da1c8812428357128f92"
+    },
+    {
+      "bytes": 1631,
+      "git_blob_sha1": "ce4091317fe130b885351cc6be9fcc8c8a3e381e",
+      "path_in_repo": "provenance/source_data/pantry_plan_modebench_v2/identity.json",
+      "sha256": "865628033a7cdfc28e1c3c92172c93d1d34e40ce42eec094673b5b29dc3792b4"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/pantry_plan_modebench_v2/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 649,
+      "git_blob_sha1": "424248b26b9785c58704f9c453d455f680b4adb7",
+      "path_in_repo": "provenance/source_data/pantry_plan_modebench_v2/train/train/dataset_info.json",
+      "sha256": "321f2702833c5746cecdd10b289a15f8cc9396a4d5280e9126dc2ab83e8d2d4e"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "ffc6362a61b9b644cc6be0dbf6294bbffc1f5f11",
+      "path_in_repo": "provenance/source_data/pantry_plan_modebench_v2/train/train/state.json",
+      "sha256": "256dd6a5c3088c1e95d88cf65f09ffcafc34d3de543d18f551a441f7e382204a"
+    },
+    {
+      "bytes": 28,
+      "git_blob_sha1": "bec072a844d9c8b58cd512cdd5004f9b8c26ad64",
+      "path_in_repo": "provenance/source_data/python_factor_modebench_v1/eval/dataset_dict.json",
+      "sha256": "3d2b7908811384a988b8c5e66b0e3afd5ce44e25ba23bf829808c6dc8fd49caf"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/python_factor_modebench_v1/eval/multi_answer/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "f729e5879140fe617438ecb5f25fe1499ef00820",
+      "path_in_repo": "provenance/source_data/python_factor_modebench_v1/eval/multi_answer/state.json",
+      "sha256": "ebbbd75ff8373c9404d689185fbe40b065305e08e1555bd44fcd32ba37c6d4f4"
+    },
+    {
+      "bytes": 475,
+      "git_blob_sha1": "e67bbbe2e3eb15ff7bf594aac687b87485c8d3ea",
+      "path_in_repo": "provenance/source_data/python_factor_modebench_v1/identity.json",
+      "sha256": "d4c710b9b433555cacb081683fddb0cf1b18497262283b17ded9a71c8a2c6d39"
+    },
+    {
+      "bytes": 21,
+      "git_blob_sha1": "40d5c04b431649b5c469de1fd03044ba97b6fded",
+      "path_in_repo": "provenance/source_data/python_factor_modebench_v1/train/dataset_dict.json",
+      "sha256": "c172eebfc28c1400d6be4338ce7d00191507ffb4ae64c315f039585c894df5b7"
+    },
+    {
+      "bytes": 481,
+      "git_blob_sha1": "5db33a5d461fde3365428ea1e1ebdee57e5e6d21",
+      "path_in_repo": "provenance/source_data/python_factor_modebench_v1/train/train/dataset_info.json",
+      "sha256": "937ede6f568e39159d9ec7906776651b4a8ef82983246f2a8bd6648398a268a6"
+    },
+    {
+      "bytes": 247,
+      "git_blob_sha1": "08ea11c59c768d01f0a61a646139fccb01837157",
+      "path_in_repo": "provenance/source_data/python_factor_modebench_v1/train/train/state.json",
+      "sha256": "45718961de23f91262a751aaeb5d8c913cab2f84ccd817824d45924bb9a0a921"
+    },
+    {
+      "bytes": 196,
+      "git_blob_sha1": "0ea4603431bdcb719b3367b1768a6b4122ff5c25",
+      "path_in_repo": "requirements-verifier.txt",
+      "sha256": "a1a91a4f20d29765766368f050a7cf03c9557c08a6e5b303bb6a1dc7d83e7cd6"
+    },
+    {
+      "bytes": 25024,
+      "git_blob_sha1": "8b59c78a1fff1167b5e6b240319d3984251fbc6f",
+      "path_in_repo": "tools/export_modebench_hf_release.py",
+      "sha256": "23dbb20cd97e7c61c36f072bf1199738991f7dd09081c207ea6067733ed85715"
+    },
+    {
+      "bytes": 3891,
+      "git_blob_sha1": "882c196b214dfb07e4186b416759eab6176cb6a7",
+      "path_in_repo": "tools/seal_modebench_hf_release.py",
+      "sha256": "1de66a50152f995c6958f9f4e14709a6651bdfed72b5270590ed6af36324233c"
+    }
+  ],
+  "files_count": 228,
+  "schema": "modebench-public-content-manifest-v1",
+  "self_excluded": "CONTENT_SHA256.json",
+  "total_bytes": 5637784
+}

EVALUATION.md

@@ -0,0 +1,28 @@
+# Executable verification and canonical identity
+
+For responses already decoded to the task's verifier surface, the supplied `code/oat_drgrpo/math_grader.py` entry point is `validated_modebench_outcome_key(response, row["answer"])`. It returns a canonical key only when that same response passes the executable task verifier; invalid responses return `None`.
+
+| Domain | Executable acceptance | Canonical identity |
+| --- | --- | --- |
+| Graph Coloring | Parse assignments; preserve fixed colors and satisfy every edge | Complete color vector |
+| Countdown | Restricted arithmetic AST, exact operand multiplicities and exact target value | Normalized expression AST with registered commutative normalization |
+| Python Factors | Restricted function AST executed in the bounded external worker on the specified cases | Executed return vector |
+| MathIR | Restricted action menu expanded and executed using exact equation transformations | Executed normalized state trajectory |
+| PantryPlan | Bounded ingredient quantities, serving steps, mass/nutrient constraints and dietary restrictions | Ingredient support |
+
+Install the versioned dependencies recorded in `MANIFEST.json`/`requirements-verifier.txt`; prepend the release's `code` directory to Python's import path. The code is supplied as inspectable ordinary source, not automatically executed by the datasets loader.
+
+```python
+import sys
+sys.path.insert(0, "path/to/ModeBench/code")
+from oat_drgrpo.math_grader import validated_modebench_outcome_key
+
+key = validated_modebench_outcome_key(response, row["answer"])
+verified = key is not None
+```
+
+Policy action adapters must run before this grader when the registered interface uses them. In particular, Pantry's six-bit support mask is not an allocation string: use `decode_pantry_support_mask(mask, json.loads(row["answer"]))` from `oat_drgrpo.pantry_support_action`, then grade the returned allocation. The frozen adapter searches only the chosen support's registered quantity grid and returns an invalid sentinel when infeasible; it does not consult a gold support catalogue. `canonical_actions.py` preserves the other registered action-to-verifier adapters.
+
+Python Factors retains its original separate, syntax-restricted worker. Use the supplied implementation for model outputs rather than evaluating arbitrary response strings in a notebook. The code also contains imported legacy task support needed by the original module; this release's dataset configurations contain only the five listed domains.
+
+All copied verifier/template dependencies are authenticated against the completed Level-3 confirmation's source hashes. The release validation checks canonical *problem* identity uniqueness and disjointness, row/feature preservation, and the original structural/support-histogram records. It does not regenerate every exhaustive answer catalogue, retrain models, or claim a new model-admission result.

LICENSE_PROVENANCE.md

@@ -0,0 +1,17 @@
+# Existing source terms
+
+{
+  "dataset_specific_license": "No separate dataset license found in the frozen dataset roots; no new dataset license assigned by this export.",
+  "pantry_ingredient_source": {
+    "archive_name": "FoodData_Central_foundation_food_json_2026-04-30.zip",
+    "archive_sha256": "186e988ec542e913f51ef62b86a47758e8cdd0d1dc3889e7b055581f3c09c77a",
+    "dataset": "USDA FoodData Central Foundation Foods",
+    "food_object_rows": 363,
+    "license": "CC0 1.0 / U.S. public-domain data",
+    "null_placeholder_rows": 32,
+    "physical_rows": 395,
+    "release": "April 2026",
+    "url": "https://fdc.nal.usda.gov/download-datasets/"
+  },
+  "source_code": "Existing repository Apache-2.0 LICENSE copied verbatim; existing source copyright notices retained."
+}

LOADER_VALIDATION.json

@@ -0,0 +1,19 @@
+{
+  "all_rows_compared": 9152,
+  "command": "PYTHONDONTWRITEBYTECODE=1 HF_DATASETS_OFFLINE=1 var/seed_paper_eval/paper310/bin/python -m pytest tests/test_modebench_hf_release.py -q --tb=short --basetemp=/tmp/modebench_release_tests_20260911",
+  "elapsed_seconds": 9.26,
+  "feature_schema_equal": true,
+  "network_required": false,
+  "original_sources_deleted": false,
+  "pantry_policy_adapter_verified": true,
+  "portable_verifier_domains": 5,
+  "row_order_equal": true,
+  "schema": "modebench-standard-loader-and-portable-verifier-validation-v1",
+  "separate_python_worker_verified": true,
+  "splits_compared_to_original": 42,
+  "standard_huggingface_config_loads": 16,
+  "status": "passed",
+  "test_source_sha256": "c944a8bcbbc171fbd4750c2a47fe3301df57388e5f6dbb04b4c114ed8d3d02c1",
+  "tests_passed": 18,
+  "validated_at_utc": "2026-09-11T07:40:45.457482+00:00"
+}

PROMPTS.md

@@ -0,0 +1,9 @@
+# Prompt formatting
+
+Every Parquet row preserves the original `problem` string and the original serialized `answer` specification. Send the problem through the selected model/experiment's frozen template; do not concatenate the answer specification or support metadata into the prompt.
+
+For the original Qwen Level-1 training interface, Graph, Countdown, Python, and MathIR use `qwen_boxed`; Pantry uses `qwen_pantry_support_mask`. The copied `code/oat_drgrpo/templates.py` preserves the exact template text and Qwen/Falcon role markers. `provenance/source_code/ops/check_paper_domain_prompts.py` binds the original paper examples to those strings.
+
+Level-2/Level-3 admission uses the versioned interface in `provenance/source_code/ops/evaluate_modebench_level2_viability.py` and `evaluate_modebench_level3.py`: Graph uses the direct boxed interface, while the other domains use the registered hybrid solver interface and their legal-output constraints. That admission interface and its model-native tokenizer rendering are distinct from a training experiment's fixed template. Copying a dataset alone does not reproduce a decoder or inference-engine configuration.
+
+The original training and evaluation launchers remain the source of model-specific precision, length limits, guided-decoding profiles, draw seeds, and selected model checkpoints. The files here preserve the shared prompt/template implementation and the dataset rows; they do not silently standardize these experiment-specific choices.

README.md

@@ -0,0 +1,192 @@
+---
+language:
+- en
+task_categories:
+- text-generation
+tags:
+- reasoning
+- reinforcement-learning
+- verifiable-rewards
+- modebench
+pretty_name: ModeBench
+configs:
+- config_name: level1_countdown
+  data_files:
+  - split: train
+    path: data/level1_countdown/train.parquet
+  - split: eval
+    path: data/level1_countdown/eval.parquet
+- config_name: level1_graph_coloring
+  data_files:
+  - split: train
+    path: data/level1_graph_coloring/train.parquet
+  - split: eval
+    path: data/level1_graph_coloring/eval.parquet
+- config_name: level1_graph_coloring_unique_answer
+  data_files:
+  - split: eval
+    path: data/level1_graph_coloring_unique_answer/eval.parquet
+- config_name: level1_mathir
+  data_files:
+  - split: train
+    path: data/level1_mathir/train.parquet
+  - split: eval
+    path: data/level1_mathir/eval.parquet
+- config_name: level1_pantry_plan
+  data_files:
+  - split: train
+    path: data/level1_pantry_plan/train.parquet
+  - split: dev
+    path: data/level1_pantry_plan/dev.parquet
+  - split: eval
+    path: data/level1_pantry_plan/eval.parquet
+- config_name: level1_python_factors
+  data_files:
+  - split: train
+    path: data/level1_python_factors/train.parquet
+  - split: eval
+    path: data/level1_python_factors/eval.parquet
+- config_name: level2_countdown
+  data_files:
+  - split: train
+    path: data/level2_countdown/train.parquet
+  - split: dev
+    path: data/level2_countdown/dev.parquet
+  - split: eval
+    path: data/level2_countdown/eval.parquet
+- config_name: level2_graph_coloring
+  data_files:
+  - split: train
+    path: data/level2_graph_coloring/train.parquet
+  - split: dev
+    path: data/level2_graph_coloring/dev.parquet
+  - split: eval
+    path: data/level2_graph_coloring/eval.parquet
+- config_name: level2_mathir
+  data_files:
+  - split: train
+    path: data/level2_mathir/train.parquet
+  - split: dev
+    path: data/level2_mathir/dev.parquet
+  - split: eval
+    path: data/level2_mathir/eval.parquet
+- config_name: level2_pantry_plan
+  data_files:
+  - split: train
+    path: data/level2_pantry_plan/train.parquet
+  - split: dev
+    path: data/level2_pantry_plan/dev.parquet
+  - split: eval
+    path: data/level2_pantry_plan/eval.parquet
+- config_name: level2_python_factors
+  data_files:
+  - split: train
+    path: data/level2_python_factors/train.parquet
+  - split: dev
+    path: data/level2_python_factors/dev.parquet
+  - split: eval
+    path: data/level2_python_factors/eval.parquet
+- config_name: level3_countdown
+  data_files:
+  - split: train
+    path: data/level3_countdown/train.parquet
+  - split: dev
+    path: data/level3_countdown/dev.parquet
+  - split: eval
+    path: data/level3_countdown/eval.parquet
+- config_name: level3_graph_coloring
+  data_files:
+  - split: train
+    path: data/level3_graph_coloring/train.parquet
+  - split: dev
+    path: data/level3_graph_coloring/dev.parquet
+  - split: eval
+    path: data/level3_graph_coloring/eval.parquet
+- config_name: level3_mathir
+  data_files:
+  - split: train
+    path: data/level3_mathir/train.parquet
+  - split: dev
+    path: data/level3_mathir/dev.parquet
+  - split: eval
+    path: data/level3_mathir/eval.parquet
+- config_name: level3_pantry_plan
+  data_files:
+  - split: train
+    path: data/level3_pantry_plan/train.parquet
+  - split: dev
+    path: data/level3_pantry_plan/dev.parquet
+  - split: eval
+    path: data/level3_pantry_plan/eval.parquet
+- config_name: level3_python_factors
+  data_files:
+  - split: train
+    path: data/level3_python_factors/train.parquet
+  - split: dev
+    path: data/level3_python_factors/dev.parquet
+  - split: eval
+    path: data/level3_python_factors/eval.parquet
+---
+
+# ModeBench
+
+ModeBench measures both correctness and the variety of correct answers produced by language models. Each problem has an executable verifier and a canonical definition of answer identity, so distinct wording alone does not count as a new solution.
+
+This release contains three frozen benchmark levels across **Graph Coloring, Countdown, Python Factors, MathIR, and PantryPlan**. It preserves every original feature, row, and row order. The `answer` field is a serialized executable specification, not a target answer to include in the model prompt.
+
+[Level 1](#level-1) · [Level 2](#level-2) · [Level 3](#level-3) · [Loading](#loading) · [Evaluation](#evaluation) · [Manifest](MANIFEST.json) · [Validation](VALIDATION.json)
+
+The accompanying [model and research-artifact archive](https://huggingface.co/od2961/maxent-grpo-models) contains experiment-specific model indexes and mappings to the paper results. Dataset publication does not imply completed Level-3 training results.
+
+<a id="level-1"></a>
+## Level 1
+
+The original benchmark uses 384 training problems and 128 primary evaluation problems per domain. PantryPlan additionally has its original 64-row development split. Graph Coloring also includes a separate 128-row `unique_answer` evaluation subset; it is published as the auxiliary `level1_graph_coloring_unique_answer` configuration and is not the primary multi-answer paper evaluation.
+
+<a id="level-2"></a>
+## Level 2
+
+Level 2 is the frozen `modebench_harder_v2_matched_r5` release. It changes problem structure while retaining the verifier and canonicalizer contracts. Each domain has 384 training, 128 development, and 128 evaluation rows. Support histograms follow the recorded matched reference construction; refer to the original identity manifest for the precise reference splits and scaling factors.
+
+<a id="level-3"></a>
+## Level 3
+
+Level 3 is the E122-frozen `modebench_level3_matched_v3` release, with 384 training, 128 development, and 128 evaluation rows per domain. It preserves Level-2 support histograms. Admission used adaptive second-round matching to fixed historical Level-1 measurements: Graph and Python have fresh v3 confirmation, while Countdown, MathIR, and Pantry retain prior split bytes and confirmation evidence. This is not a claim of statistical equivalence, or of five fresh same-round confirmations.
+
+The original [identity manifest](provenance/source_data/modebench_level3_matched_v3/identity.json) still records `pending_fresh_candidate_confirmation`. That historical record is preserved verbatim. The later [confirmation report](provenance/confirmation_report.json) records `matched_fixed_reference` and binds that exact dataset identity. Neither record has been rewritten for publication.
+
+<a id="loading"></a>
+## Loading
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("od2961/ModeBench", "level2_countdown")
+train = ds["train"]
+development = ds["dev"]
+evaluation = ds["eval"]
+
+# Raw problem text goes to the policy. Keep the executable answer spec private
+# from the policy and use it only in the verifier.
+problem = evaluation[0]["problem"]
+reference_spec = evaluation[0]["answer"]
+```
+
+Use `level1_`, `level2_`, or `level3_` followed by `graph_coloring`, `countdown`, `python_factors`, `mathir`, or `pantry_plan`. Only existing splits are exposed; Level 1 generally has no `dev` split. No `test` split is invented. The Parquet files load through the standard datasets loader without remote dataset code. Pin a dataset revision for reproducible experiments.
+
+<a id="evaluation"></a>
+## Evaluation
+
+Use the original held-out `eval` rows and the frozen prompt, decoding, and verifier settings for a stated comparison. Use `dev` only where the original release provides it. Do not fit prompts, choose checkpoints, or tune methods on evaluation outcomes; training, development, and evaluation roles remain separate after public release.
+
+The same executable validation produces acceptance and canonical identity. Report correctness and distinct correct identities separately: with K sampled answers, pass@K is whether any answer verifies, and distinct@K counts unique verified canonical keys. The reported main benchmark uses K=8; the papers specify the seeds, draws, and training checkpoints. [Evaluation and prompt guide](EVALUATION.md) documents the supplied verifier interface and its versioned source.
+
+The support-count metadata and reference specifications are for construction, checking, and analysis. Do not supply gold support catalogues or hidden evaluation references to the policy. Original prompt strings are retained; [prompt formatting](PROMPTS.md) distinguishes raw problems from the model-specific chat and decoding interfaces.
+
+## Files and provenance
+
+`MANIFEST.json` records every source identity, feature schema, ordered-row digest, split mapping, and Parquet digest. `VALIDATION.json` records full row and feature round trips, unchanged source files, canonical problem-identity checks, and support matching. `code/oat_drgrpo/` preserves verifier and template source files byte for byte; `provenance/` preserves original identities and construction/admission records.
+
+## License provenance
+
+The original repository's Apache-2.0 source-code license is preserved in [licenses/source_repository_APACHE_2.0.txt](licenses/source_repository_APACHE_2.0.txt), and copied source copyright notices remain intact. The frozen dataset roots contain no separate dataset-specific license declaration; this export does not invent new dataset license terms. PantryPlan ingredient provenance records USDA FoodData Central Foundation Foods under CC0/public-domain source terms in [pantry_ingredient_source.json](provenance/pantry_ingredient_source.json).

SPLITS.md

@@ -0,0 +1,46 @@
+# Configurations and original split mappings
+
+| Config | Split | Rows | Original serialized subset |
+| --- | --- | ---: | --- |
+| `level1_graph_coloring` | `train` | 384 | `train` |
+| `level1_graph_coloring` | `eval` | 128 | `multi_answer` |
+| `level1_graph_coloring_unique_answer` | `eval` | 128 | `unique_answer` |
+| `level1_countdown` | `train` | 384 | `train` |
+| `level1_countdown` | `eval` | 128 | `multi_answer` |
+| `level1_python_factors` | `train` | 384 | `train` |
+| `level1_python_factors` | `eval` | 128 | `multi_answer` |
+| `level1_mathir` | `train` | 384 | `train` |
+| `level1_mathir` | `eval` | 128 | `multi_answer` |
+| `level1_pantry_plan` | `train` | 384 | `train` |
+| `level1_pantry_plan` | `dev` | 64 | `multi_answer` |
+| `level1_pantry_plan` | `eval` | 128 | `multi_answer` |
+| `level2_graph_coloring` | `train` | 384 | `train` |
+| `level2_graph_coloring` | `dev` | 128 | `multi_answer` |
+| `level2_graph_coloring` | `eval` | 128 | `multi_answer` |
+| `level2_countdown` | `train` | 384 | `train` |
+| `level2_countdown` | `dev` | 128 | `multi_answer` |
+| `level2_countdown` | `eval` | 128 | `multi_answer` |
+| `level2_python_factors` | `train` | 384 | `train` |
+| `level2_python_factors` | `dev` | 128 | `multi_answer` |
+| `level2_python_factors` | `eval` | 128 | `multi_answer` |
+| `level2_mathir` | `train` | 384 | `train` |
+| `level2_mathir` | `dev` | 128 | `multi_answer` |
+| `level2_mathir` | `eval` | 128 | `multi_answer` |
+| `level2_pantry_plan` | `train` | 384 | `train` |
+| `level2_pantry_plan` | `dev` | 128 | `multi_answer` |
+| `level2_pantry_plan` | `eval` | 128 | `multi_answer` |
+| `level3_graph_coloring` | `train` | 384 | `train` |
+| `level3_graph_coloring` | `dev` | 128 | `multi_answer` |
+| `level3_graph_coloring` | `eval` | 128 | `multi_answer` |
+| `level3_countdown` | `train` | 384 | `train` |
+| `level3_countdown` | `dev` | 128 | `multi_answer` |
+| `level3_countdown` | `eval` | 128 | `multi_answer` |
+| `level3_python_factors` | `train` | 384 | `train` |
+| `level3_python_factors` | `dev` | 128 | `multi_answer` |
+| `level3_python_factors` | `eval` | 128 | `multi_answer` |
+| `level3_mathir` | `train` | 384 | `train` |
+| `level3_mathir` | `dev` | 128 | `multi_answer` |
+| `level3_mathir` | `eval` | 128 | `multi_answer` |
+| `level3_pantry_plan` | `train` | 384 | `train` |
+| `level3_pantry_plan` | `dev` | 128 | `multi_answer` |
+| `level3_pantry_plan` | `eval` | 128 | `multi_answer` |

VALIDATION.json

@@ -0,0 +1,396 @@
+{
+  "all_L2_L3_support_histograms_equal": true,
+  "all_primary_problem_identities_disjoint_across_published_splits": true,
+  "all_source_files_unchanged": true,
+  "config_count": 16,
+  "limits": [
+    "Canonical problem identities and original structural checks are validated; this export does not regenerate every exhaustive answer catalogue or rerun model admission.",
+    "Original source split names and auxiliary Graph unique-answer rows are preserved; no test split is created."
+  ],
+  "row_count": 9152,
+  "schema": "modebench-hf-roundtrip-validation-v1",
+  "source_verifier_code_bound_to_completed_confirmation": true,
+  "split_count": 42,
+  "splits": [
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level1_graph_coloring",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": false,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level1_graph_coloring",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": false,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level1_graph_coloring_unique_answer",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": false,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level1_countdown",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": false,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level1_countdown",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": false,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level1_python_factors",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": false,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level1_python_factors",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": false,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level1_mathir",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": false,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level1_mathir",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": false,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level1_pantry_plan",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": false,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level1_pantry_plan",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": false,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "dev"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level1_pantry_plan",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": false,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_graph_coloring",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_graph_coloring",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "dev"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_graph_coloring",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_countdown",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_countdown",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "dev"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_countdown",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_python_factors",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_python_factors",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "dev"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_python_factors",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_mathir",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_mathir",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "dev"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_mathir",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_pantry_plan",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_pantry_plan",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "dev"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level2_pantry_plan",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_graph_coloring",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_graph_coloring",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "dev"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_graph_coloring",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_countdown",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_countdown",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "dev"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_countdown",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_python_factors",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_python_factors",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "dev"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_python_factors",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_mathir",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_mathir",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "dev"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_mathir",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_pantry_plan",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "train"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_pantry_plan",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "dev"
+    },
+    {
+      "canonical_problem_identities_unique": true,
+      "config": "level3_pantry_plan",
+      "feature_schema_equal": true,
+      "frozen_row_digest_verified": true,
+      "row_order_equal": true,
+      "source_rows_equal_export_rows": true,
+      "split": "eval"
+    }
+  ],
+  "status": "passed",
+  "validated_at_utc": "2026-09-11T07:38:24.101092+00:00"
+}

code/oat_drgrpo/__init__.py

@@ -0,0 +1 @@
+"""Direct MaxEnt-GRPO primitives and the landed xDr.GRPO surrogate."""

code/oat_drgrpo/ant_maze_worker_v10.py

@@ -0,0 +1,207 @@
+"""Hash-bound AntMaze executor for the admitted v10 waypoint controller."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+from typing import Any, Mapping
+
+from .maze_modebench import (
+    ANT_MAZE_VERIFIER,
+    parse_maze_action_program,
+    parse_maze_action_spec,
+    validate_maze_execution,
+)
+from .maze_runtime_identity import maze_runtime_identity
+
+
+ROOT = Path(
+    os.environ.get("OAT_ZERO_REPO_ROOT", Path(__file__).resolve().parents[2])
+).resolve()
+MODEL_PATH = ROOT / "var/maze_runtime/controllers/ant_waypoint_v10.zip"
+RECEIPT_PATH = (
+    ROOT / "var/maze_runtime/controllers/ant_waypoint_v10.evaluation.json"
+)
+TRAINING_IDENTITY_PATH = (
+    ROOT / "var/artifacts/ant_waypoint_controller_v10_identity.json"
+)
+WAYPOINT_DISTANCE = 4.0
+WAYPOINT_SUCCESS_THRESHOLD = 0.45
+_MODEL = None
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def controller_receipt_sha256() -> str:
+    controller_identity()
+    return _sha256(RECEIPT_PATH)
+
+
+def controller_identity() -> dict[str, Any]:
+    receipt_sha256 = _sha256(RECEIPT_PATH)
+    model_sha256 = _sha256(MODEL_PATH)
+    training_identity_sha256 = _sha256(TRAINING_IDENTITY_PATH)
+    receipt = json.loads(RECEIPT_PATH.read_text(encoding="utf-8"))
+    training_identity = json.loads(
+        TRAINING_IDENTITY_PATH.read_text(encoding="utf-8")
+    )
+    if (
+        receipt.get("status") != "pass"
+        or receipt.get("decision") != "admitted_to_fresh_maze_route_gate_v10"
+    ):
+        raise RuntimeError("Ant v10 controller is not admitted")
+    if receipt.get("seed") != 73010 or receipt.get("timesteps") != 2_000_000:
+        raise RuntimeError("Ant v10 receipt differs from its frozen training identity")
+    if (
+        training_identity.get("job_id") != 30193111
+        or training_identity.get("seed") != 73010
+    ):
+        raise RuntimeError("Ant v10 training identity is not the frozen job")
+    checks = receipt.get("checks", {})
+    required_checks = {
+        "episode_count",
+        "success_rate_at_least_0p90",
+        "minimum_heading_success_rate_at_least_0p75",
+        "minimum_map_success_rate_at_least_0p75",
+        "unhealthy_termination_rate_at_most_0p10",
+        "median_success_steps_at_most_300",
+        "all_metrics_finite",
+    }
+    if not isinstance(checks, dict) or not required_checks.issubset(checks) or not all(
+        checks[key] is True for key in required_checks
+    ):
+        raise RuntimeError("Ant v10 receipt contains a failed controller check")
+    if receipt.get("hashes", {}).get("model_sha256") != model_sha256:
+        raise RuntimeError("Ant v10 receipt does not bind the controller model")
+    if receipt.get("training_waypoint_distances") != [WAYPOINT_DISTANCE]:
+        raise RuntimeError("Ant v10 receipt has a different waypoint distance")
+    if receipt.get("waypoint_distance") != WAYPOINT_DISTANCE:
+        raise RuntimeError("Ant v10 receipt has a different executor distance")
+    if receipt.get("success_threshold") != WAYPOINT_SUCCESS_THRESHOLD:
+        raise RuntimeError("Ant v10 receipt has a different waypoint threshold")
+    route_identity_path = os.environ.get("OAT_ZERO_PROTOCOL_IDENTITY")
+    if route_identity_path:
+        route_identity = json.loads(
+            Path(route_identity_path).read_text(encoding="utf-8")
+        )
+        expected = {
+            "controller_receipt_sha256": receipt_sha256,
+            "controller_model_sha256": model_sha256,
+            "controller_training_identity_sha256": training_identity_sha256,
+        }
+        if route_identity.get("schema_version") != (
+            "ant-maze-v10-route-generation-identity-v1"
+        ):
+            raise RuntimeError("Ant v10 route identity schema mismatch")
+        if any(route_identity.get(key) != value for key, value in expected.items()):
+            raise RuntimeError("Ant v10 route identity does not bind the controller")
+    return receipt
+
+
+def _model():
+    global _MODEL
+    controller_identity()
+    if _MODEL is None:
+        from stable_baselines3 import PPO
+
+        _MODEL = PPO.load(MODEL_PATH, device="cpu")
+    return _MODEL
+
+
+def _heading(token: str):
+    import numpy as np
+
+    diagonal = 1.0 / math.sqrt(2.0)
+    values = {
+        "N": (0.0, 1.0), "NE": (diagonal, diagonal), "E": (1.0, 0.0),
+        "SE": (diagonal, -diagonal), "S": (0.0, -1.0),
+        "SW": (-diagonal, -diagonal), "W": (-1.0, 0.0),
+        "NW": (-diagonal, diagonal),
+    }
+    return np.asarray(values[token], dtype=np.float32)
+
+
+def execute_ant_v10_raw(candidate: str, raw_spec: Mapping[str, Any]) -> dict[str, Any]:
+    import gymnasium as gym
+    import gymnasium_robotics
+    import numpy as np
+
+    gym.register_envs(gymnasium_robotics)
+    spec = parse_maze_action_spec(raw_spec)
+    if spec.verifier != ANT_MAZE_VERIFIER:
+        raise ValueError("AntMaze executor received a non-AntMaze spec")
+    runtime = maze_runtime_identity()
+    if spec.environment_sha256 != runtime["ant_environment_sha256"]:
+        raise ValueError("AntMaze environment hash differs from installed runtime")
+    if spec.controller_sha256 != controller_receipt_sha256():
+        raise ValueError("AntMaze controller hash differs from frozen v10 receipt")
+    tokens = parse_maze_action_program(candidate, spec)
+    model = _model()
+    env = gym.make(
+        spec.environment_id,
+        maze_map=[list(row) for row in spec.maze_map],
+        reward_type="sparse",
+        continuing_task=False,
+        reset_target=False,
+        max_episode_steps=len(tokens) * spec.action_repeat,
+    )
+    try:
+        env.unwrapped.position_noise_range = 0.0
+        observation, info = env.reset(
+            seed=spec.reset_seed,
+            options={"reset_cell": list(spec.reset_cell), "goal_cell": list(spec.goal_cell)},
+        )
+        trajectory = [observation["achieved_goal"].astype(float).tolist()]
+        success = bool(info.get("success", False))
+        simulator_steps = 0
+        terminated = truncated = False
+        for token in tokens:
+            current = np.asarray(env.unwrapped.data.qpos[:2], dtype=np.float32)
+            target = current + WAYPOINT_DISTANCE * _heading(token)
+            for _ in range(spec.action_repeat):
+                current = np.asarray(env.unwrapped.data.qpos[:2], dtype=np.float32)
+                relative = np.clip((target - current) / WAYPOINT_DISTANCE, -1.0, 1.0)
+                controller_input = np.concatenate([
+                    np.asarray(observation["observation"], dtype=np.float32), relative,
+                ])
+                action, _ = model.predict(controller_input, deterministic=True)
+                observation, _reward, terminated, truncated, info = env.step(action)
+                simulator_steps += 1
+                trajectory.append(observation["achieved_goal"].astype(float).tolist())
+                success = bool(info.get("success", False))
+                current = np.asarray(env.unwrapped.data.qpos[:2], dtype=np.float32)
+                waypoint_reached = float(np.linalg.norm(target - current)) <= WAYPOINT_SUCCESS_THRESHOLD
+                if success or waypoint_reached or terminated or truncated:
+                    break
+            if success or terminated or truncated:
+                break
+        distance = float(np.linalg.norm(
+            observation["achieved_goal"] - observation["desired_goal"]
+        ))
+    finally:
+        env.close()
+    return {
+        "environment_sha256": spec.environment_sha256,
+        "controller_sha256": spec.controller_sha256,
+        "spec_sha256": spec.spec_sha256,
+        "reset_seed": spec.reset_seed,
+        "action_tokens": list(tokens),
+        "success": success,
+        "final_goal_distance": distance,
+        "trajectory_xy": trajectory,
+        "simulator_steps": simulator_steps,
+    }
+
+
+def execute_ant_v10(candidate: str, raw_spec: Mapping[str, Any]):
+    execution = execute_ant_v10_raw(candidate, raw_spec)
+    return validate_maze_execution(candidate, raw_spec, execution), execution

code/oat_drgrpo/ant_maze_worker_v11.py

@@ -0,0 +1,91 @@
+"""Hash-bound AntMaze executor for the admitted v11 waypoint controller."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+from typing import Any, Mapping
+
+from . import ant_maze_worker_v10 as base
+
+
+ROOT = base.ROOT
+MODEL_PATH = ROOT / "var/maze_runtime/controllers/ant_waypoint_v11.zip"
+RECEIPT_PATH = ROOT / "var/maze_runtime/controllers/ant_waypoint_v11.evaluation.json"
+TRAINING_IDENTITY_PATH = ROOT / "var/artifacts/ant_waypoint_controller_v11_identity.json"
+WAYPOINT_DISTANCE = base.WAYPOINT_DISTANCE
+WAYPOINT_SUCCESS_THRESHOLD = base.WAYPOINT_SUCCESS_THRESHOLD
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def controller_receipt_sha256() -> str:
+    controller_identity()
+    return _sha256(RECEIPT_PATH)
+
+
+def controller_identity() -> dict[str, Any]:
+    receipt_sha256 = _sha256(RECEIPT_PATH)
+    model_sha256 = _sha256(MODEL_PATH)
+    training_identity_sha256 = _sha256(TRAINING_IDENTITY_PATH)
+    receipt = json.loads(RECEIPT_PATH.read_text(encoding="utf-8"))
+    training_identity = json.loads(TRAINING_IDENTITY_PATH.read_text(encoding="utf-8"))
+    if receipt.get("status") != "pass" or receipt.get("decision") != "admitted_to_fresh_maze_route_gate_v11":
+        raise RuntimeError("Ant v11 controller is not admitted")
+    if receipt.get("seed") != 73011 or receipt.get("timesteps") != 2_000_000:
+        raise RuntimeError("Ant v11 receipt differs from its frozen training identity")
+    if training_identity.get("job_id") != 30198291 or training_identity.get("seed") != 73011:
+        raise RuntimeError("Ant v11 training identity is not the frozen job")
+    checks = receipt.get("checks", {})
+    required_checks = {
+        "episode_count", "success_rate_at_least_0p90",
+        "minimum_heading_success_rate_at_least_0p75",
+        "minimum_map_success_rate_at_least_0p75",
+        "unhealthy_termination_rate_at_most_0p10",
+        "median_success_steps_at_most_300", "all_metrics_finite",
+    }
+    if not isinstance(checks, dict) or not required_checks.issubset(checks) or not all(checks[key] is True for key in required_checks):
+        raise RuntimeError("Ant v11 receipt contains a failed controller check")
+    if receipt.get("hashes", {}).get("model_sha256") != model_sha256:
+        raise RuntimeError("Ant v11 receipt does not bind the controller model")
+    if receipt.get("training_waypoint_distances") != [WAYPOINT_DISTANCE] or receipt.get("waypoint_distance") != WAYPOINT_DISTANCE:
+        raise RuntimeError("Ant v11 receipt has a different waypoint distance")
+    if receipt.get("success_threshold") != WAYPOINT_SUCCESS_THRESHOLD:
+        raise RuntimeError("Ant v11 receipt has a different waypoint threshold")
+    route_identity_path = os.environ.get("OAT_ZERO_PROTOCOL_IDENTITY")
+    if route_identity_path:
+        route_identity = json.loads(Path(route_identity_path).read_text(encoding="utf-8"))
+        expected = {
+            "controller_receipt_sha256": receipt_sha256,
+            "controller_model_sha256": model_sha256,
+            "controller_training_identity_sha256": training_identity_sha256,
+        }
+        if route_identity.get("schema_version") != "ant-maze-v11-route-generation-identity-v1":
+            raise RuntimeError("Ant v11 route identity schema mismatch")
+        if any(route_identity.get(key) != value for key, value in expected.items()):
+            raise RuntimeError("Ant v11 route identity does not bind the controller")
+    return receipt
+
+
+base.MODEL_PATH = MODEL_PATH
+base.RECEIPT_PATH = RECEIPT_PATH
+base.TRAINING_IDENTITY_PATH = TRAINING_IDENTITY_PATH
+base.controller_identity = controller_identity
+base.controller_receipt_sha256 = controller_receipt_sha256
+base._MODEL = None
+
+
+def execute_ant_v11_raw(candidate: str, raw_spec: Mapping[str, Any]) -> dict[str, Any]:
+    return base.execute_ant_v10_raw(candidate, raw_spec)
+
+
+def execute_ant_v11(candidate: str, raw_spec: Mapping[str, Any]):
+    return base.execute_ant_v10(candidate, raw_spec)

code/oat_drgrpo/ant_maze_worker_v12.py

@@ -0,0 +1,248 @@
+"""Grid-anchored AntMaze executor for the admitted v11 controller."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+from typing import Any, Mapping
+
+from . import ant_maze_worker_v10 as executor
+from .maze_modebench import (
+    ANT_MAZE_VERIFIER,
+    parse_maze_action_program,
+    parse_maze_action_spec,
+    validate_maze_execution,
+)
+from .maze_runtime_identity import maze_runtime_identity
+
+
+ROOT = executor.ROOT
+MODEL_PATH = ROOT / "var/maze_runtime/controllers/ant_waypoint_v11.zip"
+RECEIPT_PATH = (
+    ROOT / "var/maze_runtime/controllers/ant_waypoint_v11.evaluation.json"
+)
+TRAINING_IDENTITY_PATH = (
+    ROOT / "var/artifacts/ant_waypoint_controller_v11_identity.json"
+)
+WAYPOINT_DISTANCE = 4.0
+WAYPOINT_SUCCESS_THRESHOLD = 0.45
+TARGETING_VERSION = "initial-grid-cumulative-v12"
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _canonical_sha256(value: Any) -> str:
+    return hashlib.sha256(
+        json.dumps(
+            value,
+            allow_nan=False,
+            ensure_ascii=True,
+            separators=(",", ":"),
+            sort_keys=True,
+        ).encode("ascii")
+    ).hexdigest()
+
+
+def _executor_identity() -> dict[str, Any]:
+    return {
+        "targeting_version": TARGETING_VERSION,
+        "worker_source_sha256": _sha256(Path(__file__)),
+        "controller_receipt_sha256": _sha256(RECEIPT_PATH),
+        "controller_model_sha256": _sha256(MODEL_PATH),
+        "controller_training_identity_sha256": _sha256(TRAINING_IDENTITY_PATH),
+        "waypoint_distance": WAYPOINT_DISTANCE,
+        "waypoint_success_threshold": WAYPOINT_SUCCESS_THRESHOLD,
+    }
+
+
+def controller_receipt_sha256() -> str:
+    controller_identity()
+    return _canonical_sha256(_executor_identity())
+
+
+def controller_identity() -> dict[str, Any]:
+    receipt = json.loads(RECEIPT_PATH.read_text(encoding="utf-8"))
+    training_identity = json.loads(
+        TRAINING_IDENTITY_PATH.read_text(encoding="utf-8")
+    )
+    if (
+        receipt.get("status") != "pass"
+        or receipt.get("decision") != "admitted_to_fresh_maze_route_gate_v11"
+        or receipt.get("seed") != 73011
+        or receipt.get("timesteps") != 2_000_000
+    ):
+        raise RuntimeError("Ant v12 requires the exact admitted v11 controller")
+    if (
+        training_identity.get("job_id") != 30198291
+        or training_identity.get("seed") != 73011
+    ):
+        raise RuntimeError("Ant v12 training identity differs from admitted v11")
+    checks = receipt.get("checks", {})
+    if not isinstance(checks, dict) or not checks or not all(
+        value is True for value in checks.values()
+    ):
+        raise RuntimeError("Ant v12 received a failed v11 controller check")
+    if receipt.get("hashes", {}).get("model_sha256") != _sha256(MODEL_PATH):
+        raise RuntimeError("Ant v12 receipt does not bind the v11 model")
+    if (
+        receipt.get("training_waypoint_distances") != [WAYPOINT_DISTANCE]
+        or receipt.get("waypoint_distance") != WAYPOINT_DISTANCE
+        or receipt.get("success_threshold") != WAYPOINT_SUCCESS_THRESHOLD
+    ):
+        raise RuntimeError("Ant v12 local waypoint contract drift")
+    route_identity_path = os.environ.get("OAT_ZERO_PROTOCOL_IDENTITY")
+    if route_identity_path:
+        route_identity = json.loads(
+            Path(route_identity_path).read_text(encoding="utf-8")
+        )
+        expected = _executor_identity()
+        if route_identity.get("schema_version") != (
+            "ant-maze-v12-route-generation-identity-v1"
+        ):
+            raise RuntimeError("Ant v12 route identity schema mismatch")
+        for key, value in expected.items():
+            if route_identity.get(key) != value:
+                raise RuntimeError(f"Ant v12 route identity does not bind {key}")
+    return receipt
+
+
+def _model():
+    executor.MODEL_PATH = MODEL_PATH
+    executor.RECEIPT_PATH = RECEIPT_PATH
+    executor.TRAINING_IDENTITY_PATH = TRAINING_IDENTITY_PATH
+    executor.controller_identity = controller_identity
+    executor.controller_receipt_sha256 = controller_receipt_sha256
+    return executor._model()
+
+
+def _heading(token: str):
+    import numpy as np
+
+    diagonal = 1.0 / math.sqrt(2.0)
+    return np.asarray(
+        {
+            "N": (0.0, 1.0),
+            "NE": (diagonal, diagonal),
+            "E": (1.0, 0.0),
+            "SE": (diagonal, -diagonal),
+            "S": (0.0, -1.0),
+            "SW": (-diagonal, -diagonal),
+            "W": (-1.0, 0.0),
+            "NW": (-diagonal, diagonal),
+        }[token],
+        dtype=np.float32,
+    )
+
+
+def execute_ant_v12_raw(candidate: str, raw_spec: Mapping[str, Any]) -> dict[str, Any]:
+    import gymnasium as gym
+    import gymnasium_robotics
+    import numpy as np
+
+    gym.register_envs(gymnasium_robotics)
+    spec = parse_maze_action_spec(raw_spec)
+    if spec.verifier != ANT_MAZE_VERIFIER:
+        raise ValueError("AntMaze v12 received a non-AntMaze spec")
+    runtime = maze_runtime_identity()
+    if spec.environment_sha256 != runtime["ant_environment_sha256"]:
+        raise ValueError("AntMaze environment hash differs from installed runtime")
+    if spec.controller_sha256 != controller_receipt_sha256():
+        raise ValueError("AntMaze controller hash differs from frozen v12 executor")
+    tokens = parse_maze_action_program(candidate, spec)
+    model = _model()
+    env = gym.make(
+        spec.environment_id,
+        maze_map=[list(row) for row in spec.maze_map],
+        reward_type="sparse",
+        continuing_task=False,
+        reset_target=False,
+        max_episode_steps=len(tokens) * spec.action_repeat,
+    )
+    segment_steps = []
+    nominal_targets = []
+    try:
+        env.unwrapped.position_noise_range = 0.0
+        observation, info = env.reset(
+            seed=spec.reset_seed,
+            options={
+                "reset_cell": list(spec.reset_cell),
+                "goal_cell": list(spec.goal_cell),
+            },
+        )
+        initial = np.asarray(env.unwrapped.data.qpos[:2], dtype=np.float32).copy()
+        cumulative_heading = np.zeros(2, dtype=np.float32)
+        trajectory = [observation["achieved_goal"].astype(float).tolist()]
+        success = bool(info.get("success", False))
+        simulator_steps = 0
+        terminated = truncated = False
+        for token in tokens:
+            cumulative_heading += _heading(token)
+            target = initial + WAYPOINT_DISTANCE * cumulative_heading
+            nominal_targets.append(target.astype(float).tolist())
+            before_segment = simulator_steps
+            for _ in range(spec.action_repeat):
+                current = np.asarray(
+                    env.unwrapped.data.qpos[:2], dtype=np.float32
+                )
+                relative = np.clip(
+                    (target - current) / WAYPOINT_DISTANCE, -1.0, 1.0
+                )
+                controller_input = np.concatenate(
+                    [
+                        np.asarray(observation["observation"], dtype=np.float32),
+                        relative,
+                    ]
+                )
+                action, _ = model.predict(controller_input, deterministic=True)
+                observation, _reward, terminated, truncated, info = env.step(action)
+                simulator_steps += 1
+                trajectory.append(
+                    observation["achieved_goal"].astype(float).tolist()
+                )
+                success = bool(info.get("success", False))
+                current = np.asarray(
+                    env.unwrapped.data.qpos[:2], dtype=np.float32
+                )
+                waypoint_reached = float(np.linalg.norm(target - current)) <= (
+                    WAYPOINT_SUCCESS_THRESHOLD
+                )
+                if success or waypoint_reached or terminated or truncated:
+                    break
+            segment_steps.append(simulator_steps - before_segment)
+            if success or terminated or truncated:
+                break
+        distance = float(
+            np.linalg.norm(
+                observation["achieved_goal"] - observation["desired_goal"]
+            )
+        )
+    finally:
+        env.close()
+    return {
+        "environment_sha256": spec.environment_sha256,
+        "controller_sha256": spec.controller_sha256,
+        "spec_sha256": spec.spec_sha256,
+        "reset_seed": spec.reset_seed,
+        "action_tokens": list(tokens),
+        "targeting_version": TARGETING_VERSION,
+        "nominal_targets_xy": nominal_targets,
+        "segment_steps": segment_steps,
+        "success": success,
+        "final_goal_distance": distance,
+        "trajectory_xy": trajectory,
+        "simulator_steps": simulator_steps,
+    }
+
+
+def execute_ant_v12(candidate: str, raw_spec: Mapping[str, Any]):
+    execution = execute_ant_v12_raw(candidate, raw_spec)
+    return validate_maze_execution(candidate, raw_spec, execution), execution

code/oat_drgrpo/ant_maze_worker_v5.py

@@ -0,0 +1,170 @@
+"""Hash-bound AntMaze executor for the admitted v5 macro controller."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+from typing import Any, Mapping
+
+from .maze_modebench import (
+    ANT_MAZE_VERIFIER,
+    parse_maze_action_program,
+    parse_maze_action_spec,
+    validate_maze_execution,
+)
+from .maze_runtime_identity import maze_runtime_identity
+
+
+ROOT = Path(
+    os.environ.get("OAT_ZERO_REPO_ROOT", Path(__file__).resolve().parents[2])
+).resolve()
+MODEL_PATH = ROOT / "var/maze_runtime/controllers/ant_heading_v1.zip"
+RECEIPT_PATH = ROOT / "var/maze_runtime/controllers/ant_heading_v5.evaluation.json"
+RECEIPT_SHA256 = (
+    "324d3301b8e21b4dbbfcc2e6b9a87aba479bd2da5aa3a040cff24adebaf8828e"
+)
+MODEL_SHA256 = (
+    "526b669bb14cf8a07b44a1c725f94411632a3ac8a8e84966db09336cc96e4b0f"
+)
+_MODEL = None
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def controller_identity() -> dict[str, Any]:
+    """Load and verify the immutable v5 controller receipt."""
+
+    if _sha256(RECEIPT_PATH) != RECEIPT_SHA256:
+        raise RuntimeError("Ant v5 controller receipt hash mismatch")
+    receipt = json.loads(RECEIPT_PATH.read_text(encoding="utf-8"))
+    if receipt.get("status") != "pass":
+        raise RuntimeError("Ant v5 controller is not admitted")
+    if _sha256(MODEL_PATH) != MODEL_SHA256:
+        raise RuntimeError("Ant v5 controller model hash mismatch")
+    if receipt.get("hashes", {}).get("model_sha256") != MODEL_SHA256:
+        raise RuntimeError("Ant v5 receipt does not bind the controller model")
+    return receipt
+
+
+def _model():
+    global _MODEL
+    receipt = controller_identity()
+    if _MODEL is None:
+        from stable_baselines3 import PPO
+
+        _MODEL = PPO.load(MODEL_PATH, device="cpu")
+    return _MODEL, receipt["macro_identity"]
+
+
+def execute_ant_v5_raw(
+    candidate: str,
+    raw_spec: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Execute one program and retain its raw record even on goal failure."""
+
+    import gymnasium as gym
+    import gymnasium_robotics
+    import numpy as np
+
+    gym.register_envs(gymnasium_robotics)
+    spec = parse_maze_action_spec(raw_spec)
+    if spec.verifier != ANT_MAZE_VERIFIER:
+        raise ValueError("AntMaze executor received a non-AntMaze spec")
+    runtime = maze_runtime_identity()
+    if spec.environment_sha256 != runtime["ant_environment_sha256"]:
+        raise ValueError("AntMaze environment hash differs from installed runtime")
+    if spec.controller_sha256 != RECEIPT_SHA256:
+        raise ValueError("AntMaze controller hash differs from frozen v5 receipt")
+    tokens = parse_maze_action_program(candidate, spec)
+    model, identity = _model()
+    names = tuple(str(value) for value in identity["command_names"])
+    commands = np.asarray(identity["commands"], dtype=np.float32)
+    macros = tuple(
+        tuple(int(index) for index in macro) for macro in identity["macros"]
+    )
+    token_to_index = {name: index for index, name in enumerate(names)}
+    if tuple(token_to_index) != spec.action_tokens:
+        raise RuntimeError("Ant v5 macro alphabet differs from the maze spec")
+
+    env = gym.make(
+        spec.environment_id,
+        maze_map=[list(row) for row in spec.maze_map],
+        reward_type="sparse",
+        continuing_task=False,
+        reset_target=False,
+        max_episode_steps=len(tokens) * spec.action_repeat,
+    )
+    try:
+        env.unwrapped.position_noise_range = 0.0
+        observation, info = env.reset(
+            seed=spec.reset_seed,
+            options={
+                "reset_cell": list(spec.reset_cell),
+                "goal_cell": list(spec.goal_cell),
+            },
+        )
+        trajectory = [observation["achieved_goal"].astype(float).tolist()]
+        success = bool(info.get("success", False))
+        simulator_steps = 0
+        terminated = truncated = False
+        for token in tokens:
+            macro = macros[token_to_index[token]]
+            for primitive_step in range(spec.action_repeat):
+                segment = min(
+                    primitive_step * len(macro) // spec.action_repeat,
+                    len(macro) - 1,
+                )
+                command = commands[macro[segment]]
+                controller_input = np.concatenate(
+                    [
+                        np.asarray(observation["observation"], dtype=np.float32),
+                        command,
+                    ]
+                )
+                action, _ = model.predict(controller_input, deterministic=True)
+                observation, _reward, terminated, truncated, info = env.step(
+                    action
+                )
+                simulator_steps += 1
+                trajectory.append(
+                    observation["achieved_goal"].astype(float).tolist()
+                )
+                success = bool(info.get("success", False))
+                if success or terminated or truncated:
+                    break
+            if success or terminated or truncated:
+                break
+        distance = float(
+            np.linalg.norm(
+                observation["achieved_goal"] - observation["desired_goal"]
+            )
+        )
+    finally:
+        env.close()
+    execution = {
+        "environment_sha256": spec.environment_sha256,
+        "controller_sha256": spec.controller_sha256,
+        "spec_sha256": spec.spec_sha256,
+        "reset_seed": spec.reset_seed,
+        "action_tokens": list(tokens),
+        "success": success,
+        "final_goal_distance": distance,
+        "trajectory_xy": trajectory,
+        "simulator_steps": simulator_steps,
+    }
+    return execution
+
+
+def execute_ant_v5(candidate: str, raw_spec: Mapping[str, Any]):
+    """Execute and validate one program in the pinned AntMaze runtime."""
+
+    execution = execute_ant_v5_raw(candidate, raw_spec)
+    return validate_maze_execution(candidate, raw_spec, execution), execution

code/oat_drgrpo/ant_maze_worker_v8.py

@@ -0,0 +1,196 @@
+"""Hash-bound AntMaze executor for the admitted v8 waypoint controller."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+from typing import Any, Mapping
+
+from .maze_modebench import (
+    ANT_MAZE_VERIFIER,
+    parse_maze_action_program,
+    parse_maze_action_spec,
+    validate_maze_execution,
+)
+from .maze_runtime_identity import maze_runtime_identity
+
+
+ROOT = Path(
+    os.environ.get("OAT_ZERO_REPO_ROOT", Path(__file__).resolve().parents[2])
+).resolve()
+MODEL_PATH = ROOT / "var/maze_runtime/controllers/ant_waypoint_v8.zip"
+RECEIPT_PATH = (
+    ROOT / "var/maze_runtime/controllers/ant_waypoint_v8.evaluation.json"
+)
+RECEIPT_SHA256 = (
+    "fc2961d74a1fdfc8f3d2c1936ea61041cff65333ada0e6ebcd571b44919b18f1"
+)
+MODEL_SHA256 = (
+    "77e780dfff1147bc2f542c1761f6efeaa2305fd5ddb625244ebf8e82b3fa871d"
+)
+WAYPOINT_DISTANCE = 4.0
+WAYPOINT_SUCCESS_THRESHOLD = 0.45
+_MODEL = None
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def controller_identity() -> dict[str, Any]:
+    """Load and verify the immutable v8 controller receipt and model."""
+
+    if _sha256(RECEIPT_PATH) != RECEIPT_SHA256:
+        raise RuntimeError("Ant v8 controller receipt hash mismatch")
+    receipt = json.loads(RECEIPT_PATH.read_text(encoding="utf-8"))
+    if (
+        receipt.get("status") != "pass"
+        or receipt.get("decision") != "admitted_to_fresh_maze_route_gate_v8"
+    ):
+        raise RuntimeError("Ant v8 controller is not admitted")
+    if _sha256(MODEL_PATH) != MODEL_SHA256:
+        raise RuntimeError("Ant v8 controller model hash mismatch")
+    if receipt.get("hashes", {}).get("model_sha256") != MODEL_SHA256:
+        raise RuntimeError("Ant v8 receipt does not bind the controller model")
+    if receipt.get("training_waypoint_distances") != [WAYPOINT_DISTANCE]:
+        raise RuntimeError("Ant v8 receipt has a different waypoint distance")
+    if receipt.get("success_threshold") != WAYPOINT_SUCCESS_THRESHOLD:
+        raise RuntimeError("Ant v8 receipt has a different waypoint threshold")
+    return receipt
+
+
+def _model():
+    global _MODEL
+    controller_identity()
+    if _MODEL is None:
+        from stable_baselines3 import PPO
+
+        _MODEL = PPO.load(MODEL_PATH, device="cpu")
+    return _MODEL
+
+
+def _heading(token: str):
+    import numpy as np
+
+    diagonal = 1.0 / math.sqrt(2.0)
+    values = {
+        "N": (0.0, 1.0),
+        "NE": (diagonal, diagonal),
+        "E": (1.0, 0.0),
+        "SE": (diagonal, -diagonal),
+        "S": (0.0, -1.0),
+        "SW": (-diagonal, -diagonal),
+        "W": (-1.0, 0.0),
+        "NW": (-diagonal, diagonal),
+    }
+    return np.asarray(values[token], dtype=np.float32)
+
+
+def execute_ant_v8_raw(
+    candidate: str,
+    raw_spec: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Execute commands as successive four-unit relative waypoint targets."""
+
+    import gymnasium as gym
+    import gymnasium_robotics
+    import numpy as np
+
+    gym.register_envs(gymnasium_robotics)
+    spec = parse_maze_action_spec(raw_spec)
+    if spec.verifier != ANT_MAZE_VERIFIER:
+        raise ValueError("AntMaze executor received a non-AntMaze spec")
+    runtime = maze_runtime_identity()
+    if spec.environment_sha256 != runtime["ant_environment_sha256"]:
+        raise ValueError("AntMaze environment hash differs from installed runtime")
+    if spec.controller_sha256 != RECEIPT_SHA256:
+        raise ValueError("AntMaze controller hash differs from frozen v8 receipt")
+    tokens = parse_maze_action_program(candidate, spec)
+    model = _model()
+
+    env = gym.make(
+        spec.environment_id,
+        maze_map=[list(row) for row in spec.maze_map],
+        reward_type="sparse",
+        continuing_task=False,
+        reset_target=False,
+        max_episode_steps=len(tokens) * spec.action_repeat,
+    )
+    try:
+        env.unwrapped.position_noise_range = 0.0
+        observation, info = env.reset(
+            seed=spec.reset_seed,
+            options={
+                "reset_cell": list(spec.reset_cell),
+                "goal_cell": list(spec.goal_cell),
+            },
+        )
+        trajectory = [observation["achieved_goal"].astype(float).tolist()]
+        success = bool(info.get("success", False))
+        simulator_steps = 0
+        terminated = truncated = False
+        for token in tokens:
+            current = np.asarray(env.unwrapped.data.qpos[:2], dtype=np.float32)
+            target = current + WAYPOINT_DISTANCE * _heading(token)
+            waypoint_reached = False
+            for _ in range(spec.action_repeat):
+                current = np.asarray(env.unwrapped.data.qpos[:2], dtype=np.float32)
+                relative = np.clip(
+                    (target - current) / WAYPOINT_DISTANCE,
+                    -1.0,
+                    1.0,
+                )
+                controller_input = np.concatenate(
+                    [
+                        np.asarray(observation["observation"], dtype=np.float32),
+                        relative,
+                    ]
+                )
+                action, _ = model.predict(controller_input, deterministic=True)
+                observation, _reward, terminated, truncated, info = env.step(action)
+                simulator_steps += 1
+                trajectory.append(
+                    observation["achieved_goal"].astype(float).tolist()
+                )
+                success = bool(info.get("success", False))
+                current = np.asarray(env.unwrapped.data.qpos[:2], dtype=np.float32)
+                waypoint_reached = (
+                    float(np.linalg.norm(target - current))
+                    <= WAYPOINT_SUCCESS_THRESHOLD
+                )
+                if success or waypoint_reached or terminated or truncated:
+                    break
+            if success or terminated or truncated:
+                break
+        distance = float(
+            np.linalg.norm(
+                observation["achieved_goal"] - observation["desired_goal"]
+            )
+        )
+    finally:
+        env.close()
+    return {
+        "environment_sha256": spec.environment_sha256,
+        "controller_sha256": spec.controller_sha256,
+        "spec_sha256": spec.spec_sha256,
+        "reset_seed": spec.reset_seed,
+        "action_tokens": list(tokens),
+        "success": success,
+        "final_goal_distance": distance,
+        "trajectory_xy": trajectory,
+        "simulator_steps": simulator_steps,
+    }
+
+
+def execute_ant_v8(candidate: str, raw_spec: Mapping[str, Any]):
+    """Execute and validate one v8 program in the pinned AntMaze runtime."""
+
+    execution = execute_ant_v8_raw(candidate, raw_spec)
+    return validate_maze_execution(candidate, raw_spec, execution), execution

code/oat_drgrpo/ant_maze_worker_v9.py

@@ -0,0 +1,240 @@
+"""Hash-bound AntMaze executor for the admitted v9 waypoint controller."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+from typing import Any, Mapping
+
+from .maze_modebench import (
+    ANT_MAZE_VERIFIER,
+    parse_maze_action_program,
+    parse_maze_action_spec,
+    validate_maze_execution,
+)
+from .maze_runtime_identity import maze_runtime_identity
+
+
+ROOT = Path(
+    os.environ.get("OAT_ZERO_REPO_ROOT", Path(__file__).resolve().parents[2])
+).resolve()
+MODEL_PATH = ROOT / "var/maze_runtime/controllers/ant_waypoint_v9.zip"
+RECEIPT_PATH = (
+    ROOT / "var/maze_runtime/controllers/ant_waypoint_v9.evaluation.json"
+)
+TRAINING_IDENTITY_PATH = (
+    ROOT / "var/artifacts/ant_waypoint_controller_v9_identity.json"
+)
+WAYPOINT_DISTANCE = 4.0
+WAYPOINT_SUCCESS_THRESHOLD = 0.45
+_MODEL = None
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def controller_receipt_sha256() -> str:
+    """Return the exact v9 receipt identity after validating admission."""
+
+    controller_identity()
+    return _sha256(RECEIPT_PATH)
+
+
+def controller_identity() -> dict[str, Any]:
+    """Load and verify the terminal v9 receipt and model as one identity."""
+
+    receipt_sha256 = _sha256(RECEIPT_PATH)
+    model_sha256 = _sha256(MODEL_PATH)
+    training_identity_sha256 = _sha256(TRAINING_IDENTITY_PATH)
+    receipt = json.loads(RECEIPT_PATH.read_text(encoding="utf-8"))
+    training_identity = json.loads(
+        TRAINING_IDENTITY_PATH.read_text(encoding="utf-8")
+    )
+    if (
+        receipt.get("status") != "pass"
+        or receipt.get("decision") != "admitted_to_fresh_maze_route_gate_v9"
+    ):
+        raise RuntimeError("Ant v9 controller is not admitted")
+    if receipt.get("seed") != 73009 or receipt.get("timesteps") != 5_000_000:
+        raise RuntimeError("Ant v9 receipt differs from its frozen training identity")
+    if (
+        training_identity.get("job_id") != 30192731
+        or training_identity.get("seed") != 73009
+    ):
+        raise RuntimeError("Ant v9 training identity is not the frozen job")
+    checks = receipt.get("checks", {})
+    required_checks = {
+        "episode_count",
+        "success_rate_at_least_0p90",
+        "minimum_heading_success_rate_at_least_0p75",
+        "minimum_map_success_rate_at_least_0p75",
+        "unhealthy_termination_rate_at_most_0p10",
+        "median_success_steps_at_most_300",
+        "all_metrics_finite",
+    }
+    if not isinstance(checks, dict) or not required_checks.issubset(checks) or not all(
+        checks[key] is True for key in required_checks
+    ):
+        raise RuntimeError("Ant v9 receipt contains a failed controller check")
+    if receipt.get("hashes", {}).get("model_sha256") != model_sha256:
+        raise RuntimeError("Ant v9 receipt does not bind the controller model")
+    if receipt.get("training_waypoint_distances") != [WAYPOINT_DISTANCE]:
+        raise RuntimeError("Ant v9 receipt has a different waypoint distance")
+    if receipt.get("waypoint_distance") != WAYPOINT_DISTANCE:
+        raise RuntimeError("Ant v9 receipt has a different executor distance")
+    if receipt.get("success_threshold") != WAYPOINT_SUCCESS_THRESHOLD:
+        raise RuntimeError("Ant v9 receipt has a different waypoint threshold")
+    route_identity_path = os.environ.get("OAT_ZERO_PROTOCOL_IDENTITY")
+    if route_identity_path:
+        route_identity = json.loads(
+            Path(route_identity_path).read_text(encoding="utf-8")
+        )
+        expected = {
+            "controller_receipt_sha256": receipt_sha256,
+            "controller_model_sha256": model_sha256,
+            "controller_training_identity_sha256": training_identity_sha256,
+        }
+        if route_identity.get("schema_version") != (
+            "ant-maze-v9-route-generation-identity-v1"
+        ):
+            raise RuntimeError("Ant v9 route identity schema mismatch")
+        if any(route_identity.get(key) != value for key, value in expected.items()):
+            raise RuntimeError("Ant v9 route identity does not bind the controller")
+    return receipt
+
+
+def _model():
+    global _MODEL
+    controller_identity()
+    if _MODEL is None:
+        from stable_baselines3 import PPO
+
+        _MODEL = PPO.load(MODEL_PATH, device="cpu")
+    return _MODEL
+
+
+def _heading(token: str):
+    import numpy as np
+
+    diagonal = 1.0 / math.sqrt(2.0)
+    values = {
+        "N": (0.0, 1.0),
+        "NE": (diagonal, diagonal),
+        "E": (1.0, 0.0),
+        "SE": (diagonal, -diagonal),
+        "S": (0.0, -1.0),
+        "SW": (-diagonal, -diagonal),
+        "W": (-1.0, 0.0),
+        "NW": (-diagonal, diagonal),
+    }
+    return np.asarray(values[token], dtype=np.float32)
+
+
+def execute_ant_v9_raw(
+    candidate: str,
+    raw_spec: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Execute commands as successive four-unit relative waypoint targets."""
+
+    import gymnasium as gym
+    import gymnasium_robotics
+    import numpy as np
+
+    gym.register_envs(gymnasium_robotics)
+    spec = parse_maze_action_spec(raw_spec)
+    if spec.verifier != ANT_MAZE_VERIFIER:
+        raise ValueError("AntMaze executor received a non-AntMaze spec")
+    runtime = maze_runtime_identity()
+    if spec.environment_sha256 != runtime["ant_environment_sha256"]:
+        raise ValueError("AntMaze environment hash differs from installed runtime")
+    if spec.controller_sha256 != controller_receipt_sha256():
+        raise ValueError("AntMaze controller hash differs from frozen v9 receipt")
+    tokens = parse_maze_action_program(candidate, spec)
+    model = _model()
+
+    env = gym.make(
+        spec.environment_id,
+        maze_map=[list(row) for row in spec.maze_map],
+        reward_type="sparse",
+        continuing_task=False,
+        reset_target=False,
+        max_episode_steps=len(tokens) * spec.action_repeat,
+    )
+    try:
+        env.unwrapped.position_noise_range = 0.0
+        observation, info = env.reset(
+            seed=spec.reset_seed,
+            options={
+                "reset_cell": list(spec.reset_cell),
+                "goal_cell": list(spec.goal_cell),
+            },
+        )
+        trajectory = [observation["achieved_goal"].astype(float).tolist()]
+        success = bool(info.get("success", False))
+        simulator_steps = 0
+        terminated = truncated = False
+        for token in tokens:
+            current = np.asarray(env.unwrapped.data.qpos[:2], dtype=np.float32)
+            target = current + WAYPOINT_DISTANCE * _heading(token)
+            for _ in range(spec.action_repeat):
+                current = np.asarray(env.unwrapped.data.qpos[:2], dtype=np.float32)
+                relative = np.clip(
+                    (target - current) / WAYPOINT_DISTANCE,
+                    -1.0,
+                    1.0,
+                )
+                controller_input = np.concatenate(
+                    [
+                        np.asarray(observation["observation"], dtype=np.float32),
+                        relative,
+                    ]
+                )
+                action, _ = model.predict(controller_input, deterministic=True)
+                observation, _reward, terminated, truncated, info = env.step(action)
+                simulator_steps += 1
+                trajectory.append(
+                    observation["achieved_goal"].astype(float).tolist()
+                )
+                success = bool(info.get("success", False))
+                current = np.asarray(env.unwrapped.data.qpos[:2], dtype=np.float32)
+                waypoint_reached = (
+                    float(np.linalg.norm(target - current))
+                    <= WAYPOINT_SUCCESS_THRESHOLD
+                )
+                if success or waypoint_reached or terminated or truncated:
+                    break
+            if success or terminated or truncated:
+                break
+        distance = float(
+            np.linalg.norm(
+                observation["achieved_goal"] - observation["desired_goal"]
+            )
+        )
+    finally:
+        env.close()
+    return {
+        "environment_sha256": spec.environment_sha256,
+        "controller_sha256": spec.controller_sha256,
+        "spec_sha256": spec.spec_sha256,
+        "reset_seed": spec.reset_seed,
+        "action_tokens": list(tokens),
+        "success": success,
+        "final_goal_distance": distance,
+        "trajectory_xy": trajectory,
+        "simulator_steps": simulator_steps,
+    }
+
+
+def execute_ant_v9(candidate: str, raw_spec: Mapping[str, Any]):
+    """Execute and validate one v9 program in the pinned AntMaze runtime."""
+
+    execution = execute_ant_v9_raw(candidate, raw_spec)
+    return validate_maze_execution(candidate, raw_spec, execution), execution

code/oat_drgrpo/canonical_actions.py

@@ -0,0 +1,915 @@
+"""Fixed-support canonical action policies for exact-answer experiments."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+import itertools
+import json
+import math
+from typing import Any
+
+import torch
+
+from .pantry_support_action import (
+    PANTRY_SUPPORT_MASK_TASK,
+    PANTRY_SUPPORT_MASK_WIDTH,
+    decode_pantry_support_mask,
+    pantry_support_mask_from_allocation,
+)
+
+
+GRAPH_COLOR_ACTIONS = ("1", "2", "3")
+COUNTDOWN_ACTIONS_BY_POSITION = (
+    ("1", "2", "3", "4", "5", "6"),
+    ("1", "2", "3"),
+    ("1", "2", "3", "4", "5", "6"),
+)
+
+
+@dataclass(frozen=True)
+class CanonicalActionSpace:
+    """A finite three-position action grammar resolved into tokenizer IDs."""
+
+    task: str
+    action_strings_by_position: tuple[tuple[str, ...], ...]
+    token_ids_by_position: tuple[tuple[int, ...], ...]
+
+    @property
+    def horizon(self) -> int:
+        return len(self.token_ids_by_position)
+
+    @property
+    def union_token_ids(self) -> tuple[int, ...]:
+        return tuple(
+            dict.fromkeys(
+                token_id
+                for support in self.token_ids_by_position
+                for token_id in support
+            )
+        )
+
+    @property
+    def sequence_count(self) -> int:
+        return math.prod(len(support) for support in self.token_ids_by_position)
+
+    @property
+    def max_sequence_entropy(self) -> float:
+        return math.log(self.sequence_count)
+
+
+def canonical_action_strings_by_position(
+    task: str,
+) -> tuple[tuple[str, ...], ...]:
+    """Return the audited action grammar for a canonical benchmark task."""
+
+    if task == "graph_coloring":
+        return (GRAPH_COLOR_ACTIONS,) * 3
+    if task == "countdown":
+        return COUNTDOWN_ACTIONS_BY_POSITION
+    if task == PANTRY_SUPPORT_MASK_TASK:
+        return (("0", "1"),) * PANTRY_SUPPORT_MASK_WIDTH
+    raise ValueError(f"unsupported canonical action task: {task!r}")
+
+
+def resolve_canonical_action_space(tokenizer: Any, task: str) -> CanonicalActionSpace:
+    """Resolve every grammar position while preserving its support order."""
+
+    action_strings = canonical_action_strings_by_position(task)
+    union_actions = tuple(
+        dict.fromkeys(action for support in action_strings for action in support)
+    )
+    union_ids = resolve_single_token_actions(tokenizer, union_actions)
+    action_to_id = dict(zip(union_actions, union_ids))
+    return CanonicalActionSpace(
+        task=task,
+        action_strings_by_position=action_strings,
+        token_ids_by_position=tuple(
+            tuple(action_to_id[action] for action in support)
+            for support in action_strings
+        ),
+    )
+
+
+def enumerate_countdown_action_codes() -> tuple[str, ...]:
+    """Enumerate the 6 x 3 x 6 Countdown codes in lexical digit order."""
+
+    return tuple(
+        "".join(digits)
+        for digits in itertools.product(
+            COUNTDOWN_ACTIONS_BY_POSITION[0],
+            COUNTDOWN_ACTIONS_BY_POSITION[1],
+            COUNTDOWN_ACTIONS_BY_POSITION[2],
+        )
+    )
+
+
+def decode_countdown_action_code(code: str, reference: str | dict[str, Any]) -> str:
+    """Decode one audited three-digit code into a full Countdown expression.
+
+    The singleton digit selects one operand in dataset order. The inner digit
+    combines the other two operands (also in dataset order), and the root
+    digit combines that pair with the singleton. No answer or target is used.
+    """
+
+    text = str(code).strip()
+    if (
+        len(text) != 3
+        or text[0] not in COUNTDOWN_ACTIONS_BY_POSITION[0]
+        or text[1] not in COUNTDOWN_ACTIONS_BY_POSITION[1]
+        or text[2] not in COUNTDOWN_ACTIONS_BY_POSITION[2]
+    ):
+        raise ValueError(f"invalid canonical Countdown action code: {code!r}")
+    try:
+        spec = json.loads(reference) if isinstance(reference, str) else reference
+        if not isinstance(spec, dict) or spec.get("verifier") != "countdown":
+            raise ValueError
+        numbers = tuple(int(value) for value in spec["numbers"])
+    except (KeyError, TypeError, ValueError, json.JSONDecodeError) as exc:
+        raise ValueError("canonical Countdown reference is malformed") from exc
+    if len(numbers) != 3 or len(set(numbers)) != 3:
+        raise ValueError(
+            "canonical Countdown requires exactly three distinct operands"
+        )
+
+    root_action, singleton_action, inner_action = (int(value) for value in text)
+    singleton_index = singleton_action - 1
+    singleton = numbers[singleton_index]
+    a, b = (
+        value for index, value in enumerate(numbers) if index != singleton_index
+    )
+    pair = {
+        1: f"({a} + {b})",
+        2: f"({a} * {b})",
+        3: f"({a} - {b})",
+        4: f"({b} - {a})",
+        5: f"({a} / {b})",
+        6: f"({b} / {a})",
+    }[inner_action]
+    return {
+        1: f"({pair} + {singleton})",
+        2: f"({pair} * {singleton})",
+        3: f"({pair} - {singleton})",
+        4: f"({singleton} - {pair})",
+        5: f"({pair} / {singleton})",
+        6: f"({singleton} / {pair})",
+    }[root_action]
+
+
+def decode_canonical_action_response(
+    task: str, code: str, reference: str | dict[str, Any]
+) -> str:
+    """Map policy action tokens to the benchmark response seen by the grader."""
+
+    text = str(code).strip()
+    if task == "graph_coloring":
+        if len(text) != 3 or any(action not in GRAPH_COLOR_ACTIONS for action in text):
+            raise ValueError(f"invalid canonical graph action code: {code!r}")
+        return text
+    if task == "countdown":
+        return decode_countdown_action_code(text, reference)
+    if task == PANTRY_SUPPORT_MASK_TASK:
+        try:
+            spec = json.loads(reference) if isinstance(reference, str) else reference
+        except json.JSONDecodeError:
+            spec = {}
+        if not isinstance(spec, dict):
+            spec = {}
+        return decode_pantry_support_mask(text, spec)
+    raise ValueError(f"unsupported canonical action task: {task!r}")
+
+
+def canonical_action_code_from_verified_response(
+    task: str,
+    response: str,
+    reference: str | dict[str, Any],
+) -> str:
+    """Represent a verified replay witness on its registered policy surface."""
+
+    text = str(response).strip()
+    if task == "graph_coloring":
+        decode_canonical_action_response(task, text, reference)
+        return text
+    if task == PANTRY_SUPPORT_MASK_TASK:
+        try:
+            spec = json.loads(reference) if isinstance(reference, str) else reference
+        except json.JSONDecodeError as exc:
+            raise ValueError("canonical Pantry reference is malformed") from exc
+        if not isinstance(spec, dict):
+            raise ValueError("canonical Pantry reference is malformed")
+        return pantry_support_mask_from_allocation(text, spec)
+    raise ValueError(
+        f"verified replay projection is unsupported for canonical task {task!r}"
+    )
+
+
+def canonical_action_code_token_ids(
+    action_space: CanonicalActionSpace,
+    code: str,
+) -> tuple[int, ...]:
+    """Encode one canonical code as exactly one registered token per action."""
+
+    text = str(code).strip()
+    if len(text) != action_space.horizon:
+        raise ValueError(
+            f"canonical action code has length {len(text)}, expected "
+            f"{action_space.horizon}"
+        )
+    token_ids: list[int] = []
+    for position, action in enumerate(text):
+        actions = action_space.action_strings_by_position[position]
+        try:
+            action_index = actions.index(action)
+        except ValueError as exc:
+            raise ValueError(
+                f"canonical action {action!r} is outside position {position} support"
+            ) from exc
+        token_ids.append(action_space.token_ids_by_position[position][action_index])
+    return tuple(token_ids)
+
+
+def _sample_canonical_actions_from_logits(
+    next_token_logits: torch.Tensor,
+    *,
+    allowed_token_ids: Sequence[int],
+    uniforms: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Sample one categorical action per row from a fixed token support.
+
+    Explicit uniforms make the sampling stream reproducible independently of
+    CUDA generator implementation.  The caller remains responsible for the
+    autoregressive loop: this helper samples exactly one next action.
+    """
+
+    if next_token_logits.ndim != 2:
+        raise ValueError("next_token_logits must have shape [batch, vocab]")
+    if next_token_logits.shape[0] <= 0:
+        raise ValueError("next_token_logits batch must be nonempty")
+    if uniforms.shape != (next_token_logits.shape[0],):
+        raise ValueError("uniforms must have shape [batch]")
+    ids = tuple(int(token_id) for token_id in allowed_token_ids)
+    if not ids or len(ids) != len(set(ids)):
+        raise ValueError("allowed_token_ids must be nonempty and unique")
+    if min(ids) < 0 or max(ids) >= int(next_token_logits.shape[-1]):
+        raise ValueError("allowed_token_ids must lie inside the model vocabulary")
+    if not bool(torch.isfinite(uniforms).all()) or not bool(
+        ((uniforms >= 0) & (uniforms < 1)).all()
+    ):
+        raise ValueError("uniforms must be finite values in [0, 1)")
+
+    allowed = torch.tensor(ids, dtype=torch.long, device=next_token_logits.device)
+    action_logits = next_token_logits.index_select(-1, allowed).float()
+    if not bool(torch.isfinite(action_logits).all()):
+        raise FloatingPointError("canonical next-action logits are nonfinite")
+    full_log_probs = torch.log_softmax(action_logits, dim=-1)
+    probabilities = torch.exp(full_log_probs)
+    cumulative = torch.cumsum(probabilities, dim=-1)
+    uniform_rows = uniforms.to(
+        device=next_token_logits.device, dtype=probabilities.dtype
+    )
+    sampled_indices = (uniform_rows.unsqueeze(-1) >= cumulative).sum(dim=-1)
+    sampled_indices = sampled_indices.clamp_max(len(ids) - 1)
+    token_ids = allowed[sampled_indices]
+    selected_log_probs = torch.gather(
+        full_log_probs, -1, sampled_indices.unsqueeze(-1)
+    ).squeeze(-1)
+    return (
+        token_ids.detach(),
+        selected_log_probs.detach(),
+        full_log_probs.detach(),
+    )
+
+
+def resolve_single_token_actions(
+    tokenizer: Any,
+    actions: Sequence[str],
+) -> tuple[int, ...]:
+    """Resolve a one-token, one-to-one serialization for canonical actions."""
+
+    if not actions:
+        raise ValueError("canonical action support cannot be empty")
+    token_ids: list[int] = []
+    for action in actions:
+        encoded = list(tokenizer.encode(action, add_special_tokens=False))
+        if len(encoded) != 1:
+            raise ValueError(
+                f"canonical action {action!r} must encode to exactly one token; "
+                f"got {encoded}"
+            )
+        token_id = int(encoded[0])
+        decoded = str(
+            tokenizer.decode(
+                [token_id],
+                skip_special_tokens=False,
+                clean_up_tokenization_spaces=False,
+            )
+        )
+        if decoded != action:
+            raise ValueError(
+                f"canonical action {action!r} is not one-to-one: token "
+                f"{token_id} decodes as {decoded!r}"
+            )
+        token_ids.append(token_id)
+    if len(set(token_ids)) != len(token_ids):
+        raise ValueError("canonical actions must resolve to distinct token ids")
+    return tuple(token_ids)
+
+
+def resolve_graph_color_action_token_ids(tokenizer: Any) -> tuple[int, ...]:
+    """Return the exact token ids for graph-color actions 1, 2, and 3."""
+
+    return resolve_single_token_actions(tokenizer, GRAPH_COLOR_ACTIONS)
+
+
+def restricted_action_log_probs_entropy_and_distribution(
+    logits: torch.Tensor,
+    labels: torch.Tensor,
+    response_masks: torch.Tensor,
+    *,
+    allowed_token_ids: Sequence[int],
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Score a fixed-support autoregressive action policy.
+
+    ``logits`` and ``labels`` have the ordinary causal-LM sequence shapes.
+    Only active response labels must belong to ``allowed_token_ids``. Returned
+    tensors have the shifted ``[batch, sequence - 1]`` shape and are zero away
+    from response actions.
+    """
+
+    if logits.ndim != 3:
+        raise ValueError("logits must have shape [batch, sequence, vocab]")
+    if labels.shape != logits.shape[:-1]:
+        raise ValueError("labels must match logits batch/sequence dimensions")
+    if response_masks.shape != (logits.shape[0], logits.shape[1] - 1):
+        raise ValueError("response_masks must have shape [batch, sequence - 1]")
+    ids = tuple(int(token_id) for token_id in allowed_token_ids)
+    if not ids or len(set(ids)) != len(ids):
+        raise ValueError("allowed_token_ids must be nonempty and unique")
+    if min(ids) < 0 or max(ids) >= int(logits.shape[-1]):
+        raise ValueError("allowed_token_ids must lie inside the model vocabulary")
+
+    shifted_labels = labels[:, 1:]
+    active = response_masks.to(torch.bool)
+    allowed = torch.tensor(ids, dtype=torch.long, device=logits.device)
+    matches = shifted_labels.unsqueeze(-1).eq(allowed)
+    match_count = matches.sum(dim=-1)
+    invalid_active = active & match_count.ne(1)
+    if bool(invalid_active.any()):
+        invalid_ids = shifted_labels[invalid_active].detach().cpu().unique().tolist()
+        raise ValueError(
+            "canonical response contains token ids outside its action support: "
+            f"{invalid_ids}"
+        )
+
+    action_logits = logits[:, :-1, :].index_select(-1, allowed).float()
+    if not bool(torch.isfinite(action_logits[active]).all()):
+        raise FloatingPointError(
+            "canonical policy has nonfinite allowed-support logits on active actions"
+        )
+    action_log_probs = torch.log_softmax(action_logits, dim=-1)
+    selected_indices = matches.to(torch.int64).argmax(dim=-1)
+    selected = torch.gather(
+        action_log_probs, dim=-1, index=selected_indices.unsqueeze(-1)
+    ).squeeze(-1)
+    probabilities = torch.softmax(action_logits, dim=-1)
+    entropy = -(probabilities * action_log_probs).sum(dim=-1)
+    if not bool(torch.isfinite(selected[active]).all()):
+        raise FloatingPointError(
+            "canonical policy has nonfinite selected log probabilities"
+        )
+    if not bool(torch.isfinite(entropy[active]).all()):
+        raise FloatingPointError("canonical policy has nonfinite action entropy")
+    zeros = torch.zeros_like(selected)
+    masked_distribution = torch.where(
+        active.unsqueeze(-1), action_log_probs, torch.zeros_like(action_log_probs)
+    )
+    return (
+        torch.where(active, selected, zeros),
+        torch.where(active, entropy, zeros),
+        masked_distribution,
+    )
+
+
+def restricted_action_log_probs_and_entropy(
+    logits: torch.Tensor,
+    labels: torch.Tensor,
+    response_masks: torch.Tensor,
+    *,
+    allowed_token_ids: Sequence[int],
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Backward-compatible two-output canonical-policy scorer."""
+
+    selected, entropy, _ = restricted_action_log_probs_entropy_and_distribution(
+        logits,
+        labels,
+        response_masks,
+        allowed_token_ids=allowed_token_ids,
+    )
+    return selected, entropy
+
+
+def restricted_position_action_log_probs_entropy_and_distribution(
+    logits: torch.Tensor,
+    labels: torch.Tensor,
+    response_masks: torch.Tensor,
+    *,
+    allowed_token_ids_by_position: Sequence[Sequence[int]],
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Score a fixed-horizon policy with position-specific token supports.
+
+    The full distribution uses the ordered union vocabulary. Disallowed union
+    entries are ``-inf`` on active rows and accompanied by an explicit support
+    mask, so callers never treat a masked action as probability mass.
+    """
+
+    if logits.ndim != 3:
+        raise ValueError("logits must have shape [batch, sequence, vocab]")
+    if labels.shape != logits.shape[:-1]:
+        raise ValueError("labels must match logits batch/sequence dimensions")
+    if response_masks.shape != (logits.shape[0], logits.shape[1] - 1):
+        raise ValueError("response_masks must have shape [batch, sequence - 1]")
+    supports = tuple(
+        tuple(int(token_id) for token_id in support)
+        for support in allowed_token_ids_by_position
+    )
+    if not supports or any(
+        not support or len(support) != len(set(support)) for support in supports
+    ):
+        raise ValueError("every positional action support must be nonempty and unique")
+    union_ids = tuple(
+        dict.fromkeys(token_id for support in supports for token_id in support)
+    )
+    if min(union_ids) < 0 or max(union_ids) >= int(logits.shape[-1]):
+        raise ValueError("allowed_token_ids must lie inside the model vocabulary")
+
+    active = response_masks.to(torch.bool)
+    row_counts = active.sum(dim=-1)
+    if not bool(row_counts.eq(len(supports)).all()):
+        raise ValueError(
+            "canonical rows must contain exactly one action per positional support"
+        )
+    ordinals = active.to(torch.int64).cumsum(dim=-1) - 1
+    safe_ordinals = ordinals.clamp(min=0, max=len(supports) - 1)
+    union_allowed = torch.tensor(
+        [
+            [token_id in set(support) for token_id in union_ids]
+            for support in supports
+        ],
+        dtype=torch.bool,
+        device=logits.device,
+    )
+    support_mask = union_allowed[safe_ordinals] & active.unsqueeze(-1)
+    union = torch.tensor(union_ids, dtype=torch.long, device=logits.device)
+    action_logits = logits[:, :-1, :].index_select(-1, union).float()
+    if not bool(torch.isfinite(action_logits[support_mask]).all()):
+        raise FloatingPointError(
+            "canonical policy has nonfinite positional-support logits"
+        )
+    masked_logits = action_logits.masked_fill(~support_mask, -torch.inf)
+    # Inactive prompt/padding positions have no support by construction. Give
+    # those rows a harmless finite distribution before log-softmax; they are
+    # zeroed in every returned tensor below. This avoids all--inf softmax NaNs
+    # (and their gradients) outside the response mask.
+    masked_logits = torch.where(
+        active.unsqueeze(-1), masked_logits, torch.zeros_like(masked_logits)
+    )
+    action_log_probs = torch.log_softmax(masked_logits, dim=-1)
+
+    shifted_labels = labels[:, 1:]
+    matches = shifted_labels.unsqueeze(-1).eq(union)
+    valid_selected = (matches & support_mask).sum(dim=-1).eq(1)
+    if bool((active & ~valid_selected).any()):
+        invalid_ids = shifted_labels[active & ~valid_selected].unique().tolist()
+        raise ValueError(
+            "canonical response contains token ids outside its positional support: "
+            f"{invalid_ids}"
+        )
+    selected_indices = matches.to(torch.int64).argmax(dim=-1)
+    selected = torch.gather(
+        action_log_probs, dim=-1, index=selected_indices.unsqueeze(-1)
+    ).squeeze(-1)
+    probabilities = torch.exp(action_log_probs)
+    finite_log_probs = action_log_probs.masked_fill(~support_mask, 0.0)
+    entropy_terms = probabilities * finite_log_probs
+    entropy = -entropy_terms.sum(dim=-1)
+    if not bool(torch.isfinite(selected[active]).all()) or not bool(
+        torch.isfinite(entropy[active]).all()
+    ):
+        raise FloatingPointError("canonical positional policy scoring is nonfinite")
+    zeros = torch.zeros_like(selected)
+    return (
+        torch.where(active, selected, zeros),
+        torch.where(active, entropy, zeros),
+        torch.where(
+            active.unsqueeze(-1),
+            action_log_probs,
+            torch.zeros_like(action_log_probs),
+        ),
+        support_mask,
+    )
+
+
+def materialize_position_canonical_behavior_policy(
+    shifted_labels: torch.Tensor,
+    response_masks: torch.Tensor,
+    *,
+    action_ids: Sequence[Sequence[int]],
+    selected_log_probs: Sequence[Sequence[float]],
+    full_log_probs: Sequence[Sequence[Sequence[float]]],
+    behavior_action_token_ids_by_position: Sequence[Sequence[Sequence[int]]],
+    allowed_token_ids_by_position: Sequence[Sequence[int]],
+    normalizer_atol: float = 1e-6,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, float, float]:
+    """Align a ragged positional behavior trace into an ordered union tensor."""
+
+    if shifted_labels.shape != response_masks.shape:
+        raise ValueError("shifted_labels and response_masks must have equal shape")
+    if normalizer_atol < 0:
+        raise ValueError("normalizer_atol must be nonnegative")
+    supports = tuple(
+        tuple(int(token_id) for token_id in support)
+        for support in allowed_token_ids_by_position
+    )
+    union_ids = tuple(
+        dict.fromkeys(token_id for support in supports for token_id in support)
+    )
+    union_index = {token_id: index for index, token_id in enumerate(union_ids)}
+    batch_size, shifted_length = shifted_labels.shape
+    fields = {
+        "action_ids": action_ids,
+        "selected_log_probs": selected_log_probs,
+        "full_log_probs": full_log_probs,
+        "behavior_action_token_ids_by_position": (
+            behavior_action_token_ids_by_position
+        ),
+    }
+    for name, rows in fields.items():
+        if len(rows) != batch_size:
+            raise RuntimeError(
+                f"canonical behavior {name} has {len(rows)} rows; "
+                f"expected {batch_size}"
+            )
+
+    dtype = torch.float32
+    device = shifted_labels.device
+    selected = torch.zeros((batch_size, shifted_length), dtype=dtype, device=device)
+    full = torch.full(
+        (batch_size, shifted_length, len(union_ids)),
+        -torch.inf,
+        dtype=dtype,
+        device=device,
+    )
+    support_mask = torch.zeros_like(full, dtype=torch.bool)
+    active = response_masks.to(torch.bool)
+    normalization_error_max = 0.0
+    selected_echo_diff_max = 0.0
+
+    for row_index in range(batch_size):
+        positions = torch.where(active[row_index])[0]
+        row_actions = [int(value) for value in action_ids[row_index]]
+        row_selected = [float(value) for value in selected_log_probs[row_index]]
+        row_full = list(full_log_probs[row_index])
+        row_supports = tuple(
+            tuple(int(value) for value in support)
+            for support in behavior_action_token_ids_by_position[row_index]
+        )
+        if row_supports != supports:
+            raise RuntimeError(
+                "canonical behavior positional support mismatch at row "
+                f"{row_index}: expected={supports} observed={row_supports}"
+            )
+        if not (
+            len(positions)
+            == len(row_actions)
+            == len(row_selected)
+            == len(row_full)
+            == len(supports)
+        ):
+            raise RuntimeError(
+                f"canonical behavior trace length mismatch at row {row_index}"
+            )
+        active_labels = shifted_labels[row_index, positions].detach().cpu().tolist()
+        if row_actions != [int(value) for value in active_labels]:
+            raise RuntimeError(
+                "canonical behavior action IDs do not match shifted learner labels "
+                f"at row {row_index}"
+            )
+
+        for action_position, (position, action_id, support) in enumerate(
+            zip(positions.tolist(), row_actions, supports)
+        ):
+            if action_id not in support:
+                raise RuntimeError(
+                    f"canonical behavior action {action_id} is outside support {support}"
+                )
+            values = torch.as_tensor(
+                row_full[action_position], dtype=dtype, device=device
+            )
+            selected_value = torch.as_tensor(
+                row_selected[action_position], dtype=dtype, device=device
+            )
+            if values.shape != (len(support),) or not bool(
+                torch.isfinite(values).all()
+            ) or not bool(torch.isfinite(selected_value)):
+                raise RuntimeError("canonical behavior trace is malformed or nonfinite")
+            log_normalizer = torch.logsumexp(values, dim=-1)
+            normalization_error = float(torch.abs(log_normalizer).cpu().item())
+            if normalization_error > normalizer_atol:
+                raise RuntimeError(
+                    "canonical behavior probabilities are not normalized at "
+                    f"row={row_index} position={action_position}: "
+                    f"abs(logsumexp)={normalization_error:.6g}"
+                )
+            support_action_index = support.index(action_id)
+            echo_diff = float(
+                torch.abs(selected_value - values[support_action_index]).cpu().item()
+            )
+            if echo_diff > 1e-7:
+                raise RuntimeError(
+                    "canonical selected behavior log probability does not match "
+                    f"its positional row at row={row_index} "
+                    f"position={action_position}: difference={echo_diff:.6g}"
+                )
+            normalized = values - log_normalizer
+            selected[row_index, position] = normalized[support_action_index]
+            union_indices = torch.tensor(
+                [union_index[token_id] for token_id in support],
+                dtype=torch.long,
+                device=device,
+            )
+            full[row_index, position, union_indices] = normalized
+            support_mask[row_index, position, union_indices] = True
+            normalization_error_max = max(
+                normalization_error_max, normalization_error
+            )
+            selected_echo_diff_max = max(selected_echo_diff_max, echo_diff)
+
+    return (
+        selected,
+        full,
+        support_mask,
+        normalization_error_max,
+        selected_echo_diff_max,
+    )
+
+
+def materialize_canonical_behavior_policy(
+    shifted_labels: torch.Tensor,
+    response_masks: torch.Tensor,
+    *,
+    action_ids: Sequence[Sequence[int]],
+    selected_log_probs: Sequence[Sequence[float]],
+    full_log_probs: Sequence[Sequence[Sequence[float]]],
+    behavior_action_token_ids: Sequence[Sequence[int]],
+    allowed_token_ids: Sequence[int],
+    normalizer_atol: float = 1e-6,
+) -> tuple[torch.Tensor, torch.Tensor, float, float]:
+    """Align the exact actor behavior trace with shifted learner positions.
+
+    Returns selected behavior log probabilities, ordered full-support behavior
+    log probabilities, maximum normalization error, and maximum discrepancy
+    between the separately transported selected value and its full-row entry.
+    """
+
+    if shifted_labels.shape != response_masks.shape:
+        raise ValueError("shifted_labels and response_masks must have equal shape")
+    if normalizer_atol < 0:
+        raise ValueError("normalizer_atol must be nonnegative")
+    batch_size, shifted_length = shifted_labels.shape
+    ids = tuple(int(token_id) for token_id in allowed_token_ids)
+    if not ids or len(ids) != len(set(ids)):
+        raise ValueError("allowed_token_ids must be nonempty and unique")
+    fields = {
+        "action_ids": action_ids,
+        "selected_log_probs": selected_log_probs,
+        "full_log_probs": full_log_probs,
+        "behavior_action_token_ids": behavior_action_token_ids,
+    }
+    for name, rows in fields.items():
+        if len(rows) != batch_size:
+            raise RuntimeError(
+                f"canonical behavior {name} has {len(rows)} rows; "
+                f"expected {batch_size}"
+            )
+
+    dtype = torch.float32
+    device = shifted_labels.device
+    selected = torch.zeros((batch_size, shifted_length), dtype=dtype, device=device)
+    full = torch.zeros(
+        (batch_size, shifted_length, len(ids)), dtype=dtype, device=device
+    )
+    id_to_index = {token_id: index for index, token_id in enumerate(ids)}
+    normalization_error_max = 0.0
+    selected_echo_diff_max = 0.0
+    active = response_masks.to(torch.bool)
+
+    for row_index in range(batch_size):
+        positions = torch.where(active[row_index])[0]
+        expected_count = int(positions.numel())
+        row_actions = [int(value) for value in action_ids[row_index]]
+        row_selected = [float(value) for value in selected_log_probs[row_index]]
+        row_full = list(full_log_probs[row_index])
+        row_support = tuple(int(value) for value in behavior_action_token_ids[row_index])
+        if row_support != ids:
+            raise RuntimeError(
+                "canonical behavior support order mismatch at row "
+                f"{row_index}: expected={ids} observed={row_support}"
+            )
+        if not (
+            len(row_actions)
+            == len(row_selected)
+            == len(row_full)
+            == expected_count
+        ):
+            raise RuntimeError(
+                "canonical behavior trace length mismatch at row "
+                f"{row_index}: actions={len(row_actions)} "
+                f"selected={len(row_selected)} full={len(row_full)} "
+                f"active={expected_count}"
+            )
+        active_labels = shifted_labels[row_index, positions].detach().cpu().tolist()
+        if row_actions != [int(value) for value in active_labels]:
+            raise RuntimeError(
+                "canonical behavior action IDs do not match shifted learner labels "
+                f"at row {row_index}"
+            )
+
+        for trace_index, (position, action_id) in enumerate(
+            zip(positions.tolist(), row_actions)
+        ):
+            if action_id not in id_to_index:
+                raise RuntimeError(
+                    f"canonical behavior action {action_id} is outside support {ids}"
+                )
+            values = torch.as_tensor(
+                row_full[trace_index], dtype=dtype, device=device
+            )
+            if values.shape != (len(ids),):
+                raise RuntimeError(
+                    "canonical behavior full row has wrong shape at "
+                    f"row={row_index} position={trace_index}: {tuple(values.shape)}"
+                )
+            selected_value = torch.as_tensor(
+                row_selected[trace_index], dtype=dtype, device=device
+            )
+            if not bool(torch.isfinite(values).all()) or not bool(
+                torch.isfinite(selected_value)
+            ):
+                raise RuntimeError("canonical behavior trace contains nonfinite values")
+            log_normalizer = torch.logsumexp(values, dim=-1)
+            normalization_error = float(
+                torch.abs(log_normalizer).detach().cpu().item()
+            )
+            if normalization_error > normalizer_atol:
+                raise RuntimeError(
+                    "canonical behavior probabilities are not normalized at "
+                    f"row={row_index} position={trace_index}: "
+                    f"abs(logsumexp)={normalization_error:.6g}"
+                )
+            selected_from_full_raw = values[id_to_index[action_id]]
+            echo_diff = float(
+                torch.abs(selected_value - selected_from_full_raw)
+                .detach()
+                .cpu()
+                .item()
+            )
+            if echo_diff > 1e-7:
+                raise RuntimeError(
+                    "canonical selected behavior log probability does not match "
+                    f"its full row at row={row_index} position={trace_index}: "
+                    f"difference={echo_diff:.6g}"
+                )
+            normalized_values = values - log_normalizer
+            selected[row_index, position] = normalized_values[id_to_index[action_id]]
+            full[row_index, position] = normalized_values
+            normalization_error_max = max(
+                normalization_error_max, normalization_error
+            )
+            selected_echo_diff_max = max(selected_echo_diff_max, echo_diff)
+
+    return selected, full, normalization_error_max, selected_echo_diff_max
+
+
+def canonical_behavior_overlap_diagnostics(
+    behavior_selected_log_probs: torch.Tensor,
+    behavior_full_log_probs: torch.Tensor,
+    learner_selected_log_probs: torch.Tensor,
+    learner_full_log_probs: torch.Tensor,
+    response_masks: torch.Tensor,
+    support_mask: torch.Tensor | None = None,
+) -> dict[str, torch.Tensor]:
+    """Compute full-distribution overlap and horizon-three IS diagnostics."""
+
+    if behavior_selected_log_probs.shape != response_masks.shape:
+        raise ValueError("behavior selected log-probabilities have the wrong shape")
+    if learner_selected_log_probs.shape != response_masks.shape:
+        raise ValueError("learner selected log-probabilities have the wrong shape")
+    expected_full_shape = (*response_masks.shape, behavior_full_log_probs.shape[-1])
+    if behavior_full_log_probs.shape != expected_full_shape:
+        raise ValueError("behavior full log-probabilities have the wrong shape")
+    if learner_full_log_probs.shape != expected_full_shape:
+        raise ValueError("learner full log-probabilities have the wrong shape")
+    if support_mask is not None and support_mask.shape != expected_full_shape:
+        raise ValueError("canonical support mask has the wrong shape")
+
+    active = response_masks.to(torch.bool)
+    if not bool(active.any()):
+        raise ValueError("canonical behavior diagnostics require active actions")
+    behavior_rows = behavior_full_log_probs[active].double()
+    learner_rows = learner_full_log_probs[active].double()
+    active_support = (
+        torch.ones_like(behavior_rows, dtype=torch.bool)
+        if support_mask is None
+        else support_mask[active].to(torch.bool)
+    )
+    if not bool(active_support.any(dim=-1).all()):
+        raise ValueError("canonical behavior diagnostics found an empty support row")
+    if not bool(torch.isfinite(behavior_rows[active_support]).all()) or not bool(
+        torch.isfinite(learner_rows[active_support]).all()
+    ):
+        raise FloatingPointError("canonical behavior diagnostics are nonfinite")
+    behavior_rows = behavior_rows - torch.logsumexp(
+        behavior_rows.masked_fill(~active_support, -torch.inf),
+        dim=-1,
+        keepdim=True,
+    )
+    learner_rows = learner_rows - torch.logsumexp(
+        learner_rows.masked_fill(~active_support, -torch.inf),
+        dim=-1,
+        keepdim=True,
+    )
+
+    log_ratio_rows = torch.where(
+        active_support,
+        learner_rows - behavior_rows,
+        torch.zeros_like(learner_rows),
+    )
+    density_ratios = torch.exp(log_ratio_rows[active_support])
+    behavior_probabilities = torch.where(
+        active_support, torch.exp(behavior_rows), torch.zeros_like(behavior_rows)
+    )
+    learner_probabilities = torch.where(
+        active_support, torch.exp(learner_rows), torch.zeros_like(learner_rows)
+    )
+    tv = 0.5 * torch.abs(
+        learner_probabilities - behavior_probabilities
+    ).sum(dim=-1)
+    kl_actor_learner = (
+        torch.where(
+            active_support,
+            behavior_probabilities * (behavior_rows - learner_rows),
+            torch.zeros_like(behavior_probabilities),
+        )
+    ).sum(dim=-1)
+    kl_learner_actor = (
+        torch.where(
+            active_support,
+            learner_probabilities * (learner_rows - behavior_rows),
+            torch.zeros_like(learner_probabilities),
+        )
+    ).sum(dim=-1)
+
+    selected_log_ratio = (
+        learner_selected_log_probs.double() - behavior_selected_log_probs.double()
+    )
+    row_counts = active.sum(dim=-1)
+    if not bool(row_counts.eq(row_counts[0]).all()):
+        raise RuntimeError("canonical behavior rows have unequal horizons")
+    horizon = int(row_counts[0].item())
+    compact_log_ratio = torch.stack(
+        [selected_log_ratio[row][active[row]] for row in range(active.shape[0])]
+    )
+    inclusive_prefix_log_ratio = torch.cumsum(compact_log_ratio, dim=-1)
+    exclusive_prefix_log_ratio = torch.cat(
+        (
+            torch.zeros_like(inclusive_prefix_log_ratio[:, :1]),
+            inclusive_prefix_log_ratio[:, :-1],
+        ),
+        dim=-1,
+    )
+
+    def _ess_fraction(weights: torch.Tensor) -> torch.Tensor:
+        count = torch.tensor(
+            float(weights.numel()), dtype=weights.dtype, device=weights.device
+        )
+        return weights.sum().square() / weights.square().sum().clamp_min(1e-12) / count
+
+    prefix_ess = []
+    for depth in range(horizon):
+        prefix_ess.append(
+            _ess_fraction(torch.exp(exclusive_prefix_log_ratio[:, depth]))
+        )
+    sequence_weights = torch.exp(inclusive_prefix_log_ratio[:, horizon - 1])
+
+    return {
+        "canonical_behavior_ratio_min": density_ratios.min(),
+        "canonical_behavior_ratio_max": density_ratios.max(),
+        "canonical_behavior_tv_mean": tv.mean(),
+        "canonical_behavior_tv_max": tv.max(),
+        "canonical_behavior_kl_actor_learner_mean": kl_actor_learner.mean(),
+        "canonical_behavior_kl_actor_learner_max": kl_actor_learner.max(),
+        "canonical_behavior_kl_learner_actor_mean": kl_learner_actor.mean(),
+        "canonical_behavior_kl_learner_actor_max": kl_learner_actor.max(),
+        "canonical_behavior_sequence_ess_fraction": _ess_fraction(sequence_weights),
+        "canonical_behavior_prefix_ess_fraction_min": torch.stack(prefix_ess).min(),
+    }

code/oat_drgrpo/math_grader.py

@@ -0,0 +1,2141 @@
+# Copyright 2025 Garena Online Private Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Provides a math answer grading function with high recall.
+Based on HF math_verify, verl, open reasoner zero, etc.
+"""
+
+import ast
+from dataclasses import dataclass
+import functools
+import json
+from multiprocessing import TimeoutError as MultiprocessingTimeoutError
+import queue
+import re
+import signal
+import threading
+from collections import Counter
+from fractions import Fraction
+from itertools import islice, zip_longest
+from math import isclose
+from typing import Any, Optional
+
+import sympy
+from latex2sympy2_extended import latex2sympy
+from math_verify import ExprExtractionConfig, LatexExtractionConfig, parse, verify
+from math_verify import grader as math_verify_grader
+from math_verify import parser as math_verify_parser
+from math_verify.errors import TimeoutException as MathVerifyTimeout
+from math_verify.utils import timeout as math_verify_signal_timeout
+from pylatexenc import latex2text
+from sympy import N, simplify
+from sympy.parsing import sympy_parser
+from sympy.parsing.latex import parse_latex
+from sympy.parsing.sympy_parser import parse_expr
+
+from .maze_modebench import (
+    ANT_MAZE_VERIFIER,
+    POINT_MAZE_VERIFIER,
+)
+from .maze_modebench_process import validate_maze_action_program_external
+from .mathir import (
+    MATHIR_MENU_VERIFIER,
+    MATHIR_VERIFIER,
+    validate_mathir_action_menu,
+    validate_mathir_algebra,
+)
+from .math_route import validate_math_route_response
+from .pantry_plan import (
+    PANTRY_PLAN_VERIFIER,
+    validate_pantry_plan,
+)
+from .python_modebench import (
+    PYTHON_FACTOR_VERIFIER,
+    python_factor_route_signature,
+)
+from .python_modebench_process import validate_python_factor_function_external
+
+
+def _thread_compatible_math_verify_timeout(timeout_seconds: int = 10):
+    """Keep math_verify bounded when grading runs in an actor worker thread.
+
+    math_verify's POSIX timeout installs SIGALRM. Python only permits signal
+    handler installation on the interpreter's main thread, while OAT grades
+    actor responses in a ThreadPool to avoid forking a CUDA/vLLM process. On
+    the main thread retain math_verify's native alarm. Else run the protected
+    operation in a daemon helper thread and bound the caller's wait.
+    """
+
+    seconds = int(timeout_seconds)
+    if seconds <= 0:
+        raise ValueError("timeout_seconds must be positive")
+
+    def decorator(func):
+        signal_wrapped = math_verify_signal_timeout(timeout_seconds=seconds)(func)
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            if threading.current_thread() is threading.main_thread():
+                return signal_wrapped(*args, **kwargs)
+            result_queue: queue.Queue[tuple[bool, Any]] = queue.Queue(maxsize=1)
+
+            def run() -> None:
+                try:
+                    result_queue.put((True, func(*args, **kwargs)))
+                except BaseException as error:
+                    result_queue.put((False, error))
+
+            worker = threading.Thread(
+                target=run,
+                name="math-verify-timeout",
+                daemon=True,
+            )
+            worker.start()
+            worker.join(seconds)
+            if worker.is_alive():
+                raise MathVerifyTimeout("Operation timed out!")
+            succeeded, value = result_queue.get_nowait()
+            if succeeded:
+                return value
+            raise value
+
+        return wrapper
+
+    return decorator
+
+
+# parse() and verify() resolve `timeout` from their defining module globals at
+# call time. Install the actor-thread-safe policy without altering the external
+# math_verify package or its grading semantics.
+math_verify_parser.timeout = _thread_compatible_math_verify_timeout
+math_verify_grader.timeout = _thread_compatible_math_verify_timeout
+
+
+_math_verify_sympy_solve_and_compare = math_verify_grader.sympy_solve_and_compare
+
+
+def _robust_math_verify_sympy_solve_and_compare(
+    gold,
+    pred,
+    float_rounding: int,
+    numeric_precision: int,
+):
+    """Repair math_verify's scalar ``solve(Eq)`` compatibility edge case.
+
+    Some SymPy versions return a list of scalar roots for ``solve(Eq, symbols)``
+    while math_verify assumes a list of dictionaries and calls ``.items()``.
+    Retry only that failing equality path with ``dict=True`` and preserve the
+    package's exact symbol-key and expression-comparison semantics.
+    """
+
+    try:
+        return _math_verify_sympy_solve_and_compare(
+            gold,
+            pred,
+            float_rounding,
+            numeric_precision,
+        )
+    except AttributeError as error:
+        if (
+            "items" not in str(error)
+            or not isinstance(gold, sympy.Eq)
+            or not isinstance(pred, sympy.Eq)
+        ):
+            raise
+
+    solved_gold = sympy.solve(
+        gold,
+        gold.free_symbols,
+        dict=True,
+    )
+    solved_pred = sympy.solve(
+        pred,
+        pred.free_symbols,
+        dict=True,
+    )
+    if not isinstance(solved_gold, list) or not isinstance(solved_pred, list):
+        return False
+    if len(solved_gold) != len(solved_pred):
+        return False
+
+    unmatched = list(solved_pred)
+    for gold_solution in solved_gold:
+        if not isinstance(gold_solution, dict):
+            return False
+        match_index = None
+        for index, pred_solution in enumerate(unmatched):
+            if (
+                isinstance(pred_solution, dict)
+                and set(gold_solution) == set(pred_solution)
+                and all(
+                    math_verify_grader.sympy_expr_eq(
+                        gold_solution[key],
+                        pred_solution[key],
+                        float_rounding,
+                        numeric_precision,
+                    )
+                    for key in gold_solution
+                )
+            ):
+                match_index = index
+                break
+        if match_index is None:
+            return False
+        unmatched.pop(match_index)
+    return not unmatched
+
+
+math_verify_grader.sympy_solve_and_compare = _robust_math_verify_sympy_solve_and_compare
+
+
+def collect_threaded_math_rewards(
+    pool,
+    reward_fn,
+    responses,
+    references,
+    *,
+    timeout_seconds: float,
+):
+    """Grade a response batch concurrently with one bounded wait per result."""
+
+    pending = [
+        pool.apply_async(reward_fn, (response, reference))
+        for response, reference in zip(responses, references)
+    ]
+    rewards = []
+    infos = []
+    for result in pending:
+        try:
+            info, reward = result.get(timeout=timeout_seconds)
+            rewards.append(reward)
+            infos.append(info)
+        except MultiprocessingTimeoutError:
+            rewards.append(0.0)
+            infos.append({"formatted": False})
+    return rewards, infos
+
+
+# Dan Hendrycks' code
+def mathd_normalize_answer(answer: Optional[str]) -> Optional[str]:
+    if answer is None:
+        return None
+    answer = answer.strip()
+    try:
+        # Remove enclosing `\text{}`.
+        m = re.search(r"^\\text\{(?P<text>.+?)\}$", answer)
+        if m is not None:
+            answer = m.group("text").strip()
+        return _strip_string(answer)
+    except Exception:
+        return answer
+
+
+# units mainly from MathQA
+unit_texts = [
+    "east",
+    "degree",
+    "mph",
+    "kmph",
+    "ft",
+    "m sqaure",
+    " m east",
+    "sq m",
+    "deg",
+    "mile",
+    "q .",
+    "monkey",
+    "prime",
+    "ratio",
+    "profit of rs",
+    "rd",
+    "o",
+    "gm",
+    "p . m",
+    "lb",
+    "tile",
+    "per",
+    "dm",
+    "lt",
+    "gain",
+    "ab",
+    "way",
+    "west",
+    "a .",
+    "b .",
+    "c .",
+    "d .",
+    "e .",
+    "f .",
+    "g .",
+    "h .",
+    "t",
+    "a",
+    "h",
+    "no change",
+    "men",
+    "soldier",
+    "pie",
+    "bc",
+    "excess",
+    "st",
+    "inches",
+    "noon",
+    "percent",
+    "by",
+    "gal",
+    "kmh",
+    "c",
+    "acre",
+    "rise",
+    "a . m",
+    "th",
+    "π r 2",
+    "sq",
+    "mark",
+    "l",
+    "toy",
+    "coin",
+    "sq . m",
+    "gallon",
+    "° f",
+    "profit",
+    "minw",
+    "yr",
+    "women",
+    "feet",
+    "am",
+    "pm",
+    "hr",
+    "cu cm",
+    "square",
+    "v â € ™",
+    "are",
+    "rupee",
+    "rounds",
+    "cubic",
+    "cc",
+    "mtr",
+    "s",
+    "ohm",
+    "number",
+    "kmph",
+    "day",
+    "hour",
+    "minute",
+    "min",
+    "second",
+    "man",
+    "woman",
+    "sec",
+    "cube",
+    "mt",
+    "sq inch",
+    "mp",
+    "∏ cm ³",
+    "hectare",
+    "more",
+    "sec",
+    "unit",
+    "cu . m",
+    "cm 2",
+    "rs .",
+    "rs",
+    "kg",
+    "g",
+    "month",
+    "km",
+    "m",
+    "cm",
+    "mm",
+    "apple",
+    "liter",
+    "loss",
+    "yard",
+    "pure",
+    "year",
+    "increase",
+    "decrease",
+    "d",
+    "less",
+    "Surface",
+    "litre",
+    "pi sq m",
+    "s .",
+    "metre",
+    "meter",
+    "inch",
+]
+
+unit_texts.extend([t + "s" for t in unit_texts])
+
+
+def _strip_string(string):
+    def _fix_fracs(string):
+        substrs = string.split("\\frac")
+        new_str = substrs[0]
+        if len(substrs) > 1:
+            substrs = substrs[1:]
+            for substr in substrs:
+                new_str += "\\frac"
+                if substr[0] == "{":
+                    new_str += substr
+                else:
+                    try:
+                        assert len(substr) >= 2
+                    except Exception:
+                        return string
+                    a = substr[0]
+                    b = substr[1]
+                    if b != "{":
+                        if len(substr) > 2:
+                            post_substr = substr[2:]
+                            new_str += "{" + a + "}{" + b + "}" + post_substr
+                        else:
+                            new_str += "{" + a + "}{" + b + "}"
+                    else:
+                        if len(substr) > 2:
+                            post_substr = substr[2:]
+                            new_str += "{" + a + "}" + b + post_substr
+                        else:
+                            new_str += "{" + a + "}" + b
+        string = new_str
+        return string
+
+    def _fix_a_slash_b(string):
+        if len(string.split("/")) != 2:
+            return string
+        a = string.split("/")[0]
+        b = string.split("/")[1]
+        try:
+            a = int(a)
+            b = int(b)
+            assert string == "{}/{}".format(a, b)
+            new_string = "\\frac{" + str(a) + "}{" + str(b) + "}"
+            return new_string
+        except Exception:
+            return string
+
+    def _remove_right_units(string):
+        # "\\text{ " only ever occurs (at least in the val set) when describing units
+        if "\\text{ " in string:
+            splits = string.split("\\text{ ")
+            assert len(splits) == 2
+            return splits[0]
+        else:
+            return string
+
+    def _fix_sqrt(string):
+        if "\\sqrt" not in string:
+            return string
+        splits = string.split("\\sqrt")
+        new_string = splits[0]
+        for split in splits[1:]:
+            if split[0] != "{":
+                a = split[0]
+                new_substr = "\\sqrt{" + a + "}" + split[1:]
+            else:
+                new_substr = "\\sqrt" + split
+            new_string += new_substr
+        return new_string
+
+    # linebreaks
+    string = string.replace("\n", "")
+    # print(string)
+
+    # remove inverse spaces
+    string = string.replace("\\!", "")
+    # print(string)
+
+    # replace \\ with \
+    string = string.replace("\\\\", "\\")
+    # print(string)
+
+    # matrix
+    string = re.sub(r"\\begin\{array\}\{.*?\}", r"\\begin{pmatrix}", string)
+    string = re.sub(r"\\end\{array\}", r"\\end{pmatrix}", string)
+    string = string.replace("bmatrix", "pmatrix")
+
+    # replace tfrac and dfrac with frac
+    string = string.replace("tfrac", "frac")
+    string = string.replace("dfrac", "frac")
+    string = (
+        string.replace("\\neq", "\\ne")
+        .replace("\\leq", "\\le")
+        .replace("\\geq", "\\ge")
+    )
+    # print(string)
+
+    # remove \left and \right
+    string = string.replace("\\left", "")
+    string = string.replace("\\right", "")
+    # print(string)
+
+    # Remove unit: miles, dollars if after is not none
+    _string = re.sub(r"\\text{.*?}$", "", string).strip()
+    if _string != "" and _string != string:
+        # print("Warning: unit not removed: '{}' -> '{}'".format(string, _string))
+        string = _string
+
+    # Remove unit: texts
+    for _ in range(2):
+        for unit_text in unit_texts:
+            # use regex, the prefix should be either the start of the string or a non-alphanumeric character
+            # the suffix should be either the end of the string or a non-alphanumeric character
+            _string = re.sub(r"(^|\W)" + unit_text + r"($|\W)", r"\1\2", string)
+            if _string != "":
+                string = _string
+
+    # Remove circ (degrees)
+    string = string.replace("^{\\circ}", "")
+    string = string.replace("^\\circ", "")
+
+    # remove dollar signs
+    string = string.replace("\\$", "")
+
+    # remove units (on the right)
+    string = _remove_right_units(string)
+
+    # remove percentage
+    string = string.replace("\\%", "")
+    string = string.replace(r"\%", "")
+
+    # " 0." equivalent to " ." and "{0." equivalent to "{." Alternatively, add "0" if "." is the start of the string
+    string = string.replace(" .", " 0.")
+    string = string.replace("{.", "{0.")
+    # if empty, return empty string
+    if len(string) == 0:
+        return string
+    if string[0] == ".":
+        string = "0" + string
+
+    # to consider: get rid of e.g. "k = " or "q = " at beginning
+    if len(string.split("=")) == 2:
+        if len(string.split("=")[0]) <= 2:
+            string = string.split("=")[1]
+
+    # fix sqrt3 --> sqrt{3}
+    string = _fix_sqrt(string)
+
+    # remove spaces
+    string = string.replace(" ", "")
+
+    # \frac1b or \frac12 --> \frac{1}{b} and \frac{1}{2}, etc. Even works with \frac1{72} (but not \frac{72}1). Also does a/b --> \\frac{a}{b}
+    string = _fix_fracs(string)
+
+    # manually change 0.5 --> \frac{1}{2}
+    if string == "0.5":
+        string = "\\frac{1}{2}"
+
+    # NOTE: X/Y changed to \frac{X}{Y} in dataset, but in simple cases fix in case the model output is X/Y
+    string = _fix_a_slash_b(string)
+
+    return string
+
+
+SUBSTITUTIONS = [
+    ("an ", ""),
+    ("a ", ""),
+    (".$", "$"),
+    ("\\$", ""),
+    (r"\ ", ""),
+    (" ", ""),
+    ("mbox", "text"),
+    (",\\text{and}", ","),
+    ("\\text{and}", ","),
+    ("\\text{m}", "\\text{}"),
+]
+
+
+REMOVED_EXPRESSIONS = [
+    "square",
+    "ways",
+    "integers",
+    "dollars",
+    "mph",
+    "inches",
+    "ft",
+    "hours",
+    "km",
+    "units",
+    "\\ldots",
+    "sue",
+    "points",
+    "feet",
+    "minutes",
+    "digits",
+    "cents",
+    "degrees",
+    "cm",
+    "gm",
+    "pounds",
+    "meters",
+    "meals",
+    "edges",
+    "students",
+    "childrentickets",
+    "multiples",
+    "\\text{s}",
+    "\\text{.}",
+    "\\text{\ns}",
+    "\\text{}^2",
+    "\\text{}^3",
+    "\\text{\n}",
+    "\\text{}",
+    r"\mathrm{th}",
+    r"^\circ",
+    r"^{\circ}",
+    r"\;",
+    r",\!",
+    "{,}",
+    '"',
+    "\\dots",
+]
+
+
+def normalize_final_answer(final_answer: str) -> str:
+    """
+    Normalize a final answer to a quantitative reasoning question.
+    This code comes from https://arxiv.org/pdf/2206.14858.pdf, page18.
+    """
+    # final_answer = final_answer.split("=")[-1]
+
+    for before, after in SUBSTITUTIONS:
+        final_answer = final_answer.replace(before, after)
+    for expr in REMOVED_EXPRESSIONS:
+        final_answer = final_answer.replace(expr, "")
+
+    # Extract answer that is in LaTeX math, is bold,
+    # is surrounded by a box, etc.
+    final_answer = re.sub(r"(.*?)(\$)(.*?)(\$)(.*)", "$\\3$", final_answer)
+    final_answer = re.sub(r"(\\text\{)(.*?)(\})", "\\2", final_answer)
+    final_answer = re.sub(r"(\\textbf\{)(.*?)(\})", "\\2", final_answer)
+    final_answer = re.sub(r"(\\overline\{)(.*?)(\})", "\\2", final_answer)
+    final_answer = re.sub(r"(\\boxed\{)(.*)(\})", "\\2", final_answer)
+
+    # Normalize shorthand TeX:
+    # \fracab -> \frac{a}{b}
+    # \frac{abc}{bef} -> \frac{abc}{bef}
+    # \fracabc -> \frac{a}{b}c
+    # \sqrta -> \sqrt{a}
+    # \sqrtab -> sqrt{a}b
+    final_answer = re.sub(r"(frac)([^{])(.)", "frac{\\2}{\\3}", final_answer)
+    final_answer = re.sub(r"(sqrt)([^{])", "sqrt{\\2}", final_answer)
+    final_answer = final_answer.replace("$", "")
+
+    # Normalize 100,000 -> 100000
+    if final_answer.replace(",", "").isdigit():
+        final_answer = final_answer.replace(",", "")
+
+    return final_answer
+
+
+def repeatness(s: str):
+    def ranks(values):
+        index = {v: i for i, v in enumerate(sorted(set(values)))}
+        return [index[v] for v in values]
+
+    def suffixArray(s):
+        line = ranks(s)
+        n, k, ans, sa = len(s), 1, line, [0] * len(s)
+        while k < n - 1:
+            line = ranks(list(zip_longest(line, islice(line, k, None), fillvalue=-1)))
+            ans, k = line, k << 1
+        for i, k in enumerate(ans):
+            sa[k] = i
+        return ans, sa
+
+    def lcp(arr, suffixArr, inv_suff):
+        n, ans, k = len(arr), [0] * len(arr), 0
+
+        for i in range(n):
+            if inv_suff[i] == n - 1:
+                k = 0
+                continue
+
+            j = suffixArr[inv_suff[i] + 1]
+            while i + k < n and j + k < n and arr[i + k] == arr[j + k]:
+                k += 1
+
+            ans[inv_suff[i]] = k
+            if k > 0:
+                k -= 1
+
+        return ans
+
+    arr = [ord(i) for i in s]
+    n = len(arr)
+    if n <= 1:
+        return 0
+    c, sa = suffixArray(arr)
+    cnt = sum(lcp(arr, sa, c))
+
+    return (cnt * 2 / (n * (n + 1))) > 0.2
+
+
+class timeout:
+    def __init__(self, seconds=1, error_message="Timeout"):
+        self.seconds = seconds
+        self.error_message = error_message
+        self._armed = False
+        self._old_handler = None
+
+    def handle_timeout(self, signum, frame):
+        raise TimeoutError(self.error_message)
+
+    def __enter__(self):
+        if threading.current_thread() is not threading.main_thread():
+            return self
+        self._old_handler = signal.getsignal(signal.SIGALRM)
+        signal.signal(signal.SIGALRM, self.handle_timeout)
+        signal.alarm(self.seconds)
+        self._armed = True
+        return self
+
+    def __exit__(self, type, value, traceback):
+        if self._armed:
+            signal.alarm(0)
+            signal.signal(signal.SIGALRM, self._old_handler)
+            self._armed = False
+
+
+def latex_eval(latex):
+    sym = parse_latex(latex)
+    val = sym.evalf()
+    return sym, val
+
+
+def numeric_equal(prediction: float, reference: float):
+    # Note that relative tolerance has significant impact
+    # on the result of the synthesized GSM-Hard dataset
+    # if reference.is_integer():
+    #     return isclose(reference, round(prediction), abs_tol=1e-4)
+    # else:
+    # prediction = round(prediction, len(str(reference).split(".")[-1]))
+    return isclose(reference, prediction, rel_tol=1e-4)
+
+
+def symbolic_equal(a, b):
+    def _parse(s):
+        for f in [parse_latex, parse_expr, latex2sympy]:
+            try:
+                return f(s.replace("\\\\", "\\"))
+            except Exception:
+                try:
+                    return f(s)
+                except Exception:
+                    pass
+        return s
+
+    a = _parse(a)
+    b = _parse(b)
+
+    # direct equal
+    try:
+        if str(a) == str(b) or a == b:
+            return True
+    except Exception:
+        pass
+
+    # simplify equal
+    try:
+        if a.equals(b) or simplify(a - b) == 0:
+            return True
+    except Exception:
+        pass
+
+    # equation equal
+    try:
+        if (abs(a.lhs - a.rhs)).equals(abs(b.lhs - b.rhs)):
+            return True
+    except Exception:
+        pass
+
+    try:
+        if numeric_equal(float(N(a)), float(N(b))):
+            return True
+    except Exception:
+        pass
+
+    # matrix
+    try:
+        # if a and b are matrix
+        if a.shape == b.shape:
+            _a = a.applyfunc(lambda x: round(x, 3))
+            _b = b.applyfunc(lambda x: round(x, 3))
+            if _a.equals(_b):
+                return True
+    except Exception:
+        pass
+
+    return False
+
+
+def _is_latex_equal(str1, str2):
+    try:
+        sym1, val1 = latex_eval(str1)
+        sym2, val2 = latex_eval(str2)
+        if sym1 == sym2 or val1 == val2:
+            return True
+        else:
+            raise ValueError
+    except Exception:  # noqa
+        try:
+            norm1, norm2 = normalize_final_answer(str1), normalize_final_answer(str2)
+            sym1, val1 = latex_eval(norm1)
+            sym2, val2 = latex_eval(norm2)
+            if sym1 == sym2 or val1 == val2:
+                return True
+        except Exception:  # noqa
+            return norm1 == norm2
+    return False
+
+
+def is_latex_equal(given_answer: str, ground_truth: str) -> bool:
+    try:
+        with timeout(1):
+            try:
+                if (len(given_answer) > 128 and repeatness(given_answer)) or (
+                    len(ground_truth) > 128 and repeatness(ground_truth)
+                ):
+                    return False
+                # First conduct normalized string matching.
+                ground_truth_normalized = _normalize(ground_truth)
+                given_normalized = _normalize(given_answer)
+                if ground_truth_normalized is None:
+                    return False
+                if ground_truth_normalized == given_normalized:
+                    return True
+
+                # Next call math verify.
+                given_answer.replace("\n", "")
+                ground_truth.replace("\n", "")
+                if "$" not in given_answer:
+                    given_answer = f"${given_answer}$"
+                if "$" not in ground_truth:
+                    ground_truth = f"${ground_truth}$"
+                return verify(
+                    parse(
+                        ground_truth,
+                        extraction_config=(
+                            LatexExtractionConfig(boxed_match_priority=0),
+                            ExprExtractionConfig(),
+                        ),
+                        fallback_mode="no_fallback",
+                        extraction_mode=["first_match"],
+                        parsing_timeout=1,
+                    ),
+                    parse(
+                        given_answer,
+                        extraction_config=(
+                            LatexExtractionConfig(boxed_match_priority=0),
+                            ExprExtractionConfig(),
+                        ),
+                        fallback_mode="no_fallback",
+                        extraction_mode=["first_match"],
+                        parsing_timeout=1,
+                    ),
+                    timeout_seconds=1,
+                )
+                # or symbolic_equal(ground_truth, given_answer)
+            except Exception:
+                return False
+    except TimeoutError:
+        return False
+
+
+def is_value_equal(given_answer: str, ground_truth: str) -> bool:
+    assert ground_truth is not None
+    ground_truth_normalized_mathd = mathd_normalize_answer(ground_truth)
+    given_answer_normalized_mathd = mathd_normalize_answer(given_answer)
+
+    str_equal = ground_truth_normalized_mathd == given_answer_normalized_mathd
+    try:
+        number_equal = float(ground_truth_normalized_mathd) == float(
+            given_answer_normalized_mathd
+        )
+        return str_equal or number_equal
+    except Exception:
+        return str_equal
+
+
+# sympy might hang -- we don't care about trying to be lenient in these cases
+BAD_SUBSTRINGS = ["^{", "^("]
+BAD_REGEXES = [r"\^[0-9]+\^", r"\^[0-9][0-9]+"]
+TUPLE_CHARS = "()[]"
+
+
+def _sympy_parse(expr: str):
+    """Parses an expression with sympy."""
+    py_expr = expr.replace("^", "**")
+    return sympy_parser.parse_expr(
+        py_expr,
+        transformations=(
+            sympy_parser.standard_transformations
+            + (sympy_parser.implicit_multiplication_application,)
+        ),
+    )
+
+
+def _parse_latex(expr: str) -> str:
+    """Attempts to parse latex to an expression sympy can read."""
+    expr = expr.replace("\\tfrac", "\\frac")
+    expr = expr.replace("\\dfrac", "\\frac")
+    expr = expr.replace("\\frac", " \\frac")  # Play nice with mixed numbers.
+    expr = latex2text.LatexNodes2Text().latex_to_text(expr)
+
+    # Replace the specific characters that this parser uses.
+    expr = expr.replace("√", "sqrt")
+    expr = expr.replace("π", "pi")
+    expr = expr.replace("∞", "inf")
+    expr = expr.replace("∪", "U")
+    expr = expr.replace("·", "*")
+    expr = expr.replace("×", "*")
+
+    return expr.strip()
+
+
+def _is_float(num: str) -> bool:
+    try:
+        float(num)
+        return True
+    except ValueError:
+        return False
+
+
+def _is_int(x: float) -> bool:
+    try:
+        return abs(x - int(round(x))) <= 1e-7
+    except Exception:
+        return False
+
+
+def _is_frac(expr: str) -> bool:
+    return bool(re.search(r"^-?[0-9]+.?/0*[1-9][0-9]*.?$", expr))
+
+
+def _str_is_int(x: str) -> bool:
+    try:
+        x = _strip_properly_formatted_commas(x)
+        x = float(x)
+        return abs(x - int(round(x))) <= 1e-7
+    except Exception:
+        return False
+
+
+def _str_to_int(x: str) -> bool:
+    x = x.replace(",", "")
+    x = float(x)
+    return int(x)
+
+
+def _inject_implicit_mixed_number(step: str):
+    """
+    Automatically make a mixed number evalable
+    e.g. 7 3/4 => 7+3/4
+    """
+    p1 = re.compile("([0-9]) +([0-9])")
+    step = p1.sub("\\1+\\2", step)  ## implicit mults
+    return step
+
+
+def _strip_properly_formatted_commas(expr: str):
+    # We want to be careful because we don't want to strip tuple commas
+    p1 = re.compile(r"(\d)(,)(\d\d\d)($|\D)")
+    while True:
+        next_expr = p1.sub("\\1\\3\\4", expr)
+        if next_expr == expr:
+            break
+        expr = next_expr
+    return next_expr
+
+
+def _normalize(expr: str) -> str:
+    """Normalize answer expressions."""
+    if expr is None:
+        return None
+
+    # Remove enclosing `\text{}`.
+    m = re.search(r"^\\text\{(?P<text>.+?)\}$", expr)
+    if m is not None:
+        expr = m.group("text")
+
+    expr = expr.replace("\\%", "%")
+    expr = expr.replace("\\$", "$")
+    expr = expr.replace("$", "")
+    expr = expr.replace("%", "")
+    expr = expr.replace(" or ", " , ")
+    expr = expr.replace(" and ", " , ")
+
+    expr = expr.replace("million", "*10^6")
+    expr = expr.replace("billion", "*10^9")
+    expr = expr.replace("trillion", "*10^12")
+
+    for unit in [
+        "degree",
+        "cm",
+        "centimeter",
+        "meter",
+        "mile",
+        "second",
+        "minute",
+        "hour",
+        "day",
+        "week",
+        "month",
+        "year",
+        "foot",
+        "feet",
+        "inch",
+        "yard",
+    ]:
+        expr = re.sub(rf"{unit}(es)?(s)? *(\^[0-9]+)?", "", expr)
+    expr = re.sub(r"\^ *\\\\circ", "", expr)
+
+    if len(expr) > 0 and expr[0] == "{" and expr[-1] == "}":
+        expr = expr[1:-1]
+
+    expr = re.sub(",\\\\! *", "", expr)
+    if _is_float(expr) and _is_int(float(expr)):
+        expr = str(int(round(float(expr))))
+    if "\\" in expr:
+        try:
+            expr = _parse_latex(expr)
+        except Exception:
+            pass
+
+    # edge case with mixed numbers and negative signs
+    expr = re.sub("- *", "-", expr)
+
+    expr = _inject_implicit_mixed_number(expr)
+    expr = expr.replace(" ", "")
+
+    # if we somehow still have latex braces here, just drop them
+    expr = expr.replace("{", "")
+    expr = expr.replace("}", "")
+
+    # don't be case sensitive for text answers
+    expr = expr.lower()
+
+    if _str_is_int(expr):
+        expr = str(_str_to_int(expr))
+
+    return expr
+
+
+def count_unknown_letters_in_expr(expr: str):
+    expr = expr.replace("sqrt", "")
+    expr = expr.replace("frac", "")
+    letters_in_expr = set([x for x in expr if x.isalpha()])
+    return len(letters_in_expr)
+
+
+def should_allow_eval(expr: str):
+    # we don't want to try parsing unknown text or functions of more than two variables
+    if count_unknown_letters_in_expr(expr) > 2:
+        return False
+
+    for bad_string in BAD_SUBSTRINGS:
+        if bad_string in expr:
+            return False
+
+    for bad_regex in BAD_REGEXES:
+        if re.search(bad_regex, expr) is not None:
+            return False
+
+    return True
+
+
+def are_equal_under_sympy(ground_truth_normalized: str, given_normalized: str):
+    are_equal = False
+    try:
+        expr = f"({ground_truth_normalized})-({given_normalized})"
+        if should_allow_eval(expr):
+            sympy_diff = _sympy_parse(expr)
+            simplified = sympy.simplify(sympy_diff)
+            if simplified == 0:
+                are_equal = True
+    except Exception:
+        pass
+    return are_equal
+
+
+def split_tuple(expr: str):
+    """
+    Split the elements in a tuple/interval, while handling well-formatted commas in large numbers
+    """
+    expr = _strip_properly_formatted_commas(expr)
+    if len(expr) == 0:
+        return []
+    if (
+        len(expr) > 2
+        and expr[0] in TUPLE_CHARS
+        and expr[-1] in TUPLE_CHARS
+        and all([ch not in expr[1:-1] for ch in TUPLE_CHARS])
+    ):
+        elems = [elem.strip() for elem in expr[1:-1].split(",")]
+    else:
+        elems = [expr]
+    return elems
+
+
+def last_boxed_only_string(string):
+    idx = string.rfind("\\boxed")
+    if idx < 0:
+        idx = string.rfind("\\fbox")
+        if idx < 0:
+            return None
+
+    i = idx
+    right_brace_idx = None
+    num_left_braces_open = 0
+    while i < len(string):
+        if string[i] == "{":
+            num_left_braces_open += 1
+        if string[i] == "}":
+            num_left_braces_open -= 1
+            if num_left_braces_open == 0:
+                right_brace_idx = i
+                break
+        i += 1
+
+    if right_brace_idx is None:
+        retval = None
+    else:
+        retval = string[idx : right_brace_idx + 1]
+
+    return retval
+
+
+def remove_boxed(s):
+    left = "\\boxed{"
+    try:
+        assert s[: len(left)] == left
+        assert s[-1] == "}"
+        return s[len(left) : -1]
+    except Exception:
+        return None
+
+
+def extract_boxed_answer(solution: str) -> str:
+    """Extract the answer from inside a LaTeX \\boxed{} command"""
+    solution = last_boxed_only_string(solution)
+    solution = remove_boxed(solution)
+    return solution
+
+
+def grade_answer_sympy(given_answer: str, ground_truth: str) -> bool:
+    ground_truth_normalized = _normalize(ground_truth)
+    given_normalized = _normalize(given_answer)
+
+    if ground_truth_normalized is None:
+        return False
+
+    if ground_truth_normalized == given_normalized:
+        return True
+
+    if len(given_normalized) == 0:
+        return False
+
+    ground_truth_elems = split_tuple(ground_truth_normalized)
+    given_elems = split_tuple(given_normalized)
+
+    if len(ground_truth_elems) > 1 and (
+        ground_truth_normalized[0] != given_normalized[0]
+        or ground_truth_normalized[-1] != given_normalized[-1]
+    ):
+        is_correct = False
+    elif len(ground_truth_elems) != len(given_elems):
+        is_correct = False
+    else:
+        for ground_truth_elem, given_elem in zip(ground_truth_elems, given_elems):
+            if _is_frac(ground_truth_elem) and _is_frac(given_elem):
+                # if fractions aren't reduced, then shouldn't be marked as correct
+                # so, we don't want to allow sympy.simplify in this case
+                is_correct = ground_truth_elem == given_elem
+            elif _str_is_int(ground_truth_elem) != _str_is_int(given_elem):
+                # if the ground truth answer is an integer, we require the given answer to be a strict match (no sympy.simplify)
+                is_correct = False
+            else:
+                is_correct = are_equal_under_sympy(ground_truth_elem, given_elem)
+            if not is_correct:
+                break
+
+    return is_correct
+
+
+def grade_answer_mathd(given_answer: str, ground_truth: str) -> bool:
+    ground_truth_normalized_mathd = mathd_normalize_answer(ground_truth)
+    given_answer_normalized_mathd = mathd_normalize_answer(given_answer)
+
+    # be at least as lenient as mathd
+    if ground_truth_normalized_mathd == given_answer_normalized_mathd:
+        return True
+    return False
+
+
+def extract_answer(passage: str) -> str:
+    if "\\boxed" in passage:
+        return extract_boxed_answer(passage)
+    return None
+
+
+def _parse_modebench_spec(gt_answer: Any) -> dict[str, Any] | None:
+    if isinstance(gt_answer, dict):
+        spec = gt_answer
+    elif isinstance(gt_answer, str):
+        text = gt_answer.strip()
+        if not (text.startswith("{") and text.endswith("}")):
+            return None
+        try:
+            spec = json.loads(text)
+        except Exception:
+            return None
+    else:
+        return None
+    verifier = spec.get("verifier")
+    if verifier in {
+        "graph_coloring",
+        "countdown",
+        MATHIR_VERIFIER,
+        MATHIR_MENU_VERIFIER,
+        PANTRY_PLAN_VERIFIER,
+        PYTHON_FACTOR_VERIFIER,
+        POINT_MAZE_VERIFIER,
+        ANT_MAZE_VERIFIER,
+    }:
+        return spec
+    return None
+
+
+PYTHON_FACTOR_RESPONSE_SURFACE_VERSION = (
+    "python-factor-response-v2-latex-lambda"
+)
+
+
+def _normalize_python_factor_lambda_surface(candidate: str) -> str:
+    """Normalize one formatting-only LaTeX spelling of ``lambda n:``."""
+
+    # Qwen's native boxed surface can typeset the Python keyword as the LaTeX
+    # command ``\lambda``.  Accept only the exact required signature (plus the
+    # conventional ``\,`` spacing alias); the restricted AST parser and
+    # isolated executable validator remain the authority.
+    return re.sub(
+        r"^\\lambda(?:\s+|\\,\s*)n\s*:\s*",
+        "lambda n: ",
+        str(candidate).strip(),
+        count=1,
+    ).strip()
+
+
+def _extract_modebench_candidate(model_response: str, gt_answer: Any) -> str | None:
+    spec = _parse_modebench_spec(gt_answer)
+    if spec is None:
+        return None
+    if "\\boxed" in str(model_response):
+        candidate = extract_answer(str(model_response))
+        if candidate is None:
+            return None
+        if str(spec.get("verifier")) == PYTHON_FACTOR_VERIFIER:
+            candidate = _normalize_python_factor_lambda_surface(candidate)
+        return candidate or None
+    candidate = str(model_response).strip()
+    if not candidate:
+        return None
+    if str(spec.get("verifier")) in {
+        MATHIR_VERIFIER,
+        MATHIR_MENU_VERIFIER,
+    }:
+        fenced = re.fullmatch(
+            r"```(?:mathir)?\s*(.*?)\s*```",
+            candidate,
+            flags=re.IGNORECASE | re.DOTALL,
+        )
+        if fenced is not None:
+            candidate = fenced.group(1).strip()
+        if len(candidate) > 200 or "<" in candidate or ">" in candidate:
+            return None
+        # Whitespace, a terminal semicolon, and an all-program code fence are
+        # formatting aliases.  The restricted parser remains the authority.
+        return candidate or None
+    if str(spec.get("verifier")) == PYTHON_FACTOR_VERIFIER:
+        fenced = re.fullmatch(
+            r"```(?:python)?\s*(.*?)\s*```",
+            candidate,
+            flags=re.IGNORECASE | re.DOTALL,
+        )
+        if fenced is not None:
+            candidate = fenced.group(1).strip()
+        if (
+            len(candidate) > 240
+            or "\n" in candidate
+            or "\r" in candidate
+            or "<" in candidate
+            or ">" in candidate
+        ):
+            return None
+        candidate = re.sub(
+            r"^\s*(?:the\s+)?(?:final\s+)?(?:answer|program|function)\s*"
+            r"(?:is|=|:)\s*",
+            "",
+            candidate,
+            flags=re.IGNORECASE,
+        ).strip()
+        candidate = _normalize_python_factor_lambda_surface(candidate)
+        return candidate or None
+    if str(spec.get("verifier")) in {
+        POINT_MAZE_VERIFIER,
+        ANT_MAZE_VERIFIER,
+    }:
+        fenced = re.fullmatch(
+            r"```(?:actions?|plan)?\s*(.*?)\s*```",
+            candidate,
+            flags=re.IGNORECASE | re.DOTALL,
+        )
+        if fenced is not None:
+            candidate = fenced.group(1).strip()
+        if len(candidate) > 4096 or "<" in candidate or ">" in candidate:
+            return None
+        candidate = re.sub(
+            r"^\s*(?:the\s+)?(?:final\s+)?(?:answer|plan|program|actions?)\s*"
+            r"(?:is|=|:)\s*",
+            "",
+            candidate,
+            flags=re.IGNORECASE,
+        ).strip()
+        return candidate or None
+    if str(spec.get("verifier")) == PANTRY_PLAN_VERIFIER:
+        if (
+            len(candidate) > 512
+            or "\n" in candidate
+            or "\r" in candidate
+            or "<" in candidate
+            or ">" in candidate
+        ):
+            return None
+        candidate = re.sub(
+            r"^\s*(?:the\s+)?(?:final\s+)?(?:answer|plan|recipe)\s*"
+            r"(?:is|=|:)\s*",
+            "",
+            candidate,
+            flags=re.IGNORECASE,
+        ).strip()
+        return candidate or None
+    if "\n" in candidate or "\r" in candidate or "<" in candidate or ">" in candidate:
+        return None
+    if len(candidate) > 160:
+        return None
+    candidate = re.sub(
+        r"^\s*(?:the\s+)?(?:final\s+)?(?:answer|expression|coloring|program)\s*"
+        r"(?:is|=|:)\s*",
+        "",
+        candidate,
+        flags=re.IGNORECASE,
+    ).strip()
+    return candidate or None
+
+
+def _parse_graph_coloring_answer(candidate: str, n: int) -> list[int] | None:
+    text = str(candidate).strip().lower()
+    text = re.sub(r"^(?:coloring|answer)\s*(?:is|=|:)\s*", "", text).strip()
+    compact = re.sub(r"[\s,;|\[\]\(\)\{\}:.-]+", "", text)
+    if len(compact) == n and all(ch in "123" for ch in compact):
+        return [int(ch) for ch in compact]
+    tokens = re.findall(r"[123]", text)
+    if len(tokens) == n:
+        return [int(token) for token in tokens]
+    return None
+
+
+def _parse_graph_digit_sequence(candidate: str, expected_len: int) -> list[int] | None:
+    text = str(candidate).strip().lower()
+    text = re.sub(
+        r"^(?:missing\s+)?(?:colors?|digits?|answer)\s*(?:are|is|=|:)\s*",
+        "",
+        text,
+    ).strip()
+    compact = re.sub(r"[\s,;|\[\]\(\)\{\}:.-]+", "", text)
+    if len(compact) == expected_len and all(ch in "123" for ch in compact):
+        return [int(ch) for ch in compact]
+    tokens = re.findall(r"[123]", text)
+    if len(tokens) == expected_len:
+        return [int(token) for token in tokens]
+    return None
+
+
+def _verify_graph_coloring_colors(
+    colors: list[int] | None,
+    spec: dict[str, Any],
+) -> bool:
+    """Validate one already-parsed coloring object against its problem."""
+
+    try:
+        n = int(spec["n"])
+        edges = spec["edges"]
+    except Exception:
+        return False
+    if colors is None or len(colors) != n:
+        return False
+    partial_colors = spec.get("partial_colors")
+    if partial_colors is not None:
+        try:
+            if len(partial_colors) != n:
+                return False
+            for index, color in enumerate(partial_colors):
+                if color is None:
+                    continue
+                if colors[index] != int(color):
+                    return False
+        except Exception:
+            return False
+    for edge in edges:
+        try:
+            u, v = int(edge[0]), int(edge[1])
+        except Exception:
+            return False
+        if u < 1 or v < 1 or u > n or v > n:
+            return False
+        if colors[u - 1] == colors[v - 1]:
+            return False
+    return True
+
+
+def _verify_graph_coloring_answer(candidate: str, spec: dict[str, Any]) -> bool:
+    colors = _graph_coloring_from_candidate(candidate, spec)
+    return _verify_graph_coloring_colors(colors, spec)
+
+
+def _normalize_countdown_expression(candidate: str) -> str:
+    text = str(candidate).strip()
+    text = text.replace("\\times", "*").replace("\\cdot", "*")
+    text = text.replace("\\div", "/").replace("÷", "/").replace("×", "*")
+    text = text.replace("^", "**")
+    text = re.sub(r"^\s*(?:expression|answer)\s*(?:is|=|:)\s*", "", text, flags=re.I)
+    return text.strip()
+
+
+def _countdown_eval_and_numbers(node: ast.AST) -> tuple[Fraction, list[int]]:
+    if isinstance(node, ast.Expression):
+        return _countdown_eval_and_numbers(node.body)
+    if isinstance(node, ast.Constant):
+        if isinstance(node.value, bool) or not isinstance(node.value, int):
+            raise ValueError("Countdown constants must be integers.")
+        return Fraction(int(node.value), 1), [int(node.value)]
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)):
+        value, numbers = _countdown_eval_and_numbers(node.operand)
+        if isinstance(node.op, ast.USub):
+            value = -value
+        return value, numbers
+    if isinstance(node, ast.BinOp):
+        left, left_numbers = _countdown_eval_and_numbers(node.left)
+        right, right_numbers = _countdown_eval_and_numbers(node.right)
+        if isinstance(node.op, ast.Add):
+            value = left + right
+        elif isinstance(node.op, ast.Sub):
+            value = left - right
+        elif isinstance(node.op, ast.Mult):
+            value = left * right
+        elif isinstance(node.op, ast.Div):
+            if right == 0:
+                raise ValueError("Countdown division by zero.")
+            value = left / right
+        else:
+            raise ValueError("Unsupported Countdown operator.")
+        return value, left_numbers + right_numbers
+    raise ValueError("Unsupported Countdown expression.")
+
+
+def _verify_countdown_expression(candidate: str, spec: dict[str, Any]) -> bool:
+    try:
+        target = Fraction(int(spec["target"]), 1)
+        expected_numbers = Counter(int(value) for value in spec["numbers"])
+    except Exception:
+        return False
+    text = _normalize_countdown_expression(candidate)
+    if not text:
+        return False
+    parts = [part.strip() for part in text.split("=") if part.strip()]
+    if not parts:
+        parts = [text]
+    for part in parts:
+        if not re.fullmatch(r"[0-9+\-*/().\s*]+", part):
+            continue
+        try:
+            parsed = ast.parse(part, mode="eval")
+            value, used_numbers = _countdown_eval_and_numbers(parsed)
+        except Exception:
+            continue
+        if value == target and Counter(used_numbers) == expected_numbers:
+            return True
+    return False
+
+
+def _graph_coloring_from_candidate(
+    candidate: str,
+    spec: dict[str, Any],
+) -> list[int] | None:
+    try:
+        n = int(spec["n"])
+    except Exception:
+        return None
+    colors = _parse_graph_coloring_answer(candidate, n)
+    partial_colors = spec.get("partial_colors")
+    if colors is None and partial_colors is not None:
+        try:
+            hidden_positions = [
+                index for index, color in enumerate(partial_colors) if color is None
+            ]
+            fill = _parse_graph_digit_sequence(candidate, len(hidden_positions))
+            if fill is not None:
+                colors = [
+                    int(color) if color is not None else 0 for color in partial_colors
+                ]
+                for index, color in zip(hidden_positions, fill):
+                    colors[index] = color
+        except Exception:
+            return None
+    if colors is None or len(colors) != n:
+        return None
+    return colors
+
+
+def _canonical_countdown_ast(node: ast.AST) -> str:
+    if isinstance(node, ast.Expression):
+        return _canonical_countdown_ast(node.body)
+    if isinstance(node, ast.Constant):
+        if isinstance(node.value, bool) or not isinstance(node.value, int):
+            raise ValueError("Countdown constants must be integers.")
+        return str(int(node.value))
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)):
+        inner = _canonical_countdown_ast(node.operand)
+        if isinstance(node.op, ast.USub):
+            return f"neg({inner})"
+        return inner
+    if isinstance(node, ast.BinOp):
+        left = _canonical_countdown_ast(node.left)
+        right = _canonical_countdown_ast(node.right)
+        if isinstance(node.op, ast.Add):
+            parts = sorted([left, right])
+            return f"add({parts[0]},{parts[1]})"
+        if isinstance(node.op, ast.Mult):
+            parts = sorted([left, right])
+            return f"mul({parts[0]},{parts[1]})"
+        if isinstance(node.op, ast.Sub):
+            return f"sub({left},{right})"
+        if isinstance(node.op, ast.Div):
+            return f"div({left},{right})"
+    raise ValueError("Unsupported Countdown expression.")
+
+
+def _canonical_countdown_route_ast(node: ast.AST) -> str:
+    """Canonical operator/dependency skeleton with numeric leaves abstracted."""
+
+    if isinstance(node, ast.Expression):
+        return _canonical_countdown_route_ast(node.body)
+    if isinstance(node, ast.Constant):
+        if isinstance(node.value, bool) or not isinstance(node.value, int):
+            raise ValueError("Countdown constants must be integers.")
+        return "input"
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)):
+        inner = _canonical_countdown_route_ast(node.operand)
+        return f"neg({inner})" if isinstance(node.op, ast.USub) else inner
+    if isinstance(node, ast.BinOp):
+        left = _canonical_countdown_route_ast(node.left)
+        right = _canonical_countdown_route_ast(node.right)
+        if isinstance(node.op, ast.Add):
+            parts = sorted([left, right])
+            return f"add({parts[0]},{parts[1]})"
+        if isinstance(node.op, ast.Mult):
+            parts = sorted([left, right])
+            return f"mul({parts[0]},{parts[1]})"
+        if isinstance(node.op, ast.Sub):
+            return f"sub({left},{right})"
+        if isinstance(node.op, ast.Div):
+            return f"div({left},{right})"
+    raise ValueError("Unsupported Countdown route expression.")
+
+
+def _canonical_countdown_expression_key(
+    candidate: str,
+    spec: dict[str, Any],
+) -> str | None:
+    try:
+        expected_numbers = Counter(int(value) for value in spec["numbers"])
+    except Exception:
+        return None
+    text = _normalize_countdown_expression(candidate)
+    if not text:
+        return None
+    parts = [part.strip() for part in text.split("=") if part.strip()] or [text]
+    for part in parts:
+        if not re.fullmatch(r"[0-9+\-*/().\s*]+", part):
+            continue
+        try:
+            parsed = ast.parse(part, mode="eval")
+            _, used_numbers = _countdown_eval_and_numbers(parsed)
+            if Counter(used_numbers) != expected_numbers:
+                continue
+            return f"countdown:{_canonical_countdown_ast(parsed)}"
+        except Exception:
+            continue
+    return None
+
+
+def _modebench_answer_key(
+    model_response: str,
+    gt_answer: Any,
+) -> str | None:
+    spec = _parse_modebench_spec(gt_answer)
+    if spec is None:
+        return None
+    candidate = _extract_modebench_candidate(model_response, gt_answer)
+    if candidate is None:
+        return None
+    verifier = str(spec.get("verifier"))
+    if verifier == "graph_coloring":
+        colors = _graph_coloring_from_candidate(candidate, spec)
+        if colors is None:
+            return None
+        return "graph_coloring:" + "".join(str(int(color)) for color in colors)
+    if verifier == "countdown":
+        return _canonical_countdown_expression_key(candidate, spec)
+    if verifier == MATHIR_VERIFIER:
+        validation = validate_mathir_algebra(candidate, spec)
+        return validation.canonical_key if validation is not None else None
+    if verifier == MATHIR_MENU_VERIFIER:
+        validation = validate_mathir_action_menu(candidate, spec)
+        return validation.canonical_key if validation is not None else None
+    if verifier == PYTHON_FACTOR_VERIFIER:
+        validation = validate_python_factor_function_external(candidate, spec)
+        return validation.canonical_key if validation is not None else None
+    if verifier == PANTRY_PLAN_VERIFIER:
+        validation = validate_pantry_plan(candidate, spec)
+        return validation.canonical_key if validation is not None else None
+    if verifier in {POINT_MAZE_VERIFIER, ANT_MAZE_VERIFIER}:
+        validation = validate_maze_action_program_external(candidate, spec)
+        return validation.canonical_key if validation is not None else None
+    return None
+
+
+def validated_modebench_outcome_key(
+    model_response: str,
+    gt_answer: Any,
+) -> str | None:
+    """Return a canonical outcome only when that same response verifies.
+
+    This is the admission boundary for online canonical banks.  It deliberately
+    supports only ModeBench tasks with executable validators:
+
+    - graph colorings are parsed and checked against every graph edge;
+    - Countdown expressions are parsed, checked for exact operand use, and
+      executed against the requested target.
+
+    - MathIR algebra programs are parsed by a restricted grammar, executed as
+      state transformations, exact-normalized, and accepted only when execution
+      isolates the right solution.  Their key comes from those executed states.
+
+    - Python factor functions are syntax-restricted and called in an isolated
+      Python worker.  Their key is the vector returned by those exact tool calls.
+
+    Ordinary MATH final-answer grading is not a proof/strategy verifier and is
+    therefore rejected here rather than being mislabeled as canonical search.
+    """
+
+    spec = _parse_modebench_spec(gt_answer)
+    if spec is None:
+        return None
+    candidate = _extract_modebench_candidate(model_response, gt_answer)
+    if candidate is None:
+        return None
+    verifier = str(spec.get("verifier"))
+    if verifier == "graph_coloring":
+        colors = _graph_coloring_from_candidate(candidate, spec)
+        if not _verify_graph_coloring_colors(colors, spec):
+            return None
+        assert colors is not None
+        return "graph_coloring:" + "".join(str(int(color)) for color in colors)
+    if verifier == MATHIR_VERIFIER:
+        validation = validate_mathir_algebra(candidate, spec)
+        # The key is constructed from the exact normalized equation states
+        # produced by the same interpreter execution that validated the answer.
+        return validation.canonical_key if validation is not None else None
+    if verifier == MATHIR_MENU_VERIFIER:
+        validation = validate_mathir_action_menu(candidate, spec)
+        # Menu labels are expanded first. Identity comes only from the exact
+        # normalized states produced by executing those concrete operations.
+        return validation.canonical_key if validation is not None else None
+    if verifier == PYTHON_FACTOR_VERIFIER:
+        validation = validate_python_factor_function_external(candidate, spec)
+        return validation.canonical_key if validation is not None else None
+    if verifier == PANTRY_PLAN_VERIFIER:
+        validation = validate_pantry_plan(candidate, spec)
+        return validation.canonical_key if validation is not None else None
+    if verifier in {POINT_MAZE_VERIFIER, ANT_MAZE_VERIFIER}:
+        validation = validate_maze_action_program_external(candidate, spec)
+        return validation.canonical_key if validation is not None else None
+    if verifier != "countdown":
+        return None
+    try:
+        target = Fraction(int(spec["target"]), 1)
+        expected_numbers = Counter(int(value) for value in spec["numbers"])
+    except Exception:
+        return None
+    text = _normalize_countdown_expression(candidate)
+    parts = [part.strip() for part in text.split("=") if part.strip()] or [text]
+    for part in parts:
+        if not re.fullmatch(r"[0-9+\-*/().\s*]+", part):
+            continue
+        try:
+            parsed = ast.parse(part, mode="eval")
+            value, used_numbers = _countdown_eval_and_numbers(parsed)
+            if value != target or Counter(used_numbers) != expected_numbers:
+                continue
+            # The key is derived from the exact AST object that passed
+            # execution and operand validation above.
+            return f"countdown:{_canonical_countdown_ast(parsed)}"
+        except Exception:
+            continue
+    return None
+
+
+@dataclass(frozen=True)
+class VerifiedExplorationIdentity:
+    """Separate prompt-local endpoint and cross-prompt route identities."""
+
+    verifier: str
+    endpoint_key: str
+    route_signature: str | None
+
+
+def validated_modebench_exploration_identity(
+    model_response: str,
+    gt_answer: Any,
+) -> VerifiedExplorationIdentity | None:
+    """Return hierarchical identity only after exact executable validation."""
+
+    spec = _parse_modebench_spec(gt_answer)
+    if spec is None:
+        return None
+    candidate = _extract_modebench_candidate(model_response, gt_answer)
+    if candidate is None:
+        return None
+    verifier = str(spec.get("verifier"))
+    if verifier == "graph_coloring":
+        colors = _graph_coloring_from_candidate(candidate, spec)
+        if not _verify_graph_coloring_colors(colors, spec):
+            return None
+        assert colors is not None
+        endpoint = "graph_coloring:" + "".join(str(int(color)) for color in colors)
+        return VerifiedExplorationIdentity(verifier, endpoint, None)
+    if verifier == MATHIR_VERIFIER:
+        validation = validate_mathir_algebra(candidate, spec)
+        if validation is None:
+            return None
+        solution = validation.solution
+        endpoint = f"mathir-solution:{solution.numerator}/{solution.denominator}"
+        return VerifiedExplorationIdentity(
+            verifier,
+            endpoint,
+            validation.route_signature,
+        )
+    if verifier == MATHIR_MENU_VERIFIER:
+        validation = validate_mathir_action_menu(candidate, spec)
+        if validation is None:
+            return None
+        solution = validation.solution
+        endpoint = f"mathir-solution:{solution.numerator}/{solution.denominator}"
+        return VerifiedExplorationIdentity(
+            verifier,
+            endpoint,
+            validation.route_signature,
+        )
+    if verifier == PYTHON_FACTOR_VERIFIER:
+        validation = validate_python_factor_function_external(candidate, spec)
+        if validation is None:
+            return None
+        try:
+            route = python_factor_route_signature(candidate)
+        except Exception:
+            return None
+        return VerifiedExplorationIdentity(
+            verifier,
+            validation.canonical_key,
+            route,
+        )
+    if verifier == PANTRY_PLAN_VERIFIER:
+        validation = validate_pantry_plan(candidate, spec)
+        if validation is None:
+            return None
+        return VerifiedExplorationIdentity(
+            verifier,
+            validation.canonical_key,
+            None,
+        )
+    if verifier in {POINT_MAZE_VERIFIER, ANT_MAZE_VERIFIER}:
+        validation = validate_maze_action_program_external(candidate, spec)
+        if validation is None:
+            return None
+        return VerifiedExplorationIdentity(
+            verifier,
+            f"{verifier}:goal:{spec.get('map_id')}",
+            validation.canonical_key,
+        )
+    if verifier != "countdown":
+        return None
+    try:
+        target = Fraction(int(spec["target"]), 1)
+        expected_numbers = Counter(int(value) for value in spec["numbers"])
+    except Exception:
+        return None
+    text = _normalize_countdown_expression(candidate)
+    parts = [part.strip() for part in text.split("=") if part.strip()] or [text]
+    for part in parts:
+        if not re.fullmatch(r"[0-9+\-*/().\s*]+", part):
+            continue
+        try:
+            parsed = ast.parse(part, mode="eval")
+            value, used_numbers = _countdown_eval_and_numbers(parsed)
+            if value != target or Counter(used_numbers) != expected_numbers:
+                continue
+            endpoint = f"countdown-value:{value.numerator}/{value.denominator}"
+            route = "countdown-route:v1:" + _canonical_countdown_route_ast(parsed)
+            return VerifiedExplorationIdentity(verifier, endpoint, route)
+        except Exception:
+            continue
+    return None
+
+
+def _grade_modebench_answer(model_answer: str, gt_answer: Any) -> bool | None:
+    spec = _parse_modebench_spec(gt_answer)
+    if spec is None:
+        return None
+    verifier = str(spec.get("verifier"))
+    if verifier == "graph_coloring":
+        return _verify_graph_coloring_answer(model_answer, spec)
+    if verifier == "countdown":
+        return _verify_countdown_expression(model_answer, spec)
+    if verifier == MATHIR_VERIFIER:
+        return validate_mathir_algebra(model_answer, spec) is not None
+    if verifier == MATHIR_MENU_VERIFIER:
+        return validate_mathir_action_menu(model_answer, spec) is not None
+    if verifier == PYTHON_FACTOR_VERIFIER:
+        return validate_python_factor_function_external(model_answer, spec) is not None
+    if verifier == PANTRY_PLAN_VERIFIER:
+        return validate_pantry_plan(model_answer, spec) is not None
+    if verifier in {POINT_MAZE_VERIFIER, ANT_MAZE_VERIFIER}:
+        return validate_maze_action_program_external(model_answer, spec) is not None
+    return False
+
+
+def _clean_final_answer_candidate(candidate: str | None) -> str | None:
+    """Return a compact final-answer candidate, or ``None`` for malformed text."""
+
+    if candidate is None:
+        return None
+    candidate = str(candidate).strip()
+    if not candidate:
+        return None
+    # Answer identity is deliberately stricter than correctness grading: mode
+    # metrics need one stable, compact key per formatted final answer.
+    if "\n" in candidate or "\r" in candidate or "<" in candidate or ">" in candidate:
+        return None
+    if len(candidate) > 160:
+        return None
+    candidate = re.sub(
+        r"^\s*(?:the\s+)?(?:final\s+)?answer\s*(?:is|=|:)\s*",
+        "",
+        candidate,
+        flags=re.IGNORECASE,
+    ).strip()
+    return candidate or None
+
+
+def _extract_r1_reasoning_and_answer_sections(
+    model_response: str,
+) -> tuple[str | None, str | None]:
+    """Return ``(<think> body, <answer> body)`` for an R1-style trace.
+
+    Training prompts already end inside an open ``<think>`` tag, so many model
+    responses begin with reasoning text and only emit the closing ``</think>``
+    before ``<answer>``. We accept both:
+
+    1. full tagged traces containing ``<think>...</think><answer>...</answer>``
+    2. response-only continuations containing ``... </think> <answer>...</answer>``
+    """
+
+    if "<answer>" not in model_response or "</answer>" not in model_response:
+        return None, None
+    try:
+        prefix, answer_suffix = model_response.split("<answer>", 1)
+        answer = answer_suffix.split("</answer>", 1)[0].strip()
+        reasoning = None
+        if "<think>" in prefix and "</think>" in prefix:
+            reasoning = prefix.split("<think>", 1)[1].split("</think>", 1)[0].strip()
+        elif "</think>" in prefix:
+            reasoning = prefix.split("</think>", 1)[0].strip()
+        else:
+            return None, None
+        answer = answer
+    except Exception:
+        return None, None
+    return reasoning or None, answer or None
+
+
+def extract_normalized_final_answer(
+    model_response: str, *, template: str = "r1", gt_answer: Any = None
+) -> str | None:
+    """Return a conservative canonical key for an answer or exact benchmark mode."""
+
+    try:
+        if gt_answer is not None:
+            if _parse_modebench_spec(gt_answer) is not None:
+                return _modebench_answer_key(
+                    model_response,
+                    gt_answer,
+                )
+            modebench_key = _modebench_answer_key(
+                model_response,
+                gt_answer,
+            )
+            if modebench_key is not None:
+                return modebench_key
+        candidate = None
+        if template == "r1":
+            # Match the training reward's strict R1 formatting gate.
+            _, candidate = _extract_r1_reasoning_and_answer_sections(model_response)
+            if candidate is None:
+                return None
+        else:
+            candidate = extract_answer(model_response)
+        if candidate is None:
+            return None
+        extracted = extract_answer(candidate) if "\\boxed" in candidate else candidate
+        extracted = _clean_final_answer_candidate(extracted)
+        if extracted is None:
+            return None
+        normalized = normalize_final_answer(extracted)
+        normalized = _normalize(normalized)
+        if normalized is None:
+            normalized = normalize_final_answer(extracted)
+        if normalized is None:
+            return None
+        normalized = str(normalized).strip().lower()
+        return normalized or None
+    except Exception:
+        return None
+
+
+def grade(model_answer: str, gt_answer: str, fast: bool = True):
+    if "\\boxed" in gt_answer:
+        gt_answer = extract_answer(gt_answer)
+    correct = grade_answer_mathd(model_answer, gt_answer) or grade_answer_sympy(
+        model_answer, gt_answer
+    )
+    if not fast:
+        # This mode further uses math_verify to recall originally false positives.
+        # Will be a bit slower, and sensitive to bad inputs.
+        correct = correct or is_latex_equal(
+            model_answer,
+            gt_answer,
+        )
+    return correct
+
+
+def boxed_reward_fn(model_response, gt_answer, fast=False):
+    model_answer = _extract_modebench_candidate(model_response, gt_answer)
+    if model_answer is not None:
+        modebench_correct = _grade_modebench_answer(model_answer, gt_answer)
+        if modebench_correct is not None:
+            return {"formatted": True}, 1.0 if modebench_correct else 0.0
+    model_answer = extract_answer(model_response)
+    if model_answer is None:
+        return {"formatted": False}, 0.0  # Cannot even parse anything.
+    modebench_correct = _grade_modebench_answer(model_answer, gt_answer)
+    if modebench_correct is not None:
+        return {"formatted": True}, 1.0 if modebench_correct else 0.0
+    if isinstance(gt_answer, float) or isinstance(gt_answer, int):
+        gt_answer = str(gt_answer)
+    if isinstance(gt_answer, str):
+        is_correct = grade(model_answer, gt_answer, fast)
+    elif isinstance(gt_answer, list):
+        is_correct = False
+        for gt in gt_answer:
+            is_correct |= grade(model_answer, gt, fast)
+    if is_correct:
+        return {"formatted": True}, 1.0  # Correctness reward.
+    else:
+        return {
+            "formatted": True
+        }, 0.0  # Formatted but wrong answer; no format reward to avoid hacking.
+
+
+def validated_math_route_signature(
+    model_response: str,
+    problem: str,
+    gt_answer: Any,
+    *,
+    fast: bool = False,
+    task_verified: bool | None = None,
+) -> str | None:
+    """Return an executable route identity only for a task-correct response.
+
+    Task correctness, route execution, and agreement between the trace terminal
+    value and the response's boxed answer are independent fail-closed checks.
+    A correct answer without a valid trace keeps its ordinary task reward but
+    has no route identity.
+    """
+
+    try:
+        if task_verified is None:
+            _info, reward = boxed_reward_fn(
+                model_response,
+                gt_answer,
+                fast=fast,
+            )
+            task_verified = float(reward) > 0.0
+        if not bool(task_verified):
+            return None
+        validation = validate_math_route_response(model_response, problem)
+        if validation is None:
+            return None
+        model_answer = extract_answer(model_response)
+        if model_answer is None:
+            return None
+        terminal_answer = sympy.latex(validation.terminal_value)
+        if not grade(model_answer, terminal_answer, fast=fast):
+            return None
+        return validation.route_signature
+    except Exception:
+        return None
+
+
+def validated_exploration_identity(
+    model_response: str,
+    problem: str,
+    gt_answer: Any,
+    *,
+    fast: bool = False,
+    task_verified: bool | None = None,
+) -> VerifiedExplorationIdentity | None:
+    """Return the endpoint/route pair for ModeBench or free-form MATH.
+
+    ModeBench references always remain on their exact executable validator
+    path. Free-form MATH may reuse the actor's already-computed task verdict,
+    but route admission still independently executes the restricted trace and
+    checks its terminal value against the boxed response. Thus a task-correct
+    response without a valid route retains an endpoint identity and ordinary
+    reward while contributing no route identity.
+    """
+
+    if _parse_modebench_spec(gt_answer) is not None:
+        return validated_modebench_exploration_identity(
+            model_response,
+            gt_answer,
+        )
+    try:
+        if task_verified is None:
+            _info, reward = boxed_reward_fn(
+                model_response,
+                gt_answer,
+                fast=fast,
+            )
+            task_verified = float(reward) > 0.0
+        if not bool(task_verified):
+            return None
+        endpoint = extract_normalized_final_answer(
+            model_response,
+            template="qwen_math_route",
+            gt_answer=gt_answer,
+        )
+        if endpoint is None:
+            return None
+        route = validated_math_route_signature(
+            model_response,
+            problem,
+            gt_answer,
+            fast=fast,
+            task_verified=True,
+        )
+        return VerifiedExplorationIdentity(
+            verifier="math_verify",
+            endpoint_key=f"math-answer:{endpoint}",
+            route_signature=route,
+        )
+    except Exception:
+        return None
+
+
+def answer_tag_reward_fn(model_response, gt_answer, fast=False):
+    # We are strict about format to evaluate our models.
+    if "</think> <answer>" in model_response and "</answer>" in model_response:
+        model_answer = model_response.split("<answer>")[-1].replace("</answer>", "")
+        if "\\boxed" in model_answer:
+            model_answer = extract_answer(model_answer)
+            if model_answer is None:
+                return {"formatted": True}, 0.0
+        modebench_plain_answer = _extract_modebench_candidate(model_answer, gt_answer)
+        if modebench_plain_answer is not None:
+            model_answer = modebench_plain_answer
+        modebench_correct = _grade_modebench_answer(model_answer, gt_answer)
+        if modebench_correct is not None:
+            return {"formatted": True}, 1.0 if modebench_correct else 0.0
+        if isinstance(gt_answer, float) or isinstance(gt_answer, int):
+            gt_answer = str(gt_answer)
+        if isinstance(gt_answer, str):
+            is_correct = grade(model_answer, gt_answer, fast)
+        elif isinstance(gt_answer, list):
+            is_correct = False
+            for gt in gt_answer:
+                is_correct |= grade(model_answer, gt, fast)
+        if is_correct:
+            return {"formatted": True}, 1.0  # Correctness reward.
+        else:
+            return (
+                {"formatted": True},
+                0.0,
+            )  # Formatted but wrong answer; no format reward to avoid hacking.
+    else:
+        return {"formatted": False}, 0.0  # Unformatted.
+
+
+def answer_tag_reward_fn_for_orz(model_response, gt_answer, fast=False):
+    # We are a bit less strict for baselines.
+    if "<answer>" in model_response and "</answer>" in model_response:
+        model_answer = model_response.split("<answer>")[-1].replace("</answer>", "")
+        if "\\boxed" in model_answer:
+            model_answer = extract_answer(model_answer)
+            if model_answer is None:
+                return {"formatted": True}, 0.0
+        modebench_plain_answer = _extract_modebench_candidate(model_answer, gt_answer)
+        if modebench_plain_answer is not None:
+            model_answer = modebench_plain_answer
+        modebench_correct = _grade_modebench_answer(model_answer, gt_answer)
+        if modebench_correct is not None:
+            return {"formatted": True}, 1.0 if modebench_correct else 0.0
+        if isinstance(gt_answer, float) or isinstance(gt_answer, int):
+            gt_answer = str(gt_answer)
+        if isinstance(gt_answer, str):
+            is_correct = grade(model_answer, gt_answer, fast)
+        elif isinstance(gt_answer, list):
+            is_correct = False
+            for gt in gt_answer:
+                is_correct |= grade(model_answer, gt, fast)
+        if is_correct:
+            return {"formatted": True}, 1.0  # Correctness reward.
+        else:
+            return (
+                {"formatted": True},
+                0.0,
+            )  # Formatted but wrong answer; no format reward to avoid hacking.
+    else:
+        return {"formatted": False}, 0.0  # Unformatted.

code/oat_drgrpo/math_route.py

@@ -0,0 +1,458 @@
+"""Fail-closed executable route traces for answer-verified free-form math.
+
+The trace is deliberately separate from the natural-language derivation and
+from the boxed answer. It contains only references and operations; it never
+contains model-declared intermediate results. Numeric leaves must be grounded
+in the problem text, every operation is executed exactly, and every trace node
+must contribute to the terminal value.
+
+This validator establishes a checkable computational route, not a proof that
+the route's modeling assumptions follow from the prose problem. Ordinary MATH
+answer verification remains a separate mandatory admission condition.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass
+from fractions import Fraction
+import json
+import math
+import re
+from typing import Any, Mapping
+
+import sympy
+
+
+MATH_ROUTE_VERSION = "math-route-v1"
+MATH_ROUTE_RPN_VERSION = "math-route-rpn-v2"
+_MAX_TRACE_CHARS = 4_096
+_MAX_STEPS = 20
+_MAX_ARGS = 6
+_MAX_INTEGER_BITS = 512
+_ID_RE = re.compile(r"s[1-9][0-9]?")
+_NUMBER_RE = re.compile(
+    r"(?<![\w.])-?\d+(?:,\d{3})*(?:\.\d+)?(?!\w)(?!\.\d)"
+)
+_SLASH_FRACTION_RE = re.compile(
+    r"(?<![\w.])(-?\d+(?:,\d{3})*)\s*/\s*(\d+(?:,\d{3})*)"
+    r"(?!\w)(?!\.\d)"
+)
+_LATEX_FRACTION_RE = re.compile(
+    r"\\(?:d?frac)\s*\{\s*(-?\d+(?:,\d{3})*)\s*\}"
+    r"\s*\{\s*(\d+(?:,\d{3})*)\s*\}"
+)
+_ROUTE_BLOCK_RE = re.compile(r"<route>(.*?)</route>", re.DOTALL)
+_COMMUTATIVE_OPS = frozenset({"add", "mul", "gcd", "lcm", "min", "max"})
+_UNARY_OPS = frozenset(
+    {"neg", "abs", "square", "cube", "sqrt", "factorial", "percent"}
+)
+_BINARY_OPS = frozenset(
+    {"sub", "div", "pow", "mod", "choose", "permute"}
+)
+_NARY_OPS = frozenset({"add", "mul", "gcd", "lcm", "min", "max", "average"})
+_ALLOWED_TOP_LEVEL = frozenset({"version", "steps", "final"})
+_ALLOWED_STEP_KEYS = frozenset({"id", "op", "args", "value"})
+_RPN_UNARY_OPS = {
+    "neg": "neg",
+    "abs": "abs",
+    "square": "square",
+    "cube": "cube",
+    "sqrt": "sqrt",
+    "factorial": "factorial",
+    "percent": "percent",
+}
+_RPN_BINARY_OPS = {
+    "add": "add",
+    "mul": "mul",
+    "sub": "sub",
+    "div": "div",
+    "pow": "pow",
+    "mod": "mod",
+    "choose": "choose",
+    "permute": "permute",
+    "gcd": "gcd",
+    "lcm": "lcm",
+    "min": "min",
+    "max": "max",
+    "average": "average",
+}
+
+
+@dataclass(frozen=True)
+class MathRouteValidation:
+    route_signature: str
+    terminal_value: sympy.Expr
+    operations: tuple[str, ...]
+    step_count: int
+    source_count: int
+
+
+class MathRouteError(ValueError):
+    """Raised for a malformed, ungrounded, or non-executable trace."""
+
+
+def _fraction(text: str) -> Fraction:
+    compact = str(text).replace(",", "").strip()
+    if re.fullmatch(r"-?\d+", compact):
+        return Fraction(int(compact), 1)
+    if re.fullmatch(r"-?\d+/\d+", compact):
+        numerator, denominator = compact.split("/", 1)
+        if int(denominator) == 0:
+            raise MathRouteError("zero denominator")
+        return Fraction(int(numerator), int(denominator))
+    if re.fullmatch(r"-?\d+\.\d+", compact):
+        return Fraction(compact)
+    raise MathRouteError("source values must be exact integers, decimals, or fractions")
+
+
+def problem_number_inventory(problem: str) -> Counter[Fraction]:
+    """Return exact numeric leaves present in problem text, with multiplicity."""
+
+    text = str(problem)
+    inventory: Counter[Fraction] = Counter()
+
+    def consume_latex(match: re.Match[str]) -> str:
+        numerator, denominator = match.groups()
+        inventory[Fraction(int(numerator.replace(",", "")), int(denominator.replace(",", "")))] += 1
+        return " "
+
+    def consume_slash(match: re.Match[str]) -> str:
+        numerator, denominator = match.groups()
+        inventory[Fraction(int(numerator.replace(",", "")), int(denominator.replace(",", "")))] += 1
+        return " "
+
+    text = _LATEX_FRACTION_RE.sub(consume_latex, text)
+    text = _SLASH_FRACTION_RE.sub(consume_slash, text)
+    for match in _NUMBER_RE.finditer(text):
+        inventory[_fraction(match.group(0))] += 1
+    return inventory
+
+
+def extract_math_route_block(model_response: str) -> str | None:
+    matches = _ROUTE_BLOCK_RE.findall(str(model_response))
+    if len(matches) != 1:
+        return None
+    block = matches[0].strip()
+    if not block or len(block) > _MAX_TRACE_CHARS:
+        return None
+    return block
+
+
+def _exact_integer(value: sympy.Expr, *, name: str) -> int:
+    simplified = sympy.simplify(value)
+    if not simplified.is_Integer:
+        raise MathRouteError(f"{name} requires an exact integer")
+    integer = int(simplified)
+    if abs(integer).bit_length() > _MAX_INTEGER_BITS:
+        raise MathRouteError(f"{name} integer is too large")
+    return integer
+
+
+def _bounded(value: sympy.Expr) -> sympy.Expr:
+    simplified = sympy.simplify(value)
+    if simplified.has(
+        sympy.nan,
+        sympy.zoo,
+        sympy.oo,
+        -sympy.oo,
+        sympy.I,
+    ):
+        raise MathRouteError("operation produced a non-finite or complex value")
+    if len(str(simplified)) > 1_024 or int(sympy.count_ops(simplified)) > 128:
+        raise MathRouteError("operation result is too large")
+    for atom in simplified.atoms(sympy.Integer):
+        if abs(int(atom)).bit_length() > _MAX_INTEGER_BITS:
+            raise MathRouteError("operation result integer is too large")
+    return simplified
+
+
+def _execute_operation(op: str, arguments: tuple[sympy.Expr, ...]) -> sympy.Expr:
+    if op in _UNARY_OPS and len(arguments) != 1:
+        raise MathRouteError(f"{op} requires one argument")
+    if op in _BINARY_OPS and len(arguments) != 2:
+        raise MathRouteError(f"{op} requires two arguments")
+    if op in _NARY_OPS and not 2 <= len(arguments) <= _MAX_ARGS:
+        raise MathRouteError(f"{op} requires two to {_MAX_ARGS} arguments")
+    if op == "neg":
+        result = -arguments[0]
+    elif op == "abs":
+        result = sympy.Abs(arguments[0])
+    elif op == "square":
+        result = arguments[0] ** 2
+    elif op == "cube":
+        result = arguments[0] ** 3
+    elif op == "sqrt":
+        if arguments[0].is_nonnegative is not True:
+            raise MathRouteError("sqrt requires a provably nonnegative argument")
+        result = sympy.sqrt(arguments[0])
+    elif op == "factorial":
+        integer = _exact_integer(arguments[0], name=op)
+        if not 0 <= integer <= 100:
+            raise MathRouteError("factorial input is outside [0,100]")
+        result = sympy.factorial(integer)
+    elif op == "percent":
+        result = arguments[0] / 100
+    elif op == "add":
+        result = sum(arguments, sympy.Integer(0))
+    elif op == "mul":
+        result = math.prod(arguments, start=sympy.Integer(1))
+    elif op == "sub":
+        result = arguments[0] - arguments[1]
+    elif op == "div":
+        if sympy.simplify(arguments[1]) == 0:
+            raise MathRouteError("division by zero")
+        result = arguments[0] / arguments[1]
+    elif op == "pow":
+        exponent = _exact_integer(arguments[1], name=op)
+        if not -12 <= exponent <= 12:
+            raise MathRouteError("power exponent is outside [-12,12]")
+        if arguments[0] == 0 and exponent < 0:
+            raise MathRouteError("zero to a negative power")
+        result = arguments[0] ** exponent
+    elif op == "mod":
+        left = _exact_integer(arguments[0], name=op)
+        right = _exact_integer(arguments[1], name=op)
+        if right == 0:
+            raise MathRouteError("modulo by zero")
+        result = sympy.Integer(left % right)
+    elif op == "choose":
+        n = _exact_integer(arguments[0], name=op)
+        k = _exact_integer(arguments[1], name=op)
+        if not 0 <= k <= n <= 10_000:
+            raise MathRouteError("choose inputs are outside 0 <= k <= n <= 10000")
+        result = sympy.binomial(n, k)
+    elif op == "permute":
+        n = _exact_integer(arguments[0], name=op)
+        k = _exact_integer(arguments[1], name=op)
+        if not 0 <= k <= n <= 1_000:
+            raise MathRouteError("permute inputs are outside 0 <= k <= n <= 1000")
+        result = sympy.factorial(n) / sympy.factorial(n - k)
+    elif op in {"gcd", "lcm"}:
+        integers = [_exact_integer(argument, name=op) for argument in arguments]
+        function = math.gcd if op == "gcd" else math.lcm
+        result = sympy.Integer(function(*integers))
+    elif op == "min":
+        if not all(argument.is_real is True for argument in arguments):
+            raise MathRouteError("min requires real arguments")
+        result = sympy.Min(*arguments)
+    elif op == "max":
+        if not all(argument.is_real is True for argument in arguments):
+            raise MathRouteError("max requires real arguments")
+        result = sympy.Max(*arguments)
+    elif op == "average":
+        result = sum(arguments, sympy.Integer(0)) / len(arguments)
+    else:
+        raise MathRouteError(f"unsupported route operation {op!r}")
+    return _bounded(result)
+
+
+def _signature(op: str, argument_signatures: tuple[str, ...]) -> str:
+    children = (
+        tuple(sorted(argument_signatures))
+        if op in _COMMUTATIVE_OPS
+        else argument_signatures
+    )
+    return f"{op}({','.join(children)})"
+
+
+def validate_math_route_trace(
+    trace: str | Mapping[str, Any],
+    problem: str,
+) -> MathRouteValidation | None:
+    """Parse and execute a grounded route trace; return ``None`` on any failure."""
+
+    try:
+        parsed = json.loads(trace) if isinstance(trace, str) else dict(trace)
+        if not isinstance(parsed, dict) or set(parsed) != _ALLOWED_TOP_LEVEL:
+            raise MathRouteError("route object has missing or extra fields")
+        if parsed["version"] != MATH_ROUTE_VERSION:
+            raise MathRouteError("unsupported route version")
+        raw_steps = parsed["steps"]
+        if not isinstance(raw_steps, list) or not 2 <= len(raw_steps) <= _MAX_STEPS:
+            raise MathRouteError("route has an invalid number of steps")
+        final_id = str(parsed["final"])
+        if _ID_RE.fullmatch(final_id) is None:
+            raise MathRouteError("invalid final node ID")
+
+        inventory = problem_number_inventory(problem)
+        values: dict[str, sympy.Expr] = {}
+        signatures: dict[str, str] = {}
+        dependencies: dict[str, tuple[str, ...]] = {}
+        operations: list[str] = []
+        source_count = 0
+        non_source_count = 0
+        for expected_index, raw_step in enumerate(raw_steps, start=1):
+            if not isinstance(raw_step, dict):
+                raise MathRouteError("route step must be an object")
+            if not set(raw_step).issubset(_ALLOWED_STEP_KEYS):
+                raise MathRouteError("route step has extra fields")
+            step_id = str(raw_step.get("id", ""))
+            if step_id != f"s{expected_index}" or step_id in values:
+                raise MathRouteError("route node IDs must be contiguous and ordered")
+            op = str(raw_step.get("op", ""))
+            if op == "source":
+                if set(raw_step) != {"id", "op", "value"}:
+                    raise MathRouteError("source step schema is invalid")
+                value = _fraction(str(raw_step["value"]))
+                if inventory[value] <= 0:
+                    raise MathRouteError("source value is not available in the problem")
+                inventory[value] -= 1
+                values[step_id] = sympy.Rational(value.numerator, value.denominator)
+                signatures[step_id] = "input"
+                dependencies[step_id] = ()
+                source_count += 1
+                operations.append(op)
+                continue
+
+            if set(raw_step) != {"id", "op", "args"}:
+                raise MathRouteError("operation step schema is invalid")
+            raw_args = raw_step["args"]
+            if not isinstance(raw_args, list):
+                raise MathRouteError("operation args must be a list")
+            argument_ids = tuple(str(argument) for argument in raw_args)
+            if (
+                not argument_ids
+                or len(argument_ids) > _MAX_ARGS
+                or len(set(argument_ids)) != len(argument_ids)
+                or any(argument_id not in values for argument_id in argument_ids)
+            ):
+                raise MathRouteError("operation dependencies are invalid")
+            arguments = tuple(values[argument_id] for argument_id in argument_ids)
+            values[step_id] = _execute_operation(op, arguments)
+            signatures[step_id] = _signature(
+                op,
+                tuple(signatures[argument_id] for argument_id in argument_ids),
+            )
+            dependencies[step_id] = argument_ids
+            operations.append(op)
+            non_source_count += 1
+
+        if final_id not in values or non_source_count < 1 or source_count < 1:
+            raise MathRouteError("route lacks a computed terminal value")
+        reachable = {final_id}
+        frontier = [final_id]
+        while frontier:
+            node = frontier.pop()
+            for dependency in dependencies[node]:
+                if dependency not in reachable:
+                    reachable.add(dependency)
+                    frontier.append(dependency)
+        if reachable != set(values):
+            raise MathRouteError("every route node must contribute to the final value")
+        return MathRouteValidation(
+            route_signature=(
+                f"math-route:{MATH_ROUTE_VERSION}:{signatures[final_id]}"
+            ),
+            terminal_value=values[final_id],
+            operations=tuple(operations),
+            step_count=len(values),
+            source_count=source_count,
+        )
+    except Exception:
+        return None
+
+
+def validate_math_route_rpn(
+    trace: str,
+    problem: str,
+) -> MathRouteValidation | None:
+    """Execute the compact v2 reverse-Polish route language.
+
+    Numeric tokens are grounded problem leaves. Unary and binary operator
+    tokens consume the stack, so a successful one-item terminal stack also
+    proves that every emitted token contributes to the final value. The
+    language has no result literals, variable names, prose, or code execution.
+    """
+
+    try:
+        compact = str(trace).strip()
+        if not compact or len(compact) > 1_024:
+            raise MathRouteError("RPN route is empty or too long")
+        tokens = compact.split()
+        if not tokens or tokens[0] not in {
+            "v2",
+            MATH_ROUTE_RPN_VERSION,
+        }:
+            raise MathRouteError("unsupported RPN route version")
+        tokens = tokens[1:]
+        if not 2 <= len(tokens) <= 40:
+            raise MathRouteError("RPN route has an invalid token count")
+
+        inventory = problem_number_inventory(problem)
+        stack: list[tuple[sympy.Expr, str]] = []
+        operations: list[str] = []
+        source_count = 0
+        operation_count = 0
+        for token in tokens:
+            if token in _RPN_UNARY_OPS:
+                if len(stack) < 1:
+                    raise MathRouteError("RPN unary operation underflow")
+                argument_value, argument_signature = stack.pop()
+                op = _RPN_UNARY_OPS[token]
+                stack.append(
+                    (
+                        _execute_operation(op, (argument_value,)),
+                        _signature(op, (argument_signature,)),
+                    )
+                )
+                operations.append(op)
+                operation_count += 1
+                continue
+            if token in _RPN_BINARY_OPS:
+                if len(stack) < 2:
+                    raise MathRouteError("RPN binary operation underflow")
+                right_value, right_signature = stack.pop()
+                left_value, left_signature = stack.pop()
+                op = _RPN_BINARY_OPS[token]
+                stack.append(
+                    (
+                        _execute_operation(op, (left_value, right_value)),
+                        _signature(op, (left_signature, right_signature)),
+                    )
+                )
+                operations.append(op)
+                operation_count += 1
+                continue
+
+            value = _fraction(token)
+            if inventory[value] <= 0:
+                raise MathRouteError("RPN source value is not available in the problem")
+            inventory[value] -= 1
+            stack.append(
+                (
+                    sympy.Rational(value.numerator, value.denominator),
+                    "input",
+                )
+            )
+            operations.append("source")
+            source_count += 1
+
+        if len(stack) != 1 or source_count < 1 or operation_count < 1:
+            raise MathRouteError("RPN route lacks one computed terminal value")
+        terminal_value, terminal_signature = stack[0]
+        return MathRouteValidation(
+            route_signature=(
+                f"math-route:{MATH_ROUTE_RPN_VERSION}:{terminal_signature}"
+            ),
+            terminal_value=terminal_value,
+            operations=tuple(operations),
+            step_count=len(tokens),
+            source_count=source_count,
+        )
+    except Exception:
+        return None
+
+
+def validate_math_route_response(
+    model_response: str,
+    problem: str,
+) -> MathRouteValidation | None:
+    """Extract the response's unique route block and execute it."""
+
+    block = extract_math_route_block(model_response)
+    if block is None:
+        return None
+    if block.lstrip().startswith("{"):
+        return validate_math_route_trace(block, problem)
+    return validate_math_route_rpn(block, problem)

code/oat_drgrpo/mathir.py

@@ -0,0 +1,906 @@
+"""A small, fail-closed executable algebra language for canonical search.
+
+MathIR linear v0 is intentionally narrower than ordinary mathematical text.
+The model emits a semicolon-separated sequence of equation transformations,
+for example ``sub(b);div(a)``.  Every command is applied to both sides of the
+current equation and exact rational normalization happens after every step.
+
+The validator and canonicalizer share one execution path: a canonical strategy
+key is produced only from the normalized states created by a successful
+execution.  There is no parser for prose, LaTeX derivations, Python, or a
+model-supplied final answer.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass
+from fractions import Fraction
+from itertools import permutations
+import re
+from typing import Any, Iterable, Mapping
+
+import sympy
+
+
+MATHIR_VERIFIER = "mathir_algebra"
+MATHIR_VERSION = "linear-v0"
+MATHIR_MENU_VERIFIER = "mathir_action_menu"
+MATHIR_MENU_VERSION = "linear-menu-v1"
+MATHIR_ROUTE_VERSION = "linear-route-v1"
+_MAX_REFERENCE_SYMBOLS = 6
+_MAX_PROGRAM_STEPS = 4
+_MAX_PROGRAM_CHARS = 160
+_MAX_ARGUMENT_NODES = 11
+_MAX_ARGUMENT_DEPTH = 6
+_MAX_MENU_ACTIONS = 8
+_MODEL_OPERATORS = frozenset({"add", "sub", "mul", "div", "neg"})
+_COMMANDS = frozenset({"add", "sub", "mul", "div"})
+_TOKEN_RE = re.compile(r"[A-Za-z][A-Za-z0-9_]*|[(),;]")
+_MENU_ACTION_RE = re.compile(r"[A-H]")
+
+
+@dataclass(frozen=True)
+class Expr:
+    """A bounded MathIR expression.
+
+    ``const`` nodes are interpreter-internal exact rationals.  The model-side
+    parser never accepts numeric literals.
+    """
+
+    op: str
+    args: tuple["Expr", ...] = ()
+    value: str | Fraction | None = None
+
+
+@dataclass(frozen=True)
+class Command:
+    op: str
+    argument: Expr
+
+
+@dataclass(frozen=True)
+class EquationState:
+    lhs: Expr
+    rhs: Expr
+
+
+@dataclass(frozen=True)
+class MathIRValidation:
+    canonical_key: str
+    solution: Fraction
+    commands: tuple[Command, ...]
+    states: tuple[EquationState, ...]
+    action_ids: tuple[str, ...] = ()
+    route_signature: str = ""
+
+
+class MathIRError(ValueError):
+    """Raised for a malformed or invalid MathIR program."""
+
+
+class _ExpressionParser:
+    def __init__(
+        self,
+        tokens: list[str],
+        *,
+        allowed_symbols: frozenset[str],
+        allow_constants: bool,
+    ) -> None:
+        self.tokens = tokens
+        self.index = 0
+        self.allowed_symbols = allowed_symbols
+        self.allow_constants = bool(allow_constants)
+
+    def _take(self, expected: str | None = None) -> str:
+        if self.index >= len(self.tokens):
+            raise MathIRError("unexpected end of expression")
+        token = self.tokens[self.index]
+        if expected is not None and token != expected:
+            raise MathIRError(f"expected {expected!r}")
+        self.index += 1
+        return token
+
+    def parse(self, *, depth: int = 0) -> Expr:
+        if depth > _MAX_ARGUMENT_DEPTH:
+            raise MathIRError("expression nesting is too deep")
+        token = self._take()
+        if token in {"(", ")", ",", ";"}:
+            raise MathIRError("expected a symbol or operator")
+        if self.index < len(self.tokens) and self.tokens[self.index] == "(":
+            if token not in _MODEL_OPERATORS:
+                raise MathIRError(f"unsupported operator {token!r}")
+            self._take("(")
+            first = self.parse(depth=depth + 1)
+            if token == "neg":
+                self._take(")")
+                return Expr("neg", (first,))
+            self._take(",")
+            second = self.parse(depth=depth + 1)
+            self._take(")")
+            return Expr(token, (first, second))
+        if token in self.allowed_symbols:
+            return Expr("symbol", value=token)
+        if self.allow_constants and re.fullmatch(r"-?\d+(?:/\d+)?", token):
+            return Expr("const", value=Fraction(token))
+        raise MathIRError(f"unknown symbol {token!r}")
+
+
+def _tokenize(text: str) -> list[str]:
+    compact = re.sub(r"\s+", "", str(text))
+    if not compact:
+        raise MathIRError("empty MathIR text")
+    tokens = _TOKEN_RE.findall(compact)
+    if "".join(tokens) != compact:
+        raise MathIRError("unsupported MathIR character or numeric literal")
+    return tokens
+
+
+def parse_mathir_expression(
+    text: str,
+    *,
+    allowed_symbols: Iterable[str],
+) -> Expr:
+    """Parse one model-authored expression without using Python evaluation."""
+
+    tokens = _tokenize(text)
+    parser = _ExpressionParser(
+        tokens,
+        allowed_symbols=frozenset(str(symbol) for symbol in allowed_symbols),
+        allow_constants=False,
+    )
+    expression = parser.parse()
+    if parser.index != len(tokens):
+        raise MathIRError("trailing expression tokens")
+    if _expr_node_count(expression) > _MAX_ARGUMENT_NODES:
+        raise MathIRError("expression is too large")
+    return expression
+
+
+def _parse_trusted_expression(
+    text: str,
+    *,
+    allowed_symbols: Iterable[str],
+) -> Expr:
+    """Parse a dataset-owned formal expression.
+
+    Dataset expressions currently use no constants, but this separate entry
+    point makes the trust boundary explicit and permits exact rationals if a
+    later, versioned reference schema needs them.
+    """
+
+    tokens = _tokenize(text)
+    parser = _ExpressionParser(
+        tokens,
+        allowed_symbols=frozenset(str(symbol) for symbol in allowed_symbols),
+        allow_constants=True,
+    )
+    expression = parser.parse()
+    if parser.index != len(tokens):
+        raise MathIRError("trailing trusted-expression tokens")
+    if _expr_node_count(expression) > 31:
+        raise MathIRError("trusted expression is too large")
+    return expression
+
+
+def parse_mathir_program(
+    text: str,
+    *,
+    allowed_symbols: Iterable[str],
+    max_steps: int,
+) -> tuple[Command, ...]:
+    """Parse a bounded sequence such as ``sub(b);div(a)``."""
+
+    compact = re.sub(r"\s+", "", str(text))
+    if not compact or len(compact) > _MAX_PROGRAM_CHARS:
+        raise MathIRError("program is empty or too long")
+    # A final statement terminator is surface formatting, not a new action.
+    compact = compact[:-1] if compact.endswith(";") else compact
+    if not compact or compact.startswith(";") or ";;" in compact:
+        raise MathIRError("empty program command")
+    command_texts = compact.split(";")
+    if not 1 <= len(command_texts) <= int(max_steps):
+        raise MathIRError("program has an invalid number of commands")
+    commands: list[Command] = []
+    for command_text in command_texts:
+        match = re.fullmatch(r"([A-Za-z][A-Za-z0-9_]*)\((.*)\)", command_text)
+        if match is None:
+            raise MathIRError("commands must use op(expression) syntax")
+        op, argument_text = match.groups()
+        if op not in _COMMANDS:
+            raise MathIRError(f"unsupported command {op!r}")
+        argument = parse_mathir_expression(
+            argument_text,
+            allowed_symbols=allowed_symbols,
+        )
+        commands.append(Command(op, argument))
+    return tuple(commands)
+
+
+def _expr_node_count(expression: Expr) -> int:
+    return 1 + sum(_expr_node_count(argument) for argument in expression.args)
+
+
+def _expr_symbols(expression: Expr) -> set[str]:
+    if expression.op == "symbol":
+        assert isinstance(expression.value, str)
+        return {expression.value}
+    return set().union(*(_expr_symbols(argument) for argument in expression.args), set())
+
+
+def _fraction_from_reference(value: Any) -> Fraction:
+    if isinstance(value, bool):
+        raise MathIRError("boolean binding")
+    if isinstance(value, int):
+        return Fraction(value, 1)
+    if isinstance(value, str) and re.fullmatch(r"-?\d+(?:/[1-9]\d*)?", value.strip()):
+        return Fraction(value.strip())
+    raise MathIRError("bindings must be exact integers or rational strings")
+
+
+def _expr_to_sympy(expression: Expr) -> sympy.Expr:
+    if expression.op == "symbol":
+        assert isinstance(expression.value, str)
+        return sympy.Symbol(expression.value)
+    if expression.op == "const":
+        assert isinstance(expression.value, Fraction)
+        return sympy.Rational(expression.value.numerator, expression.value.denominator)
+    converted = tuple(_expr_to_sympy(argument) for argument in expression.args)
+    if expression.op == "add":
+        return converted[0] + converted[1]
+    if expression.op == "sub":
+        return converted[0] - converted[1]
+    if expression.op == "mul":
+        return converted[0] * converted[1]
+    if expression.op == "div":
+        return converted[0] / converted[1]
+    if expression.op == "neg":
+        return -converted[0]
+    if expression.op == "inv":
+        return sympy.Integer(1) / converted[0]
+    raise MathIRError(f"unsupported internal expression {expression.op!r}")
+
+
+def _fold(op: str, arguments: tuple[Expr, ...]) -> Expr:
+    if not arguments:
+        return Expr("const", value=Fraction(0 if op == "add" else 1, 1))
+    result = arguments[0]
+    for argument in arguments[1:]:
+        result = Expr(op, (result, argument))
+    return result
+
+
+def _expr_from_sympy(expression: sympy.Expr) -> Expr:
+    if expression.is_Symbol:
+        return Expr("symbol", value=str(expression))
+    if expression.is_Rational:
+        return Expr(
+            "const",
+            value=Fraction(int(expression.p), int(expression.q)),
+        )
+    if expression.is_Add:
+        return _fold(
+            "add",
+            tuple(_expr_from_sympy(argument) for argument in expression.args),
+        )
+    if expression.is_Mul:
+        return _fold(
+            "mul",
+            tuple(_expr_from_sympy(argument) for argument in expression.args),
+        )
+    if expression.is_Pow and expression.exp == -1:
+        return Expr("inv", (_expr_from_sympy(expression.base),))
+    raise MathIRError(f"normalizer produced unsupported expression {expression!r}")
+
+
+def _normalize_expr(expression: Expr) -> Expr:
+    symbolic = _expr_to_sympy(expression)
+    normalized = sympy.cancel(symbolic)
+    return _expr_from_sympy(normalized)
+
+
+def _canonical_parts(expression: Expr) -> tuple[str, ...]:
+    if expression.op not in {"add", "mul"}:
+        return (_canonical_expr(expression),)
+    parts: list[str] = []
+    for argument in expression.args:
+        converted = _canonicalized_expr(argument)
+        if converted.op == expression.op:
+            parts.extend(_canonical_parts(converted))
+        else:
+            parts.append(_canonical_expr(converted))
+    return tuple(sorted(parts))
+
+
+def _canonicalized_expr(expression: Expr) -> Expr:
+    if expression.op == "sub":
+        return Expr(
+            "add",
+            (
+                _canonicalized_expr(expression.args[0]),
+                Expr("neg", (_canonicalized_expr(expression.args[1]),)),
+            ),
+        )
+    if expression.op == "div":
+        return Expr(
+            "mul",
+            (
+                _canonicalized_expr(expression.args[0]),
+                Expr("inv", (_canonicalized_expr(expression.args[1]),)),
+            ),
+        )
+    return Expr(
+        expression.op,
+        tuple(_canonicalized_expr(argument) for argument in expression.args),
+        expression.value,
+    )
+
+
+def _canonical_expr(expression: Expr) -> str:
+    expression = _canonicalized_expr(expression)
+    if expression.op == "symbol":
+        assert isinstance(expression.value, str)
+        return expression.value
+    if expression.op == "const":
+        assert isinstance(expression.value, Fraction)
+        if expression.value.denominator == 1:
+            return str(expression.value.numerator)
+        return f"rat({expression.value.numerator},{expression.value.denominator})"
+    if expression.op in {"add", "mul"}:
+        return f"{expression.op}({','.join(_canonical_parts(expression))})"
+    if expression.op in {"neg", "inv"}:
+        return f"{expression.op}({_canonical_expr(expression.args[0])})"
+    raise MathIRError(f"cannot canonicalize {expression.op!r}")
+
+
+def _canonical_state(state: EquationState) -> str:
+    return f"eq({_canonical_expr(state.lhs)},{_canonical_expr(state.rhs)})"
+
+
+def _rename_expr_symbols(
+    expression: Expr,
+    symbol_map: Mapping[str, str],
+) -> Expr:
+    if expression.op == "symbol":
+        assert isinstance(expression.value, str)
+        return Expr(
+            "symbol",
+            value=symbol_map.get(expression.value, expression.value),
+        )
+    return Expr(
+        expression.op,
+        tuple(
+            _rename_expr_symbols(argument, symbol_map)
+            for argument in expression.args
+        ),
+        expression.value,
+    )
+
+
+def _alpha_canonical_route(
+    initial_state: EquationState,
+    commands: tuple[Command, ...],
+) -> str:
+    """Canonicalize a verified route independently of coefficient names.
+
+    At most six coefficient symbols are allowed by the reference schema, so a
+    small exhaustive alpha-renaming is simpler and safer than relying on
+    symbol-name or traversal-order heuristics. Numeric binding values never
+    enter this representation.
+    """
+
+    symbols = sorted(
+        (
+            _expr_symbols(initial_state.lhs)
+            | _expr_symbols(initial_state.rhs)
+            | set().union(
+                *(_expr_symbols(command.argument) for command in commands),
+                set(),
+            )
+        )
+        - {"x"}
+    )
+    roles = tuple(f"c{index}" for index in range(len(symbols)))
+    candidates: list[str] = []
+    for assigned_symbols in permutations(symbols):
+        symbol_map = {
+            symbol: role for symbol, role in zip(assigned_symbols, roles)
+        }
+        renamed_initial = EquationState(
+            _rename_expr_symbols(initial_state.lhs, symbol_map),
+            _rename_expr_symbols(initial_state.rhs, symbol_map),
+        )
+        command_parts = []
+        for command in commands:
+            renamed_argument = _rename_expr_symbols(
+                command.argument,
+                symbol_map,
+            )
+            command_parts.append(
+                f"{command.op}({_canonical_expr(renamed_argument)})"
+            )
+        candidates.append(
+            f"init={_canonical_state(renamed_initial)}"
+            f"|commands={'>'.join(command_parts)}"
+        )
+    if not candidates:
+        candidates.append(
+            f"init={_canonical_state(initial_state)}"
+            f"|commands={'>'.join(command.op for command in commands)}"
+        )
+    return f"mathir-route:{MATHIR_ROUTE_VERSION}:{min(candidates)}"
+
+
+def _validate_denominators(
+    expression: Expr,
+    *,
+    bindings: Mapping[str, Fraction],
+) -> None:
+    if expression.op == "div":
+        denominator = expression.args[1]
+        if "x" in _expr_symbols(denominator):
+            raise MathIRError("x-dependent denominators are not supported")
+        if _eval_fraction(denominator, bindings) == 0:
+            raise MathIRError("division by zero in command expression")
+    for argument in expression.args:
+        _validate_denominators(argument, bindings=bindings)
+
+
+def _eval_fraction(
+    expression: Expr,
+    bindings: Mapping[str, Fraction],
+) -> Fraction:
+    if expression.op == "symbol":
+        assert isinstance(expression.value, str)
+        if expression.value not in bindings:
+            raise MathIRError("cannot evaluate an expression containing x")
+        return bindings[expression.value]
+    if expression.op == "const":
+        assert isinstance(expression.value, Fraction)
+        return expression.value
+    values = tuple(_eval_fraction(argument, bindings) for argument in expression.args)
+    if expression.op == "add":
+        return values[0] + values[1]
+    if expression.op == "sub":
+        return values[0] - values[1]
+    if expression.op == "mul":
+        return values[0] * values[1]
+    if expression.op == "div":
+        if values[1] == 0:
+            raise MathIRError("division by zero")
+        return values[0] / values[1]
+    if expression.op == "neg":
+        return -values[0]
+    if expression.op == "inv":
+        if values[0] == 0:
+            raise MathIRError("division by zero")
+        return Fraction(1, 1) / values[0]
+    raise MathIRError(f"cannot evaluate {expression.op!r}")
+
+
+def _initial_solution(
+    state: EquationState,
+    *,
+    bindings: Mapping[str, Fraction],
+) -> Fraction:
+    x = sympy.Symbol("x")
+    substitutions = {
+        sympy.Symbol(name): sympy.Rational(value.numerator, value.denominator)
+        for name, value in bindings.items()
+    }
+    equation = sympy.cancel(
+        (_expr_to_sympy(state.lhs) - _expr_to_sympy(state.rhs)).subs(substitutions)
+    )
+    numerator, denominator = sympy.together(equation).as_numer_denom()
+    if x in denominator.free_symbols:
+        raise MathIRError("initial equation has an x-dependent denominator")
+    polynomial = sympy.Poly(sympy.expand(numerator), x)
+    if polynomial.degree() != 1:
+        raise MathIRError("initial equation is not uniquely linear")
+    coefficient = polynomial.coeff_monomial(x)
+    constant = polynomial.coeff_monomial(1)
+    if coefficient == 0:
+        raise MathIRError("initial equation has no unique solution")
+    solution = sympy.cancel(-constant / coefficient)
+    if not solution.is_Rational:
+        raise MathIRError("initial solution is not rational")
+    return Fraction(int(solution.p), int(solution.q))
+
+
+def _apply_command(
+    state: EquationState,
+    command: Command,
+    *,
+    bindings: Mapping[str, Fraction],
+) -> EquationState:
+    _validate_denominators(command.argument, bindings=bindings)
+    argument_symbols = _expr_symbols(command.argument)
+    if command.op in {"mul", "div"}:
+        if "x" in argument_symbols:
+            raise MathIRError("multiplication and division by x are not reversible")
+        if _eval_fraction(command.argument, bindings) == 0:
+            raise MathIRError("multiplication and division require a nonzero argument")
+    if command.op == "add":
+        lhs = Expr("add", (state.lhs, command.argument))
+        rhs = Expr("add", (state.rhs, command.argument))
+    elif command.op == "sub":
+        lhs = Expr("sub", (state.lhs, command.argument))
+        rhs = Expr("sub", (state.rhs, command.argument))
+    elif command.op == "mul":
+        lhs = Expr("mul", (state.lhs, command.argument))
+        rhs = Expr("mul", (state.rhs, command.argument))
+    elif command.op == "div":
+        lhs = Expr("div", (state.lhs, command.argument))
+        rhs = Expr("div", (state.rhs, command.argument))
+    else:
+        raise MathIRError(f"unsupported command {command.op!r}")
+    # This exact normalizer is part of the interpreter semantics, rather than
+    # model-authored text which could claim a simplification without doing it.
+    return EquationState(_normalize_expr(lhs), _normalize_expr(rhs))
+
+
+def _validated_reference(
+    spec: Mapping[str, Any],
+) -> tuple[EquationState, dict[str, Fraction], int]:
+    if spec.get("verifier") != MATHIR_VERIFIER:
+        raise MathIRError("wrong verifier")
+    if spec.get("mathir_version") != MATHIR_VERSION:
+        raise MathIRError("unsupported MathIR version")
+    raw_bindings = spec.get("bindings")
+    if not isinstance(raw_bindings, dict):
+        raise MathIRError("missing bindings")
+    if not 1 <= len(raw_bindings) <= _MAX_REFERENCE_SYMBOLS:
+        raise MathIRError("invalid number of bindings")
+    bindings: dict[str, Fraction] = {}
+    for raw_name, raw_value in raw_bindings.items():
+        name = str(raw_name)
+        if not re.fullmatch(r"[a-wyz]", name) or name == "x":
+            raise MathIRError("binding names must be single lowercase coefficient symbols")
+        bindings[name] = _fraction_from_reference(raw_value)
+    if len(bindings) != len(raw_bindings):
+        raise MathIRError("duplicate binding names")
+    max_steps = int(spec.get("max_steps", _MAX_PROGRAM_STEPS))
+    if not 1 <= max_steps <= _MAX_PROGRAM_STEPS:
+        raise MathIRError("invalid max_steps")
+    allowed_symbols = frozenset(bindings) | {"x"}
+    lhs = _parse_trusted_expression(
+        str(spec["initial_lhs"]),
+        allowed_symbols=allowed_symbols,
+    )
+    rhs = _parse_trusted_expression(
+        str(spec["initial_rhs"]),
+        allowed_symbols=allowed_symbols,
+    )
+    referenced_coefficients = (_expr_symbols(lhs) | _expr_symbols(rhs)) - {"x"}
+    if referenced_coefficients != set(bindings):
+        raise MathIRError("bindings and initial equation symbols disagree")
+    state = EquationState(_normalize_expr(lhs), _normalize_expr(rhs))
+    _initial_solution(state, bindings=bindings)
+    return state, bindings, max_steps
+
+
+def _execute_mathir_commands(
+    *,
+    initial_state: EquationState,
+    bindings: Mapping[str, Fraction],
+    commands: tuple[Command, ...],
+    key_version: str,
+    action_ids: tuple[str, ...] = (),
+) -> MathIRValidation:
+    target_solution = _initial_solution(initial_state, bindings=bindings)
+    seen = {_canonical_state(initial_state)}
+    states: list[EquationState] = []
+    state = initial_state
+    for command in commands:
+        state = _apply_command(state, command, bindings=bindings)
+        state_key = _canonical_state(state)
+        if state_key in seen:
+            raise MathIRError("program revisits a previous equation state")
+        seen.add(state_key)
+        states.append(state)
+
+    if state.lhs == Expr("symbol", value="x"):
+        final_expression = state.rhs
+    elif state.rhs == Expr("symbol", value="x"):
+        final_expression = state.lhs
+    else:
+        raise MathIRError("program does not finish with x isolated")
+    if "x" in _expr_symbols(final_expression):
+        raise MathIRError("final expression still contains x")
+    solution = _eval_fraction(final_expression, bindings)
+    if solution != target_solution:
+        raise MathIRError("executed program has the wrong solution")
+    canonical_key = (
+        f"mathir:{key_version}:"
+        + ">".join(_canonical_state(executed_state) for executed_state in states)
+    )
+    route_signature = _alpha_canonical_route(initial_state, commands)
+    return MathIRValidation(
+        canonical_key=canonical_key,
+        solution=solution,
+        commands=commands,
+        states=tuple(states),
+        action_ids=action_ids,
+        route_signature=route_signature,
+    )
+
+
+def validate_mathir_algebra(
+    program_text: str,
+    spec: Mapping[str, Any],
+) -> MathIRValidation | None:
+    """Execute and validate a MathIR program, returning its canonical path.
+
+    All failures return ``None``.  This function is the single admission
+    boundary used by both task reward and the online canonical bank.
+    """
+
+    try:
+        initial_state, bindings, max_steps = _validated_reference(spec)
+        allowed_symbols = frozenset(bindings) | {"x"}
+        commands = parse_mathir_program(
+            program_text,
+            allowed_symbols=allowed_symbols,
+            max_steps=max_steps,
+        )
+        return _execute_mathir_commands(
+            initial_state=initial_state,
+            bindings=bindings,
+            commands=commands,
+            key_version=MATHIR_VERSION,
+        )
+    except Exception:
+        return None
+
+
+def _validated_menu_reference(
+    spec: Mapping[str, Any],
+) -> tuple[
+    EquationState,
+    dict[str, Fraction],
+    int,
+    dict[str, Command],
+]:
+    if spec.get("verifier") != MATHIR_MENU_VERIFIER:
+        raise MathIRError("wrong menu verifier")
+    if spec.get("mathir_version") != MATHIR_MENU_VERSION:
+        raise MathIRError("unsupported menu MathIR version")
+    base_spec = dict(spec)
+    base_spec["verifier"] = MATHIR_VERIFIER
+    base_spec["mathir_version"] = MATHIR_VERSION
+    initial_state, bindings, max_steps = _validated_reference(base_spec)
+    raw_actions = spec.get("actions")
+    if not isinstance(raw_actions, dict):
+        raise MathIRError("missing action menu")
+    if not 2 <= len(raw_actions) <= _MAX_MENU_ACTIONS:
+        raise MathIRError("invalid action menu size")
+    expected_ids = [chr(ord("A") + index) for index in range(len(raw_actions))]
+    if list(raw_actions) != expected_ids:
+        raise MathIRError("action IDs must be contiguous and ordered")
+    allowed_symbols = frozenset(bindings) | {"x"}
+    actions: dict[str, Command] = {}
+    normalized_programs: set[str] = set()
+    for action_id, raw_program in raw_actions.items():
+        if _MENU_ACTION_RE.fullmatch(str(action_id)) is None:
+            raise MathIRError("invalid action ID")
+        program = re.sub(r"\s+", "", str(raw_program))
+        if program in normalized_programs:
+            raise MathIRError("duplicate action semantics")
+        parsed = parse_mathir_program(
+            program,
+            allowed_symbols=allowed_symbols,
+            max_steps=1,
+        )
+        if len(parsed) != 1:
+            raise MathIRError("each action must contain exactly one command")
+        normalized_programs.add(program)
+        actions[str(action_id)] = parsed[0]
+    return initial_state, bindings, max_steps, actions
+
+
+def parse_mathir_action_program(
+    text: str,
+    *,
+    action_ids: Iterable[str],
+    max_steps: int,
+) -> tuple[str, ...]:
+    """Parse a bounded sequence of prompt-local action IDs."""
+
+    compact = re.sub(r"\s+", "", str(text))
+    if not compact or len(compact) > _MAX_PROGRAM_CHARS:
+        raise MathIRError("action program is empty or too long")
+    compact = compact[:-1] if compact.endswith(";") else compact
+    if not compact or compact.startswith(";") or ";;" in compact:
+        raise MathIRError("empty action")
+    selected = tuple(compact.split(";"))
+    if not 1 <= len(selected) <= int(max_steps):
+        raise MathIRError("action program has an invalid number of steps")
+    allowed = frozenset(str(action_id) for action_id in action_ids)
+    if any(
+        _MENU_ACTION_RE.fullmatch(action_id) is None or action_id not in allowed
+        for action_id in selected
+    ):
+        raise MathIRError("unknown action ID")
+    return selected
+
+
+def validate_mathir_action_menu(
+    program_text: str,
+    spec: Mapping[str, Any],
+) -> MathIRValidation | None:
+    """Execute the exact prompt-local action sequence and key its state path."""
+
+    try:
+        initial_state, bindings, max_steps, actions = _validated_menu_reference(spec)
+        action_ids = parse_mathir_action_program(
+            program_text,
+            action_ids=actions,
+            max_steps=max_steps,
+        )
+        commands = tuple(actions[action_id] for action_id in action_ids)
+        return _execute_mathir_commands(
+            initial_state=initial_state,
+            bindings=bindings,
+            commands=commands,
+            key_version=MATHIR_MENU_VERSION,
+            action_ids=action_ids,
+        )
+    except Exception:
+        return None
+
+
+def enumerate_mathir_action_menu_keys(
+    spec: Mapping[str, Any],
+) -> set[str]:
+    """Exhaustively enumerate the bounded menu's distinct verified state paths."""
+
+    return {
+        validation.canonical_key
+        for validation in enumerate_mathir_action_menu_validations(spec)
+    }
+
+
+def _terminal_solution(
+    state: EquationState,
+    *,
+    bindings: Mapping[str, Fraction],
+    target_solution: Fraction,
+) -> Fraction | None:
+    if state.lhs == Expr("symbol", value="x"):
+        final_expression = state.rhs
+    elif state.rhs == Expr("symbol", value="x"):
+        final_expression = state.lhs
+    else:
+        return None
+    if "x" in _expr_symbols(final_expression):
+        return None
+    solution = _eval_fraction(final_expression, bindings)
+    return solution if solution == target_solution else None
+
+
+def enumerate_mathir_action_menu_validations(
+    spec: Mapping[str, Any],
+) -> tuple[MathIRValidation, ...]:
+    """Enumerate exact support while caching deterministic state transitions."""
+
+    initial_state, bindings, max_steps, actions = _validated_menu_reference(spec)
+    target_solution = _initial_solution(initial_state, bindings=bindings)
+    transition_cache: dict[
+        tuple[str, str], tuple[EquationState, str] | None
+    ] = {}
+    admitted: dict[str, MathIRValidation] = {}
+
+    def transition(
+        state: EquationState,
+        action_id: str,
+    ) -> tuple[EquationState, str] | None:
+        state_key = _canonical_state(state)
+        cache_key = (state_key, action_id)
+        if cache_key not in transition_cache:
+            try:
+                next_state = _apply_command(
+                    state,
+                    actions[action_id],
+                    bindings=bindings,
+                )
+                transition_cache[cache_key] = (
+                    next_state,
+                    _canonical_state(next_state),
+                )
+            except Exception:
+                transition_cache[cache_key] = None
+        return transition_cache[cache_key]
+
+    def visit(
+        state: EquationState,
+        *,
+        seen: frozenset[str],
+        commands: tuple[Command, ...],
+        action_ids: tuple[str, ...],
+        states: tuple[EquationState, ...],
+    ) -> None:
+        if len(commands) >= max_steps:
+            return
+        for action_id in actions:
+            result = transition(state, action_id)
+            if result is None:
+                continue
+            next_state, next_state_key = result
+            if next_state_key in seen:
+                continue
+            next_commands = commands + (actions[action_id],)
+            next_action_ids = action_ids + (action_id,)
+            next_states = states + (next_state,)
+            solution = _terminal_solution(
+                next_state,
+                bindings=bindings,
+                target_solution=target_solution,
+            )
+            if solution is not None:
+                canonical_key = (
+                    f"mathir:{MATHIR_MENU_VERSION}:"
+                    + ">".join(
+                        _canonical_state(executed_state)
+                        for executed_state in next_states
+                    )
+                )
+                admitted[canonical_key] = MathIRValidation(
+                    canonical_key=canonical_key,
+                    solution=solution,
+                    commands=next_commands,
+                    states=next_states,
+                    action_ids=next_action_ids,
+                    route_signature=_alpha_canonical_route(
+                        initial_state,
+                        next_commands,
+                    ),
+                )
+            visit(
+                next_state,
+                seen=seen | {next_state_key},
+                commands=next_commands,
+                action_ids=next_action_ids,
+                states=next_states,
+            )
+
+    initial_key = _canonical_state(initial_state)
+    visit(
+        initial_state,
+        seen=frozenset({initial_key}),
+        commands=(),
+        action_ids=(),
+        states=(),
+    )
+    return tuple(admitted[key] for key in sorted(admitted))
+
+
+def enumerate_mathir_action_menu_route_signatures(
+    spec: Mapping[str, Any],
+) -> set[str]:
+    """Exhaustively enumerate the menu's verified cross-prompt route support."""
+
+    return {
+        validation.route_signature
+        for validation in enumerate_mathir_action_menu_validations(spec)
+    }
+
+
+def certified_mathir_strategy_keys(
+    spec: Mapping[str, Any],
+    programs: Iterable[str],
+) -> set[str]:
+    """Validate a finite audit list without treating it as exhaustive support."""
+
+    keys: set[str] = set()
+    for program in programs:
+        validation = validate_mathir_algebra(program, spec)
+        if validation is None:
+            raise MathIRError(f"certified program failed validation: {program}")
+        keys.add(validation.canonical_key)
+    return keys
+
+
+def mathir_command_histogram(validation: MathIRValidation) -> Counter[str]:
+    """Small diagnostic helper used by audits and tests."""
+
+    return Counter(command.op for command in validation.commands)

code/oat_drgrpo/maze_modebench.py

@@ -0,0 +1,517 @@
+"""Verified language action programs for PointMaze and AntMaze.
+
+This module is deliberately simulator-independent. It validates the trusted
+episode specification, parses the LM's finite action alphabet, and derives a
+topological route key from a hash-bound successful execution record. MuJoCo
+remains outside the trainer process; its worker must return the trajectory and
+environment hashes consumed here.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import hashlib
+import json
+import math
+import re
+from typing import Any, Mapping, Sequence
+
+
+POINT_MAZE_VERIFIER = "point_maze_action_program"
+ANT_MAZE_VERIFIER = "ant_maze_action_program"
+MAZE_ACTION_VERSION = "maze-action-v1"
+ANT_MAZE_ACTION_VERSION = "maze-action-ant-v5"
+
+POINT_ACTIONS = ("N", "NE", "E", "SE", "S", "SW", "W", "NW", "COAST")
+ANT_ACTIONS = ("N", "NE", "E", "SE", "S", "SW", "W", "NW")
+
+_SHA256 = re.compile(r"[0-9a-f]{64}")
+_IDENTIFIER = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,95}")
+_GATE_ID = re.compile(r"[a-z][a-z0-9_-]{0,31}")
+_MAX_PROGRAM_CHARS = 4096
+
+
+class MazeModeBenchError(ValueError):
+    """Raised when a trusted maze spec or execution record is invalid."""
+
+
+@dataclass(frozen=True)
+class DirectedGate:
+    gate_id: str
+    axis: str
+    coordinate: float
+    span_min: float
+    span_max: float
+    hysteresis: float
+
+
+@dataclass(frozen=True)
+class MazeActionSpec:
+    verifier: str
+    environment_id: str
+    environment_sha256: str
+    controller_sha256: str | None
+    map_id: str
+    maze_map: tuple[tuple[int, ...], ...]
+    reset_cell: tuple[int, int]
+    goal_cell: tuple[int, int]
+    reset_seed: int
+    min_actions: int
+    max_actions: int
+    action_repeat: int
+    action_tokens: tuple[str, ...]
+    success_threshold: float
+    max_segment_length: float
+    bounds: tuple[tuple[float, float], tuple[float, float]]
+    gates: tuple[DirectedGate, ...]
+    spec_sha256: str
+
+
+@dataclass(frozen=True)
+class MazeExecutionRecord:
+    environment_sha256: str
+    controller_sha256: str | None
+    spec_sha256: str
+    reset_seed: int
+    action_tokens: tuple[str, ...]
+    success: bool
+    final_goal_distance: float
+    trajectory_xy: tuple[tuple[float, float], ...]
+    simulator_steps: int
+
+
+@dataclass(frozen=True)
+class MazeValidation:
+    canonical_key: str
+    directed_gates: tuple[str, ...]
+    action_tokens: tuple[str, ...]
+    simulator_steps: int
+
+
+def _finite_float(value: Any, *, label: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise MazeModeBenchError(f"{label} must be a finite number")
+    result = float(value)
+    if not math.isfinite(result):
+        raise MazeModeBenchError(f"{label} must be a finite number")
+    return result
+
+
+def _bounded_int(value: Any, *, label: str, minimum: int, maximum: int) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise MazeModeBenchError(f"{label} must be an integer")
+    result = int(value)
+    if not minimum <= result <= maximum:
+        raise MazeModeBenchError(f"{label} is outside [{minimum}, {maximum}]")
+    return result
+
+
+def _sha(value: Any, *, label: str) -> str:
+    result = str(value)
+    if _SHA256.fullmatch(result) is None:
+        raise MazeModeBenchError(f"{label} must be a lowercase SHA-256")
+    return result
+
+
+def _canonical_spec_sha256(spec: Mapping[str, Any]) -> str:
+    payload = dict(spec)
+    claimed = payload.pop("spec_sha256", None)
+    canonical = json.dumps(
+        payload,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    observed = hashlib.sha256(canonical).hexdigest()
+    if claimed is not None and claimed != observed:
+        raise MazeModeBenchError("spec_sha256 does not match the canonical spec")
+    return observed
+
+
+def _parse_bounds(value: Any) -> tuple[tuple[float, float], tuple[float, float]]:
+    if not isinstance(value, list) or len(value) != 2:
+        raise MazeModeBenchError("bounds_xy must contain x and y bounds")
+    parsed: list[tuple[float, float]] = []
+    for index, raw in enumerate(value):
+        if not isinstance(raw, list) or len(raw) != 2:
+            raise MazeModeBenchError(f"bounds_xy[{index}] must contain two values")
+        low = _finite_float(raw[0], label=f"bounds_xy[{index}][0]")
+        high = _finite_float(raw[1], label=f"bounds_xy[{index}][1]")
+        if low >= high:
+            raise MazeModeBenchError("each coordinate bound must be increasing")
+        parsed.append((low, high))
+    return parsed[0], parsed[1]
+
+
+def _parse_gates(value: Any) -> tuple[DirectedGate, ...]:
+    if not isinstance(value, list) or not 1 <= len(value) <= 32:
+        raise MazeModeBenchError("route_gates must contain between 1 and 32 gates")
+    gates: list[DirectedGate] = []
+    observed: set[str] = set()
+    for index, raw in enumerate(value):
+        if not isinstance(raw, Mapping):
+            raise MazeModeBenchError(f"route gate {index} must be an object")
+        gate_id = str(raw.get("id", ""))
+        if _GATE_ID.fullmatch(gate_id) is None:
+            raise MazeModeBenchError(f"route gate {index} has an invalid id")
+        if gate_id in observed:
+            raise MazeModeBenchError(f"duplicate route gate id {gate_id!r}")
+        observed.add(gate_id)
+        axis = str(raw.get("axis", ""))
+        if axis not in {"x", "y"}:
+            raise MazeModeBenchError(f"route gate {gate_id!r} has invalid axis")
+        coordinate = _finite_float(raw.get("coordinate"), label=f"{gate_id}.coordinate")
+        raw_span = raw.get("span")
+        if not isinstance(raw_span, list) or len(raw_span) != 2:
+            raise MazeModeBenchError(f"route gate {gate_id!r} needs a span")
+        span_min = _finite_float(raw_span[0], label=f"{gate_id}.span[0]")
+        span_max = _finite_float(raw_span[1], label=f"{gate_id}.span[1]")
+        if span_min >= span_max:
+            raise MazeModeBenchError(f"route gate {gate_id!r} span is not increasing")
+        hysteresis = _finite_float(raw.get("hysteresis"), label=f"{gate_id}.hysteresis")
+        if not 0.0 < hysteresis <= 0.25:
+            raise MazeModeBenchError(f"route gate {gate_id!r} hysteresis is invalid")
+        gates.append(
+            DirectedGate(
+                gate_id=gate_id,
+                axis=axis,
+                coordinate=coordinate,
+                span_min=span_min,
+                span_max=span_max,
+                hysteresis=hysteresis,
+            )
+        )
+    return tuple(gates)
+
+
+def _parse_maze_map(
+    value: Any,
+    reset_cell_value: Any,
+    goal_cell_value: Any,
+) -> tuple[tuple[tuple[int, ...], ...], tuple[int, int], tuple[int, int]]:
+    if not isinstance(value, list) or not 5 <= len(value) <= 16:
+        raise MazeModeBenchError("maze_map must contain between 5 and 16 rows")
+    width = len(value[0]) if isinstance(value[0], list) else 0
+    if not 5 <= width <= 16:
+        raise MazeModeBenchError("maze_map must contain between 5 and 16 columns")
+    rows: list[tuple[int, ...]] = []
+    for index, raw_row in enumerate(value):
+        if (
+            not isinstance(raw_row, list)
+            or len(raw_row) != width
+            or any(isinstance(cell, bool) or cell not in {0, 1} for cell in raw_row)
+        ):
+            raise MazeModeBenchError(f"maze_map row {index} is malformed")
+        rows.append(tuple(int(cell) for cell in raw_row))
+    if any(cell != 1 for cell in rows[0] + rows[-1]):
+        raise MazeModeBenchError("maze_map top and bottom borders must be walls")
+    if any(row[0] != 1 or row[-1] != 1 for row in rows):
+        raise MazeModeBenchError("maze_map left and right borders must be walls")
+
+    def parse_cell(raw: Any, label: str) -> tuple[int, int]:
+        if (
+            not isinstance(raw, list)
+            or len(raw) != 2
+            or any(isinstance(item, bool) or not isinstance(item, int) for item in raw)
+        ):
+            raise MazeModeBenchError(f"{label} must be a [row, column] integer pair")
+        cell = int(raw[0]), int(raw[1])
+        if not (0 <= cell[0] < len(rows) and 0 <= cell[1] < width):
+            raise MazeModeBenchError(f"{label} is outside maze_map")
+        if rows[cell[0]][cell[1]] != 0:
+            raise MazeModeBenchError(f"{label} must select a free maze cell")
+        return cell
+
+    reset_cell = parse_cell(reset_cell_value, "reset_cell")
+    goal_cell = parse_cell(goal_cell_value, "goal_cell")
+    if reset_cell == goal_cell:
+        raise MazeModeBenchError("reset_cell and goal_cell must differ")
+    return tuple(rows), reset_cell, goal_cell
+
+
+def parse_maze_action_spec(spec: Mapping[str, Any]) -> MazeActionSpec:
+    """Parse one trusted PointMaze or AntMaze action-program specification."""
+
+    if not isinstance(spec, Mapping):
+        raise MazeModeBenchError("maze spec must be an object")
+    verifier = str(spec.get("verifier", ""))
+    if verifier not in {POINT_MAZE_VERIFIER, ANT_MAZE_VERIFIER}:
+        raise MazeModeBenchError("wrong maze action-program verifier")
+    expected_version = (
+        MAZE_ACTION_VERSION
+        if verifier == POINT_MAZE_VERIFIER
+        else ANT_MAZE_ACTION_VERSION
+    )
+    if spec.get("maze_action_version") != expected_version:
+        raise MazeModeBenchError("unsupported maze action-program version")
+    environment_id = str(spec.get("environment_id", ""))
+    if _IDENTIFIER.fullmatch(environment_id) is None:
+        raise MazeModeBenchError("environment_id is invalid")
+    expected_prefix = "PointMaze" if verifier == POINT_MAZE_VERIFIER else "AntMaze"
+    if not environment_id.startswith(expected_prefix):
+        raise MazeModeBenchError("environment_id does not match the verifier")
+    map_id = str(spec.get("map_id", ""))
+    if _IDENTIFIER.fullmatch(map_id) is None:
+        raise MazeModeBenchError("map_id is invalid")
+
+    expected_actions = POINT_ACTIONS if verifier == POINT_MAZE_VERIFIER else ANT_ACTIONS
+    raw_actions = spec.get("action_tokens")
+    if not isinstance(raw_actions, list) or tuple(raw_actions) != expected_actions:
+        raise MazeModeBenchError("action_tokens differ from the frozen verifier alphabet")
+
+    environment_sha256 = _sha(spec.get("environment_sha256"), label="environment_sha256")
+    raw_controller = spec.get("controller_sha256")
+    if verifier == ANT_MAZE_VERIFIER:
+        controller_sha256 = _sha(raw_controller, label="controller_sha256")
+    else:
+        if raw_controller is not None:
+            raise MazeModeBenchError("PointMaze cannot declare a locomotion controller")
+        controller_sha256 = None
+
+    min_actions = _bounded_int(
+        spec.get("min_actions"), label="min_actions", minimum=1, maximum=512
+    )
+    max_actions = _bounded_int(
+        spec.get("max_actions"), label="max_actions", minimum=min_actions, maximum=512
+    )
+    action_repeat = _bounded_int(
+        spec.get("action_repeat"),
+        label="action_repeat",
+        minimum=1,
+        maximum=100 if verifier == POINT_MAZE_VERIFIER else 400,
+    )
+    success_threshold = _finite_float(
+        spec.get("success_threshold"), label="success_threshold"
+    )
+    if not 0.0 < success_threshold <= 1.0:
+        raise MazeModeBenchError("success_threshold is outside (0, 1]")
+    max_segment_length = _finite_float(
+        spec.get("max_segment_length"), label="max_segment_length"
+    )
+    if not 0.0 < max_segment_length <= 10.0:
+        raise MazeModeBenchError("max_segment_length is outside (0, 10]")
+
+    maze_map, reset_cell, goal_cell = _parse_maze_map(
+        spec.get("maze_map"),
+        spec.get("reset_cell"),
+        spec.get("goal_cell"),
+    )
+
+    return MazeActionSpec(
+        verifier=verifier,
+        environment_id=environment_id,
+        environment_sha256=environment_sha256,
+        controller_sha256=controller_sha256,
+        map_id=map_id,
+        maze_map=maze_map,
+        reset_cell=reset_cell,
+        goal_cell=goal_cell,
+        reset_seed=_bounded_int(
+            spec.get("reset_seed"), label="reset_seed", minimum=0, maximum=2**31 - 1
+        ),
+        min_actions=min_actions,
+        max_actions=max_actions,
+        action_repeat=action_repeat,
+        action_tokens=expected_actions,
+        success_threshold=success_threshold,
+        max_segment_length=max_segment_length,
+        bounds=_parse_bounds(spec.get("bounds_xy")),
+        gates=_parse_gates(spec.get("route_gates")),
+        spec_sha256=_canonical_spec_sha256(spec),
+    )
+
+
+def parse_maze_action_program(candidate: str, spec: MazeActionSpec) -> tuple[str, ...]:
+    """Parse a bounded whitespace/comma-separated action program."""
+
+    text = str(candidate).strip()
+    if not text or len(text) > _MAX_PROGRAM_CHARS:
+        raise MazeModeBenchError("action program is empty or too long")
+    tokens = tuple(token for token in re.split(r"[\s,]+", text.upper()) if token)
+    if not spec.min_actions <= len(tokens) <= spec.max_actions:
+        raise MazeModeBenchError("action program length is outside the frozen bounds")
+    allowed = set(spec.action_tokens)
+    unknown = [token for token in tokens if token not in allowed]
+    if unknown:
+        raise MazeModeBenchError(f"unknown action token {unknown[0]!r}")
+    return tokens
+
+
+def _parse_execution_record(value: Mapping[str, Any]) -> MazeExecutionRecord:
+    if not isinstance(value, Mapping):
+        raise MazeModeBenchError("execution record must be an object")
+    raw_trajectory = value.get("trajectory_xy")
+    if not isinstance(raw_trajectory, list) or len(raw_trajectory) < 2:
+        raise MazeModeBenchError("execution trajectory must contain at least two points")
+    trajectory: list[tuple[float, float]] = []
+    for index, raw_point in enumerate(raw_trajectory):
+        if not isinstance(raw_point, list) or len(raw_point) != 2:
+            raise MazeModeBenchError(f"trajectory point {index} is malformed")
+        trajectory.append(
+            (
+                _finite_float(raw_point[0], label=f"trajectory[{index}].x"),
+                _finite_float(raw_point[1], label=f"trajectory[{index}].y"),
+            )
+        )
+    raw_success = value.get("success")
+    if not isinstance(raw_success, bool):
+        raise MazeModeBenchError("execution success must be boolean")
+    raw_tokens = value.get("action_tokens")
+    if not isinstance(raw_tokens, list) or not all(isinstance(x, str) for x in raw_tokens):
+        raise MazeModeBenchError("execution action_tokens must be a string list")
+    raw_controller = value.get("controller_sha256")
+    controller_sha256 = None if raw_controller is None else _sha(
+        raw_controller, label="execution.controller_sha256"
+    )
+    return MazeExecutionRecord(
+        environment_sha256=_sha(
+            value.get("environment_sha256"), label="execution.environment_sha256"
+        ),
+        controller_sha256=controller_sha256,
+        spec_sha256=_sha(value.get("spec_sha256"), label="execution.spec_sha256"),
+        reset_seed=_bounded_int(
+            value.get("reset_seed"),
+            label="execution.reset_seed",
+            minimum=0,
+            maximum=2**31 - 1,
+        ),
+        action_tokens=tuple(raw_tokens),
+        success=raw_success,
+        final_goal_distance=_finite_float(
+            value.get("final_goal_distance"), label="execution.final_goal_distance"
+        ),
+        trajectory_xy=tuple(trajectory),
+        simulator_steps=_bounded_int(
+            value.get("simulator_steps"),
+            label="execution.simulator_steps",
+            minimum=1,
+            maximum=1_000_000,
+        ),
+    )
+
+
+def _outside_side(value: float, gate: DirectedGate) -> int:
+    if value < gate.coordinate - gate.hysteresis:
+        return -1
+    if value > gate.coordinate + gate.hysteresis:
+        return 1
+    return 0
+
+
+def _gate_crossing(
+    first: tuple[float, float],
+    second: tuple[float, float],
+    gate: DirectedGate,
+) -> str | None:
+    axis_index = 0 if gate.axis == "x" else 1
+    span_index = 1 - axis_index
+    denominator = second[axis_index] - first[axis_index]
+    if denominator == 0.0:
+        return None
+    fraction = (gate.coordinate - first[axis_index]) / denominator
+    if not 0.0 <= fraction <= 1.0:
+        return None
+    span_value = first[span_index] + fraction * (
+        second[span_index] - first[span_index]
+    )
+    if not gate.span_min <= span_value <= gate.span_max:
+        return None
+    direction = "+" if second[axis_index] > first[axis_index] else "-"
+    return f"{gate.gate_id}{direction}"
+
+
+def extract_directed_gate_route(
+    trajectory_xy: Sequence[tuple[float, float]],
+    spec: MazeActionSpec,
+) -> tuple[str, ...]:
+    """Extract a hysteresis-stable ordered directed bottleneck sequence."""
+
+    if len(trajectory_xy) < 2:
+        raise MazeModeBenchError("trajectory is too short")
+    if len(trajectory_xy) > spec.max_actions * spec.action_repeat + 2:
+        raise MazeModeBenchError("trajectory exceeds the frozen execution horizon")
+    for index, point in enumerate(trajectory_xy):
+        if not (
+            spec.bounds[0][0] <= point[0] <= spec.bounds[0][1]
+            and spec.bounds[1][0] <= point[1] <= spec.bounds[1][1]
+        ):
+            raise MazeModeBenchError(f"trajectory point {index} is outside maze bounds")
+        if index:
+            previous = trajectory_xy[index - 1]
+            distance = math.hypot(point[0] - previous[0], point[1] - previous[1])
+            if distance > spec.max_segment_length:
+                raise MazeModeBenchError("trajectory contains a teleport-sized segment")
+
+    route: list[str] = []
+    state: dict[str, tuple[int, tuple[float, float]] | None] = {
+        gate.gate_id: None for gate in spec.gates
+    }
+    for point in trajectory_xy:
+        step_crossings: list[str] = []
+        for gate in spec.gates:
+            coordinate = point[0] if gate.axis == "x" else point[1]
+            side = _outside_side(coordinate, gate)
+            previous_state = state[gate.gate_id]
+            if side == 0:
+                continue
+            if previous_state is None:
+                state[gate.gate_id] = (side, point)
+                continue
+            previous_side, previous_point = previous_state
+            if side != previous_side:
+                crossing = _gate_crossing(previous_point, point, gate)
+                if crossing is not None:
+                    step_crossings.append(crossing)
+            state[gate.gate_id] = (side, point)
+        if len(step_crossings) > 1:
+            raise MazeModeBenchError("one trajectory segment crosses multiple route gates")
+        if step_crossings and (not route or route[-1] != step_crossings[0]):
+            route.append(step_crossings[0])
+    if not route:
+        raise MazeModeBenchError("successful trajectory has no certified route gate")
+    gate_ids = [crossing[:-1] for crossing in route]
+    if len(gate_ids) != len(set(gate_ids)):
+        raise MazeModeBenchError("trajectory recrosses a route gate")
+    return tuple(route)
+
+
+def validate_maze_execution(
+    candidate: str,
+    raw_spec: Mapping[str, Any],
+    raw_execution: Mapping[str, Any],
+) -> MazeValidation:
+    """Bind one successful simulator execution to its semantic route key."""
+
+    spec = parse_maze_action_spec(raw_spec)
+    tokens = parse_maze_action_program(candidate, spec)
+    execution = _parse_execution_record(raw_execution)
+    if execution.environment_sha256 != spec.environment_sha256:
+        raise MazeModeBenchError("execution environment hash does not match the spec")
+    if execution.controller_sha256 != spec.controller_sha256:
+        raise MazeModeBenchError("execution controller hash does not match the spec")
+    if execution.spec_sha256 != spec.spec_sha256:
+        raise MazeModeBenchError("execution is bound to a different spec")
+    if execution.reset_seed != spec.reset_seed:
+        raise MazeModeBenchError("execution reset seed does not match the spec")
+    if execution.action_tokens != tokens:
+        raise MazeModeBenchError("execution action program does not match the candidate")
+    if not execution.success:
+        raise MazeModeBenchError("unsuccessful execution has no ModeBench identity")
+    if not 0.0 <= execution.final_goal_distance <= spec.success_threshold:
+        raise MazeModeBenchError("successful execution fails the frozen goal threshold")
+    if execution.simulator_steps > len(tokens) * spec.action_repeat:
+        raise MazeModeBenchError("execution exceeds the action-program step budget")
+    route = extract_directed_gate_route(execution.trajectory_xy, spec)
+    action_version = (
+        MAZE_ACTION_VERSION
+        if spec.verifier == POINT_MAZE_VERIFIER
+        else ANT_MAZE_ACTION_VERSION
+    )
+    key = f"{spec.verifier}:{action_version}:{spec.map_id}:" + ",".join(route)
+    return MazeValidation(
+        canonical_key=key,
+        directed_gates=route,
+        action_tokens=tokens,
+        simulator_steps=execution.simulator_steps,
+    )

code/oat_drgrpo/maze_modebench_process.py

@@ -0,0 +1,168 @@
+"""Killable external MuJoCo boundary for maze language-action programs."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+import select
+import subprocess
+import threading
+from typing import Any, Mapping
+
+from .maze_modebench import MazeValidation
+
+
+class MazeVerifierProcess:
+    """Execute maze action programs outside the trainer process."""
+
+    def __init__(
+        self,
+        *,
+        timeout_seconds: float = 25.0,
+        worker_python: str | Path | None = None,
+    ) -> None:
+        if timeout_seconds <= 0:
+            raise ValueError("timeout_seconds must be positive")
+        root = Path(
+            os.environ.get(
+                "OAT_ZERO_REPO_ROOT", Path(__file__).resolve().parents[2]
+            )
+        ).resolve()
+        configured = worker_python or os.environ.get("OAT_ZERO_MAZE_WORKER_PYTHON")
+        self.worker_python = Path(configured) if configured else (
+            root / "var/maze_runtime/venv/bin/python"
+        )
+        self.timeout_seconds = float(timeout_seconds)
+        self._process: subprocess.Popen[str] | None = None
+        self._owner_pid = os.getpid()
+        self._lock = threading.Lock()
+
+    def _start(self) -> subprocess.Popen[str]:
+        if self._owner_pid != os.getpid():
+            self._process = None
+            self._owner_pid = os.getpid()
+        process = self._process
+        if process is not None and process.poll() is None:
+            return process
+        if not self.worker_python.is_file():
+            raise FileNotFoundError(f"maze worker Python is missing: {self.worker_python}")
+        source_root = str(Path(__file__).resolve().parents[1])
+        entrypoint = (
+            "import runpy,sys;"
+            f"sys.path.insert(0,{source_root!r});"
+            "runpy.run_module('oat_drgrpo.maze_modebench_worker',run_name='__main__')"
+        )
+        worker_env = os.environ.copy()
+        worker_env.setdefault("MUJOCO_GL", "egl")
+        self._process = subprocess.Popen(
+            [str(self.worker_python), "-B", "-I", "-c", entrypoint],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=None,
+            text=True,
+            encoding="utf-8",
+            bufsize=1,
+            start_new_session=True,
+            env=worker_env,
+        )
+        return self._process
+
+    def _stop(self) -> None:
+        process, self._process = self._process, None
+        if process is None:
+            return
+        if process.poll() is None:
+            process.terminate()
+            try:
+                process.wait(timeout=1)
+            except subprocess.TimeoutExpired:
+                process.kill()
+                process.wait(timeout=1)
+        if process.stdin is not None:
+            process.stdin.close()
+        if process.stdout is not None:
+            process.stdout.close()
+
+    def close(self) -> None:
+        with self._lock:
+            self._stop()
+
+    def validate(
+        self,
+        candidate: str,
+        spec: Mapping[str, Any],
+    ) -> MazeValidation | None:
+        result = self.validate_with_execution(candidate, spec)
+        return result[0] if result is not None else None
+
+    def validate_with_execution(
+        self,
+        candidate: str,
+        spec: Mapping[str, Any],
+    ) -> tuple[MazeValidation, dict[str, Any]] | None:
+        """Return validation plus the trusted raw record for offline audits."""
+
+        request = json.dumps(
+            {"candidate": str(candidate), "spec": dict(spec)},
+            allow_nan=False,
+        )
+        with self._lock:
+            for attempt in range(2):
+                try:
+                    process = self._start()
+                    assert process.stdin is not None and process.stdout is not None
+                    process.stdin.write(request + "\n")
+                    process.stdin.flush()
+                    readable, _, _ = select.select(
+                        [process.stdout], [], [], self.timeout_seconds
+                    )
+                    if not readable:
+                        self._stop()
+                        return None
+                    line = process.stdout.readline()
+                    if not line:
+                        raise BrokenPipeError("maze worker closed stdout")
+                    payload = json.loads(line)
+                    if not payload.get("valid"):
+                        return None
+                    validation = MazeValidation(
+                        canonical_key=str(payload["canonical_key"]),
+                        directed_gates=tuple(
+                            str(value) for value in payload["directed_gates"]
+                        ),
+                        action_tokens=tuple(
+                            str(value) for value in payload["action_tokens"]
+                        ),
+                        simulator_steps=int(payload["simulator_steps"]),
+                    )
+                    return validation, dict(payload["execution"])
+                except (
+                    BrokenPipeError,
+                    FileNotFoundError,
+                    OSError,
+                    ValueError,
+                    json.JSONDecodeError,
+                ):
+                    self._stop()
+                    if attempt:
+                        return None
+        return None
+
+    def __del__(self) -> None:
+        try:
+            self._stop()
+        except Exception:
+            pass
+
+
+_SHARED_VERIFIER = MazeVerifierProcess()
+
+
+def validate_maze_action_program_external(
+    candidate: str,
+    spec: Mapping[str, Any],
+) -> MazeValidation | None:
+    """Validate a candidate through the shared pinned MuJoCo worker."""
+
+    return _SHARED_VERIFIER.validate(candidate, spec)

code/oat_drgrpo/maze_modebench_worker.py

@@ -0,0 +1,179 @@
+"""Networkless JSON-lines worker for 0.5B maze action programs."""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+import signal
+import sys
+from typing import Any, Mapping
+
+from .maze_modebench import (
+    ANT_MAZE_VERIFIER,
+    POINT_MAZE_VERIFIER,
+    parse_maze_action_program,
+    parse_maze_action_spec,
+    validate_maze_execution,
+)
+from .maze_runtime_identity import maze_runtime_identity
+from .ant_maze_worker_v5 import execute_ant_v5
+from .ant_maze_worker_v5 import RECEIPT_SHA256 as ANT_V5_RECEIPT_SHA256
+from .ant_maze_worker_v8 import execute_ant_v8
+from .ant_maze_worker_v8 import RECEIPT_SHA256 as ANT_V8_RECEIPT_SHA256
+from .ant_maze_worker_v9 import controller_receipt_sha256 as ant_v9_receipt_sha256
+from .ant_maze_worker_v9 import execute_ant_v9
+from .ant_maze_worker_v10 import controller_receipt_sha256 as ant_v10_receipt_sha256
+from .ant_maze_worker_v10 import execute_ant_v10
+from .ant_maze_worker_v11 import controller_receipt_sha256 as ant_v11_receipt_sha256
+from .ant_maze_worker_v11 import execute_ant_v11
+from .ant_maze_worker_v12 import controller_receipt_sha256 as ant_v12_receipt_sha256
+from .ant_maze_worker_v12 import execute_ant_v12
+
+
+WORKER_TIMEOUT_SECONDS = float(
+    os.environ.get("OAT_ZERO_MAZE_WORKER_TIMEOUT_SECONDS", "20.0")
+)
+if not math.isfinite(WORKER_TIMEOUT_SECONDS) or WORKER_TIMEOUT_SECONDS <= 0:
+    raise ValueError("maze worker timeout must be finite and positive")
+
+
+def _timeout(_signum, _frame) -> None:
+    raise TimeoutError("maze action-program execution timed out")
+
+
+def _point_action(token: str):
+    import numpy as np
+
+    diagonal = 1.0 / math.sqrt(2.0)
+    values = {
+        "N": (0.0, 1.0),
+        "NE": (diagonal, diagonal),
+        "E": (1.0, 0.0),
+        "SE": (diagonal, -diagonal),
+        "S": (0.0, -1.0),
+        "SW": (-diagonal, -diagonal),
+        "W": (-1.0, 0.0),
+        "NW": (-diagonal, diagonal),
+        "COAST": (0.0, 0.0),
+    }
+    return np.asarray(values[token], dtype=np.float32)
+
+
+def _execute_point(candidate: str, raw_spec: Mapping[str, Any]):
+    import gymnasium as gym
+    import gymnasium_robotics
+    import numpy as np
+
+    gym.register_envs(gymnasium_robotics)
+    spec = parse_maze_action_spec(raw_spec)
+    if spec.verifier != POINT_MAZE_VERIFIER:
+        raise ValueError("PointMaze executor received a non-PointMaze spec")
+    runtime = maze_runtime_identity()
+    if spec.environment_sha256 != runtime["point_environment_sha256"]:
+        raise ValueError("PointMaze environment hash differs from installed runtime")
+    tokens = parse_maze_action_program(candidate, spec)
+    env = gym.make(
+        spec.environment_id,
+        maze_map=[list(row) for row in spec.maze_map],
+        reward_type="sparse",
+        continuing_task=False,
+        reset_target=False,
+        max_episode_steps=len(tokens) * spec.action_repeat,
+    )
+    try:
+        # Gymnasium-Robotics 1.4.2 forwards this constructor argument to the
+        # nested PointEnv, so bind it on the MazeEnv before reset instead.
+        env.unwrapped.position_noise_range = 0.0
+        observation, info = env.reset(
+            seed=spec.reset_seed,
+            options={
+                "reset_cell": list(spec.reset_cell),
+                "goal_cell": list(spec.goal_cell),
+            },
+        )
+        trajectory = [observation["achieved_goal"].astype(float).tolist()]
+        success = bool(info.get("success", False))
+        simulator_steps = 0
+        for token in tokens:
+            action = _point_action(token)
+            for _ in range(spec.action_repeat):
+                observation, _reward, terminated, truncated, info = env.step(action)
+                simulator_steps += 1
+                achieved = observation["achieved_goal"].astype(float)
+                trajectory.append(achieved.tolist())
+                success = bool(info.get("success", False))
+                if success or terminated or truncated:
+                    break
+            if success or terminated or truncated:
+                break
+        distance = float(
+            np.linalg.norm(
+                observation["achieved_goal"] - observation["desired_goal"]
+            )
+        )
+    finally:
+        env.close()
+    execution = {
+        "environment_sha256": spec.environment_sha256,
+        "controller_sha256": None,
+        "spec_sha256": spec.spec_sha256,
+        "reset_seed": spec.reset_seed,
+        "action_tokens": list(tokens),
+        "success": success,
+        "final_goal_distance": distance,
+        "trajectory_xy": trajectory,
+        "simulator_steps": simulator_steps,
+    }
+    return validate_maze_execution(candidate, raw_spec, execution), execution
+
+
+def execute(candidate: str, raw_spec: Mapping[str, Any]):
+    spec = parse_maze_action_spec(raw_spec)
+    if spec.verifier == POINT_MAZE_VERIFIER:
+        return _execute_point(candidate, raw_spec)
+    if spec.verifier == ANT_MAZE_VERIFIER:
+        if spec.controller_sha256 == ANT_V5_RECEIPT_SHA256:
+            return execute_ant_v5(candidate, raw_spec)
+        if spec.controller_sha256 == ANT_V8_RECEIPT_SHA256:
+            return execute_ant_v8(candidate, raw_spec)
+        # V12 route identities are intentionally incompatible with the older
+        # controller-specific route schemas.  Resolve the newest bound
+        # controller before asking any older validator to inspect that identity.
+        if spec.controller_sha256 == ant_v12_receipt_sha256():
+            return execute_ant_v12(candidate, raw_spec)
+        if spec.controller_sha256 == ant_v9_receipt_sha256():
+            return execute_ant_v9(candidate, raw_spec)
+        if spec.controller_sha256 == ant_v10_receipt_sha256():
+            return execute_ant_v10(candidate, raw_spec)
+        if spec.controller_sha256 == ant_v11_receipt_sha256():
+            return execute_ant_v11(candidate, raw_spec)
+        raise ValueError("unsupported AntMaze controller identity")
+    raise ValueError("unsupported maze verifier")
+
+
+def main() -> None:
+    signal.signal(signal.SIGALRM, _timeout)
+    for line in sys.stdin:
+        try:
+            request = json.loads(line)
+            signal.setitimer(signal.ITIMER_REAL, WORKER_TIMEOUT_SECONDS)
+            validation, execution = execute(request["candidate"], request["spec"])
+            payload = {
+                "valid": True,
+                "canonical_key": validation.canonical_key,
+                "directed_gates": list(validation.directed_gates),
+                "action_tokens": list(validation.action_tokens),
+                "simulator_steps": validation.simulator_steps,
+                "execution": execution,
+            }
+        except Exception as error:
+            payload = {"valid": False, "error": type(error).__name__}
+        finally:
+            signal.setitimer(signal.ITIMER_REAL, 0.0)
+        sys.stdout.write(json.dumps(payload, allow_nan=False) + "\n")
+        sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()

code/oat_drgrpo/maze_runtime_identity.py

@@ -0,0 +1,87 @@
+"""Hash the exact installed runtime used by maze execution workers."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib.metadata
+import json
+from pathlib import Path
+import platform
+from typing import Any
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _canonical_sha256(value: Any) -> str:
+    encoded = json.dumps(
+        value,
+        allow_nan=False,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _file_receipt(path: Path, package_root: Path) -> dict[str, str]:
+    return {
+        "path": path.relative_to(package_root.parent).as_posix(),
+        "sha256": _sha256(path),
+    }
+
+
+def maze_runtime_identity() -> dict[str, Any]:
+    """Return source-bound PointMaze and AntMaze environment identities."""
+
+    import gymnasium
+    import gymnasium_robotics
+
+    robotics_root = Path(gymnasium_robotics.__file__).resolve().parent
+    site_packages = robotics_root.parent
+    gymnasium_root = Path(gymnasium.__file__).resolve().parent
+    common = {
+        "python": platform.python_version(),
+        "packages": {
+            package: importlib.metadata.version(package)
+            for package in ("gymnasium", "gymnasium-robotics", "mujoco", "numpy")
+        },
+        "maze_v4": _file_receipt(
+            robotics_root / "envs/maze/maze_v4.py", site_packages
+        ),
+    }
+    point_payload = {
+        "schema_version": "point-maze-runtime-v1",
+        "common": common,
+        "point_maze": _file_receipt(
+            robotics_root / "envs/maze/point_maze.py", site_packages
+        ),
+        "point_xml": _file_receipt(
+            robotics_root / "envs/assets/point/point.xml", site_packages
+        ),
+    }
+    ant_payload = {
+        "schema_version": "ant-maze-runtime-v1",
+        "common": common,
+        "ant_maze": _file_receipt(
+            robotics_root / "envs/maze/ant_maze_v5.py", site_packages
+        ),
+        "ant_v5": _file_receipt(
+            gymnasium_root / "envs/mujoco/ant_v5.py", site_packages
+        ),
+        "ant_xml": _file_receipt(
+            gymnasium_root / "envs/mujoco/assets/ant.xml", site_packages
+        ),
+    }
+    return {
+        "schema_version": "maze-runtime-identity-v1",
+        "point": point_payload,
+        "ant": ant_payload,
+        "point_environment_sha256": _canonical_sha256(point_payload),
+        "ant_environment_sha256": _canonical_sha256(ant_payload),
+    }

code/oat_drgrpo/modebench_guided.py

@@ -0,0 +1,85 @@
+"""Target-blind legal-output grammars for the admitted Level-2 benchmark."""
+
+from __future__ import annotations
+
+import itertools
+import json
+import re
+
+
+PROFILES = frozenset({"none", "domain_legal_v1", "countdown_legal_v3"})
+
+
+def countdown_legal_regex(reference: str) -> str:
+    """Enumerate operand-exact expression syntax without consulting the target."""
+
+    numbers = tuple(str(int(value)) for value in json.loads(reference)["numbers"])
+    operator = r"[+*/-]"
+
+    def trees(values: tuple[str, ...]) -> tuple[str, ...]:
+        if len(values) == 1:
+            return (re.escape(values[0]),)
+        expressions = []
+        for split in range(1, len(values)):
+            for left in trees(values[:split]):
+                for right in trees(values[split:]):
+                    expressions.append(r"\(" + left + " " + operator + " " + right + r"\)")
+        return tuple(expressions)
+
+    expressions = set()
+    for values in set(itertools.permutations(numbers)):
+        expressions.update(trees(values))
+    return r"\\boxed\{(?:" + "|".join(sorted(expressions)) + r")\}"
+
+
+def legal_regex(profile: str, domain: str, reference: str) -> str | None:
+    """Return the frozen legal syntax for one row; never inspect its target."""
+
+    if profile not in PROFILES:
+        raise ValueError(f"unknown ModeBench syntax profile: {profile}")
+    if profile == "none":
+        return None
+    if profile == "countdown_legal_v3":
+        if domain != "countdown":
+            raise ValueError("countdown_legal_v3 is Countdown-only")
+        return countdown_legal_regex(reference)
+    if domain == "pantry_plan":
+        spec = json.loads(reference)
+        alternatives = []
+        for ingredient in spec["ingredients"]:
+            identifier = str(ingredient["id"])
+            minimum = int(ingredient["min_if_used_g"])
+            available = int(ingredient["available_g"])
+            step = int(ingredient["step_g"])
+            alternatives.extend(
+                f"{identifier}={grams}"
+                for grams in range(minimum, available + 1, step)
+            )
+        atom = "(?:" + "|".join(re.escape(value) for value in alternatives) + ")"
+        return r"\\boxed\{" + atom + "(?:;" + atom + r"){1,3}\}"
+    fixed = {
+        "python_factors": r"\\boxed\{lambda n: [A-Za-z0-9 _%<>=!+*/().-]+\}",
+        "mathir": r"\\boxed\{[A-F](?:;[A-F]){0,3}\}",
+    }
+    if domain not in fixed:
+        raise ValueError(f"domain_legal_v1 has no grammar for {domain}")
+    return fixed[domain]
+
+
+def guided_sampling_params(base, profile: str, domain: str, references: list[str]):
+    """Copy one vLLM parameter object per row and attach its legal grammar."""
+
+    if profile == "none":
+        return base
+    import copy
+    from vllm.sampling_params import GuidedDecodingParams
+
+    params = []
+    for reference in references:
+        row = copy.copy(base)
+        regex = legal_regex(profile, domain, str(reference))
+        if regex is None:
+            raise RuntimeError("active syntax profile resolved no grammar")
+        row.guided_decoding = GuidedDecodingParams(regex=regex)
+        params.append(row)
+    return params

code/oat_drgrpo/pantry_plan.py

@@ -0,0 +1,370 @@
+"""Executable nutrition-and-inventory plans for PantryPlan ModeBench.
+
+The model emits a compact allocation such as ``lentils=150;rice=100``.  The
+trusted specification supplies a frozen pantry, exact per-100g attributes,
+dietary exclusions, and feasibility bounds.  Correctness and semantic identity
+come from the same validation:
+
+* every used ingredient exists, is allowed, and respects its available,
+  minimum-serving, and quantity-step limits;
+* exact decimal arithmetic checks mass, nutrition, cost, and other registered
+  bounds; and
+* the canonical mode is the sorted set of ingredients actually used.
+
+Quantities affect correctness but not identity.  This deliberately collapses
+nearby quantity variants of the same formulation instead of treating gram-level
+perturbations as new semantic modes.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from decimal import Decimal, InvalidOperation
+import re
+from typing import Any, Mapping
+
+
+PANTRY_PLAN_VERIFIER = "pantry_plan"
+PANTRY_PLAN_VERSION = "pantry-v1"
+
+_ID = re.compile(r"[a-z][a-z0-9_]{0,31}")
+_ATTRIBUTE = re.compile(r"[a-z][a-z0-9_]{0,31}")
+_TAG = re.compile(r"[a-z][a-z0-9_-]{0,31}")
+_MAX_INGREDIENTS = 16
+_MAX_CANDIDATE_CHARS = 512
+_ALLOWED_ATTRIBUTES = {
+    "energy_kcal",
+    "protein_g",
+    "fiber_g",
+    "fat_g",
+    "carbohydrate_g",
+    "sodium_mg",
+    "cost_cents",
+}
+
+
+class PantryPlanError(ValueError):
+    """Raised for an invalid trusted specification or candidate plan."""
+
+
+@dataclass(frozen=True)
+class PantryIngredient:
+    ingredient_id: str
+    available_g: int
+    step_g: int
+    min_if_used_g: int
+    attributes_per_100g: tuple[tuple[str, Decimal], ...]
+    tags: frozenset[str]
+
+    @property
+    def attributes(self) -> dict[str, Decimal]:
+        return dict(self.attributes_per_100g)
+
+
+@dataclass(frozen=True)
+class PantryTarget:
+    attribute: str
+    minimum: Decimal | None
+    maximum: Decimal | None
+
+
+@dataclass(frozen=True)
+class PantryPlanSpec:
+    ingredients: tuple[PantryIngredient, ...]
+    targets: tuple[PantryTarget, ...]
+    min_ingredients: int
+    max_ingredients: int
+    forbidden_tags: frozenset[str]
+    certified_mode_count: int
+
+    @property
+    def ingredient_by_id(self) -> dict[str, PantryIngredient]:
+        return {row.ingredient_id: row for row in self.ingredients}
+
+
+@dataclass(frozen=True)
+class PantryPlanValidation:
+    """One accepted allocation and its validator-derived semantic mode."""
+
+    canonical_key: str
+    allocations_g: tuple[tuple[str, int], ...]
+    totals: tuple[tuple[str, Decimal], ...]
+
+
+def _decimal(value: Any, *, label: str) -> Decimal:
+    if isinstance(value, bool) or not isinstance(value, (int, float, str, Decimal)):
+        raise PantryPlanError(f"{label} must be a finite decimal")
+    try:
+        result = Decimal(str(value))
+    except (InvalidOperation, ValueError) as error:
+        raise PantryPlanError(f"{label} must be a finite decimal") from error
+    if not result.is_finite() or result < 0:
+        raise PantryPlanError(f"{label} must be a nonnegative finite decimal")
+    return result
+
+
+def _bounded_int(
+    value: Any,
+    *,
+    label: str,
+    minimum: int,
+    maximum: int,
+) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise PantryPlanError(f"{label} must be an integer")
+    result = int(value)
+    if not minimum <= result <= maximum:
+        raise PantryPlanError(f"{label} is outside [{minimum}, {maximum}]")
+    return result
+
+
+def _tags(value: Any, *, label: str) -> frozenset[str]:
+    if not isinstance(value, list) or len(value) > 32:
+        raise PantryPlanError(f"{label} must be a bounded tag list")
+    result: set[str] = set()
+    for raw in value:
+        tag = str(raw)
+        if not _TAG.fullmatch(tag):
+            raise PantryPlanError(f"{label} contains invalid tag {tag!r}")
+        if tag in result:
+            raise PantryPlanError(f"{label} contains duplicate tag {tag!r}")
+        result.add(tag)
+    return frozenset(result)
+
+
+def parse_pantry_plan_spec(spec: Mapping[str, Any]) -> PantryPlanSpec:
+    """Validate a trusted PantryPlan specification."""
+
+    if spec.get("verifier") != PANTRY_PLAN_VERIFIER:
+        raise PantryPlanError("wrong PantryPlan verifier")
+    if spec.get("pantry_version") != PANTRY_PLAN_VERSION:
+        raise PantryPlanError("unsupported PantryPlan version")
+
+    raw_ingredients = spec.get("ingredients")
+    if (
+        not isinstance(raw_ingredients, list)
+        or not 2 <= len(raw_ingredients) <= _MAX_INGREDIENTS
+    ):
+        raise PantryPlanError("ingredients must contain between 2 and 16 rows")
+
+    ingredients: list[PantryIngredient] = []
+    observed_ids: set[str] = set()
+    for index, raw in enumerate(raw_ingredients):
+        if not isinstance(raw, Mapping):
+            raise PantryPlanError(f"ingredient {index} must be an object")
+        ingredient_id = str(raw.get("id", ""))
+        if not _ID.fullmatch(ingredient_id):
+            raise PantryPlanError(f"ingredient {index} has an invalid id")
+        if ingredient_id in observed_ids:
+            raise PantryPlanError(f"duplicate ingredient id {ingredient_id!r}")
+        observed_ids.add(ingredient_id)
+
+        available_g = _bounded_int(
+            raw.get("available_g"),
+            label=f"{ingredient_id}.available_g",
+            minimum=1,
+            maximum=10_000,
+        )
+        step_g = _bounded_int(
+            raw.get("step_g"),
+            label=f"{ingredient_id}.step_g",
+            minimum=1,
+            maximum=1_000,
+        )
+        min_if_used_g = _bounded_int(
+            raw.get("min_if_used_g"),
+            label=f"{ingredient_id}.min_if_used_g",
+            minimum=step_g,
+            maximum=available_g,
+        )
+        if available_g % step_g or min_if_used_g % step_g:
+            raise PantryPlanError(
+                f"{ingredient_id} availability and minimum must align to step_g"
+            )
+
+        raw_attributes = raw.get("attributes_per_100g")
+        if not isinstance(raw_attributes, Mapping) or not raw_attributes:
+            raise PantryPlanError(
+                f"{ingredient_id}.attributes_per_100g must be nonempty"
+            )
+        attributes: list[tuple[str, Decimal]] = []
+        for raw_name, raw_value in raw_attributes.items():
+            name = str(raw_name)
+            if (
+                not _ATTRIBUTE.fullmatch(name)
+                or name not in _ALLOWED_ATTRIBUTES
+            ):
+                raise PantryPlanError(
+                    f"{ingredient_id} has unsupported attribute {name!r}"
+                )
+            attributes.append(
+                (
+                    name,
+                    _decimal(
+                        raw_value,
+                        label=f"{ingredient_id}.attributes_per_100g.{name}",
+                    ),
+                )
+            )
+        ingredients.append(
+            PantryIngredient(
+                ingredient_id=ingredient_id,
+                available_g=available_g,
+                step_g=step_g,
+                min_if_used_g=min_if_used_g,
+                attributes_per_100g=tuple(sorted(attributes)),
+                tags=_tags(raw.get("tags", []), label=f"{ingredient_id}.tags"),
+            )
+        )
+
+    min_ingredients = _bounded_int(
+        spec.get("min_ingredients"),
+        label="min_ingredients",
+        minimum=1,
+        maximum=len(ingredients),
+    )
+    max_ingredients = _bounded_int(
+        spec.get("max_ingredients"),
+        label="max_ingredients",
+        minimum=min_ingredients,
+        maximum=len(ingredients),
+    )
+    certified_mode_count = _bounded_int(
+        spec.get("certified_mode_count"),
+        label="certified_mode_count",
+        minimum=2,
+        maximum=1_000_000,
+    )
+    forbidden_tags = _tags(spec.get("forbidden_tags", []), label="forbidden_tags")
+
+    raw_targets = spec.get("targets")
+    if not isinstance(raw_targets, Mapping) or not raw_targets:
+        raise PantryPlanError("targets must be a nonempty object")
+    targets: list[PantryTarget] = []
+    for raw_name, raw_bounds in raw_targets.items():
+        name = str(raw_name)
+        if name != "mass_g" and name not in _ALLOWED_ATTRIBUTES:
+            raise PantryPlanError(f"unsupported target attribute {name!r}")
+        if not isinstance(raw_bounds, Mapping):
+            raise PantryPlanError(f"target {name!r} must be an object")
+        unknown_bounds = set(raw_bounds) - {"min", "max"}
+        if unknown_bounds:
+            raise PantryPlanError(f"target {name!r} has unknown bounds")
+        minimum = (
+            _decimal(raw_bounds["min"], label=f"targets.{name}.min")
+            if "min" in raw_bounds
+            else None
+        )
+        maximum = (
+            _decimal(raw_bounds["max"], label=f"targets.{name}.max")
+            if "max" in raw_bounds
+            else None
+        )
+        if minimum is None and maximum is None:
+            raise PantryPlanError(f"target {name!r} has no bound")
+        if minimum is not None and maximum is not None and minimum > maximum:
+            raise PantryPlanError(f"target {name!r} has min greater than max")
+        if name != "mass_g":
+            for ingredient in ingredients:
+                if name not in ingredient.attributes:
+                    raise PantryPlanError(
+                        f"ingredient {ingredient.ingredient_id!r} lacks target "
+                        f"attribute {name!r}"
+                    )
+        targets.append(PantryTarget(name, minimum, maximum))
+
+    return PantryPlanSpec(
+        ingredients=tuple(ingredients),
+        targets=tuple(sorted(targets, key=lambda target: target.attribute)),
+        min_ingredients=min_ingredients,
+        max_ingredients=max_ingredients,
+        forbidden_tags=forbidden_tags,
+        certified_mode_count=certified_mode_count,
+    )
+
+
+def parse_pantry_plan_candidate(candidate: str) -> tuple[tuple[str, int], ...]:
+    """Parse ``ingredient_id=grams`` entries without executing model text."""
+
+    text = str(candidate).strip()
+    if not text or len(text) > _MAX_CANDIDATE_CHARS:
+        raise PantryPlanError("candidate is empty or too long")
+    if text.startswith("{") and text.endswith("}"):
+        text = text[1:-1].strip()
+    pieces = [piece.strip() for piece in re.split(r"[;,]", text)]
+    if not pieces or any(not piece for piece in pieces):
+        raise PantryPlanError("candidate contains an empty allocation")
+
+    allocations: dict[str, int] = {}
+    for piece in pieces:
+        match = re.fullmatch(r"([a-z][a-z0-9_]{0,31})\s*=\s*([0-9]+)", piece)
+        if match is None:
+            raise PantryPlanError(f"invalid allocation {piece!r}")
+        ingredient_id, raw_grams = match.groups()
+        if ingredient_id in allocations:
+            raise PantryPlanError(f"duplicate allocation for {ingredient_id!r}")
+        grams = int(raw_grams)
+        if not 1 <= grams <= 10_000:
+            raise PantryPlanError(f"allocation for {ingredient_id!r} is out of range")
+        allocations[ingredient_id] = grams
+    return tuple(sorted(allocations.items()))
+
+
+def validate_pantry_plan(
+    candidate: str,
+    spec: Mapping[str, Any],
+) -> PantryPlanValidation | None:
+    """Return the exact verified formulation mode, or ``None`` on rejection."""
+
+    try:
+        parsed_spec = parse_pantry_plan_spec(spec)
+        allocations = parse_pantry_plan_candidate(candidate)
+        if not (
+            parsed_spec.min_ingredients
+            <= len(allocations)
+            <= parsed_spec.max_ingredients
+        ):
+            raise PantryPlanError("candidate uses the wrong number of ingredients")
+
+        by_id = parsed_spec.ingredient_by_id
+        totals: dict[str, Decimal] = {"mass_g": Decimal(0)}
+        for ingredient_id, grams in allocations:
+            ingredient = by_id.get(ingredient_id)
+            if ingredient is None:
+                raise PantryPlanError(f"unknown ingredient {ingredient_id!r}")
+            if ingredient.tags & parsed_spec.forbidden_tags:
+                raise PantryPlanError(f"ingredient {ingredient_id!r} is forbidden")
+            if (
+                grams < ingredient.min_if_used_g
+                or grams > ingredient.available_g
+                or grams % ingredient.step_g
+            ):
+                raise PantryPlanError(
+                    f"allocation for {ingredient_id!r} violates pantry bounds"
+                )
+            grams_decimal = Decimal(grams)
+            totals["mass_g"] += grams_decimal
+            for name, per_100g in ingredient.attributes_per_100g:
+                totals[name] = (
+                    totals.get(name, Decimal(0))
+                    + per_100g * grams_decimal / Decimal(100)
+                )
+
+        for target in parsed_spec.targets:
+            value = totals.get(target.attribute, Decimal(0))
+            if target.minimum is not None and value < target.minimum:
+                raise PantryPlanError(f"{target.attribute} is below its minimum")
+            if target.maximum is not None and value > target.maximum:
+                raise PantryPlanError(f"{target.attribute} exceeds its maximum")
+
+        support = tuple(ingredient_id for ingredient_id, _grams in allocations)
+        canonical_key = f"{PANTRY_PLAN_VERIFIER}:{PANTRY_PLAN_VERSION}:" + "+".join(
+            support
+        )
+        return PantryPlanValidation(
+            canonical_key=canonical_key,
+            allocations_g=allocations,
+            totals=tuple(sorted(totals.items())),
+        )
+    except (PantryPlanError, ArithmeticError, ValueError):
+        return None

code/oat_drgrpo/pantry_support_action.py

@@ -0,0 +1,180 @@
+"""Development adapter for support-first PantryPlan actions.
+
+The language policy chooses only the ingredient support.  A deterministic,
+trusted environment transition searches the registered quantity grid for the
+lexicographically first feasible allocation on exactly that support.  It never
+consults the certified support catalogue or a reference allocation.
+"""
+
+from __future__ import annotations
+
+from itertools import product
+import re
+from typing import Any, Mapping
+
+from .pantry_plan import (
+    PantryPlanError,
+    PantryPlanValidation,
+    parse_pantry_plan_spec,
+    validate_pantry_plan,
+)
+
+
+PANTRY_SUPPORT_ACTION_VERSION = "pantry-support-action-dev-v1"
+PANTRY_SUPPORT_MASK_TASK = "pantry_support_mask"
+PANTRY_SUPPORT_MASK_WIDTH = 6
+PANTRY_SUPPORT_MASK_INVALID = "__INVALID_PANTRY_SUPPORT_MASK__"
+_MAX_SUPPORT_CHARS = 256
+
+
+def parse_pantry_support_action(
+    candidate: str,
+    spec: Mapping[str, Any],
+) -> tuple[str, ...]:
+    """Parse a support-only action against the prompt-local ingredient IDs."""
+
+    parsed_spec = parse_pantry_plan_spec(spec)
+    text = str(candidate).strip()
+    if not text or len(text) > _MAX_SUPPORT_CHARS:
+        raise PantryPlanError("support action is empty or too long")
+    if text.startswith("{") and text.endswith("}"):
+        text = text[1:-1].strip()
+    text = re.sub(r"^(?:support|ingredients?)\s*[:=]\s*", "", text, flags=re.I)
+    pieces = tuple(
+        piece for piece in re.split(r"[\s,;+]+", text.lower()) if piece
+    )
+    if not parsed_spec.min_ingredients <= len(pieces) <= parsed_spec.max_ingredients:
+        raise PantryPlanError("support action uses the wrong number of ingredients")
+    if len(set(pieces)) != len(pieces):
+        raise PantryPlanError("support action contains a duplicate ingredient")
+    allowed = parsed_spec.ingredient_by_id
+    unknown = [piece for piece in pieces if piece not in allowed]
+    if unknown:
+        raise PantryPlanError(f"unknown ingredient {unknown[0]!r}")
+    return tuple(sorted(pieces))
+
+
+def project_pantry_support(
+    support: tuple[str, ...],
+    spec: Mapping[str, Any],
+) -> PantryPlanValidation | None:
+    """Search only the selected support's registered quantity lattice."""
+
+    parsed_spec = parse_pantry_plan_spec(spec)
+    by_id = parsed_spec.ingredient_by_id
+    if (
+        not parsed_spec.min_ingredients <= len(support) <= parsed_spec.max_ingredients
+        or len(set(support)) != len(support)
+        or any(ingredient_id not in by_id for ingredient_id in support)
+    ):
+        return None
+    grids = []
+    for ingredient_id in support:
+        ingredient = by_id[ingredient_id]
+        grids.append(
+            range(
+                ingredient.min_if_used_g,
+                ingredient.available_g + 1,
+                ingredient.step_g,
+            )
+        )
+    for quantities in product(*grids):
+        allocation = ";".join(
+            f"{ingredient_id}={grams}"
+            for ingredient_id, grams in zip(support, quantities)
+        )
+        validation = validate_pantry_plan(allocation, spec)
+        if validation is not None:
+            return validation
+    return None
+
+
+def validate_pantry_support_action(
+    candidate: str,
+    spec: Mapping[str, Any],
+) -> PantryPlanValidation | None:
+    """Return a verifier-bound mode after deterministic quantity projection."""
+
+    try:
+        support = parse_pantry_support_action(candidate, spec)
+    except (PantryPlanError, ValueError):
+        return None
+    return project_pantry_support(support, spec)
+
+def pantry_support_from_mask(
+    mask: str,
+    spec: Mapping[str, Any],
+) -> tuple[str, ...] | None:
+    """Decode one fixed-width inclusion mask using the public pantry row order."""
+
+    parsed_spec = parse_pantry_plan_spec(spec)
+    text = str(mask).strip()
+    if (
+        len(parsed_spec.ingredients) != PANTRY_SUPPORT_MASK_WIDTH
+        or len(text) != PANTRY_SUPPORT_MASK_WIDTH
+        or any(bit not in {"0", "1"} for bit in text)
+    ):
+        return None
+    support = tuple(
+        ingredient.ingredient_id
+        for bit, ingredient in zip(text, parsed_spec.ingredients)
+        if bit == "1"
+    )
+    if not parsed_spec.min_ingredients <= len(support) <= parsed_spec.max_ingredients:
+        return None
+    return tuple(sorted(support))
+
+
+def pantry_support_mask_from_allocation(
+    allocation: str,
+    spec: Mapping[str, Any],
+) -> str:
+    """Project a verifier-valid allocation onto its public-row support mask.
+
+    This is the inverse representation adapter needed when an offline replay
+    pool stores PantryPlan witnesses but the policy acts on the registered
+    support-mask surface. It validates the original witness first and changes
+    only its serialization; no replay row is dropped or deduplicated.
+    """
+
+    parsed_spec = parse_pantry_plan_spec(spec)
+    if len(parsed_spec.ingredients) != PANTRY_SUPPORT_MASK_WIDTH:
+        raise PantryPlanError(
+            "Pantry support masks require exactly "
+            f"{PANTRY_SUPPORT_MASK_WIDTH} public ingredient rows"
+        )
+    validation = validate_pantry_plan(allocation, spec)
+    if validation is None:
+        raise PantryPlanError("replayed Pantry allocation fails its verifier")
+    selected = {ingredient_id for ingredient_id, _grams in validation.allocations_g}
+    mask = "".join(
+        "1" if ingredient.ingredient_id in selected else "0"
+        for ingredient in parsed_spec.ingredients
+    )
+    decoded_support = pantry_support_from_mask(mask, spec)
+    if decoded_support != tuple(sorted(selected)):
+        raise PantryPlanError("Pantry allocation cannot be represented by its mask")
+    return mask
+
+
+def decode_pantry_support_mask(
+    mask: str,
+    spec: Mapping[str, Any],
+) -> str:
+    """Project a six-bit policy action into the exact allocation grader surface.
+
+    Every bit string is a syntactically valid fixed-horizon policy action.
+    Masks with an invalid support width or no feasible quantity assignment map
+    to a fail-closed sentinel that the ordinary PantryPlan verifier rejects.
+    """
+
+    support = pantry_support_from_mask(mask, spec)
+    if support is None:
+        return PANTRY_SUPPORT_MASK_INVALID
+    validation = project_pantry_support(support, spec)
+    if validation is None:
+        return PANTRY_SUPPORT_MASK_INVALID
+    return ";".join(
+        f"{ingredient_id}={grams}"
+        for ingredient_id, grams in validation.allocations_g
+    )

code/oat_drgrpo/python_modebench.py

@@ -0,0 +1,238 @@
+"""Restricted executable Python tasks for ModeBench.
+
+The model writes one pure ``lambda n: ...`` expression.  A separate worker
+process evaluates the function on a frozen prompt-local test suite.  A response
+is correct when every returned integer is a proper divisor of its input.  The
+semantic outcome is the complete vector returned by that same execution.
+
+This module owns the syntax and task contract.  The actual call to model code
+is made only by :mod:`oat_drgrpo.python_modebench_worker`.
+"""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from math import prod
+from typing import Any, Mapping
+
+
+PYTHON_FACTOR_VERIFIER = "python_factor_function"
+PYTHON_FACTOR_VERSION = "factor-v1"
+_MAX_CANDIDATE_CHARS = 240
+_MAX_AST_NODES = 64
+_MAX_CASES = 8
+
+_ALLOWED_NODE_TYPES = (
+    ast.Expression,
+    ast.Lambda,
+    ast.arguments,
+    ast.arg,
+    ast.IfExp,
+    ast.BoolOp,
+    ast.And,
+    ast.Or,
+    ast.Compare,
+    ast.Eq,
+    ast.NotEq,
+    ast.Lt,
+    ast.LtE,
+    ast.Gt,
+    ast.GtE,
+    ast.BinOp,
+    ast.Add,
+    ast.Sub,
+    ast.Mult,
+    ast.FloorDiv,
+    ast.Mod,
+    ast.UnaryOp,
+    ast.UAdd,
+    ast.USub,
+    ast.Not,
+    ast.Name,
+    ast.Load,
+    ast.Constant,
+)
+
+
+class PythonModeBenchError(ValueError):
+    """Raised for a malformed task or candidate program."""
+
+
+@dataclass(frozen=True)
+class PythonFactorValidation:
+    """Result of one successful external execution."""
+
+    canonical_key: str
+    outputs: tuple[int, ...]
+
+
+def _canonical_python_route_ast(node: ast.AST) -> str:
+    """Return a literal-abstracted strategy skeleton for restricted Python."""
+
+    if isinstance(node, ast.Expression):
+        return _canonical_python_route_ast(node.body)
+    if isinstance(node, ast.Lambda):
+        return f"lambda({_canonical_python_route_ast(node.body)})"
+    if isinstance(node, ast.Name):
+        return "input"
+    if isinstance(node, ast.Constant):
+        return "literal"
+    if isinstance(node, ast.UnaryOp):
+        return (
+            f"{type(node.op).__name__.lower()}"
+            f"({_canonical_python_route_ast(node.operand)})"
+        )
+    if isinstance(node, ast.BinOp):
+        op = type(node.op).__name__.lower()
+        children = [
+            _canonical_python_route_ast(node.left),
+            _canonical_python_route_ast(node.right),
+        ]
+        if isinstance(node.op, (ast.Add, ast.Mult)):
+            children.sort()
+        return f"{op}({','.join(children)})"
+    if isinstance(node, ast.Compare):
+        return "compare(" + ",".join(
+            [
+                _canonical_python_route_ast(node.left),
+                *(type(op).__name__.lower() for op in node.ops),
+                *(
+                    _canonical_python_route_ast(comparator)
+                    for comparator in node.comparators
+                ),
+            ]
+        ) + ")"
+    if isinstance(node, ast.BoolOp):
+        values = [_canonical_python_route_ast(value) for value in node.values]
+        values.sort()
+        return f"{type(node.op).__name__.lower()}({','.join(values)})"
+    if isinstance(node, ast.IfExp):
+        return (
+            f"if({_canonical_python_route_ast(node.test)},"
+            f"{_canonical_python_route_ast(node.body)},"
+            f"{_canonical_python_route_ast(node.orelse)})"
+        )
+    raise PythonModeBenchError(
+        f"cannot canonicalize Python route node {type(node).__name__}"
+    )
+
+
+def python_factor_route_signature(candidate: str) -> str:
+    """Return code-structure identity after the restricted parser accepts it."""
+
+    parsed = parse_python_factor_candidate(candidate)
+    return "python-factor-route:v1:" + _canonical_python_route_ast(parsed)
+
+
+def proper_divisors(value: int) -> tuple[int, ...]:
+    """Return all positive proper divisors other than one."""
+
+    value = int(value)
+    if value < 4:
+        return ()
+    return tuple(divisor for divisor in range(2, value) if value % divisor == 0)
+
+
+def python_factor_mode_count(cases: tuple[int, ...] | list[int]) -> int:
+    """Return the exact number of valid behavior vectors for a task."""
+
+    divisor_sets = [proper_divisors(value) for value in cases]
+    if any(not divisors for divisors in divisor_sets):
+        return 0
+    return prod(len(divisors) for divisors in divisor_sets)
+
+
+def parse_python_factor_spec(spec: Mapping[str, Any]) -> tuple[int, ...]:
+    """Validate a trusted dataset specification and return its tool inputs."""
+
+    if spec.get("verifier") != PYTHON_FACTOR_VERIFIER:
+        raise PythonModeBenchError("wrong Python ModeBench verifier")
+    if spec.get("python_version") != PYTHON_FACTOR_VERSION:
+        raise PythonModeBenchError("unsupported Python ModeBench version")
+    raw_cases = spec.get("cases")
+    if not isinstance(raw_cases, list) or not 2 <= len(raw_cases) <= _MAX_CASES:
+        raise PythonModeBenchError("cases must contain between two and eight inputs")
+    if any(isinstance(value, bool) or not isinstance(value, int) for value in raw_cases):
+        raise PythonModeBenchError("case inputs must be integers")
+    cases = tuple(int(value) for value in raw_cases)
+    if len(set(cases)) != len(cases):
+        raise PythonModeBenchError("case inputs must be unique")
+    if any(value < 4 or value > 1_000 for value in cases):
+        raise PythonModeBenchError("case inputs are outside the bounded domain")
+    if python_factor_mode_count(cases) < 2:
+        raise PythonModeBenchError("task does not have multiple valid modes")
+    return cases
+
+
+def parse_python_factor_candidate(candidate: str) -> ast.Expression:
+    """Parse the bounded, call-free lambda language."""
+
+    text = str(candidate).strip()
+    if not text or len(text) > _MAX_CANDIDATE_CHARS:
+        raise PythonModeBenchError("candidate is empty or too long")
+    try:
+        parsed = ast.parse(text, mode="eval")
+    except (SyntaxError, ValueError) as error:
+        raise PythonModeBenchError("candidate is not one Python expression") from error
+    if not isinstance(parsed.body, ast.Lambda):
+        raise PythonModeBenchError("candidate must be a lambda")
+    arguments = parsed.body.args
+    if (
+        len(arguments.args) != 1
+        or arguments.args[0].arg != "n"
+        or arguments.posonlyargs
+        or arguments.kwonlyargs
+        or arguments.vararg is not None
+        or arguments.kwarg is not None
+        or arguments.defaults
+        or arguments.kw_defaults
+    ):
+        raise PythonModeBenchError("lambda must have the exact signature lambda n")
+    nodes = list(ast.walk(parsed))
+    if len(nodes) > _MAX_AST_NODES:
+        raise PythonModeBenchError("candidate AST is too large")
+    for node in nodes:
+        if not isinstance(node, _ALLOWED_NODE_TYPES):
+            raise PythonModeBenchError(
+                f"unsupported Python syntax: {type(node).__name__}"
+            )
+        if isinstance(node, ast.Name) and node.id != "n":
+            raise PythonModeBenchError(f"unknown name: {node.id}")
+        if isinstance(node, ast.Constant):
+            if isinstance(node.value, bool) or not isinstance(node.value, int):
+                raise PythonModeBenchError("only integer literals are allowed")
+            if abs(int(node.value)) > 10_000:
+                raise PythonModeBenchError("integer literal is too large")
+    return parsed
+
+
+def execute_python_factor_candidate(
+    candidate: str,
+    spec: Mapping[str, Any],
+) -> PythonFactorValidation:
+    """Execute one already restricted candidate.
+
+    This entry point is worker-only.  Callers in the trainer and evaluator use
+    ``validate_python_factor_function_external`` so model code never executes
+    in their process.
+    """
+
+    cases = parse_python_factor_spec(spec)
+    parsed = parse_python_factor_candidate(candidate)
+    code = compile(parsed, "<modebench-python-factor>", "eval")
+    function = eval(code, {"__builtins__": {}}, {})  # noqa: S307
+    outputs: list[int] = []
+    for value in cases:
+        output = function(value)
+        if isinstance(output, bool) or not isinstance(output, int):
+            raise PythonModeBenchError("function output must be an integer")
+        output = int(output)
+        if output <= 1 or output >= value or value % output != 0:
+            raise PythonModeBenchError(
+                f"function returned {output}, not a proper divisor of {value}"
+            )
+        outputs.append(output)
+    output_tuple = tuple(outputs)
+    key = "python_factor:" + ",".join(str(value) for value in output_tuple)
+    return PythonFactorValidation(canonical_key=key, outputs=output_tuple)

code/oat_drgrpo/python_modebench_process.py

@@ -0,0 +1,135 @@
+"""Killable external execution boundary for ModeBench Python functions."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+import select
+import subprocess
+import sys
+import threading
+from typing import Any, Mapping
+
+from .python_modebench import PythonFactorValidation
+
+
+class PythonFactorVerifierProcess:
+    """Execute restricted candidate functions outside the trainer process."""
+
+    def __init__(self, *, timeout_seconds: float = 1.0) -> None:
+        if timeout_seconds <= 0:
+            raise ValueError("timeout_seconds must be positive")
+        self.timeout_seconds = float(timeout_seconds)
+        self._process: subprocess.Popen[str] | None = None
+        self._owner_pid = os.getpid()
+        self._lock = threading.Lock()
+
+    def _start(self) -> subprocess.Popen[str]:
+        if self._owner_pid != os.getpid():
+            self._process = None
+            self._owner_pid = os.getpid()
+        process = self._process
+        if process is not None and process.poll() is None:
+            return process
+        worker_env = os.environ.copy()
+        source_root = str(Path(__file__).resolve().parents[1])
+        inherited_pythonpath = worker_env.get("PYTHONPATH")
+        worker_env["PYTHONPATH"] = (
+            source_root
+            if not inherited_pythonpath
+            else source_root + os.pathsep + inherited_pythonpath
+        )
+        isolated_entrypoint = (
+            "import runpy,sys;"
+            f"sys.path.insert(0,{source_root!r});"
+            "runpy.run_module('oat_drgrpo.python_modebench_worker',run_name='__main__')"
+        )
+        self._process = subprocess.Popen(
+            [sys.executable, "-I", "-c", isolated_entrypoint],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=None,
+            text=True,
+            encoding="utf-8",
+            bufsize=1,
+            start_new_session=True,
+            env=worker_env,
+        )
+        return self._process
+
+    def _stop(self) -> None:
+        process, self._process = self._process, None
+        if process is None:
+            return
+        if process.poll() is None:
+            process.terminate()
+            try:
+                process.wait(timeout=1)
+            except subprocess.TimeoutExpired:
+                process.kill()
+                process.wait(timeout=1)
+        if process.stdin is not None:
+            process.stdin.close()
+        if process.stdout is not None:
+            process.stdout.close()
+
+    def close(self) -> None:
+        with self._lock:
+            self._stop()
+
+    def validate(
+        self,
+        candidate: str,
+        spec: Mapping[str, Any],
+    ) -> PythonFactorValidation | None:
+        request = json.dumps(
+            {"candidate": str(candidate), "spec": dict(spec)},
+            allow_nan=False,
+        )
+        with self._lock:
+            for attempt in range(2):
+                process = self._start()
+                try:
+                    assert process.stdin is not None and process.stdout is not None
+                    process.stdin.write(request + "\n")
+                    process.stdin.flush()
+                    readable, _, _ = select.select(
+                        [process.stdout], [], [], self.timeout_seconds
+                    )
+                    if not readable:
+                        self._stop()
+                        return None
+                    line = process.stdout.readline()
+                    if not line:
+                        raise BrokenPipeError("Python ModeBench worker closed stdout")
+                    payload = json.loads(line)
+                    if not payload.get("valid"):
+                        return None
+                    return PythonFactorValidation(
+                        canonical_key=str(payload["canonical_key"]),
+                        outputs=tuple(int(value) for value in payload["outputs"]),
+                    )
+                except (BrokenPipeError, OSError, ValueError, json.JSONDecodeError):
+                    self._stop()
+                    if attempt:
+                        return None
+        return None
+
+    def __del__(self) -> None:
+        try:
+            self._stop()
+        except Exception:
+            pass
+
+
+_SHARED_VERIFIER = PythonFactorVerifierProcess()
+
+
+def validate_python_factor_function_external(
+    candidate: str,
+    spec: Mapping[str, Any],
+) -> PythonFactorValidation | None:
+    """Validate a candidate through the shared external Python worker."""
+
+    return _SHARED_VERIFIER.validate(candidate, spec)

code/oat_drgrpo/python_modebench_worker.py

@@ -0,0 +1,43 @@
+"""JSON-lines worker that executes restricted ModeBench Python functions."""
+
+from __future__ import annotations
+
+import json
+import signal
+import sys
+
+from .python_modebench import execute_python_factor_candidate
+
+
+def _timeout(_signum, _frame) -> None:
+    raise TimeoutError("Python ModeBench candidate timed out")
+
+
+def main() -> None:
+    signal.signal(signal.SIGALRM, _timeout)
+    for line in sys.stdin:
+        try:
+            request = json.loads(line)
+            signal.setitimer(signal.ITIMER_REAL, 0.25)
+            validation = execute_python_factor_candidate(
+                request["candidate"],
+                request["spec"],
+            )
+            payload = {
+                "valid": True,
+                "canonical_key": validation.canonical_key,
+                "outputs": list(validation.outputs),
+            }
+        except Exception as error:
+            payload = {
+                "valid": False,
+                "error": type(error).__name__,
+            }
+        finally:
+            signal.setitimer(signal.ITIMER_REAL, 0)
+        sys.stdout.write(json.dumps(payload, allow_nan=False) + "\n")
+        sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()

code/oat_drgrpo/templates.py

@@ -0,0 +1,492 @@
+"""Prompt templates and response-token mask helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+
+import torch
+
+# Chat surfaces keep one benchmark contract portable across model families.
+# A surface supplies only the role markers; the system instruction and the user
+# body below are shared verbatim, so a Qwen prompt and its Falcon counterpart
+# differ in nothing but the tokens the base model was instruction-tuned on.
+# The Falcon markers reproduce tiiuae/Falcon3-*-Instruct's published chat
+# template byte for byte (``<|system|>\n...\n<|user|>\n...\n<|assistant|>\n``);
+# unlike Qwen's single-token ``<|im_start|>`` they encode as ordinary tokens,
+# which costs a few prompt tokens but leaves the response surface untouched.
+CHAT_SURFACES: dict[str, tuple[str, str, str]] = {
+    "qwen": (
+        "<|im_start|>system\n",
+        "<|im_end|>\n<|im_start|>user\n",
+        "<|im_end|>\n<|im_start|>assistant\n",
+    ),
+    "falcon": ("<|system|>\n", "\n<|user|>\n", "\n<|assistant|>\n"),
+}
+
+
+def render_chat_prompt(surface: str, system: str, user: str) -> str:
+    """Render one system/user turn onto a named chat surface."""
+
+    system_marker, user_marker, assistant_marker = CHAT_SURFACES[surface]
+    return system_marker + system + user_marker + user + assistant_marker
+
+
+_MATH_SYSTEM = (
+    "Please reason step by step, and put your final answer within \\boxed{}."
+)
+
+
+def apply_qwen_math_template(question: str) -> str:
+    return render_chat_prompt("qwen", _MATH_SYSTEM, question)
+
+
+def apply_falcon_math_template(question: str) -> str:
+    return render_chat_prompt("falcon", _MATH_SYSTEM, question)
+
+
+def apply_qwen_math_route_json_v1_template(question: str) -> str:
+    """Reproduce the frozen JSON-v1 Gate 1 prompt exactly."""
+
+    return (
+        "<|im_start|>system\n"
+        "Solve the problem step by step and put the final answer within "
+        "\\boxed{}. After the boxed answer, also emit exactly one compact "
+        "<route>JSON</route> block when the computation fits this schema: "
+        '{"version":"math-route-v1","steps":[...],"final":"sN"}. '
+        "Step IDs are contiguous s1,s2,... . A source step is "
+        '{"id":"s1","op":"source","value":"a number copied from the problem"}. '
+        "Other steps contain only id, op, and earlier args; never write a "
+        "result field. Allowed ops are neg, abs, square, cube, sqrt, factorial, "
+        "percent, add, mul, sub, div, pow, mod, choose, permute, gcd, lcm, min, "
+        "max, and average. Every step must contribute to final. If this exact "
+        "numeric trace language cannot express the solution, omit the route "
+        "block but still give the boxed answer."
+        "<|im_end|>\n<|im_start|>user\n"
+        + question
+        + "<|im_end|>\n<|im_start|>assistant\n"
+    )
+
+
+_MATH_ROUTE_SYSTEM = (
+        "Solve the problem step by step and put the final answer within "
+        "\\boxed{}. When the answer is computed from numbers in the problem, "
+        "end with exactly one compact reverse-Polish program between "
+        "<route> and </route>. Start the program with v2. Write copied input "
+        "numbers and operation words separated only by spaces. For example, "
+        "'<route>v2 2 5 mul 1 sub square 1 add</route>' computes "
+        "(2*5-1)^2+1. Unary operations are neg abs square cube sqrt factorial "
+        "percent. Binary operations are add mul sub div pow mod choose permute "
+        "gcd lcm min max average. A binary operation consumes the previous two "
+        "values in left-to-right order. Copy every numeric input from the "
+        "problem; never put a computed result, JSON, equations, labels, or "
+        "prose inside <route>. If this numeric stack language cannot express "
+        "the solution, omit <route> but still give the boxed answer."
+)
+
+
+def apply_qwen_math_route_template(question: str) -> str:
+    """Request a boxed answer plus a compact executable numeric route."""
+
+    return render_chat_prompt("qwen", _MATH_ROUTE_SYSTEM, question)
+
+
+def apply_falcon_math_route_template(question: str) -> str:
+    """Falcon-surface twin of :func:`apply_qwen_math_route_template`."""
+
+    return render_chat_prompt("falcon", _MATH_ROUTE_SYSTEM, question)
+
+
+_BOXED_SYSTEM = "Return only the final answer inside \\boxed{}. Do not explain."
+
+
+def apply_qwen_boxed_template(question: str) -> str:
+    return render_chat_prompt("qwen", _BOXED_SYSTEM, question)
+
+
+def apply_falcon_boxed_template(question: str) -> str:
+    return render_chat_prompt("falcon", _BOXED_SYSTEM, question)
+
+
+_LEVEL2_HYBRID_SYSTEMS = {
+    "countdown": (
+        "Solve the executable constraint problem carefully. You may reason briefly, "
+        "but end with exactly one final answer inside \\boxed{}. Systematically combine "
+        "every supplied number exactly once using +, -, *, /, and parentheses. Check "
+        "the exact target before answering. Output exactly the boxed expression."
+    ),
+    "python_factors": (
+        "Solve the executable constraint problem carefully. You may reason briefly, "
+        "but end with exactly one final answer inside \\boxed{}. Construct one allowed "
+        "lambda expression. Test small divisors with nested conditional expressions, "
+        "for example 2 if n % 2 == 0 else 3 if n % 3 == 0 else 5, but adapt the "
+        "tests to every listed case. You may instead dispatch on each listed value. "
+        "Output exactly the boxed lambda."
+    ),
+    "mathir": (
+        "Solve the executable constraint problem carefully. You may reason briefly, "
+        "but end with exactly one final answer inside \\boxed{}. Use algebraic isolation: "
+        "move the right-side x term left, remove the left constant, then divide by the "
+        "combined coefficient. Match those operations to the shuffled menu IDs."
+    ),
+    "pantry": (
+        "Solve the executable constraint problem carefully. You may reason briefly, "
+        "but end with exactly one final answer inside \\boxed{}. Prefer allowed "
+        "high-energy/protein, very-low-sodium ingredients, especially seeds or oats. "
+        "Choose stepped amounts, check every bound, and output 2 to 4 "
+        "ingredient_id=grams pairs."
+    ),
+}
+
+
+def apply_qwen_level2_countdown_template(question: str) -> str:
+    return render_chat_prompt("qwen", _LEVEL2_HYBRID_SYSTEMS["countdown"], question)
+
+
+def apply_qwen_level2_python_factors_template(question: str) -> str:
+    return render_chat_prompt("qwen", _LEVEL2_HYBRID_SYSTEMS["python_factors"], question)
+
+
+def apply_qwen_level2_mathir_template(question: str) -> str:
+    return render_chat_prompt("qwen", _LEVEL2_HYBRID_SYSTEMS["mathir"], question)
+
+
+def apply_qwen_level2_pantry_template(question: str) -> str:
+    return render_chat_prompt("qwen", _LEVEL2_HYBRID_SYSTEMS["pantry"], question)
+
+
+_GRAPH_DIGITS_SYSTEM = (
+    "Return only the requested bare sequence of digits. Do not explain, "
+    "add punctuation, or use LaTeX."
+)
+
+
+def _graph_digits_user(question: str, template_name: str) -> str:
+    boxed_suffix = "inside \\boxed{}."
+    if question.count(boxed_suffix) != 1 or not question.endswith(boxed_suffix):
+        raise ValueError(
+            f"{template_name} requires a graph prompt ending in a boxed answer"
+        )
+    return (
+        question[: -len(boxed_suffix)]
+        + "as one bare digit string with no spaces, punctuation, or other text."
+    )
+
+
+def apply_qwen_graph_digits_template(question: str) -> str:
+    """Request the benchmark's canonical bare graph-color action vector."""
+
+    return render_chat_prompt(
+        "qwen",
+        _GRAPH_DIGITS_SYSTEM,
+        _graph_digits_user(question, "qwen_graph_digits"),
+    )
+
+
+def apply_falcon_graph_digits_template(question: str) -> str:
+    """Falcon-surface twin of :func:`apply_qwen_graph_digits_template`."""
+
+    return render_chat_prompt(
+        "falcon",
+        _GRAPH_DIGITS_SYSTEM,
+        _graph_digits_user(question, "falcon_graph_digits"),
+    )
+
+
+_COUNTDOWN_DIGITS_SYSTEM = (
+    "Return only three digits and no other text. The given numbers are "
+    "n1,n2,n3 in dataset order. Digit 2 selects singleton s: 1=n1, "
+    "2=n2, 3=n3; a,b are the other two numbers in their original order. "
+    "Digit 3 makes pair: 1=a+b, 2=a*b, 3=a-b, 4=b-a, 5=a/b, 6=b/a. "
+    "Digit 1 combines pair and s: 1=pair+s, 2=pair*s, 3=pair-s, "
+    "4=s-pair, 5=pair/s, 6=s/pair."
+)
+
+
+def _countdown_digits_user(question: str, template_name: str) -> str:
+    boxed_suffix = "the expression inside \\boxed{}."
+    if question.count(boxed_suffix) != 1 or not question.endswith(boxed_suffix):
+        raise ValueError(
+            f"{template_name} requires an easy3 Countdown prompt ending "
+            "in the boxed-expression instruction"
+        )
+    return (
+        question[: -len(boxed_suffix)]
+        + "a three-digit canonical action code using the scheme above."
+    )
+
+
+def apply_qwen_countdown_digits_template(question: str) -> str:
+    """Request the audited three-digit Countdown expression code."""
+
+    return render_chat_prompt(
+        "qwen",
+        _COUNTDOWN_DIGITS_SYSTEM,
+        _countdown_digits_user(question, "qwen_countdown_digits"),
+    )
+
+
+def apply_falcon_countdown_digits_template(question: str) -> str:
+    """Falcon-surface twin of :func:`apply_qwen_countdown_digits_template`."""
+
+    return render_chat_prompt(
+        "falcon",
+        _COUNTDOWN_DIGITS_SYSTEM,
+        _countdown_digits_user(question, "falcon_countdown_digits"),
+    )
+
+
+_PANTRY_SUPPORT_MASK_SYSTEM = (
+    "Return only six binary digits and no other text. Each digit maps to "
+    "the corresponding Pantry row in printed order. A trusted environment "
+    "will choose exact quantities on precisely the selected rows."
+)
+
+
+def _pantry_support_mask_user(question: str, template_name: str) -> str:
+    suffix = (
+        "Return only ingredient_id=grams pairs separated by semicolons inside "
+        "\\boxed{}. Do not add a recipe name or preparation prose."
+    )
+    if question.count(suffix) != 1 or not question.endswith(suffix):
+        raise ValueError(
+            f"{template_name} requires the frozen PantryPlan answer suffix"
+        )
+    return (
+        question[: -len(suffix)]
+        + "Choose the ingredient support as a six-bit mask in the exact Pantry "
+        "row order. Bit 1 includes that row and bit 0 excludes it."
+    )
+
+
+def apply_qwen_pantry_support_mask_template(question: str) -> str:
+    """Request a six-bit ingredient-support action in printed pantry order."""
+
+    return render_chat_prompt(
+        "qwen",
+        _PANTRY_SUPPORT_MASK_SYSTEM,
+        _pantry_support_mask_user(question, "qwen_pantry_support_mask"),
+    )
+
+
+def apply_falcon_pantry_support_mask_template(question: str) -> str:
+    """Falcon-surface twin of :func:`apply_qwen_pantry_support_mask_template`."""
+
+    return render_chat_prompt(
+        "falcon",
+        _PANTRY_SUPPORT_MASK_SYSTEM,
+        _pantry_support_mask_user(question, "falcon_pantry_support_mask"),
+    )
+
+
+# Every canonical-action task admits exactly one prompt template per chat
+# surface.  Binding the task to that closed set keeps a Falcon run from
+# silently training against Qwen role markers the base model never saw.
+CANONICAL_TASK_PROMPT_TEMPLATES: dict[str, frozenset[str]] = {
+    "graph_coloring": frozenset({"qwen_graph_digits", "falcon_graph_digits"}),
+    "countdown": frozenset(
+        {"qwen_countdown_digits", "falcon_countdown_digits"}
+    ),
+    "pantry_support_mask": frozenset(
+        {"qwen_pantry_support_mask", "falcon_pantry_support_mask"}
+    ),
+}
+
+
+def validate_canonical_prompt_materialization(
+    prompt_template: str,
+    raw_questions: Sequence[str],
+    formatted_prompts: Sequence[str],
+) -> None:
+    """Fail closed if dataset mapping did not render the canonical template.
+
+    The exact string comparison deliberately detects stale Hugging Face map
+    caches from older prompt templates as well as dropped or reordered rows.
+    Re-applying ``TEMPLATE_FACTORY[prompt_template]`` rather than a hardcoded
+    function makes the check family-agnostic: a Falcon-surface run is held to
+    its own template and cannot pass on Qwen-rendered rows.
+    """
+
+    if len(raw_questions) != len(formatted_prompts):
+        raise RuntimeError(
+            "canonical prompt materialization changed the row count: "
+            f"raw={len(raw_questions)} formatted={len(formatted_prompts)}"
+        )
+    apply_template = TEMPLATE_FACTORY[prompt_template]
+    for row_index, (question, observed) in enumerate(
+        zip(raw_questions, formatted_prompts)
+    ):
+        if observed != apply_template(question):
+            raise RuntimeError(
+                f"canonical {prompt_template} prompt materialization mismatch "
+                f"at row {row_index}; stale or foreign template cache detected"
+            )
+
+
+def validate_qwen_graph_digits_materialization(
+    raw_questions: Sequence[str], formatted_prompts: Sequence[str]
+) -> None:
+    """Fail closed on stale or foreign canonical graph prompt rows."""
+
+    validate_canonical_prompt_materialization(
+        "qwen_graph_digits", raw_questions, formatted_prompts
+    )
+
+
+def validate_qwen_countdown_digits_materialization(
+    raw_questions: Sequence[str], formatted_prompts: Sequence[str]
+) -> None:
+    """Fail closed on stale or foreign canonical Countdown prompt rows."""
+
+    validate_canonical_prompt_materialization(
+        "qwen_countdown_digits", raw_questions, formatted_prompts
+    )
+
+
+def validate_qwen_pantry_support_mask_materialization(
+    raw_questions: Sequence[str], formatted_prompts: Sequence[str]
+) -> None:
+    """Fail closed on stale or foreign Pantry support-mask prompt rows."""
+
+    validate_canonical_prompt_materialization(
+        "qwen_pantry_support_mask", raw_questions, formatted_prompts
+    )
+
+
+def apply_r1_template(question: str) -> str:
+    return (
+        "A conversation between User and Assistant. The User asks a question, "
+        "and the Assistant solves it. The Assistant first thinks about the "
+        "reasoning process in the mind and then provides the User with the "
+        "answer. The reasoning process is enclosed within <think> </think> "
+        "and answer is enclosed within <answer> </answer> tags, respectively, "
+        "i.e., <think> reasoning process here </think> <answer> answer here "
+        "</answer>.\nUser: " + question + "\nAssistant: <think>"
+    )
+
+
+def apply_no_template(question: str) -> str:
+    return question
+
+
+TEMPLATE_FACTORY: dict[str, Callable[[str], str]] = {
+    "qwen_boxed": apply_qwen_boxed_template,
+    "qwen_countdown_digits": apply_qwen_countdown_digits_template,
+    "qwen_graph_digits": apply_qwen_graph_digits_template,
+    "qwen_pantry_support_mask": apply_qwen_pantry_support_mask_template,
+    "qwen_math": apply_qwen_math_template,
+    "qwen_math_route": apply_qwen_math_route_template,
+    "qwen_level2_countdown": apply_qwen_level2_countdown_template,
+    "qwen_level2_python_factors": apply_qwen_level2_python_factors_template,
+    "qwen_level2_mathir": apply_qwen_level2_mathir_template,
+    "qwen_level2_pantry": apply_qwen_level2_pantry_template,
+    "falcon_boxed": apply_falcon_boxed_template,
+    "falcon_countdown_digits": apply_falcon_countdown_digits_template,
+    "falcon_graph_digits": apply_falcon_graph_digits_template,
+    "falcon_pantry_support_mask": apply_falcon_pantry_support_mask_template,
+    "falcon_math": apply_falcon_math_template,
+    "falcon_math_route": apply_falcon_math_route_template,
+    "r1": apply_r1_template,
+    "no": apply_no_template,
+}
+
+# The Qwen and Falcon families must stay a pure surface swap of one contract.
+PROMPT_TEMPLATE_FAMILY_TWINS: dict[str, str] = {
+    "qwen_boxed": "falcon_boxed",
+    "qwen_countdown_digits": "falcon_countdown_digits",
+    "qwen_graph_digits": "falcon_graph_digits",
+    "qwen_pantry_support_mask": "falcon_pantry_support_mask",
+    "qwen_math": "falcon_math",
+    "qwen_math_route": "falcon_math_route",
+}
+
+# A template's *role* is the training contract it encodes; the chat surface is
+# an implementation detail of the base model. Argument validation keys off the
+# role so a Falcon run is held to exactly the Qwen run's contract.
+PROMPT_TEMPLATE_ROLES: dict[str, str] = {
+    "qwen_boxed": "boxed",
+    "falcon_boxed": "boxed",
+    "qwen_countdown_digits": "countdown_digits",
+    "falcon_countdown_digits": "countdown_digits",
+    "qwen_graph_digits": "graph_digits",
+    "falcon_graph_digits": "graph_digits",
+    "qwen_pantry_support_mask": "pantry_support_mask",
+    "falcon_pantry_support_mask": "pantry_support_mask",
+    "qwen_math": "math",
+    "falcon_math": "math",
+    "qwen_math_route": "math_route",
+    "qwen_level2_countdown": "boxed",
+    "qwen_level2_python_factors": "boxed",
+    "qwen_level2_mathir": "boxed",
+    "qwen_level2_pantry": "boxed",
+    "falcon_math_route": "math_route",
+    "r1": "r1",
+    "no": "no",
+}
+
+CANONICAL_DIGIT_TEMPLATE_ROLES: frozenset[str] = frozenset(
+    {"graph_digits", "countdown_digits", "pantry_support_mask"}
+)
+
+
+def prompt_template_role(prompt_template: str) -> str:
+    """Return the surface-independent training contract a template encodes."""
+
+    return PROMPT_TEMPLATE_ROLES[prompt_template]
+
+
+def prompt_template_surface(prompt_template: str) -> str:
+    """Return the chat surface family a template renders onto."""
+
+    for surface in CHAT_SURFACES:
+        if prompt_template.startswith(f"{surface}_"):
+            return surface
+    return "none"
+
+
+def apply_prompt_template_to_example(
+    example: dict,
+    *,
+    input_key: str,
+    prompt_template: str,
+) -> dict:
+    """Apply a configured prompt template to one dataset row."""
+
+    problem = example[input_key]
+    example[input_key] = TEMPLATE_FACTORY[prompt_template](problem)
+    return example
+
+
+def collate_eval_prompt_items(
+    item_list: list[dict],
+    *,
+    prompt_template: str,
+) -> tuple[list[str], list[str], list[str]]:
+    """Collate eval rows into templated prompts, raw problems, and answers."""
+
+    problems = []
+    formatted_problems = []
+    answers = []
+    for item in item_list:
+        problems.append(item["problem"])
+        formatted_problems.append(TEMPLATE_FACTORY[prompt_template](item["problem"]))
+        answers.append(item["answer"])
+    return formatted_problems, problems, answers
+
+
+def build_response_token_prefix_mask(
+    response_masks: torch.Tensor,
+    token_counts: torch.Tensor,
+) -> torch.Tensor:
+    """Select the first ``token_counts`` response tokens in each row."""
+
+    if response_masks.ndim != 2:
+        raise ValueError("response_masks must have shape [batch, seq].")
+    if token_counts.ndim != 1 or token_counts.shape[0] != response_masks.shape[0]:
+        raise ValueError(
+            "token_counts must have shape [batch] matching response_masks."
+        )
+    safe_counts = token_counts.to(
+        device=response_masks.device, dtype=torch.int64
+    ).clamp(min=0)
+    response_positions = response_masks.to(torch.int64).cumsum(dim=1)
+    return response_masks.to(torch.bool) & (response_positions <= safe_counts[:, None])

data/level1_countdown/eval.parquet

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

data/level1_countdown/train.parquet

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

data/level1_graph_coloring/eval.parquet

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

data/level1_graph_coloring/train.parquet

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

data/level1_graph_coloring_unique_answer/eval.parquet

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

data/level1_mathir/eval.parquet

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

data/level1_mathir/train.parquet

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

data/level1_pantry_plan/dev.parquet

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

data/level1_pantry_plan/eval.parquet

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

data/level1_pantry_plan/train.parquet

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

data/level1_python_factors/eval.parquet

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

data/level1_python_factors/train.parquet

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

data/level2_countdown/dev.parquet

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

data/level2_countdown/eval.parquet

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

data/level2_countdown/train.parquet

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

data/level2_graph_coloring/dev.parquet

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

data/level2_graph_coloring/eval.parquet

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

data/level2_graph_coloring/train.parquet

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

data/level2_mathir/dev.parquet

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