VLR-Recurrence-Verified

Verification-grounded synthetic data for iterative code repair, preference fine-tuning, and regression-aware model behavior.

VLR-Recurrence-Verified is a training-first code dataset built around iterative program revision. Each example starts from an existing implementation and structured verification feedback, then represents one or more candidate revisions whose outcomes were checked deterministically during dataset construction.

The dataset is released as a standalone public resource. It does not assume a particular model architecture, training framework, inference controller, or proprietary method. It is intended for standard supervised fine-tuning, parameter-efficient fine-tuning, preference optimization, reward/ranking model training, and controlled research on iterative code repair.

Meaning of “Verified”. In this dataset name, Verified means that candidate outcomes and labels were derived from deterministic requirement-level checks during data construction. It does not imply third-party certification of the dataset or of models trained on it.

Why this dataset exists

A recurring failure mode in code-model fine-tuning is partial improvement with collateral regression: a revision fixes one failing behavior but breaks behavior that was already correct.

Final-answer-only SFT does not directly expose the distinction between:

• a revision that makes measurable progress;
• a revision that changes nothing relevant;
• a revision that regresses previously satisfied behavior;
• a trade-off revision that improves some requirements while worsening others;
• a revision that reaches a fully verified solution.

VLR-Recurrence-Verified makes these outcomes explicit at the data level. This enables models to learn not only what a corrected program looks like, but also which next revision is preferable given the current program and verification feedback.

What fine-tuning on this dataset is intended to improve

The dataset targets the following model behaviors:

1. Feedback-conditioned repair — use structured verification feedback to produce a better next implementation instead of restarting from the original task.
2. Regression-aware revision — preserve already-correct behavior while addressing remaining failures.
3. Candidate discrimination — rank a verified improvement above no-progress, regressive, or trade-off candidates from the same current state.
4. Iterative repair continuity — continue improving through intermediate states rather than learning only one-shot final answers.
5. Verified completion behavior — learn final-step corrections that satisfy all tracked requirements.
6. Termination recognition — optionally learn that a fully satisfied state requires no further repair.
7. Family-level transfer — test whether the learned behavior transfers to held-out semantic families.

These are behavioral training objectives, not runtime guarantees. Fine-tuning on this dataset may improve the probability of proposing better repairs; it does not by itself prove that a model will always avoid regressions, always terminate correctly, or generalize to arbitrary real-world repositories.

Dataset at a glance

Property	Value
Unique tasks	400
Semantic families	10
Train/validation families	8
Test-only family-OOD families	2
Primary tuples	1,289
Balanced preference pairs	4,447
Exhaustive preference pairs	5,760
Accepted-action targets	1,289
Fully verified generation targets	400
Recursive trajectories	400
Terminal STOP auxiliary records	400
Trajectory depth	2–5 repair steps
Verification-vector arity	12 / 15 / 18
JSONL files	21
Total rows across all released views	13,985

Important: the 13,985 rows are not 13,985 independent tasks. Multiple files are intentionally synchronized training views derived from the same underlying repair states. Do not concatenate all views blindly.

Splits

View	Train	Validation	Test	Total
Primary tuples	930	108	251	1,289
Balanced preference pairs	3,205	372	870	4,447
Exhaustive preference pairs	4,144	481	1,135	5,760
Accepted action	930	108	251	1,289
Fully verified generation	286	34	80	400
Recursive trajectory	286	34	80	400
Terminal STOP auxiliary	286	34	80	400

Semantic-family split

Train + validation

• piecewise_bias
• residue_bias
• quadratic_residue
• mod_product
• xor_mask
• fsm_delta
• lookup_delta
• signed_bucket

Test only (family-level OOD)

• parity_grid
• bit_rotate

If family-OOD results are reported, the test split must not be used for training, preference mining, hyperparameter selection, or prompt tuning.

Dataset configurations

The release exposes seven complementary configurations. They are alternative or deliberately combined objectives, not seven independent datasets that should automatically be concatenated.

primary-tuples

Files: data/primary_tuples_{train,validation,test}.jsonl

Each record joins the current repair context with one verified positive candidate and one verified negative candidate.

Best for: custom multi-objective fine-tuning, controlled ablations, and research trainers.

preference-balanced

Files: data/preference_pairs_balanced_{train,validation,test}.jsonl

Same-context chosen/rejected pairs with a balanced mixture of negative outcomes.

Recommended default for: DPO-style objectives, IPO, SimPO-style objectives, ORPO-style objectives, pairwise reward modeling, and ranking-model training.

preference-exhaustive

Files: data/preference_pairs_exhaustive_{train,validation,test}.jsonl

All released same-context positive/negative combinations.

Best for: ablations, ranking analysis, calibration, negative-mining studies, and controlled hard-negative experiments.

Because states with more available negatives contribute more pairs, this view should normally be re-weighted before being used as the default training mixture.

accepted-action

Files: data/accepted_action_{train,validation,test}.jsonl

Supervised next-revision examples containing a repair context and the verified next complete implementation.

Recommended for: SFT, LoRA, DoRA, QLoRA, and auxiliary next-action training.

certified-generation

Files: data/certified_generation_{train,validation,test}.jsonl

A strict subset whose target resolves all tracked requirements for the task.

Recommended for: final-step SFT and controlled completion-focused auxiliary training.

Because this view overlaps with accepted-action examples and contains only 400 records, it should normally be used with deliberate weighting.

recursive-trajectory

Files: data/recursive_trajectory_{train,validation,test}.jsonl

Complete accepted repair trajectories with 2–5 steps.

Recommended for: curriculum learning, trajectory-aware SFT, step-wise conditioning, and iterative-repair policy research.

For ordinary one-turn SFT, prefer accepted-action rather than flattening trajectories without a weighting policy.

terminal-stop-auxiliary

Files: data/terminal_stop_auxiliary_{train,validation,test}.jsonl

Auxiliary terminal-state examples with target STOP.

Recommended only for: explicit termination-policy experiments.

Do not include this view in ordinary language-model loss by default. Predicting STOP is not, by itself, evidence of correctness.

Recommended fine-tuning recipes

Default research recipe: PEFT + balanced preference learning

For most code-capable decoder-only language models:

• Parameterization: LoRA or DoRA; QLoRA when memory is constrained.
• Preference objective: preference-balanced.
• Positive-generation auxiliary: accepted-action.
• Optional final-step auxiliary: certified-generation at controlled weight.
• Validation: matching validation views.
• Final family-OOD evaluation: test split only.

This setup trains both candidate selection and candidate generation without requiring full-parameter updates.

SFT-only baseline

Use accepted-action as the primary training set.

This is the cleanest baseline for measuring whether preference information adds value beyond ordinary supervised next-repair training.

Preference-only baseline

Use preference-balanced with a pairwise objective.

This isolates ranking behavior from explicit next-target SFT.

Full-parameter fine-tuning

Supported, but not the recommended first-line use of this release. The dataset is deliberately narrow and behavior-focused; PEFT generally provides a cleaner and more economical first test of whether the targeted behavior can be added to a capable base model.

Reward/ranking model training

Use preference-balanced for balanced training and preference-exhaustive for analysis or carefully re-weighted hard-negative training.

On-policy RL

This dataset is not an online interaction environment. It may initialize a policy, scorer, or preference model, but PPO/GRPO-style online optimization requires a separate generation-and-evaluation loop.

Recommended field mapping

Preference optimization

For preference files:

prompt = row["prompt_messages"]
chosen = row["chosen"]["text"]
rejected = row["rejected"]["text"]

For primary tuples:

prompt = row["prompt_messages"]
chosen = row["accepted"]["text"]
rejected = row["rejected"]["text"]

Supervised fine-tuning

For accepted-action and certified-generation views:

prompt = row["prompt_messages"]
target = row["target"]

IDs, digests, verification vectors, and other audit fields should not be treated as natural-language target tokens unless this is an explicit research objective.

Loading with 🤗 Datasets

from datasets import load_dataset

repo_id = "tsinghua-sigs-robot-lab/VLR-Recurrence-Verified"

prefs = load_dataset(repo_id, "preference-balanced")
actions = load_dataset(repo_id, "accepted-action")
trajectories = load_dataset(repo_id, "recursive-trajectory")

Individual files can also be loaded directly:

from datasets import load_dataset

prefs = load_dataset(
    "json",
    data_files={
        "train": "data/preference_pairs_balanced_train.jsonl",
        "validation": "data/preference_pairs_balanced_validation.jsonl",
        "test": "data/preference_pairs_balanced_test.jsonl",
    },
)

Record semantics

Prompt context

prompt_messages contains a chat-style repair context built from:

• the task instruction;
• visible input/output examples;
• the current implementation;
• sanitized verification feedback;
• a request for the next complete implementation.

Positive candidates

Positive candidates are complete revisions that improve the checked repair state without invalidating already-satisfied tracked requirements. Some are intermediate repairs; others are fully verified solutions.

Negative candidates

Negative examples represent qualitatively different failure modes, including:

• no-progress candidates;
• regressive candidates;
• trade-off candidates that improve some requirements while worsening others;
• hard negatives that may appear better under a coarse aggregate signal while still introducing a regression.

These distinctions support controlled preference training and error analysis.

Verification vectors

Aligned verification-vector fields record per-requirement outcomes for auditing, filtering, metrics, and custom objectives. Generic SFT and DPO pipelines do not need to expose these fields to the language model.

Evaluation protocol

Report behavior-level metrics separately rather than collapsing them into one aggregate score.

1. Non-regressive improvement rate — fraction of generated revisions that resolve at least one previously failing requirement while preserving previously satisfied requirements.
2. Regression rate — fraction of generated revisions that break at least one previously satisfied requirement.
3. Pairwise preference accuracy — fraction of held-out same-context pairs for which the positive revision is ranked above the negative revision.
4. Fully verified completion rate — fraction of repair contexts for which the generated revision satisfies all tracked requirements.
5. Family-OOD transfer — report the above metrics separately on parity_grid and bit_rotate.
6. Multi-step repair efficiency — for iterative systems, report steps-to-completion together with failure-to-complete and regression rates.

Data integrity and leakage controls

The released views retain identifiers and audit information that support reproducible grouping and leakage checks:

• stable sample identifiers and record digests;
• same-context construction for preference pairs;
• task and trajectory identifiers for grouping;
• explicit train/validation/test labels;
• test-only semantic-family isolation;
• sanitized model-facing verification feedback;
• separate terminal-state examples;
• separate derived views rather than silently duplicated training mixtures.

Researchers should preserve task-level grouping when creating additional subsplits.

Intended uses

VLR-Recurrence-Verified is suitable for research on:

• parameter-efficient code-model fine-tuning;
• supervised iterative code repair;
• verifier-feedback conditioning;
• regression-aware code revision;
• pairwise preference optimization;
• reward/ranking model training;
• hard-negative learning;
• multi-step repair curricula;
• termination-policy modeling;
• family-level OOD generalization;
• controlled comparisons between SFT and preference-based training.

Limitations and unsupported claims

This dataset should not be used by itself to claim:

• guaranteed correctness of model outputs;
• guaranteed monotonic improvement during inference;
• repository-scale software-engineering competence;
• improved SWE-bench or other external benchmark scores without direct evaluation;
• universal reasoning improvement outside the represented repair setting;
• third-party certification;
• production-safety or reliability guarantees.

The tasks are compact synthetic Python repair problems constructed to isolate iterative repair behavior. Downstream gains remain an empirical property of the base model, training objective, trainable capacity, optimization setup, and evaluation protocol.

Reproducibility recommendations

When publishing results with this dataset, report at minimum:

• base model and exact revision;
• tokenizer and chat-template revision;
• trainable parameterization;
• dataset configuration(s) used;
• weighting when multiple overlapping views are combined;
• optimizer, learning rate, batch size, gradient accumulation, updates/epochs, and random seed;
• evaluation decoding settings;
• confirmation of train/validation/test separation;
• per-family test metrics for parity_grid and bit_rotate;
• an ordinary SFT baseline when claiming benefits from preference learning.

For causal comparisons between training objectives, keep base initialization, training budget, trainable capacity, and evaluation prompts matched.

License

Released under the Apache License 2.0.

Users are responsible for ensuring that their chosen base model, training stack, and redistributed downstream checkpoints comply with their respective licenses.

Citation

@dataset{vlr_recurrence_verified_2026,
  title     = {VLR-Recurrence-Verified},
  year      = {2026},
  publisher = {Hugging Face}
}