acceptodds
Under review as a conference paper at ICLR 2027

OR-Diffusion: Structural Data Synthesis and Hierarchical Verification for Optimization Modeling

Abstract

Large language models can translate problem descriptions into optimization models, but two challenges limit their utility. First, existing synthesis pipelines mainly paraphrase or perturb parameters, altering descriptions rather than constraint topology. Second, evaluation and training collapse distinct failure modes into a scalar reward, ignoring the natural priority: executability, structural fidelity, feasibility, and optimality, in that order. We introduce OR-Diffusion, which couples structural synthesis with hierarchical training. It synthesizes structurally novel instances via discrete diffusion over graph specifications, each feasible by construction and carrying a solver-certified gold optimum. A Hierarchical Verification Engine (HVE) certifies candidates along four ordered dimensions and reports the weakest failing layer. It guides supervised fine-tuning on executability, structural fidelity, and feasibility, and a preference stage on optimality. A pair enters that stage only when its rejected response passes the first three layers. On six public benchmarks, OR-Diffusion raises an 8B backbone from 57.8% to 78.2% macro optimal-solution rate, surpassing a 671B generalist (DeepSeek-V3, 73.3%) and specialized fine-tuned models (e.g., ORLM-8B, 65.5%), while also improving executability and feasibility. Ablations show that the two components are complementary, yielding a joint gain of 6.5 percentage points, and that diffusion outperforms textual synthesis by 4.2 percentage points. Weakest-layer diagnosis confirms this division of labor: fine-tuning removes most executability failures and leaves structural mismatches as the main residual, and the gated stage raises optimality without reducing feasibility.

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
optimization modeling, large language models, data synthetic, discrete diffusion, preference optimization

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_xkysOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes OR-Diffusion, a systematic optimization modeling method: it first uses a diffusion model to generate diverse data, then passes the data through a fine-grained evaluator, and finally adopts more targeted training methods for data with different feedback. Strengths: Innovative use of diffusion: the use of diffusion is well integrated with the motivation of insufficient data diversity, and it makes good use of the characteristics of diffusion models and the properties of the task itself. Isolating executability from other properties makes sense: the authors argue that during DPO, learning from comparing non-executable programs with correct answers is inefficient. Weaknesses: The baseline setup has problems: one of the main contributions of this paper is to address the lack of diversity in existing data generation, such as ReSocratic. However, only in the ablation experiments is there a comparison between OR-Diffusion and ReSocratic on some literal statistics, which is not convincing. The experiments in Table 1 should include the performance of a model trained with the ReSocratic method; the ablation experiments in Table 3 are too thin and insufficient. Strong teacher distillation confound. Reverse and Rewrite both use DeepSeek-V4-Flash, used by latter SFT/DPO. The improvement of the 8B model may partly come from distilling a stronger model, rather than entirely from diffusion/HVE. The paper does not report the zero-shot performance of DeepSeek-V4-Flash on these benchmarks, nor does it provide a “pure distillation with the same data” control. Lack of connection between contributions: the two core contributions—data augmentation and training-objective optimization—lack an intrinsic connection and look more like a concatenation to strengthen the contribution, without leaving a deeper or more insightful contribution in either aspect. For example, the discussion of the lexicographic protocol or HVE is actually quite shallow. Although the authors claim it is a four-layer hierarchical reward, V1 and V2 are not important enough (Table 3 also shows that V3 is the most critical layer). So why can’t the reward be directly simplified into a binary classification (V1–V3 as one class and V4 as the other)?

Critical strengths

Innovative use of diffusion: the use of diffusion is well integrated with the motivation of insufficient data diversity, and it makes good use of the characteristics of diffusion models and the properties of the task itself. Isolating executability from other properties makes sense: the authors argue that during DPO, learning from comparing non-executable programs with correct answers is inefficient.

Critical weaknesses
  1. A central contribution is addressing the limited diversity of existing data-generation methods such as ReSocratic. However, the comparison with ReSocratic is restricted to an ablation and some surface-level textual statistics, which is not convincing. Table 1 should include a model trained with the ReSocratic method, and the ablations in Table 3 are too limited to substantiate the claims.

  2. Both Reverse and Rewrite use DeepSeek-V4-Flash, and the resulting data later supervise SFT/DPO. Therefore, part of the improvement in the 8B model may come from distilling a stronger model rather than solely from diffusion/HVE. The paper does not report the zero-shot performance of DeepSeek-V4-Flash on these benchmarks, nor does it provide a distillation-only control under matched data and training budgets.

  3. Data augmentation and training-objective optimization lack an intrinsic connection and read more like a concatenation intended to strengthen the contribution, without yielding deeper insight into either aspect. For example, the discussion of the lexicographic protocol/HVE is relatively shallow. Although the authors describe a four-layer hierarchical reward, the distinct value of V1 and V2 remains unclear; Table 3 suggests that V3 is the most critical layer. Why can the reward not be simplified into a binary classification, with V1–V3 as one class and V4 as the other? This concern bears directly on whether the hierarchical design, rather than the generated corpus or teacher distillation, drives the reported gains.

Questions for authors
  1. The paper positions diffusion-based structural synthesis against text-level synthesis such as ReSocratic, but Table 1 does not include a ReSocratic-trained model. Can the authors report the downstream Opt@1 of a ReSocratic-style baseline trained with the same backbone, corpus size, and SFT/DPO protocol? If that is not feasible, can they explain why the current textual-synthesis control (A2) is a sufficient proxy for evaluating the claimed advantage of diffusion?
  2. Reverse and Rewrite both use DeepSeek-V4-Flash, and the resulting data later supervise the 8B model. Can the authors report the zero-shot performance of DeepSeek-V4-Flash on the six benchmarks, and provide a distillation-only control that uses the same teacher-generated data but without diffusion-based synthesis or HVE-based routing/gating? This would help determine how much of the gain is attributable to OR-Diffusion rather than to strong-teacher supervision.
  3. Table 3 suggests that V3 is the most critical layer, while the independent contributions of V1 and V2 remain unclear. Can the authors provide an ablation that collapses V1–V3 into a single binary admission condition—i.e., pass V1–V3 versus fail V1–V3, followed by V4 optimization? Would performance remain comparable? This directly tests whether the lexicographic hierarchy is necessary or whether a simpler binary gate suffices.
  4. The paper claims the two components are strongly complementary, but the mechanism is not fully isolated. Can the authors provide more direct evidence that diffusion-generated instances, rather than seed instances or teacher-generated data, specifically elicit the feasible-but-suboptimal rollouts that gated DPO refines? For example, what fraction of DPO pairs are formed on diffusion versus seed corpora, and how does that mediate the reported gain?
7 comments
AuthorsOpenReview ↗

Response to Reviewer xkys (Part1, W1 & Q1)

We sincerely thank Reviewer xkys for recognizing our core motivation—using discrete graph diffusion to overcome the structural diversity bottleneck in training data and isolating executability and feasibility from objective-matching accuracy during preference learning. Following your suggestions, we ran all four requested sets of controlled experiments under the exact same backbone (Qwen3-8B), corpus size (N=3,461N = 3{,}461), and training budget, and have incorporated all new baselines, ablations, and mechanism diagnostics into the revised manuscript (highlighted in blue in the uploaded PDF). Below, we address each weakness and question in detail.


1. Direct Downstream Comparison with ReSocratic (Weakness 1 & Question 1)

Downstream benchmark comparison under matched protocols. Following your recommendation, we implemented the sequential reverse-synthesis pipeline of ReSocratic—composing optimization expressions and application scenarios in text space and back-translating them into natural-language word problems—under the exact same corpus size (N=3,461N = 3{,}461), teacher model (DeepSeek-V4-Flash), student backbone (Qwen3-8B), and HVE training protocol (evaluating both SFT-only and SFT + Gated DPO):

Synthesis Method (N=3,461N = 3{,}461, Qwen3-8B)Unseen Sig. (%) ↑NL4OptEasyLPComplexLPNLP4LPCompORIndORAvg. Opt@1
Routed Seed SFT (OR-Instruct, Table 1)0.092.194.764.993.844.440.571.7
Seed Corpus + Gated DPO (A1, Table 3)0.088.395.463.193.350.054.874.1
Textual Synthesis (A2, SFT only, Table 3)2.986.495.863.187.638.938.168.3
ReSocratic-style Synthesis (SFT only, revised Table 1)0.084.693.955.086.033.335.764.7
ReSocratic-style Synthesis (SFT + Gated DPO, A3 in revised Table 3)0.083.694.155.085.438.940.566.2
OR-Diffusion (SFT only, B1 in Table 3)42.990.796.160.490.450.047.672.5
OR-Diffusion (SFT + Gated DPO, Full)42.996.397.465.897.255.657.178.2

Why OR-Diffusion substantially outperforms ReSocratic under strictly matched protocols (+7.8 points under SFT-only; +12.0 points under SFT + Gated DPO): ReSocratic composes constraints sequentially in text/expression space without a formal feasibility construction. Under our matched budget, sequentially recombining seed-like constraint clauses and filtering for solver feasibility leaves surviving variable-type/degree signatures inside the existing OR-Instruct seed support (0.0% unseen constraint signatures under the subsampling protocol of revised Table 12—below even surface paraphrasing A2 at 2.9%). Consequently, ReSocratic reaches 64.7% under SFT-only (7.8 points below OR-Diffusion SFT-only B1 at 72.5%) and 66.2% under SFT + Gated DPO (A3, 12.0 points below full OR-Diffusion at 78.2%), with the sharpest deficits on structurally complex benchmarks (ComplexLP: 55.0% vs. 65.8%; CompOR: 33.3%–38.9% vs. 55.6%). Without a witness-point anchor, combining multiple tight constraints in text space can produce mutually inconsistent systems that fail solver verification, leaving survivors concentrated on simple seed skeletons. Notably, gated DPO adds only +1.5 points on ReSocratic (64.7% →\to 66.2%) versus +5.7 points on OR-Diffusion (72.5% →\to 78.2%), confirming that preference optimization cannot compensate for narrow structural diversity. In contrast, OR-Diffusion denoises bipartite topologies jointly and instantiates right-hand sides around an explicit integral, non-negative witness point xwx^w, guaranteeing 100% solver feasibility by construction (submission Table 7 / revised Table 9) and preserving complex multi-constraint topologies. We have added the ReSocratic baselines directly to Table 1 (main comparison), Table 3 (A3 ablation), and Table 12 (submission Table 9, structural diversity) in the revised manuscript.


AuthorsOpenReview ↗

Response to Reviewer xkys (Part2, W2 & W3 & Q2)

2. Disentangling Teacher Distillation from OR-Diffusion—and Synergy Between Synthesis and HVE (Weakness 2, Weakness 3 & Question 2)

To cleanly separate strong-teacher supervision (DeepSeek-V4-Flash) from our structural synthesis and hierarchical training, we evaluated (i) the standalone zero-shot accuracy of DeepSeek-V4-Flash across all six benchmarks and (ii) a Distillation-Only Control that applies DeepSeek-V4-Flash (Rewrite) to the seed problems (N=3,461N = 3{,}461) and trains Qwen3-8B with standard unweighted cross-entropy SFT (no diffusion synthesis and no HVE routing/gating):

Model / Control SettingDiffusionHVE Routing/GatingNL4OptEasyLPComplexLPNLP4LPCompORIndORAvg. Opt@1
Base Qwen3-8B (Zero-shot, Table 1)××76.295.614.488.222.250.057.8
DeepSeek-V3 (671B, Zero-shot, Table 1)——79.996.755.094.944.469.073.3
DeepSeek-V4-Flash (Synthesis Teacher, Zero-shot, revised Table 1)——75.794.757.794.450.069.073.6
Distillation-Only Control (Seed + Teacher TgT_g, Plain SFT, revised Table 1)××87.492.362.288.838.945.269.1
Diffusion + Teacher TgT_g, Plain SFT (B2 in Table 3)✓×84.689.036.989.927.845.262.2
Seed + Weakest-Layer SFT + Gated DPO (A1 in Table 3)×✓88.395.463.193.350.054.874.1
Full OR-Diffusion (Qwen3-8B, Table 1)✓✓96.397.465.897.255.657.178.2

Three key findings:

  1. Quantitative decomposition of the +20.4-point total gain (57.8% →\to 78.2%): Standard supervised distillation from DeepSeek-V4-Flash on seed problems lifts Qwen3-8B from 57.8% to 69.1% (Distillation-Only, +11.3 points), which remains 4.5 points below the teacher itself (73.6%). Under the exact same teacher, corpus size (N=3,461N = 3{,}461), backbone, and training budget, coupling discrete graph diffusion with HVE routing and gated DPO contributes an additional +9.1 percentage points (69.1% →\to 78.2%). Both DeepSeek-V4-Flash and the Distillation-Only Control are now reported in Table 1 of the revised manuscript.
  2. Why our 8B student surpasses its own synthesis teacher (DeepSeek-V4-Flash, 78.2% vs. 73.6%, +4.6 points) as well as 671B DeepSeek-V3 (73.3%): Two ingredients work together. First, witness-point construction supplies an exact solver-certified ground-truth optimum f∗f^* for every synthesized graph, allowing solver-checked Rewrite (with up to two retries; Appendix G.4) to filter out teacher errors exceeding 10−410^{-4} (retaining 1,910 of 3,000 candidates; submission Table 7 / revised Table 9) so TgT_g is clean. Second—as Distillation-Only (69.1% << 73.6%) confirms—clean teacher labels alone do not surpass the teacher: exceeding the teacher requires expanding structural coverage via graph diffusion (42.9% unseen signatures) and resolving failure modes via HVE routing and gated DPO (+9.1 points).
  3. Strong synergy rather than simple concatenation—why diffusion requires HVE (62.2% without HVE vs. 78.2% with HVE): Comparing both with and without HVE reveals a striking interaction:
    • Without HVE (Plain SFT): Training on novel diffused topologies (B2, 62.2%, dropping to 36.9% on ComplexLP) actually underperforms plain SFT on familiar seeds (Distillation-Only, 69.1%) by 6.9 points, because 42.9% unfamiliar multi-constraint topologies initially trigger frequent syntax and structural mistakes (87.6% of non-optimal base rollouts) that swamp unweighted updates.
    • With HVE (Matched 2×22\times 2 in submission Table 5 / revised Table 7): Once balanced pool routing stabilizes Stage 1 (B1, 72.5% vs. routed Seed SFT 71.7%) and gated DPO refines numerical binding in Stage 2, the diffusion corpus yields a +5.7-point DPO gain versus +2.4 points on seeds (A1, 74.1%), flipping diffusion to +4.1 points ahead overall (78.2%, and +28.7 points on held-out unseen constraint signatures, 79.0% vs. 50.3% in revised Table 16). Structural synthesis and hierarchical training are therefore mutually reinforcing rather than a loose concatenation.

AuthorsOpenReview ↗

Response to Reviewer xkys (Part3, W3 & Q3)

3. Deeper Formulation of HVE and Necessity of All Four Layers vs. Binary Collapse of V1V_1–V3V_3 (W3 & Q3)

Clarifying HVE's role (routing & gating vs. scalar reward) and why B3 had the largest drop in original Table 3: First, we have substantially expanded Section 3.3 (Page 6) in the revised PDF to clarify the theoretical role of the four-layer hierarchy. Importantly, HVE is not trained as a four-layer weighted scalar reward (indeed, collapsing layers into an un-gated scalar reward in B4 degrades Opt@1 to 69.8%, below SFT-only at 72.5%). As formalized in Section 3.3, while the four-layer lexicographic order carries the exact same diagnostic information as a non-overlapping milestone rubric, its empirical power comes from driving two distinct stage-specific training rules: inverse-size pool routing in SFT and hard candidate exclusion in DPO. Moreover, the large drop when removing pool S3\mathrm{S}3 (B3, 66.7%, -11.5 points) in original Table 3 did not mean V1V_1 and V2V_2 were unimportant—rather, S3\mathrm{S}3 errors are rare (4.8%) compared to S1\mathrm{S}1 (28.4%) and S2\mathrm{S}2 (59.2%), so without explicit four-layer separation S3\mathrm{S}3 is immediately drowned out.

To test your exact hypothesis—collapsing V1V_1–V3V_3 into a single binary condition (Pass V1–V3 vs. Fail V1–V3) followed by V4V_4 optimization, alongside individual ablations of V1V_1 and V2V_2—we ran four new controlled ablations under the exact same backbone (Qwen3-8B), corpus size (NN = 3,461), and budget (now added as rows B5–B8 in revised Table 3):

Hierarchy / Ablation Variant (NN = 3,461, Qwen3-8B, revised Table 3)NL4OptEasyLPComplexLPNLP4LPCompORIndORAvg. Opt@1
Full 4-Layer HVE (S1\mathrm{S}1–S4\mathrm{S}4 routing + V1=V2=V3=1V_1{=}V_2{=}V_3{=}1 gated DPO)96.397.465.897.255.657.178.2
B5 Binary Collapse in SFT (merge S1\mathrm{S}1–S3\mathrm{S}3 into one "Fail V1V_1–V3V_3" pool + Gated DPO)89.794.553.290.438.950.069.5
B8 Solver-Only Binary Gate in DPO (drop V2V_2; gate only on V1=V3=1V_1 = V_3 = 1)92.596.561.392.750.050.073.8
B6 w/o S1\mathrm{S}1 (executability) pool in SFT (+ Gated DPO)91.695.859.591.650.050.073.1
B7 w/o S2\mathrm{S}2 (structural fidelity) pool in SFT (+ Gated DPO)89.794.152.389.938.945.268.4
B3 w/o S3\mathrm{S}3 (feasibility) pool in SFT (+ Gated DPO)88.893.650.588.833.345.266.7

Why both stages require explicit separation of V1V_1, V2V_2, and V3V_3:

  1. In Stage 1 (SFT Pool Routing), collapsing Fail(V1–V3) into one binary pool drops Opt@1 by -8.7 points (B5, 69.5%), and both V1V_1 and V2V_2 contribute substantially (B6, B7): Across non-optimal base-policy rollouts on DSFT\mathcal{D}_{\text{SFT}}, 28.4% fail at V1V_1 (S1\mathrm{S}1, execution crashes), 59.2% fail at V2V_2 (S2\mathrm{S}2, wrong constraint structure), only 4.8% pass V1V_1–V2V_2 yet fail solver feasibility (S3\mathrm{S}3, conflicting parameter bindings), and 7.6% pass V1V_1–V3V_3 with misbound objectives (S4\mathrm{S}4). Merging S1\mathrm{S}1–S3\mathrm{S}3 into a single binary "Fail V1V_1–V3V_3" SFT pool (B5) causes syntax and structural mistakes to occupy 94.8% of failed updates (87.6/92.487.6 / 92.4), starving S3\mathrm{S}3 and dropping macro Opt@1 from 78.2% to 69.5% (-8.7 points). Moreover, individually dropping the S1\mathrm{S}1 pool (B6, 73.1%, -5.1 points) or the S2\mathrm{S}2 pool (B7, 68.4%, -9.8 points—nearly matching B3's -11.5-point drop) confirms the strong independent contribution of both V1V_1 and V2V_2.
  2. In Stage 2 (DPO Admission Gate), our gate is a binary Pass(V1–V3) vs. Fail(V1–V3) filter—but computing Pass(V1–V3) still requires HVE's explicit V2V_2 structural check (-4.4 points without V2V_2, B8): We agree that DPO itself uses V1V_1–V3V_3 conjunctively as a binary admission condition (Fq={V1=V2=V3=1,V4<1}\mathcal{F}_q = \lbrace V_1 = V_2 = V_3 = 1, V_4 < 1 \rbrace) before optimizing V4V_4. Crucially, however, an off-the-shelf solver can only verify execution (V1=1V_1 = 1) and feasibility (V3=1V_3 = 1); no solver can check whether the candidate encoded the right constraint structure (V2=1V_2 = 1). On Dint\mathcal{D}_{\text{int}} (Table 2), post-SFT feasibility p3p_3 (91.7%) far exceeds structural fidelity p2p_2 (60.0%) because omitting a constraint or flipping an inequality often leaves a feasible LP. Simplifying the DPO gate to a solver-only binary check (V1=V3=1V_1 = V_3 = 1, dropping V2V_2; B8) lets structurally wrong programs leak into Fq\mathcal{F}_q, dropping macro Opt@1 from 78.2% to 73.8% (-4.4 points). Thus, all four explicit verification layers are indispensable across the two stages.

Reviewer_HVVNOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper trains LLMs to turn natural-language decision problems into MILP/Gurobi code. A DiGress-style discrete diffusion model recombines the variable-constraint graphs of OR-Instruct seed programs; coefficients are set around a witness point so every instance is feasible and bounded, and a teacher LLM writes the word problem and reference code. A four-layer verifier (executability, structure, feasibility, optimality) drives weakest-layer SFT and a feasibility-gated DPO stage. With Qwen3-8B, macro Opt@1 over six benchmarks rises from 71.7% to 78.2%, above DeepSeek-V3 .

Critical strengths
  1. Diffusion over constraint graphs changes problem structure rather than wording, and each verifier layer maps to a training stage. The pipeline is clearly described.
  2. The ablations are well controlled in Tables 3 and 5, and Table 6 shows the feasibility gate does what it is meant to.
Critical weaknesses
  1. The paper reports no instance-level deduplication between OR-Instruct / the synthetic corpus and the six test sets. In addition, about 36% of generated problems are dropped at the teacher's Rewrite step (1,910 of 3,000 kept, Table 7), and the dropped ones are not characterized, so the corpus is biased toward what the teacher can solve.
  2. The diffusion pipeline cannot be reproduced from the paper. Appendix C gives no noise schedule, architecture, training setup, seeds or coefficient sampling rules, and code is promised only upon acceptance, despite the claim of a complete specification in page 10.
Questions for authors
  1. What deduplication against the six test sets was done, and how do the rejected instances differ from the retained ones?
  2. Could you give the full diffusion configuration and teacher settings, and release D_SFT for review?
7 comments
AuthorsOpenReview ↗

Response to Reviewer HVVN (Part1.1, W1 & Q1)

We sincerely thank Reviewer HVVN for the positive and constructive assessment of our work, and for recognizing the value of structural graph diffusion, the alignment between our four verification layers and two training stages, and our controlled ablations (submission Tables 3, 5, and 6 / revised Tables 3, 7, and 8). Below, we address both of your questions in full detail: we establish two-level test-set isolation across the seed pool and our synthesized corpus (with explicit instance-level deduplication against all 1,1081{,}108 public test instances), characterize the 36.3% of instances filtered at the Rewrite stage, clarify our open-source release plan for all datasets and code upon acceptance, and provide the complete architectural, sampling, and teacher specifications (now added to Appendix C, Table 6 of the revised manuscript).


1. Test-Set Deduplication and Characterization of Rewrite-Filtered Instances (Weakness 1 & Question 1)

(a) Two-Level Isolation and Post-Hoc Deduplication Against All Six Public Test Sets

Our pipeline prevents test-set contamination at both the OR-Instruct seed level and the synthetic-corpus level, which we further verify via explicit instance-level nearest-neighbor similarity across all 1,1081{,}108 test problems in the six public benchmarks (Table 4):

  1. Level 1 — Structural Abstraction of OR-Instruct Seeds and Matched-Seed Controls: Built on the OR-Instruct seed corpus (Huang et al., 2025, constructed disjointly from standard public evaluation splits), our synthesis pipeline never copies seed problem text or reference code into DSFT\mathcal{D}_{\text{SFT}}: OR-Instruct programs are parsed solely into abstract bipartite skeletons to train the discrete graph diffusion model, after which diffusion resamples new constraint topologies and our witness-point procedure draws all objective coefficients, constraint matrix entries, variable bounds, and right-hand sides from fresh random seeds before Reverse writes a brand-new problem narrative (Section 3.2). Moreover, every same-backbone control (Seed SFT, Distillation-Only, A1 w/o Diffusion, and A2 Textual synthesis) trains directly on the exact same OR-Instruct seed pool (Tables 1 and 3); hence, even if any topical similarity existed between seeds and public benchmarks, it would benefit the seed baselines at least as much, making our +6.5-point macro Opt@1 gain over routed Seed SFT (78.2%78.2\% vs. 71.7%71.7\%) and +4.1-point gain over A1 (78.2%78.2\% vs. 74.1%74.1\%) strictly conservative.

  2. Level 2 — Instance-Level Deduplication of Synthesized Prompts (DSFT\mathcal{D}_{\text{SFT}}) Against All 1,1081{,}108 Public Test Instances: Using the exact all-mpnet-base-v2 sentence-encoder protocol from submission Table 10 (revised Table 13), we computed the maximum cosine similarity between each of the 3,4613{,}461 synthesized problem statements in DSFT\mathcal{D}_{\text{SFT}} and all 1,1081{,}108 public test instances across the six benchmarks. Across all 3,4613{,}461 training instances, the nearest-neighbor test similarity has a mean of 0.70 (0.6990.699) and a 99th percentile of 0.85 (0.8530.853), with 0 instances reaching 0.95 (overall maximum 0.9180.918, and only 55 instances ≥0.90\ge 0.90).

    Submission Table 10 (revised Table 13) provides a calibrated reference scale for interpreting these numbers: surface paraphrasing of an existing problem yields a cosine similarity of 0.90 (with 0.99 graph similarity), whereas structurally distinct problems written in the same operations-research domain register (pairing each Reverse statement with its nearest OR-Instruct seed) yield 0.72 text similarity with only 0.25 graph similarity. Our test-set nearest-neighbor distribution (mean 0.70, 99th percentile 0.85) aligns closely with this ∼0.72\sim 0.72 register baseline of structurally distinct OR word problems and sits well below the 0.900.90 paraphrase regime. Furthermore, because graph topologies and all numerical parameters (c,A,b,l,u)(c, A, b, l, u) are freshly sampled from independent random seeds, even the 55 tail instances in [0.90,0.92][0.90, 0.92] reflect shared domain scenario phrasing (such as standard blending or transportation templates) rather than copied benchmark formulations. We have added this instance-level deduplication analysis to Appendix B (Table 5) of the revised manuscript.

AuthorsOpenReview ↗

Response to Reviewer HVVN (Part1.2, W1 & Q1)

(b) Characterization of the 36.3% Dropped Instances at Rewrite (Submission Table 7 / Revised Table 9)

In the single generation round reported in submission Table 7 / revised Table 9 (from which multiple rounds are pooled to assemble the final N=3,461N = 3{,}461 corpus; Appendix D), all 3,0003{,}000 diffused graphs entering Reverse are already certified by Gurobi to be feasible and bounded with a known exact optimal value f∗f^*. Consequently, Reverse (converting the formal MILP into a natural-language story qq) followed by solver-checked Rewrite (initially generating Gurobi code TgT_g from qq alone, with up to two solver-guided retries; Appendix G.3–G.4, and retaining only feasible code within relative gap 10−410^{-4} of f∗f^*) acts as a round-trip verbalization-and-compilation consistency filter: an instance is dropped either when Reverse omits or ambiguously phrases a numerical bound, inequality sense, or coefficient in prose, or when Rewrite fails within three attempts to compile a multi-constraint narrative back into feasible code matching f∗f^*.

Comparing the 1,9101{,}910 retained instances and the 1,0901{,}090 dropped instances from that generation round (added as Table 10 in revised Appendix D) directly characterizes how they differ:

Metric (Generation round in revised Table 9: 3,0003{,}000 graphs sent to Reverse)Retained (n=1,910n = 1{,}910)Dropped (n=1,090n = 1{,}090)
Variable nodes ∣Vvar∣\lvert V_{\text{var}} \rvert3.67±2.533.67 \pm 2.534.51±3.954.51 \pm 3.95
Constraint nodes ∣Vcon∣\lvert V_{\text{con}} \rvert3.46±2.423.46 \pm 2.424.95±3.094.95 \pm 3.09
Nonzero incidence edges ∣E∣\lvert E \rvert7.05±6.277.05 \pm 6.279.54±10.129.54 \pm 10.12
Integer / binary variable share (%)98.1%98.1\%96.4%96.4\%
Unseen constraint signatures vs. seeds (%)∗^{*}40.2%40.2\%61.5%61.5\%

∗^{*}Note: Measured directly over the full 1,9101{,}910 retained vs. 1,0901{,}090 dropped partitions of that round (under the 50-draw, 212-instance subsampling protocol of submission Table 9 / revised Table 12 on the final corpus, the retained unseen-signature rate is 42.9%42.9\%).

Three findings directly address the concern regarding potential teacher filtering bias:

  1. No bias against discrete or combinatorial formulations: The retained corpus actually has a slightly higher proportion of integer and binary decision variables than the dropped set (98.1%98.1\% vs. 96.4%96.4\%), confirming that Rewrite filtering does not steer the dataset toward easier continuous LPs.
  2. Why dropped graphs are moderately larger—and why student accuracy is NOT upper-bounded by the teacher's zero-shot accuracy: Dropped instances contain roughly 1.51.5 more constraints and 2.52.5 more nonzero edges on average (9.549.54 vs. 7.057.05). Because a constraint signature pairs the variable-type multiset with the constraint-degree sequence (Appendix D, Table 12; Appendix F), larger edge counts mechanically produce more unique degree combinations (61.5%61.5\% vs. 40.2%40.2\%) while simultaneously demanding lossless narration of more parameters in Reverse and exact multi-constraint compilation in Rewrite. This reflects a deliberate precision–recall trade-off to guarantee noise-free training anchors: relaxing the 10−410^{-4} verification check to retain those 1,0901{,}090 instances would inject underspecified or mismatched (q,Tg)(q, T_g) pairs, corrupting the gold anchor TgT_g required by SFT and gated DPO. Crucially, as our new teacher comparison in revised Table 1 shows, OR-Diffusion (78.2% Opt@1) surpasses the zero-shot accuracy of its own synthesis teacher DeepSeek-V4-Flash (73.6%) by +4.6 percentage points (and beats a Distillation-Only teacher-rewrite control at 69.1% by +9.1 points), confirming that student accuracy is not upper-bounded by the standalone teacher's zero-shot accuracy.
  3. Substantial retained structural novelty and strong tail generalization: Even under strict round-trip verification, the retained instances preserve 40.2%40.2\% unseen signatures within that round—and 42.9%42.9\% on the final corpus under the matched subsampling protocol of revised Table 12, which is 14.8×14.8\times higher than surface paraphrasing (2.9%2.9\%) and 9.3×9.3\times higher than coefficient perturbation (4.6%4.6\%). Moreover, Appendix F (submission Table 13 / revised Table 16) confirms that our trained 8B student generalizes strongly to novel and larger structures: OR-Diffusion reaches 79.0% Opt@1 on held-out unseen constraint signatures (+28.7 points over Seed SFT at 50.3%50.3\%), 75.8% on the MILP slice (+9.9 points), and 58.2% on the high-constraint tail slice (+5.3 points).

AuthorsOpenReview ↗

Response to Reviewer HVVN (Part2.1, W2 & Q2)

2. Open-Source Release Plan and Complete Reproducibility Specifications (Weakness 2 & Question 2)

(a) Open-Source Release Plan for All Datasets and Code Upon Acceptance

We appreciate your critique regarding the overstatement in our original Reproducibility Statement on Page 10: claiming complete specification while omitting diffusion architecture and sampling details in Appendix C was an oversight on our part, which we have now fully corrected in the revised PDF.

Regarding artifact release, while we complete packaging and cleanup of our internal pipeline scripts, we commit to publicly open-sourcing both all datasets and the complete codebase immediately upon acceptance under a permissive license (hosted permanently on HuggingFace and GitHub):

  • Datasets: The complete synthesized training corpus DSFT\mathcal{D}_{\text{SFT}} (NN = 3,461 instances) together with both held-out diagnostic benchmarks (Dint\mathcal{D}_{\text{int}}, n=325n = 325; and the provably infeasible reference slice, n=180n = 180). Every entry will include the natural-language problem statement qq, the attributed bipartite graph specification G=(V,E,A)\mathcal{G} = (V, E, \mathcal{A}), the 20-dimensional application-type vector yy, the Gurobi-certified optimal value f∗f^{\ast}, and the verified reference program TgT_g.
  • Codebase: The end-to-end synthesis and training codebase—covering OR-Instruct graph parsing, DiGress discrete bipartite diffusion training and sampling, witness-point numerical instantiation, Reverse/Rewrite teacher generation, the four-layer HVE verifier (including compiled Gurobi Model structural canonicalization), pool-routed SFT, and feasibility-gated DPO—along with configuration files and evaluation scripts.

To ensure full transparency and inspectability during the review period itself, we have added Table 6 in Appendix C with every architectural, noise-schedule, random-seed, sampling-distribution, teacher, and training hyperparameter needed to reproduce our pipeline from scratch, alongside the full prompt templates in Appendix G (and the worked formulation walkthrough in Example 1, Section 1).

Reviewer_bSHLOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
1
Soundness
1
Read review
Paper summary

The paper claims that existing methods for synthesizing optimization training data are limited because they mainly change parameters or problem descriptions rather than fundamentally changing the structure of the problem. Furthermore, generating correct optimization models requires several capabilities, including producing executable code, identifying the correct formulation structure, and encoding the problem so that a solver returns the correct status and objective value. To tackle these issues, the authors introduce OR-Diffusion, which first synthesizes optimization problem structures via a discrete graph diffusion process, then assigns numerical parameters to ensure that the resulting problems are feasible and bounded. These problems are converted into natural language descriptions and paired with solver-verified reference code. They additionally introduce a hierarchical verification engine that checks executability, structural fidelity, feasibility, and optimality. These checks guide the sampling of training examples for SFT, followed by a DPO stage that compares reference solutions against generated programs that pass the first three checks but fail to match the reference objective. They show that this approach allows them to train an 8B-parameter model that outperforms a zero-shot 671B-parameter DeepSeek-V3 model in average objective-matching accuracy across six optimization benchmarks.

Critical strengths
  • Strong performance of a compact model: The authors train an 8B-parameter model that outperforms zero-shot DeepSeek-V3 (671B parameters) in macro-average accuracy across six optimization benchmarks.

  • The graph diffusion idea is an interesting and novel approach to synthesizing new optimization problems. The general idea is to start with a fixed number of nodes (representing decision variables, constraints, objectives, etc) and then denoise their types and connections, so multi-variable constraints are formed afterwards.

  • Controlled ablations: The authors include matched comparisons of seed versus diffusion-generated training data and SFT versus SFT followed by DPO, helping establish the contributions of structural synthesis and preference training.

Critical weaknesses

While the results are interesting, I think this paper could heavily benefit from improved writing and clarity of communication. To illustrate this point, the introduction contains several sweeping abstractions that are not sufficiently explained or contextualized.

  • The terms “executability, structural fidelity, feasibility, optimality” are introduced without enough explanation to distinguish between them. Although formal definitions appear later, concrete examples in the introduction would help motivate these checks. For example, what does it mean for a non-executable program to be “uninformative”? Doesn't a non-executable program result in errors, which could provide feedback to the model? How should one distinguish "structural fidelity" from "optimality": don't both errors produce solver-feasible solutions, but simply produce the wrong objective value?

  • I am not convinced that collapsing the hierarchy into a scalar reward is an issue. One could design a rubric that assigns progressively higher rewards depending on how many program requirements are satisfied, preserving the proposed priority order and allowing the failure stage to be recovered from the score. The paper itself acknowledges that appropriately chosen weights can respect this order. For this reason, I am not sure whether evaluating a candidate solution requires four ordered dimensions, or whether a scale reward is sufficient to train the model.

  • The method is restricted to MILPs. Existing work such as Gao et al. (2026) [1] covers quadratic and nonlinear formulations in addition to MILPs. I would be interested to see how well this method can be extended to other nonlinear optimization problem as well. Furthermore, Gao et al. (2026) discusses how models often cannot structurally bind the correct numerical constraints to their variables, which also provides a way to separate the functional components to solve the optimization problem. I would like to see further discussion on the connection between these two papers.

Overall, while the results are promising, my main concern is on the readability and communication of this paper. I highly recommend revising and reworking the draft to make it easier for readers to digest.

[1] Zhiqi Gao, Albert Ge, Alexander Berenbeim, Nathaniel D. Bastian, and Frederic Sala. Models Can Model, But Can’t Bind: Structured Grounding in Text-to-Optimization. Conference on Language Modeling (COLM), 2026. https://arxiv.org/abs/2605.21751

Questions for authors

Could you provide concrete examples distinguishing the four verification stages, for example a structurally incorrect but feasible program versus one that passes V1–V3 but fails V4? These examples would help clarify the motivation for the hierarchy.

Could you clarify why a scalar reward cannot preserve the proposed priority order through a rubric with non-overlapping reward ranges? How much of the improvement comes from the hierarchical representation versus the rule that excludes earlier-stage failures from DPO pairs?

Among rejected responses that pass V1–V3 but fail V4, what proportion contain incorrect coefficients, right-hand sides, or bounds? Since the solver optimizes the generated formulation, could the DPO gains primarily reflect improved numerical binding rather than optimality refinement? Please discuss the connection to Gao et al. (2026) [1].

Which components of the framework depend on the MILP restriction? What changes would be needed to support quadratic or nonlinear formulations, such as those covered in [1], and would the proposed verification hierarchy remain applicable?

14 comments
AuthorsOpenReview ↗

Response to Reviewer bSHL (Part1.1, W1 & Q1)

We sincerely thank Reviewer bSHL for the candid assessment of our manuscript's presentation, the insightful methodological questions, and for bringing Gao et al. (2026) [1] to our attention. We found Gao et al. (2026) [1] to be a particularly insightful and timely contribution to text-to-optimization: its clean formal separation between mathematical modeling and numerical parameter binding, its forward-engineered benchmark across linear and nonlinear problem classes (Text2Opt-Bench) alongside programmatic data offloading (BIND), and its empirical diagnosis of why multi-stage partial rewards degrade reinforcement learning (Appendix G.5 and Appendix G.10) illuminate central bottlenecks in this area and gave us a much sharper lens for articulating our own contributions. Taking your recommendation to heart, we have thoroughly revised and reorganized the manuscript for readability (with all major changes highlighted in blue in the uploaded PDF) and have prominently cited and discussed the connections, comparisons, and complementarity between OR-Diffusion and Gao et al. (2026) [1] across Sections 1, 2, 3, 5, and Appendix A. Below, we address each of your concerns and questions in full detail.


1. Concrete Examples of the Four Verification Stages, Clarifying Terminology, and Improving Readability (Weakness 1 & Question 1)

(a) Why we wrote "uninformative," and how error messages relate to single-turn evaluation

We completely agree that describing a non-executable program as "uninformative" in the original introduction was imprecise. Runtime error messages and tracebacks certainly provide valuable diagnostic feedback in multi-turn code-repair settings (which we ourselves use during the retry step of our data-generation pipeline in Appendix G.4, and which Gao et al. [1] evaluate under multi-turn repair). What we meant in the context of single-turn evaluation and preference ranking is that when a generated Python script crashes with a syntax error or an invalid solver API call before optimization finishes, no mathematical model is ever constructed inside the solver. As a result, the solver cannot provide any mathematical assessment of whether the formulation structure is sound, whether the constraints are feasible, or what objective value the model achieves. In Section 1 of the revised manuscript, we have replaced the vague word "uninformative" with this explicit explanation—that a runtime crash "yields no solver-level mathematical signal."

[1] Zhiqi Gao, Albert Ge, Alexander Berenbeim, Nathaniel D. Bastian, and Frederic Sala. Models Can Model, But Can’t Bind: Structured Grounding in Text-to-Optimization. Conference on Language Modeling (COLM), 2026. https://arxiv.org/abs/2605.21751

AuthorsOpenReview ↗

Response to Reviewer bSHL (Part1.2, W1 & Q1)

(b) A single concrete example distinguishing all four verification stages (V1V_1 through V4V_4)

First, it helps to state the division of roles between the language model and the solver: the language model never solves the optimization problem numerically. Instead, given a natural-language problem description, the language model writes Python code that defines a candidate mathematical model, and an exact solver (Gurobi) then solves whatever model was written to global optimality.

To make the four verification stages concrete right from the beginning of the paper, we added a standalone callout box (Example 1 in Section 1, Page 2) built around a simple two-product manufacturing problem. Suppose a factory chooses non-negative integer production quantities x1x_1 and x2x_2 (matching Gurobi's default lower bound of zero) to maximize total profit 5x1+4x25x_1 + 4x_2, subject to three requirements:

  • a labor-hour limit: 2x1+3x2≤122x_1 + 3x_2 \le 12,
  • a raw-material limit: x1+2x2≤8x_1 + 2x_2 \le 8, and
  • a minimum total production batch: x1+x2≥4x_1 + x_2 \ge 4.

For this reference problem, Gurobi returns an OPTIMAL status with a true maximum profit of 30 (achieved by producing 6 units of product 1 and 0 units of product 2). On this single problem, the four failure stages arise as clearly distinct mistakes:

  1. Stage 1 — Executability failure (V1V_1 fails): The generated Python script crashes before the solver can run. For instance, the model writes a strict inequality model.addConstr(2*x1 + 3*x2 < 12) (which Gurobi rejects because linear programs do not admit strict inequalities) or calls Python's built-in max(x1, x2) function directly on Gurobi decision variables. Python raises an exception, and optimization never completes.
  2. Stage 2 — Structural fidelity / modeling failure (V1V_1 passes, V2V_2 fails, yet solver feasibility V3V_3 passes): The code runs without error and Gurobi returns OPTIMAL, but the code formulates the wrong mathematical problem structure. For example, suppose the language model forgets to include the labor-hour constraint altogether (so Gurobi maximizes profit under only the material and batch limits, returning an optimal profit of 40 at 8 units of product 1), or reverses the direction of the material limit to x1+2x2≥8x_1 + 2x_2 \ge 8 (returning an optimal profit of 16). Even though the program is executable and solver-feasible, it fails the modeling task because a constraint is missing or an inequality direction is flipped.
  3. Stage 3 — Feasibility / solver-status failure (V1V_1 and V2V_2 pass, V3V_3 fails): The generated code captures the exact right decision variables, variable types, objective direction, and all three constraint structures, but misreads a number from the text in a way that makes the constraints mutually contradictory. For example, if the language model misreads the available labor hours as 6 instead of 12 (writing 2x1+3x2≤62x_1 + 3x_2 \le 6), then satisfying the minimum batch of 4 total units already requires at least 8 labor hours. No non-negative production plan can satisfy both constraints simultaneously, so Gurobi returns INFEASIBLE instead of OPTIMAL.
  4. Stage 4 — Exact objective match / parameter-binding failure (V1V_1, V2V_2, and V3V_3 all pass, V4V_4 fails): The generated code executes cleanly, encodes the exact right variable and constraint structure, and remains feasible and bounded so Gurobi returns OPTIMAL—yet it transcribes a numerical parameter inaccurately from the problem text. For instance, misreading available labor hours as 10 instead of 12 (2x1+3x2≤102x_1 + 3x_2 \le 10) causes Gurobi to return an optimal profit of 25; misreading labor hours as 14 yields 35; and swapping the two products' labor coefficients (3x1+2x2≤123x_1 + 2x_2 \le 12) yields 22.

How this directly answers the distinction between "structural fidelity" (V2V_2) and "optimality / objective match" (V4V_4): As Cases 2 and 4 illustrate, both errors can indeed produce solver-feasible programs that return an incorrect objective value. The crucial difference is why the objective value is wrong: in a Stage 2 failure, the language model built the wrong equation structure (omitting a constraint, adding a spurious constraint, using the wrong variable domain, or flipping an inequality sense), whereas in a Stage 4 failure, the mathematical skeleton is completely faithful to the reference problem and the discrepancy comes strictly from misbinding a numerical constant (an objective coefficient, constraint coefficient, right-hand side, or bound).

AuthorsOpenReview ↗

Response to Reviewer bSHL (Part1.3, W1 & Q1)

(c) Summary of manuscript revisions made to improve readability

  • Section 1 (Pages 1–2): We rewrote the introduction in plain, concrete language, explicitly clarified the respective roles of the language model and the exact solver, and placed the manufacturing example above in a standalone visual box (Example 1) so readers can grasp all four stages before seeing any formal notation.
  • Unambiguous optimization terminology throughout: In our original submission, calling Stage 4 errors "feasible-but-suboptimal" and Stage 2 "optimality refinement" was confusing because Gurobi solves every generated formulation to global optimality—and a misread number can relax a constraint and produce an objective value higher than the true optimum (such as 35 instead of 30) just as easily as a lower one. Throughout the revised manuscript, we have replaced those terms with objective-mismatched (misbound) formulations and numerical-binding refinement.
  • Section 3.3 (Page 6): We added a clean visual summary table connecting each verification layer (V1V_1 through V4V_4) to its check, its concrete failure case from Example 1, its resulting score profile, and where it is routed during training.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.