[auto-memory content redacted for sharing]

[auto-memory content redacted for sharing]

[auto-memory content redacted for sharing]

[auto-memory content redacted for sharing]

# maze_thinking — STATUS

**Read this first in any new session.**

## What this is
Free-choice round of David's automating-ML-research experiment (started 2026-07-12).
Question: can a weight-tied *recurrent* CNN, trained to mark the shortest path in small
mazes, use extra test-time iterations ("thinking longer") to solve larger mazes than it
was trained on — and how does that compare to fixed-depth CNNs?

Planned comparison: FixedCNN (a few depths) vs RecurrentCNN without input recall vs
RecurrentCNN with recall (input re-fed every iteration). Then one novel twist chosen
based on results. Deliverables: writeup + self-contained interactive HTML viz
(maze picker + thinking-steps slider). Twice-reviewed (code + writeup by independent
subagents) before done.

## Ground rules
- Toy scale, CPU only. Shared venv: `D:\claude_code\ml_venv\Scripts\python.exe`
  (torch 2.13.0+cpu, numpy 2.5.1). No new packages without asking David.
- No third-party code. Interactive viz = vanilla JS + baked-in JSON, no CDN.
- Budget target ~$5-ish for the round.

## Design decisions
- Perfect mazes (spanning tree) on c×c cell lattice via iterative randomized DFS,
  rendered to (2c+1)×(2c+1) binary images (1=wall). Corridor pixels of a perfect maze
  form a tree ⇒ the start→goal path is unique, so "shortest path" = exact-match target.
- Input: 3 channels (walls, start one-hot, goal one-hot). Target: binary path mask
  (BFS in image space, includes endpoints). Loss: per-pixel BCE.
- Metrics: pixel accuracy and **solved rate** (thresholded prediction exactly equals
  the target mask).
- Train size: c=6 (13×13 images); extrapolation tests up to c=16 (33×33).
- Datasets deduped by hash of (walls,start,goal); test splits disjoint from train.

## State
- Phase 1 (pipeline + sanity): IN PROGRESS.

## Log
- 2026-07-12: project started, scaffold created.

File created successfully at: D:\claude_code\maze_thinking\STATUS.md (file state is current in your context — no need to Read it back)

"""Maze generation and shortest-path ground truth.

Mazes are "perfect" (spanning-tree) mazes on a c x c cell lattice, generated by
iterative randomized DFS and rendered to (2c+1) x (2c+1) binary images where
1 = wall, 0 = corridor. Cell (r, c) sits at image pixel (2r+1, 2c+1); carving a
passage between adjacent cells clears the pixel between them.

Because the corridor pixels of a perfect maze form a tree, the path between any
two cells is unique, so the shortest path (found by BFS in image space) is an
unambiguous exact-match training target.
"""

import argparse
import hashlib
from collections import deque

import numpy as np


def generate_maze(c: int, rng: np.random.Generator) -> np.ndarray:
    """Return a (2c+1, 2c+1) uint8 image, 1 = wall."""
    s = 2 * c + 1
    img = np.ones((s, s), dtype=np.uint8)
    visited = np.zeros((c, c), dtype=bool)
    r0, c0 = rng.integers(c), rng.integers(c)
    visited[r0, c0] = True
    img[2 * r0 + 1, 2 * c0 + 1] = 0
    stack = [(r0, c0)]
    while stack:
        r, cc = stack[-1]
        neighbors = [
            (r + dr, cc + dc)
            for dr, dc in ((-1, 0), (1, 0), (0, -1), (0, 1))
            if 0 <= r + dr < c and 0 <= cc + dc < c and not visited[r + dr, cc + dc]
        ]
        if not neighbors:
            stack.pop()
            continue
        nr, nc = neighbors[rng.integers(len(neighbors))]
        visited[nr, nc] = True
        img[2 * nr + 1, 2 * nc + 1] = 0
        img[r + nr + 1, cc + nc + 1] = 0  # pixel between the two cells
        stack.append((nr, nc))
    return img


def shortest_path_mask(walls: np.ndarray, start_px: tuple, goal_px: tuple) -> np.ndarray:
    """BFS over corridor pixels; returns uint8 mask of the unique path (incl. endpoints)."""
    s = walls.shape[0]
    parent = -np.ones((s, s, 2), dtype=np.int32)
    seen = np.zeros((s, s), dtype=bool)
    seen[start_px] = True
    q = deque([start_px])
    while q:
        r, c = q.popleft()
        if (r, c) == goal_px:
            break
        for dr, dc in ((-1, 0), (1, 0), (0, -1), (0, 1)):
            nr, nc = r + dr, c + dc
            if 0 <= nr < s and 0 <= nc < s and not seen[nr, nc] and walls[nr, nc] == 0:
                seen[nr, nc] = True
                parent[nr, nc] = (r, c)
                q.append((nr, nc))
    else:
        raise RuntimeError("goal unreachable — maze generation is broken")
    mask = np.zeros((s, s), dtype=np.uint8)
    r, c = goal_px
    while (r, c) != start_px:
        mask[r, c] = 1
        r, c = parent[r, c]
    mask[start_px] = 1
    return mask


def example_hash(walls: np.ndarray, start: tuple, goal: tuple) -> str:
    h = hashlib.sha1(walls.tobytes())
    h.update(bytes(list(start) + list(goal)))
    return h.hexdigest()


def build_dataset(n: int, c: int, seed: int, exclude_hashes: set | None = None):
    """Generate n unique examples. Returns (dict of arrays, set of hashes)."""
    rng = np.random.default_rng(seed)
    exclude = set(exclude_hashes) if exclude_hashes else set()
    hashes: set[str] = set()
    walls_l, path_l, start_l, goal_l = [], [], [], []
    attempts = 0
    while len(walls_l) < n:
        attempts += 1
        if attempts > 50 * n:
            raise RuntimeError(f"too many collisions generating c={c} dataset")
        walls = generate_maze(c, rng)
        cells = rng.choice(c * c, size=2, replace=False)
        start = (2 * (cells[0] // c) + 1, 2 * (cells[0] % c) + 1)
        goal = (2 * (cells[1] // c) + 1, 2 * (cells[1] % c) + 1)
        h = example_hash(walls, start, goal)
        if h in hashes or h in exclude:
            continue
        hashes.add(h)
        walls_l.append(walls)
        path_l.append(shortest_path_mask(walls, start, goal))
        start_l.append(start)
        goal_l.append(goal)
    data = {
        "walls": np.stack(walls_l),
        "path": np.stack(path_l),
        "start": np.array(start_l, dtype=np.int32),
        "goal": np.array(goal_l, dtype=np.int32),
    }
    return data, hashes


def to_input(walls: np.ndarray, start: np.ndarray, goal: np.ndarray) -> np.ndarray:
    """(N,s,s) walls + (N,2) start/goal -> (N,3,s,s) float32 model input."""
    n, s, _ = walls.shape
    x = np.zeros((n, 3, s, s), dtype=np.float32)
    x[:, 0] = walls
    idx = np.arange(n)
    x[idx, 1, start[:, 0], start[:, 1]] = 1.0
    x[idx, 2, goal[:, 0], goal[:, 1]] = 1.0
    return x


def ascii_maze(walls: np.ndarray, path: np.ndarray, start: tuple, goal: tuple) -> str:
    chars = np.where(walls == 1, "#", " ").astype(object)
    chars[path == 1] = "."
    chars[tuple(start)] = "S"
    chars[tuple(goal)] = "G"
    return "\n".join("".join(row) for row in chars)


if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("--preview", action="store_true", help="print a sample maze")
    ap.add_argument("--cells", type=int, default=6)
    ap.add_argument("--seed", type=int, default=0)
    args = ap.parse_args()
    if args.preview:
        data, _ = build_dataset(1, args.cells, args.seed)
        print(ascii_maze(data["walls"][0], data["path"][0], data["start"][0], data["goal"][0]))
        print(f"path length: {int(data['path'][0].sum())} pixels")

File created successfully at: D:\claude_code\maze_thinking\mazes.py (file state is current in your context — no need to Read it back)

"""Models: fixed-depth residual CNN vs weight-tied recurrent CNN (with/without recall).

All models are fully convolutional (3x3 convs, no pooling/padding tricks), so they
run on any maze size. Output is a single logit map over pixels; the target is the
shortest-path mask.
"""

import torch
import torch.nn as nn


def conv3(cin: int, cout: int) -> nn.Conv2d:
    return nn.Conv2d(cin, cout, kernel_size=3, padding=1, bias=False)


class ResBlock(nn.Module):
    def __init__(self, width: int):
        super().__init__()
        self.c1 = conv3(width, width)
        self.c2 = conv3(width, width)
        self.act = nn.ReLU()

    def forward(self, s):
        return self.act(s + self.c2(self.act(self.c1(s))))


class FixedCNN(nn.Module):
    """Encoder + `depth` residual blocks (untied weights) + head."""

    def __init__(self, width: int = 64, depth: int = 8):
        super().__init__()
        self.encode = nn.Sequential(conv3(3, width), nn.ReLU())
        self.blocks = nn.Sequential(*[ResBlock(width) for _ in range(depth)])
        self.head = nn.Conv2d(width, 1, kernel_size=3, padding=1)

    def forward(self, x, iters=None, return_all=False):
        out = self.head(self.blocks(self.encode(x)))
        return [out] if return_all else out


class RecurrentCNN(nn.Module):
    """Encoder + ONE residual block applied `iters` times (weights tied) + head.

    recall=True re-concatenates the raw 3-channel input to the state at every
    iteration, so the maze can't be forgotten as the state evolves.
    """

    def __init__(self, width: int = 64, recall: bool = True):
        super().__init__()
        self.recall = recall
        self.encode = nn.Sequential(conv3(3, width), nn.ReLU())
        cin = width + 3 if recall else width
        self.c1 = conv3(cin, width)
        self.c2 = conv3(width, width)
        self.act = nn.ReLU()
        self.head = nn.Conv2d(width, 1, kernel_size=3, padding=1)

    def step(self, s, x):
        inp = torch.cat([s, x], dim=1) if self.recall else s
        return self.act(s + self.c2(self.act(self.c1(inp))))

    def forward(self, x, iters: int = 20, return_all: bool = False):
        s = self.encode(x)
        outs = []
        for _ in range(iters):
            s = self.step(s, x)
            if return_all:
                outs.append(self.head(s))
        return outs if return_all else self.head(s)


def make_model(name: str, width: int, depth: int) -> nn.Module:
    if name == "fixed":
        return FixedCNN(width, depth)
    if name == "recurrent":
        return RecurrentCNN(width, recall=False)
    if name == "recall":
        return RecurrentCNN(width, recall=True)
    raise ValueError(name)


def count_params(model: nn.Module) -> int:
    return sum(p.numel() for p in model.parameters())

File created successfully at: D:\claude_code\maze_thinking\models.py (file state is current in your context — no need to Read it back)

"""Train one model on small mazes; log per-epoch metrics to JSON.

Datasets are generated on first use and cached in data/ as .npz, keyed by
(n, cells, seed). Train-set hashes are cached alongside so evaluation sets can
be generated disjoint from training data.
"""

import argparse
import json
import time
from pathlib import Path

import numpy as np
import torch
import torch.nn as nn

from mazes import build_dataset, to_input
from models import count_params, make_model

ROOT = Path(__file__).parent
DATA = ROOT / "data"
DATA.mkdir(exist_ok=True)


def get_dataset(n: int, cells: int, seed: int, exclude_hashes: set | None = None):
    """Load or generate a dataset. Returns (x, y, hashes)."""
    tag = f"n{n}_c{cells}_s{seed}"
    f = DATA / f"maze_{tag}.npz"
    if f.exists():
        z = np.load(f)
        data = {k: z[k] for k in ("walls", "path", "start", "goal")}
        hashes = set(z["hashes"].tolist())
    else:
        data, hashes = build_dataset(n, cells, seed, exclude_hashes)
        np.savez_compressed(f, **data, hashes=np.array(sorted(hashes)))
    x = to_input(data["walls"], data["start"], data["goal"])
    y = data["path"].astype(np.float32)[:, None]  # (N,1,s,s)
    return torch.from_numpy(x), torch.from_numpy(y), hashes


@torch.no_grad()
def evaluate(model, x, y, iters: int, batch: int = 256):
    """Returns (pixel_acc, solved_rate)."""
    model.eval()
    correct_px, total_px, solved = 0, 0, 0
    for i in range(0, len(x), batch):
        xb, yb = x[i : i + batch], y[i : i + batch]
        pred = (model(xb, iters=iters) > 0).float()
        eq = pred == yb
        correct_px += eq.sum().item()
        total_px += eq.numel()
        solved += eq.flatten(1).all(dim=1).sum().item()
    return correct_px / total_px, solved / len(x)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--model", choices=["fixed", "recurrent", "recall"], required=True)
    ap.add_argument("--width", type=int, default=64)
    ap.add_argument("--depth", type=int, default=8, help="blocks (fixed model only)")
    ap.add_argument("--train-iters", type=int, default=20, help="recurrent iterations")
    ap.add_argument("--n-train", type=int, default=20000)
    ap.add_argument("--n-val", type=int, default=1000)
    ap.add_argument("--cells", type=int, default=6)
    ap.add_argument("--epochs", type=int, default=10)
    ap.add_argument("--batch", type=int, default=32)
    ap.add_argument("--lr", type=float, default=1e-3)
    ap.add_argument("--seed", type=int, default=0)
    ap.add_argument("--out", required=True, help="run directory under runs/")
    args = ap.parse_args()

    torch.manual_seed(args.seed)
    out = ROOT / "runs" / args.out
    out.mkdir(parents=True, exist_ok=True)

    # data seeds: train=1000+seed, val=2000+seed (val generated disjoint from train)
    xtr, ytr, tr_hashes = get_dataset(args.n_train, args.cells, 1000 + args.seed)
    xva, yva, _ = get_dataset(args.n_val, args.cells, 2000 + args.seed, exclude_hashes=tr_hashes)

    model = make_model(args.model, args.width, args.depth)
    iters = args.train_iters if args.model in ("recurrent", "recall") else None
    print(f"{args.model} width={args.width} depth={args.depth} iters={iters} "
          f"params={count_params(model):,}")

    opt = torch.optim.Adam(model.parameters(), lr=args.lr)
    lossf = nn.BCEWithLogitsLoss()
    log = {"config": vars(args), "params": count_params(model), "epochs": []}

    for epoch in range(args.epochs):
        model.train()
        t0 = time.time()
        perm = torch.randperm(len(xtr))
        total_loss, nb = 0.0, 0
        for i in range(0, len(xtr), args.batch):
            idx = perm[i : i + args.batch]
            opt.zero_grad()
            outp = model(xtr[idx], iters=iters)
            loss = lossf(outp, ytr[idx])
            loss.backward()
            opt.step()
            total_loss += loss.item()
            nb += 1
        px, solved = evaluate(model, xva, yva, iters=iters)
        rec = {"epoch": epoch, "loss": total_loss / nb, "val_pixel_acc": px,
               "val_solved": solved, "secs": round(time.time() - t0, 1)}
        log["epochs"].append(rec)
        print(rec)
        torch.save(model.state_dict(), out / "model.pt")
        (out / "log.json").write_text(json.dumps(log, indent=1))
    print("done ->", out)


if __name__ == "__main__":
    main()

File created successfully at: D:\claude_code\maze_thinking\train.py (file state is current in your context — no need to Read it back)

"""Phase 2 driver: train the four comparison models sequentially.

Skips any run whose log.json already shows all epochs finished, so the driver
can simply be relaunched if the machine is switched off mid-way.
"""

import json
import subprocess
import sys
from pathlib import Path

ROOT = Path(__file__).parent
PY = sys.executable

COMMON = ["--width", "64", "--n-train", "20000", "--n-val", "1000",
          "--epochs", "20", "--seed", "0"]

RUNS = [
    (["--model", "fixed", "--depth", "8"], "p2_fixed_d8"),
    (["--model", "fixed", "--depth", "16"], "p2_fixed_d16"),
    (["--model", "recurrent", "--train-iters", "20"], "p2_rec_plain_i20"),
    (["--model", "recall", "--train-iters", "20"], "p2_rec_recall_i20"),
]


def finished(out: str) -> bool:
    f = ROOT / "runs" / out / "log.json"
    if not f.exists():
        return False
    log = json.loads(f.read_text())
    return len(log["epochs"]) >= log["config"]["epochs"]


for extra, out in RUNS:
    if finished(out):
        print(f"[driver] {out}: already finished, skipping", flush=True)
        continue
    print(f"[driver] starting {out}", flush=True)
    r = subprocess.run([PY, "-u", str(ROOT / "train.py"), *extra, *COMMON, "--out", out])
    if r.returncode != 0:
        print(f"[driver] {out} FAILED (rc={r.returncode}), aborting", flush=True)
        sys.exit(1)
print("[driver] all phase 2 runs complete", flush=True)

File created successfully at: D:\claude_code\maze_thinking\run_phase2.py (file state is current in your context — no need to Read it back)

"""Evaluate a trained run across maze sizes and (for recurrent models) test-time iterations.

For recurrent models the forward pass is run once to the max iteration count with
return_all=True, and every intermediate output is scored — so a full iteration sweep
costs one long rollout. Test sets are freshly seeded and, at the training size,
explicitly disjoint from the training hashes.

Writes runs/<run>/eval.json:
  {"size": {"<cells>": {"<iters>": {"pixel_acc": ..., "solved": ...}}}}
(fixed models get a single entry under iters key "0").
"""

import argparse
import json
from pathlib import Path

import torch

from models import make_model
from train import get_dataset

ROOT = Path(__file__).parent


@torch.no_grad()
def sweep(model, x, y, iter_list, batch=64):
    """Score model at each iteration count in iter_list. Returns {iters: metrics}."""
    max_it = max(iter_list)
    stats = {t: [0, 0, 0] for t in iter_list}  # correct_px, total_px, solved
    for i in range(0, len(x), batch):
        xb, yb = x[i : i + batch], y[i : i + batch]
        outs = model(xb, iters=max_it, return_all=True)
        for t in iter_list:
            pred = (outs[t - 1] > 0).float() if len(outs) > 1 else (outs[0] > 0).float()
            eq = pred == yb
            stats[t][0] += eq.sum().item()
            stats[t][1] += eq.numel()
            stats[t][2] += eq.flatten(1).all(dim=1).sum().item()
    return {t: {"pixel_acc": s[0] / s[1], "solved": s[2] / len(x)} for t, s in stats.items()}


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--run", required=True)
    ap.add_argument("--sizes", default="6,8,10,12,16")
    ap.add_argument("--iters", default="5,10,20,30,50,100,200")
    ap.add_argument("--n-test", type=int, default=500)
    args = ap.parse_args()

    run_dir = ROOT / "runs" / args.run
    cfg = json.loads((run_dir / "log.json").read_text())["config"]
    model = make_model(cfg["model"], cfg["width"], cfg["depth"])
    model.load_state_dict(torch.load(run_dir / "model.pt", weights_only=True))
    model.eval()
    recurrent = cfg["model"] in ("recurrent", "recall")
    iter_list = [int(t) for t in args.iters.split(",")] if recurrent else [0]

    # hashes of this run's training set (cached by train.py)
    _, _, train_hashes = get_dataset(cfg["n_train"], cfg["cells"], 1000 + cfg["seed"])

    results = {}
    for c in (int(s) for s in args.sizes.split(",")):
        exclude = train_hashes if c == cfg["cells"] else None
        x, y, _ = get_dataset(args.n_test, c, 3000, exclude_hashes=exclude)
        if recurrent:
            res = sweep(model, x, y, iter_list)
        else:
            res = {0: sweep(model, x, y, [1])[1]}  # fixed net ignores iters
        results[c] = res
        print(args.run, f"c={c}:", {t: round(r["solved"], 3) for t, r in res.items()}, flush=True)

    out = {str(c): {str(t): r for t, r in res.items()} for c, res in results.items()}
    (run_dir / "eval.json").write_text(json.dumps(out, indent=1))
    print("wrote", run_dir / "eval.json")


if __name__ == "__main__":
    main()

File created successfully at: D:\claude_code\maze_thinking\eval.py (file state is current in your context — no need to Read it back)

"""Export sample mazes + per-iteration model predictions as JSON for the interactive viewer.

For each sample maze and each recurrent run, stores the sigmoid probability map at a
subsampled schedule of thinking steps (dense early, sparser late), quantized to uint8
and base64-encoded. Fixed runs store their single output map. Output: viz_data.json.
"""

import argparse
import base64
import json
from pathlib import Path

import numpy as np
import torch

from models import make_model
from train import get_dataset

ROOT = Path(__file__).parent

# thinking steps to store: every step to 40, then sparser out to 200
STEPS = list(range(1, 41)) + list(range(45, 101, 5)) + list(range(110, 201, 10))


def b64(arr: np.ndarray) -> str:
    return base64.b64encode(arr.astype(np.uint8).tobytes()).decode()


def quantize(logits: torch.Tensor) -> np.ndarray:
    return (torch.sigmoid(logits).numpy() * 255).round()


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--runs", required=True, help="comma-separated run names")
    ap.add_argument("--sizes", default="6,10,16")
    ap.add_argument("--per-size", type=int, default=3)
    ap.add_argument("--n-test", type=int, default=500, help="must match eval.py's test sets")
    args = ap.parse_args()

    runs = []
    for name in args.runs.split(","):
        cfg = json.loads((ROOT / "runs" / name / "log.json").read_text())["config"]
        model = make_model(cfg["model"], cfg["width"], cfg["depth"])
        model.load_state_dict(torch.load(ROOT / "runs" / name / "model.pt", weights_only=True))
        model.eval()
        runs.append((name, cfg, model))

    mazes = []
    with torch.no_grad():
        for c in (int(s) for s in args.sizes.split(",")):
            x, y, _ = get_dataset(args.n_test, c, 3000)  # same sets eval.py scores
            for i in range(args.per_size):
                xi = x[i : i + 1]
                walls = xi[0, 0].numpy()
                start = np.argwhere(xi[0, 1].numpy() == 1)[0]
                goal = np.argwhere(xi[0, 2].numpy() == 1)[0]
                entry = {
                    "cells": c, "size": walls.shape[0],
                    "walls": b64(walls), "path": b64(y[0 + i, 0].numpy()),
                    "start": start.tolist(), "goal": goal.tolist(),
                    "preds": {},
                }
                for name, cfg, model in runs:
                    if cfg["model"] in ("recurrent", "recall"):
                        outs = model(xi, iters=max(STEPS), return_all=True)
                        maps = np.stack([quantize(outs[t - 1][0, 0]) for t in STEPS])
                        entry["preds"][name] = {"steps": STEPS, "maps": b64(maps)}
                    else:
                        out = model(xi)
                        entry["preds"][name] = {"steps": [0], "maps": b64(quantize(out[0, 0]))}
                mazes.append(entry)

    meta = [{"id": name, "model": cfg["model"], "depth": cfg["depth"],
             "train_iters": cfg["train_iters"]} for name, cfg, _ in runs]
    out = {"runs": meta, "mazes": mazes}
    (ROOT / "viz_data.json").write_text(json.dumps(out))
    kb = (ROOT / "viz_data.json").stat().st_size // 1024
    print(f"wrote viz_data.json ({kb} KB, {len(mazes)} mazes, {len(runs)} runs)")


if __name__ == "__main__":
    main()

File created successfully at: D:\claude_code\maze_thinking\viz_export.py (file state is current in your context — no need to Read it back)

<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Maze thinking — can a network think longer?</title>
<style>
  .viz-root {
    --surface-1: #fcfcfb; --page: #f9f9f7;
    --ink: #0b0b0b; --ink-2: #52514e; --muted: #898781;
    --grid: #e1e0d9; --axis: #c3c2b7; --border: rgba(11,11,11,0.10);
    --s1: #2a78d6; --s2: #1baf7a; --s3: #eda100; --s4: #008300;
    --good: #0ca30c; --crit: #d03b3b;
    --wall: #3a3934; --corridor: #f4f3ef;
    /* sequential blue ramp for prediction probability */
    --seq: 205,226,251;
  }
  @media (prefers-color-scheme: dark) {
    .viz-root {
      --surface-1: #1a1a19; --page: #0d0d0d;
      --ink: #ffffff; --ink-2: #c3c2b7; --muted: #898781;
      --grid: #2c2c2a; --axis: #383835; --border: rgba(255,255,255,0.10);
      --s1: #3987e5; --s2: #199e70; --s3: #c98500; --s4: #008300;
      --wall: #35342f; --corridor: #232320;
    }
  }
  html, body { margin: 0; }
  body { background: var(--page); }
  .viz-root {
    font-family: system-ui, -apple-system, "Segoe UI", sans-serif;
    color: var(--ink); background: var(--page);
    max-width: 1180px; margin: 0 auto; padding: 24px 20px 60px;
  }
  h1 { font-size: 26px; margin: 0 0 6px; }
  h2 { font-size: 18px; margin: 36px 0 4px; }
  .sub { color: var(--ink-2); font-size: 14px; line-height: 1.5; max-width: 72ch; margin: 0 0 18px; }
  .controls { display: flex; flex-wrap: wrap; gap: 18px; align-items: center; margin: 14px 0; font-size: 13px; }
  .ctl-group { display: flex; gap: 6px; align-items: center; }
  .ctl-label { color: var(--muted); margin-right: 2px; }
  button.opt {
    font: inherit; color: var(--ink-2); background: var(--surface-1);
    border: 1px solid var(--border); border-radius: 6px; padding: 4px 10px; cursor: pointer;
  }
  button.opt.active { color: var(--ink); border-color: var(--ink-2); font-weight: 600; }
  label.chk { color: var(--ink-2); display: flex; gap: 6px; align-items: center; cursor: pointer; }
  #grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(230px, 1fr)); gap: 14px; }
  .panel {
    background: var(--surface-1); border: 1px solid var(--border); border-radius: 10px;
    padding: 10px 12px 12px;
  }
  .panel h3 { font-size: 13px; margin: 0 0 8px; font-weight: 600; display: flex; align-items: center; gap: 7px; }
  .chip { width: 10px; height: 10px; border-radius: 3px; display: inline-block; }
  .panel canvas { width: 100%; image-rendering: pixelated; border-radius: 4px; display: block; }
  .panel .status { font-size: 12px; margin-top: 8px; color: var(--ink-2); }
  .panel .status .ok { color: var(--good); font-weight: 600; }
  .panel .note { font-size: 11px; color: var(--muted); margin-top: 2px; }
  .stepbar {
    display: flex; gap: 14px; align-items: center; margin: 16px 0 4px;
    background: var(--surface-1); border: 1px solid var(--border); border-radius: 10px; padding: 10px 14px;
  }
  .stepbar input[type=range] { flex: 1; }
  .stepbar .steplabel { font-size: 13px; color: var(--ink-2); min-width: 130px; }
  .stepbar .steplabel b { color: var(--ink); font-size: 15px; }
  button.play {
    font: inherit; font-size: 14px; background: var(--surface-1); color: var(--ink);
    border: 1px solid var(--axis); border-radius: 8px; padding: 5px 14px; cursor: pointer; min-width: 74px;
  }
  .legendrow { display: flex; flex-wrap: wrap; gap: 16px; font-size: 13px; color: var(--ink-2); margin: 10px 0 14px; }
  .legendrow .item { display: flex; gap: 6px; align-items: center; }
  .dash { width: 18px; height: 0; border-top: 2px dashed; display: inline-block; }
  .line { width: 18px; height: 0; border-top: 2px solid; display: inline-block; }
  #chartgrid { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 14px; }
  .chartbox { background: var(--surface-1); border: 1px solid var(--border); border-radius: 10px; padding: 12px; position: relative; }
  .chartbox h3 { font-size: 13px; margin: 0 0 4px; font-weight: 600; }
  .chartbox .csub { font-size: 11px; color: var(--muted); margin-bottom: 6px; }
  .tooltip {
    position: absolute; pointer-events: none; background: var(--surface-1); color: var(--ink);
    border: 1px solid var(--axis); border-radius: 8px; padding: 7px 10px; font-size: 12px;
    box-shadow: 0 2px 10px rgba(0,0,0,0.12); display: none; z-index: 5; white-space: nowrap;
  }
  .tooltip .trow { display: flex; gap: 8px; justify-content: space-between; }
  .tooltip .tname { color: var(--ink-2); display: flex; gap: 5px; align-items: center; }
  details { margin-top: 18px; font-size: 13px; color: var(--ink-2); }
  summary { cursor: pointer; }
  table { border-collapse: collapse; margin-top: 10px; font-variant-numeric: tabular-nums; }
  th, td { border: 1px solid var(--grid); padding: 4px 10px; text-align: right; font-size: 12px; }
  th { color: var(--ink-2); font-weight: 600; }
  .startdot { color: var(--good); font-weight: 700; }
  .goaldot { color: var(--crit); font-weight: 700; }
  footer { margin-top: 40px; font-size: 12px; color: var(--muted); }
</style>
</head>
<body>
<div class="viz-root">
  <header>
    <h1>Can a network think longer?</h1>
    <p class="sub">
      Four networks were trained to mark the shortest path (<span class="startdot">start</span> →
      <span class="goaldot">goal</span>) in small 13×13 mazes. Two are ordinary CNNs with a fixed
      number of layers. Two are <b>recurrent</b>: they apply the same small block over and over, so at
      test time we can simply run them for <i>more steps than they were trained with</i> — the
      slider below is that dial. Blue shading = where the model currently believes the path is.
      The question: does extra "thinking" let a network solve <b>bigger mazes than it ever saw in
      training</b>?
    </p>
  </header>

  <section>
    <div class="controls">
      <div class="ctl-group" id="sizebtns"><span class="ctl-label">Maze size</span></div>
      <div class="ctl-group" id="mazebtns"><span class="ctl-label">Example</span></div>
      <label class="chk"><input type="checkbox" id="truthchk"> show true path</label>
    </div>
    <div id="grid"></div>
    <div class="stepbar">
      <button class="play" id="playbtn">▶ Play</button>
      <input type="range" id="stepslider" min="0" value="0">
      <div class="steplabel">thinking step <b id="stepnum">1</b><span id="trainmark"></span></div>
    </div>
  </section>

  <section id="chartsec">
    <h2>Solved rate vs thinking steps</h2>
    <p class="sub">Fraction of 500 unseen mazes solved <i>exactly</i> (predicted path mask identical
      to the true one). Recurrent models are curves over test-time steps; fixed CNNs can't think
      longer, so they are horizontal dashed lines. The vertical hairline marks the recurrent models'
      training budget — everything to its right is extrapolation.</p>
    <div class="legendrow" id="legend"></div>
    <div id="chartgrid"></div>
    <details id="tabledetails"><summary>Data table (all numbers)</summary><div id="tablewrap"></div></details>
  </section>

  <footer id="foot"></footer>
</div>

<script>
const DATA = __DATA__;

/* ---------- helpers ---------- */
const $ = (id) => document.getElementById(id);
const css = (name) => getComputedStyle(document.querySelector(".viz-root")).getPropertyValue(name).trim();
function b64ToBytes(s) {
  const bin = atob(s), out = new Uint8Array(bin.length);
  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
  return out;
}
const SLOTS = ["--s1", "--s2", "--s3", "--s4"];
function runLabel(r) {
  if (r.model === "fixed") return `CNN · depth ${r.depth}`;
  return r.model === "recall" ? "Recurrent + recall" : "Recurrent · no recall";
}
const runs = DATA.runs.map((r, i) => ({ ...r, label: runLabel(r), slot: SLOTS[i % 4] }));
const recRuns = runs.filter(r => r.model !== "fixed");
const TRAIN_ITERS = recRuns.length ? recRuns[0].train_iters : 20;
// union of stored steps across recurrent runs (they share a schedule)
const STEPS = DATA.mazes[0] ? DATA.mazes[0].preds[recRuns[0].id].steps : [1];

/* decode mazes once */
for (const m of DATA.mazes) {
  m.wallsA = b64ToBytes(m.walls);
  m.pathA = b64ToBytes(m.path);
  for (const rid in m.preds) m.preds[rid].mapsA = b64ToBytes(m.preds[rid].maps);
}
const sizes = [...new Set(DATA.mazes.map(m => m.cells))];

/* ---------- state ---------- */
let curSize = sizes[0], curMaze = 0, stepIdx = 0, showTruth = false, playing = null;

/* ---------- maze panels ---------- */
const SCALE = 8;
const panels = [];
function buildPanels() {
  const grid = $("grid");
  grid.innerHTML = "";
  panels.length = 0;
  for (const r of runs) {
    const div = document.createElement("div");
    div.className = "panel";
    const fixedNote = r.model === "fixed"
      ? `<div class="note">fixed depth — no thinking dial</div>` : "";
    div.innerHTML = `<h3><span class="chip" style="background:var(${r.slot})"></span>${r.label}</h3>
      <canvas></canvas><div class="status"></div>${fixedNote}`;
    grid.appendChild(div);
    panels.push({ run: r, canvas: div.querySelector("canvas"), status: div.querySelector(".status") });
  }
}
function seqColor(p) {
  // p in [0,1] -> sequential blue, transparent below threshold
  if (p < 0.06) return null;
  const t = (p - 0.06) / 0.94;
  // interpolate lightest (#cde2fb) -> darkest (#0d366b)
  const a = [205, 226, 251], b = [13, 54, 107];
  const c = a.map((v, i) => Math.round(v + (b[i] - v) * t));
  return `rgb(${c[0]},${c[1]},${c[2]})`;
}
function currentMaze() {
  return DATA.mazes.filter(m => m.cells === curSize)[curMaze];
}
function drawPanel(p) {
  const m = currentMaze(), s = m.size, px = SCALE;
  const cv = p.canvas;
  cv.width = s * px; cv.height = s * px;
  const ctx = cv.getContext("2d");
  const pred = m.preds[p.run.id];
  const isRec = p.run.model !== "fixed";
  const si = isRec ? Math.min(stepIdx, pred.steps.length - 1) : 0;
  const off = si * s * s;
  const wall = css("--wall"), corridor = css("--corridor");
  let solved = true;
  for (let r = 0; r < s; r++) {
    for (let c = 0; c < s; c++) {
      const i = r * s + c;
      const prob = pred.mapsA[off + i] / 255;
      if ((prob >= 0.5 ? 1 : 0) !== m.pathA[i]) solved = false;
      ctx.fillStyle = m.wallsA[i] ? wall : corridor;
      ctx.fillRect(c * px, r * px, px, px);
      if (!m.wallsA[i]) {
        const col = seqColor(prob);
        if (col) { ctx.fillStyle = col; ctx.fillRect(c * px, r * px, px, px); }
      }
      if (showTruth && m.pathA[i]) {
        ctx.fillStyle = css("--ink-2");
        ctx.beginPath();
        ctx.arc(c * px + px / 2, r * px + px / 2, px / 6, 0, 7);
        ctx.fill();
      }
    }
  }
  const mark = (pos, col) => {
    ctx.fillStyle = col;
    ctx.beginPath();
    ctx.arc(pos[1] * px + px / 2, pos[0] * px + px / 2, px / 2.6, 0, 7);
    ctx.fill();
    ctx.lineWidth = 1.5; ctx.strokeStyle = css("--surface-1"); ctx.stroke();
  };
  mark(m.start, css("--good"));
  mark(m.goal, css("--crit"));
  p.status.innerHTML = solved
    ? `<span class="ok">✓ solved</span> — path exactly right`
    : `✗ not solved at this step`;
}
function drawAll() {
  $("stepnum").textContent = STEPS[stepIdx];
  $("trainmark").textContent = STEPS[stepIdx] > TRAIN_ITERS ? " — beyond training budget" : "";
  for (const p of panels) drawPanel(p);
}

/* ---------- controls ---------- */
function optButtons(containerId, labels, onpick) {
  const box = $(containerId);
  const btns = labels.map((lab, i) => {
    const b = document.createElement("button");
    b.className = "opt"; b.textContent = lab;
    b.onclick = () => { btns.forEach(x => x.classList.remove("active")); b.classList.add("active"); onpick(i); };
    box.appendChild(b);
    return b;
  });
  btns[0].classList.add("active");
  return btns;
}
optButtons("sizebtns", sizes.map(c => `${2 * c + 1}×${2 * c + 1}`), i => { curSize = sizes[i]; curMaze = 0; drawAll(); });
const nPer = DATA.mazes.filter(m => m.cells === sizes[0]).length;
optButtons("mazebtns", Array.from({ length: nPer }, (_, i) => `${i + 1}`), i => { curMaze = i; drawAll(); });
$("truthchk").onchange = e => { showTruth = e.target.checked; drawAll(); };

const slider = $("stepslider");
slider.max = STEPS.length - 1;
slider.oninput = () => { stepIdx = +slider.value; drawAll(); };
$("playbtn").onclick = () => {
  if (playing) { clearInterval(playing); playing = null; $("playbtn").textContent = "▶ Play"; return; }
  if (stepIdx >= STEPS.length - 1) stepIdx = 0;
  $("playbtn").textContent = "⏸ Pause";
  playing = setInterval(() => {
    stepIdx++;
    if (stepIdx >= STEPS.length - 1) { stepIdx = STEPS.length - 1; clearInterval(playing); playing = null; $("playbtn").textContent = "▶ Play"; }
    slider.value = stepIdx;
    drawAll();
  }, 90);
};

/* ---------- charts ---------- */
function buildLegend() {
  const box = $("legend");
  for (const r of runs) {
    const it = document.createElement("span");
    it.className = "item";
    const swatch = r.model === "fixed" ? "dash" : "line";
    it.innerHTML = `<span class="${swatch}" style="border-color:var(${r.slot})"></span>${r.label}`;
    box.appendChild(it);
  }
}
function buildCharts() {
  if (!DATA.eval) { $("chartsec").style.display = "none"; return; }
  buildLegend();
  const evalSizes = Object.keys(DATA.eval[runs[0].id]).map(Number).sort((a, b) => a - b);
  for (const c of evalSizes) makeChart(c);
  buildTable(evalSizes);
}
function makeChart(cells) {
  const iters = Object.keys(DATA.eval[recRuns[0].id][cells]).map(Number).sort((a, b) => a - b);
  const W = 340, H = 220, ML = 38, MR = 14, MT = 10, MB = 28;
  const lx = t => ML + (Math.log(t) - Math.log(iters[0])) / (Math.log(iters[iters.length - 1]) - Math.log(iters[0])) * (W - ML - MR);
  const ly = v => MT + (1 - v) * (H - MT - MB);
  const NS = "http://www.w3.org/2000/svg";
  const svg = document.createElementNS(NS, "svg");
  svg.setAttribute("viewBox", `0 0 ${W} ${H}`);
  const el = (tag, attrs, text) => {
    const e = document.createElementNS(NS, tag);
    for (const k in attrs) e.setAttribute(k, attrs[k]);
    if (text != null) e.textContent = text;
    svg.appendChild(e);
    return e;
  };
  // gridlines + y ticks
  for (const v of [0, 0.25, 0.5, 0.75, 1]) {
    el("line", { x1: ML, x2: W - MR, y1: ly(v), y2: ly(v), stroke: "var(--grid)", "stroke-width": 1 });
    el("text", { x: ML - 5, y: ly(v) + 3.5, "text-anchor": "end", "font-size": 9, fill: "var(--muted)" }, `${v * 100}%`);
  }
  // x ticks
  for (const t of [5, 10, 20, 50, 100, 200].filter(t => t >= iters[0] && t <= iters[iters.length - 1])) {
    el("text", { x: lx(t), y: H - MB + 13, "text-anchor": "middle", "font-size": 9, fill: "var(--muted)" }, t);
  }
  el("text", { x: (ML + W - MR) / 2, y: H - 3, "text-anchor": "middle", "font-size": 9, fill: "var(--muted)" }, "test-time steps (log scale)");
  // training-budget hairline
  el("line", { x1: lx(TRAIN_ITERS), x2: lx(TRAIN_ITERS), y1: MT, y2: H - MB, stroke: "var(--axis)", "stroke-width": 1, "stroke-dasharray": "3 3" });
  el("text", { x: lx(TRAIN_ITERS) + 3, y: MT + 8, "font-size": 8.5, fill: "var(--muted)" }, "training budget");
  // baseline
  el("line", { x1: ML, x2: W - MR, y1: ly(0), y2: ly(0), stroke: "var(--axis)", "stroke-width": 1 });
  // fixed models: dashed horizontals
  for (const r of runs.filter(r => r.model === "fixed")) {
    const v = DATA.eval[r.id][cells]["0"].solved;
    el("line", { x1: ML, x2: W - MR, y1: ly(v), y2: ly(v), stroke: `var(${r.slot})`, "stroke-width": 2, "stroke-dasharray": "6 4", opacity: 0.9 });
  }
  // recurrent curves
  for (const r of recRuns) {
    const pts = iters.map(t => [lx(t), ly(DATA.eval[r.id][cells][t].solved)]);
    el("path", { d: "M" + pts.map(p => p.map(v => v.toFixed(1)).join(",")).join("L"), fill: "none", stroke: `var(${r.slot})`, "stroke-width": 2 });
    for (const p of pts) el("circle", { cx: p[0], cy: p[1], r: 2.4, fill: `var(${r.slot})` });
  }
  const box = document.createElement("div");
  box.className = "chartbox";
  box.innerHTML = `<h3>${2 * cells + 1}×${2 * cells + 1} mazes</h3>
    <div class="csub">${cells === (DATA.trainCells || 6) ? "training size" : "never seen in training"}</div>`;
  box.appendChild(svg);
  const tip = document.createElement("div");
  tip.className = "tooltip";
  box.appendChild(tip);
  // hover: snap to nearest iteration
  svg.addEventListener("mousemove", ev => {
    const rect = svg.getBoundingClientRect();
    const xf = (ev.clientX - rect.left) / rect.width * W;
    let best = iters[0];
    for (const t of iters) if (Math.abs(lx(t) - xf) < Math.abs(lx(best) - xf)) best = t;
    let html = `<b>${best} steps</b>`;
    for (const r of runs) {
      const v = r.model === "fixed" ? DATA.eval[r.id][cells]["0"].solved : DATA.eval[r.id][cells][best].solved;
      html += `<div class="trow"><span class="tname"><span class="chip" style="background:var(${r.slot})"></span>${r.label}</span><b>${(v * 100).toFixed(1)}%</b></div>`;
    }
    tip.innerHTML = html;
    tip.style.display = "block";
    tip.style.left = Math.min(ev.clientX - rect.left + 14, rect.width - 170) + "px";
    tip.style.top = (ev.clientY - rect.top + 14) + "px";
  });
  svg.addEventListener("mouseleave", () => tip.style.display = "none");
  $("chartgrid").appendChild(box);
}
function buildTable(evalSizes) {
  const wrap = $("tablewrap");
  for (const c of evalSizes) {
    const iters = Object.keys(DATA.eval[recRuns[0].id][c]).map(Number).sort((a, b) => a - b);
    let h = `<h3 style="font-size:13px;margin:14px 0 2px">${2 * c + 1}×${2 * c + 1} mazes — % solved</h3><table><tr><th>steps</th>`;
    for (const r of runs) h += `<th>${r.label}</th>`;
    h += "</tr>";
    for (const t of iters) {
      h += `<tr><td>${t}</td>`;
      for (const r of runs) {
        const v = r.model === "fixed" ? (t === iters[0] ? DATA.eval[r.id][c]["0"].solved : null) : DATA.eval[r.id][c][t].solved;
        h += `<td>${v == null ? "—" : (v * 100).toFixed(1)}</td>`;
      }
      h += "</tr>";
    }
    h += "</table>";
    wrap.innerHTML += h;
  }
}

/* ---------- init ---------- */
buildPanels();
drawAll();
buildCharts();
$("foot").textContent = `Generated __DATE__ · models trained on 20,000 mazes of size 13×13 · `
  + `solved-rate curves from 500 unseen mazes per size · recurrent training budget ${TRAIN_ITERS} steps`;
window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", drawAll);
</script>
</body>
</html>

File created successfully at: D:\claude_code\maze_thinking\viewer_template.html (file state is current in your context — no need to Read it back)

"""Build maze_viewer.html: inject viz_data.json (+ any eval.json results) into the template."""

import argparse
import datetime
import json
from pathlib import Path

ROOT = Path(__file__).parent


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--out", default="maze_viewer.html")
    args = ap.parse_args()

    data = json.loads((ROOT / "viz_data.json").read_text())
    evals = {}
    for r in data["runs"]:
        f = ROOT / "runs" / r["id"] / "eval.json"
        if f.exists():
            evals[r["id"]] = json.loads(f.read_text())
    if evals and len(evals) == len(data["runs"]):
        data["eval"] = evals
    data["trainCells"] = 6

    html = (ROOT / "viewer_template.html").read_text(encoding="utf-8")
    html = html.replace("__DATA__", json.dumps(data))
    html = html.replace("__DATE__", datetime.date.today().isoformat())
    (ROOT / args.out).write_text(html, encoding="utf-8")
    kb = (ROOT / args.out).stat().st_size // 1024
    print(f"wrote {args.out} ({kb} KB, eval data: {'yes' if 'eval' in data else 'no'})")


if __name__ == "__main__":
    main()

File created successfully at: D:\claude_code\maze_thinking\build_viewer.py (file state is current in your context — no need to Read it back)

{
  "version": "0.0.1",
  "configurations": [
    {
      "name": "maze-viewer",
      "runtimeExecutable": "D:\\claude_code\\ml_venv\\Scripts\\python.exe",
      "runtimeArgs": ["-m", "http.server", "8731", "--directory", "D:\\claude_code\\maze_thinking"],
      "port": 8731
    }
  ]
}

File created successfully at: D:\claude_code\.claude\launch.json (file state is current in your context — no need to Read it back)

# Can a network think longer? Test-time compute on maze solving

*Free-choice round of the automating-ML-research experiment, 2026-07-12. Status: DRAFT —
methods written ahead of results; results sections filled in as phases complete.*

## Question

A fixed-depth network spends the same amount of computation on every input, however hard.
A weight-tied recurrent network applies one small block repeatedly, so the amount of
computation is a *dial we can turn at test time*. On a task with a natural notion of
problem size — shortest paths in mazes — we ask:

1. Does a recurrent net trained with a modest thinking budget keep improving when given
   more steps at test time?
2. Does extra thinking let it solve **larger mazes than it ever saw in training**, and how
   does that compare to simply making a feedforward net deeper?
3. Does re-feeding the input at every step ("recall") matter, as reported in the
   deep-thinking literature?

## Setup

**Task.** Perfect mazes (spanning trees, unique solution path) on a c×c cell lattice,
generated by randomized DFS, rendered to (2c+1)×(2c+1) binary images. Input: 3 channels
(walls, start one-hot, goal one-hot). Target: binary mask of the unique start→goal
corridor path (BFS ground truth). Loss: per-pixel binary cross-entropy.

**Metric.** *Solved rate*: fraction of mazes where the thresholded prediction equals the
target mask on **every pixel**. (Pixel accuracy is uninformative — ~89% of pixels are
background; the all-zeros predictor gets ~0.89.)

**Models** (all fully convolutional, width 64, 3×3 kernels; ~0.6M params for the d8 CNN):

| name | description |
|---|---|
| CNN d8 | encoder + 8 untied residual blocks + head |
| CNN d16 | same, 16 blocks |
| Recurrent (no recall) | encoder + **one** residual block applied T times + head |
| Recurrent + recall | same, but the raw 3-channel input is re-concatenated to the state at every step |

**Training.** 20,000 mazes at c=6 (13×13 images), 20 epochs, Adam 1e-3, batch 32,
recurrent models trained at T=20. Val/test sets deduped against training mazes by hash
of (walls, start, goal).

**Evaluation.** 500 fresh mazes per size c ∈ {6, 8, 10, 12, 16} (13×13 up to 33×33
images; c=6 explicitly disjoint from training set). Recurrent models scored at
T ∈ {5, 10, 20, 30, 50, 100, 200} from a single rollout's intermediate outputs.

## Results

*(pending — phase 2 training in progress)*

## The twist

*(to be chosen after phase 2: candidates are recall-gated recurrence, adaptive halting,
or a size curriculum — depends on where the interesting failure is)*

## Interactive visualization

`maze_viewer.html` (self-contained, no dependencies): pick a maze size and example, drag
the thinking-steps slider (or press play) and watch each model's path belief evolve;
solved-rate charts with the training budget marked. Built by
`viz_export.py` → `build_viewer.py`.

## Reproduction

```
ml_venv\Scripts\python.exe run_phase2.py          # trains the 4 models (resumable)
ml_venv\Scripts\python.exe eval.py --run <name>   # per-run size × iters sweep
ml_venv\Scripts\python.exe viz_export.py --runs p2_fixed_d8,p2_fixed_d16,p2_rec_plain_i20,p2_rec_recall_i20
ml_venv\Scripts\python.exe build_viewer.py
```

File created successfully at: D:\claude_code\maze_thinking\REPORT.md (file state is current in your context — no need to Read it back)

"""Phase 3 driver: retrain both recurrent variants with a randomized thinking budget.

T ~ U[10, 30] per batch (loss at the sampled step), so the network cannot tune its
dynamics to one readout time. Resumable like run_phase2.py.
"""

import json
import subprocess
import sys
from pathlib import Path

ROOT = Path(__file__).parent
PY = sys.executable

COMMON = ["--width", "64", "--n-train", "20000", "--n-val", "1000",
          "--epochs", "20", "--seed", "0",
          "--train-iters", "20", "--rand-iters", "10,30"]

RUNS = [
    (["--model", "recurrent"], "p3_rec_plain_rand"),
    (["--model", "recall"], "p3_rec_recall_rand"),
]


def finished(out: str) -> bool:
    f = ROOT / "runs" / out / "log.json"
    if not f.exists():
        return False
    log = json.loads(f.read_text())
    return len(log["epochs"]) >= log["config"]["epochs"]


for extra, out in RUNS:
    if finished(out):
        print(f"[driver] {out}: already finished, skipping", flush=True)
        continue
    print(f"[driver] starting {out}", flush=True)
    r = subprocess.run([PY, "-u", str(ROOT / "train.py"), *extra, *COMMON, "--out", out])
    if r.returncode != 0:
        print(f"[driver] {out} FAILED (rc={r.returncode}), aborting", flush=True)
        sys.exit(1)
print("[driver] all phase 3 runs complete", flush=True)

File created successfully at: D:\claude_code\maze_thinking\run_phase3.py (file state is current in your context — no need to Read it back)

"""Seed-1 replicates of the four recurrent configs (the runs behind the headline claims).

Fresh seed changes init AND the training/val data streams (data seeds are 1000+seed /
2000+seed), so this tests robustness to both. Resumable like the other drivers.
"""

import json
import subprocess
import sys
from pathlib import Path

ROOT = Path(__file__).parent
PY = sys.executable

COMMON = ["--width", "64", "--n-train", "20000", "--n-val", "1000",
          "--epochs", "20", "--seed", "1", "--train-iters", "20"]

RUNS = [
    (["--model", "recurrent"], "p2_rec_plain_i20_s1"),
    (["--model", "recall"], "p2_rec_recall_i20_s1"),
    (["--model", "recurrent", "--rand-iters", "10,30"], "p3_rec_plain_rand_s1"),
    (["--model", "recall", "--rand-iters", "10,30"], "p3_rec_recall_rand_s1"),
]


def finished(out: str) -> bool:
    f = ROOT / "runs" / out / "log.json"
    if not f.exists():
        return False
    log = json.loads(f.read_text())
    return len(log["epochs"]) >= log["config"]["epochs"]


for extra, out in RUNS:
    if finished(out):
        print(f"[driver] {out}: already finished, skipping", flush=True)
        continue
    print(f"[driver] starting {out}", flush=True)
    r = subprocess.run([PY, "-u", str(ROOT / "train.py"), *extra, *COMMON, "--out", out])
    if r.returncode != 0:
        print(f"[driver] {out} FAILED (rc={r.returncode}), aborting", flush=True)
        sys.exit(1)
print("[driver] all replicate runs complete", flush=True)

File created successfully at: D:\claude_code\maze_thinking\run_replicates.py (file state is current in your context — no need to Read it back)

"""Measure state dynamics of recurrent runs: relative state change per step.

For each run, rolls N mazes for --iters steps recording mean ||s_{t+1}-s_t|| / ||s_t||
per step. Attractor-like (fixed-point) dynamics -> ratio decays toward 0; transient
dynamics -> stays high. Writes dynamics.json {run: {cells: [per-step ratios]}}.
"""

import argparse
import json
from pathlib import Path

import torch

from models import ckpt_path, make_model
from train import get_dataset

ROOT = Path(__file__).parent


@torch.no_grad()
def state_deltas(model, x, iters):
    s = model.encode(x)
    out = []
    for _ in range(iters):
        s_next = model.step(s, x)
        num = (s_next - s).flatten(1).norm(dim=1)
        den = s.flatten(1).norm(dim=1).clamp_min(1e-8)
        out.append((num / den).mean().item())
        s = s_next
    return out


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--runs", required=True)
    ap.add_argument("--sizes", default="6,10,16")
    ap.add_argument("--n", type=int, default=50)
    ap.add_argument("--iters", type=int, default=200)
    args = ap.parse_args()

    results = {}
    for name in args.runs.split(","):
        cfg = json.loads((ROOT / "runs" / name / "log.json").read_text())["config"]
        assert cfg["model"] in ("recurrent", "recall"), f"{name} is not recurrent"
        model = make_model(cfg["model"], cfg["width"], cfg["depth"])
        model.load_state_dict(torch.load(ckpt_path(ROOT / "runs" / name), weights_only=True))
        model.eval()
        results[name] = {}
        for c in (int(s) for s in args.sizes.split(",")):
            x, _, _ = get_dataset(500, c, 3000)
            results[name][c] = state_deltas(model, x[: args.n], args.iters)
            last = results[name][c][-1]
            print(f"{name} c={c}: delta@1={results[name][c][0]:.4f} "
                  f"@20={results[name][c][19]:.4f} @200={last:.6f}", flush=True)

    (ROOT / "dynamics.json").write_text(json.dumps(results))
    print("wrote dynamics.json")


if __name__ == "__main__":
    main()

File created successfully at: D:\claude_code\maze_thinking\analyze_dynamics.py (file state is current in your context — no need to Read it back)