Interpretable Proof Generation via Iterative Backward Reasoning

We first formulate the proof generation task as follows. Given a tuple $(C,Q,A,P)$, where $C=\{RF_{i}\}$ is the contexts containing several textual rules and facts $RF$, $Q$ is the question, $A\in\{$True, False$\}$ is the answer, and $P$ indicates the proof path for the detailed reasoning procedure to derive $A$, our goal is twofold: 1) predicting the answer $A$, and 2) generating the proof path $P$. Taking DU0-DU5 Clark et al. (2020) dataset as example, $P$ is a single-directed acyclic graph having the shortest path to derive $A$. $P$ can start from one or multiple nodes but must end in one node that directly entails or contradicts $Q$. A node in $P$ can be a fact, a rule, or a special NAF (Negation As Failure) node¹¹1A start node when the negation condition in the next node has no corresponding fact nor rule node, and the negation will be considered as true. E.g., there is no item in $C$ related to “Anne is big”, its negation “Anne is not big” will be considered as true.. Edges between nodes indicate that the start nodes can be used to prove the end nodes during reasoning. Proofs in the dataset can be roughly classified into two types according to their strategies $S$ to prove the question: (1)Proof: the question can be directly proven to be True or False using the given $C$ and NAF; (2) Fail-Proof: the question cannot be explicitly deduced barely using $C$ and NAF as some key information is missed, hence a positive statement is judged as False while a negative statement as True in such cases (Figure 2).

The proposed Iterative Backward Reasoning (IBR) model takes $Q$ as the initial node and produce a proof path $P$ backward, from the end node to the start node. Two actions are included at each iteration: (1) Predicting the new parent node, i.e. a node in the derived proof path where a child node will be added (except the first step that only $Q$ exists); (2) Predicting the child node, i.e. the fact or rule in $C$ that will be the child for the selected parent node. After each iteration, a new node and an associated edge are added. After obtaining the whole reasoning path, we remove $Q$ and reverse all edges to get the final proof $P$.

The Figure 3 illustrates our IBR model, which can be divided into three modules, (1) QA and Strategy Prediction, (2) Parent Node Prediction, and (3) Child Node Prediction. In order to make the question $Q$ can fully interact with context $C$ (facts and rules) and obtain better representations, IBR uses pretrained RoBERTa Liu et al. (2019) as the backbone network. The input of RoBERTa is the concatenation of the question $Q$ and the context $C=\{RF_{i}\}$, separated by special $[SEP]$ token, denoted as $[CLS]\ Q\ [SEP]\ [SEP]\ C\ [SEP]$.

IBR only uses the QA prediction and strategy prediction modules once at first to predict the answer $A$ and the strategy of the proof (refer to §3.1, where the latter one will result in different proof generation procedures. In order to improve the reasoning efficiency as well as accuracy, instead of using generated intermediate texts Liang et al. (2021); Tafjord et al. (2021), all possible nodes (rules and facts) are represented by node embeddings in IBR. The initial state of the proof is only the representation of the question $h_{Q}$, then the rest of the reasoning path will be constructed based on it.

Samples with Fail-Proof strategy differs from ones with Proof, because their proofs are usually short without sub-branches, and only consist of rules due to lacking essential supporting facts. To take the advantage of such a property distinction and extend the applicability compared to former models Liang et al. (2021) that cannot generate proofs for Fail-Proof samples, we apply different actions in modules (2) and (3) depending on the output from strategy prediction.

This module aims to predict the answer $A$ of the question $Q$ and the corresponding strategy $S$ of proof $P$. Since the representation of $[CLS]$ token from pretrained models is proven to have the capability of modeling the whole input, we use it as the input feature for both predictions as they condition the global information. The encoded $[CLS]$ by RoBERTa, $h_{[CLS]}$ is passed to a linear layer and the softmax function $\sigma$ for answer and strategy classification respectively,

$P_{QA}$= $\sigma$($f_{QA}$($h_{[CLS]}$)),

$P_{Strategy}$ = $\sigma$($f_{Strategy}$($h_{[CLS]}$)).

Here, $f_{QA}$ and $f_{Strategy}$ indicate the linear layer for QA classification and strategy classification, respectively. $P_{QA}$ and $P_{Strategy}$ are binary-class probability values, the former one is for values of $A\in\{True,False\}$ while the later one is for values of $S\in\{$Proof, Fail-proof$\}$.

This module determines which node in the current reasoning path is going to be the next parent node that a new child node will link to. To better represent the sequential information of each possible node (fact or rule), an LSTM Hochreiter and Schmidhuber (1997) is used to further encode the token-level embedding from RoBERTa. The hidden state in the last step is used as the textual representation $h_{gi}$ of a possible parent node $RF_{i}$.

In addition, selecting a node from the existing proof path also needs global and structural modeling on the history path. To make this procedure a more convenient representation that involves the order of reasoning, the path is regarded as a tree structure and nodes are reordered by level traversal from top to down. Since $Q$ is always the root node of the tree, e.g., if $Q$ have two children $RF_{1}$ and $RF_{3}$, and $RF_{1}$ has a child $RF_{2}$, the reordered representation sequence is $[h_{Q},h_{g1},h_{g3},h_{g2}]$. We then utilize another LSTM model to encode the reordered representation sequence of the current reasoning path obtained before, extracting the overall state of the path, which is the hidden state $h_{g}$ at the last time step in this LSTM.

A parent node attention based on the Transformer attention Vaswani et al. (2017) is used to obtain the weights of all possible parents nodes. It takes $h_{g}$ and the representation sequence of the current path $\mathbf{H}_{p}=[h_{Q},h_{g1}\ldots h_{gt}]$ as input, i.e.

$${\rm Att}(h_{g},\mathbf{H}_{p})=\sigma(f_{Q}(h_{g})(f_{K}(\mathbf{H}_{p}))^{T}/\sqrt{d}),$$

(1)

where $f_{Q}$ and $f_{K}$ indicate linear layers, $\sigma$ is a softmax function, and $d$ is the dimension of $h_{g}$. As we discussed in §3.2, different operations are employed for corresponding strategy types of proofs. 1) If the predicted proof strategy is Proof, we select the node with the highest weight as the parent node $RF_{p}$. 2) If the predicted proof strategy is Fail-proof, we use the last node in the current path, i.e. $h_{gt}$ in $\mathbf{H}_{P}$, as the parent node $RF_{p}$, because no sub-branch is included in such proof paths.

This module decides which node will be added to the proof path and linked to the parent node $RF_{p}$ we have obtained before. To derive the representations of candidate child nodes, similar to §3.4, we apply another LSTM model to the encoded RoBERTa embeddings and get $h_{n_{i}}$ for $RF_{i}$. Since we discussed a special NAF node in §3.1 which may contain information from the whole context, we utilize a linear layer $f_{NAF}$ to transform the $[CLS]$ token embedding $h_{[CLS]}$ into its representation $h_{NAF}$. Moreover, we initialize a representation $h_{END}$ for the special END node, indicating that the proof generation process will finish here.

During selecting the new child node, we need to consider not only the knowledge of the history path, but also the state of the parent node. To better model such relationships, we propose a Path Focus Selection module to generate relevant features before predicting the child node. A 2-layer Transformer model along with a LSTM model is introduced. It first encodes the representations of node sequence $\mathbf{H}_{p}$ from Parent Node Prediction respectively, then fuses their hidden state via a linear layer $f_{U}$,

$$h_{F}=f_{U}([{\rm Trans}(h_{gp},\mathbf{H}_{p},\mathbf{H}_{p});{\rm LSTM}(\mathbf{H}_{p})]).$$

(2)

Here, $h_{gp}$ is the representation of the selected parent node in §3.4, $f_{U}$ is the linear layer for feature fusing, while $[\cdot;\cdot]$ stands for concatenation. $q,k,v$ in ${\rm Trans}(q,k,v)$ indicate the inputs corresponding to Query, Key, and Value in a transformer model, and only the hidden state in the last time step is remained in both ${\rm Trans}$ and ${\rm LSTM}$. It is worth noting that the LSTM used here is a supplementary knowledge source for a better representation according to our empirical study. Such an operation results in a feature $h_{F}$ that is aware of both the history proof path and the parent node that a child will link to.

This feature $h_{F}$ will then be used in the Child Node Attention to calculate the attention weights on all possible child nodes. Particularly, an attention model same as Eq. 1 is applied on $h_{F}$ and a series of child node representations obtained before $\mathbf{H}_{c}=[h_{n1}\ldots h_{nk},h_{NAF},h_{END}]$, and the attention weights are defined as ${\rm Att}(h_{F},\mathbf{H}_{c})$. It contains all facts and rules in the context, and the special NAF node as well as END node.

Similar to §3.4, we also apply different actions according to our predicted proof strategies before.

The whole model is trained via binary cross-entropy losses from all three above modules jointly,

$L=L_{QA}+L_{Parent}+L_{Child}+\alpha*L_{Strategy}$.

$L_{QA}$ and $L_{Strategy}$ correspond to the loss of QA prediction and strategy prediction, respectively. $\alpha$ is a hyperparameter to reweigh the influence of [CLS] token. $L_{Parent}$ is the loss for parent node prediction, where the cross-entropy is calculated between the attention weight vector and a one-hot vector indicating the gold parent node. $L_{Child}$ is in a similar way on child node prediction. Note that samples labeled as Fail-proof strategy are not involved in the training of parent node prediction. As all their proof paths are chains and the new parent node is always the last node added to the path, so learning about these data may introduce model bias. To determine the gold reasoning order used as the target for training, we set a higher priority of fact nodes than rule nodes, as the clearer subject information is involved in facts. E.g., for a parent node with multiple children, the gold reasoning order of child node prediction is NAF nodes first, then fact nodes, and finally rule nodes. If there are more than one fact or rule nodes, IBR randomly swaps their order within each type at different training epochs.

During inference, IBR first makes predictions on the answer $A$ and strategy $S$, then generate the parent node and child node iteratively, until the special END node is predicted as the new child node. IBR uses beam search to keep the top-K best proof paths at each proof generation step and select the best one as the final prediction, where the beam size is set as 8.

We train IBR on the training split of the DU5 dataset and evaluate on the test split of DU5. We compare the performance of IBR with baselines except for EVR in Table 1, while with EVR in Table 2 where only partial test split is included, excluding samples whose proof strategy is Fail-proof. Because EVR always fails on these samples (EVR on these excluded samples is given in Appendix A.5).

Obviously, IBR achieves the best proof generation accuracy (PA) as well as full accuracy (FA) among all baseline models, on samples with every depth. Our model also shows a greater advantage on samples with deeper proof path, e.g., 81.7 vs. 72.2 on PA when depth is 5, illustrating the superiority of iterative models on complex proof paths. Besides, despite not being the best in answer accuracy (QA), there is a very narrow gap between our model and the best one, which proves that IBR is still a comprehensive model covering both subtasks. When compared to EVR, also an iterative model, IBR shows significantly stronger performance on all metrics, benefiting from our elaborate two-fold reasoning process at each step.

We also explore the performance of IBR when training using fewer data, ranging from 10k to 30k to all the examples (70k) in DU5. The comparison between our model, PROVER (PV), and PROBR (PB) is shown in Table 3, in all three metrics. Our model significantly has the best proof generation performance than the other two baselines in all cases, due to the iterative architecture requiring less global modeling capability and thus fewer training samples. Although PB shows a promising answer prediction accuracy under fewer-data settings, the performance of IBR is close to it while better than PV, e.g., 94.3 vs. 87.1 under 10k. In addition, in Table 4, we also compare with EVR under the same settings but using a different test set that excludes Fail-proof samples. EVR outperforms IBR under the 10k setting for proof generation, but IBR is stronger if more training samples are available.

We further test the out-of-domain performance of IBR against baselines on Birds-Electricity dataset to evaluate their robustness, where B1 and B2 are two sets from the birds domain, and E1-E4 are four sets from the electricity domain. Results are shown in Table 5 and Table 6. Note that Fail-proof samples are still not involved in the comparison for EVR. Overall, our IBR achieves 2.5% promotion in PA while an equivalent result on QA, compared to PROVER. Despite being the best one on QA, PROBR is also defeated by IBR on both PA and FA. In addition, our model shows more improvement on the hardest E3 and E4 subsets, which further verifies its robustness. When it comes to EVR, we can find its cross-domain capability is relatively weak as it sees a significant drop in PA, and IBR is superior to it without any doubt. Because the cross-domain generation for intermediate texts is much harder, our usage of high-level node features to finished reasoning can alleviate this challenge.

Generalize to higher depths. Following the previous work (Sun et al., 2021), we test the generalization ability of IBR by first training the model on the training splits of DU0, DU1, DU2, and DU3, then test them on the test split of DU5 with deeper proof paths respectively⁵⁵5We remove the position embedding in path focus selection to proceed to this test, see Appedix A.1 for details. Results are shown in Table 7. We notice that all models suffer performance degeneration especially when the proof depth of the training set is lower, because it is hard for the model to learn complex reasoning based on simple proof paths. However, IBR still realizes the best performance in terms of PA and FA, especially on DU3, where it gets 4.2% PA/FA promotion to PROBR and even outperforms PROVER trained on the whole DU5 data. These observations again prove that iterative approaches can better learn the detailed reasoning step by step, obtaining a better generalization capability than at-once models.

To explore the effects between different components in our model, we consider the following ablations: 1) IBR +Gold-Parent: given the gold parent nodes during inference to explore the accuracy of child node prediction; 2) IBR +Gold-Child: given the gold child nodes to verify the accuracy of parent node prediction; 3) w/o QA: removing QA task in loss to check its impact on proof generation; 4) w/o node LSTM: using mean pooling rather than LSTM encoding to get the representations of nodes; 5) w/o focus LSTM: Removing the supplementary LSTM in path focus selection.

Results on the whole DU5 test split are given in Table 9. As the numeric performance shows, giving either gold parent nodes or gold child nodes can benefit the performance especially the later one. This signifies that our parent node prediction achieves promising accuracy while the prediction of child nodes can be further improved. Moreover, IBR can still learn to generate proofs without supervision from answers. And LSTM encoders attribute to a better representation of both the nodes and the path that has been derived.

To demonstrate the computational efficiency of IBR, we compare the per sample inference time of IBR with EVR, also an iterative proof generation model, on the test split of DU5. Additionally, we also compare the per sample inference time of IBR with PROVER and PROBR, both at-once models. All models are tested on one NVIDIA Tesla-V100 GPU with the same batch size and the beam size of IBR sets to 1 for a fair comparison. As shown in Figure 4, our IBR could achieve up to $\times$119.5 speedup compared with EVR, benefiting from our reasoning based on node and path features rather than intermediate texts. It is also noticeable that the runtime of EVR grows linearly with depth, while such an effect is slight on our model. Because EVR needs to infer on all contexts at every step, but IBR uses a simplified parent node prediction based on the derived path. Figure 5 illustrates that IBR is also faster than PROVER because PROVER has some constraints during post-processing in inference, like ensuring proof connectivity, which takes extra time.