riddickz/llada-sudoku-violation-pairs-50k-v1

LLaDA Sudoku Violation Pairs (50k v1)

SFT pairs for training a diffusion language model (LLaDA-8B-Instruct) to diagnose constraint violations and emit a corrected solution in a single response — the "diagnose + correct in one shot" objective.

Each row is a (prompt, response, meta) triple where:

• prompt is the LLaDA-native chat-template prefix containing the sudoku puzzle and the model's wrong answer (one full assistant turn already written), with a fresh assistant header opened
• response is the natural-language list of oracle constraint violations on the wrong answer, followed by the ground-truth answer inside <answer>...</answer> tags

Data generation

50,000 4×4 sudoku puzzles from the d1 train split were each run through a 5-turn multi-turn correction loop using LLaDA-8B-Instruct with a per-layer router stack (RYS):

Setting	Value
Model	GSAI-ML/LLaDA-8B-Instruct
Sudoku size	4×4
Generation length	32 tokens
Diffusion steps	32
Block length	32
Max turns	5
RYS mode	per_layer_router, layers [10, 18), k=1, init_bias=−4.0 (uniform 0.018 gate)
Feedback	natural-language bullet list of oracle constraint violations
Stop condition	no_progress (violation count fails to strictly decrease for 2 turns) OR T=5
History mode	last_only (only the most recent turn's response is in context)

Per-puzzle records were collected on 2× 8-H200 boxes in parallel (subsamples [0, 25k) and [25k, 50k)).

Aggregate generation outcomes (50k puzzles):

• Final accuracy: 62.76% (31381 solved)
• Per-turn cumulative: 55.97% → 62.49% → 62.75% → 62.76% → 62.76%
• Termination: solved 62.76% / no_progress 34.95% / budget_exhausted 2.29%
• Mean turns to convergence: 1.11

For every puzzle and every wrong-answer turn (turns where the model failed), one (puzzle, wrong_answer, oracle_violations) pair is extracted. Pairs are deduplicated on (puzzle, wrong_answer_dense) — turns within a puzzle that emit byte-identical responses contribute only one pair.

	h106 [0, 25k)	h107 [25k, 50k)	total
Raw wrong-answer turns	24656	34319	58975
Unique pairs after dedup	10761	14418	25179

Schema

{
  "prompt": "<|startoftext|><|start_header_id|>user<|end_header_id|>\n\n{puzzle question}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n<answer>\n{wrong_answer_dense}\n</answer><|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n",
  "response": "Your solution has 3 constraint violation(s):\n- Row 2 contains 4 more than once (columns 1, 3).\n- ...\n\nHere is the corrected solution:\n<answer>\n{ground_truth}\n</answer>",
  "meta": {
    "n_violations": 3,
    "violation_kinds": ["row", "row", "given"],
    "turn": 1,
    "ground_truth": "1234\n3412\n2143\n4321",
    "wrong_answer_dense": "1234\n3412\n2443\n4321"
  }
}

The prompt ends with a second open assistant header — the response slot is the second consecutive assistant turn, where the violation diagnosis and corrected answer are emitted. This keeps the wrong attempt visible to the model as fixed context (frozen, never masked during MDLM training).

Wrong answers are rendered in dense format (no spaces between digits). Ground-truth answers are rendered the same way, separated by newlines between rows.

Why "diagnose + correct" (the v1 fix)

A previous v0 dataset (4446 pairs) trained the model to emit only a violation list as response. Result: 78% violation-cell-F1 on a held-out val set, but 0% answer-generation accuracy on the original task — catastrophic forgetting of the answer-generation behaviour. The v1 format keeps the corrective behaviour in the same response slot, so a single SFT objective trains both the diagnostic and the correction without erasing the underlying generation distribution.

Intended use

• SFT a base diffusion language model (LLaDA-style) on the masked diffusion ELBO with response tokens as the target. The prompt is fixed context (never masked).
• Evaluate the SFT'd model on multi-turn sudoku correction; compare turn-2 accuracy against the un-SFT'd 62.49% baseline reported here.

This dataset is single-task / domain-specific (4×4 sudoku constraint repair). It is not intended as a general-purpose instruction-tuning corpus.

Limitations

• 4×4 only. 9×9 generation accuracy with the same base model is 0%, so multi-turn data of this form cannot be bootstrapped at 9×9.
• Difficulty distribution differs across the two parallel-collection shards — h106 [0, 25k) puzzles solve at 68.4% on turn-1, h107 [25k, 50k) at 50.8%. Reflect this when interpreting per-pair difficulty signals.
• 34.95% of puzzles terminate via no_progress; the wrong-answer turns from those puzzles include drift / oscillation patterns that may be a feature (more diverse failure modes) or a noise source for SFT.

Citation / source code

Code: [LLaDA d1 fork] — see eval/utils/build_sft_violation_data.py for the builder and eval/generation/eval_sudoku_multiturn.py for the multi-turn generation runner.