code/oat_drgrpo/maze_modebench.py

"""Verified language action programs for PointMaze and AntMaze.

This module is deliberately simulator-independent. It validates the trusted
episode specification, parses the LM's finite action alphabet, and derives a
topological route key from a hash-bound successful execution record. MuJoCo
remains outside the trainer process; its worker must return the trajectory and
environment hashes consumed here.
"""

from __future__ import annotations

from dataclasses import dataclass
import hashlib
import json
import math
import re
from typing import Any, Mapping, Sequence


POINT_MAZE_VERIFIER = "point_maze_action_program"
ANT_MAZE_VERIFIER = "ant_maze_action_program"
MAZE_ACTION_VERSION = "maze-action-v1"
ANT_MAZE_ACTION_VERSION = "maze-action-ant-v5"

POINT_ACTIONS = ("N", "NE", "E", "SE", "S", "SW", "W", "NW", "COAST")
ANT_ACTIONS = ("N", "NE", "E", "SE", "S", "SW", "W", "NW")

_SHA256 = re.compile(r"[0-9a-f]{64}")
_IDENTIFIER = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,95}")
_GATE_ID = re.compile(r"[a-z][a-z0-9_-]{0,31}")
_MAX_PROGRAM_CHARS = 4096


class MazeModeBenchError(ValueError):
    """Raised when a trusted maze spec or execution record is invalid."""


@dataclass(frozen=True)
class DirectedGate:
    gate_id: str
    axis: str
    coordinate: float
    span_min: float
    span_max: float
    hysteresis: float


@dataclass(frozen=True)
class MazeActionSpec:
    verifier: str
    environment_id: str
    environment_sha256: str
    controller_sha256: str | None
    map_id: str
    maze_map: tuple[tuple[int, ...], ...]
    reset_cell: tuple[int, int]
    goal_cell: tuple[int, int]
    reset_seed: int
    min_actions: int
    max_actions: int
    action_repeat: int
    action_tokens: tuple[str, ...]
    success_threshold: float
    max_segment_length: float
    bounds: tuple[tuple[float, float], tuple[float, float]]
    gates: tuple[DirectedGate, ...]
    spec_sha256: str


@dataclass(frozen=True)
class MazeExecutionRecord:
    environment_sha256: str
    controller_sha256: str | None
    spec_sha256: str
    reset_seed: int
    action_tokens: tuple[str, ...]
    success: bool
    final_goal_distance: float
    trajectory_xy: tuple[tuple[float, float], ...]
    simulator_steps: int


@dataclass(frozen=True)
class MazeValidation:
    canonical_key: str
    directed_gates: tuple[str, ...]
    action_tokens: tuple[str, ...]
    simulator_steps: int


def _finite_float(value: Any, *, label: str) -> float:
    if isinstance(value, bool) or not isinstance(value, (int, float)):
        raise MazeModeBenchError(f"{label} must be a finite number")
    result = float(value)
    if not math.isfinite(result):
        raise MazeModeBenchError(f"{label} must be a finite number")
    return result


def _bounded_int(value: Any, *, label: str, minimum: int, maximum: int) -> int:
    if isinstance(value, bool) or not isinstance(value, int):
        raise MazeModeBenchError(f"{label} must be an integer")
    result = int(value)
    if not minimum <= result <= maximum:
        raise MazeModeBenchError(f"{label} is outside [{minimum}, {maximum}]")
    return result


def _sha(value: Any, *, label: str) -> str:
    result = str(value)
    if _SHA256.fullmatch(result) is None:
        raise MazeModeBenchError(f"{label} must be a lowercase SHA-256")
    return result


def _canonical_spec_sha256(spec: Mapping[str, Any]) -> str:
    payload = dict(spec)
    claimed = payload.pop("spec_sha256", None)
    canonical = json.dumps(
        payload,
        allow_nan=False,
        ensure_ascii=True,
        separators=(",", ":"),
        sort_keys=True,
    ).encode("ascii")
    observed = hashlib.sha256(canonical).hexdigest()
    if claimed is not None and claimed != observed:
        raise MazeModeBenchError("spec_sha256 does not match the canonical spec")
    return observed


def _parse_bounds(value: Any) -> tuple[tuple[float, float], tuple[float, float]]:
    if not isinstance(value, list) or len(value) != 2:
        raise MazeModeBenchError("bounds_xy must contain x and y bounds")
    parsed: list[tuple[float, float]] = []
    for index, raw in enumerate(value):
        if not isinstance(raw, list) or len(raw) != 2:
            raise MazeModeBenchError(f"bounds_xy[{index}] must contain two values")
        low = _finite_float(raw[0], label=f"bounds_xy[{index}][0]")
        high = _finite_float(raw[1], label=f"bounds_xy[{index}][1]")
        if low >= high:
            raise MazeModeBenchError("each coordinate bound must be increasing")
        parsed.append((low, high))
    return parsed[0], parsed[1]


def _parse_gates(value: Any) -> tuple[DirectedGate, ...]:
    if not isinstance(value, list) or not 1 <= len(value) <= 32:
        raise MazeModeBenchError("route_gates must contain between 1 and 32 gates")
    gates: list[DirectedGate] = []
    observed: set[str] = set()
    for index, raw in enumerate(value):
        if not isinstance(raw, Mapping):
            raise MazeModeBenchError(f"route gate {index} must be an object")
        gate_id = str(raw.get("id", ""))
        if _GATE_ID.fullmatch(gate_id) is None:
            raise MazeModeBenchError(f"route gate {index} has an invalid id")
        if gate_id in observed:
            raise MazeModeBenchError(f"duplicate route gate id {gate_id!r}")
        observed.add(gate_id)
        axis = str(raw.get("axis", ""))
        if axis not in {"x", "y"}:
            raise MazeModeBenchError(f"route gate {gate_id!r} has invalid axis")
        coordinate = _finite_float(raw.get("coordinate"), label=f"{gate_id}.coordinate")
        raw_span = raw.get("span")
        if not isinstance(raw_span, list) or len(raw_span) != 2:
            raise MazeModeBenchError(f"route gate {gate_id!r} needs a span")
        span_min = _finite_float(raw_span[0], label=f"{gate_id}.span[0]")
        span_max = _finite_float(raw_span[1], label=f"{gate_id}.span[1]")
        if span_min >= span_max:
            raise MazeModeBenchError(f"route gate {gate_id!r} span is not increasing")
        hysteresis = _finite_float(raw.get("hysteresis"), label=f"{gate_id}.hysteresis")
        if not 0.0 < hysteresis <= 0.25:
            raise MazeModeBenchError(f"route gate {gate_id!r} hysteresis is invalid")
        gates.append(
            DirectedGate(
                gate_id=gate_id,
                axis=axis,
                coordinate=coordinate,
                span_min=span_min,
                span_max=span_max,
                hysteresis=hysteresis,
            )
        )
    return tuple(gates)


def _parse_maze_map(
    value: Any,
    reset_cell_value: Any,
    goal_cell_value: Any,
) -> tuple[tuple[tuple[int, ...], ...], tuple[int, int], tuple[int, int]]:
    if not isinstance(value, list) or not 5 <= len(value) <= 16:
        raise MazeModeBenchError("maze_map must contain between 5 and 16 rows")
    width = len(value[0]) if isinstance(value[0], list) else 0
    if not 5 <= width <= 16:
        raise MazeModeBenchError("maze_map must contain between 5 and 16 columns")
    rows: list[tuple[int, ...]] = []
    for index, raw_row in enumerate(value):
        if (
            not isinstance(raw_row, list)
            or len(raw_row) != width
            or any(isinstance(cell, bool) or cell not in {0, 1} for cell in raw_row)
        ):
            raise MazeModeBenchError(f"maze_map row {index} is malformed")
        rows.append(tuple(int(cell) for cell in raw_row))
    if any(cell != 1 for cell in rows[0] + rows[-1]):
        raise MazeModeBenchError("maze_map top and bottom borders must be walls")
    if any(row[0] != 1 or row[-1] != 1 for row in rows):
        raise MazeModeBenchError("maze_map left and right borders must be walls")

    def parse_cell(raw: Any, label: str) -> tuple[int, int]:
        if (
            not isinstance(raw, list)
            or len(raw) != 2
            or any(isinstance(item, bool) or not isinstance(item, int) for item in raw)
        ):
            raise MazeModeBenchError(f"{label} must be a [row, column] integer pair")
        cell = int(raw[0]), int(raw[1])
        if not (0 <= cell[0] < len(rows) and 0 <= cell[1] < width):
            raise MazeModeBenchError(f"{label} is outside maze_map")
        if rows[cell[0]][cell[1]] != 0:
            raise MazeModeBenchError(f"{label} must select a free maze cell")
        return cell

    reset_cell = parse_cell(reset_cell_value, "reset_cell")
    goal_cell = parse_cell(goal_cell_value, "goal_cell")
    if reset_cell == goal_cell:
        raise MazeModeBenchError("reset_cell and goal_cell must differ")
    return tuple(rows), reset_cell, goal_cell


def parse_maze_action_spec(spec: Mapping[str, Any]) -> MazeActionSpec:
    """Parse one trusted PointMaze or AntMaze action-program specification."""

    if not isinstance(spec, Mapping):
        raise MazeModeBenchError("maze spec must be an object")
    verifier = str(spec.get("verifier", ""))
    if verifier not in {POINT_MAZE_VERIFIER, ANT_MAZE_VERIFIER}:
        raise MazeModeBenchError("wrong maze action-program verifier")
    expected_version = (
        MAZE_ACTION_VERSION
        if verifier == POINT_MAZE_VERIFIER
        else ANT_MAZE_ACTION_VERSION
    )
    if spec.get("maze_action_version") != expected_version:
        raise MazeModeBenchError("unsupported maze action-program version")
    environment_id = str(spec.get("environment_id", ""))
    if _IDENTIFIER.fullmatch(environment_id) is None:
        raise MazeModeBenchError("environment_id is invalid")
    expected_prefix = "PointMaze" if verifier == POINT_MAZE_VERIFIER else "AntMaze"
    if not environment_id.startswith(expected_prefix):
        raise MazeModeBenchError("environment_id does not match the verifier")
    map_id = str(spec.get("map_id", ""))
    if _IDENTIFIER.fullmatch(map_id) is None:
        raise MazeModeBenchError("map_id is invalid")

    expected_actions = POINT_ACTIONS if verifier == POINT_MAZE_VERIFIER else ANT_ACTIONS
    raw_actions = spec.get("action_tokens")
    if not isinstance(raw_actions, list) or tuple(raw_actions) != expected_actions:
        raise MazeModeBenchError("action_tokens differ from the frozen verifier alphabet")

    environment_sha256 = _sha(spec.get("environment_sha256"), label="environment_sha256")
    raw_controller = spec.get("controller_sha256")
    if verifier == ANT_MAZE_VERIFIER:
        controller_sha256 = _sha(raw_controller, label="controller_sha256")
    else:
        if raw_controller is not None:
            raise MazeModeBenchError("PointMaze cannot declare a locomotion controller")
        controller_sha256 = None

    min_actions = _bounded_int(
        spec.get("min_actions"), label="min_actions", minimum=1, maximum=512
    )
    max_actions = _bounded_int(
        spec.get("max_actions"), label="max_actions", minimum=min_actions, maximum=512
    )
    action_repeat = _bounded_int(
        spec.get("action_repeat"),
        label="action_repeat",
        minimum=1,
        maximum=100 if verifier == POINT_MAZE_VERIFIER else 400,
    )
    success_threshold = _finite_float(
        spec.get("success_threshold"), label="success_threshold"
    )
    if not 0.0 < success_threshold <= 1.0:
        raise MazeModeBenchError("success_threshold is outside (0, 1]")
    max_segment_length = _finite_float(
        spec.get("max_segment_length"), label="max_segment_length"
    )
    if not 0.0 < max_segment_length <= 10.0:
        raise MazeModeBenchError("max_segment_length is outside (0, 10]")

    maze_map, reset_cell, goal_cell = _parse_maze_map(
        spec.get("maze_map"),
        spec.get("reset_cell"),
        spec.get("goal_cell"),
    )

    return MazeActionSpec(
        verifier=verifier,
        environment_id=environment_id,
        environment_sha256=environment_sha256,
        controller_sha256=controller_sha256,
        map_id=map_id,
        maze_map=maze_map,
        reset_cell=reset_cell,
        goal_cell=goal_cell,
        reset_seed=_bounded_int(
            spec.get("reset_seed"), label="reset_seed", minimum=0, maximum=2**31 - 1
        ),
        min_actions=min_actions,
        max_actions=max_actions,
        action_repeat=action_repeat,
        action_tokens=expected_actions,
        success_threshold=success_threshold,
        max_segment_length=max_segment_length,
        bounds=_parse_bounds(spec.get("bounds_xy")),
        gates=_parse_gates(spec.get("route_gates")),
        spec_sha256=_canonical_spec_sha256(spec),
    )


def parse_maze_action_program(candidate: str, spec: MazeActionSpec) -> tuple[str, ...]:
    """Parse a bounded whitespace/comma-separated action program."""

    text = str(candidate).strip()
    if not text or len(text) > _MAX_PROGRAM_CHARS:
        raise MazeModeBenchError("action program is empty or too long")
    tokens = tuple(token for token in re.split(r"[\s,]+", text.upper()) if token)
    if not spec.min_actions <= len(tokens) <= spec.max_actions:
        raise MazeModeBenchError("action program length is outside the frozen bounds")
    allowed = set(spec.action_tokens)
    unknown = [token for token in tokens if token not in allowed]
    if unknown:
        raise MazeModeBenchError(f"unknown action token {unknown[0]!r}")
    return tokens


def _parse_execution_record(value: Mapping[str, Any]) -> MazeExecutionRecord:
    if not isinstance(value, Mapping):
        raise MazeModeBenchError("execution record must be an object")
    raw_trajectory = value.get("trajectory_xy")
    if not isinstance(raw_trajectory, list) or len(raw_trajectory) < 2:
        raise MazeModeBenchError("execution trajectory must contain at least two points")
    trajectory: list[tuple[float, float]] = []
    for index, raw_point in enumerate(raw_trajectory):
        if not isinstance(raw_point, list) or len(raw_point) != 2:
            raise MazeModeBenchError(f"trajectory point {index} is malformed")
        trajectory.append(
            (
                _finite_float(raw_point[0], label=f"trajectory[{index}].x"),
                _finite_float(raw_point[1], label=f"trajectory[{index}].y"),
            )
        )
    raw_success = value.get("success")
    if not isinstance(raw_success, bool):
        raise MazeModeBenchError("execution success must be boolean")
    raw_tokens = value.get("action_tokens")
    if not isinstance(raw_tokens, list) or not all(isinstance(x, str) for x in raw_tokens):
        raise MazeModeBenchError("execution action_tokens must be a string list")
    raw_controller = value.get("controller_sha256")
    controller_sha256 = None if raw_controller is None else _sha(
        raw_controller, label="execution.controller_sha256"
    )
    return MazeExecutionRecord(
        environment_sha256=_sha(
            value.get("environment_sha256"), label="execution.environment_sha256"
        ),
        controller_sha256=controller_sha256,
        spec_sha256=_sha(value.get("spec_sha256"), label="execution.spec_sha256"),
        reset_seed=_bounded_int(
            value.get("reset_seed"),
            label="execution.reset_seed",
            minimum=0,
            maximum=2**31 - 1,
        ),
        action_tokens=tuple(raw_tokens),
        success=raw_success,
        final_goal_distance=_finite_float(
            value.get("final_goal_distance"), label="execution.final_goal_distance"
        ),
        trajectory_xy=tuple(trajectory),
        simulator_steps=_bounded_int(
            value.get("simulator_steps"),
            label="execution.simulator_steps",
            minimum=1,
            maximum=1_000_000,
        ),
    )


def _outside_side(value: float, gate: DirectedGate) -> int:
    if value < gate.coordinate - gate.hysteresis:
        return -1
    if value > gate.coordinate + gate.hysteresis:
        return 1
    return 0


def _gate_crossing(
    first: tuple[float, float],
    second: tuple[float, float],
    gate: DirectedGate,
) -> str | None:
    axis_index = 0 if gate.axis == "x" else 1
    span_index = 1 - axis_index
    denominator = second[axis_index] - first[axis_index]
    if denominator == 0.0:
        return None
    fraction = (gate.coordinate - first[axis_index]) / denominator
    if not 0.0 <= fraction <= 1.0:
        return None
    span_value = first[span_index] + fraction * (
        second[span_index] - first[span_index]
    )
    if not gate.span_min <= span_value <= gate.span_max:
        return None
    direction = "+" if second[axis_index] > first[axis_index] else "-"
    return f"{gate.gate_id}{direction}"


def extract_directed_gate_route(
    trajectory_xy: Sequence[tuple[float, float]],
    spec: MazeActionSpec,
) -> tuple[str, ...]:
    """Extract a hysteresis-stable ordered directed bottleneck sequence."""

    if len(trajectory_xy) < 2:
        raise MazeModeBenchError("trajectory is too short")
    if len(trajectory_xy) > spec.max_actions * spec.action_repeat + 2:
        raise MazeModeBenchError("trajectory exceeds the frozen execution horizon")
    for index, point in enumerate(trajectory_xy):
        if not (
            spec.bounds[0][0] <= point[0] <= spec.bounds[0][1]
            and spec.bounds[1][0] <= point[1] <= spec.bounds[1][1]
        ):
            raise MazeModeBenchError(f"trajectory point {index} is outside maze bounds")
        if index:
            previous = trajectory_xy[index - 1]
            distance = math.hypot(point[0] - previous[0], point[1] - previous[1])
            if distance > spec.max_segment_length:
                raise MazeModeBenchError("trajectory contains a teleport-sized segment")

    route: list[str] = []
    state: dict[str, tuple[int, tuple[float, float]] | None] = {
        gate.gate_id: None for gate in spec.gates
    }
    for point in trajectory_xy:
        step_crossings: list[str] = []
        for gate in spec.gates:
            coordinate = point[0] if gate.axis == "x" else point[1]
            side = _outside_side(coordinate, gate)
            previous_state = state[gate.gate_id]
            if side == 0:
                continue
            if previous_state is None:
                state[gate.gate_id] = (side, point)
                continue
            previous_side, previous_point = previous_state
            if side != previous_side:
                crossing = _gate_crossing(previous_point, point, gate)
                if crossing is not None:
                    step_crossings.append(crossing)
            state[gate.gate_id] = (side, point)
        if len(step_crossings) > 1:
            raise MazeModeBenchError("one trajectory segment crosses multiple route gates")
        if step_crossings and (not route or route[-1] != step_crossings[0]):
            route.append(step_crossings[0])
    if not route:
        raise MazeModeBenchError("successful trajectory has no certified route gate")
    gate_ids = [crossing[:-1] for crossing in route]
    if len(gate_ids) != len(set(gate_ids)):
        raise MazeModeBenchError("trajectory recrosses a route gate")
    return tuple(route)


def validate_maze_execution(
    candidate: str,
    raw_spec: Mapping[str, Any],
    raw_execution: Mapping[str, Any],
) -> MazeValidation:
    """Bind one successful simulator execution to its semantic route key."""

    spec = parse_maze_action_spec(raw_spec)
    tokens = parse_maze_action_program(candidate, spec)
    execution = _parse_execution_record(raw_execution)
    if execution.environment_sha256 != spec.environment_sha256:
        raise MazeModeBenchError("execution environment hash does not match the spec")
    if execution.controller_sha256 != spec.controller_sha256:
        raise MazeModeBenchError("execution controller hash does not match the spec")
    if execution.spec_sha256 != spec.spec_sha256:
        raise MazeModeBenchError("execution is bound to a different spec")
    if execution.reset_seed != spec.reset_seed:
        raise MazeModeBenchError("execution reset seed does not match the spec")
    if execution.action_tokens != tokens:
        raise MazeModeBenchError("execution action program does not match the candidate")
    if not execution.success:
        raise MazeModeBenchError("unsuccessful execution has no ModeBench identity")
    if not 0.0 <= execution.final_goal_distance <= spec.success_threshold:
        raise MazeModeBenchError("successful execution fails the frozen goal threshold")
    if execution.simulator_steps > len(tokens) * spec.action_repeat:
        raise MazeModeBenchError("execution exceeds the action-program step budget")
    route = extract_directed_gate_route(execution.trajectory_xy, spec)
    action_version = (
        MAZE_ACTION_VERSION
        if spec.verifier == POINT_MAZE_VERIFIER
        else ANT_MAZE_ACTION_VERSION
    )
    key = f"{spec.verifier}:{action_version}:{spec.map_id}:" + ",".join(route)
    return MazeValidation(
        canonical_key=key,
        directed_gates=route,
        action_tokens=tokens,
        simulator_steps=execution.simulator_steps,
    )