src/explicit_learning/executors/geometry.py

"""``geometry_dsl_v1`` executor — direct-lookup solver over the supported subset (P3).

Evaluates ``SOLVE(goal, AND(constraints))`` programs built by
:mod:`~explicit_learning.dsl.geometrydsl` against a ``geometry_world_v1``. The P3
supported predicate subset is the *direct-lookup* case: the goal target's value
is stated outright by a ``MeasureOf(target, v)`` or ``Equals(target, v)``
constraint. A full theorem-proving solver (the 6-check Inter-GPS/FormalGeo
acceptance of ``docs/02`` §6.3) is the **reference executor** (P13); this
executor covers the subset where the answer is explicitly given and reports
``MISSING_INFORMATION`` (never a guess) when it cannot derive the goal.

Channel provenance (``text``/``visual``/``redundant``) lives on the program
envelope; the executor reads the formal constraint graph from the **world**
(``world["constraints"]`` dicts, not the program's ``AND`` mirror) so that
re-executing the fixed program against a *mutated* world (§14 replay) reflects
the mutation. ``U_INVALID`` arises when the scalar ``SELECT_ENTITY`` referent
(the goal target) is deleted from the world.
"""

from __future__ import annotations

from collections.abc import Mapping
from fractions import Fraction
from typing import Any

from ..dsl.ast import Arg, AstNode, Program
from ..sources.base import World
from .base import (
    AnswerValue,
    ExecutionResult,
    ExecutorError,
    _InvalidReferent,
    _MissingInformation,
    _Trace,
    serialize_answer,
)

NAME = "geometry_executor"
VERSION = "geometry_dsl_v1/1"


class GeometryExecutor:
    """Deterministic direct-lookup executor for ``geometry_dsl_v1``."""

    name = NAME
    version = VERSION

    def execute(self, program: Program, *, world: World) -> ExecutionResult:
        trace = _Trace()
        try:
            referent_card = self._check_referent(program, world, trace)
            answer = self._solve(program.program, world, trace)
            _steps, deps, tsha = trace.finish()
            return ExecutionResult(
                status="UNIQUE",
                answer_value=answer,
                answer_canonical=serialize_answer(answer, return_type=program.program.return_type),
                dependency_node_ids=deps,
                referent_cardinality=referent_card,
                trace_sha256=tsha,
                executor_name=self.name,
                executor_version=self.version,
            )
        except _InvalidReferent:
            _steps, deps, tsha = trace.finish()
            return ExecutionResult(
                status="INVALID_REFERENT",
                answer_value=None,
                answer_canonical=None,
                dependency_node_ids=deps,
                referent_cardinality=self._safe_referent_card(program, world),
                trace_sha256=tsha,
                executor_name=self.name,
                executor_version=self.version,
            )
        except _MissingInformation:
            _steps, deps, tsha = trace.finish()
            return ExecutionResult(
                status="MISSING_INFORMATION",
                answer_value=None,
                answer_canonical=None,
                dependency_node_ids=deps,
                referent_cardinality=self._safe_referent_card(program, world),
                trace_sha256=tsha,
                executor_name=self.name,
                executor_version=self.version,
            )
        except ExecutorError:
            _steps, deps, tsha = trace.finish()
            return ExecutionResult(
                status="ERROR",
                answer_value=None,
                answer_canonical=None,
                dependency_node_ids=deps,
                referent_cardinality=self._safe_referent_card(program, world),
                trace_sha256=tsha,
                executor_name=self.name,
                executor_version=self.version,
            )

    def execute_selector(self, selector: AstNode, *, world: World) -> tuple[str, ...]:
        if selector.op == "SELECT_ENTITY":
            eid = _ref_id(selector.args[0])
            return (eid,) if _entity(world, eid) is not None else ()
        if selector.op == "SELECT_SERIES":  # parity; geometry worlds carry no series
            return ()
        return ()

    # --- referent precondition --------------------------------------------

    def _check_referent(self, program: Program, world: World, trace: _Trace) -> int | None:
        selector = program.referent_selector
        required = program.required_referent_cardinality
        if selector is None or required is None:
            return None if selector is None else len(self.execute_selector(selector, world=world))
        refs = self.execute_selector(selector, world=world)
        trace.record("REFERENT", refs, len(refs))
        if len(refs) != required:
            raise _InvalidReferent(
                f"scalar referent cardinality {len(refs)} != required {required}"
            )
        return len(refs)

    def _safe_referent_card(self, program: Program, world: World) -> int | None:
        if program.referent_selector is None:
            return None
        try:
            return len(self.execute_selector(program.referent_selector, world=world))
        except ExecutorError:
            return None

    # --- solving ------------------------------------------------------------

    def _solve(self, node: AstNode, world: World, trace: _Trace) -> AnswerValue:
        if node.op != "SOLVE":
            raise ExecutorError(f"expected SOLVE root, got {node.op!r}")
        goal = node.args[0]
        constraints = self._world_constraints(world)
        return self._solve_goal(goal, constraints, world, trace)

    def _world_constraints(self, world: World) -> tuple[Mapping[str, Any], ...]:
        """The formal constraint facts (``world["constraints"]`` dicts).

        Read from the world — not the program's ``AND`` mirror — so a mutated
        world (a deleted stating-constraint, §14 replay) changes the result.
        """
        out: list[Mapping[str, Any]] = []
        for c in world.get("constraints", []) or []:
            if isinstance(c, Mapping) and c.get("predicate"):
                out.append(c)
        return tuple(out)

    def _solve_goal(
        self, goal: Arg, constraints: tuple[Mapping[str, Any], ...], world: World, trace: _Trace
    ) -> AnswerValue:
        if not isinstance(goal, AstNode):
            raise ExecutorError(f"expected a goal AST node, got {type(goal).__name__}")
        if goal.op == "MEASURE":
            target = _ref_id(goal.args[0])
            return self._measure(target, constraints, trace)
        if goal.op == "FIND":
            target = _ref_id(goal.args[0])
            return self._find(target, constraints, trace)
        if goal.op == "PROVE":
            return self._prove(goal, constraints, trace)
        raise ExecutorError(f"unsupported goal op {goal.op!r}")

    def _measure(
        self, target: str, constraints: tuple[Mapping[str, Any], ...], trace: _Trace
    ) -> Fraction:
        for c in constraints:
            if c.get("predicate") == "MeasureOf" and _arg0(c) == target:
                value = _as_number(_arg1(c))
                trace.record("MEASURE", (target,), value)
                return value
        raise _MissingInformation(f"no MeasureOf constraint states {target!r}")

    def _find(
        self, target: str, constraints: tuple[Mapping[str, Any], ...], trace: _Trace
    ) -> Fraction:
        for c in constraints:
            if c.get("predicate") == "MeasureOf" and _arg0(c) == target:
                value = _as_number(_arg1(c))
                trace.record("FIND", (target,), value)
                return value
            if c.get("predicate") == "Equals" and _equals_target_value(c, target) is not None:
                value = _as_number(_equals_target_value(c, target))
                trace.record("FIND", (target,), value)
                return value
        raise _MissingInformation(f"no constraint states the value of {target!r}")

    def _prove(
        self, goal: AstNode, constraints: tuple[Mapping[str, Any], ...], trace: _Trace
    ) -> bool:
        # PROVE asserts a predicate; true iff an identical constraint is given.
        target_pred = goal.args[0]
        if not isinstance(target_pred, AstNode):
            raise ExecutorError("PROVE expects a predicate argument")
        for c in constraints:
            if _constraint_matches(c, target_pred):
                trace.record("PROVE", (), True)
                return True
        raise _MissingInformation("PROVE: asserted predicate not found among givens")


# --- helpers ---------------------------------------------------------------


def _entity(world: World, eid: str) -> Mapping[str, Any] | None:
    for entity in world.get("entities", []) or []:
        if isinstance(entity, Mapping) and entity.get("id") == eid:
            return entity
    return None


def _ref_id(arg: Any) -> str:
    if isinstance(arg, AstNode):
        return arg.ref_id()
    return str(arg)


def _arg0(c: Mapping[str, Any]) -> str:
    args = c.get("args") or []
    return str(args[0]) if args else ""


def _arg1(c: Mapping[str, Any]) -> str:
    args = c.get("args") or []
    return str(args[1]) if len(args) > 1 else ""


def _equals_target_value(c: Mapping[str, Any], target: str) -> str | None:
    """If ``Equals(target, v)`` or ``Equals(v, target)``, return the other side's value."""
    args = c.get("args") or []
    if len(args) != 2:
        return None
    a, b = str(args[0]), str(args[1])
    if a == target and _looks_numeric(b):
        return b
    if b == target and _looks_numeric(a):
        return a
    return None


def _looks_numeric(text: str) -> bool:
    try:
        Fraction(text)
    except (ValueError, ZeroDivisionError):
        return False
    return True


def _as_number(value: Any) -> Fraction:
    if isinstance(value, bool):  # noqa: FBT001
        raise ExecutorError("boolean where a number was expected")
    if isinstance(value, Fraction):
        return value
    if isinstance(value, int):
        return Fraction(value)
    try:
        return Fraction(str(value))
    except (ValueError, ZeroDivisionError) as exc:  # unparseable → ERROR, never a crash/U
        raise ExecutorError(f"unparseable numeric value {value!r}") from exc


def _constraint_matches(c: Mapping[str, Any], pred_node: AstNode) -> bool:
    if pred_node.op not in ("MeasureOf", "Equals", "IsMidpointOf", "Parallel", "Perpendicular"):
        return False
    if c.get("predicate") != pred_node.op:
        return False
    cargs = [str(a) for a in (c.get("args") or [])]
    pargs = [str(a.ref_id()) if isinstance(a, AstNode) else str(a) for a in pred_node.args]
    return cargs == pargs


__all__ = ["GeometryExecutor"]