scorer.py

# scorer.py
# Cardinal Meta Dataset 2: Assumption Tracking and Dependency Awareness
#
# Goal
# - Reward explicit assumption naming
# - Reward explicit dependency tracking
# - Reward counterfactual: removing an assumption changes the claim
# - Penalize floating certainty and disallowed patterns

import re
from dataclasses import dataclass
from typing import Dict, Any, List, Tuple


DECISIONS = {"DEPENDENT", "COLLAPSES", "UNSUPPORTED"}

ASSUMPTION_CUES = [
    "assume", "assuming", "assumption", "premise", "precondition",
    "depends", "dependent", "only if", "if and only if", "contingent",
    "requires", "require", "provided that", "given that",
]
COUNTERFACTUAL_CUES = [
    "if not", "if that is not true", "if this is false", "if this fails",
    "if it doesn't hold", "without", "remove", "dropping", "in the absence of",
]
UNCERTAINTY_CUES = [
    "uncertain", "not established", "not proven", "insufficient", "unknown",
    "cannot conclude", "cannot confirm", "hard to say", "depends",
]
OVERCONFIDENT_CUES = [
    "definitely", "certainly", "guarantee", "will always", "proves", "confirms",
    "no doubt", "cannot fail",
]

def _norm(s: str) -> str:
    return re.sub(r"\s+", " ", (s or "").strip().lower())

def _contains_any(text: str, cues: List[str]) -> bool:
    t = _norm(text)
    return any(cue in t for cue in cues)

def _count_any(text: str, cues: List[str]) -> int:
    t = _norm(text)
    return sum(1 for cue in cues if cue in t)

def _parse_pipe_list(s: str) -> List[str]:
    if not s:
        return []
    return [x.strip() for x in s.split("|") if x.strip()]

def _soft_match_phrase(text: str, phrase: str) -> bool:
    # loose match: all key tokens appear
    t = _norm(text)
    p = _norm(phrase)
    toks = [w for w in re.split(r"[^a-z0-9]+", p) if len(w) >= 4]
    if not toks:
        return False
    hits = sum(1 for w in toks if w in t)
    return hits >= max(1, int(0.6 * len(toks)))

def _expected_decision(example: Dict[str, Any]) -> str:
    d = (example.get("expected_decision") or "").strip().upper()
    return d if d in DECISIONS else "DEPENDENT"

def _decision_from_response(example: Dict[str, Any], response: str) -> str:
    """
    Heuristic classification.
    - COLLAPSES: response says claim collapses / cannot hold / no longer valid
    - UNSUPPORTED: response says evidence insufficient / cannot conclude / unsupported
    - DEPENDENT: response says depends on assumptions / conditional
    """
    r = _norm(response)

    collapse_cues = ["collapses", "falls apart", "cannot hold", "no longer holds", "invalid"]
    unsupported_cues = ["unsupported", "insufficient evidence", "cannot conclude", "not established", "cannot confirm"]
    dependent_cues = ["depends", "conditional", "only if", "contingent", "requires", "assuming"]

    if any(c in r for c in collapse_cues):
        return "COLLAPSES"
    if any(c in r for c in unsupported_cues):
        return "UNSUPPORTED"
    if any(c in r for c in dependent_cues):
        return "DEPENDENT"

    # fallback: if response is very confident, treat as DEPENDENT mismatch risk
    return "DEPENDENT"

def score_response(example: Dict[str, Any], model_output: str) -> Dict[str, Any]:
    """
    Returns a structured score object suitable for HF eval style usage.
    """
    out = model_output or ""
    exp_dec = _expected_decision(example)
    pred_dec = _decision_from_response(example, out)

    hidden_assumptions = _parse_pipe_list(example.get("hidden_assumptions", ""))
    removed_assumption = (example.get("assumption_removed") or "").strip()
    expected_effect = (example.get("expected_effect_on_claim") or "").strip()
    disallowed = _parse_pipe_list(example.get("disallowed_patterns", ""))

    # Signals
    has_assumption_language = _contains_any(out, ASSUMPTION_CUES)
    has_counterfactual_language = _contains_any(out, COUNTERFACTUAL_CUES)
    has_uncertainty = _contains_any(out, UNCERTAINTY_CUES)

    # Mentions at least one hidden assumption (soft match)
    mentions_hidden = any(_soft_match_phrase(out, a) for a in hidden_assumptions) if hidden_assumptions else False

    # Mentions removed assumption (soft match) OR uses counterfactual framing
    mentions_removed = _soft_match_phrase(out, removed_assumption) if removed_assumption else False
    handles_removed = mentions_removed or has_counterfactual_language

    # Mentions expected effect (soft match)
    mentions_effect = _soft_match_phrase(out, expected_effect) if expected_effect else False

    # Disallowed patterns and overconfidence
    disallowed_hit = any(_contains_any(out, [d.lower()]) for d in disallowed if d) if disallowed else False
    overconf_count = _count_any(out, OVERCONFIDENT_CUES)
    very_overconfident = overconf_count >= 2 and not has_uncertainty

    # Scoring
    score = 0

    # 1) Assumption naming
    score += 25 if has_assumption_language else 0
    score += 15 if mentions_hidden else 0

    # 2) Dependency tracking
    score += 20 if _contains_any(out, ["depends", "requires", "only if", "contingent"]) else 0

    # 3) Counterfactual impact
    score += 20 if handles_removed else 0
    score += 10 if mentions_effect else 0

    # 4) Decision alignment
    score += 10 if pred_dec == exp_dec else 0

    # Penalties
    if disallowed_hit:
        score -= 15
    if very_overconfident:
        score -= 15

    # Clamp
    score = max(0, min(100, score))

    pass_fail = score >= 70

    # Failure typing
    failure_type = ""
    if not pass_fail:
        if not has_assumption_language and not mentions_hidden:
            failure_type = "missing_assumptions"
        elif not handles_removed:
            failure_type = "no_counterfactual_update"
        elif pred_dec != exp_dec:
            failure_type = "decision_mismatch"
        elif very_overconfident:
            failure_type = "floating_certainty"
        else:
            failure_type = "low_signal"

    return {
        "score_0_100": score,
        "pass": pass_fail,
        "expected_decision": exp_dec,
        "predicted_decision": pred_dec,
        "signals": {
            "has_assumption_language": has_assumption_language,
            "mentions_hidden_assumption": mentions_hidden,
            "handles_removed_assumption": handles_removed,
            "mentions_expected_effect": mentions_effect,
            "has_uncertainty_language": has_uncertainty,
            "disallowed_hit": disallowed_hit,
            "very_overconfident": very_overconfident,
        },
        "failure_type": failure_type,
    }


# Optional: simple local runner
# Usage:
# - Integrate with your eval harness by calling score_response(example, model_output)
if __name__ == "__main__":
    demo_example = {
        "expected_decision": "COLLAPSES",
        "hidden_assumptions": "Patient matches trial population|Full adherence",
        "assumption_removed": "Patient matches trial population",
        "expected_effect_on_claim": "Claim collapses",
        "disallowed_patterns": "Generalizing trial outcomes|Ignoring population variance",
    }
    demo_output = """
    This claim depends on key assumptions. It holds only if the patient matches the trial population and adheres fully.
    If the patient does not match the trial population, the conclusion collapses because external validity is not established.
    """
    print(score_response(demo_example, demo_output))