# Copyright 2025 Garena Online Private Limited # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Provides a math answer grading function with high recall. Based on HF math_verify, verl, open reasoner zero, etc. """ import ast from dataclasses import dataclass import functools import json from multiprocessing import TimeoutError as MultiprocessingTimeoutError import queue import re import signal import threading from collections import Counter from fractions import Fraction from itertools import islice, zip_longest from math import isclose from typing import Any, Optional import sympy from latex2sympy2_extended import latex2sympy from math_verify import ExprExtractionConfig, LatexExtractionConfig, parse, verify from math_verify import grader as math_verify_grader from math_verify import parser as math_verify_parser from math_verify.errors import TimeoutException as MathVerifyTimeout from math_verify.utils import timeout as math_verify_signal_timeout from pylatexenc import latex2text from sympy import N, simplify from sympy.parsing import sympy_parser from sympy.parsing.latex import parse_latex from sympy.parsing.sympy_parser import parse_expr from .maze_modebench import ( ANT_MAZE_VERIFIER, POINT_MAZE_VERIFIER, ) from .maze_modebench_process import validate_maze_action_program_external from .mathir import ( MATHIR_MENU_VERIFIER, MATHIR_VERIFIER, validate_mathir_action_menu, validate_mathir_algebra, ) from .math_route import validate_math_route_response from .pantry_plan import ( PANTRY_PLAN_VERIFIER, validate_pantry_plan, ) from .python_modebench import ( PYTHON_FACTOR_VERIFIER, python_factor_route_signature, ) from .python_modebench_process import validate_python_factor_function_external def _thread_compatible_math_verify_timeout(timeout_seconds: int = 10): """Keep math_verify bounded when grading runs in an actor worker thread. math_verify's POSIX timeout installs SIGALRM. Python only permits signal handler installation on the interpreter's main thread, while OAT grades actor responses in a ThreadPool to avoid forking a CUDA/vLLM process. On the main thread retain math_verify's native alarm. Else run the protected operation in a daemon helper thread and bound the caller's wait. """ seconds = int(timeout_seconds) if seconds <= 0: raise ValueError("timeout_seconds must be positive") def decorator(func): signal_wrapped = math_verify_signal_timeout(timeout_seconds=seconds)(func) @functools.wraps(func) def wrapper(*args, **kwargs): if threading.current_thread() is threading.main_thread(): return signal_wrapped(*args, **kwargs) result_queue: queue.Queue[tuple[bool, Any]] = queue.Queue(maxsize=1) def run() -> None: try: result_queue.put((True, func(*args, **kwargs))) except BaseException as error: result_queue.put((False, error)) worker = threading.Thread( target=run, name="math-verify-timeout", daemon=True, ) worker.start() worker.join(seconds) if worker.is_alive(): raise MathVerifyTimeout("Operation timed out!") succeeded, value = result_queue.get_nowait() if succeeded: return value raise value return wrapper return decorator # parse() and verify() resolve `timeout` from their defining module globals at # call time. Install the actor-thread-safe policy without altering the external # math_verify package or its grading semantics. math_verify_parser.timeout = _thread_compatible_math_verify_timeout math_verify_grader.timeout = _thread_compatible_math_verify_timeout _math_verify_sympy_solve_and_compare = math_verify_grader.sympy_solve_and_compare def _robust_math_verify_sympy_solve_and_compare( gold, pred, float_rounding: int, numeric_precision: int, ): """Repair math_verify's scalar ``solve(Eq)`` compatibility edge case. Some SymPy versions return a list of scalar roots for ``solve(Eq, symbols)`` while math_verify assumes a list of dictionaries and calls ``.items()``. Retry only that failing equality path with ``dict=True`` and preserve the package's exact symbol-key and expression-comparison semantics. """ try: return _math_verify_sympy_solve_and_compare( gold, pred, float_rounding, numeric_precision, ) except AttributeError as error: if ( "items" not in str(error) or not isinstance(gold, sympy.Eq) or not isinstance(pred, sympy.Eq) ): raise solved_gold = sympy.solve( gold, gold.free_symbols, dict=True, ) solved_pred = sympy.solve( pred, pred.free_symbols, dict=True, ) if not isinstance(solved_gold, list) or not isinstance(solved_pred, list): return False if len(solved_gold) != len(solved_pred): return False unmatched = list(solved_pred) for gold_solution in solved_gold: if not isinstance(gold_solution, dict): return False match_index = None for index, pred_solution in enumerate(unmatched): if ( isinstance(pred_solution, dict) and set(gold_solution) == set(pred_solution) and all( math_verify_grader.sympy_expr_eq( gold_solution[key], pred_solution[key], float_rounding, numeric_precision, ) for key in gold_solution ) ): match_index = index break if match_index is None: return False unmatched.pop(match_index) return not unmatched math_verify_grader.sympy_solve_and_compare = _robust_math_verify_sympy_solve_and_compare def collect_threaded_math_rewards( pool, reward_fn, responses, references, *, timeout_seconds: float, ): """Grade a response batch concurrently with one bounded wait per result.""" pending = [ pool.apply_async(reward_fn, (response, reference)) for response, reference in zip(responses, references) ] rewards = [] infos = [] for result in pending: try: info, reward = result.get(timeout=timeout_seconds) rewards.append(reward) infos.append(info) except MultiprocessingTimeoutError: rewards.append(0.0) infos.append({"formatted": False}) return rewards, infos # Dan Hendrycks' code def mathd_normalize_answer(answer: Optional[str]) -> Optional[str]: if answer is None: return None answer = answer.strip() try: # Remove enclosing `\text{}`. m = re.search(r"^\\text\{(?P.+?)\}$", answer) if m is not None: answer = m.group("text").strip() return _strip_string(answer) except Exception: return answer # units mainly from MathQA unit_texts = [ "east", "degree", "mph", "kmph", "ft", "m sqaure", " m east", "sq m", "deg", "mile", "q .", "monkey", "prime", "ratio", "profit of rs", "rd", "o", "gm", "p . m", "lb", "tile", "per", "dm", "lt", "gain", "ab", "way", "west", "a .", "b .", "c .", "d .", "e .", "f .", "g .", "h .", "t", "a", "h", "no change", "men", "soldier", "pie", "bc", "excess", "st", "inches", "noon", "percent", "by", "gal", "kmh", "c", "acre", "rise", "a . m", "th", "π r 2", "sq", "mark", "l", "toy", "coin", "sq . m", "gallon", "° f", "profit", "minw", "yr", "women", "feet", "am", "pm", "hr", "cu cm", "square", "v â € ™", "are", "rupee", "rounds", "cubic", "cc", "mtr", "s", "ohm", "number", "kmph", "day", "hour", "minute", "min", "second", "man", "woman", "sec", "cube", "mt", "sq inch", "mp", "∏ cm ³", "hectare", "more", "sec", "unit", "cu . m", "cm 2", "rs .", "rs", "kg", "g", "month", "km", "m", "cm", "mm", "apple", "liter", "loss", "yard", "pure", "year", "increase", "decrease", "d", "less", "Surface", "litre", "pi sq m", "s .", "metre", "meter", "inch", ] unit_texts.extend([t + "s" for t in unit_texts]) def _strip_string(string): def _fix_fracs(string): substrs = string.split("\\frac") new_str = substrs[0] if len(substrs) > 1: substrs = substrs[1:] for substr in substrs: new_str += "\\frac" if substr[0] == "{": new_str += substr else: try: assert len(substr) >= 2 except Exception: return string a = substr[0] b = substr[1] if b != "{": if len(substr) > 2: post_substr = substr[2:] new_str += "{" + a + "}{" + b + "}" + post_substr else: new_str += "{" + a + "}{" + b + "}" else: if len(substr) > 2: post_substr = substr[2:] new_str += "{" + a + "}" + b + post_substr else: new_str += "{" + a + "}" + b string = new_str return string def _fix_a_slash_b(string): if len(string.split("/")) != 2: return string a = string.split("/")[0] b = string.split("/")[1] try: a = int(a) b = int(b) assert string == "{}/{}".format(a, b) new_string = "\\frac{" + str(a) + "}{" + str(b) + "}" return new_string except Exception: return string def _remove_right_units(string): # "\\text{ " only ever occurs (at least in the val set) when describing units if "\\text{ " in string: splits = string.split("\\text{ ") assert len(splits) == 2 return splits[0] else: return string def _fix_sqrt(string): if "\\sqrt" not in string: return string splits = string.split("\\sqrt") new_string = splits[0] for split in splits[1:]: if split[0] != "{": a = split[0] new_substr = "\\sqrt{" + a + "}" + split[1:] else: new_substr = "\\sqrt" + split new_string += new_substr return new_string # linebreaks string = string.replace("\n", "") # print(string) # remove inverse spaces string = string.replace("\\!", "") # print(string) # replace \\ with \ string = string.replace("\\\\", "\\") # print(string) # matrix string = re.sub(r"\\begin\{array\}\{.*?\}", r"\\begin{pmatrix}", string) string = re.sub(r"\\end\{array\}", r"\\end{pmatrix}", string) string = string.replace("bmatrix", "pmatrix") # replace tfrac and dfrac with frac string = string.replace("tfrac", "frac") string = string.replace("dfrac", "frac") string = ( string.replace("\\neq", "\\ne") .replace("\\leq", "\\le") .replace("\\geq", "\\ge") ) # print(string) # remove \left and \right string = string.replace("\\left", "") string = string.replace("\\right", "") # print(string) # Remove unit: miles, dollars if after is not none _string = re.sub(r"\\text{.*?}$", "", string).strip() if _string != "" and _string != string: # print("Warning: unit not removed: '{}' -> '{}'".format(string, _string)) string = _string # Remove unit: texts for _ in range(2): for unit_text in unit_texts: # use regex, the prefix should be either the start of the string or a non-alphanumeric character # the suffix should be either the end of the string or a non-alphanumeric character _string = re.sub(r"(^|\W)" + unit_text + r"($|\W)", r"\1\2", string) if _string != "": string = _string # Remove circ (degrees) string = string.replace("^{\\circ}", "") string = string.replace("^\\circ", "") # remove dollar signs string = string.replace("\\$", "") # remove units (on the right) string = _remove_right_units(string) # remove percentage string = string.replace("\\%", "") string = string.replace(r"\%", "") # " 0." equivalent to " ." and "{0." equivalent to "{." Alternatively, add "0" if "." is the start of the string string = string.replace(" .", " 0.") string = string.replace("{.", "{0.") # if empty, return empty string if len(string) == 0: return string if string[0] == ".": string = "0" + string # to consider: get rid of e.g. "k = " or "q = " at beginning if len(string.split("=")) == 2: if len(string.split("=")[0]) <= 2: string = string.split("=")[1] # fix sqrt3 --> sqrt{3} string = _fix_sqrt(string) # remove spaces string = string.replace(" ", "") # \frac1b or \frac12 --> \frac{1}{b} and \frac{1}{2}, etc. Even works with \frac1{72} (but not \frac{72}1). Also does a/b --> \\frac{a}{b} string = _fix_fracs(string) # manually change 0.5 --> \frac{1}{2} if string == "0.5": string = "\\frac{1}{2}" # NOTE: X/Y changed to \frac{X}{Y} in dataset, but in simple cases fix in case the model output is X/Y string = _fix_a_slash_b(string) return string SUBSTITUTIONS = [ ("an ", ""), ("a ", ""), (".$", "$"), ("\\$", ""), (r"\ ", ""), (" ", ""), ("mbox", "text"), (",\\text{and}", ","), ("\\text{and}", ","), ("\\text{m}", "\\text{}"), ] REMOVED_EXPRESSIONS = [ "square", "ways", "integers", "dollars", "mph", "inches", "ft", "hours", "km", "units", "\\ldots", "sue", "points", "feet", "minutes", "digits", "cents", "degrees", "cm", "gm", "pounds", "meters", "meals", "edges", "students", "childrentickets", "multiples", "\\text{s}", "\\text{.}", "\\text{\ns}", "\\text{}^2", "\\text{}^3", "\\text{\n}", "\\text{}", r"\mathrm{th}", r"^\circ", r"^{\circ}", r"\;", r",\!", "{,}", '"', "\\dots", ] def normalize_final_answer(final_answer: str) -> str: """ Normalize a final answer to a quantitative reasoning question. This code comes from https://arxiv.org/pdf/2206.14858.pdf, page18. """ # final_answer = final_answer.split("=")[-1] for before, after in SUBSTITUTIONS: final_answer = final_answer.replace(before, after) for expr in REMOVED_EXPRESSIONS: final_answer = final_answer.replace(expr, "") # Extract answer that is in LaTeX math, is bold, # is surrounded by a box, etc. final_answer = re.sub(r"(.*?)(\$)(.*?)(\$)(.*)", "$\\3$", final_answer) final_answer = re.sub(r"(\\text\{)(.*?)(\})", "\\2", final_answer) final_answer = re.sub(r"(\\textbf\{)(.*?)(\})", "\\2", final_answer) final_answer = re.sub(r"(\\overline\{)(.*?)(\})", "\\2", final_answer) final_answer = re.sub(r"(\\boxed\{)(.*)(\})", "\\2", final_answer) # Normalize shorthand TeX: # \fracab -> \frac{a}{b} # \frac{abc}{bef} -> \frac{abc}{bef} # \fracabc -> \frac{a}{b}c # \sqrta -> \sqrt{a} # \sqrtab -> sqrt{a}b final_answer = re.sub(r"(frac)([^{])(.)", "frac{\\2}{\\3}", final_answer) final_answer = re.sub(r"(sqrt)([^{])", "sqrt{\\2}", final_answer) final_answer = final_answer.replace("$", "") # Normalize 100,000 -> 100000 if final_answer.replace(",", "").isdigit(): final_answer = final_answer.replace(",", "") return final_answer def repeatness(s: str): def ranks(values): index = {v: i for i, v in enumerate(sorted(set(values)))} return [index[v] for v in values] def suffixArray(s): line = ranks(s) n, k, ans, sa = len(s), 1, line, [0] * len(s) while k < n - 1: line = ranks(list(zip_longest(line, islice(line, k, None), fillvalue=-1))) ans, k = line, k << 1 for i, k in enumerate(ans): sa[k] = i return ans, sa def lcp(arr, suffixArr, inv_suff): n, ans, k = len(arr), [0] * len(arr), 0 for i in range(n): if inv_suff[i] == n - 1: k = 0 continue j = suffixArr[inv_suff[i] + 1] while i + k < n and j + k < n and arr[i + k] == arr[j + k]: k += 1 ans[inv_suff[i]] = k if k > 0: k -= 1 return ans arr = [ord(i) for i in s] n = len(arr) if n <= 1: return 0 c, sa = suffixArray(arr) cnt = sum(lcp(arr, sa, c)) return (cnt * 2 / (n * (n + 1))) > 0.2 class timeout: def __init__(self, seconds=1, error_message="Timeout"): self.seconds = seconds self.error_message = error_message self._armed = False self._old_handler = None def handle_timeout(self, signum, frame): raise TimeoutError(self.error_message) def __enter__(self): if threading.current_thread() is not threading.main_thread(): return self self._old_handler = signal.getsignal(signal.SIGALRM) signal.signal(signal.SIGALRM, self.handle_timeout) signal.alarm(self.seconds) self._armed = True return self def __exit__(self, type, value, traceback): if self._armed: signal.alarm(0) signal.signal(signal.SIGALRM, self._old_handler) self._armed = False def latex_eval(latex): sym = parse_latex(latex) val = sym.evalf() return sym, val def numeric_equal(prediction: float, reference: float): # Note that relative tolerance has significant impact # on the result of the synthesized GSM-Hard dataset # if reference.is_integer(): # return isclose(reference, round(prediction), abs_tol=1e-4) # else: # prediction = round(prediction, len(str(reference).split(".")[-1])) return isclose(reference, prediction, rel_tol=1e-4) def symbolic_equal(a, b): def _parse(s): for f in [parse_latex, parse_expr, latex2sympy]: try: return f(s.replace("\\\\", "\\")) except Exception: try: return f(s) except Exception: pass return s a = _parse(a) b = _parse(b) # direct equal try: if str(a) == str(b) or a == b: return True except Exception: pass # simplify equal try: if a.equals(b) or simplify(a - b) == 0: return True except Exception: pass # equation equal try: if (abs(a.lhs - a.rhs)).equals(abs(b.lhs - b.rhs)): return True except Exception: pass try: if numeric_equal(float(N(a)), float(N(b))): return True except Exception: pass # matrix try: # if a and b are matrix if a.shape == b.shape: _a = a.applyfunc(lambda x: round(x, 3)) _b = b.applyfunc(lambda x: round(x, 3)) if _a.equals(_b): return True except Exception: pass return False def _is_latex_equal(str1, str2): try: sym1, val1 = latex_eval(str1) sym2, val2 = latex_eval(str2) if sym1 == sym2 or val1 == val2: return True else: raise ValueError except Exception: # noqa try: norm1, norm2 = normalize_final_answer(str1), normalize_final_answer(str2) sym1, val1 = latex_eval(norm1) sym2, val2 = latex_eval(norm2) if sym1 == sym2 or val1 == val2: return True except Exception: # noqa return norm1 == norm2 return False def is_latex_equal(given_answer: str, ground_truth: str) -> bool: try: with timeout(1): try: if (len(given_answer) > 128 and repeatness(given_answer)) or ( len(ground_truth) > 128 and repeatness(ground_truth) ): return False # First conduct normalized string matching. ground_truth_normalized = _normalize(ground_truth) given_normalized = _normalize(given_answer) if ground_truth_normalized is None: return False if ground_truth_normalized == given_normalized: return True # Next call math verify. given_answer.replace("\n", "") ground_truth.replace("\n", "") if "$" not in given_answer: given_answer = f"${given_answer}$" if "$" not in ground_truth: ground_truth = f"${ground_truth}$" return verify( parse( ground_truth, extraction_config=( LatexExtractionConfig(boxed_match_priority=0), ExprExtractionConfig(), ), fallback_mode="no_fallback", extraction_mode=["first_match"], parsing_timeout=1, ), parse( given_answer, extraction_config=( LatexExtractionConfig(boxed_match_priority=0), ExprExtractionConfig(), ), fallback_mode="no_fallback", extraction_mode=["first_match"], parsing_timeout=1, ), timeout_seconds=1, ) # or symbolic_equal(ground_truth, given_answer) except Exception: return False except TimeoutError: return False def is_value_equal(given_answer: str, ground_truth: str) -> bool: assert ground_truth is not None ground_truth_normalized_mathd = mathd_normalize_answer(ground_truth) given_answer_normalized_mathd = mathd_normalize_answer(given_answer) str_equal = ground_truth_normalized_mathd == given_answer_normalized_mathd try: number_equal = float(ground_truth_normalized_mathd) == float( given_answer_normalized_mathd ) return str_equal or number_equal except Exception: return str_equal # sympy might hang -- we don't care about trying to be lenient in these cases BAD_SUBSTRINGS = ["^{", "^("] BAD_REGEXES = [r"\^[0-9]+\^", r"\^[0-9][0-9]+"] TUPLE_CHARS = "()[]" def _sympy_parse(expr: str): """Parses an expression with sympy.""" py_expr = expr.replace("^", "**") return sympy_parser.parse_expr( py_expr, transformations=( sympy_parser.standard_transformations + (sympy_parser.implicit_multiplication_application,) ), ) def _parse_latex(expr: str) -> str: """Attempts to parse latex to an expression sympy can read.""" expr = expr.replace("\\tfrac", "\\frac") expr = expr.replace("\\dfrac", "\\frac") expr = expr.replace("\\frac", " \\frac") # Play nice with mixed numbers. expr = latex2text.LatexNodes2Text().latex_to_text(expr) # Replace the specific characters that this parser uses. expr = expr.replace("√", "sqrt") expr = expr.replace("π", "pi") expr = expr.replace("∞", "inf") expr = expr.replace("∪", "U") expr = expr.replace("·", "*") expr = expr.replace("×", "*") return expr.strip() def _is_float(num: str) -> bool: try: float(num) return True except ValueError: return False def _is_int(x: float) -> bool: try: return abs(x - int(round(x))) <= 1e-7 except Exception: return False def _is_frac(expr: str) -> bool: return bool(re.search(r"^-?[0-9]+.?/0*[1-9][0-9]*.?$", expr)) def _str_is_int(x: str) -> bool: try: x = _strip_properly_formatted_commas(x) x = float(x) return abs(x - int(round(x))) <= 1e-7 except Exception: return False def _str_to_int(x: str) -> bool: x = x.replace(",", "") x = float(x) return int(x) def _inject_implicit_mixed_number(step: str): """ Automatically make a mixed number evalable e.g. 7 3/4 => 7+3/4 """ p1 = re.compile("([0-9]) +([0-9])") step = p1.sub("\\1+\\2", step) ## implicit mults return step def _strip_properly_formatted_commas(expr: str): # We want to be careful because we don't want to strip tuple commas p1 = re.compile(r"(\d)(,)(\d\d\d)($|\D)") while True: next_expr = p1.sub("\\1\\3\\4", expr) if next_expr == expr: break expr = next_expr return next_expr def _normalize(expr: str) -> str: """Normalize answer expressions.""" if expr is None: return None # Remove enclosing `\text{}`. m = re.search(r"^\\text\{(?P.+?)\}$", expr) if m is not None: expr = m.group("text") expr = expr.replace("\\%", "%") expr = expr.replace("\\$", "$") expr = expr.replace("$", "") expr = expr.replace("%", "") expr = expr.replace(" or ", " , ") expr = expr.replace(" and ", " , ") expr = expr.replace("million", "*10^6") expr = expr.replace("billion", "*10^9") expr = expr.replace("trillion", "*10^12") for unit in [ "degree", "cm", "centimeter", "meter", "mile", "second", "minute", "hour", "day", "week", "month", "year", "foot", "feet", "inch", "yard", ]: expr = re.sub(rf"{unit}(es)?(s)? *(\^[0-9]+)?", "", expr) expr = re.sub(r"\^ *\\\\circ", "", expr) if len(expr) > 0 and expr[0] == "{" and expr[-1] == "}": expr = expr[1:-1] expr = re.sub(",\\\\! *", "", expr) if _is_float(expr) and _is_int(float(expr)): expr = str(int(round(float(expr)))) if "\\" in expr: try: expr = _parse_latex(expr) except Exception: pass # edge case with mixed numbers and negative signs expr = re.sub("- *", "-", expr) expr = _inject_implicit_mixed_number(expr) expr = expr.replace(" ", "") # if we somehow still have latex braces here, just drop them expr = expr.replace("{", "") expr = expr.replace("}", "") # don't be case sensitive for text answers expr = expr.lower() if _str_is_int(expr): expr = str(_str_to_int(expr)) return expr def count_unknown_letters_in_expr(expr: str): expr = expr.replace("sqrt", "") expr = expr.replace("frac", "") letters_in_expr = set([x for x in expr if x.isalpha()]) return len(letters_in_expr) def should_allow_eval(expr: str): # we don't want to try parsing unknown text or functions of more than two variables if count_unknown_letters_in_expr(expr) > 2: return False for bad_string in BAD_SUBSTRINGS: if bad_string in expr: return False for bad_regex in BAD_REGEXES: if re.search(bad_regex, expr) is not None: return False return True def are_equal_under_sympy(ground_truth_normalized: str, given_normalized: str): are_equal = False try: expr = f"({ground_truth_normalized})-({given_normalized})" if should_allow_eval(expr): sympy_diff = _sympy_parse(expr) simplified = sympy.simplify(sympy_diff) if simplified == 0: are_equal = True except Exception: pass return are_equal def split_tuple(expr: str): """ Split the elements in a tuple/interval, while handling well-formatted commas in large numbers """ expr = _strip_properly_formatted_commas(expr) if len(expr) == 0: return [] if ( len(expr) > 2 and expr[0] in TUPLE_CHARS and expr[-1] in TUPLE_CHARS and all([ch not in expr[1:-1] for ch in TUPLE_CHARS]) ): elems = [elem.strip() for elem in expr[1:-1].split(",")] else: elems = [expr] return elems def last_boxed_only_string(string): idx = string.rfind("\\boxed") if idx < 0: idx = string.rfind("\\fbox") if idx < 0: return None i = idx right_brace_idx = None num_left_braces_open = 0 while i < len(string): if string[i] == "{": num_left_braces_open += 1 if string[i] == "}": num_left_braces_open -= 1 if num_left_braces_open == 0: right_brace_idx = i break i += 1 if right_brace_idx is None: retval = None else: retval = string[idx : right_brace_idx + 1] return retval def remove_boxed(s): left = "\\boxed{" try: assert s[: len(left)] == left assert s[-1] == "}" return s[len(left) : -1] except Exception: return None def extract_boxed_answer(solution: str) -> str: """Extract the answer from inside a LaTeX \\boxed{} command""" solution = last_boxed_only_string(solution) solution = remove_boxed(solution) return solution def grade_answer_sympy(given_answer: str, ground_truth: str) -> bool: ground_truth_normalized = _normalize(ground_truth) given_normalized = _normalize(given_answer) if ground_truth_normalized is None: return False if ground_truth_normalized == given_normalized: return True if len(given_normalized) == 0: return False ground_truth_elems = split_tuple(ground_truth_normalized) given_elems = split_tuple(given_normalized) if len(ground_truth_elems) > 1 and ( ground_truth_normalized[0] != given_normalized[0] or ground_truth_normalized[-1] != given_normalized[-1] ): is_correct = False elif len(ground_truth_elems) != len(given_elems): is_correct = False else: for ground_truth_elem, given_elem in zip(ground_truth_elems, given_elems): if _is_frac(ground_truth_elem) and _is_frac(given_elem): # if fractions aren't reduced, then shouldn't be marked as correct # so, we don't want to allow sympy.simplify in this case is_correct = ground_truth_elem == given_elem elif _str_is_int(ground_truth_elem) != _str_is_int(given_elem): # if the ground truth answer is an integer, we require the given answer to be a strict match (no sympy.simplify) is_correct = False else: is_correct = are_equal_under_sympy(ground_truth_elem, given_elem) if not is_correct: break return is_correct def grade_answer_mathd(given_answer: str, ground_truth: str) -> bool: ground_truth_normalized_mathd = mathd_normalize_answer(ground_truth) given_answer_normalized_mathd = mathd_normalize_answer(given_answer) # be at least as lenient as mathd if ground_truth_normalized_mathd == given_answer_normalized_mathd: return True return False def extract_answer(passage: str) -> str: if "\\boxed" in passage: return extract_boxed_answer(passage) return None def _parse_modebench_spec(gt_answer: Any) -> dict[str, Any] | None: if isinstance(gt_answer, dict): spec = gt_answer elif isinstance(gt_answer, str): text = gt_answer.strip() if not (text.startswith("{") and text.endswith("}")): return None try: spec = json.loads(text) except Exception: return None else: return None verifier = spec.get("verifier") if verifier in { "graph_coloring", "countdown", MATHIR_VERIFIER, MATHIR_MENU_VERIFIER, PANTRY_PLAN_VERIFIER, PYTHON_FACTOR_VERIFIER, POINT_MAZE_VERIFIER, ANT_MAZE_VERIFIER, }: return spec return None PYTHON_FACTOR_RESPONSE_SURFACE_VERSION = ( "python-factor-response-v2-latex-lambda" ) def _normalize_python_factor_lambda_surface(candidate: str) -> str: """Normalize one formatting-only LaTeX spelling of ``lambda n:``.""" # Qwen's native boxed surface can typeset the Python keyword as the LaTeX # command ``\lambda``. Accept only the exact required signature (plus the # conventional ``\,`` spacing alias); the restricted AST parser and # isolated executable validator remain the authority. return re.sub( r"^\\lambda(?:\s+|\\,\s*)n\s*:\s*", "lambda n: ", str(candidate).strip(), count=1, ).strip() def _extract_modebench_candidate(model_response: str, gt_answer: Any) -> str | None: spec = _parse_modebench_spec(gt_answer) if spec is None: return None if "\\boxed" in str(model_response): candidate = extract_answer(str(model_response)) if candidate is None: return None if str(spec.get("verifier")) == PYTHON_FACTOR_VERIFIER: candidate = _normalize_python_factor_lambda_surface(candidate) return candidate or None candidate = str(model_response).strip() if not candidate: return None if str(spec.get("verifier")) in { MATHIR_VERIFIER, MATHIR_MENU_VERIFIER, }: fenced = re.fullmatch( r"```(?:mathir)?\s*(.*?)\s*```", candidate, flags=re.IGNORECASE | re.DOTALL, ) if fenced is not None: candidate = fenced.group(1).strip() if len(candidate) > 200 or "<" in candidate or ">" in candidate: return None # Whitespace, a terminal semicolon, and an all-program code fence are # formatting aliases. The restricted parser remains the authority. return candidate or None if str(spec.get("verifier")) == PYTHON_FACTOR_VERIFIER: fenced = re.fullmatch( r"```(?:python)?\s*(.*?)\s*```", candidate, flags=re.IGNORECASE | re.DOTALL, ) if fenced is not None: candidate = fenced.group(1).strip() if ( len(candidate) > 240 or "\n" in candidate or "\r" in candidate or "<" in candidate or ">" in candidate ): return None candidate = re.sub( r"^\s*(?:the\s+)?(?:final\s+)?(?:answer|program|function)\s*" r"(?:is|=|:)\s*", "", candidate, flags=re.IGNORECASE, ).strip() candidate = _normalize_python_factor_lambda_surface(candidate) return candidate or None if str(spec.get("verifier")) in { POINT_MAZE_VERIFIER, ANT_MAZE_VERIFIER, }: fenced = re.fullmatch( r"```(?:actions?|plan)?\s*(.*?)\s*```", candidate, flags=re.IGNORECASE | re.DOTALL, ) if fenced is not None: candidate = fenced.group(1).strip() if len(candidate) > 4096 or "<" in candidate or ">" in candidate: return None candidate = re.sub( r"^\s*(?:the\s+)?(?:final\s+)?(?:answer|plan|program|actions?)\s*" r"(?:is|=|:)\s*", "", candidate, flags=re.IGNORECASE, ).strip() return candidate or None if str(spec.get("verifier")) == PANTRY_PLAN_VERIFIER: if ( len(candidate) > 512 or "\n" in candidate or "\r" in candidate or "<" in candidate or ">" in candidate ): return None candidate = re.sub( r"^\s*(?:the\s+)?(?:final\s+)?(?:answer|plan|recipe)\s*" r"(?:is|=|:)\s*", "", candidate, flags=re.IGNORECASE, ).strip() return candidate or None if "\n" in candidate or "\r" in candidate or "<" in candidate or ">" in candidate: return None if len(candidate) > 160: return None candidate = re.sub( r"^\s*(?:the\s+)?(?:final\s+)?(?:answer|expression|coloring|program)\s*" r"(?:is|=|:)\s*", "", candidate, flags=re.IGNORECASE, ).strip() return candidate or None def _parse_graph_coloring_answer(candidate: str, n: int) -> list[int] | None: text = str(candidate).strip().lower() text = re.sub(r"^(?:coloring|answer)\s*(?:is|=|:)\s*", "", text).strip() compact = re.sub(r"[\s,;|\[\]\(\)\{\}:.-]+", "", text) if len(compact) == n and all(ch in "123" for ch in compact): return [int(ch) for ch in compact] tokens = re.findall(r"[123]", text) if len(tokens) == n: return [int(token) for token in tokens] return None def _parse_graph_digit_sequence(candidate: str, expected_len: int) -> list[int] | None: text = str(candidate).strip().lower() text = re.sub( r"^(?:missing\s+)?(?:colors?|digits?|answer)\s*(?:are|is|=|:)\s*", "", text, ).strip() compact = re.sub(r"[\s,;|\[\]\(\)\{\}:.-]+", "", text) if len(compact) == expected_len and all(ch in "123" for ch in compact): return [int(ch) for ch in compact] tokens = re.findall(r"[123]", text) if len(tokens) == expected_len: return [int(token) for token in tokens] return None def _verify_graph_coloring_colors( colors: list[int] | None, spec: dict[str, Any], ) -> bool: """Validate one already-parsed coloring object against its problem.""" try: n = int(spec["n"]) edges = spec["edges"] except Exception: return False if colors is None or len(colors) != n: return False partial_colors = spec.get("partial_colors") if partial_colors is not None: try: if len(partial_colors) != n: return False for index, color in enumerate(partial_colors): if color is None: continue if colors[index] != int(color): return False except Exception: return False for edge in edges: try: u, v = int(edge[0]), int(edge[1]) except Exception: return False if u < 1 or v < 1 or u > n or v > n: return False if colors[u - 1] == colors[v - 1]: return False return True def _verify_graph_coloring_answer(candidate: str, spec: dict[str, Any]) -> bool: colors = _graph_coloring_from_candidate(candidate, spec) return _verify_graph_coloring_colors(colors, spec) def _normalize_countdown_expression(candidate: str) -> str: text = str(candidate).strip() text = text.replace("\\times", "*").replace("\\cdot", "*") text = text.replace("\\div", "/").replace("÷", "/").replace("×", "*") text = text.replace("^", "**") text = re.sub(r"^\s*(?:expression|answer)\s*(?:is|=|:)\s*", "", text, flags=re.I) return text.strip() def _countdown_eval_and_numbers(node: ast.AST) -> tuple[Fraction, list[int]]: if isinstance(node, ast.Expression): return _countdown_eval_and_numbers(node.body) if isinstance(node, ast.Constant): if isinstance(node.value, bool) or not isinstance(node.value, int): raise ValueError("Countdown constants must be integers.") return Fraction(int(node.value), 1), [int(node.value)] if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)): value, numbers = _countdown_eval_and_numbers(node.operand) if isinstance(node.op, ast.USub): value = -value return value, numbers if isinstance(node, ast.BinOp): left, left_numbers = _countdown_eval_and_numbers(node.left) right, right_numbers = _countdown_eval_and_numbers(node.right) if isinstance(node.op, ast.Add): value = left + right elif isinstance(node.op, ast.Sub): value = left - right elif isinstance(node.op, ast.Mult): value = left * right elif isinstance(node.op, ast.Div): if right == 0: raise ValueError("Countdown division by zero.") value = left / right else: raise ValueError("Unsupported Countdown operator.") return value, left_numbers + right_numbers raise ValueError("Unsupported Countdown expression.") def _verify_countdown_expression(candidate: str, spec: dict[str, Any]) -> bool: try: target = Fraction(int(spec["target"]), 1) expected_numbers = Counter(int(value) for value in spec["numbers"]) except Exception: return False text = _normalize_countdown_expression(candidate) if not text: return False parts = [part.strip() for part in text.split("=") if part.strip()] if not parts: parts = [text] for part in parts: if not re.fullmatch(r"[0-9+\-*/().\s*]+", part): continue try: parsed = ast.parse(part, mode="eval") value, used_numbers = _countdown_eval_and_numbers(parsed) except Exception: continue if value == target and Counter(used_numbers) == expected_numbers: return True return False def _graph_coloring_from_candidate( candidate: str, spec: dict[str, Any], ) -> list[int] | None: try: n = int(spec["n"]) except Exception: return None colors = _parse_graph_coloring_answer(candidate, n) partial_colors = spec.get("partial_colors") if colors is None and partial_colors is not None: try: hidden_positions = [ index for index, color in enumerate(partial_colors) if color is None ] fill = _parse_graph_digit_sequence(candidate, len(hidden_positions)) if fill is not None: colors = [ int(color) if color is not None else 0 for color in partial_colors ] for index, color in zip(hidden_positions, fill): colors[index] = color except Exception: return None if colors is None or len(colors) != n: return None return colors def _canonical_countdown_ast(node: ast.AST) -> str: if isinstance(node, ast.Expression): return _canonical_countdown_ast(node.body) if isinstance(node, ast.Constant): if isinstance(node.value, bool) or not isinstance(node.value, int): raise ValueError("Countdown constants must be integers.") return str(int(node.value)) if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)): inner = _canonical_countdown_ast(node.operand) if isinstance(node.op, ast.USub): return f"neg({inner})" return inner if isinstance(node, ast.BinOp): left = _canonical_countdown_ast(node.left) right = _canonical_countdown_ast(node.right) if isinstance(node.op, ast.Add): parts = sorted([left, right]) return f"add({parts[0]},{parts[1]})" if isinstance(node.op, ast.Mult): parts = sorted([left, right]) return f"mul({parts[0]},{parts[1]})" if isinstance(node.op, ast.Sub): return f"sub({left},{right})" if isinstance(node.op, ast.Div): return f"div({left},{right})" raise ValueError("Unsupported Countdown expression.") def _canonical_countdown_route_ast(node: ast.AST) -> str: """Canonical operator/dependency skeleton with numeric leaves abstracted.""" if isinstance(node, ast.Expression): return _canonical_countdown_route_ast(node.body) if isinstance(node, ast.Constant): if isinstance(node.value, bool) or not isinstance(node.value, int): raise ValueError("Countdown constants must be integers.") return "input" if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)): inner = _canonical_countdown_route_ast(node.operand) return f"neg({inner})" if isinstance(node.op, ast.USub) else inner if isinstance(node, ast.BinOp): left = _canonical_countdown_route_ast(node.left) right = _canonical_countdown_route_ast(node.right) if isinstance(node.op, ast.Add): parts = sorted([left, right]) return f"add({parts[0]},{parts[1]})" if isinstance(node.op, ast.Mult): parts = sorted([left, right]) return f"mul({parts[0]},{parts[1]})" if isinstance(node.op, ast.Sub): return f"sub({left},{right})" if isinstance(node.op, ast.Div): return f"div({left},{right})" raise ValueError("Unsupported Countdown route expression.") def _canonical_countdown_expression_key( candidate: str, spec: dict[str, Any], ) -> str | None: try: expected_numbers = Counter(int(value) for value in spec["numbers"]) except Exception: return None text = _normalize_countdown_expression(candidate) if not text: return None parts = [part.strip() for part in text.split("=") if part.strip()] or [text] for part in parts: if not re.fullmatch(r"[0-9+\-*/().\s*]+", part): continue try: parsed = ast.parse(part, mode="eval") _, used_numbers = _countdown_eval_and_numbers(parsed) if Counter(used_numbers) != expected_numbers: continue return f"countdown:{_canonical_countdown_ast(parsed)}" except Exception: continue return None def _modebench_answer_key( model_response: str, gt_answer: Any, ) -> str | None: spec = _parse_modebench_spec(gt_answer) if spec is None: return None candidate = _extract_modebench_candidate(model_response, gt_answer) if candidate is None: return None verifier = str(spec.get("verifier")) if verifier == "graph_coloring": colors = _graph_coloring_from_candidate(candidate, spec) if colors is None: return None return "graph_coloring:" + "".join(str(int(color)) for color in colors) if verifier == "countdown": return _canonical_countdown_expression_key(candidate, spec) if verifier == MATHIR_VERIFIER: validation = validate_mathir_algebra(candidate, spec) return validation.canonical_key if validation is not None else None if verifier == MATHIR_MENU_VERIFIER: validation = validate_mathir_action_menu(candidate, spec) return validation.canonical_key if validation is not None else None if verifier == PYTHON_FACTOR_VERIFIER: validation = validate_python_factor_function_external(candidate, spec) return validation.canonical_key if validation is not None else None if verifier == PANTRY_PLAN_VERIFIER: validation = validate_pantry_plan(candidate, spec) return validation.canonical_key if validation is not None else None if verifier in {POINT_MAZE_VERIFIER, ANT_MAZE_VERIFIER}: validation = validate_maze_action_program_external(candidate, spec) return validation.canonical_key if validation is not None else None return None def validated_modebench_outcome_key( model_response: str, gt_answer: Any, ) -> str | None: """Return a canonical outcome only when that same response verifies. This is the admission boundary for online canonical banks. It deliberately supports only ModeBench tasks with executable validators: - graph colorings are parsed and checked against every graph edge; - Countdown expressions are parsed, checked for exact operand use, and executed against the requested target. - MathIR algebra programs are parsed by a restricted grammar, executed as state transformations, exact-normalized, and accepted only when execution isolates the right solution. Their key comes from those executed states. - Python factor functions are syntax-restricted and called in an isolated Python worker. Their key is the vector returned by those exact tool calls. Ordinary MATH final-answer grading is not a proof/strategy verifier and is therefore rejected here rather than being mislabeled as canonical search. """ spec = _parse_modebench_spec(gt_answer) if spec is None: return None candidate = _extract_modebench_candidate(model_response, gt_answer) if candidate is None: return None verifier = str(spec.get("verifier")) if verifier == "graph_coloring": colors = _graph_coloring_from_candidate(candidate, spec) if not _verify_graph_coloring_colors(colors, spec): return None assert colors is not None return "graph_coloring:" + "".join(str(int(color)) for color in colors) if verifier == MATHIR_VERIFIER: validation = validate_mathir_algebra(candidate, spec) # The key is constructed from the exact normalized equation states # produced by the same interpreter execution that validated the answer. return validation.canonical_key if validation is not None else None if verifier == MATHIR_MENU_VERIFIER: validation = validate_mathir_action_menu(candidate, spec) # Menu labels are expanded first. Identity comes only from the exact # normalized states produced by executing those concrete operations. return validation.canonical_key if validation is not None else None if verifier == PYTHON_FACTOR_VERIFIER: validation = validate_python_factor_function_external(candidate, spec) return validation.canonical_key if validation is not None else None if verifier == PANTRY_PLAN_VERIFIER: validation = validate_pantry_plan(candidate, spec) return validation.canonical_key if validation is not None else None if verifier in {POINT_MAZE_VERIFIER, ANT_MAZE_VERIFIER}: validation = validate_maze_action_program_external(candidate, spec) return validation.canonical_key if validation is not None else None if verifier != "countdown": return None try: target = Fraction(int(spec["target"]), 1) expected_numbers = Counter(int(value) for value in spec["numbers"]) except Exception: return None text = _normalize_countdown_expression(candidate) parts = [part.strip() for part in text.split("=") if part.strip()] or [text] for part in parts: if not re.fullmatch(r"[0-9+\-*/().\s*]+", part): continue try: parsed = ast.parse(part, mode="eval") value, used_numbers = _countdown_eval_and_numbers(parsed) if value != target or Counter(used_numbers) != expected_numbers: continue # The key is derived from the exact AST object that passed # execution and operand validation above. return f"countdown:{_canonical_countdown_ast(parsed)}" except Exception: continue return None @dataclass(frozen=True) class VerifiedExplorationIdentity: """Separate prompt-local endpoint and cross-prompt route identities.""" verifier: str endpoint_key: str route_signature: str | None def validated_modebench_exploration_identity( model_response: str, gt_answer: Any, ) -> VerifiedExplorationIdentity | None: """Return hierarchical identity only after exact executable validation.""" spec = _parse_modebench_spec(gt_answer) if spec is None: return None candidate = _extract_modebench_candidate(model_response, gt_answer) if candidate is None: return None verifier = str(spec.get("verifier")) if verifier == "graph_coloring": colors = _graph_coloring_from_candidate(candidate, spec) if not _verify_graph_coloring_colors(colors, spec): return None assert colors is not None endpoint = "graph_coloring:" + "".join(str(int(color)) for color in colors) return VerifiedExplorationIdentity(verifier, endpoint, None) if verifier == MATHIR_VERIFIER: validation = validate_mathir_algebra(candidate, spec) if validation is None: return None solution = validation.solution endpoint = f"mathir-solution:{solution.numerator}/{solution.denominator}" return VerifiedExplorationIdentity( verifier, endpoint, validation.route_signature, ) if verifier == MATHIR_MENU_VERIFIER: validation = validate_mathir_action_menu(candidate, spec) if validation is None: return None solution = validation.solution endpoint = f"mathir-solution:{solution.numerator}/{solution.denominator}" return VerifiedExplorationIdentity( verifier, endpoint, validation.route_signature, ) if verifier == PYTHON_FACTOR_VERIFIER: validation = validate_python_factor_function_external(candidate, spec) if validation is None: return None try: route = python_factor_route_signature(candidate) except Exception: return None return VerifiedExplorationIdentity( verifier, validation.canonical_key, route, ) if verifier == PANTRY_PLAN_VERIFIER: validation = validate_pantry_plan(candidate, spec) if validation is None: return None return VerifiedExplorationIdentity( verifier, validation.canonical_key, None, ) if verifier in {POINT_MAZE_VERIFIER, ANT_MAZE_VERIFIER}: validation = validate_maze_action_program_external(candidate, spec) if validation is None: return None return VerifiedExplorationIdentity( verifier, f"{verifier}:goal:{spec.get('map_id')}", validation.canonical_key, ) if verifier != "countdown": return None try: target = Fraction(int(spec["target"]), 1) expected_numbers = Counter(int(value) for value in spec["numbers"]) except Exception: return None text = _normalize_countdown_expression(candidate) parts = [part.strip() for part in text.split("=") if part.strip()] or [text] for part in parts: if not re.fullmatch(r"[0-9+\-*/().\s*]+", part): continue try: parsed = ast.parse(part, mode="eval") value, used_numbers = _countdown_eval_and_numbers(parsed) if value != target or Counter(used_numbers) != expected_numbers: continue endpoint = f"countdown-value:{value.numerator}/{value.denominator}" route = "countdown-route:v1:" + _canonical_countdown_route_ast(parsed) return VerifiedExplorationIdentity(verifier, endpoint, route) except Exception: continue return None def _grade_modebench_answer(model_answer: str, gt_answer: Any) -> bool | None: spec = _parse_modebench_spec(gt_answer) if spec is None: return None verifier = str(spec.get("verifier")) if verifier == "graph_coloring": return _verify_graph_coloring_answer(model_answer, spec) if verifier == "countdown": return _verify_countdown_expression(model_answer, spec) if verifier == MATHIR_VERIFIER: return validate_mathir_algebra(model_answer, spec) is not None if verifier == MATHIR_MENU_VERIFIER: return validate_mathir_action_menu(model_answer, spec) is not None if verifier == PYTHON_FACTOR_VERIFIER: return validate_python_factor_function_external(model_answer, spec) is not None if verifier == PANTRY_PLAN_VERIFIER: return validate_pantry_plan(model_answer, spec) is not None if verifier in {POINT_MAZE_VERIFIER, ANT_MAZE_VERIFIER}: return validate_maze_action_program_external(model_answer, spec) is not None return False def _clean_final_answer_candidate(candidate: str | None) -> str | None: """Return a compact final-answer candidate, or ``None`` for malformed text.""" if candidate is None: return None candidate = str(candidate).strip() if not candidate: return None # Answer identity is deliberately stricter than correctness grading: mode # metrics need one stable, compact key per formatted final answer. if "\n" in candidate or "\r" in candidate or "<" in candidate or ">" in candidate: return None if len(candidate) > 160: return None candidate = re.sub( r"^\s*(?:the\s+)?(?:final\s+)?answer\s*(?:is|=|:)\s*", "", candidate, flags=re.IGNORECASE, ).strip() return candidate or None def _extract_r1_reasoning_and_answer_sections( model_response: str, ) -> tuple[str | None, str | None]: """Return ``( body, body)`` for an R1-style trace. Training prompts already end inside an open ```` tag, so many model responses begin with reasoning text and only emit the closing ```` before ````. We accept both: 1. full tagged traces containing ``......`` 2. response-only continuations containing ``... ...`` """ if "" not in model_response or "" not in model_response: return None, None try: prefix, answer_suffix = model_response.split("", 1) answer = answer_suffix.split("", 1)[0].strip() reasoning = None if "" in prefix and "" in prefix: reasoning = prefix.split("", 1)[1].split("", 1)[0].strip() elif "" in prefix: reasoning = prefix.split("", 1)[0].strip() else: return None, None answer = answer except Exception: return None, None return reasoning or None, answer or None def extract_normalized_final_answer( model_response: str, *, template: str = "r1", gt_answer: Any = None ) -> str | None: """Return a conservative canonical key for an answer or exact benchmark mode.""" try: if gt_answer is not None: if _parse_modebench_spec(gt_answer) is not None: return _modebench_answer_key( model_response, gt_answer, ) modebench_key = _modebench_answer_key( model_response, gt_answer, ) if modebench_key is not None: return modebench_key candidate = None if template == "r1": # Match the training reward's strict R1 formatting gate. _, candidate = _extract_r1_reasoning_and_answer_sections(model_response) if candidate is None: return None else: candidate = extract_answer(model_response) if candidate is None: return None extracted = extract_answer(candidate) if "\\boxed" in candidate else candidate extracted = _clean_final_answer_candidate(extracted) if extracted is None: return None normalized = normalize_final_answer(extracted) normalized = _normalize(normalized) if normalized is None: normalized = normalize_final_answer(extracted) if normalized is None: return None normalized = str(normalized).strip().lower() return normalized or None except Exception: return None def grade(model_answer: str, gt_answer: str, fast: bool = True): if "\\boxed" in gt_answer: gt_answer = extract_answer(gt_answer) correct = grade_answer_mathd(model_answer, gt_answer) or grade_answer_sympy( model_answer, gt_answer ) if not fast: # This mode further uses math_verify to recall originally false positives. # Will be a bit slower, and sensitive to bad inputs. correct = correct or is_latex_equal( model_answer, gt_answer, ) return correct def boxed_reward_fn(model_response, gt_answer, fast=False): model_answer = _extract_modebench_candidate(model_response, gt_answer) if model_answer is not None: modebench_correct = _grade_modebench_answer(model_answer, gt_answer) if modebench_correct is not None: return {"formatted": True}, 1.0 if modebench_correct else 0.0 model_answer = extract_answer(model_response) if model_answer is None: return {"formatted": False}, 0.0 # Cannot even parse anything. modebench_correct = _grade_modebench_answer(model_answer, gt_answer) if modebench_correct is not None: return {"formatted": True}, 1.0 if modebench_correct else 0.0 if isinstance(gt_answer, float) or isinstance(gt_answer, int): gt_answer = str(gt_answer) if isinstance(gt_answer, str): is_correct = grade(model_answer, gt_answer, fast) elif isinstance(gt_answer, list): is_correct = False for gt in gt_answer: is_correct |= grade(model_answer, gt, fast) if is_correct: return {"formatted": True}, 1.0 # Correctness reward. else: return { "formatted": True }, 0.0 # Formatted but wrong answer; no format reward to avoid hacking. def validated_math_route_signature( model_response: str, problem: str, gt_answer: Any, *, fast: bool = False, task_verified: bool | None = None, ) -> str | None: """Return an executable route identity only for a task-correct response. Task correctness, route execution, and agreement between the trace terminal value and the response's boxed answer are independent fail-closed checks. A correct answer without a valid trace keeps its ordinary task reward but has no route identity. """ try: if task_verified is None: _info, reward = boxed_reward_fn( model_response, gt_answer, fast=fast, ) task_verified = float(reward) > 0.0 if not bool(task_verified): return None validation = validate_math_route_response(model_response, problem) if validation is None: return None model_answer = extract_answer(model_response) if model_answer is None: return None terminal_answer = sympy.latex(validation.terminal_value) if not grade(model_answer, terminal_answer, fast=fast): return None return validation.route_signature except Exception: return None def validated_exploration_identity( model_response: str, problem: str, gt_answer: Any, *, fast: bool = False, task_verified: bool | None = None, ) -> VerifiedExplorationIdentity | None: """Return the endpoint/route pair for ModeBench or free-form MATH. ModeBench references always remain on their exact executable validator path. Free-form MATH may reuse the actor's already-computed task verdict, but route admission still independently executes the restricted trace and checks its terminal value against the boxed response. Thus a task-correct response without a valid route retains an endpoint identity and ordinary reward while contributing no route identity. """ if _parse_modebench_spec(gt_answer) is not None: return validated_modebench_exploration_identity( model_response, gt_answer, ) try: if task_verified is None: _info, reward = boxed_reward_fn( model_response, gt_answer, fast=fast, ) task_verified = float(reward) > 0.0 if not bool(task_verified): return None endpoint = extract_normalized_final_answer( model_response, template="qwen_math_route", gt_answer=gt_answer, ) if endpoint is None: return None route = validated_math_route_signature( model_response, problem, gt_answer, fast=fast, task_verified=True, ) return VerifiedExplorationIdentity( verifier="math_verify", endpoint_key=f"math-answer:{endpoint}", route_signature=route, ) except Exception: return None def answer_tag_reward_fn(model_response, gt_answer, fast=False): # We are strict about format to evaluate our models. if " " in model_response and "" in model_response: model_answer = model_response.split("")[-1].replace("", "") if "\\boxed" in model_answer: model_answer = extract_answer(model_answer) if model_answer is None: return {"formatted": True}, 0.0 modebench_plain_answer = _extract_modebench_candidate(model_answer, gt_answer) if modebench_plain_answer is not None: model_answer = modebench_plain_answer modebench_correct = _grade_modebench_answer(model_answer, gt_answer) if modebench_correct is not None: return {"formatted": True}, 1.0 if modebench_correct else 0.0 if isinstance(gt_answer, float) or isinstance(gt_answer, int): gt_answer = str(gt_answer) if isinstance(gt_answer, str): is_correct = grade(model_answer, gt_answer, fast) elif isinstance(gt_answer, list): is_correct = False for gt in gt_answer: is_correct |= grade(model_answer, gt, fast) if is_correct: return {"formatted": True}, 1.0 # Correctness reward. else: return ( {"formatted": True}, 0.0, ) # Formatted but wrong answer; no format reward to avoid hacking. else: return {"formatted": False}, 0.0 # Unformatted. def answer_tag_reward_fn_for_orz(model_response, gt_answer, fast=False): # We are a bit less strict for baselines. if "" in model_response and "" in model_response: model_answer = model_response.split("")[-1].replace("", "") if "\\boxed" in model_answer: model_answer = extract_answer(model_answer) if model_answer is None: return {"formatted": True}, 0.0 modebench_plain_answer = _extract_modebench_candidate(model_answer, gt_answer) if modebench_plain_answer is not None: model_answer = modebench_plain_answer modebench_correct = _grade_modebench_answer(model_answer, gt_answer) if modebench_correct is not None: return {"formatted": True}, 1.0 if modebench_correct else 0.0 if isinstance(gt_answer, float) or isinstance(gt_answer, int): gt_answer = str(gt_answer) if isinstance(gt_answer, str): is_correct = grade(model_answer, gt_answer, fast) elif isinstance(gt_answer, list): is_correct = False for gt in gt_answer: is_correct |= grade(model_answer, gt, fast) if is_correct: return {"formatted": True}, 1.0 # Correctness reward. else: return ( {"formatted": True}, 0.0, ) # Formatted but wrong answer; no format reward to avoid hacking. else: return {"formatted": False}, 0.0 # Unformatted.