Pith. sign in

REVIEW 4 major objections 5 minor 38 references

Re-evaluating LLM-based Heuristic Search: A Case Study on the 3D Packing Problem

T0 review · 4 major / 5 minor · reviewed 2026-08-05 · deepseek-v4-flash

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

Pith's one-line read An LLM told to build a 3D packing solver from scratch spent its effort on one scoring function — which then rivaled established solvers inside a human search framework.

desk verdict Solid empirical case study with a real hybrid result, but the headline interpretation about LLM limitations is confounded by the experimental scaffold. read the letter →

arxiv 2509.02297 v1 pith:NXCK3ZDO submitted 2025-09-02 cs.AI

Guorui Quan , Mingfei Sun , Manuel López-Ibáñez This is my paper
classification cs.AI MSC 90C2790C5968T20
keywords LLMheuristicsearchevolutionofheuristics3Dpackingproblemcontainerloadingscoringfunctionoptimizationconstraintscaffoldingiterativeself-correctionSSSCSP
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

To test whether large language models can design heuristics beyond tweaking a small component inside a human-built solver, the authors set an LLM the task of writing a complete solver for the constrained 3D packing problem from scratch. Direct generation mostly failed, so they added two supports: constraint scaffolding — a pre-verified library of geometric constraint checks — and iterative self-correction, a repair loop that feeds runtime errors back to the model. With those supports the LLM produced working solvers, but across every generation its improvements were almost exclusively refinements of a single scoring function that ranks which item and position to choose next; it never invented structural ideas like wall-building. Transplanted into a human-designed two-stage metaheuristic, that scoring function reached 694.3 total containers on the standard 47-instance benchmark, close to 691 for a leading human heuristic and 689 for the exact solver, though its advantage shrank as stability and separation constraints were added. The paper concludes that this one-dimensional focus is a limitation of current LLMs — pretrained biases that steer them to familiar mathematical tweaks — and identifies the engineering needed to contain their fragility as the other main barrier to automated heuristic design.

What carries the argument

The load-bearing mechanism is the scaffolded BaseAlgorithm API combined with the iterative self-correction loop. BaseAlgorithm supplies verified methods for overlap detection, boundary checks, and stability evaluation, so the LLM inherits a greedy placement loop and can only vary the strategy layer — in practice, the scoring function that ranks item and position choices. Iterative self-correction captures syntax errors, constraint violations, and timeouts and asks the LLM to repair the offending class, up to five attempts. An EoH-style evolutionary loop (diversify, synthesize, improve, tune, simplify prompts) then searches the space of heuristics. The evolved scoring function is the componen

What would settle it

Run the same evolutionary search with a scaffolded API that exposes wall-building and block-formation as first-class operations and with an initial population drawn from structurally diverse human heuristics; if the LLM then produces viable solvers whose innovations are procedural rather than scoring-function changes, the paper's central interpretive claim is false. A cheaper, generation-by-generation check: measure the fraction of code edits that touch the scoring function versus the placement loop, and look for any run that recombines or invents control-flow structure.

Watch

Extended reading notes

Core claim

The paper claims that with two supports — constraint scaffolding (pre-verified geometric constraint-checking code) and iterative self-correction (repair loops fed runtime diagnostics) — LLM-driven evolutionary search can produce a working 3D packing solver, but that the LLM's improvements are almost exclusively refinements of the scoring function, not new algorithmic structures. The authors read this concentration as evidence that the scoring-function focus of prior LLM heuristic work is a capability limit, not a chosen strategy. Transplanted into a human-designed randomized-search-plus-set-partitioning metaheuristic, the discovered scoring function reaches 694.3 total containers on the 47 S

Load-bearing premise

The interpretation that the LLM's scoring-function-only focus reveals an intrinsic capability limit assumes the scaffolded API and the homogeneous largest-item-first starting population were not the real cause of that narrow focus; if a differently framed scaffold or a diverse starting population would have produced genuinely novel algorithmic structures, the interpretive claim gives way even though the benchmark numbers could still stand.

Editorial extensions

If this is right

  • A component optimized by an LLM inside a simple greedy loop can match human-designed heuristics when transplanted into a mature search architecture (694.3 vs 691 vs 689), so LLM-discovered components are viable beyond toy problems.
  • Direct LLM generation of complete constraint-heavy solvers fails at a high rate (90% invalid in the naive baseline); feasibility requires constraint scaffolding and iterative self-correction.
  • The paper's evidence implies that the scoring-function emphasis in earlier LLM heuristic work reflects pretrained-model bias toward modular mathematical refinement rather than a principled choice.
  • The discovered heuristic is brittle: its performance degrades as load-stability and item-separation constraints are added, so its success depends on the human-designed metaheuristic and the unconstrained setting.
  • Automated heuristic design with current LLMs faces two concrete barriers: the engineering cost of mitigating fragility, and pretrained biases that narrow the search early.

Reading between the lines

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

  • The 'capability limit' conclusion may partly be an artifact of the scaffold: the candidate-position generator only enumerates axis-aligned offsets of placed items plus the origin, and the initial population is a homogeneous largest-item-first heuristic, so procedural structures like wall-building are effectively closed off. A scaffold that exposes such primitives as first-class operations might el
  • A direct test of the bias claim: seed the population with structurally diverse human heuristics (wall-building, layer-based, block-arrangement) and measure whether the LLM still converges to scoring-function-only refinements or starts recombining structures.
  • The near-optimal hybrid result with only 401 randomized runs hints that LLM-evolved scoring functions are cheap, transferable components for column-generation-style pipelines; the same function could plausibly guide other generate-and-select frameworks, a transfer the paper does not test.
  • The observed overfitting (training gap to exact of 1.0 growing to 4.3 on test) suggests the discovered scoring function partially memorizes training-instance geometry; evolving on a larger or more diverse training set could be expected to improve constraint robustness — a testable extension.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper investigates whether an LLM can autonomously design a complete solver for the constrained 3D Packing Problem, rather than merely optimizing a component inside a human-designed framework. Using the Evolution of Heuristics (EoH) loop with Gemini-2.0-flash, the authors find that direct code generation is fragile and introduce two interventions: constraint scaffolding (a pre-verified BaseAlgorithm API for geometric checks) and iterative self-correction (repairing bugs/timeouts). With these supports, the LLM evolves a greedy packing heuristic. The paper reports that the LLM's innovations concentrate almost exclusively on the scoring function, claims this reflects a natural limitation of LLM capabilities, and shows that transplanting the discovered scoring function into a human-designed RS+SP metaheuristic yields total containers 694.3 on the base SSSCSP benchmark, versus 691 for ZHU and 689 for the exact solver. Under added stability/separation constraints, the performance degrades. The paper includes instance-by-instance tables, prompts, and code.

Significance. If the results hold, the paper provides a useful empirical data point on the feasibility and limits of LLM-driven heuristic design in a complex geometric domain. Its strengths include reproducible code, a public benchmark split, detailed appendix material, and a genuinely out-of-sample evaluation: the scoring functions were evolved on 20 training instances and tested on 27 held-out instances. The hybrid experiment is valuable: it demonstrates that an LLM-discovered scoring component can transfer to a human-designed metaheuristic and rival established solvers with fewer randomized runs than the S-GRASP baseline. However, the central interpretive claim—that the observed focus on scoring functions reveals a natural limitation of LLM capabilities—is not established by the evidence, because the experimental setup (scaffolded API, homogeneous initial population, incremental mutation operators) largely determines the space of programs the LLM can explore. The paper's headline 'comparable to a human-designed greedy algorithm' also rests on the best of three seeds, while the average is substantially worse. These issues affect the framing rather than the raw quantitative tables, and are fixa

major comments (4)
  1. [§5.3 and Appendix B.2] The central claim that the LLM's near-exclusive focus on scoring functions reflects 'a natural limitation of LLM capabilities' (abstract; §5.3) is confounded by the experimental design. The scaffolded API in Appendix B.2 exposes only validity-checking methods and instructs the LLM to decompose place_item into helper methods; no structural primitives such as wall-building or block formation are available. The initial population is, by the authors' own account, 'a homogeneous population of simple largest-item-first heuristics' (§5.3), and the EoH operators M1–M3 are incremental edits (§3.2). Under these conditions, convergence to scoring-function tweaks is the expected outcome of any mutation-based search, regardless of model capability. Please either add a control that varies the initial population and the exposed primitives, or reframe the conclusion as specific to this scaffolded setup
  2. [Abstract and Table 2] The abstract's statement that 'the resulting heuristic was comparable to a human-designed greedy algorithm' rests on the single best three-seed heuristic (763 vs S-GRASP 762). The mean of the same configuration is 781.0 ± 21 (Table 2), which is 19 containers worse than S-GRASP. Presenting the best-of-three as 'the resulting heuristic' understates the stochasticity and selection bias. Please report the distribution (e.g., median and range) and either use a principled selection rule or adjust the wording to 'the best heuristic found in three runs'.
  3. [Appendix A] The separation constraint rule ('items of the first and second type in each instance are incompatible') is stated to have been established by direct communication with the authors of [14] and is not specified in the original publication. Since the constrained-problem results (Tables 4 and 8) depend on this rule, reproducibility requires that the per-instance incompatible pairs be published in the repository and that each baseline (ELY, Exact Solver) be confirmed to use the same rule. As written, the constrained comparisons rest on unpublished information that cannot be independently verified.
  4. [Abstract/§5.3 and Appendix F] The claim that the LLM explored 'a vast search space' is not demonstrated and is contradicted by the example in Appendix F: _generate_potential_positions enumerates only corners of placed items plus the origin, an O(n) set that excludes wall, layer, and block-formation structures. Although the LLM wrote this generator itself, the homogeneous initial population and incremental mutation operators restrict the region of program space actually visited. Please provide a quantitative measure of the explored space (e.g., number of distinct programs, structural diversity) or soften the 'vast search space' claim.
minor comments (5)
  1. [§2] Typo: 'The LLM receives a prompt describing the problem to proposes new solutions' should be 'to propose new solutions'.
  2. [§5.4] Notation inconsistency: the randomization parameter is called β in the text, but the implementation details refer to α = 0.0, 0.05, 0.15. Please unify the notation.
  3. [Appendix B.2] The prompt instructs the LLM to include a one-sentence algorithm description as a comment line, but later says 'The solution must not contain any comments' and 'Remove all comments before final output'. This is contradictory and should be clarified.
  4. [§5.3] The claim that the search is 'limited by the heuristic space rather than computation time' is not supported by the data: increasing the budget from 10s to 60s gives mean 777.3±4.2 vs 781.0±21, which is not an improvement and has high variance. Please either provide a statistical test or rephrase this as an observation.
  5. [§5.2] The statement that scaffolding is a 'necessary prerequisite' for iterative self-correction is not directly tested, since the authors state 'we did not test ISC on the naive baseline directly'. Please soften this to a conjecture or add the missing experiment.

Circularity Check

0 steps flagged · score 1.0 of 10

No circular derivation: test-set results are out-of-sample; the scoring-function-concentration claim is confounded but not tautological.

full rationale

The quantitative derivation chain is not circular. The EoH search evolved scoring functions on 20 training instances, and the 27 held-out instances were not used during search (Section 5.1). The best scoring function was then transplanted into the RS+SP hybrid (Section 5.4), and the reported test-total of 694.3 containers is a genuine out-of-sample evaluation, not a value fitted to the test set. No fitted parameter equals the predicted quantity: the LLM-discovered scoring function is an independent component, and the RS+SP framework's randomization and set-partitioning pool do not encode the test labels. The interpretive claim that the LLM concentrated on scoring functions 'almost exclusively' (Section 5.3, abstract) is a conclusion about model behavior, not a derived mathematical result. It is threatened by a confound: the scaffolded BaseAlgorithm API (Section 4.2, Appendix B.2) pre-supplies geometric validity checks and the initial population was 'a homogeneous population of simple largest-item-first heuristics' (Section 5.3), which may channel the LLM toward scoring refinements. However, the LLM itself authored the candidate-position generator and scoring code (Appendix F), so the behavior is not true by definition. The paper also explicitly acknowledges the limited generalizability of its observations (Section 6). Finally, there is no load-bearing self-citation chain: the cited EoH and FunSearch works are external, and no uniqueness claim is imported from the authors' own prior work. Therefore, no circular step is exhibited.

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

The central claim rests on trusting the benchmark baselines from [14], importing a constraint definition from private communication, generalizing from one LLM, and accepting a fixed candidate-position generator. No invented entities are introduced. Free parameters are the hand-chosen RS randomization values, evolution hyperparameters, and the scoring weights the search itself fits to the training split.

free parameters (3)
  • RS randomization parameter (beta in prose, alpha in implementation details) = 0.0, 0.05, 0.15
    Hand-chosen diversity parameter for the hybrid randomized-search stage; no sensitivity analysis is reported and the notation is inconsistent.
  • Evolved scoring function weights = e.g., 0.9*volume + 0.05*priority + 0.05*adjacency (Appendix F)
    Fitted by the evolutionary search to the 20 training instances; out-of-sample test results support the claims, but the headline numbers depend on these fitted weights.
  • Evolution hyperparameters = population 5, 10 generations, 10s/60s budget, 5 correction attempts
    Hand-chosen; the 10s-vs-60s comparison is used to argue the search is space-limited rather than time-limited.
assumptions (4)
  • domain assumption The SSSCSP benchmark instances, the exact-solver optima, and all cited human-designed baseline results from [14] are correct and directly comparable to the authors' runs.
    Core comparisons in Tables 2-4 treat literature baselines as ground truth without re-running them.
  • ad hoc to paper The separation constraint (items of the first and second type in each instance are incompatible) matches the rule used to compute the [14] baselines.
    Defined in Appendix A via private communication and not specified in the original publication; a mismatch would invalidate the separation rows of Table 4.
  • domain assumption Gemini-2.0-flash is representative of current LLM capabilities for the paper's generalization to 'current LLMs'.
    The abstract generalizes from a single model; Section 6 concedes this.
  • ad hoc to paper The fixed candidate-position generator (axis-aligned offsets of placed items plus origin, Appendix F) spans a useful subset of placements and does not artificially cap solution quality.
    This enumeration is inherited by every generated heuristic and cannot be modified by the LLM, so it bounds what the discovered heuristics can express, but its completeness is not analyzed.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Re-evaluating LLM-based Heuristic Search: A Case Study on the 3D Packing Problem." pith.science (2026). https://pith.science/paper/NXCK3ZDO

@misc{pith2026250902297,
  author       = {Pith},
  title        = {Pith review of: Re-evaluating LLM-based Heuristic Search: A Case Study on the 3D Packing Problem},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/NXCK3ZDO}},
  note         = {Machine review of arXiv:2509.02297}
}
read the original abstract

The art of heuristic design has traditionally been a human pursuit. While Large Language Models (LLMs) can generate code for search heuristics, their application has largely been confined to adjusting simple functions within human-crafted frameworks, leaving their capacity for broader innovation an open question. To investigate this, we tasked an LLM with building a complete solver for the constrained 3D Packing Problem. Direct code generation quickly proved fragile, prompting us to introduce two supports: constraint scaffolding--prewritten constraint-checking code--and iterative self-correction--additional refinement cycles to repair bugs and produce a viable initial population. Notably, even within a vast search space in a greedy process, the LLM concentrated its efforts almost exclusively on refining the scoring function. This suggests that the emphasis on scoring functions in prior work may reflect not a principled strategy, but rather a natural limitation of LLM capabilities. The resulting heuristic was comparable to a human-designed greedy algorithm, and when its scoring function was integrated into a human-crafted metaheuristic, its performance rivaled established solvers, though its effectiveness waned as constraints tightened. Our findings highlight two major barriers to automated heuristic design with current LLMs: the engineering required to mitigate their fragility in complex reasoning tasks, and the influence of pretrained biases, which can prematurely narrow the search for novel solutions.

Figures

Figures reproduced from arXiv: 2509.02297 by the authors.

Figure 1
Figure 1. The evolutionary trajectory for one run, plotting the fitness of the best-performing heuristic in each generation evaluated on [PITH_FULL_IMAGE:figures/full_fig_p009_1.png] view at source ↗

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

38 extracted references · 32 canonical work pages

  1. [14]

    The exact solutions of several types of container loading problems

    Deidson Vitorio Kurpel, Cassius Tadeu Scarpin, José Eduardo Pécora Junior, Cleder Marcos Schenekemberg, and Leandro C Coelho. The exact solutions of several types of container loading problems. European Journal of Operational Research , 284(1):87–107, 2020

    work page 2020

  2. [1]

    Optimus: Scalable optimization modeling with (mi) lp solvers and large language models

    Ali AhmadiTeshnizi, Wenzhi Gao, and Madeleine Udell. Optimus: Scalable optimization modeling with (mi) lp solvers and large language models. arXiv preprint arXiv:2402.10172, 2024

    arXiv 2024

  3. [2]

    A survey of genetic programming and its applications

    Milad Taleby Ahvanooey, Qianmu Li, Ming Wu, and Shuo Wang. A survey of genetic programming and its applications. 2019

    work page 2019

  4. [3]

    On-line three-dimensional packing problems: A review of off-line and on-line solution approaches

    Sara Ali, António Galrão Ramos, Maria Antónia Carravilla, and José Fernando Oliveira. On-line three-dimensional packing problems: A review of off-line and on-line solution approaches. Computers & Industrial Engineering , 168:108122, 2022

    work page 2022

  5. [4]

    Mathematical models for multi container loading problems with practical constraints

    Maria Teresa Alonso, Ramón Alvarez-Valdés, Manuel Iori, and Francisco Parreño. Mathematical models for multi container loading problems with practical constraints. Computers & Industrial Engineering , 127:722–733, 2019

    work page 2019

  6. [5]

    Eine heuristik für multiple containerladeprobleme: A heuristic for multiple container loading problems

    Andreas Bortfeldt. Eine heuristik für multiple containerladeprobleme: A heuristic for multiple container loading problems. OR-Spektrum, 22(2): 239–261, 2000

    work page 2000

  7. [6]

    Constraints in container loading–a state-of-the-art review

    Andreas Bortfeldt and Gerhard Wäscher. Constraints in container loading–a state-of-the-art review. European Journal of Operational Research , 229 (1):1–20, 2013

    work page 2013

  8. [7]

    The multiple container loading cost minimization problem

    Chan Hou Che, Weili Huang, Andrew Lim, and Wenbin Zhu. The multiple container loading cost minimization problem. European Journal of Operational Research, 214(3):501–511, 2011

    work page 2011

Show all 38 references
  1. [8]

    Bin packing approximation algorithms: survey and classification

    Edward G Coffman Jr, János Csirik, Gábor Galambos, Silvano Martello, and Daniele Vigo. Bin packing approximation algorithms: survey and classification. In Handbook of combinatorial optimization , pages 455–531. Springer, 2013

    2013

  2. [9]

    Solving container loading problems by block arrangement

    Michael Eley. Solving container loading problems by block arrangement. European Journal of Operational Research , 141(2):393–409, 2002

    2002

  3. [10]

    A bottleneck assignment approach to the multiple container loading problem

    Michael Eley. A bottleneck assignment approach to the multiple container loading problem. OR spectrum, 25(1):45–60, 2003

    2003

  4. [11]

    Sensitivity and robustness of large language models to prompt template in japanese text classification tasks

    Chengguang Gan and Tatsunori Mori. Sensitivity and robustness of large language models to prompt template in japanese text classification tasks. arXiv preprint arXiv:2305.08714, 2023

    2023 arXiv

  5. [12]

    Gimenez-Palacios, M

    I. Gimenez-Palacios, M. T. Alonso, R. Alvarez-Valdes, and F. Parreño. Logistic constraints in container loading problems: the impact of complete shipment conditions. TOP, 29:177–203, 2021

    2021

  6. [13]

    An integer programming based heuristic approach to the three dimensional packing problem

    Nancy J Ivancic. An integer programming based heuristic approach to the three dimensional packing problem. 1988

    1988

  7. [15]

    Holistic evaluation of language models

    Percy Liang, Rishi Bommasani, Tony Lee, Dimitris Tsipras, Dilara Soylu, Michihiro Yasunaga, Yian Zhang, Deepak Narayanan, Yuhuai Wu, Ananya Kumar, et al. Holistic evaluation of language models. arXiv preprint arXiv:2211.09110, 2022

    2022 arXiv

  8. [16]

    The container loading problem

    Andrew Lim and Xingwen Zhang. The container loading problem. In Proceedings of the 2005 ACM symposium on Applied computing , pages 913–917, 2005

    2005

  9. [17]

    Evolution of heuristics: Towards efficient automatic algorithm design using large language model

    Fei Liu, Xialiang Tong, Mingxuan Yuan, Xi Lin, Fu Luo, Zhenkun Wang, Zhichao Lu, and Qingfu Zhang. Evolution of heuristics: Towards efficient automatic algorithm design using large language model. arXiv preprint arXiv:2401.02051, 2024

    2024 arXiv

  10. [18]

    Heuristic methods for evolutionary computation techniques

    Zbigniew Michalewicz. Heuristic methods for evolutionary computation techniques. Journal of Heuristics, 1(2):177–206, 1996

    1996

  11. [19]

    Container packing problem with balance constraints

    Ilkyeong Moon and Thi Viet Ly Nguyen. Container packing problem with balance constraints. OR spectrum, 36(4):837–878, 2014

    2014

  12. [20]

    A grasp approach to the container-loading problem

    Ana Moura and José Fernando Oliveira. A grasp approach to the container-loading problem. IEEE Intelligent Systems, 20(4):50–57, 2005

    2005

  13. [21]

    Automating the planning of container loading for Atlas Copco: Coping with real-life stacking and stability constraints

    Jonas Olsson, Torbjörn Larsson, and Nils-Hassan Quttineh. Automating the planning of container loading for Atlas Copco: Coping with real-life stacking and stability constraints. European Journal of Operational Research , 280(3):1018–1034, 2020

    2020

  14. [22]

    Training language models to follow instructions with human feedback.Advances in neural information processing systems, 35:27730–27744, 2022

    Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instructions with human feedback.Advances in neural information processing systems, 35:27730...

    2022

  15. [23]

    A new load balance methodology for container loading problem in road transportation

    António G Ramos, Elsa Silva, and José F Oliveira. A new load balance methodology for container loading problem in road transportation. European Journal of Operational Research , 266(3):1140–1152, 2018

    2018

  16. [24]

    Mathematical discoveries from program search with large language models

    Bernardino Romera-Paredes, Mohammadamin Barekatain, Alexander Novikov, Matej Balog, M Pawan Kumar, Emilien Dupont, Francisco JR Ruiz, Jordan S Ellenberg, Pengming Wang, Omar Fawzi, et al. Mathematical discoveries from program search with large language models. Nature, 625 (799...

    2024

  17. [25]

    Heuristic algorithm for the container loading problem with multiple constraints

    Liu Sheng, Shang Xiuqin, Cheng Changjian, Zhao Hongxia, Shen Dayong, and Wang Feiyue. Heuristic algorithm for the container loading problem with multiple constraints. Computers & Industrial Engineering , 108:149–164, 2017

    2017

  18. [26]

    Large language models as optimizers

    Chengrun Yang, Xuezhi Wang, Yifeng Lu, Hanxiao Liu, Quoc V Le, Denny Zhou, and Xinyun Chen. Large language models as optimizers. In The Twelfth International Conference on Learning Representations , 2023. 14 Guorui Quan, Mingfei Sun, and Manuel López-Ibáñez

    2023

  19. [27]

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

    Haoran Ye, Jiarui Wang, Zhiguang Cao, Federico Berto, Chuanbo Hua, Haeyeon Kim, Jinkyoo Park, and Guojie Song. Reevo: Large language models as hyper-heuristics with reflective evolution. Advances in neural information processing systems , 37:43571–43608, 2024

    2024

  20. [28]

    Or-llm-agent: Automating modeling and solving of operations research optimization problem with reasoning large language model

    Bowen Zhang and Pengcheng Luo. Or-llm-agent: Automating modeling and solving of operations research optimization problem with reasoning large language model. arXiv preprint arXiv:2503.10009, 2025

    2025 arXiv

  21. [29]

    Integer linear programming models for the containership stowage problem

    Huiling Zhu, Mingjun Ji, and Wenwen Guo. Integer linear programming models for the containership stowage problem. Mathematical Problems in Engineering, 2020(1):4382745, 2020

    2020

  22. [30]

    naive approach

    Wenbin Zhu, Weili Huang, and Andrew Lim. A prototype column generation strategy for the multiple container loading problem. European Journal of Operational Research, 223(1):27–39, 2012. A Reproducibility Checklist • Code: The complete source code is available at https://github...

    2012

  23. [34]

    **No Overlap:** Items cannot overlap

  24. [36]

    Constraint Scaffolding

    **Immutable Inputs:** Your function must not modify its input arguments ( `unplaced_items`, `trucks_in_use`). Treat them as read-only.↩→ Data Distribution Summary: Container Properties (identical for all containers in a problem): - Length: Min=10.00, 25th=16.25, Median=20.00, ...

  25. [37]

    No weight or support constraints apply

    **Single Container Type:** All containers are identical. No weight or support constraints apply

  26. [38]

    **Complete Placement:** All items of all types must be packed

  27. [39]

    There are 6 possible orientations

    **Item Orientation:** Items can be rotated. There are 6 possible orientations

  28. [40]

    Re-evaluating LLM-based Heuristic Search: A Case Study on the 3D Packing Problem 17

    **No Overlap:** Items cannot overlap. Re-evaluating LLM-based Heuristic Search: A Case Study on the 3D Packing Problem 17

  29. [41]

    **Boundaries:** Items must be placed fully inside the container

  30. [42]

    epsilon should be a small positive value

    **Immutable Inputs:** Your function must not modify its input arguments (unplaced_items, trucks_in_use). Treat them as read-only. The calling environment manages state.↩→ Data Distribution Summary: Container Properties (based on all loaded instances): - Length: Min=10.00, 25th...

Pith tools

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