| """Procedural curriculum: generators of verifiable reasoning problems with exact answers. |
| |
| The families are deliberately NOT the families of the eval suites (no BBH task types, no MMLU questions): training on |
| them and then measuring BBH / MMLU-Pro / math measures transfer of the skill (state tracking, systematic search, |
| exact computation, careful reading of code), not memorised task formats. |
| |
| Every item: {id, task: "math", src: "cur/<family>", prompt, answer} with the answer graded by grade.py's math checker. |
| usage: curriculum.py <n_per_family> <out.jsonl> [seed] |
| """ |
| import itertools |
| import json |
| import math |
| import random |
| import sys |
| from fractions import Fraction |
|
|
| TAIL = "\n\nPlease reason step by step, and put your final answer within \\boxed{}." |
| NAMES = ["A", "B", "C", "D", "E", "F", "G", "H", "I"] |
|
|
|
|
| def code_trace(r): |
| """Short Python program; ask for the printed value (single line).""" |
| a, b, n = r.randint(2, 9), r.randint(1, 7), r.randint(4, 9) |
| kind = r.randint(0, 4) |
| if kind == 0: |
| src = f"x = {a}\ny = {b}\nfor i in range({n}):\n if i % 2 == 0:\n x = x + y * i\n else:\n y = (y + x) % 11\nprint(x - y)" |
| elif kind == 1: |
| lst = [r.randint(-9, 20) for _ in range(n)] |
| src = f"nums = {lst}\nbest, cur = nums[0], 0\nfor v in nums:\n cur = max(v, cur + v)\n best = max(best, cur)\nprint(best)" |
| elif kind == 2: |
| w = "".join(r.choice("abcde") for _ in range(n + 3)) |
| src = f"s = '{w}'\nseen = {{}}\nout = 0\nfor i, ch in enumerate(s):\n if ch in seen:\n out += i - seen[ch]\n seen[ch] = i\nprint(out)" |
| elif kind == 3: |
| src = f"def f(k):\n if k <= 1:\n return {b}\n return f(k - 1) + {a} * f(k - 2) % 7\nprint(f({n}))" |
| else: |
| lst = [r.randint(1, 30) for _ in range(n)] |
| src = f"a = {lst}\nfor i in range(len(a)):\n for j in range(len(a) - 1 - i):\n if a[j] % {a} > a[j + 1] % {a}:\n a[j], a[j + 1] = a[j + 1], a[j]\nprint(a[{r.randint(0, n - 1)}])" |
| env = {} |
| import io, contextlib |
| buf = io.StringIO() |
| with contextlib.redirect_stdout(buf): |
| exec(src, env) |
| return f"What does the following Python program print?\n\n```python\n{src}\n```", buf.getvalue().strip() |
|
|
|
|
| def linear_system(r): |
| while True: |
| x, y, z = (r.randint(-9, 9) for _ in range(3)) |
| rows = [[r.randint(-5, 5) for _ in range(3)] for _ in range(3)] |
| det = (rows[0][0] * (rows[1][1] * rows[2][2] - rows[1][2] * rows[2][1]) |
| - rows[0][1] * (rows[1][0] * rows[2][2] - rows[1][2] * rows[2][0]) |
| + rows[0][2] * (rows[1][0] * rows[2][1] - rows[1][1] * rows[2][0])) |
| if det != 0: |
| break |
| eqs = [] |
| for c in rows: |
| rhs = c[0] * x + c[1] * y + c[2] * z |
| terms = " ".join(f"{'+' if v >= 0 else '-'} {abs(v)}{s}" for v, s in zip(c, "xyz") if v != 0).lstrip("+ ") |
| eqs.append(f"{terms} = {rhs}") |
| p, q = r.randint(1, 5), r.randint(1, 5) |
| return ("Solve the system of equations\n" + "\n".join(eqs) + f"\nand find the value of {p}x + {q}y - z.", |
| str(p * x + q * y - z)) |
|
|
|
|
| def number_theory(r): |
| k = r.randint(0, 2) |
| if k == 0: |
| a, e, m = r.randint(2, 50), r.randint(50, 2000), r.choice([7, 9, 11, 13, 17, 19, 23, 100, 1000]) |
| return f"Find the remainder when ${a}^{{{e}}}$ is divided by ${m}$.", str(pow(a, e, m)) |
| if k == 1: |
| nums = [r.randint(2, 60) * r.choice([1, 2, 3, 6]) for _ in range(3)] |
| g = math.gcd(*nums) |
| l = math.lcm(*nums) |
| return f"Let $g = \\gcd({nums[0]}, {nums[1]}, {nums[2]})$ and $L = \\operatorname{{lcm}}({nums[0]}, {nums[1]}, {nums[2]})$. Compute $L / g$.", str(l // g) |
| n = r.randint(200, 5000) |
| if n < 300: |
| return f"How many positive divisors does ${n}^2$ have?", str(sum(1 for d in range(1, n * n + 1) if (n * n) % d == 0)) |
| return f"How many positive divisors does ${n}$ have?", str(sum(1 for d in range(1, n + 1) if n % d == 0)) |
|
|
|
|
| def graph_path(r): |
| n = r.randint(6, 9) |
| nodes = NAMES[:n] |
| edges = {} |
| for i in range(1, n): |
| j = r.randint(0, i - 1) |
| edges[(nodes[j], nodes[i])] = r.randint(1, 12) |
| for _ in range(r.randint(n, 2 * n)): |
| a, b = r.sample(nodes, 2) |
| if (a, b) not in edges and (b, a) not in edges: |
| edges[(a, b)] = r.randint(1, 12) |
| dist = {v: math.inf for v in nodes} |
| dist[nodes[0]] = 0 |
| todo = set(nodes) |
| while todo: |
| u = min(todo, key=lambda v: dist[v]) |
| todo.remove(u) |
| for (a, b), w in edges.items(): |
| for s, t in ((a, b), (b, a)): |
| if s == u and dist[u] + w < dist[t]: |
| dist[t] = dist[u] + w |
| target = max(nodes[1:], key=lambda v: (dist[v], r.random())) |
| lines = [f"{a} - {b}: {w}" for (a, b), w in r.sample(list(edges.items()), len(edges))] |
| return (f"Roads connect towns {', '.join(nodes)} (both directions, with lengths):\n" + "\n".join(lines) + |
| f"\nWhat is the length of the shortest route from {nodes[0]} to {target}?", str(dist[target])) |
|
|
|
|
| def scheduling(r): |
| n = r.randint(5, 8) |
| tasks = NAMES[:n] |
| dur = {t: r.randint(1, 9) for t in tasks} |
| pre = {t: sorted(r.sample(tasks[:i], r.randint(0, min(2, i)))) if i else [] for i, t in enumerate(tasks)} |
| fin = {} |
| for t in tasks: |
| fin[t] = max((fin[p] for p in pre[t]), default=0) + dur[t] |
| desc = "\n".join(f"Task {t} takes {dur[t]} hours" + (f" and can start only after {' and '.join(pre[t])} " |
| f"{'is' if len(pre[t]) == 1 else 'are'} finished." if pre[t] else ".") |
| for t in r.sample(tasks, n)) |
| return ("A project consists of tasks; any number of tasks can run at the same time.\n" + desc + |
| "\nWhat is the minimum number of hours needed to finish all tasks?", str(max(fin.values()))) |
|
|
|
|
| def counting(r): |
| N = r.randint(100, 3000) |
| a, b = r.sample([2, 3, 4, 5, 6, 7, 9, 11], 2) |
| c = r.choice([x for x in [3, 4, 5, 7, 8, 10, 13] if x not in (a, b)]) |
| cnt = sum(1 for k in range(1, N + 1) if (k % a == 0 or k % b == 0) and k % c != 0) |
| return f"How many integers from 1 to {N} (inclusive) are divisible by {a} or by {b}, but not by {c}?", str(cnt) |
|
|
|
|
| def probability(r): |
| k = r.randint(0, 1) |
| if k == 0: |
| s = r.randint(5, 10) |
| faces = r.choice([4, 6, 8]) |
| good = sum(1 for x, y, z in itertools.product(range(1, faces + 1), repeat=3) if x + y + z == s) |
| p = Fraction(good, faces ** 3) |
| return f"Three fair {faces}-sided dice (faces 1 to {faces}) are rolled. What is the probability that the sum is {s}? Give the answer as a fraction in lowest terms.", f"\\frac{{{p.numerator}}}{{{p.denominator}}}" |
| red, blue = r.randint(2, 7), r.randint(2, 7) |
| d = r.randint(2, 3) |
| tot = math.comb(red + blue, d) |
| good = sum(math.comb(red, i) * math.comb(blue, d - i) for i in range(1, d + 1) if i <= red and d - i <= blue) |
| p = Fraction(good, tot) |
| return f"A bag has {red} red and {blue} blue marbles. {d} marbles are drawn at random without replacement. What is the probability that at least one of them is red? Give the answer as a fraction in lowest terms.", f"\\frac{{{p.numerator}}}{{{p.denominator}}}" |
|
|
|
|
| def cipher(r): |
| words = ["planet", "garden", "silver", "rocket", "window", "puzzle", "forest", "bridge", "candle", "violin", |
| "harbor", "meadow", "tunnel", "lantern", "compass"] |
| w = r.choice(words) |
| s = r.randint(3, 22) |
| enc = "".join(chr((ord(ch) - 97 + s) % 26 + 97) for ch in w) |
| w2 = r.choice([x for x in words if x != w]) |
| enc2 = "".join(chr((ord(ch) - 97 + s) % 26 + 97) for ch in w2) |
| return (f"A Caesar cipher shifts every letter forward by the same amount (wrapping z to a). The word '{w}' is " |
| f"encrypted as '{enc}'. Using the same shift, decrypt '{enc2}'. Give the decrypted word.", |
| f"\\text{{{w2}}}") |
|
|
|
|
| def determinant(r): |
| m = [[r.randint(-6, 6) for _ in range(3)] for _ in range(3)] |
| d = (m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]) |
| + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0])) |
| rows = " \\\\ ".join(" & ".join(str(v) for v in row) for row in m) |
| return f"Compute the determinant of the matrix $\\begin{{pmatrix}} {rows} \\end{{pmatrix}}$.", str(d) |
|
|
|
|
| def rates(r): |
| a, b = r.randint(2, 12), r.randint(2, 12) |
| c = r.randint(a * b // (a + b) + 2, 40) if r.random() < 0.5 else None |
| if c: |
| t = Fraction(1, Fraction(1, a) + Fraction(1, b) - Fraction(1, c)) |
| q = f"Pipe 1 fills a tank in {a} hours and pipe 2 fills it in {b} hours, while a drain empties the full tank in {c} hours. Starting empty with both pipes and the drain open, how many hours until the tank is full?" |
| else: |
| t = Fraction(1, Fraction(1, a) + Fraction(1, b)) |
| q = f"Alice paints a fence in {a} hours and Bob paints the same fence in {b} hours. Working together, how many hours do they need?" |
| return q + " Give an exact answer.", (str(t.numerator) if t.denominator == 1 else f"\\frac{{{t.numerator}}}{{{t.denominator}}}") |
|
|
|
|
| def recurrence(r): |
| a, b, c = r.randint(1, 4), r.randint(-3, 3), r.randint(-5, 5) |
| x0, x1, n = r.randint(0, 5), r.randint(0, 5), r.randint(8, 14) |
| xs = [x0, x1] |
| for _ in range(n - 1): |
| xs.append(a * xs[-1] + b * xs[-2] + c) |
| return (f"A sequence is defined by $x_0 = {x0}$, $x_1 = {x1}$ and $x_{{n+1}} = {a}x_n {'+' if b >= 0 else '-'} " |
| f"{abs(b)}x_{{n-1}} {'+' if c >= 0 else '-'} {abs(c)}$ for $n \\ge 1$. Find $x_{{{n}}}$.", str(xs[n])) |
|
|
|
|
| def string_ops(r): |
| """Hard: state tracking over a sequence of string operations.""" |
| s = "".join(r.choice("abcdefghij") for _ in range(r.randint(7, 10))) |
| ops, cur = [], list(s) |
| for _ in range(r.randint(7, 11)): |
| k = r.randint(0, 4) |
| if k == 0: |
| i, j = sorted(r.sample(range(len(cur)), 2)) |
| ops.append(f"swap the letters at positions {i + 1} and {j + 1}") |
| cur[i], cur[j] = cur[j], cur[i] |
| elif k == 1: |
| t = r.randint(1, len(cur) - 1) |
| ops.append(f"rotate the string left by {t}") |
| cur = cur[t:] + cur[:t] |
| elif k == 2: |
| i, j = sorted(r.sample(range(len(cur)), 2)) |
| ops.append(f"reverse the part from position {i + 1} to position {j + 1}") |
| cur[i:j + 1] = cur[i:j + 1][::-1] |
| elif k == 3: |
| a, b = r.sample("abcdefghij", 2) |
| ops.append(f"replace every '{a}' with '{b}'") |
| cur = [b if c == a else c for c in cur] |
| else: |
| i = r.randint(0, len(cur) - 1) |
| ops.append(f"delete the letter at position {i + 1}") |
| del cur[i] |
| steps = "\n".join(f"{n + 1}. {o}" for n, o in enumerate(ops)) |
| return (f"Start with the string '{s}' (positions are counted from 1). Apply these operations in order:\n{steps}\n" |
| "What is the final string?", f"\\text{{{''.join(cur)}}}") |
|
|
|
|
| def stack_sim(r): |
| st, ops, total = [], [], 0 |
| for _ in range(r.randint(12, 18)): |
| if st and r.random() < 0.4: |
| k = r.choice(["pop", "dup", "add"] if len(st) >= 2 else ["pop", "dup"]) |
| if k == "pop": |
| total += st.pop() |
| ops.append("pop (add the popped value to the running total)") |
| elif k == "dup": |
| st.append(st[-1]) |
| ops.append("duplicate the top") |
| else: |
| a, b = st.pop(), st.pop() |
| st.append(a + b) |
| ops.append("pop two values and push their sum") |
| else: |
| v = r.randint(1, 20) |
| st.append(v) |
| ops.append(f"push {v}") |
| steps = "\n".join(f"{n + 1}. {o}" for n, o in enumerate(ops)) |
| return (f"A stack starts empty and a running total starts at 0. Perform:\n{steps}\nAt the end, what is the running " |
| f"total plus the sum of all values left on the stack times 2?", str(total + 2 * sum(st))) |
|
|
|
|
| def crt(r): |
| ms = r.sample([3, 4, 5, 7, 9, 11, 13], 3) |
| while math.gcd(ms[0], ms[1]) != 1 or math.gcd(ms[0], ms[2]) != 1 or math.gcd(ms[1], ms[2]) != 1: |
| ms = r.sample([3, 4, 5, 7, 9, 11, 13], 3) |
| x = r.randint(0, ms[0] * ms[1] * ms[2] - 1) |
| cond = ", ".join(f"$x \\equiv {x % m} \\pmod{{{m}}}$" for m in ms) |
| return f"Find the smallest non-negative integer $x$ such that {cond}.", str(x) |
|
|
|
|
| def graph_path_big(r): |
| q, a = graph_path(_Big(r)) |
| return q, a |
|
|
|
|
| class _Big: |
| """Random proxy that makes graph_path draw 10-12 nodes.""" |
|
|
| def __init__(self, r): |
| self.r = r |
| self.first = True |
|
|
| def randint(self, a, b): |
| if self.first and (a, b) == (6, 9): |
| self.first = False |
| return self.r.randint(9, 9) |
| return self.r.randint(a, b) |
|
|
| def __getattr__(self, k): |
| return getattr(self.r, k) |
|
|
|
|
| def counting_big(r): |
| N = r.randint(10 ** 5, 10 ** 6) |
| a, b, c = r.sample([2, 3, 5, 7, 11, 13], 3) |
| cnt = N // a + N // b + N // c - N // (a * b) - N // (a * c) - N // (b * c) + N // (a * b * c) |
| return f"How many integers from 1 to {N} are divisible by at least one of {a}, {b}, {c}?", str(cnt) |
|
|
|
|
| def linear4(r): |
| while True: |
| sol = [r.randint(-6, 6) for _ in range(4)] |
| M = [[r.randint(-4, 4) for _ in range(4)] for _ in range(4)] |
| A = [row[:] for row in M] |
| det = Fraction(1) |
| for i in range(4): |
| p = next((k for k in range(i, 4) if A[k][i] != 0), None) |
| if p is None: |
| det = 0 |
| break |
| if p != i: |
| A[i], A[p] = A[p], A[i] |
| det = -det |
| det *= A[i][i] |
| for k in range(i + 1, 4): |
| f = Fraction(A[k][i], A[i][i]) |
| A[k] = [A[k][j] - f * A[i][j] for j in range(4)] |
| if det != 0: |
| break |
| eqs = [] |
| for row in M: |
| rhs = sum(c * v for c, v in zip(row, sol)) |
| terms = " ".join(f"{'+' if c >= 0 else '-'} {abs(c)}{s}" for c, s in zip(row, "wxyz") if c).lstrip("+ ") |
| eqs.append(f"{terms} = {rhs}") |
| return "Solve the system\n" + "\n".join(eqs) + "\nand give the value of w + 2x + 3y + 4z.", \ |
| str(sol[0] + 2 * sol[1] + 3 * sol[2] + 4 * sol[3]) |
|
|
|
|
| FAMILIES = [code_trace, linear_system, number_theory, graph_path, scheduling, counting, probability, cipher, |
| determinant, rates, recurrence] |
| HARD = [string_ops, stack_sim, crt, graph_path_big, counting_big, linear4] |
|
|
| if __name__ == "__main__": |
| n, out = int(sys.argv[1]), sys.argv[2] |
| rng = random.Random(int(sys.argv[3]) if len(sys.argv) > 3 else 0) |
| fams = HARD if len(sys.argv) > 4 and sys.argv[4] == "hard" else FAMILIES |
| rows = [] |
| for fam in fams: |
| seen = set() |
| while sum(1 for x in rows if x["src"] == "cur/" + fam.__name__) < n: |
| q, a = fam(rng) |
| if q in seen: |
| continue |
| seen.add(q) |
| rows.append({"id": f"cur/{fam.__name__}/{len(seen)}", "task": "math", "src": "cur/" + fam.__name__, |
| "prompt": q + TAIL, "answer": a}) |
| rng.shuffle(rows) |
| with open(out, "w", encoding="utf-8") as f: |
| for x in rows: |
| f.write(json.dumps(x, ensure_ascii=False) + "\n") |
| print(len(rows), "items") |
|
|
