Entrants' System Descriptions

• ConnectPP 0.6.1
• CSE_E 1.7
• CSI_Enigma 1.0.6
• cvc5 1.3.0
• Drodi 4.1.0
• E 3.3.0
• hopCoP 0.1
• iProver 3.9
• iProver 3.9.3
• LastButNotLeast 0
• Leo-III 1.7.19
• LisaTT 0.9.1
• Prover9 1109a
• SPASS-SCL 0.1
• Toma 0.7
• Twee 2.6.0
• Vampire 4.4
• Vampire 4.9
• Vampire 5.0
• Zipperposition 2.1.9999

Strategies

Implementation

As substitutions need to apply to an entire proof tree the system only represents each variable once and shares the representation, simultaneously maintaining a stack of substitutions making removal of substitutions under backtracking trivial. It also creates subterms only once and shares them; these are indexed allowing constant-time lookup, and nothing is ever removed from the index, meaning that if a term is constructed again after its initial construction no new memory allocation takes place and the term itself is obtained in constant time. At the same time, fresh copies of variables are recycled under backtracking - these two design choices appear to interact very effectively, as the recycling of the variables seems to make it quite likely that subterms already in the index can be reused.

By default a standard recursive unification algorithm is used, but a polynomial-time version is optional.

If a schedule is used, it is assumed that different approaches to definitional clause conversion may be needed - typically all clauses, conjecture clauses only, or no clauses. As these choices can lead to different matrices, and the conversion itself can be expensive, the system stores and switches between the different matrices rather than converting multiple times.

As the system was developed with two guiding aims - to provide a clear implementation easily modified by others, somewhat in the spirit of MiniSAT [ES04], and to support experiments in machine learning for guiding the proof search - the implementation avoids the use of direct recusion in favour of a pair of stacks and an iterative implementation based on these, as described in [Hol23]. This allows complete and arbitrary control of backtracking restriction and other modifications to the proof search using typically quite simple modifications to the code.

The source and documentation are available at

    http://www.cl.cam.ac.uk/~sbh11/connect++.html

Expected Competition Performance

Strategies

Implementation

Expected Competition Performance

Acknowledgements

Strategies

• Complementary ratio strategy. A measure and calculation method of complementary relation between two clauses, which can guide the selection of clauses to participate in deduction and plan the deduction path effectively.
• Portfolio strategy clause selection schemes for different run stages.

Implementation

Expected Competition Performance

Acknowledgement

Like other SMT solvers, cvc5 treats quantified formulas using a two-tiered approach. First, quantified formulas are replaced by fresh Boolean predicates and the ground theory solver(s) are used in conjunction with the underlying SAT solver to determine satisfiability. If the problem is unsatisfiable at the ground level, then the solver answers "unsatisfiable". Otherwise, the quantifier instantiation module is invoked, and will either add instances of quantified formulas to the problem, answer "satisfiable", or return unknown. Finite model finding in cvc5 targets problems containing background theories whose quantification is limited to finite and uninterpreted sorts. In finite model finding mode, cvc5 uses a ground theory of finite cardinality constraints that minimizes the number of ground equivalence classes, as described in [RT+13]. When the problem is satisfiable at the ground level, a candidate model is constructed that contains complete interpretations for all predicate and function symbols. It then adds instances of quantified formulas that are in conflict with the candidate model, as described in [RT+13]. If no instances are added, it reports "satisfiable".

cvc5 has native support for problems in higher-order logic, as described in [BR+19]. It uses a pragmatic approach for HOL, where lambdas are eliminated eagerly via lambda lifting. The approach extends the theory solver for quantifier-free uninterpreted functions (UF) and E-matching. For the former, the theory solver for UF in cvc5 now handles equalities between functions using an extensionality inference. Partial applications of functions are handle using a (lazy) applicative encoding where some function applications are equated to the applicative encoding. For the latter, several of the data structures for E-matching have been modified to incorporate matching in the presence of equalities between functions, function variables, and partial function applications.

cvc5 integrates MBQI-Enum [KRB25], a new instantiation strategy that combines model-based quantifier instantiation [Gd09] with syntax-guided synthesis [RB+19]. This approach improves HOL support by generating instantiations that include lambda-terms, identity functions, and terms with uninterpreted symbols. Additionally, cvc5 incorporates an extended version of MBQI-Enum that supports Hilbert's choice operator. This extension improves cvc5's success on higher-order logic benchmarks by generating instantiations that involve choice terms.

Strategies

Implementation

    https://github.com/cvc5/cvc5

Expected Competition Performance

• Ordered resolution and equality paramodulation inferences as well as demodulation and some other standard simplifications.
• A basic implementation of clausal normal form conversion as in [NW01].
• AVATAR architecture with a SAT solver [Vor14].
• Limited Resource Strategy [RV03].
• Discrimination trees.
• KBO, non recursive and lexicographic reduction orderings. KBO has been rewriten using the polynomial-time algorithm in [BS23].
• Literal selection including lookahead as in [HR+16].
• SInE distance for clauses and symbols as in [Sud19].
• Layered clause selection as in [GS20].
• Stochastic strategy inspired in [Sud22].
• Drodi produces a (hopefully) verifiable proof in TPTP format.

Strategies

• Otter, Discount and Limited Resource Strategy [RV03] saturation algorithms.
• A basic implementation of AVATAR architecture [Vor14].
• Several literal and term reduction orderings.
• Several literal selection options [HR+16].
• Several layered clause selection heuristics with adjustable selection ratios [GS20].
• Classical clause relevancy pruning.
• Drodi V4 has new strategy portfolio inspired (but not exactly equal than) by [BS23]. The strategies have now unequal time slices and the set of strategies used depends on the problem features detected during the preprocessing.
• Some strategies are run a second time with a previously applied randomization to the problem [Sud22].
• Drodi can generate learning data from successful proofs and use the data to guide clause selection strategy. It is based in the enhanced ENIGMA method. However, unlike ENIGMA, the learning data is completely general and can be used with any kind of problems. This generality allows the use of the same learning data in both FOF and UEQ CASC competition divisions. The learning data is generated over a set of TPTP problems before the CASC competition using built-in Drodi functions that include a L2 Support Vector Machine. Drodi integrated learning functions are a generalization of ENIGMA [JU17, JU18]. Literals polarity, equality, skolem and variable occurrences are stored in clause feature vectors. Unlike ENIGMA, instead of storing the specific functions and predicates themselves only the SinE distance and arity of functions and non equality predicates are stored in clause feature vectors with different features assigned to predicates and functions.

Implementation

Expected Competition Performance

Strategies

For CASC-30, E implements a two-stage multi-core strategy-scheduling automatic mode. The total CPU time available is broken into several (unequal) time slices. For each time slice, the problem is classified into one of several classes, based on a number of simple features (number of clauses, maximal symbol arity, presence of equality, presence of non-unit and non-Horn clauses, possibly presence of certain axiom patterns, ...). For each class, a schedule of strategies is greedily constructed from experimental data as follows: The first strategy assigned to a schedule is the the one that solves the most problems from this class in the first time slice. Each subsequent strategy is selected based on the number of solutions on problems not already solved by a preceding strategy. The strategies are then scheduled onto the available cores and run in parallel.

About 140 different strategies have been thoroughly evaluated on all untyped first-order problems from TPTP 7.3.0. We have also explored some parts of the heuristic parameter space with a short time limit of 5 seconds. This allowed us to test about 650 strategies on all TPTP problems, and an extra 7000 strategies on UEQ problems from TPTP 7.2.0. About 100 of these strategies are used in the automatic mode, and about 450 are used in at least one schedule.

Implementation

    https://www.eprover.org

Expected Competition Performance

Strategies

Implementation

    http://github.com/MichaelRawson/hopcop

Expected Competition Performance

Recent features in iProver include:

• Ground joinability and connectedness in the superposition calculus [DK22].
• Support for quantified reasoning with arithmetic and arrays.
• AC joinability and AC normalisation [DK21].
• Superposition calculus with simplifications including: demodulation, light normalisation, subsumption, subsumption resolution and global subsumption. iProver's simplification set up [DK20] is tunable via command line options and generalises common architectures such as Discount or Otter.
• HOS-ML framework for learning heuristics using combination of hyper-parameter optimisation and dynamic clustering together with schedule optimisation using constraint solving [HK21, HK19]

Strategies

Implementation

    https://gitlab.com/korovin/iprover

Expected Competition Performance

Recent features in iProver include:

• Ground joinability and connectedness in the superposition calculus [DK22].
• Support for quantified reasoning with arithmetic and arrays.
• AC joinability and AC normalisation [DK21].
• Superposition calculus with simplifications including: demodulation, light normalisation, subsumption, subsumption resolution and global subsumption. iProver's simplification set up [DK20] is tunable via command line options and generalises common architectures such as Discount or Otter.
• HOS-ML framework for learning heuristics using combination of hyper-parameter optimisation and dynamic clustering together with schedule optimisation using constraint solving [HK21, HK19]

Strategies

Implementation

    https://gitlab.com/korovin/iprover

Expected Competition Performance

#!/usr/bin/env python

print("% LastButNotLeast: The fastest way to give up!")
print("% For best results, do not expect results.")
print("% SZS status GaveUp")
print("% It's not a bug - it's a philosophical stance.")
print("% Thanks for trying LastButNotLeast :)")

Leo-III cooperates with external first-order ATPs that are called asynchronously during proof search; a focus is on cooperation with systems that support typed first-order (TFF) input. For this year's CASC E [Sch02, Sch13] is used as external system. However, cooperation is in general not limited to first-order systems. Further TPTP/TSTP-compliant external systems (such as higher-order ATPs or counter model generators) may be included using simple command-line arguments. If the saturation procedure loop (or one of the external provers) finds a proof, the system stops, generates the proof certificate and returns the result.

Strategies

Implementation

    https://tptp.org/NonClassicalLogic/

The term data structure of Leo-III uses a polymorphically typed spine term representation augmented with explicit substitutions and De Bruijn-indices. Furthermore, terms are perfectly shared during proof search, permitting constant-time equality checks between alpha-equivalent terms.

Leo-III's saturation procedure may at any point invoke external reasoning tools. To that end, Leo-III includes an encoding module which translates (polymorphic) higher-order clauses to polymorphic and monomorphic typed first-order clauses, whichever is supported by the external system. While LEO-II relied on cooperation with untyped first-order provers, Leo-III exploits the native type support in first-order provers (TFF logic) for removing clutter during translation and, in turn, higher effectivity of external cooperation.

Leo-III is available on GitHub:

    https://github.com/leoprover/Leo-III

Expected Competition Performance

    https://github.com/epfl-lara/lisa/tree/main

Expected Competition Performance

Prover9 has available positive ordered (and nonordered) resolution and paramodulation, negative ordered (and nonordered) resolution, factoring, positive and negative hyperresolution, UR-resolution, and demodulation (term rewriting). Terms can be ordered with LPO, RPO, or KBO. Selection of the "given clause" is by an age-weight ratio.

Proofs can be given at two levels of detail: (1) standard, in which each line of the proof is a stored clause with detailed justification, and (2) expanded, with a separate line for each operation. When FOF problems are input, proof of transformation to clauses is not given.

Completeness is not guaranteed, so termination does not indicate satisfiability.

Strategies

Given a problem, Prover9 adjusts its inference rules and strategy according to syntactic properties of the input clauses such as the presence of equality and non-Horn clauses. Prover9 also does some preprocessing, for example, to eliminate predicates.

For CASC Prover9 uses KBO to order terms for demodulation and for the inference rules, with a simple rule for determining symbol precedence.

For the FOF problems, a preprocessing step attempts to reduce the problem to independent subproblems by a miniscope transformation; if the problem reduction succeeds, each subproblem is clausified and given to the ordinary search procedure; if the problem reduction fails, the original problem is clausified and given to the search procedure.

Implementation

    http://www.cs.unm.edu/~mccune/prover9/

Expected Competition Performance

Strategies

Implementation

Expected Competition Performance

Strategies

Implementation

    https://www.jaist.ac.jp/project/maxcomp/.

Expected Competition Performance

Twee features ground joinability testing [MN90] and a connectedness test [BD88], which together eliminate many redundant inferences in the presence of unorientable equations. The ground joinability test performs case splits on the order of variables, in the style of [MN90], and discharges individual cases by rewriting modulo a variable ordering. This year's version has fixes for some completeness bugs which allows some slightly more aggressive redundancy criteria to be used.

Strategies

• Select and normalise the lowest-scored critical pair, and if it is not redundant, add it as a rewrite rule to the active set.
• Normalise the active rules with respect to each other.
• Normalise the goal with respect to the active rules.

Each critical pair is scored using a weighted sum of the weight of both of its terms. Terms are treated as DAGs when computing weights, i.e., duplicate subterms are counted only once per term.

For CASC, to take advantage of multiple cores, several versions of Twee run in parallel using different parameters (e.g., with the goal-directed transformation on or off).

Implementation

The passive set is represented compactly (12 bytes per critical pair) by storing only the information needed to reconstruct the critical pair, not the critical pair itself. Because of this, Twee can run for an hour or more without exhausting memory.

Twee uses an LCF-style kernel: all rules in the active set come with a certified proof object which traces back to the input axioms. When a conjecture is proved, the proof object is transformed into a human-readable proof. Proof construction does not harm efficiency because the proof kernel is invoked only when a new rule is accepted. In particular, reasoning about the passive set does not invoke the kernel.

Twee can be downloaded as open source from:

    https://nick8325.github.io/twee

Expected Competition Performance

A number of standard redundancy criteria and simplification techniques are used for pruning the search space: subsumption, tautology deletion, subsumption resolution and rewriting by ordered unit equalities. The reduction ordering is the Knuth-Bendix Ordering. Substitution tree and code tree indexes are used to implement all major operations on sets of terms, literals and clauses. Internally, Vampire works only with clausal normal form. Problems in the full first-order logic syntax are clausified during preprocessing. Vampire implements many useful preprocessing transformations including the SinE axiom selection algorithm.

When a theorem is proved, the system produces a verifiable proof, which validates both the clausification phase and the refutation of the CNF. Vampire 4.4 provides a very large number of options for strategy selection. The most important ones are:

• Choices of saturation algorithm:
  • Limited Resource Strategy [RV03]
  • DISCOUNT loop
  • Otter loop
  • Instantiation using the Inst-Gen calculus
  • MACE-style finite model building with sort inference
• Splitting via AVATAR [Vor14]
• A variety of optional simplifications.
• Parameterized reduction orderings.
• A number of built-in literal selection functions and different modes of comparing literals [HR+16].
• Age-weight ratio that specifies how strongly lighter clauses are preferred for inference selection.
• Set-of-support strategy.
• For theory-reasoning:
  • Ground equational reasoning via congruence closure.
  • Addition of theory axioms and evaluation of interpreted functions.
  • Use of Z3 with AVATAR to restrict search to ground-theory-consistent splitting branches [RB+16].
  • Specialised theory instantiation and unification [RSV18].
  • Extensionality resolution with detection of extensionality axioms
• For higher-order problems:
  • Translation to applicative and combinator form.
  • Addition of combinator axioms.
  • Addition of shortcut inference rules that encode axioms.
  • Proof search heuristics targetting the growth of combinator axioms.
  • Restricted combinatory unification [RSV18].

Implementation

Expected Competition Performance

Strategies

• Choices of saturation algorithm:
  • Limited Resource Strategy [RV03]
  • DISCOUNT loop
  • Otter loop
  • MACE-style finite model building with sort inference
• Splitting via AVATAR [Vor14]
• A variety of optional simplifications.
• Parameterized reduction orderings.
• A number of built-in literal selection functions and different modes of comparing literals [HR+16].
• Age-weight ratio that specifies how strongly lighter clauses are preferred for inference selection. This has been extended with a layered clause selection approach [GS20].
• Set-of-support strategy with extensions for theory reasoning.
• For theory-reasoning:
  • Ground equational reasoning via congruence closure.
  • Addition of theory axioms and evaluation of interpreted functions [RSV21].
  • Use of Z3 with AVATAR to restrict search to ground-theory-consistent splitting branches [RB+16].
  • Specialised theory instantiation and unification [RSV18].
  • Extensionality resolution with detection of extensionality axioms

Implementation

Expected Competition Performance

Vampire 5.0 remains similar in spirit to all previous versions, but a bumper crop of changes have been merged this competition cycle. Various non-competition improvements to Vampire including a program synthesis mode [HA+24] and partial support for the polymorphic SMT-LIB 2.7 standard landed, but for the competition we mention:

• ALASCA [KK+23] for reasoning with linear arithmetic, with further VIRAS extensions [SKK24] for quantifier elimination.
• Partial redundancy calculi [HKV25]
• Stabilised and greatly enhanced runtime-specialised unidirectional term ordering checks [HC+25]
• A variant of the ground joinability redundancy elimination rule, used in forward simplification.
• Subsumption (resolution) via code trees.
• Integration of the CaDiCaL SAT solver [BF+24] alongside Minisat.
• More detailed output, including proofs that are (more) TSTP-compliant, reporting non-trivial preprocessing in saturations, and producing completely faithful finite models of the input.
• Portability: Vampire is much more standards-compliant and portable than previously, with much-reduced dependence on platform-specific APIs and hardware architectures, aided by C++17.

Architecture

Strategies

• Choices of saturation algorithm:
  • Limited Resource Strategy [RV03]
  • DISCOUNT loop
  • Otter loop
  • MACE-style finite model building with sort inference
• Splitting via AVATAR [Vor14]
• A variety of optional simplifications.
• Parameterized reduction orderings KBO and LPO.
• A number of built-in literal selection functions and different modes of comparing literals [HR+16].
• Age-weight ratio that specifies how strongly lighter clauses are preferred for inference selection. This has been extended with a layered clause selection approach [GS20].
• The set-of-support strategy with extensions for theory reasoning.
• For theory reasoning:
  • Specialised calculi such as ALASCA.
  • Addition of theory axioms and evaluation of interpreted functions [RSV21].
  • Use of Z3 with AVATAR to restrict search to ground-theory-consistent splitting branches [RB+16].
  • Specialised theory instantiation and unification [RSV18].
  • Extensionality resolution with detection of extensionality axioms

Implementation

Expected Competition Performance

Strategies

Implementation

Zipperposition's code can be found at

    https://github.com/sneeuwballen/zipperposition

Zipperposition can also output graphic proofs using graphviz. Some tools to perform type inference and clausification for typed formulas are also provided, as well as a separate library for dealing with terms and formulas [Cru15].

Expected Competition Performance