When a language model answers a question from retrieved documents, it can get a fact wrong in two different ways. It can fabricate, writing a name or number that appears nowhere in the sources. Or it can misbind, writing a name that does appear in the sources but in the wrong role: the donor's attribute given to the recipient, or the first hop's entity given as the final answer. Copy mechanisms target the first failure. The best known is the pointer-generator, a decoder that at each step mixes "generate from the vocabulary" with "copy a token the model is attending to in the input." Copying cannot help with the second failure, and it may make it worse. Attention-based copying favors whatever span is most salient, and in multi-document questions the most salient span is often a distractor.
We propose to move the copy target from tokens to entities. Retrieved documents are turned into a small graph of entity mentions. Each mention node keeps a state vector that is updated with a gated recurrent unit (GRU), a learned gate that decides how much of a node's old state to keep and how much new neighbor evidence to absorb. The decoder's pointer then chooses among entity nodes instead of raw tokens. The graph also keeps updating while the answer is written: each entity the decoder copies is sent back into the graph as a message, so the graph records which hop of the question has already been resolved. The claim is that this specifically lowers misbinding in long-form multi-hop answers without increasing fabrication, a split that existing copy-augmented models have never measured.
Core Claim
Token-level copying in large language models (LLMs) is now cheap and effective. LargePiG turns a frozen LLM into a pointer-generator at inference time by using self-attention as the copy distribution, and it beats layer-contrastive decoding (DoLa) on truthfulness metrics at about 6% latency. FiD-PGN adds a 1,537-parameter copy layer to Fusion-in-Decoder and raises NaturalQuestions exact match from 48.5 to 51.4. Both copy from flat token sequences, and both pick what to copy using the decoder's attention alone. Neither has any representation of how the entities in the sources relate to each other or to the question.
On the other side, Entity-GCN shows that gated relational message passing over an entity-mention graph keeps each mention's identity while it absorbs cross-document evidence, reaching 67.6% single-model accuracy on WikiHop. It is purely a classifier and cannot write a sentence. The gating idea comes from Gated Graph Sequence Neural Networks, which unrolls GRU node updates for a fixed number of steps. Those graphs are static during inference.
Our contribution is the coupling of the two. The pointer's support over entity nodes comes from gated multi-hop graph states. The graph is advanced by further gated steps conditioned on what the decoder has already emitted. We predict that this reduces misbound entity mentions relative to token-level copying at a matched fabrication rate. We also predict that most of the gain disappears if either the gating or the decode-time update is removed. If the predicted split does not appear, the proposal fails cleanly.
Research Program
Graph construction. For each question and its retrieved passages, we build an entity-mention graph in the style of Entity-GCN. It uses same-document edges, exact-match edges across documents, and question-to-mention edges. Entity-GCN reports that coreference edges from an off-the-shelf resolver hurt accuracy on unmasked text. Because noisy edges are exactly the failure gated propagation is supposed to tolerate, coreference edges are an ablation, not part of the default. Node states are initialized from the backbone's own hidden states, mean-pooled over each mention's span. This keeps the graph in the same representation space as the decoder.
Encoding. We run $T$ GRU message-passing steps conditioned on the question, as in GG-NNs, to produce node states $h_v$.
Entity-level pointer. At decoding step $t$ with decoder state $s_t$, the next-token distribution mixes the vocabulary with a distribution over nodes:
$$P(w) = p_{\text{gen}}\,P_{\text{vocab}}(w) + (1-p_{\text{gen}})\sum_{v:\ \text{first}(v)=w} \alpha_{t,v}, \qquad \alpha_{t,v} = \mathrm{softmax}_v\big(s_t^\top W h_v^{(t)}\big).$$
Here $\alpha_{t,v}$ is the pointer weight on node $v$ and $\text{first}(v)$ is the first token of $v$'s surface span. Once a node is selected, the rest of its span is emitted verbatim. The gate $p_{\text{gen}}$ is predicted from $s_t$ and from $\max_v \alpha_{t,v}$. If no node is well supported, the model is pushed toward vocabulary text, where it can write a hedge or say the question is unanswerable, rather than toward a confidently copied distractor.
Decode-time gated update. After the decoder copies node $u$, every node takes one more GRU step:
$$h_v^{(t+1)} = \mathrm{GRU}\big(h_v^{(t)},\ m_v^{(t)} + \mathbb{1}[v=u]\,U s_t\big),$$
where $m_v^{(t)}$ is the usual aggregated neighbor message and $U$ projects the decoder state into the graph. This is how the graph learns that hop one is done and that support should now flow to the neighbors of $u$. GG-NNs and Entity-GCN never do this, because their graphs are frozen during inference. It is also our answer to the error-compounding loop the hallucination literature describes (Siren's Song): intermediate reasoning is carried in bounded gated vectors rather than in free-form text that the model then conditions on.
Training. We train with cross-entropy plus a node-supervision loss on intermediate entities. MuSiQue's single-hop composition (MuSiQue) provides gold intermediate answers for every hop. We implement the method at two scales. The first is T5-base Fusion-in-Decoder, which allows a direct comparison with FiD-PGN. The second is a 7B decoder-only model with low-rank adapters, which allows comparison with LargePiG. The graph module is small relative to either backbone.
Task. Short-answer QA is the wrong test, because an extractive graph reader already solves it. The target output is a long-form answer that names the bridge entities: "X was directed by Y, who was born in Z." Every entity slot in such an answer can be scored as correct, misbound, or fabricated.
Baselines
Plain retrieval-augmented generation. The naive reference point is the same backbone, fine-tuned on the same long-form targets, with the retrieved passages concatenated into the context and no copy mechanism. It tells us how much fabrication and misbinding exist before any intervention.
Token-level copying (the strongest existing competitor). At T5-base scale this is FiD-PGN, the most direct prior answer to "add copying to a retrieval reader." It is run with the same retriever, the same 25 passages it reports needing, the same targets, and the same tuning budget. As a reproduction check on NaturalQuestions it should land near its reported 51.4 exact match (FiD-PGN). At 7B scale the competitor is LargePiG applied to the concatenated passages. It is training-free, so we also give it a fine-tuned backbone to equalize data. The file textualizes no LargePiG numbers ("no reported result found on Lacuna for LargePiG on MC1/MC2/MC3 values"), so it is rerun rather than quoted. Beating these baselines means a statistically reliable reduction in misbound slots with fabrication no higher, and answer F1 no lower.
Extractive graph reader plus verbalizer. An Entity-GCN-style reader picks the answer and intermediate nodes. A separately prompted LLM then writes the sentence around them. As a sanity check, the reader alone on WikiHop should approach the reported 67.6% (Entity-GCN).
Ablations isolating the key ingredients. Three ablations remove one piece each. The first replaces the GRU update with an ungated graph convolution, testing the gating. The second freezes the graph after encoding, removing the decode-time update. The third keeps the full graph but points at tokens weighted by node support instead of at nodes.
Lexical constraint. Constrained decoding restricts entity spans to strings that appear in the retrieved text. This should drive fabrication to near zero while leaving misbinding untouched, so it separates the two error types cleanly.
Why not just…?
Why not just use LargePiG or FiD-PGN on the concatenated passages? Both decide what to copy from attention over flat sequences. In disconnected-shortcut settings, attention is known to latch onto surface overlap: single-hop models lose about 30 F1 moving from HotpotQA to MuSiQue (MuSiQue). That is the profile of misbinding, not fabrication. This alternative is the main threat. If token copying already matches us on misbinding at the MuSiQue intermediate slots, the graph adds nothing. The head-to-head comparison above settles it.
Why not just retrieve and prompt a strong LLM with chain-of-thought? In HaluEval, chain-of-thought helped hallucination recognition in summarization (58.53% to 61.21%) but hurt it in QA and dialogue (HaluEval). Retrieval-grounded ChatGPT still left 16.37% of outputs hallucinated in CHATREPORT. We include a chain-of-thought plus retrieval run on the same backbone and score its rationale slots with the same misbinding metric. That makes the comparison about bound entities rather than final-answer accuracy.
Why not just run an extractive graph reader and template the answer? For single-entity answers this probably works as well as our method, which is why we abandoned short-answer QA as the target. A pipeline can still misbind when the verbalizer writes intermediate entities the reader never selected. It also cannot hedge on partially supported chains. We measure both on long-form targets and on MuSiQue-Full's unanswerable questions. If the pipeline matches us there, the honest conclusion is that tight coupling is unnecessary.
Why not just constrain decoding to source strings? This eliminates fabrication and nothing else. If it alone closes most of the gap, then misbinding was never the dominant error, and the motivation of this proposal is wrong. Reporting it as a baseline makes that outcome visible.
Proposed Experiments
The primary benchmark is MuSiQue-Ans, with 2–4 hops and gold intermediate answers. Each generated entity slot is labeled correct, misbound (present in the sources but wrong), or fabricated (absent from the sources). We also report answer F1 and support F1, with human references at 78.0 and 93.9. No model baseline number is reported in the file, so all systems are rerun.
MuSiQue-Full tests abstention. Low maximum node support should trigger a refusal written from the vocabulary rather than a copied guess.
HotpotQA distractor gives a secondary multi-hop setting with supporting-fact labels. Its reported BiDAF answer F1 is 58.28 (HotpotQA), which serves only as a floor.
NaturalQuestions checks that the graph does not hurt single-hop QA relative to FiD-PGN's 51.4.
As a side test, the node-support score $\max_v \alpha_{t,v}$ is used as a hallucination detector on HaluEval's QA split, which is seeded from HotpotQA. The reference points are ChatGPT's 62.59% accuracy without knowledge and 76.83% with knowledge.
The decisive check is the misbinding rate on MuSiQue intermediate slots for the full model against token-level copying, holding fabrication equal. This is broken down by hop count. The prediction is that the gap widens with more hops, because that is where decode-time hop tracking should matter.
The two causal checks are the gated-versus-ungated ablation and the frozen-versus-updated graph ablation. If neither ablation degrades misbinding, the gated memory is not doing the work. Coreference-edge injection gives a robustness check that tests whether gating absorbs noisy edges better than plain convolution, the failure Entity-GCN reported.
References
- LargePiG: Your Large Language Model is Secretly a Pointer Generator
- A Copy-Augmented Generative Model for Open-Domain Question Answering
- Question Answering by Reasoning Across Documents with Graph Convolutional Networks
- Gated Graph Sequence Neural Networks Yujia Li
- Siren's Song in the AI Ocean: A Survey on Hallucination in Large Language Models
- ♫ MuSiQue: Multihop Questions via Single-hop Question Composition
- HaluEval: A Large-Scale Hallucination Evaluation Benchmark for Large Language Models
- CHATREPORT: Democratizing Sustainability Disclosure Analysis through LLM-based Tools
- HotpotQA: A Dataset for Diverse, Explainable Multi-hop Question Answering