Graph-Based Adaptive Redundancy Propagation

Updated 25 February 2026

Graph-Based Adaptive Redundancy Propagation is a framework that minimizes redundant message exchanges in GNNs to improve inference efficiency.
It employs strategies like redundancy-free neighbor selection and pruned neighborhood trees to mitigate over-smoothing, oversquashing, and excessive computational costs.
Empirical studies demonstrate enhanced accuracy and faster inference, making GBARP scalable for large and complex graph-based models.

Graph-Based Adaptive Redundancy Propagation (GBARP) refers to a class of algorithmic frameworks and theoretical tools designed to identify, control, and reduce redundant information exchange along the paths of propagation in graph-based models, particularly within message passing neural networks, graph neural networks (GNNs), and graphical model inference. Redundancy in this context encompasses both informational redundancy—repeated aggregation of the same node features along multiple graph traversal paths—and computational redundancy—duplicate or unnecessary computations arising from overlapping local structures. GBARP aims to optimize propagation so that each node or region aggregates only the minimal, non-duplicative set of information required for accurate inference or representation, thus addressing issues such as over-aggregation, over-smoothing, oversquashing, and convergence instabilities.

1. Redundancy in Graph Propagation: Definitions and Impact

Redundancy in message propagation arises when features from the same sources reach target nodes via multiple overlapping paths, leading to repeated aggregations and excessive mixing of information. In classical GCNs, the use of powers of the normalized adjacency $\hat A^k$ ensures that information from distant nodes must traverse low-order neighbors multiple times, resulting in over-aggregation. Theoretical bounds show that the average number of times low-order neighbors are aggregated to reach global information grows between $N-1$ and $2^{N-2}$ , where $N$ is the number of nodes (Lu et al., 18 Apr 2025). This redundancy is the root cause of over-smoothing, where representations lose their node-uniqueness and eventually focus on the stationary distribution rather than local features.

Graph-based adaptive redundancy propagation frameworks quantify redundancy by analyzing message paths—typically using combinatorial/unfolded trees, adjacency powers, or region graphs. In message passing neural networks, redundancy explicitly amplifies oversquashing, wherein influence from distant nodes is effectively squashed due to limited capacity and repeated recalculation of the same information (Bause et al., 2023).

2. Redundancy-Free Propagation Strategies

Several algorithmic paradigms have been developed to guarantee redundancy-minimal propagation.

Redundancy-Free Neighbor Selection (RF-GCN)

RF-GCN decomposes neighborhood aggregation so that each node aggregates information from its $\ell$ -hop neighbors exactly once by constructing disjoint adjacency masks $T_\ell$ for each hop distance (Lu et al., 18 Apr 2025). For node $i$ , the set of exactly $\ell$ -hop neighbors is

$\mathcal N_{i,\ell} = \{\,j \mid \mathrm{dist}(i,j)=\ell\},$

and the redundancy-free adjacency for this shell is $T_\ell = C_\ell - C_{\ell-1}$ , with $C_\ell$ representing the cumulative adjacency up to distance $\ell$ . Each $T_\ell$ is normalized, then adaptively weighted using, e.g., personalized PageRank-style coefficients $\theta_\ell$ , and aggregated across orders.

This yields a propagation operator

$\hat T = \sum_{\ell=1}^L \theta_\ell\,\hat T_\ell,$

guaranteeing each neighbor's signal is counted only once. Empirically, this construction stably improves accuracy as depth increases, mitigates over-smoothing, and delivers robust performance across homologous and heterologous node-classification and graph-level benchmarks.

Pruned Neighborhood Trees (DAG-MLP)

DAG-MLP builds on the concept of $k$ -redundant neighborhood trees, pruning the standard unfolding tree of message passing so that each original node appears at most $k+1$ times along any root-to-leaf path (Bause et al., 2023). The resulting trees are merged via canonicalization (AHU algorithm) into a DAG, allowing computational reuse of isomorphic subbranches. This significantly reduces both information and computational redundancy and strictly mitigates oversquashing compared to standard MPNNs.

Both frameworks demonstrate that removing redundant multi-hop paths/branches stabilizes deep propagation and increases expressive capacity on tasks demanding long-range dependency capture.

3. Node- and Structure-Adaptive Redundancy Propagation

Building on global redundancy pruning, recent advancements introduce node-wise and semantically adaptive propagation protocols.

Adaptive Topology-Aware Propagation (ATP)

ATP identifies “redundant propagation” as the repeated unnecessary mixing of high-degree node features and addresses it by a two-part mechanism: (i) High-Bias Propagation Correction (HPC), which randomly sparsifies edges of high-degree nodes to prevent over-smoothing and computational waste, and (ii) Local Node-Context (LNC) encoding, which learns propagation strengths per node based on degree, eigenvector centrality, and clustering coefficient (Li et al., 2024). ATP yields a node-adaptive propagation kernel:

$\tilde\Pi = \sum_{\ell=0}^k w_\ell\, \bigl([\hat D]^{\,\tilde R-1} [\hat A] [\hat D]^{-\tilde R}\bigr)^\ell$

where the exponent $\tilde R$ is node-specific, producing a fully personalized propagation operator that can be executed offline and is plug-and-play for any scalable GNN backbone.

Node-Adaptive Inference (NAI) and Halting Units

For real-time scalable inference, node-adaptive frameworks such as NAI select exit depths either by distance-to-stationarity ("distance-based") or via lightweight per-node gates ("gate-based"), both capable of flexibly trading off accuracy and latency by terminating redundant aggregation as soon as adequate “smoothing” is detected (Gao et al., 2023). Halting-unit-based models (e.g., AP-GCN) similarly train per-node classifiers that dynamically select the minimal number of propagation steps, with tuning via communication cost regularization (Spinelli et al., 2020).

Semantically aware adaptive sampling methods, such as AdaProp for knowledge graph reasoning (Zhang et al., 2022), leverage query- and relation-dependent incremental node sampling, learning layer-wise softmax samplers to prevent exponential blow-up of involved entities and to focus computation on the most relevant subgraphs.

4. Theoretical and Empirical Effects of Redundancy Control

Redundancy elimination provably bounds the average number of aggregations and preserves stronger self-feature attention. For RF-GCN, the average number of times low-order neighbors are aggregated per node is minimized to $N-1$ , and the self-attention score asymptotically has a lower bound strictly larger than $1/N$, preventing complete information dilution (Lu et al., 18 Apr 2025). In DAG-MLP, shortest-path preserving pruning tightens influence bounds and strictly reduces oversquashing relative to standard MPNNs (Bause et al., 2023).

Empirically, redundancy-reduced models consistently outperform fixed-depth and residual-connection GCNs:

On classical datasets (Cora, Citeseer, Pubmed), accuracy improvements up to 1.6% over the second-best are reported for RF-GCN (Lu et al., 18 Apr 2025).
Node-adaptive GNN inference achieves up to 75 $\times$ speedup with negligible (≤0.6%) accuracy loss on million-node graphs (Gao et al., 2023).
ATP integration provides ~4pp accuracy gains on large-scale graphs and reduces redundant edges by 15–20% (Li et al., 2024).

Ablation studies confirm that both redundancy-free selection and adaptive weighting are indispensable for performance; disabling either component induces noticeable degradation, especially in dense or complex networks.

5. Graphical Models and Redundancy Pruning Beyond GNNs

In generalized belief propagation (GBP), region graph redundancies cause the same message constraints to be imposed multiple times along overlapping paths, resulting in slow or non-convergent updates. The Simplified GBP (SGBP) framework uses zero-sum identities among region counting numbers to prune messages: only the "first-entry" of a message into any region’s ancestry is retained, while redundant downstream entries are eliminated (Wang et al., 2013). This reduces per-iteration costs and leads to convergence on challenging graphical models, including two- and three-dimensional spin glasses, where SGBP consistently tracks critical points better than naive GBP.

These pruning strategies are transferable to any class of graphical model with complex region/factor graphs, as the underlying zero-sum consistency condition is generic.

6. Limitations and Extensions

The principal limitations of GBARP frameworks include:

Computational overhead for redundancy-free adjacency construction or $k$ -redundant tree merging ( $O(LN^2)$ for dense graphs in RF-GCN, $O(n\,m\,k)$ in DAG-MLP) (Lu et al., 18 Apr 2025, Bause et al., 2023).
Challenges in extending naive formulations to directed, attributed, or dynamic graphs (Lu et al., 18 Apr 2025, Li et al., 2024).
Existing edge-masking in ATP treats all high-degree nodes equally, which may be suboptimal; future research may focus on learning more nuanced edge selection policies (Li et al., 2024).
State-of-the-art variants suggest hybridization with attention, rewiring, or regularization-based over-smoothing remedies could provide further gains.

Notably, GBARP frameworks are largely orthogonal to most existing GNN backbones and message-passing protocols, and can be incorporated as wrappers or pre-computation stages.

7. Applications and Practical Guidelines

Graph-Based Adaptive Redundancy Propagation enables:

Deep GNN architectures operating without over-smoothing or vanishing influence (Lu et al., 18 Apr 2025, Bause et al., 2023).
Efficient large-scale knowledge graph reasoning with query-aware propagation (Zhang et al., 2022).
Real-time inference on web-scale graphs under latency constraints (Gao et al., 2023, Li et al., 2024).
Scalable graphical model inference for combinatorial optimization and statistical physics (Wang et al., 2013).

Recommended guidelines include setting the propagation depth to the graph’s diameter, tuning adaptive weighting ( $\alpha$ in PPR, mask rates in ATP), and monitoring the per-layer average degree or information gain for diminishing returns. For very large graphs, block-diagonal or sampling approximations are advocated to further curtail computation (Lu et al., 18 Apr 2025, Li et al., 2024).

The use of node-wise and query-wise adaptive protocols is especially advantageous under heterogeneous topology, high-degree centers, or when queries are highly localized, as in reasoning, recommendation, or anomaly detection. The general framework is extensible to link prediction, dynamic graphs, and heterogeneous network scenarios.

References:

(Lu et al., 18 Apr 2025, Bause et al., 2023, Li et al., 2024, Gao et al., 2023, Zhang et al., 2022, Spinelli et al., 2020, Wang et al., 2013)