GraphGlue: Riemannian Graph Pre-training Framework

• GraphGlue is a multi-domain graph pre-training framework that unifies diverse graphs by mapping their embeddings onto a smooth Riemannian manifold using adaptive orthogonal frames.
• It leverages local tangent-space isometries, holonomy regularization, and curvature smoothing to ensure minimal geometric deformation during knowledge transfer.
• Empirical evaluations show that GraphGlue improves few-shot performance across various graph tasks by quantifying transfer difficulty with geometric transfer metrics.

Searching arXiv for GraphGlue and directly related papers to ground the article in current preprints. GraphGlue is a multi-domain graph pre-training framework that reinterprets graph foundation models through Riemannian geometry. Its core idea is to merge any graph dataset into a unified, smooth Riemannian manifold, enabling a systematic understanding of knowledge integration and transfer. The framework addresses a foundational gap in graph foundation models: many methods can pre-train on multiple graph domains and transfer to a target domain, but they rarely explain how cross-domain knowledge is merged or how to quantify transfer difficulty in a principled way. GraphGlue answers this by modeling the latent space of a graph encoder as a Riemannian manifold and by treating successful transfer as the problem of attaching a target graph to the learned manifold with small geometric deformation (Sun et al., 28 Feb 2026).

1. Conceptual basis and scope

GraphGlue frames multi-domain graph pre-training not as a purely algorithmic alignment problem, but as the task of building a single smooth manifold that coherently integrates knowledge from diverse graph domains. In this formulation, each graph dataset induces a local manifold patch with its own tangent geometry, and transfer succeeds when the target graph can be glued to the learned manifold with limited distortion (Sun et al., 28 Feb 2026).

The key theoretical notion is neural manifold gluing. The method first characterizes local geometry using an adaptive orthogonal frame and then glues the local pieces together into a coherent whole. The gluing is not a literal topological stitching of graphs; it is a learned process that aligns local tangent spaces, enforces consistent transport around cycles, and regularizes the variation of the metric so the latent manifold becomes globally coherent. This geometric interpretation is explicitly positioned as a way to connect pre-training and domain adaptation under a unified theory (Sun et al., 28 Feb 2026).

A central consequence of this view is that transfer difficulty is not treated as generic domain similarity. Instead, GraphGlue defines transferability in terms of geometric compatibility with the learned manifold. This shifts the explanatory vocabulary from invariant features or prompt alignment toward local metrics, tangent transport, holonomy, and curvature (Sun et al., 28 Feb 2026).

2. Local geometry: sparse perturbations, AOF, and local metrics

GraphGlue constructs a local coordinate system around each graph embedding $z^{(i)}$ by applying a sparse perturbation with virtual nodes and then orthogonalizing and rescaling the resulting tangent directions to obtain an Adaptive Orthogonal Frame (AOF). The perturbation is defined as a $(k,M)$-sparse perturbation over a graph $G=(V,E)$, producing a perturbed graph

$$g=(V,\tilde{E}) = G_{DP} = (V \cup \{P_m\}_{m=1}^M,\; E \cup \{(V_{im},P_m)\}_{i,m}),$$

where $(V_i,P_m)$ is an edge weighted by an attentive function $h(x_i,P_m)$, and $V_{im}$ are the top-$k$ nodes selected by $h(x_i,P_m)$ (Sun et al., 28 Feb 2026).

After QR-decomposition with length recovery, the AOF is defined as $\{w_m\}_{m=1}^M$ for every representation $(k,M)$0, with a dual frame $(k,M)$1 such that $(k,M)$2. The local metric tensor is then built from these basis vectors:

$(k,M)$3

where $(k,M)$4, and the inner product at the point is $(k,M)$5 (Sun et al., 28 Feb 2026).

The paper further states that the perturbation only induces a bounded deformation of tangent vectors,

$(k,M)$6

under the conditions of Theorem 4.3. This boundedness matters because the learned frame is intended to capture local stretching and twisting while keeping the local geometry stable rather than arbitrarily distorted (Sun et al., 28 Feb 2026).

3. Global manifold construction: tangent translation, holonomy, and curvature

Once local metrics are estimated, GraphGlue merges them into a global structure through edge tangent translation. For an edge $(k,M)$7, the tangent edge translation is the linear map

$(k,M)$8

This map is stated to be the optimal isometry between tangent spaces, solving

$(k,M)$9

subject to the constraint that $G=(V,E)$0 (Sun et al., 28 Feb 2026).

Theorem 4.6 asserts that these pairwise isometries induce a unique global continuous metric $G=(V,E)$1 on the glued space, satisfying $G=(V,E)$2. However, pairwise consistency on edges is insufficient on its own, because traversing a cycle can accumulate mismatch. GraphGlue addresses this with holonomy. For a cycle $G=(V,E)$3, the holonomy map is

$G=(V,E)$4

The transport is trivial if $G=(V,E)$5 for all cycles, and the triangle-based regularizer is

$G=(V,E)$6

Theorem 4.8 states that if every edge lies in at least one triangle, then trivial holonomy on all triangles implies trivial holonomy on all cycles (Sun et al., 28 Feb 2026).

Smoothness is then enforced through a Ricci-curvature proxy based on determinant ratios of neighboring local metrics:

$G=(V,E)$7

with

$G=(V,E)$8

and curvature loss

$G=(V,E)$9

Theorem 4.11 states that if the log-determinant field is smooth enough and holonomy is trivial, the construction glues into a smooth Riemannian manifold (Sun et al., 28 Feb 2026).

4. Training and adaptation pipeline

GraphGlue operationalizes the geometry in two phases: pre-training and adaptation. During pre-training, each source graph is represented by a Riemannian prototype consisting of a global location and a metric, $$g=(V,\tilde{E}) = G_{DP} = (V \cup \{P_m\}_{m=1}^M,\; E \cup \{(V_{im},P_m)\}_{i,m}),$$0. These prototypes are updated by exponential moving average (EMA) over mini-batches:

$$g=(V,\tilde{E}) = G_{DP} = (V \cup \{P_m\}_{m=1}^M,\; E \cup \{(V_{im},P_m)\}_{i,m}),$$1

$$g=(V,\tilde{E}) = G_{DP} = (V \cup \{P_m\}_{m=1}^M,\; E \cup \{(V_{im},P_m)\}_{i,m}),$$2

where $$g=(V,\tilde{E}) = G_{DP} = (V \cup \{P_m\}_{m=1}^M,\; E \cup \{(V_{im},P_m)\}_{i,m}),$$3 is the momentum coefficient. The use of $$g=(V,\tilde{E}) = G_{DP} = (V \cup \{P_m\}_{m=1}^M,\; E \cup \{(V_{im},P_m)\}_{i,m}),$$4 is explicitly motivated by the fact that the metric is SPD, so averaging in the log-domain is geometrically appropriate (Sun et al., 28 Feb 2026).

To separate semantics across domains, GraphGlue adds a prototype contrastive loss:

$$g=(V,\tilde{E}) = G_{DP} = (V \cup \{P_m\}_{m=1}^M,\; E \cup \{(V_{im},P_m)\}_{i,m}),$$5

The pre-training algorithm uses a mixture of batches from multiple datasets, constructs a cross-dataset KNN graph, samples triangle-like paths, and applies the holonomy and curvature losses. This is intended to learn not only features but a global manifold skeleton (Sun et al., 28 Feb 2026).

At adaptation time, the framework estimates the target graph’s coordinates and tangent basis, then applies a learnable prompt matrix $$g=(V,\tilde{E}) = G_{DP} = (V \cup \{P_m\}_{m=1}^M,\; E \cup \{(V_{im},P_m)\}_{i,m}),$$6:

$$g=(V,\tilde{E}) = G_{DP} = (V \cup \{P_m\}_{m=1}^M,\; E \cup \{(V_{im},P_m)\}_{i,m}),$$7

Instead of directly prompting the metric, it prompts the tangent basis $$g=(V,\tilde{E}) = G_{DP} = (V \cup \{P_m\}_{m=1}^M,\; E \cup \{(V_{im},P_m)\}_{i,m}),$$8, producing

$$g=(V,\tilde{E}) = G_{DP} = (V \cup \{P_m\}_{m=1}^M,\; E \cup \{(V_{im},P_m)\}_{i,m}),$$9

The target graph is then connected to its $(V_i,P_m)$0-nearest prototypes to form a transfer graph $(V_i,P_m)$1, which is regularized by the same geometric consistency losses:

$(V_i,P_m)$2

GraphGlue also uses a Riemannian Mixture-of-Experts (MoE) in which each prototype acts as an expert and a gating network weights them based on the adapted target geometry. The final target representation combines task features with aligned geometric descriptors, and the adaptation objective is

$(V_i,P_m)$3

These components together define the practical GraphGlue training workflow (Sun et al., 28 Feb 2026).

5. Transferability, scaling law, and empirical profile

GraphGlue defines transferability through the Geometric Transfer Metric (GTM):

$(V_i,P_m)$4

with

$(V_i,P_m)$5

Here, $(V_i,P_m)$6 measures holonomy disagreement, or twisting around cycles, and $(V_i,P_m)$7 measures curvature disagreement, or bending and abrupt changes in local volume. A low GTM means the target graph can be integrated into the source manifold with little deformation, whereas a high GTM indicates geometric mismatch and a need for more adaptation (Sun et al., 28 Feb 2026).

The paper also reports a geometric scaling law: as more graph datasets are used in pre-training, the learned manifold becomes smoother and transferability improves. Empirically, the authors observe logarithmic trends in which more source datasets lead to higher few-shot accuracy and lower transfer loss, especially in extreme low-shot settings. The stated interpretation is that more diverse data better approximate the underlying ideal manifold, reducing geometric irregularities (Sun et al., 28 Feb 2026).

The experimental protocol covers six representative domains and tasks:

Dataset	Domain/task
Arxiv	citation network, node classification
Computers	co-purchase network, node classification
Reddit	social network, node classification
FB15k_237	knowledge graph, link classification
PROTEINS	bioinformatics graph classification
HIV	molecular graph classification

Evaluation uses a leave-one-out cross-domain protocol: pre-train on five datasets and fine-tune on the held-out one using 1-shot and 5-shot labeled data per class. Metrics are ACC for node/link classification and AUC for graph classification. GraphGlue is compared with supervised GNNs (GCN, GraphSAGE, GIN), self-supervised pre-training models (DGI, GraphMAE, GCC), and graph foundation models (PRODIGY, GFT, RAGraph, SAMGPT, GCOPE, MDGFM) (Sun et al., 28 Feb 2026).

The reported results show that GraphGlue is consistently the best or among the best across all tasks, often with large gains in the hardest few-shot settings. The paper specifically highlights strong performance on Computers in 1-shot transfer, on Reddit in 5-shot transfer, and competitive or leading results on graph classification tasks such as HIV. Ablation studies indicate that removing holonomy loss, curvature loss, EMA, or prototype loss degrades performance, and replacing the Riemannian MoE with ordinary prompting reduces adaptation quality. The method is also evaluated on heterophilic graphs such as Amazon-Ratings, Roman-empire, Texas, and Wisconsin, where it again outperforms GCOPE and MDGFM. Manifold visualization is reported to place semantically related datasets close together while separating chemically distinct datasets, suggesting that the learned geometry reflects semantic structure rather than only task loss (Sun et al., 28 Feb 2026).

6. Relation to earlier graph “gluing” problems

In the strict sense, GraphGlue denotes the Riemannian multi-domain graph pre-training framework described above (Sun et al., 28 Feb 2026). A broader reading of the literature, however, suggests several earlier graph “gluing” problems that are conceptually related while formally distinct.

One such line concerns data-model interoperability. “Mapping RDF Graphs to Property Graphs” describes “a framework based on G2GML for mapping RDF graphs to property graphs,” implemented as the G2G Mapper. In that framework, resources in RDF can be mapped to nodes in the property graph, literals in RDF can be mapped to property values, variables in the RDF pattern and property graph pattern are matched by name, and the resulting property graph can be loaded into Neo4j, Oracle Labs PGX, or Amazon Neptune for further analysis. This suggests a GraphGlue-like problem of declaratively connecting RDF/SPARQL data to property-graph analytics (Matsumoto et al., 2018).

A second line concerns database-native graph computation. “Graphulo Implementation of Server-Side Sparse Matrix Multiply in the Accumulo Database” presents Graphulo’s TableMult, a server-side implementation of sparse generalized matrix multiplication (SpGEMM) for Apache Accumulo. The design uses RemoteSourceIterator, TwoTableIterator, and RemoteWriteIterator, with a lazy $(V_i,P_m)$8 implemented through a Combiner on the output table. Its central architectural idea is compute-to-data: graph linear algebra is executed inside the tablet servers where the data already reside, and the outer-product implementation achieves performance near Accumulo’s peak write rate. This is a distinct notion of “gluing,” in which graph analytics are integrated directly into the database execution substrate (Hutchison et al., 2015).

A third line appears in interactive visual analytics. The Collaboration Spotting framework defines a directed, labeled graph $(V_i,P_m)$9, decomposes it into reduced-dimensional views, and supports three interaction operators—selection $h(x_i,P_m)$0, expansion $h(x_i,P_m)$1, and navigation $h(x_i,P_m)$2. The formal view $h(x_i,P_m)$3 is not merely a filtered subgraph; it is a two-level abstraction with content vertices, bridge vertices, and support mappings that preserve navigation across multiple facets of the same underlying network. This suggests another graph-gluing problem: connecting user interaction, view generation, and traversal across multidimensional projections (Agocs et al., 2017).

Taken together, these works indicate that “graph gluing” can refer to several different technical operations: mapping between graph data models, integrating graph computation with database systems, navigating among multiple graph views, or constructing a single smooth manifold for multi-domain graph transfer. Within that broader landscape, GraphGlue as introduced in 2026 is the explicitly geometric formulation, distinguished by its use of adaptive orthogonal frames, tangent-space isometries, holonomy regularization, curvature smoothing, EMA prototyping, and a transferability measure defined by geometric deformation (Sun et al., 28 Feb 2026).