Pith. sign in

REVIEW 4 major objections 5 minor 43 references

Backward semantic-anchor correction, not solver feedback, is claimed to drive modeling fidelity in LLM optimization, with a 7.8% average accuracy gain and up to 21.9% on ComplexLP.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-04 14:37 UTC pith:EWBYY524

load-bearing objection Sensible new correction loop with external accuracy wins, but the semantic oracle is unvalidated and the causality claim needs a random-regeneration control before it is accepted. the 4 major comments →

arxiv 2510.05115 v3 pith:EWBYY524 submitted 2025-09-28 cs.AI cs.CLcs.PL

SAC-Opt: Semantic Anchors for Iterative Correction in Optimization Modeling

Yansen Zhang , Qingcan Kang , Yujie Chen , Yufei Wang , Xiongwei Han , Tao Zhong , Mingxuan Yuan , Chen Ma This is my paper
classification cs.AI cs.CLcs.PL
keywords optimization modelingLLM code generationsemantic anchorsiterative correctionsemantic consistency verificationconstraint and objective alignmentsolver-executable codebackward correction
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

SAC-Opt claims that optimization-modeling errors that silently survive solver execution can be caught by a backward semantic loop rather than by solver feedback. The paper introduces semantic anchors—the constraints and objective extracted from a natural-language problem description—and iteratively regenerates only the code fragments whose reconstructed anchors fail to match the originals. On seven public datasets the method raises average modeling accuracy by 7.8%, with the largest gain (21.9%) on ComplexLP. The claim matters because it identifies a path to verifying code against problem intent without extra training or supervision.

Core claim

The paper's central claim is that grounding correction in problem semantics outperforms grounding it in solver error messages. Concretely, after structured data extraction, SAC-Opt translates each constraint and objective into code, runs a reconstruction agent that rewrites the code's semantics back into natural language, and compares the rewritten anchor with the original via an LLM judge or embedding cosine similarity. Only mismatched anchors are regenerated, and the loop repeats until alignment or a limit. Reported accuracy improvements across seven datasets (average +7.8%, ComplexLP +21.9%) support the claim that semantic-anchor alignment, not solver debugging, drives fidelity.

What carries the argument

Semantic anchors are the extracted constraint and objective descriptions serving as reference statements of problem intent. The load-bearing mechanism is the iterative alignment loop: reconstruct anchors from generated code, compare via a consistency function δ (an LLM binary classifier or a cosine-similarity threshold τ=0.75), build the error set of mismatched anchors, and regenerate only those fragments. This selective correction is what the paper argues yields convergence toward faithful models.

Load-bearing premise

The consistency check δ is assumed to be a trustworthy judge of semantic equivalence, but it is never validated against labeled mismatch data, so the loop can stop on false agreement or churn on false disagreements.

What would settle it

Take a generated solution whose code runs correctly but contains a deliberately reversed constraint (upper bound written as lower bound) or a silently dropped constraint, then run SAC-Opt and count whether the verifier flags it and the loop corrects it; if the flawed code passes, the semantic oracle fails.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • If the central claim holds, LLM-based optimization workflows can catch semantic errors that are invisible to solver execution, such as a reversed inequality or a missing constraint.
  • The framework requires no additional training or human supervision, so it can be layered onto existing generation pipelines and backbone LLMs.
  • The ablation results indicate that semantic correction contributes more to accuracy than solver-level debugging, suggesting where future effort should concentrate.
  • The method transfers to a different open-source backbone model, showing the correction mechanism itself, not a specific model, produces the gains.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The reported gains rest on the reliability of the consistency check; a naturally testable extension is to build a labeled mismatch dataset to calibrate either the LLM judge or the similarity threshold, something the paper does not do.
  • If the verifier is biased toward accepting rephrased descriptions, the loop may terminate early on false agreement—an adversarial reader could probe this with deliberate semantic errors.
  • The same anchor-alignment idea could transfer to other structured code-generation tasks where a natural-language specification can be decomposed into checkable semantic units.
  • The runtime trade-off between LLM-based and similarity-based verification suggests a hybrid or adaptive verifier as a concrete next step.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper proposes SAC-Opt, a backward semantic-anchor correction framework for generating optimization solver code from natural-language problems. The pipeline extracts structured data (parameters, variables, constraints, objective) from the problem statement, generates an initial model by deterministic templates for simple components and by an LLM agent for constraints/objective, then iteratively reconstructs natural-language anchors from the generated code, compares them with the original anchors through an LLM judge or cosine similarity threshold, and regenerates only the mismatched code fragments. Once the error set is empty or T_max iterations are reached, solver-feedback debugging is applied. Experiments on seven public datasets report average accuracy gains of 7.8% over the best baseline, with the largest gain (21.9%) on ComplexLP.

Significance. If the reported gains are robust, SAC-Opt is a useful contribution to LLM-based optimization modeling: it targets semantic errors that solver feedback cannot detect, and its final evaluation is based on an external ground-truth metric (objective value and solution), which avoids the circularity of judging the method by its own verifier. The framework is modular, model-agnostic (demonstrated with Qwen2.5-72B), and the source code is released. However, the central causal claim—that semantic-anchor selectivity, rather than the extra regeneration passes, drives the improvement—rests on an unvalidated consistency oracle and on an ablation that does not include a regeneration control. The convergence behavior is also asserted rather than demonstrated. These issues leave the main mechanism plausible but not yet established.

major comments (4)
  1. [Sec. 3.5, Eqs. (8)-(10); App. A.2-A.3] The entire correction loop is driven by the binary consistency function δ, yet neither implementation is validated. The LLM verifier (Eq. 9) is prompted only to judge 'consistency' (Appendix A.3), and the cosine threshold τ=0.75 (Eq. 10) is chosen without labeled original/reconstructed anchor pairs. Appendix A.2 explicitly instructs the reconstruction model to rephrase code semantics while matching the example description's structure and length, so a semantically wrong code can pass verification if the verifier cannot see the error. Table 2 shows only that removing the loop hurts; it does not show that the selectivity of δ is what helps. Without a random-regeneration control matched for number of LLM calls, the reported gains may come from regeneration alone rather than semantic grounding. Please validate δ on a labeled mismatch set and report precision/recall, and add a control that reg
  2. [Sec. 4.3, Table 1] The paper states that all results are averaged over five independent runs, but Table 1 reports no standard deviations, confidence intervals, or significance tests. Several improvements are small in absolute terms: +1.8% on ComplexOR (58.9 vs 52.2) and +2.1% on EasyLP (96.5 vs 92.4). With five runs, these differences may be within noise. Table 4 reports mean±SD only for correction/debugging counts, not for accuracy. Please report per-dataset variance and, where appropriate, paired significance tests.
  3. [Sec. 3.5, Appendix A.4] The paper claims convergence toward semantic alignment, but no evidence is given that |E(t)| decreases monotonically or that regeneration cannot reintroduce errors in previously aligned anchors. Algorithm 1 terminates when E(t)=∅ or Tmax=5; without aggregate termination statistics, the reader cannot tell whether the loop usually converges to full alignment or simply runs out of iterations. Appendix A.4 reports a single case study and average correction counts. Please report per-iteration error-set sizes aggregated over instances and the fraction of runs terminating with an empty error set.
  4. [Sec. 4.3 / Appendix A.6] The evaluation protocol for baselines is unclear. The paper says it directly reports Standard, CoT, CoE, and CAFA results from Xiao et al. (2025) but also states that all methods operate on structured data produced by a shared pipeline. If the quoted baselines did not receive the same structured-data extraction as SAC-Opt (or if the extraction is the OptiMUS-0.3 pipeline), the comparison may conflate extraction quality with correction quality. Please specify exactly which input representation each baseline received and, ideally, rerun the quoted baselines in the same harness.
minor comments (5)
  1. [Abstract and Conclusion] The average accuracy improvement is reported as 7.7% in one version of the abstract and 7.8% elsewhere (e.g., Sec. 4.4 and Conclusion); reconcile the numbers.
  2. [Figure 1, Sec. 1] 'the total investment must cannot exceed the $100 budget' contains a grammatical error; also 'Trans Agent'/'Recons Agent' labels could be expanded to 'Translation Agent'/'Reconstruction Agent' for readability.
  3. [Appendix A.3] In the verifier prompt, 'The asnswer should be' should be 'The answer should be'.
  4. [Tables 4 and 7] The two verification variants are named 'LLM'/'Sim' in Table 4 but 'SAC-Opt-LLM'/'SAC-Opt-Sim' in Table 7; unify notation.
  5. [Sec. 4.3] The choice of τ=0.75 for cosine similarity is mentioned only once; a sensitivity analysis for τ (or at least a justification) would help, since the Sim variant is used to claim robustness.

Circularity Check

1 steps flagged

The reconstruction prompt leaks the original semantic anchor into the reconstruction, so the consistency oracle δ can report agreement by paraphrase rather than by code fidelity; the headline accuracy is still externally measured against solver output.

specific steps
  1. self definitional [Appendix A.2 (reconstruction prompt), Eq. 7 in Sec. 3.4, Eqs. 8–11 in Sec. 3.5]
    "You are given a constraint implemented in {solver} code and an example natural language description that serves only as a reference for sentence structure and length. Your task is to generate a **new** natural language description that: 1. **Is derived strictly from the given code ** - do not assume information not present in the code. 2. **Maintains the structure, length, and complexity of the example description **, but is reworded. The example description for the constraint is (For Structure & Length Reference Only, NOT for Content Copying): ----- {constraint} -----"

    Eq. 7 defines bSsem = f_recons_agent(Msem), but the prompt that defines f_recons_agent (Appendix A.2) feeds the original anchor s_i into the model as the 'example description' and asks the model to match its structure and length while rewording. Thus the reconstructed anchor bs_i is a paraphrase of s_i conditioned on s_i, not an independent readout of the code. Eq. 8 then defines δ(s_i, bs_i)=1 when s_i ≡ bs_i, so the consistency check compares s_i to a paraphrase of s_i. The error set E(t) in Eq. 11 and the convergence criterion are built on this self-comparison, so a wrong code can pass when the reconstructor echoes the supplied anchor. This makes the claimed 'semantic alignment' self-referential: the original anchor, the reconstructed anchor, and the verifier all come from the same LLM

full rationale

The paper's headline results are not circular in the strongest sense: accuracy is measured externally by executing the generated code on a solver and comparing the objective value and solution against dataset ground truth (Sec. 4.3). The ablation study (Table 2) and cross-model generalization (Table 3) also provide independent evidence that removing the correction loop hurts accuracy. However, the paper's central mechanistic claim—that semantic-anchor alignment, not regeneration or solver feedback, drives the gains—relies on the consistency oracle δ (Eqs. 8–10) to identify which anchors are misaligned. That oracle is compromised by the reconstruction prompt in Appendix A.2, which includes the original anchor as an 'example description' for the LLM to mimic. Consequently, the reconstructed anchor is not a pure function of the generated code, and the equivalence check can pass when the reconstructor paraphrases the supplied original rather than faithfully reflecting the code. This is a structural, by-construction issue in the verification loop, not merely a speculation about LLM behavior. Separately, some baseline numbers in Table 1 are self-cited from Xiao et al. (2025), which shares authors with this paper; but those citations are not load-bearing for the causal claim, since the ablation and Qwen experiments are run by the present authors. Overall, the benchmark result survives, but the internal semantic-alignment guarantee is partially circular, giving a score of 5.

Axiom & Free-Parameter Ledger

3 free parameters · 4 axioms · 0 invented entities

The method rests on two untested reliability assumptions: LLM extraction is accurate enough, and LLM or similarity verification is a faithful oracle for semantic equivalence. The similarity threshold tau=0.75, T_max=5, and the debugging limit are hand-chosen. No new entities are postulated.

free parameters (3)
  • cosine similarity threshold tau = 0.75
    Hand-chosen in Sec 4.3 for the similarity-based verification variant (Eq. 10); affects correction-loop behavior and results in Table 4.
  • maximum correction iterations T_max = 5
    Set in Sec 4.3; caps the loop and therefore bounds accuracy and runtime, although most instances converge earlier.
  • debugging attempts limit = 3
    Uniformly set for all methods in Sec 4.3 to ensure fairness; partly determines final accuracy after solver errors.
axioms (4)
  • domain assumption LLM-based structured data extraction returns accurate parameters, variables, constraints, and objective from natural language.
    Invoked in Eq. 3 and Sec 3.2; the paper adopts OptiMUS-0.3's extractor and reports manual-review accuracy in Appendix A.6, but extraction errors would propagate to all anchors.
  • domain assumption The verification functions delta_LLM (Eq. 9) and delta_sim (Eq. 10) correctly detect semantic equivalence between original and reconstructed anchors.
    This is the load-bearing correction signal; no validation set, confusion matrix, or threshold calibration is provided.
  • domain assumption Reconstructed anchors (Eq. 7) faithfully capture the semantics of the generated code.
    The reconstruction prompt (Appendix A.2) tells the model to derive descriptions strictly from code and to match the original's structure; faithfulness is assumed, not measured.
  • domain assumption Solver-based accuracy (correct objective value and solution) is a valid measure of semantic correctness.
    Sec 4.3; this is the standard field metric and gives external grounding, but it only measures end-to-end success, not anchor-level correctness.

pith-pipeline@v1.3.0-alltime-deepseek · 16179 in / 11288 out tokens · 311299 ms · 2026-08-04T14:37:46.124279+00:00 · methodology

0 comments
read the original abstract

Large language models (LLMs) have opened new paradigms in optimization modeling by enabling the generation of executable solver code from natural language descriptions. Despite this promise, existing approaches typically remain solver-driven: they rely on single-pass forward generation and apply limited post-hoc fixes based on solver error messages, leaving undetected semantic errors that silently produce syntactically correct but logically flawed models. To address this challenge, we propose SAC-Opt, a backward-guided correction framework that grounds optimization modeling in problem semantics rather than solver feedback. At each step, SAC-Opt aligns the original semantic anchors with those reconstructed from the generated code and selectively corrects only the mismatched components, driving convergence toward a semantically faithful model. This anchor-driven correction enables fine-grained refinement of constraint and objective logic, enhancing both fidelity and robustness without requiring additional training or supervision. Empirical results on seven public datasets demonstrate that SAC-Opt improves average modeling accuracy by 7.7%, with gains of up to 21.9% on the ComplexLP dataset. These findings highlight the importance of semantic-anchored correction in LLM-based optimization workflows to ensure faithful translation from problem intent to solver-executable code.

Figures

Figures reproduced from arXiv: 2510.05115 by Chen Ma, Mingxuan Yuan, Qingcan Kang, Tao Zhong, Xiongwei Han, Yansen Zhang, Yufei Wang, Yujie Chen.

Figure 1
Figure 1. Figure 1: Overview of the SAC-Opt workflow. Semantic anchors, referring to the constraints and [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Comparison of cardinality of the error set and iteration count in SAC-Opt. Here the [PITH_FULL_IMAGE:figures/full_fig_p017_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Comparison of average correction and debugging numbers in SAC-Opt. [PITH_FULL_IMAGE:figures/full_fig_p018_3.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

43 extracted references · 12 linked inside Pith

  1. [1]

    Gpt-4 technical report

    Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. Gpt-4 technical report. arXiv preprint arXiv:2303.08774, 2023

    Pith/arXiv arXiv 2023

  2. [2]

    Optimus-0.3: Using large language models to model and solve optimization problems at scale

    Ali AhmadiTeshnizi, Wenzhi Gao, Herman Brunborg, Shayan Talaei, and Madeleine Udell. Optimus-0.3: Using large language models to model and solve optimization problems at scale. arXiv preprint arXiv:2407.19633, 2024 a

    Pith/arXiv arXiv 2024

  3. [3]

    Optimus: Scalable optimization modeling with (MI)LP solvers and large language models

    Ali AhmadiTeshnizi, Wenzhi Gao, and Madeleine Udell. Optimus: Scalable optimization modeling with (MI)LP solvers and large language models. In ICML, 2024 b

    2024

  4. [4]

    Practical Optimization: Algorithms and Engineering Applications

    Andreas Antoniou and Wu-Sheng Lu. Practical Optimization: Algorithms and Engineering Applications. Springer, 2007

    2007

  5. [5]

    Autoformulation of mathematical optimization models using llms

    Nicol \'a s Astorga, Tennison Liu, Yuanzhang Xiao, and Mihaela van der Schaar. Autoformulation of mathematical optimization models using llms. arXiv preprint arXiv:2411.01679, 2024

    Pith/arXiv arXiv 2024

  6. [6]

    The gurobi optimizer

    Bob Bixby. The gurobi optimizer. Transfp. Re-search Part B, 41 0 (2): 0 159--178, 2007

    2007

  7. [7]

    Introduction to modern information retrieval

    Gobinda G Chowdhury. Introduction to modern information retrieval. Facet publishing, 2010

    2010

  8. [8]

    IBM ILOG Cplex. V12. 1: User’s manual for cplex. International Business Machines Corporation, 46 0 (53): 0 157, 2009

    2009

  9. [9]

    Cafa: Coding as auto-formulation can boost large language models in solving linear programming problem

    Haoxuan Deng, Bohao Zheng, Yirui Jiang, and Trung Hieu Tran. Cafa: Coding as auto-formulation can boost large language models in solving linear programming problem. In Workshop on MATH-AI at NeurIPS, 2024

    2024

  10. [10]

    A survey on the optimization of large language model-based agents

    Shangheng Du, Jiabao Zhao, Jinxin Shi, Zhentao Xie, Xin Jiang, Yanhong Bai, and Liang He. A survey on the optimization of large language model-based agents. arXiv preprint arXiv:2503.12434, 2025

    arXiv 2025

  11. [11]

    Kto: Model alignment as prospect theoretic optimization

    Kawin Ethayarajh, Winnie Xu, Niklas Muennighoff, Dan Jurafsky, and Douwe Kiela. Kto: Model alignment as prospect theoretic optimization. arXiv preprint arXiv:2402.01306, 2024

    Pith/arXiv arXiv 2024

  12. [12]

    Cardinal O ptimizer (COPT) user guide

    Dongdong Ge, Qi Huangfu, Zizhuo Wang, Jian Wu, and Yinyu Ye. Cardinal O ptimizer (COPT) user guide. https://guide.coap.online/copt/en-doc, 2023

    2023

  13. [13]

    A survey on llm-as-a-judge

    Jiawei Gu, Xuhui Jiang, Zhichao Shi, Hexiang Tan, Xuehao Zhai, Chengjin Xu, Wei Li, Yinghan Shen, Shengjie Ma, Honghao Liu, et al. A survey on llm-as-a-judge. arXiv preprint arXiv:2411.15594, 2024

    Pith/arXiv arXiv 2024

  14. [14]

    Pyomo: modeling and solving mathematical programs in python

    William E Hart, Jean-Paul Watson, and David L Woodruff. Pyomo: modeling and solving mathematical programs in python. Mathematical Programming Computation, 3: 0 219--260, 2011

    2011

  15. [15]

    When large language model meets optimization

    Sen Huang, Kaixiang Yang, Sheng Qi, and Rui Wang. When large language model meets optimization. Swarm and Evolutionary Computation, 90: 0 101663, 2024 a

    2024

  16. [16]

    Mamo: a mathematical modeling benchmark with solvers

    Xuhan Huang, Qingning Shen, Yan Hu, Anningzhe Gao, and Benyou Wang. Mamo: a mathematical modeling benchmark with solvers. arXiv preprint arXiv:2405.13144, 2024 b

    Pith/arXiv arXiv 2024

  17. [17]

    Llmopt: Learning to define and solve general optimization problems from scratch

    Caigao Jiang, Xiang Shu, Hong Qian, Xingyu Lu, Jun Zhou, Aimin Zhou, and Yang Yu. Llmopt: Learning to define and solve general optimization problems from scratch. In ICLR, 2025

    2025

  18. [18]

    To the globe (ttg): Towards language-driven guaranteed travel planning

    Da Ju, Song Jiang, Andrew Cohen, Aaron Foss, Sasha Mitts, Arman Zharmagambetov, Brandon Amos, Xian Li, Justine T Kao, Maryam Fazel-Zarandi, et al. To the globe (ttg): Towards language-driven guaranteed travel planning. In EMNLP, 2024

    2024

  19. [19]

    When can llms actually correct their own mistakes? a critical survey of self-correction of llms

    Ryo Kamoi, Yusen Zhang, Nan Zhang, Jiawei Han, and Rui Zhang. When can llms actually correct their own mistakes? a critical survey of self-correction of llms. TACL, 12: 0 1417--1440, 2024

    2024

  20. [20]

    Large language models for supply chain optimization

    Beibin Li, Konstantina Mellou, Bo Zhang, Jeevan Pathuri, and Ishai Menache. Large language models for supply chain optimization. arXiv preprint arXiv:2307.03875, 2023

    Pith/arXiv arXiv 2023

  21. [21]

    Llms-as-judges: a comprehensive survey on llm-based evaluation methods

    Haitao Li, Qian Dong, Junjie Chen, Huixue Su, Yujia Zhou, Qingyao Ai, Ziyi Ye, and Yiqun Liu. Llms-as-judges: a comprehensive survey on llm-based evaluation methods. arXiv preprint arXiv:2412.05579, 2024

    Pith/arXiv arXiv 2024

  22. [22]

    Towards foundation models for mixed integer linear programming

    Sirui Li, Janardhan Kulkarni, Ishai Menache, Cathy Wu, and Beibin Li. Towards foundation models for mixed integer linear programming. In ICLR, 2025

    2025

  23. [23]

    State of mathematical optimization report 2023

    Gurobi Optimization. State of mathematical optimization report 2023. https://www.gurobi.com/lp/or/state-of-mathematical-optimization-report-2023/, 2023

    2023

  24. [24]

    Automatically correcting large language models: Surveying the landscape of diverse automated correction strategies

    Liangming Pan, Michael Saxon, Wenda Xu, Deepak Nathani, Xinyi Wang, and William Yang Wang. Automatically correcting large language models: Surveying the landscape of diverse automated correction strategies. TACL, 12: 0 484--506, 2024

    2024

  25. [25]

    Nl4opt competition: Formulating optimization problems based on their natural language descriptions

    Rindranirina Ramamonjison, Timothy Yu, Raymond Li, Haley Li, Giuseppe Carenini, Bissan Ghaddar, Shiqi He, Mahdi Mostajabdaveh, Amin Banitalebi-Dehkordi, Zirui Zhou, and Yong Zhang. Nl4opt competition: Formulating optimization problems based on their natural language descriptions. In NeurIPS Competition Track, pp.\ 189--203, 2023

    2023

  26. [26]

    Can you trust llm judgments? reliability of llm-as-a-judge

    Kayla Schroeder and Zach Wood-Doughty. Can you trust llm judgments? reliability of llm-as-a-judge. arXiv preprint arXiv:2412.12509, 2024

    Pith/arXiv arXiv 2024

  27. [27]

    Reflexion: Language agents with verbal reinforcement learning

    Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. Reflexion: Language agents with verbal reinforcement learning. In NeurIPS, 2023

    2023

  28. [28]

    An overview of the optimization modelling applications

    Ajay Singh. An overview of the optimization modelling applications. Journal of Hydrology, 466: 0 167--182, 2012

    2012

  29. [29]

    Orlm: Training large language models for optimization modeling

    Zhengyang Tang, Chenyu Huang, Xin Zheng, Shixi Hu, Zizhuo Wang, Dongdong Ge, and Benyou Wang. Orlm: Training large language models for optimization modeling. arXiv preprint arXiv:2405.17743, 2024

    Pith/arXiv arXiv 2024

  30. [30]

    A theoretical understanding of self-correction through in-context alignment

    Yifei Wang, Yuyang Wu, Zeming Wei, Stefanie Jegelka, and Yisen Wang. A theoretical understanding of self-correction through in-context alignment. In NeurIPS, 2024

    2024

  31. [31]

    Chain-of-thought prompting elicits reasoning in large language models

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. Chain-of-thought prompting elicits reasoning in large language models. In NeurIPS, 2022

    2022

  32. [32]

    Chain-of-experts: When llms meet complex operations research problems

    Ziyang Xiao, Dongxiang Zhang, Yangjun Wu, Lilin Xu, Yuan Jessica Wang, Xiongwei Han, Xiaojin Fu, Tao Zhong, Jia Zeng, Mingli Song, and Gang Chen. Chain-of-experts: When llms meet complex operations research problems. In ICLR, 2024

    2024

  33. [33]

    A survey of optimization modeling meets LLMs : Progress and future directions

    Ziyang Xiao, Jingrong Xie, Lilin Xu, Shisi Guan, Jingyan Zhu, Xiongwei Han, WingYin Yu, Han Wu, Wei Shi, Qingcan Kang, Jiahui Duan, Mingxuan Yuan, Jia Zeng, Yuan Wang, Gang Chen, and Dongxiang Zhang. A survey of optimization modeling meets LLMs : Progress and future directions. In IJCAI, 2025

    2025

  34. [34]

    Towards human-aligned evaluation for linear programming word problems

    Linzi Xing, Xinglu Wang, Yuxi Feng, Zhenan Fan, Jing Xiong, Zhijiang Guo, Xiaojin Fu, Rindra Ramamonjison, Mahdi Mostajabdaveh, Xiongwei Han, et al. Towards human-aligned evaluation for linear programming word problems. In LREC-COLING, 2024

    2024

  35. [35]

    Optibench meets resocratic: Measure and improve llms for optimization modeling

    Zhicheng Yang, Yiwei Wang, Yinya Huang, Zhijiang Guo, Wei Shi, Xiongwei Han, Liang Feng, Linqi Song, Xiaodan Liang, and Jing Tang. Optibench meets resocratic: Measure and improve llms for optimization modeling. In ICML, 2024

    2024

  36. [36]

    Solving general natural-language-description optimization problems with large language models

    Jihai Zhang, Wei Wang, Siyan Guo, Li Wang, Fangquan Lin, Cheng Yang, and Wotao Yin. Solving general natural-language-description optimization problems with large language models. In ACL, 2024 a

    2024

  37. [37]

    Understanding the dark side of llms' intrinsic self-correction

    Qingjie Zhang, Han Qiu, Di Wang, Haoting Qian, Yiming Li, Tianwei Zhang, and Minlie Huang. Understanding the dark side of llms' intrinsic self-correction. arXiv preprint arXiv:2412.14959, 2024 b

    Pith/arXiv arXiv 2024

  38. [38]

    Decision information meets large language models: The future of explainable operations research

    Yansen Zhang, Qingcan Kang, Wing Yin Yu, Hailei Gong, Xiaojin Fu, Xiongwei Han, Tao Zhong, and Chen Ma. Decision information meets large language models: The future of explainable operations research. In ICLR, 2025 a

    2025

  39. [39]

    Self-correction makes llms better parsers

    Ziyan Zhang, Yang Hou, Chen Gong, and Zhenghua Li. Self-correction makes llms better parsers. arXiv preprint arXiv:2504.14165, 2025 b

    Pith/arXiv arXiv 2025

  40. [40]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION format.date year duplicate empty "emp...

  41. [41]

    @esa (Ref

    \@ifxundefined[1] #1\@undefined \@firstoftwo \@secondoftwo \@ifnum[1] #1 \@firstoftwo \@secondoftwo \@ifx[1] #1 \@firstoftwo \@secondoftwo [2] @ #1 \@temptokena #2 #1 @ \@temptokena \@ifclassloaded agu2001 natbib The agu2001 class already includes natbib coding, so you should not add it explicitly Type <Return> for now, but then later remove the command n...

  42. [42]

    \@lbibitem[] @bibitem@first@sw\@secondoftwo \@lbibitem[#1]#2 \@extra@b@citeb \@ifundefined br@#2\@extra@b@citeb \@namedef br@#2 \@nameuse br@#2\@extra@b@citeb \@ifundefined b@#2\@extra@b@citeb @num @parse #2 @tmp #1 NAT@b@open@#2 NAT@b@shut@#2 \@ifnum @merge>\@ne @bibitem@first@sw \@firstoftwo \@ifundefined NAT@b*@#2 \@firstoftwo @num @NAT@ctr \@secondoft...

  43. [43]

    @open @close @open @close and [1] URL: #1 \@ifundefined chapter * \@mkboth \@ifxundefined @sectionbib * \@mkboth * \@mkboth\@gobbletwo \@ifclassloaded amsart * \@ifclassloaded amsbook * \@ifxundefined @heading @heading NAT@ctr thebibliography [1] @ \@biblabel @NAT@ctr \@bibsetup #1 @NAT@ctr @ @openbib .11em \@plus.33em \@minus.07em 4000 4000 `\.\@m @bibit...