Added arithmetic and number analysis

analyze_prompt_number_coverage.py

@@ -0,0 +1,287 @@
+# /// script
+# dependencies = ["inspect-ai"]
+# ///
+"""Measure whether every number in each prompt appears in the model response.
+
+Numbers are matched as complete numeric tokens and normalized by value, so
+10, 10.0, and 10,000-style formatting compare consistently. Repeated prompt
+values are treated as one distinct number.
+
+Example:
+    uv run hf_dataset/analyze_prompt_number_coverage.py hf_dataset/logs/example.eval
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import os
+import re
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from decimal import Decimal, InvalidOperation
+from pathlib import Path
+from typing import Any
+
+from inspect_ai.log import read_eval_log
+
+NUMBER_RE = re.compile(
+    r"(?<![\w.])[-+]?(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?(?!\w|\.\d)"
+)
+
+
+def normalize_number(token: str) -> Decimal | None:
+    """Return a canonical numeric value for a matched token."""
+    try:
+        value = Decimal(token.replace(",", ""))
+    except InvalidOperation:
+        return None
+    return value.normalize() if value else Decimal(0)
+
+
+def extract_numbers(text: str) -> set[Decimal]:
+    """Extract distinct, normalized numeric tokens from text."""
+    numbers = {normalize_number(match.group(0)) for match in NUMBER_RE.finditer(text)}
+    numbers.discard(None)
+    return numbers
+
+
+def display_number(value: Decimal) -> str:
+    """Format a normalized Decimal without scientific notation."""
+    rendered = format(value, "f")
+    if "." in rendered:
+        rendered = rendered.rstrip("0").rstrip(".")
+    return rendered or "0"
+
+
+def score_to_bool(sample: Any) -> bool | None:
+    """Read the preferred final-answer score from an Inspect sample."""
+    scores = sample.scores or {}
+    for preferred in ("math", "pattern"):
+        if preferred not in scores:
+            continue
+        value = getattr(scores[preferred], "value", scores[preferred])
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, (int, float)):
+            return bool(value)
+        if isinstance(value, str):
+            normalized = value.strip().upper()
+            if normalized in {"C", "CORRECT", "TRUE", "1"}:
+                return True
+            if normalized in {"I", "INCORRECT", "FALSE", "0"}:
+                return False
+    return None
+
+
+def safe_rate(numerator: int, denominator: int) -> float | None:
+    return numerator / denominator if denominator else None
+
+
+def summarize_group(rows: list[dict[str, Any]]) -> dict[str, Any]:
+    covered = sum(row["all_prompt_numbers_present"] for row in rows)
+    return {
+        "samples": len(rows),
+        "samples_with_all_prompt_numbers_present": covered,
+        "samples_missing_prompt_numbers": len(rows) - covered,
+        "all_prompt_numbers_present_rate": safe_rate(covered, len(rows)),
+    }
+
+
+def analyze_log(path: Path, max_samples: int | None = None) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    log = read_eval_log(str(path))
+    samples = (log.samples or [])[:max_samples]
+    sample_rows: list[dict[str, Any]] = []
+
+    for sample in samples:
+        prompt = sample.input if isinstance(sample.input, str) else str(sample.input)
+        response = sample.output.completion
+        prompt_numbers = extract_numbers(prompt)
+        response_numbers = extract_numbers(response)
+        missing_numbers = prompt_numbers - response_numbers
+
+        sample_rows.append(
+            {
+                "log": path.name,
+                "model": log.eval.model,
+                "task": log.eval.task,
+                "sample_id": sample.id,
+                "epoch": sample.epoch,
+                "source_id": (sample.metadata or {}).get("source_id"),
+                "language": (sample.metadata or {}).get("language"),
+                "final_correct": score_to_bool(sample),
+                "prompt_number_count": len(prompt_numbers),
+                "prompt_numbers": " | ".join(display_number(value) for value in sorted(prompt_numbers)),
+                "missing_prompt_number_count": len(missing_numbers),
+                "missing_prompt_numbers": " | ".join(display_number(value) for value in sorted(missing_numbers)),
+                "all_prompt_numbers_present": not missing_numbers,
+            }
+        )
+
+    final_scored = [row for row in sample_rows if row["final_correct"] is not None]
+    final_correct_rows = [row for row in final_scored if row["final_correct"]]
+    final_incorrect_rows = [row for row in final_scored if not row["final_correct"]]
+    correct_summary = summarize_group(final_correct_rows)
+    incorrect_summary = summarize_group(final_incorrect_rows)
+    correct_rate = correct_summary["all_prompt_numbers_present_rate"]
+    incorrect_rate = incorrect_summary["all_prompt_numbers_present_rate"]
+
+    summary = {
+        "log": path.name,
+        "status": str(log.status),
+        "model": log.eval.model,
+        "task": log.eval.task,
+        "samples": len(samples),
+        "final_scored_samples": len(final_scored),
+        "final_accuracy": safe_rate(
+            sum(row["final_correct"] for row in final_scored),
+            len(final_scored),
+        ),
+        "samples_with_all_prompt_numbers_present": sum(
+            row["all_prompt_numbers_present"] for row in sample_rows
+        ),
+        "all_prompt_numbers_present_rate": safe_rate(
+            sum(row["all_prompt_numbers_present"] for row in sample_rows),
+            len(sample_rows),
+        ),
+        "number_coverage_breakdown": {
+            "final_correct": correct_summary,
+            "final_incorrect": incorrect_summary,
+        },
+        "correct_minus_incorrect_percentage_points": (
+            (correct_rate - incorrect_rate) * 100
+            if correct_rate is not None and incorrect_rate is not None
+            else None
+        ),
+        "matcher": "distinct normalized complete numeric tokens",
+        "note": (
+            "A sample is covered when every distinct numeric value in the original prompt "
+            "appears somewhere in the full model completion."
+        ),
+    }
+    return summary, sample_rows
+
+
+def discover_logs(inputs: list[Path]) -> list[Path]:
+    logs: set[Path] = set()
+    for path in inputs:
+        if path.is_dir():
+            logs.update(candidate for candidate in path.rglob("*.eval") if candidate.stat().st_size >= 1_000)
+        elif path.suffix == ".eval" and path.stat().st_size >= 1_000:
+            logs.add(path)
+    return sorted(logs)
+
+
+def resolve_worker_count(requested: int | None, log_count: int) -> int:
+    if requested is not None and requested < 1:
+        raise ValueError("--workers must be at least 1.")
+    default = min(4, os.cpu_count() or 1)
+    return min(requested or default, log_count)
+
+
+def analyze_logs(
+    logs: list[Path],
+    max_samples: int | None,
+    workers: int,
+) -> list[tuple[dict[str, Any], list[dict[str, Any]]]]:
+    if workers == 1:
+        results = []
+        for path in logs:
+            print(f"Analyzing {path}")
+            results.append(analyze_log(path, max_samples))
+        return results
+
+    ordered_results: list[tuple[dict[str, Any], list[dict[str, Any]]] | None] = [None] * len(logs)
+    with ProcessPoolExecutor(max_workers=workers) as executor:
+        futures = {
+            executor.submit(analyze_log, path, max_samples): (index, path)
+            for index, path in enumerate(logs)
+        }
+        for future in as_completed(futures):
+            index, path = futures[future]
+            ordered_results[index] = future.result()
+            print(f"Analyzed {path}")
+
+    return [result for result in ordered_results if result is not None]
+
+
+def write_csv(path: Path, rows: list[dict[str, Any]]) -> None:
+    if not rows:
+        return
+    with path.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def run_self_test() -> None:
+    cases = [
+        ("Use 10, 10.0, and 1,000.", "10 and 1000", True),
+        ("Use 10 and 2.", "The result is 210.", False),
+        ("Temperatures are -5 and +3.", "-5 + 3 = -2", True),
+        ("There are 4 groups of 4.", "4 groups", True),
+        ("A value is 1.5.", "15", False),
+    ]
+    for prompt, response, expected in cases:
+        actual = extract_numbers(prompt) <= extract_numbers(response)
+        if actual != expected:
+            raise AssertionError(
+                f"Failed: prompt={prompt!r}, response={response!r}, expected={expected}, got={actual}"
+            )
+    print(f"Self-test passed ({len(cases)} cases).")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("inputs", nargs="*", type=Path, help="Inspect .eval logs or directories containing logs.")
+    parser.add_argument("--out-dir", type=Path, default=Path("prompt_number_coverage"))
+    parser.add_argument("--max-samples", type=int)
+    parser.add_argument(
+        "--workers",
+        type=int,
+        help="Parallel log processes. Defaults to min(4, CPU count); use 1 for serial execution.",
+    )
+    parser.add_argument("--self-test", action="store_true")
+    args = parser.parse_args()
+
+    if args.self_test:
+        run_self_test()
+        if not args.inputs:
+            return
+
+    logs = discover_logs(args.inputs)
+    if not logs:
+        raise SystemExit("No non-empty .eval logs found.")
+
+    try:
+        workers = resolve_worker_count(args.workers, len(logs))
+    except ValueError as error:
+        parser.error(str(error))
+    print(f"Analyzing {len(logs)} log(s) with {workers} worker(s).")
+
+    summaries: list[dict[str, Any]] = []
+    sample_rows: list[dict[str, Any]] = []
+    for summary, samples in analyze_logs(logs, args.max_samples, workers):
+        summaries.append(summary)
+        sample_rows.extend(samples)
+
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+    (args.out_dir / "summary.json").write_text(
+        json.dumps(summaries, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+    write_csv(args.out_dir / "samples.csv", sample_rows)
+
+    for summary in summaries:
+        breakdown = summary["number_coverage_breakdown"]
+        print(
+            f"{summary['model']} | {summary['task']}: "
+            f"all={summary['all_prompt_numbers_present_rate']!s}, "
+            f"right={breakdown['final_correct']['all_prompt_numbers_present_rate']!s}, "
+            f"wrong={breakdown['final_incorrect']['all_prompt_numbers_present_rate']!s}"
+        )
+    print(f"Wrote {args.out_dir}")
+
+
+if __name__ == "__main__":
+    main()

analyze_reasoning_arithmetic.py

@@ -0,0 +1,683 @@
+# /// script
+# dependencies = ["inspect-ai", "math-verify[antlr4_13_2]>=0.9,<0.10"]
+# ///
+"""Check intermediate equations in Inspect logs with Hugging Face Math-Verify.
+
+The script segments explicit equality chains, then delegates LaTeX parsing,
+normalization, symbolic execution, and equivalence checking to Math-Verify.
+It measures local mathematical consistency, not whether a step is relevant to
+the word problem.
+
+Example:
+    uv run hf_dataset/analyze_reasoning_arithmetic.py hf_dataset/logs/example.eval
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import logging
+import math
+import os
+import re
+from collections.abc import Iterable
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from dataclasses import asdict, dataclass
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+from inspect_ai.log import read_eval_log
+from math_verify import ExprExtractionConfig, LatexExtractionConfig, parse, verify
+
+MATH_SPAN_RE = re.compile(
+    r"\\\[(.*?)\\\]|\\\((.*?)\\\)|(?<!\\)\$(?![\d,])(.+?)(?<!\\)\$",
+    re.DOTALL,
+)
+APPROX_RE = re.compile(r"\\approx|\\simeq|≈|~=")
+TRANSITION_RE = re.compile(r"\\implies|\\Rightarrow|⇒|→")
+TEXT_CONTENT_RE = re.compile(r"\\(?:text|mathrm)\s*\{([^{}]*)\}")
+TEXT_COMMAND_RE = re.compile(r"\\(?:text|mathrm)\s*\{[^{}]*\}")
+PERCENT_SCALE_RE = re.compile(r"(?:\\times|\\cdot|\*|×|·)\s*100\b")
+PLAIN_WORD_RE = re.compile(r"(?<!\\)\b[^\W\d_]{2,}\b", re.UNICODE)
+FUNCTION_CALL_RE = re.compile(r"(?<!\\)\b[^\W\d_]\s*\(", re.UNICODE)
+ELLIPSIS_RE = re.compile(r"(?:\\ldots|\\dots|\.\.\.)")
+CURRENCY_RE = re.compile(r"\\?[$€£¥₹₽₪₩₫฿₺₿]")
+THOUSANDS_SEPARATOR_RE = re.compile(r"(?<=\d),(?=\d{3}(?:\D|$))")
+LATEX_LINEBREAK_RE = re.compile(r"\\\\(?=\s|$)")
+MARKDOWN_BULLET_RE = re.compile(r"^\s*[-*+]\s+")
+ASSIGNMENT_LABEL_RE = re.compile(r"^\s*[^\W\d_][^\d=+*/×÷<>]{1,80}\s*$", re.UNICODE)
+
+LATEX_CONFIG = [LatexExtractionConfig(boxed_match_priority=-1)]
+EXPR_CONFIG = [ExprExtractionConfig()]
+
+logging.getLogger("math_verify").setLevel(logging.ERROR)
+
+
+@dataclass(frozen=True)
+class EquationCheck:
+    expression: str
+    lhs: str
+    rhs: str
+    lhs_parsed: str
+    rhs_parsed: str
+    correct: bool
+    approximate: bool
+
+
+@lru_cache(maxsize=20_000)
+def parse_side(text: str) -> Any | None:
+    """Parse one side of an equality, preferring LaTeX to preserve variables."""
+    text = MARKDOWN_BULLET_RE.sub("", text.strip())
+    text = CURRENCY_RE.sub("", text)
+    text = THOUSANDS_SEPARATOR_RE.sub("", text)
+    text = text.replace(r"\left", "").replace(r"\right", "")
+    text = _strip_trailing_prose_parenthetical(text)
+
+    # Math-Verify strips units, but semantic text placeholders must remain
+    # unscored. Unit annotations follow a numeric quantity; labels do not.
+    for match in TEXT_COMMAND_RE.finditer(text):
+        prefix = text[: match.start()].rstrip()
+        if not prefix or not (prefix[-1].isdigit() or prefix[-1] in ")}]%"):
+            return None
+    text = TEXT_COMMAND_RE.sub("", text)
+    text = ELLIPSIS_RE.sub("", text)
+    text = text.replace("×", "*").replace("÷", "/").replace("·", "*")
+    text = re.sub(r"(\d+(?:\.\d+)?)\s*\\%", r"(\1/100)", text)
+    text = re.sub(r"(?<=\d)\s*\(", "*(", text)
+    if PLAIN_WORD_RE.search(text) or FUNCTION_CALL_RE.search(text) or re.search(r"\\(?:cap|cup|Pr)\b", text):
+        return None
+    symbol_text = re.sub(r"\\[A-Za-z]+", "", text)
+    if re.search(r"[A-Z]", symbol_text):
+        # Math-Verify/SymPy interpret I and E as mathematical constants. More
+        # generally, assignments involving named quantities require context.
+        return None
+    if not text:
+        return None
+
+    if not re.search(r"\\[A-Za-z]+|(?<!\\)[A-Za-z]", text):
+        text = re.sub(r"(\d+(?:\.\d+)?)\s*%", r"(\1/100)", text)
+        parsed = parse(
+            text,
+            extraction_config=EXPR_CONFIG,
+            fallback_mode="no_fallback",
+            parsing_timeout=None,
+        )
+        if parsed:
+            return parsed[0]
+
+    parsed = parse(
+        rf"\({text}\)",
+        extraction_config=LATEX_CONFIG,
+        fallback_mode="no_fallback",
+        parsing_timeout=None,
+    )
+    return parsed[0] if parsed else None
+
+
+def _free_symbols(value: Any) -> set[Any]:
+    return set(getattr(value, "free_symbols", set()))
+
+
+def _strip_trailing_prose_parenthetical(text: str) -> str:
+    match = re.search(r"\s*\(([^()]*)\)\s*$", text)
+    if not match:
+        return text
+    content = TEXT_COMMAND_RE.sub("", match.group(1))
+    content = re.sub(r"\\[A-Za-z]+", "", content)
+    if PLAIN_WORD_RE.search(content):
+        return text[: match.start()]
+    return text
+
+
+def _strip_percent(text: str) -> str:
+    return text.replace(r"\%", "").replace("%", "")
+
+
+def _display_precision(text: str) -> int:
+    numbers = re.findall(r"-?\d+(?:\.(\d+))?", _strip_percent(text))
+    if not numbers:
+        return 6
+    decimals = numbers[-1]
+    return len(decimals) if decimals else 0
+
+
+def _is_display_decimal(text: str) -> bool:
+    cleaned = TEXT_COMMAND_RE.sub("", text)
+    cleaned = CURRENCY_RE.sub("", cleaned)
+    cleaned = cleaned.strip().strip(".:;")
+    return bool(re.fullmatch(r"-?\d+\.\d+", cleaned))
+
+
+def _equivalent(lhs: Any, rhs: Any, approximate: bool, precision: int) -> bool:
+    if verify(lhs, rhs, float_rounding=precision, timeout_seconds=None):
+        return True
+    if not _free_symbols(lhs) and not _free_symbols(rhs):
+        try:
+            lhs_value = float(lhs.doit().evalf())
+            rhs_value = float(rhs.doit().evalf())
+            tolerance = (0.5 * 10**-precision) if approximate else 1e-9
+            if math.isclose(lhs_value, rhs_value, rel_tol=1e-12, abs_tol=tolerance):
+                return True
+        except (AttributeError, TypeError, ValueError):
+            pass
+    if not approximate:
+        return False
+    try:
+        lhs_rounded = lhs.doit().evalf().round(precision)
+        rhs_rounded = rhs.doit().evalf().round(precision)
+        return verify(lhs_rounded, rhs_rounded, timeout_seconds=None)
+    except (AttributeError, TypeError, ValueError):
+        return False
+
+
+def _verify_pair(lhs: str, rhs: str, approximate: bool) -> tuple[Any, Any, bool] | None:
+    if ELLIPSIS_RE.search(lhs) or ELLIPSIS_RE.search(rhs):
+        return None
+
+    lhs_parsed = parse_side(lhs)
+    rhs_parsed = parse_side(rhs)
+    if lhs_parsed is None or rhs_parsed is None:
+        return None
+
+    lhs_symbols = _free_symbols(lhs_parsed)
+    rhs_symbols = _free_symbols(rhs_parsed)
+    if (lhs_symbols or rhs_symbols) and lhs_symbols != rhs_symbols:
+        # An equation such as 100 = 2n constrains n; it is not independently
+        # true or false without the surrounding reasoning state.
+        return None
+
+    displayed_decimal = _is_display_decimal(rhs)
+    effective_approximate = approximate or displayed_decimal
+    float_rounding = _display_precision(rhs) if effective_approximate else 6
+    correct = _equivalent(lhs_parsed, rhs_parsed, effective_approximate, float_rounding)
+    if (lhs_symbols or rhs_symbols) and not correct:
+        return None
+
+    # Worked solutions commonly write ratio * 100 = 5%, using the percent
+    # suffix as display notation. Math-Verify correctly treats 5% as 0.05, so
+    # retry without the suffix only for this explicit percentage-scale idiom.
+    lhs_has_percent = "%" in lhs
+    rhs_has_percent = "%" in rhs
+    if not correct and lhs_has_percent and rhs_has_percent:
+        lhs_display = parse_side(_strip_percent(lhs))
+        rhs_display = parse_side(_strip_percent(rhs))
+        if lhs_display is not None and rhs_display is not None:
+            correct = _equivalent(lhs_display, rhs_display, effective_approximate, float_rounding)
+    if not correct and lhs_has_percent != rhs_has_percent:
+        non_percent_side = rhs if lhs_has_percent else lhs
+        if PERCENT_SCALE_RE.search(non_percent_side) or approximate:
+            percent_side = lhs if lhs_has_percent else rhs
+            percent_display = parse_side(_strip_percent(percent_side))
+            if percent_display is not None:
+                if lhs_has_percent:
+                    comparison = rhs_parsed * 100 if approximate and not PERCENT_SCALE_RE.search(rhs) else rhs_parsed
+                    correct = _equivalent(percent_display, comparison, effective_approximate, float_rounding)
+                else:
+                    comparison = lhs_parsed * 100 if approximate and not PERCENT_SCALE_RE.search(lhs) else lhs_parsed
+                    correct = _equivalent(comparison, percent_display, effective_approximate, float_rounding)
+
+    return lhs_parsed, rhs_parsed, correct
+
+
+def _unit_annotations(text: str) -> set[str]:
+    return {
+        re.sub(r"[^\w/]+", " ", content, flags=re.UNICODE).strip().lower()
+        for content in TEXT_CONTENT_RE.findall(text)
+        if content.strip()
+    }
+
+
+def _is_dimension_conversion(lhs: str, rhs: str, correct: bool) -> bool:
+    """Exclude conversions Math-Verify cannot dimensionally validate."""
+    if correct:
+        return False
+    lhs_units = _unit_annotations(lhs)
+    rhs_units = _unit_annotations(rhs)
+    if lhs_units and rhs_units and lhs_units != rhs_units:
+        return True
+
+    lhs_is_unit_quantity = bool(lhs_units) and not re.search(r"[+*/]|\\(?:times|div|frac)", lhs)
+    rhs_has_operation = bool(re.search(r"[+*/]|\\(?:times|div|frac)", rhs))
+    if lhs_is_unit_quantity and rhs_has_operation:
+        return True
+    rhs_is_unit_quantity = bool(rhs_units) and not re.search(r"[+*/]|\\(?:times|div|frac)", rhs)
+    if lhs_is_unit_quantity and CURRENCY_RE.search(rhs):
+        return True
+    if rhs_is_unit_quantity and CURRENCY_RE.search(lhs):
+        return True
+
+    if bool(lhs_units) != bool(rhs_units):
+        unitless_side = rhs if lhs_units else lhs
+        if re.search(r"(?:[*×÷/]|\b)\s*(?:12|60|1000)\b", unitless_side):
+            return True
+    return False
+
+
+def _math_fragments(completion: str) -> Iterable[str]:
+    covered: list[tuple[int, int]] = []
+    for match in MATH_SPAN_RE.finditer(completion):
+        covered.append(match.span())
+        fragment = next(group for group in match.groups() if group is not None)
+        yield from (part for part in LATEX_LINEBREAK_RE.split(fragment) if part.strip())
+
+    uncovered = list(completion)
+    for start, end in covered:
+        uncovered[start:end] = " " * (end - start)
+    for line in "".join(uncovered).splitlines():
+        if "=" in line or APPROX_RE.search(line):
+            yield line
+
+
+def _assignment_label(text: str) -> str | None:
+    text = MARKDOWN_BULLET_RE.sub("", text.strip())
+    text = TEXT_CONTENT_RE.sub(lambda match: match.group(1), text)
+    text = text.replace(r"\left", "").replace(r"\right", "").strip()
+    if not ASSIGNMENT_LABEL_RE.fullmatch(text):
+        return None
+    return re.sub(r"\s+", " ", text).casefold()
+
+
+def _is_assignment_separator(line: str) -> bool:
+    """Allow one assignment chain to span adjacent display-math blocks."""
+    return line.strip() in {"", r"\[", r"\]", r"\(", r"\)"}
+
+
+def _assignment_checks(completion: str) -> list[EquationCheck]:
+    checks: list[EquationCheck] = []
+    previous: tuple[str, str] | None = None
+
+    for line in completion.splitlines():
+        if _is_assignment_separator(line):
+            continue
+
+        equality = TRANSITION_RE.sub("=", APPROX_RE.sub("=", line))
+        if equality.count("=") != 1:
+            previous = None
+            continue
+
+        lhs, rhs = equality.split("=")
+        label = _assignment_label(lhs)
+        if label is None or parse_side(rhs) is None:
+            previous = None
+            continue
+
+        approximate = bool(APPROX_RE.search(line) or TRANSITION_RE.search(line) or ELLIPSIS_RE.search(line))
+        if previous is not None and previous[0] == label:
+            previous_text = previous[1]
+            result = _verify_pair(previous_text, rhs, approximate)
+            if result is not None:
+                previous_parsed, current_parsed, correct = result
+                checks.append(
+                    EquationCheck(
+                        expression=f"{previous_text} = {rhs.strip()}",
+                        lhs=previous_text,
+                        rhs=rhs.strip(),
+                        lhs_parsed=str(previous_parsed),
+                        rhs_parsed=str(current_parsed),
+                        correct=correct,
+                        approximate=approximate,
+                    )
+                )
+        previous = (label, rhs.strip())
+
+    return checks
+
+
+def check_completion(completion: str) -> tuple[list[EquationCheck], int]:
+    """Check every independently verifiable adjacent equality."""
+    checks: list[EquationCheck] = []
+    claims = 0
+
+    for fragment in _math_fragments(completion):
+        approximate = bool(APPROX_RE.search(fragment) or TRANSITION_RE.search(fragment) or ELLIPSIS_RE.search(fragment))
+        equality = TRANSITION_RE.sub("=", APPROX_RE.sub("=", fragment))
+        if "=" not in equality:
+            continue
+
+        parts = equality.split("=")
+        claims += max(0, len(parts) - 1)
+
+        for lhs, rhs in zip(parts, parts[1:], strict=False):
+            result = _verify_pair(lhs, rhs, approximate)
+            if result is None:
+                continue
+            lhs_parsed, rhs_parsed, correct = result
+            if _is_dimension_conversion(lhs, rhs, correct):
+                continue
+            checks.append(
+                EquationCheck(
+                    expression=fragment.strip(),
+                    lhs=lhs.strip(),
+                    rhs=rhs.strip(),
+                    lhs_parsed=str(lhs_parsed),
+                    rhs_parsed=str(rhs_parsed),
+                    correct=correct,
+                    approximate=approximate,
+                )
+            )
+
+    checks.extend(_assignment_checks(completion))
+    return checks, claims
+
+
+def score_to_bool(sample: Any) -> bool | None:
+    scores = sample.scores or {}
+    for preferred in ("math", "pattern"):
+        if preferred not in scores:
+            continue
+        value = getattr(scores[preferred], "value", scores[preferred])
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, (int, float)):
+            return bool(value)
+        if isinstance(value, str):
+            normalized = value.strip().upper()
+            if normalized in {"C", "CORRECT", "TRUE", "1"}:
+                return True
+            if normalized in {"I", "INCORRECT", "FALSE", "0"}:
+                return False
+    return None
+
+
+def _safe_rate(numerator: int, denominator: int) -> float | None:
+    return numerator / denominator if denominator else None
+
+
+def summarize_final_answer_group(rows: list[dict]) -> dict[str, Any]:
+    with_checks = [row for row in rows if row["checked_expressions"]]
+    with_wrong = [row for row in with_checks if row["any_checked_wrong"]]
+    checked_expressions = sum(row["checked_expressions"] for row in rows)
+    correct_expressions = sum(row["correct_expressions"] for row in rows)
+    wrong_expressions = checked_expressions - correct_expressions
+
+    return {
+        "samples": len(rows),
+        "samples_with_checked_expressions": len(with_checks),
+        "samples_with_wrong_expression": len(with_wrong),
+        "sample_wrong_expression_rate_all": _safe_rate(len(with_wrong), len(rows)),
+        "sample_wrong_expression_rate_checked": _safe_rate(len(with_wrong), len(with_checks)),
+        "checked_expressions": checked_expressions,
+        "wrong_expressions": wrong_expressions,
+        "expression_wrong_rate": _safe_rate(wrong_expressions, checked_expressions),
+    }
+
+
+def analyze_log(path: Path, max_samples: int | None = None) -> tuple[dict[str, Any], list[dict], list[dict]]:
+    log = read_eval_log(str(path))
+    samples = (log.samples or [])[:max_samples]
+    expression_rows: list[dict] = []
+    sample_rows: list[dict] = []
+
+    for sample in samples:
+        checks, claims = check_completion(sample.output.completion)
+        checked = len(checks)
+        correct = sum(check.correct for check in checks)
+        final_correct = score_to_bool(sample)
+        all_checked_correct = checked > 0 and correct == checked
+        any_checked_wrong = checked > 0 and correct < checked
+
+        sample_rows.append(
+            {
+                "log": path.name,
+                "model": log.eval.model,
+                "task": log.eval.task,
+                "sample_id": sample.id,
+                "epoch": sample.epoch,
+                "source_id": (sample.metadata or {}).get("source_id"),
+                "language": (sample.metadata or {}).get("language"),
+                "final_correct": final_correct,
+                "equality_claims": claims,
+                "checked_expressions": checked,
+                "correct_expressions": correct,
+                "expression_accuracy": _safe_rate(correct, checked),
+                "parse_coverage": _safe_rate(checked, claims),
+                "all_checked_correct": all_checked_correct,
+                "any_checked_wrong": any_checked_wrong,
+            }
+        )
+
+        for check in checks:
+            expression_rows.append(
+                {
+                    "log": path.name,
+                    "model": log.eval.model,
+                    "task": log.eval.task,
+                    "sample_id": sample.id,
+                    "epoch": sample.epoch,
+                    "source_id": (sample.metadata or {}).get("source_id"),
+                    "final_correct": final_correct,
+                    **asdict(check),
+                }
+            )
+
+    total_claims = sum(row["equality_claims"] for row in sample_rows)
+    total_checked = sum(row["checked_expressions"] for row in sample_rows)
+    total_correct = sum(row["correct_expressions"] for row in sample_rows)
+    with_checks = [row for row in sample_rows if row["checked_expressions"]]
+    final_scored = [row for row in sample_rows if row["final_correct"] is not None]
+    final_correct_rows = [row for row in final_scored if row["final_correct"]]
+    final_incorrect_rows = [row for row in final_scored if not row["final_correct"]]
+    suspicious = [row for row in final_correct_rows if row["any_checked_wrong"]]
+
+    summary = {
+        "log": path.name,
+        "status": str(log.status),
+        "model": log.eval.model,
+        "task": log.eval.task,
+        "samples": len(samples),
+        "final_accuracy": _safe_rate(sum(row["final_correct"] for row in final_scored), len(final_scored)),
+        "equality_claims": total_claims,
+        "checked_expressions": total_checked,
+        "parse_coverage": _safe_rate(total_checked, total_claims),
+        "expression_accuracy": _safe_rate(total_correct, total_checked),
+        "samples_with_checked_expressions": len(with_checks),
+        "all_checked_expressions_correct_rate": _safe_rate(
+            sum(row["all_checked_correct"] for row in with_checks), len(with_checks)
+        ),
+        "final_correct_with_wrong_expression_rate": _safe_rate(len(suspicious), len(final_correct_rows)),
+        "final_correct_with_wrong_expression_count": len(suspicious),
+        "wrong_expression_breakdown": {
+            "final_correct": summarize_final_answer_group(final_correct_rows),
+            "final_incorrect": summarize_final_answer_group(final_incorrect_rows),
+        },
+        "verifier": "math-verify",
+        "note": (
+            "Expression accuracy measures local mathematical consistency. "
+            "The final-correct/wrong-expression rate is a lucky-answer proxy, not proof of memorization."
+        ),
+    }
+    return summary, sample_rows, expression_rows
+
+
+def discover_logs(inputs: list[Path]) -> list[Path]:
+    logs: set[Path] = set()
+    for path in inputs:
+        if path.is_dir():
+            logs.update(candidate for candidate in path.rglob("*.eval") if candidate.stat().st_size >= 1_000)
+        elif path.suffix == ".eval" and path.stat().st_size >= 1_000:
+            logs.add(path)
+    return sorted(logs)
+
+
+def resolve_worker_count(requested: int | None, log_count: int) -> int:
+    if requested is not None and requested < 1:
+        raise ValueError("--workers must be at least 1.")
+    default = min(4, os.cpu_count() or 1)
+    return min(requested or default, log_count)
+
+
+def analyze_logs(
+    logs: list[Path],
+    max_samples: int | None,
+    workers: int,
+) -> list[tuple[dict[str, Any], list[dict], list[dict]]]:
+    if workers == 1:
+        results = []
+        for path in logs:
+            print(f"Analyzing {path}")
+            results.append(analyze_log(path, max_samples))
+        return results
+
+    ordered_results: list[tuple[dict[str, Any], list[dict], list[dict]] | None] = [None] * len(logs)
+    with ProcessPoolExecutor(max_workers=workers) as executor:
+        futures = {
+            executor.submit(analyze_log, path, max_samples): (index, path)
+            for index, path in enumerate(logs)
+        }
+        for future in as_completed(futures):
+            index, path = futures[future]
+            ordered_results[index] = future.result()
+            print(f"Analyzed {path}")
+
+    return [result for result in ordered_results if result is not None]
+
+
+def write_csv(path: Path, rows: list[dict]) -> None:
+    if not rows:
+        return
+    with path.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def run_self_test() -> None:
+    cases = [
+        (r"45 \times 4 = 180", [True]),
+        (r"180 \text{ inches} + 180 \text{ inches} = 360 \text{ inches}", [True]),
+        (r"40 * €0.75 = €30", [True]),
+        (r"5 × €8 = €40", [True]),
+        (r"\$390,000 + \$15,600 + \$42,900 = \$448,500", [True]),
+        (r"\$650,000 \times 5\% = \$32,500", [True]),
+        (r"- 14 \div 28 = 0.5", [True]),
+        (r"44 \times 0.88 = 44 \times \left(1 - 0.12\right)", [True]),
+        (r"101.16 - 17.16 = 84", [True]),
+        (r"3(11) + 1 = 33 + 1", [True]),
+        (r"2(9 \text{ feet} + 55 \text{ feet}) = 2 \times 64 \text{ feet}", [True]),
+        (r"20 + (0.10 \times 20) = 20 + 2", [True]),
+        (r"\frac{20}{9} \approx 2.22", [True]),
+        (r"\frac{3400}{150} = 22.67", [True]),
+        (r"94 - 31.333\ldots = 62.666\ldots", []),
+        (r"15 / 150 * 100 = 10\%", [True]),
+        (r"0.2 \times 100\% = 20\%", [True]),
+        (r"\frac{51}{196} \times 100 \approx 26.09\%", [False]),
+        (r"\frac{8}{15} \implies 0.5333 \implies 53.33\%", [True, True]),
+        (r"180 + 180 = 350", [False]),
+        (r"1 + 2n - 2 = 2n - 1", [True]),
+        (r"100 = 2n", []),
+        (r"164 = 2I", []),
+        (r"2 \times 5 \text{ hours} = 2 \times 60", []),
+    ]
+    for expression, expected in cases:
+        checks, _ = check_completion(rf"\[{expression}\]")
+        actual = [check.correct for check in checks]
+        if actual != expected:
+            raise AssertionError(f"Failed: {expression!r}: expected {expected}, got {checks}")
+
+    multiline = check_completion(
+        "\\[\n15 - 12.5 = 2.5 \\\\\n\\frac{2.5}{0.5} = 5\n\\]"
+    )[0]
+    if [check.correct for check in multiline] != [True, True]:
+        raise AssertionError(f"Failed multiline equations: {multiline}")
+
+    assignments = check_completion(
+        "Total costs = $26,800 + $40,200 + $500,000\n"
+        "Total costs = $587,000\n"
+    )[0]
+    if [check.correct for check in assignments] != [False]:
+        raise AssertionError(f"Failed repeated assignments: {assignments}")
+
+    display_assignments = check_completion(
+        "\\[\n"
+        r"\text{Number of bags of popcorn} = \frac{19.70}{0.55}"
+        "\n\\]\n\n\\[\n"
+        r"\text{Number of bags of popcorn} = 36"
+        "\n\\]\n"
+    )[0]
+    if [check.correct for check in display_assignments] != [False]:
+        raise AssertionError(f"Failed display-block assignments: {display_assignments}")
+
+    reused_label = check_completion(
+        "Total puppies = 14\n"
+        "Puppies with spots = 3\n"
+        "Total puppies = 11\n"
+        "Puppies with spots = 2\n"
+    )[0]
+    if reused_label:
+        raise AssertionError(f"Compared non-consecutive reused labels: {reused_label}")
+
+    prose_separated = check_completion(
+        "\\[\nTotal puppies = 14\n\\]\n"
+        "The next calculation changes topic.\n"
+        "\\[\nTotal puppies = 11\n\\]\n"
+    )[0]
+    if prose_separated:
+        raise AssertionError(f"Compared prose-separated labels: {prose_separated}")
+    print(f"Self-test passed ({len(cases)} cases).")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("inputs", nargs="*", type=Path, help="Inspect .eval logs or directories containing logs.")
+    parser.add_argument("--out-dir", type=Path, default=Path("reasoning_arithmetic"))
+    parser.add_argument("--max-samples", type=int)
+    parser.add_argument(
+        "--workers",
+        type=int,
+        help="Parallel log processes. Defaults to min(4, CPU count); use 1 for serial execution.",
+    )
+    parser.add_argument("--self-test", action="store_true")
+    args = parser.parse_args()
+
+    if args.self_test:
+        run_self_test()
+        if not args.inputs:
+            return
+
+    logs = discover_logs(args.inputs)
+    if not logs:
+        raise SystemExit("No non-empty .eval logs found.")
+
+    try:
+        workers = resolve_worker_count(args.workers, len(logs))
+    except ValueError as error:
+        parser.error(str(error))
+    print(f"Analyzing {len(logs)} log(s) with {workers} worker(s).")
+
+    summaries: list[dict] = []
+    sample_rows: list[dict] = []
+    expression_rows: list[dict] = []
+    for summary, samples, expressions in analyze_logs(logs, args.max_samples, workers):
+        summaries.append(summary)
+        sample_rows.extend(samples)
+        expression_rows.extend(expressions)
+
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+    (args.out_dir / "summary.json").write_text(
+        json.dumps(summaries, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+    write_csv(args.out_dir / "samples.csv", sample_rows)
+    write_csv(args.out_dir / "expressions.csv", expression_rows)
+
+    for summary in summaries:
+        breakdown = summary["wrong_expression_breakdown"]
+        print(
+            f"{summary['model']} | {summary['task']}: "
+            f"final={summary['final_accuracy']!s}, "
+            f"expressions={summary['expression_accuracy']!s}, "
+            f"coverage={summary['parse_coverage']!s}, "
+            f"wrong-step samples (right/wrong final)="
+            f"{breakdown['final_correct']['sample_wrong_expression_rate_checked']!s}/"
+            f"{breakdown['final_incorrect']['sample_wrong_expression_rate_checked']!s}, "
+            f"wrong expressions (right/wrong final)="
+            f"{breakdown['final_correct']['expression_wrong_rate']!s}/"
+            f"{breakdown['final_incorrect']['expression_wrong_rate']!s}"
+        )
+    print(f"Wrote {args.out_dir}")
+
+
+if __name__ == "__main__":
+    main()