import lrat certificates

This work addresses the challenge of efficiently and reliably importing large-scale logical certificates produced by SAT solvers into Lean 4 to formally verify the unsatisfiability of combinatorial problems. We present the first reflection-based LRAT checker implemented in Lean 4, which directly translates DIMACS formulas and LRAT certificates into Lean theorems without explicitly constructing massive proof terms. Our approach fully supports the internal composition of cube-and-conquer strategies and automatically synthesizes coverage completeness proofs. It significantly outperforms Mathlib’s existing proof-import mechanisms and achieves performance on par with the external checker cake_lpr when verifying large-scale instances such as the Schur number S(4)=44 and the Ramsey number R(4,4)=18, thereby enabling scalable and highly trustworthy automated verification of combinatorial theorems.

This work investigates the effectiveness of large language models (LLMs) in assisting interactive theorem proving, particularly within real-world, industrial-scale formal verification tasks. Method: We conduct a systematic evaluation on two authentic verification projects—hs-to-coq and Verdi—using the Rocq proof assistant, employing both quantitative metrics (success rate, proof length, error rate) and qualitative analysis (tactic reasonableness, technical reusability). Contribution/Results: LLMs demonstrate strong capability in generating concise, high-quality formal proofs aligned with classical proof styles, scaling effectively from small to large proofs. Performance critically depends on external dependency information and contextual modeling quality, exhibiting marked heterogeneity across projects. While rare anomalous errors occur, they are substantially mitigated via context enhancement. To our knowledge, this is the first empirical study to characterize LLM capabilities and key limiting factors—such as dependency awareness and context fidelity—in realistic, production-grade formal verification settings, thereby providing foundational evidence and practical guidance for LLM-augmented trustworthy software verification.

Formal verification of software suffers from high manual proof-writing costs, while direct integration of large language models (LLMs) incurs prohibitive computational overhead and lacks formal trustworthiness. Method: This paper proposes a novel LLM strategy extraction and formal migration framework that automatically distills implicit proof strategies from LLM-generated natural-language reasoning traces; these are then formalized via abstraction and agent-assisted error correction to produce reusable Coq lemmas. Contribution/Results: To our knowledge, this is the first end-to-end strategy distillation pipeline transferring LLM reasoning capabilities to symbolic provers—specifically Rocq and CoqHammer. Evaluated on the Rocq benchmark, our method improves CoqHammer’s theorem-proving success rate by 13.41%, substantially enhancing automation in formal verification. The approach establishes a new paradigm for synergistic verification, bridging LLM-based reasoning with rigorous, machine-checkable proofs.

Automated verification in separation logic (SL) has long relied on ad hoc heuristics, lacking a systematic metatheory and suffering from poor scalability. Method: This paper establishes the first general SL metatheory grounded in category theory and algebraic structures—specifically functors, homomorphisms, and modules over rings—systematically integrating abstract algebra into SL automation. The framework supports compositional model instantiation and modular predicate synthesis for any data structure admitting an algebraic characterization. All results are formally verified in Isabelle/HOL, and an automatic algebraic instantiation algorithm is developed. Contribution/Results: Experiments demonstrate fully automated algebraic modeling of complex imperative program semantics—including lists, trees, and graphs—and yield inference engines whose performance matches state-of-the-art hand-crafted systems. This approach decisively overcomes the scalability limitations inherent in heuristic-based methods.

In program verification, SMT solvers frequently fail due to missing critical assertions, necessitating manual assertion hints and substantially increasing verification overhead. This paper proposes an LLM-based automated assertion completion method: (1) it precisely localizes assertion gaps using SMT error messages and introduces placeholder tokens; (2) it defines a code-level proof similarity metric to enable context-aware example retrieval; and (3) it integrates domain-specific prompt engineering with SMT feedback-driven iterative refinement. Evaluated on the DafnyGym benchmark, our approach generates over 56.6% of required assertions in a single attempt, significantly improving automated verification success rates. Our key contributions are the first integration of error-driven localization, proof-aware retrieval, and verification-feedback closed-loop optimization into an LLM-assisted assertion generation framework.

This work addresses the challenge of statically verifying semantic consistency between natural language business requirements and their code implementations. It proposes a two-stage, runtime-free approach: first leveraging large language models to extract structured rules from requirements while identifying ambiguous or contradictory statements, and then performing static code auditing based on this intermediate representation. By integrating natural language processing with static analysis, the method mitigates hallucination and context loss in large models through rule structuring, enabling requirement-aware early validation. Evaluated on an automotive cybersecurity case study, the approach successfully detects semantic deviations, offers a novel solution to the test oracle problem, and significantly enhances left-shifted verification capabilities.

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.

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 critical challenge of reliably integrating automated reasoning tools—such as theorem provers, SAT/SMT solvers, and termination analyzers—with proof assistants to build highly trustworthy systems. It presents a systematic survey and comparative analysis of two principal technical approaches: certification and formal verification. The study examines core methodologies including logical encoding, result replay and checking, and integration mechanisms within proof assistants. By elucidating the respective strengths and limitations of these methods and illustrating them through multiple successful case studies, the paper offers clear methodological guidance for constructing high-assurance automated reasoning systems, thereby substantially enhancing the verifiability and trustworthiness of their outputs.