proof tactic development

To address the challenges of low reusability of high-level tactics and high proof redundancy in interactive theorem provers (ITPs), this paper proposes an automated tactic discovery and refactoring method based on Tactic Dependency Graphs (TDGs). TDGs introduce a semantic-dependency abstraction—replacing syntactic matching—to decouple logical structure from implementation details, thereby enabling cross-proof identification of reusable high-level tactics and modular refactoring of existing proofs. Integrating program synthesis with proof-structure analysis, our custom tool TacMiner implements this approach. Experiments show that TacMiner discovers three times as many reusable tactics as baseline methods; reduces average proof size by 26%; and improves the success rate of downstream automation tools by 172%. This work establishes a new paradigm for tactic-level knowledge capture and reuse in ITPs.

This work proposes a novel paradigm termed “agent-based proof automation” to address the high cost of manually crafting lengthy formal proof scripts. In this approach, human experts supply key mathematical insights, while large language model (LLM) agents autonomously generate and iteratively refine proof scripts within the Lean 4 environment. Relying solely on off-the-shelf LLMs and lightweight verification tools, the method demonstrates— for the first time—the capacity for efficient, large-scale collaborative formal verification by LLM agents. Evaluated on the 14,000-line System Capless type safety proof, the system successfully completed 189 out of 217 tasks (87% success rate), with only 16% of the tasks requiring human intervention.

To address the low efficiency and high expertise barrier of manual formal verification, this paper proposes a two-stage framework integrating full-proof generation with strategy-driven refinement. Methodologically: (1) A fine-tuned LLM (Llama/Mistral) generates complete Isabelle proofs and extracts structured proof sketches; (2) These sketches are refined stepwise at the tactic level using Isabelle’s automation infrastructure. Our key contribution is the first end-to-end co-optimization of full-proof synthesis and tactic-level strategy generation within Isabelle, accompanied by the release of a high-quality dataset and models. Evaluated on the miniF2F benchmark, our approach achieves a 59.4% proof success rate—significantly surpassing the prior state-of-the-art (56.1%). Ablation studies confirm that the synergistic interaction between the two stages is the primary driver of performance improvement.

Large language models often introduce subtle, hard-to-detect bugs when generating complex software, compromising reliability. This work proposes the first fully automated, project-level code generation and verification framework based on an interactive theorem prover (ITP). The approach separates code with side effects into C++ while formalizing pure logical components in the ITP Rocq, where they are automatically verified and extracted for integration. When proofs fail, the concrete counterexample states guide an LLM agent to autonomously repair the code. In experiments, the system generated 1,859 lines of verified Rocq code and extracted 2,848 lines of C++ within 30 minutes, passing 265 unit tests and 12 hours of AFL++ fuzzing with zero crashes or hangs—outperforming Dafny’s backend, which failed to complete verification under identical conditions.

To address the high proof-writing cost and low automation in Coq formal verification, this paper proposes an LLM-driven proof generation method based on iterative synthesis. It leverages large language models to batch-generate candidate proofs and innovatively identifies and cross-proofs fuses locally valid fragments from multiple failed attempts. The approach supports incremental synthesis guided by partial progress—including subgoal decomposition and external lemmas. Under a strict no-training-data-leakage constraint, it achieves a 48% fully automated proof rate—31 percentage points higher than the prior SOTA Proverbot9001—and reaches 58% when incorporating external progress, establishing a new end-to-end SOTA for Coq automated theorem proving. Its core innovation lies in the systematic mining and cross-proof recomposition of effective fragments from failed proofs.

Traditional formal verification relies on expert-crafted proofs, which are difficult to scale, while existing large language model–based approaches suffer from low coverage due to reliance on predefined proof strategies. This work proposes a novel paradigm that delegates the generation of complete lemma proofs to general-purpose code agents (e.g., Claude Code), guided by a verification framework that enforces hard constraints and provides feedback to guarantee correctness, completeness, and termination. By abandoning fixed proof strategies, this approach achieves, for the first time, fully automated, end-to-end formal verification without human intervention and with full coverage across multiple proof assistants, including Coq and Lean. Experiments demonstrate its effectiveness: it automatically verifies all 4,474 lemmas in Iris logic and the Rust standard library, attains 100% coverage on the reglang benchmark, and successfully proves 72 previously unverified lemmas in iris-lean.

This work addresses the semantic gap between natural language specifications and RTL designs, which often leads to SystemVerilog assertions containing syntactic errors or semantic inaccuracies that hinder formal verification. To bridge this gap, the authors propose a knowledge graph–based multi-agent collaborative framework that unifies specifications, RTL code, and verification feedback into a structured intermediate representation for the first time. This enables traceable, design-anchored contextual modeling and supports a closed-loop assertion refinement process through a triple iterative optimization mechanism—comprising syntax repair, counterexample-guided correction, and coverage-driven enhancement. Evaluated on seven benchmark designs, the generated assertions are all compilable with low syntax-repair overhead and achieve formal verification coverage ranging from 78.5% to 99.4%.

This work addresses the challenge of formally verifying mature, safety-critical industrial C++ codebases by strategically integrating theorem proving (PVS) and model checking (SeaHorn), augmented with large language models to assist in specification construction. The approach is applied to the core order book algorithm of Stellar’s SDEX blockchain module. The verification effort successfully establishes critical correctness properties—including state consistency and unreachability of erroneous states—uncovers discrepancies between documentation and implementation, and produces reusable formal artifacts. These assets enable continuous validation of invariants during future code evolution, thereby enhancing long-term reliability and maintainability of the system.

This work addresses a central challenge in system security: formally verifying that system designs and implementations satisfy intended safety properties and support security certification. The authors propose a systematic approach grounded in proof assistants, integrating interactive theorem proving and formal methods to precisely model and machine-check critical security properties across diverse domains—including system security, language-level security, secure compilation, and cryptography. By enabling rigorous, machine-verifiable proofs of correctness, this methodology significantly strengthens the formal assurance of security properties and provides a unified theoretical framework and toolchain for constructing verifiable and certifiable secure systems.

This work addresses the challenge of deploying runtime systems that support expressive formal specification languages on resource-constrained microcontrollers, a limitation that undermines the verifiability of AI-generated safety-critical firmware. To bridge this gap, the authors propose Encore!, a bare-metal CPS virtual machine that models firmware cores as pure state-transition functions and executes Scheme code extracted from Rocq. By decoupling a constant-size, unverified host layer from a formally verified core, the approach ensures that verification effort remains independent of overall system complexity. Furthermore, it integrates large language models to assist in policy synthesis, replacing manual inspection with automatically generated theorem statements. This methodology enables, for the first time, the execution of fully formally verified, AI-generated firmware directly on microcontrollers, achieving both rigorous safety guarantees and practical deployability.