Add grader module used by verification kit

"""Deterministic grading for binary-reasoning-v1 items. Pure functions, no framework deps."""
import json
import re

JUDGE_FAMILIES = {"func_summary", "arch_semantics_qa", "isa_semantics_qa", "pe_import_reasoning", "pe_structure_qa"}


def norm_symbol(s: str) -> str:
s = s.strip().lower()
s = re.sub(r"^[*&]+", "", s)
s = re.sub(r"\(.*\)$", "", s).strip()
s = re.sub(r"\.+$", "", s) # sentence-final dot captured by token regex
return s


def _answer_symbol(answer) -> str:
if isinstance(answer, dict):
return answer.get("symbol", "")
return str(answer)


def grade_func_id_exact(reply: str, answer) -> float:
sym = norm_symbol(_answer_symbol(answer))
if not sym:
return 0.0
accepted = {sym}
if isinstance(answer, dict):
accepted |= {norm_symbol(a) for a in answer.get("aliases", []) if a}
toks = [norm_symbol(t) for t in re.findall(r"[A-Za-z_][A-Za-z0-9_.]+", reply)]
return 1.0 if accepted & set(toks) else 0.0


def grade_func_id_mc(reply: str, answer: dict) -> float:
correct = answer.get("correct", "")
opts = answer.get("options", [])
r = reply.strip()
m = re.search(r"\b([A-D])\b", r[:80], re.IGNORECASE)
if m:
idx = ord(m.group(1).upper()) - 65
if 0 <= idx < len(opts):
return float(norm_symbol(opts[idx]) == norm_symbol(correct))
names = [norm_symbol(o) for o in re.findall(r"[A-Za-z_][A-Za-z0-9_.]{3,}", r.lower())]
return 1.0 if norm_symbol(correct) in names else 0.0


def grade_tcfp(reply: str, answer: dict) -> float:
strs = answer.get("toolchain_strings", [])
if not strs:
return 0.0
hits = sum(1 for s in strs if s.lower() in reply.lower())
return hits / len(strs)


def needs_judge(family: str, answer) -> bool:
if family in JUDGE_FAMILIES:
return True
if family == "func_id_exact":
sym = _answer_symbol(answer)
# descriptive/inferred answers (contain prose) cannot be string-matched
return (" " in sym.strip()) or ("inferred" in sym.lower())
return False


def grade_agentic(reply: str, answer) -> float:
flag = _answer_symbol(answer)
return 1.0 if flag and flag in reply else 0.0


def grade_crossarch(reply: str, answer) -> float:
if isinstance(answer, str):
try:
answer = json.loads(answer)
except Exception:
answer = {"same": "true" in answer.lower(),
"symbol": re.sub(r'.*?"symbol"\s*:\s*"([^"]+)".*', r"\1", answer) if '"symbol"' in answer else ""}
want = bool(answer.get("same"))
r = reply.lower()
neg = bool(re.search(r"\bnot\s+(the\s+)?same\b|\bdifferent\b|\bno\b", r))
pos = not neg and bool(re.search(r"\bsame\b|\byes\b|\btrue\b|match", r))
if not (neg or pos):
return 0.0 # abstention / no clear stance
if pos != want:
return 0.0
if want:
sym = norm_symbol(answer.get("symbol", ""))
toks = [norm_symbol(t) for t in re.findall(r"[A-Za-z_][A-Za-z0-9_.]+", reply)]
if sym not in toks:
return 0.0
return 1.0


def grade_library_ident(reply: str, answer) -> float:
ans = _answer_symbol(answer)
toks = [t for t in re.split(r"\s+", ans) if len(t) >= 2]
r = reply.lower()
return 1.0 if all(t.lower() in r for t in toks) else 0.0


def grade_item(family: str, reply: str, answer) -> float:
if needs_judge(family, answer):
return 0.0 # handled by rubric judge in taskset.py
if family == "library_ident":
return grade_library_ident(reply, answer)
if family == "crossarch_equivalence":
return grade_crossarch(reply, answer)
if family == "agentic_flag_hunt":
return grade_agentic(reply, answer)
if family == "func_id_exact":
return grade_func_id_exact(reply, answer)
if family == "func_id_mc":
return grade_func_id_mc(reply, answer)
if family == "toolchain_fp":
return grade_tcfp(reply, answer)
return 0.0

environment/src/binary_reasoning_v1/grading.py/environment/src/binary_reasoning_v1/grading.py

@@ -0,0 +1,115 @@
+"""Deterministic grading for binary-reasoning-v1 items. Pure functions, no framework deps."""
+import json
+import re
+
+JUDGE_FAMILIES = {"func_summary", "arch_semantics_qa", "isa_semantics_qa", "pe_import_reasoning", "pe_structure_qa"}
+
+
+def norm_symbol(s: str) -> str:
+    s = s.strip().lower()
+    s = re.sub(r"^[*&]+", "", s)
+    s = re.sub(r"\(.*\)$", "", s).strip()
+    s = re.sub(r"\.+$", "", s)  # sentence-final dot captured by token regex
+    return s
+
+
+def _answer_symbol(answer) -> str:
+    if isinstance(answer, dict):
+        return answer.get("symbol", "")
+    return str(answer)
+
+
+def grade_func_id_exact(reply: str, answer) -> float:
+    sym = norm_symbol(_answer_symbol(answer))
+    if not sym:
+        return 0.0
+    accepted = {sym}
+    if isinstance(answer, dict):
+        accepted |= {norm_symbol(a) for a in answer.get("aliases", []) if a}
+    toks = [norm_symbol(t) for t in re.findall(r"[A-Za-z_][A-Za-z0-9_.]+", reply)]
+    return 1.0 if accepted & set(toks) else 0.0
+
+
+def grade_func_id_mc(reply: str, answer: dict) -> float:
+    correct = answer.get("correct", "")
+    opts = answer.get("options", [])
+    r = reply.strip()
+    m = re.search(r"\b([A-D])\b", r[:80], re.IGNORECASE)
+    if m:
+        idx = ord(m.group(1).upper()) - 65
+        if 0 <= idx < len(opts):
+            return float(norm_symbol(opts[idx]) == norm_symbol(correct))
+    names = [norm_symbol(o) for o in re.findall(r"[A-Za-z_][A-Za-z0-9_.]{3,}", r.lower())]
+    return 1.0 if norm_symbol(correct) in names else 0.0
+
+
+def grade_tcfp(reply: str, answer: dict) -> float:
+    strs = answer.get("toolchain_strings", [])
+    if not strs:
+        return 0.0
+    hits = sum(1 for s in strs if s.lower() in reply.lower())
+    return hits / len(strs)
+
+
+def needs_judge(family: str, answer) -> bool:
+    if family in JUDGE_FAMILIES:
+        return True
+    if family == "func_id_exact":
+        sym = _answer_symbol(answer)
+        # descriptive/inferred answers (contain prose) cannot be string-matched
+        return (" " in sym.strip()) or ("inferred" in sym.lower())
+    return False
+
+
+def grade_agentic(reply: str, answer) -> float:
+    flag = _answer_symbol(answer)
+    return 1.0 if flag and flag in reply else 0.0
+
+
+def grade_crossarch(reply: str, answer) -> float:
+    if isinstance(answer, str):
+        try:
+            answer = json.loads(answer)
+        except Exception:
+            answer = {"same": "true" in answer.lower(),
+                      "symbol": re.sub(r'.*?"symbol"\s*:\s*"([^"]+)".*', r"\1", answer) if '"symbol"' in answer else ""}
+    want = bool(answer.get("same"))
+    r = reply.lower()
+    neg = bool(re.search(r"\bnot\s+(the\s+)?same\b|\bdifferent\b|\bno\b", r))
+    pos = not neg and bool(re.search(r"\bsame\b|\byes\b|\btrue\b|match", r))
+    if not (neg or pos):
+        return 0.0  # abstention / no clear stance
+    if pos != want:
+        return 0.0
+    if want:
+        sym = norm_symbol(answer.get("symbol", ""))
+        toks = [norm_symbol(t) for t in re.findall(r"[A-Za-z_][A-Za-z0-9_.]+", reply)]
+        if sym not in toks:
+            return 0.0
+    return 1.0
+
+
+def grade_library_ident(reply: str, answer) -> float:
+    ans = _answer_symbol(answer)
+    toks = [t for t in re.split(r"\s+", ans) if len(t) >= 2]
+    r = reply.lower()
+    return 1.0 if all(t.lower() in r for t in toks) else 0.0
+
+
+def grade_item(family: str, reply: str, answer) -> float:
+    if needs_judge(family, answer):
+        return 0.0  # handled by rubric judge in taskset.py
+    if family == "library_ident":
+        return grade_library_ident(reply, answer)
+    if family == "crossarch_equivalence":
+        return grade_crossarch(reply, answer)
+    if family == "agentic_flag_hunt":
+        return grade_agentic(reply, answer)
+    if family == "func_id_exact":
+        return grade_func_id_exact(reply, answer)
+    if family == "func_id_mc":
+        return grade_func_id_mc(reply, answer)
+    if family == "toolchain_fp":
+        return grade_tcfp(reply, answer)
+    return 0.0
+Add grader module used by verification kit