CHECKWHY: Causal Fact Verification via Argument Structure (2024)

Abstract: With the growing complexity of fact verification tasks, the concern with “thoughtful” reasoning capabilities is increasing. However, recent fact verification benchmarks mainly focus on checking a narrow scope of semantic factoids within claims and lack an explicit logical reasoning process. In this paper, we introduce CHECKWHY, a challenging dataset tailored to a novel causal fact verification task: checking the truthfulness of the causal relation within claims through rigorous reasoning steps. CHECKWHY consists of over 19K “why” claimevidence-argument structure triplets with supports, refutes, and not enough info labels. Each argument structure is composed of connected evidence, representing the reasoning process that begins with foundational evidence and progresses toward claim establishment. Through extensive experiments on state-of-the-art models, we validate the importance of incorporating the argument structure for causal fact verification. Moreover, the automated and human evaluation of argument structure generation reveals the difficulty in producing satisfying argument structure by fine-tuned models or Chainof-Thought prompted LLMs, leaving considerable room for future improvements1.

heading: 1 Introduction
text: Fact verification is a crucial debunking task that entails verifying the truthfulness of claims by cross-referencing them with reliable evidence drawn from established resources (Guo et al., 2022b), which prevents the proliferation of erroneous information online and fosters public trust (Lewandowsky et al., 2020; Glockner et al., 2022). However, with the multi-step reasoning
† Equal Contribution. * Corresponding Author.
1 The dataset and code are available at https://github.com/ jasenchn/checkwhy
capability in fact verification models remaining uncertain (Schuster et al., 2019; Pan et al., 2023; Zhang et al., 2024), existing research reflects the deficiency in in-depth understanding of the explicit reasoning mechanisms when performing inference on multi-hop evidence. This prompts us to develop a strong benchmark that incorporates the interpretable “thought” process to assess the logical reasoning capabilities of models.
Currently, substantial progress has been made on common fact verification benchmarks, e.g., HOVER (Jiang et al., 2020), FEVEROUS (Aly et al., 2021), and SCITAB (Lu et al., 2023). Nevertheless, existing resources have inherent limitations. Classic datasets primarily focus on verifying the semantic factoids of “who”, “what”, “when”, and “where” within the claim (Rani et al., 2023). For example, verifying the claim “John Lennon was born before the astronaut who drank the first coffee in space.” can be decomposed into verifying factoids such as “who, and when the astronaut drank the first coffee in space.” and “when the man was born.”. However, these semantic factoids can be answered individually by straightforward factoidsmatching between the claim and distinct independent evidence (Jiang et al., 2020; Pan et al., 2023), e.g., word overlapping or proof matching(Krishna et al., 2022), thereby limiting its significant potential to summarize the correlational evidence with “thought” steps. Heretofore, noticeably absent in prior datasets are “why” claims: containing causal relations that need to be verified. These claims prompt for not simple factoid matching, but an explicit logical reasoning path for verification (Ho et al., 2023).
More specifically, Figure 1 presents a “why” claim featuring a cause-effect pair where “military crises” causes the “decrement of the purity of denarius silver.”. Verifying such causal relations is quite challenging, which necessitates complex logical reasoning and context information beyond
15636
the factoids within the claim (Jin et al., 2023, 2024; Romanou et al., 2023). For instance, to support this causal relations (i.e., military crises cause−−−→ decrease purity of silver), it is essential to incorporate the extra intermediate reasoning steps to bridge the connection between the cause-effect pair, thus forming a logical reasoning path: military crises ①−→ financial crisis ②−→ increase amount of currency ③−→ decrease purity of silver. The rationale behind ① is that military crises often coincide with extra factors such as trade disruption or more government spending, leading to the financial crisis. The reason supporting ② is that increase amount of currency is a demanding response to suppress the financial crisis. Furthermore, the rights to mint money that is safeguarded by Roman Law ensures the behavior of ③ is established. The above inference reveals a coherent reasoning process, which involves aligning the construction of a “thoughtful” logical structure among correlational evidence with causal relation verification.
In this paper, we introduce CHECKWHY, a challenging dataset built around a novel causal fact verification task: assessing whether the causal relation within the claim is valid by explicit logical structure. This dataset consists of 19,596 claimevidence-argument structure triplets derived from the WIKIWHY dataset (Ho et al., 2023). The uniqueness of CHECKWHY is that each entry contains a “why” claim with causal relations and an argument structure formed by correlated evidence: the latter is inspired by the theory literature on argument structure (Grimshaw, 1990; Freeman, 2011), which depicts how the different statements fit together as wholes to allegedly lend support to the claim. Moreover, inspired by prior research (Glock-
ner et al., 2021), we assume that the label of a causal relation within the claim depends on the provided argument structures, rather than the semantics itself. Thus, each claim is labeled as supports, refutes, or not enough info based on different argument structures. In addition, to prevent the bias in human cognition, we employ a human-model collaboration annotation approach to generate claims, evidence, and corresponding argument structures. Compared to existing datasets, CHECKWHY covers a variety of topics and argument structures, which may prove valuable for performing causal reasoning across various scenarios.
Based on the experiments on four tasks we propose and the human evaluation in our CHECKWHY, our experiments reveal the significance of incorporating the argument structure for causal fact verification. Meanwhile, our experiments in argument structure generation also validate the difficulty in producing satisfying argument structures for causal claims. Our key contributions are summarized as follows: (I) We propose verifying the “why” claims with causal relations through reasoning on argument structure as a novel causal fact verification formulation. (II) We construct CHECKWHY by introducing a human-model collaboration annotation approach, drawing inspiration from the theory research on argument structure. (III) We conduct thorough experiments on state-of-the-art models with four tasks, including fine-tuned models and LLMs, which investigates various settings and points out the potential for improvement.

heading: 2 Preliminaries
text: Our CHECKWHY framework is inspired by the argument structures theorized in the literature on
logical theory (Thomas, 1973; Toulmin, 2003; Walton et al., 2008; Walton, 2013). Thus, we begin by outlining the standard argumentation structure and then present a concise overview of our argument structure.

heading: 2.1 Standard Argumentation Structure
text: The standard argumentation structure (Thomas, 1973) is the scheme for structurally representing argument macrostructure: concerning what are the structural patterns in which the elements that constitute an argument may combine to form the overall argument. It consists of four basic structures. • Serial Argument (P → C): an argument structure has one premise P to give a reason to support the conclusion C. • Convergent Argument (P1 ∨ P2 → C): an argument structure has more than one premise, with each one function separately (P1 ∨ P2) as a reason to support the conclusion C. • Linked Argument (P1 ∧ P2 → C): an argument structure has more than one premise, and the premises function together (P1 ∧ P2) to give a reason to support the conclusion C. • Divergent Argument (P → C1/C2): an argument structure has more than one separate conclusion (C1/C2) that can be supported by the same premise P .

heading: 2.2 Our Argument Structure
text: The argument structure in CHECKWHY follows a tree-like framework, with the claim serving as the root node and evidence branching out as child nodes. These nodes are connected by directed edges that symbolize logical relations. Specifically, following the standard argumentation structure (Thomas, 1973), we blend various basic structures into a unified argument tree. This is achieved by referring to the semantics of each piece of evidence and the logical relations between different pieces of evidence. In this structure, the series argument leads from one child node to one parent node, while the divergent argument deduces multiple parent nodes from one child node. Furthermore, due to the challenging to discern the subtle distinction between convergent and linked argument, we merge these structural types into a new combined argument. This argument tree formalizes the reasoning process that begins with foundational evidence and progresses toward claim establishment.
A tricky issue here is that the argument structure inherently supports in the claim based on its definition, whereas the refutes instances are indispensable for causal fact verification. To tackle this, drawing inspiration from the warrant and rebuttal concepts in Toulmin’s structure (Toulmin, 2003), wherein the warrant offers facts or rules to back up the claim, and the rebuttal indicates conditions that negate the claim. We apply diverse argument structures to the same claim to collect both supports and refutes instances. In specific, offering the basic argument structure (i.e., warrant) to acquire support labels, and providing another structure (i.e., rebuttal) that upholds the opposition of causal relation in the claim to obtain refutes labels.

heading: 3 The CHECKWHY Dataset
text: We adopt a human-model collaboration annotation approach to construct our CHECKWHY, as shown in Figure 2, which including data preparation (§ 3.1), generation with LLMs (§ 3.2), and manual validation (§ 3.3).

heading: 3.1 Data Preparation
text: We utilize the WIKIWHY dataset (Ho et al., 2023), a publicly available cause-and-effect QA resource, as our data source. Each QA pair in this dataset was annotated with effect (question), cause (answer), and associated explanations, making it well-suited for our purposes. From the entire collections of cause-effect pairs in WIKIWHY, we initially filter out instances that contain incomplete syntactic structure in either the cause or the effect, thus remaining cause-effect pairs with valid causal relations. This is realized by justifying the absence of a predicate component in the sentence using StanfordNLP Parser tool (Qi et al., 2020). To ensure quality, we include an option in the subsequent manual validation process to mark a claim as "Discard - not a valid causal relation, incomplete, or redundant". During this stage, we extract 7,403 cause-effect pairs from a total of 9,406 instances within the WIKIWHY dataset.

heading: 3.2 Generation with LLMs
text: The rich knowledge and generative capabilities of large language models (LLMs) raise widespread attention on their use in aiding the construction of dataset (Si et al., 2023; Chen et al., 2023). As such, we adopt GPT-4 (Achiam et al., 2023) for our data generation through in-context learning (Ouyang et al., 2022). Notably, for each cause-effect pair,
Step 1 Data Preparation
Step 2 Generation with LLMs
Step 3 Manual Validation: Editing
Step 4 Manual Validation: Filtering
CHECKWHY
-Claim Generation
-SUP Evidence Generation
-Argument Structure Generation
Cause Effect
Instructions: ... Examples: ... Input: ...
Claim
Cause Effect Explanation
Instructions: ... Examples: ... Input: ...
Instruction Examples: ... Input: ...
LLMs
SUP Evidence LLMs
Effect Counterfactual Effect LLMs Counterfactual EffectCause REF Evidence LLMs
Prompts All SUP/REF Evidence NEI Evidence
Cause Effect SUP Argument Structure LLMs SUP Evidence Cause REF Argument StructureLLMs REF Evidence Counterfactual Effect
Claim
SUP/REF Evidence Annotator
SUP/REF Argument Structure
Annotator
Cause
Effect
Claim SUP/REF Evidence
SUP/REF Argument Structure
Claim SUP/REF Evidence Criteria
Faithfulness Fluency Validity Annotator SUP/REF Argument Structure
Claim SUP/REF Evidence
NEI Evidence
Claim
&
WIKIWHY Dataset StanfordNLP Parser Cause Effect
-REF Evidence Generation
-NEI Evidence Generation
Step 1 Data Preparation
Step 2 Generation with LLMs
Step 3 Manual Validation: Editing
Step 3 Manual Validation: Filtering
CHECKWHY
Instructions: ... Examples: ... Input: ... Instructions: ... Examples: ... Input: ...
Instruction Examples: ... Input: ...
LLMs
Prompts
Claim
SUP/REF Evidence Annotator
SUP/REF Argument Structure
Annotator
Cause
Effect
Claim
SUP/REF Evidence
SUP/REF Argument Structure
Claim SUP/REF Evidence
Annotator SUP/REF Argument Structure
Claim SUP/REF Evidence
NEI Evidence
Claim
&
WIKIWHY Dataset StanfordNLP Parser
Cause Effect
Effect Counterfactual Effect LLMs Counterfactual EffectCause REF Evidence
-REF Evidence Generation
All SUP/REF Evidence NEI Evidence -NEI Evidence Generation
-Argument Structure Generation
Cause Effect SUP Argument Structure LLMs SUP Evidence Cause REF Argument StructureLLMs REF Evidence Counterfactual Effect
-Claim Generation Cause Effect Claim LLMs
LLMs
-SUP Evidence Generation Cause Effect Explanation SUP Evidence
Faithfulness Fluency Validity
Criteria
Figure 2: The human-model collaboration annotation process of CHECKWHY, which contains three steps: (I) data preparation; (II) generation with LLMs (including the generation of claim, evidence, and argument structure); (III) manual validation.
our CHECKWHY applies three argument structures to each claim to acquire the SUP, REF, and NEI instances with supports, refutes, and not enough info labels, which ensures a dataset with balanced distribution of veracity labels. All the prompts used in our annotation process are presented in Appendix E.
• Support Evidence Generation To obtain valid SUP instances, textual evidence that support the claim is generated via GPT-4. In specific, by taking the cause-effect pair and associated explanation within WIKIWHY as input, the GPT-4 is prompted with the designed ReAct-like (Yao et al., 2023) examples, enabling LLMs to logically deduce the effect from the cause through a step-bystep thought process. Finally, the reasoning process generated by LLMs is considered as support evidence.
• Refute Evidence Generation Due to the significantly broader generation scope compared to the SUP instances, building REF instances is a challenging task (Zhu et al., 2023; Tan et al., 2023). To produce valid evidence that refutes the claim, following Zhu et al. (2023), we apply the generation of evidence that refutes the counterfactual effect as an intermediate step. In specific, starting with the original cause, we prompt GPT-4 to generate
the counterfactual effect by crafting an effect with an opposite label. Then, we prompt GPT-4 with ReAct-like examples to reason from cause to the counterfactual effect, resulting in the generation of evidence that refutes the original effect. • NEI Evidence Generation Following Aly et al. (2021), we incorporate instances labeled as not enough info into our dataset. To this end, we either randomly eliminate evidence from the corresponding SUP/REF instances or merge evidence from these two types to generate NEI evidence. • Argument Structure Generation To describe the logical reasoning process for each instance, we require GPT-4 to generate succinct argument structures for both the SUP and REF instances2. Inspired by Wang et al. (2023a), we prompt GPT-4 with Python-style code examples that have strict format restrictions. These examples help establish a logical reasoning path for each instance, thus deepening the structural understanding of arguments.
In specific, by referring to the argument structure outlined in § 2.2, we introduce the FACT class, which symbolizes an evidence node within the argument structure, and three distinct func-
2 Since the containing of non-gold evidence for NEI, we abandon to generate the argument structure for NEI.
tions to regulate the generation of GPT-4. (I) The one_to_one_linking function (corresponding to series argument) represents the deduction from one piece of evidence to another. (II) The one_to_multiple_linking function (corresponding to divergent argument) illustrates the deduction from one piece of evidence to multiple pieces. (III) The multiple_to_one_linking function (corresponding to combined argument) represents the reasoning from several pieces of evidence to support a single one. • Claim Generation By taking the causeeffect pairs extracted from WIKIWHY as input, the GPT-4 is prompted with crafted examples to generate diverse causal claims linguistically without accessing external information.
Notably, to better simulate the real-world fact verification scenarios and boost the distinguishing capability of models to the misleading evidence, we employ BM25 (Robertson and Zaragoza, 2009) to retrieve and extract 300 pieces of evidence from the entire dataset that show a higher degree of lexical overlap with the claim. Then, we use BLEURT (Sellam et al., 2020) to select 8-12 pieces of evidence with close semantic similarity to serve as distractor evidence for SUP, REF, and NEI.

heading: 3.3 Manual Validation
text: The uncontrollable generation of LLMs might result in unfaithful or invalid instances. Thus, we subsequently incorporate the human validation procedure for two purposes: (I) to revise and edit the content of generated instances by LLMs; (II)) to critically review and filter out the low-quality instances. The details are shown in Appendix C.
Manual Editing We ask a group of annotators with NLP backgrounds to edit and refine the generated instances. • Claim and Evidence Annotators are required to review the claims and assess whether they accurately contain all details from the provided cause-effect pair and express clear causality. Then, annotators are instructed to refine the generated evidence by evaluating whether all evidence aligns with the label and is presented in concise language (e.g., without repetition or redundancy).
• Argument Structure The annotators are required to review and correct errors within argument structures by double-checking the validity of each reasoning step and removing unnecessary noncode content, such as comments. In this context,
we encourage annotators to apply their judgment and expertise throughout the process.
Manual Filtering Another group of annotators is required to filter out the low-quality edited instances to further improve the quality of the dataset. Given the instructions and demonstration of the annotated argument structures, annotators need to decide whether to retain or discard instances based on the following three criteria. Finally, 6,757 and 6,638 instances pass the filter for SUP and REF, respectively. • Faithfulness: The truthfulness of the claim can be verified by the evidence and is consistent with the given label. • Fluency: The claim and associated evidence are written fluently and without grammatical errors. • Validity: The argument structure is logically coherent and correctly depicts the reasoning process from cause to effect.
Quality Control We apply strict quality control measures by following the principles outlined in the Dataset Statement (Bender and Friedman, 2018), ensuring high-quality annotation. Specifically, for each instance, two annotators are required to perform the manual editing and filtering, and resolve any disagreements identified by a third annotator. We employ majority voting to determine the final retained instances, reaching an inter-rater agreement at Fleiss’s κ = 0.75 (Fleiss et al., 1981). The details are listed in Appendix C.

heading: 4 Dataset Analysis

heading: 4.1 Dataset Statistics
text: Table 1 presents the statistics of our CHECKWHY dataset. This dataset comprises 6,532 sets of instances, with each set including a SUP instance, a REF instance, and an NEI instance, resulting in 19,596 instances in total. In addition, due to the lack of argument structure for NEI — the SUP and REF instances contain three elements {claim, evidence, argument structure}, while the NEI instance is limited to the claim and evidence — we build a CHECKWHY2 dataset by excluding NEI instances to assess the reasoning ability through argument structures within SUP/REF instances. Compared to WIKIWHY, our CHECKWHY includes more extended and detailed reasoning steps, with an average of 13.7 pieces of evidence and 4.08 reasoning steps. The histograms of evidence length and reasoning step counts are detailed in Appendix B.

heading: 4.2 Argument Structure Analysis
text: Inspired by Dalvi et al. (2021), to understand the intricacies of reasoning present within CHECKWHY, we analyzed the reasoning steps extracted from 50 randomly selected instances with diverse argument structures. We identified 5 prevalent high-level categories of reasoning, as shown in Table 2. Event causality (36%) refers to the relations where one event directly leads to another event. Inference from Properties (22%) involves concluding by referring to the properties present within one input. Rule-based Inference (17%) is about deducing new information or making decisions grounded in a set of predefined rules or conditions. Inductive reasoning (14%) requires a model to make generalized conclusions based on specific observations or evidence, deriving general principles or patterns from particular examples or observations. Moreover, with 10% of instances require applying sequential reasoning. As a whole, this analysis reveals diverse forms of reasoning steps that are essential for inferring the argument structure in CHECKWHY. In addition, we summarize 5 types of prevalent complex argument structures, as shown in Figure 5, which also shows the complexity of our argument structure through a macro perspective.

heading: 5 Experiment
text: Task Notation The instance within CHECKWHY is denoted by the quadruple (C,E/LE, S, Y2|Y3), where C denotes the claim, E = {e1, e2, . . . , en} denotes the evidence, LE refers to the initial leaf evidence in an argument structure. Notably, we ensure that LE includes the valid leaf evi-
dence and all the distractor evidence, which requires the denoising capability of models. In addition, S denotes the argument structure, and Y3 ∈ {REF, SUP,NEI} or Y2 ∈ {REF, SUP} for CHECKWHY2. Based on our CHECKWHY, we define four tasks of increasing difficulty, with the aim of (i) predicting whether the evidence supports or refutes the claim, or presents not enough information; (ii) generating valid argument structures outlining the reasoning process for causal fact verification. The following describes four tasks.
Task 1: Input = (C,LE), Output = Y2|Y3. We follow the traditional fact verification formulation to evaluate the inference capability of models on the CHECKWHY dataset, i.e., verifying the claim based on foundational leaf evidence. In this vein, we conduct the experiments on three types of baselines: (I) Discriminative models: BERT (Devlin et al., 2019), Transformer-XH (Zhao et al., 2020), and UniXcoder (Guo et al., 2022a), (II) Generative models: CodeT5 (Wang et al., 2021) and CodeT5+ (Wang et al., 2023b), (III) LLMs: ChatGPT and GPT-4 3(Achiam et al., 2023) with Chainof-Thought prompts (Wei et al., 2022).
Task 2: Input = (C,LE, S), Output = Y2. Task 2 is designed to assess whether models have a better understanding when incorporating the structural information within the argument structure during the verification. In this vein, We adopt the same set of baselines as in Task 1.
Task 3: Input = (C,E), Output = (Y2, S). To investigate the logical reasoning ability of existing models when performing verification, we experiment that involves the simultaneous verification of the claim and the generation of the argument structure. Here, we conduct experiments on CodeT5, CodeT5+, GPT-4 and ChatGPT with Chain-of-Thought prompts.
Task 4: Input = (C,LE), Output = (Y2, S). Task 4 investigates whether the model can independently construct an entire argument structure from bottom to top based on leaf evidence and its reasoning ability, which is the most challenging experimental setup in this paper. The model must generate the verification label and a complete argument structure based on the input claim and leaf evidence nodes. We use the same baseline models as in Task 3 for this task.
3 https://platform.openai.com/docs/models/gpt-4-and-gpt-4turbo

heading: 5.1 Evaluation Metrics
text: Automatic Evaluation Metircs Due to the uniqueness of argument structure within CHECKWHY, traditional evaluation metrics in text generation may not be suitable in our setting. Thus, we propose two new evaluation metrics focusing on argument structure generation. • Structure Similarity Inspired by Saha et al. (2021), we introduce an automated evaluation metric named Structure Similarity. The metric treats the argument structure as a collection of edges, with each edge considered as a sentence, and a matching method is employed to determine the optimal alignment between the edges in the predicted structure
and those in the gold argument structure. In our experiments, the BERTScore based on DeBERTalarge (He et al., 2021) is used as the scoring function to measure how closely the predicted edges match the gold edges. The detailed algorithm can be found in Saha et al. (2021). • Exact Match Similarity Similar to structure similarity, exact match similarity employs a stricter matching strategy. Here, structures are also regarded as sequences of edges, but a match is considered successful only when the predicted edge exactly matches the gold edge.
Human Evaluation Criteria To improve the reliability of the evaluation on argument structure, we introduce extra human evaluations beyond the automated evaluation metircs. Empirically, we randomly select 50 instances and ask three graduate students with NLP background to assess the generated argument structure according to the following criteria with binary score. • Validity: Is the generated argument structure logically coherent? • Win/Tie/Lose: Comparing the generated argument structure against the provided reference. Mark Win if you prefer the generated structure, Tie if you have no preference, and Lose if you prefer the reference structure.

heading: 5.2 Results and Discussion
text: Main Results The overall results of baselines on our CHECKWHY dataset are reported in Ta-
ble 3 and Table 4. In general, for Task 1 and Task 2, generative models show notably poorer performance compared to the discriminative models, and LLMs encounter substantial challenges in causal verification. Despite the powerful capability of GPT-4, which shows an improvement over ChatGPT for verification, it still lags behind the topperforming fine-tuned models. In addition, through the comparison of Y3 and Y2 on Task 1, we observe the consistent improvement for both discriminative models and LLMs, which indicates the disruptive impact brought by the ambiguous evidence within NEI instance, particularly on LLMs. An interesting observation here is that there is a slight decrease in the performance of generative models, which may be attributed to the disparities between the datasets utilized during the pretraining and finetuning phases. For Task 3 and Task 4, compared to the generative models, a similar phenomenon observed is that LLMs struggle to achieve satisfactory results in the generation of argument structure and show notably poorer performance on causal verification. This may be due to the conflict raised by the internal world knowledge and the evidence we generated, e.g., there is evidence that contradicts the real-world situation. In addition, the difference can be observed in the human evaluation, where LLMs present a slightly higher performance compared to the generative models. This may be attributed to the fact that LLMs generate more fluency and human-readable text with the powerful generative capability. Overall, the results of four tasks validate the difficulty when facing the setting of our CHECKWHY. The Effectiveness of Argument Structures Argument structures prove to be particularly advantageous, especially in specific experimental setups. In Task 1, where structures are absent, models such as the CodeT5 series and LLMs, relying solely on textual information, may struggle to achieve high accuracy. Furthermore, when comparing Task 1 and Task 2, a consistent improvement is noted across all baselines if structures are directly provided. For example, GPT-4 achieves approximately a 10% increase in accuracy in Task 2 compared to Task 1. This effect shows the most prominent performance on Transformer-XH, a GNN method conducting reasoning over the evidence graph. This underscores the significance of structural information within the argument structure for causal fact verification. The Construction of Argument Structures In Task 3 and Task 4, we investigate whether models can generate argument structures. Structure similarity may be significantly higher than exact match similarity because structure similarity considers the semantic meaning within nodes, whereas exact match similarity only checks whether characters are identical. CodeT5+ exhibits particularly noticeable performance, achieving the highest exact match similarity and structure similarity, as well as the highest F1 score and accuracy. Task 4 investigates whether models can construct an entire structure and complete inference given only the leaf nodes. All models perform poorly on Task 4, which may be attributed to the vast generation space in creating an entire structure. This indicates that when
all evidence nodes are provided, the model only needs to connect these nodes, instead of inferring the complete reasoning path. However, when only leaf nodes are provided, the task becomes much more challenging.
Human Evaluation Our human evaluation experiments, as detailed in Table 4, reveal that there is significant room for improvement across different aspects. None of the baseline models, including CodeT5, CodeT5+, and GPT-4, exhibit notably superior performance. Specifically, our strongest baseline, CodeT5+, generates valid argument structures only 62.5% of the time in Task 3, whereas in Task 4 it generates up to 60.0% of argument structures that are worse than the gold references. These results from the strongest LLMs leave ample room for improvement and serve as motivation for future work on these tasks.

heading: 6 Related work

heading: 6.1 Fact Verification Datasets
text: The fact verification task has recently garnered significant attention within the NLP community. Researchers prompt the development of fact verification by introducing various resources. Wellknown datasets such as FEVER (Thorne et al., 2018), PolitiFact (Garg and Sharma, 2020), and CREAK (Onoe et al., 2021) regard the fact verification task as a form of natural language inference, aiming to predict whether the evidence supports or contradicts a claim. Subsequently, some datasets have been proposed to address fact-checking for complex claims necessitating multi-step reasoning (Aly et al., 2021; Jiang et al., 2020), which typically present multiple pieces of evidence linked to the claim through entity matching. Additionally, to improve the interpretability of the veracity predictions, Alhindi et al. (2018) extends the LIAR dataset by incorporating summaries from fact-checking articles. Furthermore, Kotonya and Toni (2020) introduces the first dataset explicitly containing gold explanations, composed of factchecking articles and other news items. Rani et al. (2023) leverages interrogative questions to enhance interpretability by exploring the semantics factoids within the claim
Despite the advancement, existing datasets are primarily designed for verifying the semantic factoids with limited types within claims. Our work for the first time focuses on “why” claims: verifying the causal relation within the claim rather than
basic semantic factoids. In addition, inspired by the literature on logical theory, we construct argument structures to explicitly represent the reasoning process, enhancing the causal reasoning ability and interpretability of the model.

heading: 6.2 Causal Reasoning
text: With the increasing attention on causality (Willig et al., 2023; Zhang et al., 2023), several formulations of causality-related skills for NLP are proposed, which can be summarized into (1) causality as knowledge (Sap et al., 2019), encompasses the representation, understanding, and utilization of causal relationships embedded within textual data, (2) causality as language comprehension (Stede, 2008; Cao et al., 2022; Yu et al., 2019), originates from traditional linguistic studies on causal connectives and the usage of causal language, extending to more recent efforts in causal relation extraction, and (3) causality as reasoning (Jin et al., 2023), involves identifying factors leading to outcomes and understanding underlying mechanisms. Our work is the first attempt to introduce causality into the fact verification task inspired by the causal reasoning in argumentation (Habernal et al., 2018; Heinisch et al., 2022), in which causal knowledge, causal language comprehension, and causal reasoning are significant. Exploring whether models can grasp the causal relationship between evidence and claim in the verification process will further promote the development of the task.

heading: 7 Conclusion
text: In this paper, we introduce CHECKWHY, a challenging dataset and benchmark built around a novel causal fact verification task, annotated by a humanmodel collaborative approach. By drawing inspiration from the logical theory, we incorporate the argument structure to represent the explicit logical reasoning process when assessing the causal relation within the “why” claim, which may prove valuable for developing multi-step reasoning skills across various scenarios. Extensive experiments on various state-of-the-art models validate the importance of incorporating argument structures and the difficulty of generating them. With the baselines achieving limited results, we believe that CHECKWHY is a challenging yet attractive benchmark for the development of fact verification systems.
Limitations
• Within the CHECKWHY framework, the label assigned to each claim is based on distinct argument structures. Therefore, the assigned label may not always correspond to real-world circumstances. • The CHECKWHY dataset is created by LLMs, which could face difficulties in retrieving evidence in open-domain scenarios compared to previous datasets. This includes selecting relevant evidence in a broad and unrestricted information space. • The initial evidence in the argument structure, as provided by LLMs, may not meet everyone’s expectations or align with their understanding. This could affect the universal acceptability and perceived validity of the evidence.

heading: Acknowledgement
text: The authors would like to thank the anonymous reviewers for their insightful comments. This work is funded by the National Natural Science Foundation of China (Grant No.62176053, No.62376130), Shandong Provincial Natural Science Foundation (Grant No.ZR2022MF243), Program of New Twenty Policies for Universities of Jinan (Grant No.202333008), and supported by the Big Data Computing Center of Southeast University.

heading: A Experiment Details
text: In the fine-tuning process for Discriminative Models, we choose BERT-base-uncased, TransformerXH (using BERT-base-uncased as the backbone), and UniXcoder-base. The batch size is set to 8, and we utilize the AdamW optimizer with a learning rate of 5e-6.
We select CodeT5-base and CodeT5+ (0.7B) for fine-tuning generation models, with a batch size of 4 and a learning rate of 1e-5. Additionally, we specify a maximum input length of 512 and a maximum generation length of 400.
Regarding Large Language Models (LLMs), our choices are gpt-4-1106-preview and ChatGPTturbo, with a temperature setting of 0.1.

heading: B Ablation Experiment
text: Number of Irrelevant Evidence We perform experiments on Task 4 with different average amounts of irrelevant evidence. The findings are summarized in Table 5, suggesting that task difficulty increases slightly as the number of irrelevant evidence increases.
Number of Reasoning Steps We group the results of Task 4 according to the number of reasoning steps in the gold argument structures. The outcomes are outlined in Table 6, demonstrating a significant decrease in scores as the number of steps increases.
Further Evaluation We refer to the evaluation metrics from ENTAILMENTBANK and make slight modifications to further evaluate the argument structures generated in Task 3 and Task 4. The specific results are shown in the Table 8.
• Leaf Nodes (F1, AllCorrect): Does the predicted argument structure use the correct leaf evidence? We compute an F1 score by comparing predicted leaf evidence to golden leaf evidence. The “AllCorrect” score is 1 if all nodes are identified correctly (F1=1.0), 0 otherwise.
• Steps (F1, AllCorrect): Are the individual reasoning steps structurally correct? As each intermediate node represents (the conclusion of) a single step, the step is considered structurally correct (score 1) if it perfectly matches the gold, 0 otherwise. We then measure F1 comparing all steps in the two trees. Then AllCorrect=1 if F1=1.0, 0 otherwise.
• Intermediates (F1, AllCorrect): Are the intermediate conclusions correct? For comparing gold
and generated conclusions. F1 is computed using the number of aligned, correct intermediates wrt. the number of gold/predicted intermediates. AllCorrect=1 if F1=1, otherwise 0.
Based on the experimental results, the performance of the fine-tuned model significantly surpasses that of large language models (LLMs). From the Leaves metric, it is evident that the model can identify most of the evidence related to verification. However, the last two metrics indicate that the model encounters difficulties in linking these pieces of evidence to form an argumentative structure.
Pipeline Setup We also design an experiment in pipeline mode, using both CodeT5 and CodeT5+ as baseline models. In the first stage, modles output argument structures, and in the second stage, they produce the final classification results. The experimental results shown in Table 7 demonstrate that CodeT5+ generates better argument structures, and achieves better classification performance.
Number of Irrelevant Evidence Acc F1 SS ES
Number of Steps Number of instances Acc F1 SS ES

heading: C Detailed Description of the Annotation Process
text: Source of Annotator To ensure the quality of our complex annotation process, we do not adopt CrowdSource platforms, even though more CrowdWorkers can be employed. We hire 20 university students with experience in NLP, especially those majoring in logical reasoning or argument mining. Before the formal annotation, we draft detailed guidelines, set up the annotation platform, and conduct three rounds of thorough training and one round of testing. In this way, 13 students pass the exam and are retained. Furthermore, we split these students into two groups, where 1 PhD student and 8 postgraduate students perform the Editing, and 1 PhD student and 3 postgraduate students perform the Filtering. Moreover, we apply a strict quality control procedure during our annotation process. In addition, authors conduct casual inspections during the annotation process and rate each annotator, with annotators who receive low scores undergoing additional training.
Annotation Cost The annotating time for each sample ranges from 8 to 30 minutes, averaging 15 minutes per sample. After annotation, we follow local labor laws, and each annotator is paid $3.05 per hour.
Due to the complex argument structure within each instance, the analysis of argument structure type and evaluation of prediction is quite timeconsuming and labor-sensitive, especially facing complex structures. The average time for analyzing argument structure type is more than 20 minutes
per instance, and the average time of evaluation on prediction ranges from 15 minutes to 20 minutes per instance, depending on different baseline models.
Quality Contol We implemented several quality control measures to minimize the possibility of annotators cutting corners and to ensure the quality of the data: • Editing Given each instance, two annotators are required to perform manual editing of the Claim and Evidence and to resolve any errors identified by the third annotator. The final result is chosen by voting from all three annotators. Due to the complexity of the argument structure and its highly time-consuming nature, we don’t apply this procedure to the editing of the argument structure. • Filtering We apply a strict quality control procedure by filtering each instance with three anonymous annotators, wherein two annotators are required to filter the instance, and the third annotator (the Ph.D. student) serves as the supervisor. The decision of each instance is made by all three annotators. Moreover, the data transfer is completed by our annotation platform. According to our statistics, the ratio of "all-pass" is acceptable. A display of an example modified by humans is shown in Table 10. • Automatic Check We have implemented a grammar check mechanism(e.g. the argument graph must be a connected graph, etc.) to verify the legality of the annotated argument structures. Before annotators can submit their results, they must pass this check. • Human Check The authors conduct a random casual inspection of the edited data and rate each annotator. Moreover, since we have separated the annotators into two groups at different stages if the annotators in Filtering find low-quality edited instances, the annotators in Editing will receive a low rating.

heading: D Annotation Interface
text: Figure 8 to Figure 11 illustrate the interfaces utilized for claim annotation, evidence annotation, argument map annotation, and the final review stage.
These figures include comprehensive instructions, as well as contextual information for cause-effect pairs, to aid annotators in their understanding. Additionally, examples for each annotation stage are provided to enhance annotator proficiency.

heading: E Generation Prompts
text: The prompts utilized during the data collection stage are depicted in Table 11 to Table 14. Meanwhile, the prompts for experiments can be found in Table 15 to Table 18.

heading: Future Work
text: These results from the strongest LLMs leave ample room for improvement and serve as motivation for future work on these tasks