Automatic fact-checkers often split a long claim into small "atomic" statements, check each one against retrieved evidence, and combine the verdicts. The appeal is easy to see: a fluent paragraph can hide one false detail, and small statements are easier to check. Splitting also breaks things. "Einstein developed relativity in Zurich" turns into "Einstein developed relativity" and "Einstein developed something in Zurich". The second atom no longer says what was developed. It retrieves irrelevant evidence, and a verifier can mark it true for the wrong reason. An empirical audit of this pipeline found that splitting helps weak verifiers on complex inputs but often hurts strong verifiers on simple ones, and traced the damage to lost context, ambiguous references, over-splitting, and altered meaning (Decomposition Dilemmas).
We propose to borrow one device from logic: the definer. In description logics, the formal languages behind large medical ontologies, a reasoner flattens a deeply nested axiom by naming each inner sub-expression with a fresh symbol and stating that symbol's definition as its own small axiom. Every resulting axiom is simple, and the set as a whole still says exactly what the original said (Pushing the EL Envelope; Uniform Interpolation and Forgetting for ALC Ontologies with ABoxes). Applied to claims, this gives atoms that stay small for the verifier while carrying explicit handles, such as "D1 = Einstein's development of relativity", that link them to the rest of the claim. The handles serve two purposes. When building a search query we can expand a handle back into its full description, so retrieval sees the whole context. When checking, the verifier still sees only one assertion at a time.
Core Claim
Two of the four decomposition error types identified by Decomposition Dilemmas, omission of context and over-decomposition, are errors of lost binding: the atom is true on its own but no longer refers to the right thing. Retrieval noise follows from the same cause. We claim that a decomposition in a small, checkable normal form, built from property atoms, relation atoms, and definer atoms whose arguments are named entities or definers, removes most binding loss. It should reach at least the accuracy of no decomposition for strong verifiers, keep the gains of decomposition for weak ones, and do so at lower retrieval cost than copying context into every atom.
What is new is not "decompose more carefully". Three things are. The bindings are made explicit and machine-checkable. Retrieval context is separated from the verification target. And the formal guarantee that normal forms preserve meaning, which holds by construction in logic, is treated as an empirical property to be measured on natural language.
That last point is where the third direction, the gap between formal guarantees and empirical behavior, comes in as a method. In Pushing the EL Envelope a normalized ontology is equivalent to the original by proof. For language-model-produced normal forms that equivalence is only a hope. We will measure it with a round-trip test and report where it fails.
Relation to Prior Work
Some prior work motivates the proposal. Decomposition Dilemmas documents the accuracy-noise trade-off and tries a prompt-based self-reflection fix, but does not change the representation of the atoms. NLI under the Microscope decomposes inference hypotheses into atoms and shows that models label the whole correctly while getting parts wrong, or the reverse. GPT-4o reaches 88.5% accuracy on SNLI but only 87.9% consistency across atoms. That paper diagnoses inconsistency without offering a way to enforce consistency; definer-bound atoms with conjunctive aggregation are one such way.
Two papers are the closest competitors on method. A Closer Look at Claim Decomposition grounds a few-shot decomposer, $D_{R\text{-}ND}$, in neo-Davidsonian semantics, the analysis that treats events as things that can carry properties. Its output is maximally atomic natural-language sentences with no explicit event or entity variables. Our grammar keeps the neo-Davidsonian insight but writes the event variable out as a definer, so atoms can share it. Optimizing Decomposition for Optimal Claim Verification (DYDECOMP) learns, with reinforcement learning, how finely to split for a given verifier. It tunes granularity but produces free text fragments with no links between them, and it must be retrained per verifier. Our proposal leaves granularity fixed by the grammar and repairs linkage instead. The two ideas are complementary, and we test whether linkage alone recovers most of DYDECOMP's benefit.
Other work constrains the design. Aristotle translates premises fully into logic, normalizes them to clausal form, and runs resolution. It does well on synthetic logic benchmarks but reaches 31.2% on LogiQA against 65.6% for chain-of-thought, because open-world text relies on unstated commonsense knowledge. We take this as a warning against full formalization. Our atoms stay in natural language and are checked by a natural-language-inference verifier (a model that judges whether evidence supports a statement), not by a theorem prover. Only the binding structure is formal.
From Chaos to Clarity rewrites noisy social posts into one clean standalone claim. Its "normalization" is rewriting, not decomposition, and it is a natural upstream step for our method.
Research Program
The decomposer is a language model prompted to emit a typed output in three atom shapes, modeled on the three normal forms of the lightweight description logic in Pushing the EL Envelope:
- a property atom, "X has property A";
- a relation atom, "X stands in relation R to Y";
- a definer atom, "D is the [event or entity] such that …".
Here X and Y are named entities or definers. A deterministic parser rejects any output that breaks the grammar, for example an atom with two predicates or a definer that is used but never defined, and triggers one re-prompt. Because the format is parseable, two operations become mechanical rather than left to the model. Unfolding replaces a definer by its definition, giving a full-context search query. Rendering shows the verifier an atom with each definer replaced by a short anchoring phrase.
Each definer atom is retrieved for and verified once, then reused wherever the definer appears. This sharing is what should keep cost below that of copying context into every atom. A claim counts as supported only if all its atoms, including definer atoms, are supported. This conjunctive rule is the aggregation that the consistency constraint of NLI under the Microscope requires.
The empirical validation strand has two parts. First, a round-trip test: we reconstruct a sentence from the normalized atoms by fully unfolding and conjoining them. We then measure two-way entailment between that reconstruction and the original, using an inference model plus human judgment on a sample. This tells us how often the "meaning-preserving" property actually holds. Second, an error analysis: annotators label a sample of decompositions from every method with the four-category taxonomy of Decomposition Dilemmas. This tests directly whether definers reduce omission of context and over-decomposition without increasing alteration of meaning.
Baselines
No decomposition. The naive reference point verifies each claim whole, with retrieval on the full claim. Decomposition Dilemmas reports that this often beats decomposition for strong verifiers on simple claims such as WICE. Our method must match it within noise on WICE with strong verifiers, or the proposal fails.
Standard decomposers. The FActScore- and VeriScore-style decomposers used in that audit are run through the identical retrieve-verify-aggregate pipeline. We use the same retriever, the same number of retrieved passages per query, and the same verifiers. We include the paper's self-reflection variant, since it is that paper's own repair attempt.
$D_{R\text{-}ND}$. The prompt from A Closer Look at Claim Decomposition is the strongest prompting baseline on decomposition quality. The paper reports a DecompScore of 42.3, against about 32 for the FActScore decomposer and 20.0 for the WiCE decomposer, on 500 biographies from 12 language models. We rerun DecompScore on the same biography setting. Beating this baseline means matching or exceeding its DecompScore while showing higher claim-level verification accuracy downstream.
DYDECOMP. Optimizing Decomposition for Optimal Claim Verification is the strongest learned baseline. It is trained per verifier with its label-free confidence reward, which the authors support with a 0.88 Pearson correlation between verifier confidence and accuracy. The file reports no claim-level verification accuracy for it, so we found no reported result on Lacuna for DYDECOMP's accuracy on WICE, FELM or BINGCHAT, and we will reproduce it ourselves. For fairness we give it the same verifiers, and we give our prompts a comparable tuning budget measured in development-set evaluations. Beating it means equal or better accuracy without per-verifier training.
Copied context (decontextualization). Every atom is rewritten to be standalone by inlining the context it depends on, the coreference-resolution approach the research file attributes to Landwehr. This baseline isolates the key ingredient of our proposal.
Ablations of our own system. We run three:
- definers without unfolding at retrieval time;
- unfolding at retrieval without separately verified definer atoms;
- the same prompt with the grammar checker switched off.
Why not just…?
Why not just use a strong verifier and skip decomposition? For simple claims this may be the right answer, and Decomposition Dilemmas says so. The same audit shows decomposition still wins when inputs exceed the verifier's capacity, as with the multi-sentence responses in FELM. Our goal is a method that does not lose on WICE and still wins on FELM. If no decomposition matches us on FELM with GPT-4o-class verifiers, the case for definers narrows to weak and cheap verifiers. We would report that outcome as it stands.
Why not just decontextualize each atom? This is the real threat. Inlining context fixes binding loss directly. The cost is atoms that grow back toward the original sentence, which reintroduces the complexity decomposition was meant to remove and multiplies retrieval over repeated context. The copied-context baseline settles the question. If it matches our accuracy at similar cost, the definer machinery adds nothing and we drop the claim. We expect the two to separate on claims with nested modifiers, where inlined atoms become long. We also expect a separation in cost, since shared definers are retrieved and verified once.
Why not just learn the granularity, as DYDECOMP does? Learned granularity can avoid over-splitting by not splitting. But a coarser fragment still carries no explicit link to the other fragments, and the policy must be retrained for each verifier. If DYDECOMP alone closes the gap, linkage is unnecessary. If the gap persists on claims where DYDECOMP splits, linkage is doing distinct work. The comparison stratified by claim depth, described below, shows which.
Why not go fully formal, as Aristotle does? The 31.2% versus 65.6% LogiQA result in Aristotle shows what happens when open-world text is forced into a closed logic. We keep the formal part to the bindings alone.
Proposed Experiments
The main experiment runs every method on WICE, FELM and BINGCHAT, the benchmarks of Decomposition Dilemmas. We cross each method with three verifiers: a weak open model (Llama-3-8b, as in NLI under the Microscope), MiniCheck, and GPT-4o. We report claim-level balanced accuracy and macro-F1, plus tokens and retrieval calls per claim. The file gives no per-method accuracy figures for these benchmarks, so we found no reported result on Lacuna for those numbers, and all baselines are rerun under one pipeline.
The secondary experiment measures DecompScore on the 500-biography setting of A Closer Look at Claim Decomposition to compare decomposition quality directly. A third measures atom-level consistency on decomposed SNLI hypotheses, following NLI under the Microscope, to test whether conjunctive aggregation over definer-bound atoms closes the reported gap between accuracy and consistency. As a stress test, we apply the method to normalized claims from the CLAN dataset of From Chaos to Clarity to see whether rewriting followed by definer decomposition improves retrieval precision at rank k over rewriting alone.
Three decisive checks follow, each phrased as a way the idea could fail.
First, a stratified analysis. We bucket claims by syntactic nesting depth, measured as the number of relative clauses, prepositional modifiers on events, and temporal or causal connectives. Our method's advantage over plain atomic decomposition and over copied context should grow with depth and be near zero at depth one. A flat advantage would mean the gain comes from prompt quality, not from binding.
Second, the error annotation. Definer outputs should show clearly fewer omission-of-context and over-decomposition errors than $D_{R\text{-}ND}$, with no rise in alteration-of-meaning errors. If definers merely move errors into the definitions, the round-trip entailment rate will show it.
Third, the strong-verifier floor on WICE. Falling clearly below no decomposition there would falsify the claim that binding loss is the main cost of decomposition.
References
- Decomposition Dilemmas: Does Claim Decomposition Boost or Burden Fact-Checking Performance?
- Pushing the EL Envelope
- Uniform Interpolation and Forgetting for ALC Ontologies with ABoxes
- NLI under the Microscope: What Atomic Hypothesis Decomposition Reveals
- A Closer Look at Claim Decomposition
- Optimizing Decomposition for Optimal Claim Verification
- Aristotle: Mastering Logical Reasoning with A Logic-Complete Decompose-Search-Resolve Framework
- From Chaos to Clarity: Claim Normalization to Empower Fact-Checking