Automated fact-checkers decide whether a claim is supported or refuted by evidence. The most interpretable ones split the claim into small pieces, check each piece against the evidence, and combine the per-piece verdicts with a fixed rule: the claim is true only if every piece is true. That rule breaks on ordinary language. In "X did not win the award," "unless," "although," or "X was born in Y, not Z," the words that change the truth value attach to specific parts of the sentence. A flat list of pieces with a global AND loses those attachments. We propose to take the combination rule from the sentence's dependency tree. A dependency tree is the grammatical parse that links each word to the word it modifies, with typed links such as "subject," "negation," or "adverbial clause." Each subtree gets a latent truth value, and a small, fixed operator for each link type combines child values into parent values, from the leaves up to the root. The explanation is then the path through the tree that produced the verdict. When a claim is refuted, the system names the smallest grammatical unit responsible, together with any negation or condition that governs it.
The opportunity is concrete. LOREN extracts flat phrases from a constituency parse and combines their latent verdicts with soft AND/OR logic. It is faithful by construction, with over 96% agreement between the final label and its phrase logic, and it reaches 74.3 F1 on culprit identification. Its authors name negation attached across dependency links, conditional clauses, and double negatives as the things it cannot handle. QA-NatVer runs a finite-state automaton over natural-logic operators, but it cuts text into linear windows that can separate a head word from its modifiers, and its automaton reads left to right rather than over a tree. The one system that verifies claims with dependency trees, DepChecker, extracts product–attribute–value triples with hand-written rules and matches them against e-commerce catalogs. It has no logical composition and no open-domain evidence.
Core Claim
Making the dependency tree the structure of the latent logic, rather than using it as a feature source, gives three things that flat decomposition and dependency graph neural networks do not. The first is correct verdicts on claims whose truth depends on where a negation, condition, or contrast attaches. The second is culprit explanations that come as whole grammatical units instead of fragments. The third is sub-claims that keep their modifiers, which reduces the context-omission failures that Decomposition Dilemmas and FactLens identify in LLM-generated decompositions. We expect the gain to appear mainly on the slice of claims containing scope-bearing words. On plain FEVER we expect parity with LOREN, and we state that expectation in advance.
Research Program
The model has three parts. The first is a unit extractor. It parses the claim and collapses multiword expressions into single nodes, in the spirit of phrase dependency parsing (Qi Zhang et al.). It then defines a verifiable unit as a content-bearing node together with the modifiers that must stay bound to it, such as adjectival and numeric modifiers, compound names, and case markers. Words that act as operators become labels on the links between units rather than units of their own. These include "not" and "never," conditional and concessive markers, and modal verbs.
The second part is local premise construction, following LOREN's reading-comprehension probing. There is one change: the probing question for a unit is generated from its dependency subtree plus the path from that subtree to the root. The question therefore carries the context needed to retrieve the right evidence. This is the atomicity-versus-sufficiency balance that FactLens describes, enforced by grammar rather than by prompting.
The third part is tree aggregation. Each node $v$ holds a distribution $q_v$ over {Supported, Refuted, Not-enough-info}. This distribution comes from a local verifier that reads the unit, its premise, and the evidence. It is then composed with the node's children:
$$q_v = \mathrm{AND}\big(\ell_v,\; T_{r_1} q_{c_1},\; \dots,\; T_{r_k} q_{c_k}\big)$$
Here $\ell_v$ is the local verdict, $c_1,\dots,c_k$ are the children of $v$, and $r_i$ is the type of the link to child $c_i$. $T_r$ is a fixed 3×3 operator for that link type: the identity for ordinary arguments, a swap of Supported and Refuted for negation, and a map for modal or conditional links that sends Refuted toward Not-enough-info. AND is LOREN's soft conjunction. The claim label is $q_{\text{root}}$. The operators are not learned, so the explanation cannot drift from the computation. The only learned parts are the local verifier and the premise generator, both trained with LOREN's teacher–student distillation. The culprit is the lowest node whose composed value is Refuted while all of its children are not Refuted.
We will also study where the fixed operators are wrong. Candidate failure cases are double negatives, scope ambiguity, and negation words that are lexicalized, such as "unhappy." We will study robustness to parser errors by swapping parsers and by corrupting links at controlled rates. We will also test a de-lexicalized variant, where entity nodes inside the tree are replaced by placeholders. This follows the observation of Nguyen et al. that abstracted trees reduce vocabulary overfitting, and it tests whether tree-structured verification reduces reliance on memorized entity knowledge.
Baselines
The naive reference points are the FEVER claim-only and evidence-concatenation baselines. These are the numbers that define "doing nothing" on the benchmark (FEVER reports 50.91% accuracy without evidence).
The strongest existing competitor is LOREN itself, because it is the only interpretable system that has faithful latent logic, culprit localization, and competitive accuracy together. It reports a 72.93 FEVER blind-test score with RoBERTa-large and 74.3 culprit F1. We will rerun it with the same retriever, the same RoBERTa-large backbone, the same premise generator, and the same hyperparameter search budget. Our model then differs only in unit extraction and aggregation. Beating LOREN means a statistically significant accuracy gain on the scope-bearing slice and on Symmetric FEVER, no loss beyond noise on the full FEVER dev set, and higher culprit F1 on a new annotated set of refuted claims.
QA-NatVer is the strongest faithful-by-construction alternative. It reports 70.3% FEVER accuracy with Flan-T5 and beat ProofVER by 4.3 points in the 32-shot setting. We will run it with the same backbone in both few-shot and full-data regimes. KGAT, with a 70.38 FEVER score, is the non-interpretable graph reference.
We add an LLM decompose-then-verify pipeline in the FactScore style, with and without self-reflection, as studied in Decomposition Dilemmas. It uses the same local verifier, so that only the decomposition differs.
Two ablations isolate the key ingredient. The first keeps our dependency-bound units but replaces tree aggregation with LOREN's flat AND. This separates better units from better composition. The second keeps tree aggregation but replaces the fixed operators with a learned gated graph network over the same tree. This tests whether symbolic operators matter beyond having a tree at all.
Why not just…?
Why not just prompt an LLM to decompose the claim? LLM decomposition fabricates content, and FactLens finds fabrication to be the most damaging error for downstream verification. Decomposition Dilemmas shows decomposition often hurts on simple claims such as those in WICE. The strongest form of this alternative is self-reflective decomposition, which raised BINGCHAT F1 from about 24.7 to 67.70 in that paper; the research file lists the starting value as both 24.71 and 24.91. This is a real threat. We run it with the same local verifier and aggregate its sub-claims with flat AND. If it matches our model on the scope-bearing slice, the tree adds little, and we will report that.
Why not just run a graph neural network over the dependency tree? Graph models can use structure without reasoning over it. EX-FEVER found that GEAR gained little even when given gold explanations. The learned-operator ablation tests this directly. It could match our model on accuracy, but its attention weights do not have to agree with its verdict. We will measure faithfulness with LOREN's agreement metric and with counterfactual edits, such as inserting or removing a negation, and compare both models on it.
Why not just give LOREN a stronger backbone or finer phrases? Finer flat phrases do not tell the system which phrase a negation governs, so no amount of backbone capacity turns "not X" under a global AND into a correct verdict. The first ablation, dependency units with flat AND, is exactly this alternative. If it recovers most of the gain, the contribution is unit extraction and not tree logic.
Proposed Experiments
We will evaluate verification on FEVER, Symmetric FEVER, and anonymized FEVER. The last is where Pratapa et al. show KGAT dropping from 77.5% to 74.3%. We will also evaluate on the multi-hop claims of EX-FEVER and the 733 complex claims of FactLens, where fine-grained verifiers reach about 80% F1 against 55–60% for holistic ones.
We will build a scope-bearing slice of FEVER dev by selecting claims whose parse contains negation, conditional or concessive markers, or modal verbs. We will add a counterfactual set made by minimally inserting or removing a negation, so that the gold label flips. We will also annotate about 300 refuted claims with culprit subtrees, extending LOREN's 100-claim protocol. For decomposition quality, we will score our units on FactLens's six dimensions and on the four-way error taxonomy of Decomposition Dilemmas.
Two checks decide the outcome. The first is accuracy on the counterfactual negation set: our model should flip its label when gold flips, and flat-AND LOREN should not. The second is the gap between the flat-AND and fixed-operator versions on the scope slice. If both checks show no difference, the tree adds nothing beyond better chunking, and we would narrow the claim to decomposition quality. Parser-corruption curves will show how much of any gain survives on noisier text.
References
- LOREN: Logic-Regularized Reasoning for Interpretable Fact Verification
- QA-NatVer: Question Answering for Natural Logic-based Fact Verification
- Fact Checking Machine Generated Text with Dependency Trees
- Decomposition Dilemmas: Does Claim Decomposition Boost or Burden Fact-Checking Performance?
- FactLens: Benchmarking Fine-Grained Fact Verification
- Phrase Dependency Parsing for Opinion Mining
- Convolution Kernels on Constituent, Dependency and Sequential Structures for Relation Extraction
- FEVER: a Large-scale Dataset for Fact Extraction and VERification
- Kernel Graph Attention Network for Fact Verification
- EX-FEVER: A Dataset for Multi-hop Explainable Fact Verification
- Constrained Fact Verification for FEVER