add ProductsDataset (multiplication tasks)

reasoning_gym/arithmetic/__init__.py

@@ -4,7 +4,7 @@ Arithmetic tasks for training reasoning capabilities:
 
 from .basic_arithmetic import BasicArithmeticDataset, BasicArithmeticDatasetConfig
 from .calendar_arithmetic import CalendarArithmeticConfig, CalendarArithmeticDataset
-from .chain_sum import ChainSum, ChainSumConfig
+from .chain_sum import ChainSumConfig, ChainSumDataset
 from .count_bits import CountBitsConfig, CountBitsDataset
 from .dice import DiceConfig, DiceDataset
 from .fraction_simplification import FractionSimplificationConfig, FractionSimplificationDataset
@@ -14,13 +14,13 @@ from .lcm import LCMConfig, LCMDataset
 from .leg_counting import LegCountingConfig, LegCountingDataset
 from .power_function import PowerFunctionConfig, PowerFunctionDataset
 from .prime_factorization import PrimeFactorizationConfig, PrimeFactorizationDataset
-from .products import Products, ProductsConfig
+from .products import ProductsConfig, ProductsDataset
 from .time_intervals import TimeIntervalsConfig, TimeIntervalsDataset
 
 __all__ = [
     "BasicArithmeticDataset",
     "BasicArithmeticDatasetConfig",
-    "ChainSum",
+    "ChainSumDataset",
     "ChainSumConfig",
     "CalendarArithmeticConfig",
     "CalendarArithmeticDataset",
@@ -36,7 +36,7 @@ __all__ = [
     "PowerFunctionDataset",
     "PrimeFactorizationConfig",
     "PrimeFactorizationDataset",
-    "Products",
+    "ProductsDataset",
     "ProductsConfig",
     "GSMSymbolicDatasetConfig",
     "GSMSymbolicDataset",

reasoning_gym/arithmetic/basic_arithmetic.py

@@ -78,17 +78,17 @@ class BasicArithmeticDataset(ProceduralDataset):
                 - metadata: dict with generation parameters
         """
         # Create deterministic RNG from base seed and idx
-        item_rng = Random(self.seed + idx)
+        rng = Random(self.seed + idx)
 
-        num_terms = item_rng.randint(self.config.min_terms, self.config.max_terms)
-        num_digits = item_rng.randint(self.config.min_digits, self.config.max_digits)
+        num_terms = rng.randint(self.config.min_terms, self.config.max_terms)
+        num_digits = rng.randint(self.config.min_digits, self.config.max_digits)
 
         if self.config.allow_parentheses:
-            expression, result = self._generate_complex_task(item_rng, num_terms, num_digits)
+            expression, result = self._generate_complex_task(rng, num_terms, num_digits)
         else:
-            expression, result = self._generate_simple_task(item_rng, num_terms, num_digits)
+            expression, result = self._generate_simple_task(rng, num_terms, num_digits)
 
-        question = self._format_question(item_rng, expression)
+        question = self._format_question(rng, expression)
 
         return {
             "question": question,

reasoning_gym/arithmetic/calendar_arithmetic.py

@@ -122,9 +122,9 @@ class CalendarArithmeticDataset(ProceduralDataset):
         self.tasks = [self.task_handlers[task] for task in self.config.tasks]
 
     def __getitem__(self, idx: int) -> dict:
-        item_rng = random.Random(self.seed + idx)
-        task = item_rng.choice(self.tasks)
-        question, answer, metadata = task(item_rng)
+        rng = random.Random(self.seed + idx)
+        task = rng.choice(self.tasks)
+        question, answer, metadata = task(rng)
         return {
             "question": question,
             "answer": str(answer),

reasoning_gym/arithmetic/chain_sum.py

@@ -32,7 +32,7 @@ class ChainSumConfig:
             assert 10 ** (self.min_digits - 1) >= 1, "min_digits would result in invalid number range"
 
 
-class ChainSum(ProceduralDataset):
+class ChainSumDataset(ProceduralDataset):
     """Generates simple arithmetic tasks using only + and - operators"""
 
     def __init__(self, config: ChainSumConfig):
@@ -51,16 +51,16 @@ class ChainSum(ProceduralDataset):
                 - metadata: dict with generation parameters
         """
         # Create deterministic RNG from base seed and idx
-        item_rng = random.Random(self.seed + idx)
+        rng = random.Random(self.seed + idx)
 
-        num_terms = item_rng.randint(self.config.min_terms, self.config.max_terms)
-        num_digits = item_rng.randint(self.config.min_digits, self.config.max_digits)
+        num_terms = rng.randint(self.config.min_terms, self.config.max_terms)
+        num_digits = rng.randint(self.config.min_digits, self.config.max_digits)
 
         # Calculate value ranges based on number of digits
         min_value = 0 if num_digits == 1 else 10 ** (num_digits - 1)  # Special case for 1 digit
         max_value = (10**num_digits) - 1  # e.g., 999 for 3 digits
 
-        expression, result = self._generate_task(item_rng, num_terms, min_value, max_value)
+        expression, result = self._generate_task(rng, num_terms, min_value, max_value)
 
         return {
             "question": f"{expression} =",
@@ -143,4 +143,4 @@ class ChainSumCurriculum(BaseCurriculum):
 
 
 # Register the dataset
-register_dataset("chain_sum", ChainSum, ChainSumConfig)
+register_dataset("chain_sum", ChainSumDataset, ChainSumConfig)

reasoning_gym/arithmetic/products.py

@@ -26,7 +26,7 @@ class ProductsConfig:
         assert self.max_digits >= self.min_digits, "max_digits must be >= min_digits"
 
 
-class Products(ProceduralDataset):
+class ProductsDataset(ProceduralDataset):
     """Generates multiplication tasks with configurable number of terms"""
 
     def __init__(self, config: ProductsConfig):
@@ -45,16 +45,16 @@ class Products(ProceduralDataset):
                 - metadata: dict with generation parameters
         """
         # Create deterministic RNG from base seed and idx
-        item_rng = random.Random(self.seed + idx)
+        rng = random.Random(self.seed + idx)
 
-        num_terms = item_rng.randint(self.config.min_terms, self.config.max_terms)
-        num_digits = item_rng.randint(self.config.min_digits, self.config.max_digits)
+        num_terms = rng.randint(self.config.min_terms, self.config.max_terms)
+        num_digits = rng.randint(self.config.min_digits, self.config.max_digits)
 
         # Calculate value ranges based on number of digits
         min_value = 0 if num_digits == 1 else 10 ** (num_digits - 1)  # Special case for 1 digit
         max_value = (10**num_digits) - 1  # e.g., 999 for 3 digits
 
-        expression, result = self._generate_task(item_rng, num_terms, min_value, max_value)
+        expression, result = self._generate_task(rng, num_terms, min_value, max_value)
 
         return {
             "question": f"{expression} =",
@@ -127,4 +127,4 @@ class ProductsCurriculum(BaseCurriculum):
 
 
 # Register the dataset
-register_dataset("products", Products, ProductsConfig)
+register_dataset("products", ProductsDataset, ProductsConfig)

reasoning_gym/arithmetic/time_intervals.py

@@ -82,14 +82,14 @@ class TimeIntervalsDataset(ProceduralDataset):
 
     def __getitem__(self, idx: int) -> dict:
         """Generate a single time interval calculation task"""
-        item_rng = random.Random(self.seed + idx)
+        rng = random.Random(self.seed + idx)
 
         # Randomly choose task type from config
-        task_type = item_rng.choice(self.config.task_types)
+        task_type = rng.choice(self.config.task_types)
 
-        start_time, end_time, format_str, expected_format = self._generate_times(item_rng, task_type)
+        start_time, end_time, format_str, expected_format = self._generate_times(rng, task_type)
 
-        template = item_rng.choice(self.TEMPLATES)
+        template = rng.choice(self.TEMPLATES)
         question = template.format(start=start_time, end=end_time, format=expected_format)
 
         # Calculate the actual difference