LLM-Guided Proof Search

• LLM-guided proof search is the integration of language models with symbolic validators to generate, check, and refine proofs in mathematics and program verification.
• It employs prompt engineering, hierarchical decomposition, and iterative error correction to mitigate syntactic errors and optimize proof generation.
• Advanced mechanisms like heuristic ranking, resource filtering, and search orchestration are used to overcome challenges such as hallucination and combinatorial explosion.

LLM-guided proof search denotes the systematic integration of LLMs with formal reasoning engines to automate, accelerate, and improve the process of constructing, checking, and refining mathematical or program verification proofs. LLMs are exploited for their pattern completion, abstraction synthesis, and linguistic capabilities to generate proof steps, suggest decompositions, or select strategies, while external symbolic systems ensure logical soundness and resource compliance through robust validation mechanisms.

1. High-level Methodology and Architectures

LLM-guided proof search spans a broad design space, but all major frameworks interleave LLM-driven generation with deterministic symbolic verification or search. In typical workflows, the LLM is not entrusted with absolute proof completion—rather, it generates candidate proof structures, tactics, decompositions, or stepwise hints that are validated, refined, or rejected by a formal core. Architectures vary depending on the target formalism, but share the following fundamental elements:

• Prompted Generation: LLMs are prompted with context—such as theorem statements, current goals, proof history, and failure feedback—to generate the next step, outline, or decomposition (Drechsler, 29 May 2025, Zhou et al., 10 Dec 2025, Hu et al., 21 May 2025).
• Symbolic Validation or Execution: Outputs are parsed and checked by systems such as BDD-based engines in PFV (Drechsler, 29 May 2025), TLAPS for TLA+ (Zhou et al., 10 Dec 2025), or SMT/ITP kernels (Lean, Isabelle, Dafny, Coq) (Baksys et al., 11 Dec 2025, Hou, 8 Jan 2026, Wischermann et al., 18 Jul 2025).
• Stateful Control: Context stores or explicit state tracking (e.g., of derived facts, proven lemmas, errors) allow interaction loops, error-driven refinement, and search pruning.
• Search Orchestration: Control is typically delegated either to a user (human-in-the-loop), to an external program, or—in advanced systems—to an LLM functioning as a strategy selector (Lu et al., 29 Oct 2025).

Major system exemplars include tightly coupled iterative loops for stepwise BDD proof generation (Drechsler, 29 May 2025), hybrid lemma-guided decompositions for Lean (Wischermann et al., 18 Jul 2025), hierarchical claim decomposition in TLA+ (Zhou et al., 10 Dec 2025), and beam-search-based synthesis with verification in Isabelle/HOL (Hou, 8 Jan 2026).

2. Prompt Engineering, Guidance, and Decomposition

A distinctive aspect of LLM-guided proof search is the use of engineered prompts and context summarization to steer generation. This involves:

• Template-driven prompting: Each step is guided by a predefined template with the current subgoal, accepted proof fragments, and explicit instructions for output format and expected constructs (e.g., LaTeX in PFV, normalized JSON for TLA+) (Drechsler, 29 May 2025, Zhou et al., 10 Dec 2025).
• Contextualization: Prompts may include natural language explanations, prior lemmas, summaries of the current proof context, or error feedback from failed verification attempts (Wischermann et al., 18 Jul 2025, Baksys et al., 11 Dec 2025).
• Hierarchical or modular decomposition: LLMs are instructed to decompose complex goals into structured sub-claims, often in normalized or restricted syntactic forms to minimize parse and verification failures. For example, in TLA+, LLM output is restricted to normalized claim blocks, which drastically increases syntactic validity compared to free-form proof generation (over 65% vs. less than 20%) (Zhou et al., 10 Dec 2025).

This paradigm achieves error containment and facilitates incremental checking, preventing error propagation that would occur with monolithic end-to-end proof generation.

3. Search, Heuristics, and Pruning Mechanisms

LLM-guided frameworks universally employ external search and pruning mechanisms to counteract LLM hallucinations, prevent tangents, and optimize search effort:

• Induction depth bounding and pattern matching: In resource-bounded PFV, the induction depth in LLM proofs is capped, common term-pattern libraries are used to restrict admissible constructions, and every suggested step is checked for compliance with an explicit resource polynomial (Drechsler, 29 May 2025).
• Linearization and modularization: Architectures like LogicTree decompose premise selection into strictly linear processes (forward and backward selection) and rigorously cache all derived facts for cross-branch reuse, which is essential for proof search scalability. This linear decomposition reduces combinatorial branch explosion and enables the system to proceed with one derivation per step (He et al., 18 Apr 2025).
• Heuristic ranking and retrieval: Fact and rule prioritization via semantic similarity or dependency parses, as well as premise retrieval using TF–IDF, bi-encoder/cross-encoder approaches or dense retrieval, are employed to select which branches of the proof tree to extend next (He et al., 18 Apr 2025, Hou, 8 Jan 2026).
• Cost-based and resource filtering: Steps proposed by the LLM that breach explicit theorem resource bounds (e.g., BDD size in PFV) are pruned before entering the symbolic checker (Drechsler, 29 May 2025).

A plausible implication is that the integration of such structural filtering is key to scaling LLM-based proof search to domains with large search spaces and nontrivial resource or syntactic constraints.

4. Validation, Feedback, Refinement

Critical to safety and completeness, external engines validate every LLM-produced step. Validation pipelines perform:

• Syntactic well-formedness checking: Ensuring outputs comply with the expected input grammar of the symbolic backend (e.g., TLA+ claim format, Lean/Isabelle tactic syntax) (Zhou et al., 10 Dec 2025, Hu et al., 21 May 2025).
• Semantic checking: Each proof step, tactic, or claim is executed or simulated in the formal system, with feedback on errors, failures, or resource overruns directly incorporated into subsequent LLM prompts (Lu et al., 29 Oct 2025, Hou, 8 Jan 2026, Baksys et al., 11 Dec 2025).
• Iterative error-guided correction: LLM-based systems include explicit loops for iterative refinement, enabling multi-stage correction of initial outputs using both structured error messages and synthesized context. This is particularly emphasized in systems such as Adapt, where the LLM acts not just as a generator but as a dynamic strategy selector, adaptively choosing among lemma discovery, context enrichment, or regeneration based on proof state and error traces (Lu et al., 29 Oct 2025).
• Abstraction learning: In multi-stage hybrid architectures (e.g., HybridProver), sketches are first extracted from whole-proof LLM outputs and then recapitalized by a tactic-based LLM for stepwise refinement, leveraging the abstraction capacities of the former and the detail-oriented control of the latter (Hu et al., 21 May 2025).

A significant consequence is that systems with external feedback loops and strategy switches substantially outperform pipelines that rely on one-shot LLM proofs alone.

5. Empirical Results and Benchmarking

Quantitative evaluations across diverse formal systems and proof goals consistently demonstrate that LLM-guided methods outperform both strictly neural and strictly symbolic baselines, but the extent depends on the degree of integration and sophistication of search and validation. Representative results include:

• Proof accuracy: On miniF2F and ProofNet, beam-size-annealed LLM-guided search achieves average pass@1 rates up to 60.74% and 21.18%, respectively—significantly surpassing alternative baselines (Lai et al., 17 May 2025).
• Resource efficiency: In ProofCompass, LLM guidance reduces prover calls on miniF2F by 25× (3200→128) while modestly increasing the top-pass rate (54.9%→55.3%) over the DSP-v1.5 baseline (Wischermann et al., 18 Jul 2025).
• Robust decomposition for syntax-rich targets: In TLA+, claim decomposition via prompted LLMs achieves over 65% syntactic validity (vs. <20% for direct proof generation) and up to 2× improvement in proof success rate on a 119-theorem benchmark compared to direct and symbolic-only baselines (Zhou et al., 10 Dec 2025).
• Iterative correction: In Dafny, LLM-hinted, error-corrected proofs realize a 35% relative improvement in pass@4 over the empty-body auto-active baseline (55.7% vs. 40.6%) (Baksys et al., 11 Dec 2025).
• Adaptivity: The Adapt system's LLM-driven strategy selection improves theorems proven on CoqDev by 18.58 and on CoqStoq by 16.63 percentage points over the best prior baselines (Lu et al., 29 Oct 2025).

6. Limitations, Open Problems, and Future Directions

Despite empirical gains, LLM-guided proof search faces notable challenges and research opportunities:

• Hallucination and semantic drift: LLMs may generate steps that are subtly wrong, misleading, or resource-violating. Error correction and proactive pruning mitigate but do not eliminate these issues (Drechsler, 29 May 2025).
• Syntactic fragility and brittleness: Without normalization or rigid prompting, LLM output can suffer from high syntactic error rates, stalling downstream automation (Zhou et al., 10 Dec 2025).
• Search complexity and step explosion: In nontrivial proofs, combinatorial branch expansion or deep nesting can overwhelm beam-search or sketch-refinement approaches. Caching, linearization, and learned prioritization heuristics only partially address this bottleneck (He et al., 18 Apr 2025, Hou, 8 Jan 2026).
• Limitation to shallow or template-based lemma invention: Most current systems employ “shallow” search; deeply inventive lemma discovery for highly non-linear proofs remains unsolved (Zhou et al., 10 Dec 2025, Lu et al., 29 Oct 2025).
• Generalization across domains and tasks: Performance may degrade for goals far outside a system's synthetic training distribution or when ported to new logics lacking abundant training data (Lai et al., 17 May 2025, Lu et al., 29 Oct 2025).
• Fundamental code and reasoning barriers: Even the latest LLMs (e.g., GPT 5.2, Gemini 3 Pro) struggle with complex, compositional Isar code spanning dozens of files and complex pointer-based context management (Hou, 8 Jan 2026).

Anticipated future work includes integrating retrieval-augmented generation, fine-tuning on proof corpora for specific logics, reinforcement learning over decomposition strategies, enhanced counterexample-guided repair, and tighter neuro-symbolic integration. There is also active exploration of theoretical characterizations for when LLM-guidance yields provable speedups over purely symbolic search.

7. Principal Research Systems and Their Comparative Characteristics

System/Domain	LLM Role	Guidance/Pruning	Validation	Key Empirical Gain
PFV (Drechsler, 29 May 2025)	Plan + step generator	Induction depth, BDD patterns, cost bounds	BDD-based checker	Generates human-readable PFV proofs, verified for n≫1000
ProofCompass (Wischermann et al., 18 Jul 2025)	NL strategy + lemma selector	Lemma extraction, NL proof summaries	Lean4 kernel	25× call reduction at constant accuracy
TLA+ (Zhou et al., 10 Dec 2025)	Claim decomposer	Normalized claim output	TLAPS	Up to 2× improvement, 65%+ syntactic validity
Dafny (Baksys et al., 11 Dec 2025)	Hint generator	Iterative error correction	SMT verifier	35% relative pass@4 gain
HybridProver (Hu et al., 21 May 2025)	Sketch + tactic generator	Stepwise refinement, model scoring	Isabelle kernel	59.4% SR vs 56.1% prior SOTA
LogicTree (He et al., 18 Apr 2025)	Derivation/selector	Linearized search, fact caching, heuristics	LLM + dataset check	95.6% accuracy vs 72% CoT baseline
Adapt (Lu et al., 29 Oct 2025)	Strategy selector	Dynamic lemma/context enrichment	Coq kernel	+18.58 pp provable over prior best

All approaches combine prompt-driven LLM generation with algorithm-guided symbolic verification, search pruning, or adaptive correction, yielding substantial gains across diverse benchmarks, albeit with domain-specific constraints and varying reliance on synthetic data or fine-tuning.