Codes That Outlive the Topology: Learning Change-Aware Interference Alignment for Moving Networks

Wireless transmitters that do not know their channels can still avoid interfering with each other if they know who can hear whom. Topological interference management (TIM) is the theory of doing exactly this. Each transmitter holds only a one-bit map of which links are above the noise floor, and transmissions are arranged across time slots so that unwanted signals pile up on top of each other at the receivers that must ignore them. The approach is attractive for fast-moving networks such as vehicles, drones and satellites, because channel feedback there goes stale before it arrives, while the coarse "who hears whom" graph changes far more slowly. The catch is that every TIM scheme on record assumes that graph is frozen for the whole coding block. When it changes, the entire code is recomputed and redistributed. At high mobility that recompute-and-broadcast loop can take longer than the topology lasts.

We propose to learn TIM codes that are built to survive predictable topology changes. Given a short forecast of how the conflict graph will evolve, the method should keep each message's code fixed wherever it can. It changes codes only where a forecast change forces it, and it trades a small loss in alignment efficiency for a large cut in re-coding signaling. The contribution is a change-aware objective together with a learned local solver for it. Measured in achieved interference-free throughput per unit of control signaling, the method should beat both per-snapshot recomputation and classical greedy repair once the network moves fast enough.

Core Claim

In scalar interference alignment, TIM precoder design is exactly a local graph-coloring problem on a "message conflict graph", where each node is a message and edges are the interference constraints the topology imposes. Learning to Code on Graphs for Topological Interference Management (LCG) establishes this mapping. LCG solves the problem with a GraphSAGE encoder and a PPO policy that assigns colors (codes) to confident nodes and defers uncertain ones to later rounds. It treats the graph as static, so any movement means rerunning the search. It reports about 4 seconds on 100-node graphs, which is far faster than TabuCol's 500 seconds but still slow next to link lifetimes in LEO or vehicular settings.

We pose the dynamic version. For a forecast sequence of conflict graphs $G_t,\dots,G_{t+W}$ over a window of $W$ snapshots, choose per-snapshot code assignments $c_\tau$ that maximize

$$\sum_{\tau=t}^{t+W} \mathrm{DoF}(c_\tau; G_\tau) \;-\; \lambda \sum_{\tau} \big|\{i : c_\tau(i) \neq c_{\tau-1}(i)\}\big|,$$

where $\mathrm{DoF}(c_\tau;G_\tau)$ is the degrees of freedom (fraction of interference-free signal dimensions per message) that the assignment achieves on that snapshot, counting zero for any message whose constraints are violated. The second term counts the messages whose code must be changed and re-signaled, weighted by the price $\lambda$ of one re-coding event. Two special cases bracket the problem. With $\lambda=0$ it reduces to LCG applied per snapshot. With $\lambda\to\infty$ it becomes coloring the union of all forecast graphs, which gives one conservative code for the whole window.

Our claim is that the useful operating points lie between these extremes. A learned solver can find them cheaply because forecast changes in bounded-mobility networks are spatially local and temporally correlated. Links appear and disappear along trajectories rather than at random.

Of the four directions, TIM supplies the object being optimized and graph neural networks supply the solver. Dynamic topology is the regime that creates the problem. Joint-allocation complexity enters as a constraint: the combined code-plus-admission decision must stay local and cheap to recompute.

Research Program

The first component is the forecast model. We borrow the time-snapshot view of Jia et al.'s Reconfigurable Time Extension Graphs, which discretize time into quasi-static slices joined by transition edges, and we move it from routing to the physical layer. Here a snapshot's edges are TIM interference constraints, and the transition edges carry re-coding cost. Forecasts come from trajectory extrapolation for vehicles and from deterministic orbital propagation for satellites, the same predictability that Wang et al.'s Tiansuan work exploits for connectivity lookup. We deliberately inject forecast error so the solver is never trained on perfect futures.

The second component is the solver. It is a spatio-temporal graph network over the stacked message conflict graphs. The spatial part uses GraphSAGE-style layers as in LCG, and the temporal part is a small convolution over the window, in the spirit of the encoder in Graph-Aware Temporal Encoder Based Service Migration and Resource Allocation in Satellite Networks. That paper encodes visibility graphs for migration and ignores co-channel interference; we instead encode interference constraints. The policy outputs a code for each (message, snapshot) pair and is trained with PPO plus LCG's defer mechanism, using the objective above as reward.

The departure from LCG that matters is incremental operation. At run time the solver is invoked only on the $k$-hop neighborhood of the messages touched by a forecast change or a forecast miss. Its input includes the current codes as node features, so preserving existing codes is the default action. This keeps update cost proportional to the size of the change rather than the size of the network, which is the property that sequential reinforcement learning over the whole graph lacks.

The third component is a discrete admission choice. Some messages sit on edges that flicker in and out every snapshot. For such a message, the cheapest decision may be to exclude it from the aligned schedule for the window and serve it on an orthogonal fallback slot. This extends the admission-control idea of Topological Interference Management with User Admission Control via Riemannian Optimization from a static graph to a window. The admission head shares the encoder. Continuous power control is left out on purpose. TIM's gains come from alignment structure, and adding power variables would reopen the continuous-CSI dependence the approach exists to avoid.

Finally, we evaluate at the signal level, not only in DoF. Each code is simulated under Rayleigh fading with sub-threshold interferers included, because one-bit thresholding hides them. This tests whether the degree-of-freedom gains survive at finite SNR.

Baselines

The naive reference is orthogonal time-division scheduling with a fresh proper coloring of the current conflict graph at every snapshot. It needs no alignment and is re-signaled whenever its coloring changes. This shows what TIM buys at all under mobility.

The strongest existing method is LCG rerun on every snapshot, using the authors' training recipe on 15-node Erdős–Rényi graphs. LCG reports a 100% success rate when transferred zero-shot to 100-node wireless simulation graphs, about 4 seconds per 100-node solve against over 500 seconds for TabuCol, and symmetric DoF of 1/3 in 18% of subspace-IA cases against 10% for scalar IA (LCG). We give it the same forecast-free snapshots, the same compute per snapshot, and the same hyperparameter search budget as our solver. To be fair, we also run it with warm-start from the previous snapshot's codes. We count its measured solve time as latency during which the stale code is in force.

The classical competitor is greedy local recoloring. When an edge appears, only violated nodes are recolored, using the smallest feasible color that respects local-coloring constraints. We run it on the same forecasts.

The key ablation replaces our learned window solver with TabuCol applied to the union graph of the window. This isolates whether learning matters or whether simply planning against the forecast does the work. A second ablation sets $\lambda=0$ within our model, which isolates the change-cost term.

For signal-level context we also run UWMMSE (Unfolding WMMSE Using Graph Neural Networks). It reports sum-rate 83.21 against 82.94 for WMMSE, at about 2 ms per sample, with perfect CSI. We feed it CSI delayed by one feedback round and charge it the corresponding feedback overhead.

Beating LCG means higher time-averaged DoF per re-coding event at equal or lower update compute, at speeds where LCG's solve time exceeds the median link lifetime. Beating greedy repair means at least that, plus a statistically clear DoF gain at equal re-coding rate.

Why not just…?

Why not just rerun LCG faster, or on a GPU? Speed alone does not remove the cost that dominates at high mobility, which is redistributing a globally recomputed code. A per-snapshot optimum can reassign many messages even when only one edge changed. The $\lambda=0$ ablation and the warm-started LCG baseline measure exactly this churn. If warm-started LCG already produces few code changes, the change-cost term is unnecessary and we will report that.

Why not just do greedy local repair? This is the real threat. Dynamic coloring heuristics are cheap and local, and they may be close to adequate. Their weakness should show up when changes are correlated: a vehicle sweeping past a cluster forces a series of repairs, each locally reasonable but together wasteful. A forecast-aware solver can pick one code that survives the whole sweep. If greedy repair comes within about 2% of our DoF-per-signal on the taxi traces, we will drop the learning claim and keep only the forecast-aware objective, solved heuristically.

Why not just color the union graph over the window? It is simple and needs no learning. However, it charges every transient edge for the whole window, which lowers DoF, and its value depends heavily on picking the window length. The TabuCol-on-union ablation, swept over $W$, shows whether a single fixed window matches the per-node adaptive trade-off our solver learns.

Why not just abandon TIM and use channel-aware power control with stale CSI? Graph power allocators such as UWMMSE assume accurate instantaneous gains. Stale gains are precisely what high mobility produces, and feedback overhead grows super-linearly with the number of nodes. The delayed-CSI UWMMSE comparison with feedback cost charged settles this regime by regime. We expect UWMMSE to win at low speed and TIM codes to win at high speed. Locating the crossover is itself a result.

Proposed Experiments

The first benchmark extends the LCG wireless simulation setup: a 1 km × 1 km area at 2.4 GHz with line-of-sight path loss and 15-to-100-node graphs. We add random-waypoint mobility swept from pedestrian to highway speed.

The second uses the Shanghai taxi GPS traces from the dynamic THz vehicular GNN work. These comprise 3,500 topology snapshots split 1,500/1,000/1,000. We convert consecutive snapshots into dynamic conflict graphs by thresholding path loss. That paper reports 91% of exhaustive-search performance for its channel-aware pairing, but no reported result was found on Lacuna for TIM coding on these traces.

The third is a satellite-to-ground downlink scenario built by propagating orbits. We report it as exploratory, because the file lists no public constellation interference benchmark with reported TIM numbers.

We report three metrics: time-averaged sum-DoF with violated messages counted as zero, re-coding events per second, and update compute per change. From fading simulations we also report finite-SNR spectral efficiency.

The decisive check is a plot of DoF per re-coding event against node speed for all methods. The proposal succeeds if a speed band exists in which it dominates both warm-started LCG and greedy repair, and if that advantage persists when forecast error is raised to realistic levels. It fails if the advantage disappears as soon as forecasts are imperfect, or if the union-graph ablation matches it. Either outcome would show that the gain comes from forecasting rather than from the learned change-aware solver.