Pith. sign in

REVIEW 3 major objections 5 minor 1 cited by

View Space: Learning Representation across Arbitrary Graphs

T0 review · 3 major / 5 minor · reviewed 2026-08-03 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A single fully inductive graph encoder, pretrained on one dataset, outperforms 12 dataset-tuned GNNs by operating in a newly identified view space.

desk verdict A genuinely strong empirical transfer result wrapped in a theory section that overreaches; worth serious refereeing, with the 'arbitrary graphs' framing needs to be pulled back. read the letter →

arxiv 2512.11561 v2 pith:AMB3W63G submitted 2025-12-12 cs.LG

Dooho Lee , Myeong Kong , Minho Jeong , Jaemin Yoo This is my paper · ORCID
classification cs.LG
keywords viewspacefullyinductivenoderepresentationlearninggraphtransformationpermutationequivariancedynamicaggregationcross-datasettransferclassificationfoundationmodels
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper's central claim is that graphs with heterogeneous node counts and feature spaces can be unified in a 'view space'—a fixed-dimensional axis built by stacking multiple adjacency-propagated copies of the node-feature matrix. The proposed mapping, Graph View Transformation (GVT), is node- and feature-permutation equivariant, which the authors prove guarantees applicability to arbitrary graphs. A linear GVT reproduces static GNN aggregations, while a nonlinear GVT performs input-dependent node-feature dynamic aggregation. A recurrent instance (RGVT), pretrained only on OGBN-Arxiv and frozen, transfers to 28 benchmarks and beats the prior fully inductive model and 12 individually tuned GNNs on average. The significance is that fully inductive node representation learning is achievable in a shared space, a step toward graph foundation models.

What carries the argument

The key machinery is the view space and the view stacking operation. View stacking lifts the N×F node-feature matrix into an N×F×C tensor by applying C view finders (adjacency preprocessing operators that are node-permutation equivariant) and stacking the resulting propagated matrices along a new axis C. Each slice along C gives the 'view vector' for a node-feature pair; the view space is simply R^C, shared by all graphs. Graph View Transformation (GVT) is the parametric map that applies a shared dimension-collapsing function φ (an MLP in the nonlinear case, an affine map in the linear case) to every view vector independently, producing the output node-representation matrix. This pointwise s

What would settle it

One concrete check: run RGVT on a large set of graphs whose optimal linear aggregation requires operators outside the fixed view-finder set (e.g., high-order Chebyshev or signed/directed propagation). If validation-selected depth keeps hitting the maximum and RGVT's average accuracy falls below the best tuned GNN on those graphs, the universality claim fails. Alternatively, if pretraining on a graph with very different homophily drastically changes downstream accuracy, then the view space is not operating independent of pretraining distribution.

Watch

Extended reading notes

Core claim

The discovery is that treating the third axis—the view space—as the operational domain solves cross-graph representation. Each node-feature pair (n,f) is projected to a fixed-size view vector v_{n,f} ∈ R^C whose coordinates are propagations of X through a fixed set of node-permutation-equivariant view finders (identity, random-walk and symmetric-normalized adjacency powers). A shared learnable function φ maps each view vector to a scalar; because φ is applied independently to every (n,f), the whole map Ψ(X,A) is equivariant under both node and feature permutations, hence well-defined for any (N,F). The authors prove that linear GVT subsumes standard static aggregations, and that nonlinear GV

Load-bearing premise

The load-bearing premise is that a single fixed set of view finders—identity plus first and second powers of the row- and symmetric-normalized adjacency—chosen on the pretraining graph, is universal enough to capture the aggregation structure of arbitrary unseen graphs; if a new graph family needs different propagation operators, the pretrained transformer does not transfer.

Editorial extensions

If this is right

  • A frozen RGVT backbone yields reusable node representations for graphs with unseen feature spaces; only a lightweight predictor and a chosen recurrent depth are dataset-specific.
  • The view space provides a standardized input format for graphs, analogous to tokens in language and patches in vision, enabling the foundation-model paradigm for graphs.
  • Linear GVT generalizes static aggregation: many existing GNN aggregation schemes are realizable as linear GVT with suitable view-finder coefficients.
  • Nonlinear GVT achieves a new granularity of dynamic aggregation (per node-feature pair), beyond node-wise or edge-wise attention.
  • Recurrent depth acts as a per-dataset receptive-field control, so a single shared parameterization serves graphs that prefer different hop ranges.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Inference: The transfer results suggest that a pretrained view-space encoder could also support link prediction and graph classification if the same view-stacking is applied with task-appropriate predictors; this is an implication the authors list as future work.
  • Inference: The reported sensitivity to the pretraining dataset indicates that view-finder universality is not automatic; a principled method for choosing or learning view finders (rather than fixing them on OGBN-Arxiv) may be needed for truly arbitrary graph families.
  • Inference: The local-linearization heatmaps imply a transferable 'aggregation prior' that could be probed on synthetic graphs with controlled homophily or degree distributions to test whether the learned view-to-rule mapping is stable across structures.
  • Inference: Since RGVT's comparisons select depth by validation labels, a stricter protocol that fixes depth a priori or uses unsupervised heuristics would clarify how much of the result depends on per-dataset validation information.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper introduces the 'view space' as a third representational axis for graphs, formed by stacking multiple adjacency-derived propagations of the node-feature matrix (view stacking), and defines Graph View Transformation (GVT), which applies a shared MLP to each node-feature-view vector. Recurrent GVT (RGVT) iterates the same GVT with shared weights to allow variable receptive-field depth. The authors claim that node-permutation equivariance (R1) and feature-permutation equivariance (R2) together guarantee full inductiveness over arbitrary graph size and feature dimension (Lemma 3.1). They pretrain RGVT on OGBN-Arxiv and evaluate on 27 downstream node-classification benchmarks, with a lightweight per-dataset predictor and per-dataset depth selection. Reported results include a +8.93% average relative improvement over GraphAny and an average accuracy higher than all 12 individually tuned GNN baselines. Additional experiments cover non-attributed graphs, LLM-embedded features, view-finder sensitivity, ablations, and computational complexity.

Significance. The empirical core is substantial and, if reproducible, constitutes a valuable practical contribution: a frozen, fully inductive encoder that transfers across a diverse suite of node-classification datasets and competes with GNNs trained from scratch on each dataset. The view-space framing is conceptually useful, and the dynamic-aggregation interpretation of nonlinear GVT is plausible. The paper releases code and checkpoints, which strengthens reproducibility. However, the theoretical foundation of the claimed full inductiveness is not rigorously established, and the 'arbitrary graphs' claim in the title and abstract is stronger than the evidence supports. These issues are localizable and fixable; they do not invalidate the benchmark results but do require a major revision of the paper's framing and theory sections.

major comments (3)
  1. [Section 3, Lemma 3.1; Appendix B] The proof of Lemma 3.1 does not establish the claim that R1+R2 imply a single function well-defined for arbitrary (N,F). Lemmas B.1-B.3 fix N and F and prove only within-size permutation invariance. The 'identical multiset' condition forces the two inputs to have the same cardinality, so it cannot compare inputs of different sizes; the step 'there exists P with P(i)=i' is unavailable when N != N'. Remark B.4's canonicalization uses the original index j as a tie-breaker, which is not permutation-invariant. Thus the proof at best defines a family of functions indexed by (N,F), not one shared rule. A concrete counterexample: the family Psi_N(X,A) = N*X satisfies R1 and R2 for each N but is not a single transferable rule. The theorem should be restated for architectures with shared pointwise parameterization, which is what GVT actually is.
  2. [Abstract, Section 8, Section I, Section 9] The title and abstract promise 'arbitrary graphs', but the empirical evaluation covers 28 homogeneous undirected node-classification benchmarks (social, citation, web, airline), and Section 9 lists heterogeneous graphs and hypergraphs as future work. Section I shows that the fixed view-finder set {I, RW^k, SYM^k}_{k=1}^2 (chosen on OGBN-Arxiv) is not universal: Chebyshev views degrade with K>1, and RW+SYM with K up to 3 works well, so the choice matters. No evidence is provided for directed, bipartite, molecular, or hypergraph domains. The claim of fully inductive 'arbitrary graphs' should be scoped to the architecture's formal capability (any N and F) and to an empirical claim on the benchmark distribution actually tested.
  3. [Section H, Table 10] The reported inference time of 0.052 s for RGVT across all 28 graphs is inconsistent with the stated complexity O(LC|E|F+L N F C^2) and with the GCN baseline at 0.002 s. OGBN-Arxiv alone has N=169,343 and |E|=2,484,941; an RGVT forward pass with L=8 and C=5 requires billions of multiply-adds. Even on an RTX A6000, a 0.052 s total is implausible, and 0.002 s for GCN across 28 datasets is uninterpretable. The measurement protocol (warm-up, batching, whether time includes data loading or only the backbone, and a per-dataset breakdown) should be reported. As written, the efficiency advantage is not reproducible.
minor comments (5)
  1. [Section 8.1] The sentence 'outperforming the linear classifier by +17.71% and MLP by +17.88% on average' has the two percentages swapped relative to Table 1: RGVT+Linear improves on Linear by +17.88%, RGVT+MLP improves on MLP by +17.71%.
  2. [Section 4.1] The reference 'As noted in Theorem 4.2' should be 'As noted in Lemma 4.2'.
  3. [Appendix B, Remark B.4] The canonicalization tie-breaker 'with j as a tie-breaker' uses original node indices, which are not permutation-invariant. A structural tie-breaker is needed for the canonicalization argument to hold.
  4. [Section J.1] The learning-rate search space is stated as eta in {0.01, 0.05}, but the selected configuration for RGVT+MLP lists eta=0.005. Please correct the typo or the search space.
  5. [Figure 2 and text] The text refers to 'left: 1st vs. right: 8th layer', but the figure panel structure is not described. Please clarify which panels correspond to which layer and dataset.

Circularity Check

0 steps flagged · score 1.0 of 10

No load-bearing circularity: central results are external benchmark comparisons; remaining concerns are framing/proof-rigor, not circular reductions.

full rationale

The paper's derivation chain is: define FI-NRL; state R1/R2; construct the view space and GVT; prove equivariance; build RGVT; pretrain on OGBN-Arxiv; transfer to 27 datasets and compare with GraphAny and 12 tuned GNNs. The load-bearing empirical claims rest on external benchmarks and baselines, not on any fitted constant being reported as a prediction. The view-finder set {I} ∪ {(D^-1 A)^k, (D^-1/2 A D^-1/2)^k}_{k=1}^K with K=2 is selected as a hyperparameter on OGBN-Arxiv validation, and the per-dataset recurrent depth L is chosen by target validation accuracy; both are disclosed adaptation steps and are not presented as zero-shot predictions. Section I's sensitivity analysis (Chebyshev degradation, RW+SYM combination) is an empirical caveat about universality, not a circular step. The only self-citation (Lee et al. 2025) appears in related work and is not load-bearing. The 'view space' repackages standard adjacency-propagation operators, and the paper itself acknowledges view finders are not new; this is an organizational framing rather than a circular derivation. Lemma 3.1's proof is terse and arguably under-specified for cross-size inputs, but this is a rigor concern, not an instance of a prediction equaling its input by construction. Therefore no specific circular step meets the evidentiary bar.

Assumptions & free parameters 5 free parameters · 4 assumptions · 1 invented entities

The framework rests on a few design choices: the view-finder family, the shared per-entry MLP, recurrence, and the equivariance assumptions. The most fragile is the universality of the fixed view-finder set, since the paper's own ablations show performance is sensitive to that choice.

free parameters (5)
  • View-finder hop count K = 2
    Selected on OGBN-Arxiv validation; ablations in Section I show performance varies with K and with the choice of filters.
  • Pretraining recurrent depth L = 8
    Selected on OGBN-Arxiv validation from {2,4,6,8}; Table 11 shows downstream performance varies with L.
  • MLP layers in phi = 2
    Selected from {1,2,3} using OGBN-Arxiv validation.
  • Learning rate = 0.01 (linear) / 0.005 (MLP)
    Selected from {0.01, 0.05} using OGBN-Arxiv validation.
  • Per-dataset recurrent depth L_k = chosen per dataset
    During adaptation the depth is chosen by downstream validation accuracy (Section 8), which is a per-dataset tuning knob.
assumptions (4)
  • domain assumption R1+R2 equivariance implies well-definedness for arbitrary N,F
    Lemma 3.1; the proof in Appendix B relies on root-preserving/canonicalization steps that do not cleanly handle inputs with different N and F. GVT itself is well-defined by construction, but the characterization theorem is not rigorously established as written.
  • standard math View finders are node-permutation equivariant
    Definition 4.1 and Lemma 4.2 verify this for normalized adjacency powers, Laplacian filters, and diffusion kernels.
  • domain assumption A fixed view-finder set {I, RW^k, SYM^k} transfers across arbitrary graphs
    Empirically supported by benchmarks, but Section I shows Chebyshev filters degrade and filter combinations matter, so this choice is not neutral.
  • standard math Taylor local linearization justifies the 'node-feature dynamic aggregation' expressivity claim
    Theorem 5.2 is a standard Taylor bound; the conceptual leap from local linearity to a new expressivity result is not formalized.
invented entities (1)
  • View space (third axis C) independent evidence
    purpose: Provides a fixed-dimensional representation space for graphs with heterogeneous N and F
    Empirical transfer results across 27 datasets give indirect evidence; there is no external theoretical handle beyond the paper's own framework.

how reviews work

0 comments
Cite this review

Pith. "Pith review of View Space: Learning Representation across Arbitrary Graphs." pith.science (2026). https://pith.science/paper/AMB3W63G

@misc{pith2026251211561,
  author       = {Pith},
  title        = {Pith review of: View Space: Learning Representation across Arbitrary Graphs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/AMB3W63G}},
  note         = {Machine review of arXiv:2512.11561}
}
read the original abstract

Generalizing pretrained models to unseen datasets without retraining is a central challenge toward foundation models. Achieving fully inductive inference on numerical data is particularly difficult due to large variations in feature dimensionality and semantics across datasets. We observe that, in the presence of graph structure, numerical data admits a distinct structure-induced representational axis beyond the feature space, which we formalize as the view space. This view space enables a unified representation of graphs with heterogeneous features and motivates Graph View Transformation (GVT), a class of parametric mappings that can be shared across arbitrary graphs. We instantiate this framework with Recurrent GVT, an architecture for fully inductive node representation learning in node classification. Pretrained on OGBN-Arxiv and evaluated on 27 benchmarks, Recurrent GVT outperforms GraphAny, the prior fully inductive graph model, by +8.93%, and surpasses 12 individually tuned GNNs by at least +3.30%. These results establish the view space as a principled and practical foundation for learning across graphs with heterogeneous feature spaces. Code and checkpoints are available in https://github.com/dooho00/graph-view-space.

Figures

Figures reproduced from arXiv: 2512.11561 by the authors.

Figure 1
Figure 1. (Left) Graphs of varying sizes and feature dimensions can be mapped into the view space as N × F view vectors vn,f = Xn,f,: ∈ R C . (Right) Graph View Transformation (GVT) transforms the node-feature matrix X into a node-feature-view tensor X through view stacking, and then applies ϕ to each view vector to produce a scalar, yielding the node-representation matrix Z. Definition 4.6 (Graph View Transformation). Given … view at source ↗
Figure 2
Figure 2. Node-feature heatmaps of linearly approximated aggrega￾tion weights for view from A2 SYM. To demonstrate that the node-feature dynamic aggregation of nonlinear GVT described in Section 5 is not merely a theoreti￾cal property but an observable behavior, we compute the local linearizations defined in Theorem 5.2 and visualize them as a heatmap over sampled nodes and features in [PITH_FULL_IMAGE:figures/full_fig_p009_2.png] view at source ↗
Figure 3
Figure 3. Pairwise Wilcoxon signed-rank tests comparing RGVT using either a Linear or MLP [PITH_FULL_IMAGE:figures/full_fig_p015_3.png] view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: Average test accuracy (%) across 28 datasets using different view-finder sets for RGVT, [PITH_FULL_IMAGE:figures/full_fig_p026_4.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Node4All: Learning Node Representation Beyond Datasets

    cs.LG 2026-07 conditional novelty 6.0 of 10

    A single graph encoder pretrained only on synthetic graphs produces node representations that rank 5th among 21 per-dataset-optimized baselines on 25 benchmarks without any per-dataset tuning.

Reference graph

Works this paper leans on

6 extracted references · 1 linked inside Pith · cited by 1 Pith paper

  1. [1]

    ν(P AP⊤) =P AP⊤ +I=P(A+I)P ⊤ =Pν(A)P ⊤

    Self-augmented. ν(P AP⊤) =P AP⊤ +I=P(A+I)P ⊤ =Pν(A)P ⊤

  2. [2]

    19 Preprint ν(P AP⊤) = (P DP⊤)−p (P AP⊤) (P DP⊤)−q =P D−p A D−q P ⊤ =Pν(A)P ⊤

    Degree-normalized. 19 Preprint ν(P AP⊤) = (P DP⊤)−p (P AP⊤) (P DP⊤)−q =P D−p A D−q P ⊤ =Pν(A)P ⊤

  3. [3]

    P LP⊤ =P DP⊤ −P AP⊤ =D ′ −A ′ =L ′, and forf(z) = P k≥0 akzk, f(P LP⊤) = X k≥0 ak(P LP⊤)k =P X k≥0 akLk P ⊤ =Pf(L)P ⊤

    Spectral/Laplacian filters. P LP⊤ =P DP⊤ −P AP⊤ =D ′ −A ′ =L ′, and forf(z) = P k≥0 akzk, f(P LP⊤) = X k≥0 ak(P LP⊤)k =P X k≥0 akLk P ⊤ =Pf(L)P ⊤. Same forL sym

  4. [4]

    Then ν(P AP⊤) =α(I−(1−α)B ′)−1 =αP(I−(1−α)B) −1P ⊤ =Pν(A)P ⊤

    Diffusion kernels.LetB=D −1A, soB ′ = (D′)−1A′ =P BP⊤. Then ν(P AP⊤) =α(I−(1−α)B ′)−1 =αP(I−(1−α)B) −1P ⊤ =Pν(A)P ⊤

  5. [5]

    Thus, all listed preprocessing operators satisfyν(P AP ⊤) =Pν(A)P ⊤ and are permutation equivariant

    Polynomial variants.Ifν 0(P AP⊤) =Pν 0(A)P ⊤, then p(ν0(P AP⊤)) = KX k=0 ck(ν0(P AP⊤))k = KX k=0 ck Pν 0(A)kP ⊤ =Pp(ν 0(A))P ⊤. Thus, all listed preprocessing operators satisfyν(P AP ⊤) =Pν(A)P ⊤ and are permutation equivariant. D.2 PROOF OFTHEOREM4.7. Theorem D.1(Fully Inductive GVT).GVT is equivariant to both node permutations (R1) and feature permutati...

    2017

  6. [2018]

    Haoyu Peter Wang, Shikun Liu, Rongzhe Wei, and Pan Li

    URLhttps://openreview.net/forum?id=rJXMpikCZ. Haoyu Peter Wang, Shikun Liu, Rongzhe Wei, and Pan Li. Generalization principles for in- ference over text-attributed graphs with large language models. InForty-second International Conference on Machine Learning, 2025. URLhttps://openreview.net/forum?id= dfOqiHuklY. Minjie Wang, Da Zheng, Zihao Ye, Quan Gan, ...

    arXiv 2025

Pith tools

Reviewed August 3, 2026 · model on record in the stance chip above.