🤖 AI

A Unified Definition of Hallucination: It's The World Model, Stupid!

This paper proposes a unified definition of hallucination as inaccurate internal world modeling observable to the user, arguing that this framework subsumes prior definitions, clarifies evaluation standards by specifying reference worlds, and distinguishes hallucinations from other error types to facilitate better benchmarking and mitigation strategies.

Original authors: Emmy Liu, Varun Gangal, Chelsea Zou, Michael Yu, Xiaoqi Huang, Alex Chang, Zhuofu Tao, Karan Singh, Sachin Kumar, Steven Y. Feng

Published 2026-06-16

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Emmy Liu, Varun Gangal, Chelsea Zou, Michael Yu, Xiaoqi Huang, Alex Chang, Zhuofu Tao, Karan Singh, Sachin Kumar, Steven Y. Feng

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 playing a game of "Telephone" with a very smart, but slightly confused, robot. You give the robot a story, a picture, or a set of rules, and ask it to tell you what happened. Sometimes, the robot tells you something that sounds confident and fluent, but it's completely made up. In the tech world, we call this a hallucination.

But here's the problem: everyone argues about what exactly counts as a hallucination.

If a robot summarizes a news article and gets a fact wrong, is it hallucinating?
If a robot answers a trivia question from its memory and gets it wrong, is it hallucinating?
If a robot tries to click a button on a website that doesn't exist, is it hallucinating?

Some researchers say "yes" to all of them. Others say "no, that's just a mistake." This confusion makes it hard to fix the problem.

This paper argues that we need to stop arguing about the definition and start looking at the root cause. The authors propose a simple, unified idea: Hallucination is just a broken "World Model."

The Core Idea: The Robot's Internal Map

Think of the robot as an explorer trying to navigate a city. To do this, it needs a map (a World Model).

The Reference World: This is the real map. It's the ground truth. It could be the news article you gave it, the actual rules of chess, the real database of a company, or the live code of a website.
The Robot's View: This is what the robot is actually allowed to see. Maybe it can see the whole article, or maybe it only sees a tiny snippet.
The Conflict Rule: This is the referee. If the robot's memory says "The sky is green" but the article says "The sky is blue," who wins? Usually, the article (the Reference World) wins.

The Paper's Definition:
A hallucination happens only when the robot's output contradicts the Reference World based on the Conflict Rule.

If the robot says, "The sky is green," and the Reference World (the article) says "The sky is blue," the robot has a broken map. It is hallucinating.

Why This Unifies Everything

The authors show that all the different types of "hallucinations" people talk about are actually just the same thing happening in different rooms:

Summarization: The "Reference World" is the source document. If the summary contradicts the document, the robot's map of that document is wrong.
Trivia (Open QA): The "Reference World" is the actual facts of the universe (e.g., who won the Nobel Prize). If the robot guesses wrong based on its training, its internal map of reality is wrong.
Web Browsing (Agents): The "Reference World" is the actual website code (the DOM). If the robot says "I clicked the Submit button" but the code shows no such button exists, the robot is hallucinating an object that isn't there.

The "Stupid" Part: It's the Map, Not the Robot

The title says, "It's The World Model, Stupid!" This is a play on a famous political slogan. The authors are saying: Stop blaming the robot for being "confused." The problem is that its internal map of the world is inaccurate.

Sometimes the robot isn't "lying"; it's just looking at the wrong map.

Planning Error: The robot knows the map is right, but it chooses a bad path. (Not a hallucination).
Hallucination: The robot thinks the map says "Bridge here," but the map actually says "Cliff." (This is a hallucination).

How to Fix It (According to the Paper)

The paper suggests we stop trying to build a "perfect robot" and start building better testing grounds.

They propose using synthetic worlds (like video games or chess) to test robots.

The Chess Analogy: Imagine a chess game where the rules are 100% clear and the board state is 100% known. We can ask the robot, "Can the white knight jump to this square?"
If the robot says "Yes" but the rules say "No," we know exactly that its internal map of the chessboard is broken.
Because the "Reference World" (the chess rules) is perfectly defined by a computer, we don't need humans to guess if the robot is lying. The computer knows instantly.

Why This Matters

By agreeing on this definition, researchers can finally:

Compare apples to apples: We can tell if a new technique actually reduces hallucinations or if it just changed the rules of the game.
Know what to fix: If a robot is hallucinating because it can't see the whole document, we fix the "View." If it's hallucinating because it ignores the document in favor of its memory, we fix the "Conflict Rule."
Build bigger tests: We can create thousands of test scenarios (like millions of chess puzzles) where we know the answer 100% of the time, without needing humans to grade every single one.

In short: The paper says, "Stop arguing about what a hallucination is. It's simply when the robot's story doesn't match the reality we agreed to test against. Let's build better maps and better tests so we can fix the robot's broken compass."

Technical Summary: A Unified Definition of Hallucination: It's The World Model, Stupid!

1. Problem Statement

Despite extensive research into mitigation strategies since the inception of Large Language Models (LLMs), hallucinations remain a persistent and unresolved issue in frontier models. The core problem identified by the authors is the fragmentation of the definition of "hallucination." Existing definitions are task-specific and often contradictory:

Summarization researchers define hallucination as content unsupported by the source document, even if factually true in the real world.
Open-domain QA researchers define it as factually incorrect content, regardless of the source.
Vision-Language Model (VLM) researchers focus on inconsistencies between visual input and text.
Agentic researchers view hallucination as inappropriate actions based on environmental observations.

This lack of a unified definition makes it difficult to compare benchmarks, evaluate the transferability of mitigation strategies, or answer fundamental questions about whether LLMs can ever stop hallucinating. Current evaluations often implicitly assume a "ground truth" without explicitly specifying what that truth is, how it is accessed, or how conflicts between sources are resolved.

2. Methodology: The Unified Framework

The authors propose a formal framework that unifies all existing definitions under a single concept: Hallucination as inaccurate (internal) world modeling observable to the user.

2.1 Core Components

The framework defines a hallucination relative to three explicit components:

Reference World Model ( $W$ ): A formal representation of what is objectively true in a given context. $W$ is a tuple $(S, H, R)$ , where $S$ is the set of possible world states, $H$ is the set of interaction histories, and $R$ is a set of rules constraining admissible states. $W$ can be instantiated as a source document, a knowledge base, a simulator, a database, or a formal grammar.
View Function ( $V$ ): A function that selects the portion of the world model relevant to a specific input $x$ (e.g., the full document, a retrieved subset, or a partial DOM observation).
Conflict Policy ( $P$ ) and Truth Function ( $T_{W,P}$ ): A policy determining how to reconcile multiple sources of information (e.g., "retrieved documents override parametric memory"). The truth function assigns a status (true, false, unknown) to any atomic claim $c$ given $W$ , $x$ , and $P$ .

2.2 Formal Definition

Let $y$ be the model output and $C(y)$ be the set of atomic claims observable to the user. The output $y$ hallucinates with respect to $(W, P)$ if and only if there exists a claim $c \in C(y)$ such that $T_{W,P}(x, c) = \text{false}$ .

Crucially, this definition distinguishes hallucination (incorrect beliefs about the reference world) from other error types:

Planning Errors: Correct beliefs but poor action selection.
Reward/Incentive Errors: Correct beliefs but confident outputs due to training incentives.
Calibration Errors: Uncertainty not properly expressed.

3. Key Contributions

The paper makes three primary contributions:

A Unified Taxonomy: The authors demonstrate that prior definitions (from summarization, RAG, agentic settings, and VLMs) are simply different instantiations of the same underlying structure. By varying $W$ , $V$ , and $P$ , one can derive existing definitions (e.g., intrinsic vs. extrinsic hallucinations) as special cases.
Explicit Benchmark Design Guidelines: The framework forces benchmark designers to explicitly state their assumptions regarding the reference world, the model's view, and conflict resolution. This allows for meaningful comparison across disparate benchmarks (e.g., FavaBench, HALoGEN, HaluEval) by diagnosing where their definitions diverge.
Scalable Benchmark Generation via Synthetic Worlds: The paper proposes a method for creating large-scale benchmarks using synthetic environments (e.g., games, simulators) where the reference world $W$ $W$ is fully specified and programmatically known.
- Case Study (Chess): The authors illustrate how a chess environment can serve as a benchmark. The world state ( $s$ ) and history ( $h$ ) are the ground truth. A document generator creates textual contexts, and a query generator creates questions. The truth function evaluates claims against the actual board state and rules, allowing for automatic, large-scale generation of hallucination labels without human annotation.

4. Results and Findings

As a position paper, the work does not present empirical results on model performance but rather provides a conceptual and diagnostic analysis:

Diagnostic Power: The framework reveals that disagreements in the literature often stem from implicit differences in $W$ , $V$ , or $P$ rather than model behavior. For example, a method might reduce hallucinations in summarization (where $W$ is the source doc) but fail in open QA (where $W$ is real-world facts) because the interventions target different components.
Clarification of Mitigation Strategies: The paper categorizes mitigation techniques based on which component they target:
- Retrieval/Tools: Interventions on the View function ( $V$ ).
- Calibration/Abstention: Interventions on the Truth function or output policy ( $T_{W,P}$ ).
- Architectural/Training Changes: Interventions on the model's internal approximation of $W$ .
Distinction of Error Types: The framework successfully separates "hallucination" (world modeling errors) from "planning" or "instruction-following" errors, a distinction often blurred in current literature.

5. Significance and Claims

The authors claim that this unified view is significant for several reasons:

Scientific Rigor: It moves the field from vague, task-specific definitions to a formal, reproducible structure. It forces researchers to clarify "what is true" before claiming a model has hallucinated.
Comparability: It enables the comparison of benchmarks and mitigation strategies across different domains (text, vision, agents) by mapping them to a common template.
Scalability: By leveraging synthetic environments with fully specified worlds, the framework enables the creation of benchmarks where hallucination labels are determined by construction rather than expensive human annotation or unreliable LLM-as-a-judge methods.
Actionable Guidance: It provides a clear roadmap for developers and researchers to identify whether a failure is due to missing information ( $V$ ), conflicting rules ( $P$ ), or a fundamentally broken internal model ( $W$ ).

The paper concludes that while perfect world modeling may be unattainable, the goal for LLMs should be to recognize the boundaries of their knowledge, abstain when uncertain, and update based on external information. The proposed framework, complemented by the HALLUWORLD benchmark suite, offers a path to systematically measure and reduce observable world-model errors.