Upload folder using huggingface_hub

.gitattributes

@@ -70,3 +70,75 @@ experiments/minimo_baseline_0pt/run_2026-06-02_00-35-54_0-150/candidates_results
 experiments/minimo_baseline_0pt/run_2026-06-02_00-35-59_150-300/candidates_results.jsonl filter=lfs diff=lfs merge=lfs -text
 experiments/minimo_baseline_0pt/run_2026-06-02_00-36-04_300-450/candidates_results.jsonl filter=lfs diff=lfs merge=lfs -text
 experiments/minimo_baseline_0pt/run_2026-06-02_00-36-08_450-all/candidates_results.jsonl filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/__pycache__/proofsearch.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57/wandb/run-20260313_011701-5a8bpycd/run-5a8bpycd.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_13-38-07/wandb/run-20260313_133811-xl6rhn8y/run-xl6rhn8y.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_13-39-00/wandb/run-20260313_133904-ky18ur1q/run-ky18ur1q.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_13-39-18/wandb/run-20260313_133921-yygzn25u/run-yygzn25u.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_95_4000_2026-04-10_18-49-47/wandb/run-20260410_184951-bmh84soq/run-bmh84soq.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_95_4000_2026-04-19_01-03-20/wandb/run-20260419_010323-7etlj96m/run-7etlj96m.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_95_4000_NEW_2026-05-08_08-43-05/wandb/run-20260508_084309-f2sii2hg/run-f2sii2hg.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/examples_0.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/examples_1.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/examples_2.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/examples_3.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/examples_4.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/outcomes_1.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/outcomes_2.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/outcomes_3.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/outcomes_4.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/results_0.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/results_1.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/results_2.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/results_3.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/results_4.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/wandb/run-20260312_234121-64ia8ii4/run-64ia8ii4.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/minimo_baseline_0pt/run_2026-06-02_00-35-54_0-150/candidates_results.jsonl filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/minimo_baseline_0pt/run_2026-06-02_00-35-59_150-300/candidates_results.jsonl filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/minimo_baseline_0pt/run_2026-06-02_00-36-04_300-450/candidates_results.jsonl filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/minimo_baseline_0pt/run_2026-06-02_00-36-08_450-all/candidates_results.jsonl filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_0pt/experiments/perturb_all_ops_B200_L0_0pt/merged_L0_0pt/training/filtered_median-easy_seed42/2026-05-10_07-33-41/updates_0_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-10_20-47-33/wandb/run-20260510_204736-f582i77k/run-f582i77k.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_0pt/experiments/perturb_all_ops_B200_L0_0pt/merged_L0_0pt/training/filtered_median-easy_seed43/2026-05-10_07-33-41/updates_0_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-10_20-47-33/wandb/run-20260510_204736-dn54ixfh/run-dn54ixfh.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_0pt/experiments/perturb_all_ops_B200_L0_0pt/merged_L0_0pt/training/filtered_median-easy_seed44/2026-05-10_07-35-16/updates_0_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-10_20-47-33/wandb/run-20260510_204736-zdgc85m6/run-zdgc85m6.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_0pt/experiments/perturb_all_ops_B200_L0_0pt/merged_L0_0pt/training/filtered_median-easy_seed45/2026-05-10_07-35-16/updates_0_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-10_20-47-33/wandb/run-20260510_204736-hg57jve5/run-hg57jve5.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_0pt/experiments/perturb_all_ops_B200_L0_0pt/merged_L0_0pt/training/filtered_median-easy_seed46/2026-05-10_07-35-16/updates_0_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-10_21-49-17/wandb/run-20260510_214920-drs7y6m3/run-drs7y6m3.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_median-easy_seed42/2026-05-08_06-33-43/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-08_07-54-37/wandb/run-20260508_075456-yprflj8i/run-yprflj8i.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_median-easy_seed43/2026-05-08_06-33-42/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-08_07-54-37/wandb/run-20260508_075456-gdz9916t/run-gdz9916t.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_median-easy_seed44/2026-05-08_06-37-42/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-08_07-54-37/wandb/run-20260508_075456-hegyn5g7/run-hegyn5g7.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_median-easy_seed45/2026-05-08_06-37-43/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-08_09-38-18/wandb/run-20260508_093822-q7sulp6t/run-q7sulp6t.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_median-easy_seed46/2026-05-08_06-37-42/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-08_09-38-18/wandb/run-20260508_093822-wkf2v9pe/run-wkf2v9pe.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_median-hard_subsampled_seed42/2026-05-11_23-29-58/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-12_00-05-55/wandb/run-20260512_000558-w0x0yc1m/run-w0x0yc1m.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_median-hard_subsampled_seed43/2026-05-11_23-29-58/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-12_00-05-55/wandb/run-20260512_000558-95yd0z4x/run-95yd0z4x.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_median-hard_subsampled_seed44/2026-05-11_23-29-59/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-12_00-05-55/wandb/run-20260512_000558-cvkq859r/run-cvkq859r.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_median-hard_subsampled_seed45/2026-05-11_23-32-22/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-12_00-05-55/wandb/run-20260512_000558-4jwdb5c0/run-4jwdb5c0.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_median-hard_subsampled_seed46/2026-05-11_23-32-22/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-12_01-19-45/wandb/run-20260512_011948-3vx4vcwr/run-3vx4vcwr.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_none_seed42/2026-05-08_06-17-18/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-08_07-02-13/wandb/run-20260508_070216-1iuye4nh/run-1iuye4nh.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_none_seed43/2026-05-08_06-17-18/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-08_07-02-13/wandb/run-20260508_070216-mzcfcucm/run-mzcfcucm.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_none_seed44/2026-05-08_06-17-18/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-08_07-02-13/wandb/run-20260508_070216-6sm2t9h2/run-6sm2t9h2.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_none_seed45/2026-05-08_06-23-24/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-08_08-20-09/wandb/run-20260508_082013-68e0jx1n/run-68e0jx1n.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_all_ops/merged_L0_1pt/experiments/perturb_all_ops/merged_L0_1pt/training/filtered_none_seed46/2026-05-08_06-23-24/updates_1_epoch_1ep_bs64/eval_extrinsic-95_4000/2026-05-08_08-20-09/wandb/run-20260508_082012-cwvwipy2/run-cwvwipy2.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_multi_hop/outputs/run_2026-05-17_21-09-46_4800-6000/candidates_results.jsonl filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_multi_hop/outputs/run_2026-05-17_21-10-07_6000-7200/candidates_results.jsonl filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_multi_hop/outputs/run_2026-05-17_21-10-16_7200-8600/candidates_results.jsonl filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/experiments/perturb_multi_hop/outputs/run_2026-05-17_21-10-21_8600-all/candidates_results.jsonl filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/eval_natmul_2026-01-29_20-11-24/wandb/run-20260129_201127-obr7hmhe/run-obr7hmhe.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/eval_natmul_2026-01-29_20-11-35/wandb/run-20260129_201138-ogrdtnt9/run-ogrdtnt9.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/eval_natmul_2026-01-29_20-11-43/wandb/run-20260129_201146-j3yhxjlx/run-j3yhxjlx.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/eval_natmul_2026-01-29_20-11-50/wandb/run-20260129_201153-tcy502sz/run-tcy502sz.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/eval_natmul_g75_2026-01-29_20-14-58/wandb/run-20260129_201501-1ocgfm7h/run-1ocgfm7h.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/eval_natmul_g75_2026-01-29_20-16-03/wandb/run-20260129_201606-e6dc0cxl/run-e6dc0cxl.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/eval_natmul_g75_2026-01-29_20-16-18/wandb/run-20260129_201621-qfy84s4t/run-qfy84s4t.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/eval_natmul_g75_2026-01-29_20-16-23/wandb/run-20260129_201626-p5so9yja/run-p5so9yja.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/eval_natmul_g75_2026-01-29_20-16-29/wandb/run-20260129_201632-bzlpccu2/run-bzlpccu2.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/examples_0.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/examples_1.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/examples_2.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/outcomes_0.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/outcomes_1.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/outcomes_2.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/results_0.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/results_1.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/results_2.json filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/bootstrap_nat_mul_800_parallel/2026-01-28_22-26-06/wandb/run-20260128_222606-uovbebo0/run-uovbebo0.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/simple_experiment_novelty/2026-02-22_17-37-04/wandb/run-20260222_173705-y2q6cuoh/run-y2q6cuoh.wandb filter=lfs diff=lfs merge=lfs -text
+experiments/learnability/outputs/simple_experiment_novelty/2026-02-22_20-09-19/wandb/run-20260222_200920-1uaognvr/run-1uaognvr.wandb filter=lfs diff=lfs merge=lfs -text

experiments/learnability/__pycache__/proofsearch.cpython-311.pyc

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

experiments/learnability/ablate_updates.py

@@ -0,0 +1,395 @@
+#!/usr/bin/env python3
+
+"""
+Ablation script: loads a checkpoint and the next iteration's training data,
+then trains copies of the agent with different hyperparameter configs
+(number of updates, learning rate, batch size, etc.) and evaluates each.
+
+Usage:
+    python ablate_updates.py
+
+Edit the ABLATION_CONFIGS list below to define the hyperparameter grid.
+"""
+
+import os
+import io
+import copy
+import json
+import random
+import datetime
+import argparse
+
+import torch
+import wandb
+from tqdm import tqdm
+
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+
+# Checkpoint to start from (all ablations fork from this).
+CHECKPOINT_PATH = "/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para_8000updates/2026-03-10_21-21-05/0.pt"
+
+# Training examples generated in the *same* iteration (i.e. examples_0.json).
+EXAMPLES_PATH = "/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para_8000updates/2026-03-10_21-21-05/examples_0.json"
+
+# Where to write ablation outputs (default: alongside the checkpoint).
+OUTPUT_ROOT = None  # If None, writes to <checkpoint_dir>/ablations/
+
+# GPU device index (set to None for CPU).
+CUDA_DEVICE = 0
+
+# wandb project (set to None to disable).
+WANDB_PROJECT = "peano-ablation"
+
+# Each dict specifies overrides.  Keys:
+#   mode          – "sample" (original: sample with replacement, char-budget batches)
+#                   "epoch"  (deduplicate, shuffle, epoch-based, fixed example-count batches)
+#   n_steps       – gradient steps (only for mode="sample"; default: 8000)
+#   n_epochs      – number of epochs (only for mode="epoch"; default: 1)
+#   batch_size    – for mode="sample": character-token budget per batch (default: 10000)
+#                   for mode="epoch":  number of examples per batch (default: 64)
+#   lr            – learning rate for AdamW  (default: 1e-4)
+#   tag           – human-readable name used in output dir & wandb run name
+ABLATION_CONFIGS = [
+    # --- Mode A: original sampling (with replacement, char-budget batches) ---
+    # Dir names auto-generated: updates_{ckpt}_{mode}_{params}
+    #{"mode": "sample", "n_steps": 2000, "batch_size": 10000},
+    #{"mode": "sample", "n_steps": 4000, "batch_size": 10000},
+
+    # --- Mode B: epoch training (deduplicate, shuffle, re-shuffle each epoch) ---
+    #{"mode": "epoch", "batch_size": 32, "n_epochs": 4, "save_every": 1},  # also save intermediate checkpoints at epoch 2
+    {"mode": "epoch", "batch_size": 64, "n_epochs": 2, "save_every": 1},  # save per-epoch ckpts: epoch_1.pt (mid) + epoch_2.pt/1.pt (final)
+    #{"mode": "epoch", "batch_size": 128, "n_epochs": 4, "save_every": 1},  # also save intermediate checkpoints at epoch 2
+
+    # --- optional: epoch with different lr ---
+    # {"mode": "epoch", "batch_size": 64, "lr": 5e-5},
+    # {"mode": "epoch", "batch_size": 64, "lr": 3e-4},
+]
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def now() -> str:
+    return "[" + datetime.datetime.now().isoformat() + "]"
+
+
+def load_examples(path: str) -> list[str]:
+    """Load training examples (list of strings) from a JSON file."""
+    with open(path) as f:
+        examples = json.load(f)
+    # examples can be plain strings or dicts with a 'str' key
+    out = []
+    for e in examples:
+        if isinstance(e, str):
+            out.append(e)
+        elif isinstance(e, dict) and "str" in e:
+            out.append(e["str"])
+        else:
+            raise ValueError(f"Unexpected example format: {type(e)}")
+    return out
+
+
+def ckpt_num(path: str) -> str:
+    """Extract checkpoint number from path, e.g. '/foo/0.pt' -> '0'."""
+    return os.path.splitext(os.path.basename(path))[0]
+
+
+def make_run_name(cfg: dict, checkpoint_path: str) -> str:
+    """Build directory name: updates_{ckpt_num}_{mode}_{params}."""
+    cn = ckpt_num(checkpoint_path)
+    mode = cfg.get("mode", "sample")
+    parts = [f"updates_{cn}", mode]
+    if mode == "sample":
+        parts.append(f"{cfg.get('n_steps', 8000)}steps")
+        bs = cfg.get('batch_size') or 10000
+        parts.append(f"bs{bs}")
+    elif mode == "epoch":
+        parts.append(f"{cfg.get('n_epochs', 1)}ep")
+        bs = cfg.get('batch_size') or 64
+        parts.append(f"bs{bs}")
+    if cfg.get("lr") is not None:
+        parts.append(f"lr{cfg['lr']}")
+    return "_".join(parts)
+
+
+def deep_copy_agent(agent):
+    """Deep-copy an agent via serialize/deserialize (handles CUDA tensors)."""
+    buf = io.BytesIO()
+    torch.save(agent, buf)
+    buf.seek(0)
+    return torch.load(buf, weights_only=False)
+
+
+def set_lr(optimizer, lr: float):
+    """Override learning rate on all param groups."""
+    for pg in optimizer.param_groups:
+        pg["lr"] = lr
+
+
+def train_agent_sample(agent, examples: list[str], n_steps: int,
+                       batch_size: int | None = None,
+                       lr: float | None = None,
+                       verbose: bool = True):
+    """
+    Original training mode: sample batches with replacement.
+
+      - n_steps:    number of gradient steps
+      - batch_size: total character-token budget per batch (default from agent)
+      - lr:         learning rate override
+    """
+    lm_policy = agent._policy          # LMPolicy
+    lm = lm_policy._lm                 # TransformerLMPolicy
+
+    bs = batch_size if batch_size is not None else lm_policy._batch_size
+
+    if lr is not None:
+        set_lr(lm._optimizer, lr)
+
+    lm.fit(examples, bs, n_steps, verbose=verbose)
+    lm.eval()
+    return n_steps
+
+
+def train_agent_epoch(agent, examples: list[str],
+                      batch_size: int = 64,
+                      n_epochs: int = 1,
+                      lr: float | None = None,
+                      save_every: int | None = None,
+                      run_dir: str | None = None,
+                      verbose: bool = True):
+    """
+    Epoch-based training: deduplicate, then train for n_epochs epochs
+    with re-shuffling each epoch and fixed example-count batches.
+
+      - batch_size:  number of examples per batch
+      - n_epochs:    number of passes over the dataset
+      - lr:          learning rate override
+      - save_every:  save a checkpoint every N epochs (None = only final)
+      - run_dir:     directory to save intermediate checkpoints into
+    """
+    lm = agent._policy._lm             # TransformerLMPolicy
+
+    if lr is not None:
+        set_lr(lm._optimizer, lr)
+
+    # Deduplicate
+    unique_examples = list(dict.fromkeys(examples))  # preserves first occurrence order
+    print(f"  Dedup: {len(examples)} -> {len(unique_examples)} unique examples")
+
+    lm._lm.train()
+    batches_per_epoch = (len(unique_examples) + batch_size - 1) // batch_size
+    total_steps = 0
+    saved_epochs = set()
+
+    for epoch in range(n_epochs):
+        # Re-shuffle each epoch
+        random.shuffle(unique_examples)
+
+        rng = range(batches_per_epoch)
+        if verbose:
+            rng = tqdm(rng, desc=f"Epoch {epoch+1}/{n_epochs}")
+
+        for i in rng:
+            batch = unique_examples[i * batch_size : (i + 1) * batch_size]
+            lm._optimizer.zero_grad()
+            loss = lm.get_loss(batch)
+            loss.backward()
+            wandb.log({"train_loss": loss, "epoch": epoch + 1})
+            lm._optimizer.step()
+            total_steps += 1
+
+        # Intermediate checkpoint
+        if save_every and run_dir and (epoch + 1) % save_every == 0:
+            lm._lm.eval()
+            ckpt_path = os.path.join(run_dir, f"epoch_{epoch+1}.pt")
+            torch.save(agent, ckpt_path)
+            print(f"  {now()} Saved checkpoint at epoch {epoch+1} -> {ckpt_path}")
+            saved_epochs.add(epoch + 1)
+            lm._lm.train()
+
+    lm._lm.eval()
+
+    # Save final if not already saved by save_every
+    if run_dir and n_epochs not in saved_epochs:
+        final_path = os.path.join(run_dir, f"epoch_{n_epochs}.pt")
+        torch.save(agent, final_path)
+        print(f"  {now()} Saved final checkpoint -> {final_path}")
+
+    print(f"  Done: {n_epochs} epoch(s), {total_steps} total steps, "
+          f"{len(unique_examples)} unique examples (batch_size={batch_size})")
+    return total_steps
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def run_ablation(cfg: dict, base_agent, examples: list[str], output_root: str,
+                 checkpoint_path: str, examples_path: str = None):
+    tag = cfg.get("tag") or make_run_name(cfg, checkpoint_path)
+    mode = cfg.get("mode", "sample")
+    n_steps = cfg.get("n_steps", 8000)
+    batch_size = cfg.get("batch_size", None)
+    lr = cfg.get("lr", None)
+
+    run_dir = os.path.join(output_root, tag)
+    os.makedirs(run_dir, exist_ok=True)
+
+    # Save config (include checkpoint + examples paths for reproducibility)
+    saved_cfg = {**cfg, "checkpoint": checkpoint_path, "examples": examples_path}
+    with open(os.path.join(run_dir, "ablation_config.json"), "w") as f:
+        json.dump(saved_cfg, f, indent=2)
+
+    # Deep-copy agent so each ablation starts from the same checkpoint
+    print(f"\n{'='*60}")
+    print(f"{now()} Starting ablation: {tag}  (mode={mode})")
+    print(f"  n_steps={n_steps}, batch_size={batch_size}, lr={lr}")
+    print(f"  output -> {run_dir}")
+    print(f"{'='*60}")
+
+    agent = deep_copy_agent(base_agent)
+
+    # Init wandb run for this ablation
+    wandb_config = {
+        "checkpoint": CHECKPOINT_PATH,
+        "examples": EXAMPLES_PATH,
+        "mode": mode,
+        "batch_size": batch_size or agent._policy._batch_size,
+        "lr": lr or agent._policy._lm._optimizer.param_groups[0]["lr"],
+        "tag": tag,
+    }
+    if mode == "sample":
+        wandb_config["n_steps"] = n_steps
+    elif mode == "epoch":
+        wandb_config["n_epochs"] = cfg.get("n_epochs", 1)
+    if WANDB_PROJECT:
+        wandb.init(
+            project=WANDB_PROJECT,
+            name=tag,
+            config=wandb_config,
+            reinit=True,
+        )
+
+    if mode == "sample":
+        total_steps = train_agent_sample(agent, examples, n_steps=n_steps,
+                                         batch_size=batch_size, lr=lr)
+    elif mode == "epoch":
+        total_steps = train_agent_epoch(agent, examples,
+                                        batch_size=batch_size or 64,
+                                        n_epochs=cfg.get("n_epochs", 1), lr=lr,
+                                        save_every=cfg.get("save_every"),
+                                        run_dir=run_dir)
+    else:
+        raise ValueError(f"Unknown training mode: {mode}")
+
+    # Save the trained agent as 1.pt (next iteration checkpoint)
+    out_path = os.path.join(run_dir, "1.pt")
+    torch.save(agent, out_path)
+    print(f"{now()} Saved trained agent to {out_path}")
+
+    # Save training stats
+    stats = {"total_gradient_steps": total_steps}
+    with open(os.path.join(run_dir, "train_stats.json"), "w") as f:
+        json.dump(stats, f, indent=2)
+
+    if WANDB_PROJECT:
+        wandb.finish()
+
+    return out_path, total_steps
+
+
+def main():
+    global WANDB_PROJECT
+    parser = argparse.ArgumentParser(description="Ablation over training hyperparameters")
+    parser.add_argument("--checkpoint", default=CHECKPOINT_PATH,
+                        help="Path to the base .pt checkpoint")
+    parser.add_argument("--examples", default=EXAMPLES_PATH,
+                        help="Path to examples JSON file")
+    parser.add_argument("--output", default=None,
+                        help="Root output directory (default: <checkpoint_dir>/ablations/)")
+    parser.add_argument("--device", type=int, default=CUDA_DEVICE,
+                        help="CUDA device index (use -1 for CPU)")
+    parser.add_argument("--seed", type=int, default=None,
+                        help="Random seed for reproducible shuffling/training (default: unseeded).")
+    parser.add_argument("--wandb-project", default=WANDB_PROJECT,
+                        help="W&B project name (empty string to disable)")
+    parser.add_argument("--configs", nargs="+", default=None,
+                        help="Run only ablations whose tags match these (default: all)")
+    args = parser.parse_args()
+
+    # Set device
+    if args.device >= 0 and torch.cuda.is_available():
+        os.environ["CUDA_VISIBLE_DEVICES"] = str(args.device)
+
+    # Seed for reproducible shuffles / training stochasticity (dropout, etc.)
+    if args.seed is not None:
+        random.seed(args.seed)
+        torch.manual_seed(args.seed)
+        torch.cuda.manual_seed_all(args.seed)
+        print(f"{now()} Seeded RNGs with seed={args.seed}")
+
+    WANDB_PROJECT = args.wandb_project or None
+
+    # If wandb is disabled, make wandb.log a no-op (policy.py's fit() calls it directly)
+    if not WANDB_PROJECT:
+        wandb.log = lambda *args, **kwargs: None
+
+    # Default output dir: <checkpoint_dir>/ablations/<timestamp>/
+    ckpt_dir = os.path.dirname(os.path.abspath(args.checkpoint))
+    timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    output_root = os.path.join(args.output or os.path.join(ckpt_dir, "ablations"), timestamp)
+    os.makedirs(output_root, exist_ok=True)
+
+    print(f"{now()} Loading checkpoint from {args.checkpoint}")
+    base_agent = torch.load(args.checkpoint, weights_only=False)
+
+    print(f"{now()} Loading examples from {args.examples}")
+    examples = load_examples(args.examples)
+    print(f"  {len(examples)} training examples loaded.")
+
+    configs = ABLATION_CONFIGS
+    if args.configs:
+        configs = [c for c in configs if
+                   (c.get("tag") or make_run_name(c, args.checkpoint)) in args.configs]
+        print(f"  Running subset: {[c.get('tag') or make_run_name(c, args.checkpoint) for c in configs]}")
+
+    results = {}
+
+    for cfg in configs:
+        agent_path, total_steps = run_ablation(cfg, base_agent, examples, output_root,
+                                                args.checkpoint,
+                                                examples_path=os.path.abspath(args.examples))
+        run_name = cfg.get("tag") or make_run_name(cfg, args.checkpoint)
+        results[run_name] = {"path": agent_path, "total_gradient_steps": total_steps}
+
+    # Summary
+    print(f"\n{'='*60}")
+    print(f"{now()} All ablations complete.")
+    print(f"{'='*60}")
+    summary_path = os.path.join(output_root, "summary.json")
+    with open(summary_path, "w") as f:
+        json.dump({
+            "checkpoint": os.path.abspath(args.checkpoint),
+            "examples": os.path.abspath(args.examples),
+            "configs": ABLATION_CONFIGS,
+            "results": results,
+        }, f, indent=2)
+    print(f"Summary saved to {summary_path}")
+
+    for tag, path in results.items():
+        print(f"  {tag}: {path}")
+
+
+if __name__ == "__main__":
+    main()
+
+
+#command to run this script:    
+
+# python ablate_updates.py --checkpoint /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_parallel/2026-01-19_12-06-16/0.pt --examples /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_parallel/2026-01-19_12-06-16/examples_0.json --wandb-project peano-ablation
+
+# python ablate_updates.py --checkpoint /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para_8000updates/2026-03-10_21-21-05/0.pt --examples /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para_8000updates/2026-03-10_21-21-05/examples_0.json --wandb-project peano-ablation
+
+# python ablate_updates.py --checkpoint /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_itlearn_fresh_parallel/2026-01-25_12-18-11/0.pt --examples /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_itlearn_fresh_parallel/2026-01-25_12-18-11/examples_5.json --wandb-project peano-ablation

experiments/learnability/action.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+# Wrapper for PyProofAction that allows for sequences of actions to be chained together.
+
+import functools
+
+import peano
+
+
+class ProofAction:
+    def __init__(self, peano_actions: list):
+        self._actions = peano_actions
+
+    def __str__(self) -> str:
+        return ' => '.join(map(str, self._actions))
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __eq__(self, rhs) -> bool:
+        return isinstance(rhs, ProofAction) and self._actions == rhs._actions
+
+    def is_intro(self) -> bool:
+        return len(self._actions) == 1 and self._actions[0].is_intro()
+
+    def is_construct(self):
+        return len(self._actions) <= 2 and self._actions[0].is_construct()
+
+    def is_apply(self):
+        return len(self._actions) <= 2 and self._actions[0].is_apply()
+
+    def execute(self, state: peano.PyProofState) -> peano.PyProofState:
+        return functools.reduce(lambda s, a: s[0].execute_action(a),
+                                self._actions, [state])
+
+    def is_eager(self):
+        return self.is_intro() or len(self._actions) == 2
+
+    def arrow_name(self):
+        assert not self.is_intro()
+        return str(self._actions[0]).split()[1]
+
+    def construction_dtype(self):
+        c_a = (self._actions[1]
+               if self._actions[0].is_construct()
+               else self._actions[0])
+        dtype, _value = c_a.selected_construction()
+        return str(dtype)
+

experiments/learnability/bestfirst_search.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""Value-free best-first proof search.
+
+A minimal, value-net-free searcher that uses ONLY the learned policy
+(P(Y | state, action)) to rank a frontier of open proof states. No MCTS,
+no UCT, no backpropagation, no value function. It is the deterministic
+sibling of `rollout_search.py`: instead of sampling independent rollouts,
+it keeps one global priority queue of partial proofs and always expands the
+most promising one.
+
+Design (agreed in design discussion):
+  * An *item* is one full proof state = a list of open subgoals (leftmost
+    first) plus a cumulative priority g = sum_i log pi(a_i), where
+    pi(a|s) = score_a / sum score is the policy distribution over the focused
+    subgoal's legal actions. All subgoals spawned by one action share one item
+    priority; conjunctions (AND) are handled automatically because an item is
+    solved exactly when its subgoal list is empty.
+  * To score actions we wrap the *focused* (leftmost) subgoal as a single-goal
+    `HolophrasmNode([ps])` -- identical to the rollout searcher -- so both the
+    state string and action strings stay in-distribution.
+  * One pop = one budget unit. We pop the max-g item, score its focused
+    subgoal's legal actions, and push one child per action (subgoals =
+    spawned + rest[1:]). Trivially dead items (no legal actions) are dropped;
+    there is no backtracking, we just pop the next best item.
+
+Budget knob: `--max-pops` (default 4000, mirrors MCTS max_mcts_nodes).
+`--timeout` is a per-problem wall-clock cap shared with the search. `evals`
+is reported as a cost meter (sum of |legal| scored across pops).
+"""
+
+import argparse
+import heapq
+import itertools
+import json
+import multiprocessing
+import os
+import time
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from dataclasses import dataclass, asdict, field
+
+import numpy as np
+import torch
+
+import peano
+import problems
+from proofsearch import HolophrasmNode
+from rollout_search import load_policy_lm
+
+
+# ----------------------------------------------------------------------------
+# A single best-first search for one problem
+# ----------------------------------------------------------------------------
+
+@dataclass
+class BestFirstTrace:
+    solved: bool
+    outcome: str                    # "solved" | "exhausted" | "budget" | "timeout"
+    pops_used: int                  # number of items expanded (budget meter)
+    evals_used: int                 # total policy action-evaluations (cost meter)
+    max_open: int                   # max frontier size
+    solution_actions: list = field(default_factory=list)
+
+
+def best_first(lm,
+               initial_state,
+               max_pops: int,
+               max_actions: int = 0,
+               deadline: float | None = None) -> BestFirstTrace:
+    """Run best-first search from `initial_state` (a peano.PyProofState).
+
+    Items are (g, tiebreak, subgoals, actions_so_far). The heap is a min-heap
+    on -g so the largest cumulative log-prob is popped first. `max_actions`
+    (> 0) drops any state whose legal-action set blows up past the cap.
+    """
+    counter = itertools.count()
+    # frontier: min-heap of (-g, tiebreak, subgoals_tuple, actions)
+    frontier = [(-0.0, next(counter), (initial_state,), [])]
+    pops = 0
+    evals = 0
+    max_open = 1
+
+    while frontier:
+        if deadline is not None and time.time() > deadline:
+            return BestFirstTrace(False, "timeout", pops, evals, max_open)
+        if pops >= max_pops:
+            return BestFirstTrace(False, "budget", pops, evals, max_open)
+
+        neg_g, _, subgoals, acts = heapq.heappop(frontier)
+        g = -neg_g
+        pops += 1
+
+        # Focus the leftmost subgoal; wrap alone so policy sees in-dist text.
+        node = HolophrasmNode([subgoals[0]])
+        try:
+            legal = node.actions
+        except BaseException:
+            continue                          # latent prover panic -> dead
+        if not legal:
+            continue                          # dead end, no backtrack
+
+        if max_actions and len(legal) > max_actions:
+            continue                          # context-bloat: abandon item
+
+        state_str = str(node)
+        action_strs = [str(a) for a in legal]
+        scores = np.clip(np.asarray(lm.estimate_state_action_values(state_str, action_strs),
+                                    dtype=np.float64), 1e-12, None)
+        evals += len(legal)
+        logpi = np.log(scores) - np.log(scores.sum())   # log normalized prior
+
+        for i, action in enumerate(legal):
+            try:
+                child = node.expand(action)
+            except BaseException:
+                continue
+            spawned = list(child._proof_states)
+            new_subgoals = spawned + list(subgoals[1:])
+            new_acts = acts + [action_strs[i]]
+            if not new_subgoals:
+                return BestFirstTrace(True, "solved", pops, evals, max_open, new_acts)
+            heapq.heappush(frontier,
+                           (-(g + logpi[i]), next(counter),
+                            tuple(new_subgoals), new_acts))
+        max_open = max(max_open, len(frontier))
+
+    return BestFirstTrace(False, "exhausted", pops, evals, max_open)
+
+
+def _summarize(tr: BestFirstTrace) -> dict:
+    return {
+        "solved": tr.solved,
+        "outcome": tr.outcome,
+        "pops_used": tr.pops_used,
+        "evals_used": tr.evals_used,
+        "max_open": tr.max_open,
+        "solution_actions": tr.solution_actions if tr.solved else None,
+    }
+
+
+# ----------------------------------------------------------------------------
+# Parallel workers (shared visible GPU; one LM load per process)
+# ----------------------------------------------------------------------------
+
+_WORKER: dict = {}
+
+
+def _worker_init(agent_path, problemset_id, max_pops, max_actions, timeout):
+    _WORKER["lm"] = load_policy_lm(agent_path)
+    _WORKER["problemset"] = problems.load_problemset(problemset_id)
+    _WORKER["max_pops"] = max_pops
+    _WORKER["max_actions"] = max_actions
+    _WORKER["timeout"] = timeout
+
+
+def _worker_solve(name: str) -> dict:
+    w = _WORKER
+    state = w["problemset"].initialize_problem(name)
+    deadline = (time.time() + w["timeout"]) if w["timeout"] and w["timeout"] > 0 else None
+    tr = best_first(w["lm"], state, max_pops=w["max_pops"],
+                    max_actions=w["max_actions"], deadline=deadline)
+    rec = _summarize(tr)
+    rec["problem"] = name
+    return rec
+
+
+def _print_result(rec: dict):
+    flag = "OK " if rec["solved"] else "   "
+    print(f"[{flag}] {rec['problem']}  ({rec['outcome']} pops={rec['pops_used']} "
+          f"evals={rec['evals_used']} maxopen={rec['max_open']})", flush=True)
+
+
+def run(agent_path, problemset_id, max_pops, max_actions, timeout,
+        output, single=None, workers=1):
+    problemset = problems.load_problemset(problemset_id)
+    names = problemset.problem_names()
+    if single is not None:
+        names = [single]
+
+    t0 = time.time()
+
+    if workers > 1 and single is None:
+        ctx = multiprocessing.get_context("spawn")
+        by_name: dict[str, dict] = {}
+        with ProcessPoolExecutor(max_workers=workers, mp_context=ctx,
+                                 initializer=_worker_init,
+                                 initargs=(agent_path, problemset_id, max_pops,
+                                           max_actions, timeout)) as ex:
+            futures = {ex.submit(_worker_solve, name): name for name in names}
+            for fut in as_completed(futures):
+                rec = fut.result()
+                by_name[rec["problem"]] = rec
+                _print_result(rec)
+        results = [by_name[name] for name in names]
+    else:
+        lm = load_policy_lm(agent_path)
+        results = []
+        for name in names:
+            state = problemset.initialize_problem(name)
+            deadline = (time.time() + timeout) if timeout and timeout > 0 else None
+            tr = best_first(lm, state, max_pops=max_pops, max_actions=max_actions,
+                            deadline=deadline)
+            rec = _summarize(tr)
+            rec["problem"] = name
+            results.append(rec)
+            _print_result(rec)
+
+    n_solved = sum(int(rec["solved"]) for rec in results)
+    elapsed = time.time() - t0
+    summary = {
+        "agent_path": agent_path,
+        "problemset": problemset_id,
+        "max_pops": max_pops,
+        "max_actions": max_actions,
+        "timeout": timeout,
+        "workers": workers,
+        "num_problems": len(names),
+        "num_solved": n_solved,
+        "elapsed_sec": elapsed,
+        "results": results,
+    }
+
+    if output:
+        os.makedirs(os.path.dirname(os.path.abspath(output)), exist_ok=True)
+        with open(output, "w") as f:
+            json.dump(summary, f, indent=2)
+        print(f"\nWrote {output}")
+
+    print(f"Solved {n_solved}/{len(names)} in {elapsed:.1f}s")
+    return summary
+
+
+def main():
+    p = argparse.ArgumentParser(description="Value-free best-first proof search.")
+    p.add_argument("--agent", required=True, help="Path to agent/policy .pt checkpoint.")
+    p.add_argument("--problemset", required=True, help="Problem set id.")
+    p.add_argument("--max-pops", type=int, default=4000,
+                   help="Budget: number of items expanded (mirrors MCTS max_mcts_nodes).")
+    p.add_argument("--max-actions", type=int, default=0,
+                   help="Abandon a state whose legal-action set exceeds this size (0 = no cap).")
+    p.add_argument("--timeout", type=float, default=0.0,
+                   help="Per-problem wall-clock budget in seconds (0 = none).")
+    p.add_argument("--workers", type=int, default=1,
+                   help="Worker processes sharing the visible GPU (1 = sequential).")
+    p.add_argument("--output", default="", help="Path to write JSON results.")
+    p.add_argument("--single", default=None, help="Run a single problem by name.")
+    args = p.parse_args()
+
+    run(agent_path=args.agent, problemset_id=args.problemset,
+        max_pops=args.max_pops, max_actions=args.max_actions,
+        timeout=args.timeout, output=args.output, single=args.single,
+        workers=args.workers)
+
+
+if __name__ == "__main__":
+    main()

experiments/learnability/bootstrap.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python3
+
+"""Implements the conjecture-prove bootstrapping learning loop."""
+
+import asyncio
+import os
+import json
+import datetime
+from pathlib import Path
+
+import hydra
+from omegaconf import DictConfig
+import torch
+import numpy as np
+from tqdm import tqdm
+
+import peano
+import worker
+from worker import StudentResult  # noqa
+from hindsight import HindsightExample  # noqa
+from util import format_blocks_with_indent, sample_batch, setup_wandb, value_color, save_json
+from conjecture import AgentLM, Context, sample_conjecture
+from proofsearch import make_agent
+
+
+def load_fixed_statements(path: str) -> list[str]:
+    """Parse a benchmark file with 'name. statement' lines into a list of statements."""
+    stmts = []
+    for line in Path(path).read_text().splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        if "." in line:
+            _, stmt = line.split(".", 1)
+            stmt = stmt.strip()
+        else:
+            stmt = line
+        stmts.append(stmt)
+    return stmts
+
+
+def now() -> str:
+    return '[' + datetime.datetime.now().isoformat() + ']'
+
+
+FAIL = "fail"
+
+
+def _get_logprob(student_result, normalize):
+    """Return logprob, optionally normalized by proof length."""
+    lp = student_result.logprob
+    if normalize and lp is not None and student_result.solution_actions:
+        lp = lp / max(len(student_result.solution_actions), 1)
+    return lp
+
+
+DISTRIBUTED = os.environ.get('DISTRIBUTED', False)
+
+
+def submit_task(agent_path: str, theory: worker.BackgroundTheory, statement: str, timeout: float = None):
+    if DISTRIBUTED:
+        return worker.try_prove.apply_async(args=(agent_path, theory, statement),
+                                            kwargs={'timeout': timeout})
+    else:
+        return worker.try_prove.run(agent_path, theory, statement, timeout=timeout)
+
+
+def get_task_result(task, timeout=None):
+    if DISTRIBUTED:
+        return task.get(timeout=timeout)
+    else:
+        return task
+
+
+async def teacher_loop(cfg: DictConfig):
+    print('Running in', 'distributed mode.' if DISTRIBUTED else 'single-process mode.')
+
+    agent = make_agent(cfg)
+
+    with open(os.path.join(os.path.dirname(__file__), 'theories', cfg.theory.name + '.p')) as f:
+        theory = f.read()
+
+    difficulty_buckets = sorted([list(cfg.difficulty_buckets[i].items())[0]
+                                 for i in range(len(cfg.difficulty_buckets))],
+                                key=lambda kv: kv[1])
+
+    premises = cfg.theory.premises
+
+    d = peano.PyDerivation()
+    d.incorporate(theory)
+    proven_conjectures = []
+    seen_hindsight_goals = set()
+    proofs = []
+    outcomes = []
+
+    continue_dir = cfg.get('continue')
+    start_iteration = 0
+
+    if continue_dir is not None:
+        os.chdir(continue_dir)
+        print('Continuing run from', continue_dir)
+        # Find largest iteration number such that i.pt exists.
+        i = 0
+        while os.path.exists(f'{i}.pt'):
+            i += 1
+        i -= 1
+        start_iteration = i
+        agent = torch.load(f'{i}.pt', weights_only=False)
+        print('Loaded agent from', f'{i}.pt')
+        # Load examples and outcomes.
+        if i > 0:
+            with open(f'outcomes_{i-1}.json', 'r') as f:
+                outcomes = json.load(f)
+                proven_conjectures = [o['problem'] for o in outcomes
+                                      if o['hindsight'] is False and
+                                         o['proof'] is not None]
+                seen_hindsight_goals = {o['problem'] for o in outcomes
+                                        if o['hindsight'] and o['proof'] is not None}
+
+        print('Loaded', len(proven_conjectures), 'proven conjectures from previous run.')
+
+
+    if cfg.get('freeze_conjecturer', False):
+        print('Ablation: Freezing conjecturer.')
+
+
+    with open('log.jsonl', 'w') as log:
+        for i in range(start_iteration, cfg.iterations):
+            torch.save(agent, f'{i}.pt')
+
+            fixed_path = cfg.get('fixed_statements_path', None)
+
+            if fixed_path is not None:
+                conjectures = load_fixed_statements(fixed_path)
+                print(now(), f'Iteration #{i}: using {len(conjectures)} fixed benchmark problems.')
+            else:
+                context = Context(d, None, [])
+                # 1- Run conjecturing model to obtain N conjectures.
+                print(now(), f'Iteration #{i}: making conjectures...')
+
+                progress_bar = tqdm(total=cfg.n_conjectures)
+
+                conjectures = []
+
+                while len(conjectures) < cfg.n_conjectures:
+                    proposal = sample_conjecture(AgentLM(agent, 'Conj:(hard) '), context)
+
+                    if proposal and proposal not in conjectures + proven_conjectures:
+                        # Contract conjectures to make them Peano-parseable.
+                        contracted_proposal = d.contract(proposal)
+                        if contracted_proposal not in conjectures + proven_conjectures:
+                            conjectures.append(contracted_proposal)
+                            progress_bar.update(1)
+
+                progress_bar.close()
+
+
+            print(now(), 'done, have', len(conjectures), 'conjectures')
+            print(conjectures)
+
+            log.write(json.dumps({'iteration': i,
+                                  'msg': f'It #{i}: posing {len(conjectures)} conjectures.',
+                                  'conjectures': conjectures}))
+            log.write('\n')
+            log.flush()
+
+            # 2- Try to prove each of the conjectures
+            tasks = []
+
+            # Reuse the checkpoint already saved above.
+            agent_path = os.path.abspath(f'{i}.pt')
+
+            proof_search_timeout = cfg.get('proof_search_timeout', None)
+            if proof_search_timeout:
+                print(f'Proof search timeout: {proof_search_timeout}s')
+
+            print('Submitting tasks...')
+            for conjecture in tqdm(conjectures, miniters=1):
+                tasks.append(submit_task(
+                    agent_path,
+                    worker.BackgroundTheory(theory, premises),
+                    conjecture,
+                    timeout=proof_search_timeout))
+
+            # 3- Train model on proofs and outcome of conjectures (easy, hard, timeout)
+            examples = []
+            student_results = []
+
+            inactivity_timeout = (proof_search_timeout + 60) if proof_search_timeout else 660
+            print('Collecting', len(tasks), f'results from workers (inactivity timeout: {inactivity_timeout}s).')
+
+            if DISTRIBUTED:
+                import time as _time
+                pending = set(range(len(tasks)))
+                last_result_time = _time.time()
+                progress_bar = tqdm(total=len(tasks), miniters=1)
+
+                while pending and (_time.time() - last_result_time) < inactivity_timeout:
+                    for idx in list(pending):
+                        if tasks[idx].ready():
+                            pending.discard(idx)
+                            progress_bar.update(1)
+                            last_result_time = _time.time()
+                            try:
+                                student_result = tasks[idx].get(timeout=5)
+                                if student_result.error:
+                                    print('Error in prover process!')
+                                    print(student_result.error)
+                                    continue
+                                student_results.append(student_result)
+                            except Exception as e:
+                                print(f'Failed to get result for task {idx}: {e}')
+                    _time.sleep(1)
+
+                progress_bar.close()
+                if pending:
+                    print(f'Collection stopped after {inactivity_timeout}s of inactivity.')
+                    print(f'Got {len(student_results)} results out of {len(tasks)} tasks.')
+            else:
+                for task in tqdm(tasks, miniters=1):
+                    student_result = get_task_result(task)
+                    if student_result.error:
+                        print('Error in prover process!')
+                        print(student_result.error)
+                        continue
+                    student_results.append(student_result)
+
+            success_logprobs = []
+            n_timeouts = 0
+            normalize_lp = cfg.get('normalize_logprob', False)
+
+            # 3a- Look at all the success logprobs and compute the easy/hard threhsold.
+            for student_result in student_results:
+                if student_result.success:
+                    success_logprobs.append(_get_logprob(student_result, normalize_lp))
+
+                if getattr(student_result, 'timed_out', False):
+                    n_timeouts += 1
+
+                outcomes.append({'iteration': i,
+                                 'problem': student_result.problem,
+                                 'proof': student_result.proof,
+                                 'logprob': student_result.logprob,
+                                 'actions': student_result.solution_actions,
+                                 'hindsight': False,
+                                 'timed_out': getattr(student_result, 'timed_out', False),
+                                 'proof_features': getattr(student_result, 'proof_features', None),
+                                 })
+
+                for h in student_result.hindsight_examples:
+                    outcomes.append({'iteration': i,
+                                     'problem': h.statement,
+                                     'proof': h.proof,
+                                     'logprob': h.logprob,
+                                     'actions': h.solution_actions,
+                                     'hindsight': True
+                                     })
+
+            if not success_logprobs:
+                print(f'No solutions found in iteration {i} - stopping learning loop...')
+                break
+
+            print(f'Iteration #{i}: {len(success_logprobs)} solved, {n_timeouts} timed out, '
+                  f'{len(student_results) - len(success_logprobs) - n_timeouts} failed.')
+
+            thresholds = [np.percentile(success_logprobs, p)
+                          for _, p in difficulty_buckets]
+
+            print('Thresholds:',
+                  list(zip([k for k, _ in difficulty_buckets], thresholds)),
+                  'min =', np.min(success_logprobs),
+                  'max =', np.max(success_logprobs))
+
+            # 3b- Classify problems into easy/hard.
+            for student_result in student_results:
+                # Outcome is the name of the first difficulty bucket that is larger than the logprob.
+                if student_result.success:
+                    lp = _get_logprob(student_result, normalize_lp)
+                    outcome = next(k
+                                   for i, (k, _) in enumerate(difficulty_buckets)
+                                   if (lp <= thresholds[i] or
+                                       i + 1 == len(difficulty_buckets)))
+                else:
+                    outcome = FAIL
+
+                if not cfg.get('freeze_conjecturer', False):
+                    examples.append(f'Conj:({outcome}) ' + d.elaborate(student_result.problem))
+
+                if student_result.success:
+                    proven_conjectures.append(student_result.problem)
+                    proofs.append(student_result.proof)
+
+                examples.extend(student_result.extracted_examples)
+
+                if cfg.train_policy_on_hindsight_examples:
+                    for h in student_result.hindsight_examples:
+                        if h.goal not in seen_hindsight_goals:
+                            h_lp = h.logprob
+                            if normalize_lp and h.solution_actions:
+                                h_lp = h_lp / max(len(h.solution_actions), 1)
+                            outcome = next(k
+                                           for i, (k, _) in enumerate(difficulty_buckets)
+                                           if h_lp <= thresholds[i] or i + 1 == len(difficulty_buckets))
+
+                            if not cfg.get('freeze_conjecturer', False):
+                                examples.append(f'Conj:({outcome}) ' + d.elaborate(student_result.problem))
+                            examples.extend(h.examples)
+                            seen_hindsight_goals.add(h.goal)
+
+            log.write(json.dumps({'iteration': i,
+                                  'msg': f'Training on {len(examples)} examples.'}))
+            log.write('\n')
+
+            # 3c- Train model on conjecturing and proof search examples.
+            if i + 1 < cfg.iterations:
+                print(len(examples), 'accumulated training examples.')
+                agent.train(examples)
+
+            save_json(examples, f'examples_{i}.json')
+            save_json(outcomes, f'outcomes_{i}.json')
+            torch.save(student_results, f'results_{i}.json')
+
+
+@hydra.main(version_base="1.2", config_path="config", config_name="bootstrap")
+def main(cfg: DictConfig):
+    print('Running from:', os.getcwd())
+    setup_wandb(cfg)
+    if cfg.task == 'teacher':
+        asyncio.run(teacher_loop(cfg))
+
+if __name__ == '__main__':
+    main()
+
+#DISTRIBUTED=1 python bootstrap.py --config-name bootstrap_NoHER
+#DISTRIBUTED=1 python bootstrap.py --config-name bootstrap_nat_mul
+#CUDA_VISIBLE_DEVICES=0 celery -A worker.app worker --loglevel=info --concurrency=5 -n gpu0@%h
+#CUDA_VISIBLE_DEVICES=1 celery -A worker.app worker --loglevel=info --concurrency=5 -n gpu1@%h
+#CUDA_VISIBLE_DEVICES=2 celery -A worker.app worker --loglevel=info --concurrency=5 -n gpu2@%h
+#CUDA_VISIBLE_DEVICES=3 celery -A worker.app worker --loglevel=info --concurrency=5 -n gpu3@%h
+#redis-server --port 6379
+#DISTRIBUTED=1 python bootstrap.py --config-name bootstrap_800_moreupdates.yaml
+#DISTRIBUTED=1 python bootstrap.py --config-name bootstrap_nat_mul_800.yaml
+
+#DISTRIBUTED=1 python bootstrap.py --config-name bootstrap_fixed_benchmark +agent_path=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/2.pt
+
+#ç
+#DISTRIBUTED=1 python bootstrap.py --config-name bootstrap_fixed_benchmark +agent_path=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_fixed_bench_noHER/2026-03-19_18-44-53/9.pt
+#DISTRIBUTED=1 python bootstrap.py --config-name bootstrap_nat_mul_800

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/.hydra/config.yaml

@@ -0,0 +1,44 @@
+task: teacher
+iterations: 5
+n_conjectures: 800
+difficulty_buckets:
+- hard: 20
+- easy: 50
+- triv: 100
+train_policy_on_hindsight_examples: true
+freeze_conjecturer: false
+proof_search_timeout: 600
+job:
+  wandb_project: peano
+agent:
+  type: mcts
+  node_type: holophrasm
+  max_mcts_nodes: 1000
+  expansions: 1000
+  max_searches: 1
+  max_examples: 1000
+  policy:
+    type: LM
+    lr: 0.0001
+    value_prior_weight: 10
+    max_pos_neg_ratio: 5
+    train_iterations: 2000
+    batch_size: 10000
+  curiosity:
+    type: constant
+theory:
+  name: propositional-logic
+  premises:
+  - and_i
+  - and_el
+  - and_er
+  - or_il
+  - or_ir
+  - or_e
+  - not_i
+  - not_e
+  - exfalso
+  - iff_i
+  - iff_el
+  - iff_er
+  - em

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/.hydra/hydra.yaml

@@ -0,0 +1,157 @@
+hydra:
+  run:
+    dir: /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/${now:%Y-%m-%d_%H-%M-%S}
+  sweep:
+    dir: multirun/${now:%Y-%m-%d}/${now:%H-%M-%S}
+    subdir: ${hydra.job.num}
+  launcher:
+    _target_: hydra._internal.core_plugins.basic_launcher.BasicLauncher
+  sweeper:
+    _target_: hydra._internal.core_plugins.basic_sweeper.BasicSweeper
+    max_batch_size: null
+    params: null
+  help:
+    app_name: ${hydra.job.name}
+    header: '${hydra.help.app_name} is powered by Hydra.
+
+      '
+    footer: 'Powered by Hydra (https://hydra.cc)
+
+      Use --hydra-help to view Hydra specific help
+
+      '
+    template: '${hydra.help.header}
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (group=option)
+
+
+      $APP_CONFIG_GROUPS
+
+
+      == Config ==
+
+      Override anything in the config (foo.bar=value)
+
+
+      $CONFIG
+
+
+      ${hydra.help.footer}
+
+      '
+  hydra_help:
+    template: 'Hydra (${hydra.runtime.version})
+
+      See https://hydra.cc for more info.
+
+
+      == Flags ==
+
+      $FLAGS_HELP
+
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (For example, append hydra/job_logging=disabled
+      to command line)
+
+
+      $HYDRA_CONFIG_GROUPS
+
+
+      Use ''--cfg hydra'' to Show the Hydra config.
+
+      '
+    hydra_help: ???
+  hydra_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][HYDRA] %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+    root:
+      level: INFO
+      handlers:
+      - console
+    loggers:
+      logging_example:
+        level: DEBUG
+    disable_existing_loggers: false
+  job_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][%(name)s][%(levelname)s] - %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+      file:
+        class: logging.FileHandler
+        formatter: simple
+        filename: ${hydra.runtime.output_dir}/${hydra.job.name}.log
+    root:
+      level: INFO
+      handlers:
+      - console
+      - file
+    disable_existing_loggers: false
+  env: {}
+  mode: RUN
+  searchpath: []
+  callbacks: {}
+  output_subdir: .hydra
+  overrides:
+    hydra:
+    - hydra.mode=RUN
+    task: []
+  job:
+    name: bootstrap
+    chdir: true
+    override_dirname: ''
+    id: ???
+    num: ???
+    config_name: bootstrap_800.yaml
+    env_set: {}
+    env_copy: []
+    config:
+      override_dirname:
+        kv_sep: '='
+        item_sep: ','
+        exclude_keys: []
+  runtime:
+    version: 1.3.2
+    version_base: '1.2'
+    cwd: /datadrive/ayush/home/minimoX/learning
+    config_sources:
+    - path: hydra.conf
+      schema: pkg
+      provider: hydra
+    - path: /datadrive/ayush/home/minimoX/learning/config
+      schema: file
+      provider: main
+    - path: ''
+      schema: structured
+      provider: schema
+    output_dir: /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21
+    choices:
+      theory: propositional-logic
+      agent: mcts-lm
+      agent/curiosity: constant
+      hydra/env: default
+      hydra/callbacks: null
+      hydra/job_logging: default
+      hydra/hydra_logging: default
+      hydra/hydra_help: default
+      hydra/help: default
+      hydra/sweeper: basic
+      hydra/launcher: basic
+      hydra/output: default
+  verbose: false

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/.hydra/overrides.yaml

@@ -0,0 +1 @@
+[]

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/0.pt

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

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/1.pt

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

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/2.pt

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

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/3.pt

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

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/4.pt

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

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/checkpoints/0.pt

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

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/.hydra/config.yaml

@@ -0,0 +1,20 @@
+task: eval
+problemset: extrinsic-pl
+max_problems: 1000
+accumulate_library: false
+proof_search_timeout: 1200
+eval_num_workers: 3
+agent:
+  max_mcts_nodes: 2000
+  type: mcts
+  node_type: vanilla
+  expansions: 50000
+  max_searches: 1
+  max_examples: 50
+  policy:
+    type: Uniform
+  curiosity:
+    type: constant
+job:
+  wandb_project: peano
+agent_path: /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/1.pt

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/.hydra/hydra.yaml

@@ -0,0 +1,163 @@
+hydra:
+  run:
+    dir: /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06
+  sweep:
+    dir: multirun/${now:%Y-%m-%d}/${now:%H-%M-%S}
+    subdir: ${hydra.job.num}
+  launcher:
+    _target_: hydra._internal.core_plugins.basic_launcher.BasicLauncher
+  sweeper:
+    _target_: hydra._internal.core_plugins.basic_sweeper.BasicSweeper
+    max_batch_size: null
+    params: null
+  help:
+    app_name: ${hydra.job.name}
+    header: '${hydra.help.app_name} is powered by Hydra.
+
+      '
+    footer: 'Powered by Hydra (https://hydra.cc)
+
+      Use --hydra-help to view Hydra specific help
+
+      '
+    template: '${hydra.help.header}
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (group=option)
+
+
+      $APP_CONFIG_GROUPS
+
+
+      == Config ==
+
+      Override anything in the config (foo.bar=value)
+
+
+      $CONFIG
+
+
+      ${hydra.help.footer}
+
+      '
+  hydra_help:
+    template: 'Hydra (${hydra.runtime.version})
+
+      See https://hydra.cc for more info.
+
+
+      == Flags ==
+
+      $FLAGS_HELP
+
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (For example, append hydra/job_logging=disabled
+      to command line)
+
+
+      $HYDRA_CONFIG_GROUPS
+
+
+      Use ''--cfg hydra'' to Show the Hydra config.
+
+      '
+    hydra_help: ???
+  hydra_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][HYDRA] %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+    root:
+      level: INFO
+      handlers:
+      - console
+    loggers:
+      logging_example:
+        level: DEBUG
+    disable_existing_loggers: false
+  job_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][%(name)s][%(levelname)s] - %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+      file:
+        class: logging.FileHandler
+        formatter: simple
+        filename: ${hydra.runtime.output_dir}/${hydra.job.name}.log
+    root:
+      level: INFO
+      handlers:
+      - console
+      - file
+    disable_existing_loggers: false
+  env: {}
+  mode: RUN
+  searchpath: []
+  callbacks: {}
+  output_subdir: .hydra
+  overrides:
+    hydra:
+    - hydra.run.dir=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06
+    - hydra.mode=RUN
+    task:
+    - task=eval
+    - +agent_path=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/1.pt
+    - problemset=extrinsic-pl
+    - agent.max_mcts_nodes=2000
+    - proof_search_timeout=1200
+    - eval_num_workers=3
+  job:
+    name: proofsearch
+    chdir: true
+    override_dirname: +agent_path=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/1.pt,agent.max_mcts_nodes=2000,eval_num_workers=3,problemset=extrinsic-pl,proof_search_timeout=1200,task=eval
+    id: ???
+    num: ???
+    config_name: proofsearch
+    env_set: {}
+    env_copy: []
+    config:
+      override_dirname:
+        kv_sep: '='
+        item_sep: ','
+        exclude_keys: []
+  runtime:
+    version: 1.3.2
+    version_base: '1.2'
+    cwd: /datadrive/ayush/home/minimoX/learning
+    config_sources:
+    - path: hydra.conf
+      schema: pkg
+      provider: hydra
+    - path: /datadrive/ayush/home/minimoX/learning/config
+      schema: file
+      provider: main
+    - path: ''
+      schema: structured
+      provider: schema
+    output_dir: /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06
+    choices:
+      agent: mcts
+      agent/curiosity: constant
+      hydra/env: default
+      hydra/callbacks: null
+      hydra/job_logging: default
+      hydra/hydra_logging: default
+      hydra/hydra_help: default
+      hydra/help: default
+      hydra/sweeper: basic
+      hydra/launcher: basic
+      hydra/output: default
+  verbose: false

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/.hydra/overrides.yaml

@@ -0,0 +1,6 @@
+- task=eval
+- +agent_path=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/1.pt
+- problemset=extrinsic-pl
+- agent.max_mcts_nodes=2000
+- proof_search_timeout=1200
+- eval_num_workers=3

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/1_pt_proved_results.json

@@ -0,0 +1,89 @@
+{
+  "results": [
+    {
+      "problem": "extrinsic_1",
+      "proof": "theorem t : [('A : prop) -> ['A -> 'A]] {\n    intro x : prop.\n    intro _ : [x -> x].\n}"
+    },
+    {
+      "problem": "extrinsic_3",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> ['B -> 'C]] -> ['B -> ['A -> 'C]]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : prop.\n    intro x2 : [x -> [x0 -> x1]].\n    intro x3 : x0.\n    intro x4 : x.\n    show [x0 -> x1] by x2.\n    apply p.\n}"
+    },
+    {
+      "problem": "extrinsic_2",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> 'B] -> ['B -> 'C] -> ['A -> 'C]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : prop.\n    intro x2 : [x -> x0].\n    intro x3 : [x0 -> x1].\n    intro x4 : x.\n    show x0 by x2.\n    apply x3.\n}"
+    },
+    {
+      "problem": "extrinsic_5",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ('C : prop) -> [(and 'A 'B) -> 'C] -> ['A -> ['B -> 'C]]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : prop.\n    intro x2 : [(and x x0) -> x1].\n    intro x3 : x.\n    intro x4 : x0.\n    apply x2.\n    goal (and x x0) {\n        apply and_i.\n    }\n}"
+    },
+    {
+      "problem": "extrinsic_6",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> 'B] -> [['B -> 'C] -> ['A -> 'C]]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : prop.\n    intro x2 : [x -> x0].\n    intro x3 : [x0 -> x1].\n    intro x4 : x.\n    apply x3.\n    goal x0 {\n        show x0 by x2.\n    }\n}"
+    },
+    {
+      "problem": "extrinsic_7",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> 'B] -> [['C -> 'A] -> ['C -> 'B]]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : prop.\n    intro x2 : [x -> x0].\n    intro x3 : [x1 -> x].\n    intro x4 : x1.\n    show x by x3.\n    apply x2.\n}"
+    },
+    {
+      "problem": "extrinsic_8a",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> 'B] -> [(and 'A 'C) -> (and 'B 'C)]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : prop.\n    intro x2 : [x -> x0].\n    intro x3 : (and x x1).\n    apply and_i.\n    goal x0 {\n        apply x2.\n        goal x {\n            show x by and_el.\n        }\n    }\n    goal x1 {\n        show x1 by and_er.\n    }\n}"
+    },
+    {
+      "problem": "extrinsic_8b",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> 'B] -> [(and 'C 'A) -> (and 'C 'B)]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : prop.\n    intro x2 : [x -> x0].\n    intro x3 : (and x1 x).\n    apply and_i.\n    goal x1 {\n        show x1 by and_el.\n    }\n    goal x0 {\n        apply x2.\n        goal x {\n            show x by and_er.\n        }\n    }\n}"
+    },
+    {
+      "problem": "extrinsic_4",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> ['B -> 'C]] -> [(and 'A 'B) -> 'C]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : prop.\n    intro x2 : [x -> [x0 -> x1]].\n    intro x3 : (and x x0).\n    show x0 by and_er.\n    show x by and_el.\n    show [x0 -> x1] by x2.\n    apply p1.\n}"
+    },
+    {
+      "problem": "extrinsic_10a",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> [(not 'A) -> ['A -> 'B]]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : (not x).\n    intro x2 : x.\n    apply exfalso.\n    goal false {\n        apply not_e.\n    }\n}"
+    },
+    {
+      "problem": "extrinsic_10b",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ['A -> [(not 'A) -> 'B]]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : x.\n    intro x2 : (not x).\n    apply exfalso.\n    goal false {\n        apply not_e.\n    }\n}"
+    },
+    {
+      "problem": "extrinsic_11",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ['B -> ['A -> 'B]]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : x0.\n    intro _ : [x -> x0].\n}"
+    },
+    {
+      "problem": "extrinsic_12",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ['A -> 'B] -> [(not 'B) -> (not 'A)]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : [x -> x0].\n    intro x2 : (not x0).\n    apply not_i.\n    goal [x -> false] {\n        intro x3 : x.\n        show x0 by x1.\n        show false by not_e.\n    }\n}"
+    },
+    {
+      "problem": "extrinsic_13",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ['A -> (not 'B)] -> ['B -> (not 'A)]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : [x -> (not x0)].\n    intro x2 : x0.\n    apply not_i.\n    goal [x -> false] {\n        intro x3 : x.\n        show (not x0) by x1.\n        show false by not_e.\n    }\n}"
+    },
+    {
+      "problem": "extrinsic_16",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ['A -> 'B] -> ['B -> 'A] -> (iff 'A 'B)] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : [x -> x0].\n    intro x2 : [x0 -> x].\n    apply iff_i.\n}"
+    },
+    {
+      "problem": "extrinsic_17a",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> ['A -> 'B]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : (iff x x0).\n    show [x -> x0] by iff_el.\n}"
+    },
+    {
+      "problem": "extrinsic_17b",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> ['B -> 'A]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : (iff x x0).\n    show [x0 -> x] by iff_er.\n}"
+    },
+    {
+      "problem": "extrinsic_18a",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> 'A -> 'B] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : (iff x x0).\n    show [x -> x0] by iff_el.\n}"
+    },
+    {
+      "problem": "extrinsic_18b",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> 'B -> 'A] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : (iff x x0).\n    show [x0 -> x] by iff_er.\n}"
+    },
+    {
+      "problem": "extrinsic_19",
+      "proof": "theorem t : [('A : prop) -> (iff 'A 'A)] {\n    intro x : prop.\n    apply iff_i.\n    goal [x -> x] {\n        intro _ : [x -> x].\n    }\n    goal [x -> x] {\n        intro _ : [x -> x].\n    }\n}"
+    },
+    {
+      "problem": "extrinsic_20",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> (iff 'B 'A)] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : (iff x x0).\n    apply iff_i.\n    goal [x0 -> x] {\n        show [x0 -> x] by iff_er.\n    }\n    goal [x -> x0] {\n        show [x -> x0] by iff_el.\n    }\n}"
+    }
+  ],
+  "num_proved": 21
+}

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/wandb/debug-internal.log

@@ -0,0 +1,13 @@
+{"time":"2026-03-13T01:16:09.785083032Z","level":"INFO","msg":"stream: starting","core version":"0.24.0"}
+{"time":"2026-03-13T01:16:10.076942766Z","level":"INFO","msg":"stream: created new stream","id":"3egbnt6l"}
+{"time":"2026-03-13T01:16:10.077089199Z","level":"INFO","msg":"handler: started","stream_id":"3egbnt6l"}
+{"time":"2026-03-13T01:16:10.077302187Z","level":"INFO","msg":"stream: started","id":"3egbnt6l"}
+{"time":"2026-03-13T01:16:10.077344416Z","level":"INFO","msg":"writer: started","stream_id":"3egbnt6l"}
+{"time":"2026-03-13T01:16:10.07739266Z","level":"INFO","msg":"sender: started","stream_id":"3egbnt6l"}
+{"time":"2026-03-13T01:16:11.071544487Z","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":82}
+{"time":"2026-03-13T01:16:11.075460643Z","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":48}
+{"time":"2026-03-13T01:24:23.280094998Z","level":"INFO","msg":"stream: closing","id":"3egbnt6l"}
+{"time":"2026-03-13T01:24:23.6285521Z","level":"INFO","msg":"fileTransfer: Close: file transfer manager closed"}
+{"time":"2026-03-13T01:24:23.812323995Z","level":"INFO","msg":"handler: closed","stream_id":"3egbnt6l"}
+{"time":"2026-03-13T01:24:23.812511385Z","level":"INFO","msg":"sender: closed","stream_id":"3egbnt6l"}
+{"time":"2026-03-13T01:24:23.812527465Z","level":"INFO","msg":"stream: closed","id":"3egbnt6l"}

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/wandb/debug.log

@@ -0,0 +1,19 @@
+2026-03-13 01:16:09,558 INFO    MainThread:494704 [wandb_setup.py:_flush():81] Current SDK version is 0.24.0
+2026-03-13 01:16:09,558 INFO    MainThread:494704 [wandb_setup.py:_flush():81] Configure stats pid to 494704
+2026-03-13 01:16:09,558 INFO    MainThread:494704 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2026-03-13 01:16:09,559 INFO    MainThread:494704 [wandb_init.py:setup_run_log_directory():717] Logging user logs to /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/wandb/run-20260313_011609-3egbnt6l/logs/debug.log
+2026-03-13 01:16:09,559 INFO    MainThread:494704 [wandb_init.py:setup_run_log_directory():718] Logging internal logs to /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/wandb/run-20260313_011609-3egbnt6l/logs/debug-internal.log
+2026-03-13 01:16:09,559 INFO    MainThread:494704 [wandb_init.py:init():844] calling init triggers
+2026-03-13 01:16:09,559 INFO    MainThread:494704 [wandb_init.py:init():849] wandb.init called with sweep_config: {}
+config: {'task': 'eval', 'problemset': 'extrinsic-pl', 'max_problems': 1000, 'accumulate_library': False, 'proof_search_timeout': 1200, 'eval_num_workers': 3, 'agent': {'max_mcts_nodes': 2000, 'type': 'mcts', 'node_type': 'vanilla', 'expansions': 50000, 'max_searches': 1, 'max_examples': 50, 'policy': {'type': 'Uniform'}, 'curiosity': {'type': 'constant'}}, 'job': {'wandb_project': 'peano', 'cwd': '/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06'}, 'agent_path': '/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/1.pt', '_wandb': {}}
+2026-03-13 01:16:09,559 INFO    MainThread:494704 [wandb_init.py:init():892] starting backend
+2026-03-13 01:16:09,779 INFO    MainThread:494704 [wandb_init.py:init():895] sending inform_init request
+2026-03-13 01:16:09,783 INFO    MainThread:494704 [wandb_init.py:init():903] backend started and connected
+2026-03-13 01:16:09,784 INFO    MainThread:494704 [wandb_init.py:init():973] updated telemetry
+2026-03-13 01:16:09,789 INFO    MainThread:494704 [wandb_init.py:init():997] communicating run to backend with 90.0 second timeout
+2026-03-13 01:16:10,993 INFO    MainThread:494704 [wandb_init.py:init():1044] starting run threads in backend
+2026-03-13 01:16:11,054 INFO    MainThread:494704 [wandb_run.py:_console_start():2529] atexit reg
+2026-03-13 01:16:11,054 INFO    MainThread:494704 [wandb_run.py:_redirect():2377] redirect: wrap_raw
+2026-03-13 01:16:11,054 INFO    MainThread:494704 [wandb_run.py:_redirect():2446] Wrapping output streams.
+2026-03-13 01:16:11,054 INFO    MainThread:494704 [wandb_run.py:_redirect():2469] Redirects installed.
+2026-03-13 01:16:11,058 INFO    MainThread:494704 [wandb_init.py:init():1084] run started, returning control to user process

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/wandb/run-20260313_011609-3egbnt6l/files/config.yaml

@@ -0,0 +1,108 @@
+_wandb:
+    value:
+        cli_version: 0.24.0
+        e:
+            861cu1nqdzk82vj98my9aev6orkfaq48:
+                args:
+                    - task=eval
+                    - +agent_path=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/1.pt
+                    - problemset=extrinsic-pl
+                    - agent.max_mcts_nodes=2000
+                    - proof_search_timeout=1200
+                    - eval_num_workers=3
+                    - hydra.run.dir=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06
+                codePath: learning/proofsearch.py
+                cpu_count: 96
+                cpu_count_logical: 96
+                cudaVersion: "12.9"
+                disk:
+                    /:
+                        total: "133003395072"
+                        used: "81316069376"
+                email: leanaimsr@gmail.com
+                executable: /datadrive/ayush/home/miniconda3/envs/minimo_new/bin/python
+                git:
+                    commit: ac4e88178e931f5de8a8c54ad25492c31d8351a4
+                    remote: https://github.com/ayush1801/minimoX.git
+                gpu: NVIDIA A100 80GB PCIe
+                gpu_count: 4
+                gpu_nvidia:
+                    - architecture: Ampere
+                      cudaCores: 6912
+                      memoryTotal: "85899345920"
+                      name: NVIDIA A100 80GB PCIe
+                      uuid: GPU-76194153-5180-b45d-7661-b5c1ab4d9253
+                    - architecture: Ampere
+                      cudaCores: 6912
+                      memoryTotal: "85899345920"
+                      name: NVIDIA A100 80GB PCIe
+                      uuid: GPU-a918c9eb-4e44-bd40-312f-677864d0ec66
+                    - architecture: Ampere
+                      cudaCores: 6912
+                      memoryTotal: "85899345920"
+                      name: NVIDIA A100 80GB PCIe
+                      uuid: GPU-e18a19fc-9805-7572-3e95-b0e4d4ef1781
+                    - architecture: Ampere
+                      cudaCores: 6912
+                      memoryTotal: "85899345920"
+                      name: NVIDIA A100 80GB PCIe
+                      uuid: GPU-c9ca30c0-1398-c581-273e-c33df47e36bc
+                host: MSRI-DNN3-NEW
+                memory:
+                    total: "929976573952"
+                os: Linux-6.8.0-1044-azure-x86_64-with-glibc2.35
+                program: /datadrive/ayush/home/minimoX/learning/proofsearch.py
+                python: CPython 3.11.14
+                root: /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06
+                startedAt: "2026-03-13T01:16:09.557066Z"
+                writerId: 861cu1nqdzk82vj98my9aev6orkfaq48
+        m: []
+        python_version: 3.11.14
+        t:
+            "1":
+                - 1
+                - 11
+                - 49
+                - 50
+            "2":
+                - 1
+                - 11
+                - 49
+                - 50
+            "3":
+                - 16
+            "4": 3.11.14
+            "5": 0.24.0
+            "6": 4.57.6
+            "12": 0.24.0
+            "13": linux-x86_64
+accumulate_library:
+    value: false
+agent:
+    value:
+        curiosity:
+            type: constant
+        expansions: 50000
+        max_examples: 50
+        max_mcts_nodes: 2000
+        max_searches: 1
+        node_type: vanilla
+        policy:
+            type: Uniform
+        type: mcts
+agent_path:
+    value: /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/1.pt
+eval_num_workers:
+    value: 3
+job:
+    value:
+        cwd: /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06
+        wandb_project: peano
+max_problems:
+    value: 1000
+problemset:
+    value: extrinsic-pl
+proof_search_timeout:
+    value: 1200
+task:
+    value: eval

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/wandb/run-20260313_011609-3egbnt6l/files/output.log

@@ -0,0 +1,35 @@
+1 [('A : prop) -> ['A -> 'A]]
+2 [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> 'B] -> ['B -> 'C] -> ['A -> 'C]]
+3 [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> ['B -> 'C]] -> ['B -> ['A -> 'C]]]
+4 [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> ['B -> 'C]] -> [(and 'A 'B) -> 'C]]
+5 [('A : prop) -> ('B : prop) -> ('C : prop) -> [(and 'A 'B) -> 'C] -> ['A -> ['B -> 'C]]]
+6 [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> 'B] -> [['B -> 'C] -> ['A -> 'C]]]
+7 [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> 'B] -> [['C -> 'A] -> ['C -> 'B]]]
+8a [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> 'B] -> [(and 'A 'C) -> (and 'B 'C)]]
+8b [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> 'B] -> [(and 'C 'A) -> (and 'C 'B)]]
+9a [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> 'B] -> [(or 'A 'C) -> (or 'B 'C)]]
+9b [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> 'B] -> [(or 'A 'C) -> (or 'B 'C)]]
+10a [('A : prop) -> ('B : prop) -> [(not 'A) -> ['A -> 'B]]]
+10b [('A : prop) -> ('B : prop) -> ['A -> [(not 'A) -> 'B]]]
+11 [('A : prop) -> ('B : prop) -> ['B -> ['A -> 'B]]]
+12 [('A : prop) -> ('B : prop) -> ['A -> 'B] -> [(not 'B) -> (not 'A)]]
+13 [('A : prop) -> ('B : prop) -> ['A -> (not 'B)] -> ['B -> (not 'A)]]
+14 [('A : prop) -> ('B : prop) -> [(not 'A) -> 'B] -> [(not 'B) -> 'A]]
+15 [('A : prop) -> ('B : prop) -> [(not 'A) -> (not 'B)] -> ['B -> 'A]]
+16 [('A : prop) -> ('B : prop) -> ['A -> 'B] -> ['B -> 'A] -> (iff 'A 'B)]
+17a [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> ['A -> 'B]]
+17b [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> ['B -> 'A]]
+18a [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> 'A -> 'B]
+18b [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> 'B -> 'A]
+19 [('A : prop) -> (iff 'A 'A)]
+20 [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> (iff 'B 'A)]
+21 [('A : prop) -> ('B : prop) -> ('C : prop) -> (iff 'A 'B) -> (iff 'B 'C) -> (iff 'A 'C)]
+22 [('A : prop) -> ('B : prop) -> ('C : prop) -> ['A -> ['B -> 'C]] -> [(not (not 'A)) -> [(not (not 'B)) -> (not (not 'C))]]]
+23 [('A : prop) -> ('B : prop) -> [(not (not ['A -> 'B]))] -> [(not (not 'A)) -> (not (not 'B))]]
+24 [('A : prop) -> ('B : prop) -> ('C : prop) -> [(not (not ['A -> 'B]))] -> [(not (not ['B -> 'C]))] -> [(not (not ['A -> 'C]))]]
+25 [('A : prop) -> ('B : prop) -> (iff (not (not (and 'A 'B))) (and (not (not 'A)) (not (not 'B))))]
+Proof search timeout: 1200s per problem
+Parallel eval: 3 workers
+Eval: 100%|███████████████████████| 30/30 [08:10<00:00, 16.35s/it]
+Solved 21/30
+Solved problems: extrinsic_11, extrinsic_1, extrinsic_6, extrinsic_8a, extrinsic_19, extrinsic_3, extrinsic_17b, extrinsic_7, extrinsic_10a, extrinsic_10b, extrinsic_4, extrinsic_13, extrinsic_5, extrinsic_16, extrinsic_20, extrinsic_17a, extrinsic_2, extrinsic_18b, extrinsic_18a, extrinsic_12, extrinsic_8b

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/wandb/run-20260313_011609-3egbnt6l/files/requirements.txt

@@ -0,0 +1,118 @@
+setuptools==80.9.0
+wheel==0.45.1
+pip==25.3
+maturin==1.11.5
+peano==0.1.0
+pytz==2025.2
+nvidia-cusparselt-cu12==0.7.1
+mpmath==1.3.0
+bottle==0.13.4
+antlr4-python3-runtime==4.9.3
+wcwidth==0.2.14
+vine==5.1.0
+urllib3==2.6.3
+tzlocal==5.3.1
+tzdata==2025.3
+typing_extensions==4.15.0
+triton==3.5.1
+tqdm==4.67.1
+sympy==1.14.0
+smmap==5.0.2
+six==1.17.0
+safetensors==0.7.0
+rpds-py==0.30.0
+regex==2026.1.15
+redis==7.1.0
+PyYAML==6.0.3
+protobuf==6.33.4
+platformdirs==4.5.1
+packaging==25.0
+nvidia-nvtx-cu12==12.8.90
+nvidia-nvshmem-cu12==3.3.20
+nvidia-nvjitlink-cu12==12.8.93
+nvidia-nccl-cu12==2.27.5
+nvidia-curand-cu12==10.3.9.90
+nvidia-cufile-cu12==1.13.1.3
+nvidia-cuda-runtime-cu12==12.8.90
+nvidia-cuda-nvrtc-cu12==12.8.93
+nvidia-cuda-cupti-cu12==12.8.90
+nvidia-cublas-cu12==12.8.4.1
+numpy==2.4.1
+networkx==3.6.1
+narwhals==2.15.0
+MarkupSafe==3.0.3
+idna==3.11
+hf-xet==1.2.0
+fsspec==2026.1.0
+filelock==3.20.3
+coloraide==7.0
+click==8.3.1
+charset-normalizer==3.4.4
+certifi==2026.1.4
+billiard==4.2.4
+attrs==25.4.0
+annotated-types==0.7.0
+typing-inspection==0.4.2
+sentry-sdk==2.49.0
+requests==2.32.5
+referencing==0.37.0
+python-dateutil==2.9.0.post0
+pydantic_core==2.41.5
+prompt_toolkit==3.0.52
+omegaconf==2.3.0
+nvidia-cusparse-cu12==12.5.8.93
+nvidia-cufft-cu12==11.3.3.83
+nvidia-cudnn-cu12==9.10.2.21
+Jinja2==3.1.6
+gitdb==4.0.12
+click-plugins==1.1.1.2
+click-didyoumean==0.3.1
+amqp==5.3.1
+pydantic==2.12.5
+nvidia-cusolver-cu12==11.7.3.90
+kombu==5.6.2
+jsonschema-specifications==2025.9.1
+hydra-core==1.3.2
+huggingface-hub==0.36.0
+GitPython==3.1.46
+croniter==6.0.0
+click-repl==0.3.0
+wandb==0.24.0
+torch==2.9.1
+tokenizers==0.22.2
+rq==2.6.1
+jsonschema==4.26.0
+celery==5.6.2
+transformers==4.57.6
+altair==6.0.0
+debugpy==1.8.19
+psutil==7.2.1
+pyzmq==27.1.0
+tornado==6.5.4
+asttokens==3.0.1
+comm==0.2.3
+decorator==5.2.1
+executing==2.2.1
+nest_asyncio==1.6.0
+parso==0.8.5
+jedi==0.19.2
+ptyprocess==0.7.0
+pexpect==4.9.0
+pure_eval==0.2.3
+Pygments==2.19.2
+ipython_pygments_lexers==1.1.1
+stack_data==0.6.3
+traitlets==5.14.3
+matplotlib-inline==0.2.1
+jupyter_core==5.9.1
+ipython==9.9.0
+jupyter_client==8.8.0
+ipykernel==7.1.0
+pyparsing==3.3.2
+pillow==12.1.0
+kiwisolver==1.4.9
+fonttools==4.61.1
+cycler==0.12.1
+contourpy==1.3.3
+matplotlib==3.10.8
+z3-solver==4.15.7.0

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/wandb/run-20260313_011609-3egbnt6l/files/wandb-metadata.json

@@ -0,0 +1,69 @@
+{
+  "os": "Linux-6.8.0-1044-azure-x86_64-with-glibc2.35",
+  "python": "CPython 3.11.14",
+  "startedAt": "2026-03-13T01:16:09.557066Z",
+  "args": [
+    "task=eval",
+    "+agent_path=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/1.pt",
+    "problemset=extrinsic-pl",
+    "agent.max_mcts_nodes=2000",
+    "proof_search_timeout=1200",
+    "eval_num_workers=3",
+    "hydra.run.dir=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06"
+  ],
+  "program": "/datadrive/ayush/home/minimoX/learning/proofsearch.py",
+  "codePath": "learning/proofsearch.py",
+  "git": {
+    "remote": "https://github.com/ayush1801/minimoX.git",
+    "commit": "ac4e88178e931f5de8a8c54ad25492c31d8351a4"
+  },
+  "email": "leanaimsr@gmail.com",
+  "root": "/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06",
+  "host": "MSRI-DNN3-NEW",
+  "executable": "/datadrive/ayush/home/miniconda3/envs/minimo_new/bin/python",
+  "cpu_count": 96,
+  "cpu_count_logical": 96,
+  "gpu": "NVIDIA A100 80GB PCIe",
+  "gpu_count": 4,
+  "disk": {
+    "/": {
+      "total": "133003395072",
+      "used": "81316069376"
+    }
+  },
+  "memory": {
+    "total": "929976573952"
+  },
+  "gpu_nvidia": [
+    {
+      "name": "NVIDIA A100 80GB PCIe",
+      "memoryTotal": "85899345920",
+      "cudaCores": 6912,
+      "architecture": "Ampere",
+      "uuid": "GPU-76194153-5180-b45d-7661-b5c1ab4d9253"
+    },
+    {
+      "name": "NVIDIA A100 80GB PCIe",
+      "memoryTotal": "85899345920",
+      "cudaCores": 6912,
+      "architecture": "Ampere",
+      "uuid": "GPU-a918c9eb-4e44-bd40-312f-677864d0ec66"
+    },
+    {
+      "name": "NVIDIA A100 80GB PCIe",
+      "memoryTotal": "85899345920",
+      "cudaCores": 6912,
+      "architecture": "Ampere",
+      "uuid": "GPU-e18a19fc-9805-7572-3e95-b0e4d4ef1781"
+    },
+    {
+      "name": "NVIDIA A100 80GB PCIe",
+      "memoryTotal": "85899345920",
+      "cudaCores": 6912,
+      "architecture": "Ampere",
+      "uuid": "GPU-c9ca30c0-1398-c581-273e-c33df47e36bc"
+    }
+  ],
+  "cudaVersion": "12.9",
+  "writerId": "861cu1nqdzk82vj98my9aev6orkfaq48"
+}

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/wandb/run-20260313_011609-3egbnt6l/files/wandb-summary.json

@@ -0,0 +1 @@
+{"_wandb":{"runtime":492},"_runtime":492}

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/wandb/run-20260313_011609-3egbnt6l/logs/debug-core.log

@@ -0,0 +1,14 @@
+{"time":"2026-03-13T01:16:09.593931934Z","level":"INFO","msg":"main: starting server","port-filename":"/tmp/tmpd9fsvhvv/port-494704.txt","pid":494704,"log-level":0,"disable-analytics":false,"shutdown-on-parent-exit":false,"enable-dcgm-profiling":false}
+{"time":"2026-03-13T01:16:09.59469141Z","level":"INFO","msg":"server: will exit if parent process dies","ppid":494704}
+{"time":"2026-03-13T01:16:09.594646101Z","level":"INFO","msg":"server: accepting connections","addr":{"Name":"/tmp/wandb-494704-494847-2830316773/socket","Net":"unix"}}
+{"time":"2026-03-13T01:16:09.778953644Z","level":"INFO","msg":"connection: ManageConnectionData: new connection created","id":"1(@)"}
+{"time":"2026-03-13T01:16:09.784970372Z","level":"INFO","msg":"handleInformInit: received","streamId":"3egbnt6l","id":"1(@)"}
+{"time":"2026-03-13T01:16:10.077315632Z","level":"INFO","msg":"handleInformInit: stream started","streamId":"3egbnt6l","id":"1(@)"}
+{"time":"2026-03-13T01:24:23.279906636Z","level":"INFO","msg":"handleInformTeardown: server teardown initiated","id":"1(@)"}
+{"time":"2026-03-13T01:24:23.280135699Z","level":"INFO","msg":"connection: closing","id":"1(@)"}
+{"time":"2026-03-13T01:24:23.280156438Z","level":"INFO","msg":"server is shutting down"}
+{"time":"2026-03-13T01:24:23.280192726Z","level":"INFO","msg":"connection: closed successfully","id":"1(@)"}
+{"time":"2026-03-13T01:24:23.280327517Z","level":"INFO","msg":"server: listener closed","addr":{"Name":"/tmp/wandb-494704-494847-2830316773/socket","Net":"unix"}}
+{"time":"2026-03-13T01:24:23.815883098Z","level":"INFO","msg":"handleInformTeardown: server shutdown complete","id":"1(@)"}
+{"time":"2026-03-13T01:24:23.815906572Z","level":"INFO","msg":"connection: ManageConnectionData: connection closed","id":"1(@)"}
+{"time":"2026-03-13T01:24:23.815915098Z","level":"INFO","msg":"server is closed"}

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/wandb/run-20260313_011609-3egbnt6l/logs/debug-internal.log

@@ -0,0 +1,13 @@
+{"time":"2026-03-13T01:16:09.785083032Z","level":"INFO","msg":"stream: starting","core version":"0.24.0"}
+{"time":"2026-03-13T01:16:10.076942766Z","level":"INFO","msg":"stream: created new stream","id":"3egbnt6l"}
+{"time":"2026-03-13T01:16:10.077089199Z","level":"INFO","msg":"handler: started","stream_id":"3egbnt6l"}
+{"time":"2026-03-13T01:16:10.077302187Z","level":"INFO","msg":"stream: started","id":"3egbnt6l"}
+{"time":"2026-03-13T01:16:10.077344416Z","level":"INFO","msg":"writer: started","stream_id":"3egbnt6l"}
+{"time":"2026-03-13T01:16:10.07739266Z","level":"INFO","msg":"sender: started","stream_id":"3egbnt6l"}
+{"time":"2026-03-13T01:16:11.071544487Z","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":82}
+{"time":"2026-03-13T01:16:11.075460643Z","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":48}
+{"time":"2026-03-13T01:24:23.280094998Z","level":"INFO","msg":"stream: closing","id":"3egbnt6l"}
+{"time":"2026-03-13T01:24:23.6285521Z","level":"INFO","msg":"fileTransfer: Close: file transfer manager closed"}
+{"time":"2026-03-13T01:24:23.812323995Z","level":"INFO","msg":"handler: closed","stream_id":"3egbnt6l"}
+{"time":"2026-03-13T01:24:23.812511385Z","level":"INFO","msg":"sender: closed","stream_id":"3egbnt6l"}
+{"time":"2026-03-13T01:24:23.812527465Z","level":"INFO","msg":"stream: closed","id":"3egbnt6l"}

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/wandb/run-20260313_011609-3egbnt6l/logs/debug.log

@@ -0,0 +1,19 @@
+2026-03-13 01:16:09,558 INFO    MainThread:494704 [wandb_setup.py:_flush():81] Current SDK version is 0.24.0
+2026-03-13 01:16:09,558 INFO    MainThread:494704 [wandb_setup.py:_flush():81] Configure stats pid to 494704
+2026-03-13 01:16:09,558 INFO    MainThread:494704 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2026-03-13 01:16:09,559 INFO    MainThread:494704 [wandb_init.py:setup_run_log_directory():717] Logging user logs to /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/wandb/run-20260313_011609-3egbnt6l/logs/debug.log
+2026-03-13 01:16:09,559 INFO    MainThread:494704 [wandb_init.py:setup_run_log_directory():718] Logging internal logs to /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06/wandb/run-20260313_011609-3egbnt6l/logs/debug-internal.log
+2026-03-13 01:16:09,559 INFO    MainThread:494704 [wandb_init.py:init():844] calling init triggers
+2026-03-13 01:16:09,559 INFO    MainThread:494704 [wandb_init.py:init():849] wandb.init called with sweep_config: {}
+config: {'task': 'eval', 'problemset': 'extrinsic-pl', 'max_problems': 1000, 'accumulate_library': False, 'proof_search_timeout': 1200, 'eval_num_workers': 3, 'agent': {'max_mcts_nodes': 2000, 'type': 'mcts', 'node_type': 'vanilla', 'expansions': 50000, 'max_searches': 1, 'max_examples': 50, 'policy': {'type': 'Uniform'}, 'curiosity': {'type': 'constant'}}, 'job': {'wandb_project': 'peano', 'cwd': '/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-06'}, 'agent_path': '/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/1.pt', '_wandb': {}}
+2026-03-13 01:16:09,559 INFO    MainThread:494704 [wandb_init.py:init():892] starting backend
+2026-03-13 01:16:09,779 INFO    MainThread:494704 [wandb_init.py:init():895] sending inform_init request
+2026-03-13 01:16:09,783 INFO    MainThread:494704 [wandb_init.py:init():903] backend started and connected
+2026-03-13 01:16:09,784 INFO    MainThread:494704 [wandb_init.py:init():973] updated telemetry
+2026-03-13 01:16:09,789 INFO    MainThread:494704 [wandb_init.py:init():997] communicating run to backend with 90.0 second timeout
+2026-03-13 01:16:10,993 INFO    MainThread:494704 [wandb_init.py:init():1044] starting run threads in backend
+2026-03-13 01:16:11,054 INFO    MainThread:494704 [wandb_run.py:_console_start():2529] atexit reg
+2026-03-13 01:16:11,054 INFO    MainThread:494704 [wandb_run.py:_redirect():2377] redirect: wrap_raw
+2026-03-13 01:16:11,054 INFO    MainThread:494704 [wandb_run.py:_redirect():2446] Wrapping output streams.
+2026-03-13 01:16:11,054 INFO    MainThread:494704 [wandb_run.py:_redirect():2469] Redirects installed.
+2026-03-13 01:16:11,058 INFO    MainThread:494704 [wandb_init.py:init():1084] run started, returning control to user process

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57/.hydra/config.yaml

@@ -0,0 +1,20 @@
+task: eval
+problemset: extrinsic-pl
+max_problems: 1000
+accumulate_library: false
+proof_search_timeout: 1200
+eval_num_workers: 3
+agent:
+  max_mcts_nodes: 2000
+  type: mcts
+  node_type: vanilla
+  expansions: 50000
+  max_searches: 1
+  max_examples: 50
+  policy:
+    type: Uniform
+  curiosity:
+    type: constant
+job:
+  wandb_project: peano
+agent_path: /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/0.pt

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57/.hydra/hydra.yaml

@@ -0,0 +1,163 @@
+hydra:
+  run:
+    dir: /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57
+  sweep:
+    dir: multirun/${now:%Y-%m-%d}/${now:%H-%M-%S}
+    subdir: ${hydra.job.num}
+  launcher:
+    _target_: hydra._internal.core_plugins.basic_launcher.BasicLauncher
+  sweeper:
+    _target_: hydra._internal.core_plugins.basic_sweeper.BasicSweeper
+    max_batch_size: null
+    params: null
+  help:
+    app_name: ${hydra.job.name}
+    header: '${hydra.help.app_name} is powered by Hydra.
+
+      '
+    footer: 'Powered by Hydra (https://hydra.cc)
+
+      Use --hydra-help to view Hydra specific help
+
+      '
+    template: '${hydra.help.header}
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (group=option)
+
+
+      $APP_CONFIG_GROUPS
+
+
+      == Config ==
+
+      Override anything in the config (foo.bar=value)
+
+
+      $CONFIG
+
+
+      ${hydra.help.footer}
+
+      '
+  hydra_help:
+    template: 'Hydra (${hydra.runtime.version})
+
+      See https://hydra.cc for more info.
+
+
+      == Flags ==
+
+      $FLAGS_HELP
+
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (For example, append hydra/job_logging=disabled
+      to command line)
+
+
+      $HYDRA_CONFIG_GROUPS
+
+
+      Use ''--cfg hydra'' to Show the Hydra config.
+
+      '
+    hydra_help: ???
+  hydra_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][HYDRA] %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+    root:
+      level: INFO
+      handlers:
+      - console
+    loggers:
+      logging_example:
+        level: DEBUG
+    disable_existing_loggers: false
+  job_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][%(name)s][%(levelname)s] - %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+      file:
+        class: logging.FileHandler
+        formatter: simple
+        filename: ${hydra.runtime.output_dir}/${hydra.job.name}.log
+    root:
+      level: INFO
+      handlers:
+      - console
+      - file
+    disable_existing_loggers: false
+  env: {}
+  mode: RUN
+  searchpath: []
+  callbacks: {}
+  output_subdir: .hydra
+  overrides:
+    hydra:
+    - hydra.run.dir=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57
+    - hydra.mode=RUN
+    task:
+    - task=eval
+    - +agent_path=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/0.pt
+    - problemset=extrinsic-pl
+    - agent.max_mcts_nodes=2000
+    - proof_search_timeout=1200
+    - eval_num_workers=3
+  job:
+    name: proofsearch
+    chdir: true
+    override_dirname: +agent_path=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/0.pt,agent.max_mcts_nodes=2000,eval_num_workers=3,problemset=extrinsic-pl,proof_search_timeout=1200,task=eval
+    id: ???
+    num: ???
+    config_name: proofsearch
+    env_set: {}
+    env_copy: []
+    config:
+      override_dirname:
+        kv_sep: '='
+        item_sep: ','
+        exclude_keys: []
+  runtime:
+    version: 1.3.2
+    version_base: '1.2'
+    cwd: /datadrive/ayush/home/minimoX/learning
+    config_sources:
+    - path: hydra.conf
+      schema: pkg
+      provider: hydra
+    - path: /datadrive/ayush/home/minimoX/learning/config
+      schema: file
+      provider: main
+    - path: ''
+      schema: structured
+      provider: schema
+    output_dir: /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57
+    choices:
+      agent: mcts
+      agent/curiosity: constant
+      hydra/env: default
+      hydra/callbacks: null
+      hydra/job_logging: default
+      hydra/hydra_logging: default
+      hydra/hydra_help: default
+      hydra/help: default
+      hydra/sweeper: basic
+      hydra/launcher: basic
+      hydra/output: default
+  verbose: false

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57/.hydra/overrides.yaml

@@ -0,0 +1,6 @@
+- task=eval
+- +agent_path=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/0.pt
+- problemset=extrinsic-pl
+- agent.max_mcts_nodes=2000
+- proof_search_timeout=1200
+- eval_num_workers=3

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57/0_pt_proved_results.json

@@ -0,0 +1,49 @@
+{
+  "results": [
+    {
+      "problem": "extrinsic_1",
+      "proof": "theorem t : [('A : prop) -> ['A -> 'A]] {\n    intro x : prop.\n    intro _ : [x -> x].\n}"
+    },
+    {
+      "problem": "extrinsic_10a",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> [(not 'A) -> ['A -> 'B]]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : (not x).\n    intro x2 : x.\n    show false by not_e.\n    apply exfalso.\n}"
+    },
+    {
+      "problem": "extrinsic_11",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ['B -> ['A -> 'B]]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : x0.\n    intro _ : [x -> x0].\n}"
+    },
+    {
+      "problem": "extrinsic_10b",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ['A -> [(not 'A) -> 'B]]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : x.\n    intro x2 : (not x).\n    show false by not_e.\n    apply exfalso.\n}"
+    },
+    {
+      "problem": "extrinsic_16",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> ['A -> 'B] -> ['B -> 'A] -> (iff 'A 'B)] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : [x -> x0].\n    intro x2 : [x0 -> x].\n    apply iff_i.\n}"
+    },
+    {
+      "problem": "extrinsic_17a",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> ['A -> 'B]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : (iff x x0).\n    show [x -> x0] by iff_el.\n}"
+    },
+    {
+      "problem": "extrinsic_17b",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> ['B -> 'A]] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : (iff x x0).\n    show [x0 -> x] by iff_er.\n}"
+    },
+    {
+      "problem": "extrinsic_18a",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> 'A -> 'B] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : (iff x x0).\n    show [x -> x0] by iff_el.\n}"
+    },
+    {
+      "problem": "extrinsic_18b",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> 'B -> 'A] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : (iff x x0).\n    show [x0 -> x] by iff_er.\n}"
+    },
+    {
+      "problem": "extrinsic_19",
+      "proof": "theorem t : [('A : prop) -> (iff 'A 'A)] {\n    intro x : prop.\n    apply iff_i.\n    goal [x -> x] {\n        intro _ : [x -> x].\n    }\n    goal [x -> x] {\n        intro _ : [x -> x].\n    }\n}"
+    },
+    {
+      "problem": "extrinsic_20",
+      "proof": "theorem t : [('A : prop) -> ('B : prop) -> (iff 'A 'B) -> (iff 'B 'A)] {\n    intro x : prop.\n    intro x0 : prop.\n    intro x1 : (iff x x0).\n    apply iff_i.\n    goal [x0 -> x] {\n        show [x0 -> x] by iff_er.\n    }\n    goal [x -> x0] {\n        show [x -> x0] by iff_el.\n    }\n}"
+    }
+  ],
+  "num_proved": 11
+}

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57/wandb/debug-internal.log

@@ -0,0 +1,11 @@
+{"time":"2026-03-13T01:17:01.316487938Z","level":"INFO","msg":"stream: starting","core version":"0.24.0"}
+{"time":"2026-03-13T01:17:01.626260827Z","level":"INFO","msg":"stream: created new stream","id":"5a8bpycd"}
+{"time":"2026-03-13T01:17:01.626453311Z","level":"INFO","msg":"handler: started","stream_id":"5a8bpycd"}
+{"time":"2026-03-13T01:17:01.626716648Z","level":"INFO","msg":"stream: started","id":"5a8bpycd"}
+{"time":"2026-03-13T01:17:01.62679041Z","level":"INFO","msg":"writer: started","stream_id":"5a8bpycd"}
+{"time":"2026-03-13T01:17:01.626838986Z","level":"INFO","msg":"sender: started","stream_id":"5a8bpycd"}
+{"time":"2026-03-13T01:32:27.20868956Z","level":"INFO","msg":"stream: closing","id":"5a8bpycd"}
+{"time":"2026-03-13T01:32:27.646647624Z","level":"INFO","msg":"fileTransfer: Close: file transfer manager closed"}
+{"time":"2026-03-13T01:32:29.975084715Z","level":"INFO","msg":"handler: closed","stream_id":"5a8bpycd"}
+{"time":"2026-03-13T01:32:29.975358015Z","level":"INFO","msg":"sender: closed","stream_id":"5a8bpycd"}
+{"time":"2026-03-13T01:32:29.975374896Z","level":"INFO","msg":"stream: closed","id":"5a8bpycd"}

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57/wandb/debug.log

@@ -0,0 +1,19 @@
+2026-03-13 01:17:01,089 INFO    MainThread:496326 [wandb_setup.py:_flush():81] Current SDK version is 0.24.0
+2026-03-13 01:17:01,089 INFO    MainThread:496326 [wandb_setup.py:_flush():81] Configure stats pid to 496326
+2026-03-13 01:17:01,089 INFO    MainThread:496326 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2026-03-13 01:17:01,089 INFO    MainThread:496326 [wandb_init.py:setup_run_log_directory():717] Logging user logs to /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57/wandb/run-20260313_011701-5a8bpycd/logs/debug.log
+2026-03-13 01:17:01,089 INFO    MainThread:496326 [wandb_init.py:setup_run_log_directory():718] Logging internal logs to /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57/wandb/run-20260313_011701-5a8bpycd/logs/debug-internal.log
+2026-03-13 01:17:01,089 INFO    MainThread:496326 [wandb_init.py:init():844] calling init triggers
+2026-03-13 01:17:01,089 INFO    MainThread:496326 [wandb_init.py:init():849] wandb.init called with sweep_config: {}
+config: {'task': 'eval', 'problemset': 'extrinsic-pl', 'max_problems': 1000, 'accumulate_library': False, 'proof_search_timeout': 1200, 'eval_num_workers': 3, 'agent': {'max_mcts_nodes': 2000, 'type': 'mcts', 'node_type': 'vanilla', 'expansions': 50000, 'max_searches': 1, 'max_examples': 50, 'policy': {'type': 'Uniform'}, 'curiosity': {'type': 'constant'}}, 'job': {'wandb_project': 'peano', 'cwd': '/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57'}, 'agent_path': '/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/0.pt', '_wandb': {}}
+2026-03-13 01:17:01,089 INFO    MainThread:496326 [wandb_init.py:init():892] starting backend
+2026-03-13 01:17:01,308 INFO    MainThread:496326 [wandb_init.py:init():895] sending inform_init request
+2026-03-13 01:17:01,313 INFO    MainThread:496326 [wandb_init.py:init():903] backend started and connected
+2026-03-13 01:17:01,315 INFO    MainThread:496326 [wandb_init.py:init():973] updated telemetry
+2026-03-13 01:17:01,320 INFO    MainThread:496326 [wandb_init.py:init():997] communicating run to backend with 90.0 second timeout
+2026-03-13 01:17:02,105 INFO    MainThread:496326 [wandb_init.py:init():1044] starting run threads in backend
+2026-03-13 01:17:02,170 INFO    MainThread:496326 [wandb_run.py:_console_start():2529] atexit reg
+2026-03-13 01:17:02,170 INFO    MainThread:496326 [wandb_run.py:_redirect():2377] redirect: wrap_raw
+2026-03-13 01:17:02,170 INFO    MainThread:496326 [wandb_run.py:_redirect():2446] Wrapping output streams.
+2026-03-13 01:17:02,170 INFO    MainThread:496326 [wandb_run.py:_redirect():2469] Redirects installed.
+2026-03-13 01:17:02,174 INFO    MainThread:496326 [wandb_init.py:init():1084] run started, returning control to user process

experiments/learnability/checkpoints/dnn3_bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57/wandb/run-20260313_011701-5a8bpycd/files/config.yaml

@@ -0,0 +1,108 @@
+_wandb:
+    value:
+        cli_version: 0.24.0
+        e:
+            7wilk39x9pkpjprvzodsvy8w5k24e2gu:
+                args:
+                    - task=eval
+                    - +agent_path=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/0.pt
+                    - problemset=extrinsic-pl
+                    - agent.max_mcts_nodes=2000
+                    - proof_search_timeout=1200
+                    - eval_num_workers=3
+                    - hydra.run.dir=/datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57
+                codePath: learning/proofsearch.py
+                cpu_count: 96
+                cpu_count_logical: 96
+                cudaVersion: "12.9"
+                disk:
+                    /:
+                        total: "133003395072"
+                        used: "81316208640"
+                email: leanaimsr@gmail.com
+                executable: /datadrive/ayush/home/miniconda3/envs/minimo_new/bin/python
+                git:
+                    commit: ac4e88178e931f5de8a8c54ad25492c31d8351a4
+                    remote: https://github.com/ayush1801/minimoX.git
+                gpu: NVIDIA A100 80GB PCIe
+                gpu_count: 4
+                gpu_nvidia:
+                    - architecture: Ampere
+                      cudaCores: 6912
+                      memoryTotal: "85899345920"
+                      name: NVIDIA A100 80GB PCIe
+                      uuid: GPU-76194153-5180-b45d-7661-b5c1ab4d9253
+                    - architecture: Ampere
+                      cudaCores: 6912
+                      memoryTotal: "85899345920"
+                      name: NVIDIA A100 80GB PCIe
+                      uuid: GPU-a918c9eb-4e44-bd40-312f-677864d0ec66
+                    - architecture: Ampere
+                      cudaCores: 6912
+                      memoryTotal: "85899345920"
+                      name: NVIDIA A100 80GB PCIe
+                      uuid: GPU-e18a19fc-9805-7572-3e95-b0e4d4ef1781
+                    - architecture: Ampere
+                      cudaCores: 6912
+                      memoryTotal: "85899345920"
+                      name: NVIDIA A100 80GB PCIe
+                      uuid: GPU-c9ca30c0-1398-c581-273e-c33df47e36bc
+                host: MSRI-DNN3-NEW
+                memory:
+                    total: "929976573952"
+                os: Linux-6.8.0-1044-azure-x86_64-with-glibc2.35
+                program: /datadrive/ayush/home/minimoX/learning/proofsearch.py
+                python: CPython 3.11.14
+                root: /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57
+                startedAt: "2026-03-13T01:17:01.087744Z"
+                writerId: 7wilk39x9pkpjprvzodsvy8w5k24e2gu
+        m: []
+        python_version: 3.11.14
+        t:
+            "1":
+                - 1
+                - 11
+                - 49
+                - 50
+            "2":
+                - 1
+                - 11
+                - 49
+                - 50
+            "3":
+                - 16
+            "4": 3.11.14
+            "5": 0.24.0
+            "6": 4.57.6
+            "12": 0.24.0
+            "13": linux-x86_64
+accumulate_library:
+    value: false
+agent:
+    value:
+        curiosity:
+            type: constant
+        expansions: 50000
+        max_examples: 50
+        max_mcts_nodes: 2000
+        max_searches: 1
+        node_type: vanilla
+        policy:
+            type: Uniform
+        type: mcts
+agent_path:
+    value: /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/0.pt
+eval_num_workers:
+    value: 3
+job:
+    value:
+        cwd: /datadrive/ayush/home/minimoX/learning/outputs/bootstrap_bs_800_para/2026-03-12_23-41-21/eval_para_2026-03-13_01-16-57
+        wandb_project: peano
+max_problems:
+    value: 1000
+problemset:
+    value: extrinsic-pl
+proof_search_timeout:
+    value: 1200
+task:
+    value: eval