| """Canonical semantic state, native restoration and offline BFS for MiniGrid v1. |
| |
| Grid encoding is MiniGrid's x-major [type, color, state] integer encoding. |
| The five permitted actions are deterministic: RNG state is not decision state. |
| Task identity hashes the complete initial state; split identity omits only direction. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import copy |
| import hashlib |
| import json |
| from collections import deque |
|
|
| import numpy as np |
|
|
| PROTOCOL = "minigrid-doorkey-8x8-h64-v1" |
| STATE_SCHEMA = "minigrid-semantic-state-v1" |
| ENV_ID = "MiniGrid-DoorKey-8x8-v0" |
| MINIGRID_VERSION = "3.0.0" |
| GYMNASIUM_VERSION = "1.2.3" |
| MISSION = "use the key to open the door and then get to the goal" |
| MAX_STEPS = 64 |
|
|
|
|
| def canonical_json(value): |
| return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False) |
|
|
|
|
| def digest(value): |
| return hashlib.sha256(canonical_json(value).encode("utf-8")).hexdigest() |
|
|
|
|
| def new_env(): |
| import gymnasium as gym |
| import minigrid |
| from minigrid.wrappers import RGBImgObsWrapper |
|
|
| if minigrid.__version__ != MINIGRID_VERSION or gym.__version__ != GYMNASIUM_VERSION: |
| raise RuntimeError(f"MiniGrid v1 requires minigrid=={MINIGRID_VERSION}, gymnasium=={GYMNASIUM_VERSION}") |
| return RGBImgObsWrapper(gym.make(ENV_ID, max_steps=MAX_STEPS, highlight=False, render_mode="rgb_array").unwrapped, tile_size=56) |
|
|
|
|
| def snapshot(env): |
| base = env.unwrapped |
| return { |
| "schema": STATE_SCHEMA, |
| "env_id": ENV_ID, |
| "mission": base.mission, |
| "width": base.width, |
| "height": base.height, |
| "max_steps": int(base.max_steps), |
| "step_count": int(base.step_count), |
| "grid": base.grid.encode().tolist(), |
| "agent_pos": [int(x) for x in base.agent_pos], |
| "agent_dir": int(base.agent_dir), |
| "carrying": list(base.carrying.encode()) if base.carrying is not None else None, |
| } |
|
|
|
|
| def validate_state(state, *, initial=False): |
| from minigrid.core.constants import COLOR_TO_IDX, OBJECT_TO_IDX |
| from minigrid.core.grid import Grid |
|
|
| required = {"schema", "env_id", "mission", "width", "height", "max_steps", "step_count", "grid", "agent_pos", "agent_dir", "carrying"} |
| if set(state) != required or state["schema"] != STATE_SCHEMA or state["env_id"] != ENV_ID or state["mission"] != MISSION: |
| raise ValueError("Incompatible MiniGrid semantic schema/mission") |
| if (state["width"], state["height"], state["max_steps"]) != (8, 8, 64): |
| raise ValueError("MiniGrid fairness requires 8x8 and horizon 64") |
| scalars = [*state["agent_pos"], state["agent_dir"], state["step_count"]] |
| if len(state["agent_pos"]) != 2 or any(type(v) is not int for v in scalars): |
| raise ValueError("MiniGrid state coordinates and counters must be integers") |
| if state["agent_dir"] not in range(4) or not 0 <= state["step_count"] <= 64 or (initial and state["step_count"] != 0): |
| raise ValueError("Invalid direction or step count") |
| array = np.asarray(state["grid"]) |
| if array.shape != (8, 8, 3) or array.dtype.kind not in "iu" or np.any(array < 0) or np.any(array > 255): |
| raise ValueError("Invalid MiniGrid grid encoding") |
| allowed = [OBJECT_TO_IDX[x] for x in ("empty", "wall", "door", "key", "goal")] |
| if not np.isin(array[:, :, 0], allowed).all(): |
| raise ValueError("Unexpected object type") |
| grid, _ = Grid.decode(array.astype(np.uint8)) |
| if not np.array_equal(grid.encode(), array): |
| raise ValueError("Noncanonical object encoding") |
| if np.any(array[[0, -1], :, 0] != OBJECT_TO_IDX["wall"]) or np.any(array[:, [0, -1], 0] != OBJECT_TO_IDX["wall"]): |
| raise ValueError("Missing boundary walls") |
| doors = np.argwhere(array[:, :, 0] == OBJECT_TO_IDX["door"]) |
| keys = np.argwhere(array[:, :, 0] == OBJECT_TO_IDX["key"]) |
| goals = np.argwhere(array[:, :, 0] == OBJECT_TO_IDX["goal"]) |
| carrying = state["carrying"] |
| if len(doors) != 1 or len(goals) != 1 or len(keys) + (carrying is not None) != 1: |
| raise ValueError("DoorKey requires one door, goal, and key") |
| if carrying is not None and carrying != [OBJECT_TO_IDX["key"], COLOR_TO_IDX["yellow"], 0]: |
| raise ValueError("Only yellow key inventory is supported") |
| for x, y in [*doors, *keys]: |
| if array[x, y, 1] != COLOR_TO_IDX["yellow"]: |
| raise ValueError("Door and key must be yellow") |
| x, y = state["agent_pos"] |
| if not (0 < x < 7 and 0 < y < 7): |
| raise ValueError("Agent is outside interior") |
| cell = grid.get(x, y) |
| if cell is not None and not cell.can_overlap(): |
| raise ValueError("Agent overlaps a blocked cell") |
| if initial and (carrying is not None or array[tuple(doors[0])][2] != 2 or (cell is not None and cell.type == "goal")): |
| raise ValueError("Initial DoorKey state must be unsolved, locked and empty-handed") |
|
|
|
|
| def restore(env, state, *, validate=True): |
| from minigrid.core.grid import Grid |
| from minigrid.core.world_object import WorldObj |
|
|
| if validate: |
| validate_state(state) |
| base = env.unwrapped |
| base.grid, _ = Grid.decode(np.asarray(state["grid"], dtype=np.uint8)) |
| base.agent_pos = np.asarray(state["agent_pos"], dtype=int) |
| base.agent_dir = state["agent_dir"] |
| base.carrying = WorldObj.decode(*state["carrying"]) if state["carrying"] else None |
| base.step_count = state["step_count"] |
| base.max_steps = state["max_steps"] |
| base.mission = state["mission"] |
|
|
|
|
| def task_id(state): |
| return digest(state) |
|
|
|
|
| def split_group_id(state): |
| return digest({k: v for k, v in state.items() if k != "agent_dir"}) |
|
|
|
|
| def decision_key(task, state): |
| return canonical_json({"task_id": task, "state": state}) |
|
|
|
|
| def validate_task(row, *, split=None): |
| if row.get("metadata", {}).get("protocol") != PROTOCOL: |
| raise ValueError("Incompatible MiniGrid task protocol") |
| validate_state(row["initial_state"], initial=True) |
| metadata = row["metadata"] |
| if metadata.get("task_id") != task_id(row["initial_state"]) or metadata.get("split_group_id") != split_group_id(row["initial_state"]): |
| raise ValueError("MiniGrid task content hash mismatch") |
| if split is not None and metadata.get("split") != split: |
| raise ValueError("MiniGrid split mismatch") |
| if not isinstance(metadata.get("shortest_length"), int) or not 1 <= metadata["shortest_length"] <= 64: |
| raise ValueError("Unreachable or unverified MiniGrid task") |
|
|
|
|
| def shortest_solution(env, initial): |
| """BFS transitions use MiniGrid's actual step, including native turn/toggle. |
| |
| The visited key excludes elapsed time: BFS first reaches each physical state |
| with the greatest remaining budget. A longer duplicate cannot improve reachability. |
| Restore mutates only dynamic fields here; walls/goal are constant for a task. |
| """ |
| from minigrid.core.world_object import Key |
|
|
| restore(env, initial) |
| base = env.unwrapped |
| door_pos = next((x, y) for x in range(8) for y in range(8) if (base.grid.get(x, y) is not None and base.grid.get(x, y).type == "door")) |
| key_pos = next((x, y) for x in range(8) for y in range(8) if (base.grid.get(x, y) is not None and base.grid.get(x, y).type == "key")) |
| door = base.grid.get(*door_pos) |
| key_obj = Key("yellow") |
| start = (*initial["agent_pos"], initial["agent_dir"], False, 2) |
| queue = deque([(start, ())]) |
| seen = {start} |
| for_state = (0, 1, 2, 3, 5) |
| while queue: |
| current, path = queue.popleft() |
| if len(path) >= 64: |
| continue |
| for action in for_state: |
| x, y, direction, held, door_state = current |
| base.agent_pos = np.array([x, y]) |
| base.agent_dir = direction |
| base.carrying = key_obj if held else None |
| base.grid.set(*key_pos, None if held else key_obj) |
| door.is_open = door_state == 0 |
| door.is_locked = door_state == 2 |
| base.step_count = len(path) |
| |
| _, reward, terminated, _, _ = base.step(action) |
| next_path = path + (action,) |
| if terminated and reward > 0: |
| restore(env, initial, validate=False) |
| return next_path |
| following = (*map(int, base.agent_pos), int(base.agent_dir), base.carrying is not None, int(door.encode()[2])) |
| if following not in seen: |
| seen.add(following) |
| queue.append((following, next_path)) |
| restore(env, initial, validate=False) |
| return None |
|
|
|
|
| class TaskSampler: |
| """Private, checkpointable task sampler, independent of validation/global RNG.""" |
|
|
| def __init__(self, rows, seed): |
| self.rows = rows |
| self.rng = np.random.RandomState(seed) |
| self.draws = 0 |
| self.pool_hash = digest([r["metadata"]["task_id"] for r in rows]) |
|
|
| def sample(self, count): |
| indices = self.rng.choice(len(self.rows), size=count, replace=False) |
| self.draws += count |
| return [self.rows[i] for i in indices] |
|
|
| def state_dict(self): |
| return {"schema": "minigrid-task-sampler-v1", "pool_hash": self.pool_hash, "draws": self.draws, "rng": copy.deepcopy(self.rng.get_state())} |
|
|
| def load_state_dict(self, state): |
| if state["schema"] != "minigrid-task-sampler-v1" or state["pool_hash"] != self.pool_hash: |
| raise ValueError("Sampler checkpoint does not match the pinned MiniGrid task pool") |
| self.rng.set_state(state["rng"]) |
| self.draws = int(state["draws"]) |
|
|
