Fact or Fiction: Verifying Scientific Claims

In plain words

Scientific papers cite each other all the time, and a sentence such as "drug X reduces inflammation" usually points to one or more studies that back it up. Checking whether a claim like that holds up means finding the right studies and judging whether they support or contradict it. Doing this by hand does not keep up with the literature, and general fact-checking tools are built for news and Wikipedia, not for specialist science.

The authors built a benchmark for this task. They took real sentences from research papers that cite other work, rewrote each one as a short, checkable claim, and had experts mark which cited abstracts support it, which contradict it, and which say too little. For every supporting or contradicting abstract they also marked the exact sentences that justify the verdict.

They also built a baseline system with three steps: find candidate abstracts with a simple keyword-similarity search, pick the sentences that look like evidence, and then decide the label from those sentences. A model trained first on a large general fact-checking dataset and then on the scientific data did best. The system is a research prototype, and the authors say it should not be used for medical decisions.

TL;DR

• Task: given a scientific claim and a corpus of abstracts, return the abstracts that SUPPORT or REFUTE the claim, each with rationale sentences §2 §4.
• Dataset SciFact: 1,409 claims, 5,183 abstracts, 809 / 300 / 300 train / dev / test claims §3 tab. 2.
• Baseline VeriSci: TF-IDF top-3 retrieval, RoBERTa-large rationale selection, and RoBERTa-large label prediction §5 app. A.1.
• Author-reported open-setting test F1: 39.5 for sentence selection with label and 46.5 for abstract label with rationale tab. 4. The paper says its main comparisons are statistically robust under bootstrap resampling §6.2 app. B.

Problem

Staying current with the literature is hard, and the risk of acting on outdated or wrong findings is high during fast-moving events such as COVID-19 §1. Earlier fact-checking datasets (FEVER, UKP Snopes) use claims that are either synthetic or come from political sources. Scientific claims need domain knowledge, and their verification needs annotators with domain expertise §1 §2. A scientific claim here is one atomic, verifiable statement; compound claims must be split §2. The authors simplify verification to a per-pair problem: a claim against a single abstract, with no global truth label §2.

Method

Task. The input is a claim c and a corpus A of abstracts. The system predicts a set of evidence abstracts for c. For each predicted abstract it predicts a label in {SUPPORTS, REFUTES, NOT_ENOUGH_INFO} and one set of rationale sentences. The gold data may hold several rationales per abstract, but the model predicts only one set §4.

Dataset construction (SciFact).

1. Seed articles are sampled from a curated set of journals; each has at least 10 citations §3.1.
2. Source citances (sentences that cite a seed article) are sampled from the S2ORC citation graph. Co-cited abstracts from the same citance are added to the corpus §3.1 fig. 2.
3. Five distractor abstracts per source are added: papers cited elsewhere in the same article, in a different paragraph §3.1.
4. Annotators read a citance in context, without the cited abstract, and write up to three atomic claims. Citances without a specific finding are skipped §3.2.
5. An NLP expert writes negations of some claims to create REFUTES cases, avoiding obvious negation words §3.2.
6. For each claim, annotators label every cited abstract as SUPPORTS, REFUTES or NOT_ENOUGH_INFO. Each claim has one label. Evidence was found in 63% of cited abstracts. For SUPPORTS and REFUTES pairs, annotators mark one or more rationales of at most three sentences each. Rationales within a pair are mutually exclusive §3.3 tab. 2.

VeriSci pipeline (baseline). The algorithm is written in prose in §5 and app. A. The paper gives no numbered algorithm box and no numbered equations.

1. Abstract retrieval. Compute TF-IDF similarity between the claim and each abstract, using unigram and bigram features. Keep the top k = 3 abstracts §5 app. A.1.
2. Rationale selection. For each sentence a_i of a retrieved abstract, encode the pair [a_i, sep, c] with RoBERTa-large. Take the [CLS] vector, apply a linear layer and a sigmoid, and call the result z_i. Keep every sentence with z_i at or above a threshold t §5 app. A.1.
3. Label prediction. Concatenate the selected rationale sentences, a separator and the claim, [rationale, sep, c]. Encode with RoBERTa-large, take the [CLS] vector, and apply a linear layer with three outputs and a softmax §5. If an abstract has no rationale sentences, its label is NOT_ENOUGH_INFO §5.
4. Training data for label prediction. For SUPPORTS and REFUTES pairs, use the gold rationales as input. For NOT_ENOUGH_INFO pairs, use the k sentences of the abstract most similar to the claim, with k sampled from {0, 1} §5 app. A.3.

# VeriSci inference for one claim  [§5] [app. A.1]
# Input:  claim (string); corpus (list of abstracts, each a list of sentences)
# Output: per retrieved abstract, a label and its rationale sentence indices

def verify_claim(claim, corpus):
    # 1. Keep the 3 abstracts most similar to the claim by TF-IDF  [app. A.1]
    retrieved = top_k_by_tfidf(claim, corpus, k=3)
    labels = {}
    for abstract in retrieved:
        # 2. Score every sentence as rationale, paired with the claim  [§5]
        scores = [
            rationale_score(sentence, claim)  # sigmoid in [0, 1]
            for sentence in abstract.sentences
        ]
        # 3. Keep sentences at or above the threshold t  [app. A.1]
        rationale = [
            index
            for index, score in enumerate(scores)
            if score >= threshold  # threshold = 0.5 for the SciFact model
        ]
        # 4. No rationale sentences means NOT_ENOUGH_INFO  [§5]
        if not rationale:
            labels[abstract.id] = "NOT_ENOUGH_INFO"
            continue
        # 5. Predict the label from the rationale text plus the claim  [§5]
        text = " ".join(abstract.sentences[i] for i in rationale)
        labels[abstract.id] = predict_label(text, claim)
    return labels

Training schedule (SciFact). Both components use RoBERTa-large. Each component is trained for 20 epochs with a cosine learning-rate decay over those 20 epochs. The effective batch size is 256 via gradient accumulation app. A.2 app. A.3. The code builds the rationale-selector training set from every sentence of each claim's cited abstracts, labelled 1 if it is in a gold rationale transformer_scifact.py, and optimises cross-entropy on the 2-way logits transformer_scifact.py.

# Train the rationale selector on claim and abstract pairs  [§5] [app. A.2]
# Input:  pairs (claim, abstract sentences, gold rationale indices)

def train_rationale_selector(pairs):
    # 1. Each example is one (claim, sentence) pair  [§5]
    examples = []
    for claim, abstract, gold in pairs:
        for index, sentence in enumerate(abstract.sentences):
            # 2. Positive if the sentence is in a gold rationale  [§5]
            examples.append((claim, sentence, index in gold))
    # 3. Cross-entropy on the 2-way logits, 20 epochs, batch 256  [app. A.2]
    for epoch in range(20):
        for batch in shuffled(examples, batch_size=256):
            loss = cross_entropy(model(batch.claims, batch.sentences),
                                 batch.labels)
            update(model, loss)
    return model

Hyperparameters

Values come from the paper; the code citations show the matching default or where the code differs. "not stated" means neither the paper nor the code sets it.

Results

Author-reported. Setup: SciFact test set (300 claims) for the main results, dev set for the component comparison §6 tab. 3 tab. 4. Metrics are micro-F1 over precision and recall §4. Abstract-level evaluation counts at most three rationale sentences per abstract; sentence-level evaluation does not limit the number §4. Standard deviations from a 10,000-sample bootstrap are shown after the ± sign app. B.

Table 4: test set, main results tab. 4. Columns: P = precision, R = recall, F1 = micro-F1 (± bootstrap std).

The paper reports these relative gains on the open setting: +47% on Sentence Selection+Label and +28% on Abstract Label+Rationale over the FEVER-only model §6.2.

Table 3: dev set, component comparison tab. 3. Rationale selection (P, R, F1) and label accuracy.

COVID-19 case study §6.3. One medical student wrote 36 claims about COVID-19. The system retrieved abstracts for each, and one annotator judged each result plausible or not. 23 of 36 were judged plausible. This is an exploratory, single-annotator result with no metric beyond that judgement.

Annotation agreement §3.3. Label agreement on 232 claim-abstract pairs has Cohen's kappa 0.75. Rationale agreement given label agreement has kappa 0.71.

Paper vs code

Code at allenai/scifact, commit 68b98a5. Repository license Apache-2.0 for code and CC BY 4.0 for claims; corpus abstracts are ODC-By 1.0 from S2ORC LICENSE.md.

• Retrieval details. Paper: TF-IDF with unigram and bigram features §5 app. A.1. Code: also removes English stop words and fits the vectoriser on title plus abstract tfidf.py. The paper does not mention either detail.
• Rationale output. Paper: sigmoid of a single linear output §5. Code: a 2-way softmax, thresholding the positive-class probability [code: verisci/inference/rationale_selection/transformer.py#L50] transformer.py. The two forms are parameterisations of the same binary decision.
• Label training: NOT_ENOUGH_INFO inputs. Paper: the k most similar sentences to the claim, with k in {0, 1} §5 app. A.3. Code: random sentences, one or two per abstract transformer_scifact.py.
• Label training: extra negatives. Code adds, for every evidence set in a SUPPORTS or REFUTES pair, one NOT_ENOUGH_INFO example made of one or two random non-rationale sentences transformer_scifact.py. The paper describes non-rationale negatives only for rationale selection §5.
• Label training: union positive. Code adds one extra positive example per abstract, made of all rationale sentences together [code: verisci/training/label_prediction/transformer_scifact.py#L51-L60]. The paper does not mention this.
• FEVER rationale learning rates. Paper: 5e-6 encoder, 5e-5 head app. A.2. The FEVER script's defaults are 1e-5 and 1e-3 [code: verisci/training/rationale_selection/transformer_fever.py#L20-L21]. The training doc does not pass learning rates training.md. Passing the paper values is needed to match the paper.
• Abstract-level rationale limit. Consistent: the evaluator uses the first three rationale sentences metrics.py metrics.py.
• Threshold for Snopes. The paper's 0.75 app. A.1 does not appear in the repo's pipeline script pipeline.sh. Only the FEVER zero-shot threshold (0.025) and the SciFact threshold (0.5) appear there. The Snopes threshold is therefore "not stated" for the repo's pipeline.
• Test set. script/pipeline.sh skips evaluation for the test fold [code: script/pipeline.sh#L108-L110]. The Table 4 test numbers cannot be recomputed with this script alone.

No discrepancies found for: the three-stage order, the NOT_ENOUGH_INFO rule for abstracts with no rationale transformer.py, the 512-token truncation of the rationale [code: verisci/inference/label_prediction/transformer.py#L44-L51], and the 20-epoch SciFact schedule transformer_scifact.py.

Pitfalls

• Retrieval limits the open setting. The paper estimates that replacing the rationale selector with an oracle adds about 20 points of sentence F1 (open setting), and replacing retrieval with an oracle adds about 20 more §6.2. Any reimplementation must match retrieval first.
• Retrieval defaults are unstated. Stop-word handling, tokenisation, title use and the TF-IDF vocabulary cut-off are not stated in the paper §5 app. A.1. The code's choices are listed under Paper vs code.
• Small training set. The SciFact training split has 809 claims tab. 2. The label model does best after FEVER pre-training (81.9 dev accuracy vs 75.7 on SciFact alone) tab. 3. The FEVER step needs the FEVER data, and the rationale model's FEVER training takes about 700 GPU-minutes app. A.4.
• Sentence selection vs label. Sentence Selection+Label is always lower than Selection-Only, because a wrong verdict makes a right rationale count as wrong §4 tab. 4. Do not compare the two columns with each other.
• Threshold choice differs by training set. Zero-shot FEVER uses t = 0.025, tuned on the SciFact dev set; the SciFact model uses 0.5 without tuning app. A.1. Applying the zero-shot threshold to a SciFact-trained model is not what the paper did.
• Rationales may be non-contiguous. 28 gold rationales have non-contiguous sentences, and rationales are mutually exclusive within a pair. The system predicts one unordered sentence set, with no contiguity constraint §3.3 §4.
• Bootstrap noise. With 300 test claims, the reported F1 standard deviations are 2 to 4 points tab. 4 app. B. Differences of a few F1 points fall within that range. The paper calls its main comparisons statistically robust §6.2 app. B.
• Truncation. Inputs longer than 512 tokens are truncated from the rationale side; the claim is never truncated §5 (footnote). Long rationales lose content silently.
• Compute cost. Rationale training on SciFact takes about 150 minutes for 20 epochs on one P100; FEVER training takes about 700 minutes app. A.4. Batch 256 is reached through accumulation of 8-item steps app. A.2.
• Data licences differ. The claims are CC BY 4.0. The corpus abstracts are S2ORC data under ODC-By 1.0 LICENSE.md. Using only the claims does not carry the abstract licence with it.
• COVID-19 results are exploratory. One annotator judged 36 claims. The paper calls the system a research prototype and says it must not be used for medical decisions §1 footnote.
• Claim-only baseline. The claim-only model reaches 44.5 dev accuracy tab. 3. The paper reads this as evidence that the negation step did not create an obvious shortcut §3.2 §6.1. It does not rule out subtler artifacts.

Lineage

• Builds on: the BERT-to-BERT pipeline of DeYoung et al. (ERASER) and Soleimani et al. (2019), which the paper follows for its three components §5. The paper gives no arXiv identifiers for them, so none are linked here.
• Compared against: a FEVER-trained zero-shot model, a SciFact-trained model with oracle inputs, and claim-only and abstract-only models §6.1 §6.2.
• Data sources: S2ORC (for the corpus and citation graph) §3.1.