src/explicit_learning/dsl/geometrydsl.py

"""``geometry_dsl_v1`` operator table + Geometry3K program compiler (``docs/02``
§6.2, ``docs/07`` §4 P2).

The compiler consumes the parsed ``geometry_world_v1`` from
:meth:`~explicit_learning.sources.geometry3k.Geometry3KAdapter.build_world` — it
does **not** re-parse the annotated logic forms. Each world constraint becomes a
typed boolean :class:`~explicit_learning.dsl.ast.AstNode`; the goal (``find_angle``
/ ``find_length``) becomes a goal op (``MEASURE`` / ``FIND``) over the single
target entity. Channel provenance (``text`` / ``visual`` / ``redundant``) is
preserved on the :class:`Program` via ``constraint_channels`` — a side table, not
part of the schema hash, so the P3 intervention layer can alter only ``visual``
constraints without changing the program fingerprint.

Goal extraction is conservative: the target entity must be the unique entity of
the goal's kind (one angle for ``find_angle``, one segment for ``find_length``).
When the target is ambiguous or the goal type is unrecognized, the program is
``compile_status="unsupported"`` with a ``reason_code`` — never a guess. The
6-check solver acceptance is P3; P2 produces the typed structure only.
"""

from __future__ import annotations

from dataclasses import replace
from fractions import Fraction
from typing import Any

from ..ingest.base import NormalizedItem
from ..sources.base import World
from .ast import AstNode, Dsl, Program, lit, ref
from .canonicalize import canonical_program_sha256
from .typecheck import OpSignature, typecheck

DSL: Dsl = "geometry_dsl_v1"

# --- operator signature table (§6.2) ---------------------------------------
#
# Constraint predicates are boolean assertions over entities; their operands are
# ``any`` because a single predicate (e.g. ``Equals``) may relate points, angles,
# or segments. Goal ops yield the sought value/boolean. ``SELECT_ENTITY`` is the
# scalar referent selector for the goal target. ``AND`` is the commutative
# conjunction of givens; ``SOLVE`` pairs a goal with its givens.
SIGNATURES: dict[str, OpSignature] = {
    # Constraint predicates (boolean facts).
    "MeasureOf": OpSignature(arg_types=("any", "any"), return_type="boolean"),
    "Equals": OpSignature(arg_types=("any", "any"), return_type="boolean"),
    "IsMidpointOf": OpSignature(arg_types=("any", "any"), return_type="boolean"),
    "Parallel": OpSignature(arg_types=("any", "any"), return_type="boolean"),
    "Perpendicular": OpSignature(arg_types=("any", "any"), return_type="boolean"),
    # Goal ops.
    "MEASURE": OpSignature(arg_types=("angle",), return_type="value", selector_kind="none"),
    "FIND": OpSignature(arg_types=("any",), return_type="value", selector_kind="none"),
    "PROVE": OpSignature(arg_types=("any",), return_type="boolean", selector_kind="none"),
    # Structural ops.
    "SELECT_ENTITY": OpSignature(arg_types=("any",), return_type="entity", selector_kind="scalar"),
    "AND": OpSignature(
        arg_types=("boolean",), return_type="boolean", commutative=True, variadic=True
    ),
    "SOLVE": OpSignature(arg_types=("any", "any"), return_type="any", selector_kind="none"),
}

# Canonicalization profile (§7.2 steps 3–5). ``AND`` is commutative; geometry has
# no operator aliases or identity casts in P2.
COMMUTATIVE_OPS: frozenset[str] = frozenset({"AND"})
ALIASES: dict[str, str] = {}
IDENTITY_CASTS: frozenset[str] = frozenset()

_UNSUPPORTED_NODE = AstNode(op="UNSUPPORTED", args=(), return_type="")


# --- compile ---------------------------------------------------------------


def compile_geometry3k(item: NormalizedItem, world: World) -> Program:
    """Build the typed ``geometry_dsl_v1`` program for one normalized Geometry3K item.

    Consumes ``build_world``'s entities/constraints/channels. Returns a compiled
    :class:`Program` (goal op + constraint conjunction, channel provenance on the
    envelope, canonical hash filled) or ``"unsupported"`` (with ``reason_code``)
    when the goal target is ambiguous/unrecognized. Never guesses.
    """
    entities = world.get("entities", []) or []
    entity_kind = {
        str(e["id"]): str(e["id"]).split(":", 1)[0]
        for e in entities
        if isinstance(e, dict) and e.get("id")
    }

    goal_type = world.get("goal")
    target_id, goal_op = _goal_target(goal_type, entities)
    if target_id is None or goal_op is None:
        return _unsupported(item, f"goal_{goal_type}_unresolved")
    target_kind = entity_kind.get(target_id, "entity")

    goal_node = AstNode(
        op=goal_op, args=(ref(target_id, return_type=target_kind),), return_type="value"
    )
    constraint_nodes, constraint_channels = _constraints(world)
    given = (
        AstNode(op="AND", args=tuple(constraint_nodes), return_type="boolean")
        if constraint_nodes
        else lit(True, return_type="boolean")
    )
    program_tree = AstNode(op="SOLVE", args=(goal_node, given), return_type="value")
    referent = AstNode(
        op="SELECT_ENTITY", args=(ref(target_id, return_type=target_kind),), return_type="entity"
    )

    program = typecheck(
        Program(
            dsl=DSL,
            program=program_tree,
            base_id=item.base_id,
            question_sha256=item.question_sha256,
            choices_sha256=item.choices_sha256,
            compile_status="compiled",
            referent_selector=referent,
            required_referent_cardinality=1,
            constraint_channels=tuple(constraint_channels),
        ),
        world=world,
    )
    return replace(program, canonical_program_sha256=canonical_program_sha256(program, world=world))


# --- goal + constraint builders -------------------------------------------


def _goal_target(goal_type: Any, entities: list[dict[str, Any]]) -> tuple[str | None, str | None]:
    """Resolve the (target entity id, goal op) for a goal type; (None, None) if ambiguous."""
    if goal_type == "find_angle":
        return _unique_entity(entities, "angle"), "MEASURE"
    if goal_type == "find_length":
        return _unique_entity(entities, "segment"), "FIND"
    return None, None


def _unique_entity(entities: list[dict[str, Any]], kind: str) -> str | None:
    matches = [
        str(e["id"])
        for e in entities
        if isinstance(e, dict) and e.get("id") and str(e["id"]).startswith(f"{kind}:")
    ]
    return matches[0] if len(matches) == 1 else None


def _constraints(world: World) -> tuple[list[AstNode], list[tuple[str, str]]]:
    """Build typed boolean nodes for each world constraint + (key, channel) provenance."""
    nodes: list[AstNode] = []
    channels: list[tuple[str, str]] = []
    for c in world.get("constraints", []) or []:
        if not isinstance(c, dict) or not c.get("predicate"):
            continue
        args = tuple(_constraint_arg(a) for a in c.get("args", []))
        nodes.append(AstNode(op=str(c["predicate"]), args=args, return_type="boolean"))
        key = f"{c['predicate']}({','.join(str(a) for a in c.get('args', []))})"
        channels.append((key, str(c.get("channel", "text"))))
    return nodes, sorted(channels, key=lambda kc: kc[0])


def _constraint_arg(raw: Any) -> AstNode:
    """One constraint operand: an entity REF (``point:A``) or a literal (number/string)."""
    text = str(raw)
    if ":" in text:
        return ref(text, return_type=text.split(":", 1)[0])
    try:
        Fraction(text)
    except (ValueError, ZeroDivisionError):
        return lit(text, return_type="string")
    return lit(text, return_type="number")


def _unsupported(item: NormalizedItem, reason: str) -> Program:
    return Program(
        dsl=DSL,
        program=_UNSUPPORTED_NODE,
        base_id=item.base_id,
        question_sha256=item.question_sha256,
        choices_sha256=item.choices_sha256,
        compile_status="unsupported",
        reason_code=reason,
    )


__all__ = [
    "ALIASES",
    "COMMUTATIVE_OPS",
    "DSL",
    "IDENTITY_CASTS",
    "SIGNATURES",
    "compile_geometry3k",
]