FaithOR-Supervision

Component-level supervision for checking whether a mathematical optimization model is faithful to the natural-language problem it was written for. Each example pairs a problem statement, a numbered candidate formulation and its solver feedback with a diagnosis: which components are wrong, what kind of error each one is, and whether a required constraint is missing.

• Paper: coming soon (arXiv)
• Detector trained on this data: FaithOR-Detector-4B
• Code (data construction, training, inference, evaluation): github.com/QMJWang/FaithOR

Upstream problem text is not redistributed

The rows derived from OptMATH-Train and ReSocratic-29k keep everything we produced (the candidate formulation, solver feedback, numbered prompt, diagnosis and labels) but not the problem statement, whose redistribution terms are not stated by the upstream releases. In those rows the question field and the problem section of prompt contain a placeholder [[UPSTREAM:<dataset>:<sha256>]], and an upstream field records which upstream record it came from (sha256 of that record's raw text). Simulated rows (procedural/*) are complete as published.

To restore the full files, download the two upstream datasets yourself (their terms apply) and run the bundled script; it rebuilds every file and verifies it against data/REHYDRATED_SHA256SUMS, so the result is byte-identical to what the detector was trained on:

python scripts/rehydrate.py --optmath /path/to/OptMATH-Train.jsonl \
  --resocratic /path/to/resocratic-29k.json --data-dir data --out-dir data_rehydrated

--optmath takes the JSONL export of Aurora-Gem/OptMATH-Train (or a save_to_disk directory); --resocratic takes the ReSocratic-29k JSON list from yangzhch6/ReSocratic. Row counts below refer to the restored files; the published files have the same rows with placeholders.

What is in the dataset

Configuration	Split	Rows	Use
sft	train	24,619	supervised fine-tuning targets
sft	validation	1,283	development metrics
sft	holdout	880	development metrics (disjoint questions)
stages	stage1	16,939	the optmath + resocratic rows of sft train, as used for stage 1 of the released detector
stages	stage2	9,189	the 13 simulated families followed by the 1,509 replay rows, in the order used for stage 2
grpo	train	3,706	prompts plus gold labels for a rule-based reward
grpo	validation	294	reward-model validation

The SFT training rows come from three kinds of sources:

Source	Rows	How the rows were made
optmath	16,260	formulations written by local LLM writers for OptMATH-Train problems, labelled by execution-checked perturbation and counterfactual localization
resocratic	679	the same construction on ReSocratic-29k problems
procedural/* (13 families)	7,680	programmatically simulated problems whose semantic contract, correct model and error variants are all generated together

1,509 of the optmath/resocratic rows carry replay: true. They are formulations produced by the same Qwen3.6 writer that the detector later works with, kept so that training sees the writer's real output distribution. The stages configuration repackages the sft train rows into the two files the released detector was trained on (no new rows; stage1 ∪ stage2 = train), so the two-stage recipe in the code repository can be run without any filtering.

Every family is balanced between correct models (empty diagnosis) and models with exactly the labelled defect. The simulated families and the error types they teach:

Family	Train rows	Error types in the positive rows
implicit_domain	2,800	var_to_int, var_to_cont
full_partial	480	var_to_int, var_to_cont
mixed_domains	320	var_to_int, var_to_cont
objective_protection	320	obj_sense, var_to_int
ratio_contract	480	con_sense
bounds_scope	480	con_sense, con_structure
share_equivalence	320	con_sense, con_structure
resource_localization	320	con_sense, num_value
dependent_coefficients	320	num_value
role_binding	480	num_value, obj_expr
evidence_profit	480	obj_expr
scope_cost	400	con_structure, obj_expr
prerequisites	480	con_structure, missing

The GRPO training file holds 3,706 prompts over writer-generated formulations: 1,856 correct models, 928 counterfactual-localized errors and 922 controlled perturbations. Labels live in the reward metadata and are never part of the prompt.

Fields

SFT rows (JSONL): id, question_id, source, family, replay, question, prompt, comp_ids, target, errors, missing, plus upstream (dataset, sha256) on rows whose problem text must be restored. prompt is the full detector input (problem, solver result, numbered model, task instruction); target is the expected response, a one-line check followed by the JSON diagnosis; errors/missing repeat the diagnosis as structured fields. GRPO rows (Parquet): data_source, prompt (chat format), ability, reward_model, extra_info (gold component labels for the reward), upstream (JSON string, same meaning as above).

A diagnosis looks like this:

{"errors": [{"id": "V1", "type": "var_to_int"}], "missing": false}

Component IDs follow the numbered model (S sets, P parameters, V variables, O1 objective, C constraints). The ten error types:

Type	Meaning	Type	Meaning
var_to_int	variable should be integer	var_to_bin	variable should be binary
var_to_cont	variable should be continuous	var_bound	wrong variable bound
con_sense	wrong inequality direction / equality	num_value	wrong number or coefficient
con_structure	wrong constraint expression, index or scope	con_extra	constraint should not exist
obj_sense	wrong min/max	obj_expr	wrong objective expression

missing: true marks a required constraint that is absent from the model; it is a separate flag because an absent component has no ID.

How the data was built

Two complementary routes feed the same diagnosis protocol.

Route 1: real candidate formulations with execution-checked labels. Problems come from filtered subsets of OptMATH-Train and ReSocratic-29k. Local writers (Qwen3.5-122B-A10B and Qwen3.6-35B-A3B) draft mathematical models; each draft is translated to code, solved, and compared with the problem's reference value, which is used offline for labelling only.

• Correct negatives: drafts whose solved objective matches the reference are kept as clean examples, so that the detector learns not to flag valid models.
• Controlled perturbations: a single component of a correct draft is edited (domain, number, unit, index, inequality direction, coefficient, right-hand side, dropped constraint, objective sense or expression). The edit record gives the label; the perturbed model is re-solved so that only edits with an observable effect are accepted.
• Counterfactual localization: a correct and a failing draft of the same problem are aligned; proposed component replacements are applied one at a time and re-solved. A replacement that restores the reference value gives an execution-supported location for the error. Cases that cannot be localized this way are not given component labels.

Numerical agreement is evidence, not proof of semantic equivalence; the labels inherit that limit.

Route 2: programmatic simulation (scripts/simulate.py in the code repository). A generator first samples a semantic contract (for example: these items are indivisible; this ratio is exact, not a lower bound; this capacity is shared by machines 1 and 3 only; this objective is net profit), then renders a problem statement and its correct model from the same contract, and finally applies tracked mutations to produce incorrect variants. Because the contract and the edit are known, every variant has an exact label. Instances are checked with a solver or by enumeration, and correct and algebraically equivalent variants are kept alongside the wrong ones.

Examples of contracts:

• Integer vs. continuous domains: the same numbers are rendered once as indivisible items and once as divisible material; crossing the two readings with the two variable domains yields correct, var_to_int and var_to_cont cases. Some problems deliberately avoid the word "integer" so that the domain has to be inferred from the objects being counted.
• Exact vs. at-least ratios: "Y is exactly k times X" and "Y is at least k times X" are paired with y = kx and y >= kx, plus equivalent algebraic forms, so that the detector cannot rely on one surface pattern.
• Shared scope and resource binding: "machines 1 and 3 together run at most B hours" must become x1 + x3 <= B; variants that widen the constraint to all machines or swap which parameter binds to which object are labelled con_structure or num_value.
• Net profit: maximize sum_i (p_i - h_i - a_i q) x_i; dropping the material cost or the quantity weight gives obj_expr; expanded and merged coefficient forms are kept as equivalent.
• Prerequisites and missing constraints: "B can only be selected if A is" becomes z_B <= z_A; the reversed, missing and equivalent versions are checked by small binary enumeration, and the missing version uses missing: true.

The export de-duplicates prompt/label pairs, drops the 13 prompts that had conflicting labels, strips a trailing code-formatting note that OptMATH questions carry but benchmark questions do not, and renumbers prerequisite examples so that a gap in constraint IDs cannot reveal the missing constraint. statistics.json records the input and retained counts.

Overlap with the evaluation benchmarks

The detector is evaluated on seven public benchmarks (NL4Opt, IndustryOR, EasyLP, ComplexLP, ComplexOR, NLP4LP, ReSocratic; 1,511 questions, 1,180 unique after merging cross-benchmark duplicates). Benchmark text was used only to reject overlapping training candidates, never as a training input or target. Two audits are reported, both read-only.

Audit of the released files. Every unique training question was compared with every benchmark question using eleven methods: normalized exact match, number-masked exact match, word and character TF-IDF cosine (plain and number-masked), 5- and 13-word n-gram Jaccard and containment, BM25, MiniLM (all-MiniLM-L6-v2) sentence cosine, and a chunk-pooled MiniLM variant for long questions.

Check (training file → all seven benchmarks)	sft train (24,619 rows)	simulated families only (7,680 rows)
normalized exact duplicates	0	0
number-masked duplicates	0	0
max 13-word containment	0.038	0.000
max 5-word containment	0.217	0.038
max word TF-IDF cosine	0.816	0.151
max MiniLM cosine (≥ 0.90 count)	0.892 (0)	0.738 (0)

Validation and holdout also have zero exact and zero number-masked duplicates against the benchmarks, and the three SFT splits share no question_id. Positive controls behave as expected: copied questions score cosine 1.0 and numeric substitutions are caught by the number-masked check 100/100. The highest benchmark→train neighbours are same-genre problems (travelling-salesperson, knapsack, facility-location) with different wording and numbers.

Audit of the historical training corpus (the 6,478-row final training stage of the detector reported in the paper, its 1,617-row validation set, 300-row holdout, and the benchmarks). Exact and number-masked duplicates between any training split and the benchmarks were again 0. MiniLM nearest-neighbour statistics for benchmark questions against that training set: mean 0.642, P95 0.805, max 0.868, 0/1,180 at or above 0.90; the 13-word containment maximum was 0.038. The figure below shows the same audit: the validation split sits far to the right because it shares simulator templates with training, while the benchmark distributions do not.

Excluding benchmark questions with the most conservative rule (any lexical match or full-text cosine ≥ 0.80 against the complete 7,744-question training ancestry) removes 170 of 1,511 questions and moves the paper's main one-round result by 0.29 points, with the margin over the strongest baseline unchanged.

What these audits do and do not show: no instance- or template-level copying of benchmark questions into the training data was found by any of the methods. They do not certify that base models never saw the public benchmarks during pre-training, and the simulated families were designed after analysing benchmark failure modes, which is benchmark-informed development rather than an untouched test.

Limitations

• Labels from Route 1 rest on execution evidence (objective agreement, restoration after a replacement); they are not formal proofs of semantic equivalence.
• Simulated families use a limited set of templates. Models trained with these rows heavily up-weighted learn template cues; mix them with real formulations.
• The validation and holdout splits share simulator templates with training and are development sets, not blind tests.
• Three of the ten error types (var_to_bin, var_bound, con_extra) appear only in the Route 1 rows, not in the simulated families.

Terms and attribution

Problem statements from OptMATH-Train and ReSocratic-29k are not redistributed here; users obtain them from the upstream releases under those datasets' terms and restore them with scripts/rehydrate.py. Everything published in this repository (simulated problems, candidate formulations, solver feedback, prompts, diagnoses and labels) is released under CC BY-NC 4.0. No benchmark question, reference answer or repair trajectory is included. See the companion code repository's NOTICE.md for the full attribution list.