yrlyrl/spatial-mmcot-zebra_tetris

Spatial MMCoT v1 · zebra_tetris

Zebra-CoT Tetris: polyomino puzzles of three kinds: apply a sequence of transformations to a shape, tile a shape with a set of pieces, and fill the grid outside a shape. The options are drawn in the input image, so the answer is a letter. Each step has its own target image: transformation puzzles start with a redraw of the start shape, then one image per transformation; tiling puzzles start with the isolated shape, fill-the-complement puzzles with the isolated shape and then its complement, and both then add one image per placed piece. All three kinds carry one task name, and no column tells them apart; the question's first words do (Apply the following sequence of transformations, Fill the exact <colour> shape, Fill the entire grid EXCEPT). The task table, the S13 balancing and the text-only baselines below pool the three kinds. The thoughts are upstream's text and were not checked against the images (see Known issues). Released rows carry 3 to 7 target images. The thoughts keep upstream's numbered labels ('THOUGHT 0:', 'THOUGHT 1:', ...) inside <think>. They count upstream's thoughts across the whole trace, not the row's slots, so one slot often holds two or more labelled thoughts, and a slot after a target image can open with the unlabelled end of the previous thought. No other source in this release has these labels; if you mix sources and do not want a model to learn them, remove them with re.sub(r'THOUGHT \d+:\s*', '', text). Refused by the conversion's checks: 1 row whose read-back is empty (S0.empty_readback).

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. The text is upstream's and was not checked against the images.

Upstream: multimodal-reasoning-lab/Zebra-CoT. Licence: cc-by-nc-4.0. Changes from upstream: every image is decoded and re-encoded as JPEG, inputs at a 512 px long edge and targets at the size in meta.target_px (upstream's own size, at most 512 px; smaller on rows flagged S9.px=*); the image placeholders in the question and the reasoning were removed and the sentence around each repaired, sometimes by inserting words such as 'the image'; the reasoning is split into one thought per target; the ThinkMorph system prompt is prepended to the question; rows were filtered and balanced as described below.

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
plan_names_answer_before_pieces	4,988	4,827	161	Tiling / fill-the-complement puzzle: the plan names the correct option before any of its pieces is drawn and no other option is tried; the piece images only confirm a choice already made in text.	question starts 'Fill the exact' (tiling; first piece is target_1) or 'Fill the entire grid EXCEPT' (complement; first piece is target_2), and after removing enumerations the thoughts up to that piece's plan name 'option/set/choice <answer>'; measured 2026-09-25; known_issues.py sha1 655e5307; export 4aaee1f rows 30d352ab/67287f6f	reports/known_issues/plan_names_answer_before_pieces.tsv
translation_clips_cells	2,242	2,159	83	Transformation puzzle: a translation step pushes part of the shape off the grid and upstream drops those cells, so the target after it shows fewer cells than the image before it while the thought describes a plain move.	question starts 'Apply the following sequence'; target_0 is the start shape and target_j the result of transformation j; for a 'translate' step, target_j has fewer coloured cells than target_j-1 (HSV S>90, V>70, cell-sized 4-connected components; the same count is unchanged on 3,883 of 3,884 rotations and 2,452 of 2,453 mirrors on r2); measured 2026-09-25; known_issues.py sha1 655e5307; export 4aaee1f rows 30d352ab/67287f6f	reports/known_issues/translation_clips_cells.tsv
shape_cell_count_contradicts_image	1,089	1,052	37	Tiling puzzle: the thought right after the isolated-shape image states a cell count for the shape that the image contradicts (almost always too few), so the row teaches a wrong read of an image the model has just drawn.	question starts 'Fill the exact'; the first 'consists of / occupies / has ... N cells|squares' in thought_1 differs from the coloured cells counted in target_0 (HSV S>90, V>70, cell-sized 4-connected components); measured 2026-09-25; known_issues.py sha1 655e5307; export 4aaee1f rows 30d352ab/67287f6f	reports/known_issues/shape_cell_count_contradicts_image.tsv
readback_names_no_option	951	914	37	The final thought never says which option matches (it only announces a comparison); the choice is only in <answer>.	after removing enumerations ('options A, B, C and D', 'A-D'), the read-back names no option: no 'option/choice/set/piece/answer X', no 'is X.', no quoted '(X)'/'X', no 'the second option'; measured 2026-09-25; known_issues.py sha1 655e5307; export 4aaee1f rows 30d352ab/67287f6f	reports/known_issues/readback_names_no_option.tsv
target_repeats_previous_target	541	531	10	Transformation puzzle: a target is byte-identical to the image before it while the plan says the shape moves (upstream does not apply a translation that would push the shape off the grid, and mirrors a symmetric shape onto itself).	md5 of target j equals md5 of target j-1; measured 2026-09-25; known_issues.py sha1 655e5307; export 4aaee1f rows 30d352ab/67287f6f	reports/known_issues/target_repeats_previous_target.tsv
validation_target_identical_to_train	34	0	34	A target of this validation row is byte-identical to a training target (for some rows the puzzle's end state), so part of what the row asks the model to draw was seen in training.	md5 of a validation target equals the md5 of some training target; measured 2026-09-25; known_issues.py sha1 655e5307; export 4aaee1f rows 30d352ab/67287f6f	reports/known_issues/validation_target_identical_to_train.tsv
text_says_options_not_shown	27	26	1	The upstream text says the options are not shown or cites a trace, template or answer the model never sees ('options (not shown, but implied by the original trace)'), although every input image draws options A-D; training on it teaches the model to deny visible options.	the question or any thought matches 'not shown|not provided|original trace|in the trace|implied by|template indicates|options are not|inferred from the answer' (the review's pattern); measured 2026-09-25; known_issues.py sha1 655e5307; export 4aaee1f rows 30d352ab/67287f6f	reports/known_issues/text_says_options_not_shown.tsv

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

import glob, os
root = "<root>/zebra_tetris"
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

Measured caveats

Measured on this release by the pre-publication review (2026-09-25): problems that cannot be listed row by row (a shortcut in the options, a label convention, an upstream labelling scheme) and what the review found around the lists above. Where a caveat counts listed rows ("listed as ..."), the count is the table's, read from reports/known_issues/summary.json. Its other numbers are the review's own measurements, which no file carries: they hold for exactly these rows and are not re-measured automatically. Items marked Training-signal defect are problems in what the rows teach, not only in how they are described; no row was removed for them.

• Training-signal defect. In the tiling and fill-the-complement puzzles (4,994 rows, half the source) the plan names the correct option before any of its pieces is drawn, and only that option's pieces are placed: 4,988 rows (4,827 train, 161 validation; listed as plan_names_answer_before_pieces), 99.9% of those puzzles, name the labelled option at or before the plan of the first piece image (e.g. 6b42e76ba4799ec1: 'Option A contains three pieces. Let's test if these pieces can tile the red shape.'). The piece images confirm a choice the text has already made: use these rows as image supervision, not as evidence that generating the image helps. In the 4,999 transformation puzzles no option is named until the read-back after the last image.
• Training-signal defect. In tiling puzzles the thought after the isolated-shape image often states a cell count for the shape that the image contradicts, nearly always too low: at least 1,089 rows (1,052 train, 37 validation; listed as shape_cell_count_contradicts_image) (the list reads only 'consists of / occupies / has N cells' wordings), 43.7% of the 2,494 tiling rows and 10.9% of the source (e.g. 6b42e76ba4799ec1 says 'It occupies 14 cells' of a 25-cell shape). The piece sizes and totals quoted in the same thoughts are unreliable in the same way (2949258c0e73136b says '3, 3, and 3 cells, totaling 9'). These rows teach a wrong reading of the image the model has just drawn.
• Training-signal defect. Upstream's generator does not keep the shape whole at the grid edge: a translation drops the cells it would move off the grid (2,242 rows (2,159 train, 83 validation; listed as translation_clips_cells) have at least one such step, listed as translation_clips_cells with the clipped steps per row), and one that would move every cell off is not applied. With mirrors and rotations of symmetric shapes, this leaves 669 target images in 541 rows (531 train, 10 validation; listed as target_repeats_previous_target) identical to the image before them, although the thought before each describes a move (e.g. fdea4b3b7b909da9); the loss on those targets can be met by copying the previous image.
• 951 rows (914 train, 37 validation; listed as readback_names_no_option), nearly all of them transformation puzzles (about one in five of that kind), end with a final thought that only says the final shape will be compared with the options and never says which option matches; the choice is then only in <answer>.
• The three puzzle kinds: transformation 4,999 rows (4,832 train, 167 validation), tiling 2,494 (2,411 / 83), fill-the-complement 2,500 (2,422 / 78).
• The 69 validation target slots with the content of a training target (see the split paragraph) hold 64 distinct images in the 34 of the 328 validation rows listed as validation_target_identical_to_train; they are shapes other puzzles also reach: 15 are the redraw of the start shape, 39 an intermediate step and 15 the final result.

Size

split	rows	target image slots	distinct target images
train	9,665	47,178	45,234
validation	328	1,581	1,565

A slot is one target position in one row. Different puzzles pass through the same shapes, and a transformation that changes nothing visible (a mirror of a symmetric shape, a translation at the grid edge) repeats the previous image, so there are fewer distinct target images (by content hash) than slots.

task	train	validation
tetris_transform	9,665	328

Input images per row: 1. Target images per row (the images the model is trained to generate): 3 to 7. Image corpus (source_scene_corpus): procedural_grid 9,993. procedural_grid is this pipeline's label for any procedurally generated synthetic image (2D grid puzzles and simple 3D renders of primitive objects alike); the source note above says what the images show.

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 3 to 7. 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; the options A-D are drawn in the input image, there is no option text
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`

Every image is a JPEG, and no input image is larger than 512 px on its long edge (measured on this release, 2026-09-25); the size each target was stored at is target_px in meta.

<answer> holds exactly meta.answer_value (also the answer column of preview) on every row: score model output against that string.

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, both empty for K <= j < 7; and the read-back in thought_7 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: cc-by-nc-4.0 9,993.

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

flag	rows	meaning
S5.replay_unsupported	9,993	no solver re-derives this task's answer from the trace, so S5 did not replay it
S14.sampled_qa	200	chosen for the S14 human spot-check (reports/s14_sample.tsv)
S9.px=384	112	targets stored at this long-edge size (px) because the row was over the token budget at full size; the trainer's VAE transform (short edge at least 512) scales them back up, so these targets are trained as upsampled, softer images
S9.px=448	9	targets stored at this long-edge size (px) because the row was over the token budget at full size; the trainer's VAE transform (short edge at least 512) scales them back up, so these targets are trained as upsampled, softer images

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 zebra_tetris/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:

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

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

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

The Hugging Face cache (.../snapshots/<hash>/train/) or a folder named spatial-mmcot-zebra_tetris 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 2 training chunk files holding 76 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 2 and alone in its group on 8 GPUs with 4 workers, it reads only 64 of the 76 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 (256 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	10,000
refused before conversion (S0raw)	0
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)	5
refused by the final structural check (S0, after S9)	1
after conversion and per-row filters	9,994
removed by S10 (1 exact duplicate)	1
removed by answer-prior balancing (S13)	0
released	9,993

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	S0	S0.empty_readback	1
build/dropped.jsonl	S5	S5.self_contradiction	5
s10_dropped.jsonl	S10	level: exact	1

Per-step counters of the conversion

10,000 upstream rows were read; S0raw refused 0 before a row existed and passed 10,000 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
S4	10,000	10,000	0	0	0	0
S4c	10,000	10,000	0	0	0	0
S5	10,000	9,995	5	0	0	0
S8	9,995	9,995	0	0	0	0
S9	9,995	9,995	0	0	0	0
S0 (final structural check, after S9)	9,995	9,994	1	0	0	0

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 md5 of the raw puzzle image, so a key is one puzzle. S12 saw 9,993 rows under 9,993 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, and none is a pixel-level near-copy of one. S12 does not record per source whether that test ran, but it skips it only for a source whose spec sets split_leak_pixels: false, and no spec does; over all sources it compared 21,661 candidate pairs (perceptual hash within 6 bits) pixel by pixel and found no near-copy (checked 2026-09-25). Target images are not covered by that check: 69 target-image slots in validation rows hold an image with the same content as a training target image (S12 compares a 64x64 greyscale hash and counts slots, so an image repeated in validation counts each time). These are states that other puzzles also reach, as a step or as their final state.

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
tetris_transform	train	answer	cap30[canon]	9,665 → 9,665	4	30.0%	25.9% → 25.9%	no
tetris_transform	train	letter	cap30[letter]	9,665 → 9,665	4	30.0%	25.9% → 25.9%	no
tetris_transform	validation	answer	cap30[canon]	328 → 328	4	30.0%	26.2% → 26.2%	no
tetris_transform	validation	letter	cap30[letter]	328 → 328	4	30.0%	26.2% → 26.2%	no

S13 removed no row 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
tetris_transform	keywords	0.259	0.250 (chance)	+0.009	4,846	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

Zebra-CoT is by Ang Li, Charles Wang, Deqing Fu, Kaiyu Yue, Zikui Cai, Wang Bill Zhu, Ollie Liu, Peng Guo, Willie Neiswanger, Furong Huang, Tom Goldstein and Micah Goldblum, released under CC BY-NC 4.0; this repository is a converted subset of it (the changes are listed under the licence line above). Its card asks users to cite:

@inproceedings{li2026zebracot,
  title={Zebra-CoT: A Dataset for Interleaved Vision-Language Reasoning},
  author={Ang Li and Charles Wang and Deqing Fu and Kaiyu Yue and Zikui Cai and Wang Bill Zhu and Ollie Liu and Peng Guo and Willie Neiswanger and Furong Huang and Tom Goldstein and Micah Goldblum},
  booktitle={The Fourteenth International Conference on Learning Representations},
  year={2026},
  url={https://openreview.net/forum?id=c6XIVI3TiQ}
}

Provenance

The release files were written by our conversion code (the code repository is not public yet), scripts/convert/export.py at commit 4aaee1f4e946, from build zebra_tetris_r2. The build was made by scripts/convert/run_source.py from the same repository at commit 949af62f8ab7. 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); 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. Part of yrlyrl/spatial-mmcot.