| """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, |
| ) |
|
|
