Blame for CODE/evaluation/eval/eval_geometric052.py

#!/usr/bin/env python3
"""Causally-audited geometric evaluator v5.2 (offline release candidate).

v5.2 keeps the public six-component schema but replaces the parts that the
real-GT counterfactual audit found to be coupled:

* semantic views are matched before a shared scale is fitted;
* geometry retains per-role/per-family one-to-one precision and recall;
* circle/arc parameters are measured explicitly, not inferred from Curve-F1;
* physical geometry never reads predicted DIMENSION text;
* annotation scores presence/type/display value/binding separately;
* structure is a binary validity/anti-hack gate, not a positive style reward;
* the scalar is hierarchical, so downstream quality cannot compensate for a
  missing view or missing required feature.

The frozen v5.1 result is preserved under ``diagnostics.v51_frozen`` solely as
an audit baseline.  This module is not connected to GRPO until its
counterfactual and real-generation acceptance suites pass.
"""

from __future__ import annotations

import copy
import math
from itertools import combinations
from pathlib import Path
from typing import Any, Mapping, Sequence

import numpy as np
from scipy.optimize import linear_sum_assignment

try:
    from . import curve_geometry_metric as CURVE
    from . import eval_geometric05 as EV5
    from . import eval_geometric051 as EV51
    from . import feature_topology_diagnostic as FEATURE
    from . import view_entity_matching_v52 as MATCH
except ImportError:  # direct evaluator import
    import curve_geometry_metric as CURVE
    import eval_geometric05 as EV5
    import eval_geometric051 as EV51
    import feature_topology_diagnostic as FEATURE
    import view_entity_matching_v52 as MATCH


METRIC_VERSION = "v5.2-rc1"
SCHEMA_VERSION = "edp-geometric-evaluator-v5.2-rc1"

ENGINEERING_THRESHOLDS = {
    "structure": 1.0,
    "view": 1.0,
    "geometry": 0.90,
    "physical": 0.90,
    "annotation": 0.90,
    "layout": 0.85,
}

PHYSICAL_SUPPORTED_SEMANTICS = {
    "profile_width",
    "overall_width",
    "profile_height",
    "overall_height",
    "extrusion_depth",
    "thickness",
    "profile_diameter",
    "outer_diameter",
    "inner_diameter",
    "hole_diameter",
    "radius",
    "arc_radius",
}


def _round(value: float | None, digits: int = 6) -> float | None:
    if value is None or not math.isfinite(float(value)):
        return None
    return round(float(value), digits)


def _clip(value: float) -> float:
    return float(min(1.0, max(0.0, value)))


def _mean(values: Sequence[float]) -> float | None:
    return float(np.mean(values)) if values else None


def _minimum(values: Sequence[float]) -> float | None:
    return float(min(values)) if values else None


def _harmonic(first: float, second: float) -> float:
    if first <= 0.0 or second <= 0.0:
        return 0.0
    return float(2.0 * first * second / (first + second))


def _component(
    score: float | None, eligible: bool, reason: str, **details: Any
) -> dict[str, Any]:
    if not eligible:
        score = None
    elif score is None:
        raise ValueError("eligible component requires numeric score")
    return {
        "score": _round(_clip(float(score))) if score is not None else None,
        "eligible": bool(eligible),
        "reason": str(reason),
        "details": details,
    }


def _zero_components(reason: str) -> dict[str, dict[str, Any]]:
    return {
        name: _component(0.0, True, reason)
        for name in ("view", "geometry", "physical", "annotation", "structure")
    } | {"layout": _component(None, False, reason)}


def _curve_quality(curve: Mapping[str, Any]) -> tuple[float, dict[str, Any]]:
    aggregate = curve.get("aggregate", {}) if isinstance(curve, Mapping) else {}
    channel = aggregate.get("all", {}) if isinstance(aggregate, Mapping) else {}
    cd = channel.get("normalized_chamfer") if isinstance(channel, Mapping) else None
    f1 = None
    thresholds = channel.get("thresholds", {}) if isinstance(channel, Mapping) else {}
    if isinstance(thresholds, Mapping):
        row = thresholds.get("0.02", {})
        if isinstance(row, Mapping) and isinstance(row.get("f1"), (int, float)):
            f1 = float(row["f1"])
    if not isinstance(cd, (int, float)) or not math.isfinite(float(cd)):
        return 0.0, {"normalized_chamfer": None, "f1_at_2pct": _round(f1), "reason": "curve_ineligible"}
    cd_value = max(0.0, float(cd))
    cd_quality = math.exp(-cd_value / 0.02)
    quality = 0.75 * cd_quality + 0.25 * (f1 if f1 is not None else cd_quality)
    return _clip(quality), {
        "normalized_chamfer": _round(cd_value),
        "chamfer_quality": _round(cd_quality),
        "f1_at_2pct": _round(f1),
        "score": _round(quality),
    }


def _semantic_rows(context: Mapping[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
    gt_by_role = context["gt_by_role"]
    pred_views = context.get("pred_views", [])
    alignment = context["alignment"]
    role_to_pred = alignment.get("role_to_pred", {})
    global_scale = float(alignment.get("global_scale", 1.0))
    rows: dict[str, Any] = {}
    curve_pred: dict[str, Mapping[str, Any] | None] = {}
    curve_gt: dict[str, Mapping[str, Any]] = {}
    for role, target_view in gt_by_role.items():
        pred_index = role_to_pred.get(role)
        predicted_view = (
            pred_views[pred_index]
            if isinstance(pred_index, int) and 0 <= pred_index < len(pred_views)
            else None
        )
        primitive = MATCH.match_view_primitives(
            predicted_view, target_view, global_scale=global_scale
        )
        target_entities = target_view["entities"]
        predicted_entities = (
            predicted_view["entities"]
            if predicted_view is not None
            else {"lines": [], "circles": [], "arcs": [], "dims": []}
        )
        diagonal = max(float(np.linalg.norm(np.asarray(target_view["size"], dtype=float))), 1.0)
        pred_closure = FEATURE._endpoint_join_diagnostic(predicted_entities, diagonal=diagonal)
        gt_closure = FEATURE._endpoint_join_diagnostic(target_entities, diagonal=diagonal)
        closure = FEATURE._closure_retention(pred_closure, gt_closure)
        strict = None
        if predicted_view is not None:
            strict = EV5.EV3.score_geometry(
                predicted_entities,
                target_entities,
                np.asarray(predicted_view["center"], dtype=float),
                np.asarray(target_view["center"], dtype=float),
                global_scale,
                diagonal,
            )
        rows[role] = {
            "present": predicted_view is not None,
            "predicted_view_index": pred_index,
            "primitive": primitive,
            "contour": {
                "predicted": pred_closure,
                "target": gt_closure,
                "retention": closure,
            },
            "strict": strict,
        }
        curve_pred[role] = predicted_view
        curve_gt[role] = target_view
    curve = CURVE.score_matched_views(
        curve_pred, curve_gt, global_scale=global_scale
    )
    return rows, curve


def _view_component(context: Mapping[str, Any], rows: Mapping[str, Any]) -> dict[str, Any]:
    roles = list(context["gt_by_role"])
    present = [role for role in roles if rows[role]["present"]]
    coverage = len(present) / max(len(roles), 1)
    missing = [role for role in roles if role not in present]
    return _component(
        coverage,
        True,
        "ok" if not missing else "semantic_roles_missing",
        expected_roles=roles,
        present_roles=present,
        missing_roles=missing,
        role_coverage=_round(coverage),
        worst_role_present=not missing,
        alignment_reason=context["alignment"].get("reason"),
        alignment_pairs=context["alignment"].get("pairs", []),
    )


def _layout_component(context: Mapping[str, Any], rows: Mapping[str, Any]) -> dict[str, Any]:
    roles = [role for role, row in rows.items() if row["present"]]
    if len(roles) < 2:
        return _component(
            None,
            False,
            "fewer_than_two_semantic_roles",
            matched_roles=roles,
        )
    alignment = context["alignment"]
    scale = float(alignment.get("global_scale", 1.0))
    role_to_pred = alignment["role_to_pred"]
    pred_views = context["pred_views"]
    gt_by_role = context["gt_by_role"]
    sheet_diagonal = max(float(alignment.get("sheet_diagonal", 1.0)), 1.0)
    errors = []
    pair_rows = []
    for first, second in combinations(roles, 2):
        pred_vector = scale * (
            np.asarray(pred_views[role_to_pred[second]]["center"], dtype=float)
            - np.asarray(pred_views[role_to_pred[first]]["center"], dtype=float)
        )
        gt_vector = (
            np.asarray(gt_by_role[second]["center"], dtype=float)
            - np.asarray(gt_by_role[first]["center"], dtype=float)
        )
        error = float(np.linalg.norm(pred_vector - gt_vector) / sheet_diagonal)
        errors.append(error)
        pair_rows.append(
            {"roles": [first, second], "vector_error_fraction": _round(error)}
        )
    mean_error = float(np.mean(errors)) if errors else math.inf
    score = math.exp(-mean_error / 0.10)
    return _component(
        score,
        True,
        "ok" if mean_error <= 0.02 else "relative_view_layout_mismatch",
        matched_roles=roles,
        mean_pair_vector_error_fraction=_round(mean_error),
        pairs=pair_rows,
        missing_roles_do_not_repeat_penalty=True,
    )


def _geometry_component(
    context: Mapping[str, Any], rows: Mapping[str, Any], curve: Mapping[str, Any]
) -> tuple[dict[str, Any], dict[str, Any]]:
    feature_scores: list[float] = []
    role_scores: dict[str, float] = {}
    parameter_scores: list[float] = []
    role_details: dict[str, Any] = {}
    for role, row in rows.items():
        local: list[float] = []
        for family in ("visible_line", "hidden_line", "circle", "arc"):
            item = row["primitive"][family]
            if item.get("eligible") and isinstance(item.get("f1"), (int, float)):
                value = float(item["f1"])
                local.append(value)
                feature_scores.append(value)
            if family in {"circle", "arc"} and item.get("eligible"):
                parameter = item.get("parameter_score")
                if isinstance(parameter, (int, float)):
                    parameter_scores.append(float(parameter))
        retention = row["contour"]["retention"]
        if retention.get("eligible") and isinstance(retention.get("score"), (int, float)):
            local.append(float(retention["score"]))
            feature_scores.append(float(retention["score"]))
        role_score = float(np.mean(local)) if local else (1.0 if row["present"] else 0.0)
        role_scores[role] = role_score
        role_details[role] = {
            "feature_macro": _round(role_score),
            "feature_worst": _round(min(local)) if local else _round(role_score),
        }
    macro = float(np.mean(feature_scores)) if feature_scores else 0.0
    worst = min(
        [min(role_scores.values()) if role_scores else 0.0]
        + [float(value) for value in feature_scores]
    )
    topology_score = 0.40 * macro + 0.60 * worst
    extra_indices = context["alignment"].get("extra_predicted_indices", [])
    pred_views = context.get("pred_views", [])
    extra_primitives = int(
        sum(
            int(pred_views[index].get("n_primitives", 0))
            for index in extra_indices
            if isinstance(index, int) and 0 <= index < len(pred_views)
        )
    )
    target_primitives = int(
        sum(int(view.get("n_primitives", 0)) for view in context["gt_by_role"].values())
    )
    extra_precision = target_primitives / max(target_primitives + extra_primitives, 1)
    topology_score *= extra_precision
    curve_score, curve_details = _curve_quality(curve)
    parameter_score = _mean(parameter_scores)
    weighted = [(0.58, topology_score), (0.30, curve_score)]
    if parameter_score is not None:
        weighted.append((0.12, parameter_score))
    weight_sum = sum(weight for weight, _ in weighted)
    score = sum(weight * value for weight, value in weighted) / weight_sum
    component = _component(
        score,
        True,
        "ok" if score >= ENGINEERING_THRESHOLDS["geometry"] else "geometry_or_topology_mismatch",
        topology_score=_round(topology_score),
        feature_macro=_round(macro),
        feature_worst=_round(worst),
        extra_fragment_precision=_round(extra_precision),
        extra_primitive_count=extra_primitives,
        curve_score=_round(curve_score),
        parameter_score=_round(parameter_score),
        roles=role_details,
    )
    return component, {
        "topology_score": topology_score,
        "feature_macro": macro,
        "feature_worst": worst,
        "curve_score": curve_score,
        "curve": curve_details,
        "parameter_score": parameter_score,
    }


def _prompt_semantics(sidecar: Mapping[str, Any] | None) -> tuple[list[str], list[str]]:
    parameters = sidecar.get("parameters") if isinstance(sidecar, Mapping) else None
    candidates = parameters.get("candidates") if isinstance(parameters, Mapping) else None
    values: list[str] = []
    if isinstance(candidates, Sequence) and not isinstance(candidates, (str, bytes)):
        for item in candidates:
            semantic = item.get("semantic") if isinstance(item, Mapping) else None
            if isinstance(semantic, Mapping) and semantic.get("type"):
                values.append(str(semantic["type"]))
    supported = sorted({value for value in values if value in PHYSICAL_SUPPORTED_SEMANTICS})
    unsupported = sorted({value for value in values if value not in PHYSICAL_SUPPORTED_SEMANTICS})
    return supported, unsupported


def _physical_component(
    context: Mapping[str, Any], rows: Mapping[str, Any], sidecar: Mapping[str, Any] | None
) -> dict[str, Any]:
    alignment = context["alignment"]
    scale = float(alignment.get("global_scale", 1.0))
    role_to_pred = alignment.get("role_to_pred", {})
    pred_views = context.get("pred_views", [])
    gt_by_role = context["gt_by_role"]
    extent_items: list[dict[str, Any]] = []
    qualities: list[float] = []
    for role, gt_view in gt_by_role.items():
        pred_index = role_to_pred.get(role)
        if not isinstance(pred_index, int) or not 0 <= pred_index < len(pred_views):
            extent_items.append({"role": role, "eligible": False, "reason": "role_missing"})
            continue
        pred_size = np.asarray(pred_views[pred_index]["size"], dtype=float) * scale
        gt_size = np.asarray(gt_view["size"], dtype=float)
        for axis, name in enumerate(("width", "height")):
            if gt_size[axis] <= 1e-9:
                continue
            log_error = abs(math.log(max(float(pred_size[axis]), 1e-12) / float(gt_size[axis])))
            quality = math.exp(-log_error / 0.10)
            qualities.append(quality)
            extent_items.append(
                {
                    "role": role,
                    "measurement": f"bbox_{name}",
                    "eligible": True,
                    "predicted_aligned": _round(float(pred_size[axis])),
                    "target": _round(float(gt_size[axis])),
                    "log_error": _round(log_error),
                    "relative_error": _round(abs(float(pred_size[axis]) / float(gt_size[axis]) - 1.0)),
                    "score": _round(quality),
                }
            )
    primitive_items: list[dict[str, Any]] = []
    for role, row in rows.items():
        for family in ("circle", "arc"):
            item = row["primitive"][family]
            if item.get("eligible"):
                value = item.get("parameter_score")
                if isinstance(value, (int, float)):
                    qualities.append(float(value))
                    primitive_items.append(
                        {
                            "role": role,
                            "family": family,
                            "score": _round(float(value)),
                            "pairs": copy.deepcopy(item.get("pairs", [])),
                            "recall": item.get("recall"),
                        }
                    )
    supported, unsupported = _prompt_semantics(sidecar)
    if not qualities:
        return _component(
            None,
            False,
            "no_supported_actual_geometry_measurements",
            extent_items=extent_items,
            primitive_items=primitive_items,
            supported_prompt_semantics=supported,
            unsupported_prompt_semantics=unsupported,
            reads_prediction_dimension_text=False,
        )
    macro = float(np.mean(qualities))
    worst = min(qualities)
    score = 0.55 * macro + 0.45 * worst
    return _component(
        score,
        True,
        "ok" if score >= ENGINEERING_THRESHOLDS["physical"] else "actual_geometry_measurement_mismatch",
        measurement_scope="matched_view_extents_and_matched_circle_arc_parameters",
        macro=_round(macro),
        worst=_round(worst),
        extent_items=extent_items,
        primitive_items=primitive_items,
        supported_prompt_semantics=supported,
        unsupported_prompt_semantics=unsupported,
        fail_closed_for_unsupported_semantics=True,
        reads_prediction_dimension_text=False,
    )


def _semantic_family(value: Any) -> str:
    token = str(value or "").lower()
    return "linear" if token in {"linear", "aligned"} else token


def _dimension_display_value(
    dimension: Mapping[str, Any],
    *,
    target_value: float,
    target_dimension: Mapping[str, Any],
    global_scale: float,
) -> tuple[float | None, str]:
    value = dimension.get("display_value")
    if isinstance(value, (int, float)) and math.isfinite(float(value)):
        return abs(float(value)), "explicit_display_text"
    measurement = dimension.get("measurement")
    target_measurement = target_dimension.get("measurement")
    if (
        isinstance(measurement, (int, float))
        and isinstance(target_measurement, (int, float))
        and abs(float(target_measurement)) > 1e-12
    ):
        inferred = abs(float(measurement)) * global_scale * target_value / abs(float(target_measurement))
        return inferred, "automatic_measurement_placeholder"
    return None, "display_value_unavailable"


def _dimension_role(
    sidecar: Mapping[str, Any] | None, gt_index: int
) -> str | None:
    dimensions = sidecar.get("dimensions") if isinstance(sidecar, Mapping) else None
    items = dimensions.get("items") if isinstance(dimensions, Mapping) else None
    item = items[gt_index] if isinstance(items, Sequence) and 0 <= gt_index < len(items) else None
    if isinstance(item, Mapping):
        for key in ("nearest_view_position", "nearest_view_role"):
            value = str(item.get(key) or "")
            if value in {"front", "top", "right"}:
                return value
        try:
            view_index = int(item.get("view_candidate_index"))
        except (TypeError, ValueError):
            view_index = -1
        views = sidecar.get("views") if isinstance(sidecar, Mapping) else None
        candidates = views.get("candidates") if isinstance(views, Mapping) else None
        if isinstance(candidates, Sequence) and 0 <= view_index < len(candidates):
            candidate = candidates[view_index]
            if isinstance(candidate, Mapping) and candidate.get("name"):
                return str(candidate["name"])
    return None


def _annotation_component(
    context: Mapping[str, Any], sidecar: Mapping[str, Any] | None
) -> tuple[dict[str, Any], dict[str, Any]]:
    contract = EV51._scope_contracts(sidecar)
    prompt = contract.get("prompt", {})
    mask = prompt.get("annotation_mask", []) if isinstance(prompt, Mapping) else []
    specs = [
        dict(spec)
        for spec, selected in zip(contract.get("specs", []), mask)
        if selected
    ]
    if not prompt.get("annotation_eligible") or not specs:
        component = _component(
            None,
            False,
            "prompt_annotation_mask_ineligible",
            contract_errors=contract.get("errors", []),
            reads_actual_geometry=False,
        )
        return component, {"items": [], "eligible": False}
    raw_pred, raw_gt = context.get("raw_pred") or {}, context.get("raw_gt") or {}
    pred_dims, gt_dims = list(raw_pred.get("dims", [])), list(raw_gt.get("dims", []))
    targets: list[dict[str, Any]] = []
    for spec in specs:
        gt_index = int(spec["gt_dimension_index"])
        if not 0 <= gt_index < len(gt_dims):
            continue
        targets.append(
            {
                "spec": spec,
                "gt_index": gt_index,
                "dimension": gt_dims[gt_index],
                "role": _dimension_role(sidecar, gt_index),
            }
        )
    if not targets:
        component = _component(None, False, "no_valid_masked_target_dimensions")
        return component, {"items": [], "eligible": False}
    sheet_diagonal = max(float(context["alignment"].get("sheet_diagonal", 1.0)), 1.0)
    costs = np.full((len(pred_dims), len(targets)), 10.0, dtype=float)
    raw_cost: dict[tuple[int, int], dict[str, Any]] = {}
    for pred_index, pred_dim in enumerate(pred_dims):
        pred_binding = np.asarray(pred_dim.get("binding_point", (0.0, 0.0)), dtype=float)
        for target_index, target in enumerate(targets):
            role = target["role"]
            transform = MATCH.role_local_transform(context, role) if role else None
            if transform is None:
                scale = float(context["alignment"].get("global_scale", 1.0))
                translation = np.asarray(context["alignment"].get("translation", (0.0, 0.0)), dtype=float)
            else:
                scale, translation = transform
            aligned_binding = pred_binding * scale + translation
            gt_binding = np.asarray(target["dimension"].get("binding_point", (0.0, 0.0)), dtype=float)
            distance = float(np.linalg.norm(aligned_binding - gt_binding) / sheet_diagonal)
            pred_family = _semantic_family(pred_dim.get("family"))
            target_family = _semantic_family(target["spec"].get("family"))
            family_penalty = 0.05 if pred_family != target_family else 0.0
            costs[pred_index, target_index] = distance + family_penalty
            raw_cost[(pred_index, target_index)] = {
                "binding_distance_fraction": distance,
                "predicted_family": pred_family,
                "target_family": target_family,
                "role": role,
                "scale": scale,
            }
    pairs: dict[int, int] = {}
    if pred_dims:
        rows, columns = linear_sum_assignment(costs)
        for pred_index, target_index in zip(rows, columns):
            if raw_cost[(int(pred_index), int(target_index))]["binding_distance_fraction"] <= 0.08:
                pairs[int(target_index)] = int(pred_index)
    item_rows: list[dict[str, Any]] = []
    item_scores: list[float] = []
    presence_values: list[float] = []
    type_values: list[float] = []
    value_values: list[float] = []
    binding_values: list[float] = []
    for target_index, target in enumerate(targets):
        spec = target["spec"]
        pred_index = pairs.get(target_index)
        if pred_index is None:
            presence_values.append(0.0)
            type_values.append(0.0)
            value_values.append(0.0)
            binding_values.append(0.0)
            item_scores.append(0.0)
            item_rows.append(
                {
                    "id": spec["id"],
                    "gt_dimension_index": target["gt_index"],
                    "pred_dimension_index": None,
                    "role": target["role"],
                    "presence": 0.0,
                    "type": 0.0,
                    "display_value": 0.0,
                    "binding": 0.0,
                    "score": 0.0,
                    "reason": "missing_dimension",
                }
            )
            continue
        pred_dim = pred_dims[pred_index]
        detail = raw_cost[(pred_index, target_index)]
        presence = 1.0
        type_quality = float(detail["predicted_family"] == detail["target_family"])
        target_value = abs(float(spec["value"]))
        predicted_value, value_source = _dimension_display_value(
            pred_dim,
            target_value=target_value,
            target_dimension=target["dimension"],
            global_scale=float(detail["scale"]),
        )
        if predicted_value is None or target_value <= 1e-12:
            relative_error, value_quality = None, 0.0
        else:
            relative_error = abs(predicted_value / target_value - 1.0)
            value_quality = math.exp(
                -abs(math.log(max(predicted_value, 1e-12) / target_value)) / 0.10
            )
        binding_quality = math.exp(-float(detail["binding_distance_fraction"]) / 0.03)
        item_score = 0.35 * presence + 0.20 * type_quality + 0.30 * value_quality + 0.15 * binding_quality
        presence_values.append(presence)
        type_values.append(type_quality)
        value_values.append(value_quality)
        binding_values.append(binding_quality)
        item_scores.append(item_score)
        item_rows.append(
            {
                "id": spec["id"],
                "gt_dimension_index": target["gt_index"],
                "pred_dimension_index": pred_index,
                "role": target["role"],
                "presence": 1.0,
                "type": _round(type_quality),
                "display_value": _round(value_quality),
                "binding": _round(binding_quality),
                "target_display_value": _round(target_value),
                "predicted_display_value": _round(predicted_value),
                "display_value_source": value_source,
                "display_value_relative_error": _round(relative_error),
                "binding_distance_fraction": _round(float(detail["binding_distance_fraction"])),
                "score": _round(item_score),
                "reason": "ok" if item_score >= 0.90 else "annotation_field_mismatch",
            }
        )
    macro = float(np.mean(item_scores))
    worst = min(item_scores)
    score = 0.50 * macro + 0.50 * worst
    component = _component(
        score,
        True,
        "ok" if score >= ENGINEERING_THRESHOLDS["annotation"] else "masked_annotation_mismatch",
        n_target=len(targets),
        n_predicted_native=len(pred_dims),
        presence_recall=_round(float(np.mean(presence_values))),
        type_macro=_round(float(np.mean(type_values))),
        display_value_macro=_round(float(np.mean(value_values))),
        binding_macro=_round(float(np.mean(binding_values))),
        item_macro=_round(macro),
        item_worst=_round(worst),
        items=item_rows,
        reads_actual_geometry=False,
        unmasked_target_dimensions_ignored=True,
    )
    return component, {"eligible": True, "items": item_rows}


def _structure_component(
    context: Mapping[str, Any], frozen: Mapping[str, Any]
) -> dict[str, Any]:
    anti_hack = frozen.get("anti_hack", {}) if isinstance(frozen, Mapping) else {}
    spam_ratio = anti_hack.get("dimension_spam_ratio", anti_hack.get("duplicate_dimension_ratio", 0.0))
    try:
        spam_ratio = float(spam_ratio or 0.0)
    except (TypeError, ValueError):
        spam_ratio = 0.0
    valid = bool(
        context.get("prediction_valid")
        and context.get("pred_meta", {}).get("readable")
        and spam_ratio < 0.50
    )
    return _component(
        1.0 if valid else 0.0,
        True,
        "ok" if valid else "invalid_or_anti_hack_gate_failed",
        gate_only=True,
        readable=bool(context.get("pred_meta", {}).get("readable")),
        nondegenerate=bool(context.get("prediction_valid")),
        dimension_spam_ratio=_round(spam_ratio),
        positive_continuous_reward=False,
    )


def _hierarchical_reward(components: Mapping[str, Mapping[str, Any]], atomic: Mapping[str, Any]) -> dict[str, Any]:
    def score(name: str, fallback: float = 1.0) -> float:
        row = components[name]
        value = row.get("score")
        return float(value) if row.get("eligible") and isinstance(value, (int, float)) else fallback

    structure_gate = score("structure", 0.0)
    view = score("view", 0.0)
    topology = float(atomic.get("topology_score", 0.0))
    geometry = score("geometry", 0.0)
    layout = score("layout", 1.0)
    physical = score("physical", geometry)
    annotation = score("annotation", 1.0)
    view_topology_gate = _harmonic(view, topology)
    geometry_gate = _harmonic(view_topology_gate, geometry)
    physical_gate = _harmonic(geometry_gate, physical)
    stages = {
        "view_topology": 0.70 * view_topology_gate + 0.30 * view_topology_gate * layout,
        "geometry": view_topology_gate * geometry,
        "physical": geometry_gate * physical,
        "annotation": physical_gate * annotation,
    }
    reward = structure_gate * (
        0.35 * stages["view_topology"]
        + 0.30 * stages["geometry"]
        + 0.20 * stages["physical"]
        + 0.15 * stages["annotation"]
    )
    return {
        "score": _round(reward),
        "structure_gate": _round(structure_gate),
        "view_topology_gate": _round(view_topology_gate),
        "geometry_gate": _round(geometry_gate),
        "physical_gate": _round(physical_gate),
        "stages": {name: _round(value) for name, value in stages.items()},
        "policy": {
            "structure": "binary_multiplicative_gate",
            "view_topology": "harmonic_gate",
            "downstream": "each_stage_multiplied_by_upstream_gate",
            "weights": {
                "view_topology": 0.35,
                "geometry": 0.30,
                "physical": 0.20,
                "annotation": 0.15,
            },
        },
    }


def _benchmark(components: Mapping[str, Mapping[str, Any]]) -> dict[str, Any]:
    states: dict[str, bool | None] = {}
    for name, threshold in ENGINEERING_THRESHOLDS.items():
        row = components[name]
        value = row.get("score")
        states[f"{name}_pass"] = (
            bool(float(value) >= threshold)
            if row.get("eligible") and isinstance(value, (int, float))
            else None
        )
    evaluable = all(value is not None for value in states.values())
    success = all(bool(value) for value in states.values()) if evaluable else None
    return {
        **states,
        "fully_evaluable": evaluable,
        "engineering_success": success,
        "cad_pass": success,
        "thresholds": dict(ENGINEERING_THRESHOLDS),
        "strict_scope": "prompt_observable_v52",
    }


def score_dxf_pair(
    pred: str | Path,
    gt: str | Path,
    sidecar: Mapping[str, Any] | None = None,
    category: str | None = None,
    **_kwargs: Any,
) -> dict[str, Any]:
    """Score an executed DXF pair with independent v5.2 components."""

    frozen = EV51.score_dxf_pair(pred, gt, sidecar=sidecar, category=category)
    context = MATCH.build_pair_context(pred, gt, sidecar=sidecar)
    result: dict[str, Any] = {
        "schema_version": SCHEMA_VERSION,
        "metric_version": METRIC_VERSION,
        "category": category,
        "anti_hack": copy.deepcopy(frozen.get("anti_hack", {})),
        "diagnostics": {
            "v51_frozen": {
                "metric_version": frozen.get("metric_version"),
                "components": copy.deepcopy(frozen.get("components", {})),
                "benchmark": copy.deepcopy(frozen.get("benchmark", {})),
                "anti_hack": copy.deepcopy(frozen.get("anti_hack", {})),
            },
            "matching": {
                key: copy.deepcopy(value)
                for key, value in context.items()
                if key
                not in {
                    "raw_pred",
                    "raw_gt",
                    "canonical_pred",
                    "canonical_gt",
                    "pred_views",
                    "pred_views_all",
                    "gt_by_role",
                }
            },
        },
    }
    if not context.get("eligible"):
        components = {
            name: _component(None, False, str(context.get("reason")))
            for name in ("view", "geometry", "physical", "annotation", "layout", "structure")
        }
        result["components"] = components
        result["hierarchical_reward"] = {"score": None, "reason": "target_ineligible"}
        result["online_reward"] = {"scope": "prompt_observable_v52", "components": components}
        result["benchmark"] = _benchmark(components)
        result["engineering_success"] = None
        return result
    if not context.get("prediction_valid"):
        components = _zero_components("prediction_dxf_unreadable_or_degenerate")
        reward = _hierarchical_reward(components, {"topology_score": 0.0})
        result["components"] = components
        result["hierarchical_reward"] = reward
        result["online_reward"] = {
            "scope": "prompt_observable_v52",
            "components": components,
            "hierarchical_reward": reward,
        }
        result["benchmark"] = _benchmark(components)
        result["engineering_success"] = result["benchmark"]["engineering_success"]
        return result

    rows, curve = _semantic_rows(context)
    view = _view_component(context, rows)
    layout = _layout_component(context, rows)
    geometry, atomic = _geometry_component(context, rows, curve)
    physical = _physical_component(context, rows, sidecar)
    annotation, annotation_diagnostic = _annotation_component(context, sidecar)
    structure = _structure_component(context, frozen)
    components = {
        "view": view,
        "geometry": geometry,
        "physical": physical,
        "annotation": annotation,
        "layout": layout,
        "structure": structure,
    }
    reward = _hierarchical_reward(components, atomic)
    benchmark = _benchmark(components)
    result.update(
        {
            "components": components,
            "online_reward": {
                "scope": "prompt_observable_v52",
                "components": components,
                "hierarchical_reward": reward,
            },
            "hierarchical_reward": reward,
            "benchmark": benchmark,
            "engineering_success": benchmark["engineering_success"],
        }
    )
    result["diagnostics"].update(
        {
            "semantic_views": rows,
            "curve_geometry": curve,
            "atomic_geometry": {
                key: copy.deepcopy(value) for key, value in atomic.items() if key != "curve"
            },
            "curve_summary": atomic.get("curve"),
            "annotation_fields": annotation_diagnostic,
            "release_status": {
                "grpo_connected": False,
                "reason": "counterfactual_and_real_generation_acceptance_required",
            },
        }
    )
    return result


__all__ = [
    "ENGINEERING_THRESHOLDS",
    "METRIC_VERSION",
    "PHYSICAL_SUPPORTED_SEMANTICS",
    "SCHEMA_VERSION",
    "score_dxf_pair",
]