wflying/rl-if-math-logic-46k

RL IF Math Logic 46K

This dataset is a mixed training set for reinforcement learning with verifiable rewards. It contains 45,980 JSON Lines covering instruction following, mathematics, and logic/table reasoning. There is one train split and no validation or test split.

The release is intended for research and development. It is not a benchmark, and downstream users should construct their own held-out evaluations and check for contamination before using it to report comparable results.

Source composition

Category	metadata.data_type	Examples	Source dataset	Source license
Instruction following	if	15,994	allenai/IF_multi_constraints_upto5	ODC-BY-1.0
Mathematics	klear_math	15,000	Kwai-Klear/KlearReasoner-MathSub-30K	Apache-2.0
Logic and table reasoning	nemotron_rl_reasoning_gym	7,486	wflying/logic-rl-24k	CC BY 4.0
Logic and table reasoning	guru_rl	7,500	wflying/logic-rl-24k	MIT

The task counts above are measured from the released file and sum to 45,980. Source-family attribution follows the corresponding components documented in wflying/rl-if-math-coding-logic-60k. Individual records do not always retain a unique upstream repository identifier or a complete sampling history.

The logic/table categories are routed through wflying/logic-rl-24k, which documents its upstream attribution to nvidia/Nemotron-RL-ReasoningGym-v1 and LLM360/guru-RL-92k.

The 7,500 Guru records break down as follows:

metadata.data_source	Examples	label type
table__hitab	3,131	string
table__multihier	1,103	string
logic__ordering_puzzle_dataset	1,381	list
logic__graph_logical_dataset	903	string
logic__zebra_puzzle_dataset	982	object

Together, these comprise 4,234 table-reasoning and 3,266 logical-reasoning examples.

File and integrity information

• File: rl-if-math-logic-46k.jsonl
• Format: UTF-8 JSON Lines, one JSON object per line
• Lines: 45,980
• Size: 148,071,341 bytes
• SHA-256: 3f5c9c4ac1beb8a34dbb40464fb5e5ad5ee35f45ed9f0c33224d06796e7a46ac

All 45,980 records parse as JSON and contain prompt, label, and metadata. The SHA-256 above matches the published file. These checks establish file integrity and basic structure, not the correctness of every reference answer.

Data structure

Each record has three top-level fields:

{
  "prompt": [
    {"role": "user", "content": "..."}
  ],
  "label": "...",
  "metadata": {"data_type": "..."}
}

• prompt: a chat-formatted prompt containing exactly one user message in every record.
• label: the reference answer, or an empty string for instruction-following examples whose reward is computed from the prompt constraints.
• metadata: source, reward-routing, ground-truth, constraint, token-count, and task-specific auxiliary fields. Its nested schema is intentionally heterogeneous.

The release contains 43,617 string labels, 1,381 list labels, and 982 object labels. All 15,994 instruction-following labels are empty strings; their prompts contain one to five constraints, with equally sized instruction_id_list and instruction_kwargs lists.

Important common metadata fields include:

• data_type: top-level task/reward family used to route the example.
• ground_truth: expected answer; it matches label in all 29,986 non-IF records.
• num_tokens: precomputed token count, present in all records (range: 24–3,967). The tokenizer is not recorded in this release.
• instruction_id_list and instruction_kwargs: verifiable instruction constraints for if records.
• data_source, ability, and style: source family and reward style for logic and table records.

Because label and parts of metadata have mixed JSON types, preserve them as JSON when loading into a fixed-schema framework. For example, JSON-encode those fields before constructing a columnar table.

Loading

Because label mixes strings, lists, and objects, and metadata contains heterogeneous nested structures, automatic Arrow schema inference may fail. Reading the original JSONL preserves the field values:

import json
from huggingface_hub import hf_hub_download

path = hf_hub_download(
    repo_id="wflying/rl-if-math-logic-46k",
    repo_type="dataset",
    filename="rl-if-math-logic-46k.jsonl",
)

with open(path, encoding="utf-8") as f:
    for line in f:
        example = json.loads(line)
        prompt = example["prompt"]
        label = example["label"]
        metadata = example["metadata"]
        # Route to the appropriate reward using metadata["data_type"].

To construct a Hugging Face datasets.Dataset with a consistent schema, JSON-encode the heterogeneous fields first. This example continues from the path above:

from datasets import Dataset

def normalized_examples():
    with open(path, encoding="utf-8") as f:
        for line in f:
            example = json.loads(line)
            yield {
                "prompt": example["prompt"],
                "label_json": json.dumps(example["label"], ensure_ascii=False),
                "metadata_json": json.dumps(example["metadata"], ensure_ascii=False),
            }

dataset = Dataset.from_generator(normalized_examples)

# Recover the original JSON types before reward computation.
label = json.loads(dataset[0]["label_json"])
metadata = json.loads(dataset[0]["metadata_json"])

Intended use

The dataset is intended for:

• reinforcement learning with rule-based or verifiable rewards;
• multi-task training across instruction following, mathematics, logic, and table reasoning;
• reward-function routing experiments based on metadata.data_type;
• controlled studies of mixed-domain training mixtures.

Reward implementations must respect the expected output format in each prompt. These formats include, among others, boxed mathematics answers, <answer>...</answer> tags, and instruction-following constraints.

Limitations

• This is only a training mixture; no held-out split is provided.
• Task families and answer formats are not uniformly distributed.
• label and metadata are heterogeneous and may require normalization.
• Reference answers and generated source data can contain errors, ambiguities, bias, or duplicate concepts.
• The compilation has not been independently audited for personal information, harmful content, or downstream benchmark contamination.
• Instruction-following examples may include content generated by third-party models subject to separate terms.

Users are responsible for validating task suitability, licenses, reward functions, and train/evaluation separation for their intended application.

Licensing and attribution

The repository uses the Hub's other license tag because it combines records under multiple licenses:

• IF records: ODC-BY-1.0, with Ai2's Responsible Use Guidelines and third-party model terms where applicable.
• Klear mathematics records: Apache-2.0.
• nemotron_rl_reasoning_gym logic records: CC BY 4.0.
• guru_rl logic/table records: MIT.

Consult the linked source datasets and their upstream licenses for the exact terms and attribution requirements that apply to your use case. This card is informational and is not legal advice.

Source citations

Please cite the source datasets and papers used to create this mixture. Key source references include:

@misc{pyatkin2025generalizing,
  title={Generalizing Verifiable Instruction Following},
  author={Valentina Pyatkin and Saumya Malik and Victoria Graf and Hamish Ivison and Shengyi Huang and Pradeep Dasigi and Nathan Lambert and Hannaneh Hajishirzi},
  year={2025},
  archivePrefix={arXiv}
}

@article{su2025klearreasoner,
  title={Klear-Reasoner: Advancing Reasoning Capability via Gradient-Preserving Clipping Policy Optimization},
  author={Zhenpeng Su and Leiyu Pan and Xue Bai and Dening Liu and Guanting Dong and Jiaming Huang and Wenping Hu and Fuzheng Zhang and Kun Gai and Guorui Zhou},
  journal={arXiv preprint arXiv:2508.07629},
  year={2025}
}

For logic/table records, also cite the attribution and upstream papers listed in wflying/logic-rl-24k, including the Guru RL and NVIDIA Nemotron RL Reasoning Gym releases.