ENIGMA: Efficient Learning-based Inference Guiding Machine

TL;DR

ENIGMA introduces a learning-based clause selection method for saturation-based theorem provers, significantly improving their performance by training a fast classification model to guide proof search effectively.

Contribution

It presents a novel, efficient classification approach that integrates with theorem provers to enhance clause selection and proof search efficiency.

Findings

Large performance increase on E prover and CASC 2016 AIM benchmark

Effective fast feature-based clause classification model

Improved proof search guidance and efficiency

Abstract

ENIGMA is a learning-based method for guiding given clause selection in saturation-based theorem provers. Clauses from many proof searches are classified as positive and negative based on their participation in the proofs. An efficient classification model is trained on this data, using fast feature-based characterization of the clauses . The learned model is then tightly linked with the core prover and used as a basis of a new parameterized evaluation heuristic that provides fast ranking of all generated clauses. The approach is evaluated on the E prover and the CASC 2016 AIM benchmark, showing a large increase of E's performance.

Tables

Table 1. Table 1: Performance of the differently parameterized (frequency and γ 𝛾 \gamma of weight ​ ( C , ℳ 1 ) weight 𝐶 subscript ℳ 1 \textsl{{weight}}(C,\mathcal{M}_{1}) combined with S 0 subscript 𝑆 0 S_{0} ) trained evaluation heuristics on the 200 AIM CASC 2016 competition problems. Frequency 0 0 (third column) for weight ​ ( C , ℳ 1 ) weight 𝐶 subscript ℳ 1 \textsl{{weight}}(C,\mathcal{M}_{1}) means that S 0 subscript 𝑆 0 S_{0} is used alone, whereas ∞ \infty means that weight ​ ( C , ℳ 1 ) weight 𝐶 subscript ℳ 1 \textsl{{weight}}(C,\mathcal{M}_{1}) is used alone. The empty entries were not run.

	auto-schedule	0	1	5	10	15	30	50	$\infty$
0	29	22	-	-	-	-	18	17	16
0.2	-	-	23	31	32	40	41	33	40
8	-	-	23	31	31	40	41	33	35

Equations

$$\{(\oplus ,=,f)\mapsto 1,(\oplus ,=,g)\mapsto 1,(=,f,\text{oasterisk})\mapsto 2,(=,g,\odot )\mapsto 2,(g,\odot ,\text{oasterisk})\mapsto 1\}$$

$$\text{textsl}vector(\Phi )=\mathbf{x}\text{mbox}suchthat{\mathbf{x}}_{[\text{textsl}code(\varphi )]}=\Phi (\varphi )\text{mbox}forall\varphi \in \text{Feature}$$

$$\min_{\textbf{w}}\big{(}\frac{1}{2}\textbf{w}^{T}\textbf{w}+c\sum_{i=1}^{l}\xi(\mathbf{w},\mathbf{x_{i}},y_{i})\big{)}$$

$$\xi (\mathbf{w},{\mathbf{x}}_{\mathbf{i}},y_i)=\max (1-y_i^{\prime }{\mathbf{w}}^T{\mathbf{x}}_{\mathbf{i}},0{)}^2\text{mbox}where{y}_i^{\prime }=\{\begin{array}{ll}1& \text{mbox}iff{y}_1=⊞\\ -1& \text{mbox}otherwise\end{array}$$

$$\text{textsl}predict-weight(C,\mathcal{M})=\{\begin{array}{ll}1& \text{mbox}iff\text{textsl}predict(C,\mathcal{M})=⊞\\ 10& \text{mbox}otherwise\end{array}$$

$$\text{textsl}weight(C,\mathcal{M})=\gamma \cdot \text{textsl}length(C)+\text{textsl}predict-weight(C,\mathcal{M})$$

Full text

0.1 Introduction: Theorem Proving and Learning

State-of-the-art resolution/superposition automated theorem provers (ATPs) such as Vampire [15] and E [20] are today’s most advanced tools for general reasoning across a variety of mathematical and scientific domains. The stronger the performance of such tools, the more realistic become tasks such as full computer understanding and automated development of complicated mathematical theories, and verification of software, hardware and engineering designs. While performance of ATPs has steadily grown over the past years due to a number of human-designed improvements, it is still on average far behind the performance of trained mathematicians. Their advanced knowledge-based proof finding is an enigma, which is unlikely to be deciphered and programmed completely manually in near future.

On large corpora such as Flyspeck, Mizar and Isabelle, the ATP progress has been mainly due to learning how to select the most relevant knowledge, based on many previous proofs [10, 12, 1, 2]. Learning from many proofs has also recently become a very useful method for automated finding of parameters of ATP strategies [22, 9, 19, 16], and for learning of sequences of tactics in interactive theorem provers (ITPs) [7]. Several experiments with the compact leanCoP [18] system have recently shown that directly using trained machine learner for internal clause selection can significantly prune the search space and solve additional problems [24, 11, 5]. An obvious next step is to implement efficient learning-based clause selection also inside the strongest superposition-based ATPs.

In this work, we introduce ENIGMA – Efficient learNing-based Internal Guidance MAchine for state-of-the-art saturation-based ATPs. The method applies fast machine learning algorithms to a large number of proofs, and uses the trained classifier together with simpler heuristics to evaluate the millions of clauses generated during the resolution/superposition proof search. This way, the theorem prover automatically takes into account thousands of previous successes and failures that it has seen in previous problems, similarly to trained humans. Thanks to a carefully chosen efficient learning/evaluation method and its tight integration with the core ATP (in our case the E prover), the penalty for this ubiquitous knowledge-based internal proof guidance is very low. This in turn very significantly improves the performance of E in terms of the number of solved problems in the CASC 2016 AIM benchmark [21].

0.2 Preliminaries

We use $\mathbb{N}$ to denote the set of natural numbers including 0. When $S$ is a finite set then $|S|$ denotes its size, and $S^{n}$ where $n\in\mathbb{N}$ is the $n$-ary Cartesian product of $S$, that is, the set of all vectors of size $n$ with members from $S$. When $\mathbf{x}\in S^{n}$ then we use notation $\mathbf{x}_{[i]}$ to denote its $i$-th member, counting indexes from 1. We use $\mathbf{x}^{T}$ to denote the transposed vector.

Multiset $M$ over a set $S$ is represented by a total function from $S$ to $\mathbb{N}$, that is, $M(s)$ is the count of $s\in S$ in $M$. The union $M_{1}\cup M_{2}$ of two multisets $M_{1}$ and $M_{2}$ over $S$ is the multiset represented by function $(M_{1}\cup M_{2})(s)=M_{1}(s)+M_{2}(s)$ for all $s\in S$. We use the notation $\{s_{1}\mapsto n_{1},\ldots,s_{k}\mapsto n_{k}\}$ to describe a multiset, omitting the members with count 0.

We assume a fixed first-order theory with stable symbol names, and denote $\Sigma$ its signature, that is, a set of symbols with assigned arities. We use $L$ to range over the set of all first-order literals (Literal), $C$ to range over the set of all first-order clauses (Clause). Finally, we use $\mathbf{C}$ to range over sets of clauses (Clauses).

0.3 Training Clause Classifiers

There are many different machine learning methods, with different function spaces they can explore, different training and evaluation speeds, etc. Based on our previous experiments with premise selection and with guiding leanCoP, we have decided to choose a very fast and scalable learning method for the first ENIGMA instantiation. While more expressive learning methods usually lead to stronger single-strategy ATP results, very important aspects of our domain are that (i) the learning and proving evolve together in a feedback loop [23] where fast learning is useful, and (ii) combinations of multiple strategies – which can be provided by learning in different ways from different proofs – usually solve much more problems than the best strategy.

After several experiments, we have chosen LIBLINEAR: open source library [4] for large-scale linear classification. This section describes how we use LIBLINEAR to train a clause classifier to guide given clause selection. Section 0.3.1 describes how training examples can be obtained from ATP runs. Section 0.3.2 describes how clauses are represented as fixed-length feature vectors. Finally, Section 0.3.3 describes how to use LIBLINEAR to train a clause classifier.

0.3.1 Extracting Training Examples from ATP Runs

Suppose we run a saturation-based ATP to prove a conjecture $\varphi$ in theory $T$. When the ATP successfully terminates with a proof, we can extract training examples from this particular proof search as follows. We collect all the clauses that were selected as given clauses during the proof search. From these clauses, those which appear in the final proof are classified as positives while the remaining given clauses as negative. This gives us two sets of clauses, positive clauses $\mathbf{C}^{\boxplus}$ and negative clauses $\mathbf{C}^{\boxminus}$.

Re-running the proof search using the information $(\mathbf{C}^{\boxplus},\mathbf{C}^{\boxminus})$ to prefer clauses from $\mathbf{C}^{\boxplus}$ as given clauses should significantly shorten the proof search. The challenge is to generalize this knowledge to be able to prove new problems which are in some sense similar. To achieve that, the positive and negative clauses extracted from proof runs on many related problems are combined and learned from jointly.

0.3.2 Encoding Clauses by Features

In order to use LIBLINEAR for linear classification (Section 0.3.3), we need to represent clauses as finite feature vectors. For our purposes, a feature vector $\mathbf{x}$ representing a clause $C$ is a fixed-length vector of natural numbers whose $i$-th member $\mathbf{x}_{[i]}$ specifies how often the $i$-th feature appears in the clause $C$.

Several choices of clause features are possible [14], for example sub-terms, their generalizations, or paths in term trees. In this work we use term walks of length 3 as follows. First we construct a feature vector for every literal $L$ in the clause $C$. We write the literal $L$ as a tree where nodes are labeled by the symbols from $\Sigma$. In order to deal with possibly infinite number of variables and Skolem symbols, we substitute all variables and Skolem symbols with special symbols. We count for each triple of symbols $(s_{1},s_{2},s_{3})\in\Sigma^{3}$, the number of directed node paths of length 3 in the literal tree, provided the trees are oriented from the root. Finally, to construct the feature vector of clause $C$, we sum the vectors of all literals $L\in C$.

More formally as follows. We consider a fixed theory $T$, hence we have a fixed signature $\Sigma$. We extend $\Sigma$ with 4 special symbols for variables ($\oasterisk$), Skolem symbols ($\odot$), positive literals ($\oplus$), and negative literals ($\ominus$). A feature $\phi$ is a triple of symbols from $\Sigma$. The set of all features is denoted Feature, that is, $\textup{{Feature}}=\Sigma^{3}$. Clause (or literal) features $\Phi$ is a multiset of features, thus recording for each feature how many times it appears in a literal or a clause. We use $\Phi$ to range over literal/clause features and the set of all literal/clause features (that is, feature multisets) is denoted Features. Recall that we represent multisets as total functions from Feature to $\mathbb{N}$. Hence every member $\Phi\in\textup{{Features}}$ is a total function of the type “$\textup{{Features}}\rightarrow\mathbb{N}$” and we can write $\Phi(\phi)$ to denote the count of $\phi$ in $\Phi$.

Now it is easy to define function features of the type “$\textup{{Literal}}\rightarrow\textup{{Features}}$” which extracts features $\Phi$ from a literal $L$. For a literal $L$, we construct a rooted feature tree with nodes labeled by the symbols from $\Sigma$. The feature tree basically corresponds to the tree representing literal $L$ with the following exceptions. The root node of the tree is labeled by $\oplus$ iff $L$ is a positive literal, otherwise it is labeled by $\ominus$. Furthermore, all variable nodes are labeled by the symbol $\oasterisk$ and all nodes corresponding to Skolem symbols are labeled by the symbol $\odot$.

Example 1**.**

Consider the following equality literal $L_{1}:f(x,y)=g(sko_{1},sko_{2}(x))$ with Skolem symbols $\text{sko}_{1}$ and $\text{sko}_{2}$, and with variables $x$ and $y$. In Figure 1, the tree representation of $L_{1}$ is depicted on the left, while the corresponding feature tree used to collect features is shown on the right. ∎

Function features constructs the feature tree of a literal $L$ and collects all directed paths of length 3. It returns the result as a feature multiset $\Phi$.

Example 2**.**

For literal $L_{2}:P(x)$ we obtain $\textsl{{features}}(L_{2})=\{(\oplus,P,\oasterisk)\mapsto 1\}$. For literal $L_{3}:\lnot Q(x,y)$ we have $\textsl{{features}}(\lnot Q(x,y))=\{(\ominus,Q,\oasterisk)\mapsto 2\}$. Finally, for literal $L_{1}$ from Example 1 we obtain the following multiset.

[TABLE]

∎

Finally, the function features is extended to clauses ($\textsl{{features}}:\textup{{Clause}}\rightarrow\textup{{Features}}$) by multiset union as $\textsl{{features}}(C)=\bigcup_{L\in C}\textsl{{features}}(L)$.

A Technical Note on Feature Vector Representation

In order to use LIBLINEAR, we transform the feature multiset $\Phi$ to a vector of numbers of length $|\textup{{Feature}}|$. We assign a natural index to every feature and we construct a vector whose $i$-th member contains the count $\Phi(\phi)$ where $i$ is the index of feature $\phi$. Technically, we construct a bijection sym between $\Sigma$ and $\{0,\ldots,|\Sigma|-1\}$ which encodes symbols by natural numbers. Then we construct a bijection between Feature and $\{1,\ldots,|\textup{{Feature}}|\}$ which encodes features by numbers111 We use $\textsl{{code}}(\phi)=\textsl{{sym}}(\phi_{[1]})\cdot|\Sigma|^{2}+\textsl{{sym}}(\phi_{[2]})\cdot|\Sigma|+\textsl{{sym}}(\phi_{[3]})+1$. . Now it is easy to construct a function vector which translates $\Phi$ to a vector from $\mathbb{N}^{|\textup{{Feature}}|}$ as follows:

[TABLE]

0.3.3 Training Clause Classifiers with LIBLINEAR

Once we have the training examples $(\mathbf{C}^{\boxplus},\mathbf{C}^{\boxminus})$ and encoding of clauses by feature vectors, we can use LIBLINEAR to construct a classification model. LIBLINEAR implements the function train of the type “$\textup{{Clauses}}\times\textup{{Clauses}}\rightarrow\textup{{Model}}$” which takes two sets of clauses (positive and negative examples) and constructs a classification model. Once we have a classification model $\mathcal{M}=\textsl{{train}}(\mathbf{C}_{\boxplus},\mathbf{C}_{\boxminus})$, LIBLINEAR provides a function predict of the type “$\textup{{Clause}}\times\textup{{Model}}\rightarrow\{\boxplus,\boxminus\}$” which can be used to predict clause classification as positive ($\boxplus$) or negative ($\boxminus$).

LIBLINEAR supports several classification methods, but we have so far used only the default solver L2-SVM (L2-regularized L2-loss Support Vector Classification) [3]. Using the functions from the previous section, we can translate the training examples $(\mathbf{C}^{\boxplus},\mathbf{C}^{\boxminus})$ to the set of instance-label pairs $(\mathbf{x}_{i},y_{i})$, where $i\in\{1,\ldots,|\mathbf{C}^{\boxplus}|+|\mathbf{C}^{\boxminus}|\}$, $\mathbf{x}_{i}\in\mathbb{N}^{|\textup{{Feature}}|}$, $y_{i}\in\{\boxplus,\boxminus\}$. A training clause $C_{i}$ is translated to the feature vector $\mathbf{x}_{i}=\textsl{{vector}}(\textsl{{features}}(C_{i}))$ and the corresponding $y_{i}$ is set to $\boxplus$ if $C_{i}\in\mathbf{C}^{\boxplus}$ or to $\boxminus$ if $C_{i}\in\mathbf{C}^{\boxminus}$. Then, LIBLINEAR solves the following optimization problem:

[TABLE]

for $\mathbf{w}\in\mathbb{R}^{|\textup{{Feature}}|}$, where $c>0$ is a penalty parameter and $\xi$ is the following loss function.

[TABLE]

LIBLINEAR implements a coordinate descend method [8] and a trust region Newton method [17].

The model computed by LIBLINEAR is basically the vector w obtained by solving the above optimization problem. When computing the prediction for a clause $C$, the clause is translated to the corresponding feature vector $\textbf{x}=\textsl{{vector}}(\textsl{{features}}(C))$ and LIBLINEAR classifies $C$ as positive ($\boxplus$) iff $\textbf{w}^{T}\textbf{x}>0$. Hence we see that the prediction can be computed in time $O(\max(|\textup{{Feature}}|,\textsl{{length}}(C)))$ where $\textsl{{length}}(C)$ is the length of clause $C$ (number of symbols).

0.4 Guiding the Proof Search

Once we have a LIBLINEAR model (classifier) $\mathcal{M}$, we construct a clause weight function which can be used inside the ATP given-clause loop to evaluate the generated clauses. As usual, clauses with smaller weight are selected before those with a higher weight. First, we define the function predict which assigns a smaller number to positively classified clauses as follows:

[TABLE]

In order to additionally prefer smaller clauses to larger ones, we add the clause length to the above predicted weight. We use $\textsl{{length}}(C)$ to denote the length of $C$ counted as the number of symbols. Furthermore, we use a real-valued parameter $\gamma$ to multiply the length as follows.

[TABLE]

This scheme is designed for the E automated prover which uses clause evaluation functions (CEFs) to select the given clause. A clause evaluation function CEF is a function which assigns a real weight to a clause. The unprocessed clause with the smallest weight is chosen to be the given clause. E allows combining several CEFs to jointly guide the proof search. This is done by specifying a finite number of CEFs together with their frequencies as follows: $(f_{1}\star\mathit{CEF}_{1},\ldots,f_{k}\star\mathit{CEF}_{k})$. Each frequency $f_{i}$ denotes how often the corresponding $\mathit{CEF}_{i}$ is used to select a given clause in this weighted round-robin scheme. We have implemented learning-based guidance as a new CEF given by the above weight function. We can either use this new CEF alone or combine it with other CEFs already defined in E.

0.5 Experimental Evaluation

We use the AIM222AIM is a long-term project on proving open algebraic conjectures by Kinyon and Veroff. category of the CASC 2016 competition for evaluation. This benchmark fits our needs as it targets internal guidance in ATPs based on training and testing examples. Before the competition, 1020 training problems were provided for the training of ATPs, while additional 200 problems were used in the competition. Prover9 proofs were provided along with all the training problems. Due to several interesting issues,333E.g., different term orderings, rewriting settings, etc., may largely change the proof search. we have decided not to use the training Prover9 proofs yet and instead find as many proofs as possible by a single E strategy.

Using fast preliminary evaluation, we have selected a strong E444We use E 1.9 and Intel Xeon 2.6GHz workstation for all experiments. strategy $S_{0}$ (see Appendix .8) which can by itself solve 239 training problems with a 30 s timeout. For comparison, E’s auto-schedule mode (using optimized strategy scheduling) can solve 261 problems. We train a clause classifier model $\mathcal{M}_{0}$ (Section 0.3) on the 239 proofs and then run E enhanced with the classifier $\mathcal{M}_{0}$ in different ways to obtain even more training examples. Either we use the classifier CEF based on $\mathcal{M}_{0}$ (i.e., function $\textsl{{weight}}(C,\mathcal{M}_{0})$ from Section 0.4) alone, or combine it with the CEFs from $S_{0}$ by adding $\textsl{{weight}}(C,\mathcal{M}_{0})$ to $S_{0}$ with a grid of frequencies ranging over {1,5,6,7,8,9,10,15,20,30,40,50}. Furthermore, every combination may be run with a different value of the parameter $\gamma\in\{0,0.1,0.2,0.4,0.7,1,2,4,8\}$ of the function $\textsl{{weight}}(C,\mathcal{M}_{0})$. All the methods are run with 30 seconds time limit, leading to the total of 337 solved training problems. As expected, the numbers of processed clauses and the solving times on the previously solved problems are typically very significantly decreased when using $\textsl{{weight}}(C,\mathcal{M}_{0})$. This is a good sign, however, the ultimate test of ENIGMA’s capability to learn and generalize is to evaluate the trained strategies on the testing problems. This is done as follows.

On the 337 solved training problems, we (greedily) find that 4 strategies are needed to cover the whole set. The strongest strategy is our classifier $\textsl{{weight}}(C,\mathcal{M}_{0})$ alone with $\gamma=0.2$, solving 318 problems. Another 15 problems are added by combining $S_{0}$ with the trained classifier using frequency 50 and $\gamma=0.2$. Three problems are contributed by $S_{0}$ and two by the trained classifier alone using $\gamma=0$. We take these four strategies and use only the proofs they found to train a new enhanced classifier $\mathcal{M}_{1}$. The proofs yield 6821 positive and 219012 negative examples. Training of $\mathcal{M}_{1}$ by LIBLINEAR takes about 7 seconds – 2 seconds for feature extraction and 5 seconds for learning. The classifier evaluation on the training examples takes about 6 seconds and reaches 97.6% accuracy (ratio of the correctly classified clauses).

This means that both the feature generation and the model evaluation times per clause are at the order of 10 microseconds. This is comparable to the speed at which clauses are generated by E on our hardware and evaluated by its built-in heuristics. Our learning-based guidance can thus be quickly trained and used by normal users of E, without expensive training phase or using multiple CPUs or GPUs for clause evaluation.

Then we use the $\mathcal{M}_{1}$ classifier to attack the 200 competition problems using 180 s time limit as in CASC. We again run several strategies: both $\textsl{{weight}}(C,\mathcal{M}_{1})$ alone and combined with $S_{0}$ with different frequencies and parameters $\gamma$. All the strategies solve together 52 problems and only 3 of the strategies are needed for this. While $S_{0}$ solves only 22 of the competition problems, our strongest strategy solves 41 problems, see Table 1. This strategy combines $S_{0}$ with $\textsl{{weight}}(C,\mathcal{M}_{1})$ using frequency 30 and $\gamma=0.2$. 7 more problems are contributed by $\textsl{{weight}}(C,\mathcal{M}_{1})$ alone with $\gamma=0.2$ and 4 more problems are added by the E auto-schedule mode. For comparison, Vampire solves 47 problems (compared to our 52 proofs) in 3*180 seconds per problem (simulating 3 runs of the best strategies, each for 180 seconds).

0.5.1 Looping and Boosting

The recent work on the premise-selection task has shown that typically there is not a single optimal way how to guide proof search. Re-learning from new proofs as introduced by MaLARea and combining proofs and learners usually outperforms a single method. Since we are using a very fast classifier here, we can easily experiment with giving it more and different data.

First such experiment is done as follows. We add the proofs obtained on the solved 52 competition problems to the training data obtained from the 337 solved training problems. Instead of immediately re-learning and re-running (as in the MaLARea loop), we however first boost all positive examples (i.e., clauses participating in the proofs) by repeating them ten times in the training data. This way, we inform the learner to more strongly avoid misclassifying the positive examples as negative, than the other way round. The resulting clasifier $\mathcal{M}_{2}$ has lower overall accuracy on all of the data (93% vs. 98% for the unboosted), however, its accuracy on the relatively rare positive data grows significantly, from 12.5% to 81.8%.

Running the most successful strategy using $\mathcal{M}_{2}$ instead of $\mathcal{M}_{1}$ indeed helps. In 180 s, it solves additional 5 problems (4 of them not solved by Vampire), all of them in less than 45 s. This raises ENIGMA’s performance on the competition problems to 57 problems (in general in 600 s). Interestingly, the second most useful strategy (now using $\mathcal{M}_{2}$ instead of $\mathcal{M}_{1}$) which is much more focused on doing inferences on the positively classified clauses, solves only two of these new problems, but six times faster. It is clear that we can continue experimenting this way with ENIGMA for long time, producing quickly a large number of strategies that have quite different search properties. In total we have proved 16 problems unsolved by Vampire.

0.6 Conclusions

The first experiments with ENIGMA are extremely encouraging. While the recent work on premise selection and on internal guidance for leanCoP indicated that large improvements are possible, this is the first practical and usable improvement of a state-of-the-art ATP by internal learning-based guidance on a large CASC benchmark. It is clear that a wide range of future improvements are possible: the learning could be dynamically used also during the proof search, training problems selected according to their similarity with the current problem,555In an initial experiment, a simple nearest-neighbor selection of training problems for the learning further decreases the solving times and proves one more AIM problem unsolved by Prover9. more sophisticated learning and feature characterization methods could be employed, etc.

The magnitude of the improvement is unusually big for the ATP field, and similar to the improvements obtained with high-level learning in MaLARea 0.5 over E-LTB (sharing the same underlying engine) in CASC 2013 [13]. We believe that this may well mark the arrival of ENIGMAs – efficient learning-based inference guiding machines – to the automated reasoning, as crucial and indispensable technology for building the strongest automated theorem provers.

0.7 Acknowledgments

We thank Stephan Schulz for his open and modular implementation of E and its many features that allowed us to do this work. We also thank the Machine Learning Group at National Taiwan University for making LIBLINEAR openly available. This work was supported by the ERC Consolidator grant no. 649043 AI4REASON.

.8 The E Prover Strategy Used in Experiments

The following fixed E strategy $S_{0}$, described by its command line arguments, was used in the experiments:

--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --forward-context-sr -winvfreqrank -c1 -Ginvfreq -WSelectComplexG --oriented-simul-paramod -tKBO6 -H(1ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1), 4ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5), 1FIFOWeight(PreferProcessed), 1ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1), 4*Refinedweight(SimulateSOS,3,2,2,1.5,2))