acceptodds
Under review as a conference paper at ICLR 2027

LeanPlan: Optimal Planning with LLM-Generated Heuristics and Admissibility Proofs

Abstract

Frontier large language models (LLMs) can generate heuristic functions that guide search to achieve state-of-the-art performance in satisficing planning, where any plan is acceptable. However, these heuristics are not guaranteed to be admissible and can lead to suboptimal plans. We introduce LeanPlan, the first planning system that finds optimal plans with LLM-generated heuristics whose admissibility is machine-checked. Given a domain description and training tasks, an agentic loop uses planner feedback to iteratively improve a reusable domain-specific heuristic, its admissibility proof and the required domain assumptions. LeanPlan implements the heuristic, its proof and an efficient planner with machine-checked grounding and search in Lean 4. We evaluate LeanPlan on ten domains from the International Planning Competition and three new domains, using test tasks with up to 57 times as many objects as the training tasks. With GPT 5.6 Sol in the agentic loop, we successfully generate heuristics and admissibility proofs for all these domains. The resulting heuristics are generally more informed than the strong admissible heuristics of the state-of-the-art Scorpion planner, and with them LeanPlan solves more tasks overall than Scorpion.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
optimal planning, large language models, formal verification, program synthesis

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_WZR3OpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
3(+1)
Read review
Paper summary

This paper studies optimal classical planning with LLM-generated heuristics. Traditional optimal planners return optimal plans, but their domain-independent heuristics do not exploit domain structure and scale poorly. Existing LLM methods generate heuristics for satisficing planning, so their plans may not be optimal. LeanPlan uses an agentic loop in which an LLM writes a strong domain-specific heuristic and proves its admissibility in Lean, so that A* finds optimal plans at low cost. The loop runs once per domain on training tasks. LeanPlan is evaluated on test tasks from ten IPC 2023 domains and three new domains, where it solves 281 and 67 tasks, against 221 and 51 for Scorpion. VAL accepts every returned plan, and all planners find plans of the same cost on a task.

Critical strengths
  1. The problem, the method and the results are clearly presented, and the purpose of the method and its correctness are easy to follow. Proving admissibility in Lean is a useful complement that removes the main reason not to trust LLM-written heuristics in optimal planning. Admissibility reduces to goal awareness and consistency on reachable states.
  2. The experiments support the correctness claim. VAL accepts every returned plan, and all planners find plans of the same cost on a task.
Critical weaknesses
  1. One run per domain shows that the loop can succeed, but not how reliably.
    • The loop was run once per domain, with one model and one coding agent (L311-312, L480-481).
    • The three new domains are the only ones the model cannot have seen, yet the appendix does not describe their heuristics or certificates. L252-253 says App. C covers the remaining heuristics, so these should be added.
    • Their test tasks are at most about twice the training size (L90-92), and even so the Cisterns certificate refused three test tasks, the only refusals among 1,170 (L418-419).
    • The method is the loop, not the 13 heuristics, so how reliably the loop runs decides how far the results generalize. Question 3 asks for a rerun.
  2. Two steps may fall outside the machine-checked guarantee.
    • The abstract says grounding is machine-checked (L018-020), and grounding prunes actions with h2h^2 mutexes (L236-237). App. A lists proofs for atom numbering, static preconditions and relevance pruning, but not for h2h^2 pruning (L787-788), and Sec. 7 does not list it as unchecked (L483-485). Since the search guarantees concern the executable ground task (L792), optimality for the original PDDL task may rest on unverified code. Please check the paper's wording against the system you built (Question 2).
    • App. B tells the agent that "A theorem that is true but says less fails" (L930-932). Sec. 3 does not say how the controller detects a weakened statement, and the axiom audit alone would not (L208-209). The source scan covers only sorry, admit, native_decide and new axioms (L205-207, L927-929), so an attribute such as implemented_by would pass both checks while letting the compiled heuristic differ from the proved definition. Could you assess whether the loop can exploit this (Question 2)?
Questions for authors
  1. [Clarification] Did the worked examples in the prompt (App. B) include a heuristic or proof for any evaluated domain?
  2. [Clarification] Is h2h^2 pruning proved, or treated as a trusted component? Does the controller compare theorem statements with fixed references and reject attributes such as implemented_by? If both are handled, I would support acceptance more firmly.
  3. [Requested analysis] Could you rerun the loop on each new domain and report how often it succeeds and the coverage of the heuristics it produces?
  4. [Clarification] Could you describe the heuristics and certificates for the three new domains in an appendix, and say what the tasks refused by the Cisterns certificate have in common?
5 comments

Thank you for the positive assessment of the method and its correctness. We first present the additional experiments, which also inform our answers below.

W1 and Q3: Repeated Synthesis on the New Domains

We extended the experiments to LeanPlan with GPT-6.1 Sol and repeated synthesis three times across all ten IPC and three new domains. Every repetition produced a verified heuristic in every domain. The table reports mean coverage (90 tasks per domain), with mean ± sample standard deviation in total rows for LeanPlan with GPT-6.1 Sol. Search totals cover the same 248 tasks solved by all configurations, using per-task medians over three evaluations for the new heuristics. Scorpion SCP and GPT-5.6 Sol results are paper references. The full domain table appears in our response to Reviewer JCJG.

DomainScorpion SCPLeanPlan GPT-5.6 SolLeanPlan GPT-6.1 Sol
Cisterns262546.7
Orrery182090.0
Qubit Routing72217.3
New-Domain Total5167154.0 ± 7.9
IPC Total221281380.3 ± 9.2
Overall Total272348534.3 ± 7.2
Total Search Time Including Heuristic Setup (s, Common Tasks)3,192.42,273.4188.3 ± 30.3
Total Expansions (Thousands, Common Tasks)74,500.033,682.1784.8 ± 325.7

All three synthesis repetitions produced a verified heuristic in every domain. Compared with Scorpion SCP, mean new-domain coverage increases from 51 to 154 tasks. On the 248 jointly solved tasks, LeanPlan with GPT-6.1 Sol is about 17 times faster, and requires 95 times fewer expansions than Scorpion SCP. These experiments extend the evidence from one successful synthesis per domain to repeated synthesis using a new model across the full benchmark suite. We will include these results in the paper.

W2 and Q2: Pruning and Enforcement of the Proof Contract

h2h^2 pruning is proved in Lean. The shared proofs establish that pruning preserves the optimal plan cost and that plans found after pruning correspond to plans of the original ground task with the same cost. They also connect the heuristic guarantees to the compiled search after pruning. We will make this proof coverage explicit in Appendix A and clarify its place in the formalized planning pipeline.

The controller checks the required theorem against a fixed statement about the actual heuristic and certificate used by the planner. A weaker theorem cannot satisfy that statement. The controller also rejects implementation overrides such as implemented_by and extern. Together with the axiom audit, these checks connect the proved claim to the executable heuristic. We will describe these checks explicitly in the paper.

Q1: Worked Examples in the Prompt

No, the prompt only uses heuristic and proof examples from Gripper and Logistics, neither of which is included in our evaluation. These illustrate the expected implementation and proof structure. We will clarify this in Appendix B.

W1 and Q4: New-Domain Heuristics and Certificate Refusals

We will include descriptions of all three heuristics and their certificates in the appendix:

  • Orrery: half the summed cyclic distances of goal wheels, rounded up. The certificate checks that an action moves at most two goal wheels by one step each.
  • Cisterns: the maximum of demand bounds and transport-potential bounds for the water-level changes still required. The certificate checks level updates and verifies that each bound decreases by at most the action cost.
  • Qubit Routing: remaining gate executions plus a swap lower bound from qubit distances and sets of gates with disjoint qubits. The certificate checks gate progression, qubit-position invariants, and the effect of each action on these bounds.

The paper's three Cisterns refusals share the same preprocessing interaction: relevance pruning removes a new-level add effect while retaining the old-level deletion. This preserves planning behavior but violates the complete level-update structure required by the certificate. The certificate correctly excludes these three tasks, which are counted as unsolved. Across the paper's test suite, the certificates accept 1,167 of 1,170 tasks. This allows the heuristics to exploit natural domain structure and apply to virtually the entire test suite with machine-checked admissibility guarantees.

Dear Reviewer WZR3,

We thank you again for your constructive review and positive assessment of the method. Our rebuttal provides the requested repeated synthesis results for all three new domains and discusses the proof guarantees, controller checks, prompt examples, and certificate refusals. As the discussion period approaches its conclusion, we would appreciate knowing whether these answers addressed the concerns you identified as important for firmer support. We would be glad to provide further clarification. If your concerns have been resolved, we kindly ask you to consider updating your score to reflect the additional evidence.

Thank you for the response and the repeated synthesis runs. Your explanations on h2h^2 pruning, the controller checks, the prompt examples, and the Cisterns refusals address my soundness questions well, so I am raising Soundness from 2 to 3. That said, the repeated runs switched to a stronger model rather than testing variance on the paper's original setup, per-domain variance and synthesis cost are still missing, and no revised PDF has been uploaded yet. I will therefore keep my overall rating at 3, and I continue to support acceptance.

Reviewer_qpPpOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes to solve the optimal planning problem by using Lean to verify that the proposed heuristic is admissible. The resulting framework, LeanPlan, has been tested on multiple domains, and has shown improvement over baseline methods such as Scorpion.

Critical strengths
  1. Having a rigorous tool such as Lean to check and prove LLM-generated heuristics is a very reasonable approach, as the quality of heuristics is the core to high-quality planning.
  2. The evaluation is done on both classical domains and new domains, and shows consistent performance across domains.
Critical weaknesses

The reviewer find the paper needs more evidence for both its novelty/theoretical claims and experimental results. Specifically.

  1. The paper claims to be the “first” Lean-verified planner. However, there are definitely work using Lean to prove admissibility of heuristics for A*. For example: Behnke, Kilian, and Gattinger (ICAPS HSDIP 2026), “A with hmax Definitely Finds Optimal Plans-Formally Verifying a Planner Based on Heuristic Search.”* This paper explicitly reports Lean proofs of A* soundness, completeness, and optimality and the admissibility of various heuristics. The reviewer noticed that the above paper is cited. But the claimed contribution of this paper should be precise.

  2. The paper emphasizes that the verified heuristics can guarantee an optimal plan with A*. However, this claim needs to be stated more rigorously. The admissible heuristic alone cannot guarantee the correctness of the entire planning system. The optimality of the plan is conditioned on the capability of A* to return a plan given the limited computational resources and time. An amissible but badly designed heuristic can result in the entire planner not able to solve within given computational budget. Therefore, admissibility should not be the only objective of the planning algorithm.

  3. The experimental section needs to be made stronger.

  • The chosen baseline Scorpion is a classical symbolic planner instead of an LLM planning agent.
  • The baseline should be more recent LLM-based methods such as [1] Phung et al., “LLM-Evolved Pattern Generators for Optimal Classical Planning” (2026) [2] Pozo et al., constrained Cartesian abstractions (AAAI 2026) [3] Corrêa, Pereira, and Seipp, “Classical Planning with LLM-Generated Heuristics: Challenging the State of the Art with Python Code” (NeurIPS 2025) [4] Murray et al., “GenePlan: Evolving Better Generalized PDDL Plans using Large Language Models” (ICAPS 2026)
  • In the results, most advantage of LeanPlan is obtained in Spanner. On IPC domains without Spanner, the improvement over Scorpion is relatively marginal.
  • On larger instances, the reported results are misleading. Although there is “up to 57 times as many objects”, both LeanPlan and Scorpion can only solve a very small portion of the problems. e. The paper only uses one synthesis run per domain and cannot reliably establish the reliability of the pipeline.
Questions for authors
  1. Please clarify the novelty of the contribution
  2. Please clarify when an optimal plan can be guaranteed to be obtained
  3. Please compare with LLM-assisted planning or heuristic generation for planning
  4. Please establish more robust results
4 comments

Thank you for the review and constructive suggestions. We answer Q4 first to introduce the results used below.

W3 and Q4: Stronger and Repeated Results

We extended the experiments by running LeanPlan with GPT-6.1 Sol, complementing LeanPlan with GPT-5.6 Sol, and repeated synthesis three times across all ten IPC and three new domains. Every repetition produced a verified heuristic in every domain. New totals show mean ± sample standard deviation. Search totals use 248 common tasks and per-task medians over three evaluations for the new heuristics. Original columns are paper references.

Mean coverage rises from 16 to 38 in Childsnack, 29 to 64.3 in Ferry, 37 to 67 in Miconic, and 20 to 90 in Orrery. Scorpion SCP solves 9, 19, 40, and 18, respectively. The full domain table appears in our response to Reviewer JCJG.

MetricScorpion SCPLeanPlan GPT-5.6 SolLeanPlan GPT-6.1 Sol
IPC Total221281380.3 ± 9.2
New-Domain Total5167154.0 ± 7.9
Overall Total272348534.3 ± 7.2
Total Search Time Including Heuristic Setup (s, Common Tasks)3,192.42,273.4188.3 ± 30.3
Total Expansions (Thousands, Common Tasks)74,500.033,682.1784.8 ± 325.7

LeanPlan with GPT-6.1 Sol solves 120.3 of the 595 larger IPC tasks on average, compared with 13 for Scorpion SCP, over nine times as many. These results show that the gains extend to larger tasks and persist across repeated synthesis, strengthening the evidence for the practical effectiveness and reliability of the approach.

W1 and Q1: Novelty and Relation to Behnke et al.

LeanPlan automatically generates domain-dependent heuristics together with their admissibility proofs. The agent improves the heuristics using planning-performance feedback, while Lean checks the proofs for the executable heuristic code. The contribution combines automated heuristic design, formal guarantees, and practical optimal-planning performance.

Behnke, Kilian, and Gattinger focus on formalizing search algorithms and existing heuristics, whose implementations are written manually. Their executable planner serves as a proof of concept, and they explicitly state that "we can only solve the smallest planning problems." They report solving Miconic with 2 passengers and 4 floors, but encounter a stack overflow with 3 passengers and 6 floors. With GPT-6.1 Sol, all three LeanPlan synthesis repetitions solve a task with 200 passengers and 120 floors. LeanPlan therefore advances both the automated construction of verified heuristics and their practical use at substantially larger scales. We will make the novelty claim more precise in the paper.

W2 and Q2: Optimality Guarantees and Practical Performance

LeanPlan’s formal proofs establish correctness guarantees for the formalized planning pipeline, including grounding, the executed heuristic, and search. Under the conditions stated in the paper, its search theorems establish that returned plans are valid and optimal. The guarantees therefore extend beyond proving heuristic admissibility alone.

We agree that limited computational resources and time determine whether a plan can be found. Our synthesis process therefore explicitly optimizes planning performance while requiring admissibility proofs. The results above show higher coverage, lower search time, and fewer expansions than Scorpion SCP. They demonstrate that formal correctness guarantees can accompany substantial improvements over a state-of-the-art optimal planner.

W3 and Q3: Baselines and Comparisons

Our objective is to find minimum-cost plans, so Scorpion SCP is our state-of-the-art optimal-planning baseline. Corrêa et al. address satisficing planning, where any valid plan is acceptable. GenePlan generates generalized planning programs, also allowing any valid plan without requiring optimality. They therefore solve a different problem and are not comparable to an approach that finds plans with optimality guarantees.

Phung et al. and Pozo et al. also address optimal planning and compare against Scorpion configurations. Phung et al. report 29.0% coverage against 35.2% for Scorpion SYS-SCP. Pozo et al. report 53.2% against 50.9% for Scorpion with unconstrained Cartesian abstractions, a relative improvement of 4.6%.

Our Scorpion SCP configuration combines SYS-SCP pattern databases and Cartesian abstractions. LeanPlan with GPT-5.6 Sol achieves 29.7% coverage, and with GPT-6.1 Sol reaches 45.7%, compared with 23.2% for Scorpion SCP. Phung et al. perform worse than their Scorpion baseline, while Pozo et al. improve coverage by 4.6%, compared with 96.4% for LeanPlan. LeanPlan therefore achieves a substantially larger relative improvement over its Scorpion baseline. If the reviewer considers it important, we can add direct comparisons with these methods in the paper.

Dear Reviewer qpPp,

We thank you again for your review and suggestions. Our rebuttal presents substantially stronger results with GPT-6.1 Sol and three synthesis repetitions, together with clarifications of the contribution, optimality guarantees, and comparisons with related methods. As the discussion period approaches its conclusion, we would appreciate knowing whether these results and clarifications addressed your concerns. We would be glad to discuss any remaining point. If your concerns have been resolved, we kindly ask you to consider updating your score to reflect the additional evidence.

Thanks for adding the explanation and additional experiments.

  1. I still think the paper is overclaiming the contribution of "formal proof". Every guarantee or proof should be stated under the assumptions. The so-called guarantee is true only under the strong assumptions that the paper imposed.
  2. This work needs to be compared with other LLM agents. Having Scorpion as the baseline is unfair because the two are not using the same set of knowledge.

Dear Reviewer qpPp,

  1. Formal Guarantees

You are correct that formal guarantees hold under stated assumptions. Our paper explicitly states these assumptions and proves its claims under them. Our claim therefore matches what we prove. The assumptions are checked automatically and hold for 1,167 of the 1,170 test tasks, giving the proofs broad practical applicability.

The guarantee itself is substantive: finding a plan of optimal cost is different from establishing that no cheaper plan exists. A satisficing planner may happen to find an optimal plan without providing this guarantee. Helmert and Röger (AAAI 2008), How Good is Almost Perfect?, show that A* can require exponentially many expansions even with an almost-perfect heuristic, illustrating the difficulty of optimal heuristic search. Matching the cost of a returned plan therefore does not make satisficing and optimal planning equivalent objectives.

LeanPlan addresses both requirements: synthesis optimizes planning performance, while the machine-checked proofs establish the correctness guarantees. Our results demonstrate that these guarantees can accompany substantial practical gains.

  1. Scorpion and LLM-Based Comparisons

Scorpion SCP is a state-of-the-art optimal planner. Among the LLM-based methods you suggested, Phung et al. guarantees optimality, but reports lower overall coverage than its Scorpion baseline: 29.0% versus 35.2%. Scorpion therefore provides a stronger published reference. Corrêa et al. and GenePlan do not guarantee optimal solutions. They solve a different problem and are not comparable as optimal-planning baselines.

LeanPlan with GPT-6.1 Sol improves coverage over Scorpion SCP by 96.4%, solving 534.3 tasks on average versus 272. On the same 248 commonly solved tasks, it is about 17 times faster and requires 95 times fewer expansions. LeanPlan automatically generates domain-dependent heuristic code together with its machine-checked admissibility proof. The comparison demonstrates that this approach combines formal guarantees with substantial improvements over a state-of-the-art optimal planner.

Reviewer_JCJGOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

LeanPlan uses an LLM-based coding agent to generate domain-specific heuristics, Lean 4 proofs of their admissibility, and checks of the assumptions under which these proofs hold. The framework links the formal proofs to the heuristic actually executed by A*, providing conditional optimality guarantees. Across 13 planning domains and 1,170 test tasks, LeanPlan solves 348 tasks, compared with 272 for Scorpion SCP.

Critical strengths

S1. Formal verification of the executed heuristic. LeanPlan proves goal awareness and consistency for the heuristic used by its planner on reachable states under checked domain assumptions. As detailed in Section 3 and Appendix B, this connects generated code to conditional admissibility and optimality guarantees rather than relying solely on empirical testing.

S2. Meaningful improvements in planning performance. Table 1 shows that LeanPlan solves 348 tasks compared with 272 for Scorpion SCP, with verified heuristics obtained in all 13 domains. Section 5.2 further reports that LeanPlan solves 53 of the 595 IPC tasks larger than all training tasks in their respective domains, compared with 13 for SCP. These results demonstrate that formal verification does not necessarily come at the expense of practical performance.

Critical weaknesses

W1. Limited evidence of generation stability. As described in Section 5, the agentic pipeline is run only once per domain, using a single model and agent configuration. While success across all 13 domains demonstrates feasibility, it remains unclear whether independent runs would consistently produce verified heuristics of comparable quality and cost. The reported variation in runtime and cost is measured across domains rather than across repeated runs within the same domain. Repeated trials on representative domains would strengthen the evidence for reliability.

W2. Incomplete performance attribution and uneven gains across domains. The blind-search comparison in Section 5.1 and the within-LeanPlan expansion analysis provide useful evidence of heuristic effectiveness. Figure 3 also shows fewer expansions for LeanPlan on 152 of the 211 IPC tasks jointly solved by LeanPlan and SCP. However, differences in search implementation and tie-breaking remain, making it difficult to attribute the entire cross-planner performance advantage to heuristic quality. Moreover, Table 1 shows that Spanner accounts for 42 of the 76 net additional tasks solved. Although LeanPlan maintains an advantage without Spanner, the substantial variation across domains warrants a clearer explanation of when and why the generated heuristics are effective.

Questions for authors

Q1. Given that the generation pipeline was run only once per domain, how much do proof-generation success, solved-task coverage, runtime, and cost vary across independent runs on representative domains?

Q2. The Cisterns results mention three test tasks rejected by the certificate. Which assumptions led to these rejections, and what do they imply about the applicability of the verified heuristics to unseen tasks?

Q3. While the blind-search controls and expansion analysis are informative, could the authors further isolate heuristic quality under more closely matched search configurations, or explain the substantial variation in performance gains across domains?

2 comments

Thank you for the positive assessment and useful suggestions.

W1 and Q1: Repeated Synthesis and New Results

We have extended the experiments to a second model by running LeanPlan with GPT-6.1 Sol, complementing the original results of LeanPlan with GPT-5.6 Sol. We repeated synthesis independently three times on all ten IPC domains and all three new domains. Every repetition produced a verified heuristic in every domain. These experiments extend the evidence from one successful synthesis per domain to repeated synthesis using a new model across the full benchmark suite.

The table reports tasks solved out of 90 per domain, with means over the three synthesis repetitions for GPT-6.1 Sol. Total rows report mean ± sample standard deviation for GPT-6.1 Sol. Search time and expansions are summed over the same 248 test tasks solved by all configurations in every repetition, using per-task medians over three evaluations for the new heuristics. Scorpion SCP results and LeanPlan GPT-5.6 Sol are included from the original paper as a reference.

DomainScorpion SCPLeanPlan GPT-5.6 SolLeanPlan GPT-6.1 Sol
Blocksworld112028.7
Childsnack91638.0
Ferry192964.3
Floortile202020.0
Miconic403767.0
Rovers171819.7
Satellite272527.0
Sokoban313030.3
Spanner307267.0
Transport171418.3
IPC Total221281380.3 ± 9.2
Cisterns262546.7
Orrery182090.0
Qubit Routing72217.3
New-Domain Total5167154.0 ± 7.9
Overall Total272348534.3 ± 7.2
Total Search Time Including Heuristic Setup (s, Common Tasks)3,192.42,273.4188.3 ± 30.3
Total Expansions (Thousands, Common Tasks)74,500.033,682.1784.8 ± 325.7

The overall coverage increases from 348 to 534.3 tasks, with gains on both IPC and new domains. The repeated syntheses achieve comparable overall coverage, with a standard deviation of 7.2 tasks. On the jointly solved tasks, the new heuristics also substantially reduce search time and expansions. Together with successful verification in every domain, these results strengthen the evidence that the pipeline reliably produces useful heuristics. We will include these repeated-synthesis results in the paper.

Q2: Cisterns Certificate Refusals

The Cisterns certificate requires complete level updates: deleting the old level and assigning the new one. Relevance pruning retains all goal facts and the dependencies needed to achieve them, but can remove other water-level effects while retaining the corresponding old-level deletions. This preserves planning behavior but violates the structure required by the heuristic’s proof, which the certificate correctly detects.

In practice, the certificates accepted all but three of the 1,170 test tasks. All three refusals resulted from an interaction between preprocessing and specific task structures. Our domain-dependent heuristics exploit assumptions that are natural for a domain, but that particular task structures or pruning can violate. The certificates check these assumptions on each task, so the heuristics can exploit domain structure without giving up machine-checked admissibility guarantees. When an assumption fails, as in these three tasks, the certificate conservatively rejects the task, which is then counted as unsolved.

W2 and Q3: Search Configurations and Domain Variation

LeanPlan and Scorpion have very similar search implementations. Both use A∗A^*, h2h^2 preprocessing, the same PDDL inputs and resource limits, and lower-hh tie-breaking. The configurations are therefore closely matched. Within LeanPlan, using generated heuristics instead of blind search reduces total expansions by about 133 times on the 154 jointly solved IPC tasks.

Variation across domains reflects the structure captured by each synthesized heuristic. The original Spanner heuristic detects shortages of usable spanners and prunes dead ends, while the original Sokoban heuristic omits interactions between boxes. We will expand this domain-level explanation in the paper.

The additional experiments with GPT-6.1 Sol show substantially larger gains across several domains. Compared with Scorpion SCP, mean coverage increases by 29 tasks in Childsnack, 45.3 in Ferry, 27 in Miconic, and 72 in Orrery. On the 248 commonly solved tasks, the new heuristics require about 95 times fewer expansions than Scorpion SCP. These results illustrate the potential for stronger models to further increase the gains of the approach.

Thanks for your timely reply. I have no further questions.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.