robbiethompson2018 commited on
Commit
17d7d2d
·
verified ·
1 Parent(s): c0c00bc

Add 508-claude_train-loops-1-4_s1

Browse files
runs/508-claude_train-loops-1-4_s1/eval_dev.jsonl ADDED
The diff for this file is too large to render. See raw diff
 
runs/508-claude_train-loops-1-4_s1/final.pt ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:031cb866caff1465c5ca9bb7964eaf8df96fb02f479dc735de13c2beb5782f45
3
+ size 25624925
runs/508-claude_train-loops-1-4_s1/found_targets.jsonl ADDED
The diff for this file is too large to render. See raw diff
 
runs/508-claude_train-loops-1-4_s1/lean_gate.disagree.jsonl ADDED
@@ -0,0 +1,7 @@
 
 
 
 
 
 
 
 
1
+ {"prompt": "THM Q , ( ( ( ~ R ) > ( P v Q ) ) v Q ) SEQ ( ( ~ ( ~ ( ~ S ) ) ) > ( ( ~ R ) > ( P v Q ) ) ) PRF", "lean_text": "have n59 : Q := h1 ; have n60 : ( ( ( ¬ R ) → ( P ∨ Q ) ) ∨ Q ) := Or.inr n59 ; have n61 : ( ( ¬ ( ¬ ( ¬ S ) ) ) → ( ( ¬ R ) → ( P ∨ Q ) ) ) := ( fun ( n62 : ( ¬ ( ¬ ( ¬ S ) ) ) ) => by have n63 : ( ( ¬ R ) → ( P ∨ Q ) ) := ( fun ( n64 : ( ¬ R ) ) => by have n64 : ( P ∨ Q ) := Or.inr n59 ; exact n64 ) ; exact n63 ) ; exact n61", "nd": "N1 Q : PR ; N2 ( ( ( ~ R ) > ( P v Q ) ) v Q ) : ORI2 N1 ; N3 | ( ~ ( ~ ( ~ S ) ) ) : AS ; N4 | | ( ~ R ) : AS ; N5 | | ( P v Q ) : ORI2 N1 ; N6 | ( ( ~ R ) > ( P v Q ) ) : IMPI N4 N5 ; N7 ( ( ~ ( ~ ( ~ S ) ) ) > ( ( ~ R ) > ( P v Q ) ) ) : IMPI N3 N6 ; QED", "nd_ok": false, "lean_ok": true}
2
+ {"prompt": "THM Q , ( ( ( ~ R ) > ( P v Q ) ) v Q ) SEQ ( ( ~ ( ~ ( ~ S ) ) ) > ( ( ~ R ) > ( P v Q ) ) ) PRF", "lean_text": "have n35 : Q := h1 ; have n36 : ( ( ( ¬ R ) → ( P ∨ Q ) ) ∨ Q ) := Or.inr n35 ; have n37 : ( ( ¬ ( ¬ ( ¬ S ) ) ) → ( ( ¬ R ) → ( P ∨ Q ) ) ) := ( fun ( n38 : ( ¬ ( ¬ ( ¬ S ) ) ) ) => by have n39 : ( ( ¬ R ) → ( P ∨ Q ) ) := ( fun ( n40 : ( ¬ R ) ) => by have n41 : ( P ∨ Q ) := Or.inr n35 ; exact n41 ) ; exact n39 ) ; exact n37", "nd": "N1 Q : PR ; N2 ( ( ( ~ R ) > ( P v Q ) ) v Q ) : ORI2 N1 ; N3 | ( ~ ( ~ ( ~ S ) ) ) : AS ; N4 | | ( ~ R ) : AS ; N5 | | ( P v Q ) : ORI2 N1 ; N6 | ( ( ~ R ) > ( P v Q ) ) : IMPI N4 N5 ; N7 ( ( ~ ( ~ ( ~ S ) ) ) > ( ( ~ R ) > ( P v Q ) ) ) : IMPI N3 N6 ; QED", "nd_ok": false, "lean_ok": true}
3
+ {"prompt": "THM Q , ( ( ( ~ R ) > ( P v Q ) ) v Q ) SEQ ( ( ~ ( ~ ( ~ S ) ) ) > ( ( ~ R ) > ( P v Q ) ) ) PRF", "lean_text": "have n16 : Q := h1 ; have n17 : ( ( ( ¬ R ) → ( P ∨ Q ) ) ∨ Q ) := Or.inr n16 ; have n18 : ( ( ¬ ( ¬ ( ¬ S ) ) ) → ( ( ¬ R ) → ( P ∨ Q ) ) ) := ( fun ( n19 : ( ¬ ( ¬ ( ¬ S ) ) ) ) => by have n20 : ( ( ¬ R ) → ( P ∨ Q ) ) := ( fun ( n21 : ( ¬ R ) ) => by have n22 : ( P ∨ Q ) := Or.inr n16 ; exact n22 ) ; exact n20 ) ; exact n18", "nd": "N1 Q : PR ; N2 ( ( ( ~ R ) > ( P v Q ) ) v Q ) : ORI2 N1 ; N3 | ( ~ ( ~ ( ~ S ) ) ) : AS ; N4 | | ( ~ R ) : AS ; N5 | | ( P v Q ) : ORI2 N1 ; N6 | ( ( ~ R ) > ( P v Q ) ) : IMPI N4 N5 ; N7 ( ( ~ ( ~ ( ~ S ) ) ) > ( ( ~ R ) > ( P v Q ) ) ) : IMPI N3 N6 ; QED", "nd_ok": false, "lean_ok": true}
4
+ {"prompt": "THM Q , ( ( ( ~ R ) > ( P v Q ) ) v Q ) SEQ ( ( ~ ( ~ ( ~ S ) ) ) > ( ( ~ R ) > ( P v Q ) ) ) PRF", "lean_text": "have n32 : Q := h1 ; have n33 : ( ( ( ¬ R ) → ( P ∨ Q ) ) ∨ Q ) := Or.inr n32 ; have n34 : ( ( ¬ ( ¬ ( ¬ S ) ) ) → ( ( ¬ R ) → ( P ∨ Q ) ) ) := ( fun ( n35 : ( ¬ ( ¬ ( ¬ S ) ) ) ) => by have n36 : ( ( ¬ R ) → ( P ∨ Q ) ) := ( fun ( n37 : ( ¬ R ) ) => by have n38 : ( P ∨ Q ) := Or.inr n32 ; exact n38 ) ; exact n36 ) ; exact n34", "nd": "N1 Q : PR ; N2 ( ( ( ~ R ) > ( P v Q ) ) v Q ) : ORI2 N1 ; N3 | ( ~ ( ~ ( ~ S ) ) ) : AS ; N4 | | ( ~ R ) : AS ; N5 | | ( P v Q ) : ORI2 N1 ; N6 | ( ( ~ R ) > ( P v Q ) ) : IMPI N4 N5 ; N7 ( ( ~ ( ~ ( ~ S ) ) ) > ( ( ~ R ) > ( P v Q ) ) ) : IMPI N3 N6 ; QED", "nd_ok": false, "lean_ok": true}
5
+ {"prompt": "THM Q , ( Q v Q ) SEQ ( ( ( S & Q ) & Q ) > ( ( ~ ( ~ P ) ) > ( ( ( ~ ( ~ P ) ) & Q ) v ( ~ ( R & R ) ) ) ) ) PRF", "lean_text": "have n30 : Q := h1 ; have n31 : ( Q ∨ Q ) := Or.inr n30 ; have n32 : ( ( ( S ∧ Q ) ∧ Q ) → ( ( ¬ ( ¬ P ) ) → ( ( ( ¬ ( ¬ P ) ) ∧ Q ) ∨ ( ¬ ( R ∧ R ) ) ) ) ) := ( fun ( n33 : ( ( S ∧ Q ) ∧ Q ) ) => by have n34 : ( ( ¬ ( ¬ P ) ) → ( ( ( ¬ ( ¬ P ) ) ∧ Q ) ∨ ( ¬ ( R ∧ R ) ) ) ) := ( fun ( n35 : ( ¬ ( ¬ P ) ) ) => by have n36 : ( ( ¬ ( ¬ P ) ) ∧ Q ) := ⟨ n35 , n30 ⟩ ; have n37 : ( ( ( ¬ ( ¬ P ) ) ∧ Q ) ∨ ( ¬ ( R ∧ R ) ) ) := Or.inl n36 ; exact n37 ) ; exact n34 ) ; exact n32", "nd": "N1 Q : PR ; N2 ( Q v Q ) : ORI2 N1 ; N3 | ( ( S & Q ) & Q ) : AS ; N4 | | ( ~ ( ~ P ) ) : AS ; N5 | | ( ( ~ ( ~ P ) ) & Q ) : ANDI N4 N1 ; N6 | | ( ( ( ~ ( ~ P ) ) & Q ) v ( ~ ( R & R ) ) ) : ORI1 N5 ; N7 | ( ( ~ ( ~ P ) ) > ( ( ( ~ ( ~ P ) ) & Q ) v ( ~ ( R & R ) ) ) ) : IMPI N4 N6 ; N8 ( ( ( S & Q ) & Q ) > ( ( ~ ( ~ P ) ) > ( ( ( ~ ( ~ P ) ) & Q ) v ( ~ ( R & R ) ) ) ) ) : IMPI N3 N7 ; QED", "nd_ok": false, "lean_ok": true}
6
+ {"prompt": "THM ( S v ( S & R ) ) , ( ~ S ) SEQ ( ~ P ) PRF", "lean_text": "have n48 : ( S ∨ ( S ∧ R ) ) := h1 ; have n49 : ( ¬ S ) := h2 ; have n50 : ( ¬ P ) := ( fun ( n51 : P ) => by have n52 : S := Or.elim n48 ( fun ( n53 : S ) => by exact n53 ) ( fun ( n54 : ( S ∧ R ) ) => by have n55 : S := n54.1 ; exact n55 ) ; have n56 : False := n49 n52 ; exact n56 ) ; exact n50", "nd": "N1 ( S v ( S & R ) ) : PR ; N2 ( ~ S ) : PR ; N3 | P : AS ; N4 | | S : AS ; N5 | | ( S & R ) : AS ; N6 | | S : ANDE1 N5 ; N7 | S : ORE N1 N4 N4 N5 N6 ; N8 | F : NEGE N7 N2 ; N9 ( ~ P ) : IMPI N3 N8 ; QED", "nd_ok": false, "lean_ok": true}
7
+ {"prompt": "THM ( S v ( S & R ) ) , ( ~ S ) SEQ ( ~ P ) PRF", "lean_text": "have n58 : ( S ∨ ( S ∧ R ) ) := h1 ; have n59 : ( ¬ S ) := h2 ; have n60 : S := Or.elim n58 ( fun ( n61 : S ) => by exact n61 ) ( fun ( n62 : ( S ∧ R ) ) => by have n63 : S := n62.1 ; exact n63 ) ; have n64 : ( ¬ P ) := ( fun ( n64 : P ) => by have n64 : False := n59 n60 ; exact n64 ) ; exact n64", "nd": "N1 ( S v ( S & R ) ) : PR ; N2 ( ~ S ) : PR ; N3 | S : AS ; N4 | ( S & R ) : AS ; N5 | S : ANDE1 N4 ; N6 S : ORE N1 N3 N3 N4 N5 ; N7 | P : AS ; N8 | F : NEGE N6 N2 ; N9 ( ~ P ) : IMPI N7 N8 ; QED", "nd_ok": false, "lean_ok": true}
runs/508-claude_train-loops-1-4_s1/lean_gate.jsonl ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {"utc": "2026-10-07T21:38:16Z", "samples": 2000, "parse_fail": 8, "distinct_checked": 1992, "both_ok": 1933, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 59, "parse_reasons": {"unbound": 4, "trailing tokens": 2, "no-eos": 1, "name": 1}, "lean_wall_s": 4.593599796295166, "lean_proc_s": 22.12117290496826, "nd_verify_s": 0.09451818466186523, "workers": 96, "chunk": 400}
2
+ {"utc": "2026-10-07T21:39:11Z", "samples": 12000, "parse_fail": 5239, "distinct_checked": 6558, "both_ok": 1434, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 5, "both_rej": 5119, "parse_reasons": {"unbound": 3928, "formula": 599, "exact not last": 254, "no-eos": 172, "name": 116, "expected )": 64, "expected (": 48, "expected False": 22, "trailing tokens": 17, "expected :=": 11, "PR position": 3, "ORE box": 2, "expected exact": 1, "expected .elim": 1, "expected ;": 1}, "lean_wall_s": 21.53453516960144, "lean_proc_s": 349.0077497959137, "nd_verify_s": 0.3137397766113281, "workers": 96, "chunk": 400}
3
+ {"utc": "2026-10-07T21:40:01Z", "samples": 8496, "parse_fail": 3557, "distinct_checked": 4549, "both_ok": 480, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 4069, "parse_reasons": {"unbound": 2769, "formula": 296, "name": 120, "exact not last": 91, "expected )": 83, "no-eos": 69, "expected (": 45, "expected False": 33, "expected :=": 25, "trailing tokens": 9, "expected exact": 4, "expected .elim": 3, "PR position": 3, "ORE box": 3, "expected =>": 2, "eof": 1, "expected None": 1}, "lean_wall_s": 15.234448909759521, "lean_proc_s": 174.76333093643188, "nd_verify_s": 0.22825956344604492, "workers": 96, "chunk": 400}
4
+ {"utc": "2026-10-07T21:41:12Z", "samples": 8472, "parse_fail": 2963, "distinct_checked": 5084, "both_ok": 689, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 4395, "parse_reasons": {"unbound": 2240, "formula": 196, "name": 155, "exact not last": 100, "expected (": 77, "no-eos": 76, "expected )": 50, "expected :=": 23, "expected False": 21, "trailing tokens": 11, "PR position": 4, "expected exact": 3, "ORE box": 3, "expected =>": 2, "expected .elim": 1, "expected ;": 1}, "lean_wall_s": 16.971303701400757, "lean_proc_s": 217.87392592430115, "nd_verify_s": 0.27953505516052246, "workers": 96, "chunk": 400}
5
+ {"utc": "2026-10-07T21:43:02Z", "samples": 8472, "parse_fail": 2864, "distinct_checked": 5145, "both_ok": 701, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 4444, "parse_reasons": {"unbound": 2089, "formula": 276, "name": 170, "exact not last": 91, "expected (": 90, "no-eos": 59, "expected )": 38, "expected False": 19, "expected exact": 10, "trailing tokens": 10, "expected :=": 4, "PR position": 4, "expected .elim": 3, "ORE box": 1}, "lean_wall_s": 21.633245944976807, "lean_proc_s": 278.0218906402588, "nd_verify_s": 0.2858917713165283, "workers": 96, "chunk": 400}
6
+ {"utc": "2026-10-07T21:45:21Z", "samples": 12000, "parse_fail": 1524, "distinct_checked": 10036, "both_ok": 6047, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 1, "both_rej": 3988, "parse_reasons": {"unbound": 1128, "formula": 134, "name": 77, "expected :=": 43, "expected )": 35, "exact not last": 34, "expected (": 29, "no-eos": 19, "ORE box": 14, "PR position": 10, "expected ;": 1}, "lean_wall_s": 31.103293418884277, "lean_proc_s": 768.4505350589752, "nd_verify_s": 0.5587365627288818, "workers": 96, "chunk": 400}
7
+ {"utc": "2026-10-07T21:45:51Z", "samples": 4704, "parse_fail": 1212, "distinct_checked": 3181, "both_ok": 110, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 3071, "parse_reasons": {"unbound": 891, "formula": 106, "name": 71, "expected )": 66, "expected :=": 23, "expected (": 17, "ORE box": 17, "exact not last": 13, "no-eos": 4, "expected ;": 3, "PR position": 1}, "lean_wall_s": 12.643057584762573, "lean_proc_s": 99.70176601409912, "nd_verify_s": 0.18921971321105957, "workers": 96, "chunk": 400}
8
+ {"utc": "2026-10-07T21:46:33Z", "samples": 4704, "parse_fail": 1307, "distinct_checked": 3090, "both_ok": 174, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 2916, "parse_reasons": {"unbound": 963, "name": 78, "expected )": 59, "ORE box": 46, "expected (": 44, "formula": 33, "exact not last": 25, "expected :=": 24, "no-eos": 21, "PR position": 4, "expected False": 4, "expected =>": 3, "expected ;": 2, "eof": 1}, "lean_wall_s": 12.811678409576416, "lean_proc_s": 99.08446407318115, "nd_verify_s": 0.14583349227905273, "workers": 96, "chunk": 400}
9
+ {"utc": "2026-10-07T21:47:34Z", "samples": 4680, "parse_fail": 1166, "distinct_checked": 3208, "both_ok": 179, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 3029, "parse_reasons": {"unbound": 861, "expected )": 113, "formula": 67, "name": 52, "expected :=": 27, "exact not last": 8, "expected ;": 8, "no-eos": 8, "expected (": 7, "ORE box": 7, "expected False": 6, "PR position": 2}, "lean_wall_s": 13.141790866851807, "lean_proc_s": 104.28537440299988, "nd_verify_s": 0.1835007667541504, "workers": 96, "chunk": 400}
10
+ {"utc": "2026-10-07T21:50:01Z", "samples": 12000, "parse_fail": 1000, "distinct_checked": 10534, "both_ok": 7376, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 3158, "parse_reasons": {"unbound": 774, "expected (": 66, "formula": 44, "name": 40, "ORE box": 18, "exact not last": 16, "expected :=": 15, "expected )": 14, "no-eos": 10, "expected =>": 1, "expected False": 1, "PR position": 1}, "lean_wall_s": 31.395925283432007, "lean_proc_s": 821.7829661369324, "nd_verify_s": 0.6218516826629639, "workers": 96, "chunk": 400}
11
+ {"utc": "2026-10-07T21:50:22Z", "samples": 3624, "parse_fail": 867, "distinct_checked": 2531, "both_ok": 63, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 2468, "parse_reasons": {"unbound": 686, "expected (": 69, "name": 30, "expected )": 26, "no-eos": 23, "formula": 9, "expected =>": 6, "exact not last": 4, "ORE box": 4, "PR position": 3, "expected :": 3, "expected False": 2, "expected ;": 1, "expected :=": 1}, "lean_wall_s": 10.163792848587036, "lean_proc_s": 64.38935494422913, "nd_verify_s": 0.12313127517700195, "workers": 96, "chunk": 400}
12
+ {"utc": "2026-10-07T21:50:48Z", "samples": 3624, "parse_fail": 1046, "distinct_checked": 2364, "both_ok": 30, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 2334, "parse_reasons": {"unbound": 761, "formula": 68, "expected (": 63, "ORE box": 47, "name": 45, "expected :=": 21, "expected )": 18, "exact not last": 17, "no-eos": 2, "expected .elim": 1, "expected =>": 1, "expected ;": 1, "expected exact": 1}, "lean_wall_s": 9.499196767807007, "lean_proc_s": 56.47677564620972, "nd_verify_s": 0.11058950424194336, "workers": 96, "chunk": 400}
13
+ {"utc": "2026-10-07T21:51:33Z", "samples": 3600, "parse_fail": 882, "distinct_checked": 2480, "both_ok": 78, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 2402, "parse_reasons": {"unbound": 706, "expected (": 57, "name": 55, "no-eos": 18, "formula": 18, "expected )": 10, "expected =>": 5, "ORE box": 4, "PR position": 3, "exact not last": 3, "expected ;": 1, "expected :=": 1, "expected fun": 1}, "lean_wall_s": 9.256057262420654, "lean_proc_s": 58.40112519264221, "nd_verify_s": 0.16170668601989746, "workers": 96, "chunk": 400}
14
+ {"utc": "2026-10-07T21:53:58Z", "samples": 12000, "parse_fail": 1051, "distinct_checked": 10470, "both_ok": 8037, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 2433, "parse_reasons": {"unbound": 761, "expected (": 118, "formula": 49, "exact not last": 45, "name": 36, "ORE box": 18, "expected )": 8, "no-eos": 7, "expected :=": 5, "expected False": 3, "eof": 1}, "lean_wall_s": 29.17173433303833, "lean_proc_s": 759.5069963932037, "nd_verify_s": 0.6224033832550049, "workers": 96, "chunk": 400}
15
+ {"utc": "2026-10-07T21:54:17Z", "samples": 3096, "parse_fail": 999, "distinct_checked": 1947, "both_ok": 17, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1930, "parse_reasons": {"unbound": 691, "expected (": 147, "formula": 62, "name": 21, "expected :=": 21, "no-eos": 14, "ORE box": 14, "expected )": 13, "exact not last": 8, "expected ;": 3, "expected =>": 2, "PR position": 1, "eof": 1, "expected False": 1}, "lean_wall_s": 8.101787805557251, "lean_proc_s": 39.904568910598755, "nd_verify_s": 0.09308743476867676, "workers": 96, "chunk": 400}
16
+ {"utc": "2026-10-07T21:54:43Z", "samples": 3072, "parse_fail": 902, "distinct_checked": 1976, "both_ok": 60, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1916, "parse_reasons": {"unbound": 634, "expected (": 103, "name": 75, "expected )": 28, "ORE box": 23, "formula": 22, "exact not last": 11, "expected False": 2, "no-eos": 2, "PR position": 2}, "lean_wall_s": 8.05149531364441, "lean_proc_s": 39.741113901138306, "nd_verify_s": 0.14103412628173828, "workers": 96, "chunk": 400}
17
+ {"utc": "2026-10-07T21:55:12Z", "samples": 3072, "parse_fail": 928, "distinct_checked": 1984, "both_ok": 50, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1934, "parse_reasons": {"unbound": 676, "expected (": 125, "name": 49, "expected )": 34, "formula": 25, "exact not last": 8, "ORE box": 5, "expected False": 4, "PR position": 1, "expected =>": 1}, "lean_wall_s": 8.126423358917236, "lean_proc_s": 39.417954206466675, "nd_verify_s": 0.08760595321655273, "workers": 96, "chunk": 400}
18
+ {"utc": "2026-10-07T21:57:44Z", "samples": 12000, "parse_fail": 1054, "distinct_checked": 10446, "both_ok": 8295, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 1, "both_rej": 2150, "parse_reasons": {"unbound": 811, "expected (": 99, "formula": 44, "name": 34, "ORE box": 24, "exact not last": 18, "expected ;": 9, "expected )": 8, "expected :=": 3, "no-eos": 2, "expected =>": 1, "PR position": 1}, "lean_wall_s": 30.61532473564148, "lean_proc_s": 790.2479627132416, "nd_verify_s": 0.6428463459014893, "workers": 96, "chunk": 400}
19
+ {"utc": "2026-10-07T21:57:59Z", "samples": 2760, "parse_fail": 876, "distinct_checked": 1749, "both_ok": 23, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1726, "parse_reasons": {"unbound": 698, "expected (": 83, "name": 32, "ORE box": 25, "expected )": 15, "formula": 10, "exact not last": 9, "expected ;": 2, "eof": 1, "PR position": 1}, "lean_wall_s": 7.023576259613037, "lean_proc_s": 31.464444875717163, "nd_verify_s": 0.1048133373260498, "workers": 96, "chunk": 400}
20
+ {"utc": "2026-10-07T21:58:19Z", "samples": 2760, "parse_fail": 983, "distinct_checked": 1631, "both_ok": 23, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1608, "parse_reasons": {"unbound": 714, "expected (": 137, "formula": 49, "name": 35, "ORE box": 19, "PR position": 10, "expected )": 7, "exact not last": 4, "expected :=": 4, "expected .elim": 1, "expected fun": 1, "no-eos": 1, "expected False": 1}, "lean_wall_s": 6.284697532653809, "lean_proc_s": 25.8290696144104, "nd_verify_s": 0.07179117202758789, "workers": 96, "chunk": 400}
21
+ {"utc": "2026-10-07T21:58:57Z", "samples": 2736, "parse_fail": 776, "distinct_checked": 1787, "both_ok": 45, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1742, "parse_reasons": {"unbound": 578, "expected (": 70, "name": 59, "ORE box": 19, "PR position": 18, "expected )": 9, "exact not last": 8, "formula": 6, "no-eos": 6, "expected .elim": 1, "expected :=": 1, "expected ;": 1}, "lean_wall_s": 6.536639928817749, "lean_proc_s": 30.039507150650024, "nd_verify_s": 0.10047245025634766, "workers": 96, "chunk": 400}
22
+ {"utc": "2026-10-07T22:01:31Z", "samples": 12000, "parse_fail": 888, "distinct_checked": 10616, "both_ok": 8686, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1930, "parse_reasons": {"unbound": 696, "expected (": 53, "formula": 53, "ORE box": 30, "name": 19, "expected ;": 9, "exact not last": 7, "expected :=": 6, "expected )": 5, "expected False": 4, "no-eos": 2, "PR position": 2, "trailing tokens": 2}, "lean_wall_s": 30.819588661193848, "lean_proc_s": 810.1652047634125, "nd_verify_s": 0.6484570503234863, "workers": 96, "chunk": 400}
23
+ {"utc": "2026-10-07T22:01:46Z", "samples": 2496, "parse_fail": 909, "distinct_checked": 1475, "both_ok": 2, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1473, "parse_reasons": {"unbound": 703, "formula": 44, "expected (": 39, "ORE box": 37, "name": 32, "expected :=": 24, "expected )": 17, "exact not last": 4, "PR position": 3, "expected fun": 2, "no-eos": 1, "expected False": 1, "expected exact": 1, "expected .elim": 1}, "lean_wall_s": 5.767206192016602, "lean_proc_s": 21.920366048812866, "nd_verify_s": 0.07423758506774902, "workers": 96, "chunk": 400}
24
+ {"utc": "2026-10-07T22:02:07Z", "samples": 2496, "parse_fail": 791, "distinct_checked": 1543, "both_ok": 17, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1526, "parse_reasons": {"unbound": 571, "expected (": 62, "formula": 40, "name": 37, "ORE box": 30, "expected ;": 17, "expected )": 14, "exact not last": 9, "expected :=": 3, "no-eos": 3, "expected False": 2, "expected exact": 1, "PR position": 1, "expected .elim": 1}, "lean_wall_s": 6.0049333572387695, "lean_proc_s": 23.82520842552185, "nd_verify_s": 0.08989119529724121, "workers": 96, "chunk": 400}
25
+ {"utc": "2026-10-07T22:02:38Z", "samples": 2496, "parse_fail": 742, "distinct_checked": 1640, "both_ok": 18, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1622, "parse_reasons": {"unbound": 576, "name": 54, "expected (": 40, "ORE box": 20, "expected :=": 18, "expected )": 15, "formula": 10, "expected False": 4, "expected ;": 3, "PR position": 1, "no-eos": 1}, "lean_wall_s": 6.4167163372039795, "lean_proc_s": 26.07410216331482, "nd_verify_s": 0.07789373397827148, "workers": 96, "chunk": 400}
26
+ {"utc": "2026-10-07T22:05:12Z", "samples": 12000, "parse_fail": 877, "distinct_checked": 10666, "both_ok": 8926, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1740, "parse_reasons": {"unbound": 637, "expected (": 87, "formula": 57, "ORE box": 37, "exact not last": 21, "name": 21, "expected )": 7, "expected ;": 4, "expected :=": 4, "PR position": 1, "no-eos": 1}, "lean_wall_s": 31.516093492507935, "lean_proc_s": 829.2077810764313, "nd_verify_s": 0.659355640411377, "workers": 96, "chunk": 400}
27
+ {"utc": "2026-10-07T22:05:24Z", "samples": 2328, "parse_fail": 792, "distinct_checked": 1413, "both_ok": 14, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1399, "parse_reasons": {"unbound": 604, "expected (": 47, "ORE box": 46, "name": 38, "formula": 26, "expected :=": 12, "exact not last": 12, "expected )": 6, "expected .elim": 1}, "lean_wall_s": 5.819785118103027, "lean_proc_s": 21.085521459579468, "nd_verify_s": 0.05943417549133301, "workers": 96, "chunk": 400}
28
+ {"utc": "2026-10-07T22:05:45Z", "samples": 2304, "parse_fail": 725, "distinct_checked": 1448, "both_ok": 14, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1434, "parse_reasons": {"unbound": 526, "formula": 68, "expected (": 65, "name": 29, "ORE box": 11, "expected )": 9, "expected ;": 7, "exact not last": 5, "expected False": 3, "no-eos": 2}, "lean_wall_s": 5.7698211669921875, "lean_proc_s": 21.737019062042236, "nd_verify_s": 0.07449960708618164, "workers": 96, "chunk": 400}
29
+ {"utc": "2026-10-07T22:06:05Z", "samples": 2304, "parse_fail": 852, "distinct_checked": 1309, "both_ok": 17, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1292, "parse_reasons": {"unbound": 625, "ORE box": 77, "expected (": 60, "name": 47, "formula": 16, "expected )": 11, "exact not last": 6, "expected ;": 5, "expected exact": 3, "PR position": 1, "expected False": 1}, "lean_wall_s": 4.877284526824951, "lean_proc_s": 16.063487768173218, "nd_verify_s": 0.06021881103515625, "workers": 96, "chunk": 400}
30
+ {"utc": "2026-10-07T22:08:39Z", "samples": 12000, "parse_fail": 800, "distinct_checked": 10699, "both_ok": 9085, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1614, "parse_reasons": {"unbound": 587, "expected (": 83, "formula": 47, "ORE box": 37, "name": 13, "exact not last": 12, "expected )": 7, "expected ;": 5, "no-eos": 3, "expected :=": 3, "trailing tokens": 2, "expected exact": 1}, "lean_wall_s": 29.67175269126892, "lean_proc_s": 785.1140115261078, "nd_verify_s": 0.6477258205413818, "workers": 96, "chunk": 400}
31
+ {"utc": "2026-10-07T22:08:54Z", "samples": 2112, "parse_fail": 718, "distinct_checked": 1295, "both_ok": 30, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1265, "parse_reasons": {"unbound": 456, "expected (": 108, "ORE box": 66, "formula": 56, "name": 13, "expected )": 9, "exact not last": 5, "no-eos": 4, "PR position": 1}, "lean_wall_s": 4.820358514785767, "lean_proc_s": 15.761304378509521, "nd_verify_s": 0.05824756622314453, "workers": 96, "chunk": 400}
32
+ {"utc": "2026-10-07T22:09:09Z", "samples": 2112, "parse_fail": 792, "distinct_checked": 1224, "both_ok": 2, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1222, "parse_reasons": {"unbound": 593, "ORE box": 77, "formula": 38, "expected (": 31, "name": 29, "expected ;": 9, "expected )": 7, "exact not last": 4, "expected :=": 4}, "lean_wall_s": 4.764538288116455, "lean_proc_s": 14.762110233306885, "nd_verify_s": 0.06479239463806152, "workers": 96, "chunk": 400}
33
+ {"utc": "2026-10-07T22:09:30Z", "samples": 2088, "parse_fail": 544, "distinct_checked": 1395, "both_ok": 18, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1377, "parse_reasons": {"unbound": 435, "name": 32, "formula": 25, "expected (": 21, "ORE box": 16, "exact not last": 8, "expected False": 2, "PR position": 2, "expected )": 2, "expected \u27e9": 1}, "lean_wall_s": 5.139159440994263, "lean_proc_s": 18.78948473930359, "nd_verify_s": 0.06953883171081543, "workers": 96, "chunk": 400}
34
+ {"utc": "2026-10-07T22:12:02Z", "samples": 12000, "parse_fail": 857, "distinct_checked": 10657, "both_ok": 9220, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1437, "parse_reasons": {"unbound": 612, "expected (": 77, "formula": 50, "ORE box": 38, "exact not last": 33, "name": 29, "expected )": 10, "PR position": 4, "expected :=": 2, "no-eos": 1, "expected ;": 1}, "lean_wall_s": 29.182825803756714, "lean_proc_s": 765.0150618553162, "nd_verify_s": 0.6331567764282227, "workers": 96, "chunk": 400}
35
+ {"utc": "2026-10-07T22:12:13Z", "samples": 2016, "parse_fail": 799, "distinct_checked": 1111, "both_ok": 1, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1110, "parse_reasons": {"unbound": 544, "expected (": 89, "name": 60, "formula": 46, "ORE box": 30, "expected )": 9, "PR position": 7, "exact not last": 7, "expected ;": 3, "no-eos": 3, "expected hh": 1}, "lean_wall_s": 4.368222951889038, "lean_proc_s": 12.358810186386108, "nd_verify_s": 0.04547905921936035, "workers": 96, "chunk": 400}
36
+ {"utc": "2026-10-07T22:12:28Z", "samples": 2016, "parse_fail": 828, "distinct_checked": 1099, "both_ok": 2, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1097, "parse_reasons": {"unbound": 566, "ORE box": 91, "name": 76, "expected (": 44, "expected )": 13, "PR position": 13, "expected =>": 10, "formula": 9, "exact not last": 5, "expected ;": 1}, "lean_wall_s": 5.553777456283569, "lean_proc_s": 15.686827898025513, "nd_verify_s": 0.05176711082458496, "workers": 96, "chunk": 400}
37
+ {"utc": "2026-10-07T22:12:57Z", "samples": 2016, "parse_fail": 835, "distinct_checked": 1088, "both_ok": 8, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 1080, "parse_reasons": {"unbound": 556, "name": 76, "ORE box": 53, "expected (": 50, "formula": 42, "expected )": 32, "exact not last": 11, "PR position": 6, "no-eos": 5, "expected fun": 2, "expected ;": 1, "expected =>": 1}, "lean_wall_s": 5.066176414489746, "lean_proc_s": 14.086556673049927, "nd_verify_s": 0.059514522552490234, "workers": 96, "chunk": 400}
38
+ {"utc": "2026-10-07T22:25:17Z", "samples": 70912, "parse_fail": 12531, "distinct_checked": 43449, "both_ok": 24084, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 19365, "parse_reasons": {"unbound": 8092, "name": 1870, "ORE box": 702, "formula": 677, "expected (": 609, "expected )": 287, "exact not last": 91, "no-eos": 85, "expected ;": 65, "PR position": 32, "expected exact": 8, "expected :=": 7, "expected =>": 5, "expected False": 1}, "lean_wall_s": 103.42623376846313, "lean_proc_s": 8427.395924329758, "nd_verify_s": 2.502133846282959, "workers": 96, "chunk": 400}
39
+ {"utc": "2026-10-07T22:25:31Z", "samples": 2000, "parse_fail": 0, "distinct_checked": 2000, "both_ok": 1985, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 15, "parse_reasons": {}, "lean_wall_s": 3.6347744464874268, "lean_proc_s": 16.882768392562866, "nd_verify_s": 0.0931863784790039, "workers": 96, "chunk": 400}
40
+ {"utc": "2026-10-07T22:30:17Z", "samples": 70912, "parse_fail": 11763, "distinct_checked": 44034, "both_ok": 23938, "nd_ok_lean_rej": 0, "nd_rej_lean_ok": 0, "both_rej": 20096, "parse_reasons": {"unbound": 8030, "name": 1371, "ORE box": 686, "expected (": 682, "formula": 562, "expected )": 185, "exact not last": 68, "expected ;": 57, "no-eos": 48, "expected :=": 38, "PR position": 25, "expected =>": 6, "expected .elim": 2, "expected False": 2, "expected exact": 1}, "lean_wall_s": 102.81334638595581, "lean_proc_s": 8299.91889834404, "nd_verify_s": 2.5768086910247803, "workers": 96, "chunk": 400}
runs/508-claude_train-loops-1-4_s1/pretrain.pt ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:0465e481a7bc70d3d9b7705eace3bb422d36d6962ab70fef775f95f58637af7a
3
+ size 25625153
runs/508-claude_train-loops-1-4_s1/source/harness.py ADDED
@@ -0,0 +1,529 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #!/usr/bin/env python3
2
+ # imports the fork (model, tokenizer, train, ...), which is not resolvable here
3
+ # pyright: reportMissingImports=false
4
+ """FROZEN harness for the test-time-loops autoresearch loop. The research agent does not edit it.
5
+
6
+ Forked from ../autoresearch/harness.py (sha 2aa52f23e7ec) on 2026-10-07. What changed: the RL
7
+ stage belongs to the agent, behind a wall-clock budget and a sampling oracle, and the metric is
8
+ measured with the model's test-time compute knob (KNOB) set to EVAL_LEVEL.
9
+
10
+ One timed run = harness owns the clocks, the oracle and the eval; `pretrain.py` (agent-editable)
11
+ owns pretraining and RL:
12
+
13
+ 1. load frozen data (Dan's cap-6 Stage-1 file, ladder RL-target pool, ladder transfer pool)
14
+ 2. call pretrain.pretrain(train_recs, PRETRAIN_SECS, ...) -> (model, tok, stats); charged for
15
+ everything including model construction and torch.compile. Overrun past the grace -> timeout.
16
+ 3. check n_params <= PARAM_CAP, tok.mode == TOK_MODE and that the model has the KNOB attribute
17
+ 4. call pretrain.rl(model, tok, targets, train_recs, oracle, RL_SECS, ...): expert iteration in
18
+ whatever form the agent likes. The targets are statements only, and `oracle.sample` is the
19
+ only way to turn them into training data: it samples the model's own attempts and returns
20
+ the ones Lean AND nd_verify accept. RL_SECS is wall-clock inside rl() minus the time the
21
+ oracle spent in the Lean gate (pod CPUs differ; GPU work is what is rationed). Overrun past
22
+ the grace, or an oracle call after the budget is spent -> timeout.
23
+ 5. eval on the dev half of the transfer pool with the harness setting the model's KNOB:
24
+ METRIC = dev theorems solved at L_true >= 7 with EVAL_K attempts at EVAL_LEVEL.
25
+ The same eval at DIAG_LEVEL is recorded as a diagnostic, not scored.
26
+ 6. SIGALRM at TOTAL_SECS from process start kills everything -> status "timeout"
27
+
28
+ The holdout half of the transfer pool is never scored here. Everything is written to --out.
29
+
30
+ python3 harness.py --out artifacts/x # on the pod (see pod.py / remote.sh)
31
+ ND_FORK=... python3 harness.py --out /tmp/smoke --smoke # CPU, ~1 min, plumbing check
32
+ """
33
+
34
+ import argparse
35
+ import collections
36
+ import hashlib
37
+ import importlib
38
+ import json
39
+ import os
40
+ import random
41
+ import shutil
42
+ import signal
43
+ import sys
44
+ import time
45
+ import traceback
46
+ from pathlib import Path
47
+
48
+ HERE = os.path.dirname(os.path.abspath(__file__))
49
+ FORK = os.environ.get("ND_FORK", "/workspace/nd-takehome")
50
+ sys.path.insert(0, HERE)
51
+ sys.path.insert(
52
+ 0, FORK
53
+ ) # fork first: its train.py provides batch/loss_on; the agent's file is pretrain.py
54
+ import torch # noqa: E402
55
+ from eval_set import judge, wilson # noqa: E402
56
+ from sample import generate # noqa: E402
57
+
58
+ # ---------------------------------------------------------------- the rules
59
+ # (hash-checked into every result)
60
+ TOTAL_SECS = int(
61
+ os.environ.get("ND_TOTAL_SECS", 5400)
62
+ ) # process start -> summary written; SIGALRM past this. env: benchmarks only
63
+ PRETRAIN_SECS = 300 # agent's pretraining budget, compile included
64
+ PRETRAIN_GRACE = 15 # seconds the agent may overrun before the run is a "timeout"
65
+ RL_SECS = 1800 # agent's RL budget: wall-clock inside rl() minus the oracle's Lean-gate time
66
+ RL_GRACE = 60
67
+ PARAM_CAP = 10_000_000 # unique trainable params, embeddings included; checked after RL too
68
+ N_TARGETS, TEMP, MAX_NEW, SAMPLE_BATCH = 1500, 0.8, 512, 1024
69
+ EVAL_K = 64
70
+ # The model's test-time compute knob: an integer attribute the harness sets before each eval and
71
+ # rl() sets before oracle calls. A sibling loop for another architecture changes these three
72
+ # constants and nothing else in this file.
73
+ KNOB = "n_loops" # loops of the shared core
74
+ EVAL_LEVEL = 8 # the metric: the knob's value during the scored eval
75
+ DIAG_LEVEL = 2 # the same eval again at this value, recorded but not scored
76
+ TOK_MODE = "lean_seq" # required tokenizer mode (fork lean_tok.py)
77
+ DEV = "cuda" if torch.cuda.is_available() else "cpu"
78
+
79
+
80
+ def read(fn):
81
+ return [json.loads(line) for line in open(fn) if line.strip()]
82
+
83
+
84
+ def log(msg):
85
+ print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True)
86
+
87
+
88
+ def sha(fn):
89
+ return hashlib.sha256(open(fn, "rb").read()).hexdigest()[:12]
90
+
91
+
92
+ class Timeout(Exception):
93
+ pass
94
+
95
+
96
+ class BudgetSpent(Timeout):
97
+ """rl() asked the oracle for samples after RL_SECS was used up."""
98
+
99
+
100
+ # ---------------------------------------------------------------- bookkeeping
101
+
102
+
103
+ def save_checkpoint(a, model, tok, stage):
104
+ """Publish complete weight snapshots atomically; these are not optimizer-resume files."""
105
+ path = Path(a.out) / f"{stage}.pt"
106
+ pending = path.with_suffix(".pt.tmp")
107
+ try:
108
+ torch.save(
109
+ {
110
+ "state": model.state_dict(),
111
+ "tok_mode": getattr(tok, "mode", None),
112
+ "stage": stage,
113
+ "seed": a.seed,
114
+ "harness_sha": sha(f"{HERE}/harness.py"),
115
+ "pretrain_sha": sha(f"{HERE}/pretrain.py"),
116
+ },
117
+ pending,
118
+ )
119
+ os.replace(pending, path)
120
+ finally:
121
+ pending.unlink(missing_ok=True)
122
+
123
+
124
+ def lstar(solved_names, recs, need=5):
125
+ ls_solved = [r["n_lines"] for r in recs if r["name"] in solved_names]
126
+ ge = {L: sum(1 for x in ls_solved if x >= L) for L in range(7, 15)}
127
+ return max([L for L, c in ge.items() if c >= need], default=0), ge
128
+
129
+
130
+ def by_bin(solved_names, recs):
131
+ by = collections.defaultdict(lambda: [0, 0])
132
+ for r in recs:
133
+ by[r["n_lines"]][0] += r["name"] in solved_names
134
+ by[r["n_lines"]][1] += 1
135
+ return {
136
+ str(L): {"solved": k, "n": n, "rate": k / n, "ci": list(wilson(k, n))}
137
+ for L, (k, n) in sorted(by.items())
138
+ }
139
+
140
+
141
+ def gate_seconds():
142
+ """Seconds the fork's lean_gate has logged so far (Lean wall-clock plus nd_verify)."""
143
+ fn = os.environ.get("LEAN_GATE_LOG")
144
+ if not fn or not os.path.exists(fn):
145
+ return 0.0
146
+ return sum(rec["lean_wall_s"] + rec["nd_verify_s"] for rec in read(fn))
147
+
148
+
149
+ def sample_and_judge(model, tok, recs, k, temperature, seed, batch, max_new):
150
+ prompts = [r["prompt"] for r in recs for _ in range(k)]
151
+ t0, g0 = time.time(), gate_seconds()
152
+ flat = generate(
153
+ model,
154
+ tok,
155
+ prompts,
156
+ greedy=(k == 1 and temperature == 0),
157
+ temperature=temperature,
158
+ batch=batch,
159
+ seed=seed,
160
+ max_new=max_new,
161
+ )
162
+ secs, gate = time.time() - t0, gate_seconds() - g0
163
+ rows = judge(recs, [flat[i * k : (i + 1) * k] for i in range(len(recs))], "n_lines")
164
+ return rows, {
165
+ "samples": len(prompts),
166
+ "secs": secs,
167
+ "gate_secs": gate,
168
+ "samples_per_sec": len(prompts) / secs,
169
+ }
170
+
171
+
172
+ def greedy_rate(model, tok, recs):
173
+ rows, _ = sample_and_judge(model, tok, recs, 1, 0, 0, SAMPLE_BATCH, MAX_NEW)
174
+ return sum(r["solved"] for r in rows) / max(len(rows), 1)
175
+
176
+
177
+ def dev_split(transfer):
178
+ return [r for r in transfer if int(hashlib.sha1(r["key"].encode()).hexdigest(), 16) % 2 == 0]
179
+
180
+
181
+ def holdout_split(transfer):
182
+ """Never scored by the loop. Score final.pt on this offline when checking in."""
183
+ return [r for r in transfer if int(hashlib.sha1(r["key"].encode()).hexdigest(), 16) % 2 == 1]
184
+
185
+
186
+ # ---------------------------------------------------------------- the RL oracle
187
+
188
+
189
+ class Oracle:
190
+ """What rl() gets instead of data: the model's own attempts at the RL targets, filtered to
191
+ the ones Lean AND nd_verify accept. It also keeps the RL clock and the record of every call.
192
+ """
193
+
194
+ def __init__(self, a, tok, targets):
195
+ self.a, self.tok = a, tok
196
+ self.targets = {t["name"]: t for t in targets}
197
+ self.found = collections.defaultdict(dict) # name -> {proof text: record}
198
+ self.calls = []
199
+ self.t0 = self.last = time.time()
200
+ self.uncharged = 0.0
201
+
202
+ def used(self):
203
+ """RL seconds charged so far: wall-clock since rl() started, minus Lean-gate time."""
204
+ return time.time() - self.t0 - self.uncharged
205
+
206
+ def left(self):
207
+ return self.a.rl_secs - self.used()
208
+
209
+ def sample(self, model, targets, k, temperature=TEMP, batch=SAMPLE_BATCH):
210
+ """k attempts at each of `targets` (records rl() was given, any subset, in any order) from
211
+ `model` as it is now, in eval mode, at whatever its KNOB is set to. Returns one
212
+ dict per target, in order: name, prompt, n_lines, proofs (the distinct accepted proof
213
+ texts), n_ok (accepted attempts) and n_tried. Rejected attempts are not returned.
214
+ Raises BudgetSpent, which ends the run as a timeout, once the budget is used up."""
215
+ if self.left() <= 0:
216
+ raise BudgetSpent(f"oracle called with {self.used():.0f}s of {self.a.rl_secs}s used")
217
+ recs = [self.targets[t["name"]] for t in targets]
218
+ call = len(self.calls) + 1
219
+ model.eval()
220
+ rows, samp = sample_and_judge(
221
+ model, self.tok, recs, k, temperature, self.a.seed * 1000 + call, batch, self.a.max_new
222
+ )
223
+ self.uncharged += samp["gate_secs"]
224
+ new = 0
225
+ for t, row in zip(recs, rows, strict=True):
226
+ for p, wl, pl in zip(
227
+ row["proofs"], row["written_lens"], row["pruned_lens"], strict=True
228
+ ):
229
+ if p not in self.found[t["name"]]:
230
+ self.found[t["name"]][p] = {
231
+ "proof": p,
232
+ "written": wl,
233
+ "pruned": pl,
234
+ "round": call,
235
+ }
236
+ new += 1
237
+ solved = {n for n, d in self.found.items() if d}
238
+ ls, ge = lstar(solved, list(self.targets.values()))
239
+ now = time.time()
240
+ self.calls.append(
241
+ {
242
+ "round": call,
243
+ "level": getattr(model, KNOB, None),
244
+ "k": k,
245
+ "n_targets": len(recs),
246
+ "sample_acc": sum(x["n_ok"] for x in rows) / max(samp["samples"], 1),
247
+ "new_proofs": new,
248
+ "targets_solved": len(solved),
249
+ "lstar": ls,
250
+ "ge": ge,
251
+ "mix_rl_records": sum(len(x["proofs"]) for x in rows), # proofs handed back
252
+ "sampling": samp,
253
+ "secs": now - self.last, # since the previous call returned: includes rl()'s work
254
+ "rl_secs_used": self.used(),
255
+ }
256
+ )
257
+ self.last = now
258
+ c = self.calls[-1]
259
+ log(
260
+ f"ei r{call}: acc {c['sample_acc']:.4f}, +{new} proofs, "
261
+ f"solved {len(solved)}/{len(self.targets)}, L*={ls}, {KNOB} {c['level']}, "
262
+ f"{len(recs)} targets x {k}, {samp['samples_per_sec']:.0f} samples/s, "
263
+ f"RL clock {c['rl_secs_used']:.0f}/{self.a.rl_secs}s"
264
+ )
265
+ return [
266
+ {
267
+ "name": t["name"],
268
+ "prompt": t["prompt"],
269
+ "n_lines": t["n_lines"],
270
+ "proofs": list(row["proofs"]),
271
+ "n_ok": row["n_ok"],
272
+ "n_tried": row["n_tried"],
273
+ }
274
+ for t, row in zip(recs, rows, strict=True)
275
+ ]
276
+
277
+
278
+ # ---------------------------------------------------------------- stages
279
+
280
+
281
+ def stage_rl(a, agent, tok, model, targets, train_recs):
282
+ oracle = Oracle(a, tok, targets)
283
+ # statements only: what the agent's RL may know about a target
284
+ visible = [{"name": t["name"], "prompt": t["prompt"], "n_lines": t["n_lines"]} for t in targets]
285
+ stats = agent.rl(model, tok, visible, train_recs, oracle, a.rl_secs, DEV, a.seed, log)
286
+ if DEV == "cuda":
287
+ torch.cuda.synchronize()
288
+ used = oracle.used()
289
+ model.eval()
290
+ with open(f"{a.out}/found_targets.jsonl", "w") as f:
291
+ for t in targets:
292
+ for x in oracle.found[t["name"]].values():
293
+ f.write(
294
+ json.dumps({"name": t["name"], "thm": t["thm"], "L_true": t["n_lines"], **x})
295
+ + "\n"
296
+ )
297
+ log(f"rl returned: {used:.0f}s of {a.rl_secs}s charged, {oracle.uncharged:.0f}s Lean gate")
298
+ return {
299
+ "rounds": oracle.calls,
300
+ "secs": time.time() - oracle.t0,
301
+ "rl_secs_used": used,
302
+ "gate_secs": oracle.uncharged,
303
+ "targets": len(targets),
304
+ "stats": dict(stats or {}),
305
+ }
306
+
307
+
308
+ def eval_at(a, tok, model, dev_pool, level):
309
+ setattr(model, KNOB, level)
310
+ rows, samp = sample_and_judge(
311
+ model, tok, dev_pool, a.eval_k, TEMP, a.seed * 1000 + 777, SAMPLE_BATCH, a.max_new
312
+ )
313
+ solved = {r["name"] for r in rows if r["solved"]}
314
+ ls, ge = lstar(solved, dev_pool)
315
+ out = {
316
+ "level": level,
317
+ "attempts_per_theorem": a.eval_k,
318
+ "solved": len(solved),
319
+ "n": len(dev_pool),
320
+ "solved_ge7": ge[7],
321
+ "lstar": ls,
322
+ "ge": ge,
323
+ "by_bin": by_bin(solved, dev_pool),
324
+ "sample_acc": sum(r["n_ok"] for r in rows) / max(samp["samples"], 1),
325
+ "max_pruned": max((max(r["pruned_lens"]) for r in rows if r["solved"]), default=0),
326
+ "sampling": samp,
327
+ }
328
+ log(
329
+ f"eval at {KNOB} {level}: solved {len(solved)}/{len(dev_pool)}, ge7 {ge[7]}, L*={ls}, "
330
+ f"per-sample {out['sample_acc']:.4f}, {samp['samples_per_sec']:.0f} samples/s"
331
+ )
332
+ return out, rows
333
+
334
+
335
+ def stage_eval(a, tok, model, dev_pool, heldout_recs):
336
+ out, rows = eval_at(a, tok, model, dev_pool, a.eval_level)
337
+ out["heldout_greedy"] = greedy_rate(model, tok, heldout_recs)
338
+ with open(f"{a.out}/eval_dev.jsonl", "w") as f:
339
+ for r in rows:
340
+ keys = ("name", "n_lines", "solved", "n_ok", "proofs", "written_lens", "pruned_lens")
341
+ f.write(json.dumps({k: r[k] for k in keys}) + "\n")
342
+ diag, _ = eval_at(a, tok, model, dev_pool, a.diag_level)
343
+ out["diag"] = diag
344
+ setattr(model, KNOB, a.eval_level)
345
+ log(
346
+ f"eval: solved {out['solved']}/{len(dev_pool)}, ge7 {out['solved_ge7']} at "
347
+ f"{KNOB} {a.eval_level} ({diag['solved_ge7']} at {a.diag_level}), L*={out['lstar']}, "
348
+ f"max pruned {out['max_pruned']}, held-out greedy {out['heldout_greedy']:.3f}"
349
+ )
350
+ return out
351
+
352
+
353
+ def lean_gate_totals():
354
+ """Sum the fork lean_gate's per-generate() log lines (remote.sh sets LEAN_GATE_LOG)."""
355
+ fn = os.environ.get("LEAN_GATE_LOG")
356
+ if not fn or not os.path.exists(fn):
357
+ return None
358
+ keys = ("samples", "parse_fail", "distinct_checked", "both_ok", "nd_ok_lean_rej")
359
+ tot = dict.fromkeys(keys + ("nd_rej_lean_ok", "lean_wall_s"), 0)
360
+ for rec in read(fn):
361
+ for k in tot:
362
+ tot[k] += rec[k]
363
+ return tot
364
+
365
+
366
+ RULES = (
367
+ "TOTAL_SECS",
368
+ "PRETRAIN_SECS",
369
+ "RL_SECS",
370
+ "PARAM_CAP",
371
+ "N_TARGETS",
372
+ "EVAL_K",
373
+ "KNOB",
374
+ "EVAL_LEVEL",
375
+ "DIAG_LEVEL",
376
+ "TOK_MODE",
377
+ )
378
+
379
+
380
+ def write_summary(a, status, **kw):
381
+ s = {
382
+ "status": status,
383
+ "metric": kw.get("eval", {}).get("solved_ge7"),
384
+ "metric_diag": kw.get("eval", {}).get("diag", {}).get("solved_ge7"),
385
+ "metric_rl": (kw.get("rl", {}).get("rounds") or [{}])[-1].get(
386
+ "targets_solved"
387
+ ), # secondary: cumulative RL targets solved
388
+ "harness_sha": sha(f"{HERE}/harness.py"),
389
+ "pretrain_sha": sha(f"{HERE}/pretrain.py"),
390
+ "device": DEV,
391
+ "gpu": torch.cuda.get_device_name(0) if DEV == "cuda" else "cpu",
392
+ "torch": torch.__version__,
393
+ "lean_gate": lean_gate_totals(),
394
+ "total_secs": time.time() - a.T0,
395
+ "rules": {k: globals()[k] for k in RULES},
396
+ **kw,
397
+ }
398
+ with open(f"{a.out}/summary.json", "w") as f:
399
+ json.dump(s, f, indent=1)
400
+ log(
401
+ f"SUMMARY status={status} metric={s['metric']} metric_diag={s['metric_diag']} "
402
+ f"metric_rl={s['metric_rl']} total {s['total_secs']:.0f}s"
403
+ )
404
+ return s
405
+
406
+
407
+ def main():
408
+ ap = argparse.ArgumentParser()
409
+ ap.add_argument("--out", required=True)
410
+ ap.add_argument("--seed", type=int, default=0)
411
+ ap.add_argument(
412
+ "--pretrain-only", action="store_true", help="save pretrain.pt and stop before eval/RL"
413
+ )
414
+ ap.add_argument(
415
+ "--smoke", action="store_true", help="tiny everything, for a CPU plumbing check"
416
+ )
417
+ a = ap.parse_args()
418
+ a.pretrain_secs, a.rl_secs, a.eval_k, a.max_new, a.n_targets = (
419
+ PRETRAIN_SECS,
420
+ RL_SECS,
421
+ EVAL_K,
422
+ MAX_NEW,
423
+ N_TARGETS,
424
+ )
425
+ a.eval_level, a.diag_level = EVAL_LEVEL, DIAG_LEVEL
426
+ if a.smoke:
427
+ a.pretrain_secs, a.rl_secs, a.eval_k, a.max_new, a.n_targets = 10, 30, 2, 120, 8
428
+ os.makedirs(a.out, exist_ok=True)
429
+ # Preserve discarded variants too: weights alone do not specify the model architecture.
430
+ source_dir = Path(a.out) / "source"
431
+ source_dir.mkdir(exist_ok=True)
432
+ for filename in ("pretrain.py", "harness.py", "remote.sh"):
433
+ shutil.copy2(Path(HERE) / filename, source_dir / filename)
434
+ a.T0 = time.time()
435
+ torch.manual_seed(a.seed)
436
+
437
+ def on_alarm(signum, frame):
438
+ raise Timeout()
439
+
440
+ signal.signal(signal.SIGALRM, on_alarm)
441
+ signal.alarm(TOTAL_SECS if not a.smoke else 900)
442
+
443
+ train_recs = read(f"{FORK}/data/train.jsonl")
444
+ assert all(r["n_lines"] <= 6 for r in train_recs), "pretrain file violates cap 6"
445
+ heldout_all = read(f"{FORK}/data/heldout.jsonl")
446
+ # Length-ordered file: take 2000 evenly spaced records, so every length 2-6 is covered.
447
+ heldout_all = [heldout_all[i * len(heldout_all) // 2000] for i in range(2000)]
448
+ heldout_recs = heldout_all if not a.smoke else heldout_all[:16]
449
+ targets_all = read(f"{FORK}/data/ladder/rl_targets.jsonl")
450
+ transfer = read(f"{FORK}/data/ladder/transfer.jsonl")
451
+ dev_pool = dev_split(transfer) if not a.smoke else dev_split(transfer)[:8]
452
+ targets = random.Random(a.seed).sample(targets_all, min(a.n_targets, len(targets_all)))
453
+ tk, dk, hk = (
454
+ {t["key"] for t in targets},
455
+ {r["key"] for r in dev_pool},
456
+ {r["key"] for r in train_recs},
457
+ )
458
+ assert not (tk & dk) and not (tk & hk) and not (dk & hk), "renaming-class leak between pools"
459
+ log(
460
+ f"pools: train {len(train_recs):,}, targets {len(targets)}, dev-transfer {len(dev_pool)}, "
461
+ f"held-out {len(heldout_recs)}; "
462
+ f"device {DEV}; harness {sha(f'{HERE}/harness.py')} pretrain {sha(f'{HERE}/pretrain.py')}"
463
+ )
464
+
465
+ pre = {}
466
+ try:
467
+ agent = importlib.import_module("pretrain")
468
+ t0 = time.time()
469
+ model, tok, pre = agent.pretrain(train_recs, a.pretrain_secs, DEV, a.seed, log)
470
+ if DEV == "cuda":
471
+ torch.cuda.synchronize()
472
+ pre = dict(pre or {})
473
+ pre["secs"] = time.time() - t0
474
+ model.eval()
475
+ n_params = sum(p.numel() for p in model.parameters())
476
+ pre["n_params"] = n_params
477
+ log(
478
+ f"pretrain returned after {pre['secs']:.0f}s (budget {a.pretrain_secs}s), "
479
+ f"{n_params:,} params"
480
+ )
481
+ if pre["secs"] > a.pretrain_secs + PRETRAIN_GRACE and not a.smoke:
482
+ over = pre["secs"] - a.pretrain_secs
483
+ write_summary(
484
+ a, "timeout", pretrain=pre, reason=f"pretrain overran budget by {over:.0f}s"
485
+ )
486
+ return
487
+ if getattr(tok, "mode", None) != TOK_MODE:
488
+ write_summary(a, "crash", pretrain=pre, reason=f"tok.mode {tok.mode!r} != {TOK_MODE!r}")
489
+ return
490
+ if n_params > PARAM_CAP:
491
+ write_summary(a, "crash", pretrain=pre, reason=f"{n_params} params > cap {PARAM_CAP}")
492
+ return
493
+ if not isinstance(getattr(model, KNOB, None), int):
494
+ reason = f"model has no integer {KNOB} for the harness to set at eval"
495
+ write_summary(a, "crash", pretrain=pre, reason=reason)
496
+ return
497
+ save_checkpoint(a, model, tok, "pretrain")
498
+ if a.pretrain_only:
499
+ write_summary(a, "ok", stage="pretrain_only", pretrain=pre)
500
+ return
501
+ pre["heldout_greedy"] = greedy_rate(model, tok, heldout_recs)
502
+ log(f"pretrain held-out greedy {pre['heldout_greedy']:.3f}")
503
+ rl = stage_rl(a, agent, tok, model, targets, train_recs)
504
+ if rl["rl_secs_used"] > a.rl_secs + RL_GRACE and not a.smoke:
505
+ over = rl["rl_secs_used"] - a.rl_secs
506
+ reason = f"rl overran budget by {over:.0f}s"
507
+ write_summary(a, "timeout", pretrain=pre, rl=rl, reason=reason)
508
+ return
509
+ n_after = sum(p.numel() for p in model.parameters())
510
+ if n_after > PARAM_CAP:
511
+ reason = f"{n_after} params > cap {PARAM_CAP} after rl"
512
+ write_summary(a, "crash", pretrain=pre, rl=rl, reason=reason)
513
+ return
514
+ save_checkpoint(a, model, tok, "final")
515
+ ev = stage_eval(a, tok, model, dev_pool, heldout_recs)
516
+ write_summary(a, "ok", pretrain=pre, rl=rl, eval=ev)
517
+ except BudgetSpent as e:
518
+ write_summary(a, "timeout", pretrain=pre, reason=f"rl: {e}")
519
+ except Timeout:
520
+ write_summary(a, "timeout", pretrain=pre, reason=f"exceeded TOTAL_SECS={TOTAL_SECS}")
521
+ except Exception:
522
+ traceback.print_exc()
523
+ write_summary(a, "crash", pretrain=pre, reason=traceback.format_exc()[-2000:])
524
+ finally:
525
+ signal.alarm(0)
526
+
527
+
528
+ if __name__ == "__main__":
529
+ main()
runs/508-claude_train-loops-1-4_s1/source/pretrain.py ADDED
@@ -0,0 +1,572 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # imports the fork (model, tokenizer, train, ...), which is not resolvable here
2
+ # pyright: reportMissingImports=false
3
+ """AGENT-EDITABLE: pretraining and RL. This is the only file the autoresearch agent changes.
4
+
5
+ Contract with harness.py (frozen):
6
+
7
+ pretrain(train_recs, budget_secs, device, seed, log) -> (model, tok, stats)
8
+
9
+ train_recs list of dicts {prompt, proof, n_lines<=6, key, ...}; the frozen cap-6 Stage-1 data
10
+ budget_secs wall-clock you are charged for, from call to return, INCLUDING model construction
11
+ and torch.compile. Overrun by more than the harness grace -> the run is a timeout.
12
+ model nn.Module; <= PARAM_CAP unique params (checked again after rl). The harness samples
13
+ from it with the fork's sample.generate, so it must provide:
14
+ - forward(idx) -> logits (B,T,V) and forward(idx, pos=, mask=, caches=) with a
15
+ per-block KV cache dict, exactly like the fork's GPT (model.blocks must exist)
16
+ - an integer `n_loops` (the harness's KNOB): the loop count applied in eval
17
+ mode. The harness sets it to EVAL_LEVEL for the scored eval and to DIAG_LEVEL
18
+ for the diagnostic one.
19
+ tok must provide encode_prompt, encode_proof, decode, shift_abs, pad, eos, mode, and
20
+ mode must be "lean_seq" (harness TOK_MODE): Lean text in and out, Lean-gated samples.
21
+ Decoder rule: decode() is deterministic and single-pass; it may not call the
22
+ verifier or try alternatives.
23
+ stats dict recorded in summary.json and copied into results.json. MUST contain `curve`:
24
+ a list of {secs, step, train_loss, val_loss} taken every ~CURVE_EVERY seconds
25
+ (see log_point below), so a run's trajectory survives in git. Add anything else.
26
+ val_loss is on VAL_N records held out from train_recs by this file; keep that.
27
+
28
+ rl(model, tok, targets, train_recs, oracle, budget_secs, device, seed, log) -> stats | None
29
+
30
+ targets list of dicts {name, prompt, n_lines}: the 1,500 RL target statements. No proofs.
31
+ oracle oracle.sample(model, targets_subset, k, temperature=0.8, batch=1024) samples k
32
+ attempts per target from the model in eval mode at its current n_loops, and returns
33
+ per target {name, prompt, n_lines, proofs, n_ok, n_tried}; `proofs` are the distinct
34
+ attempts Lean AND nd_verify accepted. This is the only source of new training data.
35
+ oracle.used() / oracle.left(): seconds of the RL budget charged / remaining.
36
+ budget_secs RL_SECS: wall-clock inside rl() minus the oracle's Lean-gate time. Returning more
37
+ than the grace late, or calling the oracle with nothing left, is a timeout.
38
+ The model is trained in place. Everything else about RL is yours: rounds, samples per target,
39
+ loop counts when sampling, which proofs to keep, weighting, replay, optimizer, loss.
40
+
41
+ Anything imported from the fork (ND_FORK) is fair game to copy in here and modify.
42
+ """
43
+
44
+ import math
45
+ import random
46
+ import time
47
+
48
+ import torch
49
+ import torch._inductor.config # noqa: F401 (explicit, so the attribute resolves for pyright)
50
+ from lean_tok import MAXN # fork
51
+ from model import GPT, Block # fork
52
+ from normalize import norm # fork
53
+ from tokenizer import make_tokenizer # fork
54
+ from train import batch as mk_batch # fork
55
+ from train import loss_on # fork
56
+
57
+ # ---- knobs
58
+ # Unique blocks: one untied entry block, N_CORE shared core blocks, one untied exit block.
59
+ N_CORE = 2
60
+ N_LAYER, D, N_HEAD = 2 + N_CORE, 384, 8
61
+ # Core applications (loops). Training draws one count per batch from TRAIN_LOOPS, in pretraining
62
+ # and in rl()'s fine-tune; eval and sampling apply model.n_loops, which the harness sets for its
63
+ # evals and rl() sets before each oracle call. DEFAULT_LOOPS is used for the validation curve and
64
+ # the harness's post-pretraining greedy check. Training stops at 4 loops: the iteration has
65
+ # converged by then (the spike's models are flat from 4 to 24 loops), so the scored 8-loop eval
66
+ # and the deepest RL retry read out the same fixed point without any batch paying for passes 5-8.
67
+ TRAIN_LOOPS = (1, 2, 3, 4)
68
+ DEFAULT_LOOPS = 2
69
+ VAL_LOOPS = (1, 2, 4, 8) # val loss at each count, once, when pretraining ends
70
+ # ---- RL knobs: the old harness's expert iteration (600 AdamW steps per round on up to 4 proofs
71
+ # per solved target, weighted x4, mixed with 20,000 replayed pretraining records), except for
72
+ # where the samples go. Each round every target gets RL_K attempts at RL_FIRST_LOOPS; a target
73
+ # all of them fail on gets RL_RETRY_K more (32 in all, as before) at ONE deeper loop count from
74
+ # RL_RETRY_LOOPS, assigned at random, so proofs that only deeper sampling finds enter the
75
+ # training set and no deep sample is spent on a target one loop already solves. The random
76
+ # assignment makes the retry calls a controlled comparison of loop counts on resistant targets.
77
+ # Rounds repeat until another one would not fit in the budget.
78
+ RL_FIRST_LOOPS, RL_K = 1, 8
79
+ RL_RETRY_LOOPS, RL_RETRY_K = (2, 4, 8), 24
80
+ FT_STEPS, FT_BS, FT_LR, FT_WARMUP = 600, 128, 3e-4, 50
81
+ RETAIN, MAX_PER_THM, RL_WEIGHT = 20000, 4, 4
82
+ # MLP width held at 151's 1280: the fork's Block hardcodes 4 * D (1536 at D 384 would pass the
83
+ # 10M cap), so PeriLNBlock swaps fc1/fc2. 1280 != 3 * D keeps muon_step's QKV-by-shape test valid.
84
+ D_FF = 1280
85
+ BS, LR, MIN_LR_FRAC, WD = 128, 1e-3, 0.3, 0.1
86
+ MUON_LR, MUON_MOMENTUM = 0.01, 0.95
87
+ # Polar Express (Amsel et al. 2025) per-iteration quintic coefficients, as in modded-nanogpt
88
+ # (num_iters=5, safety factor 2e-2): singular values land in ~[0.86, 1.14] instead of the
89
+ # fixed quintic's ~[0.68, 1.13], at the same five iterations.
90
+ NS_COEFFS = (
91
+ (8.156554524902461, -22.48329292557795, 15.878769915207462),
92
+ (4.042929935166739, -2.808917465908714, 0.5000178451051316),
93
+ (3.8916678022926607, -2.772484153217685, 0.5060648178503393),
94
+ (3.285753657755655, -2.3681294933425376, 0.46449024233003106),
95
+ (2.3465413258596377, -1.7097828382687081, 0.42323551169305323),
96
+ )
97
+ # Ten times the AdamW group's per-step multiplicative decay (lr * wd) on the Muon matrices.
98
+ MUON_WD = 10 * WD * LR / MUON_LR
99
+ TOK_MODE = "lean_seq" # required by the harness (Lean protocol)
100
+ # Hybrid heads: half the heads get ALiBi (Press et al. 2021) with the standard slope set for
101
+ # H/2 heads, 2^(-8 i / (H/2)) = 1/4 .. 1/256 with 8 heads; the other half get slope 0, i.e. no
102
+ # positional signal at all (NoPE), so they can look citations up by content at any distance.
103
+ N_ALIBI = N_HEAD // 2
104
+ ALIBI_SLOPES = tuple(2.0 ** (-8.0 * (i + 1) / N_ALIBI) for i in range(N_ALIBI)) + (0.0,) * (
105
+ N_HEAD - N_ALIBI
106
+ )
107
+ VAL_N, CURVE_EVERY = 1024, 15 # records held out for val_loss; seconds between curve points
108
+ # Token-budget batches (fairseq max-tokens): each step takes a run of length-sorted records with
109
+ # count * padded_length <= TOK_BUDGET, so a batch of short proofs has many records and a batch of
110
+ # long ones few, and the padded token count per step is ~constant. 128 x 144 matches the real
111
+ # (unpadded) tokens of the incumbent's 128-record batches (mean record ~135 tokens), whose
112
+ # padding to the batch max (~400) made every step ~3x larger than its content.
113
+ TOK_BUDGET = 128 * 144
114
+ # Multi-token prediction (DeepSeek-V3 2024, Gloeckle et al. 2024), pretraining only: one extra
115
+ # Peri-LN block reads [trunk state at t; embedding of token t+1] and predicts token t+2 through
116
+ # the model's own ln_f/head. Its loss is added at this weight (DeepSeek-V3's early-training value).
117
+ MTP_WEIGHT = 0.3
118
+
119
+
120
+ # Muon update adapted from KellerJordan/Muon, commit
121
+ # f98f1cacc0263b04290753e32be8d498c1efc806 (muon.py).
122
+ # MIT License
123
+ # Copyright (c) 2024 Keller Jordan
124
+ #
125
+ # Permission is hereby granted, free of charge, to any person obtaining a copy
126
+ # of this software and associated documentation files (the "Software"), to deal
127
+ # in the Software without restriction, including without limitation the rights
128
+ # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
129
+ # copies of the Software, and to permit persons to whom the Software is
130
+ # furnished to do so, subject to the following conditions:
131
+ # The above copyright notice and this permission notice shall be included in all
132
+ # copies or substantial portions of the Software.
133
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
134
+ # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
135
+ # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
136
+ # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
137
+ # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
138
+ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
139
+ # SOFTWARE.
140
+ @torch.no_grad()
141
+ def muon_step(params, buffers, lr):
142
+ """Nesterov momentum plus five bf16 Polar Express steps, on hidden matrices only."""
143
+ for p, momentum in zip(params, buffers, strict=True):
144
+ if p.grad is None:
145
+ continue
146
+ momentum.lerp_(p.grad, 1 - MUON_MOMENTUM)
147
+ update = p.grad.lerp(momentum, MUON_MOMENTUM).bfloat16()
148
+ # Only QKV has shape (3D, D) in this GPT; orthogonalize its roles separately.
149
+ if update.size(0) == 3 * update.size(1):
150
+ update = update.reshape(3, update.size(1), update.size(1))
151
+ transpose = update.size(-2) > update.size(-1)
152
+ if transpose:
153
+ update = update.mT
154
+ update = update / (update.norm(dim=(-2, -1), keepdim=True) * (1 + 2e-2) + 1e-6)
155
+ for a, b, c in NS_COEFFS:
156
+ gram = update @ update.mT
157
+ polynomial = b * gram + c * gram @ gram
158
+ update = a * update + polynomial @ update
159
+ if transpose:
160
+ update = update.mT
161
+ p.mul_(1 - lr * MUON_WD)
162
+ # lr may be a 0-d tensor (CUDA-graphed step); scale in p's dtype like add_(alpha=-lr)
163
+ p.sub_(lr * update.reshape_as(p).to(p.dtype))
164
+
165
+
166
+ class PeriLNBlock(Block):
167
+ """P22 Peri-LN (Kim et al. 2025): the fork's pre-LN block plus a LayerNorm on each branch
168
+ output, so every residual write has unit scale times a learned gain. Attention has no RoPE:
169
+ `mask` is the additive ALiBi bias (B or 1, H, T, S) that LoopedGPT builds once per forward
170
+ and cos/sin are unused."""
171
+
172
+ def __init__(self, d, h):
173
+ super().__init__(d, h)
174
+ self.fc1, self.fc2 = torch.nn.Linear(d, D_FF), torch.nn.Linear(D_FF, d)
175
+ self.ln_attn_out, self.ln_mlp_out = torch.nn.LayerNorm(d), torch.nn.LayerNorm(d)
176
+
177
+ def attn(self, x, cos, sin, mask, cache):
178
+ B, T, D = x.shape
179
+ q, k, v = self.qkv(x).view(B, T, 3, self.h, D // self.h).permute(2, 0, 3, 1, 4)
180
+ if cache is not None: # the fork's preallocated KV cache, unchanged
181
+ if "k" not in cache:
182
+ cache["k"] = k.new_empty(B, self.h, cache["max"], D // self.h)
183
+ cache["v"] = v.new_empty(B, self.h, cache["max"], D // self.h)
184
+ cache["n"] = 0
185
+ n0, n1 = cache["n"], cache["n"] + T
186
+ cache["k"][:, :, n0:n1] = k
187
+ cache["v"][:, :, n0:n1] = v
188
+ cache["n"] = n1
189
+ k, v = cache["k"][:, :, :n1], cache["v"][:, :, :n1]
190
+ y = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=mask.to(q.dtype))
191
+ return self.proj(y.transpose(1, 2).reshape(B, T, D))
192
+
193
+ def forward(self, x, cos, sin, mask=None, cache=None):
194
+ x = x + self.ln_attn_out(self.attn(self.ln1(x), cos, sin, mask, cache))
195
+ return x + self.ln_mlp_out(self.fc2(torch.nn.functional.gelu(self.fc1(self.ln2(x)))))
196
+
197
+
198
+ class LoopedGPT(GPT):
199
+ """Looped trunk (Universal Transformer, Dehghani et al. 2018; sandwich layout and input
200
+ injection as in Geiping et al. 2025): blocks[0] is the entry block, blocks[1:-1] the shared
201
+ core applied n times, blocks[-1] the exit block. Every core pass starts from
202
+ ln_loop(state) + e, with e the entry block's output, so each pass sees an input of the same
203
+ scale and the prompt is re-injected instead of being buried under accumulated writes.
204
+
205
+ P34: the fork's GPT with ALiBi (Press et al. 2021) instead of RoPE. Head h's attention
206
+ logits get -slope_h * (query position - key position), slopes 2^-1 .. 2^-8 for 8 heads, so
207
+ no rotation of q/k anywhere. Positions come from `pos` (sample.generate's left-padded
208
+ batches) or arange; key positions are kept in caches[0] so cached decoding sees the same
209
+ bias as the full forward. Causality/padding come from `mask` when given, else from rel < 0."""
210
+
211
+ def __init__(self, vocab, n_layer, d, n_head, seed, max_len=1024):
212
+ super().__init__(vocab, n_layer, d, n_head, max_len)
213
+ slopes = torch.tensor(ALIBI_SLOPES).view(1, n_head, 1, 1)
214
+ self.register_buffer("slopes", slopes, persistent=False)
215
+ self.ln_loop = torch.nn.LayerNorm(d)
216
+ self.n_loops, self.loop_rng = DEFAULT_LOOPS, random.Random(seed)
217
+
218
+ def forward(self, idx, pos=None, mask=None, caches=None):
219
+ return self.head(self.ln_f(self.features(idx, pos, mask, caches)[0]))
220
+
221
+ def features(self, idx, pos=None, mask=None, caches=None):
222
+ """The trunk: (final hidden state before ln_f, the ALiBi bias used)."""
223
+ B, T = idx.shape
224
+ if pos is None: # training/val: one (1, H, T, T) bias broadcast over the batch
225
+ pos = torch.arange(T, device=idx.device)[None]
226
+ key_pos = pos
227
+ if caches is not None: # incremental decoding: keys are every cached token
228
+ c = caches[0]
229
+ if "pos" not in c:
230
+ c["pos"], c["n_pos"] = pos.new_empty(pos.size(0), c["max"]), 0
231
+ n0, n1 = c["n_pos"], c["n_pos"] + T
232
+ c["pos"][:, n0:n1] = pos
233
+ c["n_pos"] = n1
234
+ key_pos = c["pos"][:, :n1]
235
+ rel = pos[:, None, :, None] - key_pos[:, None, None, :] # (B or 1, 1, T, S)
236
+ bias = -self.slopes * rel.to(self.slopes.dtype)
237
+ bias = bias.masked_fill(rel < 0 if mask is None else ~mask, float("-inf"))
238
+ n = self.loop_rng.choice(TRAIN_LOOPS) if self.training else self.n_loops
239
+ entry, *core, exit_block = self.blocks
240
+ x = e = entry(self.emb(idx), None, None, bias, None if caches is None else caches[0])
241
+ for loop in range(n):
242
+ x = self.ln_loop(x) + e
243
+ for j, b in enumerate(core, 1):
244
+ # sample.generate makes one cache dict per unique block; a shared block's keys
245
+ # and values differ per pass, so each pass gets its own sub-cache inside it.
246
+ c = caches and caches[j].setdefault(loop, {"max": caches[j]["max"]})
247
+ x = b(x, None, None, bias, c)
248
+ x = exit_block(x, None, None, bias, None if caches is None else caches[-1])
249
+ return x, bias
250
+
251
+
252
+ class MTPHead(torch.nn.Module):
253
+ """The MTP module. A separate nn.Module, never registered on the model, so the harness's
254
+ parameter count, RL AdamW and sampler never see it; it is dropped when pretrain() returns."""
255
+
256
+ def __init__(self, d, h):
257
+ super().__init__()
258
+ self.ln_h, self.ln_e = torch.nn.LayerNorm(d), torch.nn.LayerNorm(d)
259
+ self.proj = torch.nn.Linear(2 * d, d, bias=False)
260
+ self.block = PeriLNBlock(d, h)
261
+
262
+
263
+ def mtp_loss(model, mtp, x, m):
264
+ """The fork's loss_on (next-token CE on proof tokens) plus MTP_WEIGHT times the CE of the
265
+ MTP module's token-(t+2) prediction at the same proof positions. Returns (total, main)."""
266
+ h, bias = model.features(x[:, :-1])
267
+ logits = model.head(model.ln_f(h))
268
+ V = logits.size(-1)
269
+ ce = torch.nn.functional.cross_entropy(
270
+ logits.reshape(-1, V).float(), x[:, 1:].reshape(-1), reduction="none"
271
+ )
272
+ main = (ce * m[:, 1:].reshape(-1)).sum() / m[:, 1:].sum()
273
+ # Position t (0..T-3) gets h_t and emb(x_{t+1}); causal attention over these keeps every
274
+ # prediction of x_{t+2} a function of x_{<=t+1}.
275
+ z = mtp.proj(torch.cat((mtp.ln_h(h[:, :-1]), mtp.ln_e(model.emb(x[:, 1:-1]))), -1))
276
+ z = mtp.block(z, None, None, bias[..., :-1, :-1], None)
277
+ ce2 = torch.nn.functional.cross_entropy(
278
+ model.head(model.ln_f(z)).reshape(-1, V).float(), x[:, 2:].reshape(-1), reduction="none"
279
+ )
280
+ aux = (ce2 * m[:, 2:].reshape(-1)).sum() / m[:, 2:].sum().clamp(min=1)
281
+ return main + MTP_WEIGHT * aux, main, aux
282
+
283
+
284
+ def val_loss(model, ids, mask, ref_max, lens, tok, gen, autocast):
285
+ """Mean loss over the first VAL_N records (never trained on), no shift augmentation."""
286
+ model.eval()
287
+ tot = 0.0
288
+ with torch.no_grad(), autocast:
289
+ for i in range(0, VAL_N, BS):
290
+ idxs = torch.arange(i, min(i + BS, VAL_N), device=ids.device)
291
+ x, m = ids[idxs], mask[idxs]
292
+ T = int(lens[idxs].max())
293
+ tot += loss_on(model, x[:, :T], m[:, :T]).item() * len(idxs)
294
+ model.train()
295
+ return tot / VAL_N
296
+
297
+
298
+ def to_gpu(data, tok, device):
299
+ """Pad all (prompt, proof) records once into (N, T) ids + proof mask on the device."""
300
+ N, T = len(data), max(len(p) + len(q) for p, q in data)
301
+ ids = torch.full((N, T), tok.pad, dtype=torch.long)
302
+ mask = torch.zeros((N, T), dtype=torch.bool)
303
+ ref_max = torch.zeros(
304
+ N, dtype=torch.long
305
+ ) # largest N<k> index used in the proof, for the shift augmentation
306
+ for i, (p, q) in enumerate(data):
307
+ ids[i, : len(p) + len(q)] = torch.tensor(p + q)
308
+ mask[i, len(p) : len(p) + len(q)] = True
309
+ ref_max[i] = max((x - tok.ref0 + 1 for x in q if x >= tok.ref0), default=0)
310
+ return ids.to(device), mask.to(device), ref_max.to(device), (ids != tok.pad).sum(1).to(device)
311
+
312
+
313
+ def token_batches(lens, n_train, gen, rng):
314
+ """One epoch of token-budget batches: a random permutation of the training records, stably
315
+ sorted by length (equal lengths stay shuffled), cut greedily into runs of consecutive records
316
+ with count * max_len <= TOK_BUDGET, and the runs' order shuffled. Returns (order, cuts)."""
317
+ perm = torch.randperm(n_train, device=lens.device, generator=gen) + VAL_N
318
+ order = perm[torch.argsort(lens[perm], stable=True)]
319
+ sorted_lens = lens[order].cpu()
320
+ cuts, s = [], 0
321
+ while s < len(sorted_lens):
322
+ window = sorted_lens[s : s + TOK_BUDGET // int(sorted_lens[s])]
323
+ # count * max_len is non-decreasing along the window, so the fits form a prefix.
324
+ e = s + int((torch.arange(1, len(window) + 1) * window <= TOK_BUDGET).sum())
325
+ cuts.append((s, e, int(sorted_lens[e - 1]))) # sorted: last is the batch's max length
326
+ s = e
327
+ rng.shuffle(cuts)
328
+ return order, cuts
329
+
330
+
331
+ def gpu_batch(ids, mask, ref_max, lens, idxs, tok, gen, max_len=None):
332
+ """The fork's batch() + tok.shift_abs, vectorised: a random per-row offset is added to
333
+ every ref token."""
334
+ x, m = ids[idxs], mask[idxs]
335
+ # Known on the host for training batches: passing it avoids a GPU sync every step.
336
+ T = int(lens[idxs].max()) if max_len is None else max_len
337
+ x, m = x[:, :T].clone(), m[:, :T]
338
+ if tok.mode in ("abs", "lean_seq"): # lean_seq: names n1.. get the same start offset
339
+ room = MAXN - ref_max[idxs]
340
+ shift = (
341
+ (torch.rand(len(idxs), device=x.device, generator=gen) * (room + 1))
342
+ .long()
343
+ .clamp(max=room)
344
+ )
345
+ is_ref = (x >= tok.ref0) & m
346
+ x = torch.where(is_ref, x + shift[:, None], x)
347
+ return x, m
348
+
349
+
350
+ def pretrain(train_recs, budget_secs, device, seed, log):
351
+ t0 = time.time()
352
+ tok = make_tokenizer(TOK_MODE)
353
+ data = [(tok.encode_prompt(r["prompt"]), tok.encode_proof(r["proof"])) for r in train_recs]
354
+ ids, mask, ref_max, lens = to_gpu(data, tok, device)
355
+ gen = torch.Generator(device=device)
356
+ gen.manual_seed(seed)
357
+ model = LoopedGPT(tok.vocab_size, N_LAYER, D, N_HEAD, seed)
358
+ model.blocks = torch.nn.ModuleList(PeriLNBlock(D, N_HEAD) for _ in range(N_LAYER))
359
+ model.blocks.apply(model._init) # fork init: zero biases
360
+ model = model.to(device)
361
+ mtp = MTPHead(D, N_HEAD)
362
+ mtp.apply(model._init)
363
+ mtp = mtp.to(device)
364
+ # Compile the repeated blocks once each (torch >= 2.9; dynamic shapes, ~14 s): ~14% faster
365
+ # steps. The coalescing tiling analysis crashes on dynamic shapes, so it is off. Undone at
366
+ # handoff so the harness's RL fine-tune and KV-cache sampling run eager.
367
+ torch._inductor.config.triton.coalesce_tiling_analysis = False
368
+ muon_lr, muon_graph = torch.zeros((), device=device), None
369
+ compiled = list(model.blocks) + [mtp.block]
370
+ for b in compiled if device == "cuda" else []: # CPU smoke runs stay eager
371
+ b.compile(dynamic=True)
372
+ for p in list(model.blocks.parameters()) + list(mtp.parameters()):
373
+ if p.ndim == 2:
374
+ # Orthogonal matrices have element second moment gain^2 / max(rows, cols).
375
+ torch.nn.init.orthogonal_(p, gain=0.02 * math.sqrt(max(p.shape)))
376
+ log(
377
+ f"pretrain: {model.n_params():,} params, {len(data):,} records on {device} "
378
+ f"after {time.time() - t0:.0f}s, budget {budget_secs}s"
379
+ )
380
+ # The output readout joins the hidden matrices under Muon; embeddings stay on AdamW.
381
+ trainable = list(model.parameters()) + list(mtp.parameters())
382
+ matrices = [p for p in model.blocks.parameters() if p.ndim == 2] + [model.head.weight]
383
+ matrices += [p for p in mtp.parameters() if p.ndim == 2]
384
+ matrix_ids = {id(p) for p in matrices}
385
+ auxiliary = [p for p in trainable if id(p) not in matrix_ids]
386
+ momentum_buffers = [torch.zeros_like(p) for p in matrices]
387
+ opt = torch.optim.AdamW(
388
+ auxiliary, lr=LR, weight_decay=WD, betas=(0.9, 0.95), fused=device == "cuda"
389
+ )
390
+ autocast = torch.autocast("cuda", dtype=torch.bfloat16, enabled=(device == "cuda"))
391
+ model.train()
392
+ step, last_loss, records_seen = 0, float("nan"), 0
393
+ curve, recent, recent_aux, next_point = [], [], [], CURVE_EVERY
394
+ n_train = len(data) - VAL_N # records [0, VAL_N) are the val slice
395
+ rng, cuts, batches_per_epoch = random.Random(seed), [], None
396
+ order = torch.empty(0, dtype=torch.long, device=device)
397
+ while True:
398
+ frac = (
399
+ time.time() - t0
400
+ ) / budget_secs # cosine over wall-clock, so the cap is the schedule
401
+ if frac >= 1.0:
402
+ break
403
+ step += 1
404
+ # No warmup (as in modded-nanogpt): Muon's step is normalized and Adam's is ~lr per
405
+ # element from step 1, and Peri-LN normalizes every branch write.
406
+ lr = LR * MIN_LR_FRAC + 0.5 * LR * (1 - MIN_LR_FRAC) * (1 + math.cos(math.pi * frac))
407
+ for g in opt.param_groups:
408
+ g["lr"] = lr
409
+ if not cuts: # new epoch
410
+ order, cuts = token_batches(lens, n_train, gen, rng)
411
+ batches_per_epoch = len(cuts)
412
+ s, e, T = cuts.pop()
413
+ idxs = order[s:e]
414
+ records_seen += e - s
415
+ x, m = gpu_batch(ids, mask, ref_max, lens, idxs, tok, gen, T)
416
+ with autocast:
417
+ loss, main, aux = mtp_loss(model, mtp, x, m)
418
+ model.zero_grad(set_to_none=False) # grads keep fixed addresses for the Muon CUDA graph
419
+ mtp.zero_grad(set_to_none=False)
420
+ loss.backward()
421
+ torch.nn.utils.clip_grad_norm_(trainable, 1.0)
422
+ opt.step()
423
+ muon_lr.fill_(MUON_LR * lr / LR)
424
+ # Capture once; later steps replay one graph instead of ~400 kernel launches. CPU smoke
425
+ # runs call the step directly.
426
+ if device != "cuda":
427
+ muon_step(matrices, momentum_buffers, muon_lr)
428
+ elif muon_graph is None:
429
+ state = matrices + momentum_buffers
430
+ saved = [t.clone() for t in state]
431
+ side = torch.cuda.Stream()
432
+ side.wait_stream(torch.cuda.current_stream())
433
+ with torch.cuda.stream(side):
434
+ muon_step(matrices, momentum_buffers, muon_lr) # warm-up (lazy cuBLAS init)
435
+ torch.cuda.current_stream().wait_stream(side)
436
+ muon_graph = torch.cuda.CUDAGraph()
437
+ with torch.cuda.graph(muon_graph):
438
+ muon_step(matrices, momentum_buffers, muon_lr)
439
+ with torch.no_grad():
440
+ for t, v in zip(state, saved, strict=True):
441
+ t.copy_(v) # undo the warm-up and capture updates
442
+ muon_graph.replay()
443
+ else:
444
+ muon_graph.replay()
445
+ if step % 20 == 0:
446
+ last_loss = main.item() # the next-token CE, comparable with earlier runs
447
+ recent.append(last_loss)
448
+ recent_aux.append(aux.item())
449
+ if (
450
+ time.time() - t0 >= next_point
451
+ ): # curve point: mean recent train loss + val loss on the held-out slice
452
+ curve.append(
453
+ {
454
+ "secs": round(time.time() - t0),
455
+ "step": step,
456
+ "train_loss": sum(recent) / len(recent) if recent else last_loss,
457
+ "val_loss": val_loss(model, ids, mask, ref_max, lens, tok, gen, autocast),
458
+ "mtp_loss": sum(recent_aux) / len(recent_aux) if recent_aux else None,
459
+ }
460
+ )
461
+ log(
462
+ f"pretrain step {step} train {curve[-1]['train_loss']:.4f} "
463
+ f"val {curve[-1]['val_loss']:.4f} lr {lr:.2e} {curve[-1]['secs']}s"
464
+ )
465
+ recent, recent_aux, next_point = [], [], next_point + CURVE_EVERY
466
+ val_by_loops = {}
467
+ for n in VAL_LOOPS if step else (): # no steps: a checkpoint rebuild, not a training run
468
+ model.n_loops = n
469
+ val_by_loops[n] = val_loss(model, ids, mask, ref_max, lens, tok, gen, autocast)
470
+ model.n_loops = DEFAULT_LOOPS
471
+ log(f"pretrain val loss by loops: {val_by_loops}")
472
+ for b in compiled:
473
+ b._compiled_call_impl = None
474
+ model.eval()
475
+ return (
476
+ model,
477
+ tok,
478
+ {
479
+ "steps": step,
480
+ "records_seen": records_seen,
481
+ "epochs": records_seen / n_train,
482
+ "batches_per_epoch": batches_per_epoch,
483
+ "tok_budget": TOK_BUDGET,
484
+ "last_loss": last_loss,
485
+ "train_loops": TRAIN_LOOPS,
486
+ "default_loops": DEFAULT_LOOPS,
487
+ "val_by_loops": val_by_loops,
488
+ "curve": curve,
489
+ },
490
+ )
491
+
492
+
493
+ def finetune(model, tok, data, rng, device):
494
+ """The old harness's RL fine-tune: FT_STEPS AdamW steps, linear warmup then cosine to lr/10.
495
+ The model is in train mode, so every batch draws its own loop count from TRAIN_LOOPS."""
496
+ opt = torch.optim.AdamW(model.parameters(), lr=FT_LR, weight_decay=0.1, betas=(0.9, 0.95))
497
+ autocast = torch.autocast("cuda", dtype=torch.bfloat16, enabled=(device == "cuda"))
498
+ model.train()
499
+ perm = []
500
+ for step in range(1, FT_STEPS + 1):
501
+ lr = (
502
+ FT_LR * step / FT_WARMUP
503
+ if step < FT_WARMUP
504
+ else FT_LR / 10 + 0.45 * FT_LR * (1 + math.cos(math.pi * step / FT_STEPS))
505
+ )
506
+ for g in opt.param_groups:
507
+ g["lr"] = lr
508
+ if len(perm) < FT_BS:
509
+ perm = list(range(len(data)))
510
+ rng.shuffle(perm)
511
+ x, m = mk_batch(data, [perm.pop() for _ in range(FT_BS)], tok, rng, device)
512
+ with autocast:
513
+ loss = loss_on(model, x, m)
514
+ opt.zero_grad(set_to_none=True)
515
+ loss.backward()
516
+ torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
517
+ opt.step()
518
+ model.eval()
519
+ return loss.item()
520
+
521
+
522
+ def rl(model, tok, targets, train_recs, oracle, budget_secs, device, seed, log):
523
+ rng = random.Random(seed)
524
+ found = {t["name"]: {} for t in targets} # name -> {normalized proof: proof text}
525
+ rounds, round_secs, retries = 0, 0.0, []
526
+ # Start a round only if one as long as the last (plus 15%) still fits in the budget.
527
+ while oracle.left() > 1.15 * round_secs:
528
+ t0 = oracle.used()
529
+ model.n_loops = RL_FIRST_LOOPS
530
+ rows = oracle.sample(model, targets, RL_K)
531
+ failed = [t for t, row in zip(targets, rows, strict=True) if not row["proofs"]]
532
+ rng.shuffle(failed)
533
+ for i, n in enumerate(RL_RETRY_LOOPS):
534
+ part = failed[i :: len(RL_RETRY_LOOPS)]
535
+ if not part:
536
+ continue
537
+ model.n_loops = n
538
+ part_rows = oracle.sample(model, part, RL_RETRY_K)
539
+ cracked = sum(bool(row["proofs"]) for row in part_rows)
540
+ retries.append(
541
+ {"round": rounds + 1, "loops": n, "targets": len(part), "cracked": cracked}
542
+ )
543
+ rows += part_rows
544
+ for row in rows:
545
+ for proof in row["proofs"]:
546
+ found[row["name"]].setdefault(norm(proof), proof)
547
+ mix = []
548
+ for t in targets:
549
+ proofs = list(found[t["name"]].values())
550
+ rng.shuffle(proofs)
551
+ mix += [(t["prompt"], proof) for proof in proofs[:MAX_PER_THM]] * RL_WEIGHT
552
+ n_rl = len(mix)
553
+ if not n_rl:
554
+ break
555
+ mix += [(r["prompt"], r["proof"]) for r in rng.sample(train_recs, RETAIN)]
556
+ data = [(tok.encode_prompt(p), tok.encode_proof(q)) for p, q in mix]
557
+ loss = finetune(model, tok, data, rng, device)
558
+ rounds += 1
559
+ round_secs = oracle.used() - t0
560
+ log(
561
+ f"rl round {rounds}: {n_rl} RL records, fine-tune loss {loss:.4f}, "
562
+ f"round {round_secs:.0f}s, {oracle.left():.0f}s left"
563
+ )
564
+ model.n_loops = DEFAULT_LOOPS
565
+ return {
566
+ "rounds": rounds,
567
+ "first_loops": RL_FIRST_LOOPS,
568
+ "k_first": RL_K,
569
+ "retry_loops": RL_RETRY_LOOPS,
570
+ "k_retry": RL_RETRY_K,
571
+ "retries": retries,
572
+ }
runs/508-claude_train-loops-1-4_s1/source/remote.sh ADDED
@@ -0,0 +1,29 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #!/usr/bin/env bash
2
+ # Runs on the pod. Checks out Dan's fork at the pinned commit (frozen data + verifier + Lean
3
+ # tokenizer/gate), installs Lean, runs the harness.
4
+ # Usage: bash remote.sh <out-dir> [harness.py args...]
5
+ set -euo pipefail
6
+ FORK_COMMIT=51604b3feaa5e66821d1faba22238fe6d96d46d0 # dan-pandori/nd-takehome, branch dan_lean_seed2 (lean_seq with the BOTE fix)
7
+ export ND_FORK=/workspace/nd-takehome
8
+ OUT=$1; shift
9
+
10
+ if [ ! -d "$ND_FORK/.git" ]; then
11
+ git clone -q https://github.com/dan-pandori/nd-takehome.git "$ND_FORK"
12
+ fi
13
+ git -C "$ND_FORK" cat-file -e "$FORK_COMMIT" 2>/dev/null || git -C "$ND_FORK" fetch -q origin
14
+ git -C "$ND_FORK" checkout -q "$FORK_COMMIT"
15
+ [ -f "$ND_FORK/data/train.jsonl" ] || gunzip -k "$ND_FORK/data/train.jsonl.gz"
16
+ # Lean 4 core checks every sampled proof (fork lean_gate.py, called from sample.generate): the
17
+ # reward is Lean AND nd_verify. Installed before harness.py starts, so it is not charged to TOTAL_SECS.
18
+ [ -x ~/.elan/bin/lean ] || curl -sSf https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh \
19
+ | sh -s -- -y --default-toolchain leanprover/lean4:v4.34.0 > /dev/null
20
+ # One Lean process per CPU: on these pods (nproc 96) 12 workers took 146 s per RL-round gate
21
+ # pass (099) against 67-84 s with 96 workers (098).
22
+ export LEAN_GATE_WORKERS=$(nproc) LEAN_GATE_LOG="$OUT/lean_gate.jsonl"
23
+ nvidia-smi --query-gpu=name,memory.total --format=csv,noheader
24
+ echo "cpus $(nproc), $(~/.elan/bin/lean --version)"
25
+ # Newer RunPod images put torch under `python` and leave `python3` as bare system Python.
26
+ PY=$(for p in python python3; do "$p" -c "import torch" 2>/dev/null && echo "$p" && break; done)
27
+ echo "python $($PY --version 2>&1), torch $($PY -c 'import torch; print(torch.__version__)')"
28
+ cd /workspace/autoresearch
29
+ $PY harness.py --out "$OUT" "$@" 2>&1 | tee "$OUT.log"
runs/508-claude_train-loops-1-4_s1/summary.json ADDED
@@ -0,0 +1,1627 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "status": "ok",
3
+ "metric": 699,
4
+ "metric_diag": 710,
5
+ "metric_rl": 1253,
6
+ "harness_sha": "2eec1b61666a",
7
+ "pretrain_sha": "ab246e5a273c",
8
+ "device": "cuda",
9
+ "gpu": "NVIDIA A40",
10
+ "torch": "2.9.1+cu129",
11
+ "lean_gate": {
12
+ "samples": 348480,
13
+ "parse_fail": 68247,
14
+ "distinct_checked": 240903,
15
+ "both_ok": 121911,
16
+ "nd_ok_lean_rej": 0,
17
+ "nd_rej_lean_ok": 7,
18
+ "lean_wall_s": 709.3262002468109
19
+ },
20
+ "total_secs": 3438.7752063274384,
21
+ "rules": {
22
+ "TOTAL_SECS": 5400,
23
+ "PRETRAIN_SECS": 300,
24
+ "RL_SECS": 1800,
25
+ "PARAM_CAP": 10000000,
26
+ "N_TARGETS": 1500,
27
+ "EVAL_K": 64,
28
+ "KNOB": "n_loops",
29
+ "EVAL_LEVEL": 8,
30
+ "DIAG_LEVEL": 2,
31
+ "TOK_MODE": "lean_seq"
32
+ },
33
+ "pretrain": {
34
+ "steps": 4896,
35
+ "records_seen": 665840,
36
+ "epochs": 4.324591143499214,
37
+ "batches_per_epoch": 1132,
38
+ "tok_budget": 18432,
39
+ "last_loss": 0.07998035103082657,
40
+ "train_loops": [
41
+ 1,
42
+ 2,
43
+ 3,
44
+ 4
45
+ ],
46
+ "default_loops": 2,
47
+ "val_by_loops": {
48
+ "1": 0.07932555116713047,
49
+ "2": 0.07843899447470903,
50
+ "4": 0.07835306134074926,
51
+ "8": 0.0783498091623187
52
+ },
53
+ "curve": [
54
+ {
55
+ "secs": 29,
56
+ "step": 1,
57
+ "train_loss": NaN,
58
+ "val_loss": 3.9497697353363037,
59
+ "mtp_loss": null
60
+ },
61
+ {
62
+ "secs": 31,
63
+ "step": 2,
64
+ "train_loss": NaN,
65
+ "val_loss": 3.5075501799583435,
66
+ "mtp_loss": null
67
+ },
68
+ {
69
+ "secs": 45,
70
+ "step": 260,
71
+ "train_loss": 0.4138674483849452,
72
+ "val_loss": 0.11963934078812599,
73
+ "mtp_loss": 0.3816663215939815
74
+ },
75
+ {
76
+ "secs": 60,
77
+ "step": 535,
78
+ "train_loss": 0.10333871956054981,
79
+ "val_loss": 0.08769758138805628,
80
+ "mtp_loss": 0.10532220739584702
81
+ },
82
+ {
83
+ "secs": 75,
84
+ "step": 816,
85
+ "train_loss": 0.08327093347907066,
86
+ "val_loss": 0.07893737312406301,
87
+ "mtp_loss": 0.08182504560266222
88
+ },
89
+ {
90
+ "secs": 90,
91
+ "step": 1087,
92
+ "train_loss": 0.07677790096827916,
93
+ "val_loss": 0.11026985477656126,
94
+ "mtp_loss": 0.07673186888652188
95
+ },
96
+ {
97
+ "secs": 105,
98
+ "step": 1358,
99
+ "train_loss": 0.07450703130318569,
100
+ "val_loss": 0.08978806622326374,
101
+ "mtp_loss": 0.07687717762130958
102
+ },
103
+ {
104
+ "secs": 120,
105
+ "step": 1636,
106
+ "train_loss": 0.06233426263289792,
107
+ "val_loss": 0.08998281229287386,
108
+ "mtp_loss": 0.06489526719919272
109
+ },
110
+ {
111
+ "secs": 135,
112
+ "step": 1913,
113
+ "train_loss": 0.06946982416723456,
114
+ "val_loss": 0.08874713443219662,
115
+ "mtp_loss": 0.07057634687849454
116
+ },
117
+ {
118
+ "secs": 150,
119
+ "step": 2180,
120
+ "train_loss": 0.060950237193277905,
121
+ "val_loss": 0.08048161026090384,
122
+ "mtp_loss": 0.06074396919991289
123
+ },
124
+ {
125
+ "secs": 165,
126
+ "step": 2455,
127
+ "train_loss": 0.07034701452805446,
128
+ "val_loss": 0.09360270854085684,
129
+ "mtp_loss": 0.07109934722001736
130
+ },
131
+ {
132
+ "secs": 180,
133
+ "step": 2728,
134
+ "train_loss": 0.05252793205103704,
135
+ "val_loss": 0.08074245881289244,
136
+ "mtp_loss": 0.05466838314064911
137
+ },
138
+ {
139
+ "secs": 195,
140
+ "step": 3002,
141
+ "train_loss": 0.061649431341460774,
142
+ "val_loss": 0.08451414294540882,
143
+ "mtp_loss": 0.0617743365998779
144
+ },
145
+ {
146
+ "secs": 210,
147
+ "step": 3270,
148
+ "train_loss": 0.055062055874329344,
149
+ "val_loss": 0.0805716197937727,
150
+ "mtp_loss": 0.05518401299531643
151
+ },
152
+ {
153
+ "secs": 225,
154
+ "step": 3546,
155
+ "train_loss": 0.06189275932099138,
156
+ "val_loss": 0.08402281161397696,
157
+ "mtp_loss": 0.06240730998771531
158
+ },
159
+ {
160
+ "secs": 240,
161
+ "step": 3816,
162
+ "train_loss": 0.06110814070472351,
163
+ "val_loss": 0.07766791805624962,
164
+ "mtp_loss": 0.06128943138397657
165
+ },
166
+ {
167
+ "secs": 255,
168
+ "step": 4090,
169
+ "train_loss": 0.0491904823907784,
170
+ "val_loss": 0.0838982556015253,
171
+ "mtp_loss": 0.05052018431680543
172
+ },
173
+ {
174
+ "secs": 270,
175
+ "step": 4354,
176
+ "train_loss": 0.0506979778695565,
177
+ "val_loss": 0.080127096734941,
178
+ "mtp_loss": 0.05084898222524386
179
+ },
180
+ {
181
+ "secs": 285,
182
+ "step": 4627,
183
+ "train_loss": 0.057051322289875576,
184
+ "val_loss": 0.08375953789800406,
185
+ "mtp_loss": 0.05702493565955332
186
+ },
187
+ {
188
+ "secs": 300,
189
+ "step": 4896,
190
+ "train_loss": 0.05593667566203154,
191
+ "val_loss": 0.07843899447470903,
192
+ "mtp_loss": 0.056296565784857824
193
+ }
194
+ ],
195
+ "secs": 301.02019929885864,
196
+ "n_params": 6400256,
197
+ "heldout_greedy": 0.9665
198
+ },
199
+ "rl": {
200
+ "rounds": [
201
+ {
202
+ "round": 1,
203
+ "level": 1,
204
+ "k": 8,
205
+ "n_targets": 1500,
206
+ "sample_acc": 0.12375,
207
+ "new_proofs": 532,
208
+ "targets_solved": 440,
209
+ "lstar": 9,
210
+ "ge": {
211
+ "7": 440,
212
+ "8": 125,
213
+ "9": 19,
214
+ "10": 0,
215
+ "11": 0,
216
+ "12": 0,
217
+ "13": 0,
218
+ "14": 0
219
+ },
220
+ "mix_rl_records": 532,
221
+ "sampling": {
222
+ "samples": 12000,
223
+ "secs": 55.422903060913086,
224
+ "gate_secs": 21.84827494621277,
225
+ "samples_per_sec": 216.5169873330396
226
+ },
227
+ "secs": 55.80424118041992,
228
+ "rl_secs_used": 33.956244707107544
229
+ },
230
+ {
231
+ "round": 2,
232
+ "level": 2,
233
+ "k": 24,
234
+ "n_targets": 354,
235
+ "sample_acc": 0.06226459510357815,
236
+ "new_proofs": 121,
237
+ "targets_solved": 532,
238
+ "lstar": 9,
239
+ "ge": {
240
+ "7": 532,
241
+ "8": 175,
242
+ "9": 33,
243
+ "10": 1,
244
+ "11": 0,
245
+ "12": 0,
246
+ "13": 0,
247
+ "14": 0
248
+ },
249
+ "mix_rl_records": 121,
250
+ "sampling": {
251
+ "samples": 8496,
252
+ "secs": 49.493592262268066,
253
+ "gate_secs": 15.462708473205566,
254
+ "samples_per_sec": 171.6585847109144
255
+ },
256
+ "secs": 49.765456676483154,
257
+ "rl_secs_used": 68.25883650779724
258
+ },
259
+ {
260
+ "round": 3,
261
+ "level": 4,
262
+ "k": 24,
263
+ "n_targets": 353,
264
+ "sample_acc": 0.09029745042492918,
265
+ "new_proofs": 133,
266
+ "targets_solved": 633,
267
+ "lstar": 9,
268
+ "ge": {
269
+ "7": 633,
270
+ "8": 229,
271
+ "9": 54,
272
+ "10": 2,
273
+ "11": 0,
274
+ "12": 0,
275
+ "13": 0,
276
+ "14": 0
277
+ },
278
+ "mix_rl_records": 133,
279
+ "sampling": {
280
+ "samples": 8472,
281
+ "secs": 71.22210884094238,
282
+ "gate_secs": 17.25083875656128,
283
+ "samples_per_sec": 118.95182742931965
284
+ },
285
+ "secs": 71.51018285751343,
286
+ "rl_secs_used": 122.5181155204773
287
+ },
288
+ {
289
+ "round": 4,
290
+ "level": 8,
291
+ "k": 24,
292
+ "n_targets": 353,
293
+ "sample_acc": 0.09324834749763929,
294
+ "new_proofs": 122,
295
+ "targets_solved": 733,
296
+ "lstar": 10,
297
+ "ge": {
298
+ "7": 733,
299
+ "8": 285,
300
+ "9": 88,
301
+ "10": 8,
302
+ "11": 0,
303
+ "12": 0,
304
+ "13": 0,
305
+ "14": 0
306
+ },
307
+ "mix_rl_records": 122,
308
+ "sampling": {
309
+ "samples": 8472,
310
+ "secs": 108.99591207504272,
311
+ "gate_secs": 21.919137716293335,
312
+ "samples_per_sec": 77.72768573345304
313
+ },
314
+ "secs": 109.2922797203064,
315
+ "rl_secs_used": 209.89131331443787
316
+ },
317
+ {
318
+ "round": 5,
319
+ "level": 1,
320
+ "k": 8,
321
+ "n_targets": 1500,
322
+ "sample_acc": 0.53125,
323
+ "new_proofs": 345,
324
+ "targets_solved": 913,
325
+ "lstar": 10,
326
+ "ge": {
327
+ "7": 913,
328
+ "8": 410,
329
+ "9": 169,
330
+ "10": 27,
331
+ "11": 2,
332
+ "12": 0,
333
+ "13": 0,
334
+ "14": 0
335
+ },
336
+ "mix_rl_records": 1210,
337
+ "sampling": {
338
+ "samples": 12000,
339
+ "secs": 53.8583664894104,
340
+ "gate_secs": 31.66202998161316,
341
+ "samples_per_sec": 222.80660892972745
342
+ },
343
+ "secs": 139.3298361301422,
344
+ "rl_secs_used": 317.55918288230896
345
+ },
346
+ {
347
+ "round": 6,
348
+ "level": 2,
349
+ "k": 24,
350
+ "n_targets": 196,
351
+ "sample_acc": 0.02423469387755102,
352
+ "new_proofs": 36,
353
+ "targets_solved": 938,
354
+ "lstar": 11,
355
+ "ge": {
356
+ "7": 938,
357
+ "8": 431,
358
+ "9": 185,
359
+ "10": 31,
360
+ "11": 5,
361
+ "12": 0,
362
+ "13": 0,
363
+ "14": 0
364
+ },
365
+ "mix_rl_records": 36,
366
+ "sampling": {
367
+ "samples": 4704,
368
+ "secs": 30.1107919216156,
369
+ "gate_secs": 12.832277297973633,
370
+ "samples_per_sec": 156.22305823923364
371
+ },
372
+ "secs": 30.29073143005371,
373
+ "rl_secs_used": 335.01751160621643
374
+ },
375
+ {
376
+ "round": 7,
377
+ "level": 4,
378
+ "k": 24,
379
+ "n_targets": 196,
380
+ "sample_acc": 0.041666666666666664,
381
+ "new_proofs": 37,
382
+ "targets_solved": 967,
383
+ "lstar": 11,
384
+ "ge": {
385
+ "7": 967,
386
+ "8": 454,
387
+ "9": 203,
388
+ "10": 36,
389
+ "11": 6,
390
+ "12": 0,
391
+ "13": 0,
392
+ "14": 0
393
+ },
394
+ "mix_rl_records": 37,
395
+ "sampling": {
396
+ "samples": 4704,
397
+ "secs": 40.96632933616638,
398
+ "gate_secs": 12.957511901855469,
399
+ "samples_per_sec": 114.82600653330097
400
+ },
401
+ "secs": 41.139267444610596,
402
+ "rl_secs_used": 363.19925355911255
403
+ },
404
+ {
405
+ "round": 8,
406
+ "level": 8,
407
+ "k": 24,
408
+ "n_targets": 195,
409
+ "sample_acc": 0.04188034188034188,
410
+ "new_proofs": 37,
411
+ "targets_solved": 996,
412
+ "lstar": 11,
413
+ "ge": {
414
+ "7": 996,
415
+ "8": 474,
416
+ "9": 217,
417
+ "10": 42,
418
+ "11": 7,
419
+ "12": 0,
420
+ "13": 0,
421
+ "14": 0
422
+ },
423
+ "mix_rl_records": 37,
424
+ "sampling": {
425
+ "samples": 4680,
426
+ "secs": 61.046074867248535,
427
+ "gate_secs": 13.325291633605957,
428
+ "samples_per_sec": 76.66340563545124
429
+ },
430
+ "secs": 61.22578501701355,
431
+ "rl_secs_used": 411.099769115448
432
+ },
433
+ {
434
+ "round": 9,
435
+ "level": 1,
436
+ "k": 8,
437
+ "n_targets": 1500,
438
+ "sample_acc": 0.6464166666666666,
439
+ "new_proofs": 183,
440
+ "targets_solved": 1048,
441
+ "lstar": 11,
442
+ "ge": {
443
+ "7": 1048,
444
+ "8": 514,
445
+ "9": 252,
446
+ "10": 52,
447
+ "11": 7,
448
+ "12": 0,
449
+ "13": 0,
450
+ "14": 0
451
+ },
452
+ "mix_rl_records": 1472,
453
+ "sampling": {
454
+ "samples": 12000,
455
+ "secs": 51.7765793800354,
456
+ "gate_secs": 32.01777696609497,
457
+ "samples_per_sec": 231.76502085858334
458
+ },
459
+ "secs": 147.98511695861816,
460
+ "rl_secs_used": 527.0673339366913
461
+ },
462
+ {
463
+ "round": 10,
464
+ "level": 2,
465
+ "k": 24,
466
+ "n_targets": 151,
467
+ "sample_acc": 0.018211920529801324,
468
+ "new_proofs": 22,
469
+ "targets_solved": 1066,
470
+ "lstar": 11,
471
+ "ge": {
472
+ "7": 1066,
473
+ "8": 529,
474
+ "9": 265,
475
+ "10": 56,
476
+ "11": 7,
477
+ "12": 0,
478
+ "13": 0,
479
+ "14": 0
480
+ },
481
+ "mix_rl_records": 22,
482
+ "sampling": {
483
+ "samples": 3624,
484
+ "secs": 20.06104874610901,
485
+ "gate_secs": 10.286924123764038,
486
+ "samples_per_sec": 180.64858153055943
487
+ },
488
+ "secs": 20.201847314834595,
489
+ "rl_secs_used": 536.9820017814636
490
+ },
491
+ {
492
+ "round": 11,
493
+ "level": 4,
494
+ "k": 24,
495
+ "n_targets": 151,
496
+ "sample_acc": 0.008278145695364239,
497
+ "new_proofs": 20,
498
+ "targets_solved": 1082,
499
+ "lstar": 11,
500
+ "ge": {
501
+ "7": 1082,
502
+ "8": 542,
503
+ "9": 275,
504
+ "10": 61,
505
+ "11": 8,
506
+ "12": 1,
507
+ "13": 0,
508
+ "14": 0
509
+ },
510
+ "mix_rl_records": 20,
511
+ "sampling": {
512
+ "samples": 3624,
513
+ "secs": 25.822150707244873,
514
+ "gate_secs": 9.60978627204895,
515
+ "samples_per_sec": 140.34462276541595
516
+ },
517
+ "secs": 25.945783376693726,
518
+ "rl_secs_used": 553.3179998397827
519
+ },
520
+ {
521
+ "round": 12,
522
+ "level": 8,
523
+ "k": 24,
524
+ "n_targets": 150,
525
+ "sample_acc": 0.023333333333333334,
526
+ "new_proofs": 16,
527
+ "targets_solved": 1096,
528
+ "lstar": 11,
529
+ "ge": {
530
+ "7": 1096,
531
+ "8": 552,
532
+ "9": 284,
533
+ "10": 65,
534
+ "11": 10,
535
+ "12": 1,
536
+ "13": 0,
537
+ "14": 0
538
+ },
539
+ "mix_rl_records": 16,
540
+ "sampling": {
541
+ "samples": 3600,
542
+ "secs": 44.64367485046387,
543
+ "gate_secs": 9.417763948440552,
544
+ "samples_per_sec": 80.6385229723667
545
+ },
546
+ "secs": 44.77871489524841,
547
+ "rl_secs_used": 588.6789510250092
548
+ },
549
+ {
550
+ "round": 13,
551
+ "level": 1,
552
+ "k": 8,
553
+ "n_targets": 1500,
554
+ "sample_acc": 0.7039166666666666,
555
+ "new_proofs": 128,
556
+ "targets_solved": 1115,
557
+ "lstar": 11,
558
+ "ge": {
559
+ "7": 1115,
560
+ "8": 566,
561
+ "9": 295,
562
+ "10": 71,
563
+ "11": 12,
564
+ "12": 2,
565
+ "13": 0,
566
+ "14": 0
567
+ },
568
+ "mix_rl_records": 1606,
569
+ "sampling": {
570
+ "samples": 12000,
571
+ "secs": 49.093042612075806,
572
+ "gate_secs": 29.794137716293335,
573
+ "samples_per_sec": 244.4338211999161
574
+ },
575
+ "secs": 145.35737085342407,
576
+ "rl_secs_used": 704.2423753738403
577
+ },
578
+ {
579
+ "round": 14,
580
+ "level": 2,
581
+ "k": 24,
582
+ "n_targets": 129,
583
+ "sample_acc": 0.005490956072351421,
584
+ "new_proofs": 11,
585
+ "targets_solved": 1123,
586
+ "lstar": 11,
587
+ "ge": {
588
+ "7": 1123,
589
+ "8": 571,
590
+ "9": 300,
591
+ "10": 73,
592
+ "11": 14,
593
+ "12": 2,
594
+ "13": 0,
595
+ "14": 0
596
+ },
597
+ "mix_rl_records": 11,
598
+ "sampling": {
599
+ "samples": 3096,
600
+ "secs": 19.02231192588806,
601
+ "gate_secs": 8.194875240325928,
602
+ "samples_per_sec": 162.75624183128636
603
+ },
604
+ "secs": 19.132587909698486,
605
+ "rl_secs_used": 715.1799137592316
606
+ },
607
+ {
608
+ "round": 15,
609
+ "level": 4,
610
+ "k": 24,
611
+ "n_targets": 128,
612
+ "sample_acc": 0.0205078125,
613
+ "new_proofs": 15,
614
+ "targets_solved": 1136,
615
+ "lstar": 11,
616
+ "ge": {
617
+ "7": 1136,
618
+ "8": 584,
619
+ "9": 312,
620
+ "10": 78,
621
+ "11": 15,
622
+ "12": 2,
623
+ "13": 0,
624
+ "14": 0
625
+ },
626
+ "mix_rl_records": 15,
627
+ "sampling": {
628
+ "samples": 3072,
629
+ "secs": 25.690166234970093,
630
+ "gate_secs": 8.192529439926147,
631
+ "samples_per_sec": 119.57882918711196
632
+ },
633
+ "secs": 25.80337119102478,
634
+ "rl_secs_used": 732.7907383441925
635
+ },
636
+ {
637
+ "round": 16,
638
+ "level": 8,
639
+ "k": 24,
640
+ "n_targets": 128,
641
+ "sample_acc": 0.0166015625,
642
+ "new_proofs": 15,
643
+ "targets_solved": 1147,
644
+ "lstar": 11,
645
+ "ge": {
646
+ "7": 1147,
647
+ "8": 594,
648
+ "9": 320,
649
+ "10": 82,
650
+ "11": 17,
651
+ "12": 3,
652
+ "13": 0,
653
+ "14": 0
654
+ },
655
+ "mix_rl_records": 15,
656
+ "sampling": {
657
+ "samples": 3072,
658
+ "secs": 28.9809410572052,
659
+ "gate_secs": 8.214029312133789,
660
+ "samples_per_sec": 106.00069866386356
661
+ },
662
+ "secs": 29.08859634399414,
663
+ "rl_secs_used": 753.6653015613556
664
+ },
665
+ {
666
+ "round": 17,
667
+ "level": 1,
668
+ "k": 8,
669
+ "n_targets": 1500,
670
+ "sample_acc": 0.7283333333333334,
671
+ "new_proofs": 104,
672
+ "targets_solved": 1156,
673
+ "lstar": 11,
674
+ "ge": {
675
+ "7": 1156,
676
+ "8": 601,
677
+ "9": 326,
678
+ "10": 85,
679
+ "11": 18,
680
+ "12": 3,
681
+ "13": 0,
682
+ "14": 0
683
+ },
684
+ "mix_rl_records": 1718,
685
+ "sampling": {
686
+ "samples": 12000,
687
+ "secs": 50.56643867492676,
688
+ "gate_secs": 31.25817108154297,
689
+ "samples_per_sec": 237.31155118800507
690
+ },
691
+ "secs": 151.99655055999756,
692
+ "rl_secs_used": 874.403838634491
693
+ },
694
+ {
695
+ "round": 18,
696
+ "level": 2,
697
+ "k": 24,
698
+ "n_targets": 115,
699
+ "sample_acc": 0.008333333333333333,
700
+ "new_proofs": 8,
701
+ "targets_solved": 1164,
702
+ "lstar": 11,
703
+ "ge": {
704
+ "7": 1164,
705
+ "8": 607,
706
+ "9": 330,
707
+ "10": 87,
708
+ "11": 19,
709
+ "12": 3,
710
+ "13": 0,
711
+ "14": 0
712
+ },
713
+ "mix_rl_records": 8,
714
+ "sampling": {
715
+ "samples": 2760,
716
+ "secs": 14.502812385559082,
717
+ "gate_secs": 7.128389596939087,
718
+ "samples_per_sec": 190.3079159148622
719
+ },
720
+ "secs": 14.602341651916504,
721
+ "rl_secs_used": 881.8776323795319
722
+ },
723
+ {
724
+ "round": 19,
725
+ "level": 4,
726
+ "k": 24,
727
+ "n_targets": 115,
728
+ "sample_acc": 0.008333333333333333,
729
+ "new_proofs": 14,
730
+ "targets_solved": 1173,
731
+ "lstar": 11,
732
+ "ge": {
733
+ "7": 1173,
734
+ "8": 613,
735
+ "9": 334,
736
+ "10": 89,
737
+ "11": 20,
738
+ "12": 3,
739
+ "13": 0,
740
+ "14": 0
741
+ },
742
+ "mix_rl_records": 14,
743
+ "sampling": {
744
+ "samples": 2760,
745
+ "secs": 19.79558229446411,
746
+ "gate_secs": 6.3564887046813965,
747
+ "samples_per_sec": 139.42504741433353
748
+ },
749
+ "secs": 19.885202169418335,
750
+ "rl_secs_used": 895.4063513278961
751
+ },
752
+ {
753
+ "round": 20,
754
+ "level": 8,
755
+ "k": 24,
756
+ "n_targets": 114,
757
+ "sample_acc": 0.017909356725146198,
758
+ "new_proofs": 10,
759
+ "targets_solved": 1180,
760
+ "lstar": 11,
761
+ "ge": {
762
+ "7": 1180,
763
+ "8": 619,
764
+ "9": 339,
765
+ "10": 91,
766
+ "11": 20,
767
+ "12": 3,
768
+ "13": 0,
769
+ "14": 0
770
+ },
771
+ "mix_rl_records": 10,
772
+ "sampling": {
773
+ "samples": 2736,
774
+ "secs": 37.968289852142334,
775
+ "gate_secs": 6.637112379074097,
776
+ "samples_per_sec": 72.0601325646913
777
+ },
778
+ "secs": 38.06486177444458,
779
+ "rl_secs_used": 926.8341023921967
780
+ },
781
+ {
782
+ "round": 21,
783
+ "level": 1,
784
+ "k": 8,
785
+ "n_targets": 1500,
786
+ "sample_acc": 0.7615833333333333,
787
+ "new_proofs": 105,
788
+ "targets_solved": 1188,
789
+ "lstar": 11,
790
+ "ge": {
791
+ "7": 1188,
792
+ "8": 625,
793
+ "9": 342,
794
+ "10": 92,
795
+ "11": 20,
796
+ "12": 3,
797
+ "13": 0,
798
+ "14": 0
799
+ },
800
+ "mix_rl_records": 1809,
801
+ "sampling": {
802
+ "samples": 12000,
803
+ "secs": 52.52578353881836,
804
+ "gate_secs": 31.468045711517334,
805
+ "samples_per_sec": 228.45922881153382
806
+ },
807
+ "secs": 155.1357831954956,
808
+ "rl_secs_used": 1050.502231836319
809
+ },
810
+ {
811
+ "round": 22,
812
+ "level": 2,
813
+ "k": 24,
814
+ "n_targets": 104,
815
+ "sample_acc": 0.0008012820512820513,
816
+ "new_proofs": 2,
817
+ "targets_solved": 1190,
818
+ "lstar": 11,
819
+ "ge": {
820
+ "7": 1190,
821
+ "8": 627,
822
+ "9": 344,
823
+ "10": 92,
824
+ "11": 20,
825
+ "12": 3,
826
+ "13": 0,
827
+ "14": 0
828
+ },
829
+ "mix_rl_records": 2,
830
+ "sampling": {
831
+ "samples": 2496,
832
+ "secs": 13.654530048370361,
833
+ "gate_secs": 5.841443777084351,
834
+ "samples_per_sec": 182.79647788375493
835
+ },
836
+ "secs": 13.74906063079834,
837
+ "rl_secs_used": 1058.409460067749
838
+ },
839
+ {
840
+ "round": 23,
841
+ "level": 4,
842
+ "k": 24,
843
+ "n_targets": 104,
844
+ "sample_acc": 0.007211538461538462,
845
+ "new_proofs": 4,
846
+ "targets_solved": 1194,
847
+ "lstar": 11,
848
+ "ge": {
849
+ "7": 1194,
850
+ "8": 631,
851
+ "9": 345,
852
+ "10": 93,
853
+ "11": 20,
854
+ "12": 3,
855
+ "13": 0,
856
+ "14": 0
857
+ },
858
+ "mix_rl_records": 4,
859
+ "sampling": {
860
+ "samples": 2496,
861
+ "secs": 21.720415592193604,
862
+ "gate_secs": 6.094824552536011,
863
+ "samples_per_sec": 114.91492828051925
864
+ },
865
+ "secs": 21.812037467956543,
866
+ "rl_secs_used": 1074.126671075821
867
+ },
868
+ {
869
+ "round": 24,
870
+ "level": 8,
871
+ "k": 24,
872
+ "n_targets": 104,
873
+ "sample_acc": 0.008012820512820512,
874
+ "new_proofs": 7,
875
+ "targets_solved": 1200,
876
+ "lstar": 11,
877
+ "ge": {
878
+ "7": 1200,
879
+ "8": 635,
880
+ "9": 347,
881
+ "10": 95,
882
+ "11": 21,
883
+ "12": 3,
884
+ "13": 0,
885
+ "14": 0
886
+ },
887
+ "mix_rl_records": 7,
888
+ "sampling": {
889
+ "samples": 2496,
890
+ "secs": 30.535436868667603,
891
+ "gate_secs": 6.494610071182251,
892
+ "samples_per_sec": 81.74109349524795
893
+ },
894
+ "secs": 30.626827716827393,
895
+ "rl_secs_used": 1098.2588875293732
896
+ },
897
+ {
898
+ "round": 25,
899
+ "level": 1,
900
+ "k": 8,
901
+ "n_targets": 1500,
902
+ "sample_acc": 0.7785,
903
+ "new_proofs": 97,
904
+ "targets_solved": 1211,
905
+ "lstar": 11,
906
+ "ge": {
907
+ "7": 1211,
908
+ "8": 644,
909
+ "9": 354,
910
+ "10": 99,
911
+ "11": 21,
912
+ "12": 3,
913
+ "13": 0,
914
+ "14": 0
915
+ },
916
+ "mix_rl_records": 1916,
917
+ "sampling": {
918
+ "samples": 12000,
919
+ "secs": 52.54820489883423,
920
+ "gate_secs": 32.17544913291931,
921
+ "samples_per_sec": 228.36174942802313
922
+ },
923
+ "secs": 154.4447832107544,
924
+ "rl_secs_used": 1220.5285859107971
925
+ },
926
+ {
927
+ "round": 26,
928
+ "level": 2,
929
+ "k": 24,
930
+ "n_targets": 97,
931
+ "sample_acc": 0.006443298969072165,
932
+ "new_proofs": 2,
933
+ "targets_solved": 1213,
934
+ "lstar": 11,
935
+ "ge": {
936
+ "7": 1213,
937
+ "8": 645,
938
+ "9": 354,
939
+ "10": 99,
940
+ "11": 21,
941
+ "12": 3,
942
+ "13": 0,
943
+ "14": 0
944
+ },
945
+ "mix_rl_records": 2,
946
+ "sampling": {
947
+ "samples": 2328,
948
+ "secs": 11.489040851593018,
949
+ "gate_secs": 5.87921929359436,
950
+ "samples_per_sec": 202.6278807840787
951
+ },
952
+ "secs": 11.569452047348022,
953
+ "rl_secs_used": 1226.218446969986
954
+ },
955
+ {
956
+ "round": 27,
957
+ "level": 4,
958
+ "k": 24,
959
+ "n_targets": 96,
960
+ "sample_acc": 0.006944444444444444,
961
+ "new_proofs": 7,
962
+ "targets_solved": 1220,
963
+ "lstar": 11,
964
+ "ge": {
965
+ "7": 1220,
966
+ "8": 650,
967
+ "9": 358,
968
+ "10": 100,
969
+ "11": 21,
970
+ "12": 3,
971
+ "13": 0,
972
+ "14": 0
973
+ },
974
+ "mix_rl_records": 7,
975
+ "sampling": {
976
+ "samples": 2304,
977
+ "secs": 20.82362389564514,
978
+ "gate_secs": 5.844320774078369,
979
+ "samples_per_sec": 110.64356576675576
980
+ },
981
+ "secs": 20.904887437820435,
982
+ "rl_secs_used": 1241.2790114879608
983
+ },
984
+ {
985
+ "round": 28,
986
+ "level": 8,
987
+ "k": 24,
988
+ "n_targets": 96,
989
+ "sample_acc": 0.0078125,
990
+ "new_proofs": 2,
991
+ "targets_solved": 1222,
992
+ "lstar": 11,
993
+ "ge": {
994
+ "7": 1222,
995
+ "8": 651,
996
+ "9": 358,
997
+ "10": 100,
998
+ "11": 21,
999
+ "12": 3,
1000
+ "13": 0,
1001
+ "14": 0
1002
+ },
1003
+ "mix_rl_records": 2,
1004
+ "sampling": {
1005
+ "samples": 2304,
1006
+ "secs": 20.012036085128784,
1007
+ "gate_secs": 4.937503337860107,
1008
+ "samples_per_sec": 115.13071384636038
1009
+ },
1010
+ "secs": 20.082530736923218,
1011
+ "rl_secs_used": 1256.4240372180939
1012
+ },
1013
+ {
1014
+ "round": 29,
1015
+ "level": 1,
1016
+ "k": 8,
1017
+ "n_targets": 1500,
1018
+ "sample_acc": 0.7958333333333333,
1019
+ "new_proofs": 103,
1020
+ "targets_solved": 1237,
1021
+ "lstar": 11,
1022
+ "ge": {
1023
+ "7": 1237,
1024
+ "8": 662,
1025
+ "9": 364,
1026
+ "10": 101,
1027
+ "11": 21,
1028
+ "12": 3,
1029
+ "13": 0,
1030
+ "14": 0
1031
+ },
1032
+ "mix_rl_records": 2020,
1033
+ "sampling": {
1034
+ "samples": 12000,
1035
+ "secs": 51.30918574333191,
1036
+ "gate_secs": 30.319478511810303,
1037
+ "samples_per_sec": 233.87625093153048
1038
+ },
1039
+ "secs": 154.829745054245,
1040
+ "rl_secs_used": 1380.934630393982
1041
+ },
1042
+ {
1043
+ "round": 30,
1044
+ "level": 2,
1045
+ "k": 24,
1046
+ "n_targets": 88,
1047
+ "sample_acc": 0.014678030303030304,
1048
+ "new_proofs": 5,
1049
+ "targets_solved": 1242,
1050
+ "lstar": 11,
1051
+ "ge": {
1052
+ "7": 1242,
1053
+ "8": 664,
1054
+ "9": 366,
1055
+ "10": 101,
1056
+ "11": 21,
1057
+ "12": 3,
1058
+ "13": 0,
1059
+ "14": 0
1060
+ },
1061
+ "mix_rl_records": 5,
1062
+ "sampling": {
1063
+ "samples": 2112,
1064
+ "secs": 13.697171926498413,
1065
+ "gate_secs": 4.878606081008911,
1066
+ "samples_per_sec": 154.1924136846195
1067
+ },
1068
+ "secs": 13.767189025878906,
1069
+ "rl_secs_used": 1389.8228862285614
1070
+ },
1071
+ {
1072
+ "round": 31,
1073
+ "level": 4,
1074
+ "k": 24,
1075
+ "n_targets": 88,
1076
+ "sample_acc": 0.000946969696969697,
1077
+ "new_proofs": 1,
1078
+ "targets_solved": 1243,
1079
+ "lstar": 11,
1080
+ "ge": {
1081
+ "7": 1243,
1082
+ "8": 665,
1083
+ "9": 366,
1084
+ "10": 101,
1085
+ "11": 21,
1086
+ "12": 3,
1087
+ "13": 0,
1088
+ "14": 0
1089
+ },
1090
+ "mix_rl_records": 1,
1091
+ "sampling": {
1092
+ "samples": 2112,
1093
+ "secs": 15.31467318534851,
1094
+ "gate_secs": 4.829330682754517,
1095
+ "samples_per_sec": 137.9069585383345
1096
+ },
1097
+ "secs": 15.38122034072876,
1098
+ "rl_secs_used": 1400.3747754096985
1099
+ },
1100
+ {
1101
+ "round": 32,
1102
+ "level": 8,
1103
+ "k": 24,
1104
+ "n_targets": 87,
1105
+ "sample_acc": 0.010057471264367816,
1106
+ "new_proofs": 3,
1107
+ "targets_solved": 1246,
1108
+ "lstar": 11,
1109
+ "ge": {
1110
+ "7": 1246,
1111
+ "8": 667,
1112
+ "9": 367,
1113
+ "10": 102,
1114
+ "11": 21,
1115
+ "12": 3,
1116
+ "13": 0,
1117
+ "14": 0
1118
+ },
1119
+ "mix_rl_records": 3,
1120
+ "sampling": {
1121
+ "samples": 2088,
1122
+ "secs": 21.05224347114563,
1123
+ "gate_secs": 5.208698272705078,
1124
+ "samples_per_sec": 99.18182842896668
1125
+ },
1126
+ "secs": 21.125123500823975,
1127
+ "rl_secs_used": 1416.2912013530731
1128
+ },
1129
+ {
1130
+ "round": 33,
1131
+ "level": 1,
1132
+ "k": 8,
1133
+ "n_targets": 1500,
1134
+ "sample_acc": 0.8059166666666666,
1135
+ "new_proofs": 67,
1136
+ "targets_solved": 1248,
1137
+ "lstar": 11,
1138
+ "ge": {
1139
+ "7": 1248,
1140
+ "8": 667,
1141
+ "9": 367,
1142
+ "10": 102,
1143
+ "11": 21,
1144
+ "12": 3,
1145
+ "13": 0,
1146
+ "14": 0
1147
+ },
1148
+ "mix_rl_records": 2049,
1149
+ "sampling": {
1150
+ "samples": 12000,
1151
+ "secs": 50.99442172050476,
1152
+ "gate_secs": 29.815982580184937,
1153
+ "samples_per_sec": 235.3198564692189
1154
+ },
1155
+ "secs": 152.1646945476532,
1156
+ "rl_secs_used": 1538.640127658844
1157
+ },
1158
+ {
1159
+ "round": 34,
1160
+ "level": 2,
1161
+ "k": 24,
1162
+ "n_targets": 84,
1163
+ "sample_acc": 0.000496031746031746,
1164
+ "new_proofs": 1,
1165
+ "targets_solved": 1249,
1166
+ "lstar": 11,
1167
+ "ge": {
1168
+ "7": 1249,
1169
+ "8": 668,
1170
+ "9": 368,
1171
+ "10": 103,
1172
+ "11": 22,
1173
+ "12": 4,
1174
+ "13": 0,
1175
+ "14": 0
1176
+ },
1177
+ "mix_rl_records": 1,
1178
+ "sampling": {
1179
+ "samples": 2016,
1180
+ "secs": 10.517355680465698,
1181
+ "gate_secs": 4.413702011108398,
1182
+ "samples_per_sec": 191.68316269310895
1183
+ },
1184
+ "secs": 10.580989360809326,
1185
+ "rl_secs_used": 1544.8072023391724
1186
+ },
1187
+ {
1188
+ "round": 35,
1189
+ "level": 4,
1190
+ "k": 24,
1191
+ "n_targets": 84,
1192
+ "sample_acc": 0.000992063492063492,
1193
+ "new_proofs": 1,
1194
+ "targets_solved": 1250,
1195
+ "lstar": 11,
1196
+ "ge": {
1197
+ "7": 1250,
1198
+ "8": 669,
1199
+ "9": 368,
1200
+ "10": 103,
1201
+ "11": 22,
1202
+ "12": 4,
1203
+ "13": 0,
1204
+ "14": 0
1205
+ },
1206
+ "mix_rl_records": 1,
1207
+ "sampling": {
1208
+ "samples": 2016,
1209
+ "secs": 15.229247808456421,
1210
+ "gate_secs": 5.605544567108154,
1211
+ "samples_per_sec": 132.37685966870706
1212
+ },
1213
+ "secs": 15.294445514678955,
1214
+ "rl_secs_used": 1554.496110200882
1215
+ },
1216
+ {
1217
+ "round": 36,
1218
+ "level": 8,
1219
+ "k": 24,
1220
+ "n_targets": 84,
1221
+ "sample_acc": 0.003968253968253968,
1222
+ "new_proofs": 3,
1223
+ "targets_solved": 1253,
1224
+ "lstar": 11,
1225
+ "ge": {
1226
+ "7": 1253,
1227
+ "8": 671,
1228
+ "9": 369,
1229
+ "10": 103,
1230
+ "11": 22,
1231
+ "12": 4,
1232
+ "13": 0,
1233
+ "14": 0
1234
+ },
1235
+ "mix_rl_records": 3,
1236
+ "sampling": {
1237
+ "samples": 2016,
1238
+ "secs": 28.830424785614014,
1239
+ "gate_secs": 5.125690937042236,
1240
+ "samples_per_sec": 69.92612890691629
1241
+ },
1242
+ "secs": 28.894280195236206,
1243
+ "rl_secs_used": 1578.26469540596
1244
+ }
1245
+ ],
1246
+ "secs": 2183.902185201645,
1247
+ "rl_secs_used": 1680.5860569477081,
1248
+ "gate_secs": 503.29850578308105,
1249
+ "targets": 1500,
1250
+ "stats": {
1251
+ "rounds": 9,
1252
+ "first_loops": 1,
1253
+ "k_first": 8,
1254
+ "retry_loops": [
1255
+ 2,
1256
+ 4,
1257
+ 8
1258
+ ],
1259
+ "k_retry": 24,
1260
+ "retries": [
1261
+ {
1262
+ "round": 1,
1263
+ "loops": 2,
1264
+ "targets": 354,
1265
+ "cracked": 92
1266
+ },
1267
+ {
1268
+ "round": 1,
1269
+ "loops": 4,
1270
+ "targets": 353,
1271
+ "cracked": 101
1272
+ },
1273
+ {
1274
+ "round": 1,
1275
+ "loops": 8,
1276
+ "targets": 353,
1277
+ "cracked": 100
1278
+ },
1279
+ {
1280
+ "round": 2,
1281
+ "loops": 2,
1282
+ "targets": 196,
1283
+ "cracked": 25
1284
+ },
1285
+ {
1286
+ "round": 2,
1287
+ "loops": 4,
1288
+ "targets": 196,
1289
+ "cracked": 29
1290
+ },
1291
+ {
1292
+ "round": 2,
1293
+ "loops": 8,
1294
+ "targets": 195,
1295
+ "cracked": 29
1296
+ },
1297
+ {
1298
+ "round": 3,
1299
+ "loops": 2,
1300
+ "targets": 151,
1301
+ "cracked": 18
1302
+ },
1303
+ {
1304
+ "round": 3,
1305
+ "loops": 4,
1306
+ "targets": 151,
1307
+ "cracked": 16
1308
+ },
1309
+ {
1310
+ "round": 3,
1311
+ "loops": 8,
1312
+ "targets": 150,
1313
+ "cracked": 14
1314
+ },
1315
+ {
1316
+ "round": 4,
1317
+ "loops": 2,
1318
+ "targets": 129,
1319
+ "cracked": 8
1320
+ },
1321
+ {
1322
+ "round": 4,
1323
+ "loops": 4,
1324
+ "targets": 128,
1325
+ "cracked": 13
1326
+ },
1327
+ {
1328
+ "round": 4,
1329
+ "loops": 8,
1330
+ "targets": 128,
1331
+ "cracked": 11
1332
+ },
1333
+ {
1334
+ "round": 5,
1335
+ "loops": 2,
1336
+ "targets": 115,
1337
+ "cracked": 8
1338
+ },
1339
+ {
1340
+ "round": 5,
1341
+ "loops": 4,
1342
+ "targets": 115,
1343
+ "cracked": 9
1344
+ },
1345
+ {
1346
+ "round": 5,
1347
+ "loops": 8,
1348
+ "targets": 114,
1349
+ "cracked": 7
1350
+ },
1351
+ {
1352
+ "round": 6,
1353
+ "loops": 2,
1354
+ "targets": 104,
1355
+ "cracked": 2
1356
+ },
1357
+ {
1358
+ "round": 6,
1359
+ "loops": 4,
1360
+ "targets": 104,
1361
+ "cracked": 4
1362
+ },
1363
+ {
1364
+ "round": 6,
1365
+ "loops": 8,
1366
+ "targets": 104,
1367
+ "cracked": 6
1368
+ },
1369
+ {
1370
+ "round": 7,
1371
+ "loops": 2,
1372
+ "targets": 97,
1373
+ "cracked": 2
1374
+ },
1375
+ {
1376
+ "round": 7,
1377
+ "loops": 4,
1378
+ "targets": 96,
1379
+ "cracked": 7
1380
+ },
1381
+ {
1382
+ "round": 7,
1383
+ "loops": 8,
1384
+ "targets": 96,
1385
+ "cracked": 2
1386
+ },
1387
+ {
1388
+ "round": 8,
1389
+ "loops": 2,
1390
+ "targets": 88,
1391
+ "cracked": 5
1392
+ },
1393
+ {
1394
+ "round": 8,
1395
+ "loops": 4,
1396
+ "targets": 88,
1397
+ "cracked": 1
1398
+ },
1399
+ {
1400
+ "round": 8,
1401
+ "loops": 8,
1402
+ "targets": 87,
1403
+ "cracked": 3
1404
+ },
1405
+ {
1406
+ "round": 9,
1407
+ "loops": 2,
1408
+ "targets": 84,
1409
+ "cracked": 1
1410
+ },
1411
+ {
1412
+ "round": 9,
1413
+ "loops": 4,
1414
+ "targets": 84,
1415
+ "cracked": 1
1416
+ },
1417
+ {
1418
+ "round": 9,
1419
+ "loops": 8,
1420
+ "targets": 84,
1421
+ "cracked": 3
1422
+ }
1423
+ ]
1424
+ }
1425
+ },
1426
+ "eval": {
1427
+ "level": 8,
1428
+ "attempts_per_theorem": 64,
1429
+ "solved": 699,
1430
+ "n": 1108,
1431
+ "solved_ge7": 699,
1432
+ "lstar": 12,
1433
+ "ge": {
1434
+ "7": 699,
1435
+ "8": 585,
1436
+ "9": 464,
1437
+ "10": 113,
1438
+ "11": 27,
1439
+ "12": 6,
1440
+ "13": 1,
1441
+ "14": 0
1442
+ },
1443
+ "by_bin": {
1444
+ "7": {
1445
+ "solved": 114,
1446
+ "n": 150,
1447
+ "rate": 0.76,
1448
+ "ci": [
1449
+ 0.6857071477257108,
1450
+ 0.8213078599185155
1451
+ ]
1452
+ },
1453
+ "8": {
1454
+ "solved": 121,
1455
+ "n": 152,
1456
+ "rate": 0.7960526315789473,
1457
+ "ci": [
1458
+ 0.7250729822703502,
1459
+ 0.8524364888849766
1460
+ ]
1461
+ },
1462
+ "9": {
1463
+ "solved": 351,
1464
+ "n": 477,
1465
+ "rate": 0.7358490566037735,
1466
+ "ci": [
1467
+ 0.6945125652002945,
1468
+ 0.7734169982983711
1469
+ ]
1470
+ },
1471
+ "10": {
1472
+ "solved": 86,
1473
+ "n": 219,
1474
+ "rate": 0.3926940639269406,
1475
+ "ci": [
1476
+ 0.33039793393931083,
1477
+ 0.45868992039309386
1478
+ ]
1479
+ },
1480
+ "11": {
1481
+ "solved": 21,
1482
+ "n": 49,
1483
+ "rate": 0.42857142857142855,
1484
+ "ci": [
1485
+ 0.3002310889895705,
1486
+ 0.5672975248298444
1487
+ ]
1488
+ },
1489
+ "12": {
1490
+ "solved": 5,
1491
+ "n": 54,
1492
+ "rate": 0.09259259259259259,
1493
+ "ci": [
1494
+ 0.040200542070567336,
1495
+ 0.1991012753065453
1496
+ ]
1497
+ },
1498
+ "13": {
1499
+ "solved": 1,
1500
+ "n": 5,
1501
+ "rate": 0.2,
1502
+ "ci": [
1503
+ 0.03622316096978745,
1504
+ 0.6244717358814613
1505
+ ]
1506
+ },
1507
+ "14": {
1508
+ "solved": 0,
1509
+ "n": 2,
1510
+ "rate": 0.0,
1511
+ "ci": [
1512
+ 0.0,
1513
+ 0.6576280471103807
1514
+ ]
1515
+ }
1516
+ },
1517
+ "sample_acc": 0.4871248871841155,
1518
+ "max_pruned": 14,
1519
+ "sampling": {
1520
+ "samples": 70912,
1521
+ "secs": 637.4489448070526,
1522
+ "gate_secs": 105.9283676147461,
1523
+ "samples_per_sec": 111.24341890857491
1524
+ },
1525
+ "heldout_greedy": 0.9925,
1526
+ "diag": {
1527
+ "level": 2,
1528
+ "attempts_per_theorem": 64,
1529
+ "solved": 710,
1530
+ "n": 1108,
1531
+ "solved_ge7": 710,
1532
+ "lstar": 12,
1533
+ "ge": {
1534
+ "7": 710,
1535
+ "8": 596,
1536
+ "9": 472,
1537
+ "10": 111,
1538
+ "11": 27,
1539
+ "12": 7,
1540
+ "13": 2,
1541
+ "14": 0
1542
+ },
1543
+ "by_bin": {
1544
+ "7": {
1545
+ "solved": 114,
1546
+ "n": 150,
1547
+ "rate": 0.76,
1548
+ "ci": [
1549
+ 0.6857071477257108,
1550
+ 0.8213078599185155
1551
+ ]
1552
+ },
1553
+ "8": {
1554
+ "solved": 124,
1555
+ "n": 152,
1556
+ "rate": 0.8157894736842105,
1557
+ "ci": [
1558
+ 0.7466452410364233,
1559
+ 0.8693648615292588
1560
+ ]
1561
+ },
1562
+ "9": {
1563
+ "solved": 361,
1564
+ "n": 477,
1565
+ "rate": 0.7568134171907757,
1566
+ "ci": [
1567
+ 0.7163608691671525,
1568
+ 0.7931624333091724
1569
+ ]
1570
+ },
1571
+ "10": {
1572
+ "solved": 84,
1573
+ "n": 219,
1574
+ "rate": 0.3835616438356164,
1575
+ "ci": [
1576
+ 0.32169335630218043,
1577
+ 0.44944452818617364
1578
+ ]
1579
+ },
1580
+ "11": {
1581
+ "solved": 20,
1582
+ "n": 49,
1583
+ "rate": 0.40816326530612246,
1584
+ "ci": [
1585
+ 0.2821503460597105,
1586
+ 0.5475293002795374
1587
+ ]
1588
+ },
1589
+ "12": {
1590
+ "solved": 5,
1591
+ "n": 54,
1592
+ "rate": 0.09259259259259259,
1593
+ "ci": [
1594
+ 0.040200542070567336,
1595
+ 0.1991012753065453
1596
+ ]
1597
+ },
1598
+ "13": {
1599
+ "solved": 2,
1600
+ "n": 5,
1601
+ "rate": 0.4,
1602
+ "ci": [
1603
+ 0.1176182311592533,
1604
+ 0.769280067791163
1605
+ ]
1606
+ },
1607
+ "14": {
1608
+ "solved": 0,
1609
+ "n": 2,
1610
+ "rate": 0.0,
1611
+ "ci": [
1612
+ 0.0,
1613
+ 0.6576280471103807
1614
+ ]
1615
+ }
1616
+ },
1617
+ "sample_acc": 0.4862223601083033,
1618
+ "max_pruned": 13,
1619
+ "sampling": {
1620
+ "samples": 70912,
1621
+ "secs": 285.9174790382385,
1622
+ "gate_secs": 105.39015507698059,
1623
+ "samples_per_sec": 248.01561708830067
1624
+ }
1625
+ }
1626
+ }
1627
+ }