acceptodds
Under review as a conference paper at ICLR 2027

Right Answer, Wrong Model: Verifying LLM-Generated Optimization Models

Abstract

LLMs are increasingly used to translate natural-language problems into mathematical optimization models and are typically evaluated by whether the generated model attains the reference optimal objective value. This paper studies silent errors: generated models that return the correct optimal value while encoding an incorrect feasible region. Across 7 LLM generators on 40 problems selected to stress formulation correctness, 14.9% of objective-matching outputs contain silent errors; among the six generators that produce correct formulations, rates range from 7.2% (GPT-5 Mini) to 25%. These errors concentrate in constraints and variable domains, so objective-value accuracy can overstate formulation quality. Existing verifiers typically return a verdict or a relation-level profile rather than naming the violated requirement with checkable evidence. This paper introduces SILENTOR, a solver-backed verifier that checks a candidate model one requirement at a time. Behavioral requirements are compiled into executable probes, and a solver searches for a witness: a solution the candidate admits but the requirement forbids. Declared-type requirements that can be decided directly from the candidate's declarations bypass probe generation and are checked structurally. A violation is reported only with a confirmed witness or an offending declaration; otherwise the requirement is unresolved. On 49 silent-error cases with 89 requirement violations, SILENTOR raises requirement precision from 66.4% to 96.2% over a single-agent baseline at comparable recall, reaching 98.1% on naturally occurring errors. On 36 certified-correct models, false-positive rates fall from 33.3% for direct inspection to 16.7% with supplied requirements and 5.6% for SILENTOR. SILENTOR turns requirement-level predictions into localized, solver-checkable evidence.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
large language models, optimization modeling, formulation verification, silent errors, counterexample generation, LLM evaluation, operations research, neuro-symbolic verification

Reviews

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

This paper identifies silent errors in LLM-generated optimization models, where models achieve the correct objective value but violate the intended constraints or variable requirements. It proposes SILENTOR, a solver-backed verification framework that identifies requirement violations through executable probes and verifiable counterexamples. Experiments show that SILENTOR substantially improves requirement-localization precision and reduces false positives compared with LLM-based inspection.

Critical strengths

The paper identifies an important failure mode in LLM-generated optimization models. The concept of silent errors is insightful, and the motivating example and empirical analysis convincingly illustrate how correct objective values can mask incorrect formulations, exposing a meaningful limitation of existing evaluation practices.

Critical weaknesses
  1. SILENTOR searches for candidate-feasible solutions that violate the specified requirements, making its verification inherently one-sided. This approach can detect errors that admit invalid solutions, but it cannot detect errors that only exclude valid solutions, including overly restrictive constraints and some incorrect constraints. Despite explicitly identifying these three categories of constraint errors, the paper neither establishes how its method handles the latter cases nor reports category-specific detection results.

  2. SILENTOR relies on LLM-generated probes, while the solver verifies violations of the probes rather than the original requirements. Although judge-based screening and witness verification mitigate this issue, the false-positive rate of 30.6% with Gemma 3 12B highlights the framework's sensitivity to probe quality.

  3. The multi-stage verification pipeline introduces additional LLM and solver calls, but the paper does not report its computational cost or discuss the trade-off between verification reliability and overhead. Its practical value therefore remains unclear.

  4. The evaluation covers only 49 silent-error cases, including 25 naturally occurring cases and 24 controlled errors. The paper does not adequately explain why only 25 natural cases were selected for verification evaluation or establish that these cases are representative. Moreover, the evaluation relies on supplied, reviewed requirements rather than testing the complete verification pipeline in existing LLM-based OR modeling systems.

Questions for authors
  1. How does SILENTOR detect overly restrictive constraints or incorrect constraints that only shrink the candidate feasible region? Could the authors report detection results separately for missing, incorrect, and overly restrictive constraints?

  2. Could the authors quantify probe fidelity and analyze how incorrectly formulated probes contribute to false positives? How does the framework distinguish genuine modeling violations from errors in the probes themselves?

  3. Could the authors report the number of LLM and solver calls, token consumption, and end-to-end runtime to clarify the trade-off between verification accuracy and computational overhead?

  4. What criteria were used to select the 25 natural-error cases from the 236 silent-error cases identified in Section 3? Could the authors evaluate SILENTOR on outputs from existing LLM-based OR modeling systems to establish its practical effectiveness?

1 comment
AuthorsOpenReview ↗

Thank you, and answers to your questions

Thank you for the careful review. We agree with your main points; below we answer each question using data already in the supplement.

Q1. Overrestrictive and shrinking incorrect constraints. We did not evaluate this direction: our evaluation set contains no overrestrictive cases, and we did not categorize or report results by error type. By design, SilentOR's witness search finds solutions the candidate admits but a requirement forbids, so it targets errors that enlarge the feasible region; an overrestrictive constraint, or an incorrect constraint that only excludes valid solutions, produces no witness. This is a one of the limitation.

Q2. Probe fidelity. The solver certifies violation of the probe, not of the requirement. Two steps try to separate the two: judges review each probe against the requirement before execution, and a witness verifier re-checks each witness against the requirement, rejecting but never creating a violation. Removing the witness check lowers precision from 96.2% to 90.9% (Appendix F). We did not measure probe fidelity directly, and the Gemma 3 12B results show strong dependence on the backbone.

Q3. Cost. We did not report computational cost, and we did not compare against a budget-matched alternative. In the paper, SilentOR verifies each candidate against its full requirement list. The method itself checks one requirement at a time (Algorithm 1), so it can also verify a single requirement or a chosen subset, with cost growing with the number of requirements checked rather than fixed per model.

Q4. Selection and generality. The 25 natural cases were chosen for coverage across problems and error types, since 67.8% of silent errors come from 16 problem–generator combinations that repeat the same mistake. Six of the 25 come from SIRL-Gurobi (Chen et al., 2025),; we did not evaluate other complete systems. We agree that 25 cases is small, that representativeness is not established, and that supplied requirements mean we evaluate verification rather than end-to-end use.

Thank you; these points identify the main limitations of the work.

Reviewer_nkd8OpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
3
Soundness
3
Read review
Paper summary

This paper is part of a line of work that studies how to use LLMs for the automated formulation of mixed-integer linear programs (MILPs) – that is, methods that translate a natural language description of an optimization problem into a MILP. An important component of this pipeline is verification: given a benchmark’s gold-standard MILP formulation and an AI-generated MILP formulation, how do we determine whether the two MILP formulations represent the same problem?

In short, given a natural language description of a MILP, the method works by:

  1. Using a strong LLM (Claude Opus 5) to determine the semantic requirements its formulation must satisfy (e.g., its constraints).
  2. Using a weak LLM (e.g., gpt-5-mini) to generate the MILP formulation.
  3. Checking, for each semantic requirement from (1), whether the MILP formulation from (2) satisfies that requirement, and using a solver to find a witness if it does not. That failure information can be passed back to the weak LLM to fix the MILP formulation.

The results show that weak LLMs often make mistakes that can be caught using this method.

Critical strengths

None.

Critical weaknesses

The method is extremely straightforward, and I can't find a way it advances our fundamental understanding of how to use AI for MILP modeling. The method seems like it could fit in as one small module of an agentic approach to MILP modeling (e.g., OptiMuS), but it is not worthy of an entire paper in and of itself.

I'll also note that typically, good papers have:

  1. A fundamental gap that they aim to fill, and
  2. A key conceptual or technical challenge that the paper overcomes to fill that gap.

The gap that this paper seems to be addressing is that weak models sometimes skip constraints when formulating MILPs. This is an important gap if we expect that downstream users will be using weak models to formulate MILPs. However, the paper's approach to filling that gap is to rely on a strong model (Opus 5) to generate the ground-truth semantic requirements of the formulations. So why not use the strong model to formulate the MILP itself? This approach seems to be sidestepping any conceptual or technical challenge, rather than overcoming it.

Questions for authors

Unfortunately, this paper would need a complete rewrite before I'd change my assessment.

1 comment
AuthorsOpenReview ↗

Clarifications on the method, and answers to your points

Thank you for the review. Parts of the summary differ from what the paper does, so we respond to it point by point, in the hope of getting your view on the paper as it actually is.

1.

"given a benchmark's gold-standard MILP formulation and an AI-generated MILP formulation, how do we determine whether the two MILP formulations represent the same problem?"

SilentOR does not compare two formulations. It receives the problem text, the data, a requirement list and the candidate code. The reference formulation, reference solution and gold objective are removed from every prompt. The gold objective is used only to build the benchmark: in Section 3, to identify objective-matching programs, 14.9% of which are wrong models that objective matching accepts; and in Section 5, to confirm that controlled mutants preserve the optimal value.

2. The requirement list. SilentOR verifies a candidate against a given requirement list, so its verdicts are only as good as that list: it cannot detect a violation of a requirement that is not listed, and an incorrect requirement can cause a false alarm. The list acts as a specification, and since requirements are checked one at a time, it can be as short as a single item. It can be written by a domain expert, drafted by an LLM, or both. In our benchmark, the lists were drafted offline with Claude Opus 5 and then manually reviewed and revised; , and we have not evaluated lists produced in other ways. No strong model runs inside SilentOR: every runtime role uses one small model (GPT-5 Nano or Gemma 3 12B). The requirement-list inspection baseline receives the identical list, so the comparison isolates the effect of the verification method.

3.

"Using a weak LLM (e.g., gpt-5-mini) to generate the MILP formulation."

This is correct for Section 3, where we study seven LLM generators, mostly small (e.g., SIRL-Qwen2.5 7B/32B, GPT-5 Nano, GPT-5 Mini), to measure how often they produce silent errors. Generation is not a step of SilentOR, however: SilentOR takes a candidate formulation as input, whether a model or a human wrote it, and in Sections 4–6 small models (GPT-5 Nano, Gemma 3 12B) serve as the verifier.

4.

"That failure information can be passed back to the weak LLM to fix the MILP formulation."

Yes, this is possible, but the paper does not do it. SilentOR's only repair loop acts on probes, not on the candidate formulation.

5.

"The results show that weak LLMs often make mistakes that can be caught using this method."

Silent errors occur for all seven generators; Claude Haiku 4.5 has the highest objective-match rate (83.0%) yet a 16.6% silent-error rate. The main verification result is that SilentOR with a small model localizes these errors better than requirement-list inspection or direct inspection with the same model and inputs: F1 90.5% vs 73.4%, and a false-positive rate of 5.6% vs 16.7% on certified-correct models

6.

"So why not use the strong model to formulate the MILP itself?"

Whichever model or person writes the formulation, its output still has to be checked: in Section 3, all seven generators produced silent errors, and objective matching cannot catch them. We note that we did not evaluate frontier models as generators. SilentOR provides that check against one requirement or a full list, written by a domain expert, drafted by an LLM, or both, and for each violated requirement it returns a solver witness as concrete evidence. It does this with a small model.

We believe this summarizes the technical contribution

Asking an LLM whether a formulation is correct is easy; making its answer trustworthy is not. With GPT-5 Nano, the false-positive rate on 36 certified-correct models falls from 33.3% (direct inspection) to 16.7% (requirement-list inspection) to 5.6% (SilentOR). On the 49 silent errors, requirement precision rises from 66.4% to 96.2% while recall also rises, from 82.0% to 85.4%, so the gain does not come from flagging less; direct inspection names no requirements, so it has no precision.

If these clarifications change your view of the paper, we would be grateful if you would consider updating your assessment; if they do not, we would value knowing which concerns remain.

Reviewer_8u3YOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies silent errors in LLM-generated optimization models: formulations that match a reference objective value while violating the intended requirements. It measures these errors across seven generators on 40 selected problems and proposes SILENTOR, which combines requirement-specific probes, solver-based counterexample search, and LLM review to localize violations. Evaluation includes natural and controlled errors, correct models, and sensitivity to witness verification and the backbone.

Critical strengths
  1. The paper addresses an important weakness of objective-value evaluation and solver-derived training rewards: a correct numerical answer need not imply a correct formulation.
  2. The measurement includes naturally generated errors, multiple generators, and problem-clustered uncertainty estimates. The paper also acknowledges the selected problem distribution and the non-significant false-positive reduction.
  3. Requirement-level localization with concrete witnesses is actionable. On natural errors, SILENTOR substantially improves precision over requirement-list inspection while preserving recall.
  4. Probe templates, prompts, and ablations make the framework reasonably concrete. The limitations concerning probe fidelity and supplied requirements are explicitly discussed.
Critical weaknesses
  1. The incremental contribution over existing verification work is insufficiently established. The observation that objective agreement does not imply formulation correctness is established in prior work, as the related-work section acknowledges. The paper’s potential contributions therefore lie in its empirical measurement and evidence-backed requirement localization. However, experiments mainly compare against direct LLM inspection, leaving unclear how SILENTOR compares with existing structural, feasible-region, constraint-level, or solver-assisted verification approaches. Review components used in process supervision or RL are also relevant, although differences in their scope should be distinguished rather than treating all such methods as directly interchangeable baselines.
  2. Coverage of overrestrictive formulations is unclear. The central counterexample search identifies solutions admitted by the candidate but forbidden by a requirement. This addresses omitted or weakened constraints, but does not generally identify valid solutions excluded by additional or overly strong constraints. Although overrestrictive errors appear in the taxonomy, the manuscript does not sufficiently establish how they are detected or how well the method performs on this error direction. This limits the interpretation of the framework as a general formulation verifier.
  3. The comparison does not control verification resources. SILENTOR uses multiple LLM calls, probe repairs, and solver executions, whereas the principal baseline directly inspects the model with a requirement list. Without token usage, latency, solver costs, and stronger tool-enabled or budget-matched controls, the experiments do not sufficiently separate the proposed architecture from additional inference resources. The verification set is also relatively small, particularly the 25 natural-error cases.
Questions for authors
  1. What capabilities distinguish SILENTOR from existing optimization-model verifiers beyond direct LLM inspection? Can the authors provide representative comparisons under a common protocol and clarify the relationship to process-review or RL-based checking components?
  2. How does SILENTOR detect overrestrictive formulations that exclude valid solutions? Please report results separately for feasible-region expansion and restriction, with a representative example of each.
  3. What are the token usage, latency, solver runtime, and invocation counts per model? Does the advantage persist against a tool-enabled or budget-matched verifier?
  4. Can model-level verdicts distinguish confirmed violations, all supplied requirements passing, and unresolved verification? Please report model-level unresolved coverage and analyze the remaining false positives.
  5. How robust is the method to equivalent alternative formulations and ambiguity in requirement-to-probe translation? Can the authors explain the major failure modes behind the backbone-dependent performance drop?
1 comment

Thank you for the detailed and constructive review. We agree with most of the weaknesses and answer each question briefly.

Q1. Relation to existing verifiers. Reference-based methods (ModelEquivBench, ORGEval, component precision/recall) compare a candidate with a gold formulation and report agreement for a whole relation or component type; Opt-Verifier returns a verdict with a natural-language rationale; agent-based validation returns a test-coverage score. SilentOR needs no reference formulation, although it relies on a reviewed requirement list context, and it names the violated requirement with a solver witness or declaration evidence (Appendix D). Process-review and RL components such as StepORLM's reward model or SIRL's solver reward act during training; SilentOR checks a finished formulation and could in principle serve as a reward signal, which we have not tested. We did not compare against these methods under a common protocol, so an empirical advantage over them is not established.

Q2. Overrestrictive formulations. We did not evaluate SilentOR on overrestrictive formulations. We focused on errors that enlarge the feasible region, which account for most silent errors in Section 3: missing constraints alone are 42.8%, while overrestrictive constraints are 4.7%. SilentOR's witness search finds solutions the candidate admits but a requirement forbids, so a formulation that only excludes valid solutions produces no witness. An example of the expansion case is P9 (Figure 4), . We did not report results by direction, and extending verification to restriction errors is future work.

Q3. Cost and budget-matched control. We did not report cost for SilentOR or for the requirement-list inspection and direct-inspection baselines, and we did not compare against a tool-enabled, budget-matched verifier, so the gain cannot yet be separated from additional inference. SilentOR checks one requirement at a time, so it can also verify a single requirement or a chosen subset, with cost growing with the number of requirements checked.

Q4. Model-level verdicts. The per-requirement statuses (PASS, FAIL, WITNESS-REJECT, UNRESOLVED; Section 4.3) support a three-way model verdict: violation confirmed, all requirements pass, or unresolved. The paper, however, reports unresolved rates only per requirement (11.2% on certified-correct models) and does not analyze false positives.

**Q5. The remaining ambiguity is in auxiliary variables, such as activation indicators, which candidates may encode differently. With Gemma 3 12B instead of GPT-5 Nano, SilentOR's precision falls from 96.2% to 50.0%, recall from 85.4% to 66.3%, and its false-positive rate rises from 5.6% to 30.6%. The drop comes mainly from the probe generator agent : the weaker backbone writes more probes that misencode their requirement, and the judges accept more of them. Even so, SilentOR still improves on requirement-list inspection when both use Gemma 3 12B (precision 50.0% vs 28.1%, false-positive rate 30.6% vs 63.9%).

Thank you; these questions clearly identify what the work still needs.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.