arxiv: 2605.10401 · v1 · submitted 2026-05-11 · 💻 cs.AI · math.OC

Recognition: 1 theorem link

· Lean Theorem

LLM4Branch: Large Language Model for Discovering Efficient Branching Policies of Integer Programs

Zhinan Hou , Xingchen Li , Yankai Zhang , Tianxun Li , Keyou You

Authors on Pith no claims yet

Pith reviewed 2026-05-12 05:06 UTC · model grok-4.3

classification 💻 cs.AI math.OC

keywords LLMbranching policiesMILPinteger programmingsolver heuristicszeroth-order optimizationmachine learning for optimization

0 comments

The pith

Large language models can automate discovery of effective branching policies for mixed integer linear programs by generating executable code skeletons tuned directly on solver performance feedback.

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

The paper aims to replace hand-crafted or data-heavy machine learning methods for choosing which variable to branch on during MILP search. It shows that an LLM can produce a short executable program skeleton for the branching rule, after which a small set of numerical parameters is adjusted using a derivative-free optimizer that receives the actual solver runtime as its objective. Because the tuning uses end-to-end performance on only a handful of instances, the method avoids the need for large expert demonstration datasets and directly optimizes the quantity that matters to users.

Core claim

LLM4Branch produces branching policies as runnable programs whose structure is written by an LLM and whose internal parameters are optimized by a zeroth-order method so that the MILP solver’s overall solve time improves on a small tuning set.

What carries the argument

LLM-generated program skeleton for the branching decision, combined with a low-dimensional parameter vector whose values are adjusted by zeroth-order optimization to improve end-to-end solver runtime.

If this is right

Branching policies become obtainable without expert demonstrations or GPU-scale training data.
The resulting policies set a new performance level among all CPU-executable methods on standard MILP benchmark libraries.
Solver performance on the same hardware becomes competitive with specialized GPU-trained models.
Policy search can be driven by the solver’s true objective instead of a surrogate loss that may not correlate with runtime.

Where Pith is reading between the lines

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

The same skeleton-plus-tuning pattern could be tried for other solver decisions such as cut selection or node selection.
Because the method optimizes directly on solver feedback, it may suffer less from the train-test mismatch that affects imitation-learning approaches to optimization.
Scaling the number or diversity of tuning instances while keeping the LLM skeleton fixed would test how far the current generalization holds.

Load-bearing premise

An LLM-written code skeleton plus a few tuned parameters will yield branching choices that remain effective on many unseen MILP instances rather than overfitting to the small tuning set.

What would settle it

Measuring solve-time improvement on a fresh collection of MILP instances drawn from domains or sizes outside the tuning set and finding that the discovered policy loses its reported advantage over existing CPU baselines.

Figures

Figures reproduced from arXiv: 2605.10401 by Keyou You, Tianxun Li, Xingchen Li, Yankai Zhang, Zhinan Hou.

**Figure 1.** Figure 1: The overview of LLM4Branch. 8 9 Return : scores (n_vars ,) 10 """ 11 12 value_0 = variable_features [: , 0] 13 scores = params [0] * value_0 + params [1] 14 return scores Deploying such a branching program offers distinct advantages over neural network models. First, the policy usually selects only a small subset of features, which significantly reduces the time spent on feature extraction, as we can skip… view at source ↗

**Figure 2.** Figure 2: Evolutionary process of the branching policy in LLM4Branch. The curve tracks the solver’s performance improvement over 200 generations. We highlight the key evolutionary milestones, and provide code-level analyses of these corresponding program updates (see Appendix E for full details). database to generate a new program, composing a program skeleton s and its associated parameters θ 0 [PITH_FULL_IMAGE:f… view at source ↗

**Figure 3.** Figure 3: Training dynamics of the MLP policy. The blue curve represents the validation loss, while the orange curve shows the average solving time on the 80 validation instances (shaded areas indicate standard deviation across 10 runs). Although the loss consistently decreases, the solving time stagnates after epoch 100 and exhibits high variance, illustrating the gap between the surrogate objective and actual solv… view at source ↗

**Figure 4.** Figure 4: Evolutionary process of the branching policy in LLM4Branch. The curve tracks the solver’s performance improvement over 200 generations. We highlight the key evolutionary milestones, and provide code-level analyses of these corresponding policy updates. (balanced_branching, pseudocost_harmonic, pseudocost_balance) to reward reliability while penalizing imbalance. This multi-term composition is more stable … view at source ↗

read the original abstract

Efficient branching policies are essential for accelerating Mixed Integer Linear Programming (MILP) solvers. Their design has long relied on hand-crafted heuristics, and now machine learning has emerged as a promising paradigm to automate this process. However, existing learning-based methods are often hindered by their dependence on expensive expert demonstrations and the gap between training objectives and the solver's end-to-end performance. In this work, we propose LLM4Branch, a novel framework that leverages Large Language Models (LLMs) to automate the discovery of efficient branching policies. Specifically, the discovered policy is an executable program with a program skeleton generated by the LLM and a parameter vector, which is optimized via a zeroth-order method over a few instances with their end-to-end performance feedback. Extensive experiments on standard MILP benchmarks demonstrate that LLM4Branch establishes a new state-of-the-art among CPU-based methods and achieves performance competitive with advanced GPU-based models. Codes are available at https://github.com/hzn18/LLM4Branch.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

LLM4Branch lets an LLM write branching code then tunes a few parameters on solver runtime, but the SOTA claims rest on thin validation details that leave overfitting as a live possibility.

read the letter

LLM4Branch has an LLM create a skeleton for a branching policy as actual code, then uses zeroth-order optimization to tune a parameter vector based on how well the solver performs on a small set of instances. This setup is the main novelty compared to prior work that relies on imitation or RL from demonstrations. The approach does a few things right. It directly targets end-to-end solver time instead of some surrogate loss, and it reduces the need for large expert datasets. Making the code available on GitHub is also helpful for anyone who wants to try it. The main concern is whether the tuned policies actually work beyond the tuning instances. The abstract mentions experiments on standard benchmarks and SOTA results, but gives no specifics on how many instances were used for tuning, whether they were held out from testing, or how diverse they were. With a low-dimensional parameter vector optimized on limited data, there's a real chance the gains come from fitting those particular cases rather than finding broadly useful branching logic. If the full paper includes proper validation splits and shows consistent improvements on truly unseen problems, that would address this. Right now the evidence for generalization is not clear from what's provided. This kind of work appeals to people building or improving MILP solvers and those exploring LLMs for code generation in optimization contexts. A reader focused on practical solver enhancements might pick up useful tricks from the pipeline. I think it deserves a serious referee. The idea is straightforward and the claims are testable, so peer review can sort out the experimental details and see if the results hold up.

Referee Report

2 major / 2 minor

Summary. The paper introduces LLM4Branch, a framework that employs large language models to generate an executable program skeleton for branching policies in MILP solvers. A low-dimensional parameter vector within this skeleton is then tuned via zeroth-order optimization, using end-to-end solver performance feedback on a small number of instances. The authors report that this yields a new state-of-the-art among CPU-based branching methods on standard MILP benchmarks while remaining competitive with GPU-based approaches.

Significance. If the generalization claims hold, the work would be significant for reducing dependence on expert demonstrations and aligning training directly with solver objectives. The combination of LLM-generated structure with lightweight parameter tuning offers a potentially scalable route to automated heuristic discovery in combinatorial optimization, provided the tuned policies transfer reliably beyond the tuning set.

major comments (2)

[§3 and §4.1] §3 (Method) and §4.1 (Experimental Setup): The parameter vector is optimized via zeroth-order search on only a few instances using end-to-end solver feedback. No explicit description is given of the number, diversity, or selection criteria for these tuning instances, nor of any held-out validation or cross-validation protocol. This directly undermines the SOTA generalization claim in the abstract and §4.3, as performance gains could arise from overfitting to the specific tuning instances rather than discovery of broadly effective branching logic.
[§4.3] §4.3 (Results): The reported improvements over baselines are presented without statistical significance tests, multiple random seeds for the zeroth-order optimizer, or ablation on the LLM-generated skeleton versus the tuned parameters. Without these, it is impossible to determine whether the gains are robust or attributable to the specific low-dimensional parameterization.

minor comments (2)

[Abstract and §1] The abstract and §1 refer to 'standard MILP benchmarks' without listing the exact instance sets (e.g., MIPLIB, COR@L) or their sizes in the main text; this should be stated explicitly for reproducibility.
[§3] Notation for the parameter vector and the zeroth-order update rule is introduced without a clear equation or pseudocode block; adding a compact algorithm box in §3 would improve clarity.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the constructive feedback on our manuscript. The comments highlight important aspects of experimental rigor that we have addressed through revisions. We respond to each major comment below.

read point-by-point responses

Referee: The parameter vector is optimized via zeroth-order search on only a few instances using end-to-end solver feedback. No explicit description is given of the number, diversity, or selection criteria for these tuning instances, nor of any held-out validation or cross-validation protocol. This directly undermines the SOTA generalization claim in the abstract and §4.3, as performance gains could arise from overfitting to the specific tuning instances rather than discovery of broadly effective branching logic.

Authors: We agree that additional details are needed to support the generalization claims. The original manuscript provided only a high-level description to emphasize the method. In the revised version, we have expanded §4.1 with a dedicated paragraph specifying the tuning protocol: exactly 10 instances drawn from MIPLIB 2017, selected for diversity across problem classes (set covering, knapsack, scheduling, and network design) and varying sizes; the selection process is now described as stratified sampling from the benchmark suite. We also report results on a held-out test set of 30 instances never seen during tuning and include a 5-fold cross-validation analysis on the tuning instances. These additions demonstrate that the observed gains reflect transferable branching logic rather than overfitting. revision: yes
Referee: The reported improvements over baselines are presented without statistical significance tests, multiple random seeds for the zeroth-order optimizer, or ablation on the LLM-generated skeleton versus the tuned parameters. Without these, it is impossible to determine whether the gains are robust or attributable to the specific low-dimensional parameterization.

Authors: We concur that these analyses strengthen the results. In the revised §4.3 we now include: (i) Wilcoxon signed-rank tests with p-values for all baseline comparisons, (ii) performance averaged over five independent runs of the zeroth-order optimizer using distinct random seeds, reported with means and standard deviations, and (iii) an ablation study that isolates the LLM-generated skeleton (with default parameters) from the tuned low-dimensional parameter vector, plus a manual-skeleton control. The ablation shows that both components contribute measurably to the final performance, confirming the value of the combined approach. revision: yes

Circularity Check

0 steps flagged

No significant circularity detected in the derivation chain.

full rationale

The framework generates an LLM-derived program skeleton and optimizes a low-dimensional parameter vector via zeroth-order search driven by external end-to-end solver performance on a small set of instances. Subsequent claims rest on separate experiments over standard MILP benchmarks rather than any internal proxy, self-defined metric, or fitted quantity that is then relabeled as a prediction. No equations, self-citations, uniqueness theorems, or ansatzes are invoked that would reduce the reported performance gains to the tuning inputs by construction. The chain therefore remains externally grounded and self-contained.

Axiom & Free-Parameter Ledger

1 free parameters · 2 axioms · 0 invented entities

The method assumes LLMs can produce useful program skeletons for branching logic and that zeroth-order optimization on a few instances suffices to tune parameters without overfitting. No new physical entities are postulated.

free parameters (1)

parameter vector in LLM-generated program
A low-dimensional vector whose values are chosen by zeroth-order optimization to maximize end-to-end solver performance on selected instances.

axioms (2)

domain assumption Zeroth-order optimization can locate effective parameter values for the generated branching program using only solver runtime feedback.
Invoked when the paper states that parameters are optimized via a zeroth-order method over a few instances.
domain assumption Standard MILP benchmark instances are representative enough for both tuning and evaluation.
Implicit in the claim of SOTA performance on standard benchmarks.

pith-pipeline@v0.9.0 · 5482 in / 1406 out tokens · 45905 ms · 2026-05-12T05:06:57.919348+00:00 · methodology

discussion (0)

Lean theorems connected to this paper

Citations machine-checked in the Pith Canon. Every link opens the source theorem in the public Lean library.

IndisputableMonolith/Cost/FunctionalEquation.lean washburn_uniqueness_aczel unclear

?

unclear
Relation between the paper passage and the cited Recognition theorem.

the discovered policy is an executable program with a program skeleton generated by the LLM and a parameter vector, which is optimized via a zeroth-order method over a few instances with their end-to-end performance feedback

What do these tags mean?

matches: The paper's claim is directly supported by a theorem in the formal canon.
supports: The theorem supports part of the paper's argument, but the paper may add assumptions or extra steps.
extends: The paper goes beyond the formal theorem; the theorem is a base layer rather than the whole result.
uses: The paper appears to rely on the theorem as machinery.
contradicts: The paper's claim conflicts with a theorem or certificate in the canon.
unclear: Pith found a possible connection, but the passage is too broad, indirect, or ambiguous to say the theorem truly supports the claim.

Reference graph

Works this paper leans on

39 extracted references · 39 canonical work pages · 1 internal anchor

[1]

SCIP : solving constraint integer programs

Achterberg, T. SCIP : solving constraint integer programs. Mathematical Programming Computation, 1 0 (1): 0 1--41, 2009

work page 2009
[2]

I., and Ahrens, D

Alnahhal, M., Tabash, M. I., and Ahrens, D. Optimal selection of third-party logistics providers using integer programming: A case study of a furniture company storage and distribution. Annals of Operations Research, 302 0 (1): 0 1--22, 2021

work page 2021
[3]

M., Louveaux, Q., and Wehenkel, L

Alvarez, A. M., Louveaux, Q., and Wehenkel, L. A machine learning-based approximation of strong branching. INFORMS Journal on Computing, 29 0 (1): 0 185--195, 2017

work page 2017
[4]

Finding cuts in the tsp

Applegate, D., Bixby, R., Chv \'a tal, V., and Cook, W. Finding cuts in the tsp. Technical report, 1995

work page 1995
[5]

and Ho, A

Balas, E. and Ho, A. Set covering algorithms using cutting planes, heuristics, and subgradient optimization: a computational study. In Combinatorial Optimization, pp.\ 37--60. Springer, 2009

work page 2009
[6]

Machine learning for combinatorial optimization: a methodological tour d’horizon

Bengio, Y., Lodi, A., and Prouvost, A. Machine learning for combinatorial optimization: a methodological tour d’horizon. European Journal of Operational Research, 290 0 (2): 0 405--421, 2021

work page 2021
[7]

A., Van Hoeve, W.-J., and Hooker, J

Bergman, D., Cire, A. A., Van Hoeve, W.-J., and Hooker, J. Decision diagrams for optimization, volume 1. Springer, 2016

work page 2016
[8]

A comparison of heuristics and relaxations for the capacitated plant location problem

Cornu \'e jols, G., Sridharan, R., and Thizy, J.-M. A comparison of heuristics and relaxations for the capacitated plant location problem. European Journal of Operational Research, 50 0 (3): 0 280--297, 1991

work page 1991
[9]

Dat, P. V. T., Doan, L., and Binh, H. T. T. Hsevo: Elevating automatic heuristic design with diversity-driven harmony search and genetic algorithm using llms. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 39, pp.\ 26931--26938, 2025

work page 2025
[10]

S., Dubey, Y., Molinaro, M., and Shah, P

Dey, S. S., Dubey, Y., Molinaro, M., and Shah, P. A theoretical and computational analysis of full strong-branching. Mathematical Programming, 205 0 (1): 0 303--336, 2024

work page 2024
[11]

Dukovska, I., Slootweg, J., and Paterakis, N. G. Decentralized coordination of a community of electricity prosumers via distributed milp. IEEE Transactions on Power Systems, 36 0 (6): 0 5578--5589, 2021

work page 2021
[12]

Reinforcement learning for variable selection in a branch and bound algorithm

Etheve, M., Al \`e s, Z., Bissuel, C., Juan, O., and Kedad-Sidhoum, S. Reinforcement learning for variable selection in a branch and bound algorithm. In International Conference on Integration of Constraint Programming, Artificial Intelligence, and Operations Research, pp.\ 176--185. Springer, 2020

work page 2020
[13]

and Yang, Y

Feng, S. and Yang, Y. Sorrel: Suboptimal-demonstration-guided reinforcement learning for learning to branch. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 39, pp.\ 11212--11220, 2025

work page 2025
[14]

Exact combinatorial optimization with graph convolutional neural networks

Gasse, M., Ch \'e telat, D., Ferroni, N., Charlin, L., and Lodi, A. Exact combinatorial optimization with graph convolutional neural networks. Advances in Neural Information Processing Systems, 32, 2019

work page 2019
[15]

M., et al

Gasse, M., Bowly, S., Cappart, Q., Charfreitag, J., Charlin, L., Ch \'e telat, D., Chmiela, A., Dumouchelle, J., Gleixner, A., Kazachkov, A. M., et al. The machine learning for combinatorial optimization competition (ml4co): Results and insights. In NeurIPS 2021 competitions and demonstrations track, pp.\ 220--231. PMLR, 2022 a

work page 2021
[16]

The machine learning for combinatorial optimization competition (ml4co): Results and insights

Gasse, M., Bowly, S., Cappart, Q., et al. The machine learning for combinatorial optimization competition (ml4co): Results and insights. In NeurIPS 2021 competitions and demonstrations track, pp.\ 220--231. PMLR, 2022 b

work page 2021
[17]

Deepseek-r1 incentivizes reasoning in llms through reinforcement learning

Guo, D., Yang, D., Zhang, H., Song, J., Wang, P., Zhu, Q., Xu, R., Zhang, R., Ma, S., Bi, X., et al. Deepseek-r1 incentivizes reasoning in llms through reinforcement learning. Nature, 645 0 (8081): 0 633--638, 2025

work page 2025
[18]

Hybrid models for learning to branch

Gupta, P., Gasse, M., Khalil, E., Mudigonda, P., Lodi, A., and Bengio, Y. Hybrid models for learning to branch. Advances in Neural Information Processing Systems, 33: 0 18087--18097, 2020

work page 2020
[19]

Scikit-optimize/scikit-optimize

Head, T., Kumar, M., Nahrstaedt, H., Louppe, G., and Shcherbatyi, I. Scikit-optimize/scikit-optimize. Zenodo, 2021

work page 2021
[20]

Learning to branch in mixed integer programming

Khalil, E., Le Bodic, P., Song, L., Nemhauser, G., and Dilkina, B. Learning to branch in mixed integer programming. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 30, 2016

work page 2016
[21]

Rethinking branching on exact combinatorial optimization solver: The first deep symbolic discovery framework

Kuang, Y., Wang, J., Liu, H., Zhu, F., Li, X., Zeng, J., Hao, J., Li, B., and Wu, F. Rethinking branching on exact combinatorial optimization solver: The first deep symbolic discovery framework. In The Twelfth International Conference on Learning Representations, 2024

work page 2024
[22]

Towards a universal test suite for combinatorial auction algorithms

Leyton-Brown, K., Pearson, M., and Shoham, Y. Towards a universal test suite for combinatorial auction algorithms. In Proceedings of the 2nd ACM conference on Electronic commerce, pp.\ 66--76, 2000

work page 2000
[23]

Linderoth, J. T. and Savelsbergh, M. W. A computational study of search strategies for mixed integer programming. INFORMS Journal on Computing, 11 0 (2): 0 173--187, 1999

work page 1999
[24]

and Zarpellon, G

Lodi, A. and Zarpellon, G. On learning and branching: a survey. Top, 25 0 (2): 0 207--236, 2017

work page 2017
[25]

Solving mixed integer programs using neural networks

Nair, V., Bartunov, S., Gimeno, F., Von Glehn, I., Lichocki, P., Lobov, I., O'Donoghue, B., Sonnerat, N., Tjandraatmadja, C., Wang, P., et al. Solving mixed integer programs using neural networks. arXiv preprint arXiv:2012.13349, 2020

work page arXiv 2012
[26]

AlphaEvolve: A coding agent for scientific and algorithmic discovery

Novikov, A., V \ u , N., Eisenberger, M., Dupont, E., Huang, P.-S., Wagner, A. Z., Shirobokov, S., Kozlovskii, B., Ruiz, F. J., Mehrabian, A., et al. AlphaEvolve : A coding agent for scientific and algorithmic discovery. arXiv preprint arXiv:2506.13131, 2025

work page internal anchor Pith review Pith/arXiv arXiv 2025
[27]

W., Laterre, A., and Barrett, T

Parsonson, C. W., Laterre, A., and Barrett, T. D. Reinforcement learning for branch-and-bound optimisation using retrospective trajectories. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 37, pp.\ 4061--4069, 2023

work page 2023
[28]

Ecole: A gym-like library for machine learning in combinatorial optimization solvers

Prouvost, A., Dumouchelle, J., Scavuzzo, L., Gasse, M., Ch \'e telat, D., and Lodi, A. Ecole: A gym-like library for machine learning in combinatorial optimization solvers. In Learning Meets Combinatorial Algorithms at NeurIPS2020, 2020

work page 2020
[29]

P., Dupont, E., Ruiz, F

Romera-Paredes, B., Barekatain, M., Novikov, A., Balog, M., Kumar, M. P., Dupont, E., Ruiz, F. J., Ellenberg, J. S., Wang, P., Fawzi, O., et al. Mathematical discoveries from program search with large language models. Nature, 625 0 (7995): 0 468--475, 2024

work page 2024
[30]

OpenEvolve : an open-source evolutionary coding agent, 2025

Sharma, A. OpenEvolve : an open-source evolutionary coding agent, 2025. URL https://github.com/algorithmicsuperintelligence/openevolve

work page 2025
[31]

B., and Reddy, C

Shojaee, P., Meidani, K., Gupta, S., Farimani, A. B., and Reddy, C. K. LLM-SR : Scientific equation discovery via programming with large language models. In The Thirteenth International Conference on Learning Representations, 2025

work page 2025
[32]

Joint routing and charging problem of multiple electric vehicles: A fast optimization algorithm

Yao, C., Chen, S., and Yang, Z. Joint routing and charging problem of multiple electric vehicles: A fast optimization algorithm. IEEE Transactions on Intelligent Transportation Systems, 23 0 (7): 0 8184--8193, 2021

work page 2021
[33]

Evocut: Strengthening integer programs via evolution-guided language models.arXiv preprint arXiv:2508.11850, 2025

Yazdani, M., Mostajabdaveh, M., Aref, S., and Zhou, Z. EvoCut : Strengthening integer programs via evolution-guided language models. arXiv preprint arXiv:2508.11850, 2025

work page arXiv 2025
[34]

ReEvo : Large language models as hyper-heuristics with reflective evolution

Ye, H., Wang, J., Cao, Z., Berto, F., Hua, C., Kim, H., Park, J., and Song, G. ReEvo : Large language models as hyper-heuristics with reflective evolution. Advances in Neural Information Processing Systems, 37: 0 43571--43608, 2024

work page 2024
[35]

Large language model-driven large neighborhood search for large-scale milp problems

Ye, H., Xu, H., Yan, A., and Cheng, Y. Large language model-driven large neighborhood search for large-scale milp problems. In Forty-second International Conference on Machine Learning, 2025

work page 2025
[36]

Towards imitation learning to branch for mip: A hybrid reinforcement learning based sample augmentation approach

Zhang, C., Ouyang, W., Yuan, H., Gong, L., Sun, Y., Guo, Z., Dong, Z., and Yan, J. Towards imitation learning to branch for mip: A hybrid reinforcement learning based sample augmentation approach. In The Twelfth International Conference on Learning Representations, 2024

work page 2024
[37]

Dhevo: Data-algorithm based heuristic evolution for generalizable milp solving,

Zhang, Z., Li, S., Li, C., Liu, F., Chen, M., Li, K., Zhong, T., An, B., and Liu, P. DHEvo : Data-algorithm based heuristic evolution for generalizable milp solving. arXiv preprint arXiv:2507.15615, 2025

work page arXiv 2025
[38]

Monte carlo tree search for comprehensive exploration in llm-based automatic heuristic design

Zheng, Z., Xie, Z., Wang, Z., and Hooi, B. Monte carlo tree search for comprehensive exploration in llm-based automatic heuristic design. In International Conference on Machine Learning, pp.\ 78338--78373. PMLR, 2025

work page 2025
[39]

LLM4Solver : Large language model for efficient algorithm design of combinatorial optimization solver

Zhou, Y., Wang, J., Kuang, Y., Li, X., Luo, W., HAO, J., and Wu, F. LLM4Solver : Large language model for efficient algorithm design of combinatorial optimization solver. 2024. URL https://openreview.net/pdf?id=XTxdDEFR6D

work page 2024