term rewriting

This work addresses the automation challenge of interpolation construction in mechanized knowledge processing. Methodologically, it proposes an efficient interpolation generation framework based on first-order logic automated theorem proving: (i) a two-stage Craig interpolation construction integrating clause-tableaux and resolution inference, lifting propositional interpolation to quantified formulas; (ii) equality encoding to enhance theoretical expressiveness while ensuring applicability under restricted preprocessing; and (iii) a strengthened Craig interpolation variant incorporating second-order quantifier elimination (e.g., via DLS and SCAN algorithms) to support uniform interpolation. The primary contributions are: (i) the first systematic integration of automated reasoning techniques with interpolation synthesis, significantly improving scalability and practicality; and (ii) implementation within mainstream theorem provers, with empirical validation in program analysis and knowledge reasoning tasks demonstrating high-quality interpolants at low computational cost.

This work addresses the automatic translation of informal natural-language mathematical proofs into formal Lean 4 proofs—a task hindered by poor alignment between informal reasoning and structured verification languages, as well as weak controllability. We propose the novel “Chain of States” (CoS) intermediate representation, the first to explicitly decouple proof-structure modeling from tactic generation. CoS enables staged state extraction and structured tactic synthesis, and we further develop an interactive formalization framework alongside a domain-specific training dataset. Evaluated on multiple mathematical benchmarks, our approach significantly outperforms prior methods, achieving substantial gains in proof success rate. Results demonstrate that CoS effectively improves formalization accuracy and verifiability under limited computational budgets, validating its design principles and practical efficacy.

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.

This work addresses the challenge of fully automated theorem formalization, which requires simultaneous optimization of formal validity, logical fidelity, mathematical consistency, and syntactic quality—dimensions often addressed in isolation by existing approaches that also typically rely on reference standards. To overcome these limitations, we propose a reference-free, monotonically improving iterative optimization framework that leverages complementary feedback from a theorem prover and a panel of multi-role large language models (LLMs). Our approach introduces a novel response mapping mechanism to guide each LLM role toward targeted refinements and incorporates an acceptance strategy with convergence criteria that guarantee monotonic performance improvement. Experimental results demonstrate that our method achieves 93.44% formal validity and 78.22% overall score on miniF2F, and 44.09% formal validity with 29.79% overall score on ProofNet, establishing new state-of-the-art performance without reference-guided supervision.

This work addresses the challenges of integrating external domain-specific languages (DSLs) into interactive proof assistants—namely, the tedious, type-unsafe, and error-prone nature of expression translation. We propose DSLean, a framework built on Lean 4’s metaprogramming system that enables type-safe, bidirectional translation between external DSLs and their Lean equivalents through declarative syntax definitions. DSLean introduces a lightweight, syntax-directed bidirectional transformation mechanism coupled with type-driven semantic alignment, substantially reducing the integration overhead for external automated reasoning tools. We demonstrate the framework’s generality and practicality by successfully connecting solvers for interval arithmetic, ordinary differential equations, and ideal membership in polynomial rings, showcasing its effectiveness across diverse domains.

This work addresses the semantic gap and consistency challenges inherent in automatically translating informal mathematical texts into verifiable formal proofs. It proposes a two-stage approach: first, an intermediate representation called Relaxed Natural Formal Language (Relaxed NFL) is introduced to preserve the original reasoning structure while tolerating partially underspecified expressions; second, a combination of rule-driven mechanisms and large language model–guided heuristics refines this representation into a semantically precise Core Natural Formal Language (Core NFL), yielding verifiable proof obligations. The method enables end-to-end translation from natural mathematical discourse to formal proofs, maintaining linguistic naturalness while guaranteeing verifiability, and supports integration with domain-specific tactic languages and solvers.

This work unifies the modeling of inference rules and proof structures of formal systems within a categorical framework. It introduces a met-variable context representation based on Cartesian PROPs, encodes assumptions and conclusions using spans, and constructs a symmetric monoidal category of proofs with met-variable substitution as the sole primitive operation. This approach is the first to uniformly embed both inference rules and proof structures into the semantics of symmetric monoidal categories, thereby supporting compositional and reusable handling of hypotheses. The authors implement an open-source verification algorithm and surface syntax, successfully encoding formulas, axioms, and representative derivations of first-order logic, and release a functional proof checker.

Natural language API documentation is notoriously difficult to manually translate into consistent and reliable formal specifications. To address this challenge, this work proposes Doc2Spec, a novel framework that leverages multi-agent collaboration and large language models (LLMs) to automatically infer specification grammars directly from natural language descriptions. For the first time, such inferred grammars guide the generation of formal specifications without requiring any manually defined grammar, effectively constraining the specification space while incorporating domain knowledge. Evaluated across seven benchmarks spanning three programming languages, Doc2Spec significantly outperforms baseline approaches that lack grammar guidance and achieves performance on par with existing methods that rely on hand-crafted grammars.

We describe a new method of finding interpolants for classical logic using certain refutation system as a starting point. Refutation can be thought of as an alternative approach to the analysis of formal systems: instead of focusing on which formulas provably belong to a given logic, it shows which formulas are to be rejected. Thus, it provides a mirror proof system. As it turns out, the benefits of such an approach go well beyond the area of refutation calculi themselves. We provide one such example in the shape of an interpolant-searching method. To be sure, a number of such methods are already in use. The novelty of our proposal lies in the fact that it can be considered as based on a non-binary version of resolution.

Formal verification faces high barriers to adoption due to its reliance on expert knowledge and extensive manual annotation. To address this, we propose a “decompose-recombine” verification paradigm: complex program logic is modularly decomposed into independently verifiable subcomponents; AI-driven transient code refactoring automatically solves each subproblem and assembles the corresponding correctness proofs; and natural language interaction guides the verification process. Our approach integrates formal verification, modular code restructuring, AI-based reasoning, and natural language understanding to achieve automated, low-code verification. Experimental evaluation demonstrates an 86% verification success rate on standard benchmarks—18 percentage points higher than baseline methods. In complex scenarios, success rises significantly from 30% to 69%; when integrated with mainstream proof frameworks, performance reaches 87%.