ReasoningGymEnv

Wrapper for Reasoning Gym procedural reasoning datasets

ReasoningGymEnv

Wrapper environment for Reasoning Gym procedural reasoning tasks.

Overview

ReasoningGymEnv wraps Reasoning Gym datasets for use in Verifiers. It supports both single datasets and composite mixtures, automatically handles scoring via Reasoning Gym’s built-in evaluators, and provides procedurally generated tasks.

Key features:

• Procedural task generation via seeds
• Support for all Reasoning Gym datasets
• Composite dataset mixing with custom weights
• Automatic task-specific scoring
• Built-in XML parser for structured responses

Installation

Install with Reasoning Gym support:

uv add 'verifiers[rg]'

Or when developing in the verifiers repo:

uv sync --extra rg

See the Reasoning Gym integration guide for setup details.

Inheritance

Environment
└── MultiTurnEnv
    └── SingleTurnEnv
        └── ReasoningGymEnv

Constructor

ReasoningGymEnv(
    gym: str | List[str | dict],
    num_train_examples: int = 1000,
    num_eval_examples: int = 100,
    system_prompt: str = DEFAULT_SYSTEM_PROMPT,
    parser: vf.Parser | None = None,
    seed: int = 0,
)

Parameters

gym · str | List[str | dict]

Dataset specification. Can be:

• String: Single dataset name (e.g., "arc_1d")
• List of strings: Multiple datasets with equal weights
• List of dicts: Datasets with custom weights and configs using DatasetSpec format

num_train_examples · int · default: "1000"

Number of training examples to generate.

num_eval_examples · int · default: "100"

Number of evaluation examples to generate.

system_prompt · str · default: "DEFAULT_SYSTEM_PROMPT"

System prompt for the model. Defaults to Reasoning Gym’s default prompt.

parser · vf.Parser | None · default: "None"

Parser for model responses. If None, uses XMLParser(fields=["answer"]).

seed · int · default: "0"

Random seed for procedural generation.

Key Methods

build_rg_dataset

def build_rg_dataset(
    gym: str | List[str | dict],
    total_examples: int = 1000,
    seed: int = 0
) -> ProceduralDataset

Construct a Reasoning Gym dataset from the specification.

Handles three formats:

1. String: Single dataset → rg.create_dataset(gym, size=total_examples, seed=seed)
2. List of strings: Multiple datasets with equal weights (1.0 each)
3. List of dicts: Datasets with custom DatasetSpec configurations

rg_to_hf

def rg_to_hf(
    rg_dataset: ProceduralDataset
) -> Tuple[Dataset, Dataset]

Convert Reasoning Gym dataset to HuggingFace datasets for train and eval.

Dataset format:

• question: Task prompt from Reasoning Gym
• answer: Index as string (used to retrieve entry for scoring)
• task: Source dataset name from metadata

Scoring

ReasoningGymEnv automatically creates a rubric with a custom reward function:

async def check_answer_reward_func(
    completion: vf.Messages,
    answer: str,
    **kwargs
) -> float:
    # Get entry by index
    entry = self.rg_dataset[int(answer)]
    # Parse model response
    response = str(parser.parse_answer(completion)).strip()
    # Score using Reasoning Gym's scoring
    reward = self.rg_dataset.score_answer(answer=response, entry=entry)
    return reward

The reward function uses Reasoning Gym’s task-specific scoring, which varies by dataset (exact match, fuzzy match, numeric tolerance, etc.).

Example Usage

Single Dataset

import verifiers as vf
from verifiers.envs.integrations.reasoninggym_env import ReasoningGymEnv

def load_environment():
    return ReasoningGymEnv(
        gym="arc_1d",
        num_train_examples=1000,
        num_eval_examples=100,
        seed=0,
    )

Multiple Datasets (Equal Weights)

import verifiers as vf
from verifiers.envs.integrations.reasoninggym_env import ReasoningGymEnv

def load_environment():
    return ReasoningGymEnv(
        gym=["arc_1d", "gsm8k", "math_count"],
        num_train_examples=3000,  # 1000 per dataset
        num_eval_examples=300,     # 100 per dataset
        seed=42,
    )

Composite Dataset (Custom Weights)

import verifiers as vf
from verifiers.envs.integrations.reasoninggym_env import ReasoningGymEnv

def load_environment():
    # Use dict format for DatasetSpec
    return ReasoningGymEnv(
        gym=[
            {"name": "arc_1d", "weight": 2.0, "config": {}},
            {"name": "gsm8k", "weight": 1.0, "config": {}},
            {"name": "math_count", "weight": 0.5, "config": {}},
        ],
        num_train_examples=1000,
        num_eval_examples=100,
        seed=0,
    )

Custom Parser

import verifiers as vf
from verifiers.envs.integrations.reasoninggym_env import ReasoningGymEnv

def load_environment():
    # Use custom parser for chain-of-thought
    parser = vf.XMLParser(
        fields=["reasoning", "answer"],
        answer_field="answer"
    )
    
    return ReasoningGymEnv(
        gym="gsm8k",
        parser=parser,
        system_prompt="Solve the math problem step by step. Use <reasoning> for your work and <answer> for the final numerical answer.",
        num_train_examples=1000,
    )

With Custom System Prompt

import verifiers as vf
from verifiers.envs.integrations.reasoninggym_env import ReasoningGymEnv
from reasoning_gym.utils import SYSTEM_PROMPTS

def load_environment():
    # Use Reasoning Gym's CoT prompt
    return ReasoningGymEnv(
        gym="arc_1d",
        system_prompt=SYSTEM_PROMPTS["cot"],
        num_train_examples=1000,
    )

Available Datasets

Reasoning Gym provides many procedural datasets. Some popular ones:

• Pattern Recognition: arc_1d, arc_2d
• Math: gsm8k, math_count, number_theory
• Logic: boolean_logic, propositional_logic
• Sequences: sequence_next, sequence_missing
• Spatial: grid_navigation, spatial_reasoning

Check the Reasoning Gym repository for the complete list.

DatasetSpec Format

When using composite datasets with custom weights, use this format:

{
    "name": str,        # Dataset name (e.g., "arc_1d")
    "weight": float,    # Sampling weight (default 1.0)
    "config": dict      # Dataset-specific config (default {})
}

Procedural Generation

All tasks are procedurally generated using seeds:

• Each example gets a unique seed: seed + index
• Same seed always generates the same task
• Infinite variations possible
• Reproducible across runs

See Also

• Reasoning Gym Integration Guide - Setup and dataset details
• SingleTurnEnv - Base class documentation
• XMLParser - Parser for structured responses
• Rubric - Reward function configuration