Exxe/crossword-construction-logic

Dataset Card for Crossword Construction Logic (SFT, five languages)

Dataset Description

Dataset Summary

420 supervised rows that teach the construction logic of crossword puzzles: how a grid's numbering works, what a crossing contract is, why candidate counts collapse (MRV + constraint propagation), why entries nobody explicitly filled ("shadow" entries) still must be verified, why duplicate words are absolutely forbidden, which rules are hard constraints and which are declared conventions, how to diagnose a broken fill, and how to write a verification report that a machine can re-run.

The rows are built on machine-verified mini grids (2×2 through 7×7): every catalog grid, every solver trace, every candidate count, every "impossibility proof" (node-exhaustion counts), and every machine verdict on broken exhibits in this dataset was computed by the project's grid/solver library and re-asserted when the dataset was built. No narrated number was typed from memory.

The dataset is multilingual in a strict sense: 228 rows are in English (the teaching backbone, including cryptic-clue rows), and there are 48 rows each in Russian, Chinese (simplified), Hindi, and Japanese — not translations of the English rows, but native-narrated modules that run the same machinery over each language's own script unit (letter, character, akshar, mora) and its own verified catalog grids.

Why AI fails at crosswords

Crosswords are a known hard spot for language models, and the literature explains why with unusual precision:

• Local clue competence is necessary but not sufficient. On the New York Times corpus (9,152 puzzles; 578k clue–answer pairs), Kulshreshtha et al. (2022, Down and Across) show that strong clue recall does not convert into fills: their RAG-wiki baseline reached 46.8% top-10 exact match on clues, yet the fully-constrained puzzle solver achieved only 23.8% word accuracy and 37.8% character accuracy at the grid level. The grid's crossing constraints — the subject of half of this dataset — are exactly the missing half of that skill.
• Letter hints fix what models lack. Saha et al. (2024, Language Models are Crossword Solvers) report that GPT-4 Turbo jumps from 18.7% to 76.3% on cryptic clue splits when given 70% letter hints, and their SweepClip pipeline reaches 48% fully-correct Monday NYT puzzles. The models can use letter constraints when handed them; producing and checking those constraints themselves is the gap this dataset trains.
• Sub-token counting is a documented failure mode. The same literature notes LLMs fail at letter-level operations (counting, alignment) even when their rationales sound correct. This dataset drills exactly that: cell-level counting in five scripts, including scripts (Devanagari, kana) where codepoint counting is systematically wrong.
• Benchmarks exist; construction curricula don't. CrossWordBench and Cryptonite (Efrat et al. 2021) measure solving; this dataset teaches the complementary skill — constructing and verifying — which forces the model to produce the constraints itself rather than consume them. Cryptonite's famous split lesson (56.16% on a random split collapses to 7.64% on an answer-held-out split) is why this dataset's claims are machine re-derivable instead of memorized: every number a row asserts is recomputed by code at build time.
• Construction is already formalized in the literature. Dr.Fill (Ginsberg
  2014. treats American crosswords as singly-weighted CSPs; the Berkeley Crossword Solver (Wallace et al. 2022) solves them with belief propagation at 81.7% perfect-puzzle accuracy on 2021 NYT; Majima et al. (2023) generate news-centric puzzles as constraint satisfaction and optimization; Coté et al. (2021) model grid designs as bipartite multigraphs; and multilingual systems (WebCrow-French, Angelini et al. 2023; ArabIcros, Zeinalipour et al. 2023) show the genre's adaptation mechanics across scripts. This dataset turns those formalisms into supervised lessons at a scale where every step is human-checkable and machine-checked.

Supported Tasks

• SFT for grid reasoning / constrained generation — the primary use: instruction-following rows that model must answer with re-derivable reasoning (fill a grid, read a trace, diagnose a broken fill, audit a verification report).
• Critic / judge training — the 55 flawed/bad rows exhibit specific construction failure families (wrong-character cells, duplicate cascades, script/layer confusions, phantom verification reports) with machine verdicts.
• Cross-lingual transfer studies — the identical task taxonomy over five scripts and four cell-units (letter / character / akshar / mora) supports controlled comparison of where models break by script.
• Evaluation probes — the verified=yes rows with embedded masks and machine stamps can be used as checkable reasoning items.

Languages

en (228), ru (48), zh (48, simplified), hi (48, Devanagari), ja (48). Rows in each language are native-narrated (not translations); technical tokens (entry keys like 1A/3D, block headers like MASK:/FILL:, machine stamps like words: 6, blocks: 2, unchecked squares: none) are deliberately kept in the same small Latin vocabulary across languages so the dataset's machinery is script-portable.

The Five-Language Controlled Experiment

The four non-English modules are a controlled experiment: the invariants (numbering rule, crossing contract, duplicate ban, MRV search, shadow-entry verification, re-derivation discipline) are the same implementation in all five languages; the single variable is the cell unit:

Language	Cell unit	Unit facts the rows teach	Catalog grid
en / ru	letter	1 cell = 1 codepoint; 3-letter minimum conventions	EN 5×5s, RU 4×4
zh	character	1 cell = 1 hanzi = 1 codepoint; 2-character default; idiom chains (92 single-cell idiom crossings; 0 parallel idiom lattices — brute-forced)	ZH 2×2 lattices (3 word-sets, 6 fills)
hi	akshar (syllable)	matras and conjuncts fold into one cell; nukta is a distinct cell (23/23 nukta-drops detectable); codepoint counting fails by up to 3×	HI 3×3 (4 legal fills, 2 orientations × 2 letters)
ja	mora	yōon/sokuon merge into the previous cell, chōonpu occupies its own; ン never starts a word; katakana-only contract	JA 3×3 (2 legal fills); 2×2 census: 113 ordered pairs, 111 cyclic duplicates, 1 real lattice

Findings the experiment bakes into the rows (each machine-verified):

• failure families are script-independent (shadow completions producing non-words, script-variant confusions, transliteration-layer mistakes recur in all five languages);
• a mask's fillability is a property of the mask and the dictionary (the identical 3×3 mask fills in Japanese and Hindi and provably cannot fill in Chinese — 4-node exhaustion — because the Chinese pool holds only two 3-character words);
• impossibility is a deliverable result (full-open 3×3 exhaustion: RU 38 nodes, HI 73, JA 209, ZH 3).

Dataset Structure

Data Instances

Each row is a self-contained lesson:

{
  "instruction": "Below is a verified 3×3 grid from the catalog...",
  "input": "MASK:\n..#\n...\n#..\n\nFILL:\nアサ#\nワカメ\n#ナシ\n\nmachine stats: words: 6, blocks: 2, ...",
  "output": "Layer by layer. The mask first: ...",
  "task_type": "design_grid",
  "language": "ja",
  "quality": "good",
  "puzzle_style": "mini",
  "grid_size": "3x3",
  "difficulty": "beginner",
  "source_format": "original",
  "verified": "yes",
  "id": "cw_337"
}

Data Fields

field	values	notes
instruction	free text (row language)	the task
input	free text + artifact blocks	masks (MASK:), fills (FILL:), traces, machine stamps
output	free text (row language)	the model answer: layered reasoning essays
task_type	9 values	see task types
language	en, ru, zh, hi, ja	narration language
quality	good, flawed, bad	see quality axis
puzzle_style	mini, daily, cryptic, japanese, general	stylistic framing
grid_size	2x2, 3x3, 4x4, 5x5, 5x7, 7x7, 9x9, 11x11, 15x15, 21x21, na	subject grid size; na = no embedded subject grid
difficulty	beginner, intermediate, advanced, expert, na
source_format	crosshare, nyt-specs, xword-info, cryptic-guide, japanese-convention, original, historical	which convention the row documents
verified	yes, no	yes = machine-checkable claims in this row are backed by build-time asserts
id	cw_001 … cw_420	sequential, module order

Data Splits

Seed-42 shuffle, 85/15: train 357 (4 parquet shards), test 63 (1 shard). create_dataset.py regenerates the identical shards from raw.jsonl.

The Task Types

task_type	rows	what the model must do
design_grid	54	explain/derive grid anatomy: numbering, symmetry, black-cell pairs, length economics, seed-unit economics
fill_grid	56	complete a grid (or a seed) using candidate arithmetic: cohort lookups, MRV choices, forced cascades, death ledgers
fill_trace	40	read and audit solver traces: candidate collapses, propagation effects, shadow completions; catch hallucinated traces
diagnose_failure	50	find what broke in a presented fill and why (locality, duplicate cascades, script confusions, transliteration layers)
write_clues	60	write clue sets with the substitution test, polysemy ladders, enumeration in the correct unit (characters/akshar/morae, not codepoints)
cryptic_clue	28	(en) cryptic clue anatomy: definition/wordplay split, indicators, fair deletions — with the discipline that every clue is constructed, not recalled
validate_puzzle	40	write and audit verification reports; catch phantom reports; declare conventions
methodology_qa	85	the meta-lessons: MRV rationale, double/position indexing, duplicate absolutism, re-derivation mantra, declared parameters, census discipline, CSP formalization, LLM failure modes, boundary laws
historical_note	7	conservative genre history per language (public-domain facts only)

The Verification Discipline

What is machine-checked

Every verified=yes row's checkable claims are backed by the build pipeline, in three layers:

1. Catalog layer. Every grid the dataset embeds is a catalog puzzle: at import time, each fill re-validates via the grid library (pool membership, crossing agreement cell-by-cell, duplicates, minimum length, no unchecked cells). If any fill ever stops validating, the build fails loudly.
2. Trace layer. Every narrated solver number — candidate counts, node ledgers, forced-cascade effects, shadow completions, exhaustion proofs (e.g., "the full-open 3×3 dies in 209 nodes", "seed 員工 dies in 1 node", "दीवार is the only वा-middle word and the search already consumed it") — comes from the actual MRV solver and is re-asserted with exact values on every import of the row modules.
3. Artifact layer. Machine verdicts on broken exhibits (the exact unknown_words / duplicate_words dicts the rows quote) are computed by check_fill and asserted as literals.

A dataset-level battery additionally re-verifies the assembled raw.jsonl: it re-imports all 14 generator modules (re-running every assert), re-verifies the catalog, checks the JSONL is a faithful field-by-field export of the modules, and re-runs claim/purity/scaffold/ grid-size checks and distribution quotas on the artifact itself.

This design answers Cryptonite's memorization critique at the curriculum level: the dataset does not ask the model to trust testimony — every row demonstrates the habit of re-deriving from the artifact.

The quality axis (good / flawed / bad)

quality describes the primary artifact a row presents:

• good (365) — the row's exhibit is a verified grid/trace/report, or a clearly-labeled counterexample drill.
• flawed (33) — the row presents a recoverable defect (one wrong cell, a dropped nukta, a dragged matra, a misquoted idiom, a misaligned fill) and performs the diagnosis and repair.
• bad (22) — the row presents a fabricated artifact or a phantom verification report (hallucinated grids, traditional-form substitutions, invented words, reports whose claims don't match the attached grid) and performs the forensic audit. These rows are critic-training material.

Dataset Creation

Curation rationale

• Mini scale on purpose. Every grid is small enough that a human can verify every step by hand, and the machine does verify every step. The dataset teaches transferable logic, not trivia.
• Data-first authoring. Empirical numbers were probed before prose: during authoring, the writers' own narrative claims were contradicted by import-time asserts multiple times per module and corrected to machine truth each time (the worklog records the incidents). Rows in methodology_qa explicitly teach this workflow ("write the assert block first, then the prose").
• Conventions are declared, not assumed. Minimum length (2 vs 3), duplicate rules, script contracts (katakana-only, simplified-hanzi pool, nukta-as-cell) are presented as declared parameters — the dataset's rows model the discipline of stating which contract is in force before judging a grid.
• Crosswise source. The construction semantics (entry-start rule, numbering, unchecked-cell definition, autofill candidate behavior) were cross-checked against the Crosshare app's grid base (app/lib/gridBase.ts, AGPL-3.0) and re-implemented independently in this project; no Crosshare code is included. Puzzle-style conventions are documented in rows tagged source_format: nyt-specs / xword-info / cryptic-guide / japanese-convention from public domain knowledge.

Source data and the catalog

The verified catalog at the heart of the dataset:

id	language	size	blocks	entries	notes
en_pinwheel / en_corners / en_two	en	5×5	4/4/2	10 each	three verified 5×5 fills
en 7×7 mask	en	7×7	—	—	design-grid subject (symmetry/slots)
ru_4x4	ru	4×4	2	8	ЛУК/ДЕЛО/АТОМ/РОВ grid
zh_a / zh_b	zh	2×2	0	4 each	character lattices; plus a third lattice (人生/大学/大人/学生) verified in-row
hi_3x3 / hi_3x3_b	hi	3×3	2	6	बल/सड़क/काल and the ब→न variant; two more orientations verified in-row
ja_3x3	ja	3×3	2	6	アサ/ワカメ/ナシ with サカナ crossing ワカメ at カ

Word pools are deliberately toy-scale (55–472 words per language), all ordinary vocabulary or famous idioms — facts of language, free of any third-party word-list copyright.

Who are the source language producers

Rows were written by GLM (the Z.ai model, "Super Z") in this project, under the project lead's editorial direction, with the generator library (grids.py, solver.py, puzzles.py, wordlists.py, check_claims.py, and the fourteen rows_*.py modules) serving as the machine co-author. Human language review pass: the native-language modules were checked for script purity (each module's rows must be dominant in its own script) and for scaffolding contamination.

Personal and sensitive information

None. All grids, word pools, and traces are synthetic or ordinary vocabulary; no personal data appears.

Limitations

• Toy scale by design. The word pools and grids are pedagogical, not publishable puzzles. The dataset teaches verification-grade reasoning, not crossword trivia breadth.
• Node counts and census numbers are pool-relative truths. E.g., "the fully-open 3×3 is impossible in 209 nodes" is a statement about this 212-word Japanese pool. Rows state this relativity explicitly, and the limitation is itself a taught principle (census discipline).
• Cryptic rows are English-only (28 rows); the four other languages receive definition-style clue conventions matching their real puzzle traditions.
• Machine stamps are Latin. words: 6, blocks: 2, unchecked squares: none crosses scripts deliberately; this is a feature (a portable verification vocabulary), but consumers wanting fully-native text in every field should be aware.
• The verified flag is a build-time claim, not a runtime contract of the released JSON alone: reproducing it requires the generator modules (the provenance pipeline), which this package's create_dataset.py header documents.

Licensing and citation

Released under CC0 1.0 (see LICENSE). The dataset was produced by the Z.ai project workspace as part of a dataset-production engagement, 2026. If you use it, the spirit of the license asks only that you keep the verification discipline alive: re-derive, don't recite.

Key literature the dataset's framing draws on: Kulshreshtha et al. 2022 (Down and Across: Introducing Crossword-Solving as a New NLP Benchmark), Efrat et al. 2021 (Cryptonite), Saha et al. 2024 (Language Models are Crossword Solvers), Wallace et al. 2022 (Automated Crossword Solving), Ginsberg 2014 (Dr.Fill), Majima et al. 2023 (news-centric crossword generation as CSOP), Coté et al. 2021 (crossword grid multigraphs), Angelini et al. 2023 (WebCrow French), Zeinalipour et al. 2023 (ArabIcros), and the CrossWordBench evaluation. Crossword-app semantics cross-checked against Crosshare's grid base (AGPL-3.0; studied, not copied).