---
license: other
license_name: upstream-undeclared
license_link: https://huggingface.co/datasets/ThinkMorph/Jigsaw_Assembly
pretty_name: "Spatial MMCoT v1 - thinkmorph_jigsaw"
language:
- en
task_categories:
- visual-question-answering
- image-to-image
tags:
- spatial-reasoning
- interleaved-reasoning
- multimodal-chain-of-thought
size_categories:
- 1K<n<10K
configs:
- config_name: preview
  default: true
  data_files:
  - split: train
    path: preview/train/*.parquet
  - split: validation
    path: preview/validation/*.parquet
- config_name: train
  data_files:
  - split: train
    path: train/*.parquet
  - split: validation
    path: validation/*.parquet
- config_name: meta
  data_files:
  - split: train
    path: meta/train/*.parquet
  - split: validation
    path: meta/validation/*.parquet
---

# Spatial MMCoT v1 · `thinkmorph_jigsaw`

ThinkMorph ([arXiv:2510.27492](https://arxiv.org/abs/2510.27492)) Jigsaw_Assembly: a picture cut into numbered parts, shown in an order that may be shuffled; decide the arrangement, draw the assembled picture, read it back, answer. According to the ThinkMorph paper (arXiv:2510.27492, appendix on data generation), GPT-4.1 wrote the plan and the read-back from the question and the ground-truth answer, and was told not to reveal the answer. The pictures come from 3 corpora: 3,201 rows are SAT renders of ProcTHOR houses (AI2-THOR assets); 1,819 rows are real photographs from ADE20K; 774 rows are real photographs from SUN RGB-D; the per-row corpus is `source_scene_corpus` in `meta` and `preview`. On photograph rows both the input and the target are the photograph. On 1,621 of the 5,794 rows (28.0%) the parts are already shown in the right order, so the target is the input with the separator strips and the number labels removed, not a rearrangement (592 of 1,123 on 1x2, 200 of 1,192 on 1x3, 580 of 1,114 on 2x1, 50 of 1,188 on 2x2, 199 of 1,177 on 3x1). Changes from upstream: images are re-encoded as JPEG; inputs are downscaled to a long edge of at most 512 px and targets to at most 768 px (smaller images keep their size). The part numbers are drawn upstream at a fixed size, and about half of the ADE20K photographs are 1,025-2,239 px on their long edge upstream, so on those rows the numbers shrink to a few pixels and are often unreadable. Every question states which position carries which number, so the task does not depend on reading them. Refused by the conversion's checks: 118 rows whose read-back names a different option from the label (`S0.readback_names_other_option`); 14 rows whose plan names a different option from the label (`S0.plan_names_other_option`). The plan usually decides the arrangement before the picture is drawn. Where the upstream plan named an option letter, every sentence that named one was moved to the start of the read-back (2,012 rows, flag `S4.plan_verdict_moved`). On most of these rows that sentence is the plan's closing verdict, so the read-back opens with the verdict before it re-examines the picture; on some it is the plan's comparison of the options, and there the plan no longer says which arrangement to draw (see Known issues).

## Reasoning text in this release (r4)

The paragraph above describes the upstream data, and where it describes the reasoning text it describes the text of the previous release (r3). In this release every thought was rewritten: Qwen3.8-27B in thinking mode (temperature 1.0, top-p 0.95, top-k 20; prompt v4.1, `scripts/annotate/rationale.py` in our conversion code (the code repository is not public yet)) was shown the row's input images, its target images in order, the question, the options and the answer, and wrote the thought before each target image (what is still unknown, and what the picture should show to settle it) and the read-back after the last one. The images, the question, the options, the answer and the number of steps are r3's, checked row by row (image bytes, instruction, K and the `<answer>` value).

This is the training subset: 5 rows of r4 are not in it, listed with their reason in `reports/subset_dropped.jsonl`: 5 the rewrite model judged the stored answer doubtful (its note is in the list) (`label_doubt`).

Self-check of the rewritten text (measured 2026-10-02 on 22 rows sampled from this source before the removals above, each judged against its full-resolution pictures): 0.50 faithfulness errors per row (a claim the pictures contradict), 68% of rows with none; the plan names the real obstacle on 100%, the read-back reads the picture it follows on 100%, and the answer follows from the text on 100%.

The measured caveats on the r3 card were counted on r3's rows and text and are not repeated here; the per-row known-issue lists below were measured again on these rows and this text.

**Supervision kind** (`supervision_kind` in `meta`): `full_interleaved` on every row: the upstream trace itself interleaves text and target images (drawn or rendered states on most sources; the source note above says which), and the read-back comes after the target image it reads. In this release the text was rewritten by a model shown every image of the row (see the r4 section above).

Upstream: [`ThinkMorph/Jigsaw_Assembly`](https://huggingface.co/datasets/ThinkMorph/Jigsaw_Assembly). Licence: **undeclared**. The upstream repository declares no licence; this converted copy is shared for research use only, whatever terms the upstream authors set apply to it as well, and it will be taken down at their request. The ADE20K and SUN RGB-D photographs (the rows whose `source_scene_corpus` is `ade20k` or `sunrgbd`, in both `meta` and `preview`) are third-party images: neither ThinkMorph nor we hold their copyright, and they remain under the terms of ADE20K (https://groups.csail.mit.edu/vision/datasets/ADE20K/terms/) and SUN RGB-D, and of the collections those draw on. ADE20K's terms allow use only for non-commercial research and education, and allow the images to be passed on only to people who agree to those terms; download these rows only if you accept them. To leave the photographs out, filter on `source_scene_corpus`. The SAT renders come from SAT (MIT) and ProcTHOR / AI2-THOR assets. The reasoning text was generated with OpenAI's GPT-4.1 (ThinkMorph paper, appendix on data generation); OpenAI's terms for model outputs may bear on some uses, for example training models that compete with OpenAI's.

## Known issues

Rows with a measured per-row problem are listed in `reports/known_issues/`, one TSV per issue (a `# <description>` line, then `row_uid<TAB>split<TAB>detail` lines), so they can be filtered out. They are still in this release: no row was removed for these issues.

| issue | rows | train | validation | what | how it was found | file |
|---|---:|---:|---:|---|---|---|
| `target_shared_with_other_row` | 12 | 12 | 0 | The same picture (decoded pixels identical) is the target of another shipped row: one photograph or render under two upstream file names, cut into different puzzles. | md5 of the decoded target pixels occurs on more than one shipped row; measured 2026-10-03; known&#95;issues.py sha1 b2249331; export b3fa1b9 rows b9bf1db8/03b25ffb | `reports/known_issues/target_shared_with_other_row.tsv` |
| `text_states_other_arrangement` | 3 | 3 | 0 | The target image and &lt;answer&gt; show the labelled arrangement, but the text does not: the plan concludes, or the read-back says it assembled or chose, a different arrangement (or names another option's letter). | 3/4-part: a full position-&gt;part statement that is not hypothetical and not an enumerated rejected option, differs from the label (the plan's last such statement, any in the read-back); 2-part: a placing/'Part X should be left of Part Y' statement that puts the other part first; any part: 'matches/corresponds to (X)' with X not the answer, or '(X)' followed by option Y's text; measured 2026-10-03; known&#95;issues.py sha1 b2249331; export b3fa1b9 rows b9bf1db8/03b25ffb | `reports/known_issues/text_states_other_arrangement.tsv` |
| `validation_target_near_copy_of_train` | 1 | 0 | 1 | This validation row's target is a near-copy of a training row's target (the same scene shot from a slightly shifted viewpoint), so it is not fully held out. | validation target within 10 bits (of 256) of a training target by a 17x16 greyscale difference hash; the next-nearest validation-train pair on r2 is 43 bits apart; measured 2026-10-03; known&#95;issues.py sha1 b2249331; export b3fa1b9 rows b9bf1db8/03b25ffb | `reports/known_issues/validation_target_near_copy_of_train.tsv` |

To leave the listed rows out (the snippet in the loader section downloads `reports/known_issues/` with the data):

```python
import glob, os
root = "<root>/thinkmorph_jigsaw"
drop = {line.split("\t")[0] for f in glob.glob(os.path.join(root, "reports/known_issues/*.tsv"))
        for line in open(f) if line.strip() and not line.startswith(("#", "row_uid\t"))}
# keep a row when its row_uid (a column of train/, meta/ and preview/) is not in drop
```

## Size

| split | rows | target image slots | distinct target images |
|---|---:|---:|---:|
| train | 5,651 | 5,651 | 5,645 |
| validation | 143 | 143 | 143 |

A slot is one target position in one row. Upstream has a few pictures under two file names, cut into different puzzles, so a few rows share a target picture (see Known issues).

| task | train | validation |
|---|---:|---:|
| jigsaw_1x2 | 1,086 | 37 |
| jigsaw_1x3 | 1,163 | 29 |
| jigsaw_2x1 | 1,098 | 16 |
| jigsaw_2x2 | 1,158 | 30 |
| jigsaw_3x1 | 1,146 | 31 |

Input images per row: 1. Target images per row (the images the model is trained to generate): 1.
Image corpus (`source_scene_corpus`): procthor 3,201, ade20k 1,819, sunrgbd 774.

## Row format

One row is: input image(s) and a question, then K rounds of *thought → target image* (the target is the source's own ground-truth image, which the model is trained to generate), then a final thought (normally a read-back of the last target; where a source's final thought is something else, or often leaves out the answer, the source note or Known issues says so) and the answer; here K is 1. In the `train` config:

```
image_list        list<binary>  inputs first, then the K target images in order
num_input_images  int64         how many of image_list are inputs
instruction_list  list<string>  one element: system prompt + question + options
output_text_list  list<string>  K+1 elements:
  [0]   <think>plan 1</think><image_start>
  [j]   <image_end><think>plan j+1</think><image_start>
  [K]   <image_end><think>read-back</think><answer>answer</answer>
row_uid           string        join key to `meta` and `preview`
```

On every row `<answer>` holds the option key (answer type `mcq_letter` 5,794) that the model is trained to emit (a letter for `mcq_letter`), while `meta.answer_value` (the `answer` column of `preview`) holds that option's text. Map the key through the options listed in the question before comparing the two, and score model output against `<answer>`.

The system prompt is ThinkMorph's `VLM_THINK_SYSTEM_PROMPT` from its `inferencer.py`, verbatim (`GEN_THINK_SYSTEM_PROMPT` there has the same text), including its leading and trailing newline. The markers are plain strings, not tokenizer special tokens; the prompt writes `</image_end>` and the data writes `<image_end>`, exactly as the ThinkMorph-7B checkpoint was trained.

`preview` shows the same rows with one column per slot: `input_image_i` for the inputs; for each of the K = `num_steps` rounds, the plan `thought_j` and its target `target_image_j`; and the read-back in `thought_1` on every row.

`meta` holds the per-row sidecar: task, `scene_id` and `geometry_uid` (the scene and geometry keys; the split key is named in the split paragraph below), `trajectory_id` (a camera-path or sample label, empty where the source has none), `num_steps`, `num_input_images`, `answer_type`, `answer_value`, `majority_class_rate`, `target_image_kind`, `target_px`, `est_tokens`, licence, `split` (`train` / `validation`, the Hub split names), `supervision_kind` (`full_interleaved` / `visual_aux` / `visual_only`) and `filter_flags`. `majority_class_rate` is the share of the task's most frequent `answer_value` among its training rows: it measures answer skew and is not a guessing baseline (where a task mixes question types or each row has its own options it can be far below chance); compare scores with the text-only baselines below.

Per-row `license` in `meta`: undeclared 5,794.

Flags on released rows (`filter_flags` in `meta` and `preview`, comma-separated):

| flag | rows | meaning |
|---|---:|---|
| `S5.replay_unsupported` | 5,794 | no solver re-derives this task's answer from the trace, so S5 did not replay it |
| `S4.plan_verdict_moved` | 2,012 | the plan named the option letter; those sentences were moved to the start of the read-back |
| `S8.phash_near_but_distinct` | 1,373 | a target's perceptual hash is within 6 bits of an input image's, but its pixels differ, so it is not a copy; kept |
| `S14.sampled_qa` | 200 | chosen for the S14 human spot-check (`reports/s14_sample.tsv`) |
| `S0.control_chars_stripped` | 52 | control characters removed from the upstream text |
| `S4c.freeform_unadjudicated` | 13 | the label (for multiple choice, the option text) is longer than 30 characters or spans lines, and S4c's 30-character capture of the read-back's conclusion matched neither it nor the option key, so S4c could not compare them; kept |

### Training with a BAGEL-family loader

Every row here has one input image (`num_input_images` is 1), so the stock ThinkMorph `UnifiedEditIterableDataset` (https://github.com/ThinkMorph/ThinkMorph: `image_list[0]` as input, `image_list[j+1]` after `output_text_list[j]`) and the IPT release's version (which reads `num_input_images`) both read it as intended. Mixed with a source whose rows have more than one input image, only a loader that reads `num_input_images` is correct.

The stock BAGEL edit loader (ByteDance-Seed/Bagel) cannot train these rows: it never reads `output_text_list` and expects each `instruction_list` element to be a list of paraphrases.

`parquet_info.json` keys each training chunk as `<source>/<split>/<file>`, here `thinkmorph_jigsaw/train/chunk_00000.parquet`, with row-group counts read from the parquet footers. The loader matches a chunk only when its key equals the path it builds, `os.path.join(data_dir, file)`, and skips a chunk with no key without a warning: a source that is alone in its group then fails with `IndexError: list index out of range`, and in a mixed group it adds no rows. Download into a directory named after the source, not after the repository:

```python
from huggingface_hub import snapshot_download
snapshot_download("yrlyrl/spatial-mmcot-thinkmorph_jigsaw", repo_type="dataset", local_dir="<root>/thinkmorph_jigsaw",
                  allow_patterns=["train/*", "validation/*", "parquet_info.json", "reports/known_issues/*"])
```

Then either run from `<root>` with `data_dir: thinkmorph_jigsaw/train` and `parquet_info_path: thinkmorph_jigsaw/parquet_info.json`, or rebuild the index with absolute keys and use an absolute `data_dir`:

```python
import json, os
root = "/abs/path/to/root"                      # the directory that holds thinkmorph_jigsaw/
info = json.load(open(os.path.join(root, "thinkmorph_jigsaw", "parquet_info.json")))
info = {os.path.join(root, k): v for k, v in info.items()}
json.dump(info, open(os.path.join(root, "thinkmorph_jigsaw", "parquet_info_abs.json"), "w"))
# data_dir = os.path.join(root, "thinkmorph_jigsaw", "train")   (spelled exactly so, no trailing slash)
# parquet_info_path = os.path.join(root, "thinkmorph_jigsaw", "parquet_info_abs.json")
```

The Hugging Face cache (`.../snapshots/<hash>/train/`) or a folder named `spatial-mmcot-thinkmorph_jigsaw` matches no key.

`num_used_data` counts chunk files, not rows: the loader repeats this source's file list up to that number, lists every (file, row group) pair, and deals whole row groups out, floor(R / world_size) to each rank and floor(that / num_workers) to each DataLoader worker. The remainder is never read. This source has 1 training chunk file holding 45 row groups of up to 128 rows, so keep `num_used_data` large, e.g. the 128 of ThinkMorph's `interleaved_reasoning.yaml` (upstream's `example.yaml` asks for more than GPUs x workers); every row group is then read. Set to 1 and alone in its group on 8 GPUs with 4 workers, it reads only 32 of the 45 row groups. In a run that mixes sources, give each source the same multiple of its own training chunk-file count, e.g. 128 per file (128 here): the file list is repeated up to `num_used_data` entries, so a flat 128 for every source would read a two-file source's rows half as often as a one-file source's.

## How the rows were chosen

| stage | rows |
|---|---:|
| upstream rows read | 6,000 |
| refused before conversion (`S0raw`; each reason is in the table below) | 133 |
| removed as benchmark evaluation items (S11) | 2 |
| dropped at S5 (the text contains a phrase from S5's self-contradiction list, e.g. 'does not make sense', 'discrepancy', 'there must be a mistake'; a keyword match, not a comparison with the images, so it also removes some sound rows) | 36 |
| after conversion and per-row filters | 5,829 |
| removed by S10 (none) | 0 |
| removed by answer-prior balancing (S13) | 30 |
| removed for training after the r4 rewrite (`subset_dropped.jsonl`) | 5 |
| **released** | **5,794** |

Every removed row has one line, with its reason, in `reports/`:

| file | step | reason (the line's `flag`, or the field shown) | rows |
|---|---|---|---:|
| `build/dropped.jsonl` | S0raw | `S0.readback_names_other_option` | 118 |
| `build/dropped.jsonl` | S0raw | `S0.plan_names_other_option` | 14 |
| `build/dropped.jsonl` | S0raw | `S0.plan_enumerates_options` | 1 |
| `build/dropped.jsonl` | S11 | `S11.bench_item` | 2 |
| `build/dropped.jsonl` | S5 | `S5.self_contradiction` | 36 |
| `s13_dropped.jsonl` | S13 | `step: letter` | 24 |
| `s13_dropped.jsonl` | S13 | `step: answer` | 6 |
| `subset_dropped.jsonl` | r4 | `reason: label_doubt` | 5 |

Every line of `s13_dropped.jsonl` has `reason: prior_downsample`; `step` names the balancing pass that removed it, and `split` is written `train` or `val` (the Hub's `validation`).

`S0raw` lines in `build/dropped.jsonl` were refused before a release row existed, so their `row_uid` field holds the converter's key for the upstream record, not a 16-hex `row_uid`; lines from later steps carry the `row_uid` the row had. No removed row appears in `meta` or `preview`.

`S11.bench_item` marks upstream rows with an image that is an evaluation item of a benchmark (2 rows: puzzles whose target, the assembled photograph, is an image of the What's Up benchmark (Kamath et al., 2023), which is not among the benchmarks we report but is kept out of training; upstream ThinkMorph Jigsaw_Assembly still contains them); they were removed during conversion, so no such item ships.

<details><summary>Per-step counters of the conversion</summary>

6,000 upstream rows were read; `S0raw` refused 133 before a row existed and passed 5,867 to the first step. `S0` runs once more, last, on the final bytes. The reason for every refused, dropped or quarantined row is in the files above.

| step | in | out | dropped | quarantined | rejected | repaired |
|---|---:|---:|---:|---:|---:|---:|
| S0raw (refused before conversion) | 6,000 | 5,867 | 0 | 0 | 133 | 0 |
| S11 | 5,867 | 5,865 | 0 | 0 | 2 | 0 |
| S4 | 5,865 | 5,865 | 0 | 0 | 0 | 0 |
| S4c | 5,865 | 5,865 | 0 | 0 | 0 | 0 |
| S5 | 5,865 | 5,829 | 36 | 0 | 0 | 0 |
| S8 | 5,829 | 5,829 | 0 | 0 | 0 | 0 |
| S9 | 5,829 | 5,829 | 0 | 0 | 0 | 0 |
| S0 (final structural check, after S9) | 5,829 | 5,829 | 0 | 0 | 0 | 53 |

</details>

The train/validation split keeps rows sharing a `scene_id` in `meta` on one side, and the assignment is frozen (`splits/` in the summary repository). `scene_id` is the image file name. Nothing links SAT renders of one ProcTHOR house, or photographs of one place, so such images can sit on both sides, and one picture can appear under two file names (examples under Known issues). S12 saw 5,829 rows under 5,829 keys, one row per key, so the split is in effect per row. No validation input image has the content of a training input image. The S12 run did not record whether its pixel-level near-copy test ran for this source, so near-copies are not ruled out.

### Answer-prior balancing (S13)

Each (task, split) group is checked separately. An answer is the answer value compared as lower-cased text without a trailing full stop, with 'farther' read as 'further' and 'nearer' as 'closer' (for multiple choice, the option text, not the letter; where the candidates are drawn in the image, as in zebra_jigsaw and zebra_tetris, the answer is the letter itself). An answer is real when it holds at least 5 rows and 2% of the group; k is the number of real answers. Answer step: the target is max(30%, 1/k) when k >= 2, and max(30%, 1/d) over the d distinct answers when k = 1; a validation group uses the larger of its own target and its task's train target. A group is cut only when k >= 1 and its most common answer holds more than the target plus 5 percentage points; every answer is then capped at one common count, chosen so that none exceeds the target, and smaller answers keep all their rows. At the answer step, a group at or below that trigger, or with no real answer (k = 0), is left as it is, so its most common answer can hold up to the target plus 5 percentage points. A task whose train group has exactly two real answers is instead cut, in every split, so that its two largest answers have equal counts, with no trigger. Rank and label steps: then, in a group where every option value of every row is a number, the rank of the correct option among the sorted values, and after it, in a group where every trained answer is an option label, the label, are each capped by the same cut-and-trigger rule on their own counts (own target, validation included): capped, never evened out, so two labels are cut only when one exceeds 55%, and then only down to 50%. These steps can also cut groups the answer step left whole, including k = 0 groups, and can raise an answer's final share above its target; the run fails if a real answer ends above the target plus 5 percentage points. A train group of at least 20 rows in which one answer holds 90% or more fails the run. PET (exact_cells_pet) instead cuts each (question type x turn direction) cell to equal counts of its two answers; a PET cell that shows only one answer is removed.

| task | split | pass | rule | rows in → out | real answers k | target | largest share, before → after | cut |
|---|---|---|---|---:|---:|---:|---:|---|
| jigsaw_1x2 | train | answer | `cap30[canon]` | 1,086 → 1,086 | 4 | 30.0% | 26.6% → 26.6% | no |
| jigsaw_1x2 | train | letter | `cap30[letter]` | 1,086 → 1,086 | 2 | 50.0% | 51.6% → 51.6% | no |
| jigsaw_1x2 | validation | answer | `cap30[canon]` | 41 → 37 | 4 | 30.0% | 36.6% → 29.7% | yes |
| jigsaw_1x2 | validation | letter | `cap30[letter]` | 37 → 37 | 2 | 50.0% | 51.4% → 51.4% | no |
| jigsaw_1x3 | train | answer | `cap30[canon]` | 1,163 → 1,163 | 6 | 30.0% | 16.9% → 16.9% | no |
| jigsaw_1x3 | train | letter | `cap30[letter]` | 1,163 → 1,163 | 4 | 30.0% | 25.2% → 25.2% | no |
| jigsaw_1x3 | validation | answer | `cap30[canon]` | 30 → 30 | 3 | 33.3% | 26.7% → 26.7% | no |
| jigsaw_1x3 | validation | letter | `cap30[letter]` | 30 → 30 | 4 | 30.0% | 30.0% → 30.0% | no |
| jigsaw_2x1 | train | answer | `cap30[canon]` | 1,098 → 1,098 | 4 | 30.0% | 26.3% → 26.3% | no |
| jigsaw_2x1 | train | letter | `cap30[letter]` | 1,098 → 1,098 | 2 | 50.0% | 51.2% → 51.2% | no |
| jigsaw_2x1 | validation | answer | `cap30[canon]` | 26 → 24 | 3 | 33.3% | 38.5% → 33.3% | yes |
| jigsaw_2x1 | validation | letter | `cap30[letter]` | 24 → 16 | 2 | 50.0% | 66.7% → 50.0% | yes |
| jigsaw_2x2 | train | answer | `cap30[canon]` | 1,159 → 1,159 | 24 | 30.0% | 4.3% → 4.3% | no |
| jigsaw_2x2 | train | letter | `cap30[letter]` | 1,159 → 1,159 | 4 | 30.0% | 25.3% → 25.3% | no |
| jigsaw_2x2 | validation | answer | `cap30[canon]` | 37 → 37 | 0 | 30.0% | 10.8% → 10.8% | no |
| jigsaw_2x2 | validation | letter | `cap30[letter]` | 37 → 31 | 4 | 30.0% | 40.5% → 29.0% | yes |
| jigsaw_3x1 | train | answer | `cap30[canon]` | 1,148 → 1,148 | 6 | 30.0% | 17.0% → 17.0% | no |
| jigsaw_3x1 | train | letter | `cap30[letter]` | 1,148 → 1,148 | 4 | 30.0% | 25.4% → 25.4% | no |
| jigsaw_3x1 | validation | answer | `cap30[canon]` | 41 → 41 | 6 | 30.0% | 22.0% → 22.0% | no |
| jigsaw_3x1 | validation | letter | `cap30[letter]` | 41 → 31 | 4 | 30.0% | 36.6% → 29.0% | yes |

S13 removed 30 rows from this source.

### Text-only baselines

Accuracy of guessers that never see an image. For each task the released training rows are split into two fixed halves by a hash of `row_uid`; each guesser is fitted on one half and scored once on the other (one held-out half, not cross-validation; `eval rows` below). The reference is chance (the mean of 1 / number of options) where every row is multiple choice, and otherwise the eval-half accuracy of always giving the answer most common in the fit half (when a task's top answers are nearly tied, this need not be the task's most common answer; the line after the table gives that answer's validation score). Accuracies are recounted from the stored rates and `eval rows`, so they are exact. A task is flagged when a text-only guesser beats its reference by more than 0.15 (for a free-form task, a guesser other than the most common answer). A flagged task can be partly answered from the text alone; an unflagged task passed only these probes, which do not prove the text carries no answer. Report scores on every task next to this baseline.

Guessers: `keywords`: the most common answer per set of spatial words in the question; `last_mentioned`: the option named last in the question body; `letter_prior`: the most common answer letter; `majority`: the answer most common in the fit half; `option_prior`: the option text that won most often when shown; `template`: the most common answer per question wording (numbers masked, object names kept).

| task | best text-only guesser | accuracy | reference | margin | eval rows | flagged |
|---|---|---:|---:|---:|---:|---|
| jigsaw_1x2 | `option_prior` | 0.495 | 0.500 (chance) | -0.005 | 547 | no |
| jigsaw_1x3 | `letter_prior` | 0.243 | 0.250 (chance) | -0.007 | 575 | no |
| jigsaw_2x1 | `option_prior` | 0.523 | 0.500 (chance) | +0.023 | 549 | no |
| jigsaw_2x2 | `letter_prior` | 0.242 | 0.250 (chance) | -0.008 | 590 | no |
| jigsaw_3x1 | `option_prior` | 0.241 | 0.250 (chance) | -0.009 | 553 | no |

## Spot-check (S14)

**Pending.** The S14 rows are chosen and flagged `S14.sampled_qa` in `meta` and `preview`; the human pass over them has not been signed off yet.

## Citation

Please cite ThinkMorph ([arXiv:2510.27492](https://arxiv.org/abs/2510.27492)), which built the puzzles and their reasoning traces:

```bibtex
@article{gu2025thinkmorph,
  title={ThinkMorph: Emergent Properties in Multimodal Interleaved Chain-of-Thought Reasoning},
  author={Gu, Jiawei and Hao, Yunzhuo and Wang, Huichen Will and Li, Linjie and Shieh, Michael Qizhe and Choi, Yejin and Krishna, Ranjay and Cheng, Yu},
  journal={arXiv preprint arXiv:2510.27492},
  year={2025}
}
```

and the sources of the pictures:

- SAT renders (`source_scene_corpus` = `procthor`): A. Ray et al., "SAT: Dynamic Spatial Aptitude Training for Multimodal Language Models", arXiv:2412.07755; and M. Deitke et al., "ProcTHOR: Large-Scale Embodied AI Using Procedural Generation", NeurIPS 2022.
- ADE20K photographs (`ade20k`), as ADE20K asks: B. Zhou, H. Zhao, X. Puig, S. Fidler, A. Barriuso and A. Torralba, "Scene Parsing through ADE20K Dataset", CVPR 2017; and B. Zhou, H. Zhao, X. Puig, T. Xiao, S. Fidler, A. Barriuso and A. Torralba, "Semantic Understanding of Scenes through the ADE20K Dataset", IJCV (https://groups.csail.mit.edu/vision/datasets/ADE20K/).
- SUN RGB-D photographs (`sunrgbd`): S. Song, S. Lichtenberg and J. Xiao, "SUN RGB-D: A RGB-D Scene Understanding Benchmark Suite", CVPR 2015; and, as the SUN RGB-D page requires of every user (https://rgbd.cs.princeton.edu/), the three datasets it contains: N. Silberman, D. Hoiem, P. Kohli and R. Fergus, "Indoor Segmentation and Support Inference from RGBD Images", ECCV 2012; A. Janoch, S. Karayev, Y. Jia, J. T. Barron, M. Fritz, K. Saenko and T. Darrell, "A Category-Level 3-D Object Dataset: Putting the Kinect to Work", ICCV Workshop on Consumer Depth Cameras for Computer Vision 2011; J. Xiao, A. Owens and A. Torralba, "SUN3D: A Database of Big Spaces Reconstructed using SfM and Object Labels", ICCV 2013.

## Provenance

The release files were written by our conversion code (the code repository is not public yet), `scripts/convert/export.py` at commit `b3fa1b993ca9`, from build `thinkmorph_jigsaw_r3`. The build was made by `scripts/convert/run_source.py` from the same repository at commit `76c78bd817c2`. S10, S12 and S13 ran before the export; `reports/export_manifest.json` pins every input the export read by SHA-1 (`build_manifest_sha1`, `s10_keep_sha1`, `s12_assignments_sha1`, `s13_balanced_keep_sha1`).

Every row removed between upstream and this release has one line, with its reason, in `reports/`: `build/dropped.jsonl` (rows refused before conversion or dropped by a conversion step, S11 benchmark items included); `build/quarantine.jsonl` (rows set aside by S4c because an automatic check could not match the read-back's conclusion to the label); `s10_dropped.jsonl` (duplicates removed by S10); `s10_label_conflicts.jsonl` (rows S10 withheld because another row asks the identical question, options in the same order, of the same images with a different answer); `s13_dropped.jsonl` (rows removed by answer-prior balancing). `known_issues/` lists rows with a measured problem (see Known issues); `reports/` also holds the build manifest (absolute paths cut to basenames) and counters, the S14 sample list (`s14_sample.tsv`: row_uid, task, split) and `export_manifest.json`. In `reports/build/manifest.json`, `spec.source_scene_corpus` (`procthor`) is only the converter's fallback for rows that carry no corpus of their own; it does not describe every row. Each row's corpus is `source_scene_corpus` in `meta` (procthor 3,201, ade20k 1,819, sunrgbd 774). Part of [`yrlyrl/spatial-mmcot`](https://huggingface.co/datasets/yrlyrl/spatial-mmcot).