structverify 0.3.0__py3-none-any.whl

structverify/verification/decide_verdict.py

@@ -0,0 +1,216 @@
+"""[리팩] Step 8 판정 메인 진입 — profile별 분기 (fallback 우선)"""
+from __future__ import annotations
+
+import re
+
+from structverify.core.schemas import (
+    Claim,
+    Evidence,
+    MismatchType,
+    VerificationResult,
+    VerdictType,
+)
+from structverify.utils.logger import get_logger
+
+from ._config import VerificationProfile
+from .adapters import (
+    AgentCalculateInput,
+    AgentFetchInput,
+    NormalizedInput,
+    VerdictDecision,
+)
+from .decide_verdict_agent import (
+    decide_verdict_agent_calculate,
+    decide_verdict_agent_fetch,
+)
+from .growth_diff import verify_growth_or_diff
+from .row_match import extract_numeric_values, find_best_match
+from .units import is_same_unit_type, normalize_value
+from .verdict_thresholds import verdict_from_error
+
+logger = get_logger(__name__)
+
+
+def decide_verdict(
+    claim: Claim,
+    normalized: NormalizedInput | AgentFetchInput | AgentCalculateInput,
+    config: dict | None = None,
+    profile: VerificationProfile = "fallback",
+) -> VerificationResult | VerdictDecision:
+    """claim + 정규화된 입력 → VerificationResult(fallback) 또는 VerdictDecision(agent)."""
+    config = config or {}
+    if profile == "fallback":
+        if not isinstance(normalized, NormalizedInput):
+            raise TypeError("profile='fallback' requires NormalizedInput")
+        return _decide_verdict_fallback(claim, normalized, config)
+    if profile == "agent":
+        if isinstance(normalized, AgentFetchInput):
+            return decide_verdict_agent_fetch(claim, normalized, config)
+        if isinstance(normalized, AgentCalculateInput):
+            return decide_verdict_agent_calculate(claim, normalized, config)
+        raise TypeError("profile='agent' requires AgentFetchInput or AgentCalculateInput")
+    raise NotImplementedError(f"profile={profile!r}")
+
+
+def _decide_verdict_fallback(
+    claim: Claim,
+    normalized: NormalizedInput,
+    config: dict,
+) -> VerificationResult:
+    evidence = normalized.evidence
+    claim_year = normalized.claim_year
+    claim_year_month = normalized.claim_year_month
+
+    claimed = claim.schema.value if claim.schema else None
+    claim_unit = (claim.schema.unit or "") if claim.schema else ""
+
+    prev_value = getattr(claim.schema, "prev_value", None) if claim.schema else None
+    # [v6.14 C2] 증가율/차이 자동 계산 분기
+    if prev_value is not None and prev_value != 0:
+        indicator = (claim.schema.indicator or "") if claim.schema else ""
+        is_ratio_schema = claim_unit and (
+            "%" in claim_unit
+            or "퍼센트" in claim_unit
+            or "율" in claim_unit
+            or "비율" in claim_unit
+        )
+        is_diff_schema = (
+            "차이" in indicator or "증감" in indicator or "변화량" in indicator
+        )
+        if is_ratio_schema or is_diff_schema:
+            calc_result = verify_growth_or_diff(
+                claim,
+                evidence,
+                claim_year,
+                claim_year_month,
+                prev_value,
+                is_ratio_schema,
+                config,
+                classify_mismatch=_classify_mismatch,
+            )
+            if calc_result is not None:
+                return calc_result
+
+    raw = evidence.raw_response if isinstance(evidence.raw_response, dict) else {}
+    rows = raw.get("row", [])
+    if isinstance(rows, list) and rows:
+        kosis_values = extract_numeric_values(rows)
+        if kosis_values:
+            best_match, best_error = find_best_match(
+                claimed,
+                claim_unit,
+                claim_year,
+                kosis_values,
+                claim_year_month=claim_year_month,
+            )
+
+            if best_match is None:
+                return VerificationResult(
+                    claim_id=claim.claim_id,
+                    verdict=VerdictType.UNVERIFIABLE,
+                    confidence=0.3,
+                    evidence=evidence,
+                )
+
+            evidence = evidence.model_copy(update={
+                "official_value": best_match.get("value"),
+                "unit": best_match.get("unit") or evidence.unit,
+                "time_period": best_match.get("period") or evidence.time_period,
+            })
+            logger.info(
+                f"[verifier] evidence 동기화 (F2): official_value={evidence.official_value} "
+                f"unit={evidence.unit!r} time_period={evidence.time_period!r}"
+            )
+
+            return verdict_from_error(
+                claim,
+                evidence,
+                best_error,
+                best_match,
+                config,
+                _classify_mismatch,
+            )
+
+    kosis_unit = evidence.unit or ""
+
+    if not is_same_unit_type(claim_unit, kosis_unit):
+        logger.info(f"단위 타입 불일치: claim={claim_unit!r} kosis={kosis_unit!r}")
+        return VerificationResult(
+            claim_id=claim.claim_id,
+            verdict=VerdictType.UNVERIFIABLE,
+            confidence=0.3,
+            evidence=evidence,
+        )
+
+    official = normalize_value(evidence.official_value, kosis_unit)
+    denom = max(abs(official), abs(claimed), 1e-9)
+    diff_pct = abs(claimed - official) / denom * 100
+
+    return verdict_from_error(
+        claim, evidence, diff_pct / 100, None, config, _classify_mismatch,
+    )
+
+
+def _primary_year_from_period(text: str | None) -> str | None:
+    if not text or not str(text).strip():
+        return None
+    m = re.search(r"(?:19|20)\d{2}", str(text))
+    return m.group(0) if m else None
+
+
+def _norm_token(s: str | None) -> str:
+    if not s:
+        return ""
+    return " ".join(str(s).split()).lower()
+
+
+def _population_incompatible(claim_pop: str | None, ev_pop: str | None) -> bool:
+    c = _norm_token(claim_pop)
+    e = _norm_token(ev_pop)
+    if not c or not e:
+        return False
+    if c in e or e in c:
+        return False
+    return True
+
+
+def _classify_mismatch(
+    claim: Claim,
+    evidence: Evidence,
+    diff_pct: float,
+    config: dict,
+) -> MismatchType:
+    """
+    MISMATCH 세부 유형 분류 (fallback 프로필, LLM 미사용).
+    우선순위: TIME_PERIOD → POPULATION → EXAGGERATION → VALUE
+    """
+    vconf = config.get("verification", {}) if config else {}
+    exaggeration_pct = float(vconf.get("exaggeration_diff_percent", 20.0))
+
+    schema = claim.schema
+    if schema is None:
+        return (
+            MismatchType.EXAGGERATION
+            if diff_pct > exaggeration_pct
+            else MismatchType.VALUE
+        )
+
+    # 시점
+    cy = _primary_year_from_period(schema.time_period)
+    ey = _primary_year_from_period(evidence.time_period)
+    if cy and ey and cy != ey:
+        return MismatchType.TIME_PERIOD
+
+    # 집단
+    raw = evidence.raw_response if isinstance(evidence.raw_response, dict) else {}
+    ev_pop = raw.get("population") or raw.get("population_label")
+    if isinstance(ev_pop, (list, tuple)):
+        ev_pop = " ".join(str(x) for x in ev_pop)
+    if schema.population and _population_incompatible(schema.population, ev_pop):
+        return MismatchType.POPULATION
+
+    # 과장
+    if diff_pct > exaggeration_pct:
+        return MismatchType.EXAGGERATION
+
+    return MismatchType.VALUE

structverify/verification/decide_verdict_agent.py

@@ -0,0 +1,454 @@
+"""[리팩] agent 프로필 판정 — loop._synthesize_verdict_* 로직 추출 (이동만)"""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from structverify.agent.schemas import ClaimType
+from structverify.core.schemas import Claim, VerdictType
+from structverify.utils.logger import get_logger
+
+from .adapters import AgentCalculateInput, AgentFetchInput, VerdictDecision
+from .growth_diff import try_difference_from_rows, try_growth_rate_from_rows
+from .verdict_thresholds import (
+    classify_atomic_ratio_agent,
+    classify_calculate_simple_agent,
+    classify_difference_gap_agent,
+    classify_growth_rate_pp_agent,
+    detect_threshold_direction,
+    growth_rate_direction_mismatch,
+)
+
+logger = get_logger(__name__)
+
+_COMPLEX_TYPES = {ClaimType.GROWTH_RATE, ClaimType.DIFFERENCE, ClaimType.RANKING}
+
+# 한국어 큰 수 단위 배수 (선두 접두어). "만 건"→10⁴·"건", "억달러"→10⁸·"달러".
+_KOR_MULT = {"천": 1e3, "만": 1e4, "억": 1e8, "조": 1e12}
+
+
+def _kor_unit_scale(unit: str | None) -> tuple[float, str]:
+    """단위 문자열 선두의 만/억/조/천 배수와 기본단위를 분리.
+
+    스키마 유도가 "228만 건"을 (228, "만 건")처럼 *값은 접두어 앞 숫자, 단위엔 접두어*
+    로 뽑을 때가 있다("150만 명"은 (1500000,"명")으로 뽑기도 함 — LLM 비일관). 어느
+    쪽이든 '값이 단위 표기와 일치'하므로, 비교 직전 단위 배수를 값에 반영하면 일관돼진다.
+
+    Returns: (배수, 기본단위)  예: "만 건"→(10000.0,"건"), "건"→(1.0,"건").
+    """
+    u = (unit or "").strip()
+    m = re.match(r"^\s*(천|만|억|조)\s*(.*)$", u)
+    if m:
+        return _KOR_MULT[m.group(1)], m.group(2).strip()
+    return 1.0, u
+
+
+def decide_verdict_agent_fetch(
+    claim: Claim,
+    normalized: AgentFetchInput,
+    config: dict,
+) -> VerdictDecision:
+    """fetch observation 기반 agent 판정 (loop._synthesize_verdict_from_observation).
+
+    합성 규칙:
+      - fetch 성공 + claim에 값 있음 → 값 비교 (tolerance, 기본 5%)
+      - growth_rate/difference/ranking → 두 시점 비교 필요인데 단일 fetch 뿐 → UNVERIFIABLE
+        (단, GROWTH_RATE/DIFFERENCE는 rows pool에서 직접 계산 시도)
+      - fetch 실패 또는 값 없음 → UNVERIFIABLE
+    """
+    claim_id = normalized.claim_id
+    evidence = normalized.evidence
+    tolerance = normalized.tolerance
+    claim_actual_type = normalized.claim_actual_type
+
+    fetched_value = evidence.get("value")
+    fetched_unit = evidence.get("unit", "") or ""
+    fetched_time = evidence.get("time_period", "") or ""
+    stat_table_id = evidence.get("stat_table_id", "") or ""
+    stat_name = evidence.get("stat_name", "") or ""
+
+    # 소스 인식 라벨 (KOSIS 전용 하드코딩 제거 — custom_csv 등도 지원). 모든 branch에서 사용.
+    _src = str(evidence.get("source") or "").strip()
+    _src_disp = {"kosis": "KOSIS", "custom_csv": "기준 데이터", "custom_db": "기준 데이터"}.get(
+        _src, _src or "기준 데이터"
+    )
+    src_label = _src_disp + (f"({stat_table_id})" if stat_table_id else "")
+    if stat_name:
+        src_label += f" {stat_name}"
+
+    schema = claim.schema
+    claim_value = schema.value if schema is not None else None
+    claim_unit = (schema.unit or "") if schema is not None else ""
+    claim_time = (schema.time_period or "") if schema is not None else ""
+    claim_indicator = (schema.indicator or "") if schema is not None else ""
+
+    # 복합 claim type: 두 시점 비교 필요인데 plan은 단일 fetch
+    # ★ plan.claim_type은 Planner LLM이 source_text 의미로 일괄 분류해서 부정확함
+    #   → claim.schema에서 직접 추론한 type을 더 신뢰
+    if isinstance(claim_actual_type, ClaimType) and claim_actual_type in _COMPLEX_TYPES:
+        # ── [v6.17] GROWTH_RATE 직접 계산 시도 ──────────────────────────
+        if claim_actual_type == ClaimType.GROWTH_RATE:
+            result = _try_growth_rate_verdict(
+                claim, claim_id, evidence, schema, claim_value, claim_indicator,
+                stat_table_id, normalized.all_fetch_observations, config,
+            )
+            if result is not None:
+                return result
+
+        if claim_actual_type == ClaimType.DIFFERENCE:
+            result = _try_difference_verdict(
+                claim, claim_id, evidence, schema, claim_value,
+                stat_table_id, normalized.all_fetch_observations, config,
+            )
+            if result is not None:
+                return result
+
+        logger.info(
+            f"[loop] {claim_id}: claim type={claim_actual_type.value} "
+            f"(planner type={normalized.plan_claim_type.value}) — 단일 fetch로 검증 불가"
+        )
+        return VerdictDecision(
+            claim_id=claim_id,
+            verdict=VerdictType.UNVERIFIABLE,
+            confidence=0.3,
+            explanation=(
+                f"{claim_actual_type.value} 유형은 두 시점 비교 필요. "
+                f"{src_label} 현재값 {fetched_value!r}{fetched_unit} "
+                f"(시점 {fetched_time}) 확보. "
+                f"이전 시점 데이터 부재로 검증 불가."
+            ),
+        )
+
+    if fetched_value is None or claim_value is None:
+        return VerdictDecision(
+            claim_id=claim_id,
+            verdict=VerdictType.UNVERIFIABLE,
+            confidence=0.3,
+            explanation=(
+                f"비교 불가: 주장값={claim_value!r}{claim_unit}, "
+                f"{src_label} 조회값={fetched_value!r}{fetched_unit}."
+            ),
+        )
+
+    try:
+        fv = float(fetched_value)
+        cv = float(claim_value)
+    except (TypeError, ValueError):
+        return VerdictDecision(
+            claim_id=claim_id,
+            verdict=VerdictType.UNVERIFIABLE,
+            confidence=0.3,
+            explanation=(
+                f"값 숫자 변환 실패 — 주장값={claim_value!r}, 조회값={fetched_value!r}."
+            ),
+        )
+
+    # 한국어 큰 수 단위(만/억/조) 스케일 정규화 — "228만 건" vs "건" 같은 단위 스케일
+    # 불일치 구제. 단, *스케일링이 두 값을 더 가깝게 만들 때만* 적용한다.
+    #   - 오히려 멀어지면: 단위 표기가 어긋났거나(예: 스키마가 "억"을 떨궈 잘못된 단위)
+    #     값이 이미 완전 환산된 것(이중스케일) → 건드리면 오판. 그대로 둔다.
+    #   이 가드로 [만 건 vs 건] 구제와 [잘못된 단위·이중스케일] 회귀 방지를 동시에.
+    _cs, _cbase = _kor_unit_scale(claim_unit)
+    _fs, _fbase = _kor_unit_scale(fetched_unit)
+    if (_cs != 1.0 or _fs != 1.0) and (_cbase == _fbase or not _cbase or not _fbase):
+        def _dr(a: float, b: float) -> float:
+            return abs(b - a) / abs(a) if abs(a) > 1e-9 else (0.0 if abs(b) < 1e-9 else 1.0)
+        if _dr(cv * _cs, fv * _fs) < _dr(cv, fv):
+            _cv0, _fv0 = cv, fv
+            cv, fv = cv * _cs, fv * _fs
+            claim_unit, fetched_unit = (_cbase or claim_unit), (_fbase or fetched_unit)
+            logger.info(
+                f"[loop] {claim_id}: 단위 스케일 정규화(값이 가까워짐) "
+                f"주장 {_cv0:.4g}×{_cs:g}={cv:.4g}{claim_unit}, "
+                f"조회 {_fv0:.4g}×{_fs:g}={fv:.4g}{fetched_unit}"
+            )
+
+    if abs(cv) < 1e-9:
+        diff_ratio = 0.0 if abs(fv) < 1e-9 else 1.0
+    else:
+        diff_ratio = abs(fv - cv) / abs(cv)
+
+    time_aligned = True
+    if claim_time and fetched_time:
+        ct_norm = str(claim_time).replace("-", "").replace(".", "")
+        ft_norm = str(fetched_time).replace("-", "").replace(".", "")
+        time_aligned = (ct_norm in ft_norm) or (ft_norm in ct_norm)
+
+    # [규정/예산] evidence에 규칙 operator가 실려오면 *규칙 기준 준수* 판정.
+    #   fv=기준값(한도/최소), cv=신청/주장값. 예: operator '<=' → 신청 cv ≤ 한도 fv 이면 승인(MATCH).
+    #   (detect_threshold_direction은 '주장 자체가 부등식'인 경우 — 여긴 규칙이 부등식이라 별도)
+    _rule_op = str(evidence.get("operator") or "").strip()
+    if _rule_op and time_aligned:
+        import operator as _opmod
+        _OPS = {"<=": _opmod.le, "≤": _opmod.le, "<": _opmod.lt,
+                ">=": _opmod.ge, "≥": _opmod.ge, ">": _opmod.gt,
+                "==": _opmod.eq, "=": _opmod.eq}
+        _fn = _OPS.get(_rule_op)
+        if _fn is not None:
+            _rel = {"<=": "이하", "≤": "이하", "<": "미만", ">=": "이상",
+                    "≥": "이상", ">": "초과", "==": "일치", "=": "일치"}[_rule_op]
+            # 단위 스케일 정규화 — 신청/기준 단위가 둘 다 통화 단위면 '원' 기준으로 맞춤.
+            #   (스키마 유도가 "6000만원"→6000/만원, 규칙은 50000000/원 처럼 스케일이 달라 오판 방지)
+            _WON = {"원": 1, "천원": 1000, "만원": 10000, "십만원": 100000,
+                    "백만원": 1_000_000, "천만원": 10_000_000, "억원": 100_000_000}
+            _cu, _fu = _WON.get((claim_unit or "").strip()), _WON.get((fetched_unit or "").strip())
+            _cvn, _fvn = (cv * _cu, fv * _fu) if (_cu and _fu) else (cv, fv)
+            _ok = _fn(_cvn, _fvn)
+            logger.info(
+                f"[loop] {claim_id}: 규칙 operator 판정 신청={cv:.4g} {_rule_op} "
+                f"기준={fv:.4g} → {'승인' if _ok else '반려'}"
+            )
+            return VerdictDecision(
+                claim_id=claim_id,
+                verdict=VerdictType.MATCH if _ok else VerdictType.MISMATCH,
+                confidence=0.9,
+                explanation=(
+                    f"신청/주장값 {cv:.4g}{claim_unit}이(가) 기준 {fv:.4g}{fetched_unit} "
+                    f"{_rel} 규칙을 {'충족 → 승인' if _ok else '위반 → 반려'} "
+                    f"({src_label}, 시점 {fetched_time or claim_time})."
+                ),
+            )
+
+    # [v6.20] 부등식 주장 — threshold 방향 감지 후 실측값 vs 기준값 비교
+    thr_dir = detect_threshold_direction(claim)
+    if thr_dir is not None and time_aligned:
+        if thr_dir == "gte":
+            satisfied = fv >= cv
+            rel_txt = "이상"
+        else:
+            satisfied = fv <= cv
+            rel_txt = "이하"
+        logger.info(
+            f"[loop] {claim_id}: threshold 판정 dir={thr_dir} "
+            f"기준값={cv:.4g} 실측={fv:.4g} → {'충족' if satisfied else '미충족'}"
+        )
+        if satisfied:
+            return VerdictDecision(
+                claim_id=claim_id,
+                verdict=VerdictType.MATCH,
+                confidence=0.8,
+                explanation=(
+                    f"주장은 '{cv:.4g}{claim_unit} {rel_txt}'(부등식)이고, "
+                    f"{src_label} 조회값은 {fv:.4g}{fetched_unit} "
+                    f"(시점 {fetched_time or claim_time})이므로 주장이 성립합니다."
+                ),
+            )
+        return VerdictDecision(
+            claim_id=claim_id,
+            verdict=VerdictType.MISMATCH,
+            confidence=0.7,
+            explanation=(
+                f"주장은 '{cv:.4g}{claim_unit} {rel_txt}'(부등식)이지만, "
+                f"{src_label} 조회값은 {fv:.4g}{fetched_unit} "
+                f"(시점 {fetched_time or claim_time})이므로 주장이 성립하지 않습니다."
+            ),
+        )
+
+    if diff_ratio < tolerance and time_aligned:
+        return VerdictDecision(
+            claim_id=claim_id,
+            verdict=VerdictType.MATCH,
+            confidence=0.85,
+            explanation=(
+                f"주장값 {cv:.4g}{claim_unit}과 {src_label} 조회값 "
+                f"{fv:.4g}{fetched_unit}이 일치 (오차 {diff_ratio*100:.2f}%, "
+                f"시점 주장={claim_time or '?'}, 조회={fetched_time or '?'})."
+            ),
+        )
+
+    if not time_aligned:
+        return VerdictDecision(
+            claim_id=claim_id,
+            verdict=VerdictType.UNVERIFIABLE,
+            confidence=0.35,
+            explanation=(
+                f"시점 불일치 — 주장은 {claim_time}, {src_label} 조회는 {fetched_time}. "
+                f"동일 시점 데이터 미확보로 검증 불가 "
+                f"(조회값 {fv:.4g}{fetched_unit}, 주장값 {cv:.4g}{claim_unit})."
+            ),
+        )
+
+    verdict_t, conf = classify_atomic_ratio_agent(diff_ratio, config)
+    return VerdictDecision(
+        claim_id=claim_id,
+        verdict=verdict_t,
+        confidence=conf,
+        explanation=(
+            f"주장값 {cv:.4g}{claim_unit}과 {src_label} 조회값 "
+            f"{fv:.4g}{fetched_unit}이 {diff_ratio*100:.1f}% 차이 "
+            f"(시점 {fetched_time or claim_time})."
+        ),
+    )
+
+
+def decide_verdict_agent_calculate(
+    claim: Claim,
+    normalized: AgentCalculateInput,
+    config: dict,
+) -> VerdictDecision:
+    """calculate observation 기반 agent 판정 (loop._synthesize_verdict_from_calculate).
+
+    LLM이 prev/current를 계산했지만 finish를 안 부르고 다시 같은 액션 반복
+    → 중복차단 → 강제 unverifiable로 죽는 케이스 회복. calculate output의
+    result 값을 claim.schema.value와 비교해 자동 verdict 생성한다.
+    """
+    claim_id = normalized.claim_id
+    calc_value = normalized.calc_value
+    claim_actual_type = normalized.claim_actual_type
+    calc_summary = normalized.calc_summary
+
+    schema = claim.schema
+    claim_value = schema.value if schema is not None else None
+    claim_unit = (schema.unit or "") if schema is not None else ""
+    cv = float(claim_value)
+
+    if isinstance(claim_actual_type, ClaimType) and claim_actual_type == ClaimType.GROWTH_RATE:
+        diff = abs(abs(calc_value) - abs(cv))
+        verdict_t, conf = classify_growth_rate_pp_agent(diff, config)
+        label = "일치" if verdict_t == VerdictType.MATCH else (
+            "오차 큼" if verdict_t == VerdictType.UNVERIFIABLE else "불일치"
+        )
+        diff_desc = f"차이 {diff:.2f}%p"
+    elif isinstance(claim_actual_type, ClaimType) and claim_actual_type == ClaimType.DIFFERENCE:
+        gap = abs(abs(calc_value) - abs(cv))
+        verdict_t, conf = classify_difference_gap_agent(gap, cv, config)
+        tol = max(abs(cv) * 0.10, 0.02)
+        label = "일치" if verdict_t == VerdictType.MATCH else (
+            "오차 큼" if verdict_t == VerdictType.UNVERIFIABLE else "불일치"
+        )
+        diff_desc = f"차이 {gap:.4f}, 허용 {tol:.4f}"
+    else:
+        if abs(cv) < 1e-9:
+            diff_ratio = 0.0 if abs(calc_value) < 1e-9 else 1.0
+        else:
+            diff_ratio = abs(calc_value - cv) / abs(cv)
+        verdict_t, conf = classify_calculate_simple_agent(diff_ratio, config)
+        label = "일치" if verdict_t == VerdictType.MATCH else "불일치"
+        diff_desc = f"오차 {diff_ratio*100:.2f}%"
+
+    logger.info(
+        f"[loop] {claim_id}: calculate 합성 판정={label} "
+        f"(기사 {cv}{claim_unit} vs 계산 {calc_value:.4g}, {diff_desc})"
+    )
+    return VerdictDecision(
+        claim_id=claim_id,
+        verdict=verdict_t,
+        confidence=conf,
+        explanation=(
+            f"Agent가 직접 계산한 결과로 검증: 기사 주장 {cv}{claim_unit}, "
+            f"산출된 값 {calc_value:.4g} ({diff_desc}). "
+            f"계산식: {calc_summary[:200]}"
+        ),
+    )
+
+
+def _try_growth_rate_verdict(
+    claim: Claim,
+    claim_id: str,
+    evidence: dict,
+    schema: Any,
+    claim_value: Any,
+    claim_indicator: str,
+    stat_table_id: str,
+    all_fetch_observations: list | None,
+    config: dict,
+) -> VerdictDecision | None:
+    calc = try_growth_rate_from_rows(
+        evidence, schema, claim_id, all_fetch_observations=all_fetch_observations,
+    )
+    if calc is None or claim_value is None:
+        return None
+    calc_rate, _cur_v, _prev_v, calc_desc = calc
+    try:
+        claimed_rate = float(claim_value)
+    except (TypeError, ValueError):
+        return None
+
+    if growth_rate_direction_mismatch(claim_indicator, calc_rate):
+        # [패치 J] 증가/감소 방향 불일치 — 부호 가드
+        diff = abs(abs(calc_rate) - abs(claimed_rate))
+        logger.warning(
+            f"[loop] {claim_id}: growth_rate 부호 방향 불일치 "
+            f"(indicator={claim_indicator!r}, 기사 {claimed_rate:+.2f}% 방향, "
+            f"계산 {calc_rate:+.2f}% 반대 방향) → MISMATCH 강제"
+        )
+        return VerdictDecision(
+            claim_id=claim_id,
+            verdict=VerdictType.MISMATCH,
+            confidence=0.75,
+            explanation=(
+                f"증가율 방향 불일치: 기사는 '{claim_indicator}' "
+                f"{claimed_rate}% (양의 방향), "
+                f"KOSIS({stat_table_id}) 표 계산값 "
+                f"{calc_rate:.2f}% ({'감소' if calc_rate < 0 else '증가'} 방향). "
+                f"{calc_desc}"
+            ),
+        )
+
+    diff = abs(abs(calc_rate) - abs(claimed_rate))
+    verdict_t, conf = classify_growth_rate_pp_agent(diff, config)
+    v_label = {
+        VerdictType.MATCH: "일치",
+        VerdictType.UNVERIFIABLE: "오차 큼",
+        VerdictType.MISMATCH: "불일치",
+    }[verdict_t]
+    logger.info(
+        f"[loop] {claim_id}: growth_rate 직접계산 판정={v_label} "
+        f"(기사 {claimed_rate}% vs 계산 {calc_rate:.2f}%, 차이 {diff:.2f}%p)"
+    )
+    return VerdictDecision(
+        claim_id=claim_id,
+        verdict=verdict_t,
+        confidence=conf,
+        explanation=(
+            f"증가율 직접 검증: 기사 주장 {claimed_rate}%, "
+            f"KOSIS({stat_table_id}) 표에서 계산한 값 "
+            f"{calc_rate:.2f}% (차이 {diff:.2f}%p). {calc_desc}"
+        ),
+    )
+
+
+def _try_difference_verdict(
+    claim: Claim,
+    claim_id: str,
+    evidence: dict,
+    schema: Any,
+    claim_value: Any,
+    stat_table_id: str,
+    all_fetch_observations: list | None,
+    config: dict,
+) -> VerdictDecision | None:
+    calc = try_difference_from_rows(
+        evidence, schema, claim_id, all_fetch_observations=all_fetch_observations,
+    )
+    if calc is None or claim_value is None:
+        return None
+    calc_diff, _cur_v, _prev_v, calc_desc = calc
+    try:
+        claimed_diff = float(claim_value)
+    except (TypeError, ValueError):
+        return None
+
+    gap = abs(abs(calc_diff) - abs(claimed_diff))
+    verdict_t, conf = classify_difference_gap_agent(gap, claimed_diff, config)
+    tol = max(abs(claimed_diff) * 0.10, 0.02)
+    v_label = {
+        VerdictType.MATCH: "일치",
+        VerdictType.UNVERIFIABLE: "오차 큼",
+        VerdictType.MISMATCH: "불일치",
+    }[verdict_t]
+    logger.info(
+        f"[loop] {claim_id}: difference 직접계산 판정={v_label} "
+        f"(기사 {claimed_diff} vs 계산 {calc_diff:.4f}, "
+        f"차이 {gap:.4f}, 허용 {tol:.4f})"
+    )
+    return VerdictDecision(
+        claim_id=claim_id,
+        verdict=verdict_t,
+        confidence=conf,
+        explanation=(
+            f"차이값 직접 검증: 기사 주장 {claimed_diff}, "
+            f"KOSIS({stat_table_id}) 표에서 계산한 값 "
+            f"{calc_diff:.4f} (차이 {gap:.4f}). {calc_desc}"
+        ),
+    )