Stopping Early on Purpose: Latency-Aware Robust Beamforming for Fresh Updates over Aging Channels

A base station that serves fast-moving users has to estimate each user's channel, compute transmit weights by running an iterative optimizer, and only then send. The channel keeps changing during all three steps. Wireless research treats these steps separately. Optimizers are judged as if their output were applied the instant they were given the channel. Robust designs, which pick weights that work for every channel inside an assumed "uncertainty set", treat the size of that set as fixed. Freshness metrics such as Age of Information (AoI) treat each transmission as a coin flip with a known success probability. This proposal joins the three into one loop. Each extra optimizer iteration improves the weights for the channel the solver was given, but it also lets the real channel drift further from that estimate. It also delays the moment the receiver gets new information. So there is a best moment to stop computing, and it moves with user speed.

We propose an unfolded optimizer that can be stopped after any layer. An unfolded optimizer is an iterative algorithm truncated to a fixed number of steps, each step becoming a trainable neural-network layer. In our design, the output of every layer is a valid robust beamformer for an uncertainty set that has been widened to match the time already spent computing. A stopping rule then picks the layer that minimizes the expected age of correctly decoded status updates. The claim to be tested is simple. Across 10–100 km/h, this joint choice of depth and robustness margin beats both "converge, then apply" and "fixed shallow network". It also beats the most natural alternative, which is to predict the future channel and optimize against the prediction.

Core Claim

The time spent optimizing is an input to the uncertainty set the optimizer must guard against, not a cost to report afterward. For a user with maximum Doppler frequency $f_D$ (the rate at which motion makes the channel rotate) and a total delay $\tau$ between pilot reception and the moment the weights are applied, the classical Jakes correlation model gives a normalized channel error whose standard deviation grows roughly as $\pi\sqrt{2}\, f_D \tau$ for small $\tau$. This comes from the expansion $1-J_0(x)\approx x^2/4$ of the Bessel correlation. The uncertainty radius $\delta(\tau)$ therefore grows about linearly in solver time. With a layer cost of $c$, the delay after $k$ layers is $\tau_k=\tau_0+kc$, and each update cycle lasts $T_k=\tau_k+T_{tx}$. If a cycle's update is decoded with probability $p_k$, which is the probability that the true channel at transmission time meets the target signal-to-interference-plus-noise ratio (SINR), then for periodic updates with independent successes the average age is

$$\bar\Delta(k) \approx T_k + T_k\left(\frac{1}{p_k}-\frac{1}{2}\right).$$

The first term is the delivery delay. The second is the inter-delivery penalty of geometric retries. Deeper solvers raise $p_k$ only as long as the improvement in the weights outpaces the growth of $\delta(\tau_k)$, so $\bar\Delta(k)$ has an interior minimum that depends on speed.

This regime is real, not hypothetical. Unfolding WMMSE Using Graph Neural Networks reports about 2 ms per sample for its 4-layer network and 16 ms for classical WMMSE (a standard iterative weighted-MMSE beamforming algorithm). The research file places coherence times at 1–5 ms under mobility. Both solver latencies are therefore comparable to or longer than the time the channel stays roughly constant.

Relation to Prior Work

Three lines of work each hold one piece of the loop and fix the others.

The robust-design papers supply the uncertainty-set machinery but treat the set as exogenous. Robust Downlink Transmit Optimization Under Quantized Channel Feedback includes outdated channel information in a compound uncertainty model. It assumes the delay is a known constant and solves with matrix-inequality interior-point methods whose own run time would add to that delay. Joint Beamforming and Power Allocation based on CSI uses an ellipsoidal set solved as a second-order cone program, with the ellipsoid fixed across the frame. We reuse their worst-case reasoning. What we change is that the radius becomes a function of how long we compute.

The unfolding papers supply the fast solver but assume the channel freezes during inference. UWMMSE evaluates static Rayleigh snapshots. Soft-Output Joint Channel Estimation and Data Detection using Deep Unfolding assumes block fading over the frame. Deep FlexQP adds an elastic $\ell_1$ relaxation that keeps unfolded solvers well-defined when constraints become infeasible. We borrow that method directly. As $\delta$ grows, some users' worst-case SINR targets become unreachable, and an elastic slack is what lets the network shed those users gracefully instead of failing.

The freshness papers supply the objective but idealize the channel. Age-Based Scheduling for Mobile Edge Computing counts computation delay inside AoI, but the computation it means is payload processing, and its links are block-fading. Remote State Estimation over a Wearing Channel is the closest conceptual neighbor because it trades freshness against channel aging. Its "aging", however, is scalar hardware wear, and its policy comes from offline dynamic programming with zero computation time. Joint Status Sampling and Updating motivates the stopping idea: it shows that zero-wait updating is suboptimal and that waiting can lower age. We apply the same lesson to computation instead of sampling.

One paper constrains the design. Cross-layer Optimization for URLLC shows that splitting a reliability budget equally across error sources lands within 2–5% of optimal power. This warns us that a simple fixed rule might capture most of the benefit, and our baselines are built to test exactly that.

Research Program

Problem setting. We study multi-user multi-antenna downlink with per-user status updates. Each update counts as delivered only if the SINR evaluated on the true channel at transmission time exceeds a target $\gamma$.

Layer operation. Each layer updates the beamformers $w_j$ by an unfolded projected-gradient or WMMSE-style step. It works on a closed-form, conservative worst-case surrogate for a ball of radius $\delta$ around the estimate $\hat h_i$. The useful signal is lower-bounded by $(|\hat h_i^H w_i|-\delta\|w_i\|)^2$, and the interference is upper-bounded by $(|\hat h_i^H w_j|+\delta\|w_j\|)^2$. This avoids the semidefinite programs of the robust literature, keeps every layer cheap and differentiable, and makes every intermediate output a certified (if conservative) robust solution.

Inputs at each layer. - Layer $k$ receives $\delta(\tau_k)$ as an input, so robustness tightens as computation proceeds. - Per-user priority weights are set to the users' current ages, so stale users are protected first. - Elastic slacks in the style of FlexQP mark which users are effectively dropped this cycle.

Setting the radius. $\delta(\tau)$ is not taken from the Jakes formula at deployment time. Instead it is calibrated empirically: we use the residuals of a channel predictor, the MambaCSP architecture or a cheaper autoregressive predictor, as a function of prediction horizon. We take a split-calibration quantile so that the ball contains the true channel with a chosen coverage. This addresses a gap the research file names: predictors output point estimates, not set geometry.

Stopping rule. A small head estimates $p_k$ from the current slack values and $\delta$. The network halts at the layer minimizing the age expression above, given the observed Doppler and the current ages.

Training. We train end to end on drifting channels. The loss is the realized age of the resulting schedule, with SINR evaluated on the channel at actuation time rather than at pilot time.

Baselines

Naive reference. Classical WMMSE run to convergence on the pilot-time estimate, with the result applied to the aged channel. This is the "assume quasi-static" default, and it defines how much is lost by ignoring both drift and latency.

Strongest existing fast optimizer. UWMMSE at its published 4 layers. Its paper reports an average sum-rate of 83.21 versus 82.94 for WMMSE, at about 2 ms versus 16 ms per sample, on Rayleigh fading with path-loss exponent 2.2 and 20 transceiver pairs. We first reproduce those numbers on its static benchmark to validate our implementation. We then run it on the same drifting channels, training data, and GPU budget as our method. No AoI or aged-channel result is reported for it on Lacuna. Beating it means lower average and peak age at equal transmit power, at every speed above some threshold we will report.

Strongest robustness competitor. The ellipsoidal cone-program design of Chen et al., solved with a standard interior-point solver. Its radius will be swept and the best value chosen per speed bin on validation data, and its measured wall-clock solve time will be charged to $\tau$. No reported quantitative result was found on Lacuna for this method, or for the Huang et al. QCQP method, under mobility.

Predict-then-optimize. A channel predictor forecasts the channel at actuation time, and UWMMSE then optimizes against that forecast. For MambaCSP, the only reported figures are relative: 9% (TDD) and 12% (FDD) lower NMSE than an LLM baseline on QuaDRiGa urban macro-cell non-line-of-sight at 10–100 km/h. No absolute NMSE values and no downstream age figures are reported on Lacuna.

Tuned fixed rule. The best fixed depth together with a constant calibrated margin, chosen per speed bin by grid search with the same tuning budget we spend on our method.

Ablations. Two ablations isolate the key ingredient:

  • Anytime stopping with $\delta$ frozen at its pilot-time value, which removes latency-driven widening.
  • Latency-driven widening with fixed depth, which removes stopping.

Why not just…?

Why not just predict the channel at actuation time and optimize the prediction? This is the most serious threat. If prediction error stayed small over the whole solver horizon, a point forecast would remove most of the drift and robustness would add little. The predict-then-optimize baseline tests this directly. Our expectation is that the advantage concentrates where prediction error grows quickly with horizon, at high speed and long horizons. Prediction also does not answer how long to compute, since solver time still lengthens the forecast horizon. If predict-then-optimize matches us at every speed, we will report that the robust set adds nothing beyond a good forecast. In that case the contribution narrows to the stopping rule, applied on top of the predictor.

Why not just use a shallow fixed-depth network and call latency negligible? UWMMSE's roughly 2 ms is not negligible against 1–5 ms coherence times. More importantly, the best depth should shift with speed, and a fixed depth cannot follow it. If the per-speed best depth turns out to be constant across 10–100 km/h, this alternative wins and our stopping head is unnecessary. The depth-sweep experiment below checks this.

Why not just inflate a fixed robustness margin offline? The URLLC equal-split result suggests fixed rules can come close to optimal, so this is plausible. The tuned fixed-rule baseline is that alternative, given oracle access to the speed bin. Our method has to beat it on data with speed variation inside each episode, where no single bin applies. If it does not, the honest conclusion is a lookup-table design rule rather than a learned stopping mechanism, and we will say so.

Proposed Experiments and Decisive Checks

Simulation data. We use QuaDRiGa 3GPP TR 38.901 urban macro-cell non-line-of-sight channels at 10–100 km/h with 4–64 antennas, matching the MambaCSP setup of 8,000 training, 2,000 validation, and 10,000 test samples. We also use continuous-time Rayleigh/Jakes processes with path-loss exponent 2.2 for controlled sweeps.

Timing. All solver times are measured as wall-clock on the same GPU and inserted into the simulated timeline. Nothing is assumed to take zero time.

Metrics. Primary metrics are average and peak AoI of decoded updates. Secondary metrics are worst-case-SINR violation rate, the empirical coverage of the calibrated $\delta(\tau)$, and power.

Decisive check 1: the trade-off exists. For each speed, we plot realized age against forced stopping depth. The thesis requires an interior minimum whose location moves to shallower layers as speed rises. If the curves are monotone, the core claim fails.

Decisive check 2: both ingredients are needed. Both ablations must lose to the full method. Otherwise latency-driven widening, or stopping, is not doing the work.

Decisive check 3: it holds under changing speed. We test on episodes whose speed changes mid-run, which removes the oracle advantage of per-bin tuning. Here the method must beat the tuned fixed rule and predict-then-optimize, with confidence intervals computed over test episodes.