Unifying Graph Neural Networks Through a Common Layer Equation
Sai Karthik Navuluru, Siddhartha Shankar Das, Bo Ni, Hongjie Chen, Yu Wang, Baris Coskunuzer, Nesreen K. Ahmed, Franck Dernoncourt, Mahantesh Halappanavar, Tyler Derr, Ryan A. Rossi, Lakshman Tamil
cs.LG
2026-08-17
A seven-component common layer equation spans seven GNN families and 200+ architectures, turning cross-family differences into checkable slot assignments with two identifiability results attached.
A decade of GNN research has produced hundreds of architectures, each with its own paper, notation, and motivating narrative. The cost is more concrete than reading fatigue: the same mechanism appears under different names across families, similarly named methods change different parts of the computation, and cross-family comparisons conflate support, transmitted values, mixing, and updating. Results proved for one family do not visibly transfer to another. Existing unifiers each have blind spots: the message-passing paradigm does not separate scalar support from transmitted values, geometric deep learning foregrounds symmetry, and encoder-decoder taxonomies foreground tasks. What is missing is a layer-level component inventory that puts all seven major families in the same row for comparison.
The core is a seven-component layer equation: (update domain X, channel set K, propagation bank {Pk}, message maps {Ksik}, mixing operator, ego/residual map, update map). The central factorization separates where information moves ({Pk}, the operators deciding along which edges and at what scalar weight) from what moves (the message maps deciding the vector- or matrix-valued content). Read as a pipeline: on each channel a message map builds the value to transmit, the corresponding operator moves it, the mixing operator combines channels, the ego/residual map carries self-state, and the update map produces the new state.
GCN in this language is one channel with the sym-normalized adjacency as the operator and H times W as the message map, no ego term. The entire formal difference between GAT and GCN collapses to one slot: fixed versus state-dependent scalar weights. GraphSAGE versus GIN differs in operator normalization and ego handling.
Three design decisions keep unification from becoming vacuous. A slot discipline fixes each elementary operation by output role (scalar edge and channel weights go to the propagation bank, vector messages to the message maps), so equivalent reformulations do not move assignments. The coverage boundary is explicit: channels take a linear-value form or pairwise messages with permutation-invariant aggregation. And worked step-by-step reductions are given for GCN, GraphSAGE, GAT, and GIN. Function-valued fillings extend the same equation from local message passing to attention, spectral filtering, global communication, relation-specific channels, higher-order domains, and geometric messages. Two provable results come along: under endpoint-local messages and node-local updates, operator support bounds one-layer dependencies, and one-layer global mixing requires a full effective operator row; in the linear additive regime the displayed channel count is not identifiable, while the minimum Kronecker separation rank of the summed layer operator is the invariant.
This is a framework paper, so the results are coverage and organization themselves: more than 200 catalogued architectures (from 400+ cited works) fall into seven nonexclusive families, each with a named primary axis of variation. Spatial, attention, spectral, and graph-transformer families primarily specialize the propagation bank; the heterogeneous family varies the channel set; higher-order varies the update domain; geometric varies message and update maps jointly. A table of 21 representative methods turns "where do these two differ" into a lookup. Seventeen results connect component interactions to oversmoothing, oversquashing, heterophily, expressivity, and permutation symmetry, with sixteen proofs in the appendix. Section 4 demonstrates generating structurally consistent new architectures from the component inventory, exposing combinations absent from the catalog.
The authors are equally explicit about what is not promised: selecting the best architecture remains an empirical inverse problem, mapping measurable graph and task properties to validated component fillings is unresolved, and documented benchmark evidence is translated descriptively into component vocabulary with causal attribution reserved for controlled experiments.
For anyone in graph learning, the table works as a translator: asking which slot a new paper changes immediately exposes many "new architectures" as known slot combinations, and component-level phrasing makes the premises of cross-family transfers checkable. The two theoretical results stand on their own: operator support bounding one-layer dependencies gives the precise form of the depth-for-receptive-field argument, and channel-count non-identifiability warns that multi-channel designs carry representational redundancy, so architecture comparison should look at Kronecker rank rather than head count. For architecture search, the fixed slot discipline hands you a definition of a structurally valid search space.
Plenty sits outside the coverage boundary: training pipelines, decoders, temporal graphs, and pre-training objectives are excluded, and recurrent fixed-point GNNs are only folded into MPNNs in passing. The framework's value depends on accepting its slot discipline; the equivalence problem (the same computation can be legitimately assigned to different components) is settled by convention rather than mathematics, and readers who reject the discipline may classify differently. The 200+ assignments were made by the authors from the original papers at a declared reporting granularity, checkable but not independently verified. As a pure framework paper it reports no new benchmark numbers, "generated architectures are better" has no experimental support, and the authors themselves list the inverse problem as open. The seven-component notation has real overhead, and a one-off user who just wants to run a GCN gets nothing direct from it.