Transfer of proofs between different 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 difficulties. Indeed, not only the syntax of different systems can be very hard (when not impossible) to simulate (for example, π-abstractions used in type theory-based systems are difficult 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 difficult (in terms of implementation and space-time complexity) to simulate with lower-level proof steps typically accepted by proof assistants. Finally, different tools may use different formats to export and store statements and proofs in the first place (e.g. TPTP [1], XML [4], LFSC [5], Lambdapi [6] and other (tool-specific) formats), each requiring dedicated parsers and abstract syntax trees.
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 different 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) [7] is a large library of problems for testing automated theorem provers. It is also a specification format [1] for said problems and derivations, i.e., lists of formulas derived from the specification of the problem or from previously deduced ones. However, there is no standard specification of how formulas are derived.
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 first-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 first-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 offer 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 first-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 SC-TPTP 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.
Beyond the TPTP format itself [1] and its associated body of work, significant research efforts have been directed toward designing proof formats conducive to tool interoperability. Those efforts started by conducting various investigations in order to delineate the criteria for an ideal proof format, emphasizing the importance of ease of parsing while retaining human readability [8,9].
One of the original inspirations for designing a common format comes from the SAT community, which encountered notable success with the DRAT format [10]. Work has also been done to provide a proof checker for this format [11].
In the realm of SMT solving, diverse proof formats have emerged, including LFSC [12] used by CVC5 [13] or the Z3 [14] proof format [15], among others. While there is currently no universal proof format for SMT solvers, efforts are made toward this goal [16,12,17], resulting for instance in the Alethe [18] proof format, employed by the VeriT solver [19].
Closer to our approach, and extension of the TPTP syntax to the connection calculus [20] was implemented into the leanCoP [21] and Connect++ [22] provers. In the meantime, the Theory Extensible Sequent Calculus (TESC) format for First-Order ATPs [23] offers a sequent-based proof format capable of compiling and verifying solutions from Vampire [24] and E [25] by combining TPTP problems with their respective TSTP solutions. Within the TPTP ecosystem, the GDV Verifier [26] proof checker for CNF derivation in the TPTP format warrant mention.
Finally, our paper's overarching theme resides in the realm of proof interoperability, echoing the ethos of systems such as Dedukti and Lambdapi [6].
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 [27] to produce detailed proofs corresponding to congruence closure steps. Finally, we describe Section 5, as a use case and proof of concept, how we made the GoΓ©land ATP and the Lisa ITP support SC-TPTP, allowing for direct transfer of proofs from the first to the second.
TPTP [7] is the reference problem library in the field of automated reasoning. It is made of over 25000 problems (including over 7000 first-order (FOF category) problems), ranging from easy to open, that can be used for testing and evaluating ATPs. This library also provides standards for input and output for ATP systems, thanks to the TPTP logic language [1], that is used to specify logical decision problems in various logic ((typed) first-order, higher order, each with and without polymorphism, CNFs, ...). It is a well-adopted input format and benchmark, used for example in CASC, the CADE ATP System Competition.
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 different 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 difficult 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 differences 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 β¨ ... β¨ π π ).
The original sequent calculus LK [28] for classical logic, and its counterpart LJ [29] for intuitionistic logic, are formals system designed to study natural deduction in first-order logic. Sequent calculus admits a subformula property, which gives it its high theoretical and practical relevance. In addition, this calculus also provides a naive (but very inefficient in practice) complete proof search procedure, on which are built more refined proof-search strategies such as the method of analytics tableaux.
Tableaux The tableaux method is a semi-decision procedure for first-order logic. A variety of ATPs are based on the (free-variable) tableaux method, such as Princess [30], GoΓ©land [3], Zenon [31], ZenonModulo [32], LeanTAP [33] and others. One of the advantages of this method is that it follows generally the proof steps of sequent calculus, making it suitable for the reconstruction of efficiently and independently verifiable proofs. The tableaux calculus consists of a set of (refutationally complete) inference rules, divided in four categories: πΌ rules (unary inferences), π½ rules (binary inferences), πΎ rules (instantiation rules) and πΏ rules (Skolemization rules).
The Gentzen-SchΓΌtte calculus (GS3) [34] is a one-sided variant of sequent calculus where formulas are only allowed on the left side. The deduction rules are similar to those of the usual sequent calculus, but the right rules are replaced by left-negation rules. Except for equality, it is easy to observe that the three proof systems are equivalent, with GS3 as a middle ground. For equality reasoning, however, expressing the global closure substitution step using the equality substitution rules is non-trivial, and will be the topic of Section 4.
We introduce the SC-TPTP format as an over-specification of the TPTP format [1] for derivations, with two level of derivation steps. A derivation is a list of annotated formulas, which can be conjectures or axioms as in the specification of TPTP problems, or derived from previously annotated formulas via some inference rule and parameters. Formulas themselves are part of the FOFX grammar of TPTP (Figure 2), which extends FOF by supporting notation for sequents. Until now, the FOFX format was defined but "not yet in use". Technically, TPTP does not allow free variables. However, they are an integral part of sequent calculus1 , and the grammar supports free variables. [premises]).
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 efficient (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.
Rule Parameters hyp 0 Ξ, π΄ β’ π΄, Ξ i:Int: Index of π΄ on the left j:Int: Index of π΄ on the right leftHyp 0 Ξ, π΄, Β¬π΄ β’ Ξ i:Int: Index of π΄ on the left j:Int: Index of Β¬π΄ on the left.
i:Int: Index of the cut formula on the right of the first premise Table 1 Level 1 rules of SC-TPTP, for one-sided and two-sided sequent calculus -structural rules.
Rule Parameters
Level 1 rules of SC-TPTP, for one-sided and two-sided sequent calculus -left introduction rules.
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 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), p 1 , ..., p π ], [r 1 , ..., 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 [36]. In SC-TPTP, all steps are deductive inference and hence we only use the thm status. -The elements p π 's within the parameter list vary in number and shape based on the proof step (indexes, variables, (first-order) terms ($fot), etc). They are described in the 4 th column of Table 1-Table 6 and typically indicate how the step is constructed, thus making its correctness easily verifiable, without requiring inference. -The elements r π 's in the premises list point to the premises of the deduction step.
Their number varies between 0 and 2, depending on the proof step, and are referenced in the 2 nd column of Table 1-Table 6.
Rule Parameters
Level 1 rules of SC-TPTP, for one-sided and two-sided sequent calculus -left not introduction rules. These rules are equivalent to the right rules of Table 3, but more directly match tableaux reasonning.
Level 1 rules of SC-TPTP, for one-sided and two-sided sequent calculus -equality reasoning.
Example 3.2. SC-TPTP proof of the drinker paradox [37].
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 efficient, 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:
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:
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:
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:
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 efficiently either by using some hash function that is congruent with respect to alpha-equivalence, such as in [38], or more simply by computing a locally nameless normal form for formulas.
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 different: 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:
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:
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 difficult 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
Rule Parameters
The premise and conclusion are equal up to negation normal form
No parameter Ξ contains a set of equalities such that π‘ and π’ are congruent (actually more general, see bellow)
[i 1 , ..., i π :Int]: Index of π‘ π = π’ π on the left P(Z 1 , ..., Z π ):Term: Shape of the formula on the right Z 1 , ..., Z π :Int]: variables indicating where to substitute
.., i π :Int: Index of π‘ π = π’ π on the left P(Z 1 , ..., Z π ):Term: Shape of the formula on the left Z 1 , ..., Z π :Int]: variables indicating where to substitute
Level 2 rules of SC-TPTP, for one-sided and two-sided sequent calculus. 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 [39,40] to close branches, which becomes a congruence-like step at proof reconstruction. We implemented a method to eliminate such congruence steps in SC-TPTP proofs using e-graphs, as explained in Section 4.2.
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.
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: 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: 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 suffices 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 suffixed with _s.
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 [27] and [41]. 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 [41], which when prompted to explain π = π outputs a path (π, π 1 ), (π 1 , π 2 ), ..., (π π , π) of equalities. We also record whether an edge comes from an external equality or is a congruence. Congruence edges are then recursively justified by the explain method.
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 [3,42] is an automated theorem prover for first-order logic with equality. It relies on a concurrent proof-search procedure based on the method of free-variable analytics tableaux that allows it to perform a fair branch exploration. The prover is also able to deal with axiomatisable theories thanks to a module of deduction modulo theory [43], to deal with polymorphic types, and to produce machine-checkable proofs in Coq, Lambdapi and Lisa.
Lisa [2] is a proof assistant based on first-order logic, with set-theoretic foundations. Its proof system is inspired by sequent calculus, with additional built-in proof steps to allow for a more efficient representation of typical transformation, such as the substitution of equivalent formulas, simultaneous substitution, quantified substitution, and transformation modulo orthologic [44,45]. All the proof steps from Table 1 to Table 5 are readily convertible to Lisa's Kernel steps.
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.
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 [46] or Zenon [31,32]. We also want to support the Connection Calculus [47,48], related to Tableaux and used by the Connect++ ATP [22] and unify with existing work to export proofs from connection calculi to TPTP. Longer term, we are interested in generalizing our tool to resolution, but this requires additional steps in order to make resolution proofs readily machine-checkable.
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 [6], Isabelle [52] or Lean [53].
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 offer 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)