ENIGMA-NG: Efficient Neural and Gradient-Boosted Inference Guidance for E

TL;DR

This paper introduces ENIGMA-NG, an advanced clause guidance system for automated theorem provers that leverages gradient boosted trees and neural networks, achieving significant improvements over previous manual methods.

Contribution

It presents the first practical integration of gradient-boosted and neural clause guidance in saturation-based theorem provers, enhancing efficiency and effectiveness.

Findings

Gradient boosted trees and neural networks outperform manual guidance.

Deep integration reduces neural evaluation costs.

Methods achieve competitive real-time theorem proving results.

Abstract

We describe an efficient implementation of clause guidance in saturation-based automated theorem provers extending the ENIGMA approach. Unlike in the first ENIGMA implementation where fast linear classifier is trained and used together with manually engineered features, we have started to experiment with more sophisticated state-of-the-art machine learning methods such as gradient boosted trees and recursive neural networks. In particular the latter approach poses challenges in terms of efficiency of clause evaluation, however, we show that deep integration of the neural evaluation with the ATP data-structures can largely amortize this cost and lead to competitive real-time results. Both methods are evaluated on a large dataset of theorem proving problems and compared with the previous approaches. The resulting methods improve on the manually designed clause guidance, providing the first practically convincing application of gradient-boosted and neural clause guidance in saturation-style automated theorem provers.

Tables

Table 1. Table 1: True Positive Rate (TPR) and True Negative Rate (TNR) on training data.

	${ℳ}_{\text{lin}}$	${ℳ}_{\text{tree}}$	${ℳ}_{\text{nn}}$
TPR	$90.54\%$	$99.36\%$	$97.82\%$
TNR	$83.52\%$	$93.32\%$	$94.69\%$

Table 2. Table 2: Number of problems solved (and uniquely solved) by the individual models. 𝒮 + limit-from 𝒮 \mathcal{S}+ and 𝒮 − limit-from 𝒮 \mathcal{S}- are the additions and missing solutions wrt 𝒮 𝒮 \mathcal{S} .

	$𝒮$	$𝒮\odot {ℳ}_{\text{lin}}$	$𝒮\oplus {ℳ}_{\text{lin}}$	$𝒮\odot {ℳ}_{\text{tree}}$	$𝒮\oplus {ℳ}_{\text{tree}}$	$𝒮\odot {ℳ}_{\text{nn}}$	$𝒮\oplus {ℳ}_{\text{nn}}$
solved	1086	1115	1210	1231	1256	1167	1197
unique	0	3	7	10	15	3	2
$𝒮+$	0	+119	+138	+155	+173	+114	+119
$𝒮-$	0	-90	-14	-10	-3	-33	-8

Table 3. Table 3: The greedy sequence—methods sorted by their greedily computed contribution to all the problems solved.

greedy sequence	$𝒮\oplus {ℳ}_{\text{tree}}$	$𝒮\oplus {ℳ}_{\text{lin}}$	$𝒮\odot {ℳ}_{\text{nn}}$	$𝒮\odot {ℳ}_{\text{tree}}$	$𝒮\odot {ℳ}_{\text{lin}}$	$𝒮\oplus {ℳ}_{\text{nn}}$	$𝒮$
greedy addition	1256	33	13	11	3	2	0
greedy total	1256	1289	1302	1313	1316	1318	1318

Table 4. Table 4: True Positive Rate (TPR) and True Negative Rate (TNR) on testing data from the newly solved 232 problems.

	${ℳ}_{\text{lin}}$	${ℳ}_{\text{tree}}$	${ℳ}_{\text{nn}}$
TPR	$80.54\%$	$83.35\%$	$82.00\%$
TNR	$62.28\%$	$72.60\%$	$76.88\%$

Table 5. Table 5: The ASRPA and NSRGA ratios. ASRPA are the average ratios (and standard deviations) of the relative number of processed clauses with respect to 𝒮 𝒮 \mathcal{S} on problems on which all runs succeeded. NSRGA are the average ratios (and standard deviations) of the relative number of generated clauses with respect to 𝒮 𝒮 \mathcal{S} on problems on which all runs timed out. The numbers of problems were 898 898 898 and 681 681 681 , respectively.

	$𝒮$	$𝒮\odot {ℳ}_{\text{lin}}$	$𝒮\oplus {ℳ}_{\text{lin}}$	$𝒮\odot {ℳ}_{\text{tree}}$	$𝒮\oplus {ℳ}_{\text{tree}}$	$𝒮\odot {ℳ}_{\text{nn}}$	$𝒮\oplus {ℳ}_{\text{nn}}$
ASRPA	$1\pm 0$	$2.18\pm 20.35$	$0.91\pm 0.58$	$0.60\pm 0.98$	$0.59\pm 0.36$	$0.59\pm 0.75$	$0.69\pm 0.94$
NSRGA	$1\pm 0$	$0.61\pm 0.52$	$0.56\pm 0.35$	$0.42\pm 0.38$	$0.43\pm 0.35$	$0.06\pm 0.08$	$0.07\pm 0.09$

Table 6. Table 6: Effect of feature hashing on prediction rates and ATP performance.

model $\backslash$ hash size		without	32k	16k	8k	4k	2k	1k
${ℳ}_{\text{lin}}$	TPR [%]	90.54	89.32	88.27	89.92	82.08	91.08	83.68
	TNR [%]	83.52	82.40	86.01	83.02	81.50	76.04	77.53
	$𝒮\odot ℳ$	1115	1106	1072	1078	1076	1028	938
	$𝒮\oplus ℳ$	1210	1218	1189	1202	1189	1183	1119
${ℳ}_{\text{tree}}$	TPR [%]	99.36	99.38	99.38	99.51	99.62	99.65	99.69
	TNR [%]	93.32	93.54	93.29	93.69	93.90	94.53	94.88
	$𝒮\odot ℳ$	1231	1231	1233	1232	1223	1227	1215
	$𝒮\oplus ℳ$	1256	1244	1244	1256	1245	1236	1232

Equations

$$(f_1\ast {\mathcal{W}}_1,\dots ,f_k\ast {\mathcal{W}}_k).$$

$$\begin{array}[]{lllll}\mbox{in }\mathcal{S}\odot\mathcal{M}:&&(f_{1}*\mathcal{W}_{1},\ldots,f_{k}*\mathcal{W}_{k})&\rightsquigarrow&(1*\mathcal{M}),\\ \mbox{in }\mathcal{S}\oplus\mathcal{M}:&&(f_{1}*\mathcal{W}_{1},\ldots,f_{k}*\mathcal{W}_{k})&\rightsquigarrow&((\sum{f_{i}})*\mathcal{M},f_{1}*\mathcal{W}_{1},\ldots,f_{k}*\mathcal{W}_{k}).\end{array}$$

$$h_i=s_i+(h_{i-1}\ll 6)+(h_{i-1}\ll 16)-h_{i-1}$$

$$p=\frac{1}{1+e^{(x_0-x_1)}}.$$

$$x_0<x_1.$$

Full text

1 Introduction

Automated theorem provers (ATPs) [32] have been developed for decades by manually designing proof calculi and search heuristics. Their power has been growing and they are already very useful, e.g., as parts of large interactive theorem proving (ITP) verification toolchains (hammers) [5]. On the other hand, with small exceptions, ATPs are still significantly weaker than trained mathematicians in finding proofs in most research domains.

Recently, machine learning over large formal corpora created from ITP libraries [37, 28, 19] has started to be used to develop guidance of ATP systems [39, 25, 2]. This has already produced strong systems for selecting relevant facts for proving new conjectures over large formal libraries [1, 4, 9]. More recently, machine learning has also started to be used to guide the internal search of the ATP systems. In sophisticated saturation-style provers this has been done by feedback loops for strategy invention [38, 16, 33] and by using supervised learning [14, 26] to select the next given clause [27]. In the simpler connection tableau systems such as leancop [29], supervised learning has been used to choose the next tableau extension step [40, 20] and first experiments with Monte-Carlo guided proof search [8] and reinforcement learning [21] have been done.

In this work, we add two state-of-the-art machine learning methods to the ENIGMA [14, 15] algorithm that efficiently guides saturation-style proof search. The first one trains gradient boosted trees on efficiently extracted manually designed (handcrafted) clause features. The second method removes the need for manually designed features, and instead uses end-to-end training of recursive neural networks. Such architectures, when implemented naively, are typically expensive and may be impractical for saturation-style ATP. We show that deep integration of the neural evaluation with the ATP data-structures can largely amortize this cost, allowing competitive performance.

The rest of the paper is structured as follows. Section 2 introduces the saturation-based automated theorem proving with the emphasis on machine learning. Section 3 briefly summarizes our previous work with handcrafted features in ENIGMA, it extends previously published ENIGMA with additional classifier based on decision trees (Section 3.3) and simple feature hashing (Section 3.4). Section 4 presents our new approach to apply neural networks for ATP guidance. Section 5 provides experimental evaluation of our work and we conclude in Section 6.

2 Automated Theorem Proving with Machine Learning

State-of-the-art saturation-based automated theorem provers (ATPs) for first-order logic (FOL), such as E [34] and Vampire [23] are today’s most advanced tools for general reasoning across a variety of mathematical and scientific domains. Many ATPs employ the given clause algorithm, translating the input FOL problem $T\cup\{\lnot C\}$ into a refutationally equivalent set of clauses. The search for a contradiction is performed maintaining sets of processed ($P$) and unprocessed ($U$) clauses. The algorithm repeatedly selects a given clause $g$ from $U$, moves $g$ to $P$, and extends $U$ with all clauses inferred with $g$ and $P$. This process continues until a contradiction is found, $U$ becomes empty, or a resource limit is reached. The search space of this loop grows quickly and it is a well-known fact that the selection of the right given clause is crucial for success. Machine learning from a large number of proofs and proof searches may help guide the selection of the given clauses.

E allows the user to select a proof search strategy $\mathcal{S}$ to guide the proof search. An E strategy $\mathcal{S}$ specifies parameters such as term ordering, literal selection function, clause splitting, paramodulation setting, premise selection, and, most importantly for us, the given clause selection mechanism. The given clause selection in E is implemented using a list of priority queues. Each priority queue stores all the generated clauses in a specific order determined by a clause weight function. The clause weight function assigns a numeric (real) value to each clause, and the clauses with smaller weights (“lighter clauses”) are prioritized. To select a given clause, one of the queues is chosen in a round robin manner, and the clause at the front of the chosen queue gets processed. Each queue is additionally assigned a frequency which amounts to the relative number of clause selections from that particular queue. Frequencies can be used to prefer one queue over another. We use the following notation to denote the list of priority queues with frequencies $f_{i}$ and weight functions $\mathcal{W}_{i}$:

[TABLE]

To facilitate machine learning research, E implements an option under which each successful proof search gets analyzed and the prover outputs a list of clauses annotated as either positive or negative training examples. Each processed clause which is present in the final proof is classified as positive. On the other hand, processing of clauses not present in the final proof was redundant, hence they are classified as negative. Our goal is to learn such classification (possibly conditioned on the problem and its features) in a way that generalizes and allows solving related problems.

Given a set of problems $\mathcal{P}$, we can run E with a strategy $\mathcal{S}$ and obtain positive and negative training data $\mathcal{T}$ from each of the successful proof searches. In this work, we use three different machine learning methods to learn the clause classification given by $\mathcal{T}$, each method yielding a classifier or model $\mathcal{M}$. Each of the machine learning methods has a different structure of $\mathcal{M}$ described in detail later. With any method, however, $\mathcal{M}$ provides the function to compute the weight of an arbitrary clause. This weight function is then used in E to guide further proof runs.

A model $\mathcal{M}$ can be used in E in different ways. We use two methods to combine $\mathcal{M}$ with a strategy $\mathcal{S}$. Either (1) we use $\mathcal{M}$ to select all the given clauses, or (2) we combine $\mathcal{M}$ with the given clause guidance from $\mathcal{S}$ so that roughly half of the clauses are selected by $\mathcal{M}$. We denote the resulting E strategies as (1) $\mathcal{S}\odot\mathcal{M}$, and (2) $\mathcal{S}\oplus\mathcal{M}$. The two strategies are equal up to the priority queues for given clause selection which are changed ($\rightsquigarrow$) as follows.

[TABLE]

The strategy $\mathcal{S}\oplus\mathcal{M}$ usually performs better in practice as it helps to counter overfitting by combining powers with the original strategy $\mathcal{S}$. The strategy $\mathcal{S}\odot\mathcal{M}$ usually provides additional proved problems, gaining additional training data, and it is useful for the evaluation of the training phase. When $\mathcal{S}\odot\mathcal{M}$ performs better than $\mathcal{S}$, it indicates that $\mathcal{M}$ has learned the training data well. When it performs much worse, it indicates that $\mathcal{M}$ is not very well trained. The strategy $\mathcal{S}\oplus\mathcal{M}$ should always perform better than $\mathcal{S}$, otherwise the guidance of $\mathcal{M}$ is not very useful. Additional indication of successful training can be obtained from the number of clauses processed during a successful proof search. The strategy $\mathcal{S}\odot\mathcal{M}$ should run with much less processed clauses, in some cases even better than $\mathcal{S}\oplus\mathcal{M}$ as the original $\mathcal{S}$ might divert the proof search. In the best case, when $\mathcal{M}$ learns some problem perfectly, the number of processed clauses is approaching the length of the proof.

It is important, however, to combine a model $\mathcal{M}$ only with a “compatible” strategy $\mathcal{S}$. For example, let us consider a model $\mathcal{M}$ trained on samples obtained with another strategy $S_{0}$ which has a different term ordering than $\mathcal{S}$. As the term ordering can change term normal forms, the clauses encountered in the proof search with $\mathcal{S}$ might look quite different than the training clauses. This causes problems unless the trained models are independent of symbol names, which is not (yet) our case. Additional problems might be caused as term orderings and literal selection might change the proof space and the original proofs might not be reachable. Hence we only combine $\mathcal{M}$ with the strategy $\mathcal{S}$ which provided the examples on which $\mathcal{M}$ was trained.

3 ATP Guidance with Handcrafted Clause Features

In order to employ a machine learning method for ATP guidance, first-order clauses need to be represented in a format recognized by the selected learning method. A common approach is to manually extract a finite set of various properties of clauses called features, and to encode these clause features by a fixed-length numeric vector. Various machine learning methods can handle numeric vectors and their success heavily depends on the selection of correct clause features. In this section, we work with handcrafted clause features which, we believe, capture the information important for ATP guidance.

ENIGMA [14, 15] is our efficient learning-based method for guiding given clause selection in saturation-based ATPs. Sections 3.1 and 3.2 briefly summarizes our previous work. Sections 3.3 and 3.4 describe extensions first-presented in this work.

3.1 ENIGMA Clause Features

So far, the development of ENIGMA was focusing on fast and practically usable methods, allowing E users to directly benefit from our work. Various possible choices of efficient clause features for theorem prover guidance have been experimented with [14, 15, 21, 22]. The original ENIGMA [14] uses term-tree walks of length 3 as features, while the second version [15] reaches better results by employing various additional features. In particular, the following types of features are used (see [14, Sec. 3.2] and [15, Sec.2] for details):

Vertical Features

are (top-down-)oriented term-tree walks of length 3. For example, the unit clause $P(f(a,b))$ contains only features $(P,f,a)$ and $(P,f,b)$.

Horizontal Features

are horizontal cuts of a term tree. For every term $f(t_{1},\ldots,t_{n})$ in the clause, we introduce the feature $f(s_{1},\ldots,s_{n})$ where $s_{i}$ is the top-level symbol of $t_{i}$.

Symbol Features

are various statistics about clause symbols, namely, the number of occurrences and the maximal depth for each symbol.

Length Features

count the clause length and the numbers of positive and negative literals.

Conjecture Features

embed information about the conjecture being proved into the feature vector. In this way, ENIGMA can provide conjecture-dependent predictions.

Since there are only finitely many features in any training data, the features can be serially numbered. This numbering is fixed for each experiment. Let $n$ be the number of different features appearing in the training data. A clause $C$ is translated to a feature vector $\varphi_{C}$ whose $i$-th member counts the number of occurrences of the $i$-th feature in $C$. Hence every clause is represented by a sparse numeric vector of length $n$.

With conjecture features, instead of using the vector $\varphi_{C}$ of length $n$, we use a vector $(\varphi_{C},\varphi_{G})$ of length $2n$ where $\varphi_{G}$ contains the features of the conjecture $G$. For a training clause $C$, $G$ corresponds to the conjecture of the proof search where $C$ was selected as a given clause. When classifying a clause $C$ during proof search, $G$ corresponds to the conjecture currently being proved. When the conjecture consists of several clauses, their vectors are computed separately and then summed (with the exception of features corresponding to maxima, such as the maximal symbol depth, where maximum is taken instead).

3.2 ATP Guidance with Fast Linear Classifiers

ENIGMA has so far used simple but fast linear classifiers such as linear SVM and logistic regression efficiently implemented by the LIBLINEAR open source library [7]. In order to employ them, clause representation by numeric feature vectors described above in Section 3.1 is used. Clausal training data $\mathcal{T}$ are translated to a set of fixed-size labeled vectors. Each (typically sparse) vector of length $n$ is labeled either as positive or negative.

The labeled numeric vectors serve as an input to LIBLINEAR which, after the training, outputs a model $\mathcal{M}$ consisting mainly of a weight vector $w$ of length $n$. The main cost in classifying an arbitrary clause $C$ consists of computation of its feature vector $\varphi_{C}$ and its dot product with the weight vector $\varphi_{C}\cdot w$. ENIGMA assigns to the positively classified clauses a chosen small weight ($1.0$) and a higher weight ($10.0$) to the negatively classified ones. This weight is then used inside E to guide given clause selection as described in Section 2.

The training data obtained from the proof runs are typically not balanced with respect to the number of positive and negative examples. Usually, there are much more negative examples and the method of Accuracy-Balancing Boosting [15] was found useful in practice to improve precision on the positive training data. This is done as follows. Given training data $\mathcal{T}$ we create a LIBLINEAR classifier $\mathcal{M}$, test $\mathcal{M}$ on the training data, and collect the positives mis-classified by $\mathcal{M}$. We then repeat (boost) the mis-classified positives in the training data, yielding updated $\mathcal{T}_{1}$ and an updated classifier $\mathcal{M}_{1}$. We iterate this process, and with every iteration, the accuracy on the positive samples increases, while the accuracy on the negatives typically decreases. We finish the boosting when the positive accuracy exceeds the negative one. See [15, Sec.2] for details.

3.3 ATP Guidance with Gradient Boosted Trees

Fast linear classifiers together with well-designed features have been used with good results for a number of tasks in areas such as NLP [18]. However, more advanced learning models have been recently developed, showing improved performance on a number of tasks, while maintaining efficiency. One such method is gradient boosted trees and, in particular, their implementation in the XGBoost library [6]. Gradient boosted trees are ensembles of decision trees trained by tree boosting.

The format of the training and evaluation data used by XGBoost is the same as the input used by LIBLINEAR (sparse feature vectors). Hence, we use practically the same approach for obtaining the positive and negative training examples, extracting their features, and clause evaluation during proof runs as described in Sections 3.1 and 3.2. XGBoost, however, does not require the accuracy-balancing boosting. This is because XGBoost can deal with unbalanced training data by setting the ratio of positive and negative examples.111We use the XGBoost parameter scale_pos_weight.

The model $\mathcal{M}$ produced by XGBoost consists of a set (ensemble [31]) of decision trees. The inner nodes of the decision trees consist of conditions on feature values, while the leafs contain numeric scores. Given a vector $\varphi_{C}$ representing a clause $C$, each tree in $\mathcal{M}$ is navigated to a unique leaf using the values from $\varphi_{C}$, and the corresponding leaf scores are aggregated across all trees. The final score is translated to yield the probability that $\varphi_{C}$ represents a positive clause. When using $\mathcal{M}$ as a weight function in E, the probabilities are turned into binary classification, assigning weight $1.0$ for probabilities $\geq 0.5$ and weight $10.0$ otherwise. Our experiments with scaling of the weight by the probability did not yet yield improved functionality.

3.4 Feature Hashing

The vectors representing clauses have so far had length $n$ when $n$ is the total number of features in the training data $\mathcal{T}$ (or $2n$ with conjecture features). Experiments revealed that both LIBLINEAR and XGBoost are capable of dealing with vectors up to the length of $10^{5}$ with a reasonable performance. This might be enough for smaller benchmarks but with the need to train on bigger training data, we might need to handle much larger feature sets. In experiments with the whole translated Mizar Mathematical Library, the feature vector length can easily grow over $10^{6}$. This significantly increases both the training and the clause evaluation times. To handle such larger data sets, we have implemented a simple hashing method to decrease the dimension of the vectors.

Instead of serially numbering all features, we represent each feature $f$ by a unique string and apply a general-purpose string hashing function to obtain a number $n_{f}$ within a required range (between 0 and an adjustable hash base). The value of $f$ is then stored in the feature vector at the position $n_{f}$. If different features get mapped to the same vector index, the corresponding values are summed up.

We use the following hashing function $\mathit{sdbm}$ coming from the open source SDBM project. Given a string $s$, the value $h_{i}$ is computed for every character as follows:

[TABLE]

where $h_{0}=0$, $s_{i}$ is the ASCII code of the character at the $i$-th position, and the operation $\ll$ stands for a bit shift. The value for the last character is computed with a fixed-size data type (we use 64-bit unsigned integers) and this value modulo the selected hash base is returned. We evaluate the effect of the selected hashing function later in Section 5.

4 Neural Architecture for ATP Guidance

Although the handcrafted clause features, described in Section 3.1, lead to very good results, they have naturally several limitations. It is never clear whether the selected set of features is the best available given the training data. Moreover, a rich set of features can easily lead to long sparse vectors and thus using them for large corpora requires the use of dimensionality reduction techniques (c.f. Section 3.4). Hence selecting the features automatically is a natural further step.

Among various techniques used to extract features fully automatically, neural networks (NN) have recently become the most popular thanks to many successful applications in, e.g., computer vision and natural language processing. There have been several attempts to use NNs for guiding ATPs. However, such attempts have so far typically suffered from a large overhead needed to evaluate the used NN [26], making them impractical for actual proving.

A popular approach for representing tree-structured data, like logical formulae, is based on recursive NNs [36]. The basic idea is that all objects (tree nodes, subterms, subformulas) are represented in a high dimensional vector space and these representations are subject to learning. Moreover, the representation of more complex objects is a function of representations of their arguments. Hence constants, variables, and atomic predicates are represented as directly learned vectors, called vector embeddings. Assume that all such objects are represented by $n$-dimensional vectors. For example, constants $a$ and $b$ are represented by learned vectors $v_{a}$ and $v_{b}$, respectively. The representation of $f(a,b)$ is then produced by a learned function (NN), say $v_{f}$, that has as an input two vectors and returns a vector; hence $v_{f}(v_{a},v_{b})\in\mathbf{R}^{n}$. Moreover, the representation of $P(f(a,b),a)$ is obtained similarly, because from our point of view a representation is just a function of arguments. Therefore we have

[TABLE]

in our language. Similarly to ENIGMA, and to make the comparison better and the model simpler, we also do not distinguish different variable and Skolem names, e.g., all variables are represented by one vector. We also replace symbols that appear rarely in our training set by a representative, e.g., all rare binary functions become the same binary function. Loosely speaking, we learn a general binary function this way. Because we treat equality and negation as learned predicates, we have described how a representation of a literal is produced.

We could now produce the representation of clauses by assuming that disjunction is a binary connective, however, we instead use a more direct approach and we treat clauses directly as sequences of literals. Recurrent neural networks (RNN) are commonly used to process arbitrary sequences of vectors. Hence we train an RNN, called $\mathit{Cl}$, that consumes the representations of literals in a clause and produces the representation of the clause, $\mathit{Cl}\colon\mathbf{R}^{n}\times\dots\times\mathbf{R}^{n}\to\mathbf{R}^{n}$.

Given a representation of a clause we could learn a function that says whether the clause is a good given clause. However, without any context this may be hard to decide. As in ENIGMA and [26], we introduce more context into our setting by using the problem’s conjecture. The negated conjecture is translated by E into a set of clauses. We combine the vector representations of these clauses by another RNN, called $\mathit{Conj}$ and defined by $\mathit{Conj}\colon\mathbf{R}^{n}\times\dots\times\mathbf{R}^{n}\to\mathbf{R}^{n}$.

Now we know how to represent a conjecture, by a vector, and a given clause, by a vector. Hence we can define a function that combines them into a decision, called $\mathit{Fin}$ and defined by $\mathit{Fin}\colon\mathbf{R}^{n}\times\mathbf{R}^{n}\to\mathbf{R}^{2}$. Note that binary classifications are commonly represented by functions into $\mathbf{R}^{2}$, see Section 4.2.

Although all the representations have been vectors in $\mathbf{R}^{n}$, this is an unnecessary restriction. It suffices if the objects of the same type are represented by vectors of the same length. For example, we have experimented with $\mathit{Conj}$ where outputs are shorter (and inputs to $\mathit{Fin}$ are changed accordingly) with the aim to decrease overfitting to a particular problem.

4.1 Neural Model Parameters

The above mentioned neural model can be implemented in many ways. Although we have not performed an extensive grid search over various variants, we can discuss some of them shortly. The basic parameter is the dimension $n$ of the vectors. We have tried various models with $n\in\{8,16,32,64,128\}$. The functions used for $v_{f}$ and $v_{P}$ can be simple linear transformations (tensors), or more complex combinations of linear and nonlinear layers. An example of a frequently used nonlinearity is the rectified linear unit (ReLU), defined by $\max(0,x)$.222Due to various numerical problems with deep recursive networks we have obtained better results with ReLU6, defined by $\min(\max(0,x),6)$, or $\tanh$.

For $\mathit{Cl}$ and $\mathit{Conj}$ we use (multi-layer) long short-term memory (LSTM) RNNs [13]. We have tried to restrict the output vector of $\mathit{Conj}$ to $m={n\over 2}$ or $m={n\over 4}$ to prevent overfitting with inconclusive results. The $\mathit{Fin}$ component is a sequence of alternating linear and nonlinear layers (ReLU), where the last two linear layers are $\mathbf{R}^{n+m}\to\mathbf{R}^{n\over 2}$ and $\mathbf{R}^{n\over 2}\to\mathbf{R}^{2}$.

4.2 ATP Guidance with Pytorch

We have created our neural model using the Pytorch library and integrated it with E using the library’s C++ API.333https://pytorch.org/cppdocs/ This API allows to load a previously trained model saved to a file in a special TorchScript format. We use a separate file for each of the neural parts described above. This includes computing of the vector embeddings of terms, literals, and clauses, as well as the conjecture embedding $\mathit{Conj}$ summarizing the conjecture clauses into one vector, and finally the part $\mathit{Fin}$, which classifies clauses into those deemed useful for proving the given conjecture and the rest.

We have created a new clause weight function in E called TorchEval which interfaces these parts and can be used for evaluating clauses based on the neural model. One of the key features of the interface, which is important for ensuring reasonable evaluation speed, is caching of the embeddings of terms and literals. Whenever the evaluation encounters a term or a literal which was evaluated before, its embedding is simply retrieved from the memory in constant time instead of being computed from the embeddings of its subterms recursively. We use the fact that terms in E are perfectly shared and thus a pointer to a particular term can be used as a key for retrieving the corresponding embedding. Note that this pervasive caching is possible thanks to our choice of recursive neural networks (that match our symbolic data) and it would not work with naive use of other neural models such as convolutional or recurrent networks without their further modifications.

The clause evaluation part of the model returns two real outputs $x_{0}$ and $x_{1}$, which can be turned into a probability that the given clause will be useful using the sigmoid (logistic) function:

[TABLE]

However, for classification, i.e. for a yes-no answer, we can just compare the two numbers and “say yes” whenever

[TABLE]

After experimenting with other schemes that did not perform so well,444For instance, using the probability (1) for a more fine-grained order on clauses dictated by the neural model. we made TorchEval return $1.0$ whenever condition (2) is satisfied and $10.0$ otherwise. This is in accord with the standard convention employed by E that clauses with smaller weight should be preferred and also corresponds to the ENIGMA approach. Moreover, E implicitly uses an ever increasing clause id as a tie breaker, so among the clauses within the same class, both TorchEval and ENIGMA behave as FIFO.

Another performance improvement was obtained by forcing Pytorch to use just a single core when evaluating the model in E. The default Pytorch setting was causing degradation of performance on machines with many cores, probably by assuming by default that multi-threading will speed up frequent numeric operations such as matrix multiplication. It seems that in our case, the overhead for multi-threading at this point may be higher than the gain.

5 Experimental Evaluation

We experimentally evaluate the three learning-based ATP guidance methods on the MPTP2078 benchmark [1]. MPTP2078 contains 2078 problems coming from the MPTP translation [37] of the Mizar Mathematical Library (MML) [3] to FOL. The consistent use of symbol names across the MPTP corpus is crucial for our symbol-based learning methods. We evaluate ATP performance with a good-performing baseline E strategy, denoted $\mathcal{S}$, which was previously optimized [17] on Mizar problems (see Appendix 0.A for details).

Section 5.1 provides details on model training and the hyperparameters used, and analyzes the most important features used by the tree model. The model based on linear regression (Section 3.2) is denoted $\mathcal{M}_{\textrm{lin}}$, the model based on decision trees (Section 3.3) is denoted $\mathcal{M}_{\textrm{tree}}$, and the neural model (Section 4) is denoted $\mathcal{M}_{\textrm{nn}}$. Sections 5.2 and 5.3 evaluate the performance of the models both by standard machine learning metrics and by plugging them into the ATPs. Section 5.4 evaluates the effect of the feature hashing described in Section 3.4.

All experiments were run on a server with 36 hyperthreading Intel(R) Xeon(R) Gold 6140 CPU @ 2.30GHz cores, with 755 GB of memory available in total. Each problem is always assigned one core. For training of the neural models we used NVIDIA GeForce GTX 1080 Ti GPUs. As described above, neither GPU nor multi-threading is, however, employed when using the trained models for clause evaluation inside the ATP.

5.1 Model Training, Hyperparameters and Feature Analysis

We evaluate the baseline strategy $\mathcal{S}$ on all the 2078 benchmark problems with a fixed CPU time limit of 10 seconds per problem. This yields 1086 solved problems and provides the training data for the learning methods as described in Section 2. For $\mathcal{M}_{\textrm{lin}}$ and $\mathcal{M}_{\textrm{tree}}$, the training data are translated to feature vectors (see Section 3) which are then fed to the learner. For $\mathcal{M}_{\textrm{nn}}$ we use the training data directly without any feature extraction.

5.1.1 Training Data and Training of Linear and Tree Models:

The training data consists of around 222000 training samples (21000 positives and 201000 negatives) with almost 32000 different ENIGMA features. This means that the training vectors for $\mathcal{M}_{\textrm{lin}}$ and $\mathcal{M}_{\textrm{tree}}$ have dimension close to 64000, and so has the output weight vector of $\mathcal{M}_{\textrm{lin}}$. For $\mathcal{M}_{\textrm{tree}}$, we re-use the parameters that performed well in the ATPBoost [30] and rlCoP [21] systems and produce models with 200 decision trees, each with maximal depth 9. The resulting models—both linear and boosted trees—are about 1MB large. The training time for $\mathcal{M}_{\textrm{lin}}$ is around 8 minutes (five iterations of accuracy-balancing boosting), and approximately 5 minutes for $\mathcal{M}_{\textrm{tree}}$. Both of them are measured on a single CPU core. During the boosting of $\mathcal{M}_{\textrm{lin}}$, the positive samples are extended from 21k to 110k by repeating the mis-classified vectors.

5.1.2 Learned Tree Features:

The boosted tree model $\mathcal{M}_{\textrm{tree}}$ allows computing statistics of the most frequently used features. This is an interesting aspect that goes in the direction of explainable AI. The most important features can be analyzed by ATP developers and compared with the ideas used in standard clause evaluation heuristics. There are 200 trees in $\mathcal{M}_{\textrm{tree}}$ with 20215 decision nodes in total. These decision nodes refer to only 3198 features out of the total 32000. The most frequently used feature is the clause length, used 3051 times, followed by the conjecture length, used 893 times, and by the numbers of the positive and negative literals in the clauses and conjectures. In a crude way, the machine learning here seems to confirm the importance assigned to these basic metrics by ATP researchers. The set of top ten features additionally contains three symbol counts (including “$\in$” and “$\subseteq$”) and a vertical feature corresponding to a variable occurring under negated set membership $\in$ (like in “$x\not\in\cdot$” or “$\cdot\not\in x$”). This seems plausible, since the Mizar library and thus MPTP2078 are based on set theory where membership and inclusion are the key concepts.

5.1.3 Neural Training and Final Neural Parameters:

We try to improve the training of $\mathcal{M}_{\textrm{nn}}$ by randomly changing the order of clauses in conjectures, literals in clauses, and terms in equalities. If after these transformations a negative example, a pair $(C,G)$, is equivalent to a positive example, we remove the negative one from the training set. This way we reduce the number of negative examples to 198k. We train our model in batches555Moreover, we concentrate the examples with the same $G$ into the same batch to reduce the training time, because the representation of $G$ has to be recomputed for every batch. of size 128 and use the negative log-likelihood as a loss function (the learning rate is $10^{-3}$), where we apply log-softmax on the output of $\mathit{Fin}$. We weight positive examples more to simulate a balanced training set. All symbols of the same type and arity that have less than 10 occurrences in the training set are represented by one symbol. We set the vector dimension to be $n=64$ for the neural model $\mathcal{M}_{\textrm{nn}}$ and we set the output of $\mathit{Conj}$ to be $m=16$. All the functions representing function symbols and predicates are composed of a linear layer and ReLU6. $\mathit{Fin}$ is set to be a sequence of linear, ReLU, linear, ReLU, and linear layers. The training time for $\mathcal{M}_{\textrm{nn}}$ is around 6 minutes per epoch and the model was trained for 50 epochs.

5.2 Evaluation of the Model Performance

5.2.1 Training Performance of the Models:

We first evaluate how well the individual models managed to learn the training data. Due to possible overfitting, this is obviously only used as a heuristic and the main metric is provided by the ultimate ATP evaluation. Table 1 shows for each model the true positive and true negative rates (TPR, TNR) on the training data, that is, the percentage of the positive and negative examples, classified correctly by each model.666For $\mathcal{M}_{\textrm{lin}}$, we show the numbers after five iterations of the boosting loop (see Section 3.2). The values in the first round were $40.81\text{\,}\mathrm{\char 37\relax}$ for the positive and $98.62\text{\,}\mathrm{\char 37\relax}$ for the negative rate. We can see that the highest TPR, also called sensitivity, is achieved by $\mathcal{M}_{\textrm{tree}}$ while the highest TNR, also specificity, by $\mathcal{M}_{\textrm{nn}}$. As expected, the accuracy of the linear model is lower. Its main strength seems to come from the relatively high speed of evaluation (see below).

5.2.2 ATP Performance of the Models:

Table 2 shows the total number of problems solved by the four methods. For each learning-based model $\mathcal{M}$, we always consider the model alone ($\mathcal{S}\odot\mathcal{M}$) and the model combined equally with $\mathcal{S}$ ($\mathcal{S}\oplus\mathcal{M}$). All methods are using the same time limit, i.e., 10 seconds. This is our ultimate “real-life” evaluation, confirming that the boosted trees indeed outperform the guidance by the linear classifier and that the recursive neural network and its caching implementation is already competitive with these methods in real time. The best method $\mathcal{S}\oplus\mathcal{M}_{\textrm{tree}}$ solves $15.7\text{\,}\mathrm{\char 37\relax}$ more problems than the original strategy $\mathcal{S}$, and $3.8\text{\,}\mathrm{\char 37\relax}$ problems more than the previously best linear strategy $\mathcal{S}\oplus\mathcal{M}_{\textrm{lin}}$.777We have also measured how much $\mathcal{S}$ benefits from increased time limits. It solves 1099 problems in $20\text{\,}\mathrm{s}$ and 1137 problems in $300\text{\,}\mathrm{s}$. Table 2 provides also further explanation of these aggregated numbers. We show the number of unique solutions provided by each of the methods and the difference to the original strategy. Table 3 shows how useful are the particular methods when used together. Both the linear and the neural models complement the boosted trees well, while the original strategy is made completely redundant.

5.2.3 Testing Performance of the Models on Newly Solved Problems:

There are 232 problems newly solved—some of them multiple times—by the six learning-based methods. To see how the trained models behave on new data, we again extract positive and negative examples from all successful proof runs on these problems. This results in around $31\,000$ positive testing examples and around $300\,000$ negative testing examples.

Table 4 shows again for each of the previously trained models the true positive and true negative rates (TPR, TNR) on these testing data. The highest TPR is again achieved by $\mathcal{M}_{\textrm{tree}}$ and the highest TNR by $\mathcal{M}_{\textrm{nn}}$. The accuracy of the linear model is again lower. Both the TPR and TNR testing scores are for all methods significantly lower compared to their training counterparts. TPR decreases by about $15\text{\,}\mathrm{\char 37\relax}$ and TNR by about $20\text{\,}\mathrm{\char 37\relax}$. This likely shows the limits of our current learning and proof-state characterization methods. It also points to the very interesting issue of obtaining many alternative proofs [24] and learning from them. It seems that just using learning or reasoning is not sufficient in our AI domain, and feedback loops combining the two multiple times [39, 30] are really necessary for building strong ATP systems.

5.3 Speed of Clause Evaluation by the Learned Models

The number of generated clauses reported by E can be used as a rough estimate of the amount of work done by the prover. If we compare this statistic for those runs that timed out—i.e., did not find a proof within the given time limit—we can use it to estimate the slowdown of the clause processing rate incurred by employing a machine learner inside E. (Note that each generated clause needs to be evaluated before it is inserted on the respective queue.)

Complementarily, the number of processed clauses compared across the problems on which all runs succeeded may be seen as an indicator of how well the respective clause selection guides the search towards a proof (with a perfect guidance, we only ever process those clauses which constitute a proof).888This metric is similar in spirit to given clause utilization introduced by Schulz and Möhrmann [35].

Table 5 compares the individual configurations of E based on the seven evaluated models with respect to these two metrics. To obtain the shown values, we first normalized the numbers on per problem basis with respect to the result of the baseline strategy $\mathcal{S}$ and computed an average across all relevant problems. The comparison of thus obtained All Solved Relative Processed Average (ASRPA) values shows that, with the exception of $\mathcal{S}\odot\mathcal{M}_{\textrm{lin}}$ (which has a very high standard deviation), all other configurations on average manage to improve over $\mathcal{S}$ and find the corresponding proofs with fewer iterations of the given clause loop. This indicates better guidance towards the proof on the selected benchmarks.

The None Solved Relative Generated Average (NSRGA) values represent the speed of the clause evaluation. It can be seen that while the linear model is relatively fast (approximately $60\text{\,}\mathrm{\char 37\relax}$ of the speed of $\mathcal{S}$), followed closely by the tree-based model (around $40\text{\,}\mathrm{\char 37\relax}$), the neural model is more expensive to evaluate (achieving between $6$ and $7\text{\,}\mathrm{\char 37\relax}$ of $\mathcal{S}$).

We note that without caching, NSRGA of $\mathcal{S}\oplus\mathcal{M}_{\textrm{nn}}$ drops from $7.1$ to $3.6\text{\,}\mathrm{\char 37\relax}$ of the speed of $\mathcal{S}$. Thus caching currently helps to approximately double the speed of the evaluation of clauses with $\mathcal{M}_{\textrm{nn}}$.999Note that more global caching (of e.g. whole clauses and frequent combinations of literals) across multiple problems may further amortize the cost of the neural evaluation. This is left as future work here. It is interesting and encouraging that despite the neural method being currently about ten times slower than the linear method—and thus generating about ten times fewer inferences within the $10\text{\,}\mathrm{s}$ time limit used for the ATP evaluation (Table 2)—the neural model already manages to outperform the linear model in the unassisted setting. I.e., $\mathcal{S}\odot\mathcal{M}_{\textrm{nn}}$ is already better than $\mathcal{S}\odot\mathcal{M}_{\textrm{lin}}$, despite the latter being much faster.

5.4 Evaluation of Feature Hashing

Finally, we evaluate the feature hashing described in Section 3.4. We try different hash bases in order to reduce dimensionality of the vectors and to estimate the influence on the ATP performance. We evaluate on 6 hash bases from 32k ($2^{15}$), 16k ($2^{14}$), down to 1k ($2^{10}$). For each hash base, we construct models $\mathcal{M}_{\textrm{lin}}$ and $\mathcal{M}_{\textrm{tree}}$, we compute their prediction rates, and evaluate their ATP performance.

With the hash base $n$, each feature must fall into one of $n$ buckets. When the number of features is greater than the base—which is our case as we intend to use hashing for dimensionality reduction—collisions are inevitable. When using hash base of 32000 (ca $2^{15}$) there are almost as many hashing buckets as there are features in the training data (31675). Out of these features, ca 12000 features are hashed without a collision and 12000 buckets are unoccupied. This yields a $40\text{\,}\mathrm{\char 37\relax}$ probability of a collision. With lower bases, the collisions are evenly distributed.

Lower hash bases lead to larger loss of information, hence decreased performance can be expected. On the other hand, dimensionality reduction sometimes leads to better generalization (less overfitting of the learners). Also, the evaluation in the ATP can be done more efficiently in a lower dimension, thus giving the ATP the chance to process more clauses. The prediction rates and ATP performance for models with and without hashing are presented in Table 6. We compute the true positive (TPR) and negative (TNR) rates as in Section 5.1, and we again evaluate E’s performance based on the strategy $\mathcal{S}$ in the two ways ($\odot$ and $\oplus$) as in Section 5.2. The best value in each row is highlighted. Both models perform comparably to the version without hashing even when the vector dimension is reduced to $25\text{\,}\mathrm{\char 37\relax}$. With reduction to 1000 (32x), the models still provide a decent improvement over the baseline strategy $\mathcal{S}$. The $\mathcal{M}_{\textrm{tree}}$ model deals with the reduction slightly better.

Interestingly, the classification accuracy of the models (again, measured only on the training data) seems to increase with the decrease of hash base (especially for $\mathcal{M}_{\textrm{tree}}$). However, with this increased accuracy, the ATP performance mildly decreases. This could be caused by the more frequent collisions and thus learning on data that have been made less precise.

6 Conclusions and Future Work

We have described an efficient implementation of gradient-boosted and recursive neural guidance in E, extending the ENIGMA framework. The tree-based models improve on the previously used linear classifier, while the neural methods have been for the first time shown practically competitive and useful, by using extensive caching corresponding to the term sharing implemented in E. While this is clearly not the last word in this area, we believe that this is the first practically convincing application of gradient-boosted and neural clause guidance in saturation-style automated theorem provers.

There are a number of future directions. For example, research in better proof state characterization of saturation-style systems has been started recently [10, 11] and it is likely that evolving vectorial representations of the proof state will further contribute to the quality of the learning-based guidance. Our recursive neural model is just one of many, and a number of related and combined models can be experimented with.

Appendix 0.A Strategy $\mathcal{S}$ from Experiments in Section 5

The following E strategy has been used to undertake the experimental evaluation in Section 5. The given clause selection strategy (heuristic) is defined using parameter “-H”.

--definitional-cnf=24 --split-aggressive --simul-paramod -tKBO6 -c1 -F1 -Ginvfreq -winvfreqrank --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -WSelectMaxLComplexAvoidPosPred -H’(1ConjectureTermPrefixWeight(DeferSOS,1,3,0.1,5,0,0.1,1,4), 1ConjectureTermPrefixWeight(DeferSOS,1,3,0.5,100,0,0.2,0.2,4), 1Refinedweight(ConstPrio,4,300,4,4,0.7), 1RelevanceLevelWeight2(PreferProcessed,0,1,2,1,1,1,200,200,2.5, 9999.9,9999.9), 1StaggeredWeight(DeferSOS,1), 1SymbolTypeweight(DeferSOS,18,7,-2,5,9999.9,2,1.5), 2Clauseweight(ConstPrio,20,9999,4), 2ConjectureSymbolWeight(DeferSOS,9999,20,50,-1,50,3,3,0.5), 2*StaggeredWeight(DeferSOS,2))’