Initial release: 3,577 construct/optimize math RL tasks with deterministic graders (part 2)

graders/rlve_integer_linear_system/check.py

@@ -0,0 +1,10 @@
+from run import Invalid, int_list
+
+
+def check(inst, ans):
+    n = len(inst["coeffs"][0])
+    x = int_list(ans.get("x"), n, name="x")
+    for k, (e, r) in enumerate(zip(inst["coeffs"], inst["rhs"])):
+        if sum(c * v for c, v in zip(e, x)) != r:
+            raise Invalid(f"equation {k} is violated")
+    return None, {}

graders/rlve_largest_convex_polygon/check.py

@@ -0,0 +1,27 @@
+from run import Invalid, int_list
+
+
+def _cross(o, a, b):
+    return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])
+
+
+def check(inst, ans):
+    P, k = inst["points"], inst["k"]
+    idx = int_list(ans.get("indices"), None, 0, len(P) - 1, "indices")
+    if len(set(idx)) != len(idx):
+        raise Invalid("indices must be distinct")
+    if len(idx) < k:
+        raise Invalid(f"{len(idx)} points given, need {k}")
+    pts = sorted(tuple(P[i]) for i in idx)
+    lower, upper = [], []
+    for p in pts:  # monotone chain, strict (collinear points dropped)
+        while len(lower) >= 2 and _cross(lower[-2], lower[-1], p) <= 0:
+            lower.pop()
+        lower.append(p)
+    for p in reversed(pts):
+        while len(upper) >= 2 and _cross(upper[-2], upper[-1], p) <= 0:
+            upper.pop()
+        upper.append(p)
+    if len(lower) + len(upper) - 2 != len(pts):
+        raise Invalid("the chosen points are not in convex position")
+    return None, {}

graders/rlve_largest_rectangle/check.py

@@ -0,0 +1,24 @@
+from run import Invalid, int_list
+
+
+def check(inst, ans):
+    P = inst["points"]
+    idx = int_list(ans.get("indices"), 4, 0, len(P) - 1, "indices")
+    if len(set(idx)) != 4:
+        raise Invalid("indices must be distinct")
+    A, *rest = [tuple(P[i]) for i in idx]
+    if len(set([A] + rest)) != 4:
+        raise Invalid("points must be distinct")
+    # the vertex farthest from A is opposite; the other two are A's neighbours
+    rest.sort(key=lambda X: (X[0] - A[0]) ** 2 + (X[1] - A[1]) ** 2)
+    B, D, C = rest
+    u = (B[0] - A[0], B[1] - A[1])
+    v = (D[0] - A[0], D[1] - A[1])
+    if u[0] * v[0] + u[1] * v[1] != 0:
+        raise Invalid("not a rectangle (no right angle at the first vertex)")
+    if (B[0] + D[0] - A[0], B[1] + D[1] - A[1]) != C:
+        raise Invalid("not a rectangle")
+    area = abs(u[0] * v[1] - u[1] * v[0])
+    if area < inst["area"]:
+        raise Invalid(f"area {area} < {inst['area']}")
+    return None, {"area": area}

graders/rlve_matrix_permutation_equivalence/check.py

@@ -0,0 +1,15 @@
+from run import Invalid, int_list
+
+
+def check(inst, ans):
+    A, B = inst["A"], inst["B"]
+    N, M = len(A), len(A[0])
+    a = int_list(ans.get("a"), N, 0, N - 1, "a")
+    b = int_list(ans.get("b"), M, 0, M - 1, "b")
+    if len(set(a)) != N or len(set(b)) != M:
+        raise Invalid("a and b must be permutations")
+    for i in range(N):
+        for j in range(M):
+            if A[a[i]][b[j]] != B[i][j]:
+                raise Invalid(f"mismatch at ({i}, {j})")
+    return None, {}

graders/rlve_max_achromatic_coloring/check.py

@@ -0,0 +1,16 @@
+from run import Invalid, int_list
+
+
+def check(inst, ans):
+    n, k = inst["n"], inst["k"]
+    c = int_list(ans.get("colors"), n, 0, k - 1, "colors")
+    if len(set(c)) != k:
+        raise Invalid(f"uses {len(set(c))} colours, need all {k}")
+    pairs = set()
+    for u, v in inst["edges"]:
+        if c[u] == c[v]:
+            raise Invalid(f"edge ({u},{v}) is monochromatic")
+        pairs.add((min(c[u], c[v]), max(c[u], c[v])))
+    if len(pairs) != k * (k - 1) // 2:
+        raise Invalid("some pair of colours is not joined by an edge")
+    return None, {}

graders/rlve_maximum_clique/check.py

@@ -0,0 +1,16 @@
+from run import Invalid, int_list
+
+
+def check(inst, ans):
+    n, k = inst["n"], inst["k"]
+    c = int_list(ans.get("clique"), None, 0, n - 1, "clique")
+    if len(set(c)) != len(c):
+        raise Invalid("vertices must be distinct")
+    if len(c) < k:
+        raise Invalid(f"clique has {len(c)} vertices, need {k}")
+    es = {(min(u, v), max(u, v)) for u, v in inst["edges"]}
+    for i in range(len(c)):
+        for j in range(i + 1, len(c)):
+            if (min(c[i], c[j]), max(c[i], c[j])) not in es:
+                raise Invalid(f"{c[i]} and {c[j]} are not adjacent")
+    return None, {}

graders/rlve_min_chromatic_number/check.py

@@ -0,0 +1,10 @@
+from run import Invalid, int_list
+
+
+def check(inst, ans):
+    n, k = inst["n"], inst["k"]
+    c = int_list(ans.get("colors"), n, 0, k - 1, "colors")
+    for u, v in inst["edges"]:
+        if c[u] == c[v]:
+            raise Invalid(f"edge ({u},{v}) is monochromatic")
+    return None, {}

graders/rlve_min_harmonious_coloring/check.py

@@ -0,0 +1,15 @@
+from run import Invalid, int_list
+
+
+def check(inst, ans):
+    n, k = inst["n"], inst["k"]
+    c = int_list(ans.get("colors"), n, 0, k - 1, "colors")
+    seen = set()
+    for u, v in inst["edges"]:
+        if c[u] == c[v]:
+            raise Invalid(f"edge ({u},{v}) is monochromatic")
+        pair = (min(c[u], c[v]), max(c[u], c[v]))
+        if pair in seen:
+            raise Invalid(f"colour pair {pair} appears on two edges")
+        seen.add(pair)
+    return None, {}

graders/rlve_pairwise_sums_recovery/check.py

@@ -0,0 +1,14 @@
+from collections import Counter
+
+from run import Invalid, int_list
+
+
+def check(inst, ans):
+    n = inst["n"]
+    x = int_list(ans.get("numbers"), n, 1, None, "numbers")
+    if len(set(x)) != n:
+        raise Invalid("numbers must be distinct")
+    got = Counter(x[i] + x[j] for i in range(n) for j in range(i + 1, n))
+    if got != Counter(inst["sums"]):
+        raise Invalid("pairwise sums do not match")
+    return None, {}

graders/rlve_pan_solar_panels/check.py

@@ -0,0 +1,12 @@
+import math
+
+from run import Invalid, as_int
+
+
+def check(inst, ans):
+    X = as_int(ans.get("X"), "X", lo=inst["A"], hi=inst["B"])
+    Y = as_int(ans.get("Y"), "Y", lo=inst["C"], hi=inst["D"])
+    g = math.gcd(X, Y)
+    if g < inst["target"]:
+        raise Invalid(f"gcd(X, Y) = {g} < {inst['target']}")
+    return None, {"gcd": g}

graders/rlve_polynomial_global_minimum/check.py

@@ -0,0 +1,19 @@
+from fractions import Fraction
+
+from run import Invalid, num
+
+
+def check(inst, ans):
+    x0 = Fraction(num(ans.get("x0"), "x0"))
+    if abs(x0) > 10 ** 6:
+        raise Invalid("x0 out of range")
+    v = Fraction(0)
+    for a in reversed(inst["coeffs"]):
+        v = v * x0 + a
+    fmin = Fraction(inst["fmin"])
+    tol = Fraction(1, 10 ** 9) * max(Fraction(1), abs(fmin))
+    if v > fmin + tol:
+        raise Invalid(f"f(x0) = {float(v)} is above the global minimum {float(fmin)}")
+    if v < fmin - tol:  # cannot happen for a correct f_min; guards against a bad instance
+        raise Invalid("internal: f(x0) below recorded minimum")
+    return None, {"f_x0": float(v)}

graders/rlve_polynomial_integer_roots/check.py

@@ -0,0 +1,20 @@
+from run import Invalid, int_list
+
+
+def check(inst, ans):
+    c = inst["coeffs"]  # c[i] = coefficient of x^i, monic of degree len(c) - 1
+    n = len(c) - 1
+    r = int_list(ans.get("roots"), n, name="roots")
+    bound = 1 + max(abs(v) for v in c)  # Cauchy bound on roots
+    if any(abs(a) > bound for a in r):  # any integer root divides the constant term / is bounded by max|c_i|
+        raise Invalid("root out of range")
+    prod = [1]
+    for a in r:  # multiply by (x - a)
+        nxt = [0] * (len(prod) + 1)
+        for i, v in enumerate(prod):
+            nxt[i + 1] += v
+            nxt[i] -= a * v
+        prod = nxt
+    if prod != c:
+        raise Invalid("the product does not expand to P(x)")
+    return None, {}

graders/rlve_polynomial_interpolation/check.py

@@ -0,0 +1,13 @@
+from run import Invalid, int_list
+
+
+def check(inst, ans):
+    X, Y = inst["X"], inst["Y"]
+    c = int_list(ans.get("coeffs"), len(X), name="coeffs")
+    for x, y in zip(X, Y):
+        v = 0
+        for a in reversed(c):
+            v = v * x + a
+        if v != y:
+            raise Invalid(f"f({x}) = {v}, need {y}")
+    return None, {}

graders/rlve_prefix_product_permutation/check.py

@@ -0,0 +1,15 @@
+from run import Invalid, int_list
+
+
+def check(inst, ans):
+    n = inst["n"]
+    p = int_list(ans.get("perm"), n, 1, n, "perm")
+    if len(set(p)) != n:
+        raise Invalid("not a permutation")
+    seen, acc = set(), 1
+    for v in p:
+        acc = acc * v % n
+        if acc in seen:
+            raise Invalid(f"prefix product residue {acc} repeats")
+        seen.add(acc)
+    return None, {}

graders/rlve_prefix_sum_permutation/check.py

@@ -0,0 +1,15 @@
+from run import Invalid, int_list
+
+
+def check(inst, ans):
+    n = inst["n"]
+    p = int_list(ans.get("perm"), n, 1, n, "perm")
+    if len(set(p)) != n:
+        raise Invalid("not a permutation")
+    seen, acc = set(), 0
+    for v in p:
+        acc = (acc + v) % n
+        if acc in seen:
+            raise Invalid(f"prefix sum residue {acc} repeats")
+        seen.add(acc)
+    return None, {}

graders/rlve_prime_graph_coloring/check.py

@@ -0,0 +1,20 @@
+from run import Invalid, int_list
+
+
+def check(inst, ans):
+    n, k = inst["n"], inst["k"]
+    c = int_list(ans.get("colors"), n, 0, k - 1, "colors")
+    sieve = [True] * (n + 1)
+    sieve[0] = False
+    if n >= 1:
+        sieve[1] = False
+    for i in range(2, int(n ** 0.5) + 1):
+        if sieve[i]:
+            for j in range(i * i, n + 1, i):
+                sieve[j] = False
+    for p in range(2, n):
+        if sieve[p]:
+            for u in range(n - p):
+                if c[u] == c[u + p]:
+                    raise Invalid(f"vertices {u + 1} and {u + p + 1} (difference {p}) share a colour")
+    return None, {}

graders/rlve_recursive_sequence_sum/check.py

@@ -0,0 +1,29 @@
+from run import Invalid, int_list
+
+
+def F(inst, n):
+    F0, A, B = inst["F0"], inst["A"], inst["B"]
+    if A == 1:
+        return F0 + n * B
+    An = A ** n
+    return An * F0 + B * (An - 1) // (A - 1)
+
+
+def check(inst, ans):
+    S = inst["S"]
+    idx = int_list(ans.get("indices"), None, 1, None, "indices")
+    if not idx:
+        raise Invalid("need at least one index")
+    if len(set(idx)) != len(idx):
+        raise Invalid("indices must be distinct")
+    total = 0
+    for n in idx:
+        # F is strictly increasing with F(n) >= n and, when A >= 2, F(n) >= 2^(n-1); bail out before big powers
+        if n > S or (inst["A"] >= 2 and n - 1 > S.bit_length()):
+            raise Invalid(f"F({n}) exceeds S")
+        total += F(inst, n)
+        if total > S:
+            raise Invalid("sum exceeds S")
+    if total != S:
+        raise Invalid(f"sum is {total}, need {S}")
+    return None, {}

graders/rlve_round_robin_scores/check.py

@@ -0,0 +1,24 @@
+from run import Invalid
+
+
+def check(inst, ans):
+    W = inst["W"]
+    n = len(W)
+    A = ans.get("A")
+    if not isinstance(A, list) or len(A) != n:
+        raise Invalid(f"A must be a list of {n} strings")
+    for r in A:
+        if not isinstance(r, str) or len(r) != n or set(r) - {"0", "1", "2"}:
+            raise Invalid(f"each row must be a string of {n} digits 0/1/2")
+    for i in range(n):
+        if A[i][i] != "0":
+            raise Invalid("diagonal must be 0")
+        w = 0
+        for j in range(n):
+            if i != j:
+                if int(A[i][j]) + int(A[j][i]) != 2:
+                    raise Invalid(f"A[{i}][{j}] + A[{j}][{i}] != 2")
+                w += 3 * (A[i][j] == "2") + (A[i][j] == "1")
+        if w != W[i]:
+            raise Invalid(f"W[{i}] = {w}, need {W[i]}")
+    return None, {}

graders/rlve_shortest_path_count/check.py

@@ -0,0 +1,34 @@
+from run import Invalid, as_int
+
+
+def check(inst, ans):
+    n = as_int(ans.get("n"), "n", lo=2, hi=inst["n_max"])
+    adj = ans.get("adj")
+    if not isinstance(adj, list) or len(adj) != n:
+        raise Invalid(f"adj must be a list of {n} strings")
+    for r in adj:
+        if not isinstance(r, str) or len(r) != n or set(r) - {"Y", "N"}:
+            raise Invalid("each row must be a string of length n over {'Y','N'}")
+    for i in range(n):
+        if adj[i][i] != "N":
+            raise Invalid("self-loop")
+        for j in range(i + 1, n):
+            if adj[i][j] != adj[j][i]:
+                raise Invalid("matrix not symmetric")
+    nb = [[j for j in range(n) if adj[i][j] == "Y"] for i in range(n)]
+    dist = [-1] * n
+    cnt = [0] * n
+    dist[0], cnt[0] = 0, 1
+    q = [0]
+    for u in q:  # BFS with exact (Python int) path counts
+        for v in nb[u]:
+            if dist[v] < 0:
+                dist[v] = dist[u] + 1
+                q.append(v)
+            if dist[v] == dist[u] + 1:
+                cnt[v] += cnt[u]
+    if dist[1] < 0:
+        raise Invalid("vertex 2 is unreachable from vertex 1")
+    if cnt[1] != inst["K"]:
+        raise Invalid(f"{cnt[1]} shortest paths, need {inst['K']}")
+    return None, {}

graders/rlve_smallest_enclosing_circle/check.py

@@ -0,0 +1,17 @@
+import math
+
+from run import Invalid, num
+
+TOL = 1e-6
+
+
+def check(inst, ans):
+    x, y, r = num(ans.get("x"), "x"), num(ans.get("y"), "y"), num(ans.get("r"), "r")
+    if r <= 0:
+        raise Invalid("r must be positive")
+    if r > inst["r_opt"] + TOL:
+        raise Invalid(f"r = {r} exceeds the minimum radius {inst['r_opt']} by more than {TOL}")
+    for px, py in inst["points"]:
+        if math.hypot(px - x, py - y) > r + TOL:
+            raise Invalid(f"point ({px}, {py}) is outside the circle")
+    return None, {"r": r}

graders/rlve_subgraph_isomorphism/check.py

@@ -0,0 +1,16 @@
+from run import Invalid, int_list
+
+
+def check(inst, ans):
+    n1, n2 = inst["n1"], inst["n2"]
+    p = int_list(ans.get("p"), n1, 0, n2 - 1, "p")
+    if len(set(p)) != n1:
+        raise Invalid("p is not injective")
+    e1 = {(min(u, v), max(u, v)) for u, v in inst["edges1"]}
+    e2 = {(min(u, v), max(u, v)) for u, v in inst["edges2"]}
+    for u in range(n1):
+        for v in range(u + 1, n1):
+            a, b = min(p[u], p[v]), max(p[u], p[v])
+            if ((u, v) in e1) != ((a, b) in e2):
+                raise Invalid(f"pair ({u}, {v}) is not preserved")
+    return None, {}

graders/run.py

@@ -0,0 +1,127 @@
+"""rlmath runtime grader. Copied into every task as /tests/run.py next to /tests/check.py.
+
+Deterministic; no LLM in the reward path. Runs with python3 + numpy/scipy/sympy/networkx only.
+
+    python3 /tests/run.py /tests/instance.json /workdir/answer.json
+
+Prints the reward in [0, 1] and writes /logs/verifier/details.json when that directory exists.
+
+check.py must define  check(inst, ans) -> (value, extra_dict)  and raise Invalid for a bad answer.
+  construct : value is ignored; a returned check means the witness is valid -> reward 1.0
+  optimize  : value is the raw objective; reward = 0.1 + 0.9 * progress, where
+              progress = clip((s - baseline) / (best_known - baseline), 0, 1)       (maximize)
+                         clip((baseline - s) / (baseline - best_known), 0, 1)       (minimize)
+              inst must carry "direction", "baseline", "best_known".
+"""
+import json
+import math
+import os
+import sys
+
+VALID_FLOOR = 0.1
+
+
+class Invalid(Exception):
+    pass
+
+
+# ------------------------------------------------------------ input helpers
+
+def int_list(v, n=None, lo=None, hi=None, name="list"):
+    if not isinstance(v, list):
+        raise Invalid(f"{name} must be a list")
+    if n is not None and len(v) != n:
+        raise Invalid(f"{name} must have length {n}, got {len(v)}")
+    for x in v:
+        if isinstance(x, bool) or not isinstance(x, int):
+            raise Invalid(f"{name} must contain integers only")
+        if (lo is not None and x < lo) or (hi is not None and x > hi):
+            raise Invalid(f"{name} entry {x} out of range [{lo}, {hi}]")
+    return v
+
+
+def as_int(x, name="value", lo=None, hi=None):
+    return int_list([x], 1, lo, hi, name)[0]
+
+
+def num(x, name="value"):
+    if isinstance(x, bool) or not isinstance(x, (int, float)):
+        raise Invalid(f"{name} must be a number")
+    if not math.isfinite(x):
+        raise Invalid(f"{name} is not finite")
+    return float(x)
+
+
+def float_matrix(v, rows=None, cols=None, name="matrix"):
+    if not isinstance(v, list) or (rows is not None and len(v) != rows):
+        raise Invalid(f"{name} must be a list of {rows} rows")
+    out = []
+    for r in v:
+        if not isinstance(r, list) or (cols is not None and len(r) != cols):
+            raise Invalid(f"each row of {name} must have {cols} numbers")
+        out.append([num(x, name) for x in r])
+    return out
+
+
+def float_list(v, n=None, name="list"):
+    if not isinstance(v, list) or (n is not None and len(v) != n):
+        raise Invalid(f"{name} must be a list of length {n}")
+    return [num(x, name) for x in v]
+
+
+# ------------------------------------------------------------------ reward
+
+def optimize_reward(inst, s):
+    b, best = inst["baseline"], inst["best_known"]
+    if inst.get("progress_scale") == "log":
+        # for non-negative losses spanning orders of magnitude (e.g. overlap loss -> 0);
+        # progress is measured in log10(value + floor)
+        f = inst.get("log_floor", 1e-3)
+        b, best, s = (math.log10(max(x, 0.0) + f) for x in (b, best, s))
+    if inst["direction"] == "maximize":
+        p = (s - b) / (best - b)
+    else:
+        p = (b - s) / (b - best)
+    return VALID_FLOOR + (1 - VALID_FLOOR) * max(0.0, min(1.0, p))
+
+
+def grade(inst, ans, check):
+    try:
+        if not isinstance(ans, dict):
+            raise Invalid("answer must be a JSON object")
+        value, extra = check(inst, ans)
+        if inst.get("subset") == "optimize":
+            s = float(value)
+            if not math.isfinite(s):
+                raise Invalid("non-finite score")
+            return optimize_reward(inst, s), {"valid": True, "raw_score": s, **(extra or {})}
+        return 1.0, {"valid": True, **(extra or {})}
+    except Invalid as e:
+        return 0.0, {"valid": False, "error": str(e)}
+    except Exception as e:  # any malformed answer
+        return 0.0, {"valid": False, "error": f"{type(e).__name__}: {e}"}
+
+
+def main():
+    here = os.path.dirname(os.path.abspath(__file__))
+    sys.path.insert(0, here)
+    # import ourselves as `run` so check.py's `from run import Invalid` is the same class
+    import run as R  # noqa: E402
+    import check as family  # noqa: E402
+
+    inst = json.load(open(sys.argv[1]))
+    try:
+        ans = json.load(open(sys.argv[2]))
+    except Exception as e:
+        reward, det = 0.0, {"valid": False, "error": f"unreadable answer: {e}"}
+    else:
+        reward, det = R.grade(inst, ans, family.check)
+    det["reward"] = reward
+    if os.path.isdir("/logs/verifier"):
+        with open("/logs/verifier/details.json", "w") as f:
+            json.dump(det, f)
+    print(reward)
+
+
+if __name__ == "__main__":
+    main()