FRVA: Fact-Retrieval and Verification Augmented Entailment Tree Generation for Explainable Question Answering (2024)

Abstract: Structured entailment tree can exhibit the reasoning chains from knowledge facts to predicted answers, which is important for constructing an explainable question answering system. Existing works mainly include directly generating the entire tree and stepwise generating the proof steps. The stepwise methods can exploit combinatoriality and generalize to longer steps, but they have large fact search spaces and error accumulation problems resulting in the generation of invalid steps. In this paper, inspired by the Dual Process Theory in cognitive science, we propose FRVA, a Fact-Retrieval and Verification Augmented bidirectional entailment tree generation method that contains two systems. Specifically, System 1 makes intuitive judgments through the fact retrieval module and filters irrelevant facts to reduce the search space. System 2 designs a deductive-abductive bidirectional reasoning module, and we construct cross-verification and multi-view contrastive learning to make the generated proof steps closer to the target hypothesis. We enhance the reliability of the stepwise proofs to mitigate error propagation. Experiment results on EntailmentBank show that FRVA outperforms previous models and achieves state-of-the-art performance in fact selection and structural correctness.

text: Findings of the Association for Computational Linguistics ACL 2024, pages 9111–9128 August 11-16, 2024 ©2024 Association for Computational Linguistics
Structured entailment tree can exhibit the reasoning chains from knowledge facts to predicted answers, which is important for constructing an explainable question answering system. Existing works mainly include directly generating the entire tree and stepwise generating the proof steps. The stepwise methods can exploit combinatoriality and generalize to longer steps, but they have large fact search spaces and error accumulation problems resulting in the generation of invalid steps. In this paper, inspired by the Dual Process Theory in cognitive science, we propose FRVA, a Fact-Retrieval and Verification Augmented bidirectional entailment tree generation method that contains two systems. Specifically, System 1 makes intuitive judgments through the fact retrieval module and filters irrelevant facts to reduce the search space. System 2 designs a deductive-abductive bidirectional reasoning module, and we construct cross-verification and multi-view contrastive learning to make the generated proof steps closer to the target hypothesis. We enhance the reliability of the stepwise proofs to mitigate error propagation. Experiment results on EntailmentBank show that FRVA outperforms previous models and achieves state-of-the-art performance in fact selection and structural correctness.

heading: 1 Introduction
text: Automated reasoning, the process of reasoning from given explicit knowledge to generate valid conclusions, has always been a goal pursued in Artificial Intelligence (Wos, 1985; Mercier and Sperber, 2011; Xu et al., 2023). Interpreting the reasoning process from question to answer can provide a human-understandable inspection for the QA system, which can help improve the debuggability and trustworthiness of the model.
*Corresponding author.
Explainable Question Answering (XQA) aims to answer a question and give a corresponding explanation (Schuff et al., 2020), and current related works focus on three aspects: extracting keywords or sentences that contain the answer (Yang et al., 2018; Serrano and Smith, 2019), constructing the multi-hop explanation chain (Xu et al., 2021), and generating free-form explanations (Wei et al., 2022; Yoran et al., 2023). Among the various explanation methods, Dalvi et al. (2021) proposes to construct multi-step reasoning chains in the form of entailment tree, which shows how hypotheses (question + answer) can be explained from simple textual evidence. As shown in Figure 1, given a hypothesis and a set of supporting facts, the goal is to generate an entailment tree consisting of multiple premise proof steps, which has better expressive compared to other methods. For example, for the question “After fossils are formed, which process is most likely to destroy them?”, the reasoning process can explain why the answer “the rock cycle” is predicted.
One line of previous work converts a multi-step entailment tree into a linearized sequence (Dalvi
9111
et al., 2021; Tafjord et al., 2021; Bostrom et al., 2021), which directly outputs the entire reasoning chain using the sequence-to-sequence model (seq2seq). Although this method simplifies the generation task, it is challenging to guarantee structural correctness when the steps are longer. Therefore, subsequent works propose to use stepwise generation by splitting the tree into multiple steps and training the model to perform single-step reasoning (Liu et al., 2022; Yang et al., 2022; Hong et al., 2022; Morishita et al., 2023; Su et al., 2023; Yuan et al., 2024). Compared to generating the entire reasoning chain directly, the stepwise generation can more fully exploit the combinability of proofs, which makes the model easier to learn and generalize to longer proof steps.
However, existing stepwise methods still face two challenges: (1) combination failure due to the large fact search space and (2) generation invalid steps due to error accumulation. The current works perform single-step reasoning mainly using deductive reasoning, which is a bottom-up process that requires iterative search and generation of intermediate conclusions from known facts until the hypothesis is proved. The search space grows with new conclusions to join the known facts, easily leading to combinatorial failure. Moreover, the stepwise methods have the problem of error accumulation, e.g., the third step “sent7 & int2 -> int3” in Figure 1 is not correct, which affects the next step generation. The model may quickly generate invalid proofs with the increase of proof steps, which leads to incorrectness of the tree structure.
To tackle the above problems, we propose FRVA, a bidirectional stepwise proofs generation method. We simulate the cognitive process of human reasoning and divide the entailment tree generation into two systems. In System 1, we design a fact retrieval module, which scores all candidate facts from a global perspective and initially eliminates knowledge facts with low relevance to the hypothesis. In System 2, we propose a deductive-abductive bidirectional proof generator. In this process, forward deductive and backward abductive reasoning generate candidate steps and verify each other to satisfy bidirectional consistency. Meanwhile, we design a multi-view contrastive loss integrating the local level and global level information to pull the semantic distance between the golden facts and hypotheses, which can help the model generate proof steps closer to the hypotheses.
We improve the reliability of the stepwise
proof step in terms of both supportiveness (crossverification) and similarity (contrastive learning). Finally, we align and fuse the bidirectionally generated structure trees and select the best proof tree. Experiments on EntailmentBank show that FRVA can obtain more reliable and valid reasoning paths and outperform existing baselines regarding fact selection and structural correctness. We also demonstrate that the backward reasoning remains valid in proof discovery. In summary, our contributions are threefold:
• We design the fact retrieval module which dynamically filters irrelevant knowledge facts to the target hypothesis to reduce the search space.
• We propose a bidirectional proof generation method based on deductive-abductive reasoning, which mitigates error propagation from both supportability and similarity perspectives through cross-verification and multi-view contrastive learning.
• Through extensive experiments and analysis, we shed light that FRVA can generate more correct and reliable reasoning paths and improve performance.

heading: 2 Related Work
text: Explainability in Question Answering. Recent works explore different forms of QA explanation, including retrieval to obtain multiple supporting facts related to the question or answer (Yang et al., 2018; Serrano and Smith, 2019; Niu et al., 2020; Schuff et al., 2020; DeYoung et al., 2020; Valentino et al., 2021). However, this method does not show how the evidence reasoning leads to the question hypothesis. In addition, some researchers use multihop reasoning chains to combine model outputs with human-understandable explanations (Yang et al., 2018; Jhamtani and Clark, 2020; Xu et al., 2021), where the explanation consists of a series of inferences rather than a simple textual explanation. Some works explain QA systems in a generative manner, which connects question to answer as explanations in the free-form text (Wei et al., 2022; Yoran et al., 2023; Wang et al., 2023), but this explanation is not always reasonable and faithful. Our work generates explanation in the form of multi-step entailment trees proposed by Dalvi et al. (2021). This form can show which facts and how to combine them to produce new intermediate
conclusions and ultimately prove the target hypothesis, which makes it easier to check the reasoning behind the model. Structured entailment tree generation. Existing methods can be categorized into two types: singlestep direct generation (Tafjord et al., 2021; Dalvi et al., 2021) and stepwise generation (Liu et al., 2022; Hong et al., 2022; Qu et al., 2022; Fei et al., 2022; Bostrom et al., 2022; Morishita et al., 2023; Kazemi et al., 2023; Creswell et al., 2023; Zhao et al., 2023; Hong et al., 2023; Yuan et al., 2024; Chen et al., 2024). In direct generation methods, the entailment tree is modeled as a linearized sequence, and the entire reasoning chain is directly generated in one shot using a seq2seq model. Such methods simplify the task but make generating entailment trees with longer steps difficult.
A series of recent works exploring stepwise generation methods include two main core components: fact sentence selection and intermediate conclusion generation. RLET (Liu et al., 2022) introduces reinforcement learning to entailment tree generation for the first time. NLProofs (Yang et al., 2022) introduces an independent verification mechanism to check the validity of the proof step and prevent the generation of hallucinatory invalid steps. IRGR (Ribeiro et al., 2022) proposes an iterative retrieval-generation architecture, which combines the generated intermediate conclusions and premises for retrieval to generate entailment trees better. FLD (Morishita et al., 2023) proposes a deductive rule generation method based on formal logic theory, which further enhances the deductive reasoning ability of the model. FAME (Hong et al., 2023) uses Monte Carlo planning to implement faithful question answering, but they focus on QA while we focus on explainability.
Prior works focus on forward reasoning, and MetGen (Hong et al., 2022) further reveals the effectiveness of backward reasoning. However, they discretely perform single-step proof generation (i.e., it needs to enumerate different combinations of facts to select the best single step). Our method is also a bidirectional proof generation that enhances the reliability of stepwise proof steps by cross-verification and multi-view contrastive learning during the generation process.

heading: 3 Task Formulation
text: As shown in Figure 1, the input of the entailment tree generation task consists of the hy-
pothesis H and a set of supporting facts S = {sent1, sent2, . . . , sentn}. H is a declarative sentence consisting of question-answer pairs (QA), which can be proved by constructing one or more reasoning steps with the knowledge from S. The output is an entailment tree T where root nodes are the target hypotheses H , leaf nodes are the facts chosen from S, and intermediate nodes are the conclusions inti generated by the model. The tree T is considered valid if all non-leaf nodes can be effectively entailed by their children. The entailment tree can be formalized as T = {H,J ,M,V}, where the leaf node li ∈ J ∈ S, the intermediate conclusion inti ∈ M /∈ S, and the proof step stepi ∈ V (a step consists of an intermediate conclusion and its premise, e.g., “sent1 & sent2 -> int1”). We denote the gold entailment tree as Tgold and all the leaf nodes it contains as the gold fact Sgold. According to the different composition of the input supporting facts S, it is divided into three increasingly difficult tasks:
Task1 (no-distractor): Inputs = H + QA + leaf sentences Sgold
Task2 (distractor): Inputs = H + QA + leaf sentences Sgold + 15-20 distractor sentences
Task3 (full-corpus): Inputs = H + QA + a corpus C

heading: 4 Method
text: The reasoning process of FRVA is shown in Figure 2, which consists of two systems. System 1 retrieves relevant facts, and System 2 contains the bidirectional proof generator and the proof alignment and fusion module. We introduce the above modules in section 4.1, 4.2 and 4.3.

heading: 4.1 Fact Retrieval
text: In the tree generation process, the search space of reasoning grows with the increase of input facts, and it is easy to generate complex tree branches. Therefore, we first filter irrelevant facts from S to reduce the search space and help efficiently and accurately generate the proof steps.
Specifically, we aim to score all candidate facts based on their relevance to hypotheses. Firstly, we splice hypothesis H and fact senti and input them into the pre-training model for encoding. The sentence embedding h of hypothesis H and fi of each fact are obtained by average pooling. Then, we use a multi-layer perceptron to obtain the correlation
score of each fact:
Rfact(senti) = σ(MLPfact([h,fi])) (1)
where σ is the sigmoid activation function, [·] represents the splicing operation, and MLPfact is a multi-layer perceptron composed of two-layer feedforward neural networks. In the tree structure, a fact with a smaller depth should be closer to the target hypothesis than a larger one (Hong et al., 2022). Therefore, we use a marginal ranking as the loss of the retriever during training:
Lfact = 1 N1
∑
s+1 ,s + 2 ∈Sgold
ψ(Rfact(s+1 ),Rfact(s+2 ),Wfact)
+ 1
N2
∑
s−∈Sgold
− log ( 1−Rfact(s−) )
(2)
where si denotes senti, s+1 is the fact with depth less than s+2 in the golden tree, s
− is the rest of irrelevant facts in S, N1 is the number of (s+1 , s + 2 ) pairs, N2 is the number of disturbing facts,Wfact is the margin of fact, ψ(x1, x2,W) = max (0, x2 − x1 +W) is the marginal loss. Based on the above fact scores, we design a threshold γ to dynamically screen each candidate fact and obtain a new set S′ containing m(m < n) facts.

heading: 4.2 Proof Generation
text: We build a bidirectional proof generator and design cross-verification and multi-view contrastive loss to enhance the reliability of proof steps from the perspective of supportability and similarity.
Deductive-Abductive Generation (supportive): The backward reasoning is a top-down process, which starts with a question and iteratively decomposes the sub-questions until all of them can be solved with the existing knowledge. We use a
pre-trained T5 model (Raffel et al., 2020) as the stepwise deductive and abductive proofs generator. We construct deductive and abductive training data from the proof step of the golden tree. For deductive, we construct it in a bottom-up manner, where the inputs of each step include the outputs of the previous steps in addition to the hypothesis H and the fact set S′. As shown in Figure 1, the output of the first step model is: “$proof$ = sent14 & sent25 -> int1”. We then use that step as part of the model input for the next step and iteratively generate proof steps until the output “hypothesis” terminates.
For abductive, we construct training data from the golden tree in a top-down manner. Taking the deductive step “sent7 & int2 -> int3” in the golden tree in Figure 1 as an example, the abduction model should output: “$proof$ = int3 & sent7 -> int2”. In this case, int3 is the intermediate conclusion generated by the previous abductive model. Then, we use this step as input to the next step of the abductive model and iteratively generate the step, terminating when no more intermediate conclusions are generated.
In the above way, we construct training data and train the deductive and abductive generators:
Gtded = Encoder−Decoder(H,S′, G1:t−1ded ) Gtabd = Encoder−Decoder(H,S′, G1:t−1abd ) (3)
where t represents the number of steps in iterative generation, and Gt represents the proof step generated at time t. We maximize the conditional probability likelihood loss during training. It is worth noting that joint training of deductive and abductive generators may get better gains, and limited by resources, we train the two individually.
In reasoning, we use the trained proofs generators Gtded and G t abd to generate u candidate
steps by beam search respectively, and then design a cross-verification mechanism to select the most appropriate candidate step. Specifically, the candidate deductive step steptded is checked with the abductive verifier Vabd, and vice versa. Because we think deductive and abductive reasoning should work together, the proof steps with bidirectional consistency are more reliable. For the training of the verifier, we convert the step (sent1 & sent2 -> inti) in the golden tree into abductive steps (inti & sent2 -> sent1, inti & sent1 -> sent2), and construct deductive pairs (sent1, sent2, inti) and abductive pairs (inti, sent2, sent1), (inti, sent1, sent2), respectively. Then, we jointly learn the deductive and abductive verifier Vded−abd by fine-tuning the pretrained albert-xxlarge-v2 (Lan et al., 2020) model. We denote both the above deductive and abductive pairs as (x1, x2, y) and use a multilayer perceptron to score the candidate step:
Vded(stepded) = σ(MLPded([x1;x2])) Vabd(stepabd) = σ(MLPabd([y;x2]))
(4)
The golden proof step is used as the positive example, and the negative example is constructed by randomly replacing one of the premises with a non-golden fact in S, and the positive-to-negative proportion is set to 1:1. The loss function for training the verifier is the binary cross-entropy loss.
Multi-view Contrastive Learning (similarity): In the stepwise generator of deductive and abductive, we design a multi-view contrastive loss integrating local and global information to pull the distance between the golden facts and target hypothesis, which makes the generation of proof steps closer to the hypothesis, as shown in Figure 3.
Specifically, we first design the local contrastive information at the Encoder stage. We encode the hypothesis H and fact S′ to obtain the sentence representation h′ for the hypothesis and f ′ for each fact. Then, we take the leaf node Sgold of the
golden tree as positive examples and calculate the cosine similarity between non-golden facts in S′ and the hypothesis. The facts with scores greater than µ are also taken as positive examples, and other facts in S′ are taken as negative examples:
senti = { positive, if senti ∈ J or scorecos > µ negative, otherwise (5)
where scorecos is the cosine similarity calculation. We construct the local contrastive loss based on the above positive and negative samples:
LLocal = − log ∑
fi ′+∈S′
gold
exp ( sim(h′,f ′+i )/τ ) ∑
fi ′∈S′ exp (sim(h
′,f ′i)/τ)
(6) where fi′+ denotes the embedding of the gold fact sentence, S′gold is the set of gold facts from S′, τ is a configurable temperature coefficient hyperparameter, and sim(·) is the similarity measure function:
sim(x, y) = xT y
∥x∥∥y∥ (7)
In the Decoder stage, we design the contrastive loss of global information. For the output of the generation model, the difference in semantic information between sentences cannot be completely separated by positive and negative sample labels. In other words, even negative samples are not necessarily irrelevant to the target output.
Therefore, we obtain z candidate steps and their embedding representations {c1, c2, . . . , cz} through beam search, and then we construct the global contrastive loss by combining {c1, c2, . . . , cz} and the embedding representation co of the golden step and the embedding representation co′ of the golden step for the rest of the samples within the batch. In this way, we can construct the sample set W = {k1, k2, . . . , kr} and sample pair (k+, k−) ∈ W , where + and − are determined by the ranking of the samples, which is obtained by calculating sequence-level scores (e.g., BLEU) with the target output, and this can reflect the relative differences between the comparison samples. The global contrastive learning loss is:
LGlobal = ∑
(k+,k−)∈W max(0, cos(Ex, Ek+)
− cos(Ex, Ek−) +Wpair) (8)
where Ex is the embedding of the target output co, Ek+ , Ek− is the embedding of the sample, and Wpair is the margin.
Loss Function. In the training stage, we jointly learn the local and global contrastive loss with the stepwise proof generator. For example, the loss of the deductive generator is computed as:
Lded = LLocal + LGlobal + Ldedgenerator (9)
where Ldedgenerator is the conditional probability likelihood loss of the seq2seq generative model:
Ldedgenerator = Z∑
i=1
log pθ(G t i|H,S′, G1:t−1i ) (10)
pθ(G t i|H,S′, G1:t−1i ) = pθ(st1, st2, . . . , stL|X)
= L∏
l=1
pθ(s t l |st<l, X)
(11) where X = (H,S′, G1:t−1i ), each token in step Gti is denoted as {st1, st2, . . . , stL}, Z denotes the total number of training data and L denotes the total number of tokens. The loss of the abductive generator Labd is calculated in the same way as above.

heading: 4.3 Alignment and Fusion
text: We further align the trees Tded and Tabd obtained by Gtded and G t abd into a proof graph and search for the best structure tree according to the score of each node, where the node of the graph is node ∈ {J ∪M}, and the edge is the premise node of the proof step stepi ∈ V points to the conclusion node.
Specifically, we first construct the initial graph Ginit according to Tded, and then integrate the abduction tree Tabd whose confidence is greater than the threshold β into Ginit, expanding the nodes and edges of the proof graph while assigning scores to each node:
nodei = { 1.0, if nodei ∈ J logs+vers, otherwise
(12)
where logs is the likelihood score when the autoregressive model generates an intermediate conclusion, and vers is the step score of the verifier for the intermediate conclusion. As described in section 4.2, we use the abductive score for the deductive step, and vice versa. For searching, we follow the work of Yang et al. (2022) explore the proof of different paths on the graph and extract the best proof tree based on node and step scores. The overall flow of FRVA is shown in Algorithm 1 in Appendix A.

heading: 5 Experiments

heading: 5.1 Dataset
text: We evaluate our method on EntailmentBank (Dalvi et al., 2021), an expert-annotated benchmark for QA explanation in the form of entailment trees. It contains a total of 1,840 entailment trees and 5,881 reasoning steps, each showing how QA pairs are entailed by a small number of related sentences. On average, each entailment tree has 7.6 nodes (including leaf nodes, intermediate nodes, and root nodes) and about 3.2 entailment steps. The detailed statistics of the data are shown in Table 1.

heading: 5.2 Baselines and Evaluation Metrics
text: We use the direct generation method EntailmentWriter (Dalvi et al., 2021) and the recent stepwise generation methods IRGR (Ribeiro et al., 2022), RLET (Liu et al., 2022), MetGen (Hong et al., 2022), NLProofs (Yang et al., 2022) and FLD (Morishita et al., 2023) as comparison baselines. We evaluate the structured tree using the metrics proposed by Dalvi et al. (2021), which includes the F1 and accuracy of the Leaves, Steps and Intermediate conclusions, in addition to the overall accuracy of the tree structure. The baselines, evaluation metrics, and implementation details can be found in Appendix B.

heading: 5.3 Main Results
text: The results of the experiments on EntailmentBank are shown in Table 2. We can find the following conclusions from the experimental results.
First, FRVA generates more correct proofs. In task1, we improve the overall accuracy of the tree by 1.4% with the same settings (the FLD method uses a lot of extra data for training, nevertheless, our method is also 1.1% better than theirs). Meanwhile, FRVA achieves SOTA performance on the proof step and intermediate metrics, and the accuracy improves by 2.1% and 1.8%, respectively. In Task2, FRVA improves the overall accuracy of the tree from 33.3% to 34.4%. It also achieves the best performance on the proof step and interme-
diate metrics. This shows that our bidirectional generation method can improve the reliability of the proofs step, thus mitigating the error propagation during stepwise generation and enabling the model to generate better intermediate conclusions.
Second, FRVA can identify relevant supporting facts more effectively. In task1, FRVA improves the F1 and accuracy of leaf nodes by 0.4% and 3.9% compared to NLProofs and achieves a large improvement compared to all baselines except RLET and MetGen. Among them, MetGen manually annotates templates for different reasoning types and augments proof generation with additional Wikipedia training data. In task2, FRVA improves the F1 and accuracy of leaf nodes by 1.0% and 1.7%, respectively, compared to the best baseline, and it achieves a more significant improvement compared to the other baseline methods, which can be improved by 8.7% and 19.3% on average. This indicates that fact retrieval can filter irrelevant facts and reduce the search space in the subsequent reasoning process. Moreover, we design cross-verification and contrastive learning that can help the model more accurately select facts needed to prove the hypotheses. For task3, we use
the same retrieval results generated by Dalvi et al. (2021). We can see that our methods achieve competitive performance with the baseline except for the IRGR and MetGen.
We also use a larger pre-trained model (e.g., Flan-T5-Large (Chung et al., 2022)) as the proof step generator, and the experiment results are shown in Appendix C. We also prompt large language models (LLMs) with in-context samples to test their ability of generating proof steps. Appendix G shows that our method is significantly beyond the LLMs.

heading: 6 Analysis

heading: 6.1 Ablation Study
text: To evaluate the effectiveness of each module, we conduct an ablation study on Task2 as shown in Table 3. We can see that all the metrics exhibit an increasing trend when we introduce each component sequentially. For example, we introduce contrastive learning in deductive generation, which can significantly improve the structural correctness of the tree, which benefits from the contrastive loss pulling the distance between proof and target hy-
pothesis. Moreover, when we introduce the fact retrieval module, Leaves F1 and AllCorrect metrics improve by 1.1 and 4.1, respectively, which shows that irrelevant facts can be effectively reduced. When we introduce the cross-verification, it can be seen that all metrics have made significant improvements, which indicates that more reliable steps can be selected through bidirectional consistency verification to better generate a proof tree.

heading: 6.2 Effect of different Proof Length
text: Multi-step proof trees are difficult to generate accurately due to their complex structure. To explore the effectiveness of FRVA on multi-step generation, we break down the test performance of Task2 by the step length of the golden tree. The performance of the leaf node is shown in Figure 4, and the rest of the metrics are shown in Appendix D. We observe that the performance decreases significantly when
proof length increases, which indicates that the generation of multi-step proof trees remains challenging. Nevertheless, we can see that improving leaf node accuracy is more significant for FRVA than without cross-verification and fact retrieval. In the multi-step case, the above two modules can eliminate the distraction of some irrelevant facts and provide more reliable knowledge facts for proving the target hypothesis.

heading: 6.3 Cross-dataset Experiments
text: To further validate the generalization of our method, we perform cross-dataset experiments on other datasets. Specifically, we conduct experiments on the EntailmentBankQA, eQASC, and eOBQA datasets. Among these, EntailmentBankQA was constructed by Hong et al. (2023) following Creswell and Shanahan (2022) conversion of EntailmentBank to a more challenging version of QA by adding 4-way multiple options from the ARC
dataset for each hypothesis. eQASC and eOBQA were constructed by Jhamtani and Clark (2020) that collect one-step entailment trees from QASC (Khot et al., 2020) and OpenBookQA (Mihaylov et al., 2018) questions, which require the selection of valid single-step trees from the candidate set and evaluate the results with P@1 and NDCG metrics (Jhamtani and Clark, 2020).
Following the previous work, we directly apply Task2’s model for question answering on the above three datasets, and the experimental results are shown in Table 4 and 5. We can see that FRVA exhibits a great advantage in generalization across datasets, which validates the effectiveness of our method.

heading: 6.4 Case Study
text: We further perform a case study on the proof tree generated by FRVA, as shown in Figure 6. The golden tree contains six proof steps, whereas the previous deductive generation method generated only four proof steps. We can see that the step “sent6 & sent4 -> int1” is further supplemented to make the prediction tree closer to the standard tree in terms of the overall structure by introducing abductive reasoning. However, we find that it still has unreliable steps, such as sent20 and sent17. Therefore, we introduce fact retrieval and bidirectional verification, and we find that they can remove irrelevant facts and select more reliable steps. Finally, FRVA can obtain results closer to those of the golden tree.

heading: 6.5 Error Analysis
text: To understand the shortcomings of our model, we further analyze the output of FRVA. We select 50 proof trees of generated errors on the test set of Task2, and we classify the error types into the following two categories:
Reasoning process mistake. The missing or redundant leaves lead to incorrect proof steps, making the model generate incorrect reasoning processes (42% of errors). For example, when explaining the hypothesis “forming fossil fuels requires deposition and burial of decaying plants”, the absence of the premises “forming fossil fuels requires deposition and burial of decaying vegetation” and “plants are a kind of vegetation” makes it impossible to explain the hypothesis.
Tree structure diversity. For proof trees with steps greater than 1, there are usually multiple reasoning paths from facts to hypotheses, so it is difficult to capture the validity of different structure trees by evaluating them directly against the golden tree (36% of errors). As shown in Figure 12 of Appendix E, the prediction tree contains three premise steps, and the Steps and Overall score are 0 under the automatic evaluation, because the prediction tree does not match the golden tree. However, the prediction tree should be valid because each step can be entailed by the premises. In the future, other evaluation methods should be introduced to better evaluate the different structural trees and thereby present the true logical reasoning ability of the model. In addition, some of the errors are repeating premises as conclusions, or re-generating steps that are already in place (22% of errors).

heading: 7 Conclusion
text: In this paper, we propose FRVA, a bidirectional entailment tree generation method based on fact retrieval and verification augmented, which divides the generation process into two systems. System 1 makes the initial judgment, and System 2 makes the refined reasoning. We design a deductive-abductive bidirectional reasoning method and enhance the effectiveness of the proof step from supportive and similarity perspectives through cross-verification and multi-view contrastive learning. Experiments show that FRVA outperforms the existing baselines regarding fact selection and structural correctness. It is worth exploring to design more efficient bidirectional reasoning methods and comprehensive evaluation systems in the future.
Limitations
Despite our method to achieving the performance increase, there is still substantial room for future improvements. First, we set the termination condition for the backward abductive reasoning that no new intermediate conclusions will be generated in the iterative step generation process. However, this will ignore the proof steps that contain multiple intermediate conclusions as premises. If there are better judgment conditions, it will be more helpful to generate the structure tree. Second, like prior work (Tafjord et al., 2021; Dalvi et al., 2021), we concatenate the filtered facts into a long text sequence and encode it with the language model, which can be limited by the input length constraints of the language model and affect the practical application of proof generation. Finally, the current automatic evaluation makes it difficult to accurately capture different tree structures (as we discussed in Section 6.5), which can underestimate the reasoning ability of the language model. Therefore, we leave the exploration of better backward reasoning and accurate evaluation of structural trees for future work.
Ethics Statement
Explainable QA is an important branch of the question answering domain, where the explanations given by the model must be faithful and reliable. Therefore, giving the reasoning process from the known facts to the answer is crucial for the transparency of the model. The data used in our work come from public datasets. Our proposed bidirectional proof generation method can improve the reliability of the reasoning process.

heading: Acknowledgements
text: We thank the anonymous reviewers for their helpful comments and suggestions. This work was supported by the National Key Research and Development Program of China (2020AAA0106100) and National Natural Science Foundation of China (62376144, 62176145, 62076155).

heading: A The overall flow of FRVA
text: The overall flow of FRVA is shown in Algorithm 1.

heading: B Experiment details
text: We describe the baselines, evaluation metrics, and implementation details used in the experiment.
B.1 Baselines
EntailmentWriter (Dalvi et al., 2021) provides a powerful baseline by linearizing the tree structure and generates the entire tree as well as intermediate conclusions in one shot using a sequence-tosequence model. It is available in two versions, implemented on T5-11B (11 billion parameters) and T5-Large (770 million parameters) (Raffel et al., 2020). IRGR (Ribeiro et al., 2022) designs an iterative retrieval generation framework that improves the retrieval results of Task 3. RLET (Liu et al., 2022) introduces reinforcement learning for the first time to entailment tree generation tasks, where single-step reasoning is performed iteratively through sentence selection and deductive generation modules. MetGen (Hong et al., 2022) iteratively generates entailment trees through multiple modules and reasoning controllers. NLProofs (Yang et al., 2022) guides the generation of proof steps through an independent verifier. FLD (Morishita et al., 2023) designs new deductive data generation methods based on the synthetic corpora, and uses the new data to train and then fine-tune the EntailmentBank data.
B.2 Evaluation Metrics
Leaves (F1, AllCorrect): To evaluate the performance of the model in recognizing facts related to
Algorithm 1: FRVA Proof Tree Generation Input: Hypothesis H , Supporting facts
S = {sent1, sent2, ..., sentn}, Fact RetrieverRfact, Deductive and Abductive generator Gded, Gabd, Cross-verifier Vded−abd
Output: Proof Tree Tpred 1 Fact Retrieval (System 1): 2 S′ = {}; 3 for senti in S do 4 fact_score =Rfact(senti); 5 if fact_score > γ then 6 Add senti to S′;
7 Detailed stepwise reasoning (System 2): 8 for t = 1 to max_step do 9 steptded, s t ded← Gded(H , S′, stept−1ded );
10 vtded← Vabd(steptded) + stded; 11 if steptded is final then 12 proofpredded = step 1:t ded,Aggre(v 1:t ded); 13 break;
14 for t = 1 to max_step do 15 steptabd, s t abd← Gabd(H , S′, stept−1abd ); 16 vtabd← Vded(steptabd) + stabd; 17 if steptabd is final then 18 proofpredabd = step 1:t abd,Aggre(v 1:t abd); 19 break;
20 T predded , sded = proof pred ded ; 21 T predabd , sabd = proof pred abd ; 22 G ← initialize(T predded , sded); 23 if sabd > β then 24 G ← update(G, T predabd , sabd); 25 Tpred← extract_proof(G); 26 return Tpred;
questions and answers. We compute F1 by comparing the leaf node Spred of Tpred with the leaf node Sgold of Tgold, and AllCorrect is 1 if they match exactly. Steps (F1, AllCorrect): To evaluate whether the predicted steps are structurally correct. We compute F1 by comparing the set of premises (child nodes) of the intermediate conclusion node intpred of Tpred and the aligned conclusion node intgold in Tgold, and AllCorrect is 1 if they match exactly. Intermediates (F1, Allcorrect): To evaluate whether the intermediate conclusion of the prediction is correct or not. We compute F1 by comparing
the intermediate conclusion node intpred of the prediction tree Tpred with the aligned conclusion node intgold in the gold tree Tgold. Then we compute the BLEURT* score between them, if it is greater than 0.281 (we following Dalvi et al. (2021)), then the intermediate conclusion of the prediction intpred is considered to be correct, and if the intermediate conclusions of the prediction tree Tpred are all correct, then AllCorrect is 1. Overall (AllCorrect): Test the above three metrics together. If the AllCorrect scores for Leaves, Steps, and Intermediates of the prediction tree Tpred are all 1, the overall correctness of the tree is 1. Note that this is a strict metric, as any error in Tpred results in a score of 0. For all metrics we report the results generated by their official evaluation code†.
B.3 Implementation Details Following previous work, our proofs generators (deductive and abductive generators) also use a pre-trained T5-Large (Raffel et al., 2020) model. The fact retriever and deductive-abductive crossvalidator are implemented with fine-tuned albertxxlarge-v2 (Lan et al., 2020). We use AdamW (Loshchilov and Hutter, 2019) as the optimizer with a learning rate of 1e-5 and batch size of 4. We set the maximum length of the input sequence to 1024. The threshold γ is set to 2.5e-7, and the marginal Wfact is set to 0.1 in section 4.1. We filter the facts after the first stage to get a different number of knowledge facts for each hypothesis (the average number of facts is reduced from 25 to 17 as shown in Table 6). The temperature coefficient τ is set to 0.07, the marginalWpair is set to 0.1, the beam size u is set to 10, µ is set to 1.0, and z is set to 10 in section 4.2. β is set to 0.85 in section 4.3. Hyperparameters are tuned to the validation data separately for each task/method. For the deductive and abductive proof generators, we set a maximum
*We use the bleurt-large-512 model following Dalvi et al. (2021)
†https://github.com/allenai/entailment_bank
number of steps of 20 as an additional condition for termination to prevent the infinite generation of steps.
We train the model on Task1 and Task2, respectively. For Task3, Dalvi et al. (2021) retrieves 25 supporting facts for each hypothesis, and we use the same retrieval results. Following their work, we utilize the model trained on Task2 to test its zero-shot performance on Task3. All comparative baseline results report the results in the original paper. For our method on test set, we report the average performance and standard deviation over 5 independent runs. All experiments are run on a machine with one NVIDIA Tesla A100 (40GB) GPU.

heading: C Results of other experiments
text: Su et al. (2023) propose a contrast stepwise decoding method, ConDec, that employs an additional checker (using the T5-11B model) to construct the contrast samples. It is worth noting that their experiment uses a larger model Flan-T5-XL (3B) (Chung et al., 2022) as the backbone and points out that the model with larger parameters has better logical reasoning ability. Our work belongs to the contemporaneous work with ConDec. Nevertheless, we also compare with it as shown in Table 7.
It can be seen that FRVA outperforms the ConDec method when using the Flan-T5-Large model, and at the same time achieves a new state-of-the-art performance in the Leaves F1 and AllCorrect metrics, which are even higher than the larger model
ConDec (Flan-T5-XL (3B)) by 0.94 and 2.35. Due to resource constraints, we have not yet experimented on Flan-T5-XL (3B), but we still achieve comparable or better results than the larger model.
Furthermore, we compare FRVA with the most recent related work (Yuan et al., 2024; Chen et al., 2024), as shown in Table 8. We can see that FRVA outperforms all baselines except the Steps metric. It is worth noting that Overall AllCorrect is a strict metric that is 1 when the leaf nodes and intermediate conclusions match the golden tree exactly. We can see that FRVA is achieved the optimization on this metric, which demonstrates that our method is able to obtain a more accurate entailment tree to support the construction of a explainable QA system.

heading: D Experiment results for different proof length
text: The results of the metrics for different proof lengths on the test set of task2 as shown in Figures 7, 8, 9, 10, 11. It is worth noting that the automatic evaluation metrics underestimate the logical reasoning power of language models because the entailment tree containing multiple steps may have multiple
reasoning paths, as we described in Section 6.5. Therefore, the performance for different lengths only roughly reflects the multi-step reasoning capabilities of different models.

heading: E Error Analysis Sample
text: An entailment tree containing multiple proof steps may have multiple reasoning paths pointing from premises to hypotheses, as shown in Figure 12. The current automatic evaluation often struggles to capture the diversity of tree structures effectively. Therefore, it remains worth exploring how to evaluate the validity of structured trees more effectively in the future.

heading: F Human Evaluation
text: As mentioned above, due to the diversity of tree structures, automatic evaluation metrics have limitations and do not accurately evaluate the structured reasoning ability of the model. Therefore, we further perform a human evaluation. We randomly selected 50 instances from EntailmentBank’s Task1 test set and evaluated the model results against four criteria: (1) Facts Correctness: evaluates whether the leaf nodes of the prediction tree are correct and necessary to prove the hypothesis. (2) Single-step Validity: evaluates whether the generated intermediate conclusion can be derived from two or more premises. (3) Conclusion Consistency: assesses
whether the intermediate conclusions generated are consistent with facts and common sense and whether they are simple repetitions of the premises. (4) Overall Correctness: evaluates whether the final hypothesis can be deduced from all generated intermediate conclusions in the prediction tree. For the overall correctness metric, we count the number of valid trees. For the remaining metrics, we rate the generated reasoning steps from 1 (poor) to 5 (very good) and report the average score. We compared the results of FRVA with the baseline method, NLProofs (Yang et al., 2022), and the results are shown in Table 9. We can see that our method exhibits excellent performance on all metrics, especially on the single-step validity and conclusion consistency metrics. This demonstrates that our method is better able to generate intermediate reasoning steps.

heading: G Prompting with LLMs
text: With the help of large-scale pre-training, instruction fine-tuning, and human feedback reinforcement learning strategies, Large Language Models (LLMs) have made significant progress in natural language processing (Ling et al., 2023; Yao et al., 2023). However, researchers have begun to doubt the effectiveness of LLMs in complex logical reasoning tasks and to evaluate the capability of LLMs from different reasoning perspectives (Xu et al., 2023), such as commonsense reasoning (Bian et al., 2023), mathematical reasoning (Imani et al., 2023), and multilingual reasoning (Bang et al., 2023) and so on. The entailment tree comprises multiple reasoning steps annotated by experts, which involves complex reasoning in realworld scenarios and presents a great challenge to the reasoning ability of the model. Therefore, we
test the performance of LLMs on this task and detect their logical reasoning ability.
We explore the logical reasoning ability of LLMs using both in-context-learning (ICL) and thought of chaining (COT) for LLMs, as shown in Figures 13 and 14. We use the above instructions to prompt for ChatGPT‡ and GPT-4 (OpenAI, 2023). Specifically, we randomly sample 7 context examples from the training set of EntailmentBank (Task 2) to prompt the LLMs directly. In addition, we also design a stepwise thought of chaining (SCOT) method to further stimulate the step-by-step reasoning ability of the large model. The experiment results on the validation set of task 2 are shown in Table 10.
We set only 1-shot instructions for the input of COT, limited by the input length and resources of LLMs. Nevertheless, we can see that GPT-4 generally outperforms GPT-3.5-turbo in all metrics, which demonstrates that GPT-4 has stronger logical reasoning and better instruction following. We also find that COT outperforms ICL, which indicates that the stepwise guide to the larger model can obtain a more accurate proof. GPT-4 can choose more accurate facts and generate more plausible intermediate conclusions, but our fine-tuned smaller models (e.g., T5, Flan-T5) significantly outperform LLMs on all metrics, which indicates that well-trained language models can capture the correlations between the knowledge facts and target hypotheses. Although large language models have some logical reasoning capabilities, it remains challenging to generate complex multi-step proofs accurately.
‡https://openai.com/blog/chatgpt

heading: Future Work
text: Therefore, it remains worth exploring how to evaluate the validity of structured trees more effectively in the future