💬 NLP

ChronoFact: Timeline-based Temporal Fact Verification

This paper introduces ChronoFact, a novel timeline-based framework and accompanying dataset designed to improve temporal fact verification by extracting and chronologically aligning events from claims and evidence to systematically evaluate their accuracy and relationships.

Original authors: Anab Maulana Barik, Wynne Hsu, Mong Li Lee

Published 2026-06-09

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Anab Maulana Barik, Wynne Hsu, Mong Li Lee

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a detective trying to solve a mystery, but the suspect's story is a jumbled mess of events. They say, "I went to the bank, then I robbed a store, then I went to the bank again." If you only check if the bank and the store exist, you might think the story is true. But if you look at the timeline, you realize the story makes no sense because they were at the bank after the robbery, not before.

This is exactly the problem the paper ChronoFact tries to solve. It's a new computer system designed to fact-check stories that involve time, especially when those stories are complicated, messy, or have events that happen more than once.

Here is a simple breakdown of how it works, using everyday analogies:

1. The Problem: The "Jumbled Puzzle"

Current fact-checking systems are like detectives who only look at individual puzzle pieces. They check if a piece (an event) exists in the picture (the evidence).

The Flaw: If a story says, "I ate breakfast, then I went to work, then I ate breakfast again," a simple system might just check: "Did they eat breakfast?" (Yes). "Did they go to work?" (Yes). So, it says the story is true.
The Reality: If the evidence shows they ate breakfast after work, the story is a lie, even though the individual events happened. The order matters. Also, some events happen multiple times (like eating breakfast every day), and current systems get confused by that.

2. The Solution: ChronoFact (The "Timeline Detective")

The authors built a new framework called ChronoFact. Instead of just looking at isolated pieces, it builds a chronological timeline for both the story being checked (the Claim) and the facts found online (the Evidence).

Think of it like organizing a photo album. You don't just look at the photos; you arrange them in the order they happened to see the full story.

How ChronoFact does this in three steps:

Step 1: The Event Extractor (The Librarian)
The system reads the story and the evidence, then pulls out every specific "event" (like "meeting in 2022" or "attack in 2024"). It acts like a librarian pulling specific books off a shelf to look at the details.
Step 2: The Multi-Level Attention (The Matchmaker)
This is the brain of the operation. It compares the events in the story with the events in the evidence using three different lenses:
1. Word Level: Do the words match? (e.g., "Paris" matches "Paris").
2. Event Level: Do the whole events match? (e.g., "The meeting in Paris" matches "The meeting in Paris").
3. Time Level: Do the dates match? (e.g., "March 2023" matches "March 2023").
  It scores how well each story event fits with the evidence events.
Step 3: The Timeline Check (The Chronologist)
This is the secret sauce. Once the system matches the events, it doesn't just say "Yes" or "No." It asks: "Does the order make sense?"
It re-arranges the evidence events into a timeline and compares it to the story's timeline. If the story says "A happened before B," but the evidence shows "B happened before A," the system flags it as false.

3. The New Training Ground: ChronoClaims

To teach this system, the authors couldn't use old datasets because they were too simple (mostly single events). So, they built a brand new dataset called ChronoClaims.

The Analogy: Imagine they created a massive library of "tricky" stories. Some stories have 3, 4, or 5 events. Some events overlap (like two meetings happening at the same time). Some events happen again and again (like a recurring sports match).
They used AI to generate these stories and then had humans double-check them to make sure the "trick" (the timeline error) was real.

4. The Results: Winning the Detective Game

The authors tested ChronoFact against other top-tier fact-checking systems.

The Outcome: ChronoFact won by a huge margin.
Why? Because when the stories got complicated (more events, overlapping times, or recurring events), the other systems got lost. ChronoFact, however, kept its cool by sticking to the timeline.
The Proof: In one example, a story claimed a politician joined a party after becoming a professor. The evidence showed they joined the party before. Old systems said "True" because both events happened. ChronoFact said "False" because the order was wrong.

Summary

Think of ChronoFact as a fact-checker that refuses to be fooled by a jumbled story. It doesn't just ask, "Did this happen?" It asks, "Did this happen at the right time, in the right order, and did it happen again if it was supposed to?" By building a clear timeline, it catches lies that other systems miss.

Technical Summary: ChronoFact – Timeline-based Temporal Fact Verification

Problem Statement

The proliferation of digital misinformation includes a significant category of temporal claims—statements containing explicit (e.g., "in 1953") or implicit (e.g., "before another event") time-specific elements. Existing fact-checking systems often fail to accurately verify these claims because they focus on the veracity of individual events in isolation, neglecting the chronological order and temporal relationships between events.

Current limitations include:

Oversight of Sequence: Systems may validate individual events as true while missing that their sequence in the claim contradicts the evidence (e.g., claiming negotiations happened after bombardments when evidence shows the reverse).
Handling Complexity: Existing methods struggle with claims involving overlapping events (events occurring simultaneously) or recurring events (the same event happening at multiple distinct times).
Data Scarcity: Current datasets (e.g., T-FEVER, T-FEVEROUS) primarily consist of single-event claims or lack strict chronological dependencies, failing to capture the complexity of real-world temporal narratives.

Methodology: The ChronoFact Framework

ChronoFact is a novel framework designed to verify temporal claims by constructing and comparing coherent timelines for both the claim and the evidence. The system operates through the following modules:

1. Event Extraction and Encoding

Event Extraction: The system uses the GENRE model to retrieve relevant Wikipedia documents and AllenNLP's Semantic Role Labeling to extract events from both the claim and the evidence. Each event is enriched with core information and temporal arguments.
Event Encoder: Events are tokenized and processed using a flan-T5 model.
- Token Representations: Standard token embeddings are generated.
- Temporal Encoding: For date tokens, mean pooling is applied followed by positional encoding based on the distance from the earliest date in the context.
- Final Representation: A combination of event-level (CLS token) and token-level representations.

2. Multi-level Attention Encoder

To determine the relevance of evidence events to claim events, the framework computes attention scores at three distinct levels:

Token-level: Cosine similarity between all token pairs.
Event-level: Cosine similarity between the CLS representations of the claim and evidence events.
Time-level: Cosine similarity between the mean-pooled date representations.
The final attention score is the average of these three levels, used to weight evidence events for downstream classification.

3. Classification Modules

The framework employs three interconnected classifiers:

Claim Event Classifier: Predicts the veracity (Support, Refute, Not Enough Info) of each individual claim event based on the top- $k$ most relevant evidence events, weighted by attention scores.
Chronological Order Classifier: This is a core innovation. It assesses whether the sequence of claim events aligns with the timeline of evidence events.
- Evidence events are sorted by relevance and reordered with claim events using GPT to establish a chronological sequence.
- Two Bi-LSTMs encode the reordered sequences of claim and evidence events.
- A final classifier predicts whether the claim's chronological order is supported or refuted by the evidence.
Claim Classifier: Aggregates the outputs of the event classifier and the chronological order classifier to determine the overall veracity of the claim.

4. Training Strategy

The model is trained using a composite loss function:

Cross-Entropy Loss ( $L_{cross}$ ): Standard loss for predicting individual event labels, chronological order, and the overall claim label.
Soft Logic Loss ( $L_{soft}$ ): Enforces logical consistency using Gödel t-norms. It ensures that the overall claim is "Supported" only if all constituent events are supported and the chronological order is correct. If any event is refuted or the order is wrong, the claim is "Refuted."
Total Loss: A weighted combination $L = (1-\mu)L_{cross} + \mu L_{soft}$ .

Key Contributions

ChronoFact Framework: A systematic approach that moves beyond isolated event verification to evaluate the chronological accuracy of the entire claim narrative. It explicitly handles overlapping and recurring events by organizing evidence into timelines.
ChronoClaims Dataset: A new benchmark dataset containing 40,249 training, 3,544 validation, and 3,735 test claims. It features complex temporal structures, including:
- Claims with 3 to 5 events.
- Both explicit and implicit temporal expressions.
- Scenarios with overlapping and recurring events.
Multi-level Reasoning: The integration of token, event, and time-level attention mechanisms to capture semantic and temporal relevance simultaneously.

Experimental Results

The framework was evaluated on ChronoClaims, T-FEVER, T-FEVEROUS, and T-QuanTemp.

Performance on ChronoClaims: ChronoFact achieved a macro F1 score of 85.49%, significantly outperforming state-of-the-art baselines (e.g., TACV at 63.42%, GPT-4o at 61.93%).
- It demonstrated superior robustness as the number of events increased (3, 4, and 5 events), showing a smaller performance decline compared to other models.
- It excelled in handling overlapping (84.86% F1) and recurring (80.89% F1) event types where other models struggled.
Generalization: On T-FEVER and T-FEVEROUS, ChronoFact achieved the best performance (56.29% and 47.78% macro F1, respectively), despite these datasets having different characteristics (e.g., single-event focus).
Ablation Studies: Removing the Chronological Order Classifier resulted in the most significant performance drop (e.g., from 85.49% to 76.88% on ChronoClaims), confirming that verifying the sequence of events is critical for accuracy.

Significance and Claims

The authors claim that ChronoFact addresses a critical gap in misinformation detection: the inability of current systems to reason about the sequence of events. By treating fact verification as a timeline alignment problem rather than a collection of independent fact checks, the framework prevents false positives where individual facts are true but the narrative is chronologically impossible.

The paper emphasizes that while existing works (like TACV) utilize temporal information for retrieval or individual event reasoning, they often fail to verify the chronological consistency between the claim and the evidence. ChronoFact's ability to detect discrepancies in event ordering (as shown in case studies involving Yossi Yona and Davie Dodds) and handle complex temporal dynamics (overlaps and recurrences) represents a substantial advancement in the field of automated fact-checking.