File size: 3,239 Bytes
b8ea052
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
"""Fail-closed evaluation of normalized question predicates."""

from __future__ import annotations

from numbers import Real
from typing import Any, Mapping

from pvr_eval.question_eval.schema import AnswerRecord, EvidencePacket, EvalProcedure


STATUS_SCORES = {"pass": 1.0, "partial": 0.5, "fail": 0.0}


def value_in_band(value: float, band: Mapping[str, float | None]) -> bool:
    """Return whether *value* is inside an inclusive numeric band."""

    lower = band.get("min")
    upper = band.get("max")
    return (lower is None or value >= float(lower)) and (upper is None or value <= float(upper))


def classify_numeric(value: Any, bands: Mapping[str, Mapping[str, float | None]]) -> str | None:
    if isinstance(value, bool) or not isinstance(value, Real):
        return None
    matched = [status for status in ("pass", "partial", "fail") if status in bands and value_in_band(float(value), bands[status])]
    return matched[0] if len(matched) == 1 else None


def _uncertain(procedure: EvalProcedure, packet: EvidencePacket, *reasons: str) -> AnswerRecord:
    return AnswerRecord(
        case_id=procedure.rubric.case_id,
        check_id=procedure.rubric.check_id,
        status="uncertain",
        score=0.0,
        confidence=0.0,
        answer_source="deterministic",
        evidence_packet_hash=packet.packet_hash,
        cited_call_ids=packet.successful_call_ids,
        rationale="Deterministic scoring was withheld because required evidence is insufficient.",
        formal_eligible=False,
        reasons=tuple(reasons) or ("insufficient_evidence",),
    )


def answer_deterministically(procedure: EvalProcedure, packet: EvidencePacket) -> AnswerRecord:
    """Answer one normalized predicate without guessing missing semantics.

    Scores always mean positive rubric satisfaction, including penalty-role
    questions.  Aggregation/deduction is a separate scoring concern.
    """

    if not procedure.predicate.deterministic:
        return _uncertain(procedure, packet, "predicate_not_objectively_executable")
    if packet.status != "success":
        return _uncertain(procedure, packet, f"evidence_packet:{packet.status}", *packet.reasons)
    metric = procedure.predicate.metric
    value = packet.derived_facts.get(metric)
    status = classify_numeric(value, procedure.predicate.bands)
    if status is None:
        return _uncertain(procedure, packet, f"metric_missing_or_outside_unique_band:{metric}")
    if not packet.successful_call_ids:
        return _uncertain(procedure, packet, "no_citable_tool_calls")

    score_overrides = procedure.predicate.parameters.get("status_scores", {})
    score = float(score_overrides.get(status, STATUS_SCORES[status])) if isinstance(score_overrides, Mapping) else STATUS_SCORES[status]
    return AnswerRecord(
        case_id=procedure.rubric.case_id,
        check_id=procedure.rubric.check_id,
        status=status,
        score=max(0.0, min(1.0, score)),
        confidence=1.0,
        answer_source="deterministic",
        evidence_packet_hash=packet.packet_hash,
        cited_call_ids=packet.successful_call_ids,
        rationale=f"{metric}={float(value):.6g} falls in the normalized {status} band.",
        formal_eligible=True,
    )