Pseudo-Formalization: Bridging Natural & Formal Proofs

• Pseudo-Formalization is a methodological framework that bridges natural language proofs and fully formal proofs by enforcing modularity and explicit local premises.
• It organizes proofs into self-contained modules using dependency DAGs and scope-inheritance forests, which enhances context-local reasoning and verification efficiency.
• Empirical evaluations show significant improvements in precision, recall, and semantic correctness for automated verification and auto-formalization pipelines.

Pseudo-Formalization (PF) is a methodological framework designed to bridge the gap between informal, natural-language mathematical proofs and fully formal proofs in systems such as Lean. PF serves two primary roles in current research: as a modularized natural-language proof format optimized for automatic verification (Barkallah et al., 19 May 2026), and as an intermediate, syntactic scaffold for auto-formalization into a target proof assistant language (Jana et al., 17 Oct 2025). The PF paradigm aims to impose modular structure and local explicitness on otherwise ambiguous and context-heavy natural language proofs, yielding both higher verifiability and streamlined translation to formal code.

1. Foundations and Motivation

Fully formal proofs, as implemented in systems like Lean, are unambiguous and modular. Every inference is explicit, and mechanical checkers verify each step independently. However, most proofs written by humans or generated by AI lack these properties. Ambiguity in language—multiple possible interpretations of statements, and implicit global dependencies—renders direct verification by LLMs or proof assistants brittle or infeasible.

Pseudo-Formalization (PF) is designed as an intermediary between natural and formal proofs. It preserves the expressive power and flexibility of natural language—allowing references to standard results, human-oriented notations, and intuition—while enforcing explicit modularity. Each assertion is encapsulated in a self-contained block, with local premises and a well-defined conclusion. The aim is to recover much of the robustness, granularity, and decomposability afforded by formal proofs, while substantially reducing the translation and verification bottleneck (Barkallah et al., 19 May 2026).

2. Formal Structure of Pseudo-Formal Proofs

A PF proof consists of a finite collection of modules, each represented as a triple $(P, c, \pi)$:

• $P$: Set of premises (definitions, assumptions, or previously proven results).
• $c$: The conclusion to establish.
• $\pi$: The natural-language proof of $c$ from $P$.

The modules are organized into two combinatorial structures:

• A dependency DAG $G$, encoding which modules invoke each other's conclusions.
• A scope-inheritance forest $T$, tracking inheritance of premises or local assumptions.

Formally, a PF proof is: $\{\ v_{i}=(P_{i}, c_{i}, \pi_{i})\ \}_{i=1}^{n},$ with

• $G\subseteq V\times V$: dependency graph for module invocation,
• $P$0: forest encoding scope inheritance, such that each $P$1 may invoke $P$2 only if $P$3, and available premises at $P$4 are $P$5 (Barkallah et al., 19 May 2026).

This modular structure allows rigorous, context-local reasoning, exposing implicit global dependencies and ambiguity for verification.

3. Block Verification (BV): Modular Proof Checking

The Block Verification (BV) algorithm operationalizes automated proof checking in the PF framework:

1. Translation: An LLM translates a natural-language proof $P$6 into PF modules $P$7, optionally followed by a self-repair loop to patch missing or unfaithful modules.
2. Block Verification: Each module $P$8 is checked by a verifier LLM, which receives the complete set of premises (from scope forest), the conclusion, the proof, and any child information. The verifier returns ACCEPT or ERROR with an explanation.
3. Calibration: Aggregates the per-module error reports. A calibration LLM, conditioned on user-specified strictness (e.g., "catch all errors" vs. "require high confidence"), produces a final decision or annotation.
4. Parallel Scaling: Steps 1–3 are repeated $P$9 times (independent LLM runs). The overall output is accepted only if all runs return ACCEPT—pessimistic aggregation.

This design enables stepwise, parallelizable checking with strict context locality. For well-structured ("good") PF proofs—those with bounded scope depth and module size—blockwise verification can be implemented using a Transformer verifier with constant-sized input per module: $c$0 calls of size $c$1, where $c$2 is scope depth, $c$3 is maximum statement length (Barkallah et al., 19 May 2026).

4. Practical Instantiations and Example Conversions

PF has been applied across multiple settings:

• Competition-level mathematics: For instance, in IMO 2024 Problem 6, the official solution is decomposed into PF modules, such as:
  • Module for “If $c$4, $c$5, then $c$6” (P2), with premises the definition of $c$7.
  • Module asserting “All nonzero elements of $c$8 have the same sign,” dependent on P2 and scope assumptions.
  • The BV algorithm correctly identifies semantic gaps missed by global evaluation, such as the improper generalization in the second module (Barkallah et al., 19 May 2026).
• Research-level mathematics: Given, e.g., “Let $c$9 be a finite group acting freely on a finite set $\pi$0. Then $\pi$1,” PF decomposes the proof into a single module with premises (group action assumptions) and a conclusion asserting the divisibility, with the block-verifier checking standard group theoretic arguments (Barkallah et al., 19 May 2026).

In the context of auto-formalization, PF is also realized as a code-level skeleton in Lean 4, reflecting the structure of formal proofs but allowing for incomplete or invalid segments destined for iterative repair (Jana et al., 17 Oct 2025). PF serves as a transitional representation—closer to formal code but built from natural language—to support semantic embedding and guided translation workflows.

5. PF in Formalization Pipelines: Joint Embedding and Iterative Repair

PF plays a critical role in advanced auto-formalization systems such as ProofBridge. Here, PF is generated via the following sequence (Jana et al., 17 Oct 2025):

• A natural language proof is encoded into an embedding.
• Cross-modal retrieval fetches semantically close formal examples from Lean codebases.
• The LLM, conditioned on retrieved examples, generates a PF-level code skeleton—Lean-style code with tactics and theorem blocks, but possibly containing type errors or semantic mismatches.
• The PF output is iteratively repaired:
  • Type checker errors prompt further editing by the LLM.
  • Semantic equivalence to the target theorem is tested by attempting to prove bi-directional equivalence with bounded tactics.

This pipeline, evaluated on the miniF2F-Test-PF benchmark, enables high-fidelity translation of human-preferred proof formats to machine-verifiable formal proofs by leveraging PF as an intermediate (Jana et al., 17 Oct 2025).

6. Empirical Evaluation and Benchmarking

The performance of PF-based verification and formalization is quantified via multiple benchmark suites and metrics.

• Verification (PF+BV)
  • Hard2Verify (Olympiad/Putnam level): 200 AI-generated proofs on 80 problems, with explicit step correctness labels.
  • ArxivMathGradingBench (research level): 35 papers, 40 author-corrected errors.
  • Metrics:
  • Step-level precision/recall
  • Proof-level precision/recall
  • Coverage (fraction in which all errors are found)
  • Average false errors per proof
  • PF+BV Pareto-dominates LLM-as-judge baselines; at 90% recall, precision improves from ~75% (baseline) to ~85%. On ArxivMathGradingBench, error detection improves from ~45% to ~60%, with >20% reduction in false alarms, and coverage increases from ~50% to ~70% (Barkallah et al., 19 May 2026).
• Formalization (ProofBridge PF workflow)
  • miniF2F-Test-PF: Olympiad problems paired with Lean ground-truth.
  • Metrics:
  • Type Correctness (TC): Fraction of problems yielding at least one type-correct, sorry-free formalization in top-k LLM samples.
  • Semantic Correctness (SC): Fraction of type-correct outputs where the generated theorem is provably equivalent to ground-truth via Lean tactics.
  • Retrieval-augmented fine-tuning and PF iterative repair yield substantial gains: SC increases from 31.56% (Kimina-Prover baseline) to 62.70%, and TC rises from 93.85% to 95.49% (pass@32) (Jana et al., 17 Oct 2025).

Framework	Setting	Key Metric(s)	PF Result
PF+BV (Barkallah et al., 19 May 2026)	Proof Verification	Step Prec/Recall; Coverage	+10–20% over baseline
ProofBridge (Jana et al., 17 Oct 2025)	Auto-Formalization	Semantic/Type Correctness	+31.14pp SC, +1.64pp TC

These results highlight PF's impact on both the accuracy and reliability of automated proof assessment and formalization.

7. Formal Properties and Theoretical Guarantees

Theoretical analysis establishes that “good” PF proofs—where every module, premise, conclusion, and proof are bounded in length, and the scope tree has limited depth—are verifiable with constant-sized context per block. There exists a Transformer such that each module in the proof can be checked independently with context size $\pi$2, and the total number of calls is linear in the number of modules. This ensures that block-wise verification remains scalable, irrespective of overall proof length (Barkallah et al., 19 May 2026).

A plausible implication is that by structurally enforcing such properties in LLM-generated or human proofs, PF can be robust against scaling limitations of current transformer architectures, even as problem complexity grows.

8. Conclusion and Prospects

Pseudo-Formalization, encompassing both modularized natural-language formats for verification and code-skeleton outputs for formalization, marks a concrete advance in automating the assessment and translation of mathematical proofs. Its integration with blockwise verification algorithms like BV and joint semantic embedding architectures enables significant improvements in both error detection and semantic faithfulness. PF’s modular design and context-local reasoning facilitate effective LLM-based proof automation at scale, while providing formal guarantees on verifiability and efficiency (Barkallah et al., 19 May 2026, Jana et al., 17 Oct 2025). Further research into refining PF granularity, automated repair, and semantic alignment is expected to broaden its impact on both AI mathematics and computer-assisted proof verification.