Pith. sign in

REVIEW 4 major objections 6 minor 1 cited by

CHORUS: Zero-shot Hierarchical Retrieval and Orchestration for Generating Linear Programming Code

T0 review · 4 major / 6 minor · reviewed 2026-08-16 · deepseek-v4-flash

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

Pith's one-line read CHORUS, a zero-shot retrieval pipeline, lifts open-source LLMs' accuracy at generating Gurobi LP code to match or beat GPT-3.5 and GPT-4, using hierarchical documentation chunks, metadata-tagged code examples, and structured reasoning.

desk verdict A plausible and useful RAG recipe for LP code generation, with large reported gains that deserve independent validation before being taken at face value. read the letter →

arxiv 2505.01485 v1 pith:CDEASGTE submitted 2025-05-02 cs.AI cs.CL

Tasnim Ahmed , Salimur Choudhury This is my paper · ORCID
classification cs.AIcs.CL MSC 90C0568T5068T07
keywords linearprogramminglargelanguagemodelscodegenerationretrieval-augmentedGurobisolverhierarchicalchunkingcross-encoderrerankingstructuredreasoning
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

The paper tries to show that the bottleneck in asking large language models to write solver-specific optimization code is not model size but context. It proposes CHORUS, a zero-shot retrieval-augmented generation framework, which feeds a model the right pieces of a solver manual and matching example programs before generation. Gurobi is a commercial optimization solver with a Python API; the paper targets writing its LP code from natural-language problem statements. On a benchmark built from the NL4Opt problems paired with Gurobi reference code, CHORUS improved accuracy of five open-source models by margins of roughly 5 to 48 percentage points, with four of the five matching or beating GPT-3.5 and approaching GPT-4's 63.67% accuracy while running locally. The practical claim is that resource-efficient local models can take on specialized code-generation tasks previously reserved for large closed-model APIs.

What carries the argument

The load-bearing mechanism is the retrieval context. Theoretical content from the Gurobi manual is segmented into a hierarchical tree, and each retrieved chunk is assembled by prepending parent summaries to child text so the model sees a self-contained concept. Code examples are kept whole and enriched with generated metadata: 5-7 domain keywords and a 2-3 line synopsis, which lets natural-language queries match the examples' function rather than their syntax. Two-stage retrieval first pulls candidates by embedding cosine similarity, then a cross-encoder reranks query-document pairs and keeps the top three conceptual and top two code documents. The structured output schema adds a reasoning_steps field, which the paper argues preserves stepwise reasoning that strict code-only formatting tends to suppress.

What would settle it

Run CHORUS on a different LP code benchmark whose reference solutions were written independently of the Gurobi reference manual (for example, by a separate team using different solver idioms) and compare accuracy; if the gains shrink or vanish, the reported result depends on the specific documentation corpus. Alternatively, remove the reasoning_steps field while keeping retrieval fixed, since the ablation reports up to 92% accuracy loss from that single change.

Watch

Extended reading notes

Core claim

The central claim is that CHORUS enables zero-shot generation of Gurobi LP code from natural-language problem descriptions at accuracy levels comparable to much larger commercial models. The framework's key finding is that retrieval quality for technical documentation depends on preserving the document's own structure: theory text is chunked as a tree so each slice carries its parent's summary, and complete code examples are indexed by LLM-generated keywords and short synopses rather than by raw syntax. Candidates are gathered by embedding similarity, then a cross-encoder reranks them and keeps only the top three conceptual chunks and two code examples. An expert prompt plus a structured output schema with a reasoning_steps field forces the model to justify how each variable, constraint, and objective maps to the problem text. On the NL4Opt-Code benchmark, CHORUS raised Phi4-14B accuracy from 19.38% to 61.25%, Qwen2.5-coder-32B from 46.44% to 59.86%, and Llama3.3-70B from 22.89% to 56.75%, while the 8B Llama model improved only modestly from 7.96% to 13.49%.

Load-bearing premise

The paper assumes that two Gurobi programs are equivalent when they return the same optimal objective value on the evaluation problems, so reported accuracy could overstate correctness if a generated program reaches that value for the wrong reasons or if the reference solutions are flawed.

Editorial extensions

If this is right

  • Four open-source LLMs with CHORUS match or beat GPT-3.5 and approach GPT-4 on LP code accuracy, so resource-constrained or offline deployments could substitute local models for commercial APIs.
  • The reasoning_steps field is load-bearing: omitting it drops accuracy by 1.71% to 92.29% across model scales, so structured chain-of-thought is part of the recipe, not decoration.
  • Fixed-size chunking in traditional RAG reduces accuracy by 46-89% relative to CHORUS, implying poor context selection can outweigh a model's built-in coding expertise.
  • CHORUS is zero-shot and solver-independent, so the same retrieval recipe can be redirected to other solver APIs or related mathematical programming tasks without fine-tuning.
  • The framework keeps syntactic validity near 1.0 for most models, suggesting that coherent context also reduces parser-level errors in generated code.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The metadata-augmented code retrieval generalizes to other documentation-heavy code generation tasks where raw API syntax mismatches natural-language queries, such as pandas or tensorflow examples.
  • A direct testable extension is to apply CHORUS to mixed-integer or nonlinear Gurobi code; these formulations involve more solver-specific patterns, so the retrieval gains could be larger than for pure LP.
  • If the benchmark adopted a stricter equivalence check (constraint-by-constraint mathematical equivalence instead of matching objective value), the measured gains might be smaller but would better reflect genuine modeling correctness.
  • Parent-summary prepending is a form of hierarchical context compression; a natural follow-up is to measure whether it matters most for nested concept structures versus flat APIs, which would tell when CHORUS-style chunking is worthwhile.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 6 minor

Summary. The paper proposes CHORUS, a zero-shot retrieval-augmented generation (RAG) framework for synthesizing Gurobi-based Linear Programming (LP) code from natural language problem statements. CHORUS uses hierarchical tree-based chunking for theoretical documentation, metadata-augmented indexing of code examples, a two-stage retriever with cross-encoder reranking, and a structured output schema with a reasoning_steps field. Experiments on the author-curated NL4Opt-Code benchmark report accuracy gains across several open-source LLMs (Llama3.1, Llama3.3, Phi4, Deepseek-r1, Qwen2.5-coder) over baselines and traditional RAG, with the larger open models reaching or approaching GPT-4 performance. The paper also presents ablation results for expert prompting, traditional RAG, and structured reasoning.

Significance. If the claims hold, the paper offers a practical, LLM-agnostic pipeline that reduces reliance on closed-source models for a specialized code-generation task, which would be a useful contribution to the optimization and LLM communities. The design ideas—hierarchical chunking that respects document structure and metadata-augmented retrieval to bridge the vocabulary gap between natural language and solver code—are reasonable and potentially transferable to other solver APIs. However, the strength of the empirical claims is undermined by the evaluation metric, the self-curated benchmark, and the lack of statistical validation. These issues are load-bearing because the central contribution is the claimed performance improvement, so the significance of the work depends on the evaluation being credible.

major comments (4)
  1. [Section 3.2, Eq. (1)] The accuracy metric in Eq. (1) counts a generated solution as correct when the optimal objective value of the generated code equals that of the reference code. This condition is necessary but not sufficient for a correct formulation: an omitted binding constraint, a mis-scaled objective, or an inactive constraint that does not change the optimum on the specific test instance all receive full credit. The statement in Section 3.2 that a matching objective value 'generally indicates that all constraints and objective functions are correctly aligned' is unsupported. Because this metric underlies the headline comparisons in Table 1 (e.g., the claim that CHORUS lets open-source models match GPT-4), the reported accuracy should be treated as an upper bound on true formulation correctness. I recommend augmenting the evaluation with variable-level checks (e.g., comparing optimal decision-variable values or constraint coefficient matrices) and performing a manual audit of a random sample of outputs that are scored as correct.
  2. [Section 3.2, dataset curation] The NL4Opt-Code dataset is curated by the authors, who generated the reference Gurobi code from the same Gurobi documentation that serves as the retrieval corpus (Sections 2.1 and 3.2). This alignment may inflate the measured accuracy: the retriever can surface chunks that closely match the reference solution, making the task easier than general LP code generation. The dataset is not released, so independent verification is impossible. To support the general claim, the authors should release the dataset and reference code, or evaluate on an externally created benchmark where the reference code was written without access to the Gurobi documentation, and should report the degree of overlap between retrieved chunks and reference code.
  3. [Section 3.5, Table 2] The ablation does not isolate the effect of hierarchical chunking. The 'Traditional RAG' configuration differs from CHORUS in several components simultaneously: flat versus hierarchical chunking, absence of metadata augmentation, absence of two-stage retrieval and reranking, and presumably absence of the expert prompt. The claim that 'traditional fixed-length chunking strategy reduces accuracy by 46.14–89.33% compared to CHORUS' is therefore not causally identified. Indeed, for Llama3.1 the CHORUS-without-reasoning accuracy (0.0104) is lower than Traditional RAG (0.0144), showing that the framework's advantage over Traditional RAG comes primarily from the reasoning field and the expert prompt, not from hierarchical chunking alone. To support the ablation claim, the authors should add a flat-chunking variant that keeps all other CHORUS components fixed, and a hierarchical-chunking variant without the expert prompt and reasoning field.
  4. [Section 3.4, Tables 1 and 2] No error bars, confidence intervals, or statistical tests are reported, despite the claim of 'significant margin' in the abstract and Section 3.4. All experiments appear to be single-run. Given the observed non-monotonic effects (e.g., Llama3.1 accuracy drops from the baseline 0.0796 to 0.0104 for CHORUS without reasoning), repeated runs with different seeds and a paired significance test (e.g., McNemar's test) are needed to substantiate the claims. This is essential for any statement that CHORUS 'significantly' improves accuracy over baselines.
minor comments (6)
  1. [Abstract and Section 3.4] The abstract states that open-source LLMs 'outperform or match GPT3.5 and GPT4,' but Table 1 shows that with CHORUS the smallest model (Llama3.1 8B) reaches only 0.1349 accuracy, well below GPT3.5's 0.5260 and GPT4's 0.6367. The body text correctly notes this exception; the abstract should be qualified to avoid overstating the result.
  2. [Section 3.5, paragraph on Traditional RAG] There is a typo in the text: 'Llamma3.1' should be 'Llama3.1.'
  3. [Section 3.1, first paragraph] The statement that 'there are currently no publicly available datasets on general LP problems except the data from the NL4Opt competition' is inconsistent with the paper's own citation of E-OPT [22] as a benchmark for optimization modeling. The sentence should be revised to clarify that the authors are referring specifically to datasets paired with solver-specific Gurobi code.
  4. [Section 2.1, Metadata-Augmented Indexing] The LLM used to generate keywords and synopses is not named, nor are its sampling settings given. Since this metadata is central to retrieval, specifying the model and parameters is necessary for reproducibility and for assessing the LLM-agnosticism claim.
  5. [Section 3.2, Semantic Similarity metric] The semantic similarity metric uses all-MiniLM-L6-v2, a general-purpose sentence encoder that may not adequately represent code semantics. The paper reports that semantic similarity improves with CHORUS, but the meaning of cosine similarity between code strings should be discussed or replaced with a code-aware similarity measure.
  6. [Section 2.4, Structured Output] The reasoning_steps field is a free-text justification, but its quality or consistency with the generated code is not evaluated. Adding a manual analysis of reasoning quality would strengthen the claim that this field improves correctness.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular derivation found: CHORUS's central claim rests on external runtime comparison of generated and reference Gurobi code, with no fitted inputs relabeled as predictions.

full rationale

CHORUS does not derive a mathematical result from an input; its central contribution is an empirically evaluated retrieval-augmented generation pipeline. The primary metric, Eq. (1), defines accuracy as the fraction of instances where the optimal objective value f(Y_gen(x)) from executing the generated code equals f(Y_ref(x)) from executing the reference code. This is an external, execution-based check against fixed reference solutions, not a quantity constructed from the model's own output or from a fitted parameter. No parameter is fitted to any test subset and then called a prediction; the retrieval components (hierarchical chunking, metadata generation, cross-encoder reranking, expert prompt) are fixed pipeline choices evaluated on the test set. The only self-citation, LM4OPT [3], appears in the related-work paragraph as background and is not used as evidence for CHORUS's accuracy, so it is not load-bearing. The author-curated NL4Opt-Code benchmark and the fact that the reference Gurobi code was written from the same Gurobi documentation used as the retrieval corpus raise a legitimate evaluation concern about possible benchmark alignment and whether accuracy may overstate formulation correctness; however, that is a threat to external validity, not a circularity of the kind where a prediction reduces by definition or by fitted input to its own inputs. The limitation passage in Section 4 (prompt sensitivity, smaller-model context limits, restriction to LP/Gurobi) likewise describes scope limits rather than a circular derivation. Accordingly, no specific circular step can be exhibited, and the score is 0.

Assumptions & free parameters 5 free parameters · 5 assumptions · 0 invented entities

No genuinely new physical or conceptual entities are introduced. The framework is a composition of known retrieval components. The main assumptions are about the correctness of the benchmark, the transferability of a general-purpose reranker, and the validity of the accuracy metric.

free parameters (5)
  • chunk size threshold = 400 tokens
    Used in adaptive chunk construction; chosen without reported tuning.
  • top-k conceptual nodes per keyword
    Number of candidate nodes retrieved per keyword before reranking; not reported.
  • top-m code examples
    Number of code candidates retrieved before reranking; not reported.
  • final context sizes = top-3 conceptual docs, top-2 code examples
    Retained after cross-encoder reranking; fixed without reported sweep.
  • keyword count = 5-7
    LLM is prompted to generate 5-7 keywords per code example for metadata; arbitrary range.
assumptions (5)
  • domain assumption Gurobi PDF documentation structure (chapters, sections, subsections) maps to semantically coherent chunks.
    Hierarchical tree indexing assumes this structure aligns with retrieval needs; not directly validated.
  • domain assumption Cross-encoder trained on MS MARCO generalizes to ranking Gurobi documentation and code examples.
    The reranker is used off-the-shelf on a domain very different from web passage ranking (Section 2.3).
  • domain assumption Optimal objective value equality is a sufficient correctness criterion for generated LP code.
    Section 3.2 defines accuracy this way; different formulations may share objective values.
  • domain assumption The generated ground-truth Gurobi code in NL4Opt-Code is correct.
    Created by one graduate student and verified by another; no quantitative validation against independent solvers.
  • ad hoc to paper The LLM used for metadata generation does not bias retrieval toward a particular model.
    Metadata is generated once by an unspecified LLM and then used for all evaluated models; if metadata favors the evaluation models' lexical habits, comparisons could be affected.

how reviews work

0 comments
Cite this review

Pith. "Pith review of CHORUS: Zero-shot Hierarchical Retrieval and Orchestration for Generating Linear Programming Code." pith.science (2026). https://pith.science/paper/CDEASGTE

@misc{pith2026250501485,
  author       = {Pith},
  title        = {Pith review of: CHORUS: Zero-shot Hierarchical Retrieval and Orchestration for Generating Linear Programming Code},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/CDEASGTE}},
  note         = {Machine review of arXiv:2505.01485}
}
read the original abstract

Linear Programming (LP) problems aim to find the optimal solution to an objective under constraints. These problems typically require domain knowledge, mathematical skills, and programming ability, presenting significant challenges for non-experts. This study explores the efficiency of Large Language Models (LLMs) in generating solver-specific LP code. We propose CHORUS, a retrieval-augmented generation (RAG) framework for synthesizing Gurobi-based LP code from natural language problem statements. CHORUS incorporates a hierarchical tree-like chunking strategy for theoretical contents and generates additional metadata based on code examples from documentation to facilitate self-contained, semantically coherent retrieval. Two-stage retrieval approach of CHORUS followed by cross-encoder reranking further ensures contextual relevance. Finally, expertly crafted prompt and structured parser with reasoning steps improve code generation performance significantly. Experiments on the NL4Opt-Code benchmark show that CHORUS improves the performance of open-source LLMs such as Llama3.1 (8B), Llama3.3 (70B), Phi4 (14B), Deepseek-r1 (32B), and Qwen2.5-coder (32B) by a significant margin compared to baseline and conventional RAG. It also allows these open-source LLMs to outperform or match the performance of much stronger baselines-GPT3.5 and GPT4 while requiring far fewer computational resources. Ablation studies further demonstrate the importance of expert prompting, hierarchical chunking, and structured reasoning.

Figures

Figures reproduced from arXiv: 2505.01485 by the authors.

Figure 1
Figure 1. presents an overview of the proposed pipeline at inference. Problem Description Keywords LLM Retriever Hierarchical Context Metadata Code Repository Node Content Search top Concept Docs top Codes Document Retrieval Retrieved Context Cross-encoder Re-ranker Expert Prompt Schema Definition 1. Code 2. Reasoning Steps LLM LP Code Document Reranking Structured Generation [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Token length distributions for (left) theoretical documentation chunks [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. Word frequency analysis contrasting (left) raw code token prevalence with [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. An Agile Method for Implementing Retrieval Augmented Generation Tools in Industrial SMEs

    cs.CL 2025-08 conditional novelty 6.0 of 10

    EASI-RAG is a structured agile method for deploying RAG tools in industrial SMEs, validated by one case study where a no-experience team built a working assistant in three weeks.

Reference graph

Works this paper leans on

27 extracted references · 23 canonical work pages · cited by 1 Pith paper

  1. [1]

    Abdin, M., Aneja, J., Behl, H., Bubeck, S., Eldan, R., Gunasekar, S., Harrison, M., Hewett, R.J., Javaheripi, M., Kauffmann, P., Lee, J.R., Lee, Y.T., Li, Y., Liu, W., Mendes, C.C.T., Nguyen, A., Price, E., de Rosa, G., Saarikivi, O., Salim, A., Shah, S., Wang, X., Ward, R., Wu, Y., Yu, D., Zhang, C., Zhang, Y.: Phi-4 technical report (2024)

    work page 2024

  2. [2]

    ArXivabs/2310.06116(2023)

    AhmadiTeshnizi, A., Gao, W., Udell, M.: Optimus: Optimization modeling using mip solvers and large language models. ArXivabs/2310.06116(2023)

    arXiv 2023

  3. [3]

    Ahmed, T., Choudhury, S.: Lm4opt: Unveiling the potential of large language models in formulating mathematical optimization problems (2024)

    work page 2024

  4. [4]

    DeepSeek-AI, Guo, D., Yang, D., Zhang, H., Song, J., Zhang, R., Xu, R., Zhu, Q., Ma, S., Wang, P., Bi, X., Zhang, X., Yu, X., Wu, Y., Wu, Z.F., Gou, Z., Shao, Z., Li, Z., Gao, Z., Liu, A., Xue, B., Wang, B., Wu, B., Feng, B., Lu, C., Zhao, C., Deng, C., Zhang, C., Ruan, C., Dai, D., Chen, D., Ji, D., Li, E., Lin, F., Dai, F., Luo, F., Hao, G., Chen, G., L...

    work page 2025

  5. [5]

    Dubey, A., et al.: The llama 3 herd of models (2024)

    work page 2024

  6. [6]

    Déjean, H., Clinchant, S., Formal, T.: A thorough comparison of cross-encoders and llms for reranking splade (2024)

    work page 2024

  7. [7]

    In: Rogers, A., Boyd-Graber, J., Okazaki, N

    Gao, L., Ma, X., Lin, J., Callan, J.: Precise zero-shot dense retrieval without rele- vance labels. In: Rogers, A., Boyd-Graber, J., Okazaki, N. (eds.) Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). pp. 1762–1777. Association for Computational Linguistics, Toronto, Canada (Jul 2023)

    work page 2023

  8. [8]

    Ahmed and S

    Gurobi Optimization, LLC: Gurobi Optimizer Reference Manual (2024), https: //www.gurobi.com 16 T. Ahmed and S. Choudhury

    work page 2024

Show all 27 references
  1. [9]

    Hui, B., Yang, J., Cui, Z., Yang, J., Liu, D., Zhang, L., Liu, T., Zhang, J., Yu, B., Lu, K., Dang, K., Fan, Y., Zhang, Y., Yang, A., Men, R., Huang, F., Zheng, B., Miao, Y., Quan, S., Feng, Y., Ren, X., Ren, X., Zhou, J., Lin, J.: Qwen2.5-coder technical report (2024)

    2024

  2. [10]

    In: Krause, A., Brunskill, E., Cho, K., Engel- hardt, B., Sabato, S., Scarlett, J

    Kandpal, N., Deng, H., Roberts, A., Wallace, E., Raffel, C.: Large language models struggle to learn long-tail knowledge. In: Krause, A., Brunskill, E., Cho, K., Engel- hardt, B., Sabato, S., Scarlett, J. (eds.) Proceedings of the 40th International Con- ference on Machine Lea...

    2023

  3. [11]

    In: Larochelle, H., Ranzato, M., Had- sell, R., Balcan, M., Lin, H

    Lewis, P., Perez, E., Piktus, A., Petroni, F., Karpukhin, V., Goyal, N., Küttler, H., Lewis, M., Yih, W.t., Rocktäschel, T., Riedel, S., Kiela, D.: Retrieval-augmented generation for knowledge-intensive nlp tasks. In: Larochelle, H., Ranzato, M., Had- sell, R., Balcan, M., Lin...

    2020

  4. [12]

    Li, B., Mellou, K., Zhang, B., Pathuri, J., Menache, I.: Large language models for supply chain optimization (2023)

    2023

  5. [13]

    In: Chaudhuri, K., Jegelka, S., Song, L., Szepesvari, C., Niu, G., Sabato, S

    Mitchell, E., Lin, C., Bosselut, A., Manning, C.D., Finn, C.: Memory-based model editing at scale. In: Chaudhuri, K., Jegelka, S., Song, L., Szepesvari, C., Niu, G., Sabato, S. (eds.) Proceedings of the 39th International Conference on Machine Learning. Proceedings of Machine ...

    2022

  6. [14]

    OpenAI, Achiam, J., Adler, S., Agarwal, S., Ahmad, L., Akkaya, I., Aleman, F.L., Almeida, D., Altenschmidt, J., Altman, S., Anadkat, S., Avila, R., Babuschkin, I., Balaji, S., Balcom, V., Baltescu, P., Bao, H., Bavarian, M., Belgum, J., Bello, I., Berdine, J., Bernadett-Shapir...

    2024

  7. [15]

    In: Ciccone, M., Stolovitzky, G., Albrecht, J

    Ramamonjison, R., Yu, T., Li, R., Li, H., Carenini, G., Ghaddar, B., He, S., Mosta- jabdaveh, M., Banitalebi-Dehkordi, A., Zhou, Z., Zhang, Y.: Nl4opt competition: Formulating optimization problems based on their natural language descriptions. In: Ciccone, M., Stolovitzky, G.,...

    2022

  8. [16]

    (eds.) Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)

    Roberts, A., Raffel, C., Shazeer, N.: How much knowledge can you pack into the parameters of a language model? In: Webber, B., Cohn, T., He, Y., Liu, Y. (eds.) Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP). pp. 5418–5426. Associ...

    2020

  9. [17]

    In: Dernoncourt, F., Preoţiuc-Pietro, D., Shimorina, A

    Tam, Z.R., Wu, C.K., Tsai, Y.L., Lin, C.Y., Lee, H.y., Chen, Y.N.: Let me speak freely? a study on the impact of format restrictions on large language model perfor- mance. In: Dernoncourt, F., Preoţiuc-Pietro, D., Shimorina, A. (eds.) Proceedings of the 2024 Conference on Empi...

    2024

  10. [18]

    ArXivabs/2308.01589(2023)

    Tsouros, D.C., Verhaeghe, H., Kadiouglu, S., Guns, T.: Holy grail 2.0: From natural language to constraint models. ArXivabs/2308.01589(2023)

    2023 arXiv

  11. [19]

    NIPS ’22, Curran Associates Inc., Red Hook, NY, USA (2022)

    Wei, J., Wang, X., Schuurmans, D., Bosma, M., Ichter, B., Xia, F., Chi, E.H., Le, Q.V., Zhou, D.: Chain-of-thought prompting elicits reasoning in large language models.In:Proceedingsofthe36thInternationalConferenceonNeuralInformation Processing Systems. NIPS ’22, Curran Associ...

    2022

  12. [20]

    In: The Twelfth International Conference on Learning Representations (2024)

    Xu, P., Ping, W., Wu, X., McAfee, L., Zhu, C., Liu, Z., Subramanian, S., Bakhtu- rina, E., Shoeybi, M., Catanzaro, B.: Retrieval meets long context large language models. In: The Twelfth International Conference on Learning Representations (2024)

    2024

  13. [21]

    ArXivabs/2309.03409(2023)

    Yang, C., Wang, X., Lu, Y., Liu, H., Le, Q.V., Zhou, D., Chen, X.: Large language models as optimizers. ArXivabs/2309.03409(2023)

    2023 arXiv

  14. [22]

    Yang, Z., Huang, Y., Shi, W., Feng, L., Song, L., Wang, Y., Liang, X., Tang, J.: Benchmarking llms for optimization modeling and enhancing reasoning via reverse socratic synthesis (2024)

    2024

  15. [23]

    Ye, J., Chen, X., Xu, N., Zu, C., Shao, Z., Liu, S., Cui, Y., Zhou, Z., Gong, C., Shen, Y., Zhou, J., Chen, S., Gui, T., Zhang, Q., Huang, X.: A comprehensive capability analysis of gpt-3 and gpt-3.5 series models (2023)

    2023

  16. [24]

    Ahmed and S

    Yu, Y., Ping, W., Liu, Z., Wang, B., You, J., Zhang, C., Shoeybi, M., Catanzaro, B.: RankRAG: Unifying context ranking with retrieval-augmented generation in 18 T. Ahmed and S. Choudhury LLMs. In: The Thirty-eighth Annual Conference on Neural Information Processing Systems (2024)

    2024

  17. [25]

    Zhang, J., Wang, W., Guo, S., Wang, L., Lin, F., Yang, C., Yin, W.: Solving general natural-language-description optimization problems with large language models (2024)

    2024

  18. [26]

    In: Yang, Y., Davani, A., Sil, A., Kumar, A

    Zhang, J., Wang, W., Guo, S., Wang, L., Lin, F., Yang, C., Yin, W.: Solving general natural-language-description optimization problems with large language models. In: Yang, Y., Davani, A., Sil, A., Kumar, A. (eds.) Proceedings of the 2024 Conference of the North American Chapt...

    2024

  19. [490]

    Association for Computational Linguistics, Mexico City, Mexico (Jun 2024)

    2024

Pith tools

Reviewed August 16, 2026 · model on record in the stance chip above.