math_rlvr_filtered

Public math RL datasets (three in full, a fourth as one filtered file), each problem annotated with how often Qwen3-4B solves it in 4 attempts, plus a multiple-choice flag. The point is RL data selection: problems the model solves 1-3 times out of 4 carry GRPO-style learning signal; 4/4 problems are too easy for this model and 0/4 problems are either too hard or have unreliable reference answers.

config	source	problems (all)	train_nomc (multiple choice removed)	pass@4	1-3 of 4 correct
deepmath103k	zwhe99/DeepMath-103K	103,022	100,040	94.7%	14,397 (14.4%)
dapo17k	zhuzilin/dapo-math-17k (deduplicated DAPO-Math-17k)	17,398	17,379	89.7%	3,167 (18.2%)
polaris53k	POLARIS-Project/Polaris-Dataset-53K	53,291	52,206	84.0%	14,549 (27.9%)

Statistics in the last two columns are for train_nomc.

A fourth source is included as one filtered file, intellect2_pass0to3: PrimeIntellect/INTELLECT-2-only-math (259,465 rows: NuminaMath-1.5 217,088 + DeepScaleR 42,377). It keeps only the problems Qwen3-4B solved 0-3 times out of 4, with multiple choice removed: 97,113 rows.

n_correct (of 4)	0	1	2	3
rows	73,334	6,861	6,516	10,402

ds = load_dataset("clyu/math_rlvr_filtered", "intellect2_pass0to3", split="train")
signal = ds.filter(lambda r: r["n_correct"] >= 1)   # the 23,779 problems with 1-3 of 4 correct

Over the whole labeled set (247,056 problems after multiple choice is removed), pass@4 is 70.3% and 9.6% of problems have 1-3 of 4 correct. Only problems Qwen3-4B solved 4/4 (149,943) and multiple choice (607) are left out of this file.

Two more configs build an RL training set from these labels, after a second model, GLM-5.3-Flash, re-checked the reference answers:

config	rows	what it is
rl_final (default)	35,660	the recommended RL training set: DeepMath 15,305 / Polaris 16,318 / DAPO 4,037
glm_labels	45,988	every candidate problem (Qwen3-4B 1-3/4 and 0/4) with its GLM-5.3-Flash validation columns

from datasets import load_dataset
train = load_dataset("clyu/math_rlvr_filtered", "rl_final", split="train")   # chat-format `prompt` + `label`

RL training set (rl_final) and GLM-5.3-Flash validation (glm_labels)

Candidate pool. Built from the three train_nomc splits:

• 1-3/4 pool (30,964 problems): Qwen3-4B solved the problem 1, 2 or 3 times out of 4.
  • Polaris rows flagged by a corrected answer_suspect heuristic were dropped (4).
  • Exact-duplicate problems across or within sources were merged, keeping one copy with priority DAPO > DeepMath > Polaris.
  • Duplicate groups with conflicting answers were dropped (19 rows).
• 0/4 pool (15,024 problems): Qwen3-4B solved none of 4.
  • Suspect answers and conflicting duplicates are kept but flagged.

GLM validation. zai-org/GLM-5.3-Flash (FP8, served with sglang 0.5.20, TP8) answered every candidate problem 4 times, with reasoning_effort high, temperature 1.0, top_p 0.95, a 65,536-token cap and the same prompt as the Qwen labeling.

• Each answer was graded with the same rules as above (glm_n_rule_correct).
• If the rules marked an answer wrong, GLM itself (effort low, temperature 0) judged whether it and the reference answer are the SAME final answer (glm_n_judged_same).

glm_n_correct is the sum of the two, and the per-problem verdict is:

• confirmed: glm_n_correct >= 2
• disputed: glm_n_correct == 0 and at least 3 of the 4 answers agree on one alternative (glm_top_alt). This likely means a wrong reference answer, though GLM can also be consistently wrong.
• uncertain: everything else (one match, missing answers or answers that disagree with each other).

pool	source	n	confirmed	uncertain	disputed
1-3/4	DeepMath	14,221	85.3%	11.9%	2.8%
1-3/4	Polaris	13,597	86.6%	10.3%	3.2%
1-3/4	DAPO	3,146	87.5%	9.6%	2.9%
0/4	DeepMath	5,210	79.9%	16.1%	4.0%
0/4	Polaris	8,043	61.6%	23.0%	15.5%
0/4	DAPO	1,771	56.2%	22.4%	21.4%

In the 1-3/4 pool, the disputed share falls from about 5% (Qwen 1/4) to 2% (Qwen 3/4).

Rule-match requirement for 0/4. Many 0/4 confirmations come only from the SAME judge, not the rules: 4,497 problems, half of DeepMath's 0/4. In a spot check the judge was usually right, but these references are often things a rule-based reward cannot check:

• corrupted Polaris strings;
• statements to prove or inequalities;
• Yes/No answers where GLM adds prose.

So rl_final keeps a 0/4 problem only if GLM's answer rule-matches the label at least 2 of 4 times (glm_rule_confirmed).

rl_final selection.

• 1-3/4: every problem except GLM-disputed (912 dropped; uncertain kept, since Qwen already matched these labels at least once).
  • Kept: 30,052 problems. By Qwen n_correct: 1/4 6,891, 2/4 8,172, 3/4 14,989.
• 0/4: only glm_rule_confirmed and not dup_conflict. These are hard problems for Qwen3-4B whose labels a rule grader can match.
  • Kept: 5,608 problems. By source: DeepMath 1,477, Polaris 3,150, DAPO 981.

Rows are shuffled (seed 0). Qwen3-4B's mean accuracy on rl_final is 0.478, with 15.0k mean completion tokens.

Columns (rl_final, glm_labels)

column	meaning
prompt	chat messages ([{"role": "user", "content": ...}]), exactly the prompt used for labeling
label	reference answer (string)
source, source_idx	source config (deepmath103k / dapo17k / polaris53k) and its idx
difficulty, topic	source fields as strings (see below); null when absent
qwen_pool	mixed1to3 or zero
qwen_n_correct, qwen_mean_acc, qwen_mean_tokens, qwen_n_length_capped	Qwen3-4B pass@4 labels (see below)
answer_suspect	corrected heuristic for corrupted reference answers (0/4 pool; always false in the 1-3/4 pool, where flagged rows were dropped)
dup_conflict	the problem has an exact duplicate with a different reference answer (0/4 pool only)
glm_n_samples, glm_n_answered	GLM samples (4) and how many produced a final answer
glm_n_correct, glm_n_rule_correct, glm_n_judged_same	GLM samples matching the label: total = rule-matched + judged SAME
glm_top_alt, glm_top_alt_count	GLM's most common non-matching answer and how many samples gave it
glm_verdict	confirmed / uncertain / disputed
glm_rule_confirmed	glm_n_rule_correct >= 2

from datasets import load_dataset
ds = load_dataset("clyu/math_rlvr_filtered", "polaris53k", split="train_nomc")
signal = ds.filter(lambda r: 1 <= r["n_correct"] <= 3)

How the labels were made

• Model: Qwen/Qwen3-4B, thinking mode on, the model card's sampling (temperature 0.6, top_p 0.95, top_k 20), up to 32,768 new tokens (40,960-token context). Served with sglang; each of the 4 samples per problem used a distinct seed.
• Prompt:
  • DeepMath and Polaris: the problem text followed by Please reason step by step, and put your final answer within \boxed{}.
  • DAPO: the dataset's own chat prompt, unchanged (it asks for Answer: \boxed{...} on the last line).
• Grading: math_verify against the reference answer, with a fallback that compares the last \boxed{} (or Answer: line) to the reference after light LaTeX normalization (\dfrac→\frac, \varnothing→\emptyset, \text{}, spacing, thousands separators, Yes/No case). For Polaris, an extra rule accepts the option letter for references like \textbf{(D)} 20\sqrt{2}.

Columns (per-source configs)

column	meaning
idx	row index in the source file (DeepMath: concatenated parquet shards in order; DAPO: dapo-math-17k.jsonl; Polaris: polaris-data-53K.jsonl)
question	problem text (for DAPO: the user message, including DAPO's answer-format instruction)
final_answer	reference answer from the source dataset
difficulty	source field: DeepMath's 1-10 rating; Polaris's DeepSeek-R1-Distill-Qwen-7B pass rate (k/8); null for DAPO
topic	DeepMath's topic; null otherwise
n_samples	always 4
n_correct	samples graded correct (0-4)
pass_at_4	n_correct > 0
mean_acc	n_correct / 4
n_length_capped	samples that hit the 32k-token cap
mean_tokens	mean completion tokens over the 4 samples
is_multiple_choice, mc_type	multiple-choice flag and kind: options_listed (the question lists options A/B/C), tf_letter_label (a true/false question whose reference answer is A/B), letter_label (any other bare-letter reference answer)
answer_suspect	Polaris only: heuristic flag for corrupted reference answers (see caveats)

train_nomc contains exactly the rows with is_multiple_choice == false. Removed: DeepMath 2,982 (2.89%), DAPO 19 (0.11%), Polaris 1,085 (2.04%).

Caveats

• 0/4 is the least reliable bucket. An audit of the problems where 3-4 samples agree on one answer but are graded wrong found grader or reference-answer issues in roughly 1% of DeepMath problems and 1.5% or more of Polaris problems; DAPO, whose answers are all integers, is essentially clean (about 0.05%). Typical causes: Yes vs True, function notation (f(x) = x vs f(n) = n), case in text answers, and corrupted Polaris references. They sit almost entirely in the 0/4 bucket; the 1-3/4 bucket is barely affected.
• DeepMath true/false with letter answers. 664 DeepMath problems ask "true or false" but give A/B as the reference answer without saying which letter means what. All 664 are 0/4 here. The model's answers agree with A = True, B = False on 88.5% of them. They are tagged tf_letter_label and excluded from train_nomc.
• Polaris reference answers are sometimes corrupted, apparently with LaTeX commands stripped (\2, ^2=\frac{1}{3}(..., \frac{}{}). answer_suspect flags some of these, but it is a heuristic with a known bug: it also flags valid half-open intervals such as (4,9] or [1,\infty) (155 of its 643 flags in all are such intervals), and it misses corruptions that look valid, such as 2-1.
• Multiple-choice detection is heuristic. letter_label also catches a few problems whose answer is genuinely a letter-named object (for example "which player wins? B"); these are excluded too.
• Labels reflect Qwen3-4B under the settings above. A different model, prompt or token budget will shift the difficulty buckets.

INTELLECT-2 (intellect2_pass0to3)

Labeling. Same model, sampling, token budget and grader as the other sources.

• The prompt is the dataset's prompt followed by the DeepMath-style \boxed{} instruction.
• The reference answer is verification_info.ground_truth.
• 11,802 rows have no ground truth (null) and were not labeled. They are not in this file.

Columns. As in the per-source configs, plus problem_id.

• idx is the row index in the source's 7 parquet shards, concatenated in order.
• question, final_answer, problem_id.
• difficulty is the source's solve_rate_qwen_r1_distill_7b, as a float.
• n_samples, n_correct, pass_at_4, mean_acc, n_length_capped, mean_tokens.
• answer_suspect uses the corrected heuristic, which no longer flags valid half-open intervals.

Rows: NuminaMath-1.5 84,822 / DeepScaleR 12,291.

Caveats.

• The 0/4 bucket is large and noisy: 73,334 rows, 76% of the file. Its share of all labeled problems is 29.7%, against 6.1% for DeepMath, 9.9% for DAPO and 15.9% for Polaris.
• Most 0/4 rows are consistent disagreements. In an audit of a quarter of the rollouts, 72% of 0/4 problems had at least 3 of 4 samples agreeing on one answer that differs from the reference.
  • Grader false negatives are rare (0.35% of samples).
  • About 5% of those consensus disagreements are visibly corrupted references, with LaTeX commands stripped (\frac{^2+n^2}{n-}, (,b,)\in\{\dots\}).
  • Most of the rest are genuine disagreements: either a wrong reference or a problem the model consistently gets wrong. The labels alone cannot tell which.
• answer_suspect flags 2,257 rows, almost all NuminaMath-1.5 and almost all 0/4. It is a lower bound on corrupted references.
• Overlap with the other sources. About 28.7k INTELLECT-2 problems, before filtering, are exact (whitespace-normalized) duplicates of DeepMath-103K or Polaris-53K problems. Most are DeepScaleR rows that also appear in Polaris. Deduplicate before mixing configs.
• The 1-3/4 rows (23,779) are the reliable RL signal. 0/4 rows have not been checked with GLM-5.3-Flash, unlike the glm_labels pool.

Licenses

Each config inherits the license of its source: DeepMath-103K is MIT; DAPO-Math-17k and Polaris-Dataset-53K are Apache-2.0. The added annotation columns are released under the same terms as the corresponding source. In rl_final and glm_labels, each row follows the license of its source; glm_top_alt is GLM-5.3-Flash output (MIT-licensed model).

INTELLECT-2-only-math does not declare a license on its dataset card. Its rows come from NuminaMath-1.5 (Apache-2.0) and DeepScaleR (MIT). Check the upstream terms before redistributing intellect2_pass0to3.