Most search and retrieval-augmented generation systems score every passage on its own and ignore the citations, hyperlinks and other references that connect documents. This is called the document independence assumption. It fails on questions whose answer lies in how documents relate. One example is a multi-hop question, where the second document shares no words with the question. Another is a request to find work that broke from its predecessors, where relevance is defined by citation patterns rather than text. Existing fixes are expensive. Some re-encode documents together with their neighbors. Others walk the link graph step by step with a neural network, or run graph attention inside the retriever.
We propose a cheaper split. Keep encoding fully independent, so each document is embedded once and cached as usual. Then let a tiny learned operator spread the question's relevance scores over the link graph before ranking. That operator is a weighted sum of directed link-following steps, and the weights are predicted from the question. The weights can be negative, so the operator can learn "relevant because my citers point here" as well as "less relevant because my neighbors already cover it." Our claim is that relational reasoning in retrieval needs only a few dozen query-dependent numbers applied to cached scores, as long as those numbers are signed and direction-aware.
Core Claim
The idea borrows from decoupled graph neural networks. These are graph models that separate learning node features from spreading information along edges, so the spreading step can be a simple, deep, cheap linear operation. In Adaptive Universal Generalized PageRank Graph Neural Network (GPR-GNN), an MLP transforms node features, and learnable signed coefficients then mix successive powers of the adjacency matrix. The negative coefficients let it handle heterophily, meaning graphs where linked nodes tend to differ. GPR-GNN reaches roughly 91–92% on the Texas and Cornell web-page graphs, where coupled GCNs barely break 60%. That work studies node classification with fixed features, a single filter per graph and symmetrized edges.
We move the filter to a different object: the vector of first-stage relevance scores for one query. Let $s(q)$ be the dense-retriever scores of query $q$ over a candidate neighborhood. Let $P_m$ be a small basis of row-normalized directed walk operators built from the citation or link matrix $A$ and its transpose. The basis contains all words over $\{A, A^\top\}$ up to length three. It therefore includes "cited by," "cites," co-citation $A^\top A$ and bibliographic coupling $A A^\top$. The final score is
$$r(q) = \sum_{m=0}^{M} \gamma_m(q)\, P_m\, s(q),$$
where $P_0$ is the identity, $M=14$, and $\gamma(q)$ comes from a two-layer network on the query embedding. Training uses a listwise loss on gold supporting documents. Gradients reach only $\gamma$ and, optionally, the query tower; document embeddings stay frozen and independent.
Three things are new in this design. The filter acts on query-specific scores rather than shared node features. Its coefficients change per query. And it preserves edge direction, which the GPR-GNN family discards by symmetrizing.
Positioning Against Prior Work
The closest work is Rethinking Message Passing as Retrieval for Text-Attributed Graph Learning (RTA). RTA retrieves supporting nodes by mixing FAISS semantic similarity with fixed Personalized PageRank (PPR) proximity, a random-walk score that favors nodes reachable in a few steps. It then aggregates them with an MLP for node classification. We differ in three ways. Our propagation weights are learned, signed and query-conditioned rather than fixed and positive. Our target is document retrieval for question answering and literature search, not labeling nodes. And we avoid RTA's per-neighborhood LLM encoding, whose cost the file flags as prohibitive at scale.
SKETCH also separates aggregation from the language model. It finds neighbors with MinHash locality-sensitive hashing, a fast approximation of how much two nodes' neighbor sets overlap, and concatenates their text into an LM prompt. That prompt runs into the 8,000-token window and keeps only 1–2-hop overlaps. Our operator touches only scalars, so prompt length never limits its reach.
Coupled designs motivate the latency side of the proposal. CG-RAG runs Graph Transformer message passing over citation-linked chunks at about 404 ms per query. Learning to Retrieve Reasoning Paths over Wikipedia Graph uses beam search with an RNN over BERT embeddings. G-Retriever builds a connected subgraph with a prize-collecting Steiner tree and encodes it with a coupled GNN. Each of these pays neural cost per hop. We bet that most of their gain comes from the structural signal itself, which a linear operator can carry.
SciNet motivates the signed, directed part. Agents there reach over 60% topical consistency but only about 14% citation-path connectivity, and under 5% Recall@50 when finding disruptive papers. Disruption is by construction a signed, directional pattern: a paper's citers do not also cite its references. A low-pass filter cannot represent that pattern, but a signed combination of $A^\top$ and $A^\top A$ can.
Two results constrain the design. Dissecting the Diffusion Process in Linear GCNs shows that over-smoothing comes from tying diffusion time to step count. Tree Decomposed GNN shows that keeping hops as separate signals avoids dilution. Both support using separate per-operator coefficients rather than one repeated layer.
Research Program
We will build the operator on top of a standard dense retriever. Candidates are the top-200 seeds plus their directed two-hop neighborhoods. Every candidate is scored by a cached dot product, so propagation is a handful of sparse matrix–vector products. To produce chains for path tasks, we decompose $r(q)$ by operator and edge, and trace the walks that contributed most to each top document.
The analysis has two parts. First, we inspect the learned $\gamma(q)$ by query type, testing whether bridge-style questions load on $A$ and $A^\top$ while disruption queries load negatively on coupling terms. Second, we measure how far the gain survives when the first-stage retriever is replaced by a link-aware encoder. That second measurement directly tests whether structure must sit in the scorer or can live in the weights.
Baselines
The naive reference point is the same dense retriever with no graph, ranking by $s(q)$. Any structural method must beat it at equal candidate budget. The second naive baseline adds every one-hop link neighbor of the top-$k$ documents and reranks them by $s(q)$. It tests whether simply reaching linked documents is enough.
The strongest cheap competitor is fixed PPR seeded by $s(q)$, which mirrors the structural half of RTA. We will tune its restart probability and mixing weight on the same development set, with the same grid size as our $\gamma$-network hyperparameters.
On HotpotQA full-wiki, the strongest published system is the graph-based recurrent retriever of Asai et al., which reports 73.0 F1 end to end. We will feed our top paths into the same style of BERT reader. Beating that system means matching or exceeding 73.0 F1 at markedly lower retrieval latency. The file gives no retrieval-recall figure (no reported result found on Lacuna for HotpotQA supporting-document recall), so we will rerun their released retriever, if available, to obtain recall.
On PubMedQA-1k and PapersWithCodeQA, the target is CG-RAG at Hit@1 0.961 and accuracy 0.835, with 404 ms latency. We aim to match its accuracy within noise at a fraction of that latency, using the same generator.
On SciNet, the reference points are the agent results already reported: Recall@50 under 5% on ego-centric tasks and about 14% path connectivity. No reported result found on Lacuna for a graph-diffusion retriever on SciNet, so fixed PPR serves as the structural baseline there.
Three ablations isolate the key ingredients. Constraining $\gamma \ge 0$ yields a learnable low-pass filter and isolates the sign. Replacing $A$ with its symmetrized form isolates direction. Making $\gamma$ a single global vector isolates query conditioning. As a sanity check that the filter works at all, we run the node-feature version on Texas and Cornell and expect it to recover GPR-GNN's roughly 91–92%.
Fairness rules apply to every comparison: identical encoders, identical candidate sets, identical readers or generators, and equal tuning trials.
Why not just…?
Why not just use fixed Personalized PageRank from the seed documents? This is the most serious threat. On homophilic multi-hop QA, where the bridge document is simply linked to relevant ones, PPR may capture almost all of the gain. GPR-GNN shows that fixed positive weights collapse on heterophilic graphs, but that evidence comes from node classification, not retrieval. The non-negative and fixed-PPR ablations settle the question. If PPR matches us on HotpotQA and PubMedQA but loses on SciNet disruption and path tasks, the scope narrows honestly to relational literature search. If PPR matches everywhere, the signed operator is not needed and we will report that.
Why not just make the encoder link-aware, as LinkBERT or GLEM do? LinkBERT pretrains on linked document pairs and gains +5% F1 on HotpotQA. GLEM distills graph pseudo-labels into an LM that can then work without edges. Both show that structure can live in weights, which is a real alternative. However, weights fixed at training time cannot express query-specific relations such as "papers whose citers ignore their references" over a corpus that changes after training. We will run our operator on top of a LinkBERT-initialized retriever. Gains that persist would show the two are complementary. Gains that vanish would mean link-aware encoding suffices for these benchmarks.
Why not just put more retrieved passages into a long-context LLM? SciNet's deep-research agents with large contexts still fall below 20% on relation-aware tasks. SKETCH needed aggressive pruning even at 8,000 tokens. G-Retriever's ablation found that flattened text alone loses 22.5% relative to adding a structural signal. Our experiments include a top-50 concatenation baseline with the same generator, to confirm that this pattern holds here.
Why not just reformulate the query iteratively with an LLM? Asai et al. report that semantic retrieval trails graph-path retrieval by over 14 F1 on HotpotQA, because the bridge document lacks query terms. An iterative-reformulation baseline using the same generator for rewriting, with three rounds, will measure the gap and the latency of each approach directly.
Proposed Experiments
The decisive experiment is SciNet's ego-centric and path-wise tasks. If the signed, directed, query-conditioned operator lifts disruption Recall@50 and path connectivity well above both fixed PPR and its own non-negative ablation, the central claim holds. If it does not, the heterophily argument fails for retrieval. Learned $\gamma(q)$ with negative mass on coupling operators for those queries would be the mechanistic confirmation.
The secondary experiments are HotpotQA full-wiki against the 73.0 F1 reference, and PubMedQA-1k and PapersWithCodeQA against CG-RAG's 0.961 and 0.835. In each case we report accuracy alongside per-query latency, which is where decoupling should pay off. The LinkBERT-encoder variant then shows whether a decoupled scoring step remains useful once the encoder has already absorbed the links.
References
- Adaptive Universal Generalized PageRank Graph Neural Network
- Rethinking Message Passing as Retrieval for Text-Attributed Graph Learning
- Taming Language Models for Text-attributed Graph Learning with Decoupled Aggregation
- CG-RAG: Research Question Answering by Citation Graph Retrieval-Augmented LLMs
- Learning to Retrieve Reasoning Paths over Wikipedia Graph for Question Answering
- G-Retriever: Retrieval-Augmented Generation for Textual Graph Understanding and Question Answering
- SciNet: Evaluating AI Agents in Relation-Aware Scientific Literature Retrieval
- Dissecting the Diffusion Process in Linear Graph Convolutional Networks
- Tree Decomposed Graph Neural Network
- LinkBERT: Pretraining Language Models with Document Links
- Learning on Large-scale Text-attributed Graphs via Variational Inference