Motivated by the transfer of proofs between proof systems, and in particular from first order automated theorem provers (ATPs) to interactive theorem provers (ITPs), we specify an extension of the TPTP derivation [1] text format to describe proofs in first-order logic: SC-TPTP. To avoid multiplication of standards, our proposed format over-specifies the TPTP derivation format by focusing on sequent formalisms. By doing so, it provides a high level of detail, is faithful to mathematical tradition, and cover multiple existing tools and in particular tableaux-based strategies. We make use of this format to allow the Lisa proof assistant [2] to query the Goéland automated theorem prover [3], and implement a library of tools able to parse, print and check SC-TPTP proofs, export them into Coq files, and rebuild low-level proof steps from advanced ones.
Transfer of proofs between diferent proof systems to this day largely remains a challenge.
While the relative consistency strength of the foundations of most tools is well known, practical
translations presents a variety of technical dificulties. Indeed, not only the syntax of diferent
systems can be very hard (when not impossible) to simulate (for example, -abstractions used
in type theory-based systems are dificult to represent and reason about in first-order systems,
or an classical ATP and an intuitionistic ITP), but even proof systems with similar logical
foundations can diverge significantly in terms of the kind and granularity of accepted proof
steps. In practice, an ATP might use advanced proof steps such as Skolemization, superposition,
hyperresolution, or congruence closure, which can be dificult (in terms of implementation and
space-time complexity) to simulate with lower-level proof steps typically accepted by proof
assistants. Finally, diferent tools may use diferent formats to export and store statements and
proofs in the first place (e.g. TPTP [
Hence, even when the foundations and proof steps are similar, if systems want to import proofs directly from each other, each is required to implement − 1 diferent import and proof transform algorithms, for a total of ( − 1) implementations. With one common middle ground format, each system only needs to implement one import and one export algorithm from itself to the proof format, for a total of 2 implementations. On the other hand, as suggested above, unifying the syntax and proofs of arbitrarily many systems with unrelated foundations is overly ambitious and may not be practically feasible. A successful approach needs to convey the right level of abstraction, neither too specific nor too general.
This introduction may remind the reader of the famous xkcd comics “How Standards
Proliferate” (Figure 1). Since being counterproductive runs against our objective, we design a proof
format as a super specification of the TPTP derivation format, which is already supported by a
large collection of systems and tools. TPTP (Thousands of Problems for Theorem Provers) [
Our motivation for the present proposal is to specifically increase interoperability between tools that use first-order logic. A key goal is to allow proof systems (in particular ITPs) to query ATPs on problems, and obtain proofs in a single format in return. Hence, the present work defines a specification over the existing TPTP format for sequent-calculus style proofs in ifrst-order logic. We fix and specify a set of basic inference steps, as well as their parameters, semantics, and syntax, in the style of sequent calculus. We separate deduction steps in levels, from low-level, easy-to-verify standard steps of sequent calculus, to more complex and toolspecific steps, which ideally come with a procedure to transform them into low-level steps. We call the resulting standard SC-TPTP. By keeping as-is TPTP’s directives for everything else, including formulas, existing TPTP parsers and printers can be readily used. Our objectives are: • to allow proof systems (in particular ITPs) using first-order logic to query ATPs for ifrst-order logic (in particular tableaux-based ATPs) on problems, and obtain proofs in a single format in return; • to provide a single translation exports from multiple systems with sequent calculus-like foundations to another proof system or format (for example Coq); • to ofer transformation algorithms that simplify proofs with possibly complicated and higher level proof steps to proofs with only basic steps; • to allow answers of ATPs in competitions to be verified unambiguously (for problems in ifrst-order logic).
Our contributions in the present text are as follows: • The development of a standard format, SC-TPTP, for sequent-based calculus, with a focus on tableaux-based ATP. • The implementation of this format into the Lisa proof assistant (import), and the Goéland ATP (export). In particular, this allows Lisa users to call Goéland as a (proof-producing) tactic. • The development of a publicly available library, providing tools to parse and print SCTPTP proofs, check their validity in this format, transform proofs to eliminate high-level congruence closure steps, and export them into Coq.
This work is a proof of concept and a proposal to the community, that we hope can help connect various tools. We look forward to the community’s input and feedback on how to adapt the features and design choices to be suitable for as many tools as possible.
Related Work Beyond the TPTP format itself [
One of the original inspirations for designing a common format comes from the SAT
community, which encountered notable success with the DRAT format [
In the realm of SMT solving, diverse proof formats have emerged, including LFSC [
Closer to our approach, and extension of the TPTP syntax to the connection calculus [
Finally, our paper’s overarching theme resides in the realm of proof interoperability, echoing
the ethos of systems such as Dedukti and Lambdapi [
Organization In Section 2, we provide the necessary background on TPTP, tableaux rules,
as well as one-sided and two-sided sequent calculi. We then introduce the proof steps of
the SC-TPTP proof standard for (untyped) first order-logic in Section 3, together with their
parameters, syntax, and semantic. In Section 4, we present a library of utilities to handle and
verify proofs in SC-TPTP. In particular, we implement an export of SC-TPTP proofs to Coq,
and a proof-producing egraph [
2.1. TPTP & TSTP
TPTP [
Sibling to TPTP is the TSTP library, a collection of solutions (derivations, or proofs) produced by ATPs in response to TPTP problems. In derivations, formulas are annotated by an inference parameter, itself made of the name of the inference rule, its parameter, and its premises. However, inferences are not specified: every system can output its individual proof steps, which can be arbitrarily complex to reconstruct for a system with diferent or more basic deduction rules. As an extreme example, an ATP may output a proof step justified with “SMT solver said so”, from which it would be very dificult to recover a posteriori a syntactically strict proof, such as a sequent calculus or natural deduction proof or a well-typed proof term. Even when systems output reasonable, low-level steps, there can be many inessential diferences in the exact set of rules and their syntax.
Sequent Calculus is a proof system for (classical) first-order logic (with equality), where statements are represented by sequents. A sequent is a pair of sets of formulas, typically written 1, ..., ⊢ 1, ..., whose intended semantics is (1 ∧ ... ∧ ) =⇒ (1 ∨ ... ∨ ).
LK & LJ The original sequent calculus LK [
GS3 The Gentzen-Schütte calculus (GS3) [
We introduce the SC-TPTP format as an over-specification of the TPTP format [
<fof_annotated> ::= <formula_role> ::= <fof_formula> ::= <fof_sequent> ::=
| <fof_formula_tuple> ::= fof(<name>, <formula_role>, <fof_formula>, <annotations>). assumption | axiom | conjecture | plain <fof_logical_formula> | <fof_sequent> <fof_formula_tuple> –> <fof_formula_tuple> (<fof_sequent>) [] | [<fof_formula_tuple_list>] <fof_formula_tuple_list> ::=
<fof_logic_formula> |
<fof_logic_formula>, <fof_formula_tuple_list>
In the original presentation of Gentzen, sequents’ sides are formally lists of formulas, where
order and number of duplicates are significant. This semantics requires additional structural
rules for contraction and permutation of formulas. However, it is more convenient and eficient
(in terms of proof size and number of rules) to consider them as sets. This is the semantic
we chose for SC-TPTP. In particular, formulas in sequents can be duplicated, contracted, and
reordered at will. This does not make proof checking more complex.
1and in general of deductive reasoning, for example in the proof system of HOL Light [
cut Γ, ⊢ , Δ Γ, , ¬ ⊢ Δ
Γ ⊢ Δ Γ, ⊢ Δ
Γ ⊢ Δ Γ ⊢ , Δ Γ ⊢ , Δ Σ, ⊢ Π Γ, Σ ⊢ Δ, Π
Each step of the derivation is written as an annotated statement of the form fof(name,role,statement,annotation), in which: • name is an integer or an alphanumeric identifier starting with a lowercase letter. It is used to be referred to by other steps of the derivation. • role is either “axiom”, “conjecture” or “plain”. An “axiom” denotes an accepted formula, while a “conjecture” holds for the statement the derivation is supposed to prove, but does not play a logical role. A conjecture should always contain the same formula as the last derived formula in the proof. The TPTP syntax does not impose specific user semantics
Rule Γ, , ⊢ Δ Γ, ∧ ⊢ Δ Γ, ⊢ Δ Σ, ⊢ Π
Γ, Σ, ∨ ⊢ Δ, Π Γ ⊢ , Δ Σ, ⊢ Π
Γ, Σ, ⇒ ⊢ Δ, Π Γ, ¬ ⊢ Δ Σ, ⊢ Π
Γ, Σ, ⇒ ⊢ Δ, Π Γ, ⇒ , ⇒ ⊢ Δ Γ, ⇔ ⊢ Δ Γ ⊢ , Δ Γ, ¬ ⊢ Δ Γ, ⊢ Δ Γ, ∃. ⊢ Δ Γ, [ := ] ⊢ Δ Γ, ∀. ⊢ Δ
Parameters i:Int: Index of ∧ on the left i:Int: Index of ∨ on the left i:Int: Index of ⇒ on the left i:Int: Index of ⇒ on the left i:Int: Index of ⇔ on the left i:Int: Index of ¬ on the left i:Int: Index of ∃. on the left y:Var: Variable in place of in the premise i:Int: Index of ∀. on the left t:Term: Term in place of in the premise rightAnd rightOr rightImp rightIff rightNot rightEx rightAll 2 1 1 2 1 1 1 Γ ⊢ , Δ Σ ⊢ , Π Γ, Σ ⊢ ∧ , Δ, Π Γ ⊢ , , Δ Γ ⊢ ∨ , Δ Γ, ⊢ , Δ Γ ⊢ ⇒ , Δ Γ ⊢ ⇒ , Δ Σ ⊢ ⇒ , Π Γ, Σ ⊢ ⇔ , Δ, Π Γ, ⊢ Δ Γ ⊢ ¬, Δ Γ, [ := ] ⊢ Δ
Γ, ∃. ⊢ Δ Γ, [ := ] ⊢ Δ Γ, ∀. ⊢ Δ i:Int: Index of ∧ on the right i:Int: Index of ∨ on the right i:Int: Index of ⇒ on the right i:Int: Index of ⇔ on the right i:Int: Index of ¬ on the right i:Int: Index of ∃. on the right t:Term: Term in in place of in the premise i:Int: Index of ∀. on the right y:Var: Variable in place of in the premise
to the “plain” role, and thus we use it to denote inferred steps.
• statement can be either of a sequent or a formula. Their syntax can be found in https:
//tptp.org/TPTP/SyntaxBNF.html. For SC-TPTP, a sequent statement is made of two sets
of formulas, while a formula statement is understood as standing for the sequent with an
empty left-hand side and whose right-hand side contains exactly this formula.
• annotation are used to give additional information to the system. If the role of the
statement is “axiom” or “conjecture”, the annotation has no specific requirement in our
format. For “assumption” and “plain” statements, the annotation must be of the form
inference(stepName, [status(thm), p1, ..., p], [r1, ..., r]), in which:
– stepName is one of the entry listed in Table 1-Table 6.
– status(thm) indicates the status of the formula (e.g., a consequence of the premise,
equisatisfiable with regard to the previous step, a negated conjecture, etc.) following
the SZS ontologies [
Their number varies between 0 and 2, depending on the proof step, and are referenced in the 2nd column of Table 1-Table 6.
Example 3.1. The following example illustrates a valid SC-TPTP derivation.
Example 3.2. SC-TPTP proof of the drinker paradox [
We define three levels for deduction steps. Level 1 steps are exactly the 30 steps represented in Table 1 to Table 5. In this setup, “on the left/right” refers to the left and the right of the conclusion. Those rules are complete for first order logic with equality, and their correctness is simple to check. As they represents low-level proof steps they should also be straightforward to import into any proof system strong enough to accommodate first order logic. They encompass both the traditional two-sided sequent calculus rules, with antecedents and succedants, as well as the rules for one-sided sequent calculus typically used for tableaux theorem proving. As such, the system is not minimal.
Table 1 presents the first group of rules ( hyp, leftHyp, leftWeaken, rightWeaken, cut), also called structural rules. The next group of 8 rules introduced in Table 2 is composed by left introduction rules, all of them describing a specific way a symbol can be introduced. The subsequent group in Table 3 encompass right introduction rules, dual to the left rules. Then follow left not introduction rules in Table 4, which are essentially equivalent to the right introduction rules, but useful for tableaux-style proofs. Finally, rightRefl, leftSubst and rightSubst of Table 5 support equality reasoning.
In an SC-TPTP derivation, inferences with level 1 steps come with a set of parameters that makes verification straightforward and more eficient, without requiring inference. For most proof steps, the parameters are only indexes, pointing to the position of the formula targeted by the proof step. For example, consider a derivation with the rightAnd rule: fof(ax1, axiom, [] --> [a]) fof(ax2, axiom, [] --> [b]) fof(s1, plain, [] --> [a & b], inference(rightAnd, [status(thm), 0], [ax1, ax2])) The step s1 is inferred using the rule rightAnd. The index 0 in [0] indicates that the deduced conjunction is the first formula (on the right-hand side of the conclusion sequent), that is a & b. This then indicates that a is a formula on the right of the first premise ( ax1) and b a formula on the right of the second premise (ax2). In the general case, let Γ1 ⊢ Δ1, Γ2 ⊢ Δ2 and Γ3 ⊢ Δ3 be the sequents of ax1, ax2 and s1. To verify that the step is correctly applied, we simply have to check the following conditions:
Γ3 == Γ1 ∪ Γ2 {a} ∪ Δ3 == {a & b} ∪ Δ1 {b} ∪ Δ3 == {a & b} ∪ Δ2 Where == is equality on sets. Note that the Δ’s may contain additional occurrences of a, b and a & b, in which case the step is still valid. All left, right and leftNot propositional steps, as well as rightRefl and all structural steps but cut work the same way. Note that using hash sets, these tests can be done in time linear in the size of the sequents.
Ex and All steps take an additional argument, denoting which subterm or variable is being quantified. Consider: fof(s1,plain, [] --> [(f(X) = f(X))],
inference(rightRefl, [status(thm), 0], [])) fof(s2,plain, [] --> [?[Y]: (f(X) = Y)],
inference(rightEx, [status(thm), 0, $fot(f(X))], [s1])) fof(s3,plain, [] --> [![X]: (?[Y]: (f(X) = Y))],
inference(rightAll, [status(thm), 0, $fot(X)], [s1])) For s2, the parameter 0 indicates that the first formula in the right of the conclusion has been quantified, which is ?[Y]: (f(X) = Y). Again in a more general case with arbitrary contexts, let Γ1 ⊢ Δ1, Γ2 ⊢ Δ2 and Γ3 ⊢ Δ3 be the sequents of s1, s2 and s3. Now, to check the correctness of s2, we must verify:
Γ1 == Γ2
{(f(X) = Y)[Y := f(X)]} ∪ Δ2 == {?[Y]: (f(X) = Y)} ∪ Δ1
Where [ := ] denotes the (capture-avoiding) substitution of by in . Note that the
equality has to be performed modulo alpha-equivalence. This can be done naively in time
(2), but also eficiently either by using some hash function that is congruent with respect
to alpha-equivalence, such as in [
For step s3, the same checks need to be done, but additionally, it must be verified that the quantified variable is not free in the resulting sequent.
The Cut step is slightly diferent: because its main formula does not appear in the conclusion, the index indicates instead the position cut formula in the right-hand side of the first premise (this is arbitrary; we could have pointed instead to the cut formula in the left-hand side of the second premise).
Finally, the leftSubst and rightSubst rules are a bit more complex. Consider for example the following derivation: fof(a1, axiom, [P(f(a))] --> []) fof(s1,plain, [P(g(b)), (f(a) = g(b))] --> [],
inference(leftSubst, [status(thm), 1, $fof(P(Z)), $fot(Z)), [s1])) The parameter 1 points to the equality f(a) = g(b). The second and third parameters explain how the substitution is carried, so for general sequents Δ1 and Δ2 as above, the check is: {P(Z)[Z:=g(b)], f(a) = g(b)} ∪ Δ1 == {P(Z)[Z:=g(a)]} ∪ Δ2
Unlike in level 1, level 2 steps are not entirely fixed and are expected to expand over time. They contain more advanced proof steps, which may be more dificult to verify, but for which there should be an available and implemented algorithm eliminating them from a proof. This mechanism allows Level 1 proofs to be rebuildable from a Level 2 proof. We expect that proofs relying on level 2 proof steps will be common in practice: each tool will keep those they accept natively (or can import easily), and eliminate steps they do not support. At present time, we have implemented three level 2 steps, which were useful to our implementation: left and right simultaneous substitution of equal terms, and congruence closure. These and their parameters are shown in Table 6. Another example of a level 2 candidate (not implemented) is an NNF step, which allows deduce a sequent from a premise whose formulas are equivalent, modulo negation normal form.
Simultaneous substitutions are fairly simple. A simultaneous substitution of formulas can always be unfolded into application of leftSubst or rightSubst. Congruence closure is
NNF congruence rightSubstMulti leftSubstMulti 1 0 1 1
Rule Γ ⊢ Δ Γ′ ⊢ Δ′ Γ, () ⊢ (), Δ Γ ⊢ (1, ..., ), Δ Γ ⊢ (1, ..., ), Δ Γ, (1, ..., ) ⊢ Δ Γ, (1, ..., ) ⊢ Δ more technical. A congruence step for a sequent Γ ⊢ Δ is correct if one of the following cases hold, given all the formulas of the form = in Γ: 1. There are two formulas (1, ..., ) ∈ Γ and (1, ..., ) ∈ Δ such that for all , and are congruent (hyp case). 2. There are two formulas (1, ..., ) ∈ Γ and ! (1, ..., ) ∈ Γ such that for all , and are congruent (leftHyp case).
3. There is a formula = ∈ Δ such that and are congruent (rightRefl case).
This was immediately useful to us because Goéland uses Rigid E-Unification [
To support the SC-TPTP format, we started the development of a library of tools and utilities to parse, print, verify, and transform SC-TPTP proofs. We chose Scala to implement it because it is a high-level language adapted to the task, it is the language of Lisa and Princess (which we plan to support in the future), and there already exists a complete TPTP parser in Scala, thanks to Alexander Steen2. This library of tools is available at https://github.com/SC-TPTP/sc-tptp. 2https://github.com/leoprover/scala-tptp-parser
The library contains the syntactic definition of first-order logic, sequents, and deduction steps from Table 1 to Table 6. It also contains a parser (based on the aforementioned one) for SC-TPTP files, as well as a printer and a proof checker, which report incorrect steps. In addition, the library also contains a printer exporting SC-TPTP proofs to Coq proofs. Finally, it contains a tool to eliminate level 2 steps (in particular congruence).
The translation of SC-TPTP proofs to Coq proofs is relatively straightforward, as each sequent calculus step can be translated into a Coq lemma. Our translation relies on a one-to-one mapping between SC-TPTP rules and Coq lemmas, as exemplified below: Example 4.1. Translation of rightAnd in Coq.
Lemma rightAnd : forall P Q : Prop, ( P) → (Q) → (P ∧ Q).
Proof. intros P Q H. split. auto. auto. Qed.
Translation of rules that generate one conclusion is pretty direct. However, as Coq is based on intuitionistic logic, it only allows the conclusion to have at most one element. Consequently, rules that create two formulas on the right of the sequent must be rearranged to work with the hypothesis, as in the following example: Example 4.2. Translation of rightOr in Coq.
Lemma rightOr : forall P Q : Prop, ∼ (∼ P ∧ ∼ Q) → (P ∨ Q).
Proof. intros P Q H. apply NNPP. intro H1. apply H. split. auto. auto. Qed.
This lemma negates the formula, which subsequently allows us to introduce it and generate multiple formulas within the hypothesis. In order to make use of those rules, we need to use apply on the corresponding hypothesis before applying right rules, and to end with intro. For instance, the sequent system right or rule would generate P, Q in the conclusion of the sequent. Our Coq rule enables that by keeping ¬P and ¬Q as hypotheses. As such, when needing P or Q, it sufices to apply ¬P or ¬Q and then proceed normally.
Moreover, left rules require an additional mechanism to be translated into Coq. Indeed, in Coq, two things can be achieved thanks to a formula A -> B in the hypothesis: either we have B in the conclusion and we can generate A in the conclusion, or we have A as a hypothesis and we can generate B in the hypothesis. However, as our proof is built on an abductive way, we want to obtain A in hypothesis from a hypothesis B. In order to do that, complementarily to the rule itself, we need to define additional lemmas that “invert” the terms in the proof. We thus need to consider a proof with “holes”, and wait for Coq to fill them.
Let us illustrate it with the left implies rule. The sequent rule states that from two premises (one with ¬P and the other one with Q as hypothesis), we can infer P -> Q as a hypothesis. However, in our proof, we have P -> Q, and so we are not able to deduce anything. Luckily, we can define a lemma that inverts the rule in order to make it applicable with the conclusion P− > Q, leaving a hole in the hypothesis, which we will have to prove later by providing a witness for ¬P and Q. Those inversion steps are sufixed with _s.
Example 4.3. Translation of leftImp in Coq.
Lemma leftImply_s : forall P Q : Prop,
( ∼ P → False) → (Q → False) → ((P → Q) → False).
Proof. tauto. Qed.
Definition leftImply := fun P Q c hp hq ⇒ leftImply_s P Q hp hq c.
Finally, the context of the proof (i.e., constant, predicates, functions, etc, converted into Parameters) is retrieved and added at the beginning of the proof.
Example 4.4. Context for the Drinker’s paradox proof.
Parameter sctptp_U : Set. (* universe *) Parameter sctptp_I : sctptp_U. (* an individual in the universe. *) Parameter d: sctptp_U → Prop.
Parameter X_0: sctptp_U.
All the lemmas used for the translation can be found in SC-TPTP.v (https://github.com/
SC-TPTP/sc-tptp/tree/main/src). Then, the translation of a full proof can be done by mapping
each proof step to its corresponding lemma, using the parameters of the rule.
Example 4.5. Coq proof of the Drinker’s paradox [
Parameter X_0: sctptp_U.
Theorem drinker: ∼ (∼ (exists (X: sctptp_U), ( d(X) → (forall (Y: sctptp_U), d(Y))))). Proof. intro H0. (* [f3] *) apply H0. exists X_0. apply NNPP. intros H1. (* [f4] *) apply (leftNotImp _ _ H1). intros H2 H3. (* [f5] *) apply H3. intros Sko_0_15. apply NNPP. intros H4. (* [f6] *) apply H0. exists Sko_0_15. apply NNPP. intros H5. (* [f7] *) apply (leftNotImp _ _ H5). intros H6 H7. (* [f8] *) auto.
Qed.
As motivated in Section 3.3, to have congruence as a level 2 step, we implemented an algorithm
unfolding congruence steps into simpler substitution steps. Our approach is based on computing
the congruence closure of all subterms of all atomic and negated atomic formulas in the sequent
under the equality given left of a sequent. The congruence closure is computed using an e-graph,
a dedicated data structure used in automated theorem provers and program optimization. Our
implementation of egraph is in particular inspired by [
Goéland
SC-TPTP Utils
Lisa
Coq Proof Assistant
An e-graph is built on top of a Union-Find data structure, which maintains an equivalence
class of terms under a given set of equality (which in an e-graph are either the input equalities
or equalities that follow from congruence). To produce SC-TPTP proofs, our Union-Find data
structure is equipped with an explain method, as in [
Example 4.6. Consider the following sequent, justified by a congruence step: ( = , = , ( ())) ⊢ ¬ ( ()) The explanation of () = () is simply congruence( (), ()), and recursively the explanation of = is external(, ), external(, ). For any two congruent terms, the proof of equality is produced with a constant number of steps for each edge in the path between the two terms.
This section introduces various tools able to deal with the SC-TPTP format. This format is currently used by the Lisa proof assistant and the Goéland automated theorem prover, as an export format as well as a means of communication between the two tools. A big picture of the SC-TPTP format use case is available in Figure 3.
Goéland [
We implemented a printer, that exports queries about a conjectured sequent as a SC-TPTP problem file (but really a TPTP file, since it contains no proof), and a parser for SC-TPTP proofs directly to Lisa’s Kernel proofs. This allowed us to implement a proof tactic in the user interface, directly using Goéland to justify steps prompted by a Lisa user, as in the next example.
Example 5.1. The Goéland tactic in Lisa, proving the drinkers problem. 1 val drinkers = Theorem(∃(x, ∀(y, Q(x) ==> Q(y)))) { 2 have(thesis) by Goeland 3 }
Our goal with SC-TPTP is to provide a common format to allow sequent-based tools to communicate and exchange proofs, but the adoption of such a format entirely relies on the involvement of the community. In order to increase its potential user base, we plan to expand this format in multiple directions.
The first one will be to increase the number of tools able to deal with this format, starting
with tableau-based theorem provers such as Princess [
Our proof system can be expanded in many ways, which we hope to explore in the future.
An important extension would be the support for typed first order logic. In order to do this, our
format needs to be extended to fit with TFF [ 49]. The addition of theory reasoning is also of
interest. Theory rules should be possible to add as high-level proof steps, that could be either
exported as-is in a proof assistant (if this later is able to deal with the theory), or unfolded in
the same way as equality reasoning. Deskolemization [50, 51] is also a strong candidate step.
We plan to extend our proof-producing module to export proofs to other proof assistants, such
as Lambdapi [
While developping SC-TPTP, we have also encountered limitations within the TPTP syntax. As part of our commitment to continuous improvement, we are eager to ofer suggestions for refinement. These suggestions may include introducing an exists unique quantifier, permitting -ary conjunctions and disjunctions, or proposing a specialized character for expressing identifiers in TPTP files, allowing to bind and reuse formulas (and other syntactic expressions). By addressing these limitations, we aim to fortify the foundation of our framework for the collective benefit of the community.
Acknoledgment This publication is based upon work from COST Action EuroProofNet, supported by COST (European Cooperation in Science and Technology, www.cost.eu) mated Reasoning with Analytic Tableaux and Related Methods, Lecture Notes in Computer Science, Springer International Publishing, Cham, 2015, pp. 102–111. doi:10.1007/ 978-3-319-24312-2_8. [49] J. C. Blanchette, A. Paskevich, Tf1: The tptp typed first-order form with rank-1 polymorphism, in: Automated Deduction–CADE-24: 24th International Conference on Automated Deduction, Lake Placid, NY, USA, June 9-14, 2013. Proceedings 24, Springer, 2013, pp. 414–420. [50] R. Bonichon, O. Hermant, A Syntactic Soundness Proof for Free-Variable Tableaux with on-the-fly Skolemization, 2013. [51] J. Rosain, R. Bonichon, J. Cailler, O. Hermant, A generic deskolemization strategy, in: Logic for Programming, Artificial Intelligence, and Reasoning: 25th International Conference, LPAR-25, Balaclava, Mauritius, May 26-31, 2024. Proceedings 25, Springer, 2024. [52] T. Nipkow, M. Wenzel, L. C. Paulson, Isabelle/HOL: a proof assistant for higher-order logic,
Springer, 2002. [53] J. Avigad, L. De Moura, S. Kong, Theorem proving in lean, Release 3 (2015) 1–4.