Generating Literal and Implied Subquestions
to Fact-check Complex Claims

Our decomposition process is inspired by fact checking documents written by professional fact checkers. In the data we use from PolitiFact, each claim is paired with a justification paragraph (see Figure 2) which contains the most important factors on which the veracity made by the fact-checkers is based. Understanding what questions are answered in this paragraph will be the core task our annotators will undertake to create our dataset. However, we frame the claim decomposition task (in the next section) without regard to this justification document, as it is not available at test time.

We define the task of complex claim decomposition. Given a claim $c$ and the context $o$ of the claim (speaker, date, venue of the claim), the goal is to generate a set of $N$ yes-no subquestions $\mathbf{q}=\{q_{1},q_{2},...q_{N}\}$. The set of subquestions should have the following properties:

• •

  Comprehensiveness: The questions should cover as many aspects of the claim as possible: the questions should be sufficient for someone to judge the veracity of the claim.

• •

  Conciseness: The question set should be as minimal as is practical and not contain repeated questions asking about minor, correlated variants seeking the same information.

• •

  Relevance: The answer to subquestion should help a reader determine the veracity of the claim. Knowing an answer to a subquestion should change the reader’s belief about the veracity of the original claim (Section 5.3).

• •

  Fluency / Clarity: Each subquestion should be clear, fluent, and grammatically correct (Section 3).

We do not require subquestions to stand alone Choi et al. (2021); they are instead interpreted with respect to the claim and its context.

We set the model to generate the target number of subquestions, which matches the number of subquestions in the reference, guaranteeing a concise subquestion set. Thus, we focus on measuring the other properties with reference-based evaluation. Specifically, given an annotated set of subquestions and an automatically predicted set of subquestions, we assess recall: how many subquestions in the reference set are covered by the generated question set? A subquestion in the reference set is considered as being recalled if it is semantically equivalent to one of the generated subquestions by models.²²2There are cases where one generated question covers several reference questions, e.g., treating the whole claim as a question, in which case we only consider one of the reference questions to be recalled. Our notion of equivalence is nuanced and contextual: for example, the following two subquestions are considered semantically equivalent: “Is voting in person more secure than voting by mail?” and “Is there a greater risk of voting fraud with mail-in ballots?”. We manually judge the question equivalence, as our experiments with automatic evaluation metrics did not yield reliable results (details in Appendix E).

We collect political claims and corresponding verification articles from PolitiFact.³³3https://www.politifact.com/ Each article contains one justification paragraph (see Figure 2) which states the most important factors on which the veracity made by the fact-checkers is based. Understanding what questions are answered in this paragraph will be the core annotation task. Each claim is classified as one of six labels: pants on fire (most false), false, barely true, half-true, mostly true, and true. We collect the claims from top 50 PolitiFact pages for each label, resulting in a total of 6,859 claims.

A claim like “Approximately 60,000 Canadians currently live undocumented in the USA.” hinges on checking a single statistic and is less likely to contain information beyond the surface form. Therefore, we mainly focus on studying complex claims in this paper. To focus on complex claims, we filter claims with 3 or fewer verbs. We also filter out claims that do not have an associated justification paragraph. After the filtering, we get a subset consisting 1,494 complex claims.

Given a claim paired with the justification written by the professional fact-checker on PolitiFact, we ask our annotators to reverse engineer the fact-checking process: generate yes-no questions which are answered in the justification. As shown in Figure 2, for each question, the annotators also (1) give the answer; (2) select the relevant text in the justification or claim that is used for the generation (if any). The annotators are instructed to cover as many of the assertions made in the claim as possible without being overly specific in their questions.

This process gives rise to both literal questions, which follow directly from the claim, and implied questions, which are not necessarily as easy to predict from the claim itself. These are not attributes labeled by the annotators, but instead labels the authors assign post-hoc (described in Section 5).

We recruit 8 workers with experience in literature or politics from the freelancing platform Upwork to conduct the annotation. Appendix A includes details about the hiring process, workflow, as well as instructions and the UI.

Table 1 shows the statistics of our dataset. We collect two sets of annotations per claim to improve subquestion coverage. We collect a total of 6,555 subquestions for 1,200 claims. Most of the questions arise from the justification and most of the questions can be answered by the justification. In addition, we randomly sample 50 claims from the validation set for our human evaluation in the rest of this paper. We name this set Validation-sub.

Comparing sets of subquestions from different annotators is nontrivial: two annotators may choose different phrasings of individual questions and even different decompositions of the same claim that end up targeting the same pieces of information. Thus, we (the authors) manually compare two sets of annotations to judge inter-annotator agreement: given two sets of subquestions on the same claim, the task is to identify questions for which the semantics are not expressed by the other question set. If no questions are selected, it means that the two annotators show strong agreement on what should be captured in subquestions. Example annotations are shown in Appendix D.

We randomly sample 50 claims from our dataset and three of the authors conduct the annotation. The authors agree on this comparison task reasonably, with a Fleiss’ Kappa Fleiss (1971) value of 0.52. The comparison results are shown in Table 2. On average, the semantics of 18.4% questions are not expressed by the other set. This demonstrates the comprehensiveness of our set of questions: only a small fraction is not captured by the other set, indicating that independent annotators are not easily coming up with distinct sets of questions. Because most questions are covered in the other set, we view the agreement as high. A simple heuristic to improve comprehensiveness further is to prefer the annotator who annotated more questions. If we consider the fraction of unmatched questions in the fewer qs, we see this drops to 8.5%.⁴⁴4Merging two annotations results in many duplicate questions and deduplicating these without another round of adjudication is cognitively intensive. We opted not to do this due to the effectiveness of simply taking the larger set of questions. Through this manual examination, we also found that annotated questions are overall concise, fluent, clear, and grammatical.

We fine-tune a T5-3B Raffel et al. (2020) model to automate the question generation process under two settings: qg-multiple and qg-nucleus as shown in Figure 3. Both generation methods generate the same number of subquestions, equal to the number of subquestions generated by an annotator.

We learn a model $P(\mathbf{q}\mid c,o)$ to place a distribution over sets of subquestions given the claim and output. The annotated questions are concatenated by their annotation order to construct the output.

We learn a model $P(q\mid c,o)$ to place a distribution over single subquestions given the claim and output. For training, each annotated subquestion is paired with the claim to form a distinct input-output pair. At inference, we use nucleus sampling to generate questions. See Appendix F for training details.

We also train these generators in an oracle setting where the justification paragraph is appended to the claim to understand how well the question generator does with more information. We denote the two oracle models as qg-multiple-verify and qg-nucleus-verify respectively.

All models are trained on the training portion of our dataset and evaluated on the Validation-sub set. One of the authors evaluated the recall of each annotated subquestion in the generated subquestion set. The results are shown in Table 3. We observe that most of the literal questions can be generated while only a few of the implied questions can be recovered. Generating multiple questions as a single sequence (qg-multiple) is more effective than sampling multiple questions (qg-nucleus). Many questions generated from qg-nucleus are often slightly different but share the same semantics. We see that more than 70% of the literal questions and 18% of the implied questions can be generated by the best qg-multiple model. By examining the generated implied questions, we find that most of them belong to the domain knowledge category in Section 5.

Some questions could be better generated if related evidence were retrieved first, especially for questions of the context category (Section 5). The qg-multiple-justify model can recover most of the literal questions and half of the implied questions. Although this is an oracle setting, it shows that when given proper information about the claim, the T5 model can achieve much better performance. We discuss this retrieval step more in Section 9.

While our annotated subquestion sets cover most relevant aspects of the claim, we find some generated questions are good subquestions that are missing in our annotated set, though less important. For example, for our introduction example shown in Figure 1, the qg-nucleus model generates the question “Is Trump responsible for the increased murder rate?” Using the question generation model in collaboration with humans might be a promising direction for more comprehensive claim decomposition. See Appendix H for more examples.

We first collect human annotation to identify relevant evidence paragraphs. Given the full PolitiFact verification article consisting of $m$ paragraphs $\mathbf{p}=(p_{1},\ldots,p_{m})$ and a subquestion, annotators find paragraphs relevant to the subquestion. As this requires careful document-level reading, we hire three undergraduate linguistics students as annotators. We use the 50 claims from the Validation-sub set and present the annotators with the subquestions and the articles. For each subquestion, for each paragraph in the article, we ask the annotators to choose whether it served as context to the subquestion or whether it supports/refutes the subquestion. The statistics and inter-annotator agreement is shown in Table 7. Out of 12.4 paragraphs on average, 3-4 paragraphs were directly relevant to the claim and the rest of paragraphs mostly provide context.

We experiment with three off-the-shelf RoBERTa-based Liu et al. (2019) NLI models trained on three different datasets: MNLI Williams et al. (2018), NQ-NLI Chen et al. (2021), and DocNLI Yin et al. (2021). We compare the performance of NLI models with random, BM25, and human baselines.

We first convert the corresponding subquestions $\mathbf{q}={q_{1},...,q_{N}}$ of claim $c$ to a set of statements $\mathbf{h}={h_{1},...,h_{n}}$ using GPT-3 Brown et al. (2020).⁵⁵5We release the automatically converted statements and the negations for all of the subquestions in the published dataset. We find that with only 10 examples as demonstration, GPT-3 can perform the conversion quite well (with an error rate less than 5%). For more information about the prompt see Appendix G.

To retrieve the evidence that supports the statements, we treat the statements as hypotheses and the paragraphs in the article as premises. We feed them into an NLI model to compute the score associated with the “entailment” class for every premise and hypothesis pair. Here, the score for paragraph $p_{i}$ and hypothesis $h_{j}$ is defined as the output probability $s_{ij}=P(\text{Entailment}\mid p_{i},h_{j})$. We then select as evidence the top $k$ paragraphs by score across all subquestions: for paragraph $p_{i}$, we define $p_{i}^{\prime}=\max(\{s_{ij}\mid 1\leq j\leq N\})$, which denotes for each hypothesis from 1 to $N$ that the $j$th hypothesis $h_{j}$ achieves the highest score with $p_{i}$. Then $\mathbf{e_{sup}}=\{p_{i}\mid i\in\text{Top-K}(\{p^{\prime}_{1},...,p^{\prime}_{M}\})\}$. We set $k$ to be the number of the paragraphs that are annotated with either support or refute. Figure 6 describes this approach.

To retrieve the evidence that refutes the statements, we follow the same process, but with the negated hypotheses set $\mathbf{h}$ generated by GPT3. (Note that our NLI models trained on NQ-NLI and DocNLI only have two classes, entailed and not entailed, and not entailed is not a sufficient basis for retrieval.) The final evidence set is obtained by merging the evidence from the support and refute set. This is achieved by removing duplicates then taking Top-K paragraphs according to the scores.

BM25 baseline model uses retrieval score instead of NLI score. The random baseline randomly assign support, refute, neutral labels to paragraphs based on the paragraph label distribution in Table 7. Human performance is computed by selecting one of the three annotators and comparing their annotations with the other two (we randomly pick one annotator if they do not agree), taking the average over all three annotators. This is not directly comparable to the annotations for the other techniques as the gold labels are slightly different.

The results are shown in Table 8. We see that the decomposed questions are effective to retrieve the evidence. By aggregating evidence from the subquestions, both BM25 and the NLI models can do better than using the claim alone, except for the case of using DocNLI, and BM25 with the predicted decomposition. The best model with gold annotations (59.6) is close to human performance (69.0) in this limited setting, indicating that the detailed and implied information in decomposed questions can help gathering evidence beyond the surface level of the claim.

DocNLI outperforms BM25 on both the annotated decomposition and the predicted decomposition. This demonstrates the potential of using the NLI models to aid the evidence retrieval in the wild, although they must be combined with decomposition to yield good results.

Vlachos and Riedel (2014) proposed to decompose the fact-checking process into three components: identifying check-worthy claims, retrieving evidence, and producing verdicts. Various datasets have been proposed, including human-generated claims based on Wikepedia Thorne et al. (2018); Chen et al. (2019); Jiang et al. (2020); Schuster et al. (2021); Aly et al. (2021), real-world political claims Wang (2017); Alhindi et al. (2018); Augenstein et al. (2019); Ostrowski et al. (2021); Gupta and Srikumar (2021), and science claims Wadden et al. (2020); Saakyan et al. (2021). Our dataset focuses on real-world political claims, particularly more complex claims than past work which necessitate the use of decompositions.

Our implied subquestions go beyond what is mentioned in the claim, asking the intention and political agenda of the speaker. Gabriel et al. (2022) study such implications by gathering expected readers’ reactions and writers’ intentions towards news headlines, including fake news headlines.

To produce verdicts of the claims, other work generates explanations for models’ predictions.  Popat et al. (2017, 2018); Shu et al. (2019); Yang et al. (2019); Lu and Li (2020) presented attention-based explanations;  Gad-Elrab et al. (2019); Ahmadi et al. (2019) used logic-based systems, and  Atanasova et al. (2020); Kotonya and Toni (2020) modeled the explanation generation as a summarization task. Combining answers to the decomposed questions in our work can form an explicit explanation of the answer.

Our work also relates to question generation (QG) Du et al. (2017), which has been applied to augment data for QA models Duan et al. (2017); Sachan and Xing (2018); Alberti et al. (2019), evaluate factual consistency of summaries Wang et al. (2020); Durmus et al. (2020); Kamoi et al. (2022), identify semantic relations  He et al. (2015); Klein et al. (2020); Pyatkin et al. (2020), and identify useful missing information in a given context (clarification) Rao and Daumé III (2018); Shwartz et al. (2020); Majumder et al. (2021). Our work is most similar to QABriefs Fan et al. (2020), but differs from theirs in two ways: (1) We generate yes-no questions directly related to checking the veracity of the claim. (2) Our questions are more comprehensive and precise.

The evidence retrieval performance depends on the quality of the decomposed questions (compare our results on generated questions to those on annotated questions in Section 6). Yet, generating high-quality questions requires relevant evidence context. These two modules cannot be strictly pipelined and we envision that in future work, they will need to interact in an iterative fashion. For example, we could address this with a human-in-the-loop approach. First, retrieve some context passages with the claim to verify as a query, possibly focused on the background of the claim and the person who made the claim. This retrieval can be done by a system or a fact-checker. Then, we use context passages to retrain the QG model with the annotations we have and the fact-checker can make a judgment about those questions, adding new questions if the generated questions do not cover the whole claim. We envision that such a process can make fact-checking easier while providing data to train the retrieval and QG models.

As discussed in section 4, automatic metrics to evaluate our set of generated questions do not align well with human judgments. Current automatic metrics are not sensitive enough to minor changes that could lead to different semantics for a question. For example, changing “Are all students in Georgia required to attend chronically failing schools?” to “Are students in Georgia required to attend chronically failing schools?” yields two questions that draw an important contrast. However, we will get an extremely high BERTScore (0.99) and ROUGE-L score (0.95) between the two questions. Evaluating question similarity without considering how the questions will be used is challenging, since we do not know what minor distinctions in questions may be important. We suggest measuring the quality of the generated questions on some downstream tasks, e.g., evidence retrieval.

We have not yet built a full pipeline for fact-checking in the true real-world scenario. Instead, we envision our proposed question decomposition as an important step of such a pipeline, where we can use the candidate decompositions to retrieve deeper information and verify or refute each subquestion, then compose the results of the subquestions into an inherently explainable decision. In this paper, we have shown that the decomposed questions can help the retriever in a clean setting. But retrieving evidence in the wild is extremely hard since some statistics are not accessible through IR and not all available information is trustworthy Singh et al. (2021), which are issues beyond the scope of this paper. Through the Question Aggregation probing, we also show the potential of composing the veracity of claims through the decisions from the decomposed questions. The proposed dataset opens a door to study the core argument of a complex claim.

The dataset we collected only consists of English political claims from the PolitiFact website. These claims are US-centric and largely focused on politics; hence, our results should be interpreted with respect to these domain limitations.

Automated fact checking can help prevent the propagation of misinformation and has great potential to bring value to society. However, we should proceed with caution as the output of a fact-checking system—the veracity of a claim—could alter users’ views toward someone or something. Given this responsibility, we view it as crucial to develop explainable fact-checking systems which inform the users which parts of the claim are supported, which parts are not, and what evidence supports these judgments. In this way, even if the system makes a mistake, users will be able to check the evidence and draw the conclusion themselves.

Although we do not present a full fact-checking system here, we believe our dataset and study can help pave the way towards building more explainable systems. By introducing this claim decomposition task and the dataset, we will enable the community to further study the different aspects of real-world complex claims, especially the implied arguments behind the surface information.