Papers
Topics
Authors
Recent
Gemini 2.5 Flash
Gemini 2.5 Flash
144 tokens/sec
GPT-4o
8 tokens/sec
Gemini 2.5 Pro Pro
46 tokens/sec
o3 Pro
4 tokens/sec
GPT-4.1 Pro
38 tokens/sec
DeepSeek R1 via Azure Pro
28 tokens/sec
2000 character limit reached

Runge--Kutta Based gCQ

Updated 1 July 2025
  • Runge--Kutta based generalized Convolution Quadrature (gCQ) is a high-order, stable method for approximating convolution integrals, notably handling arbitrary time meshes unlike classical CQ.
  • This method excels in solving time-dependent problems with memory and sectorial kernels, such as fractional evolution equations and boundary integral equations, especially with singular initial data.
  • gCQ allows for fast O(N log N) implementations with low O(log N) memory usage, making it practical for long-time simulations on complex grids.

Runge–Kutta based generalized Convolution Quadrature (gCQ) is a family of high-order, stable, and computationally efficient methods for approximating convolution integrals involving causal, sectorial kernels—fundamental to the numerical treatment of time-dependent boundary integral equations, fractional evolution equations, and parabolic problems with memory. In contrast to Lubich’s classical convolution quadrature (CQ), which is restricted to uniform time grids and fixed-step multistep or Runge–Kutta methods, gCQ allows for arbitrary time meshes (including nonuniform and graded meshes), optimal accuracy for singular data, and fast memory- and computation-efficient implementation. The gCQ approach is especially potent when based on A-stable Runge–Kutta methods, enabling reliable simulation of problems with highly irregular or singular behavior at initial times.

1. Generalization of Convolution Quadrature and Time Mesh Flexibility

Classical convolution quadrature methods, as developed by Lubich, approximate causal convolutions

u(t)=(kf)(t)=0tk(ts)f(s)dsu(t) = (k*f)(t) = \int_0^t k(t-s) f(s) ds

by applying a linear multistep or Runge–Kutta time-stepping scheme to an associated operational equation involving the Laplace transform of kk, typically on a uniform time grid. The gCQ framework extends this paradigm to arbitrary, potentially highly nonuniform meshes: Δ:={0=t0<t1<<tN=T},τn=tntn1\Delta := \{0 = t_0 < t_1 < \cdots < t_N = T\}, \qquad \tau_n = t_n - t_{n-1} allowing for mesh grading or local time refinement tailored to singularities in the input data or solution.

This generalization is crucial for practical applications where solution regularity is lost at initial times—such as subdiffusion, wave propagation in non-smooth domains, or viscoelastic models—since uniform time stepping leads to significant order reduction. gCQ leverages mesh flexibility to restore optimal convergence.

2. High-Order Runge–Kutta Integration in gCQ

Runge–Kutta based gCQ replaces the discrete convolution weights of classical CQ with those generated by high-order, A-stable Runge–Kutta schemes applied to the ODE

dydt=xy+f(t),y(x,0)=0\frac{dy}{dt} = -x y + f(t), \qquad y(x, 0) = 0

for each x>0x > 0 parameterizing the Laplace variable, reflecting the Laplace inversion representation of sectorial kernels.

Given a multistage Runge–Kutta method with nodes and coefficients satisfying A-stability, classical order pp, stage order qq, and stiff accuracy, the method propagates the solution in time according to the possibly variable time steps τn\tau_n, computing yn(x)y_n(x) at each tnt_n. The numerical approximation to the target convolution is then

un=0G(x)yn(x)dxu_n = \int_0^\infty G(x) y_n(x) dx

with G(x)G(x) a function determined by the sectorial Laplace transform K(z)K(z) of k(t)k(t).

This structure allows the use of high-order RK schemes such as Radau IIA or Lobatto IIIC, ensuring superior convergence and stability properties compared to lower-order, single-step CQ (such as backward Euler).

3. Sectorial Problem Classes and Analytical Foundations

The method's strongest theoretical guarantees and performance are realized for so-called sectorial problems—those where the Laplace transform of the kernel K(z)K(z) is holomorphic for Re(z)>0\operatorname{Re}(z) > 0 (in practice, for a sector arg(z)<π|\arg(z)| < \pi) and satisfies decay conditions

K(z)Mzαfor some 0<α<1\|K(z)\| \leq M |z|^{-\alpha} \quad \text{for some } 0 < \alpha < 1

This encompasses kernels from fractional integrals, subdiffusion, boundary integral operators for parabolic PDEs, and many memory effects.

A central insight is that such k(t)k(t) admit a real inversion integral

k(t)=0extG(x)dxk(t) = \int_0^\infty e^{-x t} G(x) dx

with

G(x)=K(xeiπ)K(xeiπ)2πiG(x) = \frac{K(x e^{-i\pi}) - K(x e^{i\pi})}{2 \pi i}

enabling accurate and efficient quadrature for the convolution and the design of the gCQ scheme.

4. Convergence, Stability, and Graded Mesh Optimization

gCQ methods based on suitably chosen RK schemes preserve the classical convergence order of CQ (pp, the order of the underlying scheme), even for arbitrary time grids and for data ff with algebraic singularities f(t)=tβg(t)f(t) = t^\beta g(t), provided optimal mesh grading is enforced. Theoretical results (Theorems 1 and 2 in the source) state:

  • For sufficiently smooth data and sectorial kernels:

u(tn)unlogτminτmaxmin{p,q+1+α}\| u(t_n) - u_n \| \lesssim |\log \tau_{\min}| \, \tau_{\max}^{\min\{p, q+1+\alpha\}}

  • For singular data and a graded mesh with

tn=(nτ)γ,γ=min{p,q+1+α}α+βt_n = (n\tau)^\gamma, \quad \gamma = \frac{\min\{p, q+1+\alpha\}}{\alpha+\beta}

the scheme nearly attains the optimal order

u(tn)unClogNNmin{γ(α+β),p,q+1+α}\|u(t_n) - u_n\| \leq C \log N \cdot N^{-\min\{\gamma(\alpha+\beta), p, q+1+\alpha\}}

where qq is the stage order, α\alpha the kernel decay, and β\beta the strength of singularity in the data.

This refined control is unattainable for uniform-step CQ and is decisive for accurate simulation of memory- or singular-data-driven phenomena.

5. Fast and Memory-Efficient Implementation

A central advantage of gCQ is its amenability to fast, large-scale simulation. The convolution weights can be computed using the "fast and oblivious" algorithm, which decomposes history interactions into "local" (recent) and "history" (distant past) contributions. The latter exploits the real inversion formula for the kernel and makes use of analytical or quadrature-based recursion, yielding the following computational features:

  • O(NlogN)O(N \log N) operations for NN time steps,
  • O(logN)O(\log N) memory requirements, even on nonuniform and graded grids.

These features make gCQ practical for long-time integration and for problems with significant history-dependence, such as those found in viscoelasticity and time-domain boundary integral equations.

6. Applications and Numerical Examples

Runge–Kutta based gCQ has demonstrable performance across multiple challenging application domains:

  • Parabolic and subdiffusive PDEs with singular initial data,
  • Time-dependent boundary integral equations (for instance, in time-domain BEM discretizations of wave problems),
  • Nonlinear memory-type equations, illustrated by damped nonlinear wave equations and the Westervelt equation,
  • Fractional-order problems where uniform CQ order would be significantly degraded.

Numerical experiments confirm that, with sectorial kernels and optimal mesh grading, full theoretical convergence rates are achieved and order reduction is avoided. These experiments are reproducible with the provided MATLAB implementation (github.com/jingguo-math/gCQrK).

7. Summary Table: Method Properties

Feature/Aspect Runge–Kutta gCQ Classical CQ (BE/multistep)
Time mesh Arbitrary (graded/adaptive) Uniform only
Achievable order (for sectorial) Up to RK order pp Up to scheme order
Order with singular data Full with optimal grading Reduced
Stability Optimal (for A-stable RK) Good (for A-stable multistep)
Memory usage O(logN)O(\log N) (fast, oblivious) O(N)O(N) (classic)
Computational cost O(NlogN)O(N \log N) O(N2)O(N^2) (classic)

References

The methodology and theoretical results are as given in (2506.21242), with background in Lubich (1988), LoSau16, BanLo19, and closely related literature on RK-based time stepping and convolution quadrature.


Runge–Kutta based generalized Convolution Quadrature provides a high-order, stable, and flexible approach to discretizing convolution and memory terms on arbitrary time grids for sectorial problems, optimizing convergence for both smooth and singular data, and enabling efficient long-time simulation through advanced quadrature and recursion algorithms.

Definition Search Book Streamline Icon: https://streamlinehq.com
References (1)