# Data Everything the paper's MCTS searches, routers and fixed programs produced. For each DART-Math question: every program-of-layers a search evaluated with its verdict, the model's generated answer behind each verdict, the trained routers with their test results, the fixed program per level, and the menu cross-execution of Finding 5. The data comes in three groups: the main track, Li et al.'s setup on the PoLar split, and the cross-checks between the two. The small id files below are in this repository; everything else (about 6 GB) is hosted as the Hugging Face dataset [`SWAMBIT/re-polar`](https://huggingface.co/datasets/SWAMBIT/re-polar) and downloads into `data/` (all of it, or only the parts you need): ```bash pip install -U huggingface_hub hf download SWAMBIT/re-polar --repo-type dataset --local-dir data hf download SWAMBIT/re-polar --repo-type dataset --local-dir data --include "router_results/*" "fixed_program/*" ``` ``` data/ dart_math_splits.json our split: query_ids per level and train/val/test polar_split_ids.json Li et al.'s split: query_ids per level (pool, train/val/test) sample_qwen3_8b_dart_math_diff1.json 5 records of one MCTS file, to see the shape # main track: our split, our search, oneshot prompt (paper Sections 3-4) mcts_results//seed/dart-math-diff-/merged_mcts_samples.json.gz generated_answers//seed/diff.jsonl.gz router_checkpoints//seed/diff.pt router_results//seed/diff.json fixed_program//seed/diff.json menu_crossexec//diff.json.gz (seed 42, in-sample) menu_crossexec_heldout//diff.json.gz (seed 42, held-out) # PoLar split: Li et al.'s search, prompts and questions (paper Appendix B) polar_split/mcts_results///seed/dart-math-diff-/merged_mcts_samples.json.gz polar_split/generated_answers///seed/diff.jsonl.gz polar_split/router_results///seed/diff/{fold0..fold3,split}.json polar_split/fixed_program///seed/diff/fold{0..3}.json polar_split/router_checkpoints///seed/diff.pt (trained on `split`) polar_split/ood//{router.pt, router_asdiv_mawps.json, fixed_program.json, router_and_fixed_mmlu_pro.json} # cross-checks (paper Appendix B.4) cross_checks/their_search_our_split/{mcts_results,generated_answers,router_results,fixed_program}///... cross_checks/our_search_polar_split/{mcts_results,router_results,fixed_program}/qwen3_8b//... ``` - ``: `qwen15_moe_a27b`, `qwen25_3b`, `qwen25_7b`, `qwen3_8b`, `qwen3_32b`, `llama32_3b` (main track); `qwen15_moe_a27b`, `qwen25_3b`, `qwen3_8b`, `llama32_3b` (PoLar split). ``: search seed `42`, `1`, `7`. ``: difficulty level 1-5. - ``: `polar_default` (Li et al.'s prompt, code key `raw`) or `oneshot` (ours, one `1+1` demo, code key `paper_minimal_fewshot`). The main track uses `oneshot` throughout. - Search configuration: main track = `run_search_dart_math` defaults (`--split all`); PoLar split = `--polar-fidelity --split train` on the level's whole question pool; their search on our split = `--polar-fidelity --split trainval`; our search on the PoLar split = `--polar-fidelity --widening-search`. - Batch shape (it only bounds memory, but batched bf16 decoding is not bit-identical across shapes, so an exact rerun needs the same values): `--masked-batch-buckets` 8, except DM-5 of LLaMA-3.2-3B (all seeds) and of Qwen3-32B (seeds 1 and 7), 16; each generated-answer row's `batch_size` records the bucket it was decoded in. `--masked-batch-max-group-size` of the seed-1/7 runs: 192 for Qwen2.5-3B/7B, 64 for Qwen1.5-MoE and LLaMA-3.2-3B, 128 for Qwen3-32B (DM-5: 64), 768 for Qwen3-8B; PoLar split: 64. Qwen3-8B seed 42 of the main track ran without the KV cache (`--no-masked-batch-kv`); every other run used it. - Software: torch 2.11.0 (CUDA 12.8), flash-attn 2.8.3, transformers 5.12.1 and 5.17.0 for the searches, 5.17.0 for routers, fixed programs and baselines (`requirements.txt` pins it). Runs used A100, H100, H200 and B200 GPUs; greedy decoding differs slightly across architectures, so an exact rerun needs the same one. Router and menu result files name it in `checkpoint` / `gpu_arch`. - Not available: answer texts for Qwen3-8B with `polar_default` (all seeds) and for our search on the PoLar split; those runs did not log answers. Their programs and router results are released. ## Getting the questions Question text and reference answers aren't stored in any file here. The MATH half of DART-Math traces back to `hendrycks/competition_math`, which is no longer distributed (paper Appendix A.1), so we release scripts that rebuild both splits from the public DART-Math pool instead: ```bash python -m re_polar.datasets.dart_math --out-dir ./data/dart_math --include-gsm8k python -m re_polar.datasets.polar_split --out-dir ./data/polar_split_questions ``` `dart_math` writes `diff{1..5}/{train,val,test}.json` (1250/250/500 questions each) plus a `manifest.json`. Each record: | field | type | meaning | |---|---|---| | `query_id` | str | stable id, the join key into every file below | | `question` | str | the input question text | | `gt_ans` | str | ground-truth answer | | `domain` | str | math subject area | | `math_level` | int or null | MATH's own difficulty level (1-5); `null` for GSM8K questions, which don't have one | | `source` | str | `"math"` or `"gsm8k"` | | `fail_rate` | float | DART-Math's own per-query fail rate, used to bin questions into difficulty 1 (easiest) through 5 (hardest) | | `tot_n_samples` | int | how many responses DART-Math sampled to compute `fail_rate` | | `difficulty` | int | 1-5, the difficulty tier this record was binned into | `polar_split` writes `pool/diff{1..5}/train.json` (every question of the level, 565 / 1349 / 1579 / 1537 / 1577, MATH only; the search input) and `split/diff{1..5}/{train,val, test}.json` (Li et al.'s inferred train/val/test cut, test 141 / 337 / 395 / 384 / 394), same record fields. The router's 4-fold cross-validation over the pool is `re_polar.router.fold_data.fold_qids(pool_query_ids, fold)`. `dart_math_splits.json` and `polar_split_ids.json` record the same membership as plain `query_id` lists, to check a rebuild without the question text. ## MCTS results (`mcts_results/`, `polar_split/mcts_results/`, `cross_checks/*/mcts_results/`) For every question, every distinct program-of-layers the search evaluated, and whether it answered correctly. This is what the routers and fixed programs are trained on. One file per (model, [prompt,] seed, level): 2000 questions on our split, in the order train (1250), val (250), test (500); the level's whole pool on the PoLar split. Format: ```json {"samples": [ { ... one record per question ... } ]} ``` Each record: | field | type | meaning | |---|---|---| | `final_valid_transitions` | list of int-lists | every distinct **layer path** the search found that reaches the correct answer | | `final_invalid_transitions` | list of int-lists | every distinct layer path the search tried that did *not* reach the correct answer | | `initial_transition_metric` | float | reward of the identity program (all layers kept, in order); `0.0` means the model gets this question wrong even with no layer edits at all | | `sample_info` | dict | `query_id` (the join key back into the reconstructed DART-Math data), `domain`, `math_level`, `source`, `fail_rate`, `tot_n_samples`, `difficulty`, `split` (`train`/`val`/`test` of our split; `train` for every PoLar-split question, whose search runs over the level's whole pool) | | `search_trajectory` | list of dicts | the raw MCTS visit log, one entry per simulation: `{"path", "parent_path", "reward"}`. Lets you replay the exact tree the search built, not just its final valid/invalid path sets. | A **layer path** is a flat list of layer indices, the exact sequence of transformer layers the model ran, in order. It's what `re_polar.core.layer_engine.LayerEngine.apply_layer_rerouting()` executes directly: - The identity path is `[0, 1, 2, ..., num_layers - 1]`, every layer once, in order. - A **skipped** layer is simply missing from the path. - A **repeated** layer appears consecutively more than once. For example, `search_trajectory[0]["path"]` for one record in the sample file is: ``` [0, 1, 2, 3, 4, 4, 4, 5, 6, ...] ``` Layer 4 runs 3 times in a row (a repeat), everything else in that stretch runs once. This flat path is the *ground truth* the search records. `re_polar.core` (`Program`/`Segment`, see [`re_polar/core/ir.py`](https://github.com/DATEXIS/RE-PoLar/blob/main/re_polar/core/ir.py)) re-expresses the same information as contiguous ≤4-layer segments, each tagged `keep`/`skip`/`repeat` — the structured form the router is trained to predict. Every path in this data round-trips through it (`re_polar.router.train.program_from_layer_path` decodes a path back to a `Program`; `Program.to_layer_path()` must reproduce the original path exactly). ### Generated text (`generated_answers/`) `final_valid_transitions`/`final_invalid_transitions` say *whether* a program was correct, not what the model generated to earn that label. The model's output for every evaluation of a search is here, one file per (model, [prompt,] seed, level). The text is the model's continuation only (capped at 2,000 characters); under the `oneshot` prompt it often goes on to write a new, made-up problem after its answer. The model sometimes restates its question, so restatements are redacted: every run of 10 or more words that copies a question of our split or the PoLar split (case-insensitive, whitespace normalised) is replaced by `[question]`, and so is a full copy of the row's own question when that question has fewer than 10 words. About 5% of the answers are affected; `reward` is the verdict on the original, unredacted text. One JSON object per line: | field | meaning | |---|---| | `query_id` | same id as `mcts_results/`'s `sample_info.query_id` and the reconstructed DART-Math data's `query_id` — join directly on this | | `path` | the layer path that was executed | | `reward` | 0.0 or 1.0, same meaning as `final_valid_transitions`/`initial_transition_metric` | | `text` | the model's generated output for this (question, path), restatements of the question replaced by `[question]` (above) | | `batch_id`, `batch_pos`, `batch_size` | which generation batch this row was part of, and its position in it — batch composition affects bf16 rounding, so this lets an exact batch be reconstructed if needed | | `difficulty` | 1-5, redundant with the file path, kept so a row is self-contained | ## Router results (`router_results/`) `re_polar.router.infer --top-k-paths 5` on the test questions (main track: the 500 test questions of the level; PoLar split: the fold's test quarter, or Li et al.'s test set in `split.json`). ```json {"model": str, "checkpoint": str, "per_difficulty": [ {...} ], "overall": {...}, "programs": {"": [ {...one entry per test question...} ]}} ``` `per_difficulty`: `n`, `identity_acc`, `router_acc` (pass@1), `pass_at` (pass@1..5), `router_acc_at_k`, `rescue_at1` / `harm_at1` (questions where the top-1 program is right and identity wrong, and vice versa), `mcnemar_p`, `n_nonidentity_top1`, `n_distinct_top1`, `top_nonidentity_share`, and program-shape statistics. `programs`: per question `query_id`, the top-1 `layer_path`, `identity_correct`, `nonidentity`, and `candidates` (the 5 programs, top-1 first, each with `layer_path` and `correct`). ## Fixed programs (`fixed_program/`) `re_polar.router.fixed_program`: one program per level, the same for every question, picked on the validation questions among the 20 programs with the highest shrunk success rate on the training questions. ```json {"difficulty": int, "menu_size": int, "prompt_style": str, "n": {"train", "val", "test"}, "methods": {"fixed": {"winner": {"layer_path", "train_prior", ...}, "val": {...}, "test": {...}, "all_val": [...]}}} ``` `test`: `identity_acc`, `pass_at` (pass@1 is the fixed program's accuracy), `rescue_at1`, `harm_at1`, `mcnemar_p`, and `per_question` (`query_id`, `identity_correct`, `top1_correct`). `all_val`: every candidate's validation result. ## Out-of-distribution routers (`polar_split/ood//`) One router and one fixed program per model, trained on all five levels of Li et al.'s train/val split with the `polar_default` prompt (seed-42 search), evaluated on ASDiv and MAWPS (`router_asdiv_mawps.json`, `fixed_program.json`) and MMLU-Pro (`router_and_fixed_mmlu_pro.json`, from `analysis.mmlu_pro_track.infer_router_mmlu --fixed-program-json`). Paper Appendix B.7. ## Reading the data Every large file ships gzip-compressed. Decompressing one gives back exactly the plain-text JSON or JSONL described above. `re_polar.datasets.schemas.load_samples` and `re_polar.mcts.analysis.loader.load_menu_crosschecks` accept a `.gz` path directly. To inspect a file yourself: ```python import json, gzip json.load(gzip.open("path/to/file.json.gz", "rt")) # mcts_results/, menu_crossexec/ [json.loads(l) for l in gzip.open("path/to/file.jsonl.gz", "rt")] # generated_answers/ ``` ## Joining questions back onto the MCTS results Rebuild the questions (above), then join, per model: ```bash python -m re_polar.datasets.attach_mcts_questions \ --mcts-dir data/mcts_results/qwen3_8b --dart-math-dir ./data/dart_math \ --out-dir ./data/mcts_results_full/qwen3_8b python -m re_polar.datasets.attach_mcts_questions \ --mcts-dir data/polar_split/mcts_results/qwen3_8b/oneshot \ --dart-math-dir ./data/polar_split_questions/pool \ --out-dir ./data/mcts_results_full/polar_split/qwen3_8b/oneshot ``` This writes the same directory layout (`seed/dart-math-diff-/`), with `question`/`gt_ans` added to every record: the format `re_polar.router.train`, `re_polar.router.fixed_program` and everything under [`analysis/`](https://github.com/DATEXIS/RE-PoLar/blob/main/analysis/) expect. For the PoLar-split routers, `re_polar.router.fold_data` joins the text itself. ## Menu cross-execution data (`menu_crossexec/`, `menu_crossexec_heldout/`) Rank programs, identity included, by how many questions they solved during the seed-42 search, take the top 100, then execute each of them against every question of a question set (not just the ones the search happened to try it on), with the search's own `oneshot` prompt. Produced by [`analysis/mcts_design/menu_coverage.py`](https://github.com/DATEXIS/RE-PoLar/blob/main/analysis/mcts_design/menu_coverage.py); both sets are compared by [`analysis/mcts_design/menu_heldout.py`](https://github.com/DATEXIS/RE-PoLar/blob/main/analysis/mcts_design/menu_heldout.py). - `menu_crossexec//diff.json.gz`: in-sample, ranked and executed on all 2,000 questions of the level (`--rank-pool all --eval-pool all`; paper Fig. 4a and Fig. 9). - `menu_crossexec_heldout//diff.json.gz`: held-out, ranked on the 1,500 train+val questions and executed on the 500 test questions (`--rank-pool trainval --eval-pool test`). Cells already in the in-sample grid were taken from it (`--reuse-grid`, provenance `g`). ```json {"model": str, "k": int, "prompt_style": str, "schema": "menu_crossexec_v2", "per_difficulty": [ { ...one entry per difficulty... } ]} ``` Each `per_difficulty` entry: | field | meaning | |---|---| | `difficulty`, `n_pool`, `n_train`, `n_val`, `n_test` | pool size and split sizes for this difficulty (same split as `dart_math_splits.json`) | | `k_requested` / `k_actual` | requested vs. actually-ranked menu size | | `qids` | every pool question's `query_id`, in a fixed order — everything below indexes positionally against this list | | `per_program` | one entry per menu program: `path` (its layer path), `rewards` (one 0/1 per `qids` position) and `provenance` (one letter per `qids` position saying where that 0/1 comes from: `v` / `i` = the search already ran this program on this question (valid / invalid), so it was not run again; `f` = run for this grid, because the search tried each program on only some questions; `g` = copied from another grid that already ran this program on this question: the in-sample grid for held-out grids (`reuse_grid`), the earlier grid of the same level for the LLaMA-3.2-3B and Qwen1.5-MoE DM-5 in-sample grids) | | `provenance_legend` | the same letter meanings, stored in the file | | `n_reused_cells` / `n_new_cells` | how many reused (`v`/`i`/`g`) vs. `f` cells, across the whole grid | | `rank_pool`, `eval_pool`, `reuse_grid` | held-out grids only: `trainval`, `test`, and the in-sample grid the `g` cells come from | | `real_topk_coverage_curve`, `final_real_coverage` | coverage vs. menu size K | ## Router checkpoints (`router_checkpoints/`, `polar_split/router_checkpoints/`, `polar_split/ood/`) Trained router weights (PyTorch state dict). Load via `re_polar.router.train.load_checkpoint` (used by `re_polar/router/infer.py --checkpoint`). ```json {"state_dict": {...}, "meta": {"num_layers", "n_ops", "d_model", "nheads", "n_layer_blocks", "embed_dim", "embedding_model_name", "max_question_tokens", "ops"}, "train_meta": {...training config and val metrics...}} ``` `state_dict` holds only the trainable head; the frozen embedding encoder (`meta.embedding_model_name`) reloads its own weights from Hugging Face.