Initial release v0.4.0 — ActiveVision benchmark (85 instances, 17 tasks)

LICENSE

@@ -0,0 +1,40 @@
+Attribution 4.0 International (CC BY 4.0)
+
+The ActiveVision benchmark dataset and accompanying generation pipeline are
+licensed under the Creative Commons Attribution 4.0 International License.
+
+You are free to:
+
+  Share — copy and redistribute the material in any medium or format
+  Adapt — remix, transform, and build upon the material for any purpose,
+          even commercially.
+
+Under the following terms:
+
+  Attribution — You must give appropriate credit, provide a link to the
+  license, and indicate if changes were made. You may do so in any reasonable
+  manner, but not in any way that suggests the licensor endorses you or your
+  use.
+
+  No additional restrictions — You may not apply legal terms or technological
+  measures that legally restrict others from doing anything the license permits.
+
+Notices:
+
+  You do not have to comply with the license for elements of the material in
+  the public domain or where your use is permitted by an applicable exception
+  or limitation.
+
+  No warranties are given. The license may not give you all of the permissions
+  necessary for your intended use. For example, other rights such as publicity,
+  privacy, or moral rights may limit how you use the material.
+
+Full legal code: https://creativecommons.org/licenses/by/4.0/legalcode
+Human-readable summary: https://creativecommons.org/licenses/by/4.0/
+
+────────────────────────────────────────────────────────────────────────────
+
+Citation:
+
+  Anonymous. ActiveVision: An Exam for Active Observers.
+  NeurIPS 2026 Datasets and Benchmarks Track (under review).

README.md

@@ -0,0 +1,106 @@
+---
+license: cc-by-4.0
+pretty_name: ActiveVision
+size_categories:
+  - n<1K
+task_categories:
+  - visual-question-answering
+  - image-classification
+language:
+  - en
+tags:
+  - active-perception
+  - active-vision
+  - multimodal
+  - benchmark
+  - synthetic
+  - mllm-evaluation
+  - visual-reasoning
+configs:
+  - config_name: default
+    data_files:
+      - split: test
+        path: data/manifest.json
+---
+
+# ActiveVision
+
+An exam for active observers — a benchmark for diagnosing whether multimodal large language models can iteratively look at an image during reasoning, instead of compressing it into a fixed embedding once.
+
+## What's in this archive
+
+| Path | Contents |
+|---|---|
+| `data/images/` | 85 photorealistic PNGs, the released benchmark images |
+| `data/manifest.json` | Canonical index — one record per instance with `id`, `task`, `category`, `image`, `image_sha256`, `image_source_filename`, `question`, `answer` |
+| `data/annotations/<task>.jsonl` | Per-task verification metadata (5 records per file × 17 tasks = 85). Includes the structural ground truth used to compute each answer (region adjacency, arrow chains, traversal paths, Hausdorff distances, etc.) |
+| `code/<category>/<task>/creation.py` | Seedable, deterministic generator. The released images at v0.4 are produced at `--difficulty 4`. |
+| `code/<category>/<task>/creation.md` | Per-task design and anti-shortcut spec (where present). |
+| `code/<category>/<task>/data.json` | Per-task definition: shared question text, answer format. |
+| `code/gpt_image_prompts.json` | One gpt-image-2 image-edit prompt per task, used to re-render the matplotlib structural draft as a photorealistic variant while preserving the discriminative structure. |
+| `code/scope.md` | Project specification: the three task families and the six shortcut classes the design defeats. |
+| `croissant.json` | Croissant 1.0 + Croissant-RAI 1.0 metadata for this dataset. |
+| `LICENSE` | CC BY 4.0. |
+
+## Statistics
+
+- **85 instances**, 17 tasks, 3 task families.
+- **Distributed Scanning** (25 instances, 5 tasks): attribute_group_counting, bounded_faces_counting, counting_connected_components, counting_regions, tangled_loops.
+- **Sequential Traversal** (25 instances, 5 tasks): arrow_chain, color_zone_sequence, line_intersections, maze, traverse_ordering.
+- **Visual Attribute Transfer** (35 instances, 7 tasks): constellation_match_count, contour_silhouette_count, spot_the_contour_diff, spot_the_field_diff, spot_the_signal_diff, spot_the_stroke_diff, stroke_gesture_count.
+
+## Loading
+
+```python
+import json, pathlib
+root = pathlib.Path("data_neurips2026")
+manifest = json.loads((root / "data" / "manifest.json").read_text())
+for item in manifest:
+    image_path = root / item["image"]
+    question = item["question"]
+    gold     = item["answer"]
+```
+
+## Generation pipeline
+
+The pipeline is the artifact. Every benchmark image is produced in two deterministic stages:
+
+1. **Geometric draft (matplotlib).** `creation.py --seed S --difficulty 4` lays out a structural specification (region partition, arrow positions, maze graph, brush-stroke field, etc.) and computes the answer in closed form. Output: a plain matplotlib PNG.
+2. **Photorealistic re-render (gpt-image-2).** The matplotlib draft is sent to OpenAI gpt-image-2 via the image-edit endpoint, with a per-task prompt from `code/gpt_image_prompts.json` that preserves silhouettes, positions, counts, and labels but replaces the surface material with a photorealistic style (stones on sand, hedge maze from above, starfield, etc.).
+
+The released benchmark contains only the Stage-2 images. Held-out splits with unpublished seeds and additional difficulties can be regenerated from the included generators.
+
+## Anti-shortcut design
+
+Every task is constructed to defeat six shortcut classes (full discussion in `code/scope.md`):
+
+1. One-shot symbolic perception, then text reasoning.
+2. End-to-end CV scripting (OCR / edge / blob / vector tracing).
+3. Prior leakage / answer-distribution memorisation.
+4. Gestalt heuristics that bypass step-by-step tracing.
+5. Memorisation of the released benchmark (mitigated because the *pipeline* is released, not just the data).
+6. Tool-using zoom/crop/OCR loops.
+
+## Responsible AI
+
+See `croissant.json` for the full RAI block. Headlines:
+
+- **Synthetic only**: 100% synthetic. No human subjects, no PII, no real-world events.
+- **Use cases**: testing and validation. **Not for training.**
+- **Limitations**: small evaluation set; adversarial-by-design (not predictive of general vision-language ability); photorealistic re-renders depend on a closed-source service.
+- **License**: [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).
+
+## Validating the Croissant file
+
+Before submission, validate `croissant.json` with the official Croissant validator at:
+
+> https://huggingface.co/spaces/JoaquinVanschoren/croissant-checker
+
+(Run well in advance of any submission deadline — the doc warns of heavy load near deadlines.)
+
+## Citation
+
+```
+Anonymous. ActiveVision: An Exam for Active Observers.
+NeurIPS 2026 Datasets and Benchmarks Track (under review).
+```

code/distributed_scanning/attribute_group_counting/creation.md

@@ -0,0 +1,28 @@
+# Attribute Group Counting
+
+## Goal
+
+Scatter many small visual elements across the canvas. All elements are the same color — groups are distinguished **only by shape**. Each shape is an **irregular random blob** generated via Fourier harmonics in polar coordinates. They cannot be described by simple geometric names (circle, square, etc.), forcing the model to perform visual pairing rather than textual identification. The model must scan the entire image, visually compare every element's silhouette, and count how many distinct groups have at least 2 members.
+
+## Element library
+
+- Shapes: procedurally generated irregular blobs (random Fourier harmonics, 8-14 lobes, unique per group)
+- Color: uniform dark gray for all elements (no color differentiation)
+- Texture: solid fill for all elements (no texture differentiation)
+
+A group identity is determined solely by shape. Each group has 2-5 elements, all sharing the exact same silhouette. There are no decoys (every element belongs to a group of size ≥2).
+
+## Question
+
+"How many distinct groups of matching shapes are in the image? All shapes are the same color. Two shapes belong to the same group if and only if they have exactly the same silhouette. The shapes are irregular and cannot be described by simple geometric names — you must visually compare them. Count the number of distinct shape groups and report the total."
+
+## Generation
+
+1. Pick `K` (number of groups), e.g. 4-9.
+2. Generate `K` distinct random blob shapes using Fourier harmonics in polar coordinates.
+3. For each group, sample size in 2-5.
+4. Place all elements at random positions with minimum spacing so they don't overlap.
+5. Render using matplotlib for smooth, anti-aliased outlines.
+6. Store annotations.
+
+GT = `K`.

code/distributed_scanning/attribute_group_counting/creation.py

@@ -0,0 +1,419 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import random
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+from matplotlib.path import Path as MplPath
+import numpy as np
+
+
+# ---------------------------------------------------------------------------
+# Random irregular shape generation
+# ---------------------------------------------------------------------------
+
+def generate_blob_vertices(rng: random.Random,
+                           fourier_perturbation_amplitude: float = 0.20,
+                           num_samples: int = 80) -> List[Tuple[float, float]]:
+    """Generate a random irregular closed shape as unit-radius vertices.
+
+    ``fourier_perturbation_amplitude`` scales the harmonic amplitude budget.
+    At the default of 0.20 we match the original shape character; smaller
+    values produce blobs that are closer to a smooth near-circular profile,
+    making silhouettes harder to distinguish visually.
+    """
+    # Vary structure dramatically across shapes
+    num_lobes = rng.randint(3, 12)
+    base_radius = rng.uniform(0.5, 0.8)
+
+    # Random harmonics with wide amplitude range. Scale amplitudes by the
+    # perturbation factor so that smaller perturbation => gentler bumps.
+    amp_scale = max(fourier_perturbation_amplitude, 1e-6) / 0.20
+    harmonics = []
+    for k in range(2, num_lobes + 1):
+        amp = rng.uniform(0.08, 0.45) / (k ** rng.uniform(0.3, 0.7))
+        harmonics.append((k, amp * amp_scale, rng.uniform(0, 2 * math.pi)))
+
+    # Optionally add one dominant low-frequency lobe for variety
+    if rng.random() < 0.5:  # unrelated coin (kept as-is)
+        dom_freq = rng.randint(2, 4)
+        dom_amp = rng.uniform(0.15, 0.35) * amp_scale
+        dom_phase = rng.uniform(0, 2 * math.pi)
+        harmonics.append((dom_freq, dom_amp, dom_phase))
+
+    # Build polar radius function
+    angles = [2 * math.pi * i / num_samples for i in range(num_samples)]
+    radii = []
+    for a in angles:
+        r = base_radius
+        for freq, amp, phase in harmonics:
+            r += amp * math.sin(freq * a + phase)
+        radii.append(max(r, 0.12))
+
+    # Convert to cartesian
+    pts = [(r * math.cos(a), r * math.sin(a)) for r, a in zip(radii, angles)]
+
+    # Random aspect stretch + rotation for more variety
+    stretch_x = rng.uniform(0.6, 1.0)
+    stretch_y = rng.uniform(0.6, 1.0)
+    rot = rng.uniform(0, 2 * math.pi)
+    cos_r, sin_r = math.cos(rot), math.sin(rot)
+    stretched = []
+    for x, y in pts:
+        sx, sy = x * stretch_x, y * stretch_y
+        rx = sx * cos_r - sy * sin_r
+        ry = sx * sin_r + sy * cos_r
+        stretched.append((rx, ry))
+    pts = stretched
+
+    # Normalise so max extent = 1.0
+    max_ext = max(max(abs(x), abs(y)) for x, y in pts)
+    if max_ext > 0:
+        pts = [(x / max_ext, y / max_ext) for x, y in pts]
+
+    return pts
+
+
+def _silhouette_distance(a: List[Tuple[float, float]],
+                         b: List[Tuple[float, float]],
+                         num_samples: int = 64) -> float:
+    """Rotation/reflection-invariant silhouette distance between two unit blobs.
+
+    We compare the two shapes via their polar radius signatures sampled on
+    a common angular grid. We minimise over cyclic rotations and a reflection
+    to account for the shapes' arbitrary orientation.
+    """
+    def radial_signature(pts: List[Tuple[float, float]]) -> np.ndarray:
+        xs = np.asarray([p[0] for p in pts])
+        ys = np.asarray([p[1] for p in pts])
+        # Centre at centroid
+        xs = xs - xs.mean()
+        ys = ys - ys.mean()
+        angs = np.arctan2(ys, xs) % (2 * np.pi)
+        rads = np.hypot(xs, ys)
+        grid = np.linspace(0, 2 * np.pi, num_samples, endpoint=False)
+        order = np.argsort(angs)
+        angs_sorted = angs[order]
+        rads_sorted = rads[order]
+        # Extend for wrap-around interpolation
+        ang_ext = np.concatenate([angs_sorted - 2 * np.pi, angs_sorted,
+                                   angs_sorted + 2 * np.pi])
+        rad_ext = np.concatenate([rads_sorted, rads_sorted, rads_sorted])
+        sig = np.interp(grid, ang_ext, rad_ext)
+        # Normalise
+        m = sig.max()
+        if m > 0:
+            sig = sig / m
+        return sig
+
+    sa = radial_signature(a)
+    sb = radial_signature(b)
+    sb_rev = sb[::-1]
+
+    best = float("inf")
+    for sig_b in (sb, sb_rev):
+        for shift in range(num_samples):
+            rolled = np.roll(sig_b, shift)
+            d = float(np.mean(np.abs(sa - rolled)))
+            if d < best:
+                best = d
+    return best
+
+
+def generate_distinct_shapes(rng: random.Random, n: int,
+                             fourier_perturbation_amplitude: float,
+                             min_pairwise_silhouette_distance: float,
+                             max_attempts_per_shape: int = 60,
+                             ) -> List[List[Tuple[float, float]]]:
+    """Generate ``n`` blob shapes whose pairwise silhouette distances all exceed
+    ``min_pairwise_silhouette_distance``.
+
+    Falls back to the best-available shape after ``max_attempts_per_shape``
+    retries to avoid pathological infinite loops at tight thresholds.
+    """
+    shapes: List[List[Tuple[float, float]]] = []
+    for _ in range(n):
+        best_candidate = None
+        best_min_dist = -1.0
+        for _attempt in range(max_attempts_per_shape):
+            verts = generate_blob_vertices(rng, fourier_perturbation_amplitude)
+            if not shapes:
+                shapes.append(verts)
+                break
+            min_d = min(_silhouette_distance(verts, s) for s in shapes)
+            if min_d >= min_pairwise_silhouette_distance:
+                shapes.append(verts)
+                break
+            if min_d > best_min_dist:
+                best_min_dist = min_d
+                best_candidate = verts
+        else:
+            # Couldn't satisfy threshold; use best candidate we found.
+            shapes.append(best_candidate if best_candidate is not None
+                          else generate_blob_vertices(rng, fourier_perturbation_amplitude))
+    return shapes
+
+
+# ---------------------------------------------------------------------------
+# Position sampling
+# ---------------------------------------------------------------------------
+
+def sample_positions(rng: random.Random, n: int, width: int, height: int,
+                     margin: int, min_dist: float, max_attempts: int = 8000) -> List[Tuple[float, float]]:
+    pts: List[Tuple[float, float]] = []
+    for _ in range(max_attempts):
+        if len(pts) == n:
+            break
+        x = rng.uniform(margin, width - margin)
+        y = rng.uniform(margin, height - margin)
+        if all(math.hypot(x - px, y - py) >= min_dist for px, py in pts):
+            pts.append((x, y))
+    return pts
+
+
+# ---------------------------------------------------------------------------
+# Replica sampling
+# ---------------------------------------------------------------------------
+
+def _sample_replicas(rng: random.Random, d_val: int) -> int:
+    """Replica count from a flatter geometric: continue with prob 0.8 each
+    step, capped at max(2, d). P(k=1)=0.2, P(k=2)=0.16, P(k=3)=0.128, …,
+    with the residual mass piling at k=cap. Distribution is much more
+    spread-out than p=0.5 → meaningful chance of seeing replica counts
+    near the cap, while small counts are still common.
+    """
+    cap = max(2, d_val)
+    k = 1
+    while k < cap and rng.random() < 0.8:
+        k += 1
+    return k
+
+
+# ---------------------------------------------------------------------------
+# Sample generation
+# ---------------------------------------------------------------------------
+
+ELEMENT_COLOR = "#303030"
+
+
+def sample_instance(rng: random.Random, width: int, height: int,
+                    answer_lo: int, answer_hi: int,
+                    d_val: int,
+                    fourier_perturbation_amplitude: float,
+                    min_pairwise_silhouette_distance: float,
+                    radius: int) -> Dict[str, object] | None:
+    num_groups = rng.randint(answer_lo, answer_hi)
+
+    blob_shapes = generate_distinct_shapes(
+        rng,
+        num_groups,
+        fourier_perturbation_amplitude=fourier_perturbation_amplitude,
+        min_pairwise_silhouette_distance=min_pairwise_silhouette_distance,
+    )
+
+    elements: List[Dict[str, object]] = []
+    group_records: List[Dict[str, object]] = []
+    for gid, blob in enumerate(blob_shapes):
+        size = _sample_replicas(rng, d_val)
+        for _ in range(size):
+            elements.append({
+                "shape_id": gid,
+                "group": gid,
+            })
+        group_records.append({
+            "id": gid,
+            "shape_id": gid,
+            "size": size,
+            "shape_vertices": [[round(x, 4), round(y, 4)] for x, y in blob],
+        })
+
+    n = len(elements)
+    min_dist = radius * 2.4
+    positions = sample_positions(rng, n, width, height, margin=radius + 6, min_dist=min_dist)
+    if len(positions) < n:
+        return None
+
+    rng.shuffle(positions)
+    for el, (x, y) in zip(elements, positions):
+        el["x"] = round(x, 2)
+        el["y"] = round(y, 2)
+
+    return {
+        "width": width,
+        "height": height,
+        "num_groups": num_groups,
+        "num_elements": n,
+        "answer": num_groups,
+        "elements": elements,
+        "groups": group_records,
+        "radius": radius,
+        "fourier_perturbation_amplitude": round(fourier_perturbation_amplitude, 5),
+        "min_pairwise_silhouette_distance": round(min_pairwise_silhouette_distance, 5),
+        "blob_shapes": [[[round(x, 4), round(y, 4)] for x, y in b] for b in blob_shapes],
+    }
+
+
+def render_instance(out_path: Path, record: Dict[str, object]) -> None:
+    width = int(record["width"])
+    height = int(record["height"])
+    radius = float(record["radius"])
+    blob_shapes = record["blob_shapes"]
+
+    fig = plt.figure(figsize=(width / 100, height / 100), dpi=100)
+    ax = fig.add_axes([0, 0, 1, 1])
+    ax.set_xlim(0, width)
+    ax.set_ylim(height, 0)
+    ax.axis("off")
+    ax.set_facecolor("#faf6ed")
+
+    for el in record["elements"]:
+        cx = float(el["x"])
+        cy = float(el["y"])
+        blob = blob_shapes[el["shape_id"]]
+
+        # Scale blob vertices to canvas coordinates
+        verts = [(cx + vx * radius, cy + vy * radius) for vx, vy in blob]
+        verts.append(verts[0])
+
+        codes = [MplPath.MOVETO] + [MplPath.LINETO] * (len(verts) - 2) + [MplPath.CLOSEPOLY]
+        path = MplPath(verts, codes)
+        patch = mpatches.PathPatch(
+            path,
+            facecolor=ELEMENT_COLOR,
+            edgecolor=ELEMENT_COLOR,
+            linewidth=1.8,
+            alpha=0.92,
+            joinstyle="round",
+            capstyle="round",
+            zorder=2,
+        )
+        ax.add_patch(patch)
+
+    fig.savefig(out_path, dpi=100, bbox_inches="tight", pad_inches=0)
+    plt.close(fig)
+
+
+QUESTION = (
+    "How many distinct shapes are in the image? "
+    "The image contains many small irregular shapes (blobs) scattered across the canvas. "
+    "All shapes are the same color. Two shapes belong to the same type if and only if "
+    "they have exactly the same silhouette. The shapes are irregular and cannot be described "
+    "by simple geometric names — you must visually compare them. "
+    "Some shapes may appear only once while others appear multiple times. "
+    "Count the total number of distinct shape types and report the count as a positive integer. "
+    "Provide your final answer enclosed in <answer>...</answer> tags."
+)
+
+
+def generate_dataset(rng: random.Random, count: int, output_dir: Path,
+                     width: int, height: int,
+                     answer_lo: int, answer_hi: int,
+                     d_val: int,
+                     fourier_perturbation_amplitude: float,
+                     min_pairwise_silhouette_distance: float,
+                     radius: int) -> None:
+    images_dir = output_dir / "images"
+    images_dir.mkdir(parents=True, exist_ok=True)
+
+    # Force evenly-spaced answers across [answer_lo, answer_hi].
+    if count > 1:
+        forced_targets = [
+            int(round(answer_lo + i * (answer_hi - answer_lo) / (count - 1)))
+            for i in range(count)
+        ]
+    else:
+        forced_targets = [answer_lo]
+    print(f"forced group counts: {forced_targets}")
+
+    records: List[Dict[str, object]] = []
+    data_records: List[Dict[str, object]] = []
+    for idx in range(count):
+        target = forced_targets[idx]
+        for _ in range(2000):
+            rec = sample_instance(
+                rng, width, height,
+                answer_lo=target, answer_hi=target,
+                d_val=d_val,
+                fourier_perturbation_amplitude=fourier_perturbation_amplitude,
+                min_pairwise_silhouette_distance=min_pairwise_silhouette_distance,
+                radius=radius,
+            )
+            if rec is not None and rec.get("answer") == target:
+                break
+        else:
+            print(f"Skip {idx} (could not hit target={target})")
+            continue
+        name = f"attribute_group_counting_{idx:05d}.png"
+        render_instance(images_dir / name, rec)
+        rec["image"] = f"images/{name}"
+        rec["question"] = QUESTION
+        records.append(rec)
+        data_records.append({"image": rec["image"], "question": QUESTION, "gt": rec["answer"]})
+        print(f"  [{idx+1}/{count}] groups={rec['answer']} elements={rec['num_elements']}")
+
+    (output_dir / "annotations.jsonl").write_text(
+        "\n".join(json.dumps(r) for r in records) + "\n"
+    )
+    (output_dir / "data.json").write_text(json.dumps(data_records, indent=4))
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser()
+    p.add_argument("--output-root", type=Path, required=True)
+    p.add_argument("--count", type=int, default=30)
+    p.add_argument("--width", type=int, default=900)
+    p.add_argument("--height", type=int, default=900)
+    p.add_argument("--radius", type=int, default=36)
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--difficulty", type=int, default=5,
+                   help="Integer difficulty >=0; scales distinct-shape count, "
+                        "replica geometric cap, blob perturbation, silhouette "
+                        "separation, and canvas area.")
+    return p.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    rng = random.Random(args.seed)
+
+    d = max(0, int(args.difficulty))
+
+    # Difficulty formulas.
+    answer_lo = 3
+    answer_hi = 5 + d
+    fourier_perturbation_amplitude = 0.20 / (1 + 0.2 * d)
+    min_pairwise_silhouette_distance = 0.22 / (1 + 0.2 * d)
+
+    # Canvas scaling: area ~ total shape instances (answer_hi * E[replicas=2]).
+    N_d = (5 + d) * 2
+    N_0 = 5 * 2
+    s = math.sqrt(max(1.0, N_d / N_0))
+    args.width = int(round(args.width * s))
+    args.height = int(round(args.height * s))
+
+    print(f"difficulty={d} answer_range=[{answer_lo},{answer_hi}] "
+          f"fourier_amp={fourier_perturbation_amplitude:.4f} "
+          f"silhouette_min={min_pairwise_silhouette_distance:.4f} "
+          f"canvas={args.width}x{args.height}")
+
+    generate_dataset(
+        rng=rng, count=args.count, output_dir=args.output_root,
+        width=args.width, height=args.height,
+        answer_lo=answer_lo, answer_hi=answer_hi,
+        d_val=d,
+        fourier_perturbation_amplitude=fourier_perturbation_amplitude,
+        min_pairwise_silhouette_distance=min_pairwise_silhouette_distance,
+        radius=args.radius,
+    )
+    print(f"Saved to {args.output_root}")
+
+
+if __name__ == "__main__":
+    main()

code/distributed_scanning/attribute_group_counting/data.json

@@ -0,0 +1,27 @@
+[
+  {
+    "image": "images/attribute_group_counting_00000.png",
+    "question": "How many distinct shapes are in the image? The image contains many small pieces scattered across the canvas. Two pieces belong to the same type if and only if they have exactly the same silhouette. Pieces may differ in surface texture or colour tone \u2014 only the silhouette outline matters. Count the total number of distinct silhouette types and report the count as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+    "gt": 3
+  },
+  {
+    "image": "images/attribute_group_counting_00001.png",
+    "question": "How many distinct shapes are in the image? The image contains many small pieces scattered across the canvas. Two pieces belong to the same type if and only if they have exactly the same silhouette. Pieces may differ in surface texture or colour tone \u2014 only the silhouette outline matters. Count the total number of distinct silhouette types and report the count as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+    "gt": 5
+  },
+  {
+    "image": "images/attribute_group_counting_00002.png",
+    "question": "How many distinct shapes are in the image? The image contains many small pieces scattered across the canvas. Two pieces belong to the same type if and only if they have exactly the same silhouette. Pieces may differ in surface texture or colour tone \u2014 only the silhouette outline matters. Count the total number of distinct silhouette types and report the count as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+    "gt": 6
+  },
+  {
+    "image": "images/attribute_group_counting_00003.png",
+    "question": "How many distinct shapes are in the image? The image contains many small pieces scattered across the canvas. Two pieces belong to the same type if and only if they have exactly the same silhouette. Pieces may differ in surface texture or colour tone \u2014 only the silhouette outline matters. Count the total number of distinct silhouette types and report the count as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+    "gt": 8
+  },
+  {
+    "image": "images/attribute_group_counting_00004.png",
+    "question": "How many distinct shapes are in the image? The image contains many small pieces scattered across the canvas. Two pieces belong to the same type if and only if they have exactly the same silhouette. Pieces may differ in surface texture or colour tone \u2014 only the silhouette outline matters. Count the total number of distinct silhouette types and report the count as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+    "gt": 10
+  }
+]

code/distributed_scanning/bounded_faces_counting/creation.md

@@ -0,0 +1,30 @@
+# Bounded Faces Counting
+
+## Goal
+
+Render several closed curves (ellipses) on a canvas. The curves overlap to form a planar arrangement that subdivides the interior into one or more *bounded faces*. The model must scan the entire image and count how many distinct enclosed regions exist.
+
+This is a *distributed scanning* task — there is no path to follow. The model has to look at the whole arrangement and tally every enclosed region.
+
+## Avoiding ambiguity
+
+The user requested that there be no very small or very thin regions, and that curve overlaps should not create ambiguous regions. The generator enforces this by:
+
+- Stroking each loop with a generous thickness (visually clear).
+- Rasterizing the figure and using a flood fill to find all interior connected components.
+- Rejecting any sample where the smallest interior region is below a minimum area threshold (so no tiny slivers).
+- Rejecting any sample where the bounding box of an interior region is unusually thin (so no needle-like regions).
+
+## Question
+
+"How many distinct enclosed regions (bounded faces) are visible in this image? An enclosed region is a maximal area that is fully surrounded by the drawn curves on every side, with no opening to the outside background. The unbounded outside area does not count. Each enclosed region should be counted exactly once, even if it is shaped irregularly. Count every enclosed region in the entire image and report the total as a positive integer."
+
+## Generation
+
+1. Pick `K` (number of loops), e.g. 3-6.
+2. For each loop, sample random center, semi-axes, and rotation.
+3. Stroke each loop as a thick outline on the canvas.
+4. Flood-fill the background from the canvas border.
+5. Find all interior connected components (regions not reached by the outer flood).
+6. Reject the sample if any region has area below `min_area` or has a thin bounding box.
+7. GT = number of interior components.

code/distributed_scanning/bounded_faces_counting/creation.py

@@ -0,0 +1,473 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import random
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+Cell = Tuple[int, int]
+
+
+# ---------------------------------------------------------------------------
+# Geometry helpers
+# ---------------------------------------------------------------------------
+
+
+def _cross(ox: float, oy: float, px: float, py: float, qx: float, qy: float) -> float:
+    return (px - ox) * (qy - oy) - (py - oy) * (qx - ox)
+
+
+def segments_intersect_properly(
+    ax: float, ay: float, bx: float, by: float,
+    cx: float, cy: float, dx: float, dy: float,
+) -> bool:
+    """True if segment AB *properly* crosses segment CD (shared endpoints don't count)."""
+    d1 = _cross(cx, cy, dx, dy, ax, ay)
+    d2 = _cross(cx, cy, dx, dy, bx, by)
+    d3 = _cross(ax, ay, bx, by, cx, cy)
+    d4 = _cross(ax, ay, bx, by, dx, dy)
+    if ((d1 > 0 and d2 < 0) or (d1 < 0 and d2 > 0)) and \
+       ((d3 > 0 and d4 < 0) or (d3 < 0 and d4 > 0)):
+        return True
+    return False
+
+
+def point_seg_dist(px: float, py: float, ax: float, ay: float, bx: float, by: float) -> float:
+    dx = bx - ax
+    dy = by - ay
+    len_sq = dx * dx + dy * dy
+    if len_sq < 1e-12:
+        return math.hypot(px - ax, py - ay)
+    t = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / len_sq))
+    return math.hypot(px - (ax + t * dx), py - (ay + t * dy))
+
+
+# ---------------------------------------------------------------------------
+# Union-Find
+# ---------------------------------------------------------------------------
+
+
+class UnionFind:
+    def __init__(self, n: int) -> None:
+        self.parent = list(range(n))
+        self.rank = [0] * n
+        self.num_sets = n
+
+    def find(self, x: int) -> int:
+        while self.parent[x] != x:
+            self.parent[x] = self.parent[self.parent[x]]
+            x = self.parent[x]
+        return x
+
+    def union(self, a: int, b: int) -> bool:
+        ra, rb = self.find(a), self.find(b)
+        if ra == rb:
+            return False
+        if self.rank[ra] < self.rank[rb]:
+            ra, rb = rb, ra
+        self.parent[rb] = ra
+        if self.rank[ra] == self.rank[rb]:
+            self.rank[ra] += 1
+        self.num_sets -= 1
+        return True
+
+
+# ---------------------------------------------------------------------------
+# Graph construction — planar, no-dot-crossing edge set
+# ---------------------------------------------------------------------------
+
+
+def place_dots(
+    rng: random.Random,
+    grid_rows: int,
+    grid_cols: int,
+    num_dots: int,
+    min_gap: float,
+    border_margin: int = 5,
+    max_attempts: int = 8000,
+) -> List[Cell]:
+    cells: List[Cell] = []
+    lo_r, hi_r = border_margin, grid_rows - border_margin
+    lo_c, hi_c = border_margin, grid_cols - border_margin
+    for _ in range(max_attempts):
+        if len(cells) == num_dots:
+            break
+        r = rng.randint(lo_r, hi_r - 1)
+        c = rng.randint(lo_c, hi_c - 1)
+        if all(math.hypot(r - er, c - ec) >= min_gap for er, ec in cells):
+            cells.append((r, c))
+    return cells
+
+
+def build_planar_edge_set(
+    dots: List[Cell],
+    dot_radius: float,
+    max_edge_len: float,
+) -> List[Tuple[int, int, float]]:
+    n = len(dots)
+    candidates: List[Tuple[float, int, int]] = []
+    for i in range(n):
+        ri, ci = dots[i]
+        for j in range(i + 1, n):
+            rj, cj = dots[j]
+            d = math.hypot(ri - rj, ci - cj)
+            if d > max_edge_len:
+                continue
+            clear = True
+            for k in range(n):
+                if k == i or k == j:
+                    continue
+                if point_seg_dist(dots[k][0], dots[k][1], ri, ci, rj, cj) < dot_radius + 0.8:
+                    clear = False
+                    break
+            if clear:
+                candidates.append((d, i, j))
+    candidates.sort()
+
+    accepted: List[Tuple[int, int, float]] = []
+    seg_coords: List[Tuple[float, float, float, float]] = []
+    for dist, i, j in candidates:
+        ri, ci = dots[i]
+        rj, cj = dots[j]
+        crosses = False
+        for ax, ay, bx, by in seg_coords:
+            if (ri == ax and ci == ay) or (ri == bx and ci == by) or \
+               (rj == ax and cj == ay) or (rj == bx and cj == by):
+                continue
+            if segments_intersect_properly(ri, ci, rj, cj, ax, ay, bx, by):
+                crosses = True
+                break
+        if not crosses:
+            accepted.append((i, j, dist))
+            seg_coords.append((float(ri), float(ci), float(rj), float(cj)))
+
+    return accepted
+
+
+# ---------------------------------------------------------------------------
+# Graph construction for bounded faces
+# ---------------------------------------------------------------------------
+
+
+def build_graph_with_faces(
+    rng: random.Random,
+    n: int,
+    planar_edges: List[Tuple[int, int, float]],
+    target_faces: int,
+) -> Tuple[List[Tuple[int, int]], int, int] | None:
+    """Build a planar graph targeting a specific number of bounded faces.
+
+    Strategy:
+      1. Build a spanning forest from shuffled edges (connecting as many dots
+         as possible into one component).
+      2. Each additional intra-component edge beyond the spanning forest creates
+         exactly one new bounded face (Euler: F_bounded = E - V + C).
+      3. Add extra edges until we reach the target face count.
+
+    Returns (edges, bounded_faces, num_components) or None if infeasible.
+    """
+    uf = UnionFind(n)
+
+    # Shuffle edges, biased toward shorter ones
+    mid = len(planar_edges) // 2
+    short = list(planar_edges[:mid])
+    long = list(planar_edges[mid:])
+    rng.shuffle(short)
+    rng.shuffle(long)
+    shuffled = short + long
+
+    # Phase 1: build spanning forest (connect everything into one component ideally)
+    tree_edges: List[Tuple[int, int]] = []
+    extra_edges: List[Tuple[int, int]] = []
+
+    for i, j, d in shuffled:
+        if uf.find(i) != uf.find(j):
+            uf.union(i, j)
+            tree_edges.append((i, j))
+        else:
+            extra_edges.append((i, j))
+
+    num_components = uf.num_sets
+
+    # Phase 2: add extra edges to create faces
+    # bounded_faces = E - V + C = (tree + extra) - V + C
+    # spanning forest has V - C edges, so faces = num_extra_added
+    rng.shuffle(extra_edges)
+
+    if len(extra_edges) < target_faces:
+        return None
+
+    selected_edges = tree_edges + extra_edges[:target_faces]
+    bounded_faces = target_faces
+
+    return selected_edges, bounded_faces, num_components
+
+
+# ---------------------------------------------------------------------------
+# Instance sampling
+# ---------------------------------------------------------------------------
+
+QUESTION = (
+    "How many distinct enclosed regions (bounded faces) are visible in this image? "
+    "An enclosed region is a maximal area that is fully surrounded by the drawn "
+    "line segments on every side, with no opening to the outside background. The "
+    "unbounded outside area does not count as an enclosed region. Each enclosed "
+    "region should be counted exactly once, regardless of its shape. Count every "
+    "enclosed region in the entire image and report the total as a positive integer. "
+    "Provide your final answer enclosed in <answer>...</answer> tags."
+)
+
+
+def sample_instance(
+    rng: random.Random,
+    width: int,
+    height: int,
+    grid_rows: int,
+    grid_cols: int,
+    min_faces: int,
+    max_faces: int,
+    num_dots_min: int,
+    num_dots_max: int,
+    min_gap: float,
+    dot_radius: float,
+    max_edge_len: float,
+) -> Dict[str, object] | None:
+    target_faces = rng.randint(min_faces, max_faces)
+    num_dots = rng.randint(num_dots_min, num_dots_max)
+
+    dots = place_dots(rng, grid_rows, grid_cols, num_dots, min_gap)
+    if len(dots) < 10:
+        return None
+
+    planar_edges = build_planar_edge_set(dots, dot_radius, max_edge_len)
+
+    result = build_graph_with_faces(rng, len(dots), planar_edges, target_faces)
+    if result is None:
+        return None
+
+    edges, bounded_faces, num_components = result
+
+    if bounded_faces < min_faces:
+        return None
+
+    margin = int(min(width, height) * 0.10)
+    square_size = min(width, height) - 2 * margin
+    square_left = (width - square_size) / 2.0
+    square_top = (height - square_size) / 2.0
+
+    return {
+        "width": width,
+        "height": height,
+        "grid_rows": grid_rows,
+        "grid_cols": grid_cols,
+        "square_left": round(square_left, 2),
+        "square_top": round(square_top, 2),
+        "square_size": round(square_size, 2),
+        "num_dots": len(dots),
+        "num_edges": len(edges),
+        "num_components": num_components,
+        "question": QUESTION,
+        "answer": bounded_faces,
+        "dots": [[r, c] for r, c in dots],
+        "edges": [[i, j] for i, j in edges],
+        "dot_radius": dot_radius,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Rendering (matplotlib — smooth anti-aliased output)
+# ---------------------------------------------------------------------------
+
+LINE_COLOR = "#2f2f2f"
+DOT_COLOR = "#1d1916"
+
+
+def render_instance(out_path: Path, record: Dict[str, object], noise_seed: int = 0) -> None:
+    width = int(record["width"])
+    height = int(record["height"])
+    grid_rows = int(record["grid_rows"])
+    grid_cols = int(record["grid_cols"])
+    square_left = float(record["square_left"])
+    square_top = float(record["square_top"])
+    square_size = float(record["square_size"])
+    dots: List[List[int]] = record["dots"]  # type: ignore[assignment]
+    edges: List[List[int]] = record["edges"]  # type: ignore[assignment]
+    dot_radius_grid = float(record["dot_radius"])
+
+    cell_w = square_size / grid_cols
+    cell_h = square_size / grid_rows
+
+    def to_pixel(r: float, c: float) -> Tuple[float, float]:
+        px = square_left + (c + 0.5) * cell_w
+        py = square_top + (r + 0.5) * cell_h
+        return px, py
+
+    pixel_dot_radius = dot_radius_grid * min(cell_w, cell_h) * 0.5
+    edge_thickness = max(1.5, pixel_dot_radius * 0.3)
+
+    fig = plt.figure(figsize=(width / 100, height / 100), dpi=100)
+    ax = fig.add_axes([0, 0, 1, 1])
+    ax.set_xlim(0, width)
+    ax.set_ylim(height, 0)
+    ax.axis("off")
+    ax.set_facecolor("#f8f6f0")
+
+    # Subtle noise background
+    nrng = np.random.default_rng(noise_seed)
+    noise = nrng.normal(0.0, 1.0, size=(height, width))
+    noise = (noise - noise.min()) / max(noise.max() - noise.min(), 1e-6)
+    ax.imshow(noise, cmap="Greys", alpha=0.05, extent=(0, width, height, 0),
+              interpolation="bilinear")
+
+    # White square background
+    ax.fill_between(
+        [square_left, square_left + square_size],
+        [square_top, square_top],
+        [square_top + square_size, square_top + square_size],
+        color="#fffdf8", zorder=0.5,
+    )
+
+    # Border
+    bx = [square_left, square_left + square_size, square_left + square_size, square_left, square_left]
+    by = [square_top, square_top, square_top + square_size, square_top + square_size, square_top]
+    ax.plot(bx, by, color="#2d2720", linewidth=2.0, solid_capstyle="round", zorder=1.0)
+
+    # Plain (v4_plain): solid edges. No dashed-line anti-shortcut.
+    for i, j in edges:
+        px1, py1 = to_pixel(dots[i][0], dots[i][1])
+        px2, py2 = to_pixel(dots[j][0], dots[j][1])
+        ax.plot([px1, px2], [py1, py2],
+                color=LINE_COLOR, linewidth=edge_thickness,
+                solid_capstyle="round", alpha=0.92, zorder=2.0)
+
+    # Dots on top
+    for r, c in dots:
+        px, py = to_pixel(r, c)
+        circle = plt.Circle((px, py), pixel_dot_radius, color=DOT_COLOR, zorder=3.0)
+        ax.add_patch(circle)
+
+    fig.savefig(out_path, dpi=100, bbox_inches="tight", pad_inches=0)
+    plt.close(fig)
+
+
+# ---------------------------------------------------------------------------
+# Dataset generation
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument("--count", type=int, default=30)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--width", type=int, default=1024)
+    parser.add_argument("--height", type=int, default=1024)
+    parser.add_argument("--grid-rows", type=int, default=100)
+    parser.add_argument("--grid-cols", type=int, default=100)
+    parser.add_argument("--min-faces", type=int, default=4)
+    parser.add_argument("--max-faces", type=int, default=15)
+    parser.add_argument("--num-dots-min", type=int, default=60)
+    parser.add_argument("--num-dots-max", type=int, default=120)
+    parser.add_argument("--min-gap", type=float, default=5.0)
+    parser.add_argument("--dot-radius", type=float, default=1.5)
+    parser.add_argument("--max-edge-len", type=float, default=25.0)
+    parser.add_argument("--difficulty", type=int, default=5,
+                        help="Integer difficulty >=0; scales faces and dot count.")
+    args = parser.parse_args()
+
+    d = max(0, int(args.difficulty))
+    # Difficulty scaling per spec
+    args.min_faces = 5
+    args.max_faces = 5 + 2 * d
+    args.num_dots_min = 10 * d
+    args.num_dots_max = 20 + 10 * d
+    base_max_edge_len = args.max_edge_len
+    args.max_edge_len = base_max_edge_len / (1.0 + 0.08 * d)
+
+    # Canvas scaling based on num_dots_max growth
+    N_d = 20 + 10 * d
+    N_0 = 20
+    s = math.sqrt(max(1.0, N_d / N_0))
+    args.width = int(round(args.width * s))
+    args.height = int(round(args.height * s))
+
+    out_root: Path = args.output_root
+    img_dir = out_root / "images"
+    img_dir.mkdir(parents=True, exist_ok=True)
+    ann_path = out_root / "annotations.jsonl"
+
+    rng = random.Random(args.seed)
+    records = []
+    # Force evenly-spaced answers across [min_faces, max_faces].
+    if args.count > 1:
+        forced_targets = [
+            int(round(args.min_faces + i * (args.max_faces - args.min_faces) / (args.count - 1)))
+            for i in range(args.count)
+        ]
+    else:
+        forced_targets = [args.min_faces]
+    print(f"forced face counts: {forced_targets}")
+    with ann_path.open("w") as f:
+        for i in range(args.count):
+            sub_seed = rng.randint(0, 2**31 - 1)
+            tgt = forced_targets[i]
+            for _ in range(2000):
+                record = sample_instance(
+                    rng=rng,
+                    width=args.width,
+                    height=args.height,
+                    grid_rows=args.grid_rows,
+                    grid_cols=args.grid_cols,
+                    min_faces=tgt,
+                    max_faces=tgt,
+                    num_dots_min=args.num_dots_min,
+                    num_dots_max=args.num_dots_max,
+                    min_gap=args.min_gap,
+                    dot_radius=args.dot_radius,
+                    max_edge_len=args.max_edge_len,
+                )
+                if record is not None and record.get("answer") == tgt:
+                    break
+            else:
+                print(f"  [{i+1}/{args.count}] SKIP (failed to generate)")
+                continue
+
+            name = f"bounded_faces_counting_{i:05d}.png"
+            render_instance(img_dir / name, record, noise_seed=sub_seed)
+            print(f"  [{i+1}/{args.count}] faces={record['answer']} dots={record['num_dots']} edges={record['num_edges']}")
+
+            rec = {
+                "image": f"images/{name}",
+                "question": QUESTION,
+                "answer": record["answer"],
+                "metadata": {
+                    "bounded_faces": record["answer"],
+                    "num_dots": record["num_dots"],
+                    "num_edges": record["num_edges"],
+                    "num_components": record["num_components"],
+                    "seed": sub_seed,
+                },
+            }
+            f.write(json.dumps(rec) + "\n")
+            records.append(rec)
+
+    data_json = {
+        "task": "bounded_faces_counting",
+        "category": "distributed_scanning",
+        "count": len(records),
+        "items": records,
+    }
+    (out_root / "data.json").write_text(json.dumps(data_json, indent=2))
+    print(f"Saved to {out_root}")
+
+
+if __name__ == "__main__":
+    main()

code/distributed_scanning/bounded_faces_counting/data.json

@@ -0,0 +1,67 @@
+{
+  "task": "bounded_faces_counting",
+  "category": "distributed_scanning",
+  "count": 5,
+  "items": [
+    {
+      "image": "images/bounded_faces_counting_00000.png",
+      "question": "How many distinct enclosed regions (bounded faces) are visible in this image? An enclosed region is a maximal area that is fully surrounded by drawn lines or strands on every side, with no opening to the outside background. The unbounded outside area does not count. Each enclosed region should be counted exactly once. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 5,
+      "metadata": {
+        "bounded_faces": 5,
+        "num_dots": 58,
+        "num_edges": 62,
+        "num_components": 1,
+        "seed": 478163327
+      }
+    },
+    {
+      "image": "images/bounded_faces_counting_00001.png",
+      "question": "How many distinct enclosed regions (bounded faces) are visible in this image? An enclosed region is a maximal area that is fully surrounded by drawn lines or strands on every side, with no opening to the outside background. The unbounded outside area does not count. Each enclosed region should be counted exactly once. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 8,
+      "metadata": {
+        "bounded_faces": 8,
+        "num_dots": 69,
+        "num_edges": 76,
+        "num_components": 1,
+        "seed": 798112150
+      }
+    },
+    {
+      "image": "images/bounded_faces_counting_00002.png",
+      "question": "How many distinct enclosed regions (bounded faces) are visible in this image? An enclosed region is a maximal area that is fully surrounded by drawn lines or strands on every side, with no opening to the outside background. The unbounded outside area does not count. Each enclosed region should be counted exactly once. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 10,
+      "metadata": {
+        "bounded_faces": 10,
+        "num_dots": 68,
+        "num_edges": 77,
+        "num_components": 1,
+        "seed": 110287971
+      }
+    },
+    {
+      "image": "images/bounded_faces_counting_00003.png",
+      "question": "How many distinct enclosed regions (bounded faces) are visible in this image? An enclosed region is a maximal area that is fully surrounded by drawn lines or strands on every side, with no opening to the outside background. The unbounded outside area does not count. Each enclosed region should be counted exactly once. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 12,
+      "metadata": {
+        "bounded_faces": 12,
+        "num_dots": 60,
+        "num_edges": 70,
+        "num_components": 2,
+        "seed": 1411178445
+      }
+    },
+    {
+      "image": "images/bounded_faces_counting_00004.png",
+      "question": "How many distinct enclosed regions (bounded faces) are visible in this image? An enclosed region is a maximal area that is fully surrounded by drawn lines or strands on every side, with no opening to the outside background. The unbounded outside area does not count. Each enclosed region should be counted exactly once. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 15,
+      "metadata": {
+        "bounded_faces": 15,
+        "num_dots": 61,
+        "num_edges": 75,
+        "num_components": 1,
+        "seed": 963124353
+      }
+    }
+  ]
+}

code/distributed_scanning/counting_connected_components/creation.md

@@ -0,0 +1,13 @@
+# Counting Connected Components Dataset Generation
+
+## Goal
+
+Generate images of a large grid (e.g., 80x80 to 150x150) where scattered dots are connected by lines to form several distinct connected components — groups of dots linked together by drawn edges. 
+
+The diameter of each dot should be about 3 unit lengths. Enforce a minimum gap of at least distance of 5 unit length between any two dots so they are unambiguously separated.
+
+Each component does not necessary stay in the same region. Dots from different components can intersect with each other, but are connected with other dots under the same components.
+
+The connection edge should not get across any other dots to avoid ambiguity.
+
+Render PNG files and the question is asking how many connected components are there.

code/distributed_scanning/counting_connected_components/creation.py

@@ -0,0 +1,574 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import random
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+Cell = Tuple[int, int]
+
+
+# ---------------------------------------------------------------------------
+# Geometry helpers
+# ---------------------------------------------------------------------------
+
+
+def _cross(ox: float, oy: float, px: float, py: float, qx: float, qy: float) -> float:
+    return (px - ox) * (qy - oy) - (py - oy) * (qx - ox)
+
+
+def segments_intersect_properly(
+    ax: float, ay: float, bx: float, by: float,
+    cx: float, cy: float, dx: float, dy: float,
+) -> bool:
+    """True if segment AB *properly* crosses segment CD (shared endpoints don't count)."""
+    d1 = _cross(cx, cy, dx, dy, ax, ay)
+    d2 = _cross(cx, cy, dx, dy, bx, by)
+    d3 = _cross(ax, ay, bx, by, cx, cy)
+    d4 = _cross(ax, ay, bx, by, dx, dy)
+    if ((d1 > 0 and d2 < 0) or (d1 < 0 and d2 > 0)) and \
+       ((d3 > 0 and d4 < 0) or (d3 < 0 and d4 > 0)):
+        return True
+    return False
+
+
+def point_seg_dist(px: float, py: float, ax: float, ay: float, bx: float, by: float) -> float:
+    dx = bx - ax
+    dy = by - ay
+    len_sq = dx * dx + dy * dy
+    if len_sq < 1e-12:
+        return math.hypot(px - ax, py - ay)
+    t = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / len_sq))
+    return math.hypot(px - (ax + t * dx), py - (ay + t * dy))
+
+
+# ---------------------------------------------------------------------------
+# Union-Find
+# ---------------------------------------------------------------------------
+
+
+class UnionFind:
+    def __init__(self, n: int) -> None:
+        self.parent = list(range(n))
+        self.rank = [0] * n
+        self.size = [1] * n
+        self.num_sets = n
+
+    def find(self, x: int) -> int:
+        while self.parent[x] != x:
+            self.parent[x] = self.parent[self.parent[x]]
+            x = self.parent[x]
+        return x
+
+    def set_size(self, x: int) -> int:
+        return self.size[self.find(x)]
+
+    def union(self, a: int, b: int) -> bool:
+        ra, rb = self.find(a), self.find(b)
+        if ra == rb:
+            return False
+        if self.rank[ra] < self.rank[rb]:
+            ra, rb = rb, ra
+        self.parent[rb] = ra
+        self.size[ra] += self.size[rb]
+        if self.rank[ra] == self.rank[rb]:
+            self.rank[ra] += 1
+        self.num_sets -= 1
+        return True
+
+
+# ---------------------------------------------------------------------------
+# Graph construction — planar, no-dot-crossing edge set
+# ---------------------------------------------------------------------------
+
+
+def place_dots(
+    rng: random.Random,
+    grid_rows: int,
+    grid_cols: int,
+    num_dots: int,
+    min_gap: float,
+    border_margin: int = 5,
+    max_attempts: int = 8000,
+) -> List[Cell]:
+    cells: List[Cell] = []
+    lo_r, hi_r = border_margin, grid_rows - border_margin
+    lo_c, hi_c = border_margin, grid_cols - border_margin
+    for _ in range(max_attempts):
+        if len(cells) == num_dots:
+            break
+        r = rng.randint(lo_r, hi_r - 1)
+        c = rng.randint(lo_c, hi_c - 1)
+        if all(math.hypot(r - er, c - ec) >= min_gap for er, ec in cells):
+            cells.append((r, c))
+    return cells
+
+
+def build_planar_edge_set(
+    dots: List[Cell],
+    dot_radius: float,
+    max_edge_len: float,
+) -> List[Tuple[int, int, float]]:
+    """
+    Build a set of edges that:
+      1. Are shorter than max_edge_len
+      2. Don't pass within dot_radius of any other dot
+      3. Don't cross each other (planar)
+    Returns list of (i, j, dist) sorted by dist, with the planar filter applied.
+    """
+    n = len(dots)
+
+    # Step 1: candidate edges sorted by length, filtered by dot clearance
+    candidates: List[Tuple[float, int, int]] = []
+    for i in range(n):
+        ri, ci = dots[i]
+        for j in range(i + 1, n):
+            rj, cj = dots[j]
+            d = math.hypot(ri - rj, ci - cj)
+            if d > max_edge_len:
+                continue
+            # Check this edge doesn't pass near any other dot
+            clear = True
+            for k in range(n):
+                if k == i or k == j:
+                    continue
+                if point_seg_dist(dots[k][0], dots[k][1], ri, ci, rj, cj) < dot_radius + 0.8:
+                    clear = False
+                    break
+            if clear:
+                candidates.append((d, i, j))
+    candidates.sort()
+
+    # Step 2: greedily add edges, skip if they cross an already-added edge
+    accepted: List[Tuple[int, int, float]] = []
+    # For fast crossing checks, store segment coords
+    seg_coords: List[Tuple[float, float, float, float]] = []
+
+    for dist, i, j in candidates:
+        ri, ci = dots[i]
+        rj, cj = dots[j]
+        crosses = False
+        for ax, ay, bx, by in seg_coords:
+            # Skip if shared endpoint
+            if (ri == ax and ci == ay) or (ri == bx and ci == by) or \
+               (rj == ax and cj == ay) or (rj == bx and cj == by):
+                continue
+            if segments_intersect_properly(ri, ci, rj, cj, ax, ay, bx, by):
+                crosses = True
+                break
+        if not crosses:
+            accepted.append((i, j, dist))
+            seg_coords.append((float(ri), float(ci), float(rj), float(cj)))
+
+    return accepted
+
+
+def build_spanning_forest(
+    rng: random.Random,
+    n: int,
+    planar_edges: List[Tuple[int, int, float]],
+    num_components: int,
+) -> Tuple[List[Tuple[int, int]], List[List[int]]]:
+    """
+    From the planar edge set, build a spanning forest with exactly
+    num_components trees using Union-Find.
+
+    Strategy: shuffle edges, greedily merge until we reach the target
+    number of components. Then collect extra intra-component edges.
+    """
+    uf = UnionFind(n)
+
+    # We need to reduce n sets down to num_components, so we need n - num_components merges.
+    target_merges = n - num_components
+
+    # Cap: no single component should exceed ~2x the ideal even share.
+    max_component_size = max(4, (n // num_components) * 2)
+
+    # Shuffle edges but bias toward shorter ones: split into short/long halves,
+    # shuffle each, concatenate.
+    mid = len(planar_edges) // 2
+    short = list(planar_edges[:mid])
+    long = list(planar_edges[mid:])
+    rng.shuffle(short)
+    rng.shuffle(long)
+    shuffled = short + long
+
+    tree_edges: List[Tuple[int, int]] = []
+    deferred: List[Tuple[int, int, float]] = []
+    extra_edges: List[Tuple[int, int]] = []
+
+    for i, j, d in shuffled:
+        if uf.find(i) != uf.find(j):
+            if len(tree_edges) < target_merges:
+                merged_size = uf.set_size(i) + uf.set_size(j)
+                if merged_size <= max_component_size:
+                    uf.union(i, j)
+                    tree_edges.append((i, j))
+                else:
+                    deferred.append((i, j, d))
+            else:
+                extra_edges.append((i, j))
+        else:
+            extra_edges.append((i, j))
+
+    # Second pass: use deferred edges if we still need merges
+    for i, j, _d in deferred:
+        if len(tree_edges) >= target_merges:
+            break
+        if uf.find(i) != uf.find(j):
+            uf.union(i, j)
+            tree_edges.append((i, j))
+
+    # Add some extra intra-component edges for visual richness
+    # Only pick edges where both endpoints are already in the same component
+    intra_edges = [(i, j) for i, j in extra_edges if uf.find(i) == uf.find(j)]
+    rng.shuffle(intra_edges)
+    bonus = min(len(intra_edges), max(n // 6, 3))
+    tree_edges.extend(intra_edges[:bonus])
+
+    # Build component membership
+    comp_map: Dict[int, List[int]] = {}
+    for node in range(n):
+        root = uf.find(node)
+        comp_map.setdefault(root, []).append(node)
+    components = list(comp_map.values())
+
+    return tree_edges, components
+
+
+# ---------------------------------------------------------------------------
+# Instance sampling
+# ---------------------------------------------------------------------------
+
+
+def sample_instance(
+    rng: random.Random,
+    width: int,
+    height: int,
+    grid_rows: int,
+    grid_cols: int,
+    min_components: int,
+    max_components: int,
+    num_dots_min: int,
+    num_dots_max: int,
+    min_gap: float,
+    dot_radius: float,
+    max_edge_len: float,
+    close_strand_tolerance: float = 0.0,
+) -> Dict[str, object] | None:
+    num_components = rng.randint(min_components, max_components)
+    num_dots = rng.randint(max(num_dots_min, num_components * 2), num_dots_max)
+
+    dots = place_dots(rng, grid_rows, grid_cols, num_dots, min_gap)
+    if len(dots) < num_components * 2:
+        return None
+
+    planar_edges = build_planar_edge_set(dots, dot_radius, max_edge_len)
+
+    # Check we have enough edges to connect dots into num_components trees
+    # (need at least len(dots) - num_components edges in a spanning forest)
+    if len(planar_edges) < len(dots) - num_components:
+        return None
+
+    edges, components = build_spanning_forest(rng, len(dots), planar_edges, num_components)
+
+    # Reject if any component has fewer than 2 dots
+    if any(len(c) < 2 for c in components):
+        return None
+
+    actual_components = len(components)
+
+    if actual_components < min_components:
+        return None
+
+    # Enforce close_strand_tolerance: dots from different components must be
+    # at least this many grid units apart (visual separation).
+    if close_strand_tolerance > 0:
+        node_to_comp = {}
+        for ci, comp in enumerate(components):
+            for node in comp:
+                node_to_comp[node] = ci
+        for a in range(len(dots)):
+            ra, ca = dots[a]
+            for b in range(a + 1, len(dots)):
+                if node_to_comp[a] == node_to_comp[b]:
+                    continue
+                rb, cb = dots[b]
+                if math.hypot(ra - rb, ca - cb) < close_strand_tolerance:
+                    return None
+
+    margin = int(min(width, height) * 0.10)
+    square_size = min(width, height) - 2 * margin
+    square_left = (width - square_size) / 2.0
+    square_top = (height - square_size) / 2.0
+
+    return {
+        "width": width,
+        "height": height,
+        "grid_rows": grid_rows,
+        "grid_cols": grid_cols,
+        "square_left": round(square_left, 2),
+        "square_top": round(square_top, 2),
+        "square_size": round(square_size, 2),
+        "num_components": actual_components,
+        "num_dots": len(dots),
+        "question": (
+            "How many connected components are there in the image? "
+            "A connected component is a maximal group of dots such that any two dots "
+            "in the group are linked by a path of one or more drawn line segments "
+            "(directly or through other dots in the same group). "
+            "Every component contains at least two dots. "
+            "Two dots that are not linked by any chain of line segments "
+            "belong to different components, even if they appear visually close. "
+            "Count every connected component and report the total. "
+            "Provide your final answer enclosed in <answer>...</answer> tags."
+        ),
+        "answer": actual_components,
+        "dots": [[r, c] for r, c in dots],
+        "components": components,
+        "edges": [[i, j] for i, j in edges],
+        "dot_radius": dot_radius,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Rendering (matplotlib — smooth anti-aliased output)
+# ---------------------------------------------------------------------------
+
+LINE_COLOR = "#2f2f2f"
+DOT_COLOR = "#1d1916"
+
+
+def render_instance(out_path: Path, record: Dict[str, object], noise_seed: int = 0) -> None:
+    width = int(record["width"])
+    height = int(record["height"])
+    grid_rows = int(record["grid_rows"])
+    grid_cols = int(record["grid_cols"])
+    square_left = float(record["square_left"])
+    square_top = float(record["square_top"])
+    square_size = float(record["square_size"])
+    dots: List[List[int]] = record["dots"]  # type: ignore[assignment]
+    edges: List[List[int]] = record["edges"]  # type: ignore[assignment]
+    dot_radius_grid = float(record["dot_radius"])
+
+    cell_w = square_size / grid_cols
+    cell_h = square_size / grid_rows
+
+    def to_pixel(r: float, c: float) -> Tuple[float, float]:
+        px = square_left + (c + 0.5) * cell_w
+        py = square_top + (r + 0.5) * cell_h
+        return px, py
+
+    pixel_dot_radius = dot_radius_grid * min(cell_w, cell_h) * 0.5
+    edge_thickness = max(1.5, pixel_dot_radius * 0.3)
+
+    fig = plt.figure(figsize=(width / 100, height / 100), dpi=100)
+    ax = fig.add_axes([0, 0, 1, 1])
+    ax.set_xlim(0, width)
+    ax.set_ylim(height, 0)
+    ax.axis("off")
+    ax.set_facecolor("#f8f6f0")
+
+    # Subtle noise background
+    nrng = np.random.default_rng(noise_seed)
+    noise = nrng.normal(0.0, 1.0, size=(height, width))
+    noise = (noise - noise.min()) / max(noise.max() - noise.min(), 1e-6)
+    ax.imshow(noise, cmap="Greys", alpha=0.05, extent=(0, width, height, 0),
+              interpolation="bilinear")
+
+    # White square background
+    ax.fill_between(
+        [square_left, square_left + square_size],
+        [square_top, square_top],
+        [square_top + square_size, square_top + square_size],
+        color="#fffdf8", zorder=0.5,
+    )
+
+    # Border
+    border_lw = 2.0
+    bx = [square_left, square_left + square_size, square_left + square_size, square_left, square_left]
+    by = [square_top, square_top, square_top + square_size, square_top + square_size, square_top]
+    ax.plot(bx, by, color="#2d2720", linewidth=border_lw, solid_capstyle="round", zorder=1.0)
+
+    # Plain (v4_plain): solid edges. No dashed-line anti-shortcut.
+    for i, j in edges:
+        px1, py1 = to_pixel(dots[i][0], dots[i][1])
+        px2, py2 = to_pixel(dots[j][0], dots[j][1])
+        ax.plot([px1, px2], [py1, py2],
+                color=LINE_COLOR, linewidth=edge_thickness,
+                solid_capstyle="round", alpha=0.92, zorder=2.0)
+
+    # Dots on top
+    for r, c in dots:
+        px, py = to_pixel(r, c)
+        circle = plt.Circle((px, py), pixel_dot_radius, color=DOT_COLOR, zorder=3.0)
+        ax.add_patch(circle)
+
+    fig.savefig(out_path, dpi=100, bbox_inches="tight", pad_inches=0)
+    plt.close(fig)
+
+
+# ---------------------------------------------------------------------------
+# Dataset generation
+# ---------------------------------------------------------------------------
+
+
+def ensure_output_dir(root: Path) -> Tuple[Path, Path]:
+    root.mkdir(parents=True, exist_ok=True)
+    images_dir = root / "images"
+    images_dir.mkdir(exist_ok=True)
+    return root, images_dir
+
+
+def generate_dataset(
+    rng: random.Random,
+    count: int,
+    output_dir: Path,
+    images_dir: Path,
+    width: int,
+    height: int,
+    grid_rows: int,
+    grid_cols: int,
+    min_components: int,
+    max_components: int,
+    num_dots_min: int,
+    num_dots_max: int,
+    min_gap: float,
+    dot_radius: float,
+    max_edge_len: float,
+    close_strand_tolerance: float = 0.0,
+) -> None:
+    records: List[Dict[str, object]] = []
+    data_records: List[Dict[str, object]] = []
+
+    # Force evenly-spaced answers across [min_components, max_components].
+    if count > 1:
+        forced_targets = [
+            int(round(min_components + i * (max_components - min_components) / (count - 1)))
+            for i in range(count)
+        ]
+    else:
+        forced_targets = [min_components]
+    print(f"forced component counts: {forced_targets}")
+
+    for idx in range(count):
+        sub_seed = rng.randint(0, 2**31 - 1)
+        tgt = forced_targets[idx]
+        for _ in range(2000):
+            record = sample_instance(
+                rng=rng,
+                width=width,
+                height=height,
+                grid_rows=grid_rows,
+                grid_cols=grid_cols,
+                min_components=tgt,
+                max_components=tgt,
+                num_dots_min=num_dots_min,
+                num_dots_max=num_dots_max,
+                min_gap=min_gap,
+                dot_radius=dot_radius,
+                max_edge_len=max_edge_len,
+                close_strand_tolerance=close_strand_tolerance,
+            )
+            if record is not None and record.get("answer") == tgt:
+                break
+        else:
+            print(f"Warning: could not generate sample {idx}, skipping")
+            continue
+
+        image_name = f"counting_connected_components_{idx:05d}.png"
+        render_instance(images_dir / image_name, record, noise_seed=sub_seed)
+        record["image"] = f"images/{image_name}"
+        records.append(record)
+        data_records.append({
+            "image": record["image"],
+            "question": record["question"],
+            "answer": record["answer"],
+        })
+        print(f"  [{idx+1}/{count}] components={record['answer']} dots={record['num_dots']}")
+
+    with (output_dir / "annotations.jsonl").open("w", encoding="utf-8") as fh:
+        for record in records:
+            fh.write(json.dumps(record) + "\n")
+
+    data_json = {
+        "task": "counting_connected_components",
+        "category": "distributed_scanning",
+        "count": len(data_records),
+        "items": data_records,
+    }
+    with (output_dir / "data.json").open("w", encoding="utf-8") as fh:
+        json.dump(data_json, fh, indent=2)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Generate a counting-connected-components dataset.")
+    parser.add_argument("--output-root", type=Path, required=True, help="Dataset root directory.")
+    parser.add_argument("--count", type=int, default=30)
+    parser.add_argument("--width", type=int, default=1024)
+    parser.add_argument("--height", type=int, default=1024)
+    parser.add_argument("--grid-rows", type=int, default=100)
+    parser.add_argument("--grid-cols", type=int, default=100)
+    parser.add_argument("--min-components", type=int, default=4)
+    parser.add_argument("--max-components", type=int, default=12)
+    parser.add_argument("--num-dots-min", type=int, default=60)
+    parser.add_argument("--num-dots-max", type=int, default=120)
+    parser.add_argument("--min-gap", type=float, default=5.0)
+    parser.add_argument("--dot-radius", type=float, default=1.5)
+    parser.add_argument("--max-edge-len", type=float, default=25.0)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--difficulty", type=int, default=5,
+                        help="Integer difficulty >=0; scales components and dot count.")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    rng = random.Random(args.seed)
+    output_dir, images_dir = ensure_output_dir(args.output_root)
+    d = max(0, int(args.difficulty))
+    # Difficulty scaling per spec
+    min_components = 10
+    max_components = 10 + 2 * d
+    num_dots_min = 40
+    num_dots_max = 40 + 20 * d
+    close_strand_tolerance = float(max(3, 8 - d))
+
+    # Canvas scaling based on num_dots_max growth
+    N_d = 20 + 10 * d
+    N_0 = 20
+    s = math.sqrt(max(1.0, N_d / N_0))
+    args.width = int(round(args.width * s))
+    args.height = int(round(args.height * s))
+
+    generate_dataset(
+        rng=rng,
+        count=args.count,
+        output_dir=output_dir,
+        images_dir=images_dir,
+        width=args.width,
+        height=args.height,
+        grid_rows=args.grid_rows,
+        grid_cols=args.grid_cols,
+        min_components=min_components,
+        max_components=max_components,
+        num_dots_min=num_dots_min,
+        num_dots_max=num_dots_max,
+        min_gap=args.min_gap,
+        dot_radius=args.dot_radius,
+        max_edge_len=args.max_edge_len,
+        close_strand_tolerance=close_strand_tolerance,
+    )
+    print(f"Saved dataset to {args.output_root}")
+
+
+if __name__ == "__main__":
+    main()

code/distributed_scanning/counting_connected_components/data.json

@@ -0,0 +1,32 @@
+{
+  "task": "counting_connected_components",
+  "category": "distributed_scanning",
+  "count": 5,
+  "items": [
+    {
+      "image": "images/counting_connected_components_00000.png",
+      "question": "How many connected components are there in the image? A connected component is a maximal group of anchor points such that any two are linked by a path of one or more strands (directly or through other anchors in the same group). Anchors not linked by any chain belong to different components, even if they appear visually close. Count every connected component and report the total. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 10
+    },
+    {
+      "image": "images/counting_connected_components_00001.png",
+      "question": "How many connected components are there in the image? A connected component is a maximal group of anchor points such that any two are linked by a path of one or more strands (directly or through other anchors in the same group). Anchors not linked by any chain belong to different components, even if they appear visually close. Count every connected component and report the total. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 12
+    },
+    {
+      "image": "images/counting_connected_components_00002.png",
+      "question": "How many connected components are there in the image? A connected component is a maximal group of anchor points such that any two are linked by a path of one or more strands (directly or through other anchors in the same group). Anchors not linked by any chain belong to different components, even if they appear visually close. Count every connected component and report the total. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 15
+    },
+    {
+      "image": "images/counting_connected_components_00003.png",
+      "question": "How many connected components are there in the image? A connected component is a maximal group of anchor points such that any two are linked by a path of one or more strands (directly or through other anchors in the same group). Anchors not linked by any chain belong to different components, even if they appear visually close. Count every connected component and report the total. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 18
+    },
+    {
+      "image": "images/counting_connected_components_00004.png",
+      "question": "How many connected components are there in the image? A connected component is a maximal group of anchor points such that any two are linked by a path of one or more strands (directly or through other anchors in the same group). Anchors not linked by any chain belong to different components, even if they appear visually close. Count every connected component and report the total. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 20
+    }
+  ]
+}

code/distributed_scanning/counting_regions/creation.md

@@ -0,0 +1,170 @@
+# Counting Regions Dataset Generation
+
+## Goal
+
+Create tasks where the model counts separated regions in an image. Each
+region inside the central square is filled with a distinctive
+gradient + texture combination, and adjacent regions are guaranteed to
+look visually different so a human can read them apart.
+
+The image always contains a square in the central area. Inside the
+square the canvas is partitioned into irregular regions; outside the
+square stays plain.
+
+## Core Task
+
+Given an image containing one central square, answer:
+
+- `How many separated regions are inside the square?`
+
+The answer is a positive integer.
+
+## Visual Structure
+
+- Single square placed near the centre of the canvas with a thin dark
+  border. Everything outside is a plain off-white background.
+- Inside the square the area is partitioned into irregular regions.
+- Each region is rendered with two cues at once:
+  1. A linear two-colour gradient. The two endpoint colours are drawn
+     from a fixed palette but each region perturbs them in HSV space
+     so no two regions render identical colours globally — colour
+     histograms cannot recover the count.
+  2. A texture pattern (speckle, horizontal / vertical / diagonal
+     stripes, dots, or perlin-like band) modulated multiplicatively on
+     top of the gradient. Adjacent regions are forced to use different
+     texture styles where possible.
+- Adjacency constraints: for every pair of touching regions, their
+  unordered colour pairs differ AND there is at least ~55° of hue
+  separation at the closest pairing. This guarantees a human-readable
+  contrast across every shared boundary.
+- A low-amplitude global speckle is added across the whole canvas so
+  Canny / Sobel edge detectors fire uniformly inside regions and not
+  only at boundaries — this defeats the simple "boundary-detect →
+  flood-fill" attack.
+- No drawn boundary lines. Region discrimination relies on colour
+  discontinuity and texture-style change, not strokes.
+
+Recommended defaults:
+
+- Image canvas `1024×1024`
+- Painted square `820×820` centred
+- Region-synthesis grid `50×50` (low resolution → upsampled with smooth
+  per-region masks)
+- Number of final regions in the range `6-12`
+
+## Generation Procedure
+
+### 1. Sample target count and partition
+
+- Sample target `K` in `[min_regions, max_regions]`.
+- Choose `K` spaced seed cells on a 50×50 lattice.
+- Grow connected regions from the seeds via priority-queue expansion,
+  weighted by per-region noise fields so boundaries are organic.
+
+### 2. Upsample and clean
+
+- Upsample the label map from 50×50 to canvas resolution by
+  per-region soft-mask interpolation + argmax (smooth boundaries
+  without aliasing).
+- Absorb tiny connected-component slivers (< 0.2 % of canvas) into
+  their dominant neighbour label.
+- Relabel region ids contiguously after cleanup.
+- **Reject** the sample if the smallest remaining region covers less
+  than `min_region_frac` (default 2.5 %) of the canvas — this avoids
+  tiny near-invisible regions slipping through.
+
+### 3. Assign gradient + texture per region
+
+- Build the region adjacency graph at canvas resolution.
+- Greedy assignment over regions (descending degree first):
+  - Pick `(colour_a, colour_b)` from the palette such that no
+    neighbour shares the same unordered pair AND `pair_hue_gap` to
+    every neighbour is at least `hue_gap_min` (default 55°).
+  - Apply per-region HSV jitter (≈±18° hue, ±0.12 sat, ±0.10 val) to
+    the two endpoints.
+  - Pick a random gradient angle.
+- Assign a texture style + parameters per region, preferring styles
+  not used by already-assigned neighbours.
+
+### 4. Render
+
+- For each region, paint the linear gradient between its two jittered
+  endpoint colours along the chosen angle.
+- Multiply by `(1 + amp · texture)` per pixel to add the per-region
+  texture modulation.
+- Multiply by `(1 + 0.05 · global_speckle)` to add the canvas-wide
+  high-frequency noise that drowns Canny boundary detection.
+- Composite the painted square onto the off-white canvas with a thin
+  dark border.
+
+## Quality Checks
+
+Reject or regenerate samples if:
+
+- after cleanup the actual region count drops below 2
+- any region is smaller than `min_region_frac` of the canvas
+- gradient assignment fails to satisfy the adjacency constraints
+
+The final `answer` field always reflects the post-cleanup region
+count, which may differ from the sampled target `K`.
+
+## Anti-Shortcut Notes
+
+The previous version used dashed boundary lines on a uniform fill,
+which was defeated in one step by `cv2.dilate(boundary, k)` followed
+by `cv2.connectedComponents`. The new rendering blocks several attack
+families simultaneously:
+
+- **Boundary edge detection (Canny / Sobel)**: drowned by global
+  speckle + per-region texture so edges fire uniformly across the
+  whole image rather than only at region boundaries.
+- **Colour histogram / k-means clustering**: the per-region HSV
+  jitter ensures each region renders unique pixel colours even when
+  two regions share the same palette anchors, so cluster counts have
+  no clean correspondence to region counts.
+- **LAB-space quantisation + connected components**: same — the
+  jitter scatters pixels across many quantisation bins per region.
+- **Smooth-then-detect (Gaussian / median / bilateral filter +
+  Canny)**: smoothing strong enough to kill the texture also blurs
+  region boundaries enough that small regions merge.
+
+Empirically, the strongest CV attack tested (`median13 + Canny`) gives
+MAE ~3.5 with 0/6 exact across a held-out set of v7 prototypes.
+
+## Annotation Format
+
+Each sample stores the partition metadata required to reproduce or
+verify the answer:
+
+```json
+{
+  "image": "images/counting_regions_00000.png",
+  "width": 1024,
+  "height": 1024,
+  "grid_rows": 50,
+  "grid_cols": 50,
+  "square_left": 102.0,
+  "square_top": 102.0,
+  "square_size": 820.0,
+  "num_regions": 7,
+  "question": "How many separated regions are inside the square? ...",
+  "answer": 7,
+  "difficulty": "medium",
+  "region_seed_cells": [...],
+  "region_cell_counts": [...],
+  "region_adjacency": [[0, 2], [0, 3], ...]
+}
+```
+
+## Output Organization
+
+```text
+counting_regions/
+  creation.py
+  creation.md
+  annotations.jsonl
+  data.json
+  images/
+    counting_regions_00000.png
+    ...
+```

code/distributed_scanning/counting_regions/creation.py

@@ -0,0 +1,783 @@
+from __future__ import annotations
+
+import argparse
+import colorsys
+import heapq
+import json
+import math
+import random
+from collections import deque
+from pathlib import Path
+from typing import Dict, List, Sequence, Tuple
+
+import cv2
+import numpy as np
+from PIL import Image
+from scipy.ndimage import zoom
+from tqdm import tqdm
+
+
+Cell = Tuple[int, int]
+Point = Tuple[int, int]
+Grid = List[List[int]]
+
+
+# ── Palette + colour helpers ───────────────────────────────────────────
+
+PALETTE = [
+    (236, 152, 99),    # peach
+    (111, 163, 220),   # clear blue
+    (140, 197, 113),   # grass green
+    (223, 127, 186),   # pink
+    (194, 160, 85),    # ochre
+    (157, 134, 212),   # purple
+    (237, 211, 81),    # yellow
+    (75, 184, 173),    # teal
+    (224, 122, 112),   # coral red
+    (122, 160, 106),   # sage
+]
+
+PALETTE_HUE = [
+    colorsys.rgb_to_hsv(r / 255, g / 255, b / 255)[0] * 360
+    for r, g, b in PALETTE
+]
+
+
+def hue_gap(h1: float, h2: float) -> float:
+    d = abs(h1 - h2) % 360
+    return min(d, 360 - d)
+
+
+def pair_hue_gap(pair_a: Tuple[int, int], pair_b: Tuple[int, int]) -> float:
+    """Maximum, over each colour in pair_a, of the nearest hue distance to
+    any colour in pair_b. Tells us how visually contrastable the two pairs
+    are at their closest point."""
+    best = 0.0
+    for ca in pair_a:
+        nearest = min(hue_gap(PALETTE_HUE[ca], PALETTE_HUE[cb]) for cb in pair_b)
+        best = max(best, nearest)
+    return best
+
+
+def jitter_color(
+    rng: random.Random,
+    rgb: Tuple[int, int, int],
+    hue_jitter: float = 18.0,
+    sat_jitter: float = 0.12,
+    val_jitter: float = 0.10,
+) -> Tuple[float, float, float]:
+    """Apply small HSV perturbation to a palette anchor so each region's
+    rendered endpoints are unique (defeats colour-histogram attacks)."""
+    r, g, b = [c / 255.0 for c in rgb]
+    h, s, v = colorsys.rgb_to_hsv(r, g, b)
+    h = (h + rng.uniform(-hue_jitter, hue_jitter) / 360.0) % 1.0
+    s = max(0.0, min(1.0, s + rng.uniform(-sat_jitter, sat_jitter)))
+    v = max(0.0, min(1.0, v + rng.uniform(-val_jitter, val_jitter)))
+    rr, gg, bb = colorsys.hsv_to_rgb(h, s, v)
+    return (rr * 255.0, gg * 255.0, bb * 255.0)
+
+
+# ── Partition (connected-component growing on a small grid) ────────────
+
+def sample_spaced_cells(
+    rng: random.Random,
+    rows: int,
+    cols: int,
+    count: int,
+    min_dist: float,
+    max_attempts: int = 800,
+) -> List[Cell]:
+    cells: List[Cell] = []
+    for _ in range(max_attempts):
+        if len(cells) == count:
+            break
+        candidate = (rng.randrange(rows), rng.randrange(cols))
+        if all(math.hypot(candidate[0] - r, candidate[1] - c) >= min_dist for r, c in cells):
+            cells.append(candidate)
+    while len(cells) < count:
+        candidate = (rng.randrange(rows), rng.randrange(cols))
+        if candidate not in cells:
+            cells.append(candidate)
+    return cells
+
+
+def _make_noise_field(rng: random.Random, rows: int, cols: int, scale: int = 15) -> np.ndarray:
+    lo_r = max(2, rows // scale)
+    lo_c = max(2, cols // scale)
+    lo = np.array([[rng.gauss(0, 1) for _ in range(lo_c)] for _ in range(lo_r)])
+    field = zoom(lo, (rows / lo_r, cols / lo_c), order=1)
+    return field[:rows, :cols]
+
+
+def make_connected_partition(
+    rng: random.Random,
+    rows: int,
+    cols: int,
+    num_regions: int,
+) -> Tuple[np.ndarray, List[Cell]]:
+    """Two-phase partition.
+
+    Phase 1 (sequential round-robin): each region in turn claims one
+    cell from its current frontier, repeated until every region has at
+    least `min_cells_per_region` cells. This guarantees a minimum size
+    for every region and prevents tiny / vanishing regions.
+
+    Phase 2 (priority-queue Voronoi-like): the remaining unclaimed cells
+    are distributed using the original distance-to-centroid + noise-field
+    cost so the final boundaries look organic.
+    """
+    labels = np.full((rows, cols), -1, dtype=np.int32)
+    seeds = sample_spaced_cells(
+        rng=rng,
+        rows=rows,
+        cols=cols,
+        count=num_regions,
+        min_dist=max(2.2, min(rows, cols) / max(3.4, math.sqrt(num_regions) + 0.5)),
+    )
+    dirs = [(-1, 0), (1, 0), (0, -1), (0, 1)]
+    cr = [float(r) for r, c in seeds]
+    cc = [float(c) for r, c in seeds]
+    size = [1] * num_regions
+
+    # ── Phase 1: sequential round-robin grow ──
+    fair_share = (rows * cols) // num_regions
+    min_cells_per_region = max(8, (fair_share * 7) // 10)  # 70% of fair share floor
+    frontiers: List[List[Cell]] = [[] for _ in range(num_regions)]
+    for rid, (r, c) in enumerate(seeds):
+        labels[r, c] = rid
+        for dr, dc in dirs:
+            nr, nc = r + dr, c + dc
+            if 0 <= nr < rows and 0 <= nc < cols and labels[nr, nc] == -1:
+                frontiers[rid].append((nr, nc))
+
+    while True:
+        # Stop when every region reached the minimum, OR no region can grow.
+        if all(s >= min_cells_per_region for s in size):
+            break
+        progress = False
+        for rid in range(num_regions):
+            if size[rid] >= min_cells_per_region:
+                continue
+            # Pull a random claimable cell from this region's frontier.
+            f = frontiers[rid]
+            while f:
+                idx = rng.randrange(len(f))
+                nr, nc = f.pop(idx)
+                if labels[nr, nc] != -1:
+                    continue
+                labels[nr, nc] = rid
+                n = size[rid]
+                cr[rid] = (cr[rid] * n + nr) / (n + 1)
+                cc[rid] = (cc[rid] * n + nc) / (n + 1)
+                size[rid] += 1
+                for dr, dc in dirs:
+                    rr, ccc = nr + dr, nc + dc
+                    if 0 <= rr < rows and 0 <= ccc < cols and labels[rr, ccc] == -1:
+                        f.append((rr, ccc))
+                progress = True
+                break
+        if not progress:
+            break  # all frontiers exhausted (only possible at very high n)
+
+    # ── Phase 2: priority-queue grow on remaining cells ──
+    fields = [_make_noise_field(rng, rows, cols, scale=15) for _ in range(num_regions)]
+    noise_strength = rows * cols * 0.03
+    heap: list = []
+    for rid in range(num_regions):
+        for nr, nc in frontiers[rid]:
+            if labels[nr, nc] == -1:
+                d = (nr - cr[rid]) ** 2 + (nc - cc[rid]) ** 2
+                d += fields[rid][nr, nc] * noise_strength
+                d += rng.random() * 5.0
+                heapq.heappush(heap, (d, rid, nr, nc))
+    while heap:
+        _, rid, nr, nc = heapq.heappop(heap)
+        if labels[nr, nc] != -1:
+            continue
+        labels[nr, nc] = rid
+        n = size[rid]
+        cr[rid] = (cr[rid] * n + nr) / (n + 1)
+        cc[rid] = (cc[rid] * n + nc) / (n + 1)
+        size[rid] += 1
+        for dr, dc in dirs:
+            rr, ccc = nr + dr, nc + dc
+            if 0 <= rr < rows and 0 <= ccc < cols and labels[rr, ccc] == -1:
+                d = (rr - cr[rid]) ** 2 + (ccc - cc[rid]) ** 2
+                d += fields[rid][rr, ccc] * noise_strength
+                d += rng.random() * 5.0
+                heapq.heappush(heap, (d, rid, rr, ccc))
+    return labels, seeds
+
+
+def upsample_labels(
+    grid_labels: np.ndarray,
+    canvas_w: int,
+    canvas_h: int,
+    smooth_sigma: float = 4.5,
+) -> np.ndarray:
+    """Upsample a low-resolution label map to canvas size with smooth
+    boundaries by per-region soft-mask interpolation + argmax."""
+    num_regions = int(grid_labels.max()) + 1
+    soft = np.empty((num_regions, canvas_h, canvas_w), dtype=np.float32)
+    for rid in range(num_regions):
+        mask = (grid_labels == rid).astype(np.float32)
+        big = cv2.resize(mask, (canvas_w, canvas_h), interpolation=cv2.INTER_LINEAR)
+        if smooth_sigma > 0:
+            big = cv2.GaussianBlur(big, (0, 0), sigmaX=smooth_sigma, sigmaY=smooth_sigma)
+        soft[rid] = big
+    return np.argmax(soft, axis=0).astype(np.int32)
+
+
+def clean_tiny_components(labels: np.ndarray, min_frac: float = 0.002) -> np.ndarray:
+    """Absorb tiny connected-component specks into the dominant neighbour
+    label. Small ``min_frac`` keeps the cleanup conservative."""
+    h, w = labels.shape
+    threshold = int(h * w * min_frac)
+    out = labels.copy()
+    num_regions = int(labels.max()) + 1
+    for rid in range(num_regions):
+        mask = (out == rid).astype(np.uint8)
+        num, comp = cv2.connectedComponents(mask)
+        sizes = [int((comp == i).sum()) for i in range(num)]
+        if num <= 2:
+            continue
+        keep = max(range(1, num), key=lambda i: sizes[i])
+        for i in range(1, num):
+            if i == keep:
+                continue
+            if sizes[i] < threshold:
+                small = (comp == i)
+                ys, xs = np.where(small)
+                nbrs = []
+                for dy, dx in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
+                    ny, nx = np.clip(ys + dy, 0, h - 1), np.clip(xs + dx, 0, w - 1)
+                    nbrs.append(out[ny, nx])
+                nbr_labels = np.concatenate(nbrs)
+                nbr_labels = nbr_labels[nbr_labels != rid]
+                if len(nbr_labels) == 0:
+                    continue
+                replacement = int(np.bincount(nbr_labels).argmax())
+                out[small] = replacement
+    return out
+
+
+def relabel_contiguous(labels: np.ndarray) -> Tuple[np.ndarray, int]:
+    unique = np.unique(labels)
+    remap = -np.ones(int(unique.max()) + 1, dtype=np.int32)
+    for new_id, old_id in enumerate(unique):
+        remap[old_id] = new_id
+    return remap[labels], len(unique)
+
+
+def adjacency_from_labels(labels: np.ndarray) -> Dict[int, set]:
+    n = int(labels.max()) + 1
+    adj: Dict[int, set] = {rid: set() for rid in range(n)}
+    diff_h = labels[:, :-1] != labels[:, 1:]
+    a_h = labels[:, :-1][diff_h]
+    b_h = labels[:, 1:][diff_h]
+    diff_v = labels[:-1, :] != labels[1:, :]
+    a_v = labels[:-1, :][diff_v]
+    b_v = labels[1:, :][diff_v]
+    for a, b in zip(a_h.tolist(), b_h.tolist()):
+        adj[a].add(b)
+        adj[b].add(a)
+    for a, b in zip(a_v.tolist(), b_v.tolist()):
+        adj[a].add(b)
+        adj[b].add(a)
+    return adj
+
+
+def adjacency_pairs(labels: np.ndarray) -> List[Tuple[int, int]]:
+    adj = adjacency_from_labels(labels)
+    edges: set[Tuple[int, int]] = set()
+    for a, neighbours in adj.items():
+        for b in neighbours:
+            if a < b:
+                edges.add((a, b))
+    return sorted(edges)
+
+
+# ── Gradient assignment with adjacency constraints ────────────────────
+
+def assign_gradients(
+    rng: random.Random,
+    num_regions: int,
+    adj: Dict[int, set],
+    hue_gap_min: float = 55.0,
+    max_attempts: int = 400,
+) -> List[Tuple[Tuple[float, float, float], Tuple[float, float, float], float]] | None:
+    """Greedy assignment with restart. Adjacent regions must differ in
+    their unordered colour pair AND have at least ``hue_gap_min`` degrees
+    of hue separation at their closest pairing."""
+    palette_size = len(PALETTE)
+    order = sorted(range(num_regions), key=lambda r: -len(adj[r]))
+
+    # Since pure-flat fill uses only the FIRST colour of each pair, enforce
+    # that the FIRST hues of adjacent regions are well separated, in addition
+    # to the original pair-hue-gap constraint.
+    PRIMARY_HUE_GAP_MIN = 60.0
+
+    for _ in range(max_attempts):
+        pairs: List[Tuple[int, int] | None] = [None] * num_regions
+        ok = True
+        for rid in order:
+            cand = []
+            for a in range(palette_size):
+                for b in range(a + 1, palette_size):
+                    cand.append((a, b))
+            rng.shuffle(cand)
+            chosen = None
+            for a, b in cand:
+                valid = True
+                for n in adj[rid]:
+                    if pairs[n] is None:
+                        continue
+                    na, nb = pairs[n][0], pairs[n][1]
+                    if {a, b} == {na, nb}:
+                        valid = False
+                        break
+                    if pair_hue_gap((a, b), (na, nb)) < hue_gap_min:
+                        valid = False
+                        break
+                    if hue_gap(PALETTE_HUE[a], PALETTE_HUE[na]) < PRIMARY_HUE_GAP_MIN:
+                        valid = False
+                        break
+                if valid:
+                    chosen = (a, b)
+                    break
+            if chosen is None:
+                ok = False
+                break
+            pairs[rid] = chosen
+        if ok:
+            angles = [rng.uniform(0, 2 * math.pi) for _ in range(num_regions)]
+            jittered = []
+            for p, ang in zip(pairs, angles):
+                ca = jitter_color(rng, PALETTE[p[0]])
+                cb = jitter_color(rng, PALETTE[p[1]])
+                jittered.append((ca, cb, ang))
+            return jittered
+    return None
+
+
+# ── Per-region textures (defeat canny + colour-cluster attacks) ───────
+
+TEXTURE_STYLES = ["speckle", "stripes_h", "stripes_v", "stripes_d1",
+                  "stripes_d2", "dots", "perlin"]
+
+
+def assign_textures(
+    rng: random.Random,
+    num_regions: int,
+    adj: Dict[int, set],
+) -> List[Tuple[str, Dict[str, float]]]:
+    """Pick a (style, params) per region. Adjacent regions get different
+    styles where possible so texture acts as a region cue for humans."""
+    out: List[Tuple[str, Dict[str, float]]] = []
+    for rid in range(num_regions):
+        used_by_neighbours = {out[n][0] for n in adj[rid] if n < rid}
+        candidates = [s for s in TEXTURE_STYLES if s not in used_by_neighbours]
+        if not candidates:
+            candidates = TEXTURE_STYLES
+        style = rng.choice(candidates)
+        params = {
+            "freq": rng.uniform(0.08, 0.22),
+            "amp": rng.uniform(0.08, 0.16),
+            "orient": rng.uniform(0, math.pi),
+            "speckle_seed": rng.randint(0, 2**31 - 1),
+        }
+        out.append((style, params))
+    return out
+
+
+def make_texture(style: str, params: Dict[str, float], h: int, w: int, rng_seed: int) -> np.ndarray:
+    rng = np.random.default_rng(rng_seed)
+    ys, xs = np.mgrid[0:h, 0:w].astype(np.float32)
+    freq = params["freq"]
+    orient = params["orient"]
+    if style == "speckle":
+        n = rng.standard_normal((h, w)).astype(np.float32)
+        return cv2.GaussianBlur(n, (0, 0), sigmaX=0.7) * 1.4
+    if style.startswith("stripes"):
+        if style == "stripes_h":
+            theta = 0.0
+        elif style == "stripes_v":
+            theta = math.pi / 2
+        elif style == "stripes_d1":
+            theta = math.pi / 4
+        else:
+            theta = -math.pi / 4
+        u = xs * math.cos(theta) + ys * math.sin(theta)
+        return np.sin(u * freq * 2 * math.pi).astype(np.float32)
+    if style == "dots":
+        u = xs * freq * 2 * math.pi
+        v = ys * freq * 2 * math.pi
+        return (np.sin(u) * np.sin(v)).astype(np.float32) * 1.2
+    if style == "perlin":
+        a = np.sin((xs * math.cos(orient) + ys * math.sin(orient)) * freq * 2 * math.pi)
+        b = np.cos((xs * math.cos(orient + 1.1) + ys * math.sin(orient + 1.1)) * freq * 1.7 * 2 * math.pi)
+        return ((a + b) * 0.5).astype(np.float32)
+    return np.zeros((h, w), dtype=np.float32)
+
+
+# ── Renderer ──────────────────────────────────────────────────────────
+
+def render_region_canvas(
+    labels: np.ndarray,
+    assignments: List[Tuple],
+    textures: List[Tuple[str, Dict[str, float]]],
+    global_speckle: float = 0.05,
+) -> np.ndarray:
+    """Paint each region with its (gradient + texture). No drawn boundary
+    lines — region discrimination relies on colour discontinuity and
+    texture-style change."""
+    h, w = labels.shape
+    # SINGLE global base colour (warm light grey) across the whole canvas.
+    # Region labels and per-region palette assignments are intentionally
+    # ignored: the goal is one uniform texture that flows continuously
+    # across the entire image, so the only visible cue for the partition
+    # is the boundary line drawn on top by render_instance.
+    base = np.array([220.0, 215.0, 205.0], dtype=np.float32)
+    img = np.broadcast_to(base, (h, w, 3)).copy()
+
+    # Two-octave smooth noise field across the whole canvas, plus fine grain.
+    rng_np = np.random.default_rng(0xC0FFEE)
+    big = rng_np.standard_normal((h, w)).astype(np.float32)
+    big = cv2.GaussianBlur(big, (0, 0), sigmaX=h / 6.0, sigmaY=h / 6.0)
+    med = rng_np.standard_normal((h, w)).astype(np.float32)
+    med = cv2.GaussianBlur(med, (0, 0), sigmaX=h / 18.0, sigmaY=h / 18.0)
+    noise = big / (big.std() + 1e-6) + 0.7 * med / (med.std() + 1e-6)
+    noise /= (noise.std() + 1e-6)
+    # Multiplicative brightness modulation across the whole canvas: ±25%.
+    img = img * (1.0 + 0.25 * noise[..., None])
+    # Per-channel fine grain (±8 brightness units).
+    grain = rng_np.standard_normal((h, w, 3)).astype(np.float32) * 8.0
+    img = img + grain
+    return np.clip(img, 0, 255).astype(np.uint8)
+
+
+BG_COLOR = (248, 246, 240)
+BORDER_COLOR = (45, 39, 32)
+
+
+def composite_full_image(painted: np.ndarray, width: int, height: int) -> np.ndarray:
+    """Paste the painted region square onto the full canvas with a thin
+    dark border around it."""
+    canvas_size = painted.shape[0]
+    margin = (min(width, height) - canvas_size) // 2
+    full = np.full((height, width, 3), BG_COLOR, dtype=np.uint8)
+
+    border = max(2, canvas_size // 256)
+    y0 = margin
+    x0 = (width - canvas_size) // 2
+    full[y0:y0 + canvas_size, x0:x0 + canvas_size] = painted
+    full[y0 - border:y0, x0 - border:x0 + canvas_size + border] = BORDER_COLOR
+    full[y0 + canvas_size:y0 + canvas_size + border, x0 - border:x0 + canvas_size + border] = BORDER_COLOR
+    full[y0 - border:y0 + canvas_size + border, x0 - border:x0] = BORDER_COLOR
+    full[y0 - border:y0 + canvas_size + border, x0 + canvas_size:x0 + canvas_size + border] = BORDER_COLOR
+    return full
+
+
+# ── Sampling: build one valid instance ────────────────────────────────
+
+def difficulty_for_regions(num_regions: int) -> str:
+    if num_regions <= 6:
+        return "easy"
+    if num_regions <= 10:
+        return "medium"
+    return "hard"
+
+
+def count_region_cells(labels: np.ndarray, num_regions: int) -> List[int]:
+    return [int((labels == rid).sum()) for rid in range(num_regions)]
+
+
+def sample_instance(
+    rng: random.Random,
+    width: int,
+    height: int,
+    min_regions: int,
+    max_regions: int,
+    grid_rows: int,
+    grid_cols: int,
+    canvas_size: int,
+    min_region_frac: float,
+    hue_gap_min: float,
+    forced_target: int | None = None,
+) -> Dict[str, object] | None:
+    """Build one valid instance or return None if rejected. If forced_target
+    is given, only accept samples whose actual region count equals it."""
+    max_feasible_regions = min(max_regions, max(2, (grid_rows * grid_cols) // 6))
+    min_feasible_regions = min(min_regions, max_feasible_regions)
+    if forced_target is not None:
+        target_n = max(2, min(max_feasible_regions, forced_target))
+    else:
+        target_n = rng.randint(max(2, min_feasible_regions), max_feasible_regions)
+
+    grid_labels, seeds = make_connected_partition(rng, grid_rows, grid_cols, target_n)
+
+    if forced_target is not None:
+        # 200x200 grid + 50%-fair-share phase-1 floor makes every region
+        # big enough to survive heavy smoothing. Use the smoothed argmax
+        # path so boundaries are smooth curves instead of NEAREST staircase.
+        canvas_labels = upsample_labels(grid_labels, canvas_size, canvas_size, smooth_sigma=14.0)
+    else:
+        canvas_labels = upsample_labels(grid_labels, canvas_size, canvas_size, smooth_sigma=9.0)
+    if forced_target is None:
+        # Normal path: clean tiny specks and apply min-area floor.
+        canvas_labels = clean_tiny_components(canvas_labels, min_frac=0.002)
+        canvas_labels, actual_n = relabel_contiguous(canvas_labels)
+        if actual_n < 2:
+            return None
+        region_pixels = count_region_cells(canvas_labels, actual_n)
+        min_pixels = int(canvas_size * canvas_size * min_region_frac)
+        if min(region_pixels) < min_pixels:
+            return None
+    else:
+        # Forced path: trust the seeded grow — the partition produced exactly
+        # forced_target connected regions. Skip clean_tiny_components and the
+        # min-area floor so the count is honoured exactly.
+        canvas_labels, actual_n = relabel_contiguous(canvas_labels)
+        if actual_n != forced_target:
+            return None
+        region_pixels = count_region_cells(canvas_labels, actual_n)
+
+    adj = adjacency_from_labels(canvas_labels)
+    assignments = assign_gradients(rng, actual_n, adj, hue_gap_min=hue_gap_min)
+    if assignments is None:
+        return None
+    textures = assign_textures(rng, actual_n, adj)
+
+    margin = int(min(width, height) * 0.12)
+    square_size = canvas_size
+    square_left = (width - square_size) // 2
+    square_top = (height - square_size) // 2
+
+    return {
+        "width": width,
+        "height": height,
+        "grid_rows": grid_rows,
+        "grid_cols": grid_cols,
+        "square_left": float(square_left),
+        "square_top": float(square_top),
+        "square_size": float(square_size),
+        "num_regions": actual_n,
+        "question": (
+            "How many separated regions are inside the square? "
+            "A region is a maximal area inside the square that is filled with "
+            "one continuous colour pattern. Two locations belong to the same "
+            "region if you can travel between them without crossing into a "
+            "differently-coloured area. Count every distinct region inside the "
+            "square and report the total as a positive integer. "
+            "Provide your final answer enclosed in <answer>...</answer> tags."
+        ),
+        "answer": actual_n,
+        "difficulty": difficulty_for_regions(actual_n),
+        "region_seed_cells": [[int(r), int(c)] for r, c in seeds],
+        "region_cell_counts": region_pixels,
+        "region_adjacency": [[int(a), int(b)] for a, b in adjacency_pairs(canvas_labels)],
+        "_canvas_labels": canvas_labels,
+        "_assignments": assignments,
+        "_textures": textures,
+    }
+
+
+def render_instance(out_path: Path, record: Dict[str, object]) -> None:
+    """Coloured fill renderer: each region is filled with its assigned
+    gradient + texture, plus a thin dark boundary line drawn along the
+    label-difference set so triple junctions never have hollow gaps."""
+    canvas_labels: np.ndarray = record.pop("_canvas_labels")  # type: ignore[assignment]
+    assignments = record.pop("_assignments")
+    textures = record.pop("_textures")
+    width = int(record["width"])
+    height = int(record["height"])
+
+    h, w = canvas_labels.shape
+    painted = render_region_canvas(canvas_labels, assignments, textures)
+    line_color = (32, 32, 32)
+    line_thickness = max(1, min(h, w) // 700)
+
+    # Smooth labels first via per-region one-hot → blur → argmax. This
+    # removes the staircase from the original integer upsample but, crucially,
+    # gives a SINGLE consistent label map (no triple-junction gaps).
+    num_regions = int(canvas_labels.max()) + 1
+    smooth_sigma = max(2.5, min(h, w) / 140.0)
+    soft = np.empty((num_regions, h, w), dtype=np.float32)
+    for rid in range(num_regions):
+        mask = (canvas_labels == rid).astype(np.float32)
+        soft[rid] = cv2.GaussianBlur(mask, (0, 0), sigmaX=smooth_sigma,
+                                     sigmaY=smooth_sigma)
+    smoothed_labels = np.argmax(soft, axis=0).astype(np.int32)
+
+    # Boundary mask: a pixel is on a boundary iff any of its 4-neighbours has
+    # a different label. This produces a single closed curve per junction
+    # with no hollow gap at triple points.
+    boundary = np.zeros((h, w), dtype=np.uint8)
+    diff_h = smoothed_labels[:, :-1] != smoothed_labels[:, 1:]
+    diff_v = smoothed_labels[:-1, :] != smoothed_labels[1:, :]
+    boundary[:, :-1][diff_h] = 1
+    boundary[:, 1:][diff_h] = 1
+    boundary[:-1, :][diff_v] = 1
+    boundary[1:, :][diff_v] = 1
+    if line_thickness > 1:
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (line_thickness, line_thickness))
+        boundary = cv2.dilate(boundary, kernel)
+    painted[boundary > 0] = line_color
+
+    full = composite_full_image(painted, width, height)
+    Image.fromarray(full).save(out_path)
+
+
+# ── Dataset generation ────────────────────────────────────────────────
+
+def ensure_output_dir(root: Path) -> Tuple[Path, Path]:
+    root.mkdir(parents=True, exist_ok=True)
+    images_dir = root / "images"
+    images_dir.mkdir(exist_ok=True)
+    return root, images_dir
+
+
+def generate_dataset(
+    rng: random.Random,
+    count: int,
+    output_dir: Path,
+    images_dir: Path,
+    width: int,
+    height: int,
+    min_regions: int,
+    max_regions: int,
+    grid_rows: int,
+    grid_cols: int,
+    canvas_size: int,
+    min_region_frac: float,
+    hue_gap_min: float,
+    forced_targets: List[int] | None = None,
+) -> None:
+    records: List[Dict[str, object]] = []
+    data_records: List[Dict[str, object]] = []
+    pbar = tqdm(total=count, desc="counting_regions")
+    idx = 0
+    rejects = 0
+    while idx < count:
+        target = (forced_targets[idx] if forced_targets and idx < len(forced_targets) else None)
+        record = sample_instance(
+            rng=rng,
+            width=width,
+            height=height,
+            min_regions=min_regions,
+            max_regions=max_regions,
+            grid_rows=grid_rows,
+            grid_cols=grid_cols,
+            canvas_size=canvas_size,
+            min_region_frac=min_region_frac,
+            hue_gap_min=hue_gap_min,
+            forced_target=target,
+        )
+        if record is None:
+            rejects += 1
+            continue
+        image_name = f"counting_regions_{idx:05d}.png"
+        render_instance(images_dir / image_name, record)
+        record["image"] = f"images/{image_name}"
+        records.append(record)
+        data_records.append({
+            "image": record["image"],
+            "question": record["question"],
+            "answer": record["answer"],
+        })
+        idx += 1
+        pbar.update(1)
+        pbar.set_postfix(answer=record["answer"], rejects=rejects)
+    pbar.close()
+
+    with (output_dir / "annotations.jsonl").open("w", encoding="utf-8") as fh:
+        for record in records:
+            fh.write(json.dumps(record) + "\n")
+
+    data_json = {
+        "task": "counting_regions",
+        "category": "distributed_scanning",
+        "count": len(data_records),
+        "items": data_records,
+    }
+    with (output_dir / "data.json").open("w", encoding="utf-8") as fh:
+        json.dump(data_json, fh, indent=2)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Generate a counting-regions dataset.")
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument("--count", type=int, default=36)
+    parser.add_argument("--width", type=int, default=1024)
+    parser.add_argument("--height", type=int, default=1024)
+    parser.add_argument("--min-regions", type=int, default=6)
+    parser.add_argument("--max-regions", type=int, default=12)
+    parser.add_argument("--grid-rows", type=int, default=200)
+    parser.add_argument("--grid-cols", type=int, default=200)
+    parser.add_argument("--canvas-size", type=int, default=820,
+                        help="Pixel side of the painted square inside the image.")
+    parser.add_argument("--min-region-frac", type=float, default=0.025,
+                        help="Reject samples whose smallest region covers "
+                             "less than this fraction of the canvas.")
+    parser.add_argument("--hue-gap-min", type=float, default=55.0)
+    parser.add_argument("--seed", type=int, default=23)
+    parser.add_argument("--difficulty", type=int, default=5,
+                        help="Integer difficulty >=0; scales region count.")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    d = max(0, int(args.difficulty))
+
+    # Canvas scaling: N_d = 10 + d, N_0 = 10.
+    N_d = 10 + d
+    N_0 = 10
+    s = math.sqrt(max(1.0, N_d / N_0))
+    args.width = int(round(args.width * s))
+    args.height = int(round(args.height * s))
+    args.canvas_size = int(round(args.canvas_size * s))
+
+    rng = random.Random(args.seed)
+    output_dir, images_dir = ensure_output_dir(args.output_root)
+
+    # num_regions ∈ [5, 10 + d]
+    min_regions = 10
+    max_regions = 10 + 2 * d
+    # Auto-scale: min_region_frac = min(0.04, 1 / (2.5 * max_regions))
+    # Use max_regions (upper bound) as a conservative frac floor so any
+    # sampled count satisfies the constraint.
+    min_region_frac = min(0.04, 1.0 / (2.5 * max_regions))
+
+    # Force per-instance region counts evenly spaced across [min_regions,
+    # max_regions]. With count=5 and range=[10, 20] this yields [10, 13, 15, 18, 20].
+    if args.count > 1:
+        forced_targets = [
+            int(round(min_regions + i * (max_regions - min_regions) / (args.count - 1)))
+            for i in range(args.count)
+        ]
+    else:
+        forced_targets = [min_regions]
+
+    generate_dataset(
+        rng=rng,
+        count=args.count,
+        output_dir=output_dir,
+        images_dir=images_dir,
+        width=args.width,
+        height=args.height,
+        min_regions=min_regions,
+        max_regions=max_regions,
+        grid_rows=args.grid_rows,
+        grid_cols=args.grid_cols,
+        canvas_size=args.canvas_size,
+        min_region_frac=min_region_frac,
+        hue_gap_min=args.hue_gap_min,
+        forced_targets=forced_targets,
+    )
+    print(f"forced region counts: {forced_targets}")
+    print(f"Saved dataset to {args.output_root} (canvas {args.width}x{args.height})")
+
+
+if __name__ == "__main__":
+    main()

code/distributed_scanning/counting_regions/data.json

@@ -0,0 +1,32 @@
+{
+  "task": "counting_regions",
+  "category": "distributed_scanning",
+  "count": 5,
+  "items": [
+    {
+      "image": "images/counting_regions_00000.png",
+      "question": "How many separated regions are inside the image? A region is a maximal area filled with one continuous fill. Boundaries between regions may appear as continuous lines OR as a chain of small individual markers \u2014 discrete dots, footprints, dashes, or short segments aligned along a curve \u2014 that you must visually link together to recognize as a single boundary. Two locations belong to the same region if you can travel between them without crossing such a boundary (continuous or chained). Count every distinct region and report the total as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 10
+    },
+    {
+      "image": "images/counting_regions_00001.png",
+      "question": "How many separated regions are inside the image? A region is a maximal area filled with one continuous fill. Boundaries between regions may appear as continuous lines OR as a chain of small individual markers \u2014 discrete dots, footprints, dashes, or short segments aligned along a curve \u2014 that you must visually link together to recognize as a single boundary. Two locations belong to the same region if you can travel between them without crossing such a boundary (continuous or chained). Count every distinct region and report the total as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 12
+    },
+    {
+      "image": "images/counting_regions_00002.png",
+      "question": "How many separated regions are inside the image? A region is a maximal area filled with one continuous fill. Boundaries between regions may appear as continuous lines OR as a chain of small individual markers \u2014 discrete dots, footprints, dashes, or short segments aligned along a curve \u2014 that you must visually link together to recognize as a single boundary. Two locations belong to the same region if you can travel between them without crossing such a boundary (continuous or chained). Count every distinct region and report the total as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 15
+    },
+    {
+      "image": "images/counting_regions_00003.png",
+      "question": "How many separated regions are inside the image? A region is a maximal area filled with one continuous fill. Boundaries between regions may appear as continuous lines OR as a chain of small individual markers \u2014 discrete dots, footprints, dashes, or short segments aligned along a curve \u2014 that you must visually link together to recognize as a single boundary. Two locations belong to the same region if you can travel between them without crossing such a boundary (continuous or chained). Count every distinct region and report the total as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 18
+    },
+    {
+      "image": "images/counting_regions_00004.png",
+      "question": "How many separated regions are inside the image? A region is a maximal area filled with one continuous fill. Boundaries between regions may appear as continuous lines OR as a chain of small individual markers \u2014 discrete dots, footprints, dashes, or short segments aligned along a curve \u2014 that you must visually link together to recognize as a single boundary. Two locations belong to the same region if you can travel between them without crossing such a boundary (continuous or chained). Count every distinct region and report the total as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 20
+    }
+  ]
+}

code/distributed_scanning/tangled_loops/creation.md

@@ -0,0 +1,107 @@
+# Tangled Closed-Loop Counting
+
+## Goal
+
+Render a tangle of smooth **closed loops** on a single canvas. Every
+loop is drawn in the **same** dark colour, so the model cannot recover
+the count by colour-segmenting the image. Loops cross each other and
+themselves freely, but never run parallel for long stretches — every
+loop remains individually traceable.
+
+This is a *distributed scanning* task: there is no single starting
+point. The model must look across the whole image, follow each loop
+all the way around, and report how many distinct closed loops exist.
+
+## Differs from `sequential_traversal/tube_connection`
+
+`tube_connection` labels endpoints and asks "which top label connects
+to which bottom label", which is solved by tracing one path at a time.
+Here there are no labels, no endpoints at all, and no per-loop tracing
+question. The model needs the global *count* of distinct closed loops.
+
+## Differs from `sequential_traversal/line_intersections`
+
+`line_intersections` uses perimeter-anchored open curves and asks for
+crossing sequences along one labelled string. Here every curve is a
+closed loop (no endpoints anywhere), every loop is anonymous, all in
+the same colour, and the only ground truth is the number of loops.
+
+## Question
+
+> How many distinct closed loops are tangled together in this image?
+> Each loop is a single continuous curve that closes back on itself —
+> there are no loose endpoints anywhere. All loops are drawn in the
+> same colour and may cross other loops or themselves freely. Count
+> the total number of distinct closed loops and report the count as a
+> positive integer.
+
+## Generation Procedure
+
+1. **Sample N** in `[min_loops, max_loops]` (default 5–11).
+2. **For each loop**, build a smooth closed curve:
+   - Pick a random interior centre so the loop fits inside
+     `interior_margin` (default 55 px) of the canvas edge.
+   - Sample 6–10 waypoints on a jittered ring around that centre
+     (angle jitter ≈ 0.42 rad, radius jitter ≈ 32 % of the mean
+     radius, mean radius sampled from 150–275 px).
+   - Fit a periodic cubic B-spline through the waypoints
+     (`scipy.interpolate.splprep(..., per=True, k=3)`) and
+     dense-sample 900 points along it. The last point is snapped to
+     equal the first so the renderer draws a genuine closed curve.
+3. **Find all crossings** (self and pair) — used only by the
+   close-approach validator below.
+4. **Reject** the sample if any two curves come within ~9 px of each
+   other anywhere except at a real crossing point. For self-closeness
+   the segment-index gap is computed **circularly** (with wraparound),
+   since closed curves have no linear endpoint ordering.
+5. **Render** all loops in the same dark colour onto an off-white
+   canvas with subtle background noise.
+
+## Anti-Shortcut Notes
+
+The task has been through two shortcut-plugging rewrites:
+
+1. **Unique-colour shortcut → single stroke colour.** An earlier
+   version assigned each string a unique colour, collapsing the task
+   to "count distinct colours". Fixed by drawing every curve in the
+   same dark colour.
+2. **Skeleton-endpoint shortcut → closed loops.** The previous
+   perimeter-anchored design had each string as an *open* curve with
+   two endpoints on the border. A ten-line attack recovered the
+   answer on 28 / 30 samples: `skeletonize(gray < 110)` →
+   count pixels with exactly one 8-neighbour → divide by two.
+   Crossings are X/T junctions (degree ≥ 3), so only the two terminal
+   endpoints of each string have degree 1, and endpoints ÷ 2 is the
+   string count. Moving to closed curves eliminates the attack
+   entirely — a closed loop's skeleton has no degree-1 pixels, so the
+   attack returns 0 regardless of loop count. Verified on the
+   regenerated dataset.
+3. **No-near-parallel validation** (retained) prevents two loops that
+   run parallel for a long stretch from reading as one fat loop,
+   which would also confuse a human counter.
+
+## Annotation Format
+
+```json
+{
+  "image": "images/tangled_loops_00000.png",
+  "width": 1024,
+  "height": 1024,
+  "num_loops": 7,
+  "question": "How many distinct closed loops are tangled together ...",
+  "answer": 7
+}
+```
+
+## Output Organization
+
+```text
+tangled_loops/
+  creation.py
+  creation.md
+  annotations.jsonl
+  data.json
+  images/
+    tangled_loops_00000.png
+    ...
+```

code/distributed_scanning/tangled_loops/creation.py

@@ -0,0 +1,531 @@
+"""Tangled Closed-Loop Counting.
+
+Each string is a smooth **closed curve** living entirely in the interior
+of the canvas. Loops are generated by sampling interior waypoints on a
+jittered ring around a random centre and fitting a periodic cubic
+B-spline through them — the resulting curve has no endpoints at all,
+which plugs the "skeletonize → count degree-1 pixels → divide by 2"
+shortcut that beat the previous perimeter-anchored design.
+
+All loops render in the same dark colour. Loops may cross other loops
+or themselves, but long parallel runs are rejected so every loop stays
+individually traceable.
+
+The model is asked to count the total number of distinct closed loops.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import random
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.interpolate import splev, splprep
+from tqdm import tqdm
+
+
+LINE_COLOR = "#2f2f2f"
+
+
+# ── Closed-loop construction ───────────────────────────────────────
+
+def build_closed_loop(
+    rng: random.Random,
+    width: int,
+    height: int,
+    interior_margin: int = 55,
+    num_waypoints_range: Tuple[int, int] = (6, 10),
+    radius_range: Tuple[float, float] = (130.0, 215.0),
+    radius_jitter: float = 0.30,
+    angle_jitter: float = 0.42,
+    num_samples: int = 520,
+    existing_centers: List[Tuple[float, float]] | None = None,
+    min_center_gap: float = 190.0,
+    center_placement_attempts: int = 80,
+) -> Tuple[np.ndarray, Tuple[float, float]] | None:
+    """Build one smooth closed curve through jittered ring waypoints.
+
+    Returns ``(polyline, (cx, cy))`` where the polyline's last point
+    equals its first, or ``None`` if no valid placement was found.
+    """
+    num_wp = rng.randint(*num_waypoints_range)
+    r_mean = rng.uniform(*radius_range)
+    max_r = r_mean * (1 + radius_jitter)
+
+    low_x = interior_margin + max_r
+    high_x = width - interior_margin - max_r
+    low_y = interior_margin + max_r
+    high_y = height - interior_margin - max_r
+    if low_x >= high_x or low_y >= high_y:
+        return None
+
+    cx = cy = None
+    centers = existing_centers or []
+    for _ in range(center_placement_attempts):
+        cand_x = rng.uniform(low_x, high_x)
+        cand_y = rng.uniform(low_y, high_y)
+        ok = True
+        for ex_x, ex_y in centers:
+            if (cand_x - ex_x) ** 2 + (cand_y - ex_y) ** 2 < min_center_gap ** 2:
+                ok = False
+                break
+        if ok:
+            cx, cy = cand_x, cand_y
+            break
+    if cx is None:
+        return None
+
+    base_angles = np.linspace(0.0, 2 * math.pi, num_wp, endpoint=False)
+    phase = rng.uniform(0.0, 2 * math.pi)
+
+    xs: List[float] = []
+    ys: List[float] = []
+    for base in base_angles:
+        ang = base + phase + rng.uniform(-angle_jitter, angle_jitter)
+        r = r_mean * (1.0 + rng.uniform(-radius_jitter, radius_jitter))
+        xs.append(cx + r * math.cos(ang))
+        ys.append(cy + r * math.sin(ang))
+
+    # splprep with per=True expects the input to already be closed.
+    xs.append(xs[0])
+    ys.append(ys[0])
+
+    try:
+        tck, _ = splprep([xs, ys], s=0.0, per=True, k=3)
+    except (TypeError, ValueError):
+        return None
+
+    u_dense = np.linspace(0.0, 1.0, num_samples)
+    x_dense, y_dense = splev(u_dense, tck)
+    poly = np.column_stack([np.asarray(x_dense), np.asarray(y_dense)])
+
+    if (poly[:, 0].min() < interior_margin - 5
+            or poly[:, 0].max() > width - interior_margin + 5
+            or poly[:, 1].min() < interior_margin - 5
+            or poly[:, 1].max() > height - interior_margin + 5):
+        return None
+
+    poly[-1] = poly[0]
+    return poly, (cx, cy)
+
+
+# ── Crossing detection (used for the close-approach validation) ────
+
+def _segments_cross(p0, p1, q0, q1) -> bool:
+    eps = 1e-8
+    o1 = (p1[0]-p0[0])*(q0[1]-p0[1]) - (p1[1]-p0[1])*(q0[0]-p0[0])
+    o2 = (p1[0]-p0[0])*(q1[1]-p0[1]) - (p1[1]-p0[1])*(q1[0]-p0[0])
+    o3 = (q1[0]-q0[0])*(p0[1]-q0[1]) - (q1[1]-q0[1])*(p0[0]-q0[0])
+    o4 = (q1[0]-q0[0])*(p1[1]-q0[1]) - (q1[1]-q0[1])*(p1[0]-q0[0])
+    return ((o1 > eps and o2 < -eps) or (o1 < -eps and o2 > eps)) and \
+           ((o3 > eps and o4 < -eps) or (o3 < -eps and o4 > eps))
+
+
+def _circular_seg_gap(i: int, j: int, n: int) -> int:
+    d = abs(i - j)
+    return min(d, n - d)
+
+
+def _find_crossings(
+    poly_a: np.ndarray,
+    poly_b: np.ndarray,
+    same_curve: bool = False,
+    min_seg_gap: int = 10,
+) -> List[Dict]:
+    na = len(poly_a) - 1
+    nb = len(poly_b) - 1
+
+    a_min_x = np.minimum(poly_a[:-1, 0], poly_a[1:, 0])
+    a_max_x = np.maximum(poly_a[:-1, 0], poly_a[1:, 0])
+    a_min_y = np.minimum(poly_a[:-1, 1], poly_a[1:, 1])
+    a_max_y = np.maximum(poly_a[:-1, 1], poly_a[1:, 1])
+
+    b_min_x = np.minimum(poly_b[:-1, 0], poly_b[1:, 0])
+    b_max_x = np.maximum(poly_b[:-1, 0], poly_b[1:, 0])
+    b_min_y = np.minimum(poly_b[:-1, 1], poly_b[1:, 1])
+    b_max_y = np.maximum(poly_b[:-1, 1], poly_b[1:, 1])
+
+    cell_size = max(np.median(np.concatenate([a_max_x - a_min_x,
+                                              b_max_x - b_min_x])), 1.0) * 3
+
+    grid_b = defaultdict(list)
+    for j in range(nb):
+        cx0 = int(b_min_x[j] / cell_size); cx1 = int(b_max_x[j] / cell_size)
+        cy0 = int(b_min_y[j] / cell_size); cy1 = int(b_max_y[j] / cell_size)
+        for gx in range(cx0, cx1 + 1):
+            for gy in range(cy0, cy1 + 1):
+                grid_b[(gx, gy)].append(j)
+
+    checked = set()
+    details: List[Dict] = []
+    for i in range(na):
+        cx0 = int(a_min_x[i] / cell_size); cx1 = int(a_max_x[i] / cell_size)
+        cy0 = int(a_min_y[i] / cell_size); cy1 = int(a_max_y[i] / cell_size)
+        for gx in range(cx0, cx1 + 1):
+            for gy in range(cy0, cy1 + 1):
+                if (gx, gy) not in grid_b:
+                    continue
+                for j in grid_b[(gx, gy)]:
+                    if same_curve:
+                        ii, jj = min(i, j), max(i, j)
+                        # Closed curve: neighbours wrap around.
+                        if _circular_seg_gap(ii, jj, na) < min_seg_gap:
+                            continue
+                        key = (ii, jj)
+                    else:
+                        key = (i, j)
+                    if key in checked:
+                        continue
+                    checked.add(key)
+                    if same_curve:
+                        si, sj = key
+                    else:
+                        si, sj = i, j
+                    p0, p1 = poly_a[si], poly_a[si + 1]
+                    q0, q1 = poly_b[sj], poly_b[sj + 1]
+                    if not _segments_cross(p0, p1, q0, q1):
+                        continue
+                    d1 = p1 - p0
+                    d2 = q1 - q0
+                    denom = d1[0] * d2[1] - d1[1] * d2[0]
+                    if abs(denom) < 1e-12:
+                        continue
+                    ti = ((q0[0] - p0[0]) * d2[1] - (q0[1] - p0[1]) * d2[0]) / denom
+                    px = float(p0[0] + ti * d1[0])
+                    py = float(p0[1] + ti * d1[1])
+                    details.append({"px": px, "py": py})
+    return details
+
+
+def _details_to_points(details: List[Dict]) -> np.ndarray:
+    if not details:
+        return np.zeros((0, 2))
+    return np.array([[d["px"], d["py"]] for d in details])
+
+
+def _curves_too_close(
+    poly_a: np.ndarray,
+    poly_b: np.ndarray,
+    same_curve: bool = False,
+    min_dist: float = 7.0,
+    sample_step: int = 3,
+    self_index_gap: int = 30,
+    known_crossings: np.ndarray | None = None,
+    crossing_exclude_radius: float = 55.0,
+) -> bool:
+    nb = len(poly_b) - 1
+    b_pts = poly_b[:-1]
+    b_vecs = poly_b[1:] - poly_b[:-1]
+    b_lens_sq = np.maximum((b_vecs ** 2).sum(axis=1), 1e-12)
+
+    has_crossings = known_crossings is not None and len(known_crossings) > 0
+
+    for idx in range(0, len(poly_a), sample_step):
+        px, py = poly_a[idx]
+        p = np.array([px, py])
+        dp = p - b_pts
+        t = (dp * b_vecs).sum(axis=1) / b_lens_sq
+        t = np.clip(t, 0.0, 1.0)
+        proj = b_pts + t[:, None] * b_vecs
+        dists = np.sqrt(((p - proj) ** 2).sum(axis=1))
+        if same_curve:
+            # Closed curve: mask neighbours with wraparound distance.
+            seg_idx = np.arange(nb)
+            lin = np.abs(seg_idx - idx)
+            circ = np.minimum(lin, nb - lin)
+            mask = circ < self_index_gap
+            dists[mask] = 9999.0
+        if dists.min() < min_dist:
+            if has_crossings:
+                cross_dists = np.sqrt(((p - known_crossings) ** 2).sum(axis=1))
+                if cross_dists.min() < crossing_exclude_radius:
+                    continue
+            return True
+    return False
+
+
+# ── Instance sampling ──────────────────────────────────────────────
+
+QUESTION = (
+    "How many distinct closed loops are tangled together in this image? "
+    "Each loop is a single continuous curve that closes back on itself — "
+    "there are no loose endpoints anywhere. All loops are drawn in the "
+    "same colour and may cross other loops or themselves freely. Count "
+    "the total number of distinct closed loops and report the count as "
+    "a positive integer. "
+    "Provide your final answer enclosed in <answer>...</answer> tags."
+)
+
+
+def _min_crossing_angle_deg(poly_a: np.ndarray, poly_b: np.ndarray,
+                             details: List[Dict], same_curve: bool = False) -> float:
+    """Return the smallest crossing angle (deg) across all crossings, or
+    180.0 if there are no crossings."""
+    if not details:
+        return 180.0
+    # Re-detect with segment indices for angle computation.
+    na = len(poly_a) - 1
+    nb = len(poly_b) - 1
+    min_angle = 180.0
+    for i in range(na):
+        p0, p1 = poly_a[i], poly_a[i + 1]
+        for j in range(nb):
+            if same_curve:
+                ii, jj = min(i, j), max(i, j)
+                if _circular_seg_gap(ii, jj, na) < 10:
+                    continue
+            q0, q1 = poly_b[j], poly_b[j + 1]
+            if not _segments_cross(p0, p1, q0, q1):
+                continue
+            d1 = p1 - p0
+            d2 = q1 - q0
+            n1 = math.hypot(d1[0], d1[1])
+            n2 = math.hypot(d2[0], d2[1])
+            if n1 < 1e-9 or n2 < 1e-9:
+                continue
+            cos_a = (d1[0] * d2[0] + d1[1] * d2[1]) / (n1 * n2)
+            cos_a = max(-1.0, min(1.0, cos_a))
+            ang = math.degrees(math.acos(abs(cos_a)))
+            if ang < min_angle:
+                min_angle = ang
+    return min_angle
+
+
+def sample_instance(
+    rng: random.Random,
+    width: int,
+    height: int,
+    num_loops: int,
+    interior_margin: int = 55,
+    max_attempts: int = 600,
+    min_inter_crossings: int = 0,
+    max_self_crossings_per_loop: int = 0,
+    min_crossing_angle_deg: float = 30.0,
+) -> Dict | None:
+    for _ in range(max_attempts):
+        polylines: List[np.ndarray] = []
+        centers: List[Tuple[float, float]] = []
+        build_failed = False
+        for _ in range(num_loops):
+            result = None
+            for _ in range(40):
+                result = build_closed_loop(
+                    rng, width, height,
+                    interior_margin=interior_margin,
+                    existing_centers=centers,
+                )
+                if result is not None:
+                    break
+            if result is None:
+                build_failed = True
+                break
+            poly, centre = result
+            polylines.append(poly)
+            centers.append(centre)
+        if build_failed:
+            continue
+
+        self_details: List[List[Dict]] = []
+        pair_details: Dict[Tuple[int, int], List[Dict]] = {}
+        for a in range(num_loops):
+            self_details.append(_find_crossings(polylines[a], polylines[a],
+                                                same_curve=True))
+            for b in range(a + 1, num_loops):
+                pair_details[(a, b)] = _find_crossings(polylines[a], polylines[b])
+
+        # Enforce: no self-crossings beyond allowed limit.
+        if any(len(sd) > max_self_crossings_per_loop for sd in self_details):
+            continue
+
+        # Enforce: total inter-loop crossings >= min_inter_crossings.
+        total_inter = sum(len(v) for v in pair_details.values())
+        if total_inter < min_inter_crossings:
+            continue
+
+        # Enforce: every crossing has angle >= min_crossing_angle_deg.
+        bad_angle = False
+        for a in range(num_loops):
+            if _min_crossing_angle_deg(polylines[a], polylines[a],
+                                       self_details[a], same_curve=True) < min_crossing_angle_deg:
+                bad_angle = True
+                break
+            for b in range(a + 1, num_loops):
+                if _min_crossing_angle_deg(polylines[a], polylines[b],
+                                           pair_details[(a, b)]) < min_crossing_angle_deg:
+                    bad_angle = True
+                    break
+            if bad_angle:
+                break
+        if bad_angle:
+            continue
+
+        too_close = False
+        for a in range(num_loops):
+            if _curves_too_close(polylines[a], polylines[a], same_curve=True,
+                                 known_crossings=_details_to_points(self_details[a])):
+                too_close = True
+                break
+            for b in range(a + 1, num_loops):
+                if _curves_too_close(polylines[a], polylines[b],
+                                     known_crossings=_details_to_points(pair_details[(a, b)])):
+                    too_close = True
+                    break
+            if too_close:
+                break
+        if too_close:
+            continue
+
+        return {
+            "width": width,
+            "height": height,
+            "num_loops": num_loops,
+            "polylines": polylines,
+            "inter_loop_crossings": int(total_inter),
+            "question": QUESTION,
+            "answer": num_loops,
+        }
+    return None
+
+
+# ── Rendering ──────────────────────────────────────────────────────
+
+def render_instance(out_path: Path, record: Dict, noise_seed: int,
+                    thickness: float) -> None:
+    width = int(record["width"])
+    height = int(record["height"])
+    polylines = record["polylines"]
+
+    fig = plt.figure(figsize=(width / 100, height / 100), dpi=100)
+    ax = fig.add_axes([0, 0, 1, 1])
+    ax.set_xlim(0, width)
+    ax.set_ylim(height, 0)
+    ax.axis("off")
+    ax.set_facecolor("#f8f6f0")
+
+    nrng = np.random.default_rng(noise_seed)
+    noise = nrng.normal(0.0, 1.0, size=(height, width))
+    noise = (noise - noise.min()) / max(noise.max() - noise.min(), 1e-6)
+    ax.imshow(noise, cmap="Greys", alpha=0.05, extent=(0, width, height, 0),
+              interpolation="bilinear")
+
+    for poly in polylines:
+        ax.plot(poly[:, 0], poly[:, 1],
+                color=LINE_COLOR, linewidth=thickness, alpha=0.92,
+                solid_capstyle="round", solid_joinstyle="round",
+                zorder=2.0)
+
+    fig.savefig(out_path, dpi=100, bbox_inches="tight", pad_inches=0)
+    plt.close(fig)
+
+
+# ── Main ───────────────────────────────────────────────────────────
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument("--count", type=int, default=30)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--width", type=int, default=1024)
+    parser.add_argument("--height", type=int, default=1024)
+    parser.add_argument("--min-loops", type=int, default=3)
+    parser.add_argument("--max-loops", type=int, default=5)
+    parser.add_argument("--thickness", type=float, default=2.0,
+                        help="Absolute pixel thickness; never scaled.")
+    parser.add_argument("--difficulty", type=int, default=5,
+                        help="Integer difficulty >=0; scales loop count.")
+    parser.add_argument("--workers", type=int, default=8,
+                        help="Parallel worker processes for sampling. 1 = serial.")
+    args = parser.parse_args()
+
+    d = max(0, int(args.difficulty))
+
+    # Canvas scaling: N_d = 5 + d, N_0 = 5.
+    N_d = 5 + d
+    N_0 = 5
+    s = math.sqrt(max(1.0, N_d / N_0))
+    args.width = int(round(args.width * s))
+    args.height = int(round(args.height * s))
+
+    # num_loops ∈ [3, 5 + d]
+    args.min_loops = 10
+    args.max_loops = 10 + 2 * d
+
+    # Fixed constraints.
+    max_self_crossings_per_loop = 0
+    min_inter_crossings = 10 + 2 * d
+    min_crossing_angle_deg = 30.0
+    loop_thickness_px = 4.0  # absolute; do not scale
+
+    out_root: Path = args.output_root
+    img_dir = out_root / "images"
+    img_dir.mkdir(parents=True, exist_ok=True)
+
+    sys.path.insert(0, str(Path(__file__).resolve().parents[3]))
+    from _sample_pool import parallel_sample_records  # noqa: E402
+
+    # Force evenly-spaced answer counts across [min_loops, max_loops].
+    if args.count > 1:
+        forced_targets = [
+            int(round(args.min_loops + i * (args.max_loops - args.min_loops) / (args.count - 1)))
+            for i in range(args.count)
+        ]
+    else:
+        forced_targets = [args.min_loops]
+    print(f"forced loop counts: {forced_targets}")
+
+    records_raw = []
+    for ti, tgt in enumerate(forced_targets):
+        def _attempt(rng, _tgt=tgt):
+            rec = sample_instance(
+                rng, args.width, args.height, num_loops=_tgt,
+                min_inter_crossings=min_inter_crossings,
+                max_self_crossings_per_loop=max_self_crossings_per_loop,
+                min_crossing_angle_deg=min_crossing_angle_deg,
+                max_attempts=50,
+            )
+            return rec
+        sub = parallel_sample_records(
+            _attempt, count=1, workers=args.workers,
+            seed_base=args.seed + ti * 977,
+        )
+        records_raw.extend(sub)
+    rng_render = random.Random(args.seed ^ 0xA5A5)
+    records = []
+    for idx, record in enumerate(records_raw):
+        name = f"tangled_loops_{idx:05d}.png"
+        ns = rng_render.randint(0, 10**9)
+        render_instance(img_dir / name, record, noise_seed=ns,
+                        thickness=loop_thickness_px)
+        record.pop("polylines")
+        record["image"] = f"images/{name}"
+        records.append(record)
+    print(f"  {len(records)}/{args.count} valid samples (workers={args.workers})")
+
+    with (out_root / "annotations.jsonl").open("w") as fh:
+        for r in records:
+            fh.write(json.dumps(r) + "\n")
+
+    data_json = {
+        "task": "tangled_loops",
+        "category": "distributed_scanning",
+        "count": len(records),
+        "items": [
+            {"image": r["image"], "question": r["question"], "answer": r["answer"]}
+            for r in records
+        ],
+    }
+    (out_root / "data.json").write_text(json.dumps(data_json, indent=2))
+    print(f"Saved {len(records)} items to {out_root}")
+
+
+if __name__ == "__main__":
+    main()

code/distributed_scanning/tangled_loops/data.json

@@ -0,0 +1,32 @@
+{
+  "task": "tangled_loops",
+  "category": "distributed_scanning",
+  "count": 5,
+  "items": [
+    {
+      "image": "images/tangled_loops_00000.png",
+      "question": "How many distinct closed loops are tangled together in this image? Each loop is a continuous closed curve (rope, cord, cable, etc.) with no loose endpoints anywhere. Loops may cross other loops or themselves freely. Count the total number of distinct closed loops and report the count as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 10
+    },
+    {
+      "image": "images/tangled_loops_00001.png",
+      "question": "How many distinct closed loops are tangled together in this image? Each loop is a continuous closed curve (rope, cord, cable, etc.) with no loose endpoints anywhere. Loops may cross other loops or themselves freely. Count the total number of distinct closed loops and report the count as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 12
+    },
+    {
+      "image": "images/tangled_loops_00002.png",
+      "question": "How many distinct closed loops are tangled together in this image? Each loop is a continuous closed curve (rope, cord, cable, etc.) with no loose endpoints anywhere. Loops may cross other loops or themselves freely. Count the total number of distinct closed loops and report the count as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 15
+    },
+    {
+      "image": "images/tangled_loops_00003.png",
+      "question": "How many distinct closed loops are tangled together in this image? Each loop is a continuous closed curve (rope, cord, cable, etc.) with no loose endpoints anywhere. Loops may cross other loops or themselves freely. Count the total number of distinct closed loops and report the count as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 18
+    },
+    {
+      "image": "images/tangled_loops_00004.png",
+      "question": "How many distinct closed loops are tangled together in this image? Each loop is a continuous closed curve (rope, cord, cable, etc.) with no loose endpoints anywhere. Loops may cross other loops or themselves freely. Count the total number of distinct closed loops and report the count as a positive integer. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": 20
+    }
+  ]
+}

code/scope.md

@@ -0,0 +1,38 @@
+# Active Vision Benchmark
+
+Today's multimodal large language models (MLLMs) achieve strong performance on many vision-language tasks, but they typically process images as fixed embeddings. Human reasoning, by contrast, is often active: perception is continuously guided by intermediate reasoning. In psychology, active observers can readily solve tasks that are ill-posed for passive observers. In this paper, we investigate whether MLLMs can exhibit a similar form of active observation. We introduce a benchmark that requires iterative visual inspection, including distributed scanning, sequential traversal, and visual attribute transfer, where evidence must be accumulated across spatial locations and reasoning steps. State-of-the-art MLLMs show substantial performance drops on these tasks, and attention analysis reveals unstable and limited use of visual tokens during reasoning. These results suggest that current MLLMs lack robust active visual observation, motivating new methods and architectures for iterative, perception-driven reasoning.
+
+
+### Distributed Scanning.
+
+Tasks that require the model to inspect multiple spatially separated regions and aggregate locally identifiable evidence across the image. The main challenge is exhaustive visual coverage rather than global structural inference, as the answer is obtained by repeatedly finding and accumulating relevant local signals.
+
+### Sequential Traversal.
+
+Tasks that require the model to follow a path, line, wire, or other connected structure step by step while maintaining intermediate state. The answer depends on ordered inspection along the structure, such as tracing a route, identifying visited elements, or counting events encountered during traversal.
+
+### Visual Attribute Transfer.
+
+Tasks that require the model to extract a fine-grained visual property from one region and match or apply it to another region. The transferred property is primarily visual rather than linguistic, such as length, curvature, thickness, or spacing, and the task tests whether the model can preserve and compare such information across separated parts of the image.
+
+### Requirement
+
+A task qualifies for the benchmark only if it forces the model to *actively look at the image during reasoning*. Concretely, every task must defeat the following two shortcuts.
+
+**Shortcut 1 — One-shot perception, then pure text reasoning.**
+The model summarises the entire image in a single pass into a compact symbolic description (e.g. an adjacency list, a coordinate table, a grid of arrows), then solves the task by reasoning over that description without looking again. To block this, an instance must contain too much fine-grained visual state to be losslessly extracted in one pass at the resolutions models actually see. For example, a *Color Zone Sequence* image carries a continuous smooth curve whose region membership changes dozens of times along its length; verbalising every crossing in advance is itself the task. A *Connectivity Spotting* graph is dense enough that the model would have to verbalise the entire connectivity structure — at which point it is solving the task, not pre-extracting it. Difficulty should scale with image complexity (more zones, more arrows, more crossings) so that the one-shot description grows past what the model can reliably hold.
+
+**Shortcut 2 — Write code to solve the task end-to-end.**
+The model emits Python that runs OCR, edge detection, blob counting, or vector tracing on the raw image and returns the answer without further reasoning. To block this, the visual primitives must require human-style perception that off-the-shelf CV libraries do not solve cleanly: smoothly anti-aliased turtle curves rather than crisp lines, color-only region boundaries with no contour to detect, hand-placed arrows pointing in arbitrary directions, weighted-graph layouts whose edges are styled rather than thresholded. The answer should also depend on a continuous tracing or counting decision (which arrow comes next, which region is visited 4th) that scripted pipelines get wrong on the soft, irregular renderings used here.
+
+**Shortcut 3 — Statistical priors / answer-distribution leakage.**
+Without looking, the model guesses the modal answer for the task type (e.g. "shortest paths are usually 3 hops", "arrow chains usually terminate at A"). To block this, per-task answer distributions should be flat, with no correlation between trivially extractable image features (region count, canvas size, color palette) and the answer. Each task's annotations should be auditable for this.
+
+**Shortcut 4 — Gestalt heuristics instead of step-by-step tracing.**
+The model glances at the image and uses a learned visual prior — "the green arrow's circle is on the left, the red terminus is on the right, so go right" — without actually executing the traversal. This is especially dangerous on Sequential Traversal: the model can short-circuit a 6-hop arrow chain by interpolating from start-position and end-position. To block this, insert decoys and detours so the geometric "obvious" path is wrong, the answer requires more than half the canvas to be inspected, and the traversal length is long enough that intermediate state is required (mental running count, current-region tracking).
+
+**Shortcut 5 — Memorisation of the released benchmark.**
+Once the dataset is public, models can be fine-tuned on it directly. To block this, the generation pipeline is the artifact. We release `creation.py` with a seed protocol so that *new* unseen instances can be regenerated by evaluators, and we keep a small held-out split with seeds never published. Difficulty scaling (more zones, longer chains) also means evaluators can request harder splits than the released set.
+
+**Shortcut 6 — Agent-tool zoom / crop / OCR loops.**
+A tool-using agent can repeatedly crop, upscale, or OCR sub-regions until the answer falls out, without exercising the model's own active visual reasoning. To block this in tool-using settings, the canvas must already be at a resolution where a single zoom does not localise the answer, the answer should depend on integrating evidence across non-adjacent regions, and any single crop must omit information that another crop also needs.

code/sequential_traversal/arrow_chain/creation.py

@@ -0,0 +1,700 @@
+"""Arrow Chain Traversal (irregular scattered arrows).
+
+Small arrows are scattered across an open canvas. Each arrow is enclosed
+in its own circle, and points at the circle's center — so a ray extended
+from the arrow through the centre exits the circle on the opposite side.
+A handful of larger, labeled terminus circles sit among the arrows.
+
+The traversal rule is pure first-hit ray casting:
+
+  - Start at the green arrow S.
+  - Draw a ray from the current arrow's centre along its pointing
+    direction. The next step is the FIRST other circle the ray enters.
+  - Continue until the ray enters a labeled terminus circle; report its
+    label.
+
+The design deliberately avoids a grid. The "next element" is a global,
+ray-dependent matching problem over every circle on the canvas, so the
+transition table can only be reconstructed by doing the same geometric
+work as the task itself — for every arrow. Decoys are placed everywhere
+except in corridors that would interfere with the intended chain.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import random
+import string
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.image as mpimg
+import matplotlib.patches as mpatches
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.ndimage import rotate as _ndimage_rotate
+from tqdm import tqdm
+
+# Stamp pools: each is a list of (template-image, default-rotation-offset-deg)
+# where default-rotation tells the renderer how to interpret the template's
+# natural orientation. The original foot stamp uses an offset of +50° because
+# the photo's toes are tilted ~50° CCW from straight-up. The fish and key
+# grids were generated with stamps facing straight up, so offset = 0°.
+_FOOT_TEMPLATE: np.ndarray | None = None
+_FOOT_TEMPLATE_PATH = (
+    Path(__file__).resolve().parents[2]
+    / "visual_attribute_transfer/constellation_match_count/image.png"
+)
+_STAMP_POOLS: dict[str, tuple[list[np.ndarray], list[float]]] = {}
+
+# Pool name read from $ARROW_CHAIN_STAMP (default "foot"). Options: foot, fish, key.
+_STAMP_POOL_NAME = os.environ.get("ARROW_CHAIN_STAMP", "foot")
+
+
+def _foot_template() -> np.ndarray:
+    global _FOOT_TEMPLATE
+    if _FOOT_TEMPLATE is None:
+        _FOOT_TEMPLATE = mpimg.imread(str(_FOOT_TEMPLATE_PATH))
+    return _FOOT_TEMPLATE
+
+
+_BG_RGB = (0xf3 / 255.0, 0xef / 255.0, 0xe8 / 255.0)  # matches scene BG
+
+
+def _chroma_key_to_alpha(rgb: np.ndarray, tol: float = 0.16) -> np.ndarray:
+    """Convert HxWx3 to HxWx4 with the stamp's dominant CORNER colour
+    keyed to alpha=0. Auto-detects whether the background is light (fish
+    paper) or dark (key leather). Critical so the stamp doesn't carry a
+    visible halo into the scene that gpt-image-2 would render as a
+    container."""
+    if rgb.ndim != 3 or rgb.shape[2] not in (3, 4):
+        return rgb
+    if rgb.shape[2] == 4:
+        return rgb
+    h, w = rgb.shape[:2]
+    # Sample 4 corners to estimate background colour.
+    corners = np.stack([rgb[0, 0], rgb[0, w-1], rgb[h-1, 0], rgb[h-1, w-1]])
+    bg = corners.mean(axis=0)
+    # Per-pixel distance to background colour (Euclidean in RGB).
+    dist = np.linalg.norm(rgb - bg, axis=2)
+    # Smooth alpha: fully transparent at dist <= tol*0.5, fully opaque at dist >= tol*1.5.
+    lo = tol * 0.5
+    hi = tol * 1.5
+    alpha = np.clip((dist - lo) / max(hi - lo, 1e-6), 0.0, 1.0).astype(rgb.dtype)
+    rgba = np.concatenate([rgb, alpha[..., None]], axis=2)
+    return rgba
+
+
+def _pad_to_square(arr: np.ndarray, fill: tuple[float, float, float] | None = None) -> np.ndarray:
+    """Pad an HxWxC array to a square so scipy.ndimage.rotate operates
+    isotropically. With RGBA arrays, padding is fully transparent."""
+    h, w = arr.shape[:2]
+    n = max(h, w)
+    if h == w == n:
+        return arr
+    if arr.ndim == 3:
+        c = arr.shape[2]
+        pad = np.zeros((n, n, c), dtype=arr.dtype)
+        if c == 4:
+            pad[..., 3] = 0.0  # transparent
+        elif fill is None:
+            for k in range(3):
+                pad[..., k] = _BG_RGB[k]
+        else:
+            for k in range(3):
+                pad[..., k] = fill[k]
+    else:
+        pad = np.full((n, n), fill[0] if fill else 1.0, dtype=arr.dtype)
+    y0 = (n - h) // 2
+    x0 = (n - w) // 2
+    pad[y0:y0+h, x0:x0+w] = arr
+    return pad
+
+
+def _stamp_pool(name: str) -> tuple[list[np.ndarray], list[float]]:
+    """Return (list-of-templates, list-of-rotation-offsets-deg) for the pool."""
+    if name in _STAMP_POOLS:
+        return _STAMP_POOLS[name]
+    base = Path(__file__).resolve().parent
+    if name == "foot":
+        templates = [_pad_to_square(_foot_template())]
+        offsets = [50.0]  # foot photo tilted ~50° CCW vs straight-up
+    elif name in ("fish", "key", "airplane", "bird", "leaf"):
+        d = base / f"{name}_stamps"
+        files = sorted(d.glob("*.png"))
+        if not files:
+            raise FileNotFoundError(f"no stamps in {d}")
+        templates = [
+            _pad_to_square(_chroma_key_to_alpha(mpimg.imread(str(f))))
+            for f in files
+        ]
+        # Per-stamp offsets stored by the calibration page.
+        offsets_path = d / "offsets.json"
+        per_stamp = {}
+        if offsets_path.exists():
+            try:
+                per_stamp = json.loads(offsets_path.read_text())
+            except Exception:
+                per_stamp = {}
+        offsets = [float(per_stamp.get(f"{i:02d}", 0.0)) for i in range(len(templates))]
+    else:
+        raise ValueError(f"unknown stamp pool: {name}")
+    _STAMP_POOLS[name] = (templates, offsets)
+    return _STAMP_POOLS[name]
+
+
+ARROW_COLOR = "#2d2d2d"
+START_COLOR = "#1f9d55"
+TERMINUS_COLORS = [
+    "#c23030", "#1a6dba", "#c47a18", "#7a35a0",
+    "#2d8e2d", "#b83280", "#0f766e", "#b45309",
+]
+
+
+def _wrap(a: float) -> float:
+    return (a + math.pi) % (2 * math.pi) - math.pi
+
+
+def _ray_circle_entry(
+    origin: np.ndarray,
+    direction_unit: np.ndarray,
+    center: np.ndarray,
+    radius: float,
+) -> float | None:
+    """Return the entry t along the ray into a circle, or None if it misses.
+
+    t is the signed distance along the (unit) ray direction at which the
+    ray first crosses the circle boundary. t < 0 or None → the circle is
+    not hit forward from the origin.
+    """
+    to_c = center - origin
+    proj = float(to_c[0] * direction_unit[0] + to_c[1] * direction_unit[1])
+    to_c_sq = float(to_c[0] ** 2 + to_c[1] ** 2)
+    perp_sq = max(0.0, to_c_sq - proj * proj)
+    r_sq = radius * radius
+    if perp_sq > r_sq:
+        return None
+    offset = math.sqrt(r_sq - perp_sq)
+    t_entry = proj - offset
+    if t_entry < 0.0:
+        t_exit = proj + offset
+        if t_exit < 0.0:
+            return None
+        return 0.0  # origin is already inside the circle
+    return t_entry
+
+
+def _ray_min_gap_to_circles(
+    origin: np.ndarray,
+    direction_angle: float,
+    t_end: float,
+    other_circles: List[Tuple[np.ndarray, float, object]],
+) -> float:
+    """Minimum gap between the ray segment [0, t_end] and each circle boundary.
+
+    For each circle, computes the closest distance from the segment to the
+    circle's center, subtracts the radius. Negative means the segment enters
+    the circle. Returns the minimum over all circles (most threatening near-
+    miss).
+    """
+    dv = np.array([math.cos(direction_angle), math.sin(direction_angle)])
+    best = float("inf")
+    for center, radius, _tag in other_circles:
+        to_c = center - origin
+        proj = float(to_c[0] * dv[0] + to_c[1] * dv[1])
+        if proj < 0.0:
+            t_clamp = 0.0
+        elif proj > t_end:
+            t_clamp = t_end
+        else:
+            t_clamp = proj
+        closest = origin + t_clamp * dv
+        d = float(math.hypot(center[0] - closest[0], center[1] - closest[1]))
+        gap = d - radius
+        if gap < best:
+            best = gap
+    return best
+
+
+def _first_circle_hit(
+    origin: np.ndarray,
+    direction_angle: float,
+    circles: List[Tuple[np.ndarray, float, object]],
+    exclude_tag: object | None = None,
+) -> Tuple[float, object] | None:
+    """Return (t_entry, tag) of the first circle entered along the ray."""
+    dv = np.array([math.cos(direction_angle), math.sin(direction_angle)])
+    best = None
+    for center, radius, tag in circles:
+        if tag == exclude_tag:
+            continue
+        t = _ray_circle_entry(origin, dv, center, radius)
+        if t is None:
+            continue
+        if best is None or t < best[0]:
+            best = (t, tag)
+    return best
+
+
+def sample_instance(
+    rng: random.Random,
+    width: int,
+    height: int,
+    min_hops: int = 10,
+    max_hops: int = 13,
+    num_termini: int = 10,
+    num_decoys_target: int = 28,
+    arrow_radius: float = 22.0,
+    terminus_radius: float = 30.0,
+    step_length: float = 300.0,
+    step_jitter: float = 200.0,
+    max_attempts: int = 600,
+) -> Dict | None:
+    """Build a chain + decoys + termini; return a record dict or None."""
+    edge_margin = 110
+    min_center_gap = 2 * arrow_radius + 14  # min distance between arrow centres
+    term_gap = arrow_radius + terminus_radius + 12
+    term_term_gap = 2 * terminus_radius + 60
+    # Required clearance (px) between any ray segment [origin → correct next
+    # circle's boundary] and every OTHER circle on the canvas. This prevents
+    # wrong circles from sitting ambiguously close to a ray that isn't meant
+    # to hit them.
+    clearance_px = 25.0
+
+    for _ in range(max_attempts):
+        # ── 1. Place termini around the canvas (spaced apart) ──
+        termini_pts: List[np.ndarray] = []
+        t_attempts = 0
+        while len(termini_pts) < num_termini and t_attempts < 600:
+            t_attempts += 1
+            x = rng.uniform(edge_margin, width - edge_margin)
+            y = rng.uniform(edge_margin, height - edge_margin)
+            p = np.array([x, y])
+            if all(float(np.linalg.norm(p - q)) > term_term_gap for q in termini_pts):
+                termini_pts.append(p)
+        if len(termini_pts) < num_termini:
+            continue
+
+        num_hops = rng.randint(min_hops, max_hops)
+
+        # ── 2. Build chain of arrow (pos, direction) entries ──
+        start_pos = np.array([
+            rng.uniform(edge_margin + 40, width - edge_margin - 40),
+            rng.uniform(edge_margin + 40, height - edge_margin - 40),
+        ])
+        start_dir = rng.uniform(0, 2 * math.pi)
+        chain: List[Tuple[np.ndarray, float]] = [(start_pos, start_dir)]
+
+        ok = True
+        move_heading = start_dir
+        for _hop in range(num_hops - 1):
+            cur_pos, _ = chain[-1]
+
+            cx_margin = min(cur_pos[0] - edge_margin, width - edge_margin - cur_pos[0])
+            cy_margin = min(cur_pos[1] - edge_margin, height - edge_margin - cur_pos[1])
+            bias_strength = 0.0
+            bias_dir = 0.0
+            if cx_margin < 220 or cy_margin < 220:
+                to_center = np.array([width / 2 - cur_pos[0], height / 2 - cur_pos[1]])
+                bias_dir = math.atan2(to_center[1], to_center[0])
+                bias_strength = max(0.0, 1.0 - min(cx_margin, cy_margin) / 220.0)
+
+            placed = False
+            for _retry in range(30):
+                turn = rng.uniform(-math.pi / 4, math.pi / 4)
+                candidate_dir = move_heading + turn
+                if bias_strength > 0:
+                    cx = math.cos(candidate_dir) * (1 - 0.5 * bias_strength) + \
+                         math.cos(bias_dir) * (0.5 * bias_strength)
+                    cy = math.sin(candidate_dir) * (1 - 0.5 * bias_strength) + \
+                         math.sin(bias_dir) * (0.5 * bias_strength)
+                    candidate_dir = math.atan2(cy, cx)
+                dvec = np.array([math.cos(candidate_dir), math.sin(candidate_dir)])
+                pvec = np.array([-math.sin(candidate_dir), math.cos(candidate_dir)])
+                step_len = step_length + rng.uniform(-step_jitter, step_jitter)
+                perp = rng.uniform(-step_jitter, step_jitter)
+                next_pos = cur_pos + step_len * dvec + perp * pvec
+                if not (edge_margin < next_pos[0] < width - edge_margin and
+                        edge_margin < next_pos[1] < height - edge_margin):
+                    continue
+                if any(float(np.linalg.norm(next_pos - t)) < term_gap for t in termini_pts):
+                    continue
+                if any(float(np.linalg.norm(next_pos - p)) < min_center_gap for p, _ in chain):
+                    continue
+
+                actual_dir = math.atan2(
+                    next_pos[1] - cur_pos[1], next_pos[0] - cur_pos[0],
+                )
+                chain[-1] = (cur_pos, actual_dir)
+                chain.append((next_pos, actual_dir))
+                move_heading = actual_dir
+                placed = True
+                break
+            if not placed:
+                ok = False
+                break
+
+        if not ok or len(chain) < num_hops:
+            continue
+
+        # ── 3. Pick a terminus the last arrow can point at without blockage ──
+        last_pos = chain[-1][0]
+        other_arrow_circles = [
+            (chain[j][0], arrow_radius, ("A", j)) for j in range(num_hops - 1)
+        ]
+        terminus_circles = [
+            (termini_pts[k], terminus_radius, ("T", k)) for k in range(num_termini)
+        ]
+        feasible = []
+        for k in range(num_termini):
+            to_t = termini_pts[k] - last_pos
+            dist = float(math.hypot(to_t[0], to_t[1]))
+            if dist < arrow_radius + terminus_radius + 10:
+                continue
+            last_dir_k = math.atan2(to_t[1], to_t[0])
+            hit = _first_circle_hit(
+                last_pos, last_dir_k,
+                other_arrow_circles + terminus_circles,
+                exclude_tag=("A", num_hops - 1),
+            )
+            if hit is not None and hit[1] == ("T", k):
+                feasible.append(k)
+        if not feasible:
+            continue
+        chosen_term_idx = rng.choice(feasible)
+        last_dir = math.atan2(
+            termini_pts[chosen_term_idx][1] - last_pos[1],
+            termini_pts[chosen_term_idx][0] - last_pos[0],
+        )
+        chain[-1] = (last_pos, last_dir)
+
+        # ── 4. Verify chain integrity under the first-hit ray rule ──
+        arrow_positions = [c[0] for c in chain]
+        all_arrow_circles = [
+            (arrow_positions[j], arrow_radius, ("A", j)) for j in range(num_hops)
+        ]
+        chain_valid = True
+        for i in range(num_hops):
+            hit = _first_circle_hit(
+                arrow_positions[i], chain[i][1],
+                all_arrow_circles + terminus_circles,
+                exclude_tag=("A", i),
+            )
+            if hit is None:
+                chain_valid = False
+                break
+            expected = ("T", chosen_term_idx) if i == num_hops - 1 else ("A", i + 1)
+            if hit[1] != expected:
+                chain_valid = False
+                break
+
+            # Clearance check: every OTHER circle must stay ≥ clearance_px
+            # away from the ray segment [0, t_correct].
+            t_correct = hit[0]
+            other_circles = [
+                c for c in (all_arrow_circles + terminus_circles)
+                if c[2] not in (("A", i), expected)
+            ]
+            if other_circles:
+                gap = _ray_min_gap_to_circles(
+                    arrow_positions[i], chain[i][1], t_correct, other_circles,
+                )
+                if gap < clearance_px:
+                    chain_valid = False
+                    break
+        if not chain_valid:
+            continue
+
+        # ── 5. Add decoys that do not break any chain transition ──
+        decoys: List[Tuple[np.ndarray, float]] = []
+        add_attempts = 0
+        while len(decoys) < num_decoys_target and add_attempts < num_decoys_target * 30:
+            add_attempts += 1
+            dpos = np.array([
+                rng.uniform(edge_margin, width - edge_margin),
+                rng.uniform(edge_margin, height - edge_margin),
+            ])
+            if any(float(np.linalg.norm(dpos - p)) < min_center_gap for p in arrow_positions):
+                continue
+            if any(float(np.linalg.norm(dpos - t)) < term_gap for t in termini_pts):
+                continue
+            if any(float(np.linalg.norm(dpos - p)) < min_center_gap for p, _ in decoys):
+                continue
+
+            # A decoy circle is safe iff, for every chain ray, the ray
+            # segment up to the correct next circle's entry stays at least
+            # `clearance_px` away from the decoy boundary.
+            broken = False
+            for i in range(num_hops):
+                origin = arrow_positions[i]
+                dir_angle = chain[i][1]
+                dv_unit = np.array([math.cos(dir_angle), math.sin(dir_angle)])
+                if i < num_hops - 1:
+                    correct_c = arrow_positions[i + 1]
+                    correct_r = arrow_radius
+                else:
+                    correct_c = termini_pts[chosen_term_idx]
+                    correct_r = terminus_radius
+                t_correct = _ray_circle_entry(origin, dv_unit, correct_c, correct_r)
+                if t_correct is None:
+                    broken = True
+                    break
+                gap = _ray_min_gap_to_circles(
+                    origin, dir_angle, t_correct,
+                    [(dpos, arrow_radius, ("D", len(decoys)))],
+                )
+                if gap < clearance_px:
+                    broken = True
+                    break
+            if broken:
+                continue
+
+            ddir = rng.uniform(0, 2 * math.pi)
+            decoys.append((dpos, ddir))
+
+        if len(decoys) < max(18, num_decoys_target - 8):
+            continue
+
+        # ── 6. Assemble record ──
+        terminus_labels = list(string.ascii_uppercase[:num_termini])
+        rng.shuffle(terminus_labels)
+        answer = terminus_labels[chosen_term_idx]
+
+        question = (
+            f"The image shows many small footprints scattered across the canvas, "
+            f"each footprint enclosed in its own circle, plus {num_termini} "
+            f"larger labeled terminus circles "
+            f"({', '.join(sorted(terminus_labels))}). The footprint inside the "
+            f"GREEN circle is the starting point. From that footprint, follow "
+            f"the direction its toes point: cast an infinitely thin ray (a "
+            f"mathematical half-line with zero width) from the footprint's "
+            f"circle centre along the toe-to-heel pointing direction, and the "
+            f"next step is the FIRST other circle this zero-width ray enters. A "
+            f"circle only counts if the ray actually crosses its boundary — "
+            f"grazing nearby without entering does not count. Continue until "
+            f"the ray enters a labeled terminus circle and report its label. "
+            f"Answer with a single letter. "
+            f"Provide your final answer enclosed in <answer>...</answer> tags."
+        )
+
+        return {
+            "width": width,
+            "height": height,
+            "num_hops": num_hops,
+            "num_decoys": len(decoys),
+            "arrow_radius": arrow_radius,
+            "terminus_radius": terminus_radius,
+            "chain": [{"x": float(p[0]), "y": float(p[1]), "dir": float(d)}
+                      for p, d in chain],
+            "decoys": [{"x": float(p[0]), "y": float(p[1]), "dir": float(d)}
+                       for p, d in decoys],
+            "termini": [{"x": float(t[0]), "y": float(t[1]),
+                         "label": terminus_labels[i]}
+                        for i, t in enumerate(termini_pts)],
+            "chosen_terminus_label": answer,
+            "question": question,
+            "answer": answer,
+        }
+    return None
+
+
+# ── Rendering ────���─────────────────────────────────────────────────
+
+def _draw_arrow_in_circle(
+    ax,
+    cx: float,
+    cy: float,
+    direction: float,
+    arrow_radius: float,
+    circle_color: str,
+    arrow_color: str,
+    zorder: float = 2.0,
+    circle_lw: float = 1.2,
+    arrow_lw: float = 1.8,
+    circle_fill: str = "none",
+) -> None:
+    """Stamp the foot template at (cx, cy), rotated so the toes point in
+    ``direction`` (radians, screen convention: 0=right, π/2=down, -π/2=up).
+
+    The template's natural orientation has toes "up" (data direction -π/2),
+    so the rotation needed is direction + π/2 in display coords. scipy's
+    ndimage.rotate uses degrees, positive = counter-clockwise in array
+    coordinates (y-down). With imshow on inverted-y axes that visually
+    matches counter-clockwise on screen, so we negate.
+    """
+    pool, offsets = _stamp_pool(_STAMP_POOL_NAME)
+    # Pick a stamp from the pool. Use a process-stable hash of (cx, cy) so the
+    # same cell always gets the same stamp across regenerations (within one
+    # difficulty/seed combo).
+    pick = int((cx * 91 + cy * 53)) % len(pool)
+    template = pool[pick]
+    rot_deg = -(math.degrees(direction) + 90.0) + offsets[pick]
+    rotated = _ndimage_rotate(
+        template, rot_deg, reshape=False, order=1, mode="constant", cval=1.0
+    )
+    # Match stamp visual radius to arrow_radius (the cell circle radius).
+    stamp_radius = arrow_radius
+    extent = (cx - stamp_radius, cx + stamp_radius,
+              cy + stamp_radius, cy - stamp_radius)
+    img_artist = ax.imshow(rotated, extent=extent, zorder=zorder + 0.1,
+                            interpolation="bilinear")
+    clip = mpatches.Circle((cx, cy), radius=stamp_radius, transform=ax.transData)
+    img_artist.set_clip_path(clip)
+
+    # Cell outline: only for the foot pool (fish/key cells get no outline so
+    # the stamp is not visually cropped or boxed-in).
+    if _STAMP_POOL_NAME == "foot":
+        circle = mpatches.Circle(
+            (cx, cy), radius=arrow_radius,
+            facecolor="none", edgecolor=circle_color,
+            linewidth=circle_lw, zorder=zorder + 0.2,
+        )
+        ax.add_patch(circle)
+    elif circle_color != "#6b6b6b":
+        # Non-foot pool but a special cell (e.g. green start ring): still
+        # draw the outline so the start cell is identifiable.
+        circle = mpatches.Circle(
+            (cx, cy), radius=arrow_radius,
+            facecolor="none", edgecolor=circle_color,
+            linewidth=circle_lw, zorder=zorder + 0.2,
+        )
+        ax.add_patch(circle)
+
+
+def render_instance(out_path: Path, record: Dict, noise_seed: int) -> None:
+    width = int(record["width"])
+    height = int(record["height"])
+    arrow_radius = float(record["arrow_radius"])
+    terminus_radius = float(record["terminus_radius"])
+
+    fig = plt.figure(figsize=(width / 100, height / 100), dpi=100)
+    ax = fig.add_axes([0, 0, 1, 1])
+    ax.set_xlim(0, width)
+    ax.set_ylim(height, 0)
+    ax.axis("off")
+    ax.set_facecolor("#f3efe8")
+
+    nrng = np.random.default_rng(noise_seed)
+    noise = nrng.normal(0.0, 1.0, size=(height, width))
+    noise = (noise - noise.min()) / max(noise.max() - noise.min(), 1e-6)
+    ax.imshow(noise, cmap="Greys", alpha=0.06, extent=(0, width, height, 0),
+              interpolation="bilinear")
+
+    for d in record["decoys"]:
+        _draw_arrow_in_circle(
+            ax, d["x"], d["y"], d["dir"], arrow_radius,
+            circle_color="#6b6b6b", arrow_color=ARROW_COLOR,
+            zorder=2.0, circle_lw=1.1, arrow_lw=1.7,
+        )
+
+    for i, c in enumerate(record["chain"]):
+        if i == 0:
+            # Start cell: foot stamp inside a thicker GREEN circle (no "S" label).
+            _draw_arrow_in_circle(
+                ax, c["x"], c["y"], c["dir"], arrow_radius,
+                circle_color=START_COLOR, arrow_color=START_COLOR,
+                zorder=3.6, circle_lw=2.6, arrow_lw=2.4,
+            )
+        else:
+            _draw_arrow_in_circle(
+                ax, c["x"], c["y"], c["dir"], arrow_radius,
+                circle_color="#6b6b6b", arrow_color=ARROW_COLOR,
+                zorder=2.3, circle_lw=1.1, arrow_lw=1.8,
+            )
+
+    for i, t in enumerate(record["termini"]):
+        color = TERMINUS_COLORS[i % len(TERMINUS_COLORS)]
+        circle = mpatches.Circle(
+            (t["x"], t["y"]), radius=terminus_radius,
+            facecolor=color, edgecolor="white", linewidth=2.0, zorder=5.0,
+        )
+        ax.add_patch(circle)
+        ax.text(t["x"], t["y"], t["label"],
+                fontsize=20, fontweight="bold", color="white",
+                ha="center", va="center", zorder=5.5)
+
+    fig.savefig(out_path, dpi=100, bbox_inches="tight", pad_inches=0)
+    plt.close(fig)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument("--count", type=int, default=20)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--width", type=int, default=512)
+    parser.add_argument("--height", type=int, default=512)
+    parser.add_argument("--difficulty", type=int, default=5,
+                        help="Integer difficulty >=0; scales termini/hops/decoys.")
+    args = parser.parse_args()
+
+    def _canvas_scale(n_d, n_0):
+        import math
+        return math.sqrt(max(1.0, n_d / n_0))
+    d = max(0, int(args.difficulty))
+    N_d = 15 + 8 * d
+    N_0 = 15
+    s = _canvas_scale(N_d, N_0)
+    args.width  = int(round(args.width  * s))
+    args.height = int(round(args.height * s))
+
+    out_root = args.output_root
+    img_dir = out_root / "images"
+    img_dir.mkdir(parents=True, exist_ok=True)
+
+    rng = random.Random(args.seed)
+    records = []
+
+    _num_termini = min(12, 5 + d)
+    _min_hops = 5 + 2 * d
+    _max_hops = 5 + 2 * d + 2
+    _num_decoys_target = 10 + 6 * d
+
+    pbar = tqdm(range(args.count), desc="Generating", unit="img")
+    for idx in pbar:
+        record = sample_instance(
+            rng, args.width, args.height,
+            min_hops=_min_hops, max_hops=_max_hops,
+            num_termini=_num_termini,
+            num_decoys_target=_num_decoys_target,
+            step_length=200.0,
+            step_jitter=100.0,  # ray step range = [100, 300]
+            arrow_radius=26.0,
+            terminus_radius=26.0,
+        )
+        if record is None:
+            pbar.set_postfix(status="FAILED")
+            continue
+
+        name = f"arrow_chain_{idx:05d}.png"
+        ns = rng.randint(0, 10 ** 9)
+        render_instance(img_dir / name, record, noise_seed=ns)
+
+        record["image"] = f"images/{name}"
+        records.append(record)
+        pbar.set_postfix(ok=len(records), hops=record["num_hops"],
+                         decoys=record["num_decoys"], ans=record["answer"])
+
+    with (out_root / "annotations.jsonl").open("w") as fh:
+        for r in records:
+            fh.write(json.dumps(r) + "\n")
+
+    data_json = {
+        "task": "arrow_chain",
+        "category": "sequential_traversal",
+        "count": len(records),
+        "items": [
+            {"image": r["image"], "question": r["question"], "answer": r["answer"]}
+            for r in records
+        ],
+    }
+    (out_root / "data.json").write_text(json.dumps(data_json, indent=2))
+    print(f"Saved {len(records)} items to {out_root}")
+
+
+if __name__ == "__main__":
+    main()

code/sequential_traversal/arrow_chain/data.json

@@ -0,0 +1,32 @@
+{
+  "task": "arrow_chain",
+  "category": "sequential_traversal",
+  "count": 5,
+  "items": [
+    {
+      "image": "images/arrow_chain_00000.png",
+      "question": "The image shows many small pieces scattered across the canvas, each clearly oriented in a specific direction, plus several larger labeled terminus markers (each marker bears a distinct letter). The piece highlighted by a green ring is the starting point. From that piece, cast an infinitely thin ray (a mathematical half-line with zero width) from its centre along the direction it points; the next step is the FIRST other marker this ray enters. A marker only counts if the ray actually crosses its boundary \u2014 grazing nearby without entering does not count. Continue until the ray enters a labeled terminus marker and report its letter. Answer with a single letter. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": "H"
+    },
+    {
+      "image": "images/arrow_chain_00001.png",
+      "question": "The image shows many small pieces scattered across the canvas, each clearly oriented in a specific direction, plus several larger labeled terminus markers (each marker bears a distinct letter). The piece highlighted by a green ring is the starting point. From that piece, cast an infinitely thin ray (a mathematical half-line with zero width) from its centre along the direction it points; the next step is the FIRST other marker this ray enters. A marker only counts if the ray actually crosses its boundary \u2014 grazing nearby without entering does not count. Continue until the ray enters a labeled terminus marker and report its letter. Answer with a single letter. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": "B"
+    },
+    {
+      "image": "images/arrow_chain_00002.png",
+      "question": "The image shows many small pieces scattered across the canvas, each clearly oriented in a specific direction, plus several larger labeled terminus markers (each marker bears a distinct letter). The piece highlighted by a green ring is the starting point. From that piece, cast an infinitely thin ray (a mathematical half-line with zero width) from its centre along the direction it points; the next step is the FIRST other marker this ray enters. A marker only counts if the ray actually crosses its boundary \u2014 grazing nearby without entering does not count. Continue until the ray enters a labeled terminus marker and report its letter. Answer with a single letter. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": "B"
+    },
+    {
+      "image": "images/arrow_chain_00003.png",
+      "question": "The image shows many small pieces scattered across the canvas, each clearly oriented in a specific direction, plus several larger labeled terminus markers (each marker bears a distinct letter). The piece highlighted by a green ring is the starting point. From that piece, cast an infinitely thin ray (a mathematical half-line with zero width) from its centre along the direction it points; the next step is the FIRST other marker this ray enters. A marker only counts if the ray actually crosses its boundary \u2014 grazing nearby without entering does not count. Continue until the ray enters a labeled terminus marker and report its letter. Answer with a single letter. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": "J"
+    },
+    {
+      "image": "images/arrow_chain_00004.png",
+      "question": "The image shows many small pieces scattered across the canvas, each clearly oriented in a specific direction, plus several larger labeled terminus markers (each marker bears a distinct letter). The piece highlighted by a green ring is the starting point. From that piece, cast an infinitely thin ray (a mathematical half-line with zero width) from its centre along the direction it points; the next step is the FIRST other marker this ray enters. A marker only counts if the ray actually crosses its boundary \u2014 grazing nearby without entering does not count. Continue until the ray enters a labeled terminus marker and report its letter. Answer with a single letter. Provide your final answer enclosed in <answer>...</answer> tags.",
+      "answer": "C"
+    }
+  ]
+}

code/sequential_traversal/arrow_chain/fish_stamps/offsets.json

@@ -0,0 +1,8 @@
+{
+  "02": -1,
+  "01": -1,
+  "05": -3,
+  "00": 0,
+  "03": 1,
+  "04": -1
+}

code/sequential_traversal/arrow_chain/key_stamps/offsets.json

@@ -0,0 +1,6 @@
+{
+  "02": 0,
+  "01": 0,
+  "00": 0,
+  "05": 0
+}