tokoroten-jp/generated-tsume-shogi

Generated Tsume-Shogi

33,304,434 machine-generated tsume-shogi (Japanese chess mate problem) diagrams with mates of 1 to 15 plies, each judged by the project's own solver against strict composition rules. Terms in bold are defined in the Glossary right below the Japanese summary. The solver searches exhaustively within a fixed number of search nodes, so each verdict is either proven or left explicitly unknown (null); the forced mate itself is proven on every row. This is dataset release v4 (the dataset's own version number; the software, the rules and the web game have separate version numbers, see Glossary, Version numbers). It publishes every row of the catalogue (the project's database of the judged diagrams it keeps): the sound problems, which satisfy every rule A–G (see Rules A–G), and every kept diagram that breaks a rule. New in v4 is a third config of diagrams distilled from the game records of floodgate, a public server where shogi engines play each other.

• Config default: 8,829,856 sound problems. 6,568,536 are representatives (one row per main line; for 1 ply, every position) and 2,261,320 are variants (other valid problems; almost all share the main line of a representative, and a few are near-repeats of other retrograde extensions). Every row of default is proven minimal under rule D: no removal step (one piece, plus any piece that then becomes inert) leaves a sound problem with the same main line and no new route (see Minimality). A piece may still be removable if the result has a different main line.
• Config unsound: 21,338,874 flawed diagrams, each with the rules it breaks. 9,935,221 have an alternative solution (yozume, label = yozume); the other 11,403,653 have another defect (label = defect): pieces left in the attacker's hand at the end (koma-amari), an inert piece, or a rule-D removal step (not minimal).
• Config floodgate: 3,135,704 diagrams distilled from floodgate game records (2008–2025), sound and flawed together: 664,217 sound problems (label = sound) and 2,471,487 flawed diagrams (1,155,040 yozume, 1,316,447 defect). They are kept apart from default and unsound because they come from a different third-party source; class and label mean exactly what they mean in the other configs (see Source attribution). Tsume.Quest does not serve them as puzzles.

Every row of every config has a proven forced mate of exactly mate_ply plies; diagrams with no such mate within 15 plies are not in the catalogue.

Every row comes with its main line (column main_line), per-rule flags, the solver's search size in search nodes where it was recorded (solver_nodes), tesuji features of the main line (the columns of Tesuji features), and its provenance (where it came from).

The diagrams were made by three generation algorithms: distillation of positions from the YaneuraOu collection (and, for the floodgate config, of near-final positions of floodgate games), followed by retrograde extension; generative transformer models fine-tuned by reinforcement learning with the solver as the judge (almost all of them MaskGIT models, plus two runs of an earlier autoregressive model); and random search. Two further kinds of row were derived from those: reduced diagrams (pieces removed by the reducer) and v2's repairs. Every row, whatever its origin, went through the same solver checks.

This is the puzzle catalogue behind Tsume.Quest, a tsume-shogi web game by the same author, released for research. No human-composed problem was used as input.

日本語の要約: 計算機で生成し、自作のソルバで厳密に判定した詰将棋の図 33,304,434 件（1〜15 手詰）。v4 では、コンピュータ将棋対局場 floodgate の棋譜（2008〜2025 年）の終盤の局面から蒸留した図 3,135,704 件（完全作 664,217・不完全作 2,471,487）を、別の config floodgate として加えた（default と unsound には入れない。学習などには使えるが、Tsume.Quest では出題しない）。ソルバは探索ノード数の上限の中で網羅的に探索するので、判定は証明済みか「不明」（null）のどちらかになる。詰みそのものはどの行も証明済み。これはデータセットの版 v4（ソフトウェア・規約・ゲームの版番号とは別）で、カタログ（判定して残した図のデータベース。生成・判定したすべての図ではない）の全行を公開する。config default は規約 A〜G をすべて満たす完全作 8,829,856 問（代表 6,568,536＝主線ごとに 1 行、1 手詰は局面ごと、類題 2,261,320。類題のほとんどは代表と同じ主線を持つ）で、default のどの行も規約 D の意味で極小（駒を 1 枚外し、それで無駄駒になる駒も一緒に外して、同じ主線で主線の領域に新しい手順の無い完全作が残ることはない。主線が変わる完全作なら残ることはある）であることを、探索の予算切れが 1 つも無い状態で証明した。config unsound は規約を破る図 21,338,874 件で、余詰 9,935,221 件（label = yozume）と、それ以外の欠陥 11,403,653 件（駒余り・無駄駒・規約 D で外せる駒。label = defect）。どの行も mate_ply 手ちょうどの詰みが証明済みで、15 手以内に詰まない図はカタログに入れていない。どの行にも主線、規約ごとの判定の列、主線の手筋の特徴（捨て駒・焦点・不成・遠打・中合など）、由来が付き、記録のある行には探索ノード数が付く。作り方は 3 つ（やねうら王の詰み局面集からの蒸留と逆算による延長、ソルバを判定役とする強化学習で伸ばした生成モデル（ほとんどがマスク予測の MaskGIT、ほかに初期の自己回帰モデルの 2 run）、ランダム探索）で、ほかにそれらから駒を外した縮約図と、v2 の修理図がある。正例と負例は別の config で、3 つの config はどれも同じ 88 列なので、つなげるとカタログ全体になる。問題だけが欲しい人は default だけを読めばよい（floodgate 由来の完全作も要るなら floodgate の label = sound）。行ごとの判定は、その行を判定したパイプラインの版（pipeline_version、0.13.0〜0.16.0）の規約による。人間の創作詰将棋は入力に使っていない。CC BY 4.0。

Glossary

Japanese terms are given in parentheses.

Notation

• Sente / gote (先手 / 後手): the first and the second player of shogi. In this dataset the attacker is always sente.
• SFEN: the standard one-line text format for a shogi position (board, side to move, pieces in hand, move number); upper-case letters are sente's pieces, lower-case gote's, + marks a promoted piece. See the sfen column for the conventions used here.
• USI: the standard text protocol for shogi engines; this card uses its move notation and square names. A square is a file 1–9 (numbered right to left as seen by sente) followed by a rank a–i (from gote's side to sente's), e.g. 7c; moves are written as in the main_line column. Piece letters: P pawn, L lance, N knight, S silver, G gold, B bishop, R rook, K king.

Problems and solutions

• Tsume-shogi (詰将棋): a shogi mate problem. The attacker (攻方, sente, upper case in SFEN) must give check on every move; the defender (玉方, gote, lower case) has a king and replies so as to last as long as possible.

• Nokori-goma zenbu (残り駒全部, "all remaining pieces"): every piece that is neither on the board nor in the attacker's hand is in the defender's hand. Every sfen in this dataset writes that hand out.

• Ply (手): one move of either side. mate_ply counts both sides' moves, so it is always odd (a mate in 3 plies is check, reply, mate).

• Correct move (正解手): at an attacker turn, a check that keeps a forced mate of the shortest possible length from that position. A check that mates only more slowly is not correct.

• Main-line region R: every position reached from the start by every correct move of the attacker and by every main-line reply of the defender. At a defender turn, the main-line replies are chosen in two steps:

  1. Take the longest replies: those after which the forced mate takes the most plies. Futile interpositions are not replies here.
  2. Call a longest reply amari when, after it, the attacker can force a shortest mate that ends with pieces still in hand. If at least one longest reply is not amari, the main-line replies are the longest replies that are not amari; the amari ones (変同駒余り, "an equally long variation with pieces left over") are variations. If every longest reply is amari, all of them are main-line replies.

  Defender replies outside R lead to variations (変化).

• Main line (主線, main_line): one path through R, chosen by a fixed rule: at each position prefer the moves after which the attacker can still finish with an empty hand, then take the one with the smallest USI string. The rules are judged on the whole of R, so no verdict depends on which path is shown. In unsound it is the same walk on the flawed diagram.

• Yozume (余詰, also called a dual or cook): an alternative solution: two or more correct moves at the first move (even in a mate in 1), or at any later attacker turn in R other than the final move. It makes a problem unsound.

• Final-move alternatives (最終手余詰): several mating moves at the last attacker turn of a mate of 3 plies or more. They are allowed and are not yozume.

• Interposition (合駒): the defender blocks a check from a distant rook, bishop or lance by putting a piece between the checker and the king. Chuai (中合) is an interposition not next to the king.

• Futile interposition (無駄合): an interposition dropped from the hand that does not delay the mate: the checker captures it and mates as quickly as if it had not been played. Under the classical convention used here it is not a defence: it is not counted in the mate length, and a check whose only answers are futile interpositions is already mate.

• Koma-amari (駒余り): the attacker still has pieces in hand when the mate is delivered. Rule C forbids it against every main-line defence; on a row that breaks rule C, the main line is the path that ends with pieces in hand.

• Inert piece (無駄駒): a board piece other than a king that takes no part in the solution. Here the solution is every position reached from the start by correct attacker moves and by any defender reply that is not a futile interposition (variations included), and the king zone is the defender king's square and the 8 squares next to it. A piece takes part when at least one of these holds in some position of the solution:

  • (either side) it moves, captures or is captured;
  • (attacker piece) it attacks a square of the king zone;
  • (defender piece) it stands on a square next to the king, or attacks a square of the king zone;
  • (either side) it stands between an attacker's rook, bishop or lance (promoted or not) and a square of the king zone, so that removing it would extend that piece's reach into the zone;
  • (defender piece) it moves or captures in one of the defender's answers that refute a wrong check (a check that is not a correct move); (attacker piece) it is captured in such an answer. Since pipeline 0.16.0 every refuting answer counts (a reply refutes the wrong check when the attacker can no longer mate within the remaining plies after it); through 0.15.0 only the one reply the solver recorded for each wrong check counted (the first refuting reply in USI order), which made the verdict depend on the board's orientation in rare cases;
  • (either side, since pipeline 0.15.0) it keeps out, by standing where it stands, a check that would otherwise also mate in time: with the piece taken off (and given to the defender, as in rule D), some check that is illegal with the piece on its square (a drop on that square, a move through or onto it, or a second pawn on its file) would mate no slower than the solution, i.e. it would be a yozume (a yozume-preventing piece, 余詰防ぎの駒).

  Since pipeline 0.16.0 the solution tree read by this rule is the one of the proven mate length, whatever bound the solver searched, so the verdict is the same at every search bound and for a diagram and its mirror image.

• Minimal: no removal step (one piece, plus any piece that becomes inert because of it) leaves a sound problem whose solution is one of the original's main-line paths and whose main-line region has no new route (rule D, see Minimality).

• Main-line paths (n_main_paths): the main-line region R can hold several paths from the start to a mate (for example when the final move has alternatives, or the defender has several longest replies). main_line shows one of them; n_main_paths counts them.

• Sound / unsound (完全作 / 不完全作): a sound problem satisfies every composition rule A–G below; an unsound one breaks at least one. In the columns: class = positive / negative.

How the rows were judged

• Solver: the project's own tsume solver. It searches the AND/OR tree of checks and replies exhaustively up to a ply bound. It is written twice, in TypeScript and in Rust, and the project's tests require the two to agree exactly: on fixed and seeded random test positions (a few hundred per test run, re-run with every change of the software), the legal move lists, the verdicts, the node counts, the search graphs and the reducer's outputs must be identical. The comparison covers single-threaded searches only. The rows themselves were judged by the Rust solver, partly with multi-threaded searches (see solve_version) whose node counts can differ from a single-threaded run, while their verdicts are designed not to; the generation steps (distillation, extension, random search) also exist only in Rust, and their outputs are judged by the gate.
• Node budget: the maximum number of search nodes one search may create (never a time limit, so results are reproducible). A search that hits it ends with a budget-out: no answer either way.
• Gate: the solver step that judges one diagram: it proves the mate of exactly mate_ply plies, checks rules A, B, C and G on the proof (read under rule F), records the main line, and lists the failed rules as rejection_reasons.
• df-pn / prober: depth-first proof-number search, a standard mate-search algorithm. Since 2026-10-09 the gate first proves the mate with a df-pn search (the prober) and then builds only the part of the proof the rules need; before that, and when the prober runs out of budget, it runs a full-width search, which expands every legal check and reply up to the ply bound. The two count search nodes very differently (solver_nodes_kind).
• Reducer: the solver step that tries to remove pieces. It tries every candidate removal (each board piece, and each piece of the attacker's hand; a removed piece goes to the defender's hand) in 8 seeded random orders (attempts), keeping each removal step that its test accepts and repeating until nothing more comes off. For rule D the test is a sound problem with the same main line and no new route (see Minimality), and the output is the best attempt (fewest board pieces, then fewest attacker-hand pieces, then a fixed order). A second mode accepts any sound problem of the same length and emits up to 2 further diagrams whose main lines differ from the source's (see reduction_kind). A reduced diagram is one the reducer produced from another diagram.

Version numbers (four separate numberings)

• Dataset version (v1 … v4): a release of this Hugging Face dataset, loadable with revision="v1" etc. This card describes v4.
• Pipeline version (0.x.y; 0.9.1, 0.12.0 and 0.13.0 are those of dataset versions v1, v2 and v3; v4 was exported with pipeline 0.16.0 current): the version of the project's generation-and-judging software. It appears inside solve_version and minimality_check_version, and since v4 in its own column pipeline_version (the version whose rules gave the row's verdict).
• Rules version (column rules_version): a name for the composition rules of a pipeline version. Up to v3 one value covered the whole export; in v4 rows were judged by several pipeline versions, so rules_version is per row: strict-tsume-v3 (pipeline 0.13.0), strict-tsume-v4 (0.14.0: rule D on the main-line paths), strict-tsume-v5 (0.15.0: rule G clause for yozume-preventing pieces), strict-tsume-v6 (0.16.0: rule G reads every refuting reply, on the tree of the proven length). See What changed in v4.
• Tsume.Quest releases (1 to 6 so far; release 2 was never published): numbered releases of the web game's own puzzle set, unrelated to the dataset versions. A problem is dealt in a release when the game serves it as a puzzle there (columns first_dealt_version, last_dealt_version).

Groups of rows

• Representative / variant (代表 / 類題): rows of one config that share mate_ply and main_line form a group (for 1 ply, each position is its own group, since a one-move main line says little). One row of each group is the representative; the others are same_main_line variants. Apart from the groups, a few retrograde extensions are set aside as variants so that one parent or one original position does not dominate (extension_sibling, extension_cap); they belong to no group and have no representative. A variant is a different diagram, not a copy: in default a valid problem, in unsound a flawed diagram like its representative (see Configs).
• Catalogue: the project's internal database of the diagrams it has judged and kept. It keeps a diagram only when the solver proved a forced mate of at most 15 plies, and it deleted the otherwise sound rows whose minimality could not be settled (see Minimality). This dataset is a complete export of the catalogue as it stood at export time: every row the catalogue kept. It is not an export of every diagram the generators produced or the solver judged: candidates that were never stored (for example, those with no proven mate) and rows deleted earlier are not in it.

Where the diagrams come from

• YaneuraOu collection (やねうら王 実戦詰み局面集, 2020): about 5 million positions from self-play games of YaneuraOu, an open-source shogi engine, in which a forced mate of 3, 5, 7, 9 or 11 plies was found (files mate3.sfen … mate11.sfen). See Source attribution.
• floodgate (https://wdoor.c.u-tokyo.ac.jp/shogi/): a public online server where computer shogi programs play rated games around the clock. Its yearly game-record archives (wdoor<year>.7z, CSA format) are published on that page. See Source attribution.
• Distillation: pieces are removed from a source position while a forced mate of the required length survives, and the result is put through the gate.
• Pre-strip: an optional first stage of distillation. Each board piece other than the kings is tried once, in order of decreasing Chebyshev distance from the defender's king (the larger of the file and rank differences), ties by square; in runs since 2026-10-02 all attacker pieces come before all defender pieces. A tried piece goes to the defender's hand, and the removal is kept when the position is still legal, the defender is not in check, and a forced mate of the same length still exists (uniqueness and rules A–G are not checked at this stage; the gate checks them afterwards). The order is fixed from the starting position, there is one pass, and it also stops when its node budget is spent.
• Retrograde extension (逆算): every position from which one attacker check and one defender reply lead into an accepted problem is enumerated and put through the gate, which gives problems two plies longer.
• Random search (method = mine): random positions are searched for a forced mate. The sampler draws a position as follows: the defender's king on one of the 81 squares, uniformly; a board total of 20 to 30 pieces including the king, uniformly; the other board pieces drawn one at a time, without replacement, from the 38 non-king pieces of a shogi set (so pawns are the most frequent), each given to either side with probability 1/2, promoted with probability 0.14 if its kind can promote, and put on an empty square chosen uniformly among those where it is legal (no piece that could never move again, no second unpromoted pawn of one side on a file); no attacker king; 0 to 3 pieces in the attacker's hand (the number uniform, the pieces drawn from those left); every remaining piece in the defender's hand. A draw that fails the legality check or leaves the defender in check is drawn again. A df-pn search then looks for a forced mate of at most 7 plies, every mate found is distilled (with a pre-strip) and put through the gate, and diagrams found more than once are kept once (by id). This sampler made all method = mine rows except 1,409 in default and 343 in unsound, which come from smaller, earlier mining experiments.
• MaskGIT model: a masked generative model in the style of MaskGIT: a bidirectional transformer that writes a diagram as 88 tokens (81 squares and the counts of the attacker's hand) by filling masked tokens over a few rounds, conditioned on the requested mate length. Models were pre-trained on the catalogue and then fine-tuned by reinforcement learning (RL) whose reward comes from the gate. A diagram sampled from scratch starts from a fully masked board, so it has no source diagram.
• Autoregressive model: an earlier generator, a decoder-only transformer that writes the same 88 tokens one at a time, also fine-tuned by RL with the gate as the judge. Only the runs rl-long12 and rl-long13 of it produced rows here; both received a YaneuraOu position as input (see Source attribution).
• Model run and run names: a model run is one training or sampling run, named in run_name and in the model-sampled:<run> entry of origins. In MaskGIT run names, m<N> is the model generation (m7, m8, … m15), and rl<N> after it numbers the RL runs started from that generation (maskgit-m7rl18… is the 18th RL run from m7). The m7 series means the maskgit-m7rl… runs; the input-board runs of the m9 series (maskgit-var-m9-…) took an existing catalogue diagram, masked part of it and let the model fill it in again. In rl-long12 and rl-long13 the numbers are run labels only, not mate lengths. Other parts of run names, and of the tool names of model runs in lineage (such as sft, rl-c, m15r, l0), are internal labels of the model or run.
• Repair (v2): a diagram that gained yozume when v2 adopted the classical convention for futile interpositions, with pieces removed until the solution was unique again.

Features

• Tesuji (手筋): characteristic tactical moves of tsume-shogi, such as sacrifices and non-promotions. The tesuji columns count them on the main line (see Tesuji features).

How to load: three configs

Config	Holds	class	label	Rows
default	Only the sound problems (positives), floodgate rows excluded	positive	sound	8,829,856
unsound	Only the negatives (diagrams that break a rule), floodgate rows excluded	negative	yozume or defect	21,338,874
floodgate	Every row derived from floodgate game records, sound and flawed	positive or negative	sound, yozume or defect	3,135,704

• All three configs have the same 88 columns, so concatenating them gives the full catalogue (33,304,434 rows). id is unique across all of them.
• If you only want problems, download only default. Loading one config never downloads the others (1.76 GB, 2.68 GB and 0.45 GB of Parquet).
• A row is in floodgate when any entry of its origins starts with floodgate-wdoor, whatever its class; otherwise it is in default (sound) or unsound (flawed). So default + unsound is the catalogue without floodgate, as in v3.

from datasets import load_dataset, concatenate_datasets

# Sound problems only (positives)
ds = load_dataset("tokoroten-jp/generated-tsume-shogi", "default", revision="v4")

# Negatives only, with the rules they break
bad = load_dataset("tokoroten-jp/generated-tsume-shogi", "unsound", revision="v4")

# Diagrams from floodgate game records (both classes); the sound ones:
fg = load_dataset("tokoroten-jp/generated-tsume-shogi", "floodgate", revision="v4")
fg_sound = fg["train"].filter(lambda r: r["label"] == "sound")
yozume = bad["train"].filter(lambda r: r["label"] == "yozume")   # alternative solutions (余詰)
defect = bad["train"].filter(lambda r: r["label"] == "defect")   # koma-amari, inert piece, removable piece
# Rows that break rule C. Defects overlap: these rows may break other rules too.
amari = bad["train"].filter(lambda r: r["has_koma_amari"] is True)
# Rows that break rule C and were checked and found clean on rules B, D and G (null = not checked):
only_c = amari.filter(lambda r: r["has_dual"] is False and r["is_reducible"] is False
                      and r["has_inert_piece"] is False)

# The full catalogue: same columns, so the splits concatenate directly
full_train = concatenate_datasets([ds["train"], bad["train"], fg["train"]])
# Every sound problem, floodgate included:
all_sound_train = concatenate_datasets([ds["train"], fg_sound])

# Count each group once (benchmarks, statistics; groups and the rows outside them are
# defined in *Configs*). Representatives are chosen per
# config over all three splits, so a main line's representative can be in `validation`
# or `test` while its variants are in `train`. Over a whole config:
splits = ("train", "validation", "test")
reps = concatenate_datasets([ds[s] for s in splits]).filter(lambda r: r["is_representative"])
# (extension_sibling and extension_cap rows belong to no group and are not counted by `reps`)
# Within one split, keep the first row of each (mate_ply, main_line) instead (a 1-ply row counts on its own):
seen = set()   # create it anew before each such filter
def first_of_group(r):
    key = r["id"] if r["mate_ply"] == 1 else (r["mate_ply"], r["main_line"])
    if key in seen:
        return False
    seen.add(key)
    return True
train_once = ds["train"].filter(first_of_group, load_from_cache_file=False)   # single process only

# Rows judged under the current rules (pipeline 0.16.0) only:
current = ds["train"].filter(lambda r: r["pipeline_version"] == "0.16.0")

# Up to 11 plies, the range of v1 and v2:
short = ds["train"].filter(lambda r: r["mate_ply"] <= 11)

# Rows no generative model contributed to (see "Note on circularity" below):
def model_free(r):
    return (r["method"] != "model_sampled" and r["training_corpus"] is None
            and not any(o.startswith("model-sampled:") for o in (r["origins"] or [])))
no_model = ds["train"].filter(model_free)

The data is 4.89 GB of Parquet in 73 files. To read only some columns, load the Parquet files directly (for example with pyarrow or duckdb).

Rules A–G (what "sound" means)

A sound problem (default) is a tsume-shogi diagram, under the nokori-goma zenbu convention, that satisfies every rule below. An unsound row breaks at least one of them; the right-hand column says where to see which. Every rule is judged on the proof the gate built; rule F decides how mate lengths are counted before the others are judged.

Rule	Requirement	Column when broken
A	No attacker king on the board	has_attacker_king (no row of either config has one)
B	No yozume: exactly one correct first move, and one correct move at every other attacker turn of R except the final move	has_dual (dual_kind)
C	No koma-amari: against every main-line defence the attacker can finish with an empty hand	has_koma_amari (koma_amari_detail)
D	Minimal (see Minimality; since pipeline 0.14.0 judged on the main-line paths, not on the displayed main_line alone)	is_reducible (removable_pieces)
E	A setting of the generators, not a check: they place no attacker king (rule A is what is checked)	—
F	Futile interpositions are not defences and are not counted in the length (classical convention). A convention for reading the solution, so no diagram can break it	— (futile_interposition_judged, always false, see Other columns)
G	No inert piece (clause for yozume-preventing pieces since pipeline 0.15.0; every refuting reply counts since 0.16.0; see Glossary, Inert piece)	has_inert_piece (inert_pieces)

label of a flawed row (in unsound and floodgate) is yozume when has_dual is true and defect otherwise, which means rule C, D or G fails.

Which rules a row was judged by. The rules changed three times since v3 (pipeline 0.14.0 to 0.16.0, see What changed in v4). A row's verdict is the one of the gate run named in judged_by, whose pipeline version is in pipeline_version; not every row was judged again under 0.16.0. Rows by pipeline version:

pipeline_version	rules_version	default	unsound	floodgate sound	floodgate flawed
0.11.0	null	0	5	0	0
0.13.0	strict-tsume-v3	8,620,576	21,179,215	0	0
0.14.0	strict-tsume-v4	5	0	593,272	2,418,780
0.16.0	strict-tsume-v6	209,275	159,654	70,945	52,707

Re-judgements run on the catalogue between v3 and this export, all with solver 1.3.0 (pipeline 0.16.0), on 2026-10-31:

• Rule D re-check of the sound rows marked minimal or reduced that have two or more main-line paths (the rows the new test can judge differently), by the main-line-preserving reducer of pipeline 0.16.0 (rule D on the main-line paths): 291,012 rows were found reducible (194,901 that were minimal as generated, 96,111 reduced diagrams) and became flawed rows with is_reducible = true (in unsound, or in floodgate for floodgate rows); their 164,998 new reduced diagrams entered after the same checks. Every re-check ended with no budget-out.
• Rule G re-judgement of the 206,707 rows that had been rejected for an inert piece (has_inert_piece = true), under clauses (d) and (e) of pipeline 0.16.0: 64,837 became sound (no rule broken; minimality proven with no budget-out); on the other rows the inert-piece reasons were dropped or kept and the other reasons stayed. 30,825 new diagrams (reductions) entered with it.
• Diagrams made shortly before this export (re-solved conflicts between stored and incoming main lines, longer-than-source floodgate distillations, yozume repairs): their 156,802 records were judged again at pipeline 0.16.0 before they entered (90,051 new rows).
• 87 rows that had no stored proof were solved again; 7,856 rows of an early solver build got their koma_amari_detail corrected; 800 representative links were fixed; 67,087 floodgate rows got their source game (source_file / source_line / source_sha256); and the representatives of every mate length were elected again over the whole catalogue (2026-11-01).

Rows outside these re-judgements keep the verdict of their pipeline_version (and rules_version). For the flawed rows not yet judged again with solver 1.3.0, a census of what each rule change since their judgement could alter found a single row that the newer rules might make sound; every other such row breaks a rule that none of those changes touches.

Shogi legality. Rules A–G are composition rules on top of the ordinary rules of shogi, which the project's rules engine enforces on every diagram before it is searched:

• exactly one defender king (and, by rule A, no attacker king);
• no piece that could never move again: no unpromoted pawn or lance on the last rank and no unpromoted knight on the last two ranks, for either side;
• no two unpromoted pawns of one side on one file (nifu);
• no more pieces of a kind than a shogi set holds (P 18, L 4, N 4, S 4, G 4, B 2, R 2; a promoted piece counts as its unpromoted kind), with every missing piece in the defender's hand (nokori-goma zenbu);
• the defender (the side not to move) is not already in check.

During the search only legal moves are played: a move that would leave a piece unable to move again must promote, drops obey the same restrictions and nifu, a pawn drop that gives mate (uchifuzume) is not allowed, and the defender may not leave its king in check. Diagrams are not required to be reachable from the starting position of a game, and repetition (sennichite) plays no part, since every search is bounded by the mate length.

規約 A〜G（日本語）: どの図も通常の詰将棋（攻方は毎手王手、玉方は最長の応手、盤上と攻方の持ち駒以外の駒は全部玉方の持ち駒）。完全作（default）は次を満たす。A 攻方の玉なし、B 余詰なし（初手が一つに決まり、主線の領域の最終手以外の攻方の手番でも正解が一つ）、C 駒余りなし（主線のどの応手に対しても持ち駒 0 で詰め上がれる）、D 極小（駒を 1 枚外し（それで無駄駒になる駒も一緒に外す）、同じ主線で、主線の領域に新しい手順の無い完全作が残る、という削減が一つも無い。主線が変わる完全作になる削減は D の対象外）、E 生成では攻方の玉を置かない（設定であって検査ではない）、F 無駄合は応手に数えない（古典的な扱い。数え方の約束なので破られることはない）、G 無駄駒なし（盤上の玉以外の駒はどれも解に関わる。ここで「関わる」は手順に現れることより広く、解のどこかの局面で、動く・取る・取られる、攻方の駒なら玉と玉の隣の升のどれかに利く、玉方の駒なら玉の隣の升にいるかそこに利く、攻方の飛角香と玉の周りの間に立ってその利きを遮る、誤った王手に対する玉方の応手で動く・取る（玉方の駒）か取られる（攻方の駒）、のどれかが成り立つこと。詳しくは用語集の Inert piece）。unsound の行は少なくとも 1 つを破り、どれを破ったかは表の右の列で分かる。攻方の玉がある行は両方の config に無い。将棋としての合法性（二歩・行き所のない駒・打ち歩詰め・王手放置の禁止・駒数）は上の Shogi legality のとおりで、対局で実際に現れうる局面である必要はない。

Configs

Config	Rows	Representatives	What it holds
default	8,829,856	6,568,536	Sound problems (class = positive, label = sound): rules A–G hold, and the diagram is proven minimal
unsound	21,338,874	12,560,417	Flawed diagrams (class = negative): at least one of rules B, C, D and G fails, while the forced mate itself is proven. label is yozume when the diagram has an alternative solution (has_dual), else defect
floodgate	3,135,704	1,697,344	Every row with a floodgate origin, sound (664,217, class = positive) and flawed (2,471,487, class = negative). Representatives are chosen within the config, over both classes

is_representative and representative_id mark the config representative: one row per group within a config, over all three of its splits. For 3 plies or more a group is the rows of the config with one (mate_ply, main_line), apart from extension_sibling and extension_cap rows; for 1 ply every position is its own group and its own representative. The config representative is chosen in two steps:

1. The catalogue itself marks one catalogue representative per (mate_ply, main_line) (for 3 plies or more) across all configs, preferring rows of a source the game may serve (so a floodgate row is a catalogue representative only when its group has no other row), then sound rows, then the fewest board pieces, the fewest pieces in the attacker's hand and the smallest id. If that row is in this config, it is the config representative.
2. Otherwise (the catalogue representative is in the other config) the group's rows in this config elect one by the same order: the fewest board pieces, then the fewest pieces in the attacker's hand, then the smallest id.

Since representatives are chosen over all splits, a group's representative and its variants can be in different splits (see Splits).

Rows by mate length:

Plies	default rows	default reps	unsound rows	unsound reps	floodgate sound	floodgate flawed
1	566,091	566,091	4,961,883	4,961,883	138,862	730,644
3	2,594,719	1,308,138	6,067,772	1,231,089	298,990	865,466
5	2,483,464	1,941,558	4,414,673	2,128,029	192,340	674,637
7	1,322,174	1,149,953	3,025,411	1,929,343	29,372	184,559
9	1,089,568	945,851	1,529,115	1,165,213	4,248	15,412
11	642,751	539,606	881,299	734,237	386	744
13	97,704	87,727	302,924	268,342	18	25
15	33,385	29,612	155,797	142,281	1	0
Total	8,829,856	6,568,536	21,338,874	12,560,417	664,217	2,471,487

Flawed rows by label (and the sound rows of floodgate):

Plies	unsound yozume	unsound defect	floodgate sound	floodgate yozume	floodgate defect
1	1,065,176	3,896,707	138,862	275,803	454,841
3	1,545,759	4,522,013	298,990	350,279	515,187
5	2,605,371	1,809,302	192,340	402,397	272,240
7	2,277,738	747,673	29,372	117,047	67,512
9	1,244,174	284,941	4,248	9,137	6,275
11	774,882	106,417	386	368	376
13	276,303	26,621	18	9	16
15	145,818	9,979	1	0	0

Rule columns over unsound (a row can break several rules; in default, and on the sound rows of floodgate, every rule column is false):

Column (rule)	true (defect present)	false (checked, absent)	null (not checked)
has_dual (B)	9,935,221	11,402,587	1,066
has_koma_amari (C)	6,020,399	15,318,474	1
is_reducible (D)	4,727,801	396,971	16,214,102
has_inert_piece (G)	4,611,230	16,727,643	1

The same over the flawed rows of floodgate and its sound rows together (the sound ones count as false):

Column (rule)	true (defect present)	false (checked, absent)	null (not checked)
has_dual (B)	1,155,040	1,316,447	0
has_koma_amari (C)	2,048,329	423,158	0
is_reducible (D)	126,797	0	2,344,690
has_inert_piece (G)	284,992	2,186,495	0

Besides its reasons, the gate stores for most rows a separate record of its check of region R (the source of has_yozume and the yozume_* columns). has_dual is null on 1,066 rows of unsound (and 0 of floodgate) where that record is missing, so rule B is unknown there and these rows may also have yozume.

rejection_reasons of the flawed rows: the reasons the gate gave. Rule D is not a gate reason (it is is_reducible), so a row that fails rule D and got no reason from the gate has an empty list.

rejection_reasons value	unsound rows	floodgate flawed rows
koma_amari	6,020,399	2,048,329
yozume_in_main_line	6,643,227	452,396
first_move_not_unique	5,230,310	878,416
[] (empty list)	4,721,754	126,797
inert_attacker_piece	3,305,259	198,664
inert_defender_piece	1,870,320	190,241
incomplete_response_graph	1	0

Value	Rule	Meaning
first_move_not_unique	B	The first move has two or more correct moves
yozume_in_main_line	B	Another attacker turn of R, not the first or the final move, has two or more correct moves
koma_amari	C	Some main-line defence forces the attacker to finish with pieces in hand
inert_attacker_piece	G	An attacker board piece takes no part in the solution
inert_defender_piece	G	A defender board piece takes no part in the solution
incomplete_response_graph	—	The node budget ran out while the proof was being built, so not every rule could be checked (rule columns are null where not checked). It occurs only together with another reason

Rows by variant_kind. Every row of default, representative or variant, is a valid problem on its own.

variant_kind	default	unsound	floodgate
null (representative)	6,568,536	12,560,417	1,697,344
same_main_line	2,260,576	8,777,347	1,438,360
extension_sibling	204	170	0
extension_cap	540	940	0

variant_kind	representative_id	Meaning
null	null	The row is the representative of its group (is_representative = true)
same_main_line	the representative's id	A different diagram with exactly the same mate_ply and main_line: same answer, different position
extension_sibling	null	A retrograde extension whose main line, after its first two moves, is the same as that of sibling extensions; only a few of each such family are kept as normal rows
extension_cap	null	When more than 10 retrograde extensions share mate_ply and the first record of their derivation chain (lineage_root_id), 10 are kept as normal rows, chosen for diverse boards and an unexpected first move, and the rest are marked extension_cap

extension_sibling and extension_cap rows cluster around a few parents; down-weight them if diversity matters.

Minimality

Definition (rule D). A removal step takes one piece off the diagram (a board piece, or one piece of the attacker's hand; the piece goes to the defender's hand) together with any piece that becomes inert because of it. A diagram is minimal when no removal step leaves a sound problem whose solution is one of the original's main-line paths and whose main-line region contains no new route (every move sequence through the new region R, from the start to a mate, must already be one of the original's). Through pipeline 0.13.0 the step also required the new problem's displayed main_line to equal the original's; since 0.14.0 any of the original's main-line paths will do. The displayed line breaks ties by the smallest USI string, which depends on the board's orientation, so the old test could call a diagram minimal and its mirror image reducible; the new one cannot. A diagram with a single main-line path (n_main_paths = 1) is judged the same by both. Steps that keep the mate length but change the main line are not checked by rule D; they produce new problems instead (see reduction_kind).

Proof. A removal is judged by the gate within a node budget. A budget-out leaves that removal undecided, so "no piece came off" proves nothing by itself. A row counts as minimal only when its check had no budget-out. For v3, every row of default was run through the reducer again, single-threaded (where the reducer's output and its count of budget-outs are reproducible), at a node budget of 10 million, or at the budget of the row's previous minimality check if that was larger (long problems had been checked at 16 or 50 million, and some 15-ply problems at more), and the number of budget-outs was recorded. A row counts as proven minimal only when that number is 0. Rows with a budget-out were run again at 200 million nodes on 4 threads, with any budget-out of a parallel search counted as undecided; rows whose earlier budget was already 200 million or more were rerun at that budget. Rows that still had a budget-out were deleted from the catalogue and are in neither config. Diagrams found reducible moved to unsound (is_reducible = true), and their reduced diagrams entered the catalogue as new rows after passing the same checks. Since v3, rows enter the catalogue as minimal only with a proof recorded by the reducer itself (every removal decided within the budget); the budget is raised in steps up to 50 million nodes on several threads, and a diagram still undecided there is not entered as minimal. Before this export every minimal or reduced sound row with two or more main-line paths was checked again under the rule D of pipeline 0.16.0; 291,012 were reducible and became flawed rows (see Rules A–G, Which rules a row was judged by).

minimality_check_version is D-<reducer version>/<pipeline version>/<node budget>. D-v5 is the reducer that applies rule D as defined here; the pipeline version in the tag says whether the check used the 0.13.0 test (displayed main line) or the 0.14.0 one (main-line paths). Older tags appear only in unsound, on rows found minimal by the reducer of v1 and v2, which accepted any removal that kept a sound problem of the same length; those rows fail another rule. D-v4 is one greedy pass of that reducer; D-v4-fix is the same reducer repeated until no more pieces came off; D-d14c4fd-fixpoint is that repeated pass run with the solver build d14c4fd on the rows that v2 shortened and reduced. D-v5 always repeats until no more pieces come off. Tags on the sound rows (default and the sound rows of floodgate):

minimality_check_version (sound rows)	default	floodgate
D-v5/0.13.0/10000000	7,426,475	0
D-v5/0.13.0/50000000	1,007,452	0
D-v5/0.14.0/4000000	0	541,018
D-v5/0.16.0/50000000	209,275	70,945
D-v5/0.13.0/16000000	181,132	0
D-v5/0.14.0/10000000	0	52,254
D-v5/0.13.0/200000000	5,439	0
D-v5/0.13.0/500000000	64	0
D-v5/0.13.0/1000000000	14	0
D-v5/0.14.0/50000000	4	0
D-v5/0.14.0/500000000	1	0

reduced (in default) is true for 2,851,879 rows that the reducer produced from another diagram, and false for the 5,977,977 rows that were minimal as generated (in floodgate: 48,764 and 615,453). method = reduce marks 1,369,504 of them, reducer outputs that were recorded as rows of their own; the other reduced rows keep the method of the diagram they came from, usually with +reduce appended to run_name. reduced_from_id names the source diagram when the catalogue still holds it.

What is in a row

All 88 columns, grouped by topic (5 are new in v4: pipeline_version, n_main_paths, has_final_alt, judged_at, reduced_at). "Null" means not recorded or not applicable. Several columns describe the stored proof: the part of the solver's search graph kept with the row (in default always present; in unsound mostly absent).

Position and solution

Column	Type	Meaning
id	string	64-hex SHA-256 of a canonical byte encoding of the position: the attacker is turned to be sente, the defender's hand is filled with every remaining piece, and of the position and its left–right mirror image, the one whose encoding is smaller byte by byte is taken. The encoding is internal, so treat id as an opaque key. Mirror images therefore share an id, and since the catalogue keys its rows by id, it holds at most one diagram of each mirror pair. id is unique across all configs and splits, so it is a safe row key. Stable across dataset versions
sfen	string	Initial position in SFEN (board, side to move, hands, move number). The attacker is always sente (b) and to move, there is no attacker king, the move number is 1, and the defender's hand is written out in full. Hands are in the order R B G S N L P, attacker first. Board ranks run from rank a (top, the defender's side) to rank i, files from 9 to 1
mate_ply	int8	Length of the shortest forced mate in plies, futile interpositions not counted. Proven by the gate in every config; main_line has exactly this many moves
main_line	string	The main line in USI notation, space-separated (7a8a+ moves from 7a to 8a and promotes; N*7c drops a knight on 7c). Every row has one
main_line_source	string	Always stored (the main line comes from the catalogue, not re-solved at export)
solver_nodes	int64	Search nodes of the gate that judged the row; the scale depends on solver_nodes_kind. Null where not recorded (9,313,488 rows of unsound)
solver_nodes_non_futile	int64	Nodes of the stored proof reachable within mate_ply plies without playing a futile interposition. On prober rows it is counted on the smaller graph the prober built. Null without a stored proof
attacker_branch_nodes	int32	Attacker turns in R (first and final moves included) with more than one correct move. On a sound problem only final-move alternatives can count
yozume_allowed	bool	Legacy flag of the stored proof: true when it was made by an older solver setting (pipeline 0.7.0–0.11.0) that tolerated yozume in 9- and 11-ply problems. It says nothing about the diagram itself; false on every row of default, null without a stored proof
unique_first_move	bool	The first move is the only correct one
has_yozume	bool	Yozume in region R; false throughout default. Wherever both are set, it equals has_dual (as in v3)
has_yozume_in_variation	bool	Yozume anywhere in the stored proof, variations outside R included. Rule B does not look outside R, so this can be true in default. Null in unsound
final_move_alternatives	bool	Some final attacker turn of R has several mating moves (allowed). Null in unsound
n_main_paths	int16	(new in v4) Number of main-line paths through R, from the start to a mate (1 when main_line is the only one). Null when there are more than 512, and on rows without a stored proof or not yet counted (8,620,595 rows of default have it or has_final_alt)
has_final_alt	bool	(new in v4) Some main-line path ends in a final move that has another mating move (allowed by rule B). Counted on the same paths as n_main_paths; set even when n_main_paths is null because the paths exceed 512
defense_coverage_verified	bool	Every defender reply on the main line was searched (true on every row of default)

Groups and minimality

Column	Type	Meaning
is_representative	bool	The row is its group's representative (see Configs)
variant_kind	string	Null for a representative, else same_main_line, extension_sibling or extension_cap (see Configs)
representative_id	string	For same_main_line, the id of the representative in the same config; null otherwise
reduced	bool	true: the reducer produced this diagram from another one; false: rule D was checked and the diagram was minimal as generated; null: rule D was not checked, or the diagram is reducible (is_reducible = true)
minimality_check_version	string	D-<reducer version>/<pipeline version>/<node budget> of the rule D check (see Minimality). Null where rule D was not checked
solve_version	string	S-<solver build>/<pipeline version>/<node budget> of the gate run that gave the row's current verdict (or, for some flawed rows, of the run that stored the proof). The build is a source revision, sometimes with suffixes. +par (several threads searching one position) and +pdfpn (a multi-threaded prober) mark multi-threaded searches, whose node counts can differ from a single-threaded run; +cc marks a prober cache setting. Other suffixes (such as -vast, -gen, -extrej) are labels of the machine or run that carry no meaning for analysis. The pipeline versions are 0.13.0 to 0.16.0 (see pipeline_version). In unsound, a stored proof can be older than this run (it was kept from an earlier judgement)

Provenance

Column	Type	Meaning
method	string	How the row was made: distill (distillation, mostly of YaneuraOu positions), extend (retrograde extension), mine (random search), model_sampled (a generative model: MaskGIT, or the autoregressive model), reduce (a reducer output stored as its own row, see Minimality), repair (a v2 repair)
origin_class	string	Set when the row's chain was first recorded and never changed afterwards: third_party (the chain was imported from a YaneuraOu position or a floodgate game) or own_generated (generated by the project). The rl-long rows of Source attribution are own_generated, although their YaneuraOu source was later recorded as the first step of their chain
origins	list of string	Every data source that contributed to the row through any derivation: yaneuraou-2020 (the YaneuraOu collection), floodgate-wdoor<year> (the floodgate game archive of that year), own (the project's own random generation), model-sampled:<run> (the model run that sampled it). A derivation copies its input's set; one with several inputs takes the union
lineage_root_id	string	Internal identifier of the first record of the chain: src-<hex> for a YaneuraOu position, floodgate-<game date and time>-<8 hex>-p<ply> for a floodgate position (the game's start time, the first 8 hex digits of the SHA-256 of its record's file name, and the number of moves played before the position), maskgit-… for the model that sampled the diagram, mine-… for a random-search position. Not an id of this dataset
lineage_parent_id	string	Identifier of the record the row was directly derived from: the id of another row, written bare or as catalog:<id>, or an internal identifier of a generation run (<run>:<hex>). Null for a row whose chain starts with the row itself (no parent)
lineage	string (JSON)	The derivation chain, oldest step first: a JSON list of objects, one per step, each with at least sourceId, tool and version, plus fields that depend on the tool (see The lineage column below). 437 rows have an empty list
source_dataset	string	yaneuraou-2020 when the row derives from a specific YaneuraOu position; floodgate-wdoor<year> when it derives from a floodgate game of that year's archive; else null
source_file	string	YaneuraOu: that position's file (mate3.sfen … mate11.sfen). floodgate: wdoor<year>.7z!<game record file>, the archive and the record's file name inside it (the file name is floodgate's identifier of the game and names the two engines, wdoor+<game type>+<sente engine>+<gote engine>+<start time>.csa). Null when source_dataset is null
source_line	int64	YaneuraOu: the 1-based line number in the file. floodgate: the number of moves played in the game before the source position. Null when source_dataset is null
source_sha256	string	SHA-256 of the file (for floodgate, of the yearly archive, as published on the floodgate page)
run_name	string	<run>:<batch>: the internal run that produced the row and its input batch. Names starting with maskgit- or rl-long are model runs, uniform- and randgen- random search, yane- and yaneuraou- distillation, floodgate-wdoor-distill floodgate distillation, ext/extchain-/extend- retrograde extension, rulef010- v2's repairs; +reduce is appended for a reduced diagram. It groups the rows of one run and is not meant to be parsed further
training_corpus	list of string	For a diagram sampled by a model, or derived from one: the sources of the data that model was trained on, in the vocabulary of origins (for example ["yaneuraou-2020"], or a list of earlier model runs plus own and yaneuraou-2020 for later models trained on the catalogue). Null for other rows. Read from the trainingCorpus field of lineage

Rules and judgement

Column	Type	Meaning
rules_version	string	The name of the rule set the row was judged by, from pipeline_version (see Glossary, Version numbers). Null on 5 rows of unsound judged by pipeline 0.11.0, which predates the rule names used here
pipeline_version	string	(new in v4) Pipeline version of the gate run in judged_by (else solve_version): the version whose rules A–G gave the row's verdict
judged_at	string	(new in v4) When the solver finished the gate run that judged the row (ISO 8601, Japan time, +09:00). Recorded since 2026-10-27; null on older rows (195,341 rows of default and 3,135,704 of floodgate have it)
reduced_at	string	(new in v4) When the reducer finished the row's minimality check or reduction, recorded the same way; null on older rows and where no reduction ran
mate_ply_with_futile	int8	The length of the shortest forced mate when futile interpositions are allowed as defender replies, so that the defender can lengthen the mate with them (equal to mate_ply or larger by an even number). Computed in v2 and carried over (through v3) only for rows whose id and mate_ply are unchanged since v2 (1,700,986 rows of default); null elsewhere
yozume_count	int16	Number of attacker-to-move positions in R that are not a final move and have two or more correct moves (so a non-unique first move of a mate in 1 is not counted: a 1-ply row with has_dual = true has yozume_count = 0; use has_dual to find yozume). R branches, so there can be many more such positions than moves in the main line. 0 on every row of default; in unsound, filled where the region check was stored, else null
yozume_first_ply	int8	0-based ply of the earliest turn counted in yozume_count (0 = the first move). Null when there is none or it was not stored
yozume_max_correct	int16	The largest number of correct moves at one turn counted in yozume_count (1 when there is none). Null when not stored
yozume_in_variation	bool	Same as has_yozume_in_variation
final_move_alternative_count	int16	The most mating moves at one final attacker turn of R (1 when there is no alternative). Null in unsound
rejection_reasons	list of string	The gate's reasons (see Configs). [] on every row of default and on unsound rows that fail rule D and got no reason from the gate
class	string	positive (sound: config default, or floodgate) or negative (config unsound, or floodgate)
label	string	sound on positives; on negatives yozume when has_dual is true, else defect
solver_nodes_kind	string	How solver_nodes was counted: full (a full-width bounded search; 93 rows of default) or prober (the df-pn prober plus the proof it built, summed over all of the gate's searches: the mate itself and the checks of the rules; 8,620,483 rows of default). Prober counts are much smaller, about 1/30 of full counts at 11 plies, so compare solver_nodes only within one kind. Null where the row has no stored proof (20,502,688 rows of unsound); such rows may still carry the gate's solver_nodes, whose kind was not recorded, so leave them out of any comparison of solver_nodes
solver_nodes_proof	int64	On prober rows: nodes a fresh df-pn search needs to prove the mate in exactly mate_ply plies. Unlike solver_nodes, it does not grow when the gate searches deeper than the mate. Null on full rows and without a stored proof
has_attacker_king	bool	Rule A broken. Never true
has_dual	bool	Rule B broken: yozume, i.e. several correct moves at the first move (any length) or at a later attacker turn of R other than the final move (first_move_not_unique or yozume_in_main_line)
has_koma_amari	bool	Rule C broken
is_reducible	bool	Rule D broken: some removal step is accepted (a sound problem with the same main line and no new route, see Minimality)
futile_interposition_judged	bool	A placeholder for rule F among the rule columns. Rule F is a convention for reading the solution, not something a diagram can break, so the column can never mark a defect; it is false on every row of every config
has_inert_piece	bool	Rule G broken
dual_kind	string	Where rule B fails: first_move, main_line (a later turn), or both. Null when has_dual is not true
koma_amari_detail	string (JSON)	{"leftoverHand": n, "pieces": "3S2NL3P"}: n (int) is how many pieces are left in the attacker's hand at the end of the main line, and pieces says which, written as an SFEN hand: piece letters in the order R B G S N L P, each preceded by its count when the count is 2 or more (the example is 3 silvers, 2 knights, 1 lance and 3 pawns, so n = 9). {} when rule C holds. v3 had 7,858 rows of one early solver build where rule C failed but the object said 0 pieces; they were corrected for v4, and no row with has_koma_amari = true has leftoverHand 0 now
inert_pieces	string (JSON)	The inert board pieces, [{"square": s, "piece": p}]. [] when rule G holds
removable_pieces	string (JSON)	Pieces whose removal is a valid rule D step, same format. A piece of the attacker's hand appears as {"square": 81 + k, "piece": "hand:<letter>"} with k its index in the order P L N S G B R (the reverse of the SFEN hand order) and an upper-case letter. [] when rule D holds; null when rule D was not checked, or the diagram is reducible but the pieces were not recorded
judged_by	string	solve_version of the gate run that gave the current verdict (equal to solve_version on almost every row)
reduction_kind	string	Where recorded, the kind of reduction that produced or confirmed the row: mainline (the main-line-preserving reduction of rule D; when nothing came off, the row is its own output and reduced is false) or length (an output of the reducer's second mode: same length, different main line; always a different diagram from its source). Null otherwise
reduced_from_id	string	For a reduced diagram, the id of the diagram it was reduced from, when the catalogue still holds it

In the JSON piece lists, square is 9 × (rank − 1) + (9 − file) with ranks a–i numbered 1–9 (so 0 is 9a and 80 is 1i), and piece is b (attacker) or w (defender), then + if promoted, then the USI letter: P pawn, L lance, N knight, S silver, G gold, B bishop, R rook. For example bS is an attacker silver and w+P a defender promoted pawn.

Rule columns other than futile_interposition_judged are true (the defect is there), false (checked, not there) or null (not checked).

The lineage column

Each step is a JSON object. Three fields are on every step: sourceId (string: the identifier of the step's input or of the run's sample, an internal identifier unless it is an id of this dataset, sometimes written catalog:<id>), tool (string) and version (string: the version of that tool or of the model). The other fields depend on tool; each is present only on some steps, and a missing field means it was not recorded. The table lists the tool values of v3 and those new in v4, and the fields seen with them; fields not explained are settings recorded by the run as it wrote them, without a stable meaning across runs, and are best not used for analysis.

tool	Step	Other fields
distill	Distillation of the input	—
distill-negatives	Distillation in runs that recorded their flawed diagrams as well	—
extend	Retrograde extension of the input	—
reduce	A reducer run	fromCanonicalHash (string: the id of the diagram the reduction started from), removed (the pieces removed: a list, or on older steps their number), reduceKind (mainline or length, as in reduction_kind), reducedLineChanged (bool: the main line changed), reducedBy, entry, and on one row note and removedPieces (a written-out list of the removed piece)
reduce-negatives-aggregate	A record of flawed reducer outputs (one row)	—
rule-f-relength	v2's re-judgement under the classical convention for futile interpositions, which changed the mate length	fromMatePly, toMatePly (int: the length before and after), fromCanonicalHash
maskgit-sample	A MaskGIT sample	trainingCorpus (list of strings: the model's training data, copied to training_corpus), trainingDataSha256
maskgit-sample-browser	A MaskGIT sample made in the web game's generator page (one row)	trainingCorpus, checkpointSha256, weights, solverWasmSha256, reportedBy, note
maskgit-m13-sft-gen, maskgit-m13-rl-c-gen	Large sampling runs of MaskGIT models, kept mostly as negatives	condPly (int: the requested mate length), temperature (float), samplingSeed, batch, sampleIndex (int), policySha256 (SHA-256 of the model weights), machine, sampler
maskgit-m15r-l0-gen, maskgit-m15r-l1-gen, maskgit-m15r-l3-gen, maskgit-m15r-l5-gen	Sampling runs of later MaskGIT models	condPly, band (string: the requested class, such as sound or yozume), combo (<condPly>:<band>), temperature, samplingSeed, sampleIndex, rounds (int: decoding rounds), order, checkpoint, checkpointSha256, trainStep (int), run, experiment, file (the project-internal file the samples were written to), samplesSha256, machine, linePrefix, seedIndex, trueLine, box, fixedSourceHash, guidance, sightings
m15gen-ingest, ply13-unverified, ply15-unverified	The gate run that measured the mate length of a model sample and judged it. The ply13- and ply15-unverified steps are samples requested as 11-ply whose mate was not confirmed at 11 plies ("unverified" there) and that were then searched and judged at 13 or 15 plies	solverCommit, solverSha256 (the solver build), gateBudget (int: node budget), note (how the length was found)
maskgit-vary, maskgit-variation	Input-board runs of the m7 and m9 series: the model re-filled part of the catalogue diagram named in sourceId	—
defender-add, defender-insert	A yozume repair: defender pieces added to a flawed diagram so that the alternative solution no longer works (floodgate yozume repairs and some model rows)	settings of the repair run, the parent diagram (parentCanonicalHash, parentSfen)
recheck-d-1031, recheck-d5b-1031, recheck-g-1031, floodgate-lenchange-all-1031, lenchange-yzrepair-1031, lenchange-yzrepair-3ply-1031, conflict-resolve-1030, conflict-resolve-1031, ply15-rereduce	Re-judgements and re-reductions of 2026-10-30/31 with solver 1.3.0 (see Rules A–G, Which rules a row was judged by), and the floodgate distillation allowed to change the mate length	note (what was re-run), solver build fields
other values new since v3 (exp-ingest-1025, branch-rl, branch-rl-iter, m16-gap-harvest, m16-ply1-harvest, m16-t13-long, m16rl-ingest, maskgit-m16-rl-reduce, mac-rl-harvest, b0-gen11, fix-loop, neg-defenders-1027, rare-piece, cg-entry-rescue, decode-legal, subst-decay-s1, subst-decay-d2, count-feat, budgetout-15)	Sampling, harvesting and gating runs of later MaskGIT models (m16 and experiments around it), and small repair or re-gating runs; the names are internal run labels	run settings, as for the model runs above
rl-srccond-sample	A sample of the autoregressive runs rl-long12 / rl-long13 from a YaneuraOu position	canonicalHash (the id of the sampled diagram), sourceFile (the YaneuraOu file, with its project-internal path), sourceLine (int: line in that file)

Tesuji features (the columns listed in Tesuji features, from n_sacrifice to tesuji_version): see the next section.

Release history and split

Column	Type	Meaning
first_dealt_version, last_dealt_version	int16	The first and last Tsume.Quest release (release 2 was never published) that dealt the problem; null when it was never dealt. 2,093,287 rows of default and 385,603 of unsound were dealt (the latter fail the current, stricter rules); no row of floodgate (0)
split	string	train, validation or test (see Splits)

Tesuji features

Computed by replaying the row's main_line on its own diagram; nothing is searched. The version of these definitions is tesuji_version (tesuji-3 on every row); has_tesuji follows the definition named has-tesuji-1 below. In the definitions, the landing square of an attacker move is the square the moved or dropped piece stands on afterwards, and attacks means the squares a piece could move to, pins ignored. Material values: pawn 1, lance 3, knight 4, silver 5, gold 6, bishop 8, rook 10; a promoted piece counts at its unpromoted value. All are int16 counts unless marked bool.

Column	Meaning
n_sacrifice	Sacrifices (捨て駒): attacker moves whose piece the defender's next main-line move captures on its landing square
n_free_sacrifice	Free sacrifices (ただ捨て): sacrifices after which the attacker's next move does not land on the same square (no recapture)
n_hanging	Attacker moves whose landing square a defender piece (the king included) attacks and no other attacker piece defends, captured or not
n_focal	Focal sacrifices (焦点の捨て駒): sacrifices on a square that two or more defender pieces (the king included) attack
material_given	Total value of the attacker's pieces the defender captures on the main line
material_net	material_given minus the value of the defender's pieces the attacker captures (can be negative)
n_non_promo	Non-promotions (不成) of the attacker: board moves into, out of or within the promotion zone (the defender's three ranks) by a piece that could promote and does not
n_non_promo_br	Of those, by a bishop or a rook
n_non_promo_final	Of those, on the final move
n_non_promo_defender	Non-promotions of the defender, counted the same way in its own promotion zone
n_long_drop	Long-range drops (遠打): a rook, bishop or lance dropped on the same file, rank or diagonal as the defender's king, in a direction the piece moves, three or more squares away (pieces in between and check not considered)
n_discovered	Discovered checks (空き王手): attacker moves after which a piece other than the moved one gives check (double checks included)
n_chuai	Chuai (中合): defender interpositions (a drop, or a non-capturing move of a piece other than the king, onto a square between the king and a checking rook, bishop or lance) that are not next to the king. Futile interpositions are not on the main line, so they are never counted
n_attacker_capture	Attacker moves that capture a defender piece
n_captured_drop	Attacker drops of a piece kind the attacker holds more of than at the start, i.e. a piece captured on the main line put back on the board
n_defender_captured_interpose	Defender interpositions that drop a piece kind the defender holds more of than at the start, i.e. a piece captured from the attacker
first_move_sacrifice (bool)	The first move is a sacrifice
king_drag (bool)	玉の引き出し: some main-line move of the defender's king captures an attacker piece and lands at Chebyshev distance 2 or more from the king's starting square (two or more king steps away), or on a rank at least one rank nearer the attacker's side of the board (toward rank i) than the king's starting rank
is_narabe (bool)	並べ詰み (narabe-zume, "mating by lining pieces up"): five plies or more, no sacrifice, and every attacker move lands on a square that another attacker piece defends. An operational label of this dataset, not a judgement of quality; always false under five plies
final_captured_drop (bool)	The mating move is a drop of a captured piece (as in n_captured_drop)
n_forced_non_promo	n_non_promo - n_non_promo_final when has_dual is false; null when it is true or null. With no yozume, every non-final attacker turn has one correct move, and promoting would be a different move, so these non-promotions are forced
has_tesuji (bool)	n_free_sacrifice + n_focal + n_hanging >= 1 and not is_narabe (definition has-tesuji-1): the main line contains at least one characteristic tactical move
tesuji_version (string)	Version of the definitions above

The features describe the main line only: on a row with has_dual = true, other mating routes are not inspected. They are descriptive counts, not a quality score and not a difficulty. Share of default rows, per mate length, with has_tesuji true, with n_free_sacrifice ≥ 1 (free sacrifice), with n_forced_non_promo ≥ 1 (forced non-promotion) and with is_narabe true:

Plies	has_tesuji	free sacrifice	forced non-promotion	is_narabe
1	0.1 %	0.0 %	0.0 %	0.0 %
3	8.1 %	6.2 %	1.3 %	0.0 %
5	38.9 %	31.4 %	2.3 %	39.4 %
7	66.3 %	56.6 %	3.6 %	19.8 %
9	81.2 %	72.5 %	4.3 %	9.3 %
11	85.8 %	78.0 %	4.4 %	6.3 %
13	86.2 %	78.8 %	4.9 %	5.0 %
15	87.4 %	80.8 %	5.3 %	3.7 %

Main-line paths of the sound rows (filled: rows with n_main_paths or has_final_alt):

Plies	default: filled	n_main_paths >= 2	has_final_alt	floodgate sound: filled	n_main_paths >= 2	has_final_alt
1	555,827	0	0	133,734	0	0
3	2,474,988	1,463,116	984,718	259,616	163,500	98,329
5	2,435,571	1,589,750	1,027,842	169,232	111,373	61,091
7	1,304,507	876,207	562,343	26,205	16,899	9,163
9	1,079,773	757,296	494,504	4,082	2,621	1,455
11	639,253	456,724	307,876	384	248	150
13	97,387	69,725	47,983	18	15	10
15	33,289	24,154	16,832	1	1	1

How the problems were produced

Three generation algorithms produced the diagrams; two derived kinds of row come from them (terms in Glossary).

1. Distillation and retrograde extension (method = distill, extend). Positions of the YaneuraOu collection, and (config floodgate) near-final positions of floodgate games, are distilled into strict problems; some runs first remove pieces far from the king while a mate of the same length remains (a pre-strip, see Glossary). Accepted problems are then lengthened two plies at a time by retrograde extension (3 → 5 → … → 15). The distilled problems were also the first training data of the models.
2. Generative models with reinforcement learning (method = model_sampled). Almost all model rows come from MaskGIT models; the runs rl-long12 and rl-long13 used the earlier autoregressive model (see Glossary). MaskGIT models were pre-trained on the catalogue and fine-tuned by RL whose reward is staged: a legal position, a mate, passing the composition rules, longer mates, and main lines not yet in the catalogue. Accepted samples joined the catalogue, and later models were trained on it. A few runs took an existing diagram as input instead of sampling from scratch (see Source attribution).
3. Random search (method = mine): see Glossary.

Derived rows: reduce (reducer outputs stored as their own rows, see Minimality) and repair (v2's repairs).

Since v2, the generators produced longer mates (13 and 15 plies), more distillations of the 9-ply YaneuraOu positions, and very large batches of model samples and random positions that were judged whether sound or not; the failing ones are kept as training data for models that judge or repair diagrams, and they make up most of unsound.

method	default	unsound	floodgate
distill	467,479	938,677	3,059,487
extend	559,764	257,215	0
import	195,336	0	489
mine	1,462,234	4,782,541	0
model_sampled	4,704,791	15,298,940	0
reduce	1,369,504	35,580	75,728
repair	70,748	25,921	0

floodgate (config floodgate): from every game of the yearly archives that ended in resignation, the positions in the last 40 moves before the winner's move where the winner's own evaluation was a mate score (30000 or more) were taken; the winner's king was removed (rule A) and the winner made the attacker (sente, to move). Positions whose forced mate (by checks only) of at most 15 plies the solver proved were distilled as above, and the outputs, sound and flawed, were judged by the gate. Two further runs were made from the same positions: a distillation allowed to change the mate length (for positions whose first distillation gave no sound output; floodgate-lenchange-… in run_name; a few of its outputs mate in more plies than the source position), and yozume repairs of flawed outputs by adding defender pieces (lineage step defender-add). A reduced diagram that was reached both from a floodgate position and from another source carries both in origins and is in floodgate. As of this export no floodgate row has been extended, and none was used to train the models that sampled rows of this dataset.

Note on circularity: the generative models were trained on earlier versions of this catalogue. If your experiment needs data that no model produced, method alone is not enough: a row derived from a model sample can have another method (extend, reduce, repair, distill), or keep model_sampled after a reduction. Keep a row only when method is not model_sampled, training_corpus is null and no entry of origins starts with model-sampled: (function model_free in How to load).

Source attribution

Part of the dataset derives from やねうら王 実戦詰み局面集 (YaneuraOu practical mate positions, 2020), published at https://yaneuraou.yaneu.com/2020/12/25/christmas-present/ with the statement 「著作権は主張しませんのでご自由にお使いください。」 ("We do not assert copyright; please feel free to use it"). It consists of positions from YaneuraOu self-play games where a forced mate of 3, 5, 7, 9 or 11 plies was found, one file per length.

• Rows derived from a specific YaneuraOu position (distilled, extended, reduced or otherwise derived from one) carry yaneuraou-2020 in origins. Rows whose chain began with an imported YaneuraOu position have origin_class = third_party (except the rl-long rows below) (573,410 rows in default, 971,550 in unsound) and name that position in source_file / source_line.
• The MaskGIT models were trained on data that includes problems derived from the YaneuraOu collection. A diagram a model sampled from scratch has no YaneuraOu position as its source, so its origins name only the model run; the model's training data is recorded in training_corpus (6,619,922 rows in default, 15,519,554 in unsound, counting rows whose training_corpus includes yaneuraou-2020).
• Some model runs took a diagram as input instead of sampling from scratch: the input-board runs (lineage steps maskgit-vary and maskgit-variation, with models of the m7 and m9 series; see Glossary, Model run and run names) re-filled part of a catalogue diagram, and the two source-conditioned RL runs rl-long12 and rl-long13 of the autoregressive model received a YaneuraOu position and produced a diagram from it (in 95 % of cases a sub-board: a subset of the source position's pieces, each on its original square). Their rows and the rows derived from them carry yaneuraou-2020 in origins when the input did: every rl-long row does, and so do the input-board rows except 886 whose input diagram's origins did not include it. The rl-long rows also name their source position in lineage_root_id, source_file / source_line and the first lineage step, but keep origin_class = own_generated, because that class was fixed when they were generated.
• own_generated rows with yaneuraou-2020 in origins: 19,891 in default, 6,238 in unsound. Rows without yaneuraou-2020 in origins: 8,236,555 in default, 20,361,086 in unsound.

floodgate. The floodgate config derives from the game records of floodgate (https://wdoor.c.u-tokyo.ac.jp/shogi/), the online computer-shogi server, which publishes yearly archives of all its games (wdoor<year>.7z; this dataset used the complete years 2008–2025, each checked against the SHA-256 published on that page). The page carries no licence or terms of use. The dataset author uses the records on his own judgement that publicly released game records may be used (a documented decision, not a statement or permission of the server's operators), and publishes the derived diagrams on these terms:

• they are kept in their own config, apart from default and unsound, and are not served as puzzles in Tsume.Quest;
• every row names its source: floodgate-wdoor<year> in origins and source_dataset, the game in source_file (archive and game record file name), the move number in source_line, the archive's SHA-256 in source_sha256, and the position in lineage_root_id. Player names appear only as the engine names inside the game file name; the per-account hashes that floodgate appends to player names are not in the dataset;
• no game record and no unmodified game position is included: every row is a distilled diagram (attacker king removed, pieces removed), and the archives themselves are not redistributed.

If you use the floodgate config, please credit floodgate as the source of the positions, keep the per-row provenance, and check the floodgate page yourself if you need certainty about the source material. Rows by archive year:

source_dataset	sound	flawed
floodgate-wdoor2008	18,512	67,425
floodgate-wdoor2009	15,144	56,639
floodgate-wdoor2010	29,699	104,966
floodgate-wdoor2011	31,363	107,372
floodgate-wdoor2012	40,094	142,699
floodgate-wdoor2013	40,443	147,029
floodgate-wdoor2014	24,604	85,394
floodgate-wdoor2015	23,120	81,528
floodgate-wdoor2016	35,743	137,546
floodgate-wdoor2017	33,811	125,921
floodgate-wdoor2018	16,303	60,517
floodgate-wdoor2019	41,196	150,095
floodgate-wdoor2020	66,010	244,618
floodgate-wdoor2021	61,640	219,025
floodgate-wdoor2022	60,758	220,659
floodgate-wdoor2023	46,352	181,446
floodgate-wdoor2024	38,959	165,058
floodgate-wdoor2025	40,466	173,550

No row is identical to an original source position. Collection positions come from games and include the attacker's king, which no row has, so a match was not expected; the check is kept as a safeguard: every row was compared with all 4,995,969 positions of the collection and with the 2,000 collection positions that Tsume.Quest shows unchanged in its practice mode. Positions were compared with the side to move as sente (a position with gote to move was first rotated 180°, with the colours of all pieces and the two hands swapped); board, side to move and both hands had to be equal for a match. Mirror images were not compared. Matching rows would have been left out; 0 matched. floodgate positions were not compared, since every floodgate row comes from a game position with the winner's king removed.

Splits

Splits are inherited so that a model trained on one version is not tested on its own training data in the next:

• A row published in v3 keeps its v3 split, whichever config it is in now; a v2 row not in v3 keeps its v2 split, and a v1 row in neither keeps its v1 split.
• A new row derived from a published row (a reduced diagram, or a v2 repair) takes the split of that row.
• Any other new row takes the split of the published rows that now carry the same (mate_ply, main_line); if there are none, it uses the rule of v1: the first 8 hex digits of sha256("<mate_ply>:<main_line>"), as an integer mod 100, give test for 0, validation for 1 and train otherwise.

So a main line can straddle splits: a row keeps its split when a later judgement changes its mate_ply or main_line (v2 did this when the classical reading of futile interpositions made some problems mate sooner), and a derived row follows its source rather than its own main line. If you need strictly disjoint main lines, give each (mate_ply, main_line) one split and drop (or move) the rows of the other splits. If you use several configs, do this on their union, since a main line can appear in more than one. One way, with the majority split and ties broken toward test, then validation:

import pandas as pd

splits = ("train", "validation", "test")
data = ds   # or several configs: {s: concatenate_datasets([ds[s], bad[s], fg[s]]) for s in splits}
cols = ["id", "mate_ply", "main_line", "split"]
df = pd.concat([data[s].select_columns(cols).to_pandas() for s in splits])
n = df.groupby(["mate_ply", "main_line", "split"]).size().rename("n").reset_index()
n["tie"] = n["split"].map({"test": 0, "validation": 1, "train": 2})
chosen = (n.sort_values(["mate_ply", "main_line", "n", "tie"], ascending=[True, True, False, True])
           .drop_duplicates(["mate_ply", "main_line"])[["mate_ply", "main_line", "split"]])
keep_ids = set(df.merge(chosen, on=["mate_ply", "main_line", "split"])["id"])
disjoint = {s: data[s].filter(lambda r: r["id"] in keep_ids) for s in splits}   # drops the minority rows

Dropping loses the minority rows; moving them to the chosen split keeps them but puts some rows in a different split from the one an earlier dataset version gave them.

Config	Split	Rows	Representatives
default	train	8,651,299	6,435,036
default	validation	91,364	68,650
default	test	87,193	64,850
unsound	train	20,885,474	12,276,825
unsound	validation	242,300	154,726
unsound	test	211,100	128,866
floodgate	train	3,076,906	1,665,735
floodgate	validation	32,550	18,088
floodgate	test	26,248	13,521

Intended uses

• Training and evaluating puzzle generators, conditioned for example on length, tesuji features, or search size (solver_nodes_proof, a measure of the solver's effort).
• Benchmarking mate solvers and the tactical reasoning of language models: give sfen, ask for the solution. An exact match with main_line only tests whether the stored line was predicted: where the defender has several main-line replies, or the final move has alternatives, other answers are equally correct, and main_line is just the one picked by the fixed rule in Glossary. To score correctness, check a predicted line with a mate solver (every attacker move must keep a forced mate of the shortest length, every defender move must be one of the main-line replies defined in Glossary (Main-line region R), and the line must end in mate after mate_ply plies).
• Negative examples for models that judge or repair diagrams: unsound (and the flawed rows of floodgate) with label, the rule columns, and the pieces left over, inert or removable.
• Studying how the source of the positions shapes the problems: floodgate positions come from games between strong engines, YaneuraOu positions from one engine's self-play, the rest from generators.
• Studying how search effort (solver_nodes within one solver_nodes_kind, solver_nodes_proof) relates to length and features. These count the solver's work, not human difficulty; see Limitations.

Limitations

• Problems are machine-generated and checked mechanically. They are not curated for artistic merit.
• solver_nodes, solver_nodes_non_futile and solver_nodes_proof measure the solver's search effort, not human difficulty. How well they track human difficulty has not been validated.
• solver_nodes mixes two counting methods (solver_nodes_kind), its kind is unknown on many unsound rows, and it is missing on much of unsound. Rows judged with a multi-threaded search (+par or +pdfpn in solve_version) can have node counts that differ from a single-threaded run. The rows will be re-solved with one solver later.
• mate_ply_with_futile is only carried over from v2 and is null on most rows.
• Rows whose minimality could not be proven without a budget-out at the largest budget tried were deleted from the catalogue before v3, so some v2 rows are not in v3 or v4.
• Rows were judged by different pipeline versions (pipeline_version); a row judged before a rule change keeps its verdict until it is judged again. Filter on pipeline_version if you need one rule set.
• n_main_paths, has_final_alt, judged_at and reduced_at are null on many rows (not filled, or not recorded before 2026-10-27).
• 1-ply problems fall into a small number of mate patterns; filter further if you need diversity there.
• Please report any problem that seems to violate rules A–G or the rules of shogi in the dataset's discussion tab on Hugging Face.

Versions

Version	Date	default rows	Representatives	unsound rows	Notes
v1	2026-10-05	1,906,299	1,449,009	–	First release, 1–11 plies. Pipeline 0.9.1, rules strict-tsume-v1: futile interpositions recognised only by a narrower test, and yozume tolerated in 9- and 11-ply problems
v2	2026-10-09	1,824,669	1,349,702	381,622	Pipeline 0.12.0, rules strict-tsume-v2: every row of 3 plies or more judged again under the classical convention for futile interpositions and with yozume forbidden at every length; the rows that failed went to the new config unsound
v3	2026-10-19	5,464,517	4,111,982	19,565,883	Pipeline 0.13.0, rules strict-tsume-v3 (rule D on the displayed main line). Every catalogue row, 1–15 plies; minimality of every default row proven with no budget-out; rule columns and label; tesuji features; prober node counts; model training data separated from origins
v4	2026-11-01	8,829,856	6,568,536	21,338,874	Pipeline 0.16.0 current (rows judged by 0.13.0–0.16.0, pipeline_version): rule D on the main-line paths, rule G with yozume-preventing pieces and every refuting reply. New config floodgate (3,135,704 rows). Columns pipeline_version, n_main_paths, has_final_alt, judged_at, reduced_at

What changed in v4, in short:

• A new config floodgate: 3,135,704 diagrams distilled from floodgate game records of 2008–2025, sound and flawed, kept apart from default and unsound (see Source attribution). default + unsound remains the catalogue without floodgate.
• Rule D on the main-line paths (pipeline 0.14.0): a removal step is accepted when the reduced problem's solution is any of the original's main-line paths, not only the displayed main_line; minimality no longer depends on the board's orientation (see Minimality).
• Rule G, yozume-preventing pieces (pipeline 0.15.0): a piece whose presence alone forbids a second mating check takes part in the solution (see Glossary, Inert piece). Diagrams that were rejected only for such a piece can be sound now.
• Rule G, every refuting reply (pipeline 0.16.0): clause (d) reads every reply that refutes a wrong check, on the tree of the proven mate length, so rule G no longer depends on the board's orientation or the search bound.
• Per-row rule versions: rows were judged by pipeline 0.13.0 to 0.16.0; pipeline_version (new) and rules_version (now per row) say which.
• New columns (5): pipeline_version, n_main_paths, has_final_alt, judged_at, reduced_at.
• More rows: the catalogue grew from 25,030,400 rows (v3) to 33,304,434: besides floodgate, new model samples, reductions and re-judged rows.
• Snapshot: v4 is one read of the catalogue database as it stood on 2026-11-01 01:22 JST (file SHA-256 9c8db70435a478f09c295a45d64929cb2493815ca4a0915e0478d552a0f49405, also in export-report.json).
• From v3 to v4 by id: every one of v3's 25,030,400 rows is still in v4 (none removed). 157,375 rows moved from default to unsound and 13,866 from unsound to default. 8,274,034 rows are new: 3,508,848 in default, 1,629,482 in unsound and the 3,135,704 of floodgate.

What changed in v3 (from v2), in short:

• Every catalogue row is published. v2 published the problems that passed the rules (default) and the rows that failed its re-judgement (unsound). v3 adds every other catalogue row: model samples and random positions that failed a rule, the originals of reduced problems, and the intermediate diagrams of reductions. unsound grew from 381,622 rows to 21,338,874.
• 13- and 15-ply problems. Filter on mate_ply <= 11 to match v1 and v2.
• Minimality of every default row is proven, not assumed (see Minimality). In unsound, rule D was checked only on some rows (is_reducible is null on the rest; see the table of rule columns in Configs).
• One column per composition rule and an exclusive label, with the pieces left over, inert or removable.
• Tesuji features of the main line.
• Prober node counts. Most rows were judged by the df-pn prober; solver_nodes_kind and solver_nodes_proof tell the counts apart.
• Model training data is not an origin. A diagram a model sampled from scratch no longer lists yaneuraou-2020 in origins; the model's training data is in training_corpus.
• Corrected YaneuraOu origin on the rl-long rows. v1 and v2 listed only the model run in origins for the rows of rl-long12 / rl-long13 (10,858 rows in v1, 10,932 in v2), although each was generated from a YaneuraOu position. v3 adds yaneuraou-2020 to them and to the rows derived from them.
• Release history: first_dealt_version, last_dealt_version.
• One schema for both configs (83 columns). v2's columns keep their names; yozume_count is widened from int8 to int16, since negatives can have hundreds of yozume turns.

Load a fixed version with revision="v4". revision="v3", "v2" and "v1" still load the earlier versions in their own layouts. id is stable across versions.

License and citation

The dataset is released under CC BY 4.0 (Creative Commons Attribution 4.0 International, https://creativecommons.org/licenses/by/4.0/). When you share the dataset or something adapted from it, the licence asks you to:

• credit the dataset, for example: "Generated Tsume-Shogi by Shinta Nakayama, https://huggingface.co/datasets/tokoroten-jp/generated-tsume-shogi, version v4";
• link the licence: https://creativecommons.org/licenses/by/4.0/;
• indicate changes, if you made any (for example: "filtered to 9-ply representatives", "re-solved with another solver").

The full terms are those at the licence link. For rows of the floodgate config, please also credit floodgate (https://wdoor.c.u-tokyo.ac.jp/shogi/) as the source of the positions (see Source attribution). For rows with yaneuraou-2020 in origins, please also keep the source attribution: やねうら王 実戦詰み局面集 (YaneuraOu practical mate positions, 2020), https://yaneuraou.yaneu.com/2020/12/25/christmas-present/. The source's statement quoted in Source attribution is a statement that copyright is not asserted, not a licence; it says nothing about attribution or derived works, so if you need certainty about the source material, read the source page itself.

For academic use, please cite:

@misc{nakayama2026generatedtsume,
  author       = {Nakayama, Shinta},
  title        = {Generated Tsume-Shogi: machine-generated, solver-verified tsume-shogi problems and flawed diagrams},
  year         = {2026},
  version      = {v4},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/tokoroten-jp/generated-tsume-shogi}}
}