Jet Aggregation: Message Passing That Cannot Flatten Polynomial Features

Graph neural networks update each node by averaging messages from its neighbors. Stack enough of these layers and every node ends up with nearly the same features. This failure is called over-smoothing. On point clouds and meshes it is especially damaging, because the averaging erases the corners, ridges and curvature that distinguish one part of a shape from another. Geometry processing has long handled a closely related problem in a different way. It fits a small polynomial surface (a truncated Taylor expansion, called an n-jet) to each local neighborhood by weighted least squares, then reads off position, normal and curvature analytically. We propose to use that fitting procedure as the aggregation step itself. At each layer, a node fits a weighted polynomial to its neighbors' features as a function of their relative coordinates. It then updates itself from the fitted value and the fitted derivatives, not from the mean.

The reason this should matter is a property that averaging lacks. A degree-$n$ least-squares fit reproduces any feature field that is already a degree-$n$ polynomial of position. Plain averaging reproduces only the constant field. Stacking averaging layers therefore collapses features toward one dimension. Stacking jet-fitting layers can only remove the part of a feature field that is rougher than degree $n$, which leaves a guaranteed floor on feature rank. Our claim is that this turns over-smoothing on geometric graphs from something networks must fight with normalization or skip connections into a knob, the polynomial degree, with a provable floor and a clear link to the geometric signal the task needs.

Core Claim and What Is New

For node $i$ with neighbors $j$ at relative coordinates $u_{ij}$ (expressed in a local frame), learned confidence weights $w_{ij}$ and input features $h_j$, jet aggregation solves

$$ c^{(i)} = \arg\min_{c} \sum_{j} w_{ij} \Big\| h_j - \sum_{|\alpha| \le n} c_\alpha\, u_{ij}^{\alpha} \Big\|^2 + \lambda \sum_{|\alpha|\ge 1} \|c_\alpha\|^2 , $$

where $u^{\alpha}$ ranges over monomials of total degree at most $n$ and $\lambda$ is a small ridge penalty on the non-constant coefficients. The layer output is $h_i' = \sigma\big(W_0 c^{(i)}_0 + W_1 c^{(i)}_{1} + W_2 c^{(i)}_{2}\big)$. Here $c_0$ is the fitted value at the node, $c_1$ the fitted gradient, $c_2$ the fitted second-order (curvature-like) terms, and the $W$ are learned matrices. The solve is closed-form and differentiable, as in DeepFit.

The analytical statement we will prove is about the linear, propagation-only version of the operator. That version reads out $c_0$ and repeats. Call it $P_n$. Every degree-$n$ polynomial of position is a fixed point of $P_n$ when $\lambda=0$. If the spectral radius of $P_n$ is below one on the complement of that space, then $P_n^k$ converges to a projector whose range has dimension up to $m=\binom{n+3}{3}$ for ambient 3D coordinates. The numerical rank of deep features is then bounded below by $\min(m, \text{rank of the input's polynomial component})$. This directly contrasts with A CLT for Polynomial GNNs on Community-Based Graphs. That paper proves that repeated spectral polynomials, meaning powers of the adjacency matrix, collapse class means and covariances onto the leading eigenvector. Our "polynomial" is spatial and local, and the two notions predict opposite depth behavior. The CLT result motivates our design and also constrains it: it tells us not to build jets from adjacency powers.

The idea is distinct from its nearest neighbors in the file. DeepFit fits jets once, to geometry, in order to estimate normals. It never fits features, never repeats the fit, and never studies depth. DyPolySeg and the related Taylor-inspired segmentation networks (LSFNet, Dynamic Taylor CNN) use polynomial functions of coordinates as convolution kernels. They do not fit the feature field, and they carry no reproduction guarantee. DyPolySeg also reports that accuracy peaks at three encoder layers, which is exactly the depth saturation we target. Smoothness Errors in Dynamics Models truncates a Taylor series of a matrix exponential in time at a global order $T_{max}$. We use spatial, per-node polynomial fits, and the per-node weights can choose locally between smoothing and preserving. DoPE diagnoses over-smoothing in point-cloud GNNs but fixes it with global coordinate embeddings and non-local attention, not with local structure.

Research Program

The first strand is theory. We will prove the reproduction and rank-floor results for $P_n$ and characterize when the spectral-radius condition holds. It can fail. Least-squares reproduction weights can be negative, and moving-least-squares-type operators with negative weights can amplify high-frequency content rather than damp it. This is the method's main technical risk. It echoes the noise-amplification concern raised for high-pass channels in FB-GNN and GSAN. We will derive how the ridge term $\lambda$ and neighborhood size $k$ bound the non-polynomial eigenvalues, and we will measure those eigenvalues empirically on real neighborhoods from ScanObjectNN and the MeshPDE meshes.

The second strand is the backward pass. Backward Oversmoothing proves that gradients in deep GNNs also smooth toward a constant, which traps training at spurious stationary points. The gradient of the jet layer passes through the transpose of the same reproducing operator. We will therefore test whether the polynomial fixed-point space carries a non-vanishing gradient subspace to early layers. This is a hypothesis, not a promise. The honest version is that the forward floor is provable, while the backward benefit is an empirical question that we will measure layer by layer.

The third strand is construction. Weights $w_{ij}$ are predicted by a small point network, as in DeepFit, so neighbors across a sharp edge can be down-weighted. This addresses the fact that jets assume smooth surfaces, which DeepFit lists as a limitation. The local frame comes from a first-order geometric fit computed once per shape. Degree $n\in\{0,1,2,3\}$ is a hyperparameter. At $n=0$ with uniform weights, the layer reduces exactly to mean aggregation, which gives a clean ablation.

Baselines

The naive reference point is the same network with $n=0$, which is a weighted-mean aggregation GNN. It uses identical depth, width, neighborhoods, optimizer and tuning budget. Every gain we claim must first appear against this model. A second ablation fixes $n=1$, meaning planar fitting. This isolates whether curvature-order terms matter beyond gradients, which is relevant because the file notes that low-curvature benchmarks can favor planar approximations.

The standard anti-over-smoothing recipe is PairNorm combined with residual connections, applied to the $n=0$ network. PairNorm keeps total pairwise feature distance constant. It let SGC stay accurate at 60 layers on Cora and reach 74.5% versus 42.3% for vanilla SGC when unlabeled nodes had no features. It is the strongest cheap competitor on depth robustness. Its own authors note that it stabilizes depth without reliably raising peak accuracy.

The strongest frequency-splitting competitor is FB-GNN. It adds a learned high-pass "diversification" channel and reported roughly 10% gains over GCN on Texas and Cornell. We will run it on the same k-NN point graphs.

The strongest domain method is DyPolySeg. It reports 72.92% mIoU on S3DIS 2-way 1-shot, 71.89% mIoU on ScanNet 2-way 1-shot, and 90.8% accuracy on ScanObjectNN with 2.64M parameters. We will take its released configuration at its preferred three layers, then deepen it to match our depths. For fairness, we will swap DyPolyConv for jet aggregation inside the same Mamba/prototype pipeline, holding parameters within 10%.

For dynamics on meshes, the baseline is R-UNIMESH from Smoothness Errors, which reports a Rayleigh Error of 9.1 on MeshPDE heat diffusion against 14.2 for EMAN. We have no reported numbers from the file for its Wave or Cahn-Hilliard results, only the paper's statement that they were mixed.

Beating a baseline means one of two things, measured over five seeds with matched hyperparameter search budgets. Either we match its best-depth accuracy while holding within one point of that accuracy at 4 to 8 times the depth where it degrades, or we exceed its best-depth accuracy outright.

Why not just…?

Why not just add PairNorm and skip connections? This is a real threat on accuracy-versus-depth curves, and we treat it as the main comparison rather than arguing it away. The distinction we expect is qualitative. PairNorm preserves some spread between nodes, but random spread would satisfy it too. Are we measuring oversmoothing correctly? notes that high rank does not imply useful features, while its effective rank tracks accuracy with average Pearson correlation 0.91. Jet aggregation preserves specifically the spatially structured part of the features. The decisive test is whether, at matched rank, jet features score better on curvature-sensitive probes and segmentation boundaries. If PairNorm plus residuals matches us there too, the rank-floor story is academic and we will report that.

Why not just feed relative coordinates into a learned message function? Polynomial-kernel convolutions such as SpiderCNN and polynomial separable convolution could in principle learn derivative-like messages. However, nothing forces the learned aggregate to reproduce smooth fields, so nothing prevents collapse at depth. DyPolySeg's three-layer peak is evidence of this. We will include a learned-coordinate-message baseline with the same monomial inputs but no least-squares solve. Comparing it against jet aggregation isolates whether the fit, and not the features, is what matters.

Why not just use a high-pass difference channel or global positional encodings? FB-GNN's high-pass channel captures first differences, which amount to one unnormalized gradient direction, and it risks amplifying noise. DoPE's centroid-relative embeddings shift with the coordinate frame and give no derivatives. Both are run as baselines. The noise-robustness experiment below, on PCPNet noise levels, is where we expect the least-squares fit's averaging of residuals to separate it from a raw difference channel.

Proposed Experiments

The core experiment is a depth sweep over 3, 6, 12, 24 and 48 layers on ScanObjectNN classification and S3DIS/ScanNet few-shot segmentation. Degree $n\in\{0,1,2,3\}$ is crossed with every baseline above. At each depth we log accuracy or mIoU, numerical and effective rank of the features at every layer, and per-layer gradient norms, the latter to test the backward-over-smoothing prediction.

The central prediction is falsifiable in shape. Effective rank for $n\ge1$ should plateau near the predicted floor $m$ rather than decaying toward one. The $n=0$ model should decay. If rank for $n=2$ still collapses, the spectral-radius condition is failing on real neighborhoods, and the eigenvalue measurements will show why.

A geometric sanity check runs a feature-level version of the PCPNet protocol. We place synthetic feature fields on the shapes, namely polynomial fields, curvature fields, and fields with jump discontinuities along creases. We then measure how much of each field survives $k$ layers. Survival should be near-exact for polynomial fields of degree $\le n$. Fields with jumps are expected to be preserved only if the learned weights cut across creases.

The dynamics experiment replaces R-UNIMESH's aggregation with jet aggregation on MeshPDE heat, wave and Cahn-Hilliard, reporting Rayleigh Error and rollout stability. The prediction here is two-sided and therefore informative. On heat, jets with low effective degree should match R-UNIMESH's 9.1 by being allowed to smooth. On Cahn-Hilliard, the learned weights should keep phase boundaries sharp where the global $T_{max}$ fails. A loss on heat would tell us that the reproduction guarantee causes the under-smoothing that Smoothness Errors warns about for rigid constraints.