Divergence-Free Spherical Kernel Layer

(1) Integration point: replace one spherical graph-convolution or attention aggregation block. Inputs are unit query coordinates $x_i\in\mathbb{R}^3$, source coordinates $y_j\in\mathbb{R}^3$, and source features $h_j$. Use an MLP to produce a two-dimensional tangent vector $c_j=P_{y_j}W h_j$; in ambient coordinates this is $c_j=P_{y_j}W h_j$. Aggregate with the fixed or learned-bandwidth matrix kernel, then concatenate the result with scalar channels. Do not add an unconstrained residual to the vector output; if a residual is needed, pass it through the same divergence-free layer.

(2) Pseudocode:

for i,j:
    t = dot(x[i], y[j])
    r = sqrt(max(0, 2 - 2*t))/rho
    phi = 78/(7*pi*rho^2) * relu(1-r)^8 * (32*r^3+25*r^2+8*r+1)
    a = P_x[i] @ y[j]
    b = P_y[j] @ x[i]
    H = surface_hessian_xy(phi, x[i], y[j])
    K_ij = cross_matrix(x[i]) @ H @ P_y[j]
    out[i] += gate(i,j) * K_ij @ c[j]
out[i] = out[i] / (sum_j abs(gate(i,j)) + eps)

Here P_x=I-x x^T, P_y=I-y y^T, cross_matrix(x)v=x cross v, and surface_hessian_xy differentiates the displayed scalar function with respect to both arguments after tangent projection. For an MVP, use PyTorch automatic differentiation on batches of $x,y$; for production, symbolically simplify the derivatives and fuse them. Set gate(i,j)=1 when $r<1$, or use a learned scalar gate multiplied by the fixed kernel.

(3) Computed from the mathematics: tangent projections, the rotated-gradient construction, compact support, and the exact zero-divergence guarantee. Estimated empirically: bandwidth $\rho$, normalization, and any learned gate. Numerically verify the constraint by finite differences on a spherical triangulation or by projecting the output onto vector spherical harmonics and measuring the gradient-mode energy. The main matrix should be regularized with a small diagonal term only if learned gates destroy positive definiteness.

(4) First experiment: train a small spherical message-passing model on a synthetic incompressible velocity field generated from random stream functions and sampled on Fibonacci points. Compare an unconstrained MLP/graph-convolution layer, the same model with a divergence penalty, and this hard-constrained kernel layer at equal parameter count and FLOPs. Measure vector MSE, divergence norm, long-rollout energy drift, and wall-clock cost. Success means divergence remains near numerical precision without a penalty, lower rollout error or better MSE at equal training budget, and no worsening of conditioning as the number of points increases.