Latent Graph Representation (LGR)

• Latent Graph Representation (LGR) is a framework that infers a latent adjacency or code from data, replacing fixed observed graphs to better support message passing and convolution.
• It encompasses approaches such as task-adaptive graph reconstruction, probabilistic embeddings, and latent geometry graphs to model noisy, incomplete, or suboptimal structures.
• LGR methods improve performance by dynamically learning graph topology, latent geometries, and common factors, with applications in medicine, brain connectomics, and generative modeling.

Searching arXiv for relevant LGR papers and related graph-learning formulations. Latent Graph Representation (LGR) is an umbrella notion in graph machine learning for representing graph structure through learned latent variables, latent geometries, or latent graphs rather than treating the observed adjacency as fixed. Across the literature, the term covers several distinct but related formulations: learning a task-adaptive latent adjacency for message passing (Jiang et al., 2019, Borde et al., 2022, Borde et al., 2023, Borde et al., 2023), encoding nodes or entire graphs in latent spaces from which edges or graphs are reconstructed (Kollias et al., 2022, Yang et al., 2021, Nakis et al., 2022), representing latent-space geometries themselves as graphs (Lassance et al., 2020), and using latent graph codes for generative modeling (Siraudin et al., 20 Jan 2026, Arias et al., 21 Aug 2025, Abulikemu et al., 6 Nov 2025). A recurrent premise is that the input graph may be noisy, incomplete, adversarially perturbed, or simply suboptimal for the downstream objective, so the model should infer a more useful relational structure. The supplied record for “When Heterophily Meets Heterogeneous Graphs: Latent Graphs Guided Unsupervised Representation Learning” (Shen et al., 2024) explicitly states that the provided document is an IEEEtran template/tutorial and “does not mention” LatGRL, latent graphs, heterophily, or graph learning, so the concept must be characterized from other works in the corpus rather than from that source.

1. Conceptual scope and problem setting

In one influential line of work, LGR means replacing a fixed adjacency with a learned latent graph that better supports graph convolution or message passing. “Robust Graph Data Learning via Latent Graph Convolutional Representation” defines a latent graph $\widetilde{\mathbf{A}}$ learned from the observed graph $\mathbf{A}$ and node features, then performs graph convolution on $\widetilde{\mathbf{A}}$ rather than directly on $\mathbf{A}$ (Jiang et al., 2019). “Latent Graph Inference using Product Manifolds” generalizes this perspective by learning sparse latent adjacencies from node features through manifold distances, especially when the true adjacency is missing, noisy, or task-suboptimal (Borde et al., 2022). “Projections of Model Spaces for Latent Graph Inference” further frames latent graph inference as learning an adjacency structure from current hidden representations so that the graph becomes “a learned representation that mediates information flow through the GNN” (Borde et al., 2023).

A second line uses LGR to denote latent coordinates or latent variables from which graphs are reconstructed or explained probabilistically. “Directed Graph Auto-Encoders” learns for each node a pair of latent vectors, a source representation $s_i$ and a target representation $t_i$, so that directed adjacency is modeled asymmetrically as $A \approx ST^\top$ (Kollias et al., 2022). “A Deep Latent Space Model for Graph Representation Learning” treats LGR as a probabilistic embedding of directed graphs in which latent positions, community indicators, and node random factors jointly explain edges, community structure, and degree heterogeneity (Yang et al., 2021). “A Hierarchical Block Distance Model for Ultra Low-Dimensional Graph Representations” keeps the latent-distance semantics of graph representation while approximating the expensive likelihood by a multiscale block hierarchy (Nakis et al., 2022).

A third line shifts the object of representation from the graph itself to latent-space geometry. “Representing Deep Neural Networks Latent Space Geometries with Graphs” constructs similarity graphs from intermediate representations in a minibatch and calls them Latent Geometry Graphs (LGGs), which are then regularized for distillation, discriminative embedding learning, or robustness (Lassance et al., 2020). Here, the graph represents relations among latent representations rather than relations among original graph nodes.

A fourth line uses LGR as a compact structured code for generative modeling. “Principled Latent Diffusion for Graphs via Laplacian Autoencoders” defines LGR as a permutation-equivariant node-wise latent embedding from which adjacency is recoverable, allowing diffusion to operate in latent space rather than on quadratic-size adjacency matrices (Siraudin et al., 20 Jan 2026). “Structure-Preserving Medical Image Generation from a Latent Graph Representation” learns a patch-level graph latent code for chest X-rays and then models the distribution of those latent graphs adversarially (Arias et al., 21 Aug 2025). “Unified Generative Latent Representation for Functional Brain Graphs” learns a low-dimensional geometry-aware latent code for dense functional brain graphs and then fits latent diffusion on that graph-level space (Abulikemu et al., 6 Nov 2025).

These usages differ in object, scale, and supervision, but they share a common claim: graph structure should be treated as an inferred latent object rather than a fully trusted input.

2. Learned latent graphs for message passing

The clearest operational definition of LGR is task-adaptive graph reconstruction for downstream diffusion. In LatGCR, graph convolution is reinterpreted through neighborhood reconstruction. Standard mean aggregation is written as

$$\mathbf{h}'_i = \frac{1}{\mathbf{d}_i}\sum_{j \in \mathcal{N}_i\cup i} \mathbf{A}_{ij}\mathbf{z}_j\mathbf{W},$$

and equivalently as

$$\mathbf{h}'_i = \arg\min_{\mathbf{h}_i} \sum_{j\in \mathcal{N}_i\cup i} \mathbf{A}_{ij}\|\mathbf{h}_i-\mathbf{z}_j\mathbf{W}\|^2.$$

LatGCR extends this to a joint optimization over latent graph and representations: $$\{\widetilde{\mathbf{A}},\mathbf{H}'\} = \arg\min_{\widetilde{\mathbf{A}},\mathbf{H}} \|\mathbf{A}-\widetilde{\mathbf{A}}\|^2 + \lambda \sum_i\sum_{j\in \mathcal{N}_i\cup i} \widetilde{\mathbf{A}}_{ij}\|\mathbf{h}_i-\mathbf{z}_j\mathbf{W}\|^2,$$ with $\mathbf{A}$0 (Jiang et al., 2019). The closed-form latent graph estimation step is

$\mathbf{A}$1

followed by graph convolution on the learned graph,

$\mathbf{A}$2

Because the update is applied only on existing neighbors, the method learns a sparse, local reweighting of the observed graph rather than arbitrary dense rewiring (Jiang et al., 2019).

Dynamic latent graph inference extends this idea by generating a new sparse adjacency from latent distances at each layer. In the product-manifold formulation, node features are mapped by a learnable transformation, projected onto a product manifold, and then used to define edge probabilities

$\mathbf{A}$3

after which a sparse set of neighbors is sampled using Gumbel Top-$\mathbf{A}$4 (Borde et al., 2022, Borde et al., 2023). The learned adjacency $\mathbf{A}$5 is then used for message passing in the next layer. This makes the graph layer-specific and end-to-end trainable.

A related application appears in medicine. “Latent-Graph Learning for Disease Prediction” learns a patient-population graph from feature embeddings by computing soft pairwise affinities

$\mathbf{A}$6

then feeds the learned adjacency into a spatial GCN

$\mathbf{A}$7

optimizing the graph-learning module and classifier jointly with categorical cross-entropy (Cosmo et al., 2020). GiG transfers the same logic to graph-valued inputs: first each input graph is embedded by a within-graph GNN, then a latent population graph over those graph embeddings is learned using the same sigmoid-like soft-thresholding rule, and finally a population-level GNN performs prediction on that learned graph (Mullakaeva et al., 2022).

These methods present LGR as a learned relational scaffold for message passing. This suggests a common interpretation: the graph used by a GNN is itself part of the representation, not merely part of the data.

3. Latent geometries and metric spaces

A substantial branch of LGR research is geometric. The central question is which latent metric makes graph inference expressive, stable, and trainable.

Product-manifold latent graph inference introduces a latent space

$\mathbf{A}$8

whose factors may be Euclidean, hyperbolic, or spherical, with overall distance given by the square root of the sum of squared componentwise distances (Borde et al., 2022). The motivation is that real data may mix hierarchical, clustered, cyclic, and approximately flat structure, so a single Euclidean space can be too restrictive. Curvature is learned during training through scaling coefficients rather than fixed a priori (Borde et al., 2022).

Projected model-space inference replaces hyperboloid and hypersphere factors with stereographically projected versions such as the Poincaré ball and a stereographic sphere. The stated reason is that projected spaces “avoid divergence of the spaces when the curvature tends to zero,” while still preserving non-Euclidean inductive bias (Borde et al., 2023). The paper reports that projected model spaces achieve “comparable performance to their non-projected counterparts,” with particularly favorable behavior on Cora, CiteSeer, and TadPole, while improvements on Squirrel and Chameleon are not guaranteed (Borde et al., 2023).

Neural Snowflakes takes a more general position: instead of choosing from a catalog of Euclidean, hyperbolic, spherical, or product geometries, it learns a trainable metric family. The snowflake distance transform is built from bounded, power-law, and logarithmic components,

$\mathbf{A}$9

and is implemented by a deep non-negative network (Borde et al., 2023). The paper proves that for any finite weighted graph there exists a ReLU MLP encoder $\widetilde{\mathbf{A}}$0 and a neural snowflake $\widetilde{\mathbf{A}}$1 such that

$\widetilde{\mathbf{A}}$2

for every pair of nodes in the finite set (Borde et al., 2023). It further states that some small graphs cannot be isometrically embedded into any complete and connected smooth Riemannian manifold, using this as a critique of fixed manifold families (Borde et al., 2023). Empirically, neural snowflakes match or surpass state-of-the-art latent graph inference models without requiring random search over candidate geometries (Borde et al., 2023).

A different geometric viewpoint appears in LGGs. Here the geometry is the relational structure among minibatch representations: similarity matrices are built using cosine similarity or an RBF/Gaussian kernel, sparsified by $\widetilde{\mathbf{A}}$3-nearest neighbors, symmetrized, and optionally normalized as $\widetilde{\mathbf{A}}$4 (Lassance et al., 2020). Graph signal variation,

$\widetilde{\mathbf{A}}$5

and label variation,

$\widetilde{\mathbf{A}}$6

become the objects being minimized or matched (Lassance et al., 2020). In this formulation, a graph is the explicit representation of latent geometry itself.

4. Autoencoding, probabilistic, and directed formulations

When LGR is treated as a latent variable model, the representation is judged by whether it can reconstruct or explain adjacency.

For directed graphs, DiGAE learns two role-specific embeddings per node: $\widetilde{\mathbf{A}}$7 with asymmetric factorization

$\widetilde{\mathbf{A}}$8

Its directed message passing updates source and target embeddings separately,

$\widetilde{\mathbf{A}}$9

and the decoder reconstructs directed edges via

$\mathbf{A}$0

This source/target split is motivated by a directed extension of the Weisfeiler–Leman procedure and a bipartite reduction separating source-copy and target-copy nodes (Kollias et al., 2022). The representation is therefore explicitly asymmetric and role-aware.

DLSM pursues interpretability by combining latent positions, overlapping community indicators, and degree heterogeneity factors. The directed edge model is

$\mathbf{A}$1

where $\mathbf{A}$2 captures geometric proximity, $\mathbf{A}$3 and $\mathbf{A}$4 model outgoing and incoming propensity, and binary $\mathbf{A}$5 variables encode overlapping communities (Yang et al., 2021). The model is trained by an ELBO with KL terms for positions, communities, and random factors, plus the expected edge log-likelihood (Yang et al., 2021). This makes LGR simultaneously geometric, probabilistic, and interpretable.

HBDM instead retains the Poisson latent distance model

$\mathbf{A}$6

but approximates the non-edge term through a hierarchy of blocks and centroids so that scalability becomes linearithmic (Nakis et al., 2022). The paper stresses that homophily is encoded because edge rate increases as latent distance decreases, while transitivity arises from the triangle inequality of Euclidean distance (Nakis et al., 2022). It further reports strong performance even with two-dimensional embeddings, so the latent space can remain directly visualizable (Nakis et al., 2022).

HM-LDM and sHM-LDM constrain latent positions to a simplex,

$\mathbf{A}$7

so that coordinates are interpretable as soft memberships (Nakis et al., 2023). The Poisson rate

$\mathbf{A}$8

interpolates between flexible latent geometry and near-discrete community assignments by shrinking or expanding the simplex via $\mathbf{A}$9 (Nakis et al., 2023). The signed extension uses the Skellam distribution with separate positive and negative rates, so positive links attract nearby nodes while negative interactions are encouraged between distant nodes (Nakis et al., 2023).

These models show that LGR can mean a latent space in the strict generative sense: a representation from which the graph is reconstructed, often with explicit structural priors such as directionality, hierarchy, community overlap, or signed interactions.

5. Graph-level common factors and predictive self-supervision

Some papers redefine the target of graph representation itself. Instead of reconstructing adjacency or matching augmented views, they ask what latent object should be predicted.

deepGCFX proposes Graph-wise Common latent Factor EXtraction (GCFX), motivated by the hypothesis that many real-world graphs are generated by common graph-wise factors plus local patch-specific factors (Cooray et al., 2021). The graph is assumed generated by

$s_i$0

with conditional independence

$s_i$1

The ACCUM module iteratively separates common and local components using factor-wise similarity scores, binary masks, and a GRU-based update of the common query vector (Cooray et al., 2021). The latent-variable objective is ELBO-like, with separate KL penalties on common and local latents and a decoder that reconstructs adjacency from both common and local factors, plus a regularization decoder using the common code alone (Cooray et al., 2021). In this view, the graph-level representation is not merely a pooled node embedding but an inferred common cause.

LaGraph formulates self-supervised representation learning as latent graph prediction. It assumes an observed graph

$s_i$2

is generated from an unobserved latent graph

$s_i$3

where topology is shared but features differ, with $s_i$4 (Xie et al., 2022). The ideal supervised objective would be

$s_i$5

but since $s_i$6 is unobserved, the paper derives a self-supervised upper bound consisting of a reconstruction term plus an invariance regularizer computed under node masking (Xie et al., 2022). The node-level and graph-level losses combine feature reconstruction with penalties on masked-node embedding differences or pooled-graph embedding differences (Xie et al., 2022). The paper explicitly contrasts this with contrastive methods: LaGraph needs no negative samples and derives its objective from an upper bound to latent prediction risk rather than from mutual-information estimation (Xie et al., 2022).

Graph-JEPA applies the latent-prediction perspective to graph-level self-supervision. Graphs are partitioned into subgraphs by METIS, expanded by one-hop neighborhoods, encoded by GINE, and augmented with Random Walk Structural Embeddings (RWSE) (Skenderi et al., 2023). One random subgraph is chosen as context and $s_i$7 others as targets. Rather than reconstructing full target embeddings, the model predicts two-dimensional coordinates on the unit hyperbola: $s_i$8 with predictor

$s_i$9

The target encoder is updated by stop-gradient and exponential moving average to avoid collapse (Skenderi et al., 2023). This paper explicitly situates itself between contrastive latent graph representation learning and generative or masked autoencoding approaches.

These approaches suggest that LGR need not mean “latent adjacency” at all. A plausible implication is that the field has broadened from graph reconstruction toward latent target prediction, common-cause inference, and graph-level semantic compression.

6. Generative latent graph representations

Generative work places unusually strong requirements on LGR because decoding errors can invalidate entire samples.

LG-Flow argues that latent diffusion for graphs requires a latent representation from which the original graph is “provably recoverable” or “near-lossless” (Siraudin et al., 20 Jan 2026). The autoencoder produces node-wise latent embeddings $t_i$0 using Laplacian positional encodings. For undirected graphs, the decoder computes bilinear scores

$t_i$1

and then

$t_i$2

For DAGs, the method uses the magnetic Laplacian and a magnetic Laplacian positional encoding (mLPE), with separate real and imaginary bilinear terms (Siraudin et al., 20 Jan 2026). The VAE objective combines node reconstruction, edge reconstruction, and KL regularization,

$t_i$3

after which a Diffusion Transformer is trained in latent space using flow matching (Siraudin et al., 20 Jan 2026). The paper reports speedups up to $t_i$4 while remaining competitive with state-of-the-art graph diffusion models (Siraudin et al., 20 Jan 2026).

Medical imaging offers another interpretation. In the X-ray generation framework, an image is divided into non-overlapping patches, producing a graph

$t_i$5

with ViT patch features

$t_i$6

and a learned sparse topology

$t_i$7

A GCN decoder reconstructs the image from the graph using graph convolution layers and repeated upsampling, trained by a reconstruction objective with foreground and background sparsity penalties (Arias et al., 21 Aug 2025). A GAN is then trained not on images directly but on the distribution of latent graphs, and sampled latent graphs are mapped back to X-rays by the pretrained graph decoder (Arias et al., 21 Aug 2025). The paper reports improvements of up to $t_i$8 and $t_i$9 for classification and segmentation, respectively (Arias et al., 21 Aug 2025).

Functional brain graphs provide a graph-level generative counterpart. A graph transformer autoencoder compresses each dense functional connectivity graph into a graph-level code

$A \approx ST^\top$0

with spectral embeddings used as node features and a memory-based cross-attention decoder reconstructing node and edge structure (Abulikemu et al., 6 Nov 2025). A diffusion probabilistic model is then fit on the latent codes. The paper states that spectral embeddings gave the best reconstruction, with edge MSE $A \approx ST^\top$1 and $A \approx ST^\top$2 for resting-state FC, and that generated graphs matched the test set on mean degree, degree standard deviation, and modularity with Kolmogorov–Smirnov statistics $A \approx ST^\top$3, $A \approx ST^\top$4, and $A \approx ST^\top$5, respectively (Abulikemu et al., 6 Nov 2025).

Across these works, LGR is not merely a bottleneck. It is a structured latent object that must preserve graph validity, anatomy, or biologically grounded organization after generation.

7. Evaluation patterns, benefits, and recurring limitations

The literature attributes several recurring benefits to LGR. First is robustness to graph corruption or misspecification. LatGCR reports that GCN-m and GAT “degrade sharply under attacks,” whereas LatGCN remains more accurate under Metattack and Random Attack, often outperforming RGCN, SimP-GCN, Pro-GNN, and GeCN (Jiang et al., 2019). The disease-prediction graph learner argues that manually defined population graphs are often suboptimal and that end-to-end learned graphs yield improved accuracy, lower variance, and better scalability (Cosmo et al., 2020). GiG similarly shows that non-learned graph construction strategies such as Random and KNN perform much worse than learned latent graphs (Mullakaeva et al., 2022).

Second is accommodation of heterophily or structure not captured by local neighborhoods. deepGCFX explicitly argues that extracting graph-wise common factors benefits node-level tasks by enabling long-range dependencies, “especially for disassortative graphs” (Cooray et al., 2021). Product-manifold latent graph inference reports that learned latent graphs on heterophilic datasets become substantially more homophilic than the original graphs and that dDGM$A \approx ST^\top$6, which does not rely on the original graph as inductive bias, can outperform dDGM when the observed graph is mismatched to the task (Borde et al., 2022). Projected model spaces were also evaluated on both homophilic and heterophilic graphs, though their gains on Squirrel and Chameleon were not consistent (Borde et al., 2023).

Third is interpretability. DLSM emphasizes interpretability through community indicators and degree factors (Yang et al., 2021). HM-LDM interprets simplex coordinates as soft memberships and uses simplex volume as an explicit identifiability mechanism (Nakis et al., 2023). HBDM stresses directly visualizable two-dimensional embeddings and hierarchical-aware visualization (Nakis et al., 2022). GiG claims that the learned latent population graph can reveal patient subpopulations, protein clusters, isolated cases, and misclassified samples in ways that are valuable for healthcare and bioinformatics (Mullakaeva et al., 2022). The functional brain graph model further shows that its latent space correlates with modularity, small-worldness, and mean clustering coefficient, and can separate working-memory states and decode visual stimuli despite unsupervised training (Abulikemu et al., 6 Nov 2025).

Fourth is efficiency or scalability. LG-Flow replaces quadratic adjacency diffusion with linear-size latent tensors and reports speedups up to $A \approx ST^\top$7 (Siraudin et al., 20 Jan 2026). HBDM reduces latent distance modeling to $A \approx ST^\top$8 (Nakis et al., 2022). Neural Snowflakes argues that when the latent graph is representable in the feature space of a sufficiently regular kernel, the model does not succumb to the curse of dimensionality and uses only a low-degree polynomial number of parameters in the number of nodes (Borde et al., 2023).

At the same time, the term LGR is not unified. In some papers it denotes a latent adjacency used for diffusion (Jiang et al., 2019, Borde et al., 2022, Borde et al., 2023). In others it denotes node embeddings that reconstruct edges (Kollias et al., 2022, Yang et al., 2021, Siraudin et al., 20 Jan 2026). Elsewhere it denotes graph-level common factors (Cooray et al., 2021), hidden clean graph features (Xie et al., 2022), latent geometry graphs over minibatch representations (Lassance et al., 2020), or graph latents over image patches and dense connectomes (Arias et al., 21 Aug 2025, Abulikemu et al., 6 Nov 2025). A plausible implication is that “Latent Graph Representation” functions more as a family resemblance term than as a single standardized model class.

A further source of potential confusion is bibliographic inconsistency. The supplied details for (Shen et al., 2024) explicitly state that the provided document is unrelated to LatGRL or heterogeneous graph learning. This is not a substantive controversy about LGR itself, but it illustrates a practical issue in fast-moving preprint ecosystems: the phrase “latent graph” may refer to method families whose precise content must be verified at the document level rather than inferred from title alone.

Overall, LGR research converges on a broad methodological thesis: useful graph representations often require learning either the graph, the geometry that induces the graph, the latent variables that explain the graph, or the latent graph-structured codes from which new structured data can be generated. The main divergence lies in which of these objects is treated as primary.