diff --git a/reasoning_gym/arithmetic/__init__.py b/reasoning_gym/arithmetic/__init__.py index 12a6ee89..64a9a805 100644 --- a/reasoning_gym/arithmetic/__init__.py +++ b/reasoning_gym/arithmetic/__init__.py @@ -13,6 +13,7 @@ from .gcd import GCDConfig, GCDDataset from .lcm import LCMConfig, LCMDataset from .leg_counting import LegCountingConfig, LegCountingDataset from .prime_factorization import PrimeFactorizationConfig, PrimeFactorizationDataset +from .gsm_symbolic.gsm_symbolic_datasets import GSMSymbolicDataset, GSMSymbolicDatasetConfig __all__ = [ "BasicArithmeticDataset", @@ -30,4 +31,6 @@ __all__ = [ "LegCountingDataset", "PrimeFactorizationConfig", "PrimeFactorizationDataset", + "GSMSymbolicDatasetConfig", + "GSMSymbolicDataset", ] diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_0.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_0.py deleted file mode 100644 index 5e41ad15..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_0.py +++ /dev/null @@ -1,68 +0,0 @@ -from random import Random -from typing import Dict, Any -import math - -def generate_from_variables(name: str, food: str, peel_rate: int, batch_size: int, - time_per_batch: int, total_amount: int) -> Dict[str, Any]: - - peel_time = total_amount // peel_rate - num_batches = total_amount // batch_size - cook_time = num_batches * time_per_batch - total_time = peel_time + cook_time - - question = f"{name} can peel {peel_rate} {food}s a minute and saute {batch_size} {food}s in {time_per_batch} minutes. How long will it take her to peel and saute {total_amount} {food}s?" - - answer_cot = f"First find how long it takes {name} to peel the {food}: {total_amount} {food} / {peel_rate} {food}/minute = {peel_time} minutes\n" \ - f"Then find how many batches of {food} she needs to cook: {total_amount} {food} / {batch_size} {food}/batch = {num_batches} batches\n" \ - f"Then multiply the number of batches by the time per batch to find the total cook time: {num_batches} batches * {time_per_batch} minutes/batch = {cook_time} minutes\n" \ - f"Then add the peeling time to find the total time {name} spends: {cook_time} minutes + {peel_time} minutes = {total_time} minutes\n" \ - f"#### {total_time}" - - return { - 'question': question, - 'answer': str(total_time), - 'answer_cot': answer_cot, - 'answer_value': total_time, - 'variables': { - 'name': name, - 'food': food, - 'peel_rate': peel_rate, - 'batch_size': batch_size, - 'time_per_batch': time_per_batch, - 'total_amount': total_amount, - 'peel_time': peel_time, - 'cook_time': cook_time - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ["Emily", "Sarah", "Emma", "Sophia", "Olivia", "Ava", "Isabella", "Mia"] - foods = ["shrimp", "onion", "carrot", "mushroom", "clam"] - - name = rng.choice(names_female) - food = rng.choice(foods) - - peel_rate = int(rng.randint(4, int(15 * difficulty))) - batch_size = int(rng.randrange(20, int(50 * difficulty), 5)) - time_per_batch = int(rng.randint(5, int(20 * difficulty))) - - # Ensure total is divisible by both peel_rate and batch_size - lcm = peel_rate * batch_size // math.gcd(peel_rate, batch_size) - num_lcm = rng.randint(1, int(4 * difficulty)) - total_amount = lcm * num_lcm - - result = generate_from_variables(name, food, peel_rate, batch_size, time_per_batch, total_amount) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Emily", "shrimp", 6, 30, 10, 90) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_1.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_1.py deleted file mode 100644 index e16e6382..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_1.py +++ /dev/null @@ -1,55 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, family: str, blocks: int, animals: int, - rings: int, total: int) -> Dict[str, Any]: - bouncy_balls = total - (blocks + animals + rings) - - question = f"When {name} watches her {family}, she gets out a variety of toys for him. The bag of building blocks has {blocks} blocks in it. The bin of stuffed animals has {animals} stuffed animals inside. The tower of stacking rings has {rings} multicolored rings on it. {name} recently bought a tube of bouncy balls, bringing her total number of toys for her {family} up to {total}. How many bouncy balls came in the tube?" - - answer_cot = f"Let T be the number of bouncy balls in the tube.\nAfter buying the tube of balls, {name} has {blocks} + {animals} + {rings} + T = {blocks + animals + rings} + T = {total} toys for her {family}.\nThus, T = {total} - {blocks + animals + rings} = {bouncy_balls} bouncy balls came in the tube.\n#### {bouncy_balls}" - - return { - 'question': question, - 'answer': str(bouncy_balls), - 'answer_cot': answer_cot, - 'answer_value': bouncy_balls, - 'variables': { - 'name': name, - 'family': family, - 'building_blocks': blocks, - 'stuffed_animals': animals, - 'stacking_rings': rings, - 'total_toys': total, - 'bouncy_balls': bouncy_balls - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ['Sophie', 'Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia'] - family_members = ['nephew', 'cousin', 'brother'] - - name = rng.choice(names_female) - family = rng.choice(family_members) - - blocks = int(rng.randint(70, int(75 * difficulty))) - animals = int(rng.randint(35, int(50 * difficulty))) - rings = int(rng.randint(20, int(35 * difficulty))) - - total = blocks + animals + rings + int(rng.randint(20, int(100 * difficulty))) - - result = generate_from_variables(name, family, blocks, animals, rings, total) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Sophie', 'nephew', 31, 8, 9, 62) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_10.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_10.py deleted file mode 100644 index 9bb483c8..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_10.py +++ /dev/null @@ -1,63 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name1: str, name2: str, age1: int, years: int, - relation_type: str, mult: int) -> Dict[str, Any]: - future_age = age1 * mult - current_age = future_age - years - - question = f"{name1} is {age1} years old. In {years} years his {relation_type} {name2} will be {mult} times as old as {name1} is now. How old is {name2} right now?" - - answer_cot = f"{years} years from now {name2} will be {age1}*{mult}={future_age}.\nRight now {name2} is {future_age}-{years}={current_age} years old.\n#### {current_age}" - - return { - 'question': question, - 'answer': str(current_age), - 'answer_cot': answer_cot, - 'answer_value': current_age, - 'variables': { - 'name1': name1, - 'name2': name2, - 'age1': age1, - 'years': years, - 'relation_type': relation_type, - 'mult': mult, - 'future_age': future_age, - 'current_age': current_age - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_male = ['James', 'John', 'Robert', 'Michael', 'William', 'David', 'Richard'] - names_female = ['Mary', 'Patricia', 'Jennifer', 'Linda', 'Elizabeth', 'Barbara', 'Susan'] - relation_types = ['sister', 'cousin'] - - name1 = rng.choice(names_male) - name2 = rng.choice(names_female) - relation_type = rng.choice(relation_types) - - age1 = int(rng.randint(8, int(25 * difficulty))) - years = int(rng.randint(2, int(10 * difficulty))) - mult = int(rng.randint(2, int(5 * difficulty))) - - # Ensure conditions are met - while age1 * mult - years <= 0: - age1 = int(rng.randint(8, int(25 * difficulty))) - years = int(rng.randint(2, int(10 * difficulty))) - mult = int(rng.randint(2, int(5 * difficulty))) - - result = generate_from_variables(name1, name2, age1, years, relation_type, mult) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Brett', 'Angela', 14, 4, 'sister', 3) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_11.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_11.py deleted file mode 100644 index e6a91238..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_11.py +++ /dev/null @@ -1,63 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, food1: str, food2: str, mult: int, n: int, - m: int, k: int) -> Dict[str, Any]: - initial_food1 = n * mult # initial corn - initial_total = initial_food1 + n # initial total - bought_food1 = m - k # bought corn - bought_total = bought_food1 + m # total bought - final_total = initial_total + bought_total # final total - - question = f"At {name}'s house, there is {mult} times as much {food1} as {food2}. He has a total of {n} {food2} in his house. {name} bought {m} more {food2} at the store and {k} fewer {food1} than the number of {food2}. Find the combined total of the number of {food1} and {food2} {name} has in the house?" - - answer_cot = f"Before buying any {food1} and {food2}, {name} had {mult} times as many {food1} as {food2}, which is {n} {food2} * {mult} {food1}/{food2} = {initial_food1} {food1}\nThe total number of {food1} and {food2} that {name} had before is {initial_food1} {food1} + {n} {food2} = {initial_total} items\nWhen he bought {k} fewer {food1} than {food2}, he bought {m} {food1} - {k} {food1} = {bought_food1} {food1}\nIn total, he bought {bought_food1} {food1} + {m} {food2} = {bought_total} items\nAfter the purchases, {name} has {initial_total} items + {bought_total} items = {final_total} total {food1} and {food2} combined.\n#### {final_total}" - - return { - 'question': question, - 'answer': str(final_total), - 'answer_cot': answer_cot, - 'answer_value': final_total, - 'variables': { - 'name': name, - 'food1': food1, - 'food2': food2, - 'multiplier': mult, - 'initial_amount': n, - 'bought_amount': m, - 'difference': k, - 'initial_total': initial_total, - 'bought_total': bought_total, - 'final_total': final_total - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Allan", "John", "Michael", "David", "James", "Robert", "William"] - foods = ["corn", "apple", "banana", "orange", "pear", "grape", "fig", - "persimmon", "plum", "kiwi"] - multipliers = ["twice", "three times", "four times"] - - name = rng.choice(names) - food1, food2 = rng.sample(foods, 2) - mult = rng.randint(2, int(4 * difficulty)) - - n = int(rng.randint(20, int(100 * difficulty))) - m = int(rng.randint(30, int(100 * difficulty))) - k = int(rng.randint(10, min(m, int(50 * difficulty)))) - - result = generate_from_variables(name, food1, food2, mult, n, m, k) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Allan", "corn", "cannolis", 2, 40, 60, 40) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_12.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_12.py deleted file mode 100644 index 57b66912..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_12.py +++ /dev/null @@ -1,69 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, game1: str, game2: str, period: str, - time1: int, time2: int, num1: int, num2: int) -> Dict[str, Any]: - total_time1 = time1 * num1 - total_time2 = time2 * num2 - total_time = total_time1 + total_time2 - - question = f"It takes {name} {time1} minutes to finish a {game1} and {time2} minutes to finish a {game2}. Over the {period} she solved {num1} {game1}s and {num2} {game2}s. How much time did she spend playing these games?" - - answer_cot = f"It takes {time1} minutes to complete a {game1} and she completed {num1} for a total of {time1}*{num1} = {total_time1} minutes\n" \ - f"It takes {time2} minutes to complete a {game2} and she completed {num2} for a total of {time2}*{num2} = {total_time2} minutes\n" \ - f"She spent {total_time1} minutes on {game1}s and {total_time2} minutes on {game2}s for a total of {total_time1}+{total_time2} = {total_time} minutes\n" \ - f"#### {total_time}" - - return { - 'question': question, - 'answer': str(total_time), - 'answer_cot': answer_cot, - 'answer_value': total_time, - 'variables': { - 'name': name, - 'game1': game1, - 'game2': game2, - 'period': period, - 'time1': time1, - 'time2': time2, - 'num1': num1, - 'num2': num2, - 'total_time1': total_time1, - 'total_time2': total_time2 - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte"] - games = ["word puzzle", "jigsaw puzzle", "chess puzzle", "riddle", "brain teaser"] - periods = ["weekend", "vacation", "holiday", "day off", "free time"] - - name = rng.choice(names) - game1, game2 = rng.sample(games, 2) - period = rng.choice(periods) - - time1 = int(rng.randint(5, int(30 * difficulty))) - time2 = int(rng.randint(3, int(20 * difficulty))) - while time2 >= time1: # ensure time1 > time2 - time1 = int(rng.randint(5, int(30 * difficulty))) - time2 = int(rng.randint(3, int(20 * difficulty))) - - num1 = int(rng.randint(2, int(10 * difficulty))) - num2 = int(rng.randint(4, int(15 * difficulty))) - - result = generate_from_variables(name, game1, game2, period, time1, time2, num1, num2) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Carmen", "crossword puzzle", "sudoku puzzle", - "weekend", 10, 5, 3, 8) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_13.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_13.py deleted file mode 100644 index 14a39237..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_13.py +++ /dev/null @@ -1,66 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(park_name: str, unit: str, length1: int, length2: int, - speed1: int, speed2: int) -> Dict[str, Any]: - time1 = length1 // speed1 - time2 = length2 // speed2 - time_diff = time1 - time2 - - question = f"The biggest waterslide at {park_name} is {length1} {unit} long, and people slide down at {speed1} {unit}/minute. The second biggest waterslide is {length2} {unit} long, but steeper, so people slide down at {speed2} {unit}/minute. How much longer does it take to ride the biggest slide compared to the second biggest slide?" - - answer_cot = f"First find the ride length of the biggest slide: {length1} {unit} / {speed1} {unit}/minute = {time1} minutes\nThen find the ride length of the second biggest slide: {length2} {unit} / {speed2} {unit}/minute = {time2} minutes\nThen subtract the ride length of the second longest slide from the longest slide to find the difference: {time1} minutes - {time2} minutes = {time_diff} minutes\n#### {time_diff}" - - return { - 'question': question, - 'answer': str(time_diff), - 'answer_cot': answer_cot, - 'answer_value': time_diff, - 'variables': { - 'park_name': park_name, - 'unit': unit, - 'length1': length1, - 'length2': length2, - 'speed1': speed1, - 'speed2': speed2, - 'time1': time1, - 'time2': time2 - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - parks = ["Splash World", "Aqua Adventure", "Water Wonderland", "Neptunes Kingdom"] - units = ['yards', 'meters'] - - park_name = rng.choice(parks) - unit = rng.choice(units) - - length1 = int(rng.randrange(250, int(401 * difficulty), 10)) - length2 = int(rng.randrange(200, int(301 * difficulty), 10)) - speed1 = int(rng.randrange(40, int(81 * difficulty), 5)) - speed2 = int(rng.randrange(60, int(101 * difficulty), 5)) - - # Ensure conditions are met - while (length1 <= length2 or speed2 <= speed1 or - length1 % speed1 != 0 or length2 % speed2 != 0 or - (length1 // speed1) <= (length2 // speed2)): - length1 = int(rng.randrange(250, int(401 * difficulty), 10)) - length2 = int(rng.randrange(200, int(301 * difficulty), 10)) - speed1 = int(rng.randrange(40, int(81 * difficulty), 5)) - speed2 = int(rng.randrange(60, int(101 * difficulty), 5)) - - result = generate_from_variables(park_name, unit, length1, length2, speed1, speed2) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Five Flags", "feet", 300, 240, 60, 80) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_14.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_14.py deleted file mode 100644 index 1e57c32b..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_14.py +++ /dev/null @@ -1,62 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, day1: str, day2: str, day3: str, - time1: int, time2: int, mult: int) -> Dict[str, Any]: - combined_time = time1 + time2 - target_time = combined_time * mult - - question = f"On {day3}, {name} wants to exercise for {mult} the amount of time he did on {day2} and {day1} combined. On {day1} he exercised for {time1} minutes. On {day2} he exercised for {time2} minutes. How many minutes does he have to exercise on {day3} to reach his goal?" - - answer_cot = f"On {day1} and {day2} he exercised a total of {combined_time} minutes because {time1} + {time2} = {combined_time}\nOn {day3} he has to exercise for {target_time} minutes because {combined_time} x {mult} = {target_time}\n#### {target_time}" - - return { - 'question': question, - 'answer': str(target_time), - 'answer_cot': answer_cot, - 'answer_value': target_time, - 'variables': { - 'name': name, - 'day1': day1, - 'day2': day2, - 'day3': day3, - 'time1': time1, - 'time2': time2, - 'multiplier': mult, - 'combined_time': combined_time, - 'target_time': target_time - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Peter", "John", "Michael", "David", "James", "Robert", "William"] - weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"] - multipliers = [2, 3, 4] - - name = rng.choice(names) - day1, day2, day3 = rng.sample(weekdays, 3) - mult = rng.choice(multipliers) - - time1 = int(rng.randint(10, int(60 * difficulty))) - time2 = int(rng.randint(10, int(60 * difficulty))) - - # Check conditions - while (time1 + time2) <= 0 or ((time1 + time2) * mult / 60) >= 14: - time1 = int(rng.randint(10, int(60 * difficulty))) - time2 = int(rng.randint(10, int(60 * difficulty))) - - result = generate_from_variables(name, day1, day2, day3, time1, time2, mult) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Peter", "Sunday", "Monday", "Tuesday", 23, 16, 2) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_15.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_15.py deleted file mode 100644 index 7abb0fba..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_15.py +++ /dev/null @@ -1,79 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, sport: str, item1: str, item2: str, - item3: str, item4: str, currency: str, price1: int, - price2: int, price3: int, price4: int, discount: int) -> Dict[str, Any]: - - shorts_price = price1 + price2 - shoes_price = price3 // 2 - socks_price = price4 - discount - total = price1 + shorts_price + shoes_price + socks_price - - question = f"{name} qualified for a spot on the {sport} team, so she went shopping for some athletic gear. She bought a {item1} for {currency}{price1}, a pair of {sport} {item2} for {currency}{price2} more than the {item1} cost, and a pair of {item3} that were originally {currency}{price3} but were on sale for half price. She had a coupon for {currency}{discount} off the package of {currency}{price4} athletic {item4} that she also bought. How much did she spend on athletic gear?" - - answer_cot = f"The {item2} were {currency}{price2} more than the {item1}, so they cost {currency}{price2} + {currency}{price1} = {currency}{shorts_price}.\nHer {item3} were half the original {currency}{price3} price, so they cost {currency}{price3} / 2 = ${shoes_price}.\nWith her coupon, the {item4} were {currency}{price4} - {currency}{discount} = {currency}{socks_price}.\nThe {item1}, {item2}, {item3}, and {item4} together cost {currency}{price1} + {currency}{shorts_price} + {currency}{shoes_price} + {currency}{socks_price} = {currency}{total}.\n#### {total}" - - return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'name': name, - 'sport': sport, - 'item1': item1, - 'item2': item2, - 'item3': item3, - 'item4': item4, - 'currency': currency, - 'price1': price1, - 'price2': price2, - 'price3': price3, - 'price4': price4, - 'discount': discount - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte", "Amelia"] - sports = ["swimming", "cycling", "basketball", "soccer", "volleyball"] - items1 = ["t-shirt", "jersey", "sports bra"] - items2 = ["shorts", "leggings", "sweatpants"] - items3 = ["sneakers", "cleats", "athletic shoes"] - items4 = ["socks", "headbands", "wristbands"] - currencies = ["$", "€", "£"] - - name = rng.choice(names_female) - sport = rng.choice(sports) - item1 = rng.choice(items1) - item2 = rng.choice(items2) - item3 = rng.choice(items3) - item4 = rng.choice(items4) - currency = rng.choice(currencies) - - price1 = int(rng.randint(8, int(25 * difficulty))) - price2 = int(rng.randint(3, int(15 * difficulty))) - price4 = int(rng.randint(5, int(15 * difficulty))) - discount = int(rng.randint(1, min(5, price4))) - - # Ensure price3 is even for clean division by 2 - price3 = int(rng.randint(30, int(80 * difficulty)) // 2 * 2) - - result = generate_from_variables(name, sport, item1, item2, item3, item4, currency, - price1, price2, price3, price4, discount) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Alison", "running", "tank top", "shorts", - "tennis shoes", "socks", "$", 10, 5, 48, 8, 2) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_16.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_16.py deleted file mode 100644 index 7d0f7fe3..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_16.py +++ /dev/null @@ -1,64 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name1: str, name2: str, name3: str, platform: str, - mult1: int, mult2: int, n: int) -> Dict[str, Any]: - base_friends = n // mult1 # Dorothy's friends - charlie_friends = n # Charlie's friends - james_friends = base_friends * mult2 # James's friends - - question = f"{name1} has {mult1} times as many {platform} friends as {name2}. {name3} has {mult2} times as many friends on {platform} as {name2}. If {name1} has {n} friends on {platform}, how many {platform} friends does {name3} have?" - - answer_cot = f"{name2} has {n} / {mult1} = {base_friends} {platform} friends.\n{name3} has {mult2} * {base_friends} = {james_friends} {platform} friends.\n#### {james_friends}" - - return { - 'question': question, - 'answer': str(james_friends), - 'answer_cot': answer_cot, - 'answer_value': james_friends, - 'variables': { - 'name1': name1, - 'name2': name2, - 'name3': name3, - 'platform': platform, - 'mult1': mult1, - 'mult2': mult2, - 'base_friends': base_friends, - 'charlie_friends': charlie_friends, - 'james_friends': james_friends - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['Charlie', 'Dorothy', 'James', 'Sarah', 'Michael', 'Emily', 'David'] - platforms = ['Instagram', 'Twitter', 'LinkedIn', 'TikTok', 'Snapchat'] - - name1, name2, name3 = rng.sample(names, 3) - platform = rng.choice(platforms) - - # Generate multipliers that will be different - mult1 = rng.randint(2, int(5 * difficulty)) - mult2 = rng.randint(2, int(5 * difficulty)) - while mult2 == mult1: - mult2 = rng.randint(2, int(5 * difficulty)) - - # Generate n that's divisible by mult1 - base = rng.randint(4, int(20 * difficulty)) - n = base * mult1 - - result = generate_from_variables(name1, name2, name3, platform, mult1, mult2, n) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Charlie', 'Dorothy', 'James', 'Facebook', - 3, 4, 12) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_17.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_17.py deleted file mode 100644 index e5346be4..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_17.py +++ /dev/null @@ -1,72 +0,0 @@ -from random import Random -from typing import Dict, Any -from fractions import Fraction - -def generate_from_variables(facility: str, total: int, item: str, frac: Fraction, - event: str, daily: int, period: int) -> Dict[str, Any]: - initial_occupied = int(total * frac) - initial_empty = total - initial_occupied - weekly_admitted = daily * 7 - total_admitted = weekly_admitted * period - final_empty = initial_empty - total_admitted - - question = f"A {facility} has a capacity of {total} {item}s with {frac} occupied. Due to the {event}, {daily} patients are admitted into the {facility} each day. Calculate the total number of unoccupied {item}s in the {facility} after {period} weeks." - - answer_cot = f"If {frac} of the total capacity of the {facility} {item}s is occupied, it means {frac} * {total} = {initial_occupied} {item}s have patients using them.\nThe total number of {item}s in the {facility} without new admissions is {total} {item}s - {initial_occupied} {item}s = {initial_empty} {item}s.\nIf {daily} people are admitted each day, the total number of patients in the {facility} after one week is {daily} patients/day * 7 days/week = {weekly_admitted} patients.\nAfter {period} weeks, the total number of patients admitted into the {facility} is {weekly_admitted} patients/week * {period} weeks = {total_admitted} patients, who each use one {item}.\nIf there were {initial_empty} unoccupied {item}s in the {facility} before the new admissions, the total number is reduced to {initial_empty} {item}s - {total_admitted} {item}s = {final_empty} unoccupied {item}s.\n#### {final_empty}" - - return { - 'question': question, - 'answer': str(final_empty), - 'answer_cot': answer_cot, - 'answer_value': final_empty, - 'variables': { - 'facility': facility, - 'total_capacity': total, - 'item': item, - 'initial_fraction': frac, - 'event': event, - 'daily_patients': daily, - 'period_weeks': period, - 'initial_occupied': initial_occupied, - 'initial_empty': initial_empty, - 'total_admitted': total_admitted - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - facilities = ["hospital", "clinic", "medical center", "care facility"] - items = ["bed", "room", "ward"] - events = ["flu season", "natural disaster", "major accident", "pandemic"] - fractions = [Fraction(1,5), Fraction(1,4), Fraction(1,3), Fraction(1,2)] - - facility = rng.choice(facilities) - item = rng.choice(items) - event = rng.choice(events) - frac = rng.choice(fractions) - - total = int(rng.randint(500, int(2000 * difficulty)) // 100 * 100) - daily = int(rng.randint(20, int(100 * difficulty)) // 5 * 5) - period = int(rng.randint(2, int(5 * difficulty))) - - # Ensure conditions are met - while not (total * frac).is_integer() or total * frac + daily * period * 7 >= total: - total = int(rng.randint(500, int(2000 * difficulty)) // 100 * 100) - daily = int(rng.randint(20, int(100 * difficulty)) // 5 * 5) - period = int(rng.randint(2, int(5 * difficulty))) - - result = generate_from_variables(facility, total, item, frac, event, daily, period) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("hospital", 1000, "bed", Fraction(1,5), - "coronavirus outbreak", 50, 2) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_18.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_18.py deleted file mode 100644 index bf532ec6..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_18.py +++ /dev/null @@ -1,60 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name1: str, name2: str, game: str, n1: int, n2: int, frac: float) -> Dict[str, Any]: - score2 = int(frac * n1 + n2) - total = n1 + score2 - - question = f"{name1} scored {n1} points in one game of {game}. {name2} scored {n2} more than {frac:.0%} as many as {name1}. How many points did {name1} and {name2} have in total?" - - answer_cot = f"{name1} = {n1} points\n{name2} = {frac} * {n1} + {n2} = {score2} points\n{n1} + {score2} = {total} points\nTogether, {name1} and {name2} scored {total} points.\n#### {total}" - - return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'name1': name1, - 'name2': name2, - 'game': game, - 'score1': n1, - 'bonus': n2, - 'fraction': frac, - 'score2': score2, - 'total_score': total - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph", "Thomas", "Charles", - "Mary", "Patricia", "Jennifer", "Linda", "Elizabeth", "Barbara", "Susan", "Jessica", "Sarah", "Karen"] - games = ["bowling", "darts", "archery", "basketball", "tennis"] - fractions = [0.5] # Could add more fractions if needed - - name1, name2 = rng.sample(names, 2) - game = rng.choice(games) - frac = rng.choice(fractions) - - n1 = int(rng.randint(200, int(500 * difficulty))) - n2 = int(rng.randint(5, int(50 * difficulty))) - - # Ensure fraction calculation results in integer - while not float(frac * n1).is_integer(): - n1 = int(rng.randint(200, int(500 * difficulty))) - - result = generate_from_variables(name1, name2, game, n1, n2, frac) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Pierson", "Nikita", "bowling", 278, 11, 0.5) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_19.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_19.py deleted file mode 100644 index b11e7475..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_19.py +++ /dev/null @@ -1,69 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, pan: str, initial_kernels: int, time_interval: int, - multiplier_2: int, multiplier_3: int) -> Dict[str, Any]: - second_interval = multiplier_2 * initial_kernels - third_interval = multiplier_3 * initial_kernels - fourth_interval = third_interval // 2 - residual = fourth_interval // 4 - total = initial_kernels + second_interval + third_interval + fourth_interval + residual - - question = f"{name} is popping popcorn for a snack. As the {pan} of kernels heats up, the kernels start popping faster. {initial_kernels} pop in the first {time_interval} seconds of cooking, then {multiplier_2} times that amount in the next {time_interval} seconds. The kernels increase to {multiplier_3} times the initial popping rate in the next {time_interval} seconds, but in the final {time_interval} seconds, the popping slows down to half the rate as the past {time_interval} seconds. After {name} takes the {pan} off the heat, a quarter of the number of kernels that popped in the final {time_interval} seconds of cooking also pop from the residual heat. How many pieces of popcorn does {name} have to eat?" - - answer_cot = f"In the second {time_interval} seconds of cooking, {multiplier_2} * {initial_kernels} = {second_interval} kernels pop.\nIn the third {time_interval} seconds, {multiplier_3} * {initial_kernels} = {third_interval} kernels pop.\nIn the final {time_interval} seconds, {third_interval} / 2 = {fourth_interval} kernels pop.\nAfter cooking, the residual heat makes {fourth_interval} / 4 = {residual} kernels pop.\nThus, {name} has {initial_kernels} + {second_interval} + {third_interval} + {fourth_interval} + {residual} = {total} pieces of popcorn to eat.\n#### {total}" - - return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'name': name, - 'pan': pan, - 'initial_kernels': initial_kernels, - 'time_interval': time_interval, - 'multiplier_2': multiplier_2, - 'multiplier_3': multiplier_3, - 'second_interval': second_interval, - 'third_interval': third_interval, - 'fourth_interval': fourth_interval, - 'residual': residual, - 'total': total - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Garrett", "James", "Michael", "David", "John", "Robert", "William"] - pans = ["pan", "pot", "skillet"] - - name = rng.choice(names) - pan = rng.choice(pans) - - # Generate numbers ensuring divisibility conditions are met - initial_kernels = int(rng.randint(10, int(101 * difficulty)) // 10 * 10) - time_interval = int(rng.randint(10, int(31 * difficulty)) // 2 * 2) - multiplier_2 = rng.randint(2, int(5 * difficulty)) - - # Ensure multiplier_3 > multiplier_2 and results in clean division by 8 - while True: - multiplier_3 = rng.randint(multiplier_2 + 1, int(8 * difficulty)) - if (multiplier_3 * initial_kernels) % 8 == 0: - break - - result = generate_from_variables(name, pan, initial_kernels, time_interval, - multiplier_2, multiplier_3) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Garrett", "pan", 20, 30, 3, 4) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_2.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_2.py deleted file mode 100644 index 42fb1967..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_2.py +++ /dev/null @@ -1,77 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(teacher: str, total: int, p1: int, p2: int, - group1: str, group2: str, group3: str, - event: str) -> Dict[str, Any]: - group1_count = int(total * p1 / 100) - remaining = total - group1_count - group23_count = int(remaining * p2 / 100) - total_leaving = group1_count + group23_count - - question = f"In {teacher}'s class of {total} students, {p1}% of the class are {group1}. Out of the remaining class, {p2}% of the students are {group2} or part of {group3}. These 3 groups of students will need to leave early today to travel to an away {event}. How many students are leaving early?" - - answer_cot = f"{p1}% of the {total} student class are {group1} so that's {p1/100}*{total} = {group1_count} students\n" \ - f"There are {total} students and {group1_count} are {group1} so that leaves {total}-{group1_count} = {remaining} students\n" \ - f"{p2}% of the remaining {remaining} students are part of {group3} or {group2} so that's {p2/100}*{remaining} = {group23_count} students\n" \ - f"{group1_count} students are {group1} and {group23_count} are part of {group3}/{group2} so {group1_count}+{group23_count} = {total_leaving} students will be leaving early\n" \ - f"#### {total_leaving}" - - return { - 'question': question, - 'answer': str(total_leaving), - 'answer_cot': answer_cot, - 'answer_value': total_leaving, - 'variables': { - 'teacher': teacher, - 'total_students': total, - 'percent_group1': p1, - 'percent_group23': p2, - 'group1': group1, - 'group2': group2, - 'group3': group3, - 'event': event, - 'group1_count': group1_count, - 'group23_count': group23_count - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - teachers = ['Ms. Johnson', 'Mr. Smith', 'Dr. Lee', 'Mrs. Garcia'] - sports = ['soccer players', 'basketball players', 'volleyball players', 'swimmers'] - activities = ['dancers', 'choir members', 'debate team members', 'robotics club members'] - events = ['competition', 'tournament', 'performance', 'meet'] - - teacher = rng.choice(teachers) - group1 = rng.choice(sports) - group2, group3 = rng.sample(activities, 2) - event = rng.choice(events) - - total = int(rng.randint(20, int(150 * difficulty))) - p1 = int(rng.randint(10, min(50, int(100 * difficulty)))) - p2 = int(rng.randint(15, min(45, int(100 * difficulty)))) - - # Ensure conditions are met - while not (p1 < 100 and p2 < 100 and - (total * p1) % 100 == 0 and - ((total - total * p1 / 100) * p2) % 100 == 0): - total = int(rng.randint(20, int(150 * difficulty))) - p1 = int(rng.randint(10, min(50, int(100 * difficulty)))) - p2 = int(rng.randint(15, min(45, int(100 * difficulty)))) - - result = generate_from_variables(teacher, total, p1, p2, group1, group2, group3, event) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Mr. Roper', 30, 20, 25, 'football players', - 'cheerleaders', 'band', 'game') diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_20.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_20.py deleted file mode 100644 index ea0f58e5..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_20.py +++ /dev/null @@ -1,60 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, obj: str, surface: str, - capacity: int, total: int, num_trays: int) -> Dict[str, Any]: - max_capacity = capacity * num_trays - leftover = total - max_capacity - - question = f"{name} places {obj}s on the {surface}. Each {surface} can hold {capacity} {obj}s. If he has {total} {obj}s and {num_trays} {surface}s, how many {obj}s won't he be able to place on the {surface}?" - - answer_cot = f"{name} will be able to place a total of {capacity} x {num_trays} = {max_capacity} {obj}s.\nTherefore, there are {total} - {max_capacity} = {leftover} {obj}s that he won't be able to place on the {surface}.\n#### {leftover}" - - return { - 'question': question, - 'answer': str(leftover), - 'answer_cot': answer_cot, - 'answer_value': leftover, - 'variables': { - 'name': name, - 'obj': obj, - 'surface': surface, - 'capacity_per_tray': capacity, - 'total_items': total, - 'num_trays': num_trays, - 'max_capacity': max_capacity, - 'leftover': leftover - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['James', 'John', 'Robert', 'Michael', 'William', 'David', 'Richard'] - objects = ['olive', 'almond', 'cookie', 'cracker', 'banana'] - surfaces = ['plate', 'table', 'bowl', 'tray', 'basket'] - - name = rng.choice(names) - obj = rng.choice(objects) - surface = rng.choice(surfaces) - - capacity = int(rng.randint(20, int(51 * difficulty))) - num_trays = int(rng.randint(2, int(7 * difficulty))) - - # Ensure total is greater than max capacity - max_capacity = capacity * num_trays - total = max_capacity + int(rng.randint(1, int(20 * difficulty))) - - result = generate_from_variables(name, obj, surface, capacity, total, num_trays) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Jaime', 'egg', 'tray', 24, 64, 2) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_21.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_21.py deleted file mode 100644 index 56d28524..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_21.py +++ /dev/null @@ -1,72 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, length: int, unit_length: str, plant_width: int, - space: float, owned: int, currency: str, cost: int) -> Dict[str, Any]: - total_plants = int(length / space) - plants_to_buy = total_plants - owned - total_cost = plants_to_buy * cost - - question = f"{name} has a flower bed that is {length} {unit_length} long. {name} wants to fill her flower bed with plants. {name}'s flowers grow {plant_width} inches wide so she needs to leave {space} {unit_length} between every plant. {name} already owns {owned} flowers. Each flowering plant costs {currency}{cost} at the store, how much money will {name} spend at the store to fill up her flower bed?" - - answer_cot = f"{name}'s flower bed is {length} {unit_length} / {space} {unit_length} per plant = {total_plants} plants needed.\n{name} needs to buy {total_plants} plants - {owned} plants = {plants_to_buy} plants needed to purchase.\n{name} will spend {plants_to_buy} plants * {currency}{cost} = {currency}{total_cost}.\n#### {total_cost}" - - return { - 'question': question, - 'answer': str(total_cost), - 'answer_cot': answer_cot, - 'answer_value': total_cost, - 'variables': { - 'name': name, - 'bed_length': length, - 'unit': unit_length, - 'plant_width': plant_width, - 'plant_spacing': space, - 'owned_plants': owned, - 'currency': currency, - 'cost_per_plant': cost, - 'total_plants': total_plants, - 'plants_to_buy': plants_to_buy - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ['Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia', 'Charlotte'] - currencies = ['$', '£', '€'] - units = ['feet', 'meters'] - - name = rng.choice(names_female) - unit = rng.choice(units) - currency = rng.choice(currencies) - - length = int(rng.randint(110, int(220 * difficulty))) - plant_width = int(rng.randint(2, int(8 * difficulty))) - space = round(rng.uniform(1.25, 2.0) * difficulty, 2) - owned = int(rng.randint(10, int(30 * difficulty))) - cost = int(rng.randint(3, int(15 * difficulty))) - - # Ensure conditions are met - while not (plant_width * 3 < length and - plant_width < space and - length % space == 0 and - length / space > owned): - length = int(rng.randint(110, int(220 * difficulty))) - space = round(rng.uniform(1.25, 2.0) * difficulty, 2) - owned = int(rng.randint(10, int(30 * difficulty))) - - result = generate_from_variables(name, length, unit, plant_width, space, owned, - currency, cost) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Pat', 111, 'feet', 12, 1.5, 17, '$', 6) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_22.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_22.py deleted file mode 100644 index c11913f9..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_22.py +++ /dev/null @@ -1,70 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, property_type: str, budget: int, price: int, - brokerage_fee: int, transfer_fee: int) -> Dict[str, Any]: - brokerage_amount = int(price * brokerage_fee / 100) - transfer_amount = int(price * transfer_fee / 100) - total_price = price + brokerage_amount + transfer_amount - difference = total_price - budget - - question = f"{name} is looking for a {property_type} that will not go beyond her ${budget:,} budget. She saw a property that has a selling price of ${price:,}. On top of that, the buyer has to pay a brokerage fee which is {brokerage_fee}% of the selling price, and also the transfer fee that is {transfer_fee}% of the selling price. How much more is the total price of the {property_type} than {name}'s budget?" - - answer_cot = f"The brokerage fee is ${price:,} x {brokerage_fee}/100 = ${brokerage_amount:,}.\nThe transfer fee is ${price:,} x {transfer_fee}/100 = ${transfer_amount:,}.\nThe total price of the {property_type} is ${price:,} + ${brokerage_amount:,} + ${transfer_amount:,} = ${total_price:,}.\nSo, it is ${total_price:,} - ${budget:,} = ${difference:,} more than {name}'s budget.\n#### {difference}" - - return { - 'question': question, - 'answer': f'{difference}', - 'answer_cot': answer_cot, - 'answer_value': difference, - 'variables': { - 'name': name, - 'property_type': property_type, - 'budget': budget, - 'price': price, - 'brokerage_fee': brokerage_fee, - 'transfer_fee': transfer_fee, - 'brokerage_amount': brokerage_amount, - 'transfer_amount': transfer_amount, - 'total_price': total_price - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['Mrs. Smith', 'Ms. Johnson', 'Dr. Patel', 'Mrs. Lee'] - property_types = ['house', 'apartment', 'condo', 'townhouse'] - - name = rng.choice(names) - property_type = rng.choice(property_types) - - # Scale ranges by difficulty while maintaining integer results - budget = int(rng.randrange(300000, int(500000 * difficulty), 10000)) - price = int(rng.randrange(250000, budget, 10000)) - brokerage_fee = int(rng.randint(3, 8)) - transfer_fee = int(rng.randint(10, 15)) - - # Verify conditions - while True: - total_cost = price * (1 + brokerage_fee/100 + transfer_fee/100) - if (total_cost > budget + 1 and - price * brokerage_fee % 100 == 0 and - price * transfer_fee % 100 == 0): - break - price = int(rng.randrange(250000, budget, 10000)) - - result = generate_from_variables(name, property_type, budget, price, - brokerage_fee, transfer_fee) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Mrs. Cruz', 'house', 400000, 350000, 5, 12) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_23.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_23.py deleted file mode 100644 index a1a82fa5..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_23.py +++ /dev/null @@ -1,70 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, task: str, profession: str, hours: int, - work_type: str, rate: int, fee: int, currency: str) -> Dict[str, Any]: - lost_income = hours * rate - savings = lost_income - fee - - question = f"{name} is trying to decide whether to do {task} herself or hire an {profession}. If she does it herself, she'll be able to do {hours} fewer hours of {work_type} work, losing {currency}{rate}/hour in missed income. The {profession} charges {currency}{fee}. How much more money will she have if she hires the {profession}?" - - answer_cot = f"First find the total lost revenue if {name} does {task} herself: {currency}{rate}/hour * {hours} hours = {currency}{lost_income}\nThen subtract the {profession}'s charge to find how much money {name} saves: {currency}{lost_income} - {currency}{fee} = {currency}{savings}\n#### {savings}" - - return { - 'question': question, - 'answer': str(savings), - 'answer_cot': answer_cot, - 'answer_value': savings, - 'variables': { - 'name': name, - 'task': task, - 'profession': profession, - 'hours': hours, - 'work_type': work_type, - 'hourly_rate': rate, - 'fee': fee, - 'currency': currency, - 'lost_income': lost_income - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ['Emma', 'Sophia', 'Isabella', 'Olivia', 'Ava', 'Mia', 'Emily'] - tasks = ["her taxes", "her financial planning", "her business accounting"] - professions = ["accountant", "financial advisor", "tax consultant", "bookkeeper"] - work_types = ["freelance", "consulting", "part-time", "contract"] - currencies = ['$', '€', '£'] - - name = rng.choice(names_female) - task = rng.choice(tasks) - profession = rng.choice(professions) - work_type = rng.choice(work_types) - currency = rng.choice(currencies) - - hours = int(rng.randint(4, int(14 * difficulty))) - rate = int(rng.randint(20, int(100 * difficulty))) - fee = int(rng.randint(50, int(200 * difficulty))) - - # Ensure conditions are met - while hours * rate <= fee: - hours = int(rng.randint(4, int(14 * difficulty))) - rate = int(rng.randint(20, int(100 * difficulty))) - fee = int(rng.randint(50, int(200 * difficulty))) - - result = generate_from_variables(name, task, profession, hours, work_type, - rate, fee, currency) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Jackie", "her taxes", "accountant", 3, - "freelance", 35, 90, "$") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_24.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_24.py deleted file mode 100644 index 4567dce5..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_24.py +++ /dev/null @@ -1,66 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(comet_name: str, name: str, relative: str, orbit_period: int, - relative_age: int, multiple: int) -> Dict[str, Any]: - second_viewing_age = relative_age * multiple - first_viewing_age = second_viewing_age - orbit_period - - question = f"Comet {comet_name} orbits the sun every {orbit_period} years. {name}'s {relative} saw the Comet when he was {relative_age} years old. {name} saw the comet a second time when he was {multiple} times the age his {relative} was when he saw the Comet. How old was {name} when he saw the Comet for the first time?" - - answer_cot = f"{name} saw the Comet for the second time when he was {relative_age} years * {multiple}= {second_viewing_age} years old.\nComet {comet_name} can be seen every {orbit_period} years, so {name} saw the comet for the first time when he was {second_viewing_age} years - {orbit_period} years = {first_viewing_age} years old.\n#### {first_viewing_age}" - - return { - 'question': question, - 'answer': str(first_viewing_age), - 'answer_cot': answer_cot, - 'answer_value': first_viewing_age, - 'variables': { - 'comet_name': comet_name, - 'name': name, - 'relative': relative, - 'orbit_period': orbit_period, - 'relative_age': relative_age, - 'multiple': multiple, - 'second_viewing_age': second_viewing_age, - 'first_viewing_age': first_viewing_age - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - comets = ['Halley', 'Hale-Bopp', 'Hyakutake', 'Encke'] - names = ['William', 'James', 'John', 'Robert', 'Michael', 'David'] - relatives = ['dad', 'father', 'uncle', 'grandfather'] - multiples = ['two', 'three', 'four'] - - comet_name = rng.choice(comets) - name = rng.choice(names) - relative = rng.choice(relatives) - multiple = rng.choice(multiples) - multiple_num = {'two': 2, 'three': 3, 'four': 4}[multiple] - - orbit_period = int(rng.randrange(50, int(101 * difficulty), 5)) - relative_age = int(rng.randint(20, int(51 * difficulty))) - - # Ensure conditions are met - while (multiple_num * relative_age >= 100 or - multiple_num * relative_age <= orbit_period or - (multiple_num * relative_age - orbit_period) % 1 != 0): - relative_age = int(rng.randint(20, int(51 * difficulty))) - - result = generate_from_variables(comet_name, name, relative, orbit_period, - relative_age, multiple_num) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Halley', 'Bill', 'dad', 75, 30, 3) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_25.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_25.py deleted file mode 100644 index 92f08872..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_25.py +++ /dev/null @@ -1,77 +0,0 @@ -from random import Random -from typing import Dict, Any -from fractions import Fraction - -def generate_from_variables(food: str, calories: int, size: int, servings: int, - total_target: int, consumed: int, unit: str) -> Dict[str, Any]: - - calories_left = total_target - consumed - serving_fraction = Fraction(calories_left, calories) - grams_per_serving = size // servings - grams_allowed = grams_per_serving * serving_fraction - - question = f"According to its nutritional info, a bag of {food} has {calories} calories per serving. If a {size} {unit} bag has {servings} servings, how many {unit} can you eat if your daily calorie target is {total_target} and you have already consumed {consumed} calories?" - - answer_cot = f"If the total calorie target is {total_target} and I have consumed {consumed} calories then I have {total_target}-{consumed} = {calories_left} calories left to eat\n" \ - f"If each serving of {food} has {calories} calories and I only have {calories_left} calories left to eat, then I can only eat {calories_left}/{calories} of a serving = {serving_fraction} of a serving\n" \ - f"We also know that a {size} {unit} bag of {food} has {servings} servings, hence each serving has {size} {unit}/{servings} = {grams_per_serving} {unit}\n" \ - f"If I can only eat {serving_fraction} of a serving, then I can eat only {grams_per_serving} * {serving_fraction} = {grams_allowed} {unit}\n" \ - f"#### {float(grams_allowed)}" - - return { - 'question': question, - 'answer': str(float(grams_allowed)), - 'answer_cot': answer_cot, - 'answer_value': float(grams_allowed), - 'variables': { - 'food': food, - 'calories': calories, - 'size': size, - 'servings': servings, - 'total_target': total_target, - 'consumed': consumed, - 'unit': unit, - 'calories_left': calories_left, - 'grams_per_serving': grams_per_serving, - 'serving_fraction': serving_fraction - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - foods = ["popcorn", "breads", "cookies"] - units = ["grams", "ounces", "oz"] - - food = rng.choice(foods) - unit = rng.choice(units) - - calories = int(rng.randint(150, int(500 * difficulty)) // 25 * 25) - size = int(rng.randint(100, int(400 * difficulty)) // 25 * 25) - servings = int(rng.randint(4, int(8 * difficulty))) - total_target = int(rng.randint(1900, int(2500 * difficulty)) // 5 * 5) - consumed = int(rng.randint(600, int(1800 * difficulty)) // 25 * 25) - - # Ensure conditions are met - while (consumed >= total_target or - not (size % servings == 0) or - not ((size//servings) * Fraction(total_target-consumed, calories)).denominator == 1): - calories = int(rng.randint(150, int(500 * difficulty)) // 25 * 25) - size = int(rng.randint(100, int(400 * difficulty)) // 25 * 25) - servings = int(rng.randint(4, int(8 * difficulty))) - total_target = int(rng.randint(1900, int(2500 * difficulty)) // 5 * 5) - consumed = int(rng.randint(600, int(1800 * difficulty)) // 25 * 25) - - result = generate_from_variables(food, calories, size, servings, total_target, consumed, unit) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("chips", 250, 300, 5, 2000, 1800, "grams") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_26.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_26.py deleted file mode 100644 index 10e8454b..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_26.py +++ /dev/null @@ -1,57 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(n: int, ball_type: str, color: str, frac_1: float, frac_2: float) -> Dict[str, Any]: - first_calc = int(n * frac_1) - final_calc = int(first_calc * frac_2) - - question = f"A juggler can juggle {n} balls. {frac_1:.0%} of the balls are {ball_type} balls, and {frac_2:.0%} of the {ball_type} balls are {color}. How many {color} {ball_type} balls are there?" - - answer_cot = f"{ball_type} balls:{n} * {frac_1}={first_calc}\n{color} {ball_type} balls:{first_calc}*{frac_2}={final_calc} balls\n#### {final_calc}" - - return { - 'question': question, - 'answer': str(final_calc), - 'answer_cot': answer_cot, - 'answer_value': final_calc, - 'variables': { - 'total_balls': n, - 'ball_type': ball_type, - 'color': color, - 'fraction_first': frac_1, - 'fraction_second': frac_2, - 'first_calculation': first_calc, - 'final_calculation': final_calc - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - ball_types = ["golf", "tennis"] - colors = ["blue", "red", "green", "yellow", "white"] - fractions = [0.5, 0.25, 0.75] - - ball_type = rng.choice(ball_types) - color = rng.choice(colors) - frac_1 = rng.choice(fractions) - frac_2 = rng.choice(fractions) - - # Generate n that ensures integer results - n = int(rng.randint(10, int(100 * difficulty))) - while not (n * frac_1).is_integer() or not (n * frac_1 * frac_2).is_integer(): - n = int(rng.randint(10, int(100 * difficulty))) - - result = generate_from_variables(n, ball_type, color, frac_1, frac_2) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables(16, "golf", "blue", 0.5, 0.5) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_27.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_27.py deleted file mode 100644 index e350ba6c..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_27.py +++ /dev/null @@ -1,78 +0,0 @@ -from random import Random -from typing import Dict, Any -import math - -def generate_from_variables(name: str, n: int, n_first: int, apartments_each: int, - percent_bigger: int, freq: int, rate: float, - currency: str) -> Dict[str, Any]: - - first_two = n_first * apartments_each - third_complex = int(first_two * percent_bigger/100) - total_apartments = first_two + third_complex + first_two - weekly_visits = total_apartments * freq - weekly_earnings = int(weekly_visits * rate) - - question = f"{name} collects garbage from {n} different apartment complexes. The first {n_first} have {apartments_each} apartments each and the last one is {percent_bigger}% bigger than the other {n_first} combined. {name} collects garbage {freq} times a week from each place and he gets paid {currency}{rate:.2f} per collection for each apartment. How much money does he make in a week?" - - answer_cot = f"The first {n_first} complexes have {first_two} apartments\n" \ - f"The third one has {first_two}*{percent_bigger/100}={third_complex} more apartments than those {n_first} combined\n" \ - f"So in total, it has {first_two}+{third_complex}={first_two + third_complex} apartments\n" \ - f"So he goes to {first_two + third_complex}+{first_two}={total_apartments} apartments each time\n" \ - f"That means he visits {total_apartments}*{freq}={weekly_visits} apartments every week\n" \ - f"So he makes {weekly_visits}*{currency}{rate:.2f}={currency}{weekly_earnings} every week\n" \ - f"#### {weekly_earnings}" - - return { - 'question': question, - 'answer': str(weekly_earnings), - 'answer_cot': answer_cot, - 'answer_value': weekly_earnings, - 'variables': { - 'name': name, - 'num_complexes': n, - 'first_complexes': n_first, - 'apartments_per_complex': apartments_each, - 'percent_increase': percent_bigger, - 'collections_per_week': freq, - 'rate_per_apartment': rate, - 'currency': currency, - 'total_apartments': total_apartments, - 'weekly_visits': weekly_visits - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['John', 'Michael', 'David', 'James', 'Robert', 'William'] - currencies = ['$', '£', '€'] - - name = rng.choice(names) - currency = rng.choice(currencies) - - n = rng.randint(3, max(3, int(8 * difficulty))) - n_first = n - 1 - apartments = int(rng.randrange(100, int(500 * difficulty), 50)) - percent = rng.randrange(20, int(81 * difficulty), 5) - freq = rng.randint(2, max(2, int(6 * difficulty))) - rates = [0.25, 0.30, 0.35, 0.40, 0.45, 0.50] - rate = rng.choice(rates) - - # Ensure results are integers - while not ((n-1)*apartments*percent/100).is_integer(): - apartments = int(rng.randrange(100, int(500 * difficulty), 50)) - percent = rng.randrange(20, int(81 * difficulty), 5) - - result = generate_from_variables(name, n, n_first, apartments, percent, freq, rate, currency) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('John', 3, 2, 200, 60, 3, 0.40, '$') diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_28.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_28.py deleted file mode 100644 index c2c89dad..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_28.py +++ /dev/null @@ -1,74 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, item: str, price: float, percent: float, - usage: int, extra_item: str, extra_price: float, - currency: str, unit: str) -> Dict[str, Any]: - price_increase = price * percent / 100 - new_price = price + price_increase - weekly_usage = usage * 7 - coffee_cost = new_price * weekly_usage - total_cost = coffee_cost + extra_price - - question = f"{name} goes to the store to buy some {item}. The normal brand of {item} he buys costs {currency}{price} per {unit}. He had to buy a more expensive brand that costs {int(percent)}% more since his favorite brand was sold out. He decides to buy a week's worth of {item} and he uses {usage} {unit} of {item} per day. He also decided to buy himself a {extra_item} for {currency}{extra_price}. How much did everything cost?" - - answer_cot = f"The {item} he bought was {price}*{percent/100}={price_increase} more expensive per {unit} than what he normally buys\nSo it cost {price}+{price_increase}={new_price} per {unit}\nHe goes through {usage}*7={weekly_usage} {unit}s of {item} a week\nSo he paid {new_price}*{weekly_usage}={coffee_cost} on {item}\nThat means his total bill was {coffee_cost}+{extra_price}={total_cost}\n#### {int(total_cost)}" - - return { - 'question': question, - 'answer': str(int(total_cost)), - 'answer_cot': answer_cot, - 'answer_value': int(total_cost), - 'variables': { - 'name': name, - 'item': item, - 'base_price': price, - 'percent_increase': percent, - 'usage_per_day': usage, - 'extra_item': extra_item, - 'extra_price': extra_price, - 'currency': currency, - 'unit': unit, - 'weekly_usage': weekly_usage, - 'total_cost': total_cost - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_male = ['John', 'Michael', 'David', 'James', 'Robert', 'William', 'Richard', 'Thomas'] - items = ['tea', 'sugar', 'flour', 'rice'] - currencies_sym = ['$', '£', '€'] - units = ['kilogram', 'kg'] - extra_items = ['cookie', 'muffin', 'bagel'] - - name = rng.choice(names_male) - item = rng.choice(items) - currency = rng.choice(currencies_sym) - unit = rng.choice(units) - extra_item = rng.choice(extra_items) - - price = int(rng.randint(3, int(25 * difficulty))) - percent = int(rng.randint(2, int(10 * difficulty))) * 5 - usage = int(rng.randint(1, int(3 * difficulty))) - extra_price = int(rng.randint(1, int(5 * difficulty))) - - # Ensure price * percent / 100 is an integer - while (price * percent / 100) != int(price * percent / 100): - price = int(rng.randint(3, int(25 * difficulty))) - - result = generate_from_variables(name, item, price, percent, usage, - extra_item, extra_price, currency, unit) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Roger', 'coffee', 5, 20, 1, 'donut', 2, '$', 'pound') diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_29.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_29.py deleted file mode 100644 index 0a5578de..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_29.py +++ /dev/null @@ -1,67 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name1: str, name2: str, n1: int, n2: int, - k1: int, k2: int) -> Dict[str, Any]: - total_puppies = n1 + n2 - spotted_puppies = k1 + k2 - percentage = int(100 * spotted_puppies / total_puppies) - - question = f"{name1}'s dog has {n1} puppies, {k1} of which have spots. {name2}'s dog has {n2} puppies, {k2} of which have spots. What percentage of all the puppies have spots?" - - answer_cot = f"First find the total number of puppies: {n1} puppies + {n2} puppies = {total_puppies} puppies\n" \ - f"Then find the total number of puppies with spots: {k1} puppies + {k2} puppies = {spotted_puppies} puppies\n" \ - f"Then divide the number of spotted puppies by the total number of puppies and multiply by 100% to find the percentage of puppies with spots: {spotted_puppies} puppies / {total_puppies} puppies * 100% = {percentage}%\n" \ - f"#### {percentage}" - - return { - 'question': question, - 'answer': str(percentage), - 'answer_cot': answer_cot, - 'answer_value': percentage, - 'variables': { - 'name1': name1, - 'name2': name2, - 'puppies1': n1, - 'puppies2': n2, - 'spotted1': k1, - 'spotted2': k2, - 'total_puppies': total_puppies, - 'total_spotted': spotted_puppies - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Jennifer", "Michael", "Christopher", "Jessica", "Matthew", "Ashley", - "Joshua", "Amanda", "Daniel", "David", "James", "Robert", "John", "Joseph"] - - name1, name2 = rng.sample(names, 2) - - # Scale ranges by difficulty but ensure values remain integers - n1 = int(rng.randrange(950, int(1050 * difficulty), 5)) - n2 = int(rng.randrange(400, int(650 * difficulty), 5)) - k1 = int(rng.randrange(170, int(290 * difficulty), 10)) - k2 = int(rng.randrange(120, int(170 * difficulty), 10)) - - # Ensure conditions are met - while (k1 + k2) >= (n1 + n2) or (n1 + n2) % (k1 + k2) != 0: - n1 = int(rng.randrange(950, int(1050 * difficulty), 5)) - n2 = int(rng.randrange(400, int(650 * difficulty), 5)) - k1 = int(rng.randrange(170, int(290 * difficulty), 10)) - k2 = int(rng.randrange(120, int(170 * difficulty), 10)) - - result = generate_from_variables(name1, name2, n1, n2, k1, k2) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Jennifer", "Brandon", 8, 12, 3, 4) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_3.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_3.py deleted file mode 100644 index 13e78983..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_3.py +++ /dev/null @@ -1,67 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, initial_pals: int, lost_pals: int, - letters_per_week: int, pages_per_letter: int, - minutes_per_page: int) -> Dict[str, Any]: - current_pals = initial_pals - lost_pals - letters_received = current_pals * letters_per_week - pages_to_write = letters_received * pages_per_letter - total_minutes = pages_to_write * minutes_per_page - hours = total_minutes // 60 - - question = f"{name} was a pen pal with {initial_pals} people. He stopped being penpals with {lost_pals} of them. They each send {letters_per_week} letters a week that are {pages_per_letter} pages long. He responds in kind. He can write a page every {minutes_per_page} minutes. How many hours does he spend writing a week?" - - answer_cot = f"{name} is penpals with {initial_pals}-{lost_pals}={current_pals} people\n" \ - f"Thus he gets {current_pals}*{letters_per_week}={letters_received} letters a week\n" \ - f"So he writes {letters_received}*{pages_per_letter}={pages_to_write} pages a week\n" \ - f"So he writes for {pages_to_write}*{minutes_per_page}={total_minutes} minutes a week\n" \ - f"So he writes {total_minutes}/60={hours} hours a week\n#### {hours}" - - return { - 'question': question, - 'answer': str(hours), - 'answer_cot': answer_cot, - 'answer_value': hours, - 'variables': { - 'name': name, - 'initial_penpals': initial_pals, - 'lost_penpals': lost_pals, - 'current_penpals': current_pals, - 'letters_per_week': letters_per_week, - 'pages_per_letter': pages_per_letter, - 'minutes_per_page': minutes_per_page, - 'total_minutes': total_minutes - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Mike", "John", "David", "James", "Robert", "William", "Richard"] - name = rng.choice(names) - - initial_pals = int(rng.randint(5, int(15 * difficulty))) - lost_pals = int(rng.randint(1, initial_pals - 1)) - letters_per_week = int(rng.randint(2, int(5 * difficulty))) - pages_per_letter = int(rng.randint(5, int(12 * difficulty))) - minutes_per_page = int(rng.randint(4, int(15 * difficulty))) - - # Ensure result is in whole hours - while ((initial_pals - lost_pals) * letters_per_week * pages_per_letter * minutes_per_page) % 60 != 0: - minutes_per_page = int(rng.randint(4, int(15 * difficulty))) - - result = generate_from_variables(name, initial_pals, lost_pals, - letters_per_week, pages_per_letter, minutes_per_page) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Mike", 5, 2, 2, 5, 6) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_30.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_30.py deleted file mode 100644 index 6a618674..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_30.py +++ /dev/null @@ -1,67 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(group: str, n: int, n_1: int, n_2: int, - hobby1: str, hobby2: str, hobby3: str, hobby4: str) -> Dict[str, Any]: - n_4 = 2 * n_2 # number that like hobby4 (music) - n_3 = n - (n_1 + n_2 + n_4) # number that like hobby3 (video games) - - question = f"A {group} of {n} students has various hobbies. {n_1} like to {hobby1}, {n_2} like to play {hobby2}, and the rest like to either {hobby3} or {hobby4}. How many like to {hobby3} if the number that like to {hobby4} is twice the number that prefer playing {hobby2}?" - - answer_cot = f"The number of students that like to {hobby4} is twice as many as the number who like {hobby2}, so 2 * {n_2} = {n_4}\nThe number that like to {hobby3} is {n} total students - {n_1} {hobby1} - {n_2} {hobby2} - {n_4} {hobby4} = {n_3}\n#### {n_3}" - - return { - 'question': question, - 'answer': str(n_3), - 'answer_cot': answer_cot, - 'answer_value': n_3, - 'variables': { - 'group_type': group, - 'total_students': n, - 'hobby1_count': n_1, - 'hobby2_count': n_2, - 'hobby3_count': n_3, - 'hobby4_count': n_4, - 'hobby1': hobby1, - 'hobby2': hobby2, - 'hobby3': hobby3, - 'hobby4': hobby4 - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - groups = ["group", "class"] - hobbies = ['read', 'paint', 'hike', 'dance', 'bake', 'play video games', 'play music'] - sports = ['basketball', 'soccer', 'tennis', 'baseball', 'volleyball'] - - group = rng.choice(groups) - hobby2 = rng.choice(sports) - hobby1, hobby3, hobby4 = rng.sample([h for h in hobbies if h not in [hobby2]], 3) - - # Generate numbers that satisfy conditions - n = int(rng.randint(20, int(200 * difficulty))) - n_2 = int(rng.randint(2, n//6)) # Keep n_2 small since we multiply by 2 - n_1 = int(rng.randint(2, n//3)) - - # Verify n_1 + n_2 + (2*n_2) < n - while n_1 + 3*n_2 >= n: - n = int(rng.randint(20, int(200 * difficulty))) - n_2 = int(rng.randint(2, n//6)) - n_1 = int(rng.randint(2, n//3)) - - result = generate_from_variables(group, n, n_1, n_2, hobby1, hobby2, hobby3, hobby4) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("class", 50, 10, 5, "bake", "basketball", - "play video games", "play music") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_31.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_31.py deleted file mode 100644 index 46008e05..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_31.py +++ /dev/null @@ -1,66 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, fruit: str, total: int, n1: int, n2: int, n3: int, - sibling1: str, sibling2: str) -> Dict[str, Any]: - slice2 = n1 + n2 - slice3 = slice2 + n3 - total_eaten = n1 + slice2 + slice3 - - question = f"{name} sliced an {fruit} into {total} pieces. She ate {n1} slice, her {sibling1} ate {n2} more than her, and her {sibling2} ate {n3} more than her {sibling1}. How many slices of {fruit} did they all eat?" - - answer_cot = f"Her {sibling1} ate {n1} + {n2} = {slice2} slices.\nHer {sibling2} ate {slice2} + {n3} = {slice3} slices.\nThey ate a total of {n1} + {slice2} + {slice3} = {total_eaten} slices.\n#### {total_eaten}" - - return { - 'question': question, - 'answer': str(total_eaten), - 'answer_cot': answer_cot, - 'answer_value': total_eaten, - 'variables': { - 'name': name, - 'fruit': fruit, - 'total_slices': total, - 'first_person_slices': n1, - 'second_person_extra': n2, - 'third_person_extra': n3, - 'sibling1': sibling1, - 'sibling2': sibling2, - 'total_eaten': total_eaten - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte", "Doxa"] - fruits = ["orange", "pear", "peach", "mango", "kiwi", "apple"] - siblings = ["brother", "sister", "cousin", "friend"] - - name = rng.choice(names_female) - fruit = rng.choice(fruits) - sibling1, sibling2 = rng.sample(siblings, 2) - - total = int(rng.randint(6, int(33 * difficulty))) - n1 = int(rng.randint(3, int(15 * difficulty))) - n2 = int(rng.randint(5, int(13 * difficulty))) - n3 = int(rng.randint(3, int(14 * difficulty))) - - # Ensure conditions are met - while n1 + (n1 + n2) + (n1 + n2 + n3) > total: - n1 = int(rng.randint(3, int(15 * difficulty))) - n2 = int(rng.randint(5, int(13 * difficulty))) - n3 = int(rng.randint(3, int(14 * difficulty))) - - result = generate_from_variables(name, fruit, total, n1, n2, n3, sibling1, sibling2) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Doxa", "apple", 8, 1, 1, 1, "sister", "brother") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_32.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_32.py deleted file mode 100644 index 8f1e968a..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_32.py +++ /dev/null @@ -1,77 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, periods: int, extra_classes: int, - mins_per_class: int, days: int, weekend_fraction: float) -> Dict[str, Any]: - total_classes = periods + extra_classes - daily_mins = total_classes * mins_per_class - weekly_mins = daily_mins * days - weekend_mins = int(weekly_mins * weekend_fraction) - total_mins = weekly_mins + 2 * weekend_mins - total_hours = total_mins // 60 - - question = f"There are {periods} periods in the day for a normal student but {name} has to take {extra_classes} extra classes. Each class is {mins_per_class} minutes long. He goes to class for {days} days a week. He then spends {weekend_fraction} of his weekly minutes each on Saturday and Sunday as extra learning time. How many hours a week does he spend learning?" - - answer_cot = f"He takes {periods}+{extra_classes}={total_classes} classes a day\n" \ - f"That means he spends {mins_per_class}*{total_classes}={daily_mins} minutes per day in class\n" \ - f"So he spends {daily_mins}*{days}={weekly_mins} minutes a week\n" \ - f"That means he spends {weekly_mins}*{weekend_fraction}={weekend_mins} minutes each on Saturday and Sunday\n" \ - f"So he spends {weekly_mins}+{weekend_mins}+{weekend_mins}={total_mins} minutes per week\n" \ - f"So he spends {total_mins}/60={total_hours} hours per week\n#### {total_hours}" - - return { - 'question': question, - 'answer': str(total_hours), - 'answer_cot': answer_cot, - 'answer_value': total_hours, - 'variables': { - 'name': name, - 'periods': periods, - 'extra_classes': extra_classes, - 'mins_per_class': mins_per_class, - 'days': days, - 'weekend_fraction': weekend_fraction, - 'total_classes': total_classes, - 'daily_mins': daily_mins, - 'weekly_mins': weekly_mins, - 'weekend_mins': weekend_mins, - 'total_mins': total_mins - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["John", "James", "William", "Michael", "David", "Richard", "Thomas"] - fractions = ["1/16", "1/8", "1/4", "1/2"] - - name = rng.choice(names) - periods = int(rng.randint(5, int(10 * difficulty))) - extra_classes = int(rng.randint(1, int(5 * difficulty))) - mins_per_class = int(rng.randint(30, int(61 * difficulty)) // 5 * 5) - days = int(rng.randint(4, int(7 * difficulty))) - weekend_fraction = float(eval(rng.choice(fractions))) - - # Ensure results are integers - while not (((periods + extra_classes) * mins_per_class * days * weekend_fraction).is_integer() and - (((periods + extra_classes) * mins_per_class * days + - 2 * (periods + extra_classes) * mins_per_class * days * weekend_fraction) / 60).is_integer()): - periods = int(rng.randint(5, int(10 * difficulty))) - extra_classes = int(rng.randint(1, int(5 * difficulty))) - mins_per_class = int(rng.randint(30, int(61 * difficulty)) // 5 * 5) - days = int(rng.randint(4, int(7 * difficulty))) - - result = generate_from_variables(name, periods, extra_classes, mins_per_class, - days, weekend_fraction) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("John", 6, 2, 40, 5, 1/16) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_33.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_33.py deleted file mode 100644 index f34ddc0f..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_33.py +++ /dev/null @@ -1,58 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name1: str, name2: str, mult: int, n: int) -> Dict[str, Any]: - n_mult = n * mult - daily_total = n + n_mult - weekly_total = daily_total * 7 - - question = f"{name1} operates the cash register exactly {mult} times as fast as her less-experienced colleague {name2}. Daily, {name2} processes {n} customers. What is the total weekly production for the two if they work all days of the week?" - - answer_cot = f"While {name2} is processing {n} orders in a day, {name1} processes {n} orders/day * {mult} = {n_mult} orders/day.\n" \ - f"In a day, they process {n_mult} orders/day + {n} orders/day = {daily_total} orders together.\n" \ - f"The total number of orders the two processes in a week is {daily_total} orders/day * 7 days/week = {weekly_total} orders\n" \ - f"#### {weekly_total}" - - return { - 'question': question, - 'answer': str(weekly_total), - 'answer_cot': answer_cot, - 'answer_value': weekly_total, - 'variables': { - 'name1': name1, - 'name2': name2, - 'multiplier': mult, - 'base_rate': n, - 'fast_rate': n_mult, - 'daily_total': daily_total, - 'weekly_total': weekly_total - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ["Julie", "Sarah", "Emma", "Sophia", "Olivia", "Isabella", "Mia", "Charlotte"] - multi_times = [2, 3, 4] - - name1, name2 = rng.sample(names_female, 2) - mult = rng.choice(multi_times) - n = int(rng.randint(30, int(100 * difficulty))) - - # Ensure conditions are met - while not (n * mult).is_integer() or not ((n + n * mult) * 7).is_integer(): - n = int(rng.randint(30, int(100 * difficulty))) - - result = generate_from_variables(name1, name2, mult, n) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Julie", "Jewel", 2, 50) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_34.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_34.py deleted file mode 100644 index 1e02a32e..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_34.py +++ /dev/null @@ -1,62 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(event: str, item: str, family: str, n: int, m: int, total: int) -> Dict[str, Any]: - twins_total = 2 * n - remaining = total - twins_total - friends_found = remaining - m - - question = f"The {event} team hid {total} {item}. The {family} twins each found {n} {item}. All the other {item} except {m} were found by their friends. How many {item} did the friends find?" - - answer_cot = f"The {family} twins found, {n} * 2 = {twins_total} {item}.\nThe number that remained hidden was {total} - {twins_total} = {remaining} {item}\nSince {m} {item} were not found, this means the friends found {remaining} - {m} = {friends_found} {item}\n#### {friends_found}" - - return { - 'question': question, - 'answer': str(friends_found), - 'answer_cot': answer_cot, - 'answer_value': friends_found, - 'variables': { - 'event': event, - 'item': item, - 'family': family, - 'items_per_twin': n, - 'unfound_items': m, - 'total_items': total, - 'twins_total': twins_total, - 'friends_found': friends_found - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - events = ["Halloween candy hunt", "Treasure hunt", "Scavenger hunt", "Charity fundraiser"] - items = ["eggs", "treats", "toys", "coins", "tokens", "balls", "candies", "goodies"] - families = ["Johnson", "Williams", "Mirzakhani", "Lopez", "Garcia", "Lee"] - - event = rng.choice(events) - item = rng.choice(items) - family = rng.choice(families) - - total = int(rng.randint(50, int(201 * difficulty)) // 10 * 10) - n = int(rng.randint(10, int(51 * difficulty))) - m = int(rng.randint(5, int(21 * difficulty))) - - # Ensure conditions are met - while 2 * n + m >= total: - n = int(rng.randint(10, int(51 * difficulty))) - m = int(rng.randint(5, int(21 * difficulty))) - - result = generate_from_variables(event, item, family, n, m, total) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Easter egg hunt", "eggs", "Smith", 30, 10, 100) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_35.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_35.py deleted file mode 100644 index 21a3ccbd..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_35.py +++ /dev/null @@ -1,79 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(job: str, building: str, room: str, num_rooms: int, - num_days: int, time_per_room: int, hours_per_day: int) -> Dict[str, Any]: - - rooms_per_day = num_rooms // num_days - minutes_per_day = rooms_per_day * time_per_room - hours_cleaning = minutes_per_day / 60 - percentage = int(100 * hours_cleaning / hours_per_day) - - question = f"A {job} has to clean a {building} with {num_rooms} {room}s. They have {num_days} days to get it done. It takes them {time_per_room} minutes per {room}. If they work {hours_per_day} hour day, what percentage of their day, on average, is spent cleaning {room}s?" - - answer_cot = f"They have to clean {rooms_per_day} {room}s a day because {num_rooms} / {num_days} = {rooms_per_day}\n" \ - f"They spend {minutes_per_day} minutes cleaning per day because {rooms_per_day} x {time_per_room} = {minutes_per_day}\n" \ - f"They spend {hours_cleaning} hours a day because {minutes_per_day} / 60 = {hours_cleaning}\n" \ - f"They spend {hours_cleaning/hours_per_day} of their day cleaning {room}s because {hours_cleaning} / {hours_per_day} = {hours_cleaning/hours_per_day}\n" \ - f"They spend {percentage}% of their day cleaning {room}s because {hours_cleaning/hours_per_day} x 100 = {percentage}\n" \ - f"#### {percentage}" - - return { - 'question': question, - 'answer': str(percentage), - 'answer_cot': answer_cot, - 'answer_value': percentage, - 'variables': { - 'job': job, - 'building': building, - 'room': room, - 'num_rooms': num_rooms, - 'num_days': num_days, - 'time_per_room': time_per_room, - 'hours_per_day': hours_per_day, - 'rooms_per_day': rooms_per_day, - 'minutes_per_day': minutes_per_day, - 'hours_cleaning': hours_cleaning, - 'percentage': percentage - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - jobs = ["janitor", "cleaner", "maintenance worker"] - buildings = ["office building", "hospital", "university"] - rooms = ["room", "floor"] - - job = rng.choice(jobs) - building = rng.choice(buildings) - room = rng.choice(rooms) - - num_days = int(rng.randint(3, int(12 * difficulty))) - time_per_room = int(rng.randrange(10, int(46 * difficulty), 5)) - hours_per_day = int(rng.randint(6, int(17 * difficulty))) - - # Generate num_rooms ensuring divisibility by num_days - rooms_per_day = rng.randint(5, int(20 * difficulty)) - num_rooms = rooms_per_day * num_days - - # Ensure conditions are met - while (num_rooms/num_days) * time_per_room >= hours_per_day * 60: - rooms_per_day = rng.randint(5, int(20 * difficulty)) - num_rooms = rooms_per_day * num_days - - result = generate_from_variables(job, building, room, num_rooms, num_days, - time_per_room, hours_per_day) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("custodian", "school", "classroom", - 80, 5, 15, 8) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_36.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_36.py deleted file mode 100644 index db9dd23f..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_36.py +++ /dev/null @@ -1,74 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(n: int, p1: int, r1: int, name: str, s1: str, s2: str, s3: str) -> Dict[str, Any]: - easy_questions = int(n * (p1/100)) - other_questions = int(n * (1-p1/100)) - easy_correct = int(easy_questions * (r1/100)) - other_correct = int(other_questions * 0.5) - total_correct = easy_correct + other_correct - - question = f"In a {n}-item quiz, {p1}% of the questions are {s1}, and the rest are equally divided as {s2} and {s3} questions. If {name} is sure to get {r1}% of the {s1} questions, and half of the {s2} and {s3} questions correctly, how many points is she sure to get?" - - answer_cot = f"The {s2} and {s3} questions comprises 100% - {p1}% = {100-p1}% of the quiz.\n" \ - f"There are {n} questions x {p1}/100 = {easy_questions} {s1} questions.\n" \ - f"There are a total of {n} questions x {100-p1}/100 = {other_questions} {s2} and {s3} questions.\n" \ - f"If {name} is sure to get {r1}% of the {s1} questions, then this means she is sure of her {easy_questions} questions x {r1}/100 = {easy_correct} points.\n" \ - f"From the {s2} and {s3} questions, she is sure to get half of it correctly so that is {other_questions} questions * 0.5 = {other_correct} points.\n" \ - f"Thus, she is sure of getting {easy_correct} points + {other_correct} points = {total_correct} points in her quiz.\n#### {total_correct}" - - return { - 'question': question, - 'answer': str(total_correct), - 'answer_cot': answer_cot, - 'answer_value': total_correct, - 'variables': { - 'total_questions': n, - 'easy_percent': p1, - 'easy_correct_percent': r1, - 'student_name': name, - 'easy_subject': s1, - 'medium_subject': s2, - 'hard_subject': s3, - 'easy_questions': easy_questions, - 'other_questions': other_questions, - 'easy_correct': easy_correct, - 'other_correct': other_correct - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - subjects = ["history", "geography", "biology", "chemistry", "physics", - "economics", "literature", "algebra", "geometry"] - names = ["Emma", "Sophia", "Olivia", "Ava", "Isabella", "Mia", "Charlotte"] - - # Generate valid numbers ensuring integer results - while True: - n = int(rng.randrange(10, int(151 * difficulty), 10)) - p1 = int(rng.randrange(5, int(71 * difficulty), 5)) - r1 = int(rng.randrange(5, int(101 * difficulty), 5)) - - # Check conditions - if (n * (p1/100)).is_integer() and \ - (n * (p1/100) * (r1/100)).is_integer() and \ - (n*(1-(p1/100))*0.5).is_integer(): - break - - name = rng.choice(names) - s1, s2, s3 = rng.sample(subjects, 3) - - result = generate_from_variables(n, p1, r1, name, s1, s2, s3) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables(60, 40, 75, "Aries", "easy", "average", "difficult") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_37.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_37.py deleted file mode 100644 index 84f693f5..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_37.py +++ /dev/null @@ -1,85 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(worker: str, base: int, unit: str, tool1: str, - tool2: str, tool3: str, mult1: int, mult2: int, - n: int, days: int) -> Dict[str, Any]: - iron_amount = base * mult1 - steel_amount = int(iron_amount * (1 + mult2/100)) - daily_total = steel_amount * n - total_amount = daily_total * days - - question = f"One {worker} can mine {base} {unit} of ore per day with {tool1}. He can mine {mult1} times as much with a {tool2} and {mult2}% more with a {tool3} than with a {tool2}. How many {unit} of ore can {n} {worker}s with {tool3}s mine in a month with {days} days?" - - answer_cot = f"First find how much ore a {worker} can mine with a {tool2}: {base} {unit}/day * {mult1} = {iron_amount} {unit}/day\n" \ - f"Then multiply that amount by {100+mult2}% to find how much a {worker} can mine with a {tool3}: {iron_amount} {unit}/day * {100+mult2}% = {steel_amount} {unit}/day\n" \ - f"Then multiply the amount one {worker} can mine in a day with a {tool3} by the number of {worker}s: {steel_amount} {unit}/day/{worker} * {n} {worker}s = {daily_total} {unit}/day\n" \ - f"Then multiply the daily amount of ore by the number of days to find the total ore mined in a month: {daily_total} {unit}/day * {days} days = {total_amount} {unit}/day\n" \ - f"#### {total_amount}" - - return { - 'question': question, - 'answer': str(total_amount), - 'answer_cot': answer_cot, - 'answer_value': total_amount, - 'variables': { - 'worker': worker, - 'base_amount': base, - 'unit': unit, - 'tool1': tool1, - 'tool2': tool2, - 'tool3': tool3, - 'mult1': mult1, - 'mult2': mult2, - 'num_workers': n, - 'num_days': days, - 'iron_amount': iron_amount, - 'steel_amount': steel_amount, - 'daily_total': daily_total - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - workers = ["miner", "goblin", "gnome", "troll"] - tools1 = ["bare hands", "basic shovel", "wooden pickaxe"] - units = ["pounds", "kgs"] - tools2 = ["nickel pickaxe", "bronze pickaxe", "silver pickaxe"] - tools3 = ["steel pickaxe", "diamond pickaxe", "mithril pickaxe", "titanium pickaxe"] - - worker = rng.choice(workers) - tool1 = rng.choice(tools1) - unit = rng.choice(units) - tool2 = rng.choice(tools2) - tool3 = rng.choice(tools3) - - base = int(rng.randint(5, int(20 * difficulty))) - mult1 = int(rng.randint(2, int(4 * difficulty))) - mult2 = int(rng.randint(30, int(80 * difficulty)) // 5 * 5) - n = int(rng.randint(20, int(50 * difficulty))) - days = int(rng.randint(28, 32)) - - # Verify conditions - while not (base * mult1 * (1 + mult2/100)).is_integer() or \ - int(base * mult1 * (1 + mult2/100) * n * days) >= 100000: - base = int(rng.randint(5, int(20 * difficulty))) - mult1 = int(rng.randint(2, int(4 * difficulty))) - mult2 = int(rng.randint(30, int(80 * difficulty)) // 5 * 5) - n = int(rng.randint(20, int(50 * difficulty))) - - result = generate_from_variables(worker, base, unit, tool1, tool2, tool3, - mult1, mult2, n, days) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("dwarf", 12, "pounds", "his bare hands", - "iron pickaxe", "steel pickaxe", 2, 50, 40, 30) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_38.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_38.py deleted file mode 100644 index 6b9f25cc..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_38.py +++ /dev/null @@ -1,67 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, count: int, child_type: str, - item1: str, item2: str, item3: str, item4: str, item5: str, - n1: int, n2: int, n3: int, n4: int, n5: int) -> Dict[str, Any]: - - skeins_per_child = n1 + n2 + n3 + n4 + n5 - total_skeins = count * skeins_per_child - - question = f"{name} is knitting winter wear for her {count} grandchildren. They're {child_type}, so they're all the same size. She wants to make a {item1}, {item2}, {item3}, {item4}, and {item5} for each of them. It takes {n1} skeins of wool to make a {item1}, {n2} for a {item2}, {n3} for a {item3}, {n4} for a pair of {item4}, and {n5} for a pair of {item5}. How many skeins of wool will she need to buy?" - - answer_cot = f"A full outfit for each child will require {n1} skeins per {item1} + {n2} skeins per {item2} + {n3} skeins per {item3} + {n4} skeins per pair of {item4} + {n5} skeins per pair of {item5} = {skeins_per_child} skeins of wool.\nSo to knit outfits for all of her grandchildren, she will need {count} * {skeins_per_child} = {total_skeins} skeins of wool.\n#### {total_skeins}" - - return { - 'question': question, - 'answer': str(total_skeins), - 'answer_cot': answer_cot, - 'answer_value': total_skeins, - 'variables': { - 'name': name, - 'count': count, - 'child_type': child_type, - 'items': [item1, item2, item3, item4, item5], - 'skeins_per_item': [n1, n2, n3, n4, n5], - 'skeins_per_child': skeins_per_child, - 'total_skeins': total_skeins - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ["Martha", "Mary", "Elizabeth", "Susan", "Margaret", "Patricia"] - clothing_items = ["sweater", "shawl", "hat", "cardigan", "poncho", "vest", "beanie", "tunic"] - accessories = ["mittens", "booties", "socks", "leg warmers", "gloves"] - children_types = [("twins", 2), ("triplets", 3), ("quadruplets", 4), ("quintuplets", 5)] - - name = rng.choice(names_female) - child_type, count = rng.choice(children_types) - item1, item2, item3 = rng.sample(clothing_items, 3) - item4, item5 = rng.sample(accessories, 2) - - # Scale numbers based on difficulty - n1 = int(rng.randint(3, int(19 * difficulty))) - n2 = int(rng.randint(3, int(19 * difficulty))) - n3 = int(rng.randint(3, int(19 * difficulty))) - n4 = int(rng.randint(3, int(19 * difficulty))) - n5 = int(rng.randint(3, int(19 * difficulty))) - - result = generate_from_variables(name, count, child_type, - item1, item2, item3, item4, item5, - n1, n2, n3, n4, n5) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Martha", 3, "triplets", - "hat", "scarf", "sweater", "mittens", "socks", - 2, 4, 12, 1, 2) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_39.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_39.py deleted file mode 100644 index 646c70e4..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_39.py +++ /dev/null @@ -1,62 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(total: int, grade: str, school_name: str, num_girls: int, - day: str, absent_girls: int, absent_boys: int) -> Dict[str, Any]: - num_boys = total - num_girls - remaining_boys = num_boys - absent_boys - - question = f"There are {total} {grade}-graders at {school_name} School. {num_girls} of them are girls. On {day}, {absent_girls} {grade}-grade girls and {absent_boys} {grade}-grade boys were absent. How many {grade} grade boys were at {school_name} School on {day}?" - - answer_cot = f"Of the {total} {grade} graders, {num_girls} are girls, so {total} students - {num_girls} girls = {num_boys} boys.\nOn {day} there were {num_boys} boys - {absent_boys} absent = {remaining_boys} boys.\n#### {remaining_boys}" - - return { - 'question': question, - 'answer': str(remaining_boys), - 'answer_cot': answer_cot, - 'answer_value': remaining_boys, - 'variables': { - 'total_students': total, - 'grade': grade, - 'school_name': school_name, - 'num_girls': num_girls, - 'num_boys': num_boys, - 'day': day, - 'absent_girls': absent_girls, - 'absent_boys': absent_boys, - 'remaining_boys': remaining_boys - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - school_names = ["Maple Grove", "Sunny Hill", "Oak Ridge", "Pine Valley"] - grades = ["first", "second", "third", "fourth", "fifth"] - days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"] - - school_name = rng.choice(school_names) - grade = rng.choice(grades) - day = rng.choice(days) - - total = int(rng.randint(50, int(200 * difficulty))) - num_girls = int(rng.randint(20, total - 1)) - num_boys = total - num_girls - - absent_girls = int(rng.randint(2, min(num_girls, int(10 * difficulty)))) - absent_boys = int(rng.randint(2, min(num_boys, int(10 * difficulty)))) - - result = generate_from_variables(total, grade, school_name, num_girls, - day, absent_girls, absent_boys) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables(96, "fourth", "Small Tree", 43, "Friday", 5, 4) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_4.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_4.py deleted file mode 100644 index 8f6784ee..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_4.py +++ /dev/null @@ -1,71 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, items: str, food: str, location: str, container: str, - num_jars: int, per_jar: int, per_pan: int) -> Dict[str, Any]: - total_items = num_jars * per_jar - num_pans = total_items // per_pan - - question = f"{name} has {num_jars} jars of {items} in her {location}. Each jar of {items} can decorate {per_jar} {food}s. {name} wants to bake enough {food}s to use up all of her {items}. If each {container} holds {per_pan} {food}s, how many {container}s worth of {food}s should she bake?" - - answer_cot = f"She has enough {items} for {num_jars} * {per_jar} = {total_items} {food}s.\nShe needs {total_items} / {per_pan} = {num_pans} {container}s to bake all of the {food}s.\n#### {num_pans}" - - return { - 'question': question, - 'answer': str(num_pans), - 'answer_cot': answer_cot, - 'answer_value': num_pans, - 'variables': { - 'name': name, - 'items': items, - 'food': food, - 'location': location, - 'container': container, - 'num_jars': num_jars, - 'per_jar': per_jar, - 'per_pan': per_pan, - 'total_items': total_items - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ['Mary', 'Sarah', 'Emma', 'Elizabeth', 'Catherine'] - items = ['sprinkles', 'frosting', 'icing', 'chocolate chips'] - foods = ['cupcake', 'cookie', 'brownie', 'muffin'] - locations = ['pantry', 'cupboard', 'kitchen cabinet', 'storage room'] - containers = ['pan', 'tray', 'baking sheet', 'rack'] - - name = rng.choice(names_female) - item = rng.choice(items) - food = rng.choice(foods) - location = rng.choice(locations) - container = rng.choice(containers) - - # Generate numbers ensuring divisibility - per_pan = int(rng.randint(6, int(24 * difficulty))) - per_jar = int(rng.randint(6, int(20 * difficulty))) - num_jars = int(rng.randint(3, int(15 * difficulty))) - - # Ensure total is divisible by per_pan - total = num_jars * per_jar - while total % per_pan != 0: - num_jars = int(rng.randint(3, int(15 * difficulty))) - total = num_jars * per_jar - - result = generate_from_variables(name, item, food, location, container, - num_jars, per_jar, per_pan) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Mary', 'sprinkles', 'cupcake', 'pantry', 'pan', - 6, 8, 12) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_40.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_40.py deleted file mode 100644 index 12f21fde..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_40.py +++ /dev/null @@ -1,64 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(item: str, n1: int, c1: str, c2: str, c3: str, p: int) -> Dict[str, Any]: - more_cards = int(p/100 * n1) - n2 = n1 + more_cards - n3 = n1 + n2 - total = n3 + n3 - - question = f"In a set of {item}'s cards, there are {n1} {c1} cards, and {p}% more {c2} cards. {c3} cards are as many as the sum of {c1} and {c2} cards. How many cards of all mentioned colors are there?" - - answer_cot = f"There are {p}/100 * {n1} = {more_cards} more {c2} cards than {c1} cards.\n" \ - f"Which means there are {n1} + {more_cards} = {n2} {c2} cards.\n" \ - f"{c3} cards make up to {n1} + {n2} = {n3} cards.\n" \ - f"So in total, there are {n3} + {n3} = {total} cards of different colors.\n" \ - f"#### {total}" - - return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'item': item, - 'n1': n1, - 'c1': c1, - 'c2': c2, - 'c3': c3, - 'p': p, - 'more_cards': more_cards, - 'total': total - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - items = ["magician", "artist", "chef", "scientist", "athlete"] - colors = ["red", "blue", "green", "yellow", "purple", "orange"] - - item = rng.choice(items) - c1, c2, c3 = rng.sample(colors, 3) - - n1 = int(rng.randint(20, int(81 * difficulty))) - - # Generate p ensuring division results in integer - while True: - p = int(rng.randint(20, min(90, int(100 * difficulty)))) - if (p/100 * n1).is_integer(): - break - - result = generate_from_variables(item, n1, c1, c2, c3, p) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("magician", 15, "red", "green", "yellow", 60) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_41.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_41.py deleted file mode 100644 index 6e7e7761..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_41.py +++ /dev/null @@ -1,83 +0,0 @@ -from random import Random -from typing import Dict, Any -from fractions import Fraction - -def generate_from_variables(name: str, event: str, organization: str, fraction: str, - current: int, total: int, currency: str) -> Dict[str, Any]: - fraction = convert_fraction_word(fraction) - fraction_val = Fraction(fraction) - org_amount = int(total * fraction_val) - covered_amount = org_amount + current - missing_amount = total - covered_amount - - question = f"{name} is raising money for a {event}. He has applied for help from the {organization}, which has decided to cover {fraction} of the cost of the {event}. How much money is {name} missing if he has {currency}{current} and the {event} costs {currency}{total}?" - - answer_cot = f"{name}'s {organization} has decided to pay {total} * {fraction} = {currency}{org_amount} for his {event}.\nIn total {name} has covered {org_amount} + {current} = {currency}{covered_amount} for his {event}\nTherefore, {name} needs {total} - {covered_amount} = {currency}{missing_amount} more for the {event}.\n#### {missing_amount}" - - return { - 'question': question, - 'answer': str(missing_amount), - 'answer_cot': answer_cot, - 'answer_value': missing_amount, - 'variables': { - 'name': name, - 'event': event, - 'organization': organization, - 'fraction': fraction, - 'current_amount': current, - 'total_cost': total, - 'currency': currency, - 'org_contribution': org_amount, - 'covered_amount': covered_amount - } - } - -def convert_fraction_word(fraction_str: str) -> str: - """Convert word fractions to numeric form""" - - # Add fraction word mapping - FRACTION_WORDS = { - "half": "1/2", - "one-half": "1/2", - "quarter": "1/4", - } - return FRACTION_WORDS.get(fraction_str.lower(), fraction_str) - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["John", "Michael", "David", "James", "William", "Robert", "Joseph"] - events = ["field trip", "sports tournament", "conference", "music festival", "science fair"] - organizations = ["school", "community center", "local charity", "youth club", "parent association"] - currencies = ["$", "€", "£"] - fractions = ["half", "1/2", "one-half"] - - name = rng.choice(names) - event = rng.choice(events) - organization = rng.choice(organizations) - currency = rng.choice(currencies) - fraction = rng.choice(fractions) - fraction = convert_fraction_word(fraction) - - # Scale ranges by difficulty but ensure results are integers - current = int(rng.randint(10, int(200 * difficulty)) // 5 * 5) - total = int(rng.randint(200, int(1000 * difficulty)) // 10 * 10) - - # Ensure conditions are met - while current >= total or not float(total * Fraction(fraction)).is_integer(): - current = int(rng.randint(10, int(200 * difficulty)) // 5 * 5) - total = int(rng.randint(200, int(1000 * difficulty)) // 10 * 10) - - result = generate_from_variables(name, event, organization, fraction, current, total, currency) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("John", "school trip", "school", "half", 50, 300, "$") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_42.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_42.py deleted file mode 100644 index 8f2f9b14..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_42.py +++ /dev/null @@ -1,84 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(title: str, name: str, property_type: str, price: int, - fee1_name: str, fee1_percent: int, - fee2_name: str, fee2_percent: int, - loan: int) -> Dict[str, Any]: - - fee1_amount = price * fee1_percent // 100 - fee2_amount = price * fee2_percent // 100 - total_fees = fee1_amount + fee2_amount + loan - net_proceeds = price - total_fees - - question = f"{title} {name} sold his {property_type} for ${price}. He paid the {fee1_name} fees that amount to {fee1_percent}% of the selling price and also paid a {fee2_name} fee that is {fee2_percent}% of the selling price. If he also paid ${loan} for the remaining loan amount of the {property_type}, how much is {title} {name}'s net proceeds from selling the {property_type}?" - - answer_cot = f"{title} {name} paid ${price} x {fee1_percent}/100 = ${fee1_amount} for the {fee1_name} fees.\n" \ - f"He paid ${price} x {fee2_percent}/100 = ${fee2_amount} for the {fee2_name} fee.\n" \ - f"So, {title} {name} paid a total of ${fee1_amount} + ${fee2_amount} + ${loan} = ${total_fees} for the {fee1_name}, {fee2_name}, and loan fees.\n" \ - f"Hence, {title} {name}'s net proceeds is ${price} - ${total_fees} = ${net_proceeds}.\n#### {net_proceeds}" - - return { - 'question': question, - 'answer': str(net_proceeds), - 'answer_cot': answer_cot, - 'answer_value': net_proceeds, - 'variables': { - 'title': title, - 'name': name, - 'property_type': property_type, - 'price': price, - 'fee1_name': fee1_name, - 'fee1_percent': fee1_percent, - 'fee2_name': fee2_name, - 'fee2_percent': fee2_percent, - 'loan': loan, - 'fee1_amount': fee1_amount, - 'fee2_amount': fee2_amount, - 'total_fees': total_fees, - 'net_proceeds': net_proceeds - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - titles = ['Mr.', 'Prof.', 'Dr.'] - names = ['Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller', 'Davis', 'Rodriguez', 'Martinez'] - properties = ['house', 'apartment', 'condo', 'villa', 'cottage'] - fee1_names = ['transfer', 'registration', 'legal'] - fee2_names = ['brokerage', 'agent', 'realtor'] - - title = rng.choice(titles) - name = rng.choice(names) - property_type = rng.choice(properties) - fee1_name = rng.choice(fee1_names) - fee2_name = rng.choice(fee2_names) - - price = int(rng.randint(200000, int(1000000 * difficulty)) // 10000 * 10000) - fee1_percent = rng.randint(1, int(5 * difficulty)) - fee2_percent = rng.randint(2, int(7 * difficulty)) - loan = int(rng.randint(100000, int(700000 * difficulty)) // 10000 * 10000) - - # Ensure conditions are met - while price <= loan or price - (price * (fee1_percent + fee2_percent) / 100 + loan) <= 1: - price = int(rng.randint(200000, int(1000000 * difficulty)) // 10000 * 10000) - loan = int(rng.randint(100000, int(700000 * difficulty)) // 10000 * 10000) - - result = generate_from_variables(title, name, property_type, price, - fee1_name, fee1_percent, - fee2_name, fee2_percent, loan) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Mr.', 'Tan', 'house', 400000, - 'transfer', 3, - 'brokerage', 5, 250000) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_43.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_43.py deleted file mode 100644 index 48e37c70..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_43.py +++ /dev/null @@ -1,54 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(person1: str, item: str, n: int, relation: str, k: int) -> Dict[str, Any]: - other_amount = n - k - total = n + other_amount - - question = f"A {person1} has {n} {item}s. His {relation} has {k} fewer {item}s than he has. How many {item}s do they have together?" - - answer_cot = f"His {relation} has {n} - {k} = {other_amount} {item}s.\nTogether, they have {n} + {other_amount} = {total} {item}s.\n#### {total}" - - return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'person1': person1, - 'item': item, - 'first_amount': n, - 'relation': relation, - 'difference': k, - 'second_amount': other_amount, - 'total': total - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - people = ["student", "boy", "child", "kid"] - items = ["marble", "sticker", "toy", "book", "pencil"] - relations = ["sister", "brother", "friend", "cousin"] - - person1 = rng.choice(people) - item = rng.choice(items) - relation = rng.choice(relations) - - n = int(rng.randint(5, int(21 * difficulty))) - k = int(rng.randint(2, min(n-1, int(10 * difficulty)))) - - result = generate_from_variables(person1, item, n, relation, k) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("boy", "card", 5, "brother", 3) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_44.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_44.py deleted file mode 100644 index 2aaf8841..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_44.py +++ /dev/null @@ -1,65 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(store: str, color1: str, color2: str, color3: str, - n1: int, n2: int, n3: int, p1: int, p2: int, p3: int, - currency: str) -> Dict[str, Any]: - total1 = n1 * p1 - total2 = n2 * p2 - total3 = n3 * p3 - grand_total = total1 + total2 + total3 - - question = f"There are currently {n1} {color1} balls, {n2} {color2} balls, and {n3} {color3} balls in the {store}. {color1} balls cost {currency}{p1}, {color2} balls cost {currency}{p2} and {color3} balls cost {currency}{p3}. How much will the {store} have received after all the balls are sold?" - - answer_cot = f"For the {color1} balls, {n1} balls * {currency}{p1}/ball = {currency}{total1}.\nFor the {color2} balls, {n2} balls * {currency}{p2}/ball = {currency}{total2}.\nFor the {color3} balls, {n3} balls * {currency}{p3}/ball = {currency}{total3}.\nFor all balls, {currency}{total1} + {currency}{total2} + {currency}{total3} = {currency}{grand_total}.\n#### {grand_total}" - - return { - 'question': question, - 'answer': str(grand_total), - 'answer_cot': answer_cot, - 'answer_value': grand_total, - 'variables': { - 'store': store, - 'colors': [color1, color2, color3], - 'quantities': [n1, n2, n3], - 'prices': [p1, p2, p3], - 'currency': currency, - 'subtotals': [total1, total2, total3], - 'total': grand_total - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - stores = ["store", "shop", "market", "warehouse"] - colors = ["red", "blue", "green", "yellow", "purple", "orange", "pink"] - currencies = ["$", "€", "£"] - - store = rng.choice(stores) - color1, color2, color3 = rng.sample(colors, 3) - currency = rng.choice(currencies) - - n1 = int(rng.randint(3, int(20 * difficulty))) - n2 = int(rng.randint(5, int(30 * difficulty))) - n3 = int(rng.randint(15, int(50 * difficulty))) - - p1 = int(rng.randint(5, int(15 * difficulty))) - p2 = int(rng.randint(3, int(10 * difficulty))) - p3 = int(rng.randint(2, int(8 * difficulty))) - - result = generate_from_variables(store, color1, color2, color3, n1, n2, n3, - p1, p2, p3, currency) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("store", "red", "blue", "green", 3, 11, 25, - 9, 5, 3, "$") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_45.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_45.py deleted file mode 100644 index 9dc69f27..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_45.py +++ /dev/null @@ -1,69 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, event: str, food: str, obj: str, - package_husband: int, used_items: int, - total_remaining: int) -> Dict[str, Any]: - - total_items = total_remaining + used_items - package_size = total_items - package_husband - - question = f"{name} was preparing for a {event} at her house, where she intended to serve {food}. She noticed that she was out of plastic {obj}, so she bought a new package of {obj}. Later, her husband also bought a package of {package_husband} new {obj} and gave them to {name}. While {name} was making the {food}, she used {used_items} of the {obj} to sample her {food}. Later, when she went to set the table, she had a total of {total_remaining} {obj}. How many {obj} were in the package that {name} bought?" - - answer_cot = f"The total number of {obj} from {name} and her husband was {total_remaining}+{used_items}={total_items} {obj}.\nSince the husband bought a package of {package_husband} {obj}, then {name}'s package contained {total_items}-{package_husband}={package_size} {obj}.\n#### {package_size}" - - return { - 'question': question, - 'answer': str(package_size), - 'answer_cot': answer_cot, - 'answer_value': package_size, - 'variables': { - 'name': name, - 'event': event, - 'food': food, - 'obj': obj, - 'husband_package': package_husband, - 'used_items': used_items, - 'remaining': total_remaining, - 'total': total_items, - 'package_size': package_size - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['Emma', 'Olivia', 'Sophia', 'Isabella', 'Ava', 'Mia', 'Charlotte'] - events = ['lunch party', 'birthday party', 'potluck party', 'baby shower', 'game night'] - foods = ['roast chicken', 'grilled salmon', 'beef stew', 'vegetable lasagna', - 'stuffed peppers', 'shrimp scampi', 'creme brulee'] - objects = ['spoons', 'forks', 'plates'] - - name = rng.choice(names) - event = rng.choice(events) - food = rng.choice(foods) - obj = rng.choice(objects) - - package_husband = int(rng.randint(5, int(20 * difficulty))) - used_items = int(rng.randint(3, int(10 * difficulty))) - - # Calculate total_remaining to satisfy conditions - package_size = int(rng.randint(10, int(30 * difficulty))) - total_items = package_size + package_husband - total_remaining = total_items - used_items - - result = generate_from_variables(name, event, food, obj, - package_husband, used_items, total_remaining) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Julia", "dinner party", "stew", "spoons", - 5, 3, 12) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_46.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_46.py deleted file mode 100644 index 3d0572a6..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_46.py +++ /dev/null @@ -1,71 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(fruit1: str, fruit2: str, n1: int, n2: int, - frac1: float, frac2: float, spill: int, total: int) -> Dict[str, Any]: - n1_after_spill = n1 - spill - water_fruit1 = (n1_after_spill * frac1) - water_fruit2 = (n2 * frac2) - total_water = water_fruit1 + water_fruit2 - - question = f"I have {n1} liters of {fruit1} drink that are {frac1} water and I wish to add it to {n2} liters of {fruit2} drink that is {frac2} water. But as I pour it, I spill {spill} liter of the {fruit1} drink. How much water is in the remaining {total} liters?" - - answer_cot = f"There are {n2} x {frac2} = {water_fruit2} liters of water from the {n2} liters {fruit2} drink.\nAfter {spill} liter of {fruit1} drink was spilled, there were {n1} - {spill} = {n1_after_spill} liters of {fruit1} drink left.\nOut of the {n1_after_spill} liters, {n1_after_spill} x {frac1} = {water_fruit1} liters are water.\nThus, there are a total of {water_fruit2} + {water_fruit1} = {total_water} liters of water out of the {total} liters.\n#### {int(total_water)}" - - return { - 'question': question, - 'answer': str(int(total_water)), - 'answer_cot': answer_cot, - 'answer_value': int(total_water), - 'variables': { - 'fruit1': fruit1, - 'fruit2': fruit2, - 'initial_amount1': n1, - 'initial_amount2': n2, - 'water_fraction1': frac1, - 'water_fraction2': frac2, - 'spilled_amount': spill, - 'total_volume': total, - 'water_content1': water_fruit1, - 'water_content2': water_fruit2 - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - fruits = ["apple", "grape", "mango", "peach", "lemon"] - fractions = {"two-thirds": 2/3, "three-fifths": 3/5, "three-quarters": 3/4, - "one-half": 1/2, "four-fifths": 4/5} - - fruit1, fruit2 = rng.sample(fruits, 2) - frac1 = rng.choice(list(fractions.values())) - frac2 = rng.choice(list(fractions.values())) - - n1 = int(rng.randint(9, int(21 * difficulty))) - n2 = int(rng.randint(12, int(31 * difficulty))) - spill = int(rng.randint(3, min(7, n1))) - - # Ensure conditions are met - while not (n1 + n2 - spill > 0 and - (n2 * frac2).is_integer() and - ((n1 - spill) * frac1).is_integer()): - n1 = int(rng.randint(9, int(21 * difficulty))) - n2 = int(rng.randint(12, int(31 * difficulty))) - spill = int(rng.randint(3, min(7, n1))) - - total = n1 + n2 - spill - - result = generate_from_variables(fruit1, fruit2, n1, n2, frac1, frac2, spill, total) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("orange", "pineapple", 10, 15, 2/3, 3/5, 1, 24) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_47.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_47.py deleted file mode 100644 index 547c2c5c..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_47.py +++ /dev/null @@ -1,69 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, n1: int, c1: float, n2: int, c2: float, - c3: int, obj1: str, obj2: str, currency: str) -> Dict[str, Any]: - cost1 = n1 * c1 - cost2 = n2 * c2 - total_cost = cost1 + cost2 + c3 - - question = f"{name} went to buy some school supplies. He bought {n1} {obj1} which cost {currency}{c1} each, {n2} {obj2} which cost {currency}{c2} each, and a rim of bond paper which cost {currency}{c3}. How much did {name} spend on everything?" - - answer_cot = f"{name} spent {n1} x {currency}{c1} = {currency}{int(cost1)} for the {obj1}.\n" \ - f"He also spent {n2} x {currency}{c2} = {currency}{int(cost2)} for the {obj2}.\n" \ - f"Therefore, {name} spent a total of {currency}{int(cost1)} + {currency}{int(cost2)} + {currency}{c3} = {currency}{int(total_cost)} for the school supplies.\n" \ - f"#### {int(total_cost)}" - - return { - 'question': question, - 'answer': str(int(total_cost)), - 'answer_cot': answer_cot, - 'answer_value': int(total_cost), - 'variables': { - 'name': name, - 'items1_count': n1, - 'item1_cost': c1, - 'items2_count': n2, - 'item2_cost': c2, - 'paper_cost': c3, - 'item1': obj1, - 'item2': obj2, - 'currency': currency - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["John", "Michael", "David", "James", "William", "Robert", "Thomas"] - items = ["notebooks", "pencils", "erasers", "crayons", "colored pencils", "markers", "rulers", "folders"] - currencies = ["$", "€", "£"] - - name = rng.choice(names) - obj1, obj2 = rng.sample(items, 2) - currency = rng.choice(currencies) - - n1 = int(rng.randrange(6, int(25 * difficulty), 2)) - c1 = round(rng.uniform(2.25, 11.5 * difficulty) * 4) / 4 # Round to nearest 0.25 - n2 = int(rng.randrange(4, int(15 * difficulty), 2)) - c2 = round(rng.uniform(8.25, 19.5 * difficulty) * 4) / 4 - c3 = int(rng.randint(10, int(25 * difficulty))) - - # Ensure conditions are met - while not (n1 * c1).is_integer() or not (n2 * c2).is_integer(): - c1 = round(rng.uniform(2.25, 11.5 * difficulty) * 4) / 4 - c2 = round(rng.uniform(8.25, 19.5 * difficulty) * 4) / 4 - - result = generate_from_variables(name, n1, c1, n2, c2, c3, obj1, obj2, currency) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Raphael", 4, 1.5, 2, 4, 20, "pens", "notebooks", "$") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_48.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_48.py deleted file mode 100644 index 84df81fe..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_48.py +++ /dev/null @@ -1,71 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(item1: str, item2: str, shop: str, currency: str, - price1: int, price2: int, n1: int, n2: int) -> Dict[str, Any]: - total1 = n1 * price1 - total2 = n2 * price2 - diff = total1 - total2 - - question = f"A loaf of {item1} at the {shop} costs {currency}{price1}. {item2}s cost {currency}{price2} each. How much more do {n1} loaves of {item1} cost than {n2} {item2}s?" - - answer_cot = f"{n1} loaves of {item1} cost {n1} * {currency}{price1} = {currency}{total1}.\n" \ - f"{n2} {item2}s cost {n2} * {currency}{price2} = {currency}{total2}.\n" \ - f"The loaves of {item1} cost {currency}{total1} - {currency}{total2} = {currency}{diff} more than the {item2}s.\n" \ - f"#### {diff}" - - return { - 'question': question, - 'answer': str(diff), - 'answer_cot': answer_cot, - 'answer_value': diff, - 'variables': { - 'item1': item1, - 'item2': item2, - 'shop': shop, - 'currency': currency, - 'price1': price1, - 'price2': price2, - 'n1': n1, - 'n2': n2, - 'total1': total1, - 'total2': total2 - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - items1 = ["bread", "sourdough"] - items2 = ["bagel", "muffin", "croissant", "biscuit"] - shops = ["bakery", "cafe", "store", "market"] - currencies = ["$", "£", "€"] - - item1 = rng.choice(items1) - item2 = rng.choice(items2) - shop = rng.choice(shops) - currency = rng.choice(currencies) - - price1 = int(rng.randint(2, int(10 * difficulty))) - price2 = int(rng.randint(1, int(5 * difficulty))) - n1 = int(rng.randint(2, int(10 * difficulty))) - n2 = int(rng.randint(2, int(10 * difficulty))) - - # Ensure condition: n1 * price1 > n2 * price2 - while n1 * price1 <= n2 * price2: - n1 = int(rng.randint(2, int(10 * difficulty))) - n2 = int(rng.randint(2, int(10 * difficulty))) - - result = generate_from_variables(item1, item2, shop, currency, price1, price2, n1, n2) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("bread", "bagel", "bakery", "$", 2, 1, 3, 2) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_49.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_49.py deleted file mode 100644 index 724aacaf..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_49.py +++ /dev/null @@ -1,80 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, item1: str, item2: str, price1: int, price2: int, - total: float, n1: int, percent: int, currency: str) -> Dict[str, Any]: - change = total * percent / 100 - spent = total * (100 - percent) / 100 - cost_item1 = n1 * price1 / 100 - spent_item2 = spent - cost_item1 - n2 = int(spent_item2 / (price2 / 100)) - - question = f"The vending machines sell {item1} for {price1} cents and {item2} for {price2} cents. {name} spent {currency}{total} and got {n1} bags of {item1} and had {percent}% of his money left. How many {item2} did he buy?" - - answer_cot = f"{name} got {currency}{change} in change because {total} x {percent}/100 = {change}\n" \ - f"{name} spent {currency}{spent} because {total} - {change} = {spent}\n" \ - f"{name} spent {currency}{cost_item1} on {item1} because {n1} x {price1/100} = {cost_item1}\n" \ - f"{name} spent {spent_item2} on {item2} because {spent} - {cost_item1} = {spent_item2}\n" \ - f"{name} bought {n2} {item2} because {spent_item2} / {price2/100} = {n2}\n" \ - f"#### {n2}" - - return { - 'question': question, - 'answer': str(n2), - 'answer_cot': answer_cot, - 'answer_value': n2, - 'variables': { - 'name': name, - 'item1': item1, - 'item2': item2, - 'price1': price1, - 'price2': price2, - 'total_spent': total, - 'num_item1': n1, - 'num_item2': n2, - 'percent_change': percent, - 'currency': currency - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["George", "James", "John", "Robert", "Michael", "William"] - items = ['pretzels', 'popcorn', 'gum', 'cookies', 'crackers'] - currencies = ['$', '£', '€'] - - name = rng.choice(names) - item1, item2 = rng.sample(items, 2) - currency = rng.choice(currencies) - - price1 = int(rng.randrange(25, int(100 * difficulty), 5)) - price2 = int(rng.randrange(50, int(150 * difficulty), 5)) - while price2 <= price1: - price2 = int(rng.randrange(50, int(150 * difficulty), 5)) - - total = int(rng.randrange(500, int(1500 * difficulty), 100)) - n1 = int(rng.randint(1, int(10 * difficulty))) - percent = int(rng.randint(1, int(10 * difficulty))) - - # Validate conditions - while not (isinstance(total * percent / 100, int) and - isinstance((total * (100 - percent) / 100 - n1 * price1 / 100) / (price2 / 100), int) and - (total * (100 - percent) / 100 - n1 * price1 / 100) % (price2 / 100) == 0): - total = int(rng.randrange(500, int(1500 * difficulty), 100)) - n1 = int(rng.randint(1, int(10 * difficulty))) - percent = int(rng.randint(1, int(10 * difficulty))) - - result = generate_from_variables(name, item1, item2, price1, price2, total, n1, percent, currency) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("George", "chips", "candy bars", 40, 75, 5, 3, 1, "$") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_5.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_5.py deleted file mode 100644 index e6071ba9..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_5.py +++ /dev/null @@ -1,73 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name1: str, name2: str, city: str, celebrity_type: str, - vacation_type: str, n1: int, n2: int, s1: int, s2: int, - goal: int) -> Dict[str, Any]: - signatures_collected = s1 + s2 - signatures_needed = goal - signatures_collected - - question = f"{name1} and {name2} are sisters from {city} who love collecting signatures from {celebrity_type}. During their {vacation_type} from school, the sisters spend every afternoon collecting signatures. After {n1} weeks, {name1} and {name2} compare their autograph books, counting up the number of signatures each sister has collected. {name1} has {s1} signatures in her book, and {name2} has {s2}. The sisters have {n2} more weeks of {vacation_type}, and they decide they want to reach {goal} signatures between them by the end of the summer. How many signatures do the sisters need to collect to reach their goal?" - - answer_cot = f"{name1} and {name2} have already collected {s1} + {s2} signatures = {signatures_collected} signatures.\nSince their goal is {goal}, they need to collect {goal} - {signatures_collected} signatures. {goal} - {signatures_collected} = {signatures_needed} signatures\n#### {signatures_needed}" - - return { - 'question': question, - 'answer': str(signatures_needed), - 'answer_cot': answer_cot, - 'answer_value': signatures_needed, - 'variables': { - 'name1': name1, - 'name2': name2, - 'city': city, - 'celebrity_type': celebrity_type, - 'vacation_type': vacation_type, - 'weeks_passed': n1, - 'weeks_remaining': n2, - 'signatures1': s1, - 'signatures2': s2, - 'goal': goal, - 'signatures_collected': signatures_collected, - 'signatures_needed': signatures_needed - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ['Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia', 'Charlotte', 'Carol', 'Jennifer'] - cities = ['Los Angeles', 'New York', 'Chicago', 'Houston', 'Phoenix'] - celebrity_types = ['movie stars', 'athletes', 'musicians', 'politicians', 'authors'] - vacation_types = ['winter break', 'spring break', 'summer break', 'fall break'] - - name1, name2 = rng.sample(names_female, 2) - city = rng.choice(cities) - celebrity_type = rng.choice(celebrity_types) - vacation_type = rng.choice(vacation_types) - - n1 = int(rng.randint(3, int(8 * difficulty))) - n2 = int(rng.randint(2, int(5 * difficulty))) - s1 = int(rng.randint(15, int(40 * difficulty))) - s2 = int(rng.randint(30, int(60 * difficulty))) - goal = int(rng.randrange(90, int(150 * difficulty), 5)) - - # Ensure conditions are met - while s1 + s2 >= goal: - s1 = int(rng.randint(15, int(40 * difficulty))) - s2 = int(rng.randint(30, int(60 * difficulty))) - - result = generate_from_variables(name1, name2, city, celebrity_type, vacation_type, - n1, n2, s1, s2, goal) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Carol', 'Jennifer', 'Los Angeles', 'celebrities', - 'summer break', 5, 3, 20, 44, 100) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_50.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_50.py deleted file mode 100644 index 5b3f1ff2..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_50.py +++ /dev/null @@ -1,48 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, pieces1: int, pieces2: int) -> Dict[str, Any]: - half_pieces1 = pieces1 // 2 - total_pieces = half_pieces1 + pieces2 - - question = f"{name} finished half of a {pieces1} piece puzzle, and then started and finished another {pieces2} piece puzzle within an hour. How many puzzle pieces did {name} place during that hour?" - - answer_cot = f"{name} did 1/2 * {pieces1} pieces = {half_pieces1} pieces.\n{name} completed {half_pieces1} pieces + {pieces2} pieces = {total_pieces} pieces.\n#### {total_pieces}" - - return { - 'question': question, - 'answer': str(total_pieces), - 'answer_cot': answer_cot, - 'answer_value': total_pieces, - 'variables': { - 'name': name, - 'puzzle1_pieces': pieces1, - 'puzzle2_pieces': pieces2, - 'half_puzzle1': half_pieces1, - 'total_pieces': total_pieces - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Teddy", "Tommy", "Billy", "Jimmy", "Bobby", "Danny"] - name = rng.choice(names) - - # Generate random puzzle sizes that are even numbers - puzzle1 = int(rng.randint(100, int(500 * difficulty)) // 2 * 2) - puzzle2 = int(rng.randint(300, int(1000 * difficulty)) // 2 * 2) - - result = generate_from_variables(name, puzzle1, puzzle2) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Teddy", 500, 500) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_51.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_51.py deleted file mode 100644 index d57fa027..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_51.py +++ /dev/null @@ -1,86 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, parent: str, activity1: str, activity2: str, - activity3: str, cur: str, times: int, budget: int, - tokens: int, cost1: int, cost2: int) -> Dict[str, Any]: - - cost_per_ride = cost2 * times - cost_per_person = tokens + cost1 + cost_per_ride - total_people = budget // cost_per_person - friends = total_people - 1 - - question = f"{name}'s {parent} said that she had {cur}{budget} budgeted for her birthday party. She wants to make sure she and her friends all get to play one round of {activity1}, have {cur}{tokens} in {activity2} tokens, and get to ride the {activity3} {times}. A round of {activity1} is {cur}{cost1}. The {activity3} cost {cur}{cost2} a ride. How many friends can she invite?" - - answer_cot = f"The {activity3} will cost {cur}{cost_per_ride} per person because {cost2} x {times} = {cost_per_ride}\n" \ - f"Each person costs {cur}{cost_per_person} because {tokens} + {cost1} + {cost_per_ride} = {cost_per_person}\n" \ - f"{total_people} total people can attend because {budget} / {cost_per_person} = {total_people}\n" \ - f"She can invite {friends} friends because {total_people} - 1 = {friends}\n" \ - f"#### {friends}" - - return { - 'question': question, - 'answer': str(friends), - 'answer_cot': answer_cot, - 'answer_value': friends, - 'variables': { - 'name': name, - 'parent': parent, - 'activity1': activity1, - 'activity2': activity2, - 'activity3': activity3, - 'currency': cur, - 'times': times, - 'budget': budget, - 'tokens': tokens, - 'cost1': cost1, - 'cost2': cost2, - 'cost_per_ride': cost_per_ride, - 'cost_per_person': cost_per_person, - 'total_people': total_people - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ['Emma', 'Olivia', 'Sophia', 'Isabella', 'Mia', 'Charlotte'] - parents = ['mom', 'dad', 'aunt', 'uncle'] - activities1 = ['mini-golf', 'bowling', 'laser tag'] - activities2 = ['arcade', 'game room', 'pinball'] - activities3 = ['go-karts', 'bumper cars', 'roller coaster'] - currencies = ['$', '£', '€'] - times_options = [2, 3] - - name = rng.choice(names_female) - parent = rng.choice(parents) - activity1 = rng.choice(activities1) - activity2 = rng.choice(activities2) - activity3 = rng.choice(activities3) - cur = rng.choice(currencies) - times = rng.choice(times_options) - - tokens = int(rng.randint(3, int(11 * difficulty))) - cost1 = int(rng.randint(3, int(11 * difficulty))) - cost2 = int(rng.randint(5, int(21 * difficulty))) - - # Generate budget ensuring conditions are met - cost_per_person = tokens + cost1 + (cost2 * times) - num_people = rng.randint(2, int(10 * difficulty)) - budget = cost_per_person * num_people - - result = generate_from_variables(name, parent, activity1, activity2, activity3, - cur, times, budget, tokens, cost1, cost2) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Morgan', 'dad', 'mini-golf', 'arcade', 'go-karts', - '$', 2, 90, 5, 5, 10) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_52.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_52.py deleted file mode 100644 index 0fd9cb22..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_52.py +++ /dev/null @@ -1,72 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, alphabets: tuple, n1: str, frac: str) -> Dict[str, Any]: - alphabet_name, alphabet_count = alphabets - - # Calculate intermediate values - full_writes = n1 * alphabet_count - half_write = int(alphabet_count * frac) - subtotal = full_writes + half_write - final_total = subtotal * 2 - - question = f"{name} is learning to write and decides to keep re-writing the {alphabet_name} until she knows it. She writes it in full {n1}, writes {frac} of it once, then re-writes everything she has already written. How many letters has {name} written in total?" - - answer_cot = f"{name} has written the {alphabet_name} {n1} time(s) which is a total of {alphabet_count} * {n1} = {full_writes} letters.\n" \ - f"She then writes {frac} the {alphabet_name}, which is {alphabet_count} * {frac} = {half_write} letters.\n" \ - f"So far, this is a total of {full_writes} + {half_write} = {subtotal} letters.\n" \ - f"Writing this again means she has doubled the number of letters she has written, so she has written a total of {subtotal} * 2 = {final_total} letters.\n" \ - f"#### {final_total}" - - return { - 'question': question, - 'answer': str(final_total), - 'answer_cot': answer_cot, - 'answer_value': final_total, - 'variables': { - 'name': name, - 'alphabet_name': alphabet_name, - 'alphabet_count': alphabet_count, - 'times_written': n1, - 'fraction': frac, - 'full_writes': full_writes, - 'half_write': half_write, - 'total': final_total - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ["Emma", "Sophia", "Olivia", "Ava", "Isabella", "Mia", "Charlotte", "Amelia"] - alphabets = [("alphabet", 26), ("hiragana (with 48 letters)", 48), - ("farsi alphabet (with 32 letters)", 32), ("arabic abjad (with 28 letters)", 28)] - multi_times = ["twice", "three times", "four times"] - fraction_alnum = ["half", "one-third", "one-fourth"] - - name = rng.choice(names_female) - alphabet = rng.choice(alphabets) - n1 = rng.choice(multi_times) - frac = rng.choice(fraction_alnum) - - # Convert text numbers to numeric values - n1_map = {"twice": 2, "three times": 3, "four times": 4} - frac_map = {"half": 0.5, "one-third": 1/3, "one-fourth": 0.25} - - # Ensure division results in integer - while not (alphabet[1] * frac_map[frac]).is_integer(): - alphabet = rng.choice(alphabets) - - result = generate_from_variables(name, alphabet, n1_map[n1], frac_map[frac]) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Elise", ("alphabet", 26), 2, 0.5) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_53.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_53.py deleted file mode 100644 index af067ce1..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_53.py +++ /dev/null @@ -1,61 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, sides: int, target: int, property: str) -> Dict[str, Any]: - numbers_above = sides - target - prob_above = (numbers_above / sides) * 100 - prob_two_in_row = 25 # probability of two even/odd in a row is always 25% - difference = int(prob_above - prob_two_in_row) - - question = f"{name} is rolling a {sides}-sided die. How much more likely is it (expressed as a percentage) that he rolls a number greater than {target} than that he rolls two {property} numbers in a row?" - - answer_cot = f"There are {numbers_above} numbers greater than {target} on the dice, so the chances of rolling one of them are {numbers_above} / {sides} = {prob_above}%.\nThe chance of rolling one {property} number is 50%, so the chance of rolling two in a row is 50% * 50% = 25%.\nThe difference between these two probabilities is {prob_above}% - 25% = {difference}%.\n#### {difference}" - - return { - 'question': question, - 'answer': str(difference), - 'answer_cot': answer_cot, - 'answer_value': difference, - 'variables': { - 'name': name, - 'sides': sides, - 'target': target, - 'property': property, - 'numbers_above': numbers_above, - 'prob_above': prob_above, - 'prob_two_in_row': prob_two_in_row - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"] - properties = ["even", "odd"] - - name = rng.choice(names) - property = rng.choice(properties) - - dice_options = [4, 6, 8, 10, 12, 20] - sides = rng.choice(dice_options) - - # Generate target ensuring conditions are met - while True: - target = rng.randint(1, sides-1) - prob = ((sides-target)/sides) * 100 - if (sides-target) % target == 0 and prob.is_integer() and prob > 25: - break - - result = generate_from_variables(name, sides, target, property) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Jerry", 6, 3, "even") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_54.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_54.py deleted file mode 100644 index 06c4b059..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_54.py +++ /dev/null @@ -1,71 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name1: str, name2: str, total_time: int, - library_time: int, station_time: int, - location1: str, location2: str, location3: str) -> Dict[str, Any]: - - time_after_library = total_time - library_time - remaining_time = time_after_library - station_time - - question = f"{name1} and {name2} have {total_time} minutes to walk to {location1} together. It takes them {library_time} minutes to get to the corner where the {location2} is. It takes them another {station_time} minutes to get to the {location3}. How much longer do they have to get to {location1} without being late?" - - answer_cot = f"{name1} and {name2} arrive at the {location2} with {total_time} - {library_time} = {time_after_library} minutes left to reach the {location1}.\nThey then arrive at the {location3} and have {time_after_library} - {station_time} = {remaining_time} minutes left to get to {location1} without being late.\n#### {remaining_time}" - - return { - 'question': question, - 'answer': str(remaining_time), - 'answer_cot': answer_cot, - 'answer_value': remaining_time, - 'variables': { - 'name1': name1, - 'name2': name2, - 'total_time': total_time, - 'library_time': library_time, - 'station_time': station_time, - 'location1': location1, - 'location2': location2, - 'location3': location3, - 'remaining_time': remaining_time - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['John', 'Jack', 'James', 'William', 'Michael', 'David', 'Joseph'] - locations = ['cinema', 'mall', 'library', 'park', 'gym', 'bank', 'school'] - - name1, name2 = rng.sample(names, 2) - loc1, loc2, loc3 = rng.sample(locations, 3) - - # Generate times ensuring they're not divisible by 5 - library_time = int(rng.randint(10, int(30 * difficulty))) - while library_time % 5 == 0: - library_time = int(rng.randint(10, int(30 * difficulty))) - - station_time = int(rng.randint(10, int(70 * difficulty))) - while station_time % 5 == 0: - station_time = int(rng.randint(10, int(70 * difficulty))) - - # Ensure total time is greater than sum of other times - min_total = library_time + station_time + 5 - total_time = int(rng.randint(min_total, int(140 * difficulty))) - while total_time % 5 == 0: - total_time = int(rng.randint(min_total, int(140 * difficulty))) - - result = generate_from_variables(name1, name2, total_time, library_time, - station_time, loc1, loc2, loc3) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('John', 'Jack', 30, 6, 13, - 'school', 'library', 'fire station') diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_55.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_55.py deleted file mode 100644 index 03984a26..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_55.py +++ /dev/null @@ -1,64 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, place: str, fruit: str, location: str, - insect1: str, insect2: str, n: int, frac: str) -> Dict[str, Any]: - num_insect1 = int(n * 0.5) # half as many bugs as ants - total_insects = n + num_insect1 - - question = f"{name} went to their {place} to pick some {fruit} and found {frac} as many {insect1} as {insect2} in the {location}. If there were {n} {insect2}, calculate the total number of insects in the {location}." - - answer_cot = f"If there were {n} {insect2}, the total number of {insect1} in the {location} is {frac} * {n} {insect2} = {num_insect1} {insect1}\nThe total number of insects in the {location} is {num_insect1} {insect1} + {n} {insect2} = {total_insects} insects\n#### {total_insects}" - - return { - 'question': question, - 'answer': str(total_insects), - 'answer_cot': answer_cot, - 'answer_value': total_insects, - 'variables': { - 'name': name, - 'place': place, - 'fruit': fruit, - 'location': location, - 'insect1': insect1, - 'insect2': insect2, - 'n': n, - 'frac': frac, - 'num_insect1': num_insect1 - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Dax", "Alex", "Sam", "Jordan", "Taylor", "Morgan", "Riley"] - places = ["orchard", "backyard", "greenhouse", "allotment"] - fruits = ["strawberries", "cherries", "blueberries", "raspberries"] - locations = ["garden", "field", "plot", "patch"] - insects = ["beetles", "ladybugs", "grasshoppers", "caterpillars", "bees", "wasps"] - - name = rng.choice(names) - place = rng.choice(places) - fruit = rng.choice(fruits) - location = rng.choice(locations) - insect1, insect2 = rng.sample(insects, 2) - - n = int(rng.randint(20, int(200 * difficulty))) - # Ensure n is even for "half as many" - if n % 2 == 1: - n += 1 - - result = generate_from_variables(name, place, fruit, location, insect1, insect2, n, "half") - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Dax", "farm", "apples", "garden", - "bugs", "ants", 50, "half") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_56.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_56.py deleted file mode 100644 index aca7d085..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_56.py +++ /dev/null @@ -1,62 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(family: str, item: str, total: int, n1: int, n2: int, - flavor1: str, flavor2: str, flavor3: str) -> Dict[str, Any]: - n3 = total - (n1 + n2) - - question = f"The {family} family is busy making {item}s. So far, they've made {total} {item}s. They have {n1} {flavor1} {item}s, {n2} {flavor2} {item}s, and some {flavor3} {item}s. How many {flavor3} {item}s have they made?" - - answer_cot = f"The total number of pieces of {flavor1} and {flavor2} {item}s is {n1} + {n2} = {n1+n2}.\nTherefore, they made {total} - {n1+n2} = {n3} {flavor3} {item}s.\n#### {n3}" - - return { - 'question': question, - 'answer': str(n3), - 'answer_cot': answer_cot, - 'answer_value': n3, - 'variables': { - 'family': family, - 'item': item, - 'total': total, - 'n1': n1, - 'n2': n2, - 'n3': n3, - 'flavor1': flavor1, - 'flavor2': flavor2, - 'flavor3': flavor3 - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - families = ["Smith", "Johnson", "Williams", "Brown", "Jones"] - items = ["cupcake", "muffin", "brownie", "biscuit"] - flavors = ["vanilla", "strawberry", "blueberry", "lemon", "peanut butter"] - - family = rng.choice(families) - item = rng.choice(items) - flavor1, flavor2, flavor3 = rng.sample(flavors, 3) - - total = int(rng.randrange(5000, int(10000 * difficulty), 25)) - n1 = int(rng.randint(1000, int(3000 * difficulty))) - n2 = int(rng.randint(1000, int(3000 * difficulty))) - - while n1 + n2 >= total: - n1 = int(rng.randint(1000, int(3000 * difficulty))) - n2 = int(rng.randint(1000, int(3000 * difficulty))) - - result = generate_from_variables(family, item, total, n1, n2, flavor1, flavor2, flavor3) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Adams", "cookie", 7995, 2595, 3075, - "rainbow", "oatmeal", "chocolate chip") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_57.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_57.py deleted file mode 100644 index 8a152a59..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_57.py +++ /dev/null @@ -1,60 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(n1: int, sport1: str, sport2: str, sport3: str, - n2: int, n3: int, multiplier: int) -> Dict[str, Any]: - n_volleyball = n1 * multiplier - n_soccer = n2 + n3 - total = n1 + n_volleyball + n_soccer - - question = f"There are {n1} students playing {sport1} and twice that number playing {sport2}. There are {n2} boys and {n3} girls playing {sport3}. If each student only participates in one group, how many students are there in total?" - - answer_cot = f"There are {n1} x {multiplier} = {n_volleyball} students playing {sport2}.\nThere are {n2} + {n3} = {n_soccer} students playing {sport3}.\nIn total there are {n1} + {n_volleyball} + {n_soccer} = {total} students.\n#### {total}" - - return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'tennis_players': n1, - 'volleyball_players': n_volleyball, - 'soccer_boys': n2, - 'soccer_girls': n3, - 'total_soccer': n_soccer, - 'total_students': total, - 'sports': [sport1, sport2, sport3] - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - sports = ['basketball', 'badminton', 'table tennis', 'football', 'volleyball'] - sport1, sport2, sport3 = rng.sample(sports, 3) - - # Generate numbers based on difficulty - n1 = int(rng.randint(4, int(21 * difficulty))) - n2 = int(rng.randint(10, int(31 * difficulty))) - n3 = int(rng.randint(10, int(31 * difficulty))) - multiplier = 2 # "twice" that number - - # Check condition - while n1 * multiplier + n2 + n3 > 250: - n1 = int(rng.randint(4, int(21 * difficulty))) - n2 = int(rng.randint(10, int(31 * difficulty))) - n3 = int(rng.randint(10, int(31 * difficulty))) - - result = generate_from_variables(n1, sport1, sport2, sport3, n2, n3, multiplier) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables(6, 'tennis', 'volleyball', 'soccer', 16, 22, 2) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_58.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_58.py deleted file mode 100644 index 3037fe47..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_58.py +++ /dev/null @@ -1,61 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, container: str, liquid: str, volume: int, unit: str, - num_containers: int, calories: int) -> Dict[str, Any]: - total_volume = volume * num_containers - total_calories = total_volume * calories - - question = f"A {container} of {liquid} is {volume} {unit}s of {liquid}. {name} drinks {num_containers} {container}s of {liquid}. If {liquid} has {calories} calories per {unit} how many calories did he consume?" - - answer_cot = f"He drank {volume}*{num_containers}={total_volume} {unit}s of {liquid}.\nSo he drank {total_volume}*{calories}={total_calories} calories of {liquid}\n#### {total_calories}" - - return { - 'question': question, - 'answer': str(total_calories), - 'answer_cot': answer_cot, - 'answer_value': total_calories, - 'variables': { - 'name': name, - 'container': container, - 'liquid': liquid, - 'volume': volume, - 'unit': unit, - 'num_containers': num_containers, - 'calories': calories, - 'total_volume': total_volume, - 'total_calories': total_calories - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["John", "Mike", "James", "David", "Robert", "William"] - containers = ["cup", "bottle", "carton"] - liquids = ["juice", "soda", "sparkling water", "tea", "lemonade"] - units = ["ounce", "mL", "cc", "oz"] - - name = rng.choice(names) - container = rng.choice(containers) - liquid = rng.choice(liquids) - unit = rng.choice(units) - - volume = int(rng.randint(6, int(16 * difficulty))) - num_containers = int(rng.randint(2, int(6 * difficulty))) - calories = int(rng.randint(2, int(10 * difficulty))) - - result = generate_from_variables(name, container, liquid, volume, unit, - num_containers, calories) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("John", "glass", "milk", 8, "ounce", 2, 3) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_59.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_59.py deleted file mode 100644 index dcd6e8d7..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_59.py +++ /dev/null @@ -1,53 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(time_per_interval: int, distance_per_interval: int, total_distance: int) -> Dict[str, Any]: - intervals = total_distance // distance_per_interval - total_time = intervals * time_per_interval - - question = f"A fog bank rolls in from the ocean to cover a city. It takes {time_per_interval} minutes to cover every {distance_per_interval} miles of the city. If the city is {total_distance} miles across from the oceanfront to the opposite inland edge, how many minutes will it take for the fog bank to cover the whole city?" - - answer_cot = f"The city will be covered in {total_distance} / {distance_per_interval} = {intervals} intervals of {time_per_interval} minutes.\nThus, it will take {intervals} * {time_per_interval} = {total_time} minutes for the fog to cover the whole city.\n#### {total_time}" - - return { - 'question': question, - 'answer': str(total_time), - 'answer_cot': answer_cot, - 'answer_value': total_time, - 'variables': { - 'time_per_interval': time_per_interval, - 'distance_per_interval': distance_per_interval, - 'total_distance': total_distance, - 'intervals': intervals - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - # Generate random values scaled by difficulty - distance_per_interval = int(rng.randint(2, int(100 * difficulty))) - time_per_interval = int(rng.randint(2, int(500 * difficulty))) - - # Ensure total distance is divisible by distance_per_interval - num_intervals = rng.randint(2, int(20 * difficulty)) - total_distance = distance_per_interval * num_intervals - - # Ensure total_distance is in valid range - while total_distance > 100: - num_intervals = rng.randint(2, int(20 * difficulty)) - total_distance = distance_per_interval * num_intervals - - result = generate_from_variables(time_per_interval, distance_per_interval, total_distance) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables(10, 3, 42) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_6.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_6.py deleted file mode 100644 index 24f5a1d1..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_6.py +++ /dev/null @@ -1,52 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(n_girls: int, place: str, multiplier: int) -> Dict[str, Any]: - n_boys = n_girls * multiplier - total_kids = n_girls + n_boys - - question = f"There are {n_girls} girls in the {place}. If there are {multiplier} times the number of boys in the {place}, how many kids are in the {place}?" - - answer_cot = f"There are {n_girls} girls x {multiplier} boys/girl = {n_boys} boys in the {place}.\nIn total there are {n_girls} girls + {n_boys} boys = {total_kids} kids in the {place}\n#### {total_kids}" - - return { - 'question': question, - 'answer': str(total_kids), - 'answer_cot': answer_cot, - 'answer_value': total_kids, - 'variables': { - 'n_girls': n_girls, - 'place': place, - 'multiplier': multiplier, - 'n_boys': n_boys, - 'total_kids': total_kids - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - places = ['park', 'yard', 'field', 'playground', 'garden'] - multipliers = [2, 3, 4] # twice, triple, quadruple - - place = rng.choice(places) - multiplier = rng.choice(multipliers) - - # Scale n_girls with difficulty but ensure result is valid - n_girls = int(rng.randint(5, int(50 * difficulty))) - while n_girls * (multiplier + 1) > 200: - n_girls = int(rng.randint(5, int(50 * difficulty))) - - result = generate_from_variables(n_girls, place, multiplier) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables(6, 'park', 2) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_60.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_60.py deleted file mode 100644 index 5b4531bd..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_60.py +++ /dev/null @@ -1,71 +0,0 @@ -from random import Random -from fractions import Fraction -from typing import Dict, Any - -def generate_from_variables(name: str, unit: str, total_dist: int, beach_dist: int, - sidewalk_dist: int, speed_mult: int, beach_time: int) -> Dict[str, Any]: - - beach_rate = Fraction(beach_dist, beach_time) - sidewalk_rate = beach_rate * speed_mult - sidewalk_time = int(sidewalk_dist / sidewalk_rate) - total_time = beach_time + sidewalk_time - - question = f"{name} walks {total_dist} {unit}s every day on her favorite walking trail, which includes {beach_dist} {unit}s of walking on the beach and {sidewalk_dist} {unit}s of walking on the sidewalk. On the sidewalk, {name} walks at twice the rate of speed that she does on the beach. If {beach_time} minutes of her walk is spent on the beach, how long does it take for her to complete the entire {total_dist}-{unit} walk, in minutes?" - - answer_cot = f"On the beach, {name} walks at a rate of {beach_dist} {unit}s per {beach_time} minutes, or {beach_dist}/{beach_time} = {beach_rate} {unit}s per minute.\nOn the sidewalk, she walks at {speed_mult} times the rate of speed as when she is on the sand, or {speed_mult} * {beach_rate} = {sidewalk_rate} {unit}s per minute.\nTo walk {sidewalk_dist} {unit}s on the sidewalk, it takes her {sidewalk_dist}÷{sidewalk_rate}={sidewalk_time} minutes.\nThus, in total, it takes {name} {beach_time}+{sidewalk_time}={total_time} minutes to walk her favorite route.\n#### {total_time}" - - return { - 'question': question, - 'answer': str(total_time), - 'answer_cot': answer_cot, - 'answer_value': total_time, - 'variables': { - 'name': name, - 'unit': unit, - 'total_distance': total_dist, - 'beach_distance': beach_dist, - 'sidewalk_distance': sidewalk_dist, - 'speed_multiplier': speed_mult, - 'beach_time': beach_time, - 'sidewalk_time': sidewalk_time - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['Emma', 'Sophia', 'Isabella', 'Olivia', 'Ava', 'Mia', 'Emily'] - units = ['mile', 'kilometer', 'block'] - - name = rng.choice(names) - unit = rng.choice(units) - speed_mult = 2 # Fixed as "twice" in question - - beach_time = int(rng.randint(40, int(70 * difficulty))) - beach_dist = int(rng.randint(10, int(20 * difficulty))) - sidewalk_dist = int(rng.randint(10, int(20 * difficulty))) - total_dist = beach_dist + sidewalk_dist - - # Ensure mathematical consistency - while not (beach_dist < beach_time and - speed_mult * beach_dist < beach_time and - beach_time % beach_dist == 0): - beach_time = int(rng.randint(40, int(70 * difficulty))) - beach_dist = int(rng.randint(10, int(20 * difficulty))) - sidewalk_dist = int(rng.randint(10, int(20 * difficulty))) - total_dist = beach_dist + sidewalk_dist - - result = generate_from_variables(name, unit, total_dist, beach_dist, - sidewalk_dist, speed_mult, beach_time) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Grandma", "mile", 3, 2, 1, 2, 40) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_61.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_61.py deleted file mode 100644 index 838c1928..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_61.py +++ /dev/null @@ -1,108 +0,0 @@ -from random import Random -from typing import Dict, Any -import numpy as np - -def generate_from_variables(name: str, location: str, shop: str, item1: str, item2: str, - item3: str, unit: str, cur: str, total: float, n1: int, n2: int, - n12: int, k: int, n3: int, p1: float, p2: float, p3: float, - discount: float) -> Dict[str, Any]: - - # Calculate costs - item1_cost = n1*p1 + n2*(1-discount)*p1 + k*p1 # Cost of item1 with discount applied - item2_cost = p2 # Cost of item2 - item3_cost = n3*p3 # Cost of item3 - total_spent = int(item1_cost + item2_cost + item3_cost) - money_left = total - total_spent - - question = f"{name} went to the {location} for vacation. Her parents gave her {cur}{total} to buy whatever she wanted. At the {shop}, {item1} was on sale for \"Buy {n1} {unit}s at {cur}{p1} per {unit}, get {n2} {unit}s {discount} off.\" She scooped up {n12} {unit}s. She also bought a mixed bag of {item2} for {cur}{p2} and {n3} {item3} that were {cur}{p3} each. How much money does {name} have left?" - - answer_cot = f"{item1} is {n1} {unit}s for {cur}{p1} and gets {n2} {unit}s {discount} off. So {discount} off of {n2} {unit}s is {cur}{n2*discount}*{p1} = {cur}{n2*discount*p1}. The rest of {k} {unit}s does not have discount and come at {k*p1} so total is {n1}*{p1} + {n2}*{1-discount}*{p1} + {k}*{p1} = {item1_cost}\n{n3} {item3} at {cur}{p3} each is {n3}*{p3}={cur}{n3*p3}\nWhen you add all her purchases, {cur}{item1_cost}+{cur}{p2}+{cur}{n3*p3} = {cur}{total_spent}\nShe had {cur}{total} and spent {cur}{total_spent} so she had {cur}{total}-{cur}{total_spent} = {cur}{money_left} left over\n#### {money_left}" - - return { - 'question': question, - 'answer': str(money_left), - 'answer_cot': answer_cot, - 'answer_value': money_left, - 'variables': { - 'name': name, - 'location': location, - 'shop': shop, - 'item1': item1, - 'item2': item2, - 'item3': item3, - 'unit': unit, - 'currency': cur, - 'total_money': total, - 'n1': n1, - 'n2': n2, - 'n12': n12, - 'k': k, - 'n3': n3, - 'p1': p1, - 'p2': p2, - 'p3': p3, - 'discount': discount, - 'total_spent': total_spent - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ['Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia', 'Charlotte'] - locations = ['beach', 'boardwalk', 'pier', 'coast'] - shops = ['souvenir store', 'gift shop', 'beach shop', 'seaside store'] - items1 = ['fudge', 'saltwater taffy', 'rock candy', 'cotton candy'] - items2 = ['sand dollars', 'starfish', 'sea glass', 'coral pieces'] - items3 = ['postcards', 'keychains', 'stickers', 'pins'] - units = ['pound', 'kilogram', 'kg'] - currencies = ['$', '£', '€'] - fraction_nums = [0.25, 0.33, 0.5, 0.67, 0.75] - - name = rng.choice(names_female) - location = rng.choice(locations) - shop = rng.choice(shops) - item1 = rng.choice(items1) - item2 = rng.choice(items2) - item3 = rng.choice(items3) - unit = rng.choice(units) - cur = rng.choice(currencies) - - total = int(rng.randint(1200, int(1500 * difficulty))) - n1 = int(rng.randint(15, int(18 * difficulty))) - n2 = int(rng.randint(4, int(10 * difficulty))) - k = int(rng.randint(2, int(5 * difficulty))) - n12 = n1 + n2 + k - n3 = int(rng.randint(11, int(19 * difficulty))) - p1 = int(rng.randint(20, int(24 * difficulty))) - p2 = round(rng.uniform(11.25, 12.00), 2) - p3 = round(rng.uniform(20.25, 21.25), 2) - discount = rng.choice(fraction_nums[:4]) - - # Ensure conditions are met - while not (n2 < n1 and - n12 == n1 + n2 + k and - 0 <= k < n1 and - int(n1*p1 + n2*(1-discount)*p1 + k*p1 + p2 + n3*p3) == n1*p1 + n2*(1-discount)*p1 + k*p1 + p2 + n3*p3 and - n1*p1 + n2*(1-discount)*p1 + k*p1 + p2 + n3*p3 < total): - n1 = int(rng.randint(15, int(18 * difficulty))) - n2 = int(rng.randint(4, int(10 * difficulty))) - k = int(rng.randint(2, int(5 * difficulty))) - n12 = n1 + n2 + k - p1 = int(rng.randint(20, int(24 * difficulty))) - - result = generate_from_variables(name, location, shop, item1, item2, item3, unit, cur, - total, n1, n2, n12, k, n3, p1, p2, p3, discount) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Sally', 'seashore', 'trinket shop', 'taffy', 'seashells', - 'magnets', 'pound', '$', 10, 1, 1, 2, 0, 4, 3, 1.50, 0.25, 0.5) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_62.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_62.py deleted file mode 100644 index ba0459d2..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_62.py +++ /dev/null @@ -1,65 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(item: str, num_slices: int, name1: str, name2: str, - slices_per_day: int, multiplier: int, unit: str) -> Dict[str, Any]: - - second_person_slices = slices_per_day * multiplier - total_daily_slices = slices_per_day + second_person_slices - days_lasting = num_slices // total_daily_slices - - question = f"A {item} has {num_slices} {unit}. If {name1} can eat {slices_per_day} {unit} a day while {name2} can eat {multiplier} times as much, how many days will the {item} last?" - - answer_cot = f"{name2} can eat {slices_per_day} x {multiplier} = {second_person_slices} {unit} a day.\nTogether, {name1} and {name2} can eat {slices_per_day} + {second_person_slices} = {total_daily_slices} {unit} a day.\nSo, a {item} will last for {num_slices}/{total_daily_slices} = {days_lasting} days.\n#### {days_lasting}" - - return { - 'question': question, - 'answer': str(days_lasting), - 'answer_cot': answer_cot, - 'answer_value': days_lasting, - 'variables': { - 'item': item, - 'num_slices': num_slices, - 'name1': name1, - 'name2': name2, - 'slices_per_day': slices_per_day, - 'multiplier': multiplier, - 'second_person_slices': second_person_slices, - 'total_daily_slices': total_daily_slices, - 'unit': unit - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - items = ["pizza", "cake", "pie", "lasagna"] - units = ["pieces", "portions", "servings"] - names = ["Emma", "Liam", "Olivia", "Noah", "Ava", "Elijah", "Charlotte", "James"] - - item = rng.choice(items) - unit = rng.choice(units) - name1, name2 = rng.sample(names, 2) - - slices_per_day = int(rng.randint(2, int(6 * difficulty))) - multiplier = 2 # Using 'twice' as specified in original - - # Ensure total is divisible by daily consumption - daily_total = slices_per_day + (slices_per_day * multiplier) - num_days = rng.randint(2, int(8 * difficulty)) - num_slices = daily_total * num_days - - result = generate_from_variables(item, num_slices, name1, name2, slices_per_day, - multiplier, unit) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("loaf of bread", 24, "Abby", "Josh", 2, 2, "slices") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_63.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_63.py deleted file mode 100644 index 6f98582e..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_63.py +++ /dev/null @@ -1,69 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, hours: int, days: int, rate: int, - bonus: int, month: str) -> Dict[str, Any]: - daily_pay = hours * rate - monthly_days = days * 4 - monthly_base = daily_pay * monthly_days - monthly_bonus = bonus * 4 - total_pay = monthly_base + monthly_bonus - - question = f"{name} works a {hours}-hour shift each day, {days} days a week. He earns ${rate} per hour and gets a ${bonus} bonus each week if the company performs well. How much money did {name} make in {month} if the company performed very well for the whole month?" - - answer_cot = f"In a day, {name} makes {hours} * {rate} = ${daily_pay}\n" \ - f"If he works {days} days a week, the total number of days for the whole month is {days} * 4= {monthly_days} days.\n" \ - f"Since he makes ${daily_pay} per day, the total amount for the whole month is {monthly_days} * {daily_pay}= ${monthly_base}.\n" \ - f"He also got a {bonus} * 4 = ${monthly_bonus} bonus because the company performed well in all the weeks of {month}.\n" \ - f"At the end of {month}, he earned {monthly_base} + {monthly_bonus} = ${total_pay}.\n#### {total_pay}" - - return { - 'question': question, - 'answer': str(total_pay), - 'answer_cot': answer_cot, - 'answer_value': total_pay, - 'variables': { - 'name': name, - 'hours_per_day': hours, - 'days_per_week': days, - 'hourly_rate': rate, - 'weekly_bonus': bonus, - 'month': month, - 'daily_pay': daily_pay, - 'monthly_base': monthly_base, - 'monthly_bonus': monthly_bonus - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"] - months = ["January", "February", "March", "April", "May", "June", "July", - "August", "September", "October", "November", "December"] - - name = rng.choice(names) - month = rng.choice(months) - - hours = int(rng.randint(6, int(13 * difficulty))) - days = int(rng.randint(3, int(7 * difficulty))) - rate = int(rng.randint(8, int(31 * difficulty))) - bonus = int(rng.randint(100, int(601 * difficulty))) - - # Ensure rate * hours is an integer - while (hours * rate) % 1 != 0: - rate = int(rng.randint(8, int(31 * difficulty))) - - result = generate_from_variables(name, hours, days, rate, bonus, month) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Watson", 10, 5, 10, 300, "April") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_64.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_64.py deleted file mode 100644 index f6e186c8..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_64.py +++ /dev/null @@ -1,66 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, n1: int, d1: int, n2: int, d2: int) -> Dict[str, Any]: - first_period = n1 * d1 - second_period = n2 * d2 - total_eggs = first_period + second_period - dozens = total_eggs // 12 - - question = f"If {name} eats {n1} eggs a day for {d1} days and then increases it to {n2} eggs a day for {d2} days, how many dozens of eggs will {name} need for {d1+d2} days?" - - answer_cot = f"He starts off eating {n1} eggs a day for {d1} days for a total of {n1}*{d1} = {first_period} eggs\n" \ - f"Then he increases it to {n2} eggs a day for {d2} days for a total of {n2}*{d2} = {second_period} eggs\n" \ - f"All total he will eat {first_period}+{second_period} = {total_eggs} eggs\n" \ - f"There are 12 eggs in 1 dozen and he will eat {total_eggs} eggs which is {total_eggs}/12 = {dozens} dozen eggs\n" \ - f"#### {dozens}" - - return { - 'question': question, - 'answer': str(dozens), - 'answer_cot': answer_cot, - 'answer_value': dozens, - 'variables': { - 'name': name, - 'eggs_per_day_first': n1, - 'days_first': d1, - 'eggs_per_day_second': n2, - 'days_second': d2, - 'total_eggs': total_eggs, - 'dozens': dozens - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Chester", "James", "John", "Robert", "Michael", "William", "David"] - name = rng.choice(names) - - # Generate random values scaled by difficulty - n1 = int(rng.randint(2, int(6 * difficulty))) - n2 = int(rng.randint(4, int(8 * difficulty))) - while n2 <= n1: - n2 = int(rng.randint(4, int(8 * difficulty))) - - d1 = int(rng.randint(20, int(110 * difficulty))) - d2 = int(rng.randint(20, int(110 * difficulty))) - - # Ensure results are divisible by 12 - while (n1 * d1 + n2 * d2) % 12 != 0: - d1 = int(rng.randint(20, int(110 * difficulty))) - d2 = int(rng.randint(20, int(110 * difficulty))) - - result = generate_from_variables(name, n1, d1, n2, d2) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Chester", 3, 30, 5, 30) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_65.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_65.py deleted file mode 100644 index 157858cd..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_65.py +++ /dev/null @@ -1,72 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, fish: str, day: str, w1: int, w2: int, w3: int, - n: int, unit: str, cur: str, price: float) -> Dict[str, Any]: - total = int((w1 + w2) * price + (n-2)*w3*price) - - question = f"{name} caught {n} {fish}s last {day}, the first {fish} he caught weighs {w1} {unit}s, the second {fish} he caught weighs {w2} {unit}s, and the last {fish} he caught weighs {w3} {unit}s. If a {unit} of {fish} costs {cur}{price:.2f}, how much will he earn after selling all the {fish}s to the market?" - - answer_cot = f"{name} will earn {w1} x {cur}{price:.2f} = {cur}{w1*price:.2f} from the first {fish}.\n" \ - f"He will earn {w2} x {cur}{price:.2f} = {cur}{w2*price:.2f} for the second {fish}.\n" \ - f"The rest of the {fish}s are {n}-2 = {n-2}. He will earn {w3} x {cur}{price:.2f} = {cur}{w3*price:.2f} per each of them. So he will earn {n-2} * {w3*price:.2f} = {(n-2)*w3*price:.2f}\n" \ - f"Therefore, the total amount he will earn for all the {fish}s is {cur}{w1*price:.2f} + {cur}{w2*price:.2f} + {cur}{(n-2)*w3*price:.2f}= {cur}{total}.\n#### {total}" - - return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'name': name, - 'fish': fish, - 'day': day, - 'weight1': w1, - 'weight2': w2, - 'weight3': w3, - 'num_fish': n, - 'unit': unit, - 'currency': cur, - 'price': price - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["John", "Michael", "David", "James", "Robert", "William", "Richard"] - fish = ["salmon", "cod", "trout", "steelhead"] - days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"] - units = ["kilogram", "pound", "kg"] - currencies = ["$", "€", "£"] - - name = rng.choice(names) - fish_type = rng.choice(fish) - day = rng.choice(days) - unit = rng.choice(units) - cur = rng.choice(currencies) - - w1 = int(rng.randint(40, int(80 * difficulty))) - w2 = int(rng.randint(30, int(60 * difficulty))) - w3 = int(rng.randint(20, int(40 * difficulty))) - n = int(rng.randint(3, int(8 * difficulty))) - price = round(rng.uniform(0.25, 2.5), 2) - - # Ensure result is integer - while not ((w1 + w2) * price + (n-2) * w3 * price).is_integer(): - price = round(rng.uniform(0.25, 2.5), 2) - - result = generate_from_variables(name, fish_type, day, w1, w2, w3, n, unit, cur, price) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Deandre", "tuna", "Monday", 56, 46, 26, 3, - "kilogram", "$", 0.50) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_66.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_66.py deleted file mode 100644 index 94bf1e89..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_66.py +++ /dev/null @@ -1,75 +0,0 @@ -from random import Random -from typing import Dict, Any -from fractions import Fraction - -def generate_from_variables(name: str, weekdays: list, hour1: int, hour2: int, hour3: int, - min1: int, min2: int, total_hours: int, num_wed_episodes: int) -> Dict[str, Any]: - - mon, tue, wed, thu, fri = weekdays - - question = f"{name} watches TV after he finishes his homework every night. On {mon} and {tue}, he watched a {hour1}-hour episode of his favorite show each night. On {wed}, he watched a few episodes of a {min1}-minute show. On {thu}, he finished homework early and watched a {hour2}-hour episode and a {min2}-minute show. On {fri}, he got to stay up late for the weekend, so he watched two {hour3}-hour episodes. If he watched {total_hours} hours of TV in all, how many {min1}-minute episodes did he watch on {wed}?" - - answer_cot = f"Let {wed[0]} be the number of episodes he watched on {wed}.\n" \ - f"After {mon}, he had {total_hours} - {hour1} = {total_hours-hour1} hours of TV left.\n" \ - f"After {tue}, he had {total_hours-hour1} - {hour1} = {total_hours-2*hour1} hours of TV left.\n" \ - f"After {thu}, he had {total_hours-2*hour1} - {hour2} - {Fraction(min2,60)} = {total_hours-2*hour1-hour2-Fraction(min2,60)} hours of TV left.\n" \ - f"After {fri}, he had {total_hours-2*hour1-hour2-Fraction(min2,60)} - {2*hour3} = {total_hours-2*hour1-hour2-Fraction(min2,60)-2*hour3} hours of TV left.\n" \ - f"Each {min1}-minute episode is {Fraction(min1,60)} hour.\n" \ - f"Thus, {wed[0]} = {num_wed_episodes} episodes.\n#### {num_wed_episodes}" - - return { - 'question': question, - 'answer': str(num_wed_episodes), - 'answer_cot': answer_cot, - 'answer_value': num_wed_episodes, - 'variables': { - 'name': name, - 'weekdays': weekdays, - 'hour1': hour1, - 'hour2': hour2, - 'hour3': hour3, - 'min1': min1, - 'min2': min2, - 'total_hours': total_hours, - 'num_wed_episodes': num_wed_episodes - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"] - weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"] - - name = rng.choice(names) - weekdays_sample = weekdays.copy() # Keep original order for this problem - - hour1 = int(rng.randint(3, int(7 * difficulty))) - hour2 = int(rng.randint(2, int(7 * difficulty))) - hour3 = int(rng.randint(2, int(6 * difficulty))) - - min1 = int(rng.randint(1, int(12 * difficulty))) * 5 # Ensure divisible by 5 - min2 = int(rng.randint(1, int(11 * difficulty))) * 5 # Ensure divisible by 5 - - # Calculate num_wed_episodes to ensure total_hours works out - num_wed_episodes = int(rng.randint(1, int(8 * difficulty))) - - # Calculate total hours from all components - total_hours = 2*hour1 + hour2 + min2/60 + 2*hour3 + (num_wed_episodes * min1/60) - - result = generate_from_variables(name, weekdays_sample, hour1, hour2, hour3, - min1, min2, total_hours, num_wed_episodes) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Frankie", - ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"], - 1, 1, 1, 30, 30, 7, 3) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_67.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_67.py deleted file mode 100644 index 32b35ead..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_67.py +++ /dev/null @@ -1,64 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, fruit: str, n1: int, n2: int, d1: str, d2: str, - d3: str, mult: int) -> Dict[str, Any]: - first_two_days = n1 + n2 - friday_amount = mult * n1 - total = first_two_days + friday_amount - - question = f"{name} picks {n1} {fruit}s on {d1}. Then he picks {n2} {fruit}s on {d2}. On {d3}, he picks {mult} times the number of {fruit}s he did on {d1}. How many {fruit}s does {name} have?" - - answer_cot = f"Combining {d1} and {d2}, {name} has {n1} {fruit}s + {n2} {fruit}s = {first_two_days} {fruit}s.\nOn {d3}, he picks {mult} * {n1} {fruit}s = {friday_amount} {fruit}s.\nAltogether, {name} has {first_two_days} {fruit}s + {friday_amount} {fruit}s = {total} {fruit}s.\n#### {total}" - - return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'name': name, - 'fruit': fruit, - 'day1_amount': n1, - 'day2_amount': n2, - 'day1': d1, - 'day2': d2, - 'day3': d3, - 'multiplier': mult, - 'day3_amount': friday_amount, - 'total': total - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["John", "James", "William", "Michael", "David", "Robert", "Thomas"] - fruits = ["banana", "apple", "orange", "pear", "peach", "plum"] - weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"] - multipliers = ["double", "triple", "quadruple"] - mult_values = {"double": 2, "triple": 3, "quadruple": 4} - - name = rng.choice(names) - fruit = rng.choice(fruits) - d1, d2, d3 = rng.sample(weekdays, 3) - mult_word = rng.choice(multipliers) - mult = mult_values[mult_word] - - n1 = int(rng.randint(30, int(400 * difficulty))) - n2 = int(rng.randint(50, int(400 * difficulty))) - - result = generate_from_variables(name, fruit, n1, n2, d1, d2, d3, mult) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("John", "banana", 4, 6, "Wednesday", "Thursday", - "Friday", 3) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_68.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_68.py deleted file mode 100644 index ef15447e..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_68.py +++ /dev/null @@ -1,64 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(n0: int, r: int, d: int, disease: str) -> Dict[str, Any]: - # Calculate infected people after each day - day1_new = n0 * r - day1_total = n0 + day1_new - - day2_new = day1_total * r - day2_total = day1_total + day2_new - - day3_new = day2_total * r - day3_total = day2_total + day3_new - - question = f"A {disease} infects {n0} people. Every day, each infected person infects {r} others. How many people are infected after {d} days?" - - answer_cot = f"On the first day, the original {n0} people infect {r} people each, so {n0} * {r} = {day1_new} more people are infected.\n" \ - f"There are {n0} + {day1_new} = {day1_total} infected people after the first day.\n" \ - f"On the second day, {day1_total} * {r} = {day2_new} more people are infected.\n" \ - f"There are {day1_total} + {day2_new} = {day2_total} infected people after the second day.\n" \ - f"On the third day, {day2_total} * {r} = {day3_new} more people are infected. Therefore, there are {day2_total} + {day3_new} = {day3_total} infected people after three days.\n" \ - f"#### {day3_total}" - - return { - 'question': question, - 'answer': str(day3_total), - 'answer_cot': answer_cot, - 'answer_value': day3_total, - 'variables': { - 'initial_infected': n0, - 'infection_rate': r, - 'days': d, - 'disease_type': disease - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - diseases = ['virus', 'bacteria', 'parasite', 'infection'] - - disease = rng.choice(diseases) - n0 = int(rng.randint(5, int(21 * difficulty))) - r = int(rng.randint(2, int(8 * difficulty))) - d = 3 # Fixed at 3 days per problem description - - # Check condition: n0 * (r + 1)**d < 20000 - while n0 * (r + 1)**d >= 20000: - n0 = int(rng.randint(5, int(21 * difficulty))) - r = int(rng.randint(2, int(8 * difficulty))) - - result = generate_from_variables(n0, r, d, disease) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables(10, 6, 3, 'plague') diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_69.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_69.py deleted file mode 100644 index 4e7b4283..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_69.py +++ /dev/null @@ -1,56 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, document: str, total_pages: int, fraction: str) -> Dict[str, Any]: - frac_num = eval(fraction) - pages_done = int(total_pages * frac_num) - pages_remaining = total_pages - pages_done - - question = f"{name} is required to submit a {total_pages}-page {document}. She already finished writing {fraction} of the {document}. How many pages does she have left to write?" - - answer_cot = f"{name} has already written {fraction} of the {document} which is {total_pages} pages x {fraction} = {pages_done} pages.\nSo, she still needs to write {total_pages} pages - {pages_done} pages = {pages_remaining} pages.\n#### {pages_remaining}" - - return { - 'question': question, - 'answer': str(pages_remaining), - 'answer_cot': answer_cot, - 'answer_value': pages_remaining, - 'variables': { - 'name': name, - 'document': document, - 'total_pages': total_pages, - 'fraction': fraction, - 'pages_done': pages_done, - 'pages_remaining': pages_remaining - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte", "Amelia", "Harper", "Evelyn"] - documents = ["essay", "report", "thesis", "dissertation", "assignment"] - fractions = ["1/2", "1/3", "1/4", "2/3", "3/4"] - - name = rng.choice(names_female) - document = rng.choice(documents) - fraction = rng.choice(fractions) - - # Generate total pages ensuring it's divisible by denominator - denominator = int(fraction.split('/')[1]) - max_pages = int(325 * difficulty) - total_pages = denominator * rng.randint(1, max_pages // denominator) - - result = generate_from_variables(name, document, total_pages, fraction) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Shiela", "research paper", 15, "1/3") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_7.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_7.py deleted file mode 100644 index 9add7607..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_7.py +++ /dev/null @@ -1,63 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, plants_received: int, plants_per_ledge: int, - num_ledges: int, plants_to_give: int) -> Dict[str, Any]: - - initial_plants = plants_per_ledge * num_ledges - total_plants = initial_plants + plants_received - plants_given = num_ledges * plants_to_give - remaining_plants = total_plants - plants_given - - question = f"{name} is an avid gardener. Yesterday, she received {plants_received} new potted plants from her favorite plant nursery. She already has {plants_per_ledge} potted plants on each of the {num_ledges} window ledges of her large country home. Feeling generous, she has decided that she will give {plants_to_give} potted plant from each ledge to friends and family tomorrow. How many potted plants will {name} remain with?" - - answer_cot = f"Yesterday, before receiving the plants, {name} had {num_ledges}*{plants_per_ledge} = {initial_plants} potted plants\nAfter receiving an additional {plants_received} plants, she therefore had a total of {initial_plants} + {plants_received} = {total_plants} potted plants\nTomorrow, {name}'s plant giveaway will be {num_ledges}*{plants_to_give} = {plants_given} potted plants.\nShe will therefore remain with {total_plants} - {plants_given} = {remaining_plants} potted plants.\n#### {remaining_plants}" - - return { - 'question': question, - 'answer': str(remaining_plants), - 'answer_cot': answer_cot, - 'answer_value': remaining_plants, - 'variables': { - 'name': name, - 'plants_received': plants_received, - 'plants_per_ledge': plants_per_ledge, - 'num_ledges': num_ledges, - 'plants_to_give': plants_to_give, - 'initial_plants': initial_plants, - 'total_plants': total_plants, - 'plants_given': plants_given, - 'remaining_plants': remaining_plants - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Mary", "Emma", "Sophia", "Isabella", "Olivia", "Ava", "Mia"] - - name = rng.choice(names) - plants_received = int(rng.randint(20, int(50 * difficulty))) - plants_per_ledge = int(rng.randint(7, int(13 * difficulty))) - num_ledges = int(rng.randint(50, int(70 * difficulty))) - plants_to_give = int(rng.randint(3, int(8 * difficulty))) - - # Ensure condition: w * r + x - w*n > 0 - while (num_ledges * plants_per_ledge + plants_received - num_ledges * plants_to_give) <= 0: - plants_per_ledge = int(rng.randint(7, int(13 * difficulty))) - plants_to_give = int(rng.randint(3, int(8 * difficulty))) - - result = generate_from_variables(name, plants_received, plants_per_ledge, - num_ledges, plants_to_give) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Mary", 18, 2, 40, 1) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_70.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_70.py deleted file mode 100644 index 64bb9715..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_70.py +++ /dev/null @@ -1,76 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, objects: str, n: int, obstacle: str, - frac: float, k: int, fake_num: int, fake_object: str) -> Dict[str, Any]: - - dropped = int(n * frac) - remaining = n - dropped - found = k - after_finding = remaining + found - final = after_finding - fake_num - - question = f"{name} has a bag of {objects} with {n} inside. He tripped over {obstacle} while carrying it and dropped {dropped} of them. He scrambled to search for them but only came up with {k}. When he went back home, he inspected the {objects} further. {fake_num} of them he picked up wasn't a {objects}, but actually {fake_object} so he got rid of it. How many {objects} did {name} end up with?" - - answer_cot = f"{name} dropped his {objects} and was left with {n}*{1-frac}={remaining} {objects}.\n" \ - f"He searched and found some of his lost {objects}, getting him back to {remaining}+{k}={after_finding} {objects}.\n" \ - f"He went home and removed {fake_object}, leaving him with {after_finding}-{fake_num}={final} {objects}.\n" \ - f"#### {final}" - - return { - 'question': question, - 'answer': str(final), - 'answer_cot': answer_cot, - 'answer_value': final, - 'variables': { - 'name': name, - 'objects': objects, - 'initial_count': n, - 'obstacle': obstacle, - 'fraction_dropped': frac, - 'found_count': k, - 'fake_count': fake_num, - 'fake_object': fake_object, - 'remaining': remaining, - 'after_finding': after_finding, - 'final_count': final - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"] - objects = ["marbles", "coins", "buttons", "beads", "pebbles"] - obstacles = ["rock", "stick", "toy", "root"] - fake_objects = ["buttons", "coins", "pebbles", "beads"] - fractions = [0.5, 0.25, 0.75] - - name = rng.choice(names) - obj = rng.choice(objects) - obstacle = rng.choice(obstacles) - fake_object = rng.choice([x for x in fake_objects if x != obj]) - frac = rng.choice(fractions) - - n = int(rng.randrange(10, int(101 * difficulty), 2)) - fake_num = int(rng.randint(2, min(10, int(n * frac)))) - k = int(rng.randint(fake_num + 1, min(int(n * frac), int(20 * difficulty)))) - - # Ensure conditions are met - while not (isinstance(n * frac, int) and k < n * frac and k > fake_num): - n = int(rng.randrange(10, int(101 * difficulty), 2)) - k = int(rng.randint(fake_num + 1, min(int(n * frac), int(20 * difficulty)))) - - result = generate_from_variables(name, obj, n, obstacle, frac, k, fake_num, fake_object) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Brendan", "marbles", 10, "pebble", 0.5, 3, 1, "bead") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_71.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_71.py deleted file mode 100644 index c2760025..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_71.py +++ /dev/null @@ -1,80 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, shop: str, item: str, item1: str, item2: str, - item3: str, n1: int, n2: int, n3: int, p1: int, p2: int, - p3: int) -> Dict[str, Any]: - cost1 = n1 * p1 - cost2 = n2 * p2 - cost3 = n3 * p3 - total_cost = cost1 + cost2 + cost3 - - question = f"{name} went to the {shop} and bought various types of {item}. She bought {n1} dozen {item1} which cost ${p1} per dozen, {n2} dozen {item2} which cost ${p2} per dozen, and {n3} dozen {item3} for ${p3} per dozen. How much was the total cost?" - - answer_cot = f"The total charge for the {item1} was {n1} x ${p1} = ${cost1}.\nThe total charge for the {item2} was {n2} x ${p2} = ${cost2}.\nThe total charge for the {item3} was {n3} x ${p3} = ${p3*n3}.\nTherefore the total amount {name} paid for the {item} was ${cost1} + ${cost2} + ${cost3} = ${total_cost}.\n#### {total_cost}" - - return { - 'question': question, - 'answer': str(total_cost), - 'answer_cot': answer_cot, - 'answer_value': total_cost, - 'variables': { - 'name': name, - 'shop': shop, - 'item': item, - 'item1': item1, - 'item2': item2, - 'item3': item3, - 'n1': n1, - 'n2': n2, - 'n3': n3, - 'p1': p1, - 'p2': p2, - 'p3': p3, - 'cost1': cost1, - 'cost2': cost2, - 'cost3': cost3 - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Charlotte", "Mia", "Amelia"] - shops = ["bakery", "patisserie", "confectionery", "cafe"] - items = ["pastries", "baked goods", "desserts", "treats"] - item1_options = ["donuts", "croissants", "eclairs", "danishes"] - item2_options = ["mini cupcakes", "macarons", "cookies", "tarts"] - item3_options = ["mini cheesecakes", "brownies", "muffins", "scones"] - - name = rng.choice(names_female) - shop = rng.choice(shops) - item = rng.choice(items) - item1 = rng.choice(item1_options) - item2 = rng.choice(item2_options) - item3 = rng.choice(item3_options) - - n1 = int(rng.randint(1, int(10 * difficulty))) - n2 = int(rng.randint(4, int(10 * difficulty))) - n3 = int(rng.randint(2, int(10 * difficulty))) - - p1 = int(rng.randint(11, int(21 * difficulty))) - p2 = int(rng.randint(73, int(90 * difficulty))) - p3 = int(rng.randint(112, int(120 * difficulty))) - - result = generate_from_variables(name, shop, item, item1, item2, item3, - n1, n2, n3, p1, p2, p3) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Toula", "bakery", "pastries", "donuts", - "mini cupcakes", "mini cheesecakes", - 3, 2, 6, 68, 80, 55) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_72.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_72.py deleted file mode 100644 index c02c8624..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_72.py +++ /dev/null @@ -1,63 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(structure: str, n1: int, color1: str, color2: str, - color3: str, obj: str, mult: int, total: int) -> Dict[str, Any]: - n2 = n1 * mult - n3 = total - n1 - n2 - - question = f"A {structure} is made out of {n1} {color1} {obj}s, {mult} times as many {color2} {obj}s, and an unknown number of {color3} {obj}s. If there are {total} {obj}s in the {structure} in total, how many {color3} {obj}s are there?" - - answer_cot = f"There are {n1}*{mult} = {n2} {color2} {obj}s in the {structure}.\nThere are {total}-{n1}-{n2} = {n3} {color3} {obj}s in the {structure}.\n#### {n3}" - - return { - 'question': question, - 'answer': str(n3), - 'answer_cot': answer_cot, - 'answer_value': n3, - 'variables': { - 'structure': structure, - 'n1': n1, - 'n2': n2, - 'n3': n3, - 'color1': color1, - 'color2': color2, - 'color3': color3, - 'obj': obj, - 'mult': mult, - 'total': total - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - structures = ["building", "pyramid", "stack", "tower"] - objects = ["brick", "cube", "tile", "block"] - colors = ["green", "purple", "orange", "pink", "white", "black"] - - structure = rng.choice(structures) - obj = rng.choice(objects) - color1, color2, color3 = rng.sample(colors, 3) - - n1 = int(rng.randint(2, int(10 * difficulty))) - mult = 2 # "twice" as specified in original - n2 = n1 * mult - - # Ensure total is greater than n1 + n2 - min_total = n1 + n2 + 1 - total = int(rng.randint(min_total, min_total + int(20 * difficulty))) - - result = generate_from_variables(structure, n1, color1, color2, color3, obj, mult, total) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("tower", 4, "blue", "yellow", "red", "block", 2, 32) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_73.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_73.py deleted file mode 100644 index d3c3e74f..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_73.py +++ /dev/null @@ -1,79 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, fruit: str, food: str, d1: str, d2: str, - n1: int, n2: int, m1: int, m2: int, cn: int, cm: int, - currency: str) -> Dict[str, Any]: - - gingerbread_sunday = n1 + n2 - total_gingerbread = n1 + gingerbread_sunday - gingerbread_revenue = total_gingerbread * cn - - apple_pie_saturday = m2 - m1 - total_apple_pie = m2 + apple_pie_saturday - apple_pie_revenue = total_apple_pie * cm - - total_revenue = gingerbread_revenue + apple_pie_revenue - - question = f"{name} is selling {food} and {fruit} pie for a fundraiser. On {d1}, he sold {n1} boxes of {food} and {m1} fewer boxes of {fruit} pie, than on {d2}. On {d2}, he sold {n2} more boxes of {food} than on {d1} and {m2} boxes of {fruit} pie. If the {food} cost {currency}{cn} and the {fruit} pie cost {currency}{cm}, how much did {name} earn for two days?" - - answer_cot = f"He sold {n1} + {n2} = {gingerbread_sunday} boxes of {food} on {d2}.\nThe total number of boxes of {food}s that {name} sold is {n1} + {gingerbread_sunday} = {total_gingerbread}.\n{name} earned {total_gingerbread} x {currency}{cn} = {currency}{gingerbread_revenue} for selling {food}s.\nHe sold {m2} - {m1} = {apple_pie_saturday} boxes of {fruit} pie on {d1}.\nThe total number of boxes of {fruit} pie that {name} sold is {m2} + {apple_pie_saturday} = {total_apple_pie}.\nHe earned {total_apple_pie} x {currency}{cm} = {currency}{apple_pie_revenue} for selling {fruit} pie.\nSo, {name} earned {currency}{gingerbread_revenue} + {currency}{apple_pie_revenue} = {currency}{total_revenue} for two days.\n#### {total_revenue}" - - return { - 'question': question, - 'answer': str(total_revenue), - 'answer_cot': answer_cot, - 'answer_value': total_revenue, - 'variables': { - 'name': name, - 'fruit': fruit, - 'food': food, - 'day1': d1, - 'day2': d2, - 'gingerbread_day1': n1, - 'gingerbread_increase': n2, - 'apple_pie_difference': m1, - 'apple_pie_day2': m2, - 'gingerbread_price': cn, - 'apple_pie_price': cm, - 'currency': currency, - 'total_revenue': total_revenue - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['John', 'Michael', 'David', 'James', 'William', 'Robert'] - fruits = ['apple', 'cherry', 'blueberry', 'peach'] - foods = ['cookie', 'brownie', 'muffin', 'cupcake'] - weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] - currencies = ['$', '£', '€'] - - name = rng.choice(names) - fruit = rng.choice(fruits) - food = rng.choice(foods) - d1, d2 = rng.sample(weekdays, 2) - currency = rng.choice(currencies) - - n1 = int(rng.randint(21, int(30 * difficulty))) - n2 = int(rng.randint(11, int(15 * difficulty))) - m2 = int(rng.randint(21, int(30 * difficulty))) - m1 = int(rng.randint(11, int(min(20, m2) * difficulty))) - cn = int(rng.randint(7, int(13 * difficulty))) - cm = int(rng.randint(20, int(33 * difficulty))) - - result = generate_from_variables(name, fruit, food, d1, d2, n1, n2, m1, m2, cn, cm, currency) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Sunny', 'apple', 'gingerbread', 'Saturday', 'Sunday', - 10, 5, 4, 15, 6, 15, '$') diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_74.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_74.py deleted file mode 100644 index be3ccdce..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_74.py +++ /dev/null @@ -1,66 +0,0 @@ -from random import Random -from typing import Dict, Any -import math - -def generate_from_variables(name: str, big_fish: str, length: int, num_remoras: int, - remora_length: int) -> Dict[str, Any]: - total_remora_length_inches = num_remoras * remora_length - total_remora_length_feet = total_remora_length_inches / 12 - percentage = int((total_remora_length_feet / length) * 100) - - question = f"{name} saw a {length}-foot {big_fish} with {num_remoras} {remora_length}-inch remoras attached to it. What percentage of the {big_fish}'s body length is the combined length of the remoras?" - - answer_cot = f"First, find the combined length of the remoras in inches: {remora_length} inches/remora * {num_remoras} remoras = {total_remora_length_inches} inches\nThen divide that number by 12 to convert it to feet: {total_remora_length_inches} inches / 12 inches/foot = {total_remora_length_feet} foot\nThen divide the combined remora length in feet by the {big_fish}'s length and multiply by 100% to express the answer as a percentage: {total_remora_length_feet} foot / {length} feet * 100% = {percentage}%\n#### {percentage}" - - return { - 'question': question, - 'answer': str(percentage), - 'answer_cot': answer_cot, - 'answer_value': percentage, - 'variables': { - 'name': name, - 'big_fish': big_fish, - 'length_feet': length, - 'num_remoras': num_remoras, - 'remora_length_inches': remora_length, - 'total_remora_length_inches': total_remora_length_inches, - 'total_remora_length_feet': total_remora_length_feet, - 'percentage': percentage - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Benny", "Tommy", "Jimmy", "Billy", "Johnny", "Bobby"] - big_fish = ["dolphin", "whale", "shark"] - - name = rng.choice(names) - fish = rng.choice(big_fish) - - length = int(rng.randint(10, int(500 * difficulty)) // 10 * 10) - num_remoras = int(rng.randint(2, int(10 * difficulty))) - remora_length = int(rng.randint(2, int(100 * difficulty))) - - # Ensure conditions are met - while (num_remoras * remora_length >= length * 12 or - (num_remoras * remora_length) % 12 != 0 or - (length * 12) % (num_remoras * remora_length) != 0 or - 100 % int((num_remoras * remora_length)/(length * 12) * 100) != 0): - length = int(rng.randint(10, int(500 * difficulty)) // 10 * 10) - num_remoras = int(rng.randint(2, int(10 * difficulty))) - remora_length = int(rng.randint(2, int(100 * difficulty))) - - result = generate_from_variables(name, fish, length, num_remoras, remora_length) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Benny", "shark", 10, 2, 6) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_75.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_75.py deleted file mode 100644 index e9c65925..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_75.py +++ /dev/null @@ -1,64 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name1: str, name2: str, color1: str, color2: str, - n1: int, n2: int, frac1: float, mult1: float) -> Dict[str, Any]: - - n1_result = int(n1 * frac1) - n2_result = int(n2 * mult1) - total = n1_result + n2_result - - question = f"{name1} has {n1} tubes of {color1} paint and {n2} tubes of {color2} paint. {name2} has half as many tubes of {color1} paint as {name1}, and three times as many tubes of {color2} paint as {name1}. How many tubes of paint does {name2} have?" - - answer_cot = f"{name2} has {n1}*{frac1}={n1_result} tubes of {color1} paint\n" \ - f"{name2} has {n2}*{mult1}={n2_result} tubes of {color2} paint\n" \ - f"{name2} has a total of {n1_result}+{n2_result}={total} tubes of paint\n" \ - f"#### {total}" - - return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'name1': name1, - 'name2': name2, - 'color1': color1, - 'color2': color2, - 'n1': n1, - 'n2': n2, - 'frac1': frac1, - 'mult1': mult1, - 'n1_result': n1_result, - 'n2_result': n2_result - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Ben", "James", "John", "Michael", "William", "David", "Richard", "Joseph"] - colors = ["blue", "red", "green", "yellow", "purple", "orange"] - - name1, name2 = rng.sample(names, 2) - color1, color2 = rng.sample(colors, 2) - - # Generate numbers that ensure integer results - n1 = int(rng.randint(2, int(20 * difficulty))) - n2 = int(rng.randint(2, int(20 * difficulty))) - frac1 = 0.5 # half - mult1 = 3.0 # three times - - result = generate_from_variables(name1, name2, color1, color2, n1, n2, frac1, mult1) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Ben", "Jasper", "blue", "yellow", 4, 3, 0.5, 3.0) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_76.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_76.py deleted file mode 100644 index 7cf17164..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_76.py +++ /dev/null @@ -1,67 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(n: int, p1: int, p2: int, company: str, frac: float) -> Dict[str, Any]: - interviews = int(n * (p1/100)) - offers = int(interviews * (p2/100)) - accepts = int(offers * frac) - - question = f"{n} people apply for a job at {company}. Of the people that apply, only {p1}% receive interviews. Of those who receive interviews, {p2}% receive a job offer. Of those who receive a job offer, {frac:.2%} of the people accept the position. How many people accept the position?" - - answer_cot = f"The number of people that receive interviews is {n} * {p1/100} = {interviews} people\n" \ - f"The number of people that receive a job offer is {interviews} * {p2/100} = {offers} people\n" \ - f"The number of people that accept the position is {offers} * {frac} = {accepts} people\n" \ - f"#### {accepts}" - - return { - 'question': question, - 'answer': str(accepts), - 'answer_cot': answer_cot, - 'answer_value': accepts, - 'variables': { - 'total_applicants': n, - 'interview_percent': p1, - 'offer_percent': p2, - 'company': company, - 'acceptance_fraction': frac, - 'num_interviews': interviews, - 'num_offers': offers, - 'num_accepts': accepts - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - companies = ["Microsoft", "Apple", "Amazon", "Facebook", "Netflix", "Tesla", "Google"] - fractions = {"a third": 1/3, "half": 1/2, "a quarter": 1/4, "two thirds": 2/3} - - company = rng.choice(companies) - frac = fractions[rng.choice(list(fractions.keys()))] - - # Generate values ensuring all divisions result in integers - n = int(rng.randint(201, int(1001 * difficulty))) - p1 = int(rng.randint(10, int(51 * difficulty))) - p2 = int(rng.randint(10, int(51 * difficulty))) - - # Ensure integer results - while not (n * (p1/100)).is_integer() or \ - not (n * (p1/100) * (p2/100)).is_integer() or \ - not (n * (p1/100) * (p2/100) * frac).is_integer(): - n = int(rng.randint(201, int(1001 * difficulty))) - p1 = int(rng.randint(10, int(51 * difficulty))) - p2 = int(rng.randint(10, int(51 * difficulty))) - - result = generate_from_variables(n, p1, p2, company, frac) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables(100, 30, 20, "Google", 1/3) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_77.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_77.py deleted file mode 100644 index fd8e8706..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_77.py +++ /dev/null @@ -1,75 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(event: str, m: int, w: int, t: str, frac: float, m_left: int, - group1: str, group2: str) -> Dict[str, Any]: - total = m + w - left_count = int(total * frac) - stayed = total - left_count - w_left = stayed - m_left - - question = f"At the beginning of the {event}, there were {m} {group1} and {w} {group2}. After {t}, {frac} of the total number of people left. How many {group2} are left if {m_left} {group1} stayed at the {event}?" - - answer_cot = f"There were a total of {m} {group1} + {w} {group2} = {total} people who attended the {event}.\n" \ - f"After {t}, {total} people * {frac} = {left_count} people left the {event}.\n" \ - f"This means {total} people - {left_count} people = {stayed} people stayed.\n" \ - f"Out of the {stayed} who stayed, {stayed} people - {m_left} {group1} = {w_left} were {group2}.\n" \ - f"#### {w_left}" - - return { - 'question': question, - 'answer': str(w_left), - 'answer_cot': answer_cot, - 'answer_value': w_left, - 'variables': { - 'event': event, - 'men': m, - 'women': w, - 'time': t, - 'fraction_left': frac, - 'men_stayed': m_left, - 'women_stayed': w_left, - 'group1': group1, - 'group2': group2 - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - events = ['party', 'meeting', 'conference', 'gathering', 'celebration'] - groups = ["teachers", "doctors", "engineers", "nurses", "artists", "lawyers"] - times = ['an hour', 'two hours', 'half an hour', '45 minutes'] - fractions = [0.25, 0.5, 0.75, 0.33, 0.67] - - event = rng.choice(events) - group1, group2 = rng.sample(groups, 2) - t = rng.choice(times) - frac = rng.choice(fractions) - - m = int(rng.randint(20, int(75 * difficulty))) - w = int(rng.randint(10, int(80 * difficulty))) - total = m + w - - # Ensure fraction calculations result in integers - while not (total * frac).is_integer(): - m = int(rng.randint(20, int(75 * difficulty))) - w = int(rng.randint(10, int(80 * difficulty))) - total = m + w - - stayed = total - int(total * frac) - m_left = int(rng.randint(15, min(stayed-1, int(35 * difficulty)))) - - result = generate_from_variables(event, m, w, t, frac, m_left, group1, group2) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('party', 25, 15, 'an hour', 0.25, 22, 'men', 'women') diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_78.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_78.py deleted file mode 100644 index 053c9514..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_78.py +++ /dev/null @@ -1,55 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name1: str, name2: str, age_diff: int, age1: int) -> Dict[str, Any]: - age2 = age1 + age_diff - avg_age = (age1 + age2) // 2 - - question = f"{name1} and {name2} are currently {age_diff} years apart in age. If {name1}, who is younger than {name2}, is {age1} years old, what's the average of their ages?" - - answer_cot = f"If {name1} is {age1} years old, {name2} is {age1}+{age_diff} = {age2} years old.\n" \ - f"The sum of their ages is {age2}+{age1} = {age1+age2} years\n" \ - f"The average age of the two is {age1+age2}/2 = {avg_age} years\n" \ - f"#### {avg_age}" - - return { - 'question': question, - 'answer': str(avg_age), - 'answer_cot': answer_cot, - 'answer_value': avg_age, - 'variables': { - 'name1': name1, - 'name2': name2, - 'age_diff': age_diff, - 'age1': age1, - 'age2': age2, - 'avg_age': avg_age - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte", "Amelia"] - name1, name2 = rng.sample(names, 2) - - age_diff = int(rng.randint(5, int(30 * difficulty))) - age1 = int(rng.randint(15, int(75 * difficulty))) - - # Ensure average is an integer - while (2 * age1 + age_diff) % 2 != 0: - age1 = int(rng.randint(15, int(75 * difficulty))) - - result = generate_from_variables(name1, name2, age_diff, age1) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Mia", "Emma", 16, 40) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_79.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_79.py deleted file mode 100644 index e1a41f3b..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_79.py +++ /dev/null @@ -1,83 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, vehicle: str, start_time: int, end_time: int, - free_hours: int, currency: str, first_hour_cost: int, - multiplier: int) -> Dict[str, Any]: - total_hours = end_time - start_time - paid_hours = total_hours - free_hours - other_hours = paid_hours - 1 - hourly_rate = first_hour_cost * multiplier - other_hours_cost = other_hours * hourly_rate - total_cost = first_hour_cost + other_hours_cost - - question = f"{name} hires a {vehicle} from {start_time} PM to {end_time} PM. He gets {free_hours} hour free. The first paid hour is {currency}{first_hour_cost} and each hour after that is {multiplier} times the cost. How much did he pay?" - - answer_cot = f"He got it for {end_time}-{start_time}={total_hours} hours\n" \ - f"He pays for {total_hours}-{free_hours}={paid_hours} hours\n" \ - f"The first hour cost 1*{first_hour_cost}={currency}{first_hour_cost}\n" \ - f"The other {paid_hours}-1={other_hours} hours are more expensive\n" \ - f"They cost {first_hour_cost}*{multiplier}={currency}{hourly_rate} per hour\n" \ - f"So those {other_hours} hours cost {other_hours}*{hourly_rate}={currency}{other_hours_cost}\n" \ - f"So he pays {other_hours_cost}+{first_hour_cost}={currency}{total_cost}\n" \ - f"#### {total_cost}" - - return { - 'question': question, - 'answer': str(total_cost), - 'answer_cot': answer_cot, - 'answer_value': total_cost, - 'variables': { - 'name': name, - 'vehicle': vehicle, - 'start_time': start_time, - 'end_time': end_time, - 'free_hours': free_hours, - 'currency': currency, - 'first_hour_cost': first_hour_cost, - 'multiplier': multiplier, - 'total_hours': total_hours, - 'paid_hours': paid_hours, - 'total_cost': total_cost - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["James", "John", "Robert", "Michael", "William", "David", "Richard"] - vehicles = ["limousine", "party bus", "boat", "luxury car"] - currencies = ["$", "€", "£"] - - name = rng.choice(names) - vehicle = rng.choice(vehicles) - currency = rng.choice(currencies) - - start_time = int(rng.randint(1, int(8 * difficulty))) - end_time = int(rng.randint(start_time + 2, int(12 * difficulty))) - free_hours = int(rng.randint(1, min(3, end_time - start_time - 1))) - first_hour_cost = int(rng.randint(10, int(51 * difficulty))) - multiplier = 2 - - # Verify conditions - while not ((end_time - start_time > free_hours + 1) and - ((end_time - start_time - free_hours - 1) * first_hour_cost * multiplier).is_integer()): - start_time = int(rng.randint(1, int(8 * difficulty))) - end_time = int(rng.randint(start_time + 2, int(12 * difficulty))) - free_hours = int(rng.randint(1, min(3, end_time - start_time - 1))) - first_hour_cost = int(rng.randint(10, int(51 * difficulty))) - - result = generate_from_variables(name, vehicle, start_time, end_time, free_hours, - currency, first_hour_cost, multiplier) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("James", "horse-drawn carriage", 5, 9, 1, "$", 15, 2) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_8.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_8.py deleted file mode 100644 index d5924dfc..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_8.py +++ /dev/null @@ -1,57 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, drink: str, sugar_ratio: int, water_ratio: int, - total_items: int) -> Dict[str, Any]: - total_ratio = sugar_ratio + water_ratio - sugar_amount = (sugar_ratio * total_items) // total_ratio - - question = f"{name} makes {drink} using teaspoons of sugar and cups of water in the ratio of {sugar_ratio}:{water_ratio}. If she used a total of {total_items} teaspoons of sugar and cups of water, calculate the number of teaspoonfuls of sugar she used." - - answer_cot = f"The total ratio representing the ingredients she used to make the {drink} is {sugar_ratio}+{water_ratio} = {total_ratio}\nSince the fraction representing the number of teaspoons she used is {sugar_ratio}/{total_ratio}, she used {sugar_ratio}/{total_ratio}*{total_items} = {sugar_amount}\n#### {sugar_amount}" - - return { - 'question': question, - 'answer': str(sugar_amount), - 'answer_cot': answer_cot, - 'answer_value': sugar_amount, - 'variables': { - 'name': name, - 'drink': drink, - 'sugar_ratio': sugar_ratio, - 'water_ratio': water_ratio, - 'total_items': total_items, - 'sugar_amount': sugar_amount - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ['Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia', 'Charlotte'] - drinks = ['coffee', 'tea'] - - name = rng.choice(names_female) - drink = rng.choice(drinks) - - sugar_ratio = int(rng.randint(25, int(201 * difficulty))) - water_ratio = int(rng.randint(5, int(101 * difficulty))) - - # Ensure total is divisible by ratio sum - total_ratio = sugar_ratio + water_ratio - num_multiples = rng.randint(1, int(10 * difficulty)) - total_items = total_ratio * num_multiples - - result = generate_from_variables(name, drink, sugar_ratio, water_ratio, total_items) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Katy", "coffee", 7, 13, 120) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_80.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_80.py deleted file mode 100644 index a541a241..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_80.py +++ /dev/null @@ -1,66 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, color1: str, color2: str, n1: int, n2: int, - n3: int, n4: int) -> Dict[str, Any]: - blue_spools = n1 + n2 - total_spools = n1 + n2 + n3 + n4 - percent_blue = int(100 * blue_spools / total_spools) - - question = f"{name} has {n1} light {color1} spools of thread, {n2} dark {color1} spools of thread, {n3} light {color2} spools of thread, and {n4} dark {color2} spools of thread. What percent of her spools are {color1}?" - - answer_cot = f"First find the number of {color1} spools: {n1} spools + {n2} spools = {blue_spools} spools\nThen find the total number of spools: {n3} spools + {n4} spools + {blue_spools} spools = {total_spools} spools\nThen divide the number of {color1} spools by the total number of spools and multiply by 100% to express the answer as a percentage: {blue_spools} spools / {total_spools} spools * 100% = {percent_blue}%\n#### {percent_blue}" - - return { - 'question': question, - 'answer': str(percent_blue), - 'answer_cot': answer_cot, - 'answer_value': percent_blue, - 'variables': { - 'name': name, - 'color1': color1, - 'color2': color2, - 'light_color1_spools': n1, - 'dark_color1_spools': n2, - 'light_color2_spools': n3, - 'dark_color2_spools': n4, - 'total_color1_spools': blue_spools, - 'total_spools': total_spools, - 'percent_color1': percent_blue - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Candy", "Sarah", "Emma", "Olivia", "Isabella", "Sophia", "Mia", "Charlotte"] - colors = ["blue", "red", "green", "yellow", "purple", "orange"] - - name = rng.choice(names) - color1, color2 = rng.sample(colors, 2) - - # Generate numbers ensuring integer percentage result - n1 = int(rng.randint(15, int(45 * difficulty))) - n2 = int(rng.randint(45, int(100 * difficulty))) - n3 = int(rng.randint(20, int(80 * difficulty))) - n4 = int(rng.randint(50, int(100 * difficulty))) - - # Ensure percentage is integer - total = n1 + n2 + n3 + n4 - while ((n1 + n2) * 100) % total != 0: - n4 += 1 - total = n1 + n2 + n3 + n4 - - result = generate_from_variables(name, color1, color2, n1, n2, n3, n4) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Candy", "blue", "green", 15, 45, 40, 50) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_81.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_81.py deleted file mode 100644 index 70b74c9e..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_81.py +++ /dev/null @@ -1,56 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(occupation: str, weeks_per_month: int, days_per_week: int, - pay_per_day: int, currency: str) -> Dict[str, Any]: - days_per_month = days_per_week * weeks_per_month - monthly_pay = days_per_month * pay_per_day - yearly_pay = monthly_pay * 12 - - question = f"A {occupation} works for {weeks_per_month} weeks every month and for {days_per_week} days every week. If he gets paid {currency}{pay_per_day} every day, how much does he earn if he works for a year?" - - answer_cot = f"The {occupation} works for {days_per_week} days every week and works for {weeks_per_month} weeks every month so he works for {days_per_week} days/week * {weeks_per_month} weeks/month = {days_per_month} days/month\nIf he earns {currency}{pay_per_day} every day he then earns {currency}{pay_per_day}/day * {days_per_month} days/month = {currency}{monthly_pay}/month\nA year is equal to 12 months so every year he earns {currency}{monthly_pay}/month * 12 months/year = {currency}{yearly_pay}\n#### {yearly_pay}" - - return { - 'question': question, - 'answer': str(yearly_pay), - 'answer_cot': answer_cot, - 'answer_value': yearly_pay, - 'variables': { - 'occupation': occupation, - 'weeks_per_month': weeks_per_month, - 'days_per_week': days_per_week, - 'pay_per_day': pay_per_day, - 'currency': currency, - 'days_per_month': days_per_month, - 'monthly_pay': monthly_pay - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - occupations = ["plumber", "electrician", "painter", "carpenter", "landscaper"] - currencies = ["$", "£", "€"] - - occupation = rng.choice(occupations) - currency = rng.choice(currencies) - - weeks_per_month = int(rng.randint(2, int(5 * difficulty))) - days_per_week = int(rng.randint(4, int(7 * difficulty))) - pay_per_day = int(rng.randint(40, int(200 * difficulty)) // 5 * 5) - - result = generate_from_variables(occupation, weeks_per_month, days_per_week, - pay_per_day, currency) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("builder", 4, 6, 50, "$") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_82.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_82.py deleted file mode 100644 index 795c872d..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_82.py +++ /dev/null @@ -1,63 +0,0 @@ -from random import Random -from typing import Dict, Any -import math - -def generate_from_variables(name: str, num_emails: int, no_response_percent: int, - workdays: int) -> Dict[str, Any]: - no_response = num_emails * no_response_percent // 100 - responds_to = num_emails - no_response - total_responses = responds_to * workdays - - question = f"{name} gets {num_emails} emails a day. {no_response_percent}% of those emails don't require any response. {name} responds to the rest of them. How many emails does {name} respond to in a {workdays} day work week?" - - answer_cot = f"{name} receives {no_response}={no_response} emails that don't require a response\n" \ - f"So {name} responds to {num_emails}-{no_response}={responds_to} emails per day\n" \ - f"In a {workdays} day work week, {name} responds to {responds_to}*{workdays}={total_responses} emails\n" \ - f"#### {total_responses}" - - return { - 'question': question, - 'answer': str(total_responses), - 'answer_cot': answer_cot, - 'answer_value': total_responses, - 'variables': { - 'name': name, - 'num_emails': num_emails, - 'no_response_percent': no_response_percent, - 'workdays': workdays, - 'no_response': no_response, - 'responds_to': responds_to, - 'total_responses': total_responses - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"] - name = rng.choice(names) - - # Generate random values scaled by difficulty - num_emails = int(rng.randint(50, int(200 * difficulty))) - no_response_percent = int(rng.randint(5, int(40 * difficulty))) - workdays = int(rng.randint(3, int(7 * difficulty))) - - # Ensure conditions are met - while not (num_emails * no_response_percent % 100 == 0 and - num_emails * (100 - no_response_percent) % 100 == 0): - num_emails = int(rng.randint(50, int(200 * difficulty))) - no_response_percent = int(rng.randint(5, int(40 * difficulty))) - - result = generate_from_variables(name, num_emails, no_response_percent, workdays) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("James", 80, 20, 5) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_83.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_83.py deleted file mode 100644 index e4780812..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_83.py +++ /dev/null @@ -1,58 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name1: str, name2: str, total: int, diff: int, unit: str) -> Dict[str, Any]: - amount1 = (total - diff) // 2 # Sam's amount - amount2 = amount1 + diff # Harry's amount - - question = f"If {name1} and {name2} have {total} {unit} of fence between them, and they agree to split it with {name2} getting {diff} {unit} more than {name1}, how much is left over for {name1}?" - - answer_cot = f"Let x be the amount of fence {name1} gets and y be the amount {name2} gets. We know that y = x + {diff}, and y + x = {total}.\nSubstituting the first equation into the second equation, we get 2x+{diff}={total}\nSubtracting the {diff} from both sides, we get 2x={total-diff}\nWe divide each side by two, leaving x={amount1}. This means {name1} has {amount1} {unit} of fence left over.\n#### {amount1}" - - return { - 'question': question, - 'answer': str(amount1), - 'answer_cot': answer_cot, - 'answer_value': amount1, - 'variables': { - 'name1': name1, - 'name2': name2, - 'total_fence': total, - 'difference': diff, - 'unit': unit, - 'amount1': amount1, - 'amount2': amount2 - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['Sam', 'Harry', 'Tom', 'John', 'Mike', 'Dave', 'Steve', 'Bob'] - units = ['feet', 'yards', 'meters'] - - name1, name2 = rng.sample(names, 2) - unit = rng.choice(units) - - # Scale ranges by difficulty while maintaining integer division - diff = int(rng.randrange(20, int(200 * difficulty), 10)) - total = int(rng.randrange(diff + 20, int(1000 * difficulty), 20)) - - # Ensure conditions are met - while total - diff <= 10 or (total - diff) % 2 != 0: - diff = int(rng.randrange(20, int(200 * difficulty), 10)) - total = int(rng.randrange(diff + 20, int(1000 * difficulty), 20)) - - result = generate_from_variables(name1, name2, total, diff, unit) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Sam', 'Harry', 100, 60, 'feet') diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_84.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_84.py deleted file mode 100644 index 2dbe0d39..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_84.py +++ /dev/null @@ -1,72 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, miles: str, time_cold: int, extra_time: int, - multiplier: float, distance: int) -> Dict[str, Any]: - time_warm = extra_time + multiplier * time_cold - time_cold_total = distance * time_cold - time_warm_total = distance * time_warm - time_difference = time_warm_total - time_cold_total - - question = f"When the water is cold {name} swims a {miles} in {time_cold} minutes. When the water is warm {name} swims a {miles} in {extra_time} minutes more than {multiplier:.0f} times as long. How much longer does {name} take to swim {distance} {miles}s on a hot day than a cold day?" - - answer_cot = f"Cold water {miles} = {time_cold} minutes\n" \ - f"Warm water {miles} = {extra_time}+{multiplier:.0f}({time_cold})={time_warm} minutes\n" \ - f"{distance} {miles}s in cold water: {distance}({time_cold})={time_cold_total} minutes\n" \ - f"{distance} {miles}s in warm water: {distance}({time_warm})={time_warm_total} minutes\n" \ - f"{name} takes {time_warm_total}-{time_cold_total}={time_difference} minutes longer\n" \ - f"#### {time_difference}" - - return { - 'question': question, - 'answer': str(time_difference), - 'answer_cot': answer_cot, - 'answer_value': time_difference, - 'variables': { - 'name': name, - 'unit': miles, - 'time_cold': time_cold, - 'extra_time': extra_time, - 'multiplier': multiplier, - 'distance': distance, - 'time_warm': time_warm, - 'time_cold_total': time_cold_total, - 'time_warm_total': time_warm_total - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Ray", "Jim", "Bob", "Tom", "Mike", "John", "Steve"] - units = ["mile", "kilometer"] - - name = rng.choice(names) - unit = rng.choice(units) - - time_cold = int(rng.randint(10, int(50 * difficulty))) - extra_time = int(rng.randint(1, int(10 * difficulty))) - multiplier = 2.0 # "twice" specified in original - distance = int(rng.randint(2, int(10 * difficulty))) - - # Check conditions - while time_cold >= 60 or \ - extra_time + multiplier * time_cold >= 60 or \ - distance * (extra_time + multiplier * time_cold) - distance * time_cold <= 0: - time_cold = int(rng.randint(10, int(50 * difficulty))) - extra_time = int(rng.randint(1, int(10 * difficulty))) - distance = int(rng.randint(2, int(10 * difficulty))) - - result = generate_from_variables(name, unit, time_cold, extra_time, multiplier, distance) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Ray", "mile", 16, 2, 2.0, 3) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_85.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_85.py deleted file mode 100644 index 5d7753e7..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_85.py +++ /dev/null @@ -1,65 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, room_type: str, area: int, length: int, - unit1: str, unit2: str) -> Dict[str, Any]: - conversion = 3 if unit1 == 'feet' and unit2 == 'yards' else 1 - length_converted = length * conversion - width = area // length_converted - perimeter = 2 * (width + length_converted) - - question = f"The area of {name}'s rectangular {room_type} is {area} square {unit1}. If the length of his room is {length} {unit2}, what is the perimeter of the room in {unit1}?" - - answer_cot = f"The length of the room is {length} {unit2} * ({conversion} {unit1} / 1 {unit2}) = {length_converted} {unit1}.\n" \ - f"The width of the room is {area} square {unit1} / {length_converted} {unit1} = {width} {unit1}.\n" \ - f"The room's perimeter is 2({width}+{length_converted}) = {perimeter}\n#### {perimeter}" - - return { - 'question': question, - 'answer': str(perimeter), - 'answer_cot': answer_cot, - 'answer_value': perimeter, - 'variables': { - 'name': name, - 'room_type': room_type, - 'area': area, - 'length': length, - 'unit1': unit1, - 'unit2': unit2, - 'width': width, - 'length_converted': length_converted - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["William", "James", "John", "Michael", "David", "Robert", "Thomas"] - room_types = ["living room", "study", "office", "kitchen"] - units = ["feet", "meters"] - - name = rng.choice(names) - room_type = rng.choice(room_types) - unit1 = rng.choice(units) - unit2 = "yards" if unit1 == "feet" else "meters" - - length = int(rng.randint(5, int(44 * difficulty))) - - # Ensure width is larger than length and area calculation results in integer - conversion = 3 if unit1 == 'feet' and unit2 == 'yards' else 1 - width = int(rng.randint(length * conversion + 1, int(100 * difficulty))) - area = width * (length * conversion) - - result = generate_from_variables(name, room_type, area, length, unit1, unit2) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Billie", "bedroom", 360, 3, "feet", "yards") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_86.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_86.py deleted file mode 100644 index 5fc44fd1..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_86.py +++ /dev/null @@ -1,84 +0,0 @@ -from random import Random -from typing import Dict, Any -import math - -def generate_from_variables(animals: str, unit: str, o1: str, o2: str, o3: str, o4: str, - n1: int, n2: int, n3: int, n4: int, - w1: int, w2: int, w3: int, w4: int, - total: int) -> Dict[str, Any]: - # Calculate weights - sugar_weight = n4 * w4 - carrot_weight = n3 * w3 - hay_weight = n1 * w1 - oat_weight = n2 * w2 - total_weight = sugar_weight + carrot_weight + hay_weight + oat_weight - trips = total_weight // total - - question = f"A farmer is buying feed for his {animals}. He buys a variety of {o1}, {o2}, {o3} and {o4}. Since {o4} are a rare treat, he only buys {n4} {w4}-{unit} boxes of them for the whole stable. He only wants enough {o3} to feed the {animals} while the vegetables are fresh, so he buys {n3} {w3}-{unit} bags. {o1} is the main diet of his {animals}, so he buys {n1} {w1}-{unit} bales. {o2} are a staple to supplement the {o1}, so he buys {n2} {w2}-{unit} sacks. If his farm truck can carry {total} {unit}s at a time, how many trips does the farmer need to transport all the feed?" - - answer_cot = f"The farmer is buying {n4} * {w4} = {sugar_weight} {unit}s of {o4}.\nHe is buying {n3} * {w3} = {carrot_weight} {unit}s of {o3}.\nHe is buying {n1} * {w1} = {hay_weight} {unit}s of {o1}.\nHe is buying {n2} * {w2} = {oat_weight} {unit}s of {o2}.\nThe weight of all the feed is {sugar_weight} + {carrot_weight} + {hay_weight} + {oat_weight} = {total_weight} {unit}s.\nThus, the farmer needs {total_weight} / {total} = {trips} trips to transport all the feed in his farm truck.\n#### {trips}" - - return { - 'question': question, - 'answer': str(trips), - 'answer_cot': answer_cot, - 'answer_value': trips, - 'variables': { - 'animals': animals, - 'unit': unit, - 'feed_types': [o1, o2, o3, o4], - 'quantities': [n1, n2, n3, n4], - 'weights': [w1, w2, w3, w4], - 'truck_capacity': total, - 'total_weight': total_weight - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - animals = rng.choice(['horses', 'cows', 'sheep', 'pigs', 'alpacas']) - unit = rng.choice(['pound', 'kilogram']) - feed_options = ["hay", "corn", "oats", "apples", "wheat"] - o1, o2, o4 = rng.sample(feed_options, 3) - o3 = rng.choice(["carrots", "beets", "cucumbers"]) - - # Scale ranges by difficulty - n4 = int(rng.randint(4, int(8 * difficulty))) - n3 = int(rng.randint(11, int(15 * difficulty))) - n2 = int(rng.randint(15, int(20 * difficulty))) - n1 = int(rng.randint(31, int(35 * difficulty))) - - w4 = int(rng.randint(3, int(8 * difficulty))) - w3 = int(rng.randint(5, int(10 * difficulty))) - w2 = int(rng.randint(15, int(20 * difficulty))) - w1 = int(rng.randint(35, int(45 * difficulty))) - - # Ensure weight conditions are met - while not (w4*n4 < w3*n3 < w2*n2 < w1*n1): - w4 = int(rng.randint(3, int(8 * difficulty))) - w3 = int(rng.randint(5, int(10 * difficulty))) - w2 = int(rng.randint(15, int(20 * difficulty))) - w1 = int(rng.randint(35, int(45 * difficulty))) - - total_weight = n1*w1 + n2*w2 + n3*w3 + n4*w4 - # Find truck capacity that divides total weight - total = total_weight // rng.randint(2, 4) - - result = generate_from_variables(animals, unit, o1, o2, o3, o4, - n1, n2, n3, n4, w1, w2, w3, w4, total) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('horses', 'pound', 'hay', 'oats', 'carrots', 'sugar cubes', - 42, 20, 4, 2, - 75, 65, 12, 1, - 2250) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_87.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_87.py deleted file mode 100644 index f660cad2..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_87.py +++ /dev/null @@ -1,77 +0,0 @@ -from random import Random -from typing import Dict, Any -from fractions import Fraction - -def generate_from_variables(name: str, unit: str, weight_large: int, weight_medium: int, - weight_small: Fraction, num_large: int, num_medium: int, - num_small: int, total_amount: int) -> Dict[str, Any]: - - large_used = num_large * weight_large - medium_used = num_medium * weight_medium - small_used = float(num_small * weight_small) - total_used = large_used + medium_used + small_used - remaining = total_amount - total_used - - question = f"{name} wants to make different sized ice cubes with {total_amount} {unit}s of water. He can make giant cubes that use {weight_large} {unit}s per cube, medium cubes that use {weight_medium} {unit}s, and small cubes that use {weight_small} an {unit}. If he makes {num_large} giant cubes, {num_medium} medium cubes, and {num_small} small cubes, how many {unit}s of water does he have left?" - - answer_cot = f"The giant cubes used up {large_used} {unit}s of water because {num_large} times {weight_large} equals {large_used}.\n" \ - f"The medium cubes used up {medium_used} {unit}s of water because {num_medium} times {weight_medium} equals {medium_used}.\n" \ - f"The small cubes used up {int(small_used)} {unit}s of water because {num_small} times {weight_small} equals {int(small_used)}.\n" \ - f"This means that {name} has used up {int(total_used)} {unit}s of water because {large_used} plus {medium_used} plus {int(small_used)} equals {int(total_used)}.\n" \ - f"{name} has {int(remaining)} {unit}s of water left because {total_amount} minus {int(total_used)} equals {int(remaining)}.\n" \ - f"#### {int(remaining)}" - - return { - 'question': question, - 'answer': str(int(remaining)), - 'answer_cot': answer_cot, - 'answer_value': int(remaining), - 'variables': { - 'name': name, - 'unit': unit, - 'weight_large': weight_large, - 'weight_medium': weight_medium, - 'weight_small': weight_small, - 'num_large': num_large, - 'num_medium': num_medium, - 'num_small': num_small, - 'total_amount': total_amount, - 'remaining': remaining - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Peter", "John", "Michael", "David", "James", "Robert", "William"] - units = ["ounce", "gram", "milliliter"] - - name = rng.choice(names) - unit = rng.choice(units) - - weight_large = int(rng.randint(7, int(14 * difficulty))) - weight_medium = int(rng.randint(3, weight_large - 1)) - weight_small = Fraction(1, 2) - - num_large = int(rng.randint(2, int(8 * difficulty))) - num_medium = int(rng.randint(4, int(12 * difficulty))) - num_small = rng.choice([14, 24, 15]) - - # Calculate needed total to ensure positive remainder - used = num_large * weight_large + num_medium * weight_medium + float(num_small * weight_small) - total_amount = int(used + rng.randint(1, int(10 * difficulty))) - - result = generate_from_variables(name, unit, weight_large, weight_medium, weight_small, - num_large, num_medium, num_small, total_amount) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Peter", "ounce", 4, 2, Fraction(1,2), 3, 7, 8, 32) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_88.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_88.py deleted file mode 100644 index fcdeaa61..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_88.py +++ /dev/null @@ -1,56 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(school: str, venue: str, total: int, graduates: int, faculty: int) -> Dict[str, Any]: - remaining_seats = total - (graduates + faculty) - tickets_per_graduate = remaining_seats // graduates - - question = f"{school} is holding graduation in their {venue} this year which has space for {total} people. After accounting for {graduates} seats for graduates and {faculty} seats for faculty attending, how many tickets would each graduate receive to give to their friends and family if the tickets are split equally?" - - answer_cot = f"Add graduate and faculty seats together. {graduates} + {faculty} = {graduates+faculty} seats for faculty and graduates\nMinus seats for faculty and graduates from total seats allowed. {total} - {graduates+faculty} = {remaining_seats} remaining seats.\nDivide remaining seats by the number of graduates. {remaining_seats}/{graduates} = {tickets_per_graduate} tickets\n#### {tickets_per_graduate}" - - return { - 'question': question, - 'answer': str(tickets_per_graduate), - 'answer_cot': answer_cot, - 'answer_value': tickets_per_graduate, - 'variables': { - 'school': school, - 'venue': venue, - 'total_seats': total, - 'graduate_seats': graduates, - 'faculty_seats': faculty, - 'remaining_seats': remaining_seats, - 'tickets_per_graduate': tickets_per_graduate - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - schools = ["Oakwood High School", "Riverside Academy", "Sunnyside High", "Greenville High School"] - venues = ["Auditorium", "Gymnasium", "Sports Arena", "Convention Center"] - - school = rng.choice(schools) - venue = rng.choice(venues) - - graduates = int(rng.randint(500, int(1500 * difficulty)) // 50 * 50) - faculty = int(rng.randint(100, int(500 * difficulty)) // 50 * 50) - - # Ensure total seats allow for integer division of remaining seats - remaining_seats = rng.randint(2, int(10 * difficulty)) * graduates - total = remaining_seats + graduates + faculty - - result = generate_from_variables(school, venue, total, graduates, faculty) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Apple High School", "Fine Arts Center", 6000, 950, 300) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_89.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_89.py deleted file mode 100644 index 42cd1153..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_89.py +++ /dev/null @@ -1,94 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name1: str, name2: str, name3: str, name4: str, name5: str, - num_dozen: int, found_first: int, multiplier: float, - less_amount: int, fraction: float) -> Dict[str, Any]: - total_eggs = num_dozen * 12 - found_second = found_first * multiplier - found_third = found_second - less_amount - found_fourth = found_third * fraction - total_found = found_first + found_second + found_third + found_fourth - remaining = total_eggs - total_found - - question = f"{name1} hid {num_dozen} dozen eggs in the yard for the Easter egg hunt. {name2} finds {found_first} eggs. {name3} finds {multiplier:.0f} times as many as {name2}. {name4} finds {less_amount} less than {name3}, and {name5} finds {fraction:.1f} as many as {name4}. How many eggs are still hidden in the yard?" - - answer_cot = f"{name1} hides {num_dozen} x 12 = {total_eggs} eggs.\n" - answer_cot += f"{name2} finds {found_first} eggs.\n" - answer_cot += f"{name3} finds {found_first} x {multiplier:.0f} = {found_second} eggs.\n" - answer_cot += f"{name4} finds {found_second} - {less_amount} = {found_third} eggs.\n" - answer_cot += f"{name5} finds {found_third} x {fraction:.1f} = {found_fourth} eggs.\n" - answer_cot += f"The children find a total of {found_first} + {found_second} + {found_third} + {found_fourth} = {total_found} eggs.\n" - answer_cot += f"The total number of hidden eggs still in the yard is {total_eggs} - {total_found} = {remaining} eggs.\n#### {remaining}" - - return { - 'question': question, - 'answer': str(remaining), - 'answer_cot': answer_cot, - 'answer_value': remaining, - 'variables': { - 'name1': name1, - 'name2': name2, - 'name3': name3, - 'name4': name4, - 'name5': name5, - 'num_dozen': num_dozen, - 'found_first': found_first, - 'multiplier': multiplier, - 'less_amount': less_amount, - 'fraction': fraction, - 'total_eggs': total_eggs, - 'total_found': total_found, - 'remaining': remaining - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Emma", "Liam", "Olivia", "Noah", "Ava", "Oliver", "Isabella", "William", - "Sophia", "James", "Charlotte", "Benjamin", "Mia", "Lucas", "Harper"] - - name1, name2, name3, name4, name5 = rng.sample(names, 5) - - num_dozen = int(rng.randint(2, int(10 * difficulty))) - found_first = int(rng.randint(3, int(15 * difficulty))) - multiplier = 2.0 # Using 'twice' as specified - less_amount = int(rng.randint(1, int(5 * difficulty))) - fraction = 0.5 # Using 'half' as specified - - # Ensure all conditions are met - total = num_dozen * 12 - found_second = found_first * multiplier - found_third = found_second - less_amount - found_fourth = found_third * fraction - total_found = found_first + found_second + found_third + found_fourth - - # Regenerate if conditions not met - while (not found_third > 0 or not total > total_found or - not float(found_fourth).is_integer()): - num_dozen = int(rng.randint(2, int(10 * difficulty))) - found_first = int(rng.randint(3, int(15 * difficulty))) - less_amount = int(rng.randint(1, int(5 * difficulty))) - total = num_dozen * 12 - found_second = found_first * multiplier - found_third = found_second - less_amount - found_fourth = found_third * fraction - total_found = found_first + found_second + found_third + found_fourth - - result = generate_from_variables(name1, name2, name3, name4, name5, - num_dozen, found_first, multiplier, - less_amount, fraction) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Cole", "Lamar", "Stacy", "Charlie", "Mei", - 3, 5, 2.0, 2, 0.5) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_9.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_9.py deleted file mode 100644 index e4ea2b10..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_9.py +++ /dev/null @@ -1,83 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, num_bills: int, bill_value: int, num_items1: int, - price1: int, num_items2: int, price2: int, item1: str, - item2: str, currency: str) -> Dict[str, Any]: - - initial_amount = num_bills * bill_value - spent_items1 = num_items1 * price1 - spent_items2 = num_items2 * price2 - total_spent = spent_items1 + spent_items2 - remaining = initial_amount - total_spent - - question = f"{name} has {num_bills} {currency}{bill_value} bills. He buys {num_items1} {item1}s for {currency}{price1} each. He also buys {num_items2} packs of {item2}s for {currency}{price2} each. How much money does he have left?" - - answer_cot = f"{name} starts off with {num_bills} * {currency}{bill_value} = {currency}{initial_amount}.\n" \ - f"{name} spends {num_items1} {item1}s * {currency}{price1} = {currency}{spent_items1} on {item1}s.\n" \ - f"{name} spends {num_items2} packs of {item2}s * {currency}{price2} = {currency}{spent_items2} on {item2}s.\n" \ - f"Total {name} has spent {currency}{spent_items1} + {currency}{spent_items2} = {currency}{total_spent}.\n" \ - f"{name} has {currency}{initial_amount} - {currency}{total_spent} = {currency}{remaining} remaining.\n#### {remaining}" - - return { - 'question': question, - 'answer': str(remaining), - 'answer_cot': answer_cot, - 'answer_value': remaining, - 'variables': { - 'name': name, - 'num_bills': num_bills, - 'bill_value': bill_value, - 'num_items1': num_items1, - 'price1': price1, - 'num_items2': num_items2, - 'price2': price2, - 'item1': item1, - 'item2': item2, - 'currency': currency, - 'initial_amount': initial_amount, - 'total_spent': total_spent - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Craig", "John", "Michael", "David", "James", "Robert", "William"] - items1 = ["toy car", "action figure", "coloring book", "puzzle", "board game"] - items2 = ["sticker", "candy bar", "trading card", "pencil", "eraser"] - currencies = ["$", "€", "£"] - bills = [(5, 5), (10, 10), (20, 20), (50, 50), (100, 100)] - - name = rng.choice(names) - item1 = rng.choice(items1) - item2 = rng.choice(items2) - currency = rng.choice(currencies) - bill_value = rng.choice(bills)[1] - - num_bills = int(rng.randint(1, int(10 * difficulty))) - num_items1 = int(rng.randint(2, int(15 * difficulty))) - num_items2 = int(rng.randint(2, int(10 * difficulty))) - price1 = int(rng.randint(1, int(10 * difficulty))) - price2 = int(rng.randint(1, int(10 * difficulty))) - - # Ensure total cost doesn't exceed available money - while (num_items1 * price1 + num_items2 * price2) > (num_bills * bill_value): - num_items1 = int(rng.randint(2, int(15 * difficulty))) - num_items2 = int(rng.randint(2, int(10 * difficulty))) - - result = generate_from_variables(name, num_bills, bill_value, num_items1, price1, - num_items2, price2, item1, item2, currency) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Craig", 2, 20, 6, 2, 3, 3, - "squirt gun", "water balloon", "$") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_90.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_90.py deleted file mode 100644 index 04e6706a..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_90.py +++ /dev/null @@ -1,67 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(device: str, currency: str, rate1: float, rate2: float, - threshold: int, total_mins: int) -> Dict[str, Any]: - first_period = threshold - second_period = total_mins - threshold - - cost1 = first_period * rate1 - cost2 = second_period * rate2 - total_cost = int(cost1 + cost2) - - question = f"To make a call from a {device}, you must pay {currency}{rate1} for each minute of your call. After {threshold} minutes, that price drops to {currency}{rate2} per minute. How much would a {total_mins}-minute call cost?" - - answer_cot = f"First {threshold} minutes would be a cost of {threshold} * {rate1} = {currency}{int(cost1)}.\nAfter that, there are {total_mins} - {threshold} = {second_period} minutes of the call left.\nAnd these {second_period} minutes cost {second_period} * {rate2} = {currency}{int(cost2)}.\nSo in total, the {total_mins}-minute call would cost {int(cost1)} + {int(cost2)} = {currency}{total_cost}.\n#### {total_cost}" - - return { - 'question': question, - 'answer': str(total_cost), - 'answer_cot': answer_cot, - 'answer_value': total_cost, - 'variables': { - 'device': device, - 'currency': currency, - 'rate1': rate1, - 'rate2': rate2, - 'threshold': threshold, - 'total_mins': total_mins, - 'first_period_cost': int(cost1), - 'second_period_cost': int(cost2) - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - devices = ['payphone', 'phone booth', 'hotel room phone'] - currencies = ['$', '£', '€'] - - device = rng.choice(devices) - currency = rng.choice(currencies) - - # Generate rates ensuring rate2 < rate1 - rate1 = round(rng.uniform(0.2, 0.5 * difficulty), 2) - rate2 = round(rng.uniform(0.1, rate1), 2) - - threshold = int(rng.randint(10, int(50 * difficulty))) - total_mins = int(rng.randint(threshold + 10, int(100 * difficulty))) - - # Ensure calculations result in integers - while not (threshold * rate1).is_integer() or not ((total_mins - threshold) * rate2).is_integer(): - rate1 = round(rng.uniform(0.2, 0.5 * difficulty), 2) - rate2 = round(rng.uniform(0.1, rate1), 2) - - result = generate_from_variables(device, currency, rate1, rate2, threshold, total_mins) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('payphone', '$', 0.25, 0.2, 16, 36) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_91.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_91.py deleted file mode 100644 index 36b09ba2..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_91.py +++ /dev/null @@ -1,58 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, fruit: str, area: str, - field_size: int, density: int, months: int) -> Dict[str, Any]: - fruits_per_harvest = field_size * density - harvests_per_year = 12 // months - total_fruits = fruits_per_harvest * harvests_per_year - - question = f"{name} has {field_size} {area}s of a {fruit} field. There are {density} {fruit}s per {area}. {name} can harvest his {fruit}s every {months} months. How many {fruit}s can {name} harvest within a year?" - - answer_cot = f"{name} has {density} x {field_size}= {fruits_per_harvest} {fruit}s on his field.\n{name} can harvest his {fruit}s 12 ÷ {months} = {harvests_per_year} times per year\nTherefore {name} can harvest {fruits_per_harvest} x {harvests_per_year} = {total_fruits} {fruit}s per year.\n#### {total_fruits}" - - return { - 'question': question, - 'answer': str(total_fruits), - 'answer_cot': answer_cot, - 'answer_value': total_fruits, - 'variables': { - 'name': name, - 'fruit': fruit, - 'area': area, - 'field_size': field_size, - 'density': density, - 'months_per_harvest': months, - 'fruits_per_harvest': fruits_per_harvest, - 'harvests_per_year': harvests_per_year - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["John", "Michael", "David", "James", "Robert", "William", "Richard"] - fruits = ["pineapple", "mango", "banana", "papaya", "coconut"] - areas = ["hectare", "square yard", "square meter"] - - name = rng.choice(names) - fruit = rng.choice(fruits) - area = rng.choice(areas) - - field_size = int(rng.randint(5, int(100 * difficulty)) // 5 * 5) - density = int(rng.randint(2, int(101 * difficulty))) - months = rng.choice([1, 2, 3, 4, 6, 12]) - - result = generate_from_variables(name, fruit, area, field_size, density, months) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("John", "pineapple", "hectare", 10, 100, 3) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_92.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_92.py deleted file mode 100644 index 0bdf7d38..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_92.py +++ /dev/null @@ -1,88 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, product: str, location: str, - item1: str, item2: str, item3: str, - price1: float, price2: float, price3: float, - num1: int, num2: int, num3: int, - unit: str, currency: str) -> Dict[str, Any]: - - round_p1 = round(price1) - round_p2 = round(price2) - round_p3 = round(price3) - - total = num1 * round_p1 + num2 * round_p2 + num3 * round_p3 - - question = f"{name} has a {product} stand at the {location}. He sells three kinds of {product}s: {item1}, {item2} and {item3}. He usually sells {item1} for {currency}{price1:.2f} per {unit}, {item2} for {currency}{price2:.2f} per {unit} and {item3} for {currency}{price3:.2f} per {unit}. {name} has no change today, so he has decided to round all his prices to the nearest dollar. If {name} sells {num1} {unit}s of {item1}, {num2} {unit}s of {item2} and {num3} {unit}s of {item3}, how much will he make?" - - answer_cot = f"{name} will round his {item1} {'up' if round_p1 > price1 else 'down'} from {currency}{price1:.2f} to {currency}{round_p1}, since the number following the {int(price1)} is {'5 or higher' if round_p1 > price1 else 'less than 5'}.\n" - answer_cot += f"{name} will round his {item2} {'up' if round_p2 > price2 else 'down'} from {currency}{price2:.2f} to {currency}{round_p2}, since the number following the {int(price2)} is {'5 or higher' if round_p2 > price2 else 'less than 5'}.\n" - answer_cot += f"{name} will round his {item3} {'up' if round_p3 > price3 else 'down'} from {currency}{price3:.2f} to {currency}{round_p3}, since the number following the {int(price3)} is {'5 or higher' if round_p3 > price3 else 'less than 5'}.\n" - answer_cot += f"{name} sells {num1} {item1} x {currency}{round_p1} = {currency}{num1*round_p1}\n" - answer_cot += f"{name} sells {num2} {item2} x {currency}{round_p2} = {currency}{num2*round_p2}\n" - answer_cot += f"{name} sells {num3} {item3} x {currency}{round_p3} = {currency}{num3*round_p3}\n" - answer_cot += f"Altogether, {name} will make {currency}{num1*round_p1} + {currency}{num2*round_p2} + {currency}{num3*round_p3} = {currency}{total}\n#### {total}" - - return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'name': name, - 'product': product, - 'location': location, - 'items': [item1, item2, item3], - 'original_prices': [price1, price2, price3], - 'rounded_prices': [round_p1, round_p2, round_p3], - 'quantities': [num1, num2, num3], - 'unit': unit, - 'currency': currency - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['John', 'Mike', 'David', 'James', 'Robert', 'William', 'Richard'] - products = ['vegetable', 'flower', 'herb', 'plant'] - locations = ['local fair', 'community market', 'street bazaar', 'town square'] - items = ['roses', 'daisies', 'tulips', 'lilies', 'sunflowers', 'orchids'] - units = ['bunch', 'basket', 'bouquet', 'bundle'] - currencies = ['$', '£', '€'] - - name = rng.choice(names) - product = rng.choice(products) - location = rng.choice(locations) - item1, item2, item3 = rng.sample(items, 3) - unit = rng.choice(units) - currency = rng.choice(currencies) - - # Scale prices by difficulty - price1 = round(rng.uniform(1.26, 3.53 * difficulty), 2) - price2 = round(rng.uniform(2.27, 5.53 * difficulty), 2) - price3 = round(rng.uniform(4.85, 6.53 * difficulty), 2) - - num1 = int(rng.randint(5, int(21 * difficulty))) - num2 = int(rng.randint(15, int(31 * difficulty))) - num3 = int(rng.randint(35, int(41 * difficulty))) - - result = generate_from_variables(name, product, location, item1, item2, item3, - price1, price2, price3, num1, num2, num3, - unit, currency) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables('Artie', 'flower', 'Farmers Market', - 'marigolds', 'petunias', 'begonias', - 2.74, 1.87, 2.12, - 12, 9, 17, - 'pot', '$') diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_93.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_93.py deleted file mode 100644 index ad352f45..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_93.py +++ /dev/null @@ -1,91 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name1: str, name2: str, name3: str, name4: str, - creature: str, weapon1: str, weapon2: str, weapon3: str, - weapon4: str, weapon5: str, n1: int, frac1: float, - mult1: int, frac2: float) -> Dict[str, Any]: - - kills_arthur = int(n1 * frac1) - kills_walter = int(kills_arthur * mult1) - kills_bruce = int(kills_walter * frac2) - - question = f"{name1} slew {n1} {creature} with his mighty {weapon1}, while {name2}, using a {weapon2}, slew {frac1} as many {creature} as {name1}. Using a {weapon3}, {name3} slew {mult1} as many {creature} as {name2}. But {name4}, having forgot his {weapon4} at home, slew {frac2} as many {creature} as {name3} using a {weapon5}. How many {creature} has {name4} slain?" - - answer_cot = f"{name2} slew {frac1} as many {creature} as {name1}, or {n1}*{frac1}={kills_arthur} {creature}.\n{name3} slew {mult1} as many {creature} as {name2}, or {mult1}*{kills_arthur}={kills_walter} {creature}.\n{name4} slew {frac2} as many {creature} as {name3}, or {kills_walter}*{frac2}={kills_bruce} {creature}.\n#### {kills_bruce}" - - return { - 'question': question, - 'answer': str(kills_bruce), - 'answer_cot': answer_cot, - 'answer_value': kills_bruce, - 'variables': { - 'name1': name1, - 'name2': name2, - 'name3': name3, - 'name4': name4, - 'creature': creature, - 'weapon1': weapon1, - 'weapon2': weapon2, - 'weapon3': weapon3, - 'weapon4': weapon4, - 'weapon5': weapon5, - 'initial_kills': n1, - 'fraction1': frac1, - 'multiplier': mult1, - 'fraction2': frac2, - 'kills_arthur': kills_arthur, - 'kills_walter': kills_walter, - 'kills_bruce': kills_bruce - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_male = ["Arthur", "Bruce", "Charles", "David", "Edward", "Frederick", "George", "Henry"] - creatures = ["ogres", "trolls", "goblins", "orcs", "giants"] - weapons1 = ["sword", "mace", "battle axe", "war hammer"] - weapons2 = ["spear", "lance", "javelin", "halberd"] - weapons3 = ["rusty iron axe", "wooden club", "stone hammer", "bone dagger"] - weapons4 = ["sword", "axe", "mace", "hammer"] - weapons5 = ["nail file", "butter knife", "wooden spoon", "feather"] - fractions = [0.25, 0.5, 0.75] - multipliers = [2, 3, 4] - - name1, name2, name3, name4 = rng.sample(names_male, 4) - creature = rng.choice(creatures) - weapon1 = rng.choice(weapons1) - weapon2 = rng.choice(weapons2) - weapon3 = rng.choice(weapons3) - weapon4 = rng.choice(weapons4) - weapon5 = rng.choice(weapons5) - - # Scale numbers by difficulty but ensure integer results - n1 = int(rng.randint(50, int(500 * difficulty)) // 50 * 50) - frac1 = rng.choice(fractions) - mult1 = rng.choice(multipliers) - frac2 = rng.choice(fractions) - - # Ensure all divisions result in integers - while not (n1 * frac1).is_integer() or not (n1 * frac1 * mult1).is_integer() or \ - not (n1 * frac1 * mult1 * frac2).is_integer(): - n1 = int(rng.randint(50, int(500 * difficulty)) // 50 * 50) - - result = generate_from_variables(name1, name2, name3, name4, creature, - weapon1, weapon2, weapon3, weapon4, weapon5, - n1, frac1, mult1, frac2) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Prince Thaddeus", "Prince Arthur", "Prince Walter", "Prince Bruce", - "dragons", "sword", "spear", "rusty iron axe", "sword", "nail file", - 100, 0.75, 2, 0.2) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_94.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_94.py deleted file mode 100644 index 7e110f48..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_94.py +++ /dev/null @@ -1,68 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, num_shares: int, price_per_share: int, - increase_pct: int, decrease_pct: int) -> Dict[str, Any]: - initial_value = num_shares * price_per_share - first_increase = initial_value * increase_pct/100 - value_after_increase = initial_value + first_increase - second_decrease = value_after_increase * decrease_pct/100 - final_value = value_after_increase - second_decrease - - question = f"{name} buys {num_shares} shares of a stock for ${price_per_share} each. The stock price increases {increase_pct}% the first year {name} holds it, then decreases {decrease_pct}% in the second year. What is the final value of all {name}'s shares?" - - answer_cot = f"First find the initial total value of {name}'s purchase: {num_shares} shares * ${price_per_share}/share = ${initial_value}\n" \ - f"Then find the amount of the first price increase: ${initial_value} * {increase_pct/100} = ${int(first_increase)}\n" \ - f"Add that amount to the initial value to find the value after the first year: ${initial_value} + ${int(first_increase)} = ${int(value_after_increase)}\n" \ - f"Then multiply that amount by {decrease_pct}% to find the amount of the decrease in the second year: ${int(value_after_increase)} * {decrease_pct}% = ${int(second_decrease)}\n" \ - f"Then subtract that amount from the value after the first year to find the final value: ${int(value_after_increase)} - ${int(second_decrease)} = ${int(final_value)}\n" \ - f"#### {int(final_value)}" - - return { - 'question': question, - 'answer': str(int(final_value)), - 'answer_cot': answer_cot, - 'answer_value': int(final_value), - 'variables': { - 'name': name, - 'num_shares': num_shares, - 'price_per_share': price_per_share, - 'increase_pct': increase_pct, - 'decrease_pct': decrease_pct, - 'initial_value': initial_value, - 'final_value': int(final_value) - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['Maria', 'Sarah', 'Emma', 'Isabella', 'Sophia', 'Mia', 'Charlotte'] - name = rng.choice(names) - - num_shares = int(rng.randint(5, int(20 * difficulty))) - price_per_share = int(rng.randint(5, int(100 * difficulty))) - increase_pct = int(rng.randint(10, int(100 * difficulty)) // 5 * 5) - decrease_pct = int(rng.randint(5, int(50 * difficulty)) // 5 * 5) - - # Ensure integer results - while not (num_shares * price_per_share * increase_pct/100).is_integer() or \ - not (num_shares * price_per_share * (1 + increase_pct/100) * (1 - decrease_pct/100)).is_integer(): - num_shares = int(rng.randint(5, int(20 * difficulty))) - price_per_share = int(rng.randint(5, int(100 * difficulty))) - increase_pct = int(rng.randint(10, int(100 * difficulty)) // 5 * 5) - decrease_pct = int(rng.randint(5, int(50 * difficulty)) // 5 * 5) - - result = generate_from_variables(name, num_shares, price_per_share, increase_pct, decrease_pct) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Maria", 8, 8, 50, 25) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_95.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_95.py deleted file mode 100644 index d0a1d2f9..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_95.py +++ /dev/null @@ -1,67 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name1: str, name2: str, relation: str, food: str, - n1: int, n2: int, n3: int, time_unit: str, - time_period: str) -> Dict[str, Any]: - daily_total = n1 + n2 + n3 - total = daily_total * (7 if time_period == "week" else 30) - - question = f"{name1} eats {n1} {food} per {time_unit}, {name2} eats {n2} {food} per {time_unit}, and their {relation} eats {n3} {food} per {time_unit}. How many {food} does this family eat in one {time_period}?" - - answer_cot = f"The number of {food} they eat in one {time_unit} is {n1} + {n2} + {n3} = {daily_total} {food}.\nThe number of {food} they eat in a {time_period} is {daily_total} * {7 if time_period == 'week' else 30} = {total} {food}.\n#### {total}" - - return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'name1': name1, - 'name2': name2, - 'relation': relation, - 'food': food, - 'daily_servings1': n1, - 'daily_servings2': n2, - 'daily_servings3': n3, - 'daily_total': daily_total, - 'time_unit': time_unit, - 'time_period': time_period - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - name1_options = ["A father", "A grandfather", "An uncle"] - name2_options = ["his wife", "his partner", "his spouse"] - relation_options = ["daughter", "son", "grandchild"] - food_options = ["pizzas", "burritos", "tacos", "sushi rolls", "hamburgers"] - - name1 = rng.choice(name1_options) - name2 = rng.choice(name2_options) - relation = rng.choice(relation_options) - food = rng.choice(food_options) - - n1 = int(rng.randint(2, int(9 * difficulty))) - n2 = int(rng.randint(2, int(9 * difficulty))) - n3 = int(rng.randint(2, int(9 * difficulty))) - - time_unit = "day" - time_period = rng.choice(["week", "month"]) - - result = generate_from_variables(name1, name2, relation, food, n1, n2, n3, - time_unit, time_period) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("A man", "his wife", "son", "sandwiches", - 5, 4, 2, "day", "week") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_96.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_96.py deleted file mode 100644 index 26fec8e5..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_96.py +++ /dev/null @@ -1,75 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, food: str, animal1: str, animal2: str, - n1: int, n2: int, k1: int, k2: int, unit: str) -> Dict[str, Any]: - animal2_amount = 2 * n1 - n2 # Amount per sheep - animal2_total = k2 * animal2_amount # Total for sheep - animal1_total = k1 * n1 # Total for goats - total = animal1_total + animal2_total - - question = f"{name} is feeding his livestock {food}. Each {animal1} needs {n1} {unit}, and each {animal2} needs {n2} {unit} less than twice the amount each {animal1} needs. If there are {k1} {animal1}s and {k2} {animal2}s, how many {unit} of {food} does {name} need?" - - answer_cot = f"First figure out how much {food} each {animal2} needs: {n1} {unit} * 2 - {n2} = {animal2_amount} {unit}/{animal2}\n" \ - f"Now figure out how much {food} total the {animal2}s need: {animal2_amount} {unit}/{animal2} * {k2} {animal2} = {animal2_total} {unit}\n" \ - f"Now figure out how much {food} total the {animal1}s need: {n1} {unit}/{animal1} * {k1} {animal1}s = {animal1_total} {unit}\n" \ - f"Now add the two amounts of {food} to find the total: {animal2_total} {unit} + {animal1_total} {unit} = {total} {unit}\n#### {total}" - - return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'name': name, - 'food': food, - 'animal1': animal1, - 'animal2': animal2, - 'n1': n1, - 'n2': n2, - 'k1': k1, - 'k2': k2, - 'unit': unit, - 'animal2_amount': animal2_amount, - 'animal2_total': animal2_total, - 'animal1_total': animal1_total - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["John", "Michael", "David", "James", "Robert", "William", "Richard"] - foods = ["hay", "grain", "feed", "silage"] - animals = ["goat", "cow", "horse", "donkey", "llama", "alpaca", "pig", "turkey", "duck"] - units = ["pounds", "kilograms", "kg"] - - name = rng.choice(names) - food = rng.choice(foods) - animal1, animal2 = rng.sample(animals, 2) - unit = rng.choice(units) - - n1 = int(rng.randint(3, int(15 * difficulty))) - n2 = int(rng.randint(1, int(10 * difficulty))) - - # Ensure 2*n1 - n2 > 0 - while 2*n1 - n2 <= 0: - n1 = int(rng.randint(3, int(15 * difficulty))) - n2 = int(rng.randint(1, int(10 * difficulty))) - - k1 = int(rng.randint(10, int(50 * difficulty))) - k2 = int(rng.randint(10, int(50 * difficulty))) - - result = generate_from_variables(name, food, animal1, animal2, n1, n2, k1, k2, unit) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Nate", "hay", "goat", "sheep", 5, 3, 15, 12, "pounds") diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_97.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_97.py deleted file mode 100644 index 37e24ce8..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_97.py +++ /dev/null @@ -1,82 +0,0 @@ -from random import Random -from typing import Dict, Any -import math - -def generate_from_variables(name: str, mult_run: int, frac_skip: float, skip_speed: int, - total_time: int, frac_run: float, frac_walk: float) -> Dict[str, Any]: - run_speed = skip_speed / frac_skip - walk_speed = run_speed / mult_run - walk_hours = total_time * frac_walk - run_hours = total_time * frac_run - run_dist = run_hours * run_speed - walk_dist = walk_hours * walk_speed - total_dist = int(run_dist + walk_dist) - - question = f"{name} can run {mult_run} times faster than she can walk, but she can skip at a rate of speed that is {frac_skip:.1f} as fast as she can run. If she can skip at {skip_speed} miles per hour, how many miles can she travel in {total_time} hours if she spends {frac_run:.2f} of the time running and {frac_walk:.2f} of the time walking?" - - answer_cot = f"""If {name} can skip at {frac_skip:.1f} the speed she can run, then she can run at {skip_speed}*{1/frac_skip:.1f}={run_speed} miles per hour. -And since she can run at a speed that is {mult_run} times faster than she can walk, this means she can walk at {run_speed}/{mult_run}={walk_speed} miles per hour. -If {frac_walk:.2f} of the time is spent walking, then she walks for {total_time}*{frac_walk:.2f}={walk_hours} hours. -If {frac_run:.2f} of the time is spent running, then she runs for {total_time}-{walk_hours}={run_hours} hours. -Thus, she runs for {run_hours} hours at {run_speed} miles per hour, or {run_hours}*{run_speed}={run_dist} miles. -She walks for {walk_hours} hours at {walk_speed} miles per hour, or {walk_hours}*{walk_speed}={walk_dist} miles. -Thus, altogether, she travels {run_dist}+{walk_dist}={total_dist} miles. -#### {total_dist}""" - - return { - 'question': question, - 'answer': str(total_dist), - 'answer_cot': answer_cot, - 'answer_value': total_dist, - 'variables': { - 'name': name, - 'mult_run': mult_run, - 'frac_skip': frac_skip, - 'skip_speed': skip_speed, - 'total_time': total_time, - 'frac_run': frac_run, - 'frac_walk': frac_walk, - 'run_speed': run_speed, - 'walk_speed': walk_speed, - 'total_dist': total_dist - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Dana", "Emma", "Sarah", "Julia", "Sophie", "Maria"] - name = rng.choice(names) - - mult_run = rng.randint(2, int(6 * difficulty)) - frac_skip = 0.5 # Keep simple fraction - skip_speed = rng.randint(2, int(10 * difficulty)) - total_time = rng.randrange(4, int(12 * difficulty), 2) - - # Ensure fractions add to 1 - frac_run = 1/3 # Keep simple fraction - frac_walk = 2/3 # Keep simple fraction - - # Validate conditions - while not (skip_speed / frac_skip < 13 and - (total_time * frac_walk * (skip_speed / frac_skip / mult_run)).is_integer() and - (skip_speed / frac_skip).is_integer() and - (total_time * frac_run).is_integer() and - (total_time * frac_walk).is_integer()): - skip_speed = rng.randint(2, int(10 * difficulty)) - total_time = rng.randrange(4, int(12 * difficulty), 2) - - result = generate_from_variables(name, mult_run, frac_skip, skip_speed, - total_time, frac_run, frac_walk) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("Dana", 4, 0.5, 3, 6, 1/3, 2/3) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_98.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_98.py deleted file mode 100644 index dffa054e..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_98.py +++ /dev/null @@ -1,78 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, vehicle: str, weight_vehicle: int, - item: str, weight_item: int, passenger_type: str, - num_passengers: int, weight_passenger: int, - unit: str, force_percent: int) -> Dict[str, Any]: - - total_passenger_weight = num_passengers * weight_passenger - total_weight = weight_vehicle + weight_item + total_passenger_weight - force_needed = int((total_weight * force_percent) / 100) - - question = f"{name}'s {vehicle} breaks down. The {vehicle} weighs {weight_vehicle} {unit} and he has {item} in it weighing {weight_item} {unit}. He also has his {num_passengers} young {passenger_type} who weigh {weight_passenger} {unit} each in it. If the force to move the {vehicle} is {force_percent}% of the weight, how much force does he need to push the {vehicle}?" - - answer_cot = f"His {num_passengers} {passenger_type} weigh {weight_passenger}*{num_passengers}={total_passenger_weight} {unit}\nSo the total weight of the {vehicle} and everything is {weight_vehicle}+{weight_item}+{total_passenger_weight}={total_weight} {unit}\nSo he needs to generate {total_weight}*{force_percent/100}={force_needed} {unit}\n#### {force_needed}" - - return { - 'question': question, - 'answer': str(force_needed), - 'answer_cot': answer_cot, - 'answer_value': force_needed, - 'variables': { - 'name': name, - 'vehicle': vehicle, - 'weight_vehicle': weight_vehicle, - 'item': item, - 'weight_item': weight_item, - 'passenger_type': passenger_type, - 'num_passengers': num_passengers, - 'weight_passenger': weight_passenger, - 'unit': unit, - 'force_percent': force_percent, - 'total_weight': total_weight - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["John", "Michael", "David", "James", "Robert", "William", "Richard"] - vehicles = ['car', 'van', 'truck', 'SUV'] - items = ['luggage', 'groceries', 'equipment', 'furniture'] - passenger_types = ['children', 'friends', 'colleagues', 'teammates'] - units = ['pounds', 'kilograms'] - - name = rng.choice(names) - vehicle = rng.choice(vehicles) - item = rng.choice(items) - passenger_type = rng.choice(passenger_types) - unit = rng.choice(units) - - weight_vehicle = int(rng.randint(1000, int(3000 * difficulty) // 50) * 50) - weight_item = int(rng.randint(100, int(500 * difficulty) // 25) * 25) - weight_passenger = int(rng.randint(50, int(100 * difficulty) // 5) * 5) - num_passengers = int(rng.randint(2, int(5 * difficulty))) - force_percent = int(rng.randint(1, int(6 * difficulty))) - - # Ensure force calculation results in integer - total_weight = weight_vehicle + weight_item + (num_passengers * weight_passenger) - while (total_weight * force_percent) % 100 != 0: - force_percent = int(rng.randint(1, int(6 * difficulty))) - - result = generate_from_variables(name, vehicle, weight_vehicle, item, weight_item, - passenger_type, num_passengers, weight_passenger, - unit, force_percent) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("John", "car", 1200, "luggage", 250, - "children", 2, 75, "pounds", 1) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generator_99.py b/reasoning_gym/arithmetic/gsm_symbolic/generator_99.py deleted file mode 100644 index fa4e1f2d..00000000 --- a/reasoning_gym/arithmetic/gsm_symbolic/generator_99.py +++ /dev/null @@ -1,67 +0,0 @@ -from random import Random -from typing import Dict, Any - -def generate_from_variables(name: str, currency: str, initial_amount: float, - quantity: int, item: str, store_type: str, - unit_price: float) -> Dict[str, Any]: - total_cost = quantity * unit_price - remaining = initial_amount - total_cost - - question = f"{name} has {currency}{initial_amount:.2f} and wants to buy {quantity} {item}s from a bin at the {store_type} store. Each {item} costs {currency}{unit_price:.2f}. How much money does {name} have left after paying for the {item}s?" - - answer_cot = f"{name} paid {quantity} * {currency}{unit_price:.2f} = {currency}{total_cost:.2f} for the {item}s.\n{name} has {currency}{initial_amount:.2f} - {currency}{total_cost:.2f} = {currency}{int(remaining)} left.\n#### {int(remaining)}" - - return { - 'question': question, - 'answer': str(int(remaining)), - 'answer_cot': answer_cot, - 'answer_value': int(remaining), - 'variables': { - 'name': name, - 'currency': currency, - 'initial_amount': initial_amount, - 'quantity': quantity, - 'item': item, - 'store_type': store_type, - 'unit_price': unit_price, - 'total_cost': total_cost, - 'remaining': remaining - } - } - -def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["David", "John", "Michael", "James", "William", "Robert"] - currencies = ["$", "€", "£"] - items = ["screw", "nail", "washer", "nut", "anchor"] - store_types = ["hardware", "home improvement", "construction supply"] - - name = rng.choice(names) - currency = rng.choice(currencies) - item = rng.choice(items) - store_type = rng.choice(store_types) - - # Generate values ensuring conditions are met - quantity = int(rng.randint(15, int(60 * difficulty))) - unit_price = round(rng.uniform(0.01, min(1.0, 1.0 * difficulty)), 2) - - # Ensure initial amount is sufficient and result is integer - total_cost = quantity * unit_price - remaining = rng.randint(1, int(100 * difficulty)) - initial_amount = total_cost + remaining - - result = generate_from_variables(name, currency, initial_amount, quantity, - item, store_type, unit_price) - - return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } - } - -def original_example() -> Dict[str, Any]: - return generate_from_variables("David", "$", 12.48, 16, "bolt", "hardware", 0.03) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generators.py b/reasoning_gym/arithmetic/gsm_symbolic/generators.py new file mode 100644 index 00000000..2b00e426 --- /dev/null +++ b/reasoning_gym/arithmetic/gsm_symbolic/generators.py @@ -0,0 +1,6769 @@ +from random import Random +from typing import Dict, Any +import math +from fractions import Fraction + +def generate_0(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, food: str, peel_rate: int, batch_size: int, + time_per_batch: int, total_amount: int) -> Dict[str, Any]: + + peel_time = total_amount // peel_rate + num_batches = total_amount // batch_size + cook_time = num_batches * time_per_batch + total_time = peel_time + cook_time + + question = f"{name} can peel {peel_rate} {food}s a minute and saute {batch_size} {food}s in {time_per_batch} minutes. How long will it take her to peel and saute {total_amount} {food}s?" + + answer_cot = f"First find how long it takes {name} to peel the {food}: {total_amount} {food} / {peel_rate} {food}/minute = {peel_time} minutes\n" \ + f"Then find how many batches of {food} she needs to cook: {total_amount} {food} / {batch_size} {food}/batch = {num_batches} batches\n" \ + f"Then multiply the number of batches by the time per batch to find the total cook time: {num_batches} batches * {time_per_batch} minutes/batch = {cook_time} minutes\n" \ + f"Then add the peeling time to find the total time {name} spends: {cook_time} minutes + {peel_time} minutes = {total_time} minutes\n" \ + f"#### {total_time}" + + return { + 'question': question, + 'answer': str(total_time), + 'answer_cot': answer_cot, + 'answer_value': total_time, + 'variables': { + 'name': name, + 'food': food, + 'peel_rate': peel_rate, + 'batch_size': batch_size, + 'time_per_batch': time_per_batch, + 'total_amount': total_amount, + 'peel_time': peel_time, + 'cook_time': cook_time + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ["Emily", "Sarah", "Emma", "Sophia", "Olivia", "Ava", "Isabella", "Mia"] + foods = ["shrimp", "onion", "carrot", "mushroom", "clam"] + + name = rng.choice(names_female) + food = rng.choice(foods) + + peel_rate = int(rng.randint(4, int(15 * difficulty))) + batch_size = int(rng.randrange(20, int(50 * difficulty), 5)) + time_per_batch = int(rng.randint(5, int(20 * difficulty))) + + # Ensure total is divisible by both peel_rate and batch_size + lcm = peel_rate * batch_size // math.gcd(peel_rate, batch_size) + num_lcm = rng.randint(1, int(4 * difficulty)) + total_amount = lcm * num_lcm + + result = generate_from_variables(name, food, peel_rate, batch_size, time_per_batch, total_amount) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_1(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, family: str, blocks: int, animals: int, + rings: int, total: int) -> Dict[str, Any]: + bouncy_balls = total - (blocks + animals + rings) + + question = f"When {name} watches her {family}, she gets out a variety of toys for him. The bag of building blocks has {blocks} blocks in it. The bin of stuffed animals has {animals} stuffed animals inside. The tower of stacking rings has {rings} multicolored rings on it. {name} recently bought a tube of bouncy balls, bringing her total number of toys for her {family} up to {total}. How many bouncy balls came in the tube?" + + answer_cot = f"Let T be the number of bouncy balls in the tube.\nAfter buying the tube of balls, {name} has {blocks} + {animals} + {rings} + T = {blocks + animals + rings} + T = {total} toys for her {family}.\nThus, T = {total} - {blocks + animals + rings} = {bouncy_balls} bouncy balls came in the tube.\n#### {bouncy_balls}" + + return { + 'question': question, + 'answer': str(bouncy_balls), + 'answer_cot': answer_cot, + 'answer_value': bouncy_balls, + 'variables': { + 'name': name, + 'family': family, + 'building_blocks': blocks, + 'stuffed_animals': animals, + 'stacking_rings': rings, + 'total_toys': total, + 'bouncy_balls': bouncy_balls + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ['Sophie', 'Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia'] + family_members = ['nephew', 'cousin', 'brother'] + + name = rng.choice(names_female) + family = rng.choice(family_members) + + blocks = int(rng.randint(70, int(75 * difficulty))) + animals = int(rng.randint(35, int(50 * difficulty))) + rings = int(rng.randint(20, int(35 * difficulty))) + + total = blocks + animals + rings + int(rng.randint(20, int(100 * difficulty))) + + result = generate_from_variables(name, family, blocks, animals, rings, total) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_2(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(teacher: str, total: int, p1: int, p2: int, + group1: str, group2: str, group3: str, + event: str) -> Dict[str, Any]: + group1_count = int(total * p1 / 100) + remaining = total - group1_count + group23_count = int(remaining * p2 / 100) + total_leaving = group1_count + group23_count + + question = f"In {teacher}'s class of {total} students, {p1}% of the class are {group1}. Out of the remaining class, {p2}% of the students are {group2} or part of {group3}. These 3 groups of students will need to leave early today to travel to an away {event}. How many students are leaving early?" + + answer_cot = f"{p1}% of the {total} student class are {group1} so that's {p1/100}*{total} = {group1_count} students\n" \ + f"There are {total} students and {group1_count} are {group1} so that leaves {total}-{group1_count} = {remaining} students\n" \ + f"{p2}% of the remaining {remaining} students are part of {group3} or {group2} so that's {p2/100}*{remaining} = {group23_count} students\n" \ + f"{group1_count} students are {group1} and {group23_count} are part of {group3}/{group2} so {group1_count}+{group23_count} = {total_leaving} students will be leaving early\n" \ + f"#### {total_leaving}" + + return { + 'question': question, + 'answer': str(total_leaving), + 'answer_cot': answer_cot, + 'answer_value': total_leaving, + 'variables': { + 'teacher': teacher, + 'total_students': total, + 'percent_group1': p1, + 'percent_group23': p2, + 'group1': group1, + 'group2': group2, + 'group3': group3, + 'event': event, + 'group1_count': group1_count, + 'group23_count': group23_count + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + teachers = ['Ms. Johnson', 'Mr. Smith', 'Dr. Lee', 'Mrs. Garcia'] + sports = ['soccer players', 'basketball players', 'volleyball players', 'swimmers'] + activities = ['dancers', 'choir members', 'debate team members', 'robotics club members'] + events = ['competition', 'tournament', 'performance', 'meet'] + + teacher = rng.choice(teachers) + group1 = rng.choice(sports) + group2, group3 = rng.sample(activities, 2) + event = rng.choice(events) + + total = int(rng.randint(20, int(150 * difficulty))) + p1 = int(rng.randint(10, min(50, int(100 * difficulty)))) + p2 = int(rng.randint(15, min(45, int(100 * difficulty)))) + + # Ensure conditions are met + while not (p1 < 100 and p2 < 100 and + (total * p1) % 100 == 0 and + ((total - total * p1 / 100) * p2) % 100 == 0): + total = int(rng.randint(20, int(150 * difficulty))) + p1 = int(rng.randint(10, min(50, int(100 * difficulty)))) + p2 = int(rng.randint(15, min(45, int(100 * difficulty)))) + + result = generate_from_variables(teacher, total, p1, p2, group1, group2, group3, event) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_3(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, initial_pals: int, lost_pals: int, + letters_per_week: int, pages_per_letter: int, + minutes_per_page: int) -> Dict[str, Any]: + current_pals = initial_pals - lost_pals + letters_received = current_pals * letters_per_week + pages_to_write = letters_received * pages_per_letter + total_minutes = pages_to_write * minutes_per_page + hours = total_minutes // 60 + + question = f"{name} was a pen pal with {initial_pals} people. He stopped being penpals with {lost_pals} of them. They each send {letters_per_week} letters a week that are {pages_per_letter} pages long. He responds in kind. He can write a page every {minutes_per_page} minutes. How many hours does he spend writing a week?" + + answer_cot = f"{name} is penpals with {initial_pals}-{lost_pals}={current_pals} people\n" \ + f"Thus he gets {current_pals}*{letters_per_week}={letters_received} letters a week\n" \ + f"So he writes {letters_received}*{pages_per_letter}={pages_to_write} pages a week\n" \ + f"So he writes for {pages_to_write}*{minutes_per_page}={total_minutes} minutes a week\n" \ + f"So he writes {total_minutes}/60={hours} hours a week\n#### {hours}" + + return { + 'question': question, + 'answer': str(hours), + 'answer_cot': answer_cot, + 'answer_value': hours, + 'variables': { + 'name': name, + 'initial_penpals': initial_pals, + 'lost_penpals': lost_pals, + 'current_penpals': current_pals, + 'letters_per_week': letters_per_week, + 'pages_per_letter': pages_per_letter, + 'minutes_per_page': minutes_per_page, + 'total_minutes': total_minutes + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Mike", "John", "David", "James", "Robert", "William", "Richard"] + name = rng.choice(names) + + initial_pals = int(rng.randint(5, int(15 * difficulty))) + lost_pals = int(rng.randint(1, initial_pals - 1)) + letters_per_week = int(rng.randint(2, int(5 * difficulty))) + pages_per_letter = int(rng.randint(5, int(12 * difficulty))) + minutes_per_page = int(rng.randint(4, int(15 * difficulty))) + + # Ensure result is in whole hours + while ((initial_pals - lost_pals) * letters_per_week * pages_per_letter * minutes_per_page) % 60 != 0: + minutes_per_page = int(rng.randint(4, int(15 * difficulty))) + + result = generate_from_variables(name, initial_pals, lost_pals, + letters_per_week, pages_per_letter, minutes_per_page) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_4(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, items: str, food: str, location: str, container: str, + num_jars: int, per_jar: int, per_pan: int) -> Dict[str, Any]: + total_items = num_jars * per_jar + num_pans = total_items // per_pan + + question = f"{name} has {num_jars} jars of {items} in her {location}. Each jar of {items} can decorate {per_jar} {food}s. {name} wants to bake enough {food}s to use up all of her {items}. If each {container} holds {per_pan} {food}s, how many {container}s worth of {food}s should she bake?" + + answer_cot = f"She has enough {items} for {num_jars} * {per_jar} = {total_items} {food}s.\nShe needs {total_items} / {per_pan} = {num_pans} {container}s to bake all of the {food}s.\n#### {num_pans}" + + return { + 'question': question, + 'answer': str(num_pans), + 'answer_cot': answer_cot, + 'answer_value': num_pans, + 'variables': { + 'name': name, + 'items': items, + 'food': food, + 'location': location, + 'container': container, + 'num_jars': num_jars, + 'per_jar': per_jar, + 'per_pan': per_pan, + 'total_items': total_items + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ['Mary', 'Sarah', 'Emma', 'Elizabeth', 'Catherine'] + items = ['sprinkles', 'frosting', 'icing', 'chocolate chips'] + foods = ['cupcake', 'cookie', 'brownie', 'muffin'] + locations = ['pantry', 'cupboard', 'kitchen cabinet', 'storage room'] + containers = ['pan', 'tray', 'baking sheet', 'rack'] + + name = rng.choice(names_female) + item = rng.choice(items) + food = rng.choice(foods) + location = rng.choice(locations) + container = rng.choice(containers) + + # Generate numbers ensuring divisibility + per_pan = int(rng.randint(6, int(24 * difficulty))) + per_jar = int(rng.randint(6, int(20 * difficulty))) + num_jars = int(rng.randint(3, int(15 * difficulty))) + + # Ensure total is divisible by per_pan + total = num_jars * per_jar + while total % per_pan != 0: + num_jars = int(rng.randint(3, int(15 * difficulty))) + total = num_jars * per_jar + + result = generate_from_variables(name, item, food, location, container, + num_jars, per_jar, per_pan) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_5(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name1: str, name2: str, city: str, celebrity_type: str, + vacation_type: str, n1: int, n2: int, s1: int, s2: int, + goal: int) -> Dict[str, Any]: + signatures_collected = s1 + s2 + signatures_needed = goal - signatures_collected + + question = f"{name1} and {name2} are sisters from {city} who love collecting signatures from {celebrity_type}. During their {vacation_type} from school, the sisters spend every afternoon collecting signatures. After {n1} weeks, {name1} and {name2} compare their autograph books, counting up the number of signatures each sister has collected. {name1} has {s1} signatures in her book, and {name2} has {s2}. The sisters have {n2} more weeks of {vacation_type}, and they decide they want to reach {goal} signatures between them by the end of the summer. How many signatures do the sisters need to collect to reach their goal?" + + answer_cot = f"{name1} and {name2} have already collected {s1} + {s2} signatures = {signatures_collected} signatures.\nSince their goal is {goal}, they need to collect {goal} - {signatures_collected} signatures. {goal} - {signatures_collected} = {signatures_needed} signatures\n#### {signatures_needed}" + + return { + 'question': question, + 'answer': str(signatures_needed), + 'answer_cot': answer_cot, + 'answer_value': signatures_needed, + 'variables': { + 'name1': name1, + 'name2': name2, + 'city': city, + 'celebrity_type': celebrity_type, + 'vacation_type': vacation_type, + 'weeks_passed': n1, + 'weeks_remaining': n2, + 'signatures1': s1, + 'signatures2': s2, + 'goal': goal, + 'signatures_collected': signatures_collected, + 'signatures_needed': signatures_needed + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ['Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia', 'Charlotte', 'Carol', 'Jennifer'] + cities = ['Los Angeles', 'New York', 'Chicago', 'Houston', 'Phoenix'] + celebrity_types = ['movie stars', 'athletes', 'musicians', 'politicians', 'authors'] + vacation_types = ['winter break', 'spring break', 'summer break', 'fall break'] + + name1, name2 = rng.sample(names_female, 2) + city = rng.choice(cities) + celebrity_type = rng.choice(celebrity_types) + vacation_type = rng.choice(vacation_types) + + n1 = int(rng.randint(3, int(8 * difficulty))) + n2 = int(rng.randint(2, int(5 * difficulty))) + s1 = int(rng.randint(15, int(40 * difficulty))) + s2 = int(rng.randint(30, int(60 * difficulty))) + goal = int(rng.randrange(90, int(150 * difficulty), 5)) + + # Ensure conditions are met + while s1 + s2 >= goal: + s1 = int(rng.randint(15, int(40 * difficulty))) + s2 = int(rng.randint(30, int(60 * difficulty))) + + result = generate_from_variables(name1, name2, city, celebrity_type, vacation_type, + n1, n2, s1, s2, goal) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_6(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(n_girls: int, place: str, multiplier: int) -> Dict[str, Any]: + n_boys = n_girls * multiplier + total_kids = n_girls + n_boys + + question = f"There are {n_girls} girls in the {place}. If there are {multiplier} times the number of boys in the {place}, how many kids are in the {place}?" + + answer_cot = f"There are {n_girls} girls x {multiplier} boys/girl = {n_boys} boys in the {place}.\nIn total there are {n_girls} girls + {n_boys} boys = {total_kids} kids in the {place}\n#### {total_kids}" + + return { + 'question': question, + 'answer': str(total_kids), + 'answer_cot': answer_cot, + 'answer_value': total_kids, + 'variables': { + 'n_girls': n_girls, + 'place': place, + 'multiplier': multiplier, + 'n_boys': n_boys, + 'total_kids': total_kids + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + places = ['park', 'yard', 'field', 'playground', 'garden'] + multipliers = [2, 3, 4] # twice, triple, quadruple + + place = rng.choice(places) + multiplier = rng.choice(multipliers) + + # Scale n_girls with difficulty but ensure result is valid + n_girls = int(rng.randint(5, int(50 * difficulty))) + while n_girls * (multiplier + 1) > 200: + n_girls = int(rng.randint(5, int(50 * difficulty))) + + result = generate_from_variables(n_girls, place, multiplier) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_7(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, plants_received: int, plants_per_ledge: int, + num_ledges: int, plants_to_give: int) -> Dict[str, Any]: + + initial_plants = plants_per_ledge * num_ledges + total_plants = initial_plants + plants_received + plants_given = num_ledges * plants_to_give + remaining_plants = total_plants - plants_given + + question = f"{name} is an avid gardener. Yesterday, she received {plants_received} new potted plants from her favorite plant nursery. She already has {plants_per_ledge} potted plants on each of the {num_ledges} window ledges of her large country home. Feeling generous, she has decided that she will give {plants_to_give} potted plant from each ledge to friends and family tomorrow. How many potted plants will {name} remain with?" + + answer_cot = f"Yesterday, before receiving the plants, {name} had {num_ledges}*{plants_per_ledge} = {initial_plants} potted plants\nAfter receiving an additional {plants_received} plants, she therefore had a total of {initial_plants} + {plants_received} = {total_plants} potted plants\nTomorrow, {name}'s plant giveaway will be {num_ledges}*{plants_to_give} = {plants_given} potted plants.\nShe will therefore remain with {total_plants} - {plants_given} = {remaining_plants} potted plants.\n#### {remaining_plants}" + + return { + 'question': question, + 'answer': str(remaining_plants), + 'answer_cot': answer_cot, + 'answer_value': remaining_plants, + 'variables': { + 'name': name, + 'plants_received': plants_received, + 'plants_per_ledge': plants_per_ledge, + 'num_ledges': num_ledges, + 'plants_to_give': plants_to_give, + 'initial_plants': initial_plants, + 'total_plants': total_plants, + 'plants_given': plants_given, + 'remaining_plants': remaining_plants + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Mary", "Emma", "Sophia", "Isabella", "Olivia", "Ava", "Mia"] + + name = rng.choice(names) + plants_received = int(rng.randint(20, int(50 * difficulty))) + plants_per_ledge = int(rng.randint(7, int(13 * difficulty))) + num_ledges = int(rng.randint(50, int(70 * difficulty))) + plants_to_give = int(rng.randint(3, int(8 * difficulty))) + + # Ensure condition: w * r + x - w*n > 0 + while (num_ledges * plants_per_ledge + plants_received - num_ledges * plants_to_give) <= 0: + plants_per_ledge = int(rng.randint(7, int(13 * difficulty))) + plants_to_give = int(rng.randint(3, int(8 * difficulty))) + + result = generate_from_variables(name, plants_received, plants_per_ledge, + num_ledges, plants_to_give) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_8(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, drink: str, sugar_ratio: int, water_ratio: int, + total_items: int) -> Dict[str, Any]: + total_ratio = sugar_ratio + water_ratio + sugar_amount = (sugar_ratio * total_items) // total_ratio + + question = f"{name} makes {drink} using teaspoons of sugar and cups of water in the ratio of {sugar_ratio}:{water_ratio}. If she used a total of {total_items} teaspoons of sugar and cups of water, calculate the number of teaspoonfuls of sugar she used." + + answer_cot = f"The total ratio representing the ingredients she used to make the {drink} is {sugar_ratio}+{water_ratio} = {total_ratio}\nSince the fraction representing the number of teaspoons she used is {sugar_ratio}/{total_ratio}, she used {sugar_ratio}/{total_ratio}*{total_items} = {sugar_amount}\n#### {sugar_amount}" + + return { + 'question': question, + 'answer': str(sugar_amount), + 'answer_cot': answer_cot, + 'answer_value': sugar_amount, + 'variables': { + 'name': name, + 'drink': drink, + 'sugar_ratio': sugar_ratio, + 'water_ratio': water_ratio, + 'total_items': total_items, + 'sugar_amount': sugar_amount + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ['Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia', 'Charlotte'] + drinks = ['coffee', 'tea'] + + name = rng.choice(names_female) + drink = rng.choice(drinks) + + sugar_ratio = int(rng.randint(25, int(201 * difficulty))) + water_ratio = int(rng.randint(5, int(101 * difficulty))) + + # Ensure total is divisible by ratio sum + total_ratio = sugar_ratio + water_ratio + num_multiples = rng.randint(1, int(10 * difficulty)) + total_items = total_ratio * num_multiples + + result = generate_from_variables(name, drink, sugar_ratio, water_ratio, total_items) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_9(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, num_bills: int, bill_value: int, num_items1: int, + price1: int, num_items2: int, price2: int, item1: str, + item2: str, currency: str) -> Dict[str, Any]: + + initial_amount = num_bills * bill_value + spent_items1 = num_items1 * price1 + spent_items2 = num_items2 * price2 + total_spent = spent_items1 + spent_items2 + remaining = initial_amount - total_spent + + question = f"{name} has {num_bills} {currency}{bill_value} bills. He buys {num_items1} {item1}s for {currency}{price1} each. He also buys {num_items2} packs of {item2}s for {currency}{price2} each. How much money does he have left?" + + answer_cot = f"{name} starts off with {num_bills} * {currency}{bill_value} = {currency}{initial_amount}.\n" \ + f"{name} spends {num_items1} {item1}s * {currency}{price1} = {currency}{spent_items1} on {item1}s.\n" \ + f"{name} spends {num_items2} packs of {item2}s * {currency}{price2} = {currency}{spent_items2} on {item2}s.\n" \ + f"Total {name} has spent {currency}{spent_items1} + {currency}{spent_items2} = {currency}{total_spent}.\n" \ + f"{name} has {currency}{initial_amount} - {currency}{total_spent} = {currency}{remaining} remaining.\n#### {remaining}" + + return { + 'question': question, + 'answer': str(remaining), + 'answer_cot': answer_cot, + 'answer_value': remaining, + 'variables': { + 'name': name, + 'num_bills': num_bills, + 'bill_value': bill_value, + 'num_items1': num_items1, + 'price1': price1, + 'num_items2': num_items2, + 'price2': price2, + 'item1': item1, + 'item2': item2, + 'currency': currency, + 'initial_amount': initial_amount, + 'total_spent': total_spent + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Craig", "John", "Michael", "David", "James", "Robert", "William"] + items1 = ["toy car", "action figure", "coloring book", "puzzle", "board game"] + items2 = ["sticker", "candy bar", "trading card", "pencil", "eraser"] + currencies = ["$", "€", "£"] + bills = [(5, 5), (10, 10), (20, 20), (50, 50), (100, 100)] + + name = rng.choice(names) + item1 = rng.choice(items1) + item2 = rng.choice(items2) + currency = rng.choice(currencies) + bill_value = rng.choice(bills)[1] + + num_bills = int(rng.randint(1, int(10 * difficulty))) + num_items1 = int(rng.randint(2, int(15 * difficulty))) + num_items2 = int(rng.randint(2, int(10 * difficulty))) + price1 = int(rng.randint(1, int(10 * difficulty))) + price2 = int(rng.randint(1, int(10 * difficulty))) + + # Ensure total cost doesn't exceed available money + while (num_items1 * price1 + num_items2 * price2) > (num_bills * bill_value): + num_items1 = int(rng.randint(2, int(15 * difficulty))) + num_items2 = int(rng.randint(2, int(10 * difficulty))) + + result = generate_from_variables(name, num_bills, bill_value, num_items1, price1, + num_items2, price2, item1, item2, currency) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_10(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name1: str, name2: str, age1: int, years: int, + relation_type: str, mult: int) -> Dict[str, Any]: + future_age = age1 * mult + current_age = future_age - years + + question = f"{name1} is {age1} years old. In {years} years his {relation_type} {name2} will be {mult} times as old as {name1} is now. How old is {name2} right now?" + + answer_cot = f"{years} years from now {name2} will be {age1}*{mult}={future_age}.\nRight now {name2} is {future_age}-{years}={current_age} years old.\n#### {current_age}" + + return { + 'question': question, + 'answer': str(current_age), + 'answer_cot': answer_cot, + 'answer_value': current_age, + 'variables': { + 'name1': name1, + 'name2': name2, + 'age1': age1, + 'years': years, + 'relation_type': relation_type, + 'mult': mult, + 'future_age': future_age, + 'current_age': current_age + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_male = ['James', 'John', 'Robert', 'Michael', 'William', 'David', 'Richard'] + names_female = ['Mary', 'Patricia', 'Jennifer', 'Linda', 'Elizabeth', 'Barbara', 'Susan'] + relation_types = ['sister', 'cousin'] + + name1 = rng.choice(names_male) + name2 = rng.choice(names_female) + relation_type = rng.choice(relation_types) + + age1 = int(rng.randint(8, int(25 * difficulty))) + years = int(rng.randint(2, int(10 * difficulty))) + mult = int(rng.randint(2, int(5 * difficulty))) + + # Ensure conditions are met + while age1 * mult - years <= 0: + age1 = int(rng.randint(8, int(25 * difficulty))) + years = int(rng.randint(2, int(10 * difficulty))) + mult = int(rng.randint(2, int(5 * difficulty))) + + result = generate_from_variables(name1, name2, age1, years, relation_type, mult) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_11(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, food1: str, food2: str, mult: int, n: int, + m: int, k: int) -> Dict[str, Any]: + initial_food1 = n * mult # initial corn + initial_total = initial_food1 + n # initial total + bought_food1 = m - k # bought corn + bought_total = bought_food1 + m # total bought + final_total = initial_total + bought_total # final total + + question = f"At {name}'s house, there is {mult} times as much {food1} as {food2}. He has a total of {n} {food2} in his house. {name} bought {m} more {food2} at the store and {k} fewer {food1} than the number of {food2}. Find the combined total of the number of {food1} and {food2} {name} has in the house?" + + answer_cot = f"Before buying any {food1} and {food2}, {name} had {mult} times as many {food1} as {food2}, which is {n} {food2} * {mult} {food1}/{food2} = {initial_food1} {food1}\nThe total number of {food1} and {food2} that {name} had before is {initial_food1} {food1} + {n} {food2} = {initial_total} items\nWhen he bought {k} fewer {food1} than {food2}, he bought {m} {food1} - {k} {food1} = {bought_food1} {food1}\nIn total, he bought {bought_food1} {food1} + {m} {food2} = {bought_total} items\nAfter the purchases, {name} has {initial_total} items + {bought_total} items = {final_total} total {food1} and {food2} combined.\n#### {final_total}" + + return { + 'question': question, + 'answer': str(final_total), + 'answer_cot': answer_cot, + 'answer_value': final_total, + 'variables': { + 'name': name, + 'food1': food1, + 'food2': food2, + 'multiplier': mult, + 'initial_amount': n, + 'bought_amount': m, + 'difference': k, + 'initial_total': initial_total, + 'bought_total': bought_total, + 'final_total': final_total + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Allan", "John", "Michael", "David", "James", "Robert", "William"] + foods = ["corn", "apple", "banana", "orange", "pear", "grape", "fig", + "persimmon", "plum", "kiwi"] + multipliers = ["twice", "three times", "four times"] + + name = rng.choice(names) + food1, food2 = rng.sample(foods, 2) + mult = rng.randint(2, int(4 * difficulty)) + + n = int(rng.randint(20, int(100 * difficulty))) + m = int(rng.randint(30, int(100 * difficulty))) + k = int(rng.randint(10, min(m, int(50 * difficulty)))) + + result = generate_from_variables(name, food1, food2, mult, n, m, k) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_12(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, game1: str, game2: str, period: str, + time1: int, time2: int, num1: int, num2: int) -> Dict[str, Any]: + total_time1 = time1 * num1 + total_time2 = time2 * num2 + total_time = total_time1 + total_time2 + + question = f"It takes {name} {time1} minutes to finish a {game1} and {time2} minutes to finish a {game2}. Over the {period} she solved {num1} {game1}s and {num2} {game2}s. How much time did she spend playing these games?" + + answer_cot = f"It takes {time1} minutes to complete a {game1} and she completed {num1} for a total of {time1}*{num1} = {total_time1} minutes\n" \ + f"It takes {time2} minutes to complete a {game2} and she completed {num2} for a total of {time2}*{num2} = {total_time2} minutes\n" \ + f"She spent {total_time1} minutes on {game1}s and {total_time2} minutes on {game2}s for a total of {total_time1}+{total_time2} = {total_time} minutes\n" \ + f"#### {total_time}" + + return { + 'question': question, + 'answer': str(total_time), + 'answer_cot': answer_cot, + 'answer_value': total_time, + 'variables': { + 'name': name, + 'game1': game1, + 'game2': game2, + 'period': period, + 'time1': time1, + 'time2': time2, + 'num1': num1, + 'num2': num2, + 'total_time1': total_time1, + 'total_time2': total_time2 + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte"] + games = ["word puzzle", "jigsaw puzzle", "chess puzzle", "riddle", "brain teaser"] + periods = ["weekend", "vacation", "holiday", "day off", "free time"] + + name = rng.choice(names) + game1, game2 = rng.sample(games, 2) + period = rng.choice(periods) + + time1 = int(rng.randint(5, int(30 * difficulty))) + time2 = int(rng.randint(3, int(20 * difficulty))) + while time2 >= time1: # ensure time1 > time2 + time1 = int(rng.randint(5, int(30 * difficulty))) + time2 = int(rng.randint(3, int(20 * difficulty))) + + num1 = int(rng.randint(2, int(10 * difficulty))) + num2 = int(rng.randint(4, int(15 * difficulty))) + + result = generate_from_variables(name, game1, game2, period, time1, time2, num1, num2) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_13(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(park_name: str, unit: str, length1: int, length2: int, + speed1: int, speed2: int) -> Dict[str, Any]: + time1 = length1 // speed1 + time2 = length2 // speed2 + time_diff = time1 - time2 + + question = f"The biggest waterslide at {park_name} is {length1} {unit} long, and people slide down at {speed1} {unit}/minute. The second biggest waterslide is {length2} {unit} long, but steeper, so people slide down at {speed2} {unit}/minute. How much longer does it take to ride the biggest slide compared to the second biggest slide?" + + answer_cot = f"First find the ride length of the biggest slide: {length1} {unit} / {speed1} {unit}/minute = {time1} minutes\nThen find the ride length of the second biggest slide: {length2} {unit} / {speed2} {unit}/minute = {time2} minutes\nThen subtract the ride length of the second longest slide from the longest slide to find the difference: {time1} minutes - {time2} minutes = {time_diff} minutes\n#### {time_diff}" + + return { + 'question': question, + 'answer': str(time_diff), + 'answer_cot': answer_cot, + 'answer_value': time_diff, + 'variables': { + 'park_name': park_name, + 'unit': unit, + 'length1': length1, + 'length2': length2, + 'speed1': speed1, + 'speed2': speed2, + 'time1': time1, + 'time2': time2 + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + parks = ["Splash World", "Aqua Adventure", "Water Wonderland", "Neptunes Kingdom"] + units = ['yards', 'meters'] + + park_name = rng.choice(parks) + unit = rng.choice(units) + + length1 = int(rng.randrange(250, int(401 * difficulty), 10)) + length2 = int(rng.randrange(200, int(301 * difficulty), 10)) + speed1 = int(rng.randrange(40, int(81 * difficulty), 5)) + speed2 = int(rng.randrange(60, int(101 * difficulty), 5)) + + # Ensure conditions are met + while (length1 <= length2 or speed2 <= speed1 or + length1 % speed1 != 0 or length2 % speed2 != 0 or + (length1 // speed1) <= (length2 // speed2)): + length1 = int(rng.randrange(250, int(401 * difficulty), 10)) + length2 = int(rng.randrange(200, int(301 * difficulty), 10)) + speed1 = int(rng.randrange(40, int(81 * difficulty), 5)) + speed2 = int(rng.randrange(60, int(101 * difficulty), 5)) + + result = generate_from_variables(park_name, unit, length1, length2, speed1, speed2) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_14(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, day1: str, day2: str, day3: str, + time1: int, time2: int, mult: int) -> Dict[str, Any]: + combined_time = time1 + time2 + target_time = combined_time * mult + + question = f"On {day3}, {name} wants to exercise for {mult} the amount of time he did on {day2} and {day1} combined. On {day1} he exercised for {time1} minutes. On {day2} he exercised for {time2} minutes. How many minutes does he have to exercise on {day3} to reach his goal?" + + answer_cot = f"On {day1} and {day2} he exercised a total of {combined_time} minutes because {time1} + {time2} = {combined_time}\nOn {day3} he has to exercise for {target_time} minutes because {combined_time} x {mult} = {target_time}\n#### {target_time}" + + return { + 'question': question, + 'answer': str(target_time), + 'answer_cot': answer_cot, + 'answer_value': target_time, + 'variables': { + 'name': name, + 'day1': day1, + 'day2': day2, + 'day3': day3, + 'time1': time1, + 'time2': time2, + 'multiplier': mult, + 'combined_time': combined_time, + 'target_time': target_time + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Peter", "John", "Michael", "David", "James", "Robert", "William"] + weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"] + multipliers = [2, 3, 4] + + name = rng.choice(names) + day1, day2, day3 = rng.sample(weekdays, 3) + mult = rng.choice(multipliers) + + time1 = int(rng.randint(10, int(60 * difficulty))) + time2 = int(rng.randint(10, int(60 * difficulty))) + + # Check conditions + while (time1 + time2) <= 0 or ((time1 + time2) * mult / 60) >= 14: + time1 = int(rng.randint(10, int(60 * difficulty))) + time2 = int(rng.randint(10, int(60 * difficulty))) + + result = generate_from_variables(name, day1, day2, day3, time1, time2, mult) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_15(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, sport: str, item1: str, item2: str, + item3: str, item4: str, currency: str, price1: int, + price2: int, price3: int, price4: int, discount: int) -> Dict[str, Any]: + + shorts_price = price1 + price2 + shoes_price = price3 // 2 + socks_price = price4 - discount + total = price1 + shorts_price + shoes_price + socks_price + + question = f"{name} qualified for a spot on the {sport} team, so she went shopping for some athletic gear. She bought a {item1} for {currency}{price1}, a pair of {sport} {item2} for {currency}{price2} more than the {item1} cost, and a pair of {item3} that were originally {currency}{price3} but were on sale for half price. She had a coupon for {currency}{discount} off the package of {currency}{price4} athletic {item4} that she also bought. How much did she spend on athletic gear?" + + answer_cot = f"The {item2} were {currency}{price2} more than the {item1}, so they cost {currency}{price2} + {currency}{price1} = {currency}{shorts_price}.\nHer {item3} were half the original {currency}{price3} price, so they cost {currency}{price3} / 2 = ${shoes_price}.\nWith her coupon, the {item4} were {currency}{price4} - {currency}{discount} = {currency}{socks_price}.\nThe {item1}, {item2}, {item3}, and {item4} together cost {currency}{price1} + {currency}{shorts_price} + {currency}{shoes_price} + {currency}{socks_price} = {currency}{total}.\n#### {total}" + + return { + 'question': question, + 'answer': str(total), + 'answer_cot': answer_cot, + 'answer_value': total, + 'variables': { + 'name': name, + 'sport': sport, + 'item1': item1, + 'item2': item2, + 'item3': item3, + 'item4': item4, + 'currency': currency, + 'price1': price1, + 'price2': price2, + 'price3': price3, + 'price4': price4, + 'discount': discount + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte", "Amelia"] + sports = ["swimming", "cycling", "basketball", "soccer", "volleyball"] + items1 = ["t-shirt", "jersey", "sports bra"] + items2 = ["shorts", "leggings", "sweatpants"] + items3 = ["sneakers", "cleats", "athletic shoes"] + items4 = ["socks", "headbands", "wristbands"] + currencies = ["$", "€", "£"] + + name = rng.choice(names_female) + sport = rng.choice(sports) + item1 = rng.choice(items1) + item2 = rng.choice(items2) + item3 = rng.choice(items3) + item4 = rng.choice(items4) + currency = rng.choice(currencies) + + price1 = int(rng.randint(8, int(25 * difficulty))) + price2 = int(rng.randint(3, int(15 * difficulty))) + price4 = int(rng.randint(5, int(15 * difficulty))) + discount = int(rng.randint(1, min(5, price4))) + + # Ensure price3 is even for clean division by 2 + price3 = int(rng.randint(30, int(80 * difficulty)) // 2 * 2) + + result = generate_from_variables(name, sport, item1, item2, item3, item4, currency, + price1, price2, price3, price4, discount) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_16(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name1: str, name2: str, name3: str, platform: str, + mult1: int, mult2: int, n: int) -> Dict[str, Any]: + base_friends = n // mult1 # Dorothy's friends + charlie_friends = n # Charlie's friends + james_friends = base_friends * mult2 # James's friends + + question = f"{name1} has {mult1} times as many {platform} friends as {name2}. {name3} has {mult2} times as many friends on {platform} as {name2}. If {name1} has {n} friends on {platform}, how many {platform} friends does {name3} have?" + + answer_cot = f"{name2} has {n} / {mult1} = {base_friends} {platform} friends.\n{name3} has {mult2} * {base_friends} = {james_friends} {platform} friends.\n#### {james_friends}" + + return { + 'question': question, + 'answer': str(james_friends), + 'answer_cot': answer_cot, + 'answer_value': james_friends, + 'variables': { + 'name1': name1, + 'name2': name2, + 'name3': name3, + 'platform': platform, + 'mult1': mult1, + 'mult2': mult2, + 'base_friends': base_friends, + 'charlie_friends': charlie_friends, + 'james_friends': james_friends + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ['Charlie', 'Dorothy', 'James', 'Sarah', 'Michael', 'Emily', 'David'] + platforms = ['Instagram', 'Twitter', 'LinkedIn', 'TikTok', 'Snapchat'] + + name1, name2, name3 = rng.sample(names, 3) + platform = rng.choice(platforms) + + # Generate multipliers that will be different + mult1 = rng.randint(2, int(5 * difficulty)) + mult2 = rng.randint(2, int(5 * difficulty)) + while mult2 == mult1: + mult2 = rng.randint(2, int(5 * difficulty)) + + # Generate n that's divisible by mult1 + base = rng.randint(4, int(20 * difficulty)) + n = base * mult1 + + result = generate_from_variables(name1, name2, name3, platform, mult1, mult2, n) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_17(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(facility: str, total: int, item: str, frac: Fraction, + event: str, daily: int, period: int) -> Dict[str, Any]: + initial_occupied = int(total * frac) + initial_empty = total - initial_occupied + weekly_admitted = daily * 7 + total_admitted = weekly_admitted * period + final_empty = initial_empty - total_admitted + + question = f"A {facility} has a capacity of {total} {item}s with {frac} occupied. Due to the {event}, {daily} patients are admitted into the {facility} each day. Calculate the total number of unoccupied {item}s in the {facility} after {period} weeks." + + answer_cot = f"If {frac} of the total capacity of the {facility} {item}s is occupied, it means {frac} * {total} = {initial_occupied} {item}s have patients using them.\nThe total number of {item}s in the {facility} without new admissions is {total} {item}s - {initial_occupied} {item}s = {initial_empty} {item}s.\nIf {daily} people are admitted each day, the total number of patients in the {facility} after one week is {daily} patients/day * 7 days/week = {weekly_admitted} patients.\nAfter {period} weeks, the total number of patients admitted into the {facility} is {weekly_admitted} patients/week * {period} weeks = {total_admitted} patients, who each use one {item}.\nIf there were {initial_empty} unoccupied {item}s in the {facility} before the new admissions, the total number is reduced to {initial_empty} {item}s - {total_admitted} {item}s = {final_empty} unoccupied {item}s.\n#### {final_empty}" + + return { + 'question': question, + 'answer': str(final_empty), + 'answer_cot': answer_cot, + 'answer_value': final_empty, + 'variables': { + 'facility': facility, + 'total_capacity': total, + 'item': item, + 'initial_fraction': frac, + 'event': event, + 'daily_patients': daily, + 'period_weeks': period, + 'initial_occupied': initial_occupied, + 'initial_empty': initial_empty, + 'total_admitted': total_admitted + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + facilities = ["hospital", "clinic", "medical center", "care facility"] + items = ["bed", "room", "ward"] + events = ["flu season", "natural disaster", "major accident", "pandemic"] + fractions = [Fraction(1,5), Fraction(1,4), Fraction(1,3), Fraction(1,2)] + + facility = rng.choice(facilities) + item = rng.choice(items) + event = rng.choice(events) + frac = rng.choice(fractions) + + total = int(rng.randrange(500, int(2000 * difficulty), 100)) + daily = int(rng.randrange(20, int(100 * difficulty), 5)) + period = int(rng.randint(2, int(5 * difficulty))) + + # Ensure conditions are met + while not (total * frac).is_integer() or total * frac + daily * period * 7 >= total: + total = int(rng.randrange(500, int(2000 * difficulty), 100)) + daily = int(rng.randrange(20, int(100 * difficulty), 5)) + period = int(rng.randint(2, int(5 * difficulty))) + + result = generate_from_variables(facility, total, item, frac, event, daily, period) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_18(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name1: str, name2: str, game: str, n1: int, n2: int, frac: float) -> Dict[str, Any]: + score2 = int(frac * n1 + n2) + total = n1 + score2 + + question = f"{name1} scored {n1} points in one game of {game}. {name2} scored {n2} more than {frac:.0%} as many as {name1}. How many points did {name1} and {name2} have in total?" + + answer_cot = f"{name1} = {n1} points\n{name2} = {frac} * {n1} + {n2} = {score2} points\n{n1} + {score2} = {total} points\nTogether, {name1} and {name2} scored {total} points.\n#### {total}" + + return { + 'question': question, + 'answer': str(total), + 'answer_cot': answer_cot, + 'answer_value': total, + 'variables': { + 'name1': name1, + 'name2': name2, + 'game': game, + 'score1': n1, + 'bonus': n2, + 'fraction': frac, + 'score2': score2, + 'total_score': total + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph", "Thomas", "Charles", + "Mary", "Patricia", "Jennifer", "Linda", "Elizabeth", "Barbara", "Susan", "Jessica", "Sarah", "Karen"] + games = ["bowling", "darts", "archery", "basketball", "tennis"] + fractions = [0.5] # Could add more fractions if needed + + name1, name2 = rng.sample(names, 2) + game = rng.choice(games) + frac = rng.choice(fractions) + + n1 = int(rng.randint(200, int(500 * difficulty))) + n2 = int(rng.randint(5, int(50 * difficulty))) + + # Ensure fraction calculation results in integer + while not float(frac * n1).is_integer(): + n1 = int(rng.randint(200, int(500 * difficulty))) + + result = generate_from_variables(name1, name2, game, n1, n2, frac) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_19(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, pan: str, initial_kernels: int, time_interval: int, + multiplier_2: int, multiplier_3: int) -> Dict[str, Any]: + second_interval = multiplier_2 * initial_kernels + third_interval = multiplier_3 * initial_kernels + fourth_interval = third_interval // 2 + residual = fourth_interval // 4 + total = initial_kernels + second_interval + third_interval + fourth_interval + residual + + question = f"{name} is popping popcorn for a snack. As the {pan} of kernels heats up, the kernels start popping faster. {initial_kernels} pop in the first {time_interval} seconds of cooking, then {multiplier_2} times that amount in the next {time_interval} seconds. The kernels increase to {multiplier_3} times the initial popping rate in the next {time_interval} seconds, but in the final {time_interval} seconds, the popping slows down to half the rate as the past {time_interval} seconds. After {name} takes the {pan} off the heat, a quarter of the number of kernels that popped in the final {time_interval} seconds of cooking also pop from the residual heat. How many pieces of popcorn does {name} have to eat?" + + answer_cot = f"In the second {time_interval} seconds of cooking, {multiplier_2} * {initial_kernels} = {second_interval} kernels pop.\nIn the third {time_interval} seconds, {multiplier_3} * {initial_kernels} = {third_interval} kernels pop.\nIn the final {time_interval} seconds, {third_interval} / 2 = {fourth_interval} kernels pop.\nAfter cooking, the residual heat makes {fourth_interval} / 4 = {residual} kernels pop.\nThus, {name} has {initial_kernels} + {second_interval} + {third_interval} + {fourth_interval} + {residual} = {total} pieces of popcorn to eat.\n#### {total}" + + return { + 'question': question, + 'answer': str(total), + 'answer_cot': answer_cot, + 'answer_value': total, + 'variables': { + 'name': name, + 'pan': pan, + 'initial_kernels': initial_kernels, + 'time_interval': time_interval, + 'multiplier_2': multiplier_2, + 'multiplier_3': multiplier_3, + 'second_interval': second_interval, + 'third_interval': third_interval, + 'fourth_interval': fourth_interval, + 'residual': residual, + 'total': total + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Garrett", "James", "Michael", "David", "John", "Robert", "William"] + pans = ["pan", "pot", "skillet"] + + name = rng.choice(names) + pan = rng.choice(pans) + + # Generate numbers ensuring divisibility conditions are met + initial_kernels = int(rng.randrange(10, int(101 * difficulty), 10)) + time_interval = int(rng.randrange(10, int(31 * difficulty), 2)) + multiplier_2 = rng.randint(2, int(5 * difficulty)) + + # Ensure multiplier_3 > multiplier_2 and results in clean division by 8 + while True: + multiplier_3 = rng.randint(multiplier_2 + 1, int(8 * difficulty)) + if (multiplier_3 * initial_kernels) % 8 == 0: + break + + result = generate_from_variables(name, pan, initial_kernels, time_interval, + multiplier_2, multiplier_3) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_20(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, obj: str, surface: str, + capacity: int, total: int, num_trays: int) -> Dict[str, Any]: + max_capacity = capacity * num_trays + leftover = total - max_capacity + + question = f"{name} places {obj}s on the {surface}. Each {surface} can hold {capacity} {obj}s. If he has {total} {obj}s and {num_trays} {surface}s, how many {obj}s won't he be able to place on the {surface}?" + + answer_cot = f"{name} will be able to place a total of {capacity} x {num_trays} = {max_capacity} {obj}s.\nTherefore, there are {total} - {max_capacity} = {leftover} {obj}s that he won't be able to place on the {surface}.\n#### {leftover}" + + return { + 'question': question, + 'answer': str(leftover), + 'answer_cot': answer_cot, + 'answer_value': leftover, + 'variables': { + 'name': name, + 'obj': obj, + 'surface': surface, + 'capacity_per_tray': capacity, + 'total_items': total, + 'num_trays': num_trays, + 'max_capacity': max_capacity, + 'leftover': leftover + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ['James', 'John', 'Robert', 'Michael', 'William', 'David', 'Richard'] + objects = ['olive', 'almond', 'cookie', 'cracker', 'banana'] + surfaces = ['plate', 'table', 'bowl', 'tray', 'basket'] + + name = rng.choice(names) + obj = rng.choice(objects) + surface = rng.choice(surfaces) + + capacity = int(rng.randint(20, int(51 * difficulty))) + num_trays = int(rng.randint(2, int(7 * difficulty))) + + # Ensure total is greater than max capacity + max_capacity = capacity * num_trays + total = max_capacity + int(rng.randint(1, int(20 * difficulty))) + + result = generate_from_variables(name, obj, surface, capacity, total, num_trays) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_21(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, length: int, unit_length: str, plant_width: int, + space: float, owned: int, currency: str, cost: int) -> Dict[str, Any]: + total_plants = int(length / space) + plants_to_buy = total_plants - owned + total_cost = plants_to_buy * cost + + question = f"{name} has a flower bed that is {length} {unit_length} long. {name} wants to fill her flower bed with plants. {name}'s flowers grow {plant_width} inches wide so she needs to leave {space} {unit_length} between every plant. {name} already owns {owned} flowers. Each flowering plant costs {currency}{cost} at the store, how much money will {name} spend at the store to fill up her flower bed?" + + answer_cot = f"{name}'s flower bed is {length} {unit_length} / {space} {unit_length} per plant = {total_plants} plants needed.\n{name} needs to buy {total_plants} plants - {owned} plants = {plants_to_buy} plants needed to purchase.\n{name} will spend {plants_to_buy} plants * {currency}{cost} = {currency}{total_cost}.\n#### {total_cost}" + + return { + 'question': question, + 'answer': str(total_cost), + 'answer_cot': answer_cot, + 'answer_value': total_cost, + 'variables': { + 'name': name, + 'bed_length': length, + 'unit': unit_length, + 'plant_width': plant_width, + 'plant_spacing': space, + 'owned_plants': owned, + 'currency': currency, + 'cost_per_plant': cost, + 'total_plants': total_plants, + 'plants_to_buy': plants_to_buy + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ['Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia', 'Charlotte'] + currencies = ['$', '£', '€'] + units = ['feet', 'meters'] + + name = rng.choice(names_female) + unit = rng.choice(units) + currency = rng.choice(currencies) + + length = int(rng.randint(110, int(220 * difficulty))) + plant_width = int(rng.randint(2, int(8 * difficulty))) + space = round(rng.uniform(1.25, 2.0) * difficulty, 2) + owned = int(rng.randint(10, int(30 * difficulty))) + cost = int(rng.randint(3, int(15 * difficulty))) + + # Ensure conditions are met + while not (plant_width * 3 < length and + plant_width < space and + length % space == 0 and + length / space > owned): + length = int(rng.randint(110, int(220 * difficulty))) + space = round(rng.uniform(1.25, 2.0) * difficulty, 2) + owned = int(rng.randint(10, int(30 * difficulty))) + + result = generate_from_variables(name, length, unit, plant_width, space, owned, + currency, cost) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_22(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, property_type: str, budget: int, price: int, + brokerage_fee: int, transfer_fee: int) -> Dict[str, Any]: + brokerage_amount = int(price * brokerage_fee / 100) + transfer_amount = int(price * transfer_fee / 100) + total_price = price + brokerage_amount + transfer_amount + difference = total_price - budget + + question = f"{name} is looking for a {property_type} that will not go beyond her ${budget:,} budget. She saw a property that has a selling price of ${price:,}. On top of that, the buyer has to pay a brokerage fee which is {brokerage_fee}% of the selling price, and also the transfer fee that is {transfer_fee}% of the selling price. How much more is the total price of the {property_type} than {name}'s budget?" + + answer_cot = f"The brokerage fee is ${price:,} x {brokerage_fee}/100 = ${brokerage_amount:,}.\nThe transfer fee is ${price:,} x {transfer_fee}/100 = ${transfer_amount:,}.\nThe total price of the {property_type} is ${price:,} + ${brokerage_amount:,} + ${transfer_amount:,} = ${total_price:,}.\nSo, it is ${total_price:,} - ${budget:,} = ${difference:,} more than {name}'s budget.\n#### {difference}" + + return { + 'question': question, + 'answer': f'{difference}', + 'answer_cot': answer_cot, + 'answer_value': difference, + 'variables': { + 'name': name, + 'property_type': property_type, + 'budget': budget, + 'price': price, + 'brokerage_fee': brokerage_fee, + 'transfer_fee': transfer_fee, + 'brokerage_amount': brokerage_amount, + 'transfer_amount': transfer_amount, + 'total_price': total_price + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ['Mrs. Smith', 'Ms. Johnson', 'Dr. Patel', 'Mrs. Lee'] + property_types = ['house', 'apartment', 'condo', 'townhouse'] + + name = rng.choice(names) + property_type = rng.choice(property_types) + + # Scale ranges by difficulty while maintaining integer results + budget = int(rng.randrange(300000, int(500000 * difficulty), 10000)) + price = int(rng.randrange(250000, budget, 10000)) + brokerage_fee = int(rng.randint(3, 8)) + transfer_fee = int(rng.randint(10, 15)) + + # Verify conditions + while True: + total_cost = price * (1 + brokerage_fee/100 + transfer_fee/100) + if (total_cost > budget + 1 and + price * brokerage_fee % 100 == 0 and + price * transfer_fee % 100 == 0): + break + price = int(rng.randrange(250000, budget, 10000)) + + result = generate_from_variables(name, property_type, budget, price, + brokerage_fee, transfer_fee) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_23(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, task: str, profession: str, hours: int, + work_type: str, rate: int, fee: int, currency: str) -> Dict[str, Any]: + lost_income = hours * rate + savings = lost_income - fee + + question = f"{name} is trying to decide whether to do {task} herself or hire an {profession}. If she does it herself, she'll be able to do {hours} fewer hours of {work_type} work, losing {currency}{rate}/hour in missed income. The {profession} charges {currency}{fee}. How much more money will she have if she hires the {profession}?" + + answer_cot = f"First find the total lost revenue if {name} does {task} herself: {currency}{rate}/hour * {hours} hours = {currency}{lost_income}\nThen subtract the {profession}'s charge to find how much money {name} saves: {currency}{lost_income} - {currency}{fee} = {currency}{savings}\n#### {savings}" + + return { + 'question': question, + 'answer': str(savings), + 'answer_cot': answer_cot, + 'answer_value': savings, + 'variables': { + 'name': name, + 'task': task, + 'profession': profession, + 'hours': hours, + 'work_type': work_type, + 'hourly_rate': rate, + 'fee': fee, + 'currency': currency, + 'lost_income': lost_income + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ['Emma', 'Sophia', 'Isabella', 'Olivia', 'Ava', 'Mia', 'Emily'] + tasks = ["her taxes", "her financial planning", "her business accounting"] + professions = ["accountant", "financial advisor", "tax consultant", "bookkeeper"] + work_types = ["freelance", "consulting", "part-time", "contract"] + currencies = ['$', '€', '£'] + + name = rng.choice(names_female) + task = rng.choice(tasks) + profession = rng.choice(professions) + work_type = rng.choice(work_types) + currency = rng.choice(currencies) + + hours = int(rng.randint(4, int(14 * difficulty))) + rate = int(rng.randint(20, int(100 * difficulty))) + fee = int(rng.randint(50, int(200 * difficulty))) + + # Ensure conditions are met + while hours * rate <= fee: + hours = int(rng.randint(4, int(14 * difficulty))) + rate = int(rng.randint(20, int(100 * difficulty))) + fee = int(rng.randint(50, int(200 * difficulty))) + + result = generate_from_variables(name, task, profession, hours, work_type, + rate, fee, currency) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_24(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(comet_name: str, name: str, relative: str, orbit_period: int, + relative_age: int, multiple: int) -> Dict[str, Any]: + second_viewing_age = relative_age * multiple + first_viewing_age = second_viewing_age - orbit_period + + question = f"Comet {comet_name} orbits the sun every {orbit_period} years. {name}'s {relative} saw the Comet when he was {relative_age} years old. {name} saw the comet a second time when he was {multiple} times the age his {relative} was when he saw the Comet. How old was {name} when he saw the Comet for the first time?" + + answer_cot = f"{name} saw the Comet for the second time when he was {relative_age} years * {multiple}= {second_viewing_age} years old.\nComet {comet_name} can be seen every {orbit_period} years, so {name} saw the comet for the first time when he was {second_viewing_age} years - {orbit_period} years = {first_viewing_age} years old.\n#### {first_viewing_age}" + + return { + 'question': question, + 'answer': str(first_viewing_age), + 'answer_cot': answer_cot, + 'answer_value': first_viewing_age, + 'variables': { + 'comet_name': comet_name, + 'name': name, + 'relative': relative, + 'orbit_period': orbit_period, + 'relative_age': relative_age, + 'multiple': multiple, + 'second_viewing_age': second_viewing_age, + 'first_viewing_age': first_viewing_age + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + comets = ['Halley', 'Hale-Bopp', 'Hyakutake', 'Encke'] + names = ['William', 'James', 'John', 'Robert', 'Michael', 'David'] + relatives = ['dad', 'father', 'uncle', 'grandfather'] + multiples = ['two', 'three', 'four'] + + comet_name = rng.choice(comets) + name = rng.choice(names) + relative = rng.choice(relatives) + multiple = rng.choice(multiples) + multiple_num = {'two': 2, 'three': 3, 'four': 4}[multiple] + + orbit_period = int(rng.randrange(50, int(101 * difficulty), 5)) + relative_age = int(rng.randint(20, int(51 * difficulty))) + + # Ensure conditions are met + while (multiple_num * relative_age >= 100 or + multiple_num * relative_age <= orbit_period or + (multiple_num * relative_age - orbit_period) % 1 != 0): + relative_age = int(rng.randint(20, int(51 * difficulty))) + + result = generate_from_variables(comet_name, name, relative, orbit_period, + relative_age, multiple_num) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_25(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(food: str, calories: int, size: int, servings: int, + total_target: int, consumed: int, unit: str) -> Dict[str, Any]: + + calories_left = total_target - consumed + serving_fraction = Fraction(calories_left, calories) + grams_per_serving = size // servings + grams_allowed = grams_per_serving * serving_fraction + + question = f"According to its nutritional info, a bag of {food} has {calories} calories per serving. If a {size} {unit} bag has {servings} servings, how many {unit} can you eat if your daily calorie target is {total_target} and you have already consumed {consumed} calories?" + + answer_cot = f"If the total calorie target is {total_target} and I have consumed {consumed} calories then I have {total_target}-{consumed} = {calories_left} calories left to eat\n" \ + f"If each serving of {food} has {calories} calories and I only have {calories_left} calories left to eat, then I can only eat {calories_left}/{calories} of a serving = {serving_fraction} of a serving\n" \ + f"We also know that a {size} {unit} bag of {food} has {servings} servings, hence each serving has {size} {unit}/{servings} = {grams_per_serving} {unit}\n" \ + f"If I can only eat {serving_fraction} of a serving, then I can eat only {grams_per_serving} * {serving_fraction} = {grams_allowed} {unit}\n" \ + f"#### {float(grams_allowed)}" + + return { + 'question': question, + 'answer': str(float(grams_allowed)), + 'answer_cot': answer_cot, + 'answer_value': float(grams_allowed), + 'variables': { + 'food': food, + 'calories': calories, + 'size': size, + 'servings': servings, + 'total_target': total_target, + 'consumed': consumed, + 'unit': unit, + 'calories_left': calories_left, + 'grams_per_serving': grams_per_serving, + 'serving_fraction': serving_fraction + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + foods = ["popcorn", "breads", "cookies"] + units = ["grams", "ounces", "oz"] + + food = rng.choice(foods) + unit = rng.choice(units) + + calories = int(rng.randrange(150, int(500 * difficulty), 25)) + size = int(rng.randrange(100, int(400 * difficulty), 25)) + servings = int(rng.randint(4, int(8 * difficulty))) + total_target = int(rng.randrange(1900, int(2500 * difficulty), 5)) + consumed = int(rng.randrange(600, int(1800 * difficulty), 25)) + + # Ensure conditions are met + while (consumed >= total_target or + not (size % servings == 0) or + not ((size//servings) * Fraction(total_target-consumed, calories)).denominator == 1): + calories = int(rng.randrange(150, int(500 * difficulty), 25)) + size = int(rng.randrange(100, int(400 * difficulty), 25)) + servings = int(rng.randint(4, int(8 * difficulty))) + total_target = int(rng.randrange(1900, int(2500 * difficulty), 5)) + consumed = int(rng.randrange(600, int(1800 * difficulty), 25)) + + result = generate_from_variables(food, calories, size, servings, total_target, consumed, unit) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_26(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(n: int, ball_type: str, color: str, frac_1: float, frac_2: float) -> Dict[str, Any]: + first_calc = int(n * frac_1) + final_calc = int(first_calc * frac_2) + + question = f"A juggler can juggle {n} balls. {frac_1:.0%} of the balls are {ball_type} balls, and {frac_2:.0%} of the {ball_type} balls are {color}. How many {color} {ball_type} balls are there?" + + answer_cot = f"{ball_type} balls:{n} * {frac_1}={first_calc}\n{color} {ball_type} balls:{first_calc}*{frac_2}={final_calc} balls\n#### {final_calc}" + + return { + 'question': question, + 'answer': str(final_calc), + 'answer_cot': answer_cot, + 'answer_value': final_calc, + 'variables': { + 'total_balls': n, + 'ball_type': ball_type, + 'color': color, + 'fraction_first': frac_1, + 'fraction_second': frac_2, + 'first_calculation': first_calc, + 'final_calculation': final_calc + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + ball_types = ["golf", "tennis"] + colors = ["blue", "red", "green", "yellow", "white"] + fractions = [0.5, 0.25, 0.75] + + ball_type = rng.choice(ball_types) + color = rng.choice(colors) + frac_1 = rng.choice(fractions) + frac_2 = rng.choice(fractions) + + # Generate n that ensures integer results + n = int(rng.randint(10, int(100 * difficulty))) + while not (n * frac_1).is_integer() or not (n * frac_1 * frac_2).is_integer(): + n = int(rng.randint(10, int(100 * difficulty))) + + result = generate_from_variables(n, ball_type, color, frac_1, frac_2) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_27(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, n: int, n_first: int, apartments_each: int, + percent_bigger: int, freq: int, rate: float, + currency: str) -> Dict[str, Any]: + + first_two = n_first * apartments_each + third_complex = int(first_two * percent_bigger/100) + total_apartments = first_two + third_complex + first_two + weekly_visits = total_apartments * freq + weekly_earnings = int(weekly_visits * rate) + + question = f"{name} collects garbage from {n} different apartment complexes. The first {n_first} have {apartments_each} apartments each and the last one is {percent_bigger}% bigger than the other {n_first} combined. {name} collects garbage {freq} times a week from each place and he gets paid {currency}{rate:.2f} per collection for each apartment. How much money does he make in a week?" + + answer_cot = f"The first {n_first} complexes have {first_two} apartments\n" \ + f"The third one has {first_two}*{percent_bigger/100}={third_complex} more apartments than those {n_first} combined\n" \ + f"So in total, it has {first_two}+{third_complex}={first_two + third_complex} apartments\n" \ + f"So he goes to {first_two + third_complex}+{first_two}={total_apartments} apartments each time\n" \ + f"That means he visits {total_apartments}*{freq}={weekly_visits} apartments every week\n" \ + f"So he makes {weekly_visits}*{currency}{rate:.2f}={currency}{weekly_earnings} every week\n" \ + f"#### {weekly_earnings}" + + return { + 'question': question, + 'answer': str(weekly_earnings), + 'answer_cot': answer_cot, + 'answer_value': weekly_earnings, + 'variables': { + 'name': name, + 'num_complexes': n, + 'first_complexes': n_first, + 'apartments_per_complex': apartments_each, + 'percent_increase': percent_bigger, + 'collections_per_week': freq, + 'rate_per_apartment': rate, + 'currency': currency, + 'total_apartments': total_apartments, + 'weekly_visits': weekly_visits + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ['John', 'Michael', 'David', 'James', 'Robert', 'William'] + currencies = ['$', '£', '€'] + + name = rng.choice(names) + currency = rng.choice(currencies) + + n = rng.randint(3, max(3, int(8 * difficulty))) + n_first = n - 1 + apartments = int(rng.randrange(100, int(500 * difficulty), 50)) + percent = rng.randrange(20, int(81 * difficulty), 5) + freq = rng.randint(2, max(2, int(6 * difficulty))) + rates = [0.25, 0.30, 0.35, 0.40, 0.45, 0.50] + rate = rng.choice(rates) + + # Ensure results are integers + while not ((n-1)*apartments*percent/100).is_integer(): + apartments = int(rng.randrange(100, int(500 * difficulty), 50)) + percent = rng.randrange(20, int(81 * difficulty), 5) + + result = generate_from_variables(name, n, n_first, apartments, percent, freq, rate, currency) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_28(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, item: str, price: float, percent: float, + usage: int, extra_item: str, extra_price: float, + currency: str, unit: str) -> Dict[str, Any]: + price_increase = price * percent / 100 + new_price = price + price_increase + weekly_usage = usage * 7 + coffee_cost = new_price * weekly_usage + total_cost = coffee_cost + extra_price + + question = f"{name} goes to the store to buy some {item}. The normal brand of {item} he buys costs {currency}{price} per {unit}. He had to buy a more expensive brand that costs {int(percent)}% more since his favorite brand was sold out. He decides to buy a week's worth of {item} and he uses {usage} {unit} of {item} per day. He also decided to buy himself a {extra_item} for {currency}{extra_price}. How much did everything cost?" + + answer_cot = f"The {item} he bought was {price}*{percent/100}={price_increase} more expensive per {unit} than what he normally buys\nSo it cost {price}+{price_increase}={new_price} per {unit}\nHe goes through {usage}*7={weekly_usage} {unit}s of {item} a week\nSo he paid {new_price}*{weekly_usage}={coffee_cost} on {item}\nThat means his total bill was {coffee_cost}+{extra_price}={total_cost}\n#### {int(total_cost)}" + + return { + 'question': question, + 'answer': str(int(total_cost)), + 'answer_cot': answer_cot, + 'answer_value': int(total_cost), + 'variables': { + 'name': name, + 'item': item, + 'base_price': price, + 'percent_increase': percent, + 'usage_per_day': usage, + 'extra_item': extra_item, + 'extra_price': extra_price, + 'currency': currency, + 'unit': unit, + 'weekly_usage': weekly_usage, + 'total_cost': total_cost + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_male = ['John', 'Michael', 'David', 'James', 'Robert', 'William', 'Richard', 'Thomas'] + items = ['tea', 'sugar', 'flour', 'rice'] + currencies_sym = ['$', '£', '€'] + units = ['kilogram', 'kg'] + extra_items = ['cookie', 'muffin', 'bagel'] + + name = rng.choice(names_male) + item = rng.choice(items) + currency = rng.choice(currencies_sym) + unit = rng.choice(units) + extra_item = rng.choice(extra_items) + + price = int(rng.randint(3, int(25 * difficulty))) + percent = int(rng.randint(2, int(10 * difficulty))) * 5 + usage = int(rng.randint(1, int(3 * difficulty))) + extra_price = int(rng.randint(1, int(5 * difficulty))) + + # Ensure price * percent / 100 is an integer + while (price * percent / 100) != int(price * percent / 100): + price = int(rng.randint(3, int(25 * difficulty))) + + result = generate_from_variables(name, item, price, percent, usage, + extra_item, extra_price, currency, unit) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_29(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name1: str, name2: str, n1: int, n2: int, + k1: int, k2: int) -> Dict[str, Any]: + total_puppies = n1 + n2 + spotted_puppies = k1 + k2 + percentage = int(100 * spotted_puppies / total_puppies) + + question = f"{name1}'s dog has {n1} puppies, {k1} of which have spots. {name2}'s dog has {n2} puppies, {k2} of which have spots. What percentage of all the puppies have spots?" + + answer_cot = f"First find the total number of puppies: {n1} puppies + {n2} puppies = {total_puppies} puppies\n" \ + f"Then find the total number of puppies with spots: {k1} puppies + {k2} puppies = {spotted_puppies} puppies\n" \ + f"Then divide the number of spotted puppies by the total number of puppies and multiply by 100% to find the percentage of puppies with spots: {spotted_puppies} puppies / {total_puppies} puppies * 100% = {percentage}%\n" \ + f"#### {percentage}" + + return { + 'question': question, + 'answer': str(percentage), + 'answer_cot': answer_cot, + 'answer_value': percentage, + 'variables': { + 'name1': name1, + 'name2': name2, + 'puppies1': n1, + 'puppies2': n2, + 'spotted1': k1, + 'spotted2': k2, + 'total_puppies': total_puppies, + 'total_spotted': spotted_puppies + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Jennifer", "Michael", "Christopher", "Jessica", "Matthew", "Ashley", + "Joshua", "Amanda", "Daniel", "David", "James", "Robert", "John", "Joseph"] + + name1, name2 = rng.sample(names, 2) + + # Scale ranges by difficulty but ensure values remain integers + n1 = int(rng.randrange(950, int(1050 * difficulty), 5)) + n2 = int(rng.randrange(400, int(650 * difficulty), 5)) + k1 = int(rng.randrange(170, int(290 * difficulty), 10)) + k2 = int(rng.randrange(120, int(170 * difficulty), 10)) + + # Ensure conditions are met + while (k1 + k2) >= (n1 + n2) or (n1 + n2) % (k1 + k2) != 0: + n1 = int(rng.randrange(950, int(1050 * difficulty), 5)) + n2 = int(rng.randrange(400, int(650 * difficulty), 5)) + k1 = int(rng.randrange(170, int(290 * difficulty), 10)) + k2 = int(rng.randrange(120, int(170 * difficulty), 10)) + + result = generate_from_variables(name1, name2, n1, n2, k1, k2) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_30(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(group: str, n: int, n_1: int, n_2: int, + hobby1: str, hobby2: str, hobby3: str, hobby4: str) -> Dict[str, Any]: + n_4 = 2 * n_2 # number that like hobby4 (music) + n_3 = n - (n_1 + n_2 + n_4) # number that like hobby3 (video games) + + question = f"A {group} of {n} students has various hobbies. {n_1} like to {hobby1}, {n_2} like to play {hobby2}, and the rest like to either {hobby3} or {hobby4}. How many like to {hobby3} if the number that like to {hobby4} is twice the number that prefer playing {hobby2}?" + + answer_cot = f"The number of students that like to {hobby4} is twice as many as the number who like {hobby2}, so 2 * {n_2} = {n_4}\nThe number that like to {hobby3} is {n} total students - {n_1} {hobby1} - {n_2} {hobby2} - {n_4} {hobby4} = {n_3}\n#### {n_3}" + + return { + 'question': question, + 'answer': str(n_3), + 'answer_cot': answer_cot, + 'answer_value': n_3, + 'variables': { + 'group_type': group, + 'total_students': n, + 'hobby1_count': n_1, + 'hobby2_count': n_2, + 'hobby3_count': n_3, + 'hobby4_count': n_4, + 'hobby1': hobby1, + 'hobby2': hobby2, + 'hobby3': hobby3, + 'hobby4': hobby4 + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + groups = ["group", "class"] + hobbies = ['read', 'paint', 'hike', 'dance', 'bake', 'play video games', 'play music'] + sports = ['basketball', 'soccer', 'tennis', 'baseball', 'volleyball'] + + group = rng.choice(groups) + hobby2 = rng.choice(sports) + hobby1, hobby3, hobby4 = rng.sample([h for h in hobbies if h not in [hobby2]], 3) + + # Generate numbers that satisfy conditions + n = int(rng.randint(20, int(200 * difficulty))) + n_2 = int(rng.randint(2, n//6)) # Keep n_2 small since we multiply by 2 + n_1 = int(rng.randint(2, n//3)) + + # Verify n_1 + n_2 + (2*n_2) < n + while n_1 + 3*n_2 >= n: + n = int(rng.randint(20, int(200 * difficulty))) + n_2 = int(rng.randint(2, n//6)) + n_1 = int(rng.randint(2, n//3)) + + result = generate_from_variables(group, n, n_1, n_2, hobby1, hobby2, hobby3, hobby4) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_31(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + + def generate_from_variables(name: str, fruit: str, total: int, n1: int, n2: int, n3: int, + sibling1: str, sibling2: str) -> Dict[str, Any]: + slice2 = n1 + n2 + slice3 = slice2 + n3 + total_eaten = n1 + slice2 + slice3 + + question = f"{name} sliced an {fruit} into {total} pieces. She ate {n1} slice, her {sibling1} ate {n2} more than her, and her {sibling2} ate {n3} more than her {sibling1}. How many slices of {fruit} did they all eat?" + + answer_cot = f"Her {sibling1} ate {n1} + {n2} = {slice2} slices.\nHer {sibling2} ate {slice2} + {n3} = {slice3} slices.\nThey ate a total of {n1} + {slice2} + {slice3} = {total_eaten} slices.\n#### {total_eaten}" + + return { + 'question': question, + 'answer': str(total_eaten), + 'answer_cot': answer_cot, + 'answer_value': total_eaten, + 'variables': { + 'name': name, + 'fruit': fruit, + 'total_slices': total, + 'first_person_slices': n1, + 'second_person_extra': n2, + 'third_person_extra': n3, + 'sibling1': sibling1, + 'sibling2': sibling2, + 'total_eaten': total_eaten + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte", "Doxa"] + fruits = ["orange", "pear", "peach", "mango", "kiwi", "apple"] + siblings = ["brother", "sister", "cousin", "friend"] + + name = rng.choice(names_female) + fruit = rng.choice(fruits) + sibling1, sibling2 = rng.sample(siblings, 2) + + total = int(rng.randint(6, int(33 * difficulty))) + n1 = int(rng.randint(3, int(15 * difficulty))) + n2 = int(rng.randint(5, int(13 * difficulty))) + n3 = int(rng.randint(3, int(14 * difficulty))) + + # Ensure conditions are met + while n1 + (n1 + n2) + (n1 + n2 + n3) > total: + n1 = int(rng.randint(3, int(15 * difficulty))) + n2 = int(rng.randint(5, int(13 * difficulty))) + n3 = int(rng.randint(3, int(14 * difficulty))) + + result = generate_from_variables(name, fruit, total, n1, n2, n3, sibling1, sibling2) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_32(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, periods: int, extra_classes: int, + mins_per_class: int, days: int, weekend_fraction: float) -> Dict[str, Any]: + total_classes = periods + extra_classes + daily_mins = total_classes * mins_per_class + weekly_mins = daily_mins * days + weekend_mins = int(weekly_mins * weekend_fraction) + total_mins = weekly_mins + 2 * weekend_mins + total_hours = total_mins // 60 + + question = f"There are {periods} periods in the day for a normal student but {name} has to take {extra_classes} extra classes. Each class is {mins_per_class} minutes long. He goes to class for {days} days a week. He then spends {weekend_fraction} of his weekly minutes each on Saturday and Sunday as extra learning time. How many hours a week does he spend learning?" + + answer_cot = f"He takes {periods}+{extra_classes}={total_classes} classes a day\n" \ + f"That means he spends {mins_per_class}*{total_classes}={daily_mins} minutes per day in class\n" \ + f"So he spends {daily_mins}*{days}={weekly_mins} minutes a week\n" \ + f"That means he spends {weekly_mins}*{weekend_fraction}={weekend_mins} minutes each on Saturday and Sunday\n" \ + f"So he spends {weekly_mins}+{weekend_mins}+{weekend_mins}={total_mins} minutes per week\n" \ + f"So he spends {total_mins}/60={total_hours} hours per week\n#### {total_hours}" + + return { + 'question': question, + 'answer': str(total_hours), + 'answer_cot': answer_cot, + 'answer_value': total_hours, + 'variables': { + 'name': name, + 'periods': periods, + 'extra_classes': extra_classes, + 'mins_per_class': mins_per_class, + 'days': days, + 'weekend_fraction': weekend_fraction, + 'total_classes': total_classes, + 'daily_mins': daily_mins, + 'weekly_mins': weekly_mins, + 'weekend_mins': weekend_mins, + 'total_mins': total_mins + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["John", "James", "William", "Michael", "David", "Richard", "Thomas"] + fractions = ["1/16", "1/8", "1/4", "1/2"] + + name = rng.choice(names) + periods = int(rng.randint(5, int(10 * difficulty))) + extra_classes = int(rng.randint(1, int(5 * difficulty))) + mins_per_class = int(rng.randrange(30, int(61 * difficulty), 5)) + days = int(rng.randint(4, int(7 * difficulty))) + weekend_fraction = float(eval(rng.choice(fractions))) + + # Ensure results are integers + while not (((periods + extra_classes) * mins_per_class * days * weekend_fraction).is_integer() and + (((periods + extra_classes) * mins_per_class * days + + 2 * (periods + extra_classes) * mins_per_class * days * weekend_fraction) / 60).is_integer()): + periods = int(rng.randint(5, int(10 * difficulty))) + extra_classes = int(rng.randint(1, int(5 * difficulty))) + mins_per_class = int(rng.randrange(30, int(61 * difficulty), 5)) + days = int(rng.randint(4, int(7 * difficulty))) + + result = generate_from_variables(name, periods, extra_classes, mins_per_class, + days, weekend_fraction) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_33(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name1: str, name2: str, mult: int, n: int) -> Dict[str, Any]: + n_mult = n * mult + daily_total = n + n_mult + weekly_total = daily_total * 7 + + question = f"{name1} operates the cash register exactly {mult} times as fast as her less-experienced colleague {name2}. Daily, {name2} processes {n} customers. What is the total weekly production for the two if they work all days of the week?" + + answer_cot = f"While {name2} is processing {n} orders in a day, {name1} processes {n} orders/day * {mult} = {n_mult} orders/day.\n" \ + f"In a day, they process {n_mult} orders/day + {n} orders/day = {daily_total} orders together.\n" \ + f"The total number of orders the two processes in a week is {daily_total} orders/day * 7 days/week = {weekly_total} orders\n" \ + f"#### {weekly_total}" + + return { + 'question': question, + 'answer': str(weekly_total), + 'answer_cot': answer_cot, + 'answer_value': weekly_total, + 'variables': { + 'name1': name1, + 'name2': name2, + 'multiplier': mult, + 'base_rate': n, + 'fast_rate': n_mult, + 'daily_total': daily_total, + 'weekly_total': weekly_total + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ["Julie", "Sarah", "Emma", "Sophia", "Olivia", "Isabella", "Mia", "Charlotte"] + multi_times = [2, 3, 4] + + name1, name2 = rng.sample(names_female, 2) + mult = rng.choice(multi_times) + n = int(rng.randint(30, int(100 * difficulty))) + + # Ensure conditions are met + while not (n * mult).is_integer() or not ((n + n * mult) * 7).is_integer(): + n = int(rng.randint(30, int(100 * difficulty))) + + result = generate_from_variables(name1, name2, mult, n) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_34(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(event: str, item: str, family: str, n: int, m: int, total: int) -> Dict[str, Any]: + twins_total = 2 * n + remaining = total - twins_total + friends_found = remaining - m + + question = f"The {event} team hid {total} {item}. The {family} twins each found {n} {item}. All the other {item} except {m} were found by their friends. How many {item} did the friends find?" + + answer_cot = f"The {family} twins found, {n} * 2 = {twins_total} {item}.\nThe number that remained hidden was {total} - {twins_total} = {remaining} {item}\nSince {m} {item} were not found, this means the friends found {remaining} - {m} = {friends_found} {item}\n#### {friends_found}" + + return { + 'question': question, + 'answer': str(friends_found), + 'answer_cot': answer_cot, + 'answer_value': friends_found, + 'variables': { + 'event': event, + 'item': item, + 'family': family, + 'items_per_twin': n, + 'unfound_items': m, + 'total_items': total, + 'twins_total': twins_total, + 'friends_found': friends_found + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + events = ["Halloween candy hunt", "Treasure hunt", "Scavenger hunt", "Charity fundraiser"] + items = ["eggs", "treats", "toys", "coins", "tokens", "balls", "candies", "goodies"] + families = ["Johnson", "Williams", "Mirzakhani", "Lopez", "Garcia", "Lee"] + + event = rng.choice(events) + item = rng.choice(items) + family = rng.choice(families) + + total = int(rng.randrange(50, int(201 * difficulty), 10)) + n = int(rng.randint(10, int(51 * difficulty))) + m = int(rng.randint(5, int(21 * difficulty))) + + # Ensure conditions are met + while 2 * n + m >= total: + n = int(rng.randint(10, int(51 * difficulty))) + m = int(rng.randint(5, int(21 * difficulty))) + + result = generate_from_variables(event, item, family, n, m, total) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_35(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(job: str, building: str, room: str, num_rooms: int, + num_days: int, time_per_room: int, hours_per_day: int) -> Dict[str, Any]: + + rooms_per_day = num_rooms // num_days + minutes_per_day = rooms_per_day * time_per_room + hours_cleaning = minutes_per_day / 60 + percentage = int(100 * hours_cleaning / hours_per_day) + + question = f"A {job} has to clean a {building} with {num_rooms} {room}s. They have {num_days} days to get it done. It takes them {time_per_room} minutes per {room}. If they work {hours_per_day} hour day, what percentage of their day, on average, is spent cleaning {room}s?" + + answer_cot = f"They have to clean {rooms_per_day} {room}s a day because {num_rooms} / {num_days} = {rooms_per_day}\n" \ + f"They spend {minutes_per_day} minutes cleaning per day because {rooms_per_day} x {time_per_room} = {minutes_per_day}\n" \ + f"They spend {hours_cleaning} hours a day because {minutes_per_day} / 60 = {hours_cleaning}\n" \ + f"They spend {hours_cleaning/hours_per_day} of their day cleaning {room}s because {hours_cleaning} / {hours_per_day} = {hours_cleaning/hours_per_day}\n" \ + f"They spend {percentage}% of their day cleaning {room}s because {hours_cleaning/hours_per_day} x 100 = {percentage}\n" \ + f"#### {percentage}" + + return { + 'question': question, + 'answer': str(percentage), + 'answer_cot': answer_cot, + 'answer_value': percentage, + 'variables': { + 'job': job, + 'building': building, + 'room': room, + 'num_rooms': num_rooms, + 'num_days': num_days, + 'time_per_room': time_per_room, + 'hours_per_day': hours_per_day, + 'rooms_per_day': rooms_per_day, + 'minutes_per_day': minutes_per_day, + 'hours_cleaning': hours_cleaning, + 'percentage': percentage + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + jobs = ["janitor", "cleaner", "maintenance worker"] + buildings = ["office building", "hospital", "university"] + rooms = ["room", "floor"] + + job = rng.choice(jobs) + building = rng.choice(buildings) + room = rng.choice(rooms) + + num_days = int(rng.randint(3, int(12 * difficulty))) + time_per_room = int(rng.randrange(10, int(46 * difficulty), 5)) + hours_per_day = int(rng.randint(6, int(17 * difficulty))) + + # Generate num_rooms ensuring divisibility by num_days + rooms_per_day = rng.randint(5, int(20 * difficulty)) + num_rooms = rooms_per_day * num_days + + # Ensure conditions are met + while (num_rooms/num_days) * time_per_room >= hours_per_day * 60: + rooms_per_day = rng.randint(5, int(20 * difficulty)) + num_rooms = rooms_per_day * num_days + + result = generate_from_variables(job, building, room, num_rooms, num_days, + time_per_room, hours_per_day) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_36(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(n: int, p1: int, r1: int, name: str, s1: str, s2: str, s3: str) -> Dict[str, Any]: + easy_questions = int(n * (p1/100)) + other_questions = int(n * (1-p1/100)) + easy_correct = int(easy_questions * (r1/100)) + other_correct = int(other_questions * 0.5) + total_correct = easy_correct + other_correct + + question = f"In a {n}-item quiz, {p1}% of the questions are {s1}, and the rest are equally divided as {s2} and {s3} questions. If {name} is sure to get {r1}% of the {s1} questions, and half of the {s2} and {s3} questions correctly, how many points is she sure to get?" + + answer_cot = f"The {s2} and {s3} questions comprises 100% - {p1}% = {100-p1}% of the quiz.\n" \ + f"There are {n} questions x {p1}/100 = {easy_questions} {s1} questions.\n" \ + f"There are a total of {n} questions x {100-p1}/100 = {other_questions} {s2} and {s3} questions.\n" \ + f"If {name} is sure to get {r1}% of the {s1} questions, then this means she is sure of her {easy_questions} questions x {r1}/100 = {easy_correct} points.\n" \ + f"From the {s2} and {s3} questions, she is sure to get half of it correctly so that is {other_questions} questions * 0.5 = {other_correct} points.\n" \ + f"Thus, she is sure of getting {easy_correct} points + {other_correct} points = {total_correct} points in her quiz.\n#### {total_correct}" + + return { + 'question': question, + 'answer': str(total_correct), + 'answer_cot': answer_cot, + 'answer_value': total_correct, + 'variables': { + 'total_questions': n, + 'easy_percent': p1, + 'easy_correct_percent': r1, + 'student_name': name, + 'easy_subject': s1, + 'medium_subject': s2, + 'hard_subject': s3, + 'easy_questions': easy_questions, + 'other_questions': other_questions, + 'easy_correct': easy_correct, + 'other_correct': other_correct + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + subjects = ["history", "geography", "biology", "chemistry", "physics", + "economics", "literature", "algebra", "geometry"] + names = ["Emma", "Sophia", "Olivia", "Ava", "Isabella", "Mia", "Charlotte"] + + # Generate valid numbers ensuring integer results + while True: + n = int(rng.randrange(10, int(151 * difficulty), 10)) + p1 = int(rng.randrange(5, int(71 * difficulty), 5)) + r1 = int(rng.randrange(5, int(101 * difficulty), 5)) + + # Check conditions + if (n * (p1/100)).is_integer() and \ + (n * (p1/100) * (r1/100)).is_integer() and \ + (n*(1-(p1/100))*0.5).is_integer(): + break + + name = rng.choice(names) + s1, s2, s3 = rng.sample(subjects, 3) + + result = generate_from_variables(n, p1, r1, name, s1, s2, s3) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_37(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(worker: str, base: int, unit: str, tool1: str, + tool2: str, tool3: str, mult1: int, mult2: int, + n: int, days: int) -> Dict[str, Any]: + iron_amount = base * mult1 + steel_amount = int(iron_amount * (1 + mult2/100)) + daily_total = steel_amount * n + total_amount = daily_total * days + + question = f"One {worker} can mine {base} {unit} of ore per day with {tool1}. He can mine {mult1} times as much with a {tool2} and {mult2}% more with a {tool3} than with a {tool2}. How many {unit} of ore can {n} {worker}s with {tool3}s mine in a month with {days} days?" + + answer_cot = f"First find how much ore a {worker} can mine with a {tool2}: {base} {unit}/day * {mult1} = {iron_amount} {unit}/day\n" \ + f"Then multiply that amount by {100+mult2}% to find how much a {worker} can mine with a {tool3}: {iron_amount} {unit}/day * {100+mult2}% = {steel_amount} {unit}/day\n" \ + f"Then multiply the amount one {worker} can mine in a day with a {tool3} by the number of {worker}s: {steel_amount} {unit}/day/{worker} * {n} {worker}s = {daily_total} {unit}/day\n" \ + f"Then multiply the daily amount of ore by the number of days to find the total ore mined in a month: {daily_total} {unit}/day * {days} days = {total_amount} {unit}/day\n" \ + f"#### {total_amount}" + + return { + 'question': question, + 'answer': str(total_amount), + 'answer_cot': answer_cot, + 'answer_value': total_amount, + 'variables': { + 'worker': worker, + 'base_amount': base, + 'unit': unit, + 'tool1': tool1, + 'tool2': tool2, + 'tool3': tool3, + 'mult1': mult1, + 'mult2': mult2, + 'num_workers': n, + 'num_days': days, + 'iron_amount': iron_amount, + 'steel_amount': steel_amount, + 'daily_total': daily_total + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + workers = ["miner", "goblin", "gnome", "troll"] + tools1 = ["bare hands", "basic shovel", "wooden pickaxe"] + units = ["pounds", "kgs"] + tools2 = ["nickel pickaxe", "bronze pickaxe", "silver pickaxe"] + tools3 = ["steel pickaxe", "diamond pickaxe", "mithril pickaxe", "titanium pickaxe"] + + worker = rng.choice(workers) + tool1 = rng.choice(tools1) + unit = rng.choice(units) + tool2 = rng.choice(tools2) + tool3 = rng.choice(tools3) + + base = int(rng.randint(5, int(20 * difficulty))) + mult1 = int(rng.randint(2, int(4 * difficulty))) + mult2 = int(rng.randrange(30, int(80 * difficulty), 5)) + n = int(rng.randint(20, int(50 * difficulty))) + days = int(rng.randint(28, 32)) + + # Verify conditions + while not (base * mult1 * (1 + mult2/100)).is_integer() or \ + int(base * mult1 * (1 + mult2/100) * n * days) >= 100000: + base = int(rng.randint(5, int(20 * difficulty))) + mult1 = int(rng.randint(2, int(4 * difficulty))) + mult2 = int(rng.randrange(30, int(80 * difficulty), 5)) + n = int(rng.randint(20, int(50 * difficulty))) + + result = generate_from_variables(worker, base, unit, tool1, tool2, tool3, + mult1, mult2, n, days) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_38(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, count: int, child_type: str, + item1: str, item2: str, item3: str, item4: str, item5: str, + n1: int, n2: int, n3: int, n4: int, n5: int) -> Dict[str, Any]: + + skeins_per_child = n1 + n2 + n3 + n4 + n5 + total_skeins = count * skeins_per_child + + question = f"{name} is knitting winter wear for her {count} grandchildren. They're {child_type}, so they're all the same size. She wants to make a {item1}, {item2}, {item3}, {item4}, and {item5} for each of them. It takes {n1} skeins of wool to make a {item1}, {n2} for a {item2}, {n3} for a {item3}, {n4} for a pair of {item4}, and {n5} for a pair of {item5}. How many skeins of wool will she need to buy?" + + answer_cot = f"A full outfit for each child will require {n1} skeins per {item1} + {n2} skeins per {item2} + {n3} skeins per {item3} + {n4} skeins per pair of {item4} + {n5} skeins per pair of {item5} = {skeins_per_child} skeins of wool.\nSo to knit outfits for all of her grandchildren, she will need {count} * {skeins_per_child} = {total_skeins} skeins of wool.\n#### {total_skeins}" + + return { + 'question': question, + 'answer': str(total_skeins), + 'answer_cot': answer_cot, + 'answer_value': total_skeins, + 'variables': { + 'name': name, + 'count': count, + 'child_type': child_type, + 'items': [item1, item2, item3, item4, item5], + 'skeins_per_item': [n1, n2, n3, n4, n5], + 'skeins_per_child': skeins_per_child, + 'total_skeins': total_skeins + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ["Martha", "Mary", "Elizabeth", "Susan", "Margaret", "Patricia"] + clothing_items = ["sweater", "shawl", "hat", "cardigan", "poncho", "vest", "beanie", "tunic"] + accessories = ["mittens", "booties", "socks", "leg warmers", "gloves"] + children_types = [("twins", 2), ("triplets", 3), ("quadruplets", 4), ("quintuplets", 5)] + + name = rng.choice(names_female) + child_type, count = rng.choice(children_types) + item1, item2, item3 = rng.sample(clothing_items, 3) + item4, item5 = rng.sample(accessories, 2) + + # Scale numbers based on difficulty + n1 = int(rng.randint(3, int(19 * difficulty))) + n2 = int(rng.randint(3, int(19 * difficulty))) + n3 = int(rng.randint(3, int(19 * difficulty))) + n4 = int(rng.randint(3, int(19 * difficulty))) + n5 = int(rng.randint(3, int(19 * difficulty))) + + result = generate_from_variables(name, count, child_type, + item1, item2, item3, item4, item5, + n1, n2, n3, n4, n5) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_39(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(total: int, grade: str, school_name: str, num_girls: int, + day: str, absent_girls: int, absent_boys: int) -> Dict[str, Any]: + num_boys = total - num_girls + remaining_boys = num_boys - absent_boys + + question = f"There are {total} {grade}-graders at {school_name} School. {num_girls} of them are girls. On {day}, {absent_girls} {grade}-grade girls and {absent_boys} {grade}-grade boys were absent. How many {grade} grade boys were at {school_name} School on {day}?" + + answer_cot = f"Of the {total} {grade} graders, {num_girls} are girls, so {total} students - {num_girls} girls = {num_boys} boys.\nOn {day} there were {num_boys} boys - {absent_boys} absent = {remaining_boys} boys.\n#### {remaining_boys}" + + return { + 'question': question, + 'answer': str(remaining_boys), + 'answer_cot': answer_cot, + 'answer_value': remaining_boys, + 'variables': { + 'total_students': total, + 'grade': grade, + 'school_name': school_name, + 'num_girls': num_girls, + 'num_boys': num_boys, + 'day': day, + 'absent_girls': absent_girls, + 'absent_boys': absent_boys, + 'remaining_boys': remaining_boys + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + school_names = ["Maple Grove", "Sunny Hill", "Oak Ridge", "Pine Valley"] + grades = ["first", "second", "third", "fourth", "fifth"] + days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"] + + school_name = rng.choice(school_names) + grade = rng.choice(grades) + day = rng.choice(days) + + total = int(rng.randint(50, int(200 * difficulty))) + num_girls = int(rng.randint(20, total - 1)) + num_boys = total - num_girls + + absent_girls = int(rng.randint(2, min(num_girls, int(10 * difficulty)))) + absent_boys = int(rng.randint(2, min(num_boys, int(10 * difficulty)))) + + result = generate_from_variables(total, grade, school_name, num_girls, + day, absent_girls, absent_boys) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_40(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(item: str, n1: int, c1: str, c2: str, c3: str, p: int) -> Dict[str, Any]: + more_cards = int(p/100 * n1) + n2 = n1 + more_cards + n3 = n1 + n2 + total = n3 + n3 + + question = f"In a set of {item}'s cards, there are {n1} {c1} cards, and {p}% more {c2} cards. {c3} cards are as many as the sum of {c1} and {c2} cards. How many cards of all mentioned colors are there?" + + answer_cot = f"There are {p}/100 * {n1} = {more_cards} more {c2} cards than {c1} cards.\n" \ + f"Which means there are {n1} + {more_cards} = {n2} {c2} cards.\n" \ + f"{c3} cards make up to {n1} + {n2} = {n3} cards.\n" \ + f"So in total, there are {n3} + {n3} = {total} cards of different colors.\n" \ + f"#### {total}" + + return { + 'question': question, + 'answer': str(total), + 'answer_cot': answer_cot, + 'answer_value': total, + 'variables': { + 'item': item, + 'n1': n1, + 'c1': c1, + 'c2': c2, + 'c3': c3, + 'p': p, + 'more_cards': more_cards, + 'total': total + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + items = ["magician", "artist", "chef", "scientist", "athlete"] + colors = ["red", "blue", "green", "yellow", "purple", "orange"] + + item = rng.choice(items) + c1, c2, c3 = rng.sample(colors, 3) + + n1 = int(rng.randint(20, int(81 * difficulty))) + + # Generate p ensuring division results in integer + while True: + p = int(rng.randint(20, min(90, int(100 * difficulty)))) + if (p/100 * n1).is_integer(): + break + + result = generate_from_variables(item, n1, c1, c2, c3, p) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_41(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, event: str, organization: str, fraction: str, + current: int, total: int, currency: str) -> Dict[str, Any]: + fraction = convert_fraction_word(fraction) + fraction_val = Fraction(fraction) + org_amount = int(total * fraction_val) + covered_amount = org_amount + current + missing_amount = total - covered_amount + + question = f"{name} is raising money for a {event}. He has applied for help from the {organization}, which has decided to cover {fraction} of the cost of the {event}. How much money is {name} missing if he has {currency}{current} and the {event} costs {currency}{total}?" + + answer_cot = f"{name}'s {organization} has decided to pay {total} * {fraction} = {currency}{org_amount} for his {event}.\nIn total {name} has covered {org_amount} + {current} = {currency}{covered_amount} for his {event}\nTherefore, {name} needs {total} - {covered_amount} = {currency}{missing_amount} more for the {event}.\n#### {missing_amount}" + + return { + 'question': question, + 'answer': str(missing_amount), + 'answer_cot': answer_cot, + 'answer_value': missing_amount, + 'variables': { + 'name': name, + 'event': event, + 'organization': organization, + 'fraction': fraction, + 'current_amount': current, + 'total_cost': total, + 'currency': currency, + 'org_contribution': org_amount, + 'covered_amount': covered_amount + } + } + + def convert_fraction_word(fraction_str: str) -> str: + """Convert word fractions to numeric form""" + + # Add fraction word mapping + FRACTION_WORDS = { + "half": "1/2", + "one-half": "1/2", + "quarter": "1/4", + } + return FRACTION_WORDS.get(fraction_str.lower(), fraction_str) + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["John", "Michael", "David", "James", "William", "Robert", "Joseph"] + events = ["field trip", "sports tournament", "conference", "music festival", "science fair"] + organizations = ["school", "community center", "local charity", "youth club", "parent association"] + currencies = ["$", "€", "£"] + fractions = ["half", "1/2", "one-half"] + + name = rng.choice(names) + event = rng.choice(events) + organization = rng.choice(organizations) + currency = rng.choice(currencies) + fraction = rng.choice(fractions) + fraction = convert_fraction_word(fraction) + + # Scale ranges by difficulty but ensure results are integers + current = int(rng.randrange(10, int(200 * difficulty), 5)) + total = int(rng.randrange(200, int(1000 * difficulty), 10)) + + # Ensure conditions are met + while current >= total or not float(total * Fraction(fraction)).is_integer(): + current = int(rng.randrange(10, int(200 * difficulty), 5)) + total = int(rng.randrange(200, int(1000 * difficulty), 10)) + + result = generate_from_variables(name, event, organization, fraction, current, total, currency) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_42(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(title: str, name: str, property_type: str, price: int, + fee1_name: str, fee1_percent: int, + fee2_name: str, fee2_percent: int, + loan: int) -> Dict[str, Any]: + + fee1_amount = price * fee1_percent // 100 + fee2_amount = price * fee2_percent // 100 + total_fees = fee1_amount + fee2_amount + loan + net_proceeds = price - total_fees + + question = f"{title} {name} sold his {property_type} for ${price}. He paid the {fee1_name} fees that amount to {fee1_percent}% of the selling price and also paid a {fee2_name} fee that is {fee2_percent}% of the selling price. If he also paid ${loan} for the remaining loan amount of the {property_type}, how much is {title} {name}'s net proceeds from selling the {property_type}?" + + answer_cot = f"{title} {name} paid ${price} x {fee1_percent}/100 = ${fee1_amount} for the {fee1_name} fees.\n" \ + f"He paid ${price} x {fee2_percent}/100 = ${fee2_amount} for the {fee2_name} fee.\n" \ + f"So, {title} {name} paid a total of ${fee1_amount} + ${fee2_amount} + ${loan} = ${total_fees} for the {fee1_name}, {fee2_name}, and loan fees.\n" \ + f"Hence, {title} {name}'s net proceeds is ${price} - ${total_fees} = ${net_proceeds}.\n#### {net_proceeds}" + + return { + 'question': question, + 'answer': str(net_proceeds), + 'answer_cot': answer_cot, + 'answer_value': net_proceeds, + 'variables': { + 'title': title, + 'name': name, + 'property_type': property_type, + 'price': price, + 'fee1_name': fee1_name, + 'fee1_percent': fee1_percent, + 'fee2_name': fee2_name, + 'fee2_percent': fee2_percent, + 'loan': loan, + 'fee1_amount': fee1_amount, + 'fee2_amount': fee2_amount, + 'total_fees': total_fees, + 'net_proceeds': net_proceeds + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + titles = ['Mr.', 'Prof.', 'Dr.'] + names = ['Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller', 'Davis', 'Rodriguez', 'Martinez'] + properties = ['house', 'apartment', 'condo', 'villa', 'cottage'] + fee1_names = ['transfer', 'registration', 'legal'] + fee2_names = ['brokerage', 'agent', 'realtor'] + + title = rng.choice(titles) + name = rng.choice(names) + property_type = rng.choice(properties) + fee1_name = rng.choice(fee1_names) + fee2_name = rng.choice(fee2_names) + + price = int(rng.randrange(200000, int(1000000 * difficulty), 10000)) + fee1_percent = rng.randint(1, int(5 * difficulty)) + fee2_percent = rng.randint(2, int(7 * difficulty)) + loan = int(rng.randrange(100000, int(700000 * difficulty), 10000)) + + # Ensure conditions are met + while price <= loan or price - (price * (fee1_percent + fee2_percent) / 100 + loan) <= 1: + price = int(rng.randrange(200000, int(1000000 * difficulty), 10000)) + loan = int(rng.randrange(100000, int(700000 * difficulty), 10000)) + + result = generate_from_variables(title, name, property_type, price, + fee1_name, fee1_percent, + fee2_name, fee2_percent, loan) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_43(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(person1: str, item: str, n: int, relation: str, k: int) -> Dict[str, Any]: + other_amount = n - k + total = n + other_amount + + question = f"A {person1} has {n} {item}s. His {relation} has {k} fewer {item}s than he has. How many {item}s do they have together?" + + answer_cot = f"His {relation} has {n} - {k} = {other_amount} {item}s.\nTogether, they have {n} + {other_amount} = {total} {item}s.\n#### {total}" + + return { + 'question': question, + 'answer': str(total), + 'answer_cot': answer_cot, + 'answer_value': total, + 'variables': { + 'person1': person1, + 'item': item, + 'first_amount': n, + 'relation': relation, + 'difference': k, + 'second_amount': other_amount, + 'total': total + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + people = ["student", "boy", "child", "kid"] + items = ["marble", "sticker", "toy", "book", "pencil"] + relations = ["sister", "brother", "friend", "cousin"] + + person1 = rng.choice(people) + item = rng.choice(items) + relation = rng.choice(relations) + + n = int(rng.randint(5, int(21 * difficulty))) + k = int(rng.randint(2, min(n-1, int(10 * difficulty)))) + + result = generate_from_variables(person1, item, n, relation, k) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_44(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(store: str, color1: str, color2: str, color3: str, + n1: int, n2: int, n3: int, p1: int, p2: int, p3: int, + currency: str) -> Dict[str, Any]: + total1 = n1 * p1 + total2 = n2 * p2 + total3 = n3 * p3 + grand_total = total1 + total2 + total3 + + question = f"There are currently {n1} {color1} balls, {n2} {color2} balls, and {n3} {color3} balls in the {store}. {color1} balls cost {currency}{p1}, {color2} balls cost {currency}{p2} and {color3} balls cost {currency}{p3}. How much will the {store} have received after all the balls are sold?" + + answer_cot = f"For the {color1} balls, {n1} balls * {currency}{p1}/ball = {currency}{total1}.\nFor the {color2} balls, {n2} balls * {currency}{p2}/ball = {currency}{total2}.\nFor the {color3} balls, {n3} balls * {currency}{p3}/ball = {currency}{total3}.\nFor all balls, {currency}{total1} + {currency}{total2} + {currency}{total3} = {currency}{grand_total}.\n#### {grand_total}" + + return { + 'question': question, + 'answer': str(grand_total), + 'answer_cot': answer_cot, + 'answer_value': grand_total, + 'variables': { + 'store': store, + 'colors': [color1, color2, color3], + 'quantities': [n1, n2, n3], + 'prices': [p1, p2, p3], + 'currency': currency, + 'subtotals': [total1, total2, total3], + 'total': grand_total + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + stores = ["store", "shop", "market", "warehouse"] + colors = ["red", "blue", "green", "yellow", "purple", "orange", "pink"] + currencies = ["$", "€", "£"] + + store = rng.choice(stores) + color1, color2, color3 = rng.sample(colors, 3) + currency = rng.choice(currencies) + + n1 = int(rng.randint(3, int(20 * difficulty))) + n2 = int(rng.randint(5, int(30 * difficulty))) + n3 = int(rng.randint(15, int(50 * difficulty))) + + p1 = int(rng.randint(5, int(15 * difficulty))) + p2 = int(rng.randint(3, int(10 * difficulty))) + p3 = int(rng.randint(2, int(8 * difficulty))) + + result = generate_from_variables(store, color1, color2, color3, n1, n2, n3, + p1, p2, p3, currency) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_45(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, event: str, food: str, obj: str, + package_husband: int, used_items: int, + total_remaining: int) -> Dict[str, Any]: + + total_items = total_remaining + used_items + package_size = total_items - package_husband + + question = f"{name} was preparing for a {event} at her house, where she intended to serve {food}. She noticed that she was out of plastic {obj}, so she bought a new package of {obj}. Later, her husband also bought a package of {package_husband} new {obj} and gave them to {name}. While {name} was making the {food}, she used {used_items} of the {obj} to sample her {food}. Later, when she went to set the table, she had a total of {total_remaining} {obj}. How many {obj} were in the package that {name} bought?" + + answer_cot = f"The total number of {obj} from {name} and her husband was {total_remaining}+{used_items}={total_items} {obj}.\nSince the husband bought a package of {package_husband} {obj}, then {name}'s package contained {total_items}-{package_husband}={package_size} {obj}.\n#### {package_size}" + + return { + 'question': question, + 'answer': str(package_size), + 'answer_cot': answer_cot, + 'answer_value': package_size, + 'variables': { + 'name': name, + 'event': event, + 'food': food, + 'obj': obj, + 'husband_package': package_husband, + 'used_items': used_items, + 'remaining': total_remaining, + 'total': total_items, + 'package_size': package_size + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ['Emma', 'Olivia', 'Sophia', 'Isabella', 'Ava', 'Mia', 'Charlotte'] + events = ['lunch party', 'birthday party', 'potluck party', 'baby shower', 'game night'] + foods = ['roast chicken', 'grilled salmon', 'beef stew', 'vegetable lasagna', + 'stuffed peppers', 'shrimp scampi', 'creme brulee'] + objects = ['spoons', 'forks', 'plates'] + + name = rng.choice(names) + event = rng.choice(events) + food = rng.choice(foods) + obj = rng.choice(objects) + + package_husband = int(rng.randint(5, int(20 * difficulty))) + used_items = int(rng.randint(3, int(10 * difficulty))) + + # Calculate total_remaining to satisfy conditions + package_size = int(rng.randint(10, int(30 * difficulty))) + total_items = package_size + package_husband + total_remaining = total_items - used_items + + result = generate_from_variables(name, event, food, obj, + package_husband, used_items, total_remaining) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_46(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(fruit1: str, fruit2: str, n1: int, n2: int, + frac1: float, frac2: float, spill: int, total: int) -> Dict[str, Any]: + n1_after_spill = n1 - spill + water_fruit1 = (n1_after_spill * frac1) + water_fruit2 = (n2 * frac2) + total_water = water_fruit1 + water_fruit2 + + question = f"I have {n1} liters of {fruit1} drink that are {frac1} water and I wish to add it to {n2} liters of {fruit2} drink that is {frac2} water. But as I pour it, I spill {spill} liter of the {fruit1} drink. How much water is in the remaining {total} liters?" + + answer_cot = f"There are {n2} x {frac2} = {water_fruit2} liters of water from the {n2} liters {fruit2} drink.\nAfter {spill} liter of {fruit1} drink was spilled, there were {n1} - {spill} = {n1_after_spill} liters of {fruit1} drink left.\nOut of the {n1_after_spill} liters, {n1_after_spill} x {frac1} = {water_fruit1} liters are water.\nThus, there are a total of {water_fruit2} + {water_fruit1} = {total_water} liters of water out of the {total} liters.\n#### {int(total_water)}" + + return { + 'question': question, + 'answer': str(int(total_water)), + 'answer_cot': answer_cot, + 'answer_value': int(total_water), + 'variables': { + 'fruit1': fruit1, + 'fruit2': fruit2, + 'initial_amount1': n1, + 'initial_amount2': n2, + 'water_fraction1': frac1, + 'water_fraction2': frac2, + 'spilled_amount': spill, + 'total_volume': total, + 'water_content1': water_fruit1, + 'water_content2': water_fruit2 + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + fruits = ["apple", "grape", "mango", "peach", "lemon"] + fractions = {"two-thirds": 2/3, "three-fifths": 3/5, "three-quarters": 3/4, + "one-half": 1/2, "four-fifths": 4/5} + + fruit1, fruit2 = rng.sample(fruits, 2) + frac1 = rng.choice(list(fractions.values())) + frac2 = rng.choice(list(fractions.values())) + + n1 = int(rng.randint(9, int(21 * difficulty))) + n2 = int(rng.randint(12, int(31 * difficulty))) + spill = int(rng.randint(3, min(7, n1))) + + # Ensure conditions are met + while not (n1 + n2 - spill > 0 and + (n2 * frac2).is_integer() and + ((n1 - spill) * frac1).is_integer()): + n1 = int(rng.randint(9, int(21 * difficulty))) + n2 = int(rng.randint(12, int(31 * difficulty))) + spill = int(rng.randint(3, min(7, n1))) + + total = n1 + n2 - spill + + result = generate_from_variables(fruit1, fruit2, n1, n2, frac1, frac2, spill, total) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_47(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, n1: int, c1: float, n2: int, c2: float, + c3: int, obj1: str, obj2: str, currency: str) -> Dict[str, Any]: + cost1 = n1 * c1 + cost2 = n2 * c2 + total_cost = cost1 + cost2 + c3 + + question = f"{name} went to buy some school supplies. He bought {n1} {obj1} which cost {currency}{c1} each, {n2} {obj2} which cost {currency}{c2} each, and a rim of bond paper which cost {currency}{c3}. How much did {name} spend on everything?" + + answer_cot = f"{name} spent {n1} x {currency}{c1} = {currency}{int(cost1)} for the {obj1}.\n" \ + f"He also spent {n2} x {currency}{c2} = {currency}{int(cost2)} for the {obj2}.\n" \ + f"Therefore, {name} spent a total of {currency}{int(cost1)} + {currency}{int(cost2)} + {currency}{c3} = {currency}{int(total_cost)} for the school supplies.\n" \ + f"#### {int(total_cost)}" + + return { + 'question': question, + 'answer': str(int(total_cost)), + 'answer_cot': answer_cot, + 'answer_value': int(total_cost), + 'variables': { + 'name': name, + 'items1_count': n1, + 'item1_cost': c1, + 'items2_count': n2, + 'item2_cost': c2, + 'paper_cost': c3, + 'item1': obj1, + 'item2': obj2, + 'currency': currency + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["John", "Michael", "David", "James", "William", "Robert", "Thomas"] + items = ["notebooks", "pencils", "erasers", "crayons", "colored pencils", "markers", "rulers", "folders"] + currencies = ["$", "€", "£"] + + name = rng.choice(names) + obj1, obj2 = rng.sample(items, 2) + currency = rng.choice(currencies) + + n1 = int(rng.randrange(6, int(25 * difficulty), 2)) + c1 = round(rng.uniform(2.25, 11.5 * difficulty) * 4) / 4 # Round to nearest 0.25 + n2 = int(rng.randrange(4, int(15 * difficulty), 2)) + c2 = round(rng.uniform(8.25, 19.5 * difficulty) * 4) / 4 + c3 = int(rng.randint(10, int(25 * difficulty))) + + # Ensure conditions are met + while not (n1 * c1).is_integer() or not (n2 * c2).is_integer(): + c1 = round(rng.uniform(2.25, 11.5 * difficulty) * 4) / 4 + c2 = round(rng.uniform(8.25, 19.5 * difficulty) * 4) / 4 + + result = generate_from_variables(name, n1, c1, n2, c2, c3, obj1, obj2, currency) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_48(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(item1: str, item2: str, shop: str, currency: str, + price1: int, price2: int, n1: int, n2: int) -> Dict[str, Any]: + total1 = n1 * price1 + total2 = n2 * price2 + diff = total1 - total2 + + question = f"A loaf of {item1} at the {shop} costs {currency}{price1}. {item2}s cost {currency}{price2} each. How much more do {n1} loaves of {item1} cost than {n2} {item2}s?" + + answer_cot = f"{n1} loaves of {item1} cost {n1} * {currency}{price1} = {currency}{total1}.\n" \ + f"{n2} {item2}s cost {n2} * {currency}{price2} = {currency}{total2}.\n" \ + f"The loaves of {item1} cost {currency}{total1} - {currency}{total2} = {currency}{diff} more than the {item2}s.\n" \ + f"#### {diff}" + + return { + 'question': question, + 'answer': str(diff), + 'answer_cot': answer_cot, + 'answer_value': diff, + 'variables': { + 'item1': item1, + 'item2': item2, + 'shop': shop, + 'currency': currency, + 'price1': price1, + 'price2': price2, + 'n1': n1, + 'n2': n2, + 'total1': total1, + 'total2': total2 + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + items1 = ["bread", "sourdough"] + items2 = ["bagel", "muffin", "croissant", "biscuit"] + shops = ["bakery", "cafe", "store", "market"] + currencies = ["$", "£", "€"] + + item1 = rng.choice(items1) + item2 = rng.choice(items2) + shop = rng.choice(shops) + currency = rng.choice(currencies) + + price1 = int(rng.randint(2, int(10 * difficulty))) + price2 = int(rng.randint(1, int(5 * difficulty))) + n1 = int(rng.randint(2, int(10 * difficulty))) + n2 = int(rng.randint(2, int(10 * difficulty))) + + # Ensure condition: n1 * price1 > n2 * price2 + while n1 * price1 <= n2 * price2: + n1 = int(rng.randint(2, int(10 * difficulty))) + n2 = int(rng.randint(2, int(10 * difficulty))) + + result = generate_from_variables(item1, item2, shop, currency, price1, price2, n1, n2) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_49(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, item1: str, item2: str, price1: int, price2: int, + total: float, n1: int, percent: int, currency: str) -> Dict[str, Any]: + change = total * percent / 100 + spent = total * (100 - percent) / 100 + cost_item1 = n1 * price1 / 100 + spent_item2 = spent - cost_item1 + n2 = int(spent_item2 / (price2 / 100)) + + question = f"The vending machines sell {item1} for {price1} cents and {item2} for {price2} cents. {name} spent {currency}{total} and got {n1} bags of {item1} and had {percent}% of his money left. How many {item2} did he buy?" + + answer_cot = f"{name} got {currency}{change} in change because {total} x {percent}/100 = {change}\n" \ + f"{name} spent {currency}{spent} because {total} - {change} = {spent}\n" \ + f"{name} spent {currency}{cost_item1} on {item1} because {n1} x {price1/100} = {cost_item1}\n" \ + f"{name} spent {spent_item2} on {item2} because {spent} - {cost_item1} = {spent_item2}\n" \ + f"{name} bought {n2} {item2} because {spent_item2} / {price2/100} = {n2}\n" \ + f"#### {n2}" + + return { + 'question': question, + 'answer': str(n2), + 'answer_cot': answer_cot, + 'answer_value': n2, + 'variables': { + 'name': name, + 'item1': item1, + 'item2': item2, + 'price1': price1, + 'price2': price2, + 'total_spent': total, + 'num_item1': n1, + 'num_item2': n2, + 'percent_change': percent, + 'currency': currency + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["George", "James", "John", "Robert", "Michael", "William"] + items = ['pretzels', 'popcorn', 'gum', 'cookies', 'crackers'] + currencies = ['$', '£', '€'] + + name = rng.choice(names) + item1, item2 = rng.sample(items, 2) + currency = rng.choice(currencies) + + price1 = int(rng.randrange(25, int(100 * difficulty), 5)) + price2 = int(rng.randrange(50, int(150 * difficulty), 5)) + while price2 <= price1: + price2 = int(rng.randrange(50, int(150 * difficulty), 5)) + + total = int(rng.randrange(500, int(1500 * difficulty), 100)) + n1 = int(rng.randint(1, int(10 * difficulty))) + percent = int(rng.randint(1, int(10 * difficulty))) + + # Validate conditions + while not (isinstance(total * percent / 100, int) and + isinstance((total * (100 - percent) / 100 - n1 * price1 / 100) / (price2 / 100), int) and + (total * (100 - percent) / 100 - n1 * price1 / 100) % (price2 / 100) == 0): + total = int(rng.randrange(500, int(1500 * difficulty), 100)) + n1 = int(rng.randint(1, int(10 * difficulty))) + percent = int(rng.randint(1, int(10 * difficulty))) + + result = generate_from_variables(name, item1, item2, price1, price2, total, n1, percent, currency) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_50(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, pieces1: int, pieces2: int) -> Dict[str, Any]: + half_pieces1 = pieces1 // 2 + total_pieces = half_pieces1 + pieces2 + + question = f"{name} finished half of a {pieces1} piece puzzle, and then started and finished another {pieces2} piece puzzle within an hour. How many puzzle pieces did {name} place during that hour?" + + answer_cot = f"{name} did 1/2 * {pieces1} pieces = {half_pieces1} pieces.\n{name} completed {half_pieces1} pieces + {pieces2} pieces = {total_pieces} pieces.\n#### {total_pieces}" + + return { + 'question': question, + 'answer': str(total_pieces), + 'answer_cot': answer_cot, + 'answer_value': total_pieces, + 'variables': { + 'name': name, + 'puzzle1_pieces': pieces1, + 'puzzle2_pieces': pieces2, + 'half_puzzle1': half_pieces1, + 'total_pieces': total_pieces + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Teddy", "Tommy", "Billy", "Jimmy", "Bobby", "Danny"] + name = rng.choice(names) + + # Generate random puzzle sizes that are even numbers + puzzle1 = int(rng.randrange(100, int(500 * difficulty), 2)) + puzzle2 = int(rng.randrange(300, int(1000 * difficulty), 2)) + + result = generate_from_variables(name, puzzle1, puzzle2) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_51(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, parent: str, activity1: str, activity2: str, + activity3: str, cur: str, times: int, budget: int, + tokens: int, cost1: int, cost2: int) -> Dict[str, Any]: + + cost_per_ride = cost2 * times + cost_per_person = tokens + cost1 + cost_per_ride + total_people = budget // cost_per_person + friends = total_people - 1 + + question = f"{name}'s {parent} said that she had {cur}{budget} budgeted for her birthday party. She wants to make sure she and her friends all get to play one round of {activity1}, have {cur}{tokens} in {activity2} tokens, and get to ride the {activity3} {times}. A round of {activity1} is {cur}{cost1}. The {activity3} cost {cur}{cost2} a ride. How many friends can she invite?" + + answer_cot = f"The {activity3} will cost {cur}{cost_per_ride} per person because {cost2} x {times} = {cost_per_ride}\n" \ + f"Each person costs {cur}{cost_per_person} because {tokens} + {cost1} + {cost_per_ride} = {cost_per_person}\n" \ + f"{total_people} total people can attend because {budget} / {cost_per_person} = {total_people}\n" \ + f"She can invite {friends} friends because {total_people} - 1 = {friends}\n" \ + f"#### {friends}" + + return { + 'question': question, + 'answer': str(friends), + 'answer_cot': answer_cot, + 'answer_value': friends, + 'variables': { + 'name': name, + 'parent': parent, + 'activity1': activity1, + 'activity2': activity2, + 'activity3': activity3, + 'currency': cur, + 'times': times, + 'budget': budget, + 'tokens': tokens, + 'cost1': cost1, + 'cost2': cost2, + 'cost_per_ride': cost_per_ride, + 'cost_per_person': cost_per_person, + 'total_people': total_people + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ['Emma', 'Olivia', 'Sophia', 'Isabella', 'Mia', 'Charlotte'] + parents = ['mom', 'dad', 'aunt', 'uncle'] + activities1 = ['mini-golf', 'bowling', 'laser tag'] + activities2 = ['arcade', 'game room', 'pinball'] + activities3 = ['go-karts', 'bumper cars', 'roller coaster'] + currencies = ['$', '£', '€'] + times_options = [2, 3] + + name = rng.choice(names_female) + parent = rng.choice(parents) + activity1 = rng.choice(activities1) + activity2 = rng.choice(activities2) + activity3 = rng.choice(activities3) + cur = rng.choice(currencies) + times = rng.choice(times_options) + + tokens = int(rng.randint(3, int(11 * difficulty))) + cost1 = int(rng.randint(3, int(11 * difficulty))) + cost2 = int(rng.randint(5, int(21 * difficulty))) + + # Generate budget ensuring conditions are met + cost_per_person = tokens + cost1 + (cost2 * times) + num_people = rng.randint(2, int(10 * difficulty)) + budget = cost_per_person * num_people + + result = generate_from_variables(name, parent, activity1, activity2, activity3, + cur, times, budget, tokens, cost1, cost2) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_52(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, alphabets: tuple, n1: str, frac: str) -> Dict[str, Any]: + alphabet_name, alphabet_count = alphabets + + # Calculate intermediate values + full_writes = n1 * alphabet_count + half_write = int(alphabet_count * frac) + subtotal = full_writes + half_write + final_total = subtotal * 2 + + question = f"{name} is learning to write and decides to keep re-writing the {alphabet_name} until she knows it. She writes it in full {n1}, writes {frac} of it once, then re-writes everything she has already written. How many letters has {name} written in total?" + + answer_cot = f"{name} has written the {alphabet_name} {n1} time(s) which is a total of {alphabet_count} * {n1} = {full_writes} letters.\n" \ + f"She then writes {frac} the {alphabet_name}, which is {alphabet_count} * {frac} = {half_write} letters.\n" \ + f"So far, this is a total of {full_writes} + {half_write} = {subtotal} letters.\n" \ + f"Writing this again means she has doubled the number of letters she has written, so she has written a total of {subtotal} * 2 = {final_total} letters.\n" \ + f"#### {final_total}" + + return { + 'question': question, + 'answer': str(final_total), + 'answer_cot': answer_cot, + 'answer_value': final_total, + 'variables': { + 'name': name, + 'alphabet_name': alphabet_name, + 'alphabet_count': alphabet_count, + 'times_written': n1, + 'fraction': frac, + 'full_writes': full_writes, + 'half_write': half_write, + 'total': final_total + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ["Emma", "Sophia", "Olivia", "Ava", "Isabella", "Mia", "Charlotte", "Amelia"] + alphabets = [("alphabet", 26), ("hiragana (with 48 letters)", 48), + ("farsi alphabet (with 32 letters)", 32), ("arabic abjad (with 28 letters)", 28)] + multi_times = ["twice", "three times", "four times"] + fraction_alnum = ["half", "one-third", "one-fourth"] + + name = rng.choice(names_female) + alphabet = rng.choice(alphabets) + n1 = rng.choice(multi_times) + frac = rng.choice(fraction_alnum) + + # Convert text numbers to numeric values + n1_map = {"twice": 2, "three times": 3, "four times": 4} + frac_map = {"half": 0.5, "one-third": 1/3, "one-fourth": 0.25} + + # Ensure division results in integer + while not (alphabet[1] * frac_map[frac]).is_integer(): + alphabet = rng.choice(alphabets) + + result = generate_from_variables(name, alphabet, n1_map[n1], frac_map[frac]) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_53(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, sides: int, target: int, property: str) -> Dict[str, Any]: + numbers_above = sides - target + prob_above = (numbers_above / sides) * 100 + prob_two_in_row = 25 # probability of two even/odd in a row is always 25% + difference = int(prob_above - prob_two_in_row) + + question = f"{name} is rolling a {sides}-sided die. How much more likely is it (expressed as a percentage) that he rolls a number greater than {target} than that he rolls two {property} numbers in a row?" + + answer_cot = f"There are {numbers_above} numbers greater than {target} on the dice, so the chances of rolling one of them are {numbers_above} / {sides} = {prob_above}%.\nThe chance of rolling one {property} number is 50%, so the chance of rolling two in a row is 50% * 50% = 25%.\nThe difference between these two probabilities is {prob_above}% - 25% = {difference}%.\n#### {difference}" + + return { + 'question': question, + 'answer': str(difference), + 'answer_cot': answer_cot, + 'answer_value': difference, + 'variables': { + 'name': name, + 'sides': sides, + 'target': target, + 'property': property, + 'numbers_above': numbers_above, + 'prob_above': prob_above, + 'prob_two_in_row': prob_two_in_row + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"] + properties = ["even", "odd"] + + name = rng.choice(names) + property = rng.choice(properties) + + dice_options = [4, 6, 8, 10, 12, 20] + sides = rng.choice(dice_options) + + # Generate target ensuring conditions are met + while True: + target = rng.randint(1, sides-1) + prob = ((sides-target)/sides) * 100 + if (sides-target) % target == 0 and prob.is_integer() and prob > 25: + break + + result = generate_from_variables(name, sides, target, property) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_54(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name1: str, name2: str, total_time: int, + library_time: int, station_time: int, + location1: str, location2: str, location3: str) -> Dict[str, Any]: + + time_after_library = total_time - library_time + remaining_time = time_after_library - station_time + + question = f"{name1} and {name2} have {total_time} minutes to walk to {location1} together. It takes them {library_time} minutes to get to the corner where the {location2} is. It takes them another {station_time} minutes to get to the {location3}. How much longer do they have to get to {location1} without being late?" + + answer_cot = f"{name1} and {name2} arrive at the {location2} with {total_time} - {library_time} = {time_after_library} minutes left to reach the {location1}.\nThey then arrive at the {location3} and have {time_after_library} - {station_time} = {remaining_time} minutes left to get to {location1} without being late.\n#### {remaining_time}" + + return { + 'question': question, + 'answer': str(remaining_time), + 'answer_cot': answer_cot, + 'answer_value': remaining_time, + 'variables': { + 'name1': name1, + 'name2': name2, + 'total_time': total_time, + 'library_time': library_time, + 'station_time': station_time, + 'location1': location1, + 'location2': location2, + 'location3': location3, + 'remaining_time': remaining_time + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ['John', 'Jack', 'James', 'William', 'Michael', 'David', 'Joseph'] + locations = ['cinema', 'mall', 'library', 'park', 'gym', 'bank', 'school'] + + name1, name2 = rng.sample(names, 2) + loc1, loc2, loc3 = rng.sample(locations, 3) + + # Generate times ensuring they're not divisible by 5 + library_time = int(rng.randint(10, int(30 * difficulty))) + while library_time % 5 == 0: + library_time = int(rng.randint(10, int(30 * difficulty))) + + station_time = int(rng.randint(10, int(70 * difficulty))) + while station_time % 5 == 0: + station_time = int(rng.randint(10, int(70 * difficulty))) + + # Ensure total time is greater than sum of other times + min_total = library_time + station_time + 5 + total_time = int(rng.randint(min_total, int(140 * difficulty))) + while total_time % 5 == 0: + total_time = int(rng.randint(min_total, int(140 * difficulty))) + + result = generate_from_variables(name1, name2, total_time, library_time, + station_time, loc1, loc2, loc3) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_55(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, place: str, fruit: str, location: str, + insect1: str, insect2: str, n: int, frac: str) -> Dict[str, Any]: + num_insect1 = int(n * 0.5) # half as many bugs as ants + total_insects = n + num_insect1 + + question = f"{name} went to their {place} to pick some {fruit} and found {frac} as many {insect1} as {insect2} in the {location}. If there were {n} {insect2}, calculate the total number of insects in the {location}." + + answer_cot = f"If there were {n} {insect2}, the total number of {insect1} in the {location} is {frac} * {n} {insect2} = {num_insect1} {insect1}\nThe total number of insects in the {location} is {num_insect1} {insect1} + {n} {insect2} = {total_insects} insects\n#### {total_insects}" + + return { + 'question': question, + 'answer': str(total_insects), + 'answer_cot': answer_cot, + 'answer_value': total_insects, + 'variables': { + 'name': name, + 'place': place, + 'fruit': fruit, + 'location': location, + 'insect1': insect1, + 'insect2': insect2, + 'n': n, + 'frac': frac, + 'num_insect1': num_insect1 + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Dax", "Alex", "Sam", "Jordan", "Taylor", "Morgan", "Riley"] + places = ["orchard", "backyard", "greenhouse", "allotment"] + fruits = ["strawberries", "cherries", "blueberries", "raspberries"] + locations = ["garden", "field", "plot", "patch"] + insects = ["beetles", "ladybugs", "grasshoppers", "caterpillars", "bees", "wasps"] + + name = rng.choice(names) + place = rng.choice(places) + fruit = rng.choice(fruits) + location = rng.choice(locations) + insect1, insect2 = rng.sample(insects, 2) + + n = int(rng.randint(20, int(200 * difficulty))) + # Ensure n is even for "half as many" + if n % 2 == 1: + n += 1 + + result = generate_from_variables(name, place, fruit, location, insect1, insect2, n, "half") + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_56(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(family: str, item: str, total: int, n1: int, n2: int, + flavor1: str, flavor2: str, flavor3: str) -> Dict[str, Any]: + n3 = total - (n1 + n2) + + question = f"The {family} family is busy making {item}s. So far, they've made {total} {item}s. They have {n1} {flavor1} {item}s, {n2} {flavor2} {item}s, and some {flavor3} {item}s. How many {flavor3} {item}s have they made?" + + answer_cot = f"The total number of pieces of {flavor1} and {flavor2} {item}s is {n1} + {n2} = {n1+n2}.\nTherefore, they made {total} - {n1+n2} = {n3} {flavor3} {item}s.\n#### {n3}" + + return { + 'question': question, + 'answer': str(n3), + 'answer_cot': answer_cot, + 'answer_value': n3, + 'variables': { + 'family': family, + 'item': item, + 'total': total, + 'n1': n1, + 'n2': n2, + 'n3': n3, + 'flavor1': flavor1, + 'flavor2': flavor2, + 'flavor3': flavor3 + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + families = ["Smith", "Johnson", "Williams", "Brown", "Jones"] + items = ["cupcake", "muffin", "brownie", "biscuit"] + flavors = ["vanilla", "strawberry", "blueberry", "lemon", "peanut butter"] + + family = rng.choice(families) + item = rng.choice(items) + flavor1, flavor2, flavor3 = rng.sample(flavors, 3) + + total = int(rng.randrange(5000, int(10000 * difficulty), 25)) + n1 = int(rng.randint(1000, int(3000 * difficulty))) + n2 = int(rng.randint(1000, int(3000 * difficulty))) + + while n1 + n2 >= total: + n1 = int(rng.randint(1000, int(3000 * difficulty))) + n2 = int(rng.randint(1000, int(3000 * difficulty))) + + result = generate_from_variables(family, item, total, n1, n2, flavor1, flavor2, flavor3) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_57(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(n1: int, sport1: str, sport2: str, sport3: str, + n2: int, n3: int, multiplier: int) -> Dict[str, Any]: + n_volleyball = n1 * multiplier + n_soccer = n2 + n3 + total = n1 + n_volleyball + n_soccer + + question = f"There are {n1} students playing {sport1} and twice that number playing {sport2}. There are {n2} boys and {n3} girls playing {sport3}. If each student only participates in one group, how many students are there in total?" + + answer_cot = f"There are {n1} x {multiplier} = {n_volleyball} students playing {sport2}.\nThere are {n2} + {n3} = {n_soccer} students playing {sport3}.\nIn total there are {n1} + {n_volleyball} + {n_soccer} = {total} students.\n#### {total}" + + return { + 'question': question, + 'answer': str(total), + 'answer_cot': answer_cot, + 'answer_value': total, + 'variables': { + 'tennis_players': n1, + 'volleyball_players': n_volleyball, + 'soccer_boys': n2, + 'soccer_girls': n3, + 'total_soccer': n_soccer, + 'total_students': total, + 'sports': [sport1, sport2, sport3] + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + sports = ['basketball', 'badminton', 'table tennis', 'football', 'volleyball'] + sport1, sport2, sport3 = rng.sample(sports, 3) + + # Generate numbers based on difficulty + n1 = int(rng.randint(4, int(21 * difficulty))) + n2 = int(rng.randint(10, int(31 * difficulty))) + n3 = int(rng.randint(10, int(31 * difficulty))) + multiplier = 2 # "twice" that number + + # Check condition + while n1 * multiplier + n2 + n3 > 250: + n1 = int(rng.randint(4, int(21 * difficulty))) + n2 = int(rng.randint(10, int(31 * difficulty))) + n3 = int(rng.randint(10, int(31 * difficulty))) + + result = generate_from_variables(n1, sport1, sport2, sport3, n2, n3, multiplier) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_58(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, container: str, liquid: str, volume: int, unit: str, + num_containers: int, calories: int) -> Dict[str, Any]: + total_volume = volume * num_containers + total_calories = total_volume * calories + + question = f"A {container} of {liquid} is {volume} {unit}s of {liquid}. {name} drinks {num_containers} {container}s of {liquid}. If {liquid} has {calories} calories per {unit} how many calories did he consume?" + + answer_cot = f"He drank {volume}*{num_containers}={total_volume} {unit}s of {liquid}.\nSo he drank {total_volume}*{calories}={total_calories} calories of {liquid}\n#### {total_calories}" + + return { + 'question': question, + 'answer': str(total_calories), + 'answer_cot': answer_cot, + 'answer_value': total_calories, + 'variables': { + 'name': name, + 'container': container, + 'liquid': liquid, + 'volume': volume, + 'unit': unit, + 'num_containers': num_containers, + 'calories': calories, + 'total_volume': total_volume, + 'total_calories': total_calories + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["John", "Mike", "James", "David", "Robert", "William"] + containers = ["cup", "bottle", "carton"] + liquids = ["juice", "soda", "sparkling water", "tea", "lemonade"] + units = ["ounce", "mL", "cc", "oz"] + + name = rng.choice(names) + container = rng.choice(containers) + liquid = rng.choice(liquids) + unit = rng.choice(units) + + volume = int(rng.randint(6, int(16 * difficulty))) + num_containers = int(rng.randint(2, int(6 * difficulty))) + calories = int(rng.randint(2, int(10 * difficulty))) + + result = generate_from_variables(name, container, liquid, volume, unit, + num_containers, calories) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_59(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(time_per_interval: int, distance_per_interval: int, total_distance: int) -> Dict[str, Any]: + intervals = total_distance // distance_per_interval + total_time = intervals * time_per_interval + + question = f"A fog bank rolls in from the ocean to cover a city. It takes {time_per_interval} minutes to cover every {distance_per_interval} miles of the city. If the city is {total_distance} miles across from the oceanfront to the opposite inland edge, how many minutes will it take for the fog bank to cover the whole city?" + + answer_cot = f"The city will be covered in {total_distance} / {distance_per_interval} = {intervals} intervals of {time_per_interval} minutes.\nThus, it will take {intervals} * {time_per_interval} = {total_time} minutes for the fog to cover the whole city.\n#### {total_time}" + + return { + 'question': question, + 'answer': str(total_time), + 'answer_cot': answer_cot, + 'answer_value': total_time, + 'variables': { + 'time_per_interval': time_per_interval, + 'distance_per_interval': distance_per_interval, + 'total_distance': total_distance, + 'intervals': intervals + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + # Generate random values scaled by difficulty + distance_per_interval = int(rng.randint(2, int(100 * difficulty))) + time_per_interval = int(rng.randint(2, int(500 * difficulty))) + + # Ensure total distance is divisible by distance_per_interval + num_intervals = rng.randint(2, int(20 * difficulty)) + total_distance = distance_per_interval * num_intervals + + # Ensure total_distance is in valid range + while total_distance > 100: + num_intervals = rng.randint(2, int(20 * difficulty)) + total_distance = distance_per_interval * num_intervals + + result = generate_from_variables(time_per_interval, distance_per_interval, total_distance) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_60(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, unit: str, total_dist: int, beach_dist: int, + sidewalk_dist: int, speed_mult: int, beach_time: int) -> Dict[str, Any]: + + beach_rate = Fraction(beach_dist, beach_time) + sidewalk_rate = beach_rate * speed_mult + sidewalk_time = int(sidewalk_dist / sidewalk_rate) + total_time = beach_time + sidewalk_time + + question = f"{name} walks {total_dist} {unit}s every day on her favorite walking trail, which includes {beach_dist} {unit}s of walking on the beach and {sidewalk_dist} {unit}s of walking on the sidewalk. On the sidewalk, {name} walks at twice the rate of speed that she does on the beach. If {beach_time} minutes of her walk is spent on the beach, how long does it take for her to complete the entire {total_dist}-{unit} walk, in minutes?" + + answer_cot = f"On the beach, {name} walks at a rate of {beach_dist} {unit}s per {beach_time} minutes, or {beach_dist}/{beach_time} = {beach_rate} {unit}s per minute.\nOn the sidewalk, she walks at {speed_mult} times the rate of speed as when she is on the sand, or {speed_mult} * {beach_rate} = {sidewalk_rate} {unit}s per minute.\nTo walk {sidewalk_dist} {unit}s on the sidewalk, it takes her {sidewalk_dist}÷{sidewalk_rate}={sidewalk_time} minutes.\nThus, in total, it takes {name} {beach_time}+{sidewalk_time}={total_time} minutes to walk her favorite route.\n#### {total_time}" + + return { + 'question': question, + 'answer': str(total_time), + 'answer_cot': answer_cot, + 'answer_value': total_time, + 'variables': { + 'name': name, + 'unit': unit, + 'total_distance': total_dist, + 'beach_distance': beach_dist, + 'sidewalk_distance': sidewalk_dist, + 'speed_multiplier': speed_mult, + 'beach_time': beach_time, + 'sidewalk_time': sidewalk_time + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ['Emma', 'Sophia', 'Isabella', 'Olivia', 'Ava', 'Mia', 'Emily'] + units = ['mile', 'kilometer', 'block'] + + name = rng.choice(names) + unit = rng.choice(units) + speed_mult = 2 # Fixed as "twice" in question + + beach_time = int(rng.randint(40, int(70 * difficulty))) + beach_dist = int(rng.randint(10, int(20 * difficulty))) + sidewalk_dist = int(rng.randint(10, int(20 * difficulty))) + total_dist = beach_dist + sidewalk_dist + + # Ensure mathematical consistency + while not (beach_dist < beach_time and + speed_mult * beach_dist < beach_time and + beach_time % beach_dist == 0): + beach_time = int(rng.randint(40, int(70 * difficulty))) + beach_dist = int(rng.randint(10, int(20 * difficulty))) + sidewalk_dist = int(rng.randint(10, int(20 * difficulty))) + total_dist = beach_dist + sidewalk_dist + + result = generate_from_variables(name, unit, total_dist, beach_dist, + sidewalk_dist, speed_mult, beach_time) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_61(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, location: str, shop: str, item1: str, item2: str, + item3: str, unit: str, cur: str, total: float, n1: int, n2: int, + n12: int, k: int, n3: int, p1: float, p2: float, p3: float, + discount: float) -> Dict[str, Any]: + + # Calculate costs + item1_cost = n1*p1 + n2*(1-discount)*p1 + k*p1 # Cost of item1 with discount applied + item2_cost = p2 # Cost of item2 + item3_cost = n3*p3 # Cost of item3 + total_spent = int(item1_cost + item2_cost + item3_cost) + money_left = total - total_spent + + question = f"{name} went to the {location} for vacation. Her parents gave her {cur}{total} to buy whatever she wanted. At the {shop}, {item1} was on sale for \"Buy {n1} {unit}s at {cur}{p1} per {unit}, get {n2} {unit}s {discount} off.\" She scooped up {n12} {unit}s. She also bought a mixed bag of {item2} for {cur}{p2} and {n3} {item3} that were {cur}{p3} each. How much money does {name} have left?" + + answer_cot = f"{item1} is {n1} {unit}s for {cur}{p1} and gets {n2} {unit}s {discount} off. So {discount} off of {n2} {unit}s is {cur}{n2*discount}*{p1} = {cur}{n2*discount*p1}. The rest of {k} {unit}s does not have discount and come at {k*p1} so total is {n1}*{p1} + {n2}*{1-discount}*{p1} + {k}*{p1} = {item1_cost}\n{n3} {item3} at {cur}{p3} each is {n3}*{p3}={cur}{n3*p3}\nWhen you add all her purchases, {cur}{item1_cost}+{cur}{p2}+{cur}{n3*p3} = {cur}{total_spent}\nShe had {cur}{total} and spent {cur}{total_spent} so she had {cur}{total}-{cur}{total_spent} = {cur}{money_left} left over\n#### {money_left}" + + return { + 'question': question, + 'answer': str(money_left), + 'answer_cot': answer_cot, + 'answer_value': money_left, + 'variables': { + 'name': name, + 'location': location, + 'shop': shop, + 'item1': item1, + 'item2': item2, + 'item3': item3, + 'unit': unit, + 'currency': cur, + 'total_money': total, + 'n1': n1, + 'n2': n2, + 'n12': n12, + 'k': k, + 'n3': n3, + 'p1': p1, + 'p2': p2, + 'p3': p3, + 'discount': discount, + 'total_spent': total_spent + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ['Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia', 'Charlotte'] + locations = ['beach', 'boardwalk', 'pier', 'coast'] + shops = ['souvenir store', 'gift shop', 'beach shop', 'seaside store'] + items1 = ['fudge', 'saltwater taffy', 'rock candy', 'cotton candy'] + items2 = ['sand dollars', 'starfish', 'sea glass', 'coral pieces'] + items3 = ['postcards', 'keychains', 'stickers', 'pins'] + units = ['pound', 'kilogram', 'kg'] + currencies = ['$', '£', '€'] + fraction_nums = [0.25, 0.33, 0.5, 0.67, 0.75] + + name = rng.choice(names_female) + location = rng.choice(locations) + shop = rng.choice(shops) + item1 = rng.choice(items1) + item2 = rng.choice(items2) + item3 = rng.choice(items3) + unit = rng.choice(units) + cur = rng.choice(currencies) + + total = int(rng.randint(1200, int(1500 * difficulty))) + n1 = int(rng.randint(15, int(18 * difficulty))) + n2 = int(rng.randint(4, int(10 * difficulty))) + k = int(rng.randint(2, int(5 * difficulty))) + n12 = n1 + n2 + k + n3 = int(rng.randint(11, int(19 * difficulty))) + p1 = int(rng.randint(20, int(24 * difficulty))) + p2 = round(rng.uniform(11.25, 12.00), 2) + p3 = round(rng.uniform(20.25, 21.25), 2) + discount = rng.choice(fraction_nums[:4]) + + # Ensure conditions are met + while not (n2 < n1 and + n12 == n1 + n2 + k and + 0 <= k < n1 and + int(n1*p1 + n2*(1-discount)*p1 + k*p1 + p2 + n3*p3) == n1*p1 + n2*(1-discount)*p1 + k*p1 + p2 + n3*p3 and + n1*p1 + n2*(1-discount)*p1 + k*p1 + p2 + n3*p3 < total): + n1 = int(rng.randint(15, int(18 * difficulty))) + n2 = int(rng.randint(4, int(10 * difficulty))) + k = int(rng.randint(2, int(5 * difficulty))) + n12 = n1 + n2 + k + p1 = int(rng.randint(20, int(24 * difficulty))) + + result = generate_from_variables(name, location, shop, item1, item2, item3, unit, cur, + total, n1, n2, n12, k, n3, p1, p2, p3, discount) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_62(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(item: str, num_slices: int, name1: str, name2: str, + slices_per_day: int, multiplier: int, unit: str) -> Dict[str, Any]: + + second_person_slices = slices_per_day * multiplier + total_daily_slices = slices_per_day + second_person_slices + days_lasting = num_slices // total_daily_slices + + question = f"A {item} has {num_slices} {unit}. If {name1} can eat {slices_per_day} {unit} a day while {name2} can eat {multiplier} times as much, how many days will the {item} last?" + + answer_cot = f"{name2} can eat {slices_per_day} x {multiplier} = {second_person_slices} {unit} a day.\nTogether, {name1} and {name2} can eat {slices_per_day} + {second_person_slices} = {total_daily_slices} {unit} a day.\nSo, a {item} will last for {num_slices}/{total_daily_slices} = {days_lasting} days.\n#### {days_lasting}" + + return { + 'question': question, + 'answer': str(days_lasting), + 'answer_cot': answer_cot, + 'answer_value': days_lasting, + 'variables': { + 'item': item, + 'num_slices': num_slices, + 'name1': name1, + 'name2': name2, + 'slices_per_day': slices_per_day, + 'multiplier': multiplier, + 'second_person_slices': second_person_slices, + 'total_daily_slices': total_daily_slices, + 'unit': unit + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + items = ["pizza", "cake", "pie", "lasagna"] + units = ["pieces", "portions", "servings"] + names = ["Emma", "Liam", "Olivia", "Noah", "Ava", "Elijah", "Charlotte", "James"] + + item = rng.choice(items) + unit = rng.choice(units) + name1, name2 = rng.sample(names, 2) + + slices_per_day = int(rng.randint(2, int(6 * difficulty))) + multiplier = 2 # Using 'twice' as specified in original + + # Ensure total is divisible by daily consumption + daily_total = slices_per_day + (slices_per_day * multiplier) + num_days = rng.randint(2, int(8 * difficulty)) + num_slices = daily_total * num_days + + result = generate_from_variables(item, num_slices, name1, name2, slices_per_day, + multiplier, unit) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_63(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, hours: int, days: int, rate: int, + bonus: int, month: str) -> Dict[str, Any]: + daily_pay = hours * rate + monthly_days = days * 4 + monthly_base = daily_pay * monthly_days + monthly_bonus = bonus * 4 + total_pay = monthly_base + monthly_bonus + + question = f"{name} works a {hours}-hour shift each day, {days} days a week. He earns ${rate} per hour and gets a ${bonus} bonus each week if the company performs well. How much money did {name} make in {month} if the company performed very well for the whole month?" + + answer_cot = f"In a day, {name} makes {hours} * {rate} = ${daily_pay}\n" \ + f"If he works {days} days a week, the total number of days for the whole month is {days} * 4= {monthly_days} days.\n" \ + f"Since he makes ${daily_pay} per day, the total amount for the whole month is {monthly_days} * {daily_pay}= ${monthly_base}.\n" \ + f"He also got a {bonus} * 4 = ${monthly_bonus} bonus because the company performed well in all the weeks of {month}.\n" \ + f"At the end of {month}, he earned {monthly_base} + {monthly_bonus} = ${total_pay}.\n#### {total_pay}" + + return { + 'question': question, + 'answer': str(total_pay), + 'answer_cot': answer_cot, + 'answer_value': total_pay, + 'variables': { + 'name': name, + 'hours_per_day': hours, + 'days_per_week': days, + 'hourly_rate': rate, + 'weekly_bonus': bonus, + 'month': month, + 'daily_pay': daily_pay, + 'monthly_base': monthly_base, + 'monthly_bonus': monthly_bonus + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"] + months = ["January", "February", "March", "April", "May", "June", "July", + "August", "September", "October", "November", "December"] + + name = rng.choice(names) + month = rng.choice(months) + + hours = int(rng.randint(6, int(13 * difficulty))) + days = int(rng.randint(3, int(7 * difficulty))) + rate = int(rng.randint(8, int(31 * difficulty))) + bonus = int(rng.randint(100, int(601 * difficulty))) + + # Ensure rate * hours is an integer + while (hours * rate) % 1 != 0: + rate = int(rng.randint(8, int(31 * difficulty))) + + result = generate_from_variables(name, hours, days, rate, bonus, month) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_64(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, n1: int, d1: int, n2: int, d2: int) -> Dict[str, Any]: + first_period = n1 * d1 + second_period = n2 * d2 + total_eggs = first_period + second_period + dozens = total_eggs // 12 + + question = f"If {name} eats {n1} eggs a day for {d1} days and then increases it to {n2} eggs a day for {d2} days, how many dozens of eggs will {name} need for {d1+d2} days?" + + answer_cot = f"He starts off eating {n1} eggs a day for {d1} days for a total of {n1}*{d1} = {first_period} eggs\n" \ + f"Then he increases it to {n2} eggs a day for {d2} days for a total of {n2}*{d2} = {second_period} eggs\n" \ + f"All total he will eat {first_period}+{second_period} = {total_eggs} eggs\n" \ + f"There are 12 eggs in 1 dozen and he will eat {total_eggs} eggs which is {total_eggs}/12 = {dozens} dozen eggs\n" \ + f"#### {dozens}" + + return { + 'question': question, + 'answer': str(dozens), + 'answer_cot': answer_cot, + 'answer_value': dozens, + 'variables': { + 'name': name, + 'eggs_per_day_first': n1, + 'days_first': d1, + 'eggs_per_day_second': n2, + 'days_second': d2, + 'total_eggs': total_eggs, + 'dozens': dozens + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Chester", "James", "John", "Robert", "Michael", "William", "David"] + name = rng.choice(names) + + # Generate random values scaled by difficulty + n1 = int(rng.randint(2, int(6 * difficulty))) + n2 = int(rng.randint(4, int(8 * difficulty))) + while n2 <= n1: + n2 = int(rng.randint(4, int(8 * difficulty))) + + d1 = int(rng.randint(20, int(110 * difficulty))) + d2 = int(rng.randint(20, int(110 * difficulty))) + + # Ensure results are divisible by 12 + while (n1 * d1 + n2 * d2) % 12 != 0: + d1 = int(rng.randint(20, int(110 * difficulty))) + d2 = int(rng.randint(20, int(110 * difficulty))) + + result = generate_from_variables(name, n1, d1, n2, d2) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_65(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, fish: str, day: str, w1: int, w2: int, w3: int, + n: int, unit: str, cur: str, price: float) -> Dict[str, Any]: + total = int((w1 + w2) * price + (n-2)*w3*price) + + question = f"{name} caught {n} {fish}s last {day}, the first {fish} he caught weighs {w1} {unit}s, the second {fish} he caught weighs {w2} {unit}s, and the last {fish} he caught weighs {w3} {unit}s. If a {unit} of {fish} costs {cur}{price:.2f}, how much will he earn after selling all the {fish}s to the market?" + + answer_cot = f"{name} will earn {w1} x {cur}{price:.2f} = {cur}{w1*price:.2f} from the first {fish}.\n" \ + f"He will earn {w2} x {cur}{price:.2f} = {cur}{w2*price:.2f} for the second {fish}.\n" \ + f"The rest of the {fish}s are {n}-2 = {n-2}. He will earn {w3} x {cur}{price:.2f} = {cur}{w3*price:.2f} per each of them. So he will earn {n-2} * {w3*price:.2f} = {(n-2)*w3*price:.2f}\n" \ + f"Therefore, the total amount he will earn for all the {fish}s is {cur}{w1*price:.2f} + {cur}{w2*price:.2f} + {cur}{(n-2)*w3*price:.2f}= {cur}{total}.\n#### {total}" + + return { + 'question': question, + 'answer': str(total), + 'answer_cot': answer_cot, + 'answer_value': total, + 'variables': { + 'name': name, + 'fish': fish, + 'day': day, + 'weight1': w1, + 'weight2': w2, + 'weight3': w3, + 'num_fish': n, + 'unit': unit, + 'currency': cur, + 'price': price + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["John", "Michael", "David", "James", "Robert", "William", "Richard"] + fish = ["salmon", "cod", "trout", "steelhead"] + days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"] + units = ["kilogram", "pound", "kg"] + currencies = ["$", "€", "£"] + + name = rng.choice(names) + fish_type = rng.choice(fish) + day = rng.choice(days) + unit = rng.choice(units) + cur = rng.choice(currencies) + + w1 = int(rng.randint(40, int(80 * difficulty))) + w2 = int(rng.randint(30, int(60 * difficulty))) + w3 = int(rng.randint(20, int(40 * difficulty))) + n = int(rng.randint(3, int(8 * difficulty))) + price = round(rng.uniform(0.25, 2.5), 2) + + # Ensure result is integer + while not ((w1 + w2) * price + (n-2) * w3 * price).is_integer(): + price = round(rng.uniform(0.25, 2.5), 2) + + result = generate_from_variables(name, fish_type, day, w1, w2, w3, n, unit, cur, price) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_66(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, weekdays: list, hour1: int, hour2: int, hour3: int, + min1: int, min2: int, total_hours: int, num_wed_episodes: int) -> Dict[str, Any]: + + mon, tue, wed, thu, fri = weekdays + + question = f"{name} watches TV after he finishes his homework every night. On {mon} and {tue}, he watched a {hour1}-hour episode of his favorite show each night. On {wed}, he watched a few episodes of a {min1}-minute show. On {thu}, he finished homework early and watched a {hour2}-hour episode and a {min2}-minute show. On {fri}, he got to stay up late for the weekend, so he watched two {hour3}-hour episodes. If he watched {total_hours} hours of TV in all, how many {min1}-minute episodes did he watch on {wed}?" + + answer_cot = f"Let {wed[0]} be the number of episodes he watched on {wed}.\n" \ + f"After {mon}, he had {total_hours} - {hour1} = {total_hours-hour1} hours of TV left.\n" \ + f"After {tue}, he had {total_hours-hour1} - {hour1} = {total_hours-2*hour1} hours of TV left.\n" \ + f"After {thu}, he had {total_hours-2*hour1} - {hour2} - {Fraction(min2,60)} = {total_hours-2*hour1-hour2-Fraction(min2,60)} hours of TV left.\n" \ + f"After {fri}, he had {total_hours-2*hour1-hour2-Fraction(min2,60)} - {2*hour3} = {total_hours-2*hour1-hour2-Fraction(min2,60)-2*hour3} hours of TV left.\n" \ + f"Each {min1}-minute episode is {Fraction(min1,60)} hour.\n" \ + f"Thus, {wed[0]} = {num_wed_episodes} episodes.\n#### {num_wed_episodes}" + + return { + 'question': question, + 'answer': str(num_wed_episodes), + 'answer_cot': answer_cot, + 'answer_value': num_wed_episodes, + 'variables': { + 'name': name, + 'weekdays': weekdays, + 'hour1': hour1, + 'hour2': hour2, + 'hour3': hour3, + 'min1': min1, + 'min2': min2, + 'total_hours': total_hours, + 'num_wed_episodes': num_wed_episodes + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"] + weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"] + + name = rng.choice(names) + weekdays_sample = weekdays.copy() # Keep original order for this problem + + hour1 = int(rng.randint(3, int(7 * difficulty))) + hour2 = int(rng.randint(2, int(7 * difficulty))) + hour3 = int(rng.randint(2, int(6 * difficulty))) + + min1 = int(rng.randint(1, int(12 * difficulty))) * 5 # Ensure divisible by 5 + min2 = int(rng.randint(1, int(11 * difficulty))) * 5 # Ensure divisible by 5 + + # Calculate num_wed_episodes to ensure total_hours works out + num_wed_episodes = int(rng.randint(1, int(8 * difficulty))) + + # Calculate total hours from all components + total_hours = 2*hour1 + hour2 + min2/60 + 2*hour3 + (num_wed_episodes * min1/60) + + result = generate_from_variables(name, weekdays_sample, hour1, hour2, hour3, + min1, min2, total_hours, num_wed_episodes) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_67(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, fruit: str, n1: int, n2: int, d1: str, d2: str, + d3: str, mult: int) -> Dict[str, Any]: + first_two_days = n1 + n2 + friday_amount = mult * n1 + total = first_two_days + friday_amount + + question = f"{name} picks {n1} {fruit}s on {d1}. Then he picks {n2} {fruit}s on {d2}. On {d3}, he picks {mult} times the number of {fruit}s he did on {d1}. How many {fruit}s does {name} have?" + + answer_cot = f"Combining {d1} and {d2}, {name} has {n1} {fruit}s + {n2} {fruit}s = {first_two_days} {fruit}s.\nOn {d3}, he picks {mult} * {n1} {fruit}s = {friday_amount} {fruit}s.\nAltogether, {name} has {first_two_days} {fruit}s + {friday_amount} {fruit}s = {total} {fruit}s.\n#### {total}" + + return { + 'question': question, + 'answer': str(total), + 'answer_cot': answer_cot, + 'answer_value': total, + 'variables': { + 'name': name, + 'fruit': fruit, + 'day1_amount': n1, + 'day2_amount': n2, + 'day1': d1, + 'day2': d2, + 'day3': d3, + 'multiplier': mult, + 'day3_amount': friday_amount, + 'total': total + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["John", "James", "William", "Michael", "David", "Robert", "Thomas"] + fruits = ["banana", "apple", "orange", "pear", "peach", "plum"] + weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"] + multipliers = ["double", "triple", "quadruple"] + mult_values = {"double": 2, "triple": 3, "quadruple": 4} + + name = rng.choice(names) + fruit = rng.choice(fruits) + d1, d2, d3 = rng.sample(weekdays, 3) + mult_word = rng.choice(multipliers) + mult = mult_values[mult_word] + + n1 = int(rng.randint(30, int(400 * difficulty))) + n2 = int(rng.randint(50, int(400 * difficulty))) + + result = generate_from_variables(name, fruit, n1, n2, d1, d2, d3, mult) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_68(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(n0: int, r: int, d: int, disease: str) -> Dict[str, Any]: + # Calculate infected people after each day + day1_new = n0 * r + day1_total = n0 + day1_new + + day2_new = day1_total * r + day2_total = day1_total + day2_new + + day3_new = day2_total * r + day3_total = day2_total + day3_new + + question = f"A {disease} infects {n0} people. Every day, each infected person infects {r} others. How many people are infected after {d} days?" + + answer_cot = f"On the first day, the original {n0} people infect {r} people each, so {n0} * {r} = {day1_new} more people are infected.\n" \ + f"There are {n0} + {day1_new} = {day1_total} infected people after the first day.\n" \ + f"On the second day, {day1_total} * {r} = {day2_new} more people are infected.\n" \ + f"There are {day1_total} + {day2_new} = {day2_total} infected people after the second day.\n" \ + f"On the third day, {day2_total} * {r} = {day3_new} more people are infected. Therefore, there are {day2_total} + {day3_new} = {day3_total} infected people after three days.\n" \ + f"#### {day3_total}" + + return { + 'question': question, + 'answer': str(day3_total), + 'answer_cot': answer_cot, + 'answer_value': day3_total, + 'variables': { + 'initial_infected': n0, + 'infection_rate': r, + 'days': d, + 'disease_type': disease + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + diseases = ['virus', 'bacteria', 'parasite', 'infection'] + + disease = rng.choice(diseases) + n0 = int(rng.randint(5, int(21 * difficulty))) + r = int(rng.randint(2, int(8 * difficulty))) + d = 3 # Fixed at 3 days per problem description + + # Check condition: n0 * (r + 1)**d < 20000 + while n0 * (r + 1)**d >= 20000: + n0 = int(rng.randint(5, int(21 * difficulty))) + r = int(rng.randint(2, int(8 * difficulty))) + + result = generate_from_variables(n0, r, d, disease) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_69(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, document: str, total_pages: int, fraction: str) -> Dict[str, Any]: + frac_num = eval(fraction) + pages_done = int(total_pages * frac_num) + pages_remaining = total_pages - pages_done + + question = f"{name} is required to submit a {total_pages}-page {document}. She already finished writing {fraction} of the {document}. How many pages does she have left to write?" + + answer_cot = f"{name} has already written {fraction} of the {document} which is {total_pages} pages x {fraction} = {pages_done} pages.\nSo, she still needs to write {total_pages} pages - {pages_done} pages = {pages_remaining} pages.\n#### {pages_remaining}" + + return { + 'question': question, + 'answer': str(pages_remaining), + 'answer_cot': answer_cot, + 'answer_value': pages_remaining, + 'variables': { + 'name': name, + 'document': document, + 'total_pages': total_pages, + 'fraction': fraction, + 'pages_done': pages_done, + 'pages_remaining': pages_remaining + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte", "Amelia", "Harper", "Evelyn"] + documents = ["essay", "report", "thesis", "dissertation", "assignment"] + fractions = ["1/2", "1/3", "1/4", "2/3", "3/4"] + + name = rng.choice(names_female) + document = rng.choice(documents) + fraction = rng.choice(fractions) + + # Generate total pages ensuring it's divisible by denominator + denominator = int(fraction.split('/')[1]) + max_pages = int(325 * difficulty) + total_pages = denominator * rng.randint(1, max_pages // denominator) + + result = generate_from_variables(name, document, total_pages, fraction) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_70(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, objects: str, n: int, obstacle: str, + frac: float, k: int, fake_num: int, fake_object: str) -> Dict[str, Any]: + + dropped = int(n * frac) + remaining = n - dropped + found = k + after_finding = remaining + found + final = after_finding - fake_num + + question = f"{name} has a bag of {objects} with {n} inside. He tripped over {obstacle} while carrying it and dropped {dropped} of them. He scrambled to search for them but only came up with {k}. When he went back home, he inspected the {objects} further. {fake_num} of them he picked up wasn't a {objects}, but actually {fake_object} so he got rid of it. How many {objects} did {name} end up with?" + + answer_cot = f"{name} dropped his {objects} and was left with {n}*{1-frac}={remaining} {objects}.\n" \ + f"He searched and found some of his lost {objects}, getting him back to {remaining}+{k}={after_finding} {objects}.\n" \ + f"He went home and removed {fake_object}, leaving him with {after_finding}-{fake_num}={final} {objects}.\n" \ + f"#### {final}" + + return { + 'question': question, + 'answer': str(final), + 'answer_cot': answer_cot, + 'answer_value': final, + 'variables': { + 'name': name, + 'objects': objects, + 'initial_count': n, + 'obstacle': obstacle, + 'fraction_dropped': frac, + 'found_count': k, + 'fake_count': fake_num, + 'fake_object': fake_object, + 'remaining': remaining, + 'after_finding': after_finding, + 'final_count': final + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"] + objects = ["marbles", "coins", "buttons", "beads", "pebbles"] + obstacles = ["rock", "stick", "toy", "root"] + fake_objects = ["buttons", "coins", "pebbles", "beads"] + fractions = [0.5, 0.25, 0.75] + + name = rng.choice(names) + obj = rng.choice(objects) + obstacle = rng.choice(obstacles) + fake_object = rng.choice([x for x in fake_objects if x != obj]) + frac = rng.choice(fractions) + + n = int(rng.randrange(10, int(101 * difficulty), 2)) + fake_num = int(rng.randint(2, min(10, int(n * frac)))) + k = int(rng.randint(fake_num + 1, min(int(n * frac), int(20 * difficulty)))) + + # Ensure conditions are met + while not (isinstance(n * frac, int) and k < n * frac and k > fake_num): + n = int(rng.randrange(10, int(101 * difficulty), 2)) + k = int(rng.randint(fake_num + 1, min(int(n * frac), int(20 * difficulty)))) + + result = generate_from_variables(name, obj, n, obstacle, frac, k, fake_num, fake_object) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_71(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, shop: str, item: str, item1: str, item2: str, + item3: str, n1: int, n2: int, n3: int, p1: int, p2: int, + p3: int) -> Dict[str, Any]: + cost1 = n1 * p1 + cost2 = n2 * p2 + cost3 = n3 * p3 + total_cost = cost1 + cost2 + cost3 + + question = f"{name} went to the {shop} and bought various types of {item}. She bought {n1} dozen {item1} which cost ${p1} per dozen, {n2} dozen {item2} which cost ${p2} per dozen, and {n3} dozen {item3} for ${p3} per dozen. How much was the total cost?" + + answer_cot = f"The total charge for the {item1} was {n1} x ${p1} = ${cost1}.\nThe total charge for the {item2} was {n2} x ${p2} = ${cost2}.\nThe total charge for the {item3} was {n3} x ${p3} = ${p3*n3}.\nTherefore the total amount {name} paid for the {item} was ${cost1} + ${cost2} + ${cost3} = ${total_cost}.\n#### {total_cost}" + + return { + 'question': question, + 'answer': str(total_cost), + 'answer_cot': answer_cot, + 'answer_value': total_cost, + 'variables': { + 'name': name, + 'shop': shop, + 'item': item, + 'item1': item1, + 'item2': item2, + 'item3': item3, + 'n1': n1, + 'n2': n2, + 'n3': n3, + 'p1': p1, + 'p2': p2, + 'p3': p3, + 'cost1': cost1, + 'cost2': cost2, + 'cost3': cost3 + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Charlotte", "Mia", "Amelia"] + shops = ["bakery", "patisserie", "confectionery", "cafe"] + items = ["pastries", "baked goods", "desserts", "treats"] + item1_options = ["donuts", "croissants", "eclairs", "danishes"] + item2_options = ["mini cupcakes", "macarons", "cookies", "tarts"] + item3_options = ["mini cheesecakes", "brownies", "muffins", "scones"] + + name = rng.choice(names_female) + shop = rng.choice(shops) + item = rng.choice(items) + item1 = rng.choice(item1_options) + item2 = rng.choice(item2_options) + item3 = rng.choice(item3_options) + + n1 = int(rng.randint(1, int(10 * difficulty))) + n2 = int(rng.randint(4, int(10 * difficulty))) + n3 = int(rng.randint(2, int(10 * difficulty))) + + p1 = int(rng.randint(11, int(21 * difficulty))) + p2 = int(rng.randint(73, int(90 * difficulty))) + p3 = int(rng.randint(112, int(120 * difficulty))) + + result = generate_from_variables(name, shop, item, item1, item2, item3, + n1, n2, n3, p1, p2, p3) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_72(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(structure: str, n1: int, color1: str, color2: str, + color3: str, obj: str, mult: int, total: int) -> Dict[str, Any]: + n2 = n1 * mult + n3 = total - n1 - n2 + + question = f"A {structure} is made out of {n1} {color1} {obj}s, {mult} times as many {color2} {obj}s, and an unknown number of {color3} {obj}s. If there are {total} {obj}s in the {structure} in total, how many {color3} {obj}s are there?" + + answer_cot = f"There are {n1}*{mult} = {n2} {color2} {obj}s in the {structure}.\nThere are {total}-{n1}-{n2} = {n3} {color3} {obj}s in the {structure}.\n#### {n3}" + + return { + 'question': question, + 'answer': str(n3), + 'answer_cot': answer_cot, + 'answer_value': n3, + 'variables': { + 'structure': structure, + 'n1': n1, + 'n2': n2, + 'n3': n3, + 'color1': color1, + 'color2': color2, + 'color3': color3, + 'obj': obj, + 'mult': mult, + 'total': total + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + structures = ["building", "pyramid", "stack", "tower"] + objects = ["brick", "cube", "tile", "block"] + colors = ["green", "purple", "orange", "pink", "white", "black"] + + structure = rng.choice(structures) + obj = rng.choice(objects) + color1, color2, color3 = rng.sample(colors, 3) + + n1 = int(rng.randint(2, int(10 * difficulty))) + mult = 2 # "twice" as specified in original + n2 = n1 * mult + + # Ensure total is greater than n1 + n2 + min_total = n1 + n2 + 1 + total = int(rng.randint(min_total, min_total + int(20 * difficulty))) + + result = generate_from_variables(structure, n1, color1, color2, color3, obj, mult, total) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_73(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, fruit: str, food: str, d1: str, d2: str, + n1: int, n2: int, m1: int, m2: int, cn: int, cm: int, + currency: str) -> Dict[str, Any]: + + gingerbread_sunday = n1 + n2 + total_gingerbread = n1 + gingerbread_sunday + gingerbread_revenue = total_gingerbread * cn + + apple_pie_saturday = m2 - m1 + total_apple_pie = m2 + apple_pie_saturday + apple_pie_revenue = total_apple_pie * cm + + total_revenue = gingerbread_revenue + apple_pie_revenue + + question = f"{name} is selling {food} and {fruit} pie for a fundraiser. On {d1}, he sold {n1} boxes of {food} and {m1} fewer boxes of {fruit} pie, than on {d2}. On {d2}, he sold {n2} more boxes of {food} than on {d1} and {m2} boxes of {fruit} pie. If the {food} cost {currency}{cn} and the {fruit} pie cost {currency}{cm}, how much did {name} earn for two days?" + + answer_cot = f"He sold {n1} + {n2} = {gingerbread_sunday} boxes of {food} on {d2}.\nThe total number of boxes of {food}s that {name} sold is {n1} + {gingerbread_sunday} = {total_gingerbread}.\n{name} earned {total_gingerbread} x {currency}{cn} = {currency}{gingerbread_revenue} for selling {food}s.\nHe sold {m2} - {m1} = {apple_pie_saturday} boxes of {fruit} pie on {d1}.\nThe total number of boxes of {fruit} pie that {name} sold is {m2} + {apple_pie_saturday} = {total_apple_pie}.\nHe earned {total_apple_pie} x {currency}{cm} = {currency}{apple_pie_revenue} for selling {fruit} pie.\nSo, {name} earned {currency}{gingerbread_revenue} + {currency}{apple_pie_revenue} = {currency}{total_revenue} for two days.\n#### {total_revenue}" + + return { + 'question': question, + 'answer': str(total_revenue), + 'answer_cot': answer_cot, + 'answer_value': total_revenue, + 'variables': { + 'name': name, + 'fruit': fruit, + 'food': food, + 'day1': d1, + 'day2': d2, + 'gingerbread_day1': n1, + 'gingerbread_increase': n2, + 'apple_pie_difference': m1, + 'apple_pie_day2': m2, + 'gingerbread_price': cn, + 'apple_pie_price': cm, + 'currency': currency, + 'total_revenue': total_revenue + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ['John', 'Michael', 'David', 'James', 'William', 'Robert'] + fruits = ['apple', 'cherry', 'blueberry', 'peach'] + foods = ['cookie', 'brownie', 'muffin', 'cupcake'] + weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] + currencies = ['$', '£', '€'] + + name = rng.choice(names) + fruit = rng.choice(fruits) + food = rng.choice(foods) + d1, d2 = rng.sample(weekdays, 2) + currency = rng.choice(currencies) + + n1 = int(rng.randint(21, int(30 * difficulty))) + n2 = int(rng.randint(11, int(15 * difficulty))) + m2 = int(rng.randint(21, int(30 * difficulty))) + m1 = int(rng.randint(11, int(min(20, m2) * difficulty))) + cn = int(rng.randint(7, int(13 * difficulty))) + cm = int(rng.randint(20, int(33 * difficulty))) + + result = generate_from_variables(name, fruit, food, d1, d2, n1, n2, m1, m2, cn, cm, currency) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_74(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, big_fish: str, length: int, num_remoras: int, + remora_length: int) -> Dict[str, Any]: + total_remora_length_inches = num_remoras * remora_length + total_remora_length_feet = total_remora_length_inches / 12 + percentage = int((total_remora_length_feet / length) * 100) + + question = f"{name} saw a {length}-foot {big_fish} with {num_remoras} {remora_length}-inch remoras attached to it. What percentage of the {big_fish}'s body length is the combined length of the remoras?" + + answer_cot = f"First, find the combined length of the remoras in inches: {remora_length} inches/remora * {num_remoras} remoras = {total_remora_length_inches} inches\nThen divide that number by 12 to convert it to feet: {total_remora_length_inches} inches / 12 inches/foot = {total_remora_length_feet} foot\nThen divide the combined remora length in feet by the {big_fish}'s length and multiply by 100% to express the answer as a percentage: {total_remora_length_feet} foot / {length} feet * 100% = {percentage}%\n#### {percentage}" + + return { + 'question': question, + 'answer': str(percentage), + 'answer_cot': answer_cot, + 'answer_value': percentage, + 'variables': { + 'name': name, + 'big_fish': big_fish, + 'length_feet': length, + 'num_remoras': num_remoras, + 'remora_length_inches': remora_length, + 'total_remora_length_inches': total_remora_length_inches, + 'total_remora_length_feet': total_remora_length_feet, + 'percentage': percentage + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Benny", "Tommy", "Jimmy", "Billy", "Johnny", "Bobby"] + big_fish = ["dolphin", "whale", "shark"] + + name = rng.choice(names) + fish = rng.choice(big_fish) + + length = int(rng.randrange(10, int(500 * difficulty), 10)) + num_remoras = int(rng.randint(2, int(10 * difficulty))) + remora_length = int(rng.randint(2, int(100 * difficulty))) + + # Ensure conditions are met + while (num_remoras * remora_length >= length * 12 or + (num_remoras * remora_length) % 12 != 0 or + (length * 12) % (num_remoras * remora_length) != 0 or + 100 % int((num_remoras * remora_length)/(length * 12) * 100) != 0): + length = int(rng.randrange(10, int(500 * difficulty), 10)) + num_remoras = int(rng.randint(2, int(10 * difficulty))) + remora_length = int(rng.randint(2, int(100 * difficulty))) + + result = generate_from_variables(name, fish, length, num_remoras, remora_length) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_75(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name1: str, name2: str, color1: str, color2: str, + n1: int, n2: int, frac1: float, mult1: float) -> Dict[str, Any]: + + n1_result = int(n1 * frac1) + n2_result = int(n2 * mult1) + total = n1_result + n2_result + + question = f"{name1} has {n1} tubes of {color1} paint and {n2} tubes of {color2} paint. {name2} has half as many tubes of {color1} paint as {name1}, and three times as many tubes of {color2} paint as {name1}. How many tubes of paint does {name2} have?" + + answer_cot = f"{name2} has {n1}*{frac1}={n1_result} tubes of {color1} paint\n" \ + f"{name2} has {n2}*{mult1}={n2_result} tubes of {color2} paint\n" \ + f"{name2} has a total of {n1_result}+{n2_result}={total} tubes of paint\n" \ + f"#### {total}" + + return { + 'question': question, + 'answer': str(total), + 'answer_cot': answer_cot, + 'answer_value': total, + 'variables': { + 'name1': name1, + 'name2': name2, + 'color1': color1, + 'color2': color2, + 'n1': n1, + 'n2': n2, + 'frac1': frac1, + 'mult1': mult1, + 'n1_result': n1_result, + 'n2_result': n2_result + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Ben", "James", "John", "Michael", "William", "David", "Richard", "Joseph"] + colors = ["blue", "red", "green", "yellow", "purple", "orange"] + + name1, name2 = rng.sample(names, 2) + color1, color2 = rng.sample(colors, 2) + + # Generate numbers that ensure integer results + n1 = int(rng.randint(2, int(20 * difficulty))) + n2 = int(rng.randint(2, int(20 * difficulty))) + frac1 = 0.5 # half + mult1 = 3.0 # three times + + result = generate_from_variables(name1, name2, color1, color2, n1, n2, frac1, mult1) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_76(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(n: int, p1: int, p2: int, company: str, frac: float) -> Dict[str, Any]: + interviews = int(n * (p1/100)) + offers = int(interviews * (p2/100)) + accepts = int(offers * frac) + + question = f"{n} people apply for a job at {company}. Of the people that apply, only {p1}% receive interviews. Of those who receive interviews, {p2}% receive a job offer. Of those who receive a job offer, {frac:.2%} of the people accept the position. How many people accept the position?" + + answer_cot = f"The number of people that receive interviews is {n} * {p1/100} = {interviews} people\n" \ + f"The number of people that receive a job offer is {interviews} * {p2/100} = {offers} people\n" \ + f"The number of people that accept the position is {offers} * {frac} = {accepts} people\n" \ + f"#### {accepts}" + + return { + 'question': question, + 'answer': str(accepts), + 'answer_cot': answer_cot, + 'answer_value': accepts, + 'variables': { + 'total_applicants': n, + 'interview_percent': p1, + 'offer_percent': p2, + 'company': company, + 'acceptance_fraction': frac, + 'num_interviews': interviews, + 'num_offers': offers, + 'num_accepts': accepts + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + companies = ["Microsoft", "Apple", "Amazon", "Facebook", "Netflix", "Tesla", "Google"] + fractions = {"a third": 1/3, "half": 1/2, "a quarter": 1/4, "two thirds": 2/3} + + company = rng.choice(companies) + frac = fractions[rng.choice(list(fractions.keys()))] + + # Generate values ensuring all divisions result in integers + n = int(rng.randint(201, int(1001 * difficulty))) + p1 = int(rng.randint(10, int(51 * difficulty))) + p2 = int(rng.randint(10, int(51 * difficulty))) + + # Ensure integer results + while not (n * (p1/100)).is_integer() or \ + not (n * (p1/100) * (p2/100)).is_integer() or \ + not (n * (p1/100) * (p2/100) * frac).is_integer(): + n = int(rng.randint(201, int(1001 * difficulty))) + p1 = int(rng.randint(10, int(51 * difficulty))) + p2 = int(rng.randint(10, int(51 * difficulty))) + + result = generate_from_variables(n, p1, p2, company, frac) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_77(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(event: str, m: int, w: int, t: str, frac: float, m_left: int, + group1: str, group2: str) -> Dict[str, Any]: + total = m + w + left_count = int(total * frac) + stayed = total - left_count + w_left = stayed - m_left + + question = f"At the beginning of the {event}, there were {m} {group1} and {w} {group2}. After {t}, {frac} of the total number of people left. How many {group2} are left if {m_left} {group1} stayed at the {event}?" + + answer_cot = f"There were a total of {m} {group1} + {w} {group2} = {total} people who attended the {event}.\n" \ + f"After {t}, {total} people * {frac} = {left_count} people left the {event}.\n" \ + f"This means {total} people - {left_count} people = {stayed} people stayed.\n" \ + f"Out of the {stayed} who stayed, {stayed} people - {m_left} {group1} = {w_left} were {group2}.\n" \ + f"#### {w_left}" + + return { + 'question': question, + 'answer': str(w_left), + 'answer_cot': answer_cot, + 'answer_value': w_left, + 'variables': { + 'event': event, + 'men': m, + 'women': w, + 'time': t, + 'fraction_left': frac, + 'men_stayed': m_left, + 'women_stayed': w_left, + 'group1': group1, + 'group2': group2 + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + events = ['party', 'meeting', 'conference', 'gathering', 'celebration'] + groups = ["teachers", "doctors", "engineers", "nurses", "artists", "lawyers"] + times = ['an hour', 'two hours', 'half an hour', '45 minutes'] + fractions = [0.25, 0.5, 0.75, 0.33, 0.67] + + event = rng.choice(events) + group1, group2 = rng.sample(groups, 2) + t = rng.choice(times) + frac = rng.choice(fractions) + + m = int(rng.randint(20, int(75 * difficulty))) + w = int(rng.randint(10, int(80 * difficulty))) + total = m + w + + # Ensure fraction calculations result in integers + while not (total * frac).is_integer(): + m = int(rng.randint(20, int(75 * difficulty))) + w = int(rng.randint(10, int(80 * difficulty))) + total = m + w + + stayed = total - int(total * frac) + m_left = int(rng.randint(15, min(stayed-1, int(35 * difficulty)))) + + result = generate_from_variables(event, m, w, t, frac, m_left, group1, group2) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_78(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name1: str, name2: str, age_diff: int, age1: int) -> Dict[str, Any]: + age2 = age1 + age_diff + avg_age = (age1 + age2) // 2 + + question = f"{name1} and {name2} are currently {age_diff} years apart in age. If {name1}, who is younger than {name2}, is {age1} years old, what's the average of their ages?" + + answer_cot = f"If {name1} is {age1} years old, {name2} is {age1}+{age_diff} = {age2} years old.\n" \ + f"The sum of their ages is {age2}+{age1} = {age1+age2} years\n" \ + f"The average age of the two is {age1+age2}/2 = {avg_age} years\n" \ + f"#### {avg_age}" + + return { + 'question': question, + 'answer': str(avg_age), + 'answer_cot': answer_cot, + 'answer_value': avg_age, + 'variables': { + 'name1': name1, + 'name2': name2, + 'age_diff': age_diff, + 'age1': age1, + 'age2': age2, + 'avg_age': avg_age + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte", "Amelia"] + name1, name2 = rng.sample(names, 2) + + age_diff = int(rng.randint(5, int(30 * difficulty))) + age1 = int(rng.randint(15, int(75 * difficulty))) + + # Ensure average is an integer + while (2 * age1 + age_diff) % 2 != 0: + age1 = int(rng.randint(15, int(75 * difficulty))) + + result = generate_from_variables(name1, name2, age_diff, age1) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_79(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, vehicle: str, start_time: int, end_time: int, + free_hours: int, currency: str, first_hour_cost: int, + multiplier: int) -> Dict[str, Any]: + total_hours = end_time - start_time + paid_hours = total_hours - free_hours + other_hours = paid_hours - 1 + hourly_rate = first_hour_cost * multiplier + other_hours_cost = other_hours * hourly_rate + total_cost = first_hour_cost + other_hours_cost + + question = f"{name} hires a {vehicle} from {start_time} PM to {end_time} PM. He gets {free_hours} hour free. The first paid hour is {currency}{first_hour_cost} and each hour after that is {multiplier} times the cost. How much did he pay?" + + answer_cot = f"He got it for {end_time}-{start_time}={total_hours} hours\n" \ + f"He pays for {total_hours}-{free_hours}={paid_hours} hours\n" \ + f"The first hour cost 1*{first_hour_cost}={currency}{first_hour_cost}\n" \ + f"The other {paid_hours}-1={other_hours} hours are more expensive\n" \ + f"They cost {first_hour_cost}*{multiplier}={currency}{hourly_rate} per hour\n" \ + f"So those {other_hours} hours cost {other_hours}*{hourly_rate}={currency}{other_hours_cost}\n" \ + f"So he pays {other_hours_cost}+{first_hour_cost}={currency}{total_cost}\n" \ + f"#### {total_cost}" + + return { + 'question': question, + 'answer': str(total_cost), + 'answer_cot': answer_cot, + 'answer_value': total_cost, + 'variables': { + 'name': name, + 'vehicle': vehicle, + 'start_time': start_time, + 'end_time': end_time, + 'free_hours': free_hours, + 'currency': currency, + 'first_hour_cost': first_hour_cost, + 'multiplier': multiplier, + 'total_hours': total_hours, + 'paid_hours': paid_hours, + 'total_cost': total_cost + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["James", "John", "Robert", "Michael", "William", "David", "Richard"] + vehicles = ["limousine", "party bus", "boat", "luxury car"] + currencies = ["$", "€", "£"] + + name = rng.choice(names) + vehicle = rng.choice(vehicles) + currency = rng.choice(currencies) + + start_time = int(rng.randint(1, int(8 * difficulty))) + end_time = int(rng.randint(start_time + 2, int(12 * difficulty))) + free_hours = int(rng.randint(1, min(3, end_time - start_time - 1))) + first_hour_cost = int(rng.randint(10, int(51 * difficulty))) + multiplier = 2 + + # Verify conditions + while not ((end_time - start_time > free_hours + 1) and + ((end_time - start_time - free_hours - 1) * first_hour_cost * multiplier).is_integer()): + start_time = int(rng.randint(1, int(8 * difficulty))) + end_time = int(rng.randint(start_time + 2, int(12 * difficulty))) + free_hours = int(rng.randint(1, min(3, end_time - start_time - 1))) + first_hour_cost = int(rng.randint(10, int(51 * difficulty))) + + result = generate_from_variables(name, vehicle, start_time, end_time, free_hours, + currency, first_hour_cost, multiplier) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_80(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, color1: str, color2: str, n1: int, n2: int, + n3: int, n4: int) -> Dict[str, Any]: + blue_spools = n1 + n2 + total_spools = n1 + n2 + n3 + n4 + percent_blue = int(100 * blue_spools / total_spools) + + question = f"{name} has {n1} light {color1} spools of thread, {n2} dark {color1} spools of thread, {n3} light {color2} spools of thread, and {n4} dark {color2} spools of thread. What percent of her spools are {color1}?" + + answer_cot = f"First find the number of {color1} spools: {n1} spools + {n2} spools = {blue_spools} spools\nThen find the total number of spools: {n3} spools + {n4} spools + {blue_spools} spools = {total_spools} spools\nThen divide the number of {color1} spools by the total number of spools and multiply by 100% to express the answer as a percentage: {blue_spools} spools / {total_spools} spools * 100% = {percent_blue}%\n#### {percent_blue}" + + return { + 'question': question, + 'answer': str(percent_blue), + 'answer_cot': answer_cot, + 'answer_value': percent_blue, + 'variables': { + 'name': name, + 'color1': color1, + 'color2': color2, + 'light_color1_spools': n1, + 'dark_color1_spools': n2, + 'light_color2_spools': n3, + 'dark_color2_spools': n4, + 'total_color1_spools': blue_spools, + 'total_spools': total_spools, + 'percent_color1': percent_blue + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Candy", "Sarah", "Emma", "Olivia", "Isabella", "Sophia", "Mia", "Charlotte"] + colors = ["blue", "red", "green", "yellow", "purple", "orange"] + + name = rng.choice(names) + color1, color2 = rng.sample(colors, 2) + + # Generate numbers ensuring integer percentage result + n1 = int(rng.randint(15, int(45 * difficulty))) + n2 = int(rng.randint(45, int(100 * difficulty))) + n3 = int(rng.randint(20, int(80 * difficulty))) + n4 = int(rng.randint(50, int(100 * difficulty))) + + # Ensure percentage is integer + total = n1 + n2 + n3 + n4 + while ((n1 + n2) * 100) % total != 0: + n4 += 1 + total = n1 + n2 + n3 + n4 + + result = generate_from_variables(name, color1, color2, n1, n2, n3, n4) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_81(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(occupation: str, weeks_per_month: int, days_per_week: int, + pay_per_day: int, currency: str) -> Dict[str, Any]: + days_per_month = days_per_week * weeks_per_month + monthly_pay = days_per_month * pay_per_day + yearly_pay = monthly_pay * 12 + + question = f"A {occupation} works for {weeks_per_month} weeks every month and for {days_per_week} days every week. If he gets paid {currency}{pay_per_day} every day, how much does he earn if he works for a year?" + + answer_cot = f"The {occupation} works for {days_per_week} days every week and works for {weeks_per_month} weeks every month so he works for {days_per_week} days/week * {weeks_per_month} weeks/month = {days_per_month} days/month\nIf he earns {currency}{pay_per_day} every day he then earns {currency}{pay_per_day}/day * {days_per_month} days/month = {currency}{monthly_pay}/month\nA year is equal to 12 months so every year he earns {currency}{monthly_pay}/month * 12 months/year = {currency}{yearly_pay}\n#### {yearly_pay}" + + return { + 'question': question, + 'answer': str(yearly_pay), + 'answer_cot': answer_cot, + 'answer_value': yearly_pay, + 'variables': { + 'occupation': occupation, + 'weeks_per_month': weeks_per_month, + 'days_per_week': days_per_week, + 'pay_per_day': pay_per_day, + 'currency': currency, + 'days_per_month': days_per_month, + 'monthly_pay': monthly_pay + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + occupations = ["plumber", "electrician", "painter", "carpenter", "landscaper"] + currencies = ["$", "£", "€"] + + occupation = rng.choice(occupations) + currency = rng.choice(currencies) + + weeks_per_month = int(rng.randint(2, int(5 * difficulty))) + days_per_week = int(rng.randint(4, int(7 * difficulty))) + pay_per_day = int(rng.randrange(40, int(200 * difficulty), 5)) + + result = generate_from_variables(occupation, weeks_per_month, days_per_week, + pay_per_day, currency) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_82(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, num_emails: int, no_response_percent: int, + workdays: int) -> Dict[str, Any]: + no_response = num_emails * no_response_percent // 100 + responds_to = num_emails - no_response + total_responses = responds_to * workdays + + question = f"{name} gets {num_emails} emails a day. {no_response_percent}% of those emails don't require any response. {name} responds to the rest of them. How many emails does {name} respond to in a {workdays} day work week?" + + answer_cot = f"{name} receives {no_response}={no_response} emails that don't require a response\n" \ + f"So {name} responds to {num_emails}-{no_response}={responds_to} emails per day\n" \ + f"In a {workdays} day work week, {name} responds to {responds_to}*{workdays}={total_responses} emails\n" \ + f"#### {total_responses}" + + return { + 'question': question, + 'answer': str(total_responses), + 'answer_cot': answer_cot, + 'answer_value': total_responses, + 'variables': { + 'name': name, + 'num_emails': num_emails, + 'no_response_percent': no_response_percent, + 'workdays': workdays, + 'no_response': no_response, + 'responds_to': responds_to, + 'total_responses': total_responses + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"] + name = rng.choice(names) + + # Generate random values scaled by difficulty + num_emails = int(rng.randint(50, int(200 * difficulty))) + no_response_percent = int(rng.randint(5, int(40 * difficulty))) + workdays = int(rng.randint(3, int(7 * difficulty))) + + # Ensure conditions are met + while not (num_emails * no_response_percent % 100 == 0 and + num_emails * (100 - no_response_percent) % 100 == 0): + num_emails = int(rng.randint(50, int(200 * difficulty))) + no_response_percent = int(rng.randint(5, int(40 * difficulty))) + + result = generate_from_variables(name, num_emails, no_response_percent, workdays) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_83(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name1: str, name2: str, total: int, diff: int, unit: str) -> Dict[str, Any]: + amount1 = (total - diff) // 2 # Sam's amount + amount2 = amount1 + diff # Harry's amount + + question = f"If {name1} and {name2} have {total} {unit} of fence between them, and they agree to split it with {name2} getting {diff} {unit} more than {name1}, how much is left over for {name1}?" + + answer_cot = f"Let x be the amount of fence {name1} gets and y be the amount {name2} gets. We know that y = x + {diff}, and y + x = {total}.\nSubstituting the first equation into the second equation, we get 2x+{diff}={total}\nSubtracting the {diff} from both sides, we get 2x={total-diff}\nWe divide each side by two, leaving x={amount1}. This means {name1} has {amount1} {unit} of fence left over.\n#### {amount1}" + + return { + 'question': question, + 'answer': str(amount1), + 'answer_cot': answer_cot, + 'answer_value': amount1, + 'variables': { + 'name1': name1, + 'name2': name2, + 'total_fence': total, + 'difference': diff, + 'unit': unit, + 'amount1': amount1, + 'amount2': amount2 + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ['Sam', 'Harry', 'Tom', 'John', 'Mike', 'Dave', 'Steve', 'Bob'] + units = ['feet', 'yards', 'meters'] + + name1, name2 = rng.sample(names, 2) + unit = rng.choice(units) + + # Scale ranges by difficulty while maintaining integer division + diff = int(rng.randrange(20, int(200 * difficulty), 10)) + total = int(rng.randrange(diff + 20, int(1000 * difficulty), 20)) + + # Ensure conditions are met + while total - diff <= 10 or (total - diff) % 2 != 0: + diff = int(rng.randrange(20, int(200 * difficulty), 10)) + total = int(rng.randrange(diff + 20, int(1000 * difficulty), 20)) + + result = generate_from_variables(name1, name2, total, diff, unit) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_84(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, miles: str, time_cold: int, extra_time: int, + multiplier: float, distance: int) -> Dict[str, Any]: + time_warm = extra_time + multiplier * time_cold + time_cold_total = distance * time_cold + time_warm_total = distance * time_warm + time_difference = time_warm_total - time_cold_total + + question = f"When the water is cold {name} swims a {miles} in {time_cold} minutes. When the water is warm {name} swims a {miles} in {extra_time} minutes more than {multiplier:.0f} times as long. How much longer does {name} take to swim {distance} {miles}s on a hot day than a cold day?" + + answer_cot = f"Cold water {miles} = {time_cold} minutes\n" \ + f"Warm water {miles} = {extra_time}+{multiplier:.0f}({time_cold})={time_warm} minutes\n" \ + f"{distance} {miles}s in cold water: {distance}({time_cold})={time_cold_total} minutes\n" \ + f"{distance} {miles}s in warm water: {distance}({time_warm})={time_warm_total} minutes\n" \ + f"{name} takes {time_warm_total}-{time_cold_total}={time_difference} minutes longer\n" \ + f"#### {time_difference}" + + return { + 'question': question, + 'answer': str(time_difference), + 'answer_cot': answer_cot, + 'answer_value': time_difference, + 'variables': { + 'name': name, + 'unit': miles, + 'time_cold': time_cold, + 'extra_time': extra_time, + 'multiplier': multiplier, + 'distance': distance, + 'time_warm': time_warm, + 'time_cold_total': time_cold_total, + 'time_warm_total': time_warm_total + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Ray", "Jim", "Bob", "Tom", "Mike", "John", "Steve"] + units = ["mile", "kilometer"] + + name = rng.choice(names) + unit = rng.choice(units) + + time_cold = int(rng.randint(10, int(50 * difficulty))) + extra_time = int(rng.randint(1, int(10 * difficulty))) + multiplier = 2.0 # "twice" specified in original + distance = int(rng.randint(2, int(10 * difficulty))) + + # Check conditions + while time_cold >= 60 or \ + extra_time + multiplier * time_cold >= 60 or \ + distance * (extra_time + multiplier * time_cold) - distance * time_cold <= 0: + time_cold = int(rng.randint(10, int(50 * difficulty))) + extra_time = int(rng.randint(1, int(10 * difficulty))) + distance = int(rng.randint(2, int(10 * difficulty))) + + result = generate_from_variables(name, unit, time_cold, extra_time, multiplier, distance) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_85(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, room_type: str, area: int, length: int, + unit1: str, unit2: str) -> Dict[str, Any]: + conversion = 3 if unit1 == 'feet' and unit2 == 'yards' else 1 + length_converted = length * conversion + width = area // length_converted + perimeter = 2 * (width + length_converted) + + question = f"The area of {name}'s rectangular {room_type} is {area} square {unit1}. If the length of his room is {length} {unit2}, what is the perimeter of the room in {unit1}?" + + answer_cot = f"The length of the room is {length} {unit2} * ({conversion} {unit1} / 1 {unit2}) = {length_converted} {unit1}.\n" \ + f"The width of the room is {area} square {unit1} / {length_converted} {unit1} = {width} {unit1}.\n" \ + f"The room's perimeter is 2({width}+{length_converted}) = {perimeter}\n#### {perimeter}" + + return { + 'question': question, + 'answer': str(perimeter), + 'answer_cot': answer_cot, + 'answer_value': perimeter, + 'variables': { + 'name': name, + 'room_type': room_type, + 'area': area, + 'length': length, + 'unit1': unit1, + 'unit2': unit2, + 'width': width, + 'length_converted': length_converted + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["William", "James", "John", "Michael", "David", "Robert", "Thomas"] + room_types = ["living room", "study", "office", "kitchen"] + units = ["feet", "meters"] + + name = rng.choice(names) + room_type = rng.choice(room_types) + unit1 = rng.choice(units) + unit2 = "yards" if unit1 == "feet" else "meters" + + length = int(rng.randint(5, int(44 * difficulty))) + + # Ensure width is larger than length and area calculation results in integer + conversion = 3 if unit1 == 'feet' and unit2 == 'yards' else 1 + width = int(rng.randint(length * conversion + 1, int(100 * difficulty))) + area = width * (length * conversion) + + result = generate_from_variables(name, room_type, area, length, unit1, unit2) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_86(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(animals: str, unit: str, o1: str, o2: str, o3: str, o4: str, + n1: int, n2: int, n3: int, n4: int, + w1: int, w2: int, w3: int, w4: int, + total: int) -> Dict[str, Any]: + # Calculate weights + sugar_weight = n4 * w4 + carrot_weight = n3 * w3 + hay_weight = n1 * w1 + oat_weight = n2 * w2 + total_weight = sugar_weight + carrot_weight + hay_weight + oat_weight + trips = total_weight // total + + question = f"A farmer is buying feed for his {animals}. He buys a variety of {o1}, {o2}, {o3} and {o4}. Since {o4} are a rare treat, he only buys {n4} {w4}-{unit} boxes of them for the whole stable. He only wants enough {o3} to feed the {animals} while the vegetables are fresh, so he buys {n3} {w3}-{unit} bags. {o1} is the main diet of his {animals}, so he buys {n1} {w1}-{unit} bales. {o2} are a staple to supplement the {o1}, so he buys {n2} {w2}-{unit} sacks. If his farm truck can carry {total} {unit}s at a time, how many trips does the farmer need to transport all the feed?" + + answer_cot = f"The farmer is buying {n4} * {w4} = {sugar_weight} {unit}s of {o4}.\nHe is buying {n3} * {w3} = {carrot_weight} {unit}s of {o3}.\nHe is buying {n1} * {w1} = {hay_weight} {unit}s of {o1}.\nHe is buying {n2} * {w2} = {oat_weight} {unit}s of {o2}.\nThe weight of all the feed is {sugar_weight} + {carrot_weight} + {hay_weight} + {oat_weight} = {total_weight} {unit}s.\nThus, the farmer needs {total_weight} / {total} = {trips} trips to transport all the feed in his farm truck.\n#### {trips}" + + return { + 'question': question, + 'answer': str(trips), + 'answer_cot': answer_cot, + 'answer_value': trips, + 'variables': { + 'animals': animals, + 'unit': unit, + 'feed_types': [o1, o2, o3, o4], + 'quantities': [n1, n2, n3, n4], + 'weights': [w1, w2, w3, w4], + 'truck_capacity': total, + 'total_weight': total_weight + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + animals = rng.choice(['horses', 'cows', 'sheep', 'pigs', 'alpacas']) + unit = rng.choice(['pound', 'kilogram']) + feed_options = ["hay", "corn", "oats", "apples", "wheat"] + o1, o2, o4 = rng.sample(feed_options, 3) + o3 = rng.choice(["carrots", "beets", "cucumbers"]) + + # Scale ranges by difficulty + n4 = int(rng.randint(4, int(8 * difficulty))) + n3 = int(rng.randint(11, int(15 * difficulty))) + n2 = int(rng.randint(15, int(20 * difficulty))) + n1 = int(rng.randint(31, int(35 * difficulty))) + + w4 = int(rng.randint(3, int(8 * difficulty))) + w3 = int(rng.randint(5, int(10 * difficulty))) + w2 = int(rng.randint(15, int(20 * difficulty))) + w1 = int(rng.randint(35, int(45 * difficulty))) + + # Ensure weight conditions are met + while not (w4*n4 < w3*n3 < w2*n2 < w1*n1): + w4 = int(rng.randint(3, int(8 * difficulty))) + w3 = int(rng.randint(5, int(10 * difficulty))) + w2 = int(rng.randint(15, int(20 * difficulty))) + w1 = int(rng.randint(35, int(45 * difficulty))) + + total_weight = n1*w1 + n2*w2 + n3*w3 + n4*w4 + # Find truck capacity that divides total weight + total = total_weight // rng.randint(2, 4) + + result = generate_from_variables(animals, unit, o1, o2, o3, o4, + n1, n2, n3, n4, w1, w2, w3, w4, total) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_87(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, unit: str, weight_large: int, weight_medium: int, + weight_small: Fraction, num_large: int, num_medium: int, + num_small: int, total_amount: int) -> Dict[str, Any]: + + large_used = num_large * weight_large + medium_used = num_medium * weight_medium + small_used = float(num_small * weight_small) + total_used = large_used + medium_used + small_used + remaining = total_amount - total_used + + question = f"{name} wants to make different sized ice cubes with {total_amount} {unit}s of water. He can make giant cubes that use {weight_large} {unit}s per cube, medium cubes that use {weight_medium} {unit}s, and small cubes that use {weight_small} an {unit}. If he makes {num_large} giant cubes, {num_medium} medium cubes, and {num_small} small cubes, how many {unit}s of water does he have left?" + + answer_cot = f"The giant cubes used up {large_used} {unit}s of water because {num_large} times {weight_large} equals {large_used}.\n" \ + f"The medium cubes used up {medium_used} {unit}s of water because {num_medium} times {weight_medium} equals {medium_used}.\n" \ + f"The small cubes used up {int(small_used)} {unit}s of water because {num_small} times {weight_small} equals {int(small_used)}.\n" \ + f"This means that {name} has used up {int(total_used)} {unit}s of water because {large_used} plus {medium_used} plus {int(small_used)} equals {int(total_used)}.\n" \ + f"{name} has {int(remaining)} {unit}s of water left because {total_amount} minus {int(total_used)} equals {int(remaining)}.\n" \ + f"#### {int(remaining)}" + + return { + 'question': question, + 'answer': str(int(remaining)), + 'answer_cot': answer_cot, + 'answer_value': int(remaining), + 'variables': { + 'name': name, + 'unit': unit, + 'weight_large': weight_large, + 'weight_medium': weight_medium, + 'weight_small': weight_small, + 'num_large': num_large, + 'num_medium': num_medium, + 'num_small': num_small, + 'total_amount': total_amount, + 'remaining': remaining + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Peter", "John", "Michael", "David", "James", "Robert", "William"] + units = ["ounce", "gram", "milliliter"] + + name = rng.choice(names) + unit = rng.choice(units) + + weight_large = int(rng.randint(7, int(14 * difficulty))) + weight_medium = int(rng.randint(3, weight_large - 1)) + weight_small = Fraction(1, 2) + + num_large = int(rng.randint(2, int(8 * difficulty))) + num_medium = int(rng.randint(4, int(12 * difficulty))) + num_small = rng.choice([14, 24, 15]) + + # Calculate needed total to ensure positive remainder + used = num_large * weight_large + num_medium * weight_medium + float(num_small * weight_small) + total_amount = int(used + rng.randint(1, int(10 * difficulty))) + + result = generate_from_variables(name, unit, weight_large, weight_medium, weight_small, + num_large, num_medium, num_small, total_amount) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_88(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(school: str, venue: str, total: int, graduates: int, faculty: int) -> Dict[str, Any]: + remaining_seats = total - (graduates + faculty) + tickets_per_graduate = remaining_seats // graduates + + question = f"{school} is holding graduation in their {venue} this year which has space for {total} people. After accounting for {graduates} seats for graduates and {faculty} seats for faculty attending, how many tickets would each graduate receive to give to their friends and family if the tickets are split equally?" + + answer_cot = f"Add graduate and faculty seats together. {graduates} + {faculty} = {graduates+faculty} seats for faculty and graduates\nMinus seats for faculty and graduates from total seats allowed. {total} - {graduates+faculty} = {remaining_seats} remaining seats.\nDivide remaining seats by the number of graduates. {remaining_seats}/{graduates} = {tickets_per_graduate} tickets\n#### {tickets_per_graduate}" + + return { + 'question': question, + 'answer': str(tickets_per_graduate), + 'answer_cot': answer_cot, + 'answer_value': tickets_per_graduate, + 'variables': { + 'school': school, + 'venue': venue, + 'total_seats': total, + 'graduate_seats': graduates, + 'faculty_seats': faculty, + 'remaining_seats': remaining_seats, + 'tickets_per_graduate': tickets_per_graduate + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + schools = ["Oakwood High School", "Riverside Academy", "Sunnyside High", "Greenville High School"] + venues = ["Auditorium", "Gymnasium", "Sports Arena", "Convention Center"] + + school = rng.choice(schools) + venue = rng.choice(venues) + + graduates = int(rng.randrange(500, int(1500 * difficulty), 50)) + faculty = int(rng.randrange(100, int(500 * difficulty), 50)) + + # Ensure total seats allow for integer division of remaining seats + remaining_seats = rng.randint(2, int(10 * difficulty)) * graduates + total = remaining_seats + graduates + faculty + + result = generate_from_variables(school, venue, total, graduates, faculty) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_89(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name1: str, name2: str, name3: str, name4: str, name5: str, + num_dozen: int, found_first: int, multiplier: float, + less_amount: int, fraction: float) -> Dict[str, Any]: + total_eggs = num_dozen * 12 + found_second = found_first * multiplier + found_third = found_second - less_amount + found_fourth = found_third * fraction + total_found = found_first + found_second + found_third + found_fourth + remaining = total_eggs - total_found + + question = f"{name1} hid {num_dozen} dozen eggs in the yard for the Easter egg hunt. {name2} finds {found_first} eggs. {name3} finds {multiplier:.0f} times as many as {name2}. {name4} finds {less_amount} less than {name3}, and {name5} finds {fraction:.1f} as many as {name4}. How many eggs are still hidden in the yard?" + + answer_cot = f"{name1} hides {num_dozen} x 12 = {total_eggs} eggs.\n" + answer_cot += f"{name2} finds {found_first} eggs.\n" + answer_cot += f"{name3} finds {found_first} x {multiplier:.0f} = {found_second} eggs.\n" + answer_cot += f"{name4} finds {found_second} - {less_amount} = {found_third} eggs.\n" + answer_cot += f"{name5} finds {found_third} x {fraction:.1f} = {found_fourth} eggs.\n" + answer_cot += f"The children find a total of {found_first} + {found_second} + {found_third} + {found_fourth} = {total_found} eggs.\n" + answer_cot += f"The total number of hidden eggs still in the yard is {total_eggs} - {total_found} = {remaining} eggs.\n#### {remaining}" + + return { + 'question': question, + 'answer': str(remaining), + 'answer_cot': answer_cot, + 'answer_value': remaining, + 'variables': { + 'name1': name1, + 'name2': name2, + 'name3': name3, + 'name4': name4, + 'name5': name5, + 'num_dozen': num_dozen, + 'found_first': found_first, + 'multiplier': multiplier, + 'less_amount': less_amount, + 'fraction': fraction, + 'total_eggs': total_eggs, + 'total_found': total_found, + 'remaining': remaining + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Emma", "Liam", "Olivia", "Noah", "Ava", "Oliver", "Isabella", "William", + "Sophia", "James", "Charlotte", "Benjamin", "Mia", "Lucas", "Harper"] + + name1, name2, name3, name4, name5 = rng.sample(names, 5) + + num_dozen = int(rng.randint(2, int(10 * difficulty))) + found_first = int(rng.randint(3, int(15 * difficulty))) + multiplier = 2.0 # Using 'twice' as specified + less_amount = int(rng.randint(1, int(5 * difficulty))) + fraction = 0.5 # Using 'half' as specified + + # Ensure all conditions are met + total = num_dozen * 12 + found_second = found_first * multiplier + found_third = found_second - less_amount + found_fourth = found_third * fraction + total_found = found_first + found_second + found_third + found_fourth + + # Regenerate if conditions not met + while (not found_third > 0 or not total > total_found or + not float(found_fourth).is_integer()): + num_dozen = int(rng.randint(2, int(10 * difficulty))) + found_first = int(rng.randint(3, int(15 * difficulty))) + less_amount = int(rng.randint(1, int(5 * difficulty))) + total = num_dozen * 12 + found_second = found_first * multiplier + found_third = found_second - less_amount + found_fourth = found_third * fraction + total_found = found_first + found_second + found_third + found_fourth + + result = generate_from_variables(name1, name2, name3, name4, name5, + num_dozen, found_first, multiplier, + less_amount, fraction) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_90(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(device: str, currency: str, rate1: float, rate2: float, + threshold: int, total_mins: int) -> Dict[str, Any]: + first_period = threshold + second_period = total_mins - threshold + + cost1 = first_period * rate1 + cost2 = second_period * rate2 + total_cost = int(cost1 + cost2) + + question = f"To make a call from a {device}, you must pay {currency}{rate1} for each minute of your call. After {threshold} minutes, that price drops to {currency}{rate2} per minute. How much would a {total_mins}-minute call cost?" + + answer_cot = f"First {threshold} minutes would be a cost of {threshold} * {rate1} = {currency}{int(cost1)}.\nAfter that, there are {total_mins} - {threshold} = {second_period} minutes of the call left.\nAnd these {second_period} minutes cost {second_period} * {rate2} = {currency}{int(cost2)}.\nSo in total, the {total_mins}-minute call would cost {int(cost1)} + {int(cost2)} = {currency}{total_cost}.\n#### {total_cost}" + + return { + 'question': question, + 'answer': str(total_cost), + 'answer_cot': answer_cot, + 'answer_value': total_cost, + 'variables': { + 'device': device, + 'currency': currency, + 'rate1': rate1, + 'rate2': rate2, + 'threshold': threshold, + 'total_mins': total_mins, + 'first_period_cost': int(cost1), + 'second_period_cost': int(cost2) + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + devices = ['payphone', 'phone booth', 'hotel room phone'] + currencies = ['$', '£', '€'] + + device = rng.choice(devices) + currency = rng.choice(currencies) + + # Generate rates ensuring rate2 < rate1 + rate1 = round(rng.uniform(0.2, 0.5 * difficulty), 2) + rate2 = round(rng.uniform(0.1, rate1), 2) + + threshold = int(rng.randint(10, int(50 * difficulty))) + total_mins = int(rng.randint(threshold + 10, int(100 * difficulty))) + + # Ensure calculations result in integers + while not (threshold * rate1).is_integer() or not ((total_mins - threshold) * rate2).is_integer(): + rate1 = round(rng.uniform(0.2, 0.5 * difficulty), 2) + rate2 = round(rng.uniform(0.1, rate1), 2) + + result = generate_from_variables(device, currency, rate1, rate2, threshold, total_mins) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_91(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, fruit: str, area: str, + field_size: int, density: int, months: int) -> Dict[str, Any]: + fruits_per_harvest = field_size * density + harvests_per_year = 12 // months + total_fruits = fruits_per_harvest * harvests_per_year + + question = f"{name} has {field_size} {area}s of a {fruit} field. There are {density} {fruit}s per {area}. {name} can harvest his {fruit}s every {months} months. How many {fruit}s can {name} harvest within a year?" + + answer_cot = f"{name} has {density} x {field_size}= {fruits_per_harvest} {fruit}s on his field.\n{name} can harvest his {fruit}s 12 ÷ {months} = {harvests_per_year} times per year\nTherefore {name} can harvest {fruits_per_harvest} x {harvests_per_year} = {total_fruits} {fruit}s per year.\n#### {total_fruits}" + + return { + 'question': question, + 'answer': str(total_fruits), + 'answer_cot': answer_cot, + 'answer_value': total_fruits, + 'variables': { + 'name': name, + 'fruit': fruit, + 'area': area, + 'field_size': field_size, + 'density': density, + 'months_per_harvest': months, + 'fruits_per_harvest': fruits_per_harvest, + 'harvests_per_year': harvests_per_year + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["John", "Michael", "David", "James", "Robert", "William", "Richard"] + fruits = ["pineapple", "mango", "banana", "papaya", "coconut"] + areas = ["hectare", "square yard", "square meter"] + + name = rng.choice(names) + fruit = rng.choice(fruits) + area = rng.choice(areas) + + field_size = int(rng.randrange(5, int(100 * difficulty), 5)) + density = int(rng.randint(2, int(101 * difficulty))) + months = rng.choice([1, 2, 3, 4, 6, 12]) + + result = generate_from_variables(name, fruit, area, field_size, density, months) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_92(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, product: str, location: str, + item1: str, item2: str, item3: str, + price1: float, price2: float, price3: float, + num1: int, num2: int, num3: int, + unit: str, currency: str) -> Dict[str, Any]: + + round_p1 = round(price1) + round_p2 = round(price2) + round_p3 = round(price3) + + total = num1 * round_p1 + num2 * round_p2 + num3 * round_p3 + + question = f"{name} has a {product} stand at the {location}. He sells three kinds of {product}s: {item1}, {item2} and {item3}. He usually sells {item1} for {currency}{price1:.2f} per {unit}, {item2} for {currency}{price2:.2f} per {unit} and {item3} for {currency}{price3:.2f} per {unit}. {name} has no change today, so he has decided to round all his prices to the nearest dollar. If {name} sells {num1} {unit}s of {item1}, {num2} {unit}s of {item2} and {num3} {unit}s of {item3}, how much will he make?" + + answer_cot = f"{name} will round his {item1} {'up' if round_p1 > price1 else 'down'} from {currency}{price1:.2f} to {currency}{round_p1}, since the number following the {int(price1)} is {'5 or higher' if round_p1 > price1 else 'less than 5'}.\n" + answer_cot += f"{name} will round his {item2} {'up' if round_p2 > price2 else 'down'} from {currency}{price2:.2f} to {currency}{round_p2}, since the number following the {int(price2)} is {'5 or higher' if round_p2 > price2 else 'less than 5'}.\n" + answer_cot += f"{name} will round his {item3} {'up' if round_p3 > price3 else 'down'} from {currency}{price3:.2f} to {currency}{round_p3}, since the number following the {int(price3)} is {'5 or higher' if round_p3 > price3 else 'less than 5'}.\n" + answer_cot += f"{name} sells {num1} {item1} x {currency}{round_p1} = {currency}{num1*round_p1}\n" + answer_cot += f"{name} sells {num2} {item2} x {currency}{round_p2} = {currency}{num2*round_p2}\n" + answer_cot += f"{name} sells {num3} {item3} x {currency}{round_p3} = {currency}{num3*round_p3}\n" + answer_cot += f"Altogether, {name} will make {currency}{num1*round_p1} + {currency}{num2*round_p2} + {currency}{num3*round_p3} = {currency}{total}\n#### {total}" + + return { + 'question': question, + 'answer': str(total), + 'answer_cot': answer_cot, + 'answer_value': total, + 'variables': { + 'name': name, + 'product': product, + 'location': location, + 'items': [item1, item2, item3], + 'original_prices': [price1, price2, price3], + 'rounded_prices': [round_p1, round_p2, round_p3], + 'quantities': [num1, num2, num3], + 'unit': unit, + 'currency': currency + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ['John', 'Mike', 'David', 'James', 'Robert', 'William', 'Richard'] + products = ['vegetable', 'flower', 'herb', 'plant'] + locations = ['local fair', 'community market', 'street bazaar', 'town square'] + items = ['roses', 'daisies', 'tulips', 'lilies', 'sunflowers', 'orchids'] + units = ['bunch', 'basket', 'bouquet', 'bundle'] + currencies = ['$', '£', '€'] + + name = rng.choice(names) + product = rng.choice(products) + location = rng.choice(locations) + item1, item2, item3 = rng.sample(items, 3) + unit = rng.choice(units) + currency = rng.choice(currencies) + + # Scale prices by difficulty + price1 = round(rng.uniform(1.26, 3.53 * difficulty), 2) + price2 = round(rng.uniform(2.27, 5.53 * difficulty), 2) + price3 = round(rng.uniform(4.85, 6.53 * difficulty), 2) + + num1 = int(rng.randint(5, int(21 * difficulty))) + num2 = int(rng.randint(15, int(31 * difficulty))) + num3 = int(rng.randint(35, int(41 * difficulty))) + + result = generate_from_variables(name, product, location, item1, item2, item3, + price1, price2, price3, num1, num2, num3, + unit, currency) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_93(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name1: str, name2: str, name3: str, name4: str, + creature: str, weapon1: str, weapon2: str, weapon3: str, + weapon4: str, weapon5: str, n1: int, frac1: float, + mult1: int, frac2: float) -> Dict[str, Any]: + + kills_arthur = int(n1 * frac1) + kills_walter = int(kills_arthur * mult1) + kills_bruce = int(kills_walter * frac2) + + question = f"{name1} slew {n1} {creature} with his mighty {weapon1}, while {name2}, using a {weapon2}, slew {frac1} as many {creature} as {name1}. Using a {weapon3}, {name3} slew {mult1} as many {creature} as {name2}. But {name4}, having forgot his {weapon4} at home, slew {frac2} as many {creature} as {name3} using a {weapon5}. How many {creature} has {name4} slain?" + + answer_cot = f"{name2} slew {frac1} as many {creature} as {name1}, or {n1}*{frac1}={kills_arthur} {creature}.\n{name3} slew {mult1} as many {creature} as {name2}, or {mult1}*{kills_arthur}={kills_walter} {creature}.\n{name4} slew {frac2} as many {creature} as {name3}, or {kills_walter}*{frac2}={kills_bruce} {creature}.\n#### {kills_bruce}" + + return { + 'question': question, + 'answer': str(kills_bruce), + 'answer_cot': answer_cot, + 'answer_value': kills_bruce, + 'variables': { + 'name1': name1, + 'name2': name2, + 'name3': name3, + 'name4': name4, + 'creature': creature, + 'weapon1': weapon1, + 'weapon2': weapon2, + 'weapon3': weapon3, + 'weapon4': weapon4, + 'weapon5': weapon5, + 'initial_kills': n1, + 'fraction1': frac1, + 'multiplier': mult1, + 'fraction2': frac2, + 'kills_arthur': kills_arthur, + 'kills_walter': kills_walter, + 'kills_bruce': kills_bruce + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names_male = ["Arthur", "Bruce", "Charles", "David", "Edward", "Frederick", "George", "Henry"] + creatures = ["ogres", "trolls", "goblins", "orcs", "giants"] + weapons1 = ["sword", "mace", "battle axe", "war hammer"] + weapons2 = ["spear", "lance", "javelin", "halberd"] + weapons3 = ["rusty iron axe", "wooden club", "stone hammer", "bone dagger"] + weapons4 = ["sword", "axe", "mace", "hammer"] + weapons5 = ["nail file", "butter knife", "wooden spoon", "feather"] + fractions = [0.25, 0.5, 0.75] + multipliers = [2, 3, 4] + + name1, name2, name3, name4 = rng.sample(names_male, 4) + creature = rng.choice(creatures) + weapon1 = rng.choice(weapons1) + weapon2 = rng.choice(weapons2) + weapon3 = rng.choice(weapons3) + weapon4 = rng.choice(weapons4) + weapon5 = rng.choice(weapons5) + + # Scale numbers by difficulty but ensure integer results + n1 = int(rng.randrange(50, int(500 * difficulty), 50)) + frac1 = rng.choice(fractions) + mult1 = rng.choice(multipliers) + frac2 = rng.choice(fractions) + + # Ensure all divisions result in integers + while not (n1 * frac1).is_integer() or not (n1 * frac1 * mult1).is_integer() or \ + not (n1 * frac1 * mult1 * frac2).is_integer(): + n1 = int(rng.randrange(50, int(500 * difficulty), 50)) + + result = generate_from_variables(name1, name2, name3, name4, creature, + weapon1, weapon2, weapon3, weapon4, weapon5, + n1, frac1, mult1, frac2) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_94(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, num_shares: int, price_per_share: int, + increase_pct: int, decrease_pct: int) -> Dict[str, Any]: + initial_value = num_shares * price_per_share + first_increase = initial_value * increase_pct/100 + value_after_increase = initial_value + first_increase + second_decrease = value_after_increase * decrease_pct/100 + final_value = value_after_increase - second_decrease + + question = f"{name} buys {num_shares} shares of a stock for ${price_per_share} each. The stock price increases {increase_pct}% the first year {name} holds it, then decreases {decrease_pct}% in the second year. What is the final value of all {name}'s shares?" + + answer_cot = f"First find the initial total value of {name}'s purchase: {num_shares} shares * ${price_per_share}/share = ${initial_value}\n" \ + f"Then find the amount of the first price increase: ${initial_value} * {increase_pct/100} = ${int(first_increase)}\n" \ + f"Add that amount to the initial value to find the value after the first year: ${initial_value} + ${int(first_increase)} = ${int(value_after_increase)}\n" \ + f"Then multiply that amount by {decrease_pct}% to find the amount of the decrease in the second year: ${int(value_after_increase)} * {decrease_pct}% = ${int(second_decrease)}\n" \ + f"Then subtract that amount from the value after the first year to find the final value: ${int(value_after_increase)} - ${int(second_decrease)} = ${int(final_value)}\n" \ + f"#### {int(final_value)}" + + return { + 'question': question, + 'answer': str(int(final_value)), + 'answer_cot': answer_cot, + 'answer_value': int(final_value), + 'variables': { + 'name': name, + 'num_shares': num_shares, + 'price_per_share': price_per_share, + 'increase_pct': increase_pct, + 'decrease_pct': decrease_pct, + 'initial_value': initial_value, + 'final_value': int(final_value) + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ['Maria', 'Sarah', 'Emma', 'Isabella', 'Sophia', 'Mia', 'Charlotte'] + name = rng.choice(names) + + num_shares = int(rng.randint(5, int(20 * difficulty))) + price_per_share = int(rng.randint(5, int(100 * difficulty))) + increase_pct = int(rng.randrange(10, int(100 * difficulty), 5)) + decrease_pct = int(rng.randrange(5, int(50 * difficulty), 5)) + + # Ensure integer results + while not (num_shares * price_per_share * increase_pct/100).is_integer() or \ + not (num_shares * price_per_share * (1 + increase_pct/100) * (1 - decrease_pct/100)).is_integer(): + num_shares = int(rng.randint(5, int(20 * difficulty))) + price_per_share = int(rng.randint(5, int(100 * difficulty))) + increase_pct = int(rng.randrange(10, int(100 * difficulty), 5)) + decrease_pct = int(rng.randrange(5, int(50 * difficulty), 5)) + + result = generate_from_variables(name, num_shares, price_per_share, increase_pct, decrease_pct) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_95(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name1: str, name2: str, relation: str, food: str, + n1: int, n2: int, n3: int, time_unit: str, + time_period: str) -> Dict[str, Any]: + daily_total = n1 + n2 + n3 + total = daily_total * (7 if time_period == "week" else 30) + + question = f"{name1} eats {n1} {food} per {time_unit}, {name2} eats {n2} {food} per {time_unit}, and their {relation} eats {n3} {food} per {time_unit}. How many {food} does this family eat in one {time_period}?" + + answer_cot = f"The number of {food} they eat in one {time_unit} is {n1} + {n2} + {n3} = {daily_total} {food}.\nThe number of {food} they eat in a {time_period} is {daily_total} * {7 if time_period == 'week' else 30} = {total} {food}.\n#### {total}" + + return { + 'question': question, + 'answer': str(total), + 'answer_cot': answer_cot, + 'answer_value': total, + 'variables': { + 'name1': name1, + 'name2': name2, + 'relation': relation, + 'food': food, + 'daily_servings1': n1, + 'daily_servings2': n2, + 'daily_servings3': n3, + 'daily_total': daily_total, + 'time_unit': time_unit, + 'time_period': time_period + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + name1_options = ["A father", "A grandfather", "An uncle"] + name2_options = ["his wife", "his partner", "his spouse"] + relation_options = ["daughter", "son", "grandchild"] + food_options = ["pizzas", "burritos", "tacos", "sushi rolls", "hamburgers"] + + name1 = rng.choice(name1_options) + name2 = rng.choice(name2_options) + relation = rng.choice(relation_options) + food = rng.choice(food_options) + + n1 = int(rng.randint(2, int(9 * difficulty))) + n2 = int(rng.randint(2, int(9 * difficulty))) + n3 = int(rng.randint(2, int(9 * difficulty))) + + time_unit = "day" + time_period = rng.choice(["week", "month"]) + + result = generate_from_variables(name1, name2, relation, food, n1, n2, n3, + time_unit, time_period) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_96(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, food: str, animal1: str, animal2: str, + n1: int, n2: int, k1: int, k2: int, unit: str) -> Dict[str, Any]: + animal2_amount = 2 * n1 - n2 # Amount per sheep + animal2_total = k2 * animal2_amount # Total for sheep + animal1_total = k1 * n1 # Total for goats + total = animal1_total + animal2_total + + question = f"{name} is feeding his livestock {food}. Each {animal1} needs {n1} {unit}, and each {animal2} needs {n2} {unit} less than twice the amount each {animal1} needs. If there are {k1} {animal1}s and {k2} {animal2}s, how many {unit} of {food} does {name} need?" + + answer_cot = f"First figure out how much {food} each {animal2} needs: {n1} {unit} * 2 - {n2} = {animal2_amount} {unit}/{animal2}\n" \ + f"Now figure out how much {food} total the {animal2}s need: {animal2_amount} {unit}/{animal2} * {k2} {animal2} = {animal2_total} {unit}\n" \ + f"Now figure out how much {food} total the {animal1}s need: {n1} {unit}/{animal1} * {k1} {animal1}s = {animal1_total} {unit}\n" \ + f"Now add the two amounts of {food} to find the total: {animal2_total} {unit} + {animal1_total} {unit} = {total} {unit}\n#### {total}" + + return { + 'question': question, + 'answer': str(total), + 'answer_cot': answer_cot, + 'answer_value': total, + 'variables': { + 'name': name, + 'food': food, + 'animal1': animal1, + 'animal2': animal2, + 'n1': n1, + 'n2': n2, + 'k1': k1, + 'k2': k2, + 'unit': unit, + 'animal2_amount': animal2_amount, + 'animal2_total': animal2_total, + 'animal1_total': animal1_total + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["John", "Michael", "David", "James", "Robert", "William", "Richard"] + foods = ["hay", "grain", "feed", "silage"] + animals = ["goat", "cow", "horse", "donkey", "llama", "alpaca", "pig", "turkey", "duck"] + units = ["pounds", "kilograms", "kg"] + + name = rng.choice(names) + food = rng.choice(foods) + animal1, animal2 = rng.sample(animals, 2) + unit = rng.choice(units) + + n1 = int(rng.randint(3, int(15 * difficulty))) + n2 = int(rng.randint(1, int(10 * difficulty))) + + # Ensure 2*n1 - n2 > 0 + while 2*n1 - n2 <= 0: + n1 = int(rng.randint(3, int(15 * difficulty))) + n2 = int(rng.randint(1, int(10 * difficulty))) + + k1 = int(rng.randint(10, int(50 * difficulty))) + k2 = int(rng.randint(10, int(50 * difficulty))) + + result = generate_from_variables(name, food, animal1, animal2, n1, n2, k1, k2, unit) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_97(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, mult_run: int, frac_skip: float, skip_speed: int, + total_time: int, frac_run: float, frac_walk: float) -> Dict[str, Any]: + run_speed = skip_speed / frac_skip + walk_speed = run_speed / mult_run + walk_hours = total_time * frac_walk + run_hours = total_time * frac_run + run_dist = run_hours * run_speed + walk_dist = walk_hours * walk_speed + total_dist = int(run_dist + walk_dist) + + question = f"{name} can run {mult_run} times faster than she can walk, but she can skip at a rate of speed that is {frac_skip:.1f} as fast as she can run. If she can skip at {skip_speed} miles per hour, how many miles can she travel in {total_time} hours if she spends {frac_run:.2f} of the time running and {frac_walk:.2f} of the time walking?" + + answer_cot = f"""If {name} can skip at {frac_skip:.1f} the speed she can run, then she can run at {skip_speed}*{1/frac_skip:.1f}={run_speed} miles per hour. + And since she can run at a speed that is {mult_run} times faster than she can walk, this means she can walk at {run_speed}/{mult_run}={walk_speed} miles per hour. + If {frac_walk:.2f} of the time is spent walking, then she walks for {total_time}*{frac_walk:.2f}={walk_hours} hours. + If {frac_run:.2f} of the time is spent running, then she runs for {total_time}-{walk_hours}={run_hours} hours. + Thus, she runs for {run_hours} hours at {run_speed} miles per hour, or {run_hours}*{run_speed}={run_dist} miles. + She walks for {walk_hours} hours at {walk_speed} miles per hour, or {walk_hours}*{walk_speed}={walk_dist} miles. + Thus, altogether, she travels {run_dist}+{walk_dist}={total_dist} miles. + #### {total_dist}""" + + return { + 'question': question, + 'answer': str(total_dist), + 'answer_cot': answer_cot, + 'answer_value': total_dist, + 'variables': { + 'name': name, + 'mult_run': mult_run, + 'frac_skip': frac_skip, + 'skip_speed': skip_speed, + 'total_time': total_time, + 'frac_run': frac_run, + 'frac_walk': frac_walk, + 'run_speed': run_speed, + 'walk_speed': walk_speed, + 'total_dist': total_dist + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["Dana", "Emma", "Sarah", "Julia", "Sophie", "Maria"] + name = rng.choice(names) + + mult_run = rng.randint(2, int(6 * difficulty)) + frac_skip = 0.5 # Keep simple fraction + skip_speed = rng.randint(2, int(10 * difficulty)) + total_time = rng.randrange(4, int(12 * difficulty), 2) + + # Ensure fractions add to 1 + frac_run = 1/3 # Keep simple fraction + frac_walk = 2/3 # Keep simple fraction + + # Validate conditions + while not (skip_speed / frac_skip < 13 and + (total_time * frac_walk * (skip_speed / frac_skip / mult_run)).is_integer() and + (skip_speed / frac_skip).is_integer() and + (total_time * frac_run).is_integer() and + (total_time * frac_walk).is_integer()): + skip_speed = rng.randint(2, int(10 * difficulty)) + total_time = rng.randrange(4, int(12 * difficulty), 2) + + result = generate_from_variables(name, mult_run, frac_skip, skip_speed, + total_time, frac_run, frac_walk) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_98(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, vehicle: str, weight_vehicle: int, + item: str, weight_item: int, passenger_type: str, + num_passengers: int, weight_passenger: int, + unit: str, force_percent: int) -> Dict[str, Any]: + + total_passenger_weight = num_passengers * weight_passenger + total_weight = weight_vehicle + weight_item + total_passenger_weight + force_needed = int((total_weight * force_percent) / 100) + + question = f"{name}'s {vehicle} breaks down. The {vehicle} weighs {weight_vehicle} {unit} and he has {item} in it weighing {weight_item} {unit}. He also has his {num_passengers} young {passenger_type} who weigh {weight_passenger} {unit} each in it. If the force to move the {vehicle} is {force_percent}% of the weight, how much force does he need to push the {vehicle}?" + + answer_cot = f"His {num_passengers} {passenger_type} weigh {weight_passenger}*{num_passengers}={total_passenger_weight} {unit}\nSo the total weight of the {vehicle} and everything is {weight_vehicle}+{weight_item}+{total_passenger_weight}={total_weight} {unit}\nSo he needs to generate {total_weight}*{force_percent/100}={force_needed} {unit}\n#### {force_needed}" + + return { + 'question': question, + 'answer': str(force_needed), + 'answer_cot': answer_cot, + 'answer_value': force_needed, + 'variables': { + 'name': name, + 'vehicle': vehicle, + 'weight_vehicle': weight_vehicle, + 'item': item, + 'weight_item': weight_item, + 'passenger_type': passenger_type, + 'num_passengers': num_passengers, + 'weight_passenger': weight_passenger, + 'unit': unit, + 'force_percent': force_percent, + 'total_weight': total_weight + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["John", "Michael", "David", "James", "Robert", "William", "Richard"] + vehicles = ['car', 'van', 'truck', 'SUV'] + items = ['luggage', 'groceries', 'equipment', 'furniture'] + passenger_types = ['children', 'friends', 'colleagues', 'teammates'] + units = ['pounds', 'kilograms'] + + name = rng.choice(names) + vehicle = rng.choice(vehicles) + item = rng.choice(items) + passenger_type = rng.choice(passenger_types) + unit = rng.choice(units) + + weight_vehicle = int(rng.randrange(1000, int(3000 * difficulty), 50)) + weight_item = int(rng.randrange(100, int(500 * difficulty), 25)) + weight_passenger = int(rng.randrange(50, int(100 * difficulty), 5)) + num_passengers = int(rng.randint(2, int(5 * difficulty))) + force_percent = int(rng.randint(1, int(6 * difficulty))) + + # Ensure force calculation results in integer + total_weight = weight_vehicle + weight_item + (num_passengers * weight_passenger) + while (total_weight * force_percent) % 100 != 0: + force_percent = int(rng.randint(1, int(6 * difficulty))) + + result = generate_from_variables(name, vehicle, weight_vehicle, item, weight_item, + passenger_type, num_passengers, weight_passenger, + unit, force_percent) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) + +def generate_99(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + + def generate_from_variables(name: str, currency: str, initial_amount: float, + quantity: int, item: str, store_type: str, + unit_price: float) -> Dict[str, Any]: + total_cost = quantity * unit_price + remaining = initial_amount - total_cost + + question = f"{name} has {currency}{initial_amount:.2f} and wants to buy {quantity} {item}s from a bin at the {store_type} store. Each {item} costs {currency}{unit_price:.2f}. How much money does {name} have left after paying for the {item}s?" + + answer_cot = f"{name} paid {quantity} * {currency}{unit_price:.2f} = {currency}{total_cost:.2f} for the {item}s.\n{name} has {currency}{initial_amount:.2f} - {currency}{total_cost:.2f} = {currency}{int(remaining)} left.\n#### {int(remaining)}" + + return { + 'question': question, + 'answer': str(int(remaining)), + 'answer_cot': answer_cot, + 'answer_value': int(remaining), + 'variables': { + 'name': name, + 'currency': currency, + 'initial_amount': initial_amount, + 'quantity': quantity, + 'item': item, + 'store_type': store_type, + 'unit_price': unit_price, + 'total_cost': total_cost, + 'remaining': remaining + } + } + + def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: + names = ["David", "John", "Michael", "James", "William", "Robert"] + currencies = ["$", "€", "£"] + items = ["screw", "nail", "washer", "nut", "anchor"] + store_types = ["hardware", "home improvement", "construction supply"] + + name = rng.choice(names) + currency = rng.choice(currencies) + item = rng.choice(items) + store_type = rng.choice(store_types) + + # Generate values ensuring conditions are met + quantity = int(rng.randint(15, int(60 * difficulty))) + unit_price = round(rng.uniform(0.01, min(1.0, 1.0 * difficulty)), 2) + + # Ensure initial amount is sufficient and result is integer + total_cost = quantity * unit_price + remaining = rng.randint(1, int(100 * difficulty)) + initial_amount = total_cost + remaining + + result = generate_from_variables(name, currency, initial_amount, quantity, + item, store_type, unit_price) + + return { + 'question': result['question'], + 'answer': result['answer'], + 'metadata': { + 'difficulty': difficulty, + 'answer_value': result['answer_value'], + 'answer_cot': result['answer_cot'], + 'variables': result['variables'] + } + } + + return generate_example(rng, difficulty) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/gsm_symbolic_datasets.py b/reasoning_gym/arithmetic/gsm_symbolic/gsm_symbolic_datasets.py new file mode 100644 index 00000000..904af8c9 --- /dev/null +++ b/reasoning_gym/arithmetic/gsm_symbolic/gsm_symbolic_datasets.py @@ -0,0 +1,56 @@ +"""GSM Symblic dataset generator""" + +from . import generators +from dataclasses import dataclass +from random import Random +from typing import List, Optional + +from reasoning_gym.factory import ProceduralDataset, register_dataset + +@dataclass +class GSMSymbolicDatasetConfig: + """Configuration for GSM symbolic task generation""" + seed: Optional[int] = None + size: int = 500 + + def validate(self) -> None: + """Validate configuration parameters""" + pass + +class GSMSymbolicDataset(ProceduralDataset): + + def __init__(self, config, seed = None, size = 500): + super().__init__(config, seed, size) + # Initialize as None + self._generators = None + + @property + def generators(self): + """Lazy load generators only when first accessed""" + if self._generators is None: + self._generators = self.get_generators() + return self._generators + + def get_generators(self): + """ + Generates mapper from task identifiers (keys) to example generator functions + """ + prefix = 'generate_' + return { + self.strip_prefix(n, prefix): getattr(generators, n) for n in dir(generators) if n.startswith(prefix) + } + + def strip_prefix(self, s, prefix): + return s[len(prefix):] + + def __getitem__(self, idx) -> dict: + """Generate a single GSM symbolic dataset""" + rng = Random(self.seed + idx) + # Stringify the random integer generated from the random number generator + generator_idx = str(rng.randint(0, len(self.generators) - 1)) + generator = self.generators[generator_idx] + # Here the res is a dictionary of + res = generator(rng) + return res + +register_dataset("gsm_symbolic", GSMSymbolicDataset, GSMSymbolicDatasetConfig) \ No newline at end of file