Adaptive Parareal Method

• Adaptive Parareal methods are parallel-in-time algorithms that adapt coarse and fine solvers using feedback to improve accuracy and efficiency.
• They incorporate data-driven corrections, model order reduction, and machine learning surrogates to balance computational cost with solution fidelity.
• Adaptive error indicators, weighted updates, and spatial–temporal hybridization enable significant speedups in long-term, stiff, or multiscale problems.

Adaptive Parareal methods are advanced parallel-in-time algorithms designed to overcome the bottlenecks of traditional time integration for evolution problems, especially for stiff, high-dimensional, or multiscale systems. By dynamically modifying the fine or coarse solvers—or by directly adapting how corrections are computed—these methods aim to maximize parallel acceleration while maintaining or improving accuracy. Approaches include data-driven corrections (e.g., via Dynamic Mode Decomposition), adaptive error-driven time stepping, spatial–temporal hybridization, and the integration of model order reduction or machine learning surrogates. Adaptive Parareal frameworks exploit feedback from previous iterations to refine propagation strategies, enabling significant computational savings for long-term, stiff, or highly heterogeneous problems.

1. Classical Parareal Framework and Its Limitations

The standard Parareal method addresses the initial-value problem

$$\frac{du}{dt} = f(t,u),\quad u(0)=u_0,\quad t\in[0,T]$$

by decomposing $[0,T]$ into $N$ subintervals of length $\Delta T = T/N$. It employs:

• A fine propagator $\mathcal F_{\Delta t}$ (high accuracy, small time step).
• A coarse propagator $\mathcal G_{\delta t}$ (low accuracy, large time step).

The essential Parareal iteration is: $$u_{n+1}^{k+1} = \mathcal G_{\delta t}(u_n^{k+1}) + \mathcal F_{\Delta t}(u_n^k) - \mathcal G_{\delta t}(u_n^k),$$ with $u_0^k = u_0$ and $u_{n+1}^0 = \mathcal G_{\delta t}(u_n^0)$. Fine solves $\mathcal F_{\Delta t}(u_n^k)$ are in parallel, while $\mathcal G_{\delta t}$ is sequential.

Parareal achieves exact fine-solution after $N$ iterations but practical speedup requires rapid convergence ($k\ll N$). For stiff or oscillatory problems, the coarse solver often cannot be significantly coarsened without loss of stability or accuracy, limiting achievable speedup (Liu, 5 Mar 2025, Ariel et al., 2017, Maday et al., 2019, Dai et al., 16 Jan 2026).

2. Adaptive Coarse Solver Construction

2.1. Data-Driven and Machine Learning Approaches

Several adaptive Parareal methods replace or enrich the coarse solver using data-driven models or machine-learned surrogates.

• HODMD-based Adaptive Parareal constructs a sequence of coarse propagators using High-Order Dynamic Mode Decomposition (HODMD), trained on differences between two coarse solvers of varying fidelity ($\mathcal G_1$, $\mathcal G_2$). The HODMD model is re-trained at every iteration to adapt its correction as new data from fine and coarse solves become available. The number of snapshots, model order, and time lag are increased with iteration count for greater accuracy. In practice, $\mathcal G_1$ is used as a moderately accurate coarse solver over a short training horizon ($K_t$ subintervals), while $\mathcal G_2$ is very inexpensive and applies over the entire time domain, with HODMD-driven correction extending the utility of $\mathcal G_2$ for the remaining subintervals (Liu, 5 Mar 2025).
• Model Order Reduction (MOR) Adaptive Parareal adaptively constructs the coarse propagator $\mathcal G_k$ in each iteration by generating Proper Orthogonal Decomposition (POD) bases from recent fine solver data. The updated POD subspace is used to project the system, yielding an increasingly accurate and still low-rank coarse solver as $k$ grows. This allows for a dynamic balance between coarse step cost and solution accuracy, with spatial errors of the coarse solver decreasing iteration by iteration (Dai et al., 16 Jan 2026).
• Molecular Dynamics and ML Surrogates: In atomistic systems, combining fast empirical force fields (e.g., EAM) or low-fidelity ML interatomic potentials with accurate but expensive fine-level ML models (e.g., SNAP-205) enables adaptive error-driven partitioning of computational effort (Gorynina et al., 2022).

Table: Adaptive Coarse Solver Approaches

Approach	Mechanism	Key Adaptive Features
HODMD-based	Data-driven DMD correction	Iterative retraining, variable lag/order/snapshots
MOR-POD-based	Reduced spatial POD basis	Basis adapts per iteration/subdomain/fine-data
ML surrogate-based	Coarse/fine propagate with ML/EAM models	Adapts based on error indicators/statistical accuracy

3. Adaptive Accuracy and Weighted Parareal Schemes

Classical Parareal fixes coarse and fine solver accuracies across all iterations. Adaptive variants allow:

3.1. Adaptive Fine Solver Accuracy

The fine solver tolerance $\zeta_k^N$ is decreased with each Parareal iteration $k$, ensuring that initial iterations use fast, low-accuracy fine solves, while final iterations push toward the target accuracy $\eta$. Convergence retains the superlinear bound of classical Parareal but with substantial cost reduction, as early sweeps are cheap. Efficiency can approach $75\%$ in idealized (negligible coarse cost) settings (Maday et al., 2019).

3.2. Weighted/θ-Parareal

The θ-parareal algorithm introduces iteration- and time-dependent scalar or matrix weights $\theta_n^{(k)}$ for the coarse propagator: $$u_{n+1}^{k+1} = \theta C_H u_n^{k+1} + [F_H u_n^k - \theta C_H u_n^k]$$ or with adaptively determined $\theta_n^{(k)}$. Optimizing $\theta$ (e.g., by minimizing $\|F_H - \theta C_H\|$) improves stability and error amplification properties, especially for conservative or oscillatory problems where classical Parareal diverges. Adaptive θ selection is achieved from local data interpolation or SVD-based dimensionality reduction. This enables $10$–$100\times$ fewer iterations for specified error levels in challenging Hamiltonian or multiscale problems (Ariel et al., 2017).

4. Error Indicators, Spatial Hybridization, and Domain Adaptivity

Adaptive Parareal schemes often couple temporal adaptivity with spatial or statistical error indicators.

• Spatial Domain Hybridization: For kinetic equations, spatial regions are classified at each time step into kinetic or fluid regimes via two indicators: (1) a Maxwellian-perturbation threshold $\|g\|_{L^2_v}$, and (2) the Chapman-Enskog residual $\mathcal R^\varepsilon$. Cells satisfying convergence criteria run only a fluid solver, otherwise a full kinetic solver is applied. The parareal time iteration is performed on the macroscopic density variable, while the kinetic variables are updated via AP "lifting" after each correction. These spatial adaptivity mechanisms exponentially reduce computational complexity, especially near-equilibrium (Laidin, 17 Nov 2025).
• Trajectory or Statistical Error Control: In molecular dynamics, relative error $E(q,r; a,b)$ between updated trajectories triggers adaptive refinement of time slabs and determines whether Parareal iterations accept, refine, or partition intervals. Statistical accuracy for quantities like residence times can be maintained with relatively moderate trajectory accuracy thresholds (e.g., $\varepsilon=10^{-3}$–$10^{-5}$), enabling order-of-magnitude speedup (Gorynina et al., 2022).

5. Algorithmic Structures and Best Practices

Algorithmic patterns across adaptive Parareal variants:

• Initial iteration typically performs a coarse sweep and/or trains initial surrogate or reduced models.
• Each Parareal iteration conducts parallel fine propagations, updates coarse models using new data, and applies refined corrections.
• Adaptivity may include increasing model order, enriching POD bases, retraining data-driven predictors, and adjusting solver tolerances.
• Convergence testing leverages error indicators sensitive to local, global, or observable-based discrepancies.
• Key implementation recommendations include efficient interpolation (e.g., between coarse and fine grids for HODMD), dimension control in POD (to minimize cost), and sequentialization in cases of instability for large $N$.

A typical outline for an HODMD-based adaptive Parareal algorithm includes an initial coarse run (with two coarse solvers in parallel and initial HODMD fit), followed by iterative, parallel fine and sequential correction phases involving retraining and prediction via HODMD (Liu, 5 Mar 2025).

6. Performance Analysis and Numerical Evidence

Adaptive Parareal techniques yield superior speedups and efficiency, especially for stiff, long-time, or multiscale systems where coarse solvers cannot be heavily coarsened without adaptivity.

• For rod swimmer and elastic sphere simulations in fluid dynamics, HODMD-accelerated Parareal outperformed ordinary Parareal by factors up to $5.4\times$ vs.\ $2.9\times$ (rod swimmer, 50 cores) and $23.1\times$ vs. $12.2\times$ (elastic sphere, 50 cores) for comparable error tolerances (Liu, 5 Mar 2025).
• Efficiency for adaptive accuracy Parareal in stiff ODEs increases from $14.8\%$ to $75.5\%$ as coarse solver costs decrease, nearly tripling computational speedup under idealized hardware (Maday et al., 2019).
• In hybrid kinetic-fluid equations with spatially adaptive Parareal, speedup reached $73\times$ for $\varepsilon=10^{-4}$, combining domain and time adaptivity (Laidin, 17 Nov 2025).
• For time-dependent PDEs, adaptive MOR-Parareal reduces error by several orders of magnitude versus plain Parareal and maintains accuracy over long intervals with minimal coarse model sizes, enabling high parallel scalability (Dai et al., 16 Jan 2026).
• In molecular dynamics, statistical observables remain accurate for moderate error thresholds and yield $3$–$20\times$ wall-clock speedup depending on fine/coarse integrator pairing and time step (Gorynina et al., 2022).

7. Connections, Generalizations, and Implementation Insights

Adaptive Parareal is closely related to a variety of in-time parallelism techniques and data-driven multiscale strategies.

• Domain-decomposition-in-time and Multigrid-in-time (MGRIT) can be viewed as adaptive Parareal instances, where solver quality and correction level improve across cycles and information is recycled across levels.
• Similar ideas underlie the PFASST algorithm, where "sweeps" of Spectral Deferred Correction (SDC) methods are initialized adaptively at each Parareal level.
• The adaptive Parareal principle unifies these strategies by expressing them as iterative improvement in data, accuracy, subspace, or correction operator quality throughout the computation (Maday et al., 2019).
• For implementation, adaptivity introduces complexity (e.g., updating surrogates, managing POD basis dimensions, localized error monitoring), but the dominant cost remains communication and coarse solver evaluation once adaptivity in fine solves and coarse models is integrated.

Empirical guidance includes starting with small coarse solver training intervals, incremental increases in surrogate/model order, and close monitoring of error increments to halt iterations efficiently (Liu, 5 Mar 2025, Ariel et al., 2017).

---

References:

• (Liu, 5 Mar 2025) "A parallel-in-time method based on the Parareal algorithm and High-Order Dynamic Mode Decomposition with applications to fluid simulations"
• (Ariel et al., 2017) "θ-parareal schemes"
• (Maday et al., 2019) "An Adaptive Parareal Algorithm"
• (Laidin, 17 Nov 2025) "A space-time hybrid parareal method for kinetic equations in the diffusive scaling"
• (Gorynina et al., 2022) "Combining machine-learned and empirical force fields with the parareal algorithm: application to the diffusion of atomistic defects"
• (Dai et al., 16 Jan 2026) "A model order reduction based adaptive parareal method for time-dependent partial differential equations"