Keyframed Active Subspaces for Time-Dependent Uncertainty Propagation

When an engineer models fluid flow with an uncertain initial state or an uncertain material field, the uncertainty is usually written as a list of $d$ random numbers. Methods that represent the solution as a polynomial in those numbers, called polynomial chaos expansions, become unusable once $d$ reaches a few dozen, because the number of polynomial terms grows combinatorially. A known escape is to rotate the random inputs so that the solution depends strongly on only a few rotated directions, an "active subspace". In those rotated coordinates the expansion becomes sparse. The catch is that this rotation was developed for a single static output. In a time-dependent problem the important directions drift as shocks form and travel. Recomputing the rotation at every time step is expensive, and every rotation re-expresses the solution in a new basis, which adds projection error. Never recomputing it lets the representation go stale.

This proposal borrows the main lesson of video compression and keyframe world models: dynamics are redundant in time, so expensive re-encoding should happen only at the moments where the content actually changes. We propose to hold one rotated, sparse stochastic basis fixed over an interval of time. A cheap indicator, read directly from the current expansion coefficients, measures how much solution energy is leaking into directions the basis treats as unimportant. When that leakage crosses a tolerance, the method declares a "keyframe" and re-estimates the rotation. The claim is that, for uncertain conservation laws with tens of random inputs, event-triggered re-rotation achieves the accuracy of per-step re-rotation at close to the cost of a single static rotation. It should also beat periodic re-rotation at equal cost, because the moments where the important directions change are concentrated in time.

Where This Sits

The rotation idea comes from Enhancing sparsity of Hermite polynomial expansions by iterative rotations. That paper computes a gradient matrix analytically from Hermite expansion coefficients, rotates coordinates along its eigenvectors, and recovers sparse expansions by compressive sensing. On a 12-dimensional function whose structure is not aligned with the coordinate axes, it reports roughly 100% relative error without rotation and below 0.1% with rotation. It treats static outputs and a single-time snapshot of a KdV problem with time-dependent noise. It does not say how long a rotation stays valid as the solution evolves; that question is the gap this proposal fills. We reuse its analytic gradient construction, which supplies the method, and inherit its restriction to Gaussian inputs, which constrains the scope.

The time-evolving side comes from dynamical low-rank approximation. This is a family of methods that evolve a solution as a product of a small set of spatial modes and a small set of stochastic modes, both updated in time.

These papers motivate our work by showing that an evolving basis beats a static one. They also constrain it: Kusch et al. report that the faster decoupled integrator damps variance, and the rank-reduced filter reports that truncation makes it overconfident. Any scheme that updates its basis less often must therefore be checked for variance loss, not just mean error. Our proposal differs from all three in two ways. The stochastic factor lives in rotated, sparse coordinates, which is what makes $d$ in the tens tractable. The expensive basis update is triggered by events rather than performed every step.

From the temporal-redundancy literature we borrow two design principles rather than any code. KeyWorld spends heavy computation only at geometric turning points of a trajectory and fills the gaps cheaply. It reports a 5.68× speedup and object accuracy rising from 38% to 90% on LIBERO-goal, which motivates concentrating effort at transitions. DyCoke argues that a token judged unimportant now may matter later, and keeps such tokens in a recoverable cache instead of deleting them. We apply that warning directly: directions judged inactive are kept at low polynomial order, never discarded. A shock can make a previously quiet input direction suddenly dominant.

Core Mechanism

Let $\xi \in \mathbb{R}^d$ be the standard Gaussian inputs and $u(x,t,\xi)$ the solution. Write $\eta = A\xi$ for the rotated inputs, where $A$ is an orthogonal $d \times d$ matrix. Its first $k$ rows span the active directions, with $k$ small, around 3 to 6. The solution is expanded in Hermite polynomials of $\eta$ with two parts. The first is a full expansion up to degree $p$ in the $k$ active coordinates. The second is a "tail" that is only linear in the remaining $d-k$ coordinates. The number of terms is therefore $\binom{k+p}{p} + (d-k)$ rather than $\binom{d+p}{p}$. Coefficients evolve by intrusive stochastic Galerkin projection, coupled with the low-rank spatial/stochastic splitting of Kusch et al., so the spatial cost stays at rank $r$.

The rotation at a keyframe comes from the time-local gradient matrix

$$G(t) = \mathbb{E}_\xi\!\left[\int_\Omega \nabla_\xi u(x,t,\xi)\,\nabla_\xi u(x,t,\xi)^\top dx\right],$$

where $\Omega$ is the spatial domain. Following Lin et al., this can be assembled analytically from the current coefficients, with no extra solves. The keyframe trigger is the leakage ratio

$$\lambda(t) = \frac{\sum_{j>k} \left(A_{\text{old}}\, G(t)\, A_{\text{old}}^\top\right)_{jj}}{\operatorname{tr} G(t)}.$$

This is the fraction of gradient energy that the current rotation $A_{\text{old}}$ assigns to directions it calls inactive. Because the tail is kept at linear order, gradient energy flowing into inactive directions shows up in $\lambda$ instead of being invisible. That is the reason for keeping the tail rather than truncating it. When $\lambda$ exceeds a tolerance $\tau$, we eigendecompose $G(t)$, form the new $A$, and re-project the coefficients onto the new basis by Gauss–Hermite quadrature in the old expansion. Re-projection needs no PDE solves. It does incur a projection error, and that error accumulates with the number of keyframes. This is the second reason, beyond cost, not to rotate every step.

Computing $\lambda$ requires only the diagonal of a rotated $d \times d$ matrix built from coefficients already in memory, so its per-step cost is small. Even so, it is measured and charged against the method.

Research Program

The first stage builds the solver for scalar uncertain conservation laws: viscous and inviscid Burgers, plus KdV with noise. The random initial condition is given by a Karhunen–Loève expansion, a standard way of writing a random field as a sum of fixed spatial shapes weighted by independent random numbers. It is truncated at $d \in \{10, 20, 50, 100\}$. Burgers with uncertain shock location is the case where the important directions should change abruptly at shock formation and collision. It is also a direct extension of Kusch et al. from $d=2$ to $d=100$.

The second stage is analysis. We will derive a bound relating the accumulated error to two quantities: the integral of the leakage ratio over each interval between keyframes, and the per-keyframe re-projection error. The aim is to make explicit the trade-off that sets $\tau$. Lin et al. left the convergence of their rotations open; we do not claim to close that, only to bound the time-stale part of the error.

The third stage stress-tests the method in regimes where it should fail. One is strongly diffusive noise, where Cao and Lu observe solutions escaping low-rank manifolds. Another is a configuration whose gradient matrix has no spectral gap, with energy spread evenly. In that case keyframing has nothing to exploit, and we expect the method to degrade to per-step rotation cost.

Baselines

The naive reference point is plain Monte Carlo through the same finite-volume solver. Its sample count is chosen so that its statistical error matches the target accuracy. It sets the cost any surrogate must beat, and with $10^5$ samples it also serves as the ground truth for mean, variance, and the probability that the solution exceeds a threshold. The comparison is by wall-clock time on the same hardware to reach equal error in the variance field.

The strongest existing method is the dynamical low-rank stochastic Galerkin solver of Kusch et al., run with a total-degree basis in unrotated coordinates. It uses the same spatial discretization, rank $r$, time stepper, and filter, with the polynomial degree tuned on the same validation budget we give our method. It is the strongest competitor because it is the published approach for exactly this uncertain Burgers problem. Its reported result is that rank 9 matches 100-moment filtered stochastic Galerkin at $d=2$. We found no reported result on Lacuna for this method at $d \ge 10$, so we will produce that number ourselves. At $d=50$ with degree 3 its basis has about 23,000 terms, so we expect it to become memory-bound. Beating it means equal or lower error in mean and variance at a fraction of the cost from $d=20$ upward.

Three ablations isolate the key ingredient.

  • Static rotation: the rotation of Lin et al. computed once at $t=0$ and held fixed. This tests whether the important directions drift at all.
  • Per-step rotation: re-rotation every step, which sets the accuracy ceiling and the cost ceiling.
  • Periodic rotation: re-rotation every $m$ steps, with $m$ chosen so the number of rotations equals the number our trigger fires. This isolates whether choosing when to rotate matters, as opposed to merely rotating occasionally.

A further ablation removes the linear tail, which tests the recoverable-cache argument borrowed from DyCoke. Beating periodic rotation means lower variance error at an identical rotation count. Beating per-step rotation means matching its error within 10% at lower cost.

Why not just…?

Why not just use adaptive time-stepping? Adaptive step-size control changes how far the clock advances. It does not change which stochastic basis the solution is written in, so it is complementary rather than competing. All variants in this proposal share the same CFL-limited stepper, so any gain we report is on top of whatever adaptive stepping already provides.

Why not just re-rotate on a fixed schedule? This is the real threat. If the important directions drift smoothly, a well-chosen period will do as well as our trigger, and the keyframing claim reduces to a tuning convenience. The periodic ablation at a matched rotation count settles this. We expect the trigger to win on shock-forming Burgers, where drift is concentrated at formation and collision times, and to tie on smooth diffusive problems. We will report both outcomes. A tie on the smooth problems would narrow the claim to problems with localized transitions.

Why not just apply compressive sensing or a large total-degree basis without rotation? Lin et al. report that unrotated compressive sensing gives roughly 100% relative error on a 12-dimensional function whose structure is not aligned with the axes, versus below 0.1% after rotation. The unrotated dynamical low-rank baseline tests whether that failure carries over to time-dependent problems.

Why not just run Monte Carlo through a neural surrogate? PDEBench reports that a Fourier neural operator, a network that learns the map from inputs to PDE solutions, runs inference in about 0.14 s versus about 60 s for a classical solver on 3D fluid problems. That speed makes surrogate Monte Carlo cheap. PDEBench also reports severe degradation beyond the training time window and on shocks. We will train a Fourier neural operator on 2,000 solver runs, a budget charged to it, and compare its variance and threshold-exceedance error with ours. We expect it to be competitive for the mean and to be worse on variance near shocks. We will report it honestly if it is not.

Decisive Checks

The central experiment plots error against cost for uncertain inviscid Burgers at $d = 10, 20, 50, 100$. Error is measured in the mean, the variance (the moment where low-rank methods are known to fail), and threshold-exceedance probability. Cost counts all solver work, trigger evaluations, and re-projections.

The idea is confirmed under three conditions. First, keyframed rotation reaches per-step-rotation accuracy with at least five times fewer rotations. Second, it beats periodic rotation at matched rotation count on variance error. Third, removing the linear tail produces a visible failure at shock collision, where a previously inactive direction should become dominant. Plotting $\lambda(t)$ alongside keyframe times and shock events will show directly whether the trigger fires where the physics changes.

The idea is refuted if either of two things happens. One is that static rotation already matches per-step rotation, meaning there is no drift to exploit. The other is that periodic rotation matches the trigger everywhere. Either result would itself be informative, because it would show that active subspaces in these conservation laws are temporally persistent enough to skip adaptation altogether.