Efficient Curvature-Aware Graph Network

• The paper introduces an Efficient Curvature-aware Graph Network that replaces computationally heavy Ollivier–Ricci curvature with Effective Resistance Curvature (ERC) to achieve fast, scalable graph processing.
• It leverages the Laplacian pseudoinverse for effective resistance computation, offering speedups of 60×–1300× compared to traditional optimal transport methods.
• ERC enhances curvature-aware message passing in GNNs, improving node and graph classification while maintaining interpretability and robustness across various graph conditions.

Efficient Curvature-aware Graph Network models exploit graph curvature as a geometric prior to enhance the representation power, robustness, and interpretability of Graph Neural Networks (GNNs). Traditional curvature-aware GNNs use Ollivier–Ricci curvature for its geometric expressiveness, but its reliance on optimal transport computations results in prohibitive preprocessing cost for large-scale graphs. The Efficient Curvature-aware Graph Network advances the state of the art by introducing Effective Resistance Curvature (ERC), a scalable measure based on the Laplacian pseudoinverse and effective resistances, which maintains near-equivalent capacity to Ricci curvature in modeling local geometric structure but drastically reduces computational overhead (Fei et al., 3 Nov 2025).

1. Mathematical Foundations: Effective Resistance Curvature

Let $G=(V,E,c)$ be an undirected graph with weighted adjacency matrix $c$ and Laplacian $L = D - c$, where $D_{ii}=\sum_j c_{ij}$. The Moore–Penrose pseudoinverse $L^{\dagger}$ defines the effective resistance between nodes $i$ and $j$: $R_{ij} = (e_i - e_j)^\top L^{\dagger}(e_i - e_j)$ where $e_i$ is the $i$th basis vector. For each edge $(i,j)$, the relative resistance is

$\omega_{ij} = c_{ij} R_{ij}$

The node-resistance curvature: $p_i = 1 - \frac{1}{2} \sum_{j \sim i} \omega_{ij}$ and the edge-resistance curvature: $k_{ij} = \frac{2(p_i + p_j)}{R_{ij}}$ Theoretical analysis demonstrates that under small random walk time scales, ERC and Ollivier–Ricci curvature coincide to first order and share monotonicity properties: increasing weights or adding edges always increases curvature on adjacent edges. Proper normalization gives $k_{ij}^{\mathrm{ERC}}\leq k_{ij}^{\mathrm{OR}}$ and establishes substitutability for practical applications.

2. Computational Efficiency and Complexity

The bottleneck in Ricci curvature is solving an optimal transport (Wasserstein) problem per edge—a process with worst-case complexity $O(n^4\log^2 n)$ on graphs of $n$ nodes. For ERC, the cost is dominated by Laplacian inversion, $O(n^3)$ for dense graphs and $O(mn^2)$ for sparse graphs, and each resistance $R_{ij}$ becomes a simple quadratic form evaluation. On massive graphs, ERC permits further acceleration by Cholesky, conjugate gradient, or low-rank Laplacian sketch techniques. Real benchmarks report CPU ERC computation times of $0.04$–$6$ seconds versus $3$–$900$ seconds for Ricci curvature (speedups $60\times$–$1300\times$).

3. Algorithmic Implementation

A typical ERC computation pipeline is as follows:

Input: graph Laplacian L, regularization parameter ε L̄ = L + ε*I M = inverse(L̄) # For small n, direct; for large n, use sparse linear solver for each edge (i,j) in E: d = e_i - e_j R_ij = d.T @ (M @ d) # Or use conjugate gradient per d ω_ij = c_ij * R_ij for each node i: p_i = 1 - 0.5 * sum over neighbors j of ω_ij for each edge (i,j): k_ij = 2*(p_i + p_j)/R_ij

ERC values are then incorporated as edge weighting functions $g(k_{ij})$ in the message-passing layers.

4. Curvature-aware Message Passing and Network Architecture

ERC is used to modulate each message via a curvature weighting function (examples: $g(k_{ij}) = \exp(\alpha k_{ij})$, or $g(k_{ij}) = 1 + \alpha k_{ij}$):

$$X_i^{(\ell+1)} = \sigma\left( \sum_{j \in \mathcal{N}(i)} g(k_{ij})\,c_{ij}\,W^{(\ell)}X_j^{(\ell)} \right)$$

In matrix form: $$X^{(\ell+1)} = \sigma\left( (G \odot c) X^{(\ell)} W^{(\ell)} \right)$$ where $(G \odot c)_{ij} = g(k_{ij}) c_{ij}$.

For node classification, $X^{(L)}$ is read out per node; for graph classification, a global pooling/sum is applied followed by an MLP.

5. Training Protocol and Hyperparameter Settings

Loss functions include standard cross-entropy for classification and MSE for regression. Optionally, a curvature-smoothness regularizer: $$\mathcal{R} = \lambda \sum_{(i,j)\in E}(g(k_{ij})-1)^2$$ The recommended protocol is:

• Hidden dimensions: 64
• Layers: 2–4 graph convolution layers
• Learning rate: 0.005 (Adam)
• Weight decay: $5\times 10^{-4}$
• Dropout: 0.5

For large graphs, mini-batch sampling is used. ERC values are precomputed and stored as sparse edge attributes.

6. Empirical Evaluation and Comparative Results

ERC-GNN matches or modestly exceeds OR-GNN accuracy (mean absolute difference ≈ 0.16%). Representative results:

• Node classification: Cora, Citeseer, PubMed, Amazon, Coauthor, synthetic benchmarks
• Graph classification (global pooling): ENZYMES, MUTAG, PROTEINS, D&D, IMDB-B, COLLAB

ERC computation time is between $0.04$ and $6$s (vs. $3$–$900$s for Ricci curvature), and memory footprint is minimal (no intermediate transport plans). Ablations show ERC and Ricci curvature boost performance over standard GNNs; in high-density regimes, Ricci curvature may outperform ERC under certain schemes, but tuning $g(k_{ij})$ can recover or exceed the difference. Distributional analysis indicates ERC captures more extreme geometric anomalies via its heavier-tailed curvature distribution.

7. Practical Considerations, Robustness, and Limitations

ERC is recommended for static graphs of moderate or large size, with computation best performed offline using sparse linear algebra. It is robust to regularization ($\epsilon$) and random graph perturbations. With dynamic/evolving graphs, efficient incremental updates of ERC remain open. For directed or highly heterogeneous graphs, generalizations of ERC are required, as is end-to-end learning of $g(k_{ij})$ functions. Non-small-$t$ interpretations await further theoretical development.

ERC offers a scalable, interpretable geometric prior for GNNs, enabling curvature-aware message passing on previously intractable graph sizes, while preserving the accuracy and robustness of Ricci curvature approaches (Fei et al., 3 Nov 2025).