AxiomProver: Automated Proof System

• AxiomProver is an automated theorem proving system that turns mathematical statements into machine-checkable proofs by integrating symbolic logic algorithms with formal libraries.
• It employs advanced methodologies including superposition calculus, abductive reasoning, and LLM-driven lemma generation to construct detailed formal proofs.
• The system features a specification–verification pipeline that parses, translates, and outputs formal definitions and proof scripts for domains such as algebra, geometry, and number theory.

AxiomProver refers to a class of automated theorem proving systems that transform declarative mathematical statements into formally verified machine-checkable proofs. These systems combine sophisticated symbolic logic algorithms with extensive domain libraries (e.g., algebraic, geometric, or analytic structures) and leverage both traditional superposition calculi and, in modern instances, integration with environments like Lean/Mathlib. Noteworthy instantiations exist across domains, including equational abduction, Tarskian geometry, and formalizations in number theory and algebra.

1. System Architectures and Input–Output Modalities

AxiomProver systems are driven by a specification–verification pipeline:

• Inputs typically consist of structured or semi-structured mathematical statements (e.g., LaTeX/TeX files with environments for definitions, lemmas, conjectures), augmented by configuration or instruction files specifying proof tasks and environments (such as Lean version constraints).
• Outputs are formalizations of the problem in the chosen logic (e.g., Lean files declaring definitions and conjectures) and detailed proof scripts verifiable by proof checkers/kernels (e.g., Lean’s elaborator) (Chen et al., 3 Feb 2026). In first-order logic contexts, output may be the enumeration of ground prime implicates over specified constants (Echenim et al., 2014), or in geometry, certificate-style proofs with proof logs and machine-verifiable Skolemizations (Beeson et al., 2016).

The architectures coordinate input parsing, semantic translation to internal representations (terms, types, clauses, constraints), and the search for derivations or proofs, often tightly integrating with formal libraries (such as Mathlib for Lean).

2. Key Algorithms and Calculi

2.1 Superposition and Abductive Reasoning

Equational abduction is addressed via the A-Superposition calculus, which modifies classical superposition with the addition of A-constraints tracking hypotheses/interpretations over a finite set of abducible constants $A$. Core inference rules include A-Superposition, A-Reflection, A-Factorization, Assertion, and Substitutivity, each operating on A-clauses (pairs of clause and A-set) and tailored unification mechanisms (A-unification collects clashes in $A$ as residual constraints) (Echenim et al., 2014).

2.2 Pipeline Strategies for Formalization

For formal mathematical proofs, such as the proof of Fel’s Conjecture, systems implement the following pipeline (Chen et al., 3 Feb 2026):

• Parse input source, extract environments (Definition, Lemma, Theorem),
• Map source terminology to formal library objects (via term-and-type synthesis),
• Emit formal definition files (e.g., problem.lean) with mathematical structures, functions, and conjectures,
• Build proofs by constructing chains of supporting lemmas and invoking a tactical kernel via sequences such as simp, rw, coeff_exp, and ring.

In the Tarskian geometry domain, input files are auto-generated, sanity-checked, and encode both axioms and theorems in a resolution-friendly (often Skolemized) form. Proof search uses clause weighting, hot-lists, and demodulation settings to optimize the inference process (Beeson et al., 2016).

3. Proof Search, Heuristics, and Automation Techniques

AxiomProver systems employ a blend of search and heuristic methods:

• LLM-driven generation (in modern incarnations): Suggest possible lemmas and tactics based on natural language phrasing and map these to formal library constructs (Chen et al., 3 Feb 2026).
• Backtracking and type-directed search: Iteratively attempt proof steps; backtrack on failure; use type information to guide rewrite (rw) or simplification (simp) applications.
• Proof reflection and tactic automation: For power series or polynomial goals, heavy use of algebraic reflection (e.g., ring tactic in Lean) automates coefficient-level proofs.
• Subformula and hint strategies (classic systems): In first-order and geometric settings, hint lists are constructed from subformulae of goals, drastically improving the ability to solve complex theorems “mechanically” without recourse to book-guided steps (Beeson et al., 2016).

4. Implementation Details and Integration with Formal Libraries

4.1 Data Structures and Indexing

• Clauses: Stored as (cliteral list, A-set) pairs.
• A-sets: Managed via union-find structures for equivalence/disequivalence constraints, possibly augmented by explicit predicate-negation storage (Echenim et al., 2014).
• Proof state management: In Lean/Mathlib, generated .lean files track definitions, conjectures, and sequence of tactics.

4.2 Library Usage and Typeclass Resolution

Systems are deeply reliant on the existing formal library; for Lean/Mathlib integrations, core modules used include data.nat.factorial, data.polynomial, data.power_series, and others for finite sums, commutativity, and power series expansions (Chen et al., 3 Feb 2026). Typeclass resolution infers algebraic properties and ensures type correctness in constructions involving division or exponentials.

Automation hooks are exploited by recurrent use of algebraic tactics (by ring, by simp), especially for combinatorial coefficients and symbolic manipulations.

4.3 External Theory and SMT Solver Calls

For abductive first-order settings, external SMT and theory solvers can be called on accumulated A-constraints to check satisfiability or entailment, extending capabilities beyond pure equational reasoning (Echenim et al., 2014).

5. Illustrative Use Cases and Empirical Performance

5.1 Modern Algebraic Formalization

AxiomProver successfully formalized and proved Fel’s Conjecture on syzygies of numerical semigroups, translating a natural-language TeX source into Lean 4.26.0 files that declared all relevant algebraic objects, mapped universal polynomials and power series manipulations fully into Mathlib, and mechanized the final identity with detailed proof chains. The system processed definitions, detected relevant lemma patterns (e.g., exponential generating function manipulations), and automatically discharged most coefficient-extraction arguments. However, no timing or comparative statistics were reported, and the authors note success was enabled by near-complete library coverage of needed mathematics (Chen et al., 3 Feb 2026).

5.2 Equational Abduction

The A-Superposition calculus was instantiated on problems such as deriving $a = b$ from $f(a) = f(b)$ (for $A = \{a, b\}$), and on array commutativity axioms in the presence of abducible indices and cells. The method is proven deductively complete and terminating under standard conditions, with practical strategies for clause storage, indexing, redundancy elimination, and hypothesis accumulation (Echenim et al., 2014).

5.3 Geometric Reasoning

A pipeline integrating OTTER/Prover9, systematic input file generation, and the subformula strategy enabled the full mechanical proof of 212 Tarskian geometry theorems, including several of Ph.D.-level complexity (proof length > 100 steps). Mechanical proof rates exceed 75%, with the remainder managed by book-guided hint injection. Subformula hints—adding all subclauses and their negations of the goal to the hint list—were critical in extending reach beyond short proofs (Beeson et al., 2016).

6. Scope, Limitations, and Research Context

Reported systems exhibit the following limitations:

• Performance metrics (timings, memory, breadth) are sparse or not reported. For Fel’s Conjecture, only a single problem instance is run (Chen et al., 3 Feb 2026).
• Subject applicability is bounded by the existing formal library coverage and inference procedure scope.
• Current modern instantiations succeed on “within reach” targets—cases not requiring novel library development.
• Underlying algorithmic details—especially for neural or LLM-driven variants—are omitted or only inferred.
• In first-order abduction and geometry, completeness is theoretically ensured, but empirical success on “hard” cases may depend on strategic hinting or controlled clause explosion (Echenim et al., 2014, Beeson et al., 2016).

A plausible implication is that further progress in general AxiomProver methodologies will necessitate advances in both theory (e.g., new calculi for richer domains) and in scalable, library-aware search heuristics for the handling of large theories and challenging unsolved conjectures.