Pith. sign in

REVIEW 3 major objections 5 minor 58 references

Code Retrieval for MILP Instance Generation

T0 review · 3 major / 5 minor · reviewed 2026-08-15 · deepseek-v4-flash

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

Pith's one-line read MILP instance generation can be done by retrieving executable code, not training a model per class.

desk verdict Clever retrieval framing for MILP instance generation, but the headline similarity numbers are circular: the retrieval objective and evaluation metric are the same. read the letter →

arxiv 2505.11526 v1 pith:C4XZURRJ submitted 2025-05-11 math.OC cs.AI

Tianxing Yang , Huigen Ye , Hua Xu This is my paper · ORCID
classification math.OCcs.AI MSC 90C11
keywords mixed-integerlinearprogrammingMILPinstancegenerationcoderetrieval-augmentedcontrastivelearningbipartitegraphembeddingssimilaritymetric
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 claims that generating new MILP instances for a target problem class can be reduced to retrieving an existing piece of executable generator code and running it, instead of training a separate generative model for each class. The authors build the claim on an observation that the space of MILP problems is compact enough to be covered by a finite library: they evolve 4,000 generator codes from eight seed classes. To find the right code, they train an embedding model that maps MILP instances and their textual descriptions into one space, then define MILP-EmbedSim as the cosine similarity between normalized instance embeddings, a metric they argue stays meaningful across instance sizes. Given one target instance, MILP-Retrieval selects the library code whose generated instance embedding is closest and executes it. If the claim holds, data generation for learning-based solvers becomes training-free, single-instance, and interpretable, because scale and difficulty are controlled by parameters in the retrieved code.

What carries the argument

The load-bearing object is MILP-EmbedSim, a similarity between MILP instances defined as the cosine similarity of their normalized embeddings. The embeddings come from a contrastively trained encoder: a bipartite-graph neural network with a global summary node reads the instance's variables, constraints, and coefficients, and is aligned with a frozen text encoder through a symmetric cross-entropy loss on (instance, textual description) pairs. Because every library class contributes instances of several sizes that share one description, the trained space is pushed to put same-class instances of different scales near each other; retrieval is then literal nearest-neighbor search for a target instance's embedding, and the retrieved code is the matched library entry's generator.

What would settle it

Hold out a class absent from the training library, generate many target instances at varied scales, and for each retrieve the top-1 code. If the retrieved code's true class label (not its embedding score) frequently fails to match the target class, or if same-class pairs at different scales score below cross-class pairs at the same scale on MILP-EmbedSim, the central claim is falsified.

Watch

Extended reading notes

Core claim

The central claim is that instance generation and code generation are the same task: the object to produce is not an instance but a program that yields a distribution of instances matching the target class. The paper reports that execution of the retrieved code achieves high average similarity to targets (0.920 on the test library) while producing generally feasible instances, and that this outperforms both few-shot and fine-tuned language-model code-generation baselines, which rarely produced valid code. Against a learned reconstruction baseline, MILP-Retrieval's generated instances receive higher MILP-EmbedSim scores on all seven tested classes, including classes whose baseline training timed out or produced infeasible instances. The method needs only one target instance, no per-class training, and the retrieved code is accompanied by a mathematical formulation, so the generation process is inspectable and adjustable.

Load-bearing premise

The load-bearing premise is that the finite evolved library contains a generator whose output distribution is close enough to the target class that executing the retrieved code yields usefully similar instances; if that premise fails for a class, no embedding or similarity score can repair the match.

Editorial extensions

If this is right

  • New MILP classes can be targeted with a single instance and no model training, so data-scarce solver tasks can be addressed immediately.
  • Generated instances inherit a readable mathematical formulation, so scale, density, and difficulty can be adjusted through code parameters before solving.
  • The retrieval pipeline is reusable across classes: one encoder and one library serve all targets, amortizing the expensive embedding pretraining.
  • MILP-EmbedSim can replace the previous 11-statistic JS-divergence comparisons with pairwise, scale-robust instance similarity scores.
  • Because instances are produced by executing code rather than iterative structure prediction, generation is substantially faster and cheaper than learned reconstruction.

Reading between the lines

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

  • If library coverage is the true bottleneck, the natural next experiment is to grow the library by targeted evolution around failed retrievals and measure whether top-1 similarity to held-out classes rises; the paper's size-ablation already points that way.
  • A workflow the paper does not evaluate is downstream solver training: using MILP-Retrieval to generate a training set, then testing whether a learned branching or cut-selection model improves, which would directly validate the motivation.
  • Because the embedding is trained jointly with textual descriptions, classes with vague or missing descriptions may embed poorly; a testable variant is description-free retrieval, training only on graph-graph pairs.
  • The retrieved code could be locally tuned to hit a target difficulty profile by adjusting parameters, turning retrieval into retrieval-plus-optimization; the paper mentions the parameter control but does not automate it.
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

3 major / 5 minor

Summary. The paper reformulates MILP instance generation as a code generation task: it builds a library of MILP generation codes (plus instances, graphs, and text descriptions) using MILP-Evolve, trains a CLIP-style embedding model that aligns bipartite graph representations of MILP instances with textual descriptions, and defines a similarity metric MILP-EmbedSim as the cosine similarity between normalized embeddings. The proposed pipeline, MILP-Retrieval, retrieves the library code whose instance embedding is most similar to a target instance and executes that code to generate new instances. The authors claim that MILP-Retrieval outperforms two code-generation baselines (few-shot GPT-4o and fine-tuned LLaMA-3-8b) and a learning-based instance-generation baseline (ACM-MILP) on both code generation and instance generation tasks.

Significance. If validated, the reformulation of instance generation as code retrieval would be a useful and practical contribution: it offers training-free generation, interpretable code, and control over instance scale and difficulty, potentially removing the need for per-class model training. The paper also contributes a substantial library of 4,000 MILP classes and 59,033 instances, and a non-trivial embedding model. However, the empirical evidence for the central claim is currently compromised by a circular evaluation and by a test-set leakage in the baseline setup, so the significance of the results as presented is not established.

major comments (3)
  1. [§3.4, §4.1, Eq. (3), Tables 1–2] The evaluation metric is the same function used for retrieval, making the reported similarity scores largely self-confirming. Section 3.4 selects the code by k = argmax_k MILP-EmbedSim(p, p_k), and Section 4.1 states that instance similarity is assessed using the same MILP-EmbedSim. Tables 1 and 2 and Figures 6–7 then report MILP-EmbedSim as the outcome measure. Because the retrieved code is chosen to maximize exactly this quantity, high similarity values can reflect selection bias rather than genuine structural or semantic proximity between the generated instances and the target. This concern is not purely formal: the authors' only evidence that the 4,000-class library covers unseen classes (FCNF, TSP, GA, VRP, MIPLIB) is Figure 7, which shows the retrieval similarity increasing with library size; taking a maximum over a larger candidate set mechanically increases the expected maximum of any bounded score even when no relevant generator exists. The paper should be re-evaluated with an independent similarity measure, e.g., Jensen–Shannon divergence on structural statistics (as in prior work), constraint/variable type distributions, solving-time profiles, or downstream solver performance. Section 4.1 mentions computational hardness and feasible ratio, but these are not reported in the results tables.
  2. [Appendix E.1] The GPT-4o baseline uses few-shot examples randomly sampled from the Evolve/Test dataset, the very dataset on which the evaluation is performed. This is test-set leakage into the baseline prompt. Although the leakage favors the baseline (because the model sees examples from the target classes), it invalidates the comparison between MILP-Retrieval and GPT-4o. The few-shot examples should be drawn from a disjoint set, such as Evolve/Train, or from held-out classes not used in evaluation.
  3. [§3.1, §4.2, Figure 7] The claim that the Evolve/Train library covers unseen classes is supported only by the same MILP-EmbedSim metric that is maximized during retrieval. The paper does not report whether the retrieved code for a TSP, VRP, GA, or FCNF target actually belongs to the target class, nor does it report any class-specific structural test on the generated instances. Such a sanity check is essential: if the retrieved code is from an unrelated class, the generated instances will not resemble the target no matter how high the embedding similarity is, and the library-coverage assumption is then false. The authors should report the identity or class of the retrieved code for each target, and validate equivalence through independent structural metrics.
minor comments (5)
  1. [§3.2, Figure 4] The text refers to Figure D.4 for the accuracy curves, but the figure appears in the main text as Figure 4; the reference should be corrected.
  2. [Appendix D.1] In the description of the embedding model, 'Let xu, xu ∈ R^emb size' should presumably read 'xu, xv ∈ R^emb size'.
  3. [§4.1, Table 1] The Averaged Similarity for the baselines is computed only over classes for which valid code was generated, while MILP-Retrieval is evaluated on all 50 classes; this difference in evaluation sets should be stated explicitly and ideally a per-class comparison should be provided.
  4. [§4.2, Figure 6] The figure reports best results from 10 trials for GPT-4o and 25 trials for fine-tuned LLaMA-3-8b, whereas MILP-Retrieval is deterministic; the best-of-k selection should be acknowledged as a favorable treatment of the baselines.
  5. [Various] There are minor language and typographical issues, e.g., 'As illustrate in Figure 3' should be 'As illustrated in Figure 3'.

Circularity Check

2 steps flagged · score 6.0 of 10

Retrieval and evaluation share the same MILP-EmbedSim objective, so the headline similarity gains and the library-coverage trend are partly selection artifacts rather than independent evidence.

  1. fitted input called prediction [Section 3.4 (retrieval rule); Section 4.1 (Metrics); Tables 1 and 2]
    "The retrieval process identifies ck as: k = argmaxk MILP-EmbedSim(p, pk). ... MILP instance similarity serves as a shared metric for both the MILP Code Generation and MILP Instance Generation tasks, which is assessed using MILP-EmbedSim."

    The retrieval rule selects the library entry that maximizes MILP-EmbedSim, and the same MILP-EmbedSim score is then reported as the success metric in Tables 1-2 and Figure 6. Thus the headline similarity values are the objective function being optimized, not an independent check of whether the retrieved code produces instances similar to the target. Baselines that do not optimize this exact metric are systematically disadvantaged, so the reported 'outperforms' conclusion is partly forced by construction rather than demonstrated by an external measure.

  2. other [Section 4.2, Figure 7 and surrounding text]
    "Figure 7 highlights the retrieval performance of MILP-Retrieval on four benchmark problems (seed classes from Evolve/Test, not appearing in Evolve/Train). The results demonstrate the effectiveness of Evolve/Train, as MILP-Retrieval retrieves instances from MILP libraries of varying sizes while restricting the class number from Evolve/Train during retrieval."

    This figure is offered as evidence that enlarging the library improves coverage of unseen classes, but the plotted quantity is the maximum MILP-EmbedSim over a growing candidate set. The expected maximum of any bounded similarity score increases mechanically with the number of candidates even if no semantically related generator exists in the library. Therefore the upward trend does not independently establish that a near-matching generator exists for TSP, GA, VRP, or MIPLIB classes; it is a selection artifact of the same retrieval objective used to evaluate success.

full rationale

The main quantitative evidence for the central claim is partly circular. Section 3.4 retrieves the code whose library instance maximizes MILP-EmbedSim, and Section 4.1 declares MILP-EmbedSim to be the shared success metric for both tasks; Tables 1 and 2 and Figure 6 then report that metric. Consequently, the comparison against GPT-4o, Finetuned LLaMA, and ACM-MILP is not independent: the retrieval pipeline is by construction optimizing the exact quantity used to judge it. This is a genuine fitted-input-called-prediction issue, though not a formal tautology, because the generated instances are newly executed samples rather than the retrieved library instance itself; the high scores still depend on the embedding generalizing across instances generated by the same code. The library-coverage evidence in Figure 7 has the same problem. The claim that enlarging Evolve/Train improves coverage of unseen classes rests on the maximum MILP-EmbedSim over the library. The expected maximum of any bounded similarity score over a larger candidate set increases even under random noise, so the upward curve does not establish that a near-matching generator exists for TSP, GA, VRP, or MIPLIB classes. An independent structural metric, a human study, or a downstream solver-performance measure would be needed to corroborate similarity. No load-bearing self-citation chain was found: the MILP-Evolve library and NV-Embed-V2 text encoder are external tools, and the paper does not invoke a uniqueness theorem from its own authors to force its design. The code-validity and feasibility results are also independent of the circular similarity comparison. The circularity is therefore partial but central to the paper's quantitative claims.

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

The pipeline's load-bearing inputs are borrowed from MILP-Evolve plus a learned embedding. The paper adds no invented physical entities. The key free choices are library size, the feasibility filter, and the embedding hyperparameters; the key domain assumptions are the finite-library coverage of MILP space and the validity of embedding cosine similarity. Both assumptions are asserted rather than proven.

free parameters (3)
  • Library size of Evolve/Train = 4,000 codes; 59,033 instances
    Selected by budget (about four weeks and $50 of LLM calls) rather than by a coverage guarantee; Figure 7 shows retrieval similarity depends on library size, so this choice directly affects the headline results.
  • Feasibility filter time limit = 50 seconds
    Instances not solved to feasible status within 50 seconds by Gurobi are discarded (Appendix C), shaping the distribution of embedded instances and the retrieval pool.
  • Embedding model hyperparameters = 2 GCN layers, 6 attention layers, embedding 4096, batch 64, learning rate 1e-3
    Hand-selected and reported in Table 5 without a tuning procedure; the similarity metric is a direct function of this architecture.
assumptions (5)
  • domain assumption The space of MILP problems is small enough that a finite library of 4,000 evolved classes covers arbitrary target classes.
    Asserted in Section 1 as the motivating insight; no coverage bound or out-of-distribution validation beyond four Evolve/Test classes and three MIPLIB classes.
  • domain assumption Cosine similarity between learned embeddings is a valid measure of MILP instance similarity, including across different scales and unseen classes.
    Assumed in Sections 3.3 and 3.4; the validation uses the model's own retrieval scores, which is circular.
  • domain assumption The LLM-generated textual descriptions accurately capture each MILP class semantics.
    Descriptions are produced automatically from code and instance statistics (Section 2.2); no human verification or quality control is reported.
  • domain assumption The bipartite graph with solution-based features is a sufficient representation for similarity.
    Appendix A defines the features; the model's input is this graph, so any information lost in the representation cannot be recovered.
  • domain assumption Disjoint seed classes between Evolve/Train and Evolve/Test guarantee generalization.
    The paper only guarantees disjoint seeds (Appendix C); evolved classes may still end up similar to training classes.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Code Retrieval for MILP Instance Generation." pith.science (2026). https://pith.science/paper/C4XZURRJ

@misc{pith2026250511526,
  author       = {Pith},
  title        = {Pith review of: Code Retrieval for MILP Instance Generation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/C4XZURRJ}},
  note         = {Machine review of arXiv:2505.11526}
}
read the original abstract

Mixed-Integer Linear Programming (MILP) is widely used in fields such as scheduling, logistics, and planning. Enhancing the performance of MILP solvers, particularly learning-based solvers, requires substantial amounts of high-quality data. However, existing methods for MILP instance generation typically necessitate training a separate model for each problem class and are computationally intensive when generating new instances. To address these limitations, we reformulate the MILP Instance Generation task as MILP Code Generation task, enabling efficient, flexible, and interpretable instance generation through code. Since MILP instances generated from code can vary significantly in scale, we introduce MILP-EmbedSim, a new similarity metric that accurately measures the similarity between instances of varying sizes within the same problem class. Leveraging this metric, we propose MILP-Retrieval, a pipeline that retrieves generation code from library to produce MILP instances highly similar to target instance. MILP-Retrieval outperforms baselines in both MILP Code Generation and Instance Generation tasks, provides a novel perspective on MILP instance generation and opens new possibilities for learning-based solvers.

Figures

Figures reproduced from arXiv: 2505.11526 by the authors.

Figure 1
Figure 1. In MILP instance generation, (a) heuristic al [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Relationships among the different forms of MILP [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. We begin by constructing the MILP libraries Evolve/Train and Evolve/Test. Using Evolve/Train, we train an [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (5 more)
Figure 4
Figure 4. Figure 4: The Text-to-MILP and MILP-to-Text Accuracy [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]
Figure 5
Figure 5. Figure 5: Visualization results of Evolve/Train dataset and TSP instances. [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]
Figure 6
Figure 6. Figure 6: Results on Evolve/Test for MILP Code Generation [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 8
Figure 8. Figure 8: Visualization results of generated instances. [PITH_FULL_IMAGE:figures/full_fig_p008_8.png]
Figure 9
Figure 9. Figure 9: Similarity between instances of 3 classes from MIPLIB. [PITH_FULL_IMAGE:figures/full_fig_p018_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

58 extracted references · 37 canonical work pages

  1. [1]

    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...

  2. [2]

    and Ho, A

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

    work page 1980

  3. [3]

    Generating hard instances for maxsat

    B \'e jar, R., Cabiscol, A., Many \`a , F., and Planes, J. Generating hard instances for maxsat. In 2009 39th International Symposium on Multiple-Valued Logic, pp.\ 191--195. IEEE, 2009

    work page 2009

  4. [4]

    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

    2021

  5. [5]

    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

    2016

  6. [6]

    u hmer, E., Pfetsch, M. E., Schl \

    Bolusani, S., Besan c on, M., Bestuzheva, K., Chmiela, A., Dion \' i sio, J., Donkiewicz, T., van Doornmalen, J., Eifler, L., Ghannam, M., Gleixner, A., Graczyk, C., Halbig, K., Hedtke, I., Hoen, A., Hojny, C., van der Hulst, R., Kamp, D., Koch, T., Kofler, K., Lentz, J., Manns, J., Mexi, G., M\" u hmer, E., Pfetsch, M. E., Schl \"o sser, F., Serrano, F.,...

    work page 2024

  7. [7]

    Generation techniques for linear programming instances with controllable properties

    Bowly, S., Smith-Miles, K., Baatar, D., and Mittelmann, H. Generation techniques for linear programming instances with controllable properties. Mathematical Programming Computation, 12 0 (3): 0 389--415, 2020

    work page 2020

  8. [8]

    The vehicle routing problem: State of the art classification and review

    Braekers, K., Ramaekers, K., and Van Nieuwenhuyse, I. The vehicle routing problem: State of the art classification and review. Computers & industrial engineering, 99: 0 300--313, 2016

    work page 2016

Show all 58 references
  1. [9]

    Cattrysse, D. G. and Van Wassenhove, L. N. A survey of algorithms for the generalized assignment problem. European journal of operational research, 60 0 (3): 0 260--272, 1992

    1992

  2. [10]

    An milp for scheduling problems in an fms with one vehicle

    Caumond, A., Lacomme, P., Moukrim, A., and Tchernev, N. An milp for scheduling problems in an fms with one vehicle. European journal of operational research, 199 0 (3): 0 706--722, 2009

    2009

  3. [11]

    The generalized independent set problem: Polyhedral analysis and solution approaches

    Colombi, M., Mansini, R., and Savelsbergh, M. The generalized independent set problem: Polyhedral analysis and solution approaches. European Journal of Operational Research, 260 0 (1): 0 41--55, 2017

    2017

  4. [12]

    Xtuner: A toolkit for efficiently fine-tuning llm

    Contributors, X. Xtuner: A toolkit for efficiently fine-tuning llm. https://github.com/InternLM/xtuner, 2023

    2023

  5. [13]

    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

    1991

  6. [14]

    The llama 3 herd of models

    Dubey, A., Jauhri, A., Pandey, A., Kadian, A., Al-Dahle, A., Letman, A., Mathur, A., Schelten, A., Yang, A., Fan, A., et al. The llama 3 herd of models. arXiv preprint arXiv:2407.21783, 2024

    2024 arXiv

  7. [15]

    Floudas, C. A. and Lin, X. Mixed integer linear programming in process scheduling: Modeling, algorithms, and applications. Annals of Operations Research, 139: 0 131--162, 2005

    2005

  8. [16]

    Reverse logistics network design for a biogas plant: An approach based on milp optimization and analytical hierarchical process (ahp)

    Galvez, D., Rakotondranaivo, A., Morel, L., Camargo, M., and Fick, M. Reverse logistics network design for a biogas plant: An approach based on milp optimization and analytical hierarchical process (ahp). Journal of Manufacturing Systems, 37: 0 616--623, 2015

    2015

  9. [17]

    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

    2019

  10. [18]

    A deep instance generative framework for milp solvers under limited data availability

    Geng, Z., Li, X., Wang, J., Li, X., Zhang, Y., and Wu, F. A deep instance generative framework for milp solvers under limited data availability. Advances in Neural Information Processing Systems, 36: 0 26025--26047, 2023

    2023

  11. [19]

    Miplib 2017: data-driven compilation of the 6th mixed-integer programming library

    Gleixner, A., Hendel, G., Gamrath, G., Achterberg, T., Bastubbe, M., Berthold, T., Christophel, P., Jarck, K., Koch, T., Linderoth, J., et al. Miplib 2017: data-driven compilation of the 6th mixed-integer programming library. Mathematical Programming Computation, 13 0 (3): 0 4...

    2017

  12. [20]

    Acm-milp: Adaptive constraint modification via grouping and selection for hardness-preserving milp instance generation

    Guo, Z., Li, Y., Liu, C., Ouyang, W., and Yan, J. Acm-milp: Adaptive constraint modification via grouping and selection for hardness-preserving milp instance generation. In Forty-first International Conference on Machine Learning, 2024

    2024

  13. [21]

    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

    2020

  14. [22]

    B., Chet \'e lat, D., Gasse, M., Bengio, Y., Lodi, A., and Kumar, M

    Gupta, P., Khalil, E. B., Chet \'e lat, D., Gasse, M., Bengio, Y., Lodi, A., and Kumar, M. P. Lookback for learning to branch. arXiv preprint arXiv:2206.14987, 2022

    2022 arXiv

  15. [23]

    Gurobi Optimizer Reference Manual , 2024

    Gurobi Optimization, LLC . Gurobi Optimizer Reference Manual , 2024. URL https://www.gurobi.com

    2024

  16. [24]

    A gnn-guided predict-and-search framework for mixed-integer linear programming

    Han, Q., Yang, L., Chen, Q., Zhou, X., Zhang, D., Wang, A., Sun, R., and Luo, X. A gnn-guided predict-and-search framework for mixed-integer linear programming. arXiv preprint arXiv:2302.05636, 2023

    2023 arXiv

  17. [25]

    Gans trained by a two time-scale update rule converge to a local nash equilibrium

    Heusel, M., Ramsauer, H., Unterthiner, T., Nessler, B., and Hochreiter, S. Gans trained by a two time-scale update rule converge to a local nash equilibrium. Advances in neural information processing systems, 30, 2017

    2017

  18. [26]

    L., and Savelsbergh, M

    Hewitt, M., Nemhauser, G. L., and Savelsbergh, M. W. Combining exact and heuristic approaches for the capacitated fixed-charge network flow problem. INFORMS Journal on Computing, 22 0 (2): 0 314--325, 2010

    2010

  19. [27]

    o m, K., G \

    Holmstr \"o m, K., G \"o ran, A. O., and Edvall, M. M. User’s guide for tomlab/cplex v12. 1. Tomlab Optim. Retrieved, 1: 0 2017, 2009

    2017

  20. [28]

    M., Tian, Y., Dilkina, B., and Steiner, B

    Huang, T., Ferber, A. M., Tian, Y., Dilkina, B., and Steiner, B. Searching large neighborhoods for integer linear programs with contrastive learning. In International Conference on Machine Learning, pp.\ 13869--13890. PMLR, 2023

    2023

  21. [29]

    P., Perelman, A., Ramesh, A., Clark, A., Ostrow, A., Welihinda, A., Hayes, A., Radford, A., et al

    Hurst, A., Lerer, A., Goucher, A. P., Perelman, A., Ramesh, A., Clark, A., Ostrow, A., Welihinda, A., Hayes, A., Radford, A., et al. Gpt-4o system card. arXiv preprint arXiv:2410.21276, 2024

    2024 arXiv

  22. [30]

    and Pardalos, P

    Kim, D. and Pardalos, P. M. A solution approach to the fixed charge network flow problem using a dynamic slope scaling procedure. Operations Research Letters, 24 0 (4): 0 195--203, 1999

    1999

  23. [31]

    Kipf, T. N. and Welling, M. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations, 2017. URL https://openreview.net/forum?id=SJU4ayYgl

    2017

  24. [32]

    Accelerate presolve in large-scale linear programming via reinforcement learning

    Kuang, Y., Li, X., Wang, J., Zhu, F., Lu, M., Wang, Z., Zeng, J., Li, H., Zhang, Y., and Wu, F. Accelerate presolve in large-scale linear programming via reinforcement learning. arXiv preprint arXiv:2310.11845, 2023

    2023 arXiv

  25. [33]

    Nv-embed: Improved techniques for training llms as generalist embedding models

    Lee, C., Roy, R., Xu, M., Raiman, J., Shoeybi, M., Catanzaro, B., and Ping, W. Nv-embed: Improved techniques for training llms as generalist embedding models. arXiv preprint arXiv:2405.17428, 2024

    2024 arXiv

  26. [34]

    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

    2000

  27. [35]

    Towards foundation models for mixed integer linear programming

    Li, S., Kulkarni, J., Menache, I., Wu, C., and Li, B. Towards foundation models for mixed integer linear programming. arXiv preprint arXiv:2410.08288, 2024 a

    2024 arXiv

  28. [36]

    Machine learning insides optverse ai solver: Design principles and applications

    Li, X., Zhu, F., Zhen, H.-L., Luo, W., Lu, M., Huang, Y., Fan, Z., Zhou, Z., Kuang, Y., Wang, Z., et al. Machine learning insides optverse ai solver: Design principles and applications. arXiv preprint arXiv:2401.05960, 2024 b

    2024 arXiv

  29. [37]

    Divergence measures based on the shannon entropy

    Lin, J. Divergence measures based on the shannon entropy. IEEE Transactions on Information theory, 37 0 (1): 0 145--151, 1991

    1991

  30. [38]

    L2p-mip: Learning to presolve for mixed integer programming

    Liu, C., Dong, Z., Ma, H., Luo, W., Li, X., Pang, B., Zeng, J., and Yan, J. L2p-mip: Learning to presolve for mixed integer programming. In The Twelfth International Conference on Learning Representations, 2024 a

    2024

  31. [39]

    Milp-studio: Milp instance generation via block structure decomposition

    Liu, H., Wang, J., Zhang, W., Geng, Z., Kuang, Y., Li, X., Li, B., Zhang, Y., and Wu, F. Milp-studio: Milp instance generation via block structure decomposition. arXiv preprint arXiv:2410.22806, 2024 b

    2024 arXiv

  32. [40]

    P., and Mittal, M

    Matai, R., Singh, S. P., and Mittal, M. L. Traveling salesman problem: an overview of applications, formulations, and solution approaches. Traveling salesman problem, theory and applications, 1 0 (1): 0 1--25, 2010

    2010

  33. [41]

    M., and Ramos, A

    Morales-Espa \ n a, G., Latorre, J. M., and Ramos, A. Tight and compact milp formulation for the thermal unit commitment problem. IEEE Transactions on Power Systems, 28 0 (4): 0 4897--4908, 2013

    2013

  34. [42]

    G., and Manzolini, G

    Moretti, L., Milani, M., Lozza, G. G., and Manzolini, G. A detailed milp formulation for the optimal design of advanced biofuel supply chains. Renewable Energy, 171: 0 159--175, 2021

    2021

  35. [43]

    An exact algorithm for large multiple knapsack problems

    Pisinger, D. An exact algorithm for large multiple knapsack problems. European Journal of Operational Research, 114 0 (3): 0 528--541, 1999

    1999

  36. [44]

    W., Hallacy, C., Ramesh, A., Goh, G., Agarwal, S., Sastry, G., Askell, A., Mishkin, P., Clark, J., et al

    Radford, A., Kim, J. W., Hallacy, C., Ramesh, A., Goh, G., Agarwal, S., Sastry, G., Askell, A., Mishkin, P., Clark, J., et al. Learning transferable visual models from natural language supervision. In International conference on machine learning, pp.\ 8748--8763. PMLR, 2021

    2021

  37. [45]

    and Pinto, J

    Rejowski Jr, R. and Pinto, J. M. Efficient milp formulations and valid cuts for multiproduct pipeline scheduling. Computers & Chemical Engineering, 28 0 (8): 0 1511--1528, 2004

    2004

  38. [46]

    and Gao, W

    Ren, H. and Gao, W. A milp model for integrated plan and evaluation of distributed energy systems. Applied energy, 87 0 (3): 0 1001--1014, 2010

    2010

  39. [47]

    Improved techniques for training gans

    Salimans, T., Goodfellow, I., Zaremba, W., Cheung, V., Radford, A., and Chen, X. Improved techniques for training gans. Advances in neural information processing systems, 29, 2016

    2016

  40. [48]

    and Bowly, S

    Smith-Miles, K. and Bowly, S. Generating new test instances by evolving in instance space. Computers & Operations Research, 63: 0 102--113, 2015

    2015

  41. [49]

    D., Park, K., and Kim, J

    Song, B. D., Park, K., and Kim, J. Persistent uav delivery logistics: Milp formulation and efficient heuristic. Computers & Industrial Engineering, 120: 0 418--428, 2018

    2018

  42. [50]

    Learning a large neighborhood search algorithm for mixed integer programs

    Sonnerat, N., Wang, P., Ktena, I., Bartunov, S., and Nair, V. Learning a large neighborhood search algorithm for mixed integer programs. arXiv preprint arXiv:2107.10201, 2021

    2021 arXiv

  43. [51]

    Rethinking the inception architecture for computer vision

    Szegedy, C., Vanhoucke, V., Ioffe, S., Shlens, J., and Wojna, Z. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp.\ 2818--2826, 2016

    2016

  44. [52]

    Reinforcement learning for integer programming: Learning to cut

    Tang, Y., Agrawal, S., and Faenza, Y. Reinforcement learning for integer programming: Learning to cut. In International conference on machine learning, pp.\ 9367--9376. PMLR, 2020

    2020

  45. [53]

    P., Liu, J., Chen, X., Wang, X., Li, P., and Yin, W

    Wang, H. P., Liu, J., Chen, X., Wang, X., Li, P., and Yin, W. DIG - MILP : a deep instance generator for mixed-integer linear programming with feasibility guarantee. Transactions on Machine Learning Research, 2024. ISSN 2835-8856. URL https://openreview.net/forum?id=MywlrEaFqR

    2024

  46. [54]

    Learning cut selection for mixed-integer linear programming via hierarchical sequence model

    Wang, Z., Li, X., Wang, J., Kuang, Y., Yuan, M., Zeng, J., Zhang, Y., and Wu, F. Learning cut selection for mixed-integer linear programming via hierarchical sequence model. arXiv preprint arXiv:2302.00244, 2023

    2023 arXiv

  47. [55]

    Learning to generate scalable milp instances

    Yang, T., Ye, H., and Xu, H. Learning to generate scalable milp instances. In Proceedings of the Genetic and Evolutionary Computation Conference Companion, pp.\ 159--162, 2024

    2024

  48. [56]

    Gnn&gbdt-guided fast optimizing framework for large-scale integer programming

    Ye, H., Xu, H., Wang, H., Wang, C., and Jiang, Y. Gnn&gbdt-guided fast optimizing framework for large-scale integer programming. In International Conference on Machine Learning, pp.\ 39864--39878. PMLR, 2023

    2023

  49. [57]

    Light- MILP opt: Solving large-scale mixed integer linear programs with lightweight optimizer and small-scale training dataset

    Ye, H., Xu, H., and Wang, H. Light- MILP opt: Solving large-scale mixed integer linear programs with lightweight optimizer and small-scale training dataset. In The Twelfth International Conference on Learning Representations, 2024. URL https://openreview.net/forum?id=2oWRumm67L

    2024

  50. [58]

    Milp-fbgen: Lp/milp instance generation with feasibility/boundedness

    Zhang, Y., Fan, C., Chen, D., Li, C., Ouyang, W., Zhu, M., and Yan, J. Milp-fbgen: Lp/milp instance generation with feasibility/boundedness. In Forty-first International Conference on Machine Learning, 2024

    2024

Pith tools

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