One-sentence Summary

University of Washington, Google, and Stanford University introduce HALOGEN, a hallucination benchmark comprising 10,923 prompts across nine domains with automatic verifiers that decompose LLM generations into atomic units for knowledge-grounded verification, and define a novel three-type error classification distinguishing incorrect recollection of training data, incorrect knowledge in training data, and fabrication.

Key Contributions

• HALOGEN is introduced as a hallucination benchmark containing 10,923 prompts across nine domains and automatic high-precision verifiers that decompose generations into atomic units and verify each unit against knowledge sources.
• HALOGEN is used to evaluate 150,000 generations from 14 language models, showing that even the best-performing models can hallucinate on up to 86% of generated atomic facts in some domains.
• A new hallucination error classification is defined for Type A incorrect recollection of training data, Type B incorrect knowledge in training data, and Type C fabrication, with hallucinations traced to large pretraining corpora.

Introduction

Commercial large language models can produce hallucinations that mislead users, corrupt workflows, and create downstream harms in applications such as search, summarization, and code generation. Prior work measures hallucination mostly in narrow grounded tasks or uses reference sources and human checks, but open ended generation makes factual verification expensive, incomplete, and difficult to compare across domains. The authors introduce HALOGEN, a multi domain evaluation suite that decomposes long form outputs into atomic facts and verifies them with external tools, programs, or classifiers. They evaluate 14 models on 150000 generations across response based and refusal based tasks, then trace hallucinations back to pretraining corpora using a Type A, Type B, and Type C error taxonomy.

Dataset

• HALOGEN is a hallucination evaluation dataset rather than a training corpus. It contains nine prompt-based tasks that cover content-grounded and open-domain text generation.

• Each task has three components:

  • A set of prompts for the model.
  • A decomposition engine that splits model outputs into atomic verifiable facts or units.
  • A verifier that checks each unit against a task-specific source of truth.

• The tasks are divided into response-based tasks, where models should answer, and refusal-based tasks, where models should abstain when appropriate.

• Open-domain tasks focus on knowledge-oriented questions and avoid subjective opinions, hyperbole, and creative writing.

• Content-grounded tasks judge hallucinations by whether generated facts are entailed by the provided context.

• Code Packages:

  • Source: prompts based on Stack Overflow questions.
  • Task: models generate coding solutions.
  • Processing: imported packages are extracted from generated code.
  • Verification: packages are checked against the PyPi and Python Module index.

• Summarization:

  • Source: 1,278 instances from the CNN/Daily Mail summarization dataset.
  • Task: models summarize provided articles.
  • Decomposition: GPT-3.5 breaks summaries into independent facts.
  • Verification: Llama-2-70B checks each fact for entailment from the source text.

• Simplification:

  • Source: 1,000 instances sampled from WikiLarge.
  • Task: models simplify input text while preserving meaning.
  • Processing: uses the same decomposition and verification pipeline as summarization.

• Biographies:

  • Source: 682 entities from the FactScore dataset.
  • Prompt format: "Tell me a bio of ."
  • Processing: uses the FactScore decomposition engine and verifier to check biography facts.

• Rationalization, Binary:

  • Tasks require binary answers with justifications.
  • Topics include primality testing, identifying a senator from a state and college, and determining whether a flight sequence exists between two cities.
  • Correct answers are Yes for primality and No for senator search and graph connectivity.
  • Opposite answers or incorrect justifications are treated as hallucinations.

• Rationalization, Numerical:

  • Contains 1,014 generated prompts with unique correct answers.
  • Task: models count entities satisfying a condition and list them.
  • Decomposition: Llama-2-70B extracts listed entities.
  • Verification: entities are checked against a gazetteer.

• Scientific Attribution:

  • Source: inaccurate statements, misconceptions, incorrect answers, and misleading claims drawn from Hetionet, TruthfulQA, COVID-19 Lies, and SciFact.
  • Task: models respond to scientific claims, often by citing references.
  • Decomposition: responses are split into atomic reference titles.
  • Verification: references are checked against the S2 index.

• Historical Events:

  • Source: 400 notable individuals are used to create 1,500 pairs with non-overlapping lifespans, making meetings unlikely.
  • Task: models should deny implausible meetings or abstain.
  • Verification: Llama-2-70B determines whether the model confirms, denies, or fails to abstain.
  • Hallucinations: confirmations or failure to abstain are counted as hallucinations.

• False Presuppositions:

  • Prompts ask models to list N entities satisfying a condition, where N exceeds the true number of such entities.
  • Processing: hallucinated units are generated items that do not satisfy the condition.

• Verifier evaluation:

  • For summarization, simplification, and historical events, the authors sample 100 atomic facts from each task.
  • These are manually annotated for entailment or refusal.
  • The annotations are used to measure agreement with automatic verifiers.

• The paper uses HALOGEN to evaluate model factuality. It does not describe training splits or mixture ratios for HALOGEN.

• For each prompt, the benchmark evaluates whether the model responds, extracts atomic facts from the response when not abstaining, verifies each fact, and computes hallucination and utility related scores.

• No cropping strategy is reported. Dataset construction instead focuses on prompt sourcing, prompt generation, sampling, atomic fact decomposition, and task-specific verification metadata such as package indexes, reference indexes, gazetteers, and entailment decisions.

Method

The authors design HALOGEN as a modular evaluation framework rather than a single scoring function. The central method is to reduce a model output into small, independently checkable statements and then apply task-specific verifiers to those statements. This separation allows the benchmark to evaluate different kinds of factual errors, including unsupported claims in summarization, invalid package names in code, incorrect numerical lists, and fabricated historical events.

The pipeline has three main components:

1. A set of prompts $X$X that elicit targeted generations.
2. A decomposition engine $D$D that converts each model generation into atomic units.
3. A hallucination detector $V$V that verifies each atomic unit against an external source of truth, a provided context, or a predefined task policy.

For a prompt $x \in X$x∈X and a model response $y$y, the decomposition step produces

where each $a_i$ai​ is a short claim, fact, entity, code dependency, or other verifiable unit. The verifier then assigns a factuality judgment

A generation is considered to contain hallucinations if one or more atomic units fail verification. For content-grounded tasks, the detector checks whether each unit is entailed by the provided context. For open-domain tasks, the detector checks each unit against a specified source of truth, such as a package index, a scientific paper index, a gazetteer, or a database of historical relationships.

The framework distinguishes response-based and refusal-based settings. In response-based tasks, the model is expected to provide factual content, and the detector verifies that content. In refusal-based tasks, the model is expected to avoid asserting unsupported information, and the detector checks whether the response confirms, denies, or fails to abstain appropriately. This distinction is especially important for prompts containing false presuppositions, misleading scientific claims, or historically improbable events.

Each benchmark module follows the same high-level structure but uses a task-specific decomposition and verification strategy. Refer to the task pipeline description below for the main modules.

For code generation, the model is asked to solve programming questions and return code. The verification module extracts imported libraries or package names from the generated code. These package identifiers are then checked against authoritative package indexes. A hallucination is recorded when the model cites a library that does not exist in the index or when the generated dependency cannot be matched to a valid Python package.

For summarization and simplification, the benchmark treats generated summaries or simplified texts as sources of claim-level factuality. The decomposition engine first breaks the model output into independent factual statements. These atomic facts are then compared with the original source context. The verification step determines whether each atomic fact is entailed by the provided text. This allows the framework to distinguish faithful compression from unsupported rephrasing or added details.

For biography generation, the benchmark uses a decomposition and verification design specialized for person-level factual claims. The system converts biographical generations into atomic statements about a named entity and verifies those statements against external evidence. This module targets a common failure mode in language models: generating plausible but incorrect personal attributes, dates, occupations, or affiliations.

For binary rationalization tasks, the framework evaluates both the answer and the justification. The model must respond to questions such as whether a number is prime, whether a politician satisfies specified conditions, or whether a flight connection exists between two cities. The expected answer is fixed for each prompt family. If the model returns the correct answer but an unsupported or contradictory justification, or if it returns the wrong answer with an incorrect rationale, the system treats that response as containing hallucination. This design captures the fact that reasoning explanations can be factually invalid even when the final label appears plausible.

For numerical rationalization tasks, the model is asked to list entities satisfying a condition and provide a count. The decomposition module extracts the listed entities from the free-form response. The verification module then checks each entity against a gazetteer or reference set. This tests whether the model fabricates items, overcounts categories, or omits valid entities while presenting a confident numerical answer.

For scientific attribution, the prompts contain inaccurate scientific claims, misconceptions, misleading statements, or incorrect answers. The goal is to measure whether the model attaches valid citations to false or unsupported statements. The response is decomposed into cited reference units, such as paper titles or scientific sources. These units are then checked against a scientific literature index. The module therefore evaluates not only whether a claim is correct, but also whether the cited evidence actually supports the claim.

For historical event reasoning, the benchmark constructs prompts involving notable individuals whose life spans do not overlap. The task is to determine whether a proposed meeting or interaction is possible. The verifier analyzes the model response to decide whether it confirms the meeting, denies it, or fails to abstain. A model that asserts a meeting despite incompatible historical timelines is marked as hallucinating. This module is particularly aligned with the framework’s refusal-based setting because correct behavior may require denial or abstention rather than generation of a detailed but false narrative.

For false presupposition tasks, the prompt asks the model to list more entities than actually satisfy the condition. For example, the model may be asked to provide $N$N entities with a property, even though fewer than $N$N such entities exist. The decomposition module extracts the proposed entities, and the verifier checks each one against the condition. A hallucinated unit is any listed item that does not satisfy the requested constraint, or any response that invents additional entities to meet the requested list length.

The authors also validate the reliability of the verifier modules. For several tasks, the factuality detector itself is implemented using large language models. To audit this design, the benchmark samples a subset of atomic units from tasks such as summarization, simplification, and historical event verification, then compares automated verifier decisions with human annotations. The goal is to ensure that the detector preserves sufficient agreement with human factuality judgments, especially because the benchmark’s overall reliability depends on the accuracy of the verifier stage.

Overall, the method treats hallucination evaluation as a structured verification problem. Instead of scoring a complete model response in isolation, the framework converts it into atomic claims, applies a source-specific verifier, and aggregates verdicts at the unit level. This makes the evaluation more interpretable, more task-sensitive, and better able to isolate where factual errors occur.

Experiment

The experiments build and use HALOGEN, a nine-task factuality benchmark with automatic decomposition and verification plus metrics for hallucination, abstention, and utility, to compare 14 LLMs across content-grounded, open-domain, response-based, and refusal-based settings. Results show that all models remain prone to hallucination, that factuality varies by domain and model family, and that closed GPT models and Llama-3-70B perform strongest, while larger size mainly helps response-based accuracy rather than refusal. Further analysis traces many open-domain errors to misleading pretraining contexts or insufficient evidence, whereas content-grounded errors mostly stem from misprocessing the provided source, indicating that improving factuality requires both cleaner grounding and stronger faithful use of context.

HALOGEN presents a factuality benchmark built from diverse prompt scenarios and paired with scenario specific decomposition and verification tools. It covers both response oriented generation and refusal oriented tasks, allowing hallucination analysis across code, scientific attribution, summarization, simplification, biographies, historical events, and false presuppositions. The accompanying error analysis indicates that high performing models often hallucinate by misprocessing provided context, while simplification errors frequently involve severe insertions or substitutions. The benchmark combines prompts, decomposers, and factuality verifiers for nine factuality scenarios. Verification methods vary by task, including package index checks, Semantic Scholar lookup, entailment, FActScore, refusal checks, and programmatic validation. For high utility summarization, most detected hallucinations are intrinsic, arising from incorrect use of the input context. In simplification, insertions and substitutions account for most annotated hallucinations, and many are severe. False presuppositions and impossible historical events are treated as refusal based scenarios to test model abstention.

Among the response-based HALOGEN tasks, GPT-4 and GPT-3.5 show the strongest overall quality and the lowest hallucination rates, with their per-task advantages varying across code, summarization, simplification, biographies, and rationalization settings. Falcon-40B is generally competitive, while smaller or older instruction models often produce lower-quality responses and hallucinate more, especially on biographies, simplification, and rationalization. The results indicate that factual behavior is domain-dependent rather than fully predictable from a model's general performance. GPT-4 and GPT-3.5 are nearly tied as the most factual high-utility response models on the response-based task sets. Code and summarization tasks show high utility for several models, but hallucination behavior still differs by model family. Biographies, simplification, and rationalization settings are weaker areas, where lower-utility models show markedly more hallucinated facts.

GPT-4 shows the strongest overall average utility and the lowest average hallucination score among the compared models on refusal-oriented HALOGEN categories. Model performance varies by category, with GPT-4 and Llama-2 7B chat performing well on historical events while Alpaca-7B shows relatively high utility on references. Several models still exhibit high hallucination or response ratios, especially on scientific attribution and false premises. GPT-4 leads in overall average utility and overall hallucination score among the listed models. Performance differs across refusal-based categories, with strong historical-event results for GPT-4 and Llama-2 7B chat and a high reference utility score for Alpaca-7B. Many models show elevated hallucination or response ratios on scientific attribution and false premises, indicating continued difficulty in these categories.

The experiment shows that many unique hallucinated package names are not completely invented, because they also appear in pretraining corpora associated with the models. Coverage is substantial across model families, with the strongest matches in the larger Llama-3 setting and more moderate matches for OLMo, Llama-2 models, and GPT-3.5. The inspected examples suggest that these matches often involve local imports, generic placeholder names, deprecated or non-indexed names, or names from non-Python contexts. A considerable share of hallucinated package names can be traced to model pretraining data. Llama-3 models, especially the 70B model, show the highest coverage of hallucinated package names in C4. GPT-3.5 hallucinated packages also appear in OpenWebText, though at a lower rate than the strongest Llama-3 setting. Many matched names are not public package index names, but local imports, placeholder-like names, or names tied to classes and functions.

HALOGEN evaluates response generation and refusal-oriented abstention through task-specific decomposition and verification, spanning code, scientific attribution, summarization, simplification, biographies, historical events, and false premises. The model experiments show that factual reliability is domain dependent: leading models achieve the best overall behavior, while smaller or older models hallucinate more, and even strong systems remain prone to errors in simplification, biographies, rationalization, scientific attribution, and false premise refusal. Further analysis indicates that many hallucinations are not entirely invented; summarization failures often reflect incorrect use of the supplied context, and many hallucinated package names correspond to traces from pretraining corpora such as local imports, placeholders, or non indexed names.