Event-Level Dispersion Control for Streaming Tensor Hypergraphs

Many real systems record group events rather than pairwise ones: an email sent to five people, a paper with four authors, a forum thread with a dozen replies. A natural way to learn from such streams is to give every entity a memory vector and update the participants' memories each time an event arrives. This note argues that such models have a failure mode that has received little study. Every group event pulls its participants' memories toward each other, and active entities take part in thousands of events. Their memories therefore drift toward one shared vector over the course of the stream. This is the classic graph "over-smoothing" collapse, where repeated neighbourhood averaging makes all node representations look alike. Here the depth comes from the passage of time rather than from stacked layers. Group events make it worse, because one event mixes many entities at once.

We propose an update rule for each event that separates two jobs that averaging conflates. The first is writing new information about the event into the participants. The second is how much more similar the participants become to one another. The update rotates the participants' deviations from their group mean using a group-dependent rotation built from a low-rank factored tensor. A three-way event therefore acts differently from three pairwise events. The update shrinks those deviations only through an explicit, bounded, learned gate. The resulting model never materializes a hypergraph tensor. Each event costs time linear in its size and in the factorization rank. It admits new entities at any time, and the rate at which participants become similar is a quantity we can monitor and control.

Where the three directions meet, and what is missing

Tensor hypergraph models encode a group of size $m$ as an entry of an $m$-th order array, so that a genuine triad is not confused with three unrelated pairs. Tensorized Hypergraph Neural Networks (THNN) makes this practical. It passes "outer-product" messages, where a node receives a multilinear product of its co-members' projected features, and it uses a partially symmetric CP decomposition (a sum of $R$ rank-one terms) to keep cost linear in $R$. THNN supplies our method. It also motivates the problem: its authors report sharp degradation beyond two layers from instability and over-smoothing. THNN is moreover strictly static. The argument for keeping multi-way structure rather than collapsing it to pairs is supported by the identifiability result in A tensor approach to learning mixed membership community models and by the clique-expansion ablations in THINK.

Three papers make deep hypergraph networks stable, and all three assume a fixed topology and incidence-matrix propagation. Deep-HGCN adds initial residuals and identity-mapped weights. Hypergraph Dynamic System treats depth as the time variable of a stable ordinary differential equation. IHGNN solves for a fixed point of a contraction. In each case "dynamics" means internal depth, not a changing graph, and two of them name dynamic hypergraphs as future work. Anti-Symmetric DGN shows that skew-symmetric weights give non-dissipative propagation that survives 30+ layers. We borrow that principle but apply it per event and to group deviations rather than per layer.

Dynamic hypergraph models exist, but none treats the stream itself as the source of collapse. DHGNN and TDHNN rebuild or learn hypergraph structure during training. HYDG and Heterogeneous Temporal Hypergraph Neural Network build temporal hyperedges over snapshots. All of them use incidence matrices and shallow aggregation, and none measures representation collapse. DynaSTy adapts to changing topology through attention biases, but it is pairwise, quadratic in the number of nodes, and assumes a fixed node set.

The gap is therefore specific. No model processes a stream of polyadic events with a multilinear, factored update. No work asks whether memory-based temporal models over-smooth as a function of how many events an entity has seen.

Core Claim

Our first claim is about existing models. Streaming memory models that aggregate group events by averaging, possibly followed by a recurrent gate, homogenize their high-activity entities. The damage should show up as accuracy that falls with an entity's event count, not with layer depth.

Our second claim is about the fix. An event update that conserves within-event dispersion, except through an explicit bounded gate, removes this degradation. Making the conserving rotation depend multilinearly on the group, through CP factors, adds accuracy on data with real higher-order structure.

Mechanism

Let $h_i$ be entity $i$'s memory. Let an event $e$ with members $S_e$ arrive at time $t$, with mean member state $\bar h_e$ and deviations $\delta_i = h_i - \bar h_e$.

The update has three parts. The first part writes information into the mean: $\bar h_e$ is updated freely by a learned function of event features and elapsed time. The second part rotates each deviation, $\delta_i \leftarrow \exp(K_e)\,\delta_i$. Here $K_e$ is a skew-symmetric matrix, so its exponential is a rotation that preserves length. $K_e$ is assembled from rank-$R$ CP factors: for each component $r$, the product of the members' projections $\prod_{j\in S_e\setminus i} \langle u_r, h_j\rangle$ weights a fixed skew-symmetric generator. This is THNN's outer-product message recast as a generator of rotations rather than as an additive term. The third part scales the deviations by a gate $\gamma_e \in [\gamma_{\min}, 1]$.

Together these give

$$\textstyle\sum_{i \in S_e} \|\delta_i^{\text{new}}\|^2 = \gamma_e^2 \sum_{i \in S_e} \|\delta_i^{\text{old}}\|^2,$$

so any loss of within-group distinctiveness is attributable to $\gamma_e$ alone. We log $\gamma_e$ and can regularize it.

Events of different sizes share factors, with no padding. Each member's product runs only over the actual co-members, so THNN's global auxiliary node never appears. That node is a shortcut THNN's authors themselves link to faster collapse. A new entity enters with an encoder-initialized state.

We do not claim that equal-magnitude rotations make states informative. As Are we measuring oversmoothing in graph neural networks correctly? warns, distance-based energy can miss collapse onto a low-dimensional subspace. We therefore also track the effective rank of the memory matrix.

Research Program

The work has three stages. First, we build a diagnostic. On standard temporal hypergraph data, we will plot within-event dispersion, global dispersion and effective rank of memories against each entity's cumulative event count, for several existing streaming designs. This establishes whether temporal over-smoothing is real before we try to fix it. If high-activity entities show no collapse in strong baselines, the paper reduces to the multilinear-update question, and we will say so.

Second, we build the model and analyze it. We will derive the conservation identity above and bound how far two entities' memories can converge over $k$ shared events in terms of $\prod \gamma_e$. We will also test whether the rotation preserves the triad-versus-pairs distinction that motivates tensors.

Third, we evaluate on real streams and on a planted synthetic stream. In the synthetic stream, labels depend on whether triples co-occur as single events or as three separate pairwise events within a window.

Baselines

The naive reference point has two parts. One is a memory-free model that classifies each entity from its features and static counts of its events. The other is a static hypergraph network (HGNN) trained on the hypergraph accumulated over the training window. If our model cannot beat the accumulated-window HGNN, dynamics are not earning their cost.

The strongest existing methods differ by task. For dynamic link prediction on Yelp, we use Heterogeneous Temporal Hypergraph Neural Network, which reports AUC 74.04% against 70.43% for HTGNN. Beating it means a higher AUC on the same splits, averaged over at least five seeds, with non-overlapping confidence intervals. For dynamic node classification on DBLP3, DBLP5 and Reddit, the strongest is HYDG. The file reports only a "2-3% improvement" over EvolveGCN and DySAT, with no absolute accuracies found on Lacuna, so we will rerun HYDG ourselves under our protocol. For spatiotemporal forecasting on the Twitter Tennis data, we use THINK, which reports MSE 0.58±5e-3. Beating it means a lower MSE.

We also run Hypergraph Dynamic System and Deep-HGCN on rolling snapshots. These represent "deep static stability, re-applied over time." All methods get the same splits, the same hidden size, an equal hyperparameter-search budget (a fixed number of trials on the validation split), and the same GPU-hour cap.

Three ablations isolate the key ingredients. The first replaces the CP-dependent rotation with a fixed rotation, which tests the multilinear part. The second removes the conservation constraint by using an unconstrained GRU update of the participants, which tests the dispersion control. The third replaces the rotation with initial-residual decay toward each entity's input encoding, in the style of Deep-HGCN.

Why not just…?

Why not just use a GRU memory with mean aggregation? Gated recurrent updates can learn to resist homogenization, and Graph Neural Networks (with Proper Weights) Can Escape Oversmoothing shows that suitable weights can avoid collapse in principle. This is the main threat. The unconstrained-GRU ablation settles it. If its accuracy on high-activity entities matches ours and its effective rank does not decay with event count, the conservation constraint is unnecessary and we will report that.

Why not just add an initial residual, as Deep-HGCN does? Pulling memories back toward their input encoding prevents collapse in static hypergraphs. In a stream, however, it also erases the history the memory exists to hold. The residual-decay ablation measures this trade-off. We expect it to match us on dispersion but lose on tasks that depend on long histories, such as order classification on email-Avocado. If it does not lose there, it is the simpler answer.

Why not just expand events into pairwise edges and use a pairwise temporal model? THINK's ablations and THNN's gains over HyperGCN both indicate that pairwise expansion loses signal. Our planted triad-versus-pairs stream gives a direct test, since a pairwise model cannot separate the two cases by construction. On real data, the fixed-rotation ablation tells us whether multi-way structure matters beyond that synthetic case.

Why not just accumulate the window into a static hypergraph? Hypergraph Ego-networks and Their Temporal Evolution finds strong burstiness and temporal locality, with order classification up to 93% on email-Avocado. Accumulating the window discards exactly that ordering. The accumulated-window HGNN and HDS baselines quantify the cost of discarding it.

Proposed Experiments

The data are coauth-DBLP, email-Avocado and threads-ask-ubuntu for future-event prediction and ego-network order classification. We use DBLP3, DBLP5 and Reddit for dynamic node classification, Yelp and AMiner for dynamic link prediction, and the Twitter Tennis data for forecasting. We report accuracy, AUC and MSE as each prior paper does, along with throughput in events per second.

The decisive check is a stratified analysis. We bin test entities by cumulative event count and plot accuracy and memory effective rank per bin for every method. The proposal succeeds if three things hold. Baselines and the unconstrained ablation lose accuracy and rank in the top-activity bins. Our model stays flat across bins. Its aggregate score beats HTHGN's 74.04% AUC on Yelp and THINK's 0.58 MSE on the Twitter Tennis data. It fails if the high-activity degradation never appears or if the GRU ablation closes the gap. A second check, on the planted stream, must show the CP-dependent rotation separating single triadic events from pairwise events while the fixed-rotation ablation cannot.