Interactive Theorem Provers (ITPs)

• Interactive Theorem Provers (ITPs) are systems that support human-guided, formal proof development using detailed sequent-based methods.
• They enhance interoperability by over-specifying inference steps, reducing translation complexity between ATPs and ITPs.
• They enable modular proof construction by mapping sequent calculus steps to proof assistant primitives for efficient, verifiable proof exchange.

SC-TPTP is an extension of the TPTP derivation text format, developed to address the challenges in transferring proofs between automated theorem provers (ATPs) and interactive theorem provers (ITPs) (Cailler et al., 15 Jul 2025). By adopting a sequent-based calculus as its core formalism and over-specifying inference steps, SC-TPTP establishes a highly detailed, rule-oriented interface for describing first-order proofs. This design supports interoperability, fine-grained verification, and a faithful correspondence to mathematical traditions in proof theory.

1. Sequent-Based Formalism and Proof Representation

SC-TPTP centers on explicit sequent calculus formalism. Each proof is described as an ordered list of annotated formulas, where each annotation corresponds to a specific deduction—either as an axiom, conjecture, assumption, or an inference step based on sequent calculus rules. The core reasoning objects in SC-TPTP are sequents of the form:

$a_1,\ldots,a_n \vdash b_1,\ldots,b_m$

meaning that the set of formulas $\{a_1, \ldots, a_n\}$ collectively entails $\{b_1, \ldots, b_m\}$. Each inference—including structural rules, introduction/elimination rules for logical connectives, not-introduction, and equality handling—is given in a fine-grained, parameterized form.

For example, the hypothesis rule is encoded with explicit indices:

$\frac{}{\Gamma, A \vdash A, \Delta}$

This explicitness allows for local checking of each proof step and greatly facilitates automation of proof checking.

2. Interoperability between ATPs and ITPs

SC-TPTP's main motivation is to serve as a lingua franca for proof transfer between proof systems. The over-specification of inference rules reduces ambiguity and the combinatorial explosion of translation modules: with SC-TPTP, the number of required translation paths between $n$ tools is reduced from $n(n-1)$ to $2n$, as each tool only needs to import from and export to SC-TPTP.

Its fine granularity—level-1 steps for basic logical inferences and level-2 for complex tactics (e.g., congruence closure)—enables both detailed checking and structured expansion. SC-TPTP proofs can be imported into and exported from tools such as the Lisa proof assistant and Coq, supporting seamless bidirectional communication between ATPs (e.g., Goéland) and ITPs.

3. Integration and Proof Kernel Mapping

ITP integration is a primary design goal for SC-TPTP, realized through direct mappings from sequent-calculus steps to proof assistant primitives. In Lisa, for example, a query can be generated in SC-TPTP format, passed to Goéland for ATP-style proof search, and the returned detailed proof is then imported back into Lisa's kernel.

SC-TPTP's structure is compatible with Coq, allowing rule-to-lemma translation. For instance, the right-and introduction in sequent calculus is represented in Coq as:

Lemma rightAnd : forall P Q : Prop, P -> Q -> (P /\ Q). Proof. intros; split; auto. Qed.

This one-to-one semantic and structural correspondence makes SC-TPTP well-suited as an interchange format for proof certificates and program verification artifacts.

4. Faithfulness to Sequent Calculus and Mathematical Tradition

SC-TPTP’s adoption of sequent calculus as its foundational formalism is grounded in proof theory tradition and mathematical practice. Sequents are treated as sets rather than sequences, allowing contraction and commutativity for efficiency without affecting correctness. This enables deduplication and reordering, which are critical for scalable proof checking and manipulation.

Additionally, SC-TPTP accommodates proof strategies found in tableau-based ATPs via its explicit, granular rule encoding. Explicit parameterization—such as indices for subformulas, explicit substitutions for quantifier instantiation, and named variables—provides local verifiability and avoids hidden ambiguities, especially concerning variable capture or alpha-equivalence in quantified reasoning.

5. Support for Modular Proof Construction and Tooling

A key feature of SC-TPTP is the explicit separation between basic level-1 inferences and advanced level-2 tactics. This modularity is critical to ITP workflows, enabling users or automated systems to unfold, inspect, or replace high-level strategies with their underlying logical steps.

SC-TPTP's implementation ecosystem—such as the Scala-based SC-TPTP library—provides utilities for parsing, printing, proof checking, and transformation. For example, it is possible to replace a level-2 congruence step with a series of explicit substitution steps suitable for low-level verification. This modularity supports both transparent proof checking and the refactoring of large, complex proofs into manageable components.

6. Proof Strategies, Efficiency, and Verification

Adopting a sequent-based, over-specified formalism yields several concrete benefits:

• ATP-generated proofs are no longer “black-box” but decomposable into individually checkable steps.
• Explicit sequents and parameters support both forward (synthetic) and backward (analytic) proof development styles.
• Verifiers can check each proof step locally, supporting efficient, distributed, or incremental verification.
• Proofs can be exported, for instance, into Coq lemmas with automated rule mappings, ensuring compatibility with existing verification environments.

This structured modularity is particularly beneficial for large formal developments and enables a basis for both human-inspectable and fully automated verification pipelines.

7. Summary Table: Core Features of SC-TPTP

Feature	Description	Significance
Sequent-based rules	Full, parameterized specification of sequent calculus steps	Fine-grained, checkable proofs
Interoperability	Single format usable for both ATPs and ITPs, reduces translation complexity	Seamless proof exchange
Level-1/Level-2 step separation	Basic rules vs. advanced tactics (expandable to low-level inferences)	Modular, inspectable proofs
Explicit parameterization	Indices, substitutions, and variable names encoded in each inference step	Local verification, avoids pitfalls
Library/tool support (Scala, Coq, Lisa)	Parsing, printing, checking, transformation, and export to major environments	Practical adoption

In conclusion, SC-TPTP provides a detailed, sequent-calculus–based framework for specifying, exchanging, and verifying proofs between first-order ATPs and ITPs (Cailler et al., 15 Jul 2025). Its fine-grained inference specification, modular step separation, compatibility with traditional and modern proof systems, and tool support make it a central development for interoperability in formal logic and verification research.