gasolsun/Ask_to_Distill-eval

Ask to Distill: evaluation benchmarks

This repository collects the evaluation sets used in the Ask to Distill experiments (math, code, and tau2-bench agent tasks). Every record uses one unified format and stores the exact prompt we evaluate with next to the raw problem, so an evaluation can be reproduced without our code.

Two benchmarks are not redistributed here: AMC23 (the source declares no license) and LiveCodeBench (the source declares only "cc", and its problems are scraped from LeetCode, AtCoder and Codeforces). For those, scripts/ contains fetch scripts that download the data from the original repositories at pinned revisions and convert it to the same format.

The card describes data, prompts and settings only; it reports no results.

Contents

Domain	Config / benchmark	File	Rows	Original source
math	aime24	math/aime24.jsonl	30	BytedTsinghua-SIA/AIME-2024
math	aime25	math/aime25.jsonl	30	math-ai/aime25
math	aime26	math/aime26.jsonl	30	MathArena/aime_2026
math	brumo25	math/brumo25.jsonl	30	MathArena/brumo_2025
math	math500	math/math500.jsonl	500	HuggingFaceH4/MATH-500
math	amc23 (not rehosted)	scripts/fetch_amc23.py	40	math-ai/amc23
code	humaneval_plus	code/humaneval_plus.jsonl	164	EvalPlus HumanEval+ v0.1.10
code	mbpp_plus	code/mbpp_plus.jsonl	378	EvalPlus MBPP+ v0.2.0
code	apps_introductory	code/apps_introductory.jsonl	1,000	codeparrot/apps (test)
code	apps_interview1k	code/apps_interview1k.jsonl	1,000	codeparrot/apps (test)
code	apps_competition	code/apps_competition.jsonl	1,000	codeparrot/apps (test)
code	codecontests	code/codecontests.jsonl	165	deepmind/code_contests (test)
code	livecodebench_v5_v6 (not rehosted)	scripts/fetch_livecodebench.py	342	livecodebench/code_generation_lite
tau2	tau2_airline	tau2/airline.jsonl	20	sierra-research/tau2-bench (test split)
tau2	tau2_retail	tau2/retail.jsonl	40	sierra-research/tau2-bench (test split)
tau2	tau2_telecom	tau2/telecom.jsonl	40	sierra-research/tau2-bench (test split)

4,427 records are hosted here; AMC23 (40) and LiveCodeBench v5+v6 (342) are fetched by script.

from datasets import load_dataset
aime24 = load_dataset("gasolsun/Ask_to_Distill-eval", "aime24", split="test")

Layout

README.md
math/      aime24.jsonl  aime25.jsonl  aime26.jsonl  brumo25.jsonl  math500.jsonl
code/      humaneval_plus.jsonl  mbpp_plus.jsonl
           apps_introductory.jsonl  apps_interview1k.jsonl  apps_competition.jsonl  codecontests.jsonl
           evalplus_native/HumanEvalPlus-v0.1.10.jsonl   (official EvalPlus release file, verbatim)
           evalplus_native/MbppPlus-v0.2.0.jsonl         (official EvalPlus release file, verbatim)
tau2/      airline.jsonl  retail.jsonl  telecom.jsonl
           domains/airline/   db.json  policy.md  tasks_test.json
           domains/retail/    db.json  policy.md  tasks_test.json
           domains/telecom/   db.toml  user_db.toml  main_policy.md  tech_support_manual.md  tasks_test.json
scripts/   fetch_amc23.py  fetch_livecodebench.py

Record format

Every record, in every file, has the common fields

Field	Type	Meaning
id	string	unique across the whole collection
benchmark	string	config name, e.g. aime24, apps_interview1k, tau2_retail
domain	string	math, code or tau2
source	string	original Hugging Face / GitHub id the data comes from
license	string	license of that record's source (see Licenses)

plus domain fields.

math (math/*.jsonl, and the AMC23 fetch output)

Field	Meaning
problem	raw problem statement
answer	reference answer (string)
prompt	the exact user message sent to the model (see Prompts)
source_index	index of the problem in the source file
unique_id, subject, level	MATH-500 only: the MATH-500 identifiers

code, stdin/stdout benchmarks (apps_*, codecontests, and the LiveCodeBench fetch output)

Field	Meaning
question	problem statement
starter_code	starter code shown to the model (APPS call-based problems, LeetCode problems), else ""
entry_point	function name for call-based problems, else ""
difficulty	APPS tier, CodeContests difficulty (cf<k>), or LiveCodeBench easy/medium/hard
tests	JSON string {"inputs": [...], "outputs": [...], ("fn_name": ...)}, the input_output format graded by APPS / LiveCodeBench checkers
system_prompt	system message used at evaluation time
prompt	the exact user message sent to the model

code, EvalPlus (humaneval_plus, mbpp_plus)

Field	Meaning
question	the EvalPlus task prompt (function signature + docstring for HumanEval+, docstring with an example assert for MBPP+)
starter_code	"" (the stub is part of question)
entry_point	function name the tests call
tests	the native EvalPlus record, verbatim, as a JSON string (task_id, prompt, entry_point, canonical_solution, base_input, plus_input, atol, contract, and test (HumanEval+) or assertion (MBPP+))
prompt	the exact user message sent to the model
assistant_prefill	the assistant-turn prefix EvalPlus appends after the chat template

Writing the tests strings one per line reproduces the official EvalPlus release file byte for byte; the same files are also shipped unchanged under code/evalplus_native/, so the evalplus package can use them directly:

HUMANEVAL_OVERRIDE_PATH=code/evalplus_native/HumanEvalPlus-v0.1.10.jsonl \
MBPP_OVERRIDE_PATH=code/evalplus_native/MbppPlus-v0.2.0.jsonl  evalplus.evaluate ...

tau2 (tau2/*.jsonl)

Field	Meaning
tau2_domain	airline, retail or telecom
task_id	the native tau2-bench task id
task	the native tau2-bench task object, unchanged (id, description, user_scenario, initial_state, evaluation_criteria, ...)

tau2/domains/<domain>/ holds the environment files the tau2-bench environments read for these three domains (database, agent policy; for telecom also the user-device database and the tech support manual), byte-identical to upstream, plus tasks_test.json, the test tasks of that domain as a plain JSON list (pass it to tau2-bench as the task file).

Prompts and evaluation settings

Math

The problem is wrapped in the DAPO prompt template, and our generation script appends a boxed-answer instruction. The prompt field is the final string, sent as the only user turn (no system prompt) through the model's chat template:

Solve the following math problem step by step. The last line of your response should be of the form Answer: $Answer (without quotes) where $Answer is the answer to the problem.

{problem}

Remember to put your answer on its own line after "Answer:". Please reason step by step, and put your final answer within \boxed{}.

• Sampling: temperature 0.7, top_p 0.95, at most 31,744 new tokens.
• avg@16 (mean accuracy over 16 samples per problem) for AIME24, AIME25, AIME26, AMC23 and BRUMO25; avg@4 for MATH-500.
• The final answer is compared with answer.

LiveCodeBench v5+v6

• Problems: shards test5.jsonl + test6.jsonl of livecodebench/code_generation_lite at revision 0fe84c3912ea0c4d4a78037083943e8f0c4dd505, i.e. LiveCodeBench's v5_v6 release slice: 342 problems, contest dates 2024-09-22 to 2025-04-06, no further filtering.

• Prompt: LiveCodeBench's own CodeQwen template, system message You are a helpful assistant. The fetch script stores the user message (prompt) and the exact raw ChatML string of LiveCodeBench's CodeQwenInstruct style (prompt_chatml). For hybrid Qwen3 models in non-thinking mode we use LiveCodeBench's Qwen3NoThink style, which is prompt_chatml followed by <think>\n\n</think>\n\n. Without starter code the user message is

  You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests. You will NOT return anything except for the program.
  
  Question: {question}
  
  Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within delimiters as follows. Ensure that when the python program runs, it reads the inputs, runs the algorithm and writes output to STDOUT.
  ```python
  # YOUR CODE HERE
  ```
  

  and with starter code the last paragraph is replaced by You will use the following starter code to write the solution to the problem and enclose your code within delimiters. followed by the starter code in a python code block.

• Sampling: n=4 samples per problem (pass@1 averaged over the 4), non-thinking mode, temperature 0.7, top_p 0.8, top_k 20, at most 8,192 new tokens.

• Grading: LiveCodeBench's runner on public + private tests (tests), 6 s timeout per test.

APPS and CodeContests

• Prompt: system message You are a helpful assistant. and the user message in prompt, which is LiveCodeBench's stdin/stdout template applied to the question:

  You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests. You will NOT return anything except for the program.
  
  Question: {question}
  
  Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within delimiters as follows. Ensure that when the python program runs, it reads the inputs, runs the algorithm and writes output to STDOUT.
  ```python
  # YOUR CODE HERE
  ```
  

  For APPS problems with starter code, {question} is the question followed by a blank line, the line Use this starter code: and the (stripped) starter code in a python code block; the prompt field already contains it.

• Sampling: n=1, non-thinking mode, temperature 0.2, top_p 0.95, top_k 20, at most 4,096 new tokens.

• Grading: the code block is extracted and run with LiveCodeBench's checker on tests (6 s timeout per test); pass@1.

HumanEval+ and MBPP+

• EvalPlus' instruct prompt and protocol: greedy decoding, at most 1,024 new tokens, base + plus tests. The user message is prompt:

  Please provide a self-contained Python script that solves the following problem in a markdown code block:
  ```
  {question, stripped}
  ```
  

  and the assistant turn is prefilled with assistant_prefill:

  Below is a Python script with a self-contained function that solves the problem and passes corresponding tests:
  ```python
  

  (for hybrid Qwen3 chat templates the rendered assistant turn also contains the empty <think>\n\n</think>\n\n block, i.e. non-thinking generation).

tau2-bench

• Test split of tau2-bench (split_tasks.json, key test): 20 airline, 40 retail and 40 telecom tasks, with the task definitions (including gold labels) of the upstream repository.
• Agent in non-thinking mode, user simulator gpt-4o-mini, 4 trials per task, at most 200 steps per episode, at most 8,000 new tokens per agent turn.
• Metric: pass^1, i.e. the task success rate averaged over the 4 trials.

Fetching AMC23 and LiveCodeBench

Both scripts need huggingface_hub (plus pandas and pyarrow for AMC23), download from the original repositories at a pinned revision, and need no token.

python scripts/fetch_amc23.py --out amc23.jsonl                         # 40 records, math format
python scripts/fetch_livecodebench.py --out livecodebench_v5_v6.jsonl   # 342 records, code format

• fetch_amc23.py downloads test-00000-of-00001.parquet of math-ai/amc23 (revision 80815d37005feb82cd7f8fbc6901d5d3eff43057), converts the float answers to strings (27.0 becomes "27"), and builds the same math prompt as above. Its output is identical to the AMC23 copy used in our evaluation.
• fetch_livecodebench.py downloads test5.jsonl and test6.jsonl (~0.7 GB) of livecodebench/code_generation_lite (revision 0fe84c3912ea0c4d4a78037083943e8f0c4dd505). Each record has the unified fields (with tests holding the decoded public + private tests, exactly as LiveCodeBench grades them) and the 11 native LiveCodeBench fields verbatim (private_test_cases keeps its upstream compressed encoding), so CodeGenerationProblem(**{k: r[k] for k in NATIVE_FIELDS}) from lcb_runner rebuilds the runner's problem object. The output is ~2.1 GB; --no-decode-tests leaves tests empty and keeps the output at ~0.7 GB. Decoding unpickles data from the source repository, as LiveCodeBench itself does.

Our modifications

• Math. Problems and answers are unchanged. AIME24 is deduplicated: the source ships each of the 30 problems 32 times (960 rows); we keep the first copy, in order. Every problem is wrapped in the prompt shown above. AMC23 answers are converted from floats to strings by the fetch script.
• APPS. Converted from codeparrot/apps (test split): problems without tests are dropped (none in the three files here), tests are capped at the first 50 input/output pairs per problem, and for problems with starter code the starter code is appended to the question in the prompt (stored separately in starter_code). apps_interview1k is the first 1,000 problems after shuffling the full converted interview split (3,000 problems, in source order) with Python's random.Random(0).shuffle; its first id is apps_2639.
• CodeContests. Converted from the deepmind/code_contests test split (165 problems): public, private and generated tests are concatenated in that order and capped at the first 50; ids are cc_ plus the first 60 characters of the problem name.
• EvalPlus. Unchanged (the official release files, verbatim).
• LiveCodeBench. Not rehosted; the fetch script only adds the unified fields.
• tau2-bench. Test tasks and environment files are unchanged copies of the upstream repository (commit b7ea9074c1cba482b30687fecdb5c8425fd6f619); only the files these three domains need are included.

Licenses

Each record carries its source's license in license. The collection as a whole has no single license: use each benchmark under the terms of its source.

Benchmark	Source	License
AIME24	BytedTsinghua-SIA/AIME-2024	Apache-2.0
AIME25	math-ai/aime25	Apache-2.0
AIME26	MathArena/aime_2026	CC BY-NC-SA 4.0 (non-commercial, share-alike)
BRUMO25	MathArena/brumo_2025	CC BY-NC-SA 4.0 (non-commercial, share-alike)
MATH-500	HuggingFaceH4/MATH-500	No license is declared on the Hugging Face repository. The problems are a subset of the MATH dataset (Hendrycks et al., MIT license) selected in OpenAI's PRM800K release (MIT license).
AMC23 (not rehosted)	math-ai/amc23	No license declared; fetch it from the source
HumanEval+	EvalPlus	Apache-2.0 (built on OpenAI HumanEval, MIT)
MBPP+	EvalPlus	Apache-2.0 (built on Google MBPP, CC BY 4.0)
APPS (3 files)	codeparrot/apps, originally hendrycks/apps	MIT
CodeContests	deepmind/code_contests	CC BY 4.0
LiveCodeBench (not rehosted)	livecodebench/code_generation_lite	"cc" as declared by the source; problems from LeetCode, AtCoder and Codeforces; fetch it from the source
tau2-bench (3 domains)	sierra-research/tau2-bench	MIT

The AIME26 and BRUMO25 files are adaptations of CC BY-NC-SA 4.0 material (prompt wrapping added) and are distributed under CC BY-NC-SA 4.0: they may not be used commercially, and derivatives must be shared under the same license. AIME and AMC problems are from the Mathematical Association of America's competitions; BRUMO problems are from the Brown University Mathematics Olympiad.

Attribution and citations

Please cite the original benchmarks you use.

• AIME 2024 (as packaged for DAPO): Yu et al., DAPO: An Open-Source LLM Reinforcement Learning System at Scale, arXiv:2503.14476, 2025.
• AIME 2025: the math-ai/aime25 dataset, https://huggingface.co/datasets/math-ai/aime25.
• AIME 2026, BRUMO 2025: Balunović et al., MathArena: Evaluating LLMs on Uncontaminated Math Competitions, arXiv:2505.23281, 2025.
• MATH-500: Hendrycks et al., Measuring Mathematical Problem Solving With the MATH Dataset, NeurIPS Datasets and Benchmarks 2021 (arXiv:2103.03874); Lightman et al., Let's Verify Step by Step, arXiv:2305.20050, 2023.
• AMC23: the math-ai/amc23 dataset, https://huggingface.co/datasets/math-ai/amc23.
• HumanEval+ / MBPP+: Liu et al., Is Your Code Generated by ChatGPT Really Correct? Rigorous Evaluation of Large Language Models for Code Generation, NeurIPS 2023 (arXiv:2305.01210); Chen et al., Evaluating Large Language Models Trained on Code, arXiv:2107.03374, 2021; Austin et al., Program Synthesis with Large Language Models, arXiv:2108.07732, 2021.
• APPS: Hendrycks et al., Measuring Coding Challenge Competence With APPS, NeurIPS Datasets and Benchmarks 2021 (arXiv:2105.09938).
• CodeContests: Li et al., Competition-Level Code Generation with AlphaCode, Science 378, 2022 (arXiv:2203.07814).
• LiveCodeBench: Jain et al., LiveCodeBench: Holistic and Contamination Free Evaluation of Large Language Models for Code, arXiv:2403.07974, 2024.
• tau2-bench: Barres et al., τ²-Bench: Evaluating Conversational Agents in a Dual-Control Environment, arXiv:2506.07982, 2025; Yao et al., τ-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains, arXiv:2406.12045, 2024. Our tau2 harness is based on https://github.com/NVlabs/ToolOrchestra (Apache-2.0), whose copies of these environment files are identical to upstream.

@article{yu2025dapo,
  title   = {DAPO: An Open-Source LLM Reinforcement Learning System at Scale},
  author  = {Yu, Qiying and others},
  journal = {arXiv preprint arXiv:2503.14476},
  year    = {2025}
}
@article{balunovic2025matharena,
  title   = {MathArena: Evaluating LLMs on Uncontaminated Math Competitions},
  author  = {Balunovi{\'c}, Mislav and Dekoninck, Jasper and Petrov, Ivo and Jovanovi{\'c}, Nikola and Vechev, Martin},
  journal = {arXiv preprint arXiv:2505.23281},
  year    = {2025}
}
@inproceedings{hendrycks2021math,
  title     = {Measuring Mathematical Problem Solving With the MATH Dataset},
  author    = {Hendrycks, Dan and Burns, Collin and Kadavath, Saurav and Arora, Akul and Basart, Steven and Tang, Eric and Song, Dawn and Steinhardt, Jacob},
  booktitle = {NeurIPS Datasets and Benchmarks},
  year      = {2021}
}
@article{lightman2023verify,
  title   = {Let's Verify Step by Step},
  author  = {Lightman, Hunter and Kosaraju, Vineet and Burda, Yura and Edwards, Harri and Baker, Bowen and Lee, Teddy and Leike, Jan and Schulman, John and Sutskever, Ilya and Cobbe, Karl},
  journal = {arXiv preprint arXiv:2305.20050},
  year    = {2023}
}
@inproceedings{liu2023evalplus,
  title     = {Is Your Code Generated by ChatGPT Really Correct? Rigorous Evaluation of Large Language Models for Code Generation},
  author    = {Liu, Jiawei and Xia, Chunqiu Steven and Wang, Yuyao and Zhang, Lingming},
  booktitle = {NeurIPS},
  year      = {2023}
}
@article{chen2021codex,
  title   = {Evaluating Large Language Models Trained on Code},
  author  = {Chen, Mark and others},
  journal = {arXiv preprint arXiv:2107.03374},
  year    = {2021}
}
@article{austin2021mbpp,
  title   = {Program Synthesis with Large Language Models},
  author  = {Austin, Jacob and others},
  journal = {arXiv preprint arXiv:2108.07732},
  year    = {2021}
}
@inproceedings{hendrycks2021apps,
  title     = {Measuring Coding Challenge Competence With APPS},
  author    = {Hendrycks, Dan and Basart, Steven and Kadavath, Saurav and Mazeika, Mantas and Arora, Akul and Guo, Ethan and Burns, Collin and Puranik, Samir and He, Horace and Song, Dawn and Steinhardt, Jacob},
  booktitle = {NeurIPS Datasets and Benchmarks},
  year      = {2021}
}
@article{li2022alphacode,
  title   = {Competition-Level Code Generation with AlphaCode},
  author  = {Li, Yujia and others},
  journal = {Science},
  volume  = {378},
  number  = {6624},
  pages   = {1092--1097},
  year    = {2022}
}
@article{jain2024livecodebench,
  title   = {LiveCodeBench: Holistic and Contamination Free Evaluation of Large Language Models for Code},
  author  = {Jain, Naman and Han, King and Gu, Alex and Li, Wen-Ding and Yan, Fanjia and Zhang, Tianjun and Wang, Sida and Solar-Lezama, Armando and Sen, Koushik and Stoica, Ion},
  journal = {arXiv preprint arXiv:2403.07974},
  year    = {2024}
}
@article{barres2025tau2,
  title   = {$\tau^2$-Bench: Evaluating Conversational Agents in a Dual-Control Environment},
  author  = {Barres, Victor and Dong, Honghua and Ray, Soham and Si, Xujie and Narasimhan, Karthik},
  journal = {arXiv preprint arXiv:2506.07982},
  year    = {2025}
}
@article{yao2024taubench,
  title   = {$\tau$-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains},
  author  = {Yao, Shunyu and Shinn, Noah and Razavi, Pedram and Narasimhan, Karthik},
  journal = {arXiv preprint arXiv:2406.12045},
  year    = {2024}
}