Papers for

fact-checking tool developers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Misinformation fact-checking scores inflated by future knowledge leaks

No Hindsight for LLM Fact-Checkers: Measuring Leakage Channels in Misinformation Detection

Abstract: As automated fact-checking scales on social media, large language model (LLM) verdict scores can look stronger than warranted. One reason is that evaluations mix in information that was not knowable at claim time. Two channels are easy to conflate: outcomes memorized in pre-training and retrieved evidence published after the claim. Yet standard benchmarks rarely separate the two. In this study we measure both channels on AVeriTeC and QuanTemp++ by reconstructing point-in-time evidence conditions and probing for outcome information encoded in model representations. We find substantial evidence of parametric leakage, that can be hidden by the aggregate accuracy, while a simple representation bottleneck reduces this future leakage more efficiently than a mutual-information-based training penalty. We also find that allowing post-claim evidence inflates zero-shot accuracy by 6.3 points in AVeriTeC while the effect is negligible in QuanTemp++, where retrieval provides little post-claim evidence. These results show that misinformation benchmarks can overstate fact-checking performance when they do not account for what information was actually available at claim time.

Sun 4 OctComputation and Language
The gist
Fact-checking algorithms that judge the truth of online claims sometimes look better than they really are. This happens because they can use information that wasn’t actually available when the claim was first made, like facts learned later or evidence published after the claim. The authors studied this problem and found that when tests don't control for this, fact-checking models can appear more accurate than they truly should be. They also discovered a simple way to reduce this 'future knowledge' problem in the models.
Open → 2610.04888v1

Fallacy benchmarks detect argument style not true fallacies

Fallacy Benchmarks Measure Scheme Recognition, Not Fallacy Detection

Abstract: Fallacy-detection benchmarks pair fallacy classes with a single "valid" or "none" class that takes everything data collection did not label as a fallacy. This construction is misleading: a classifier can learn cues that do well on this class without learning to tell a fallacy from a correct argument. We show that the low false-positive rates benchmarks report are an artifact of how the class is built, not evidence of detection ability. The most informative negative for a fallacy is a correct argument using the same argumentation scheme, and such arguments are at most a few percent of the valid class across the four benchmarks we examined. Evaluated on constructed scheme-matched negatives, false-positive rates rise from 16.6% to 58.9% on CoCoLoFa and from 5.7% to 62.0% on Reddit. That rate depends on how the negatives are written, so we also compare two conditions from the same pipeline that differ only in scheme identity. Classifiers label scheme-matched negatives as the source fallacy type 40.9 points more often than wrong-scheme negatives, which are instead identified as the scheme they actually use 85.9% of the time against 0.4% for the source type. The classifier has learned which scheme an argument uses, not whether it uses it correctly, and on the benchmarks' own test sets the two are indistinguishable. The same dissociation appears in three zero-shot LLM detectors that never saw these benchmarks, and the measurement is far lower on a negative class that was built deliberately. We release the items as Scheme Foils. A reported false-positive rate should not be trusted as a measure of detection until the valid class has been audited for scheme-matched coverage.

Wed 16 SeptComputation and LanguageMachine Learning
The gist
Benchmarks for detecting fallacies in arguments often group all non-fallacy arguments together, which can confuse machines. The authors show that classifiers trained on these benchmarks learn to recognize the style or type of argument rather than whether it contains a fallacy. When tested with arguments that match the same style but are correct, these systems make many mistakes. This means current benchmarks may overstate how well computers can truly detect fallacies.
Open → 2609.18644v1