Trace-by-Trace Recursive Extrapolation

• Trace-by-trace recursive extrapolation is a method that reconstructs higher-order observables step by step using recursive relations derived from lower-order data.
• It systematically builds spectral traces, multi-trace amplitudes, and numerical bounds in fields ranging from quantum physics to number theory.
• The approach offers controlled error estimates and establishes deep links with integrable systems, enhancing its practical and theoretical significance.

Trace-by-trace recursive extrapolation refers to a class of computational and analytic techniques that reconstruct or extend observables in a system by recursively relating data or coefficients at one order, time, or trace structure to those at lower orders. This general strategy underpins numerous advancements in spectral analysis, amplitude construction, and extrapolation of numerical data, with rigorous applications in spectral geometry, quantum many-body dynamics, number theory, and quantum field theory.

1. Core Principle and Definitions

At its core, trace-by-trace recursive extrapolation exploits recursive relations—often derived from linear operators or soft limits—to compute or estimate a quantity of interest step by step in a hierarchical manner. Typical scenarios include:

• Spectral expansions of trace operators, in which higher-order heat kernel coefficients are recursively constructed from lower-order ones, thus allowing closed or asymptotic representation of spectral traces (Avramidi, 2014).
• Recursive algorithms in number theory that optimize bounds (e.g., on algebraic integer traces) by constructing auxiliary functions and iteratively expanding their basis polynomials (Flammang, 2019).
• Multi-trace amplitude expansions in scattering theory, where amplitude expressions at given trace structures and multiplicities are recursively built from fewer traces or gluons by systematically applying soft theorems and merging procedures (Du et al., 2024).
• Real-time correlation function extrapolation in strongly correlated quantum systems, where recursion relations project the future behavior of Green’s functions or states onto their span at earlier times (Tian et al., 2020).

The “trace-by-trace” moniker refers to the term-by-term or structure-by-structure accumulation of higher-level objects (e.g., expansion coefficients, traces, correlators, or amplitude terms), always via explicitly defined recursions grounded in the analytic or algebraic structure of the system.

2. Spectral Function Expansion and Heat Trace Recursion

For a self-adjoint Laplace-type operator $L = -D^2 + Q$ on a 1D compact manifold (e.g., the circle), the heat trace

$$\Theta(t) = \mathrm{Tr}\, e^{-tL} = \sum_n e^{-t\lambda_n}$$

admits an asymptotic small-$t$ expansion: $$\Theta(t) \sim (4\pi t)^{-1/2} \sum_{k=0}^\infty \frac{(-t)^k}{k!} A_k,\qquad A_k = \int_{S^1} \mathrm{tr}\, a_k(x)\, dx,$$ where the $a_k(x)$ are the local heat kernel coefficients (Avramidi, 2014). The coefficients $a_k(x)$ satisfy the recursive relation: $$D a_k(x) = -\frac{k}{2(2k-1)} E\, a_{k-1}(x),\qquad k\geq1,$$ with $D = d/dx$ and $E$ a third-order differential operator involving $Q(x)$. This recursion constructs each higher-order coefficient from its predecessor via an explicit operator, enabling systematic extrapolation of the full heat-trace expansion. Formally, one may sum the series (in the decompactification limit) to obtain closed expressions for the trace and zeta-regularized determinants, with remainder control and quantifiable limits of validity.

This recursive approach is notable both for its computational tractability—each $a_k(x)$ is determined from known data at order $k-1$—and for its deep connection to integrable structures. The same recursion underlies the integrals of motion for the matrix KdV hierarchy, manifesting a direct link between spectral geometry and integrable PDEs (Avramidi, 2014).

3. Recursive Expansion in Multi-Trace Amplitude Construction

In tree-level multi-trace Yang-Mills-scalar (YMS) amplitudes, trace-by-trace recursion provides a constructive algorithm for building all amplitudes from base cases via systematic insertion and merging based on soft limits (Du et al., 2024). The key steps are:

• Base case: The four-point double-trace pure-scalar amplitude, with two scalars in each trace, serves as the seed.
• Recursive insertion: Single-soft theorems allow insertion of additional scalars into existing traces, recursively growing the trace length.
• Trace merging: The double-soft theorem enables recursive merging of length-2 traces into larger traces, with each step yielding a lower-trace amplitude multiplied by a universal kinematic factor.
• Addition of gluons: Single-soft gluon insertions introduce additional gluon traces via a further recursion, governed by universal soft factors.

Each amplitude at given trace multiplicity and gluon content is thus recursively built from amplitudes with fewer traces or gluons. The recursion coefficients are explicit in terms of momentum and color structure, and the overall procedure yields a fully constructive and general formula for all tree-level amplitudes in YMS theories.

4. Recursive Extrapolation Algorithms in Number Theory

Trace-by-trace recursive algorithms play a central role in bounding the absolute trace of totally positive algebraic integers (Flammang, 2019). The central device is the construction and iterative refinement of an auxiliary function: $$f(x) = x - \sum_{j=1}^J c_j \log |Q_j(x)|, \qquad x > 0,$$ where $\{Q_j(x)\}$ are integer polynomials and $c_j > 0$. The method proceeds recursively:

• Given an initial polynomial family, optimize the weights $c_j$ to maximize the minimum $m$ of $f(x)$ over $x>0$.
• At each step, search for a new polynomial $R(x)$ (using LLL lattice reduction), factor it, and append irreducible factors that improve $m$.
• Repeat, enlarging the basis and re-optimizing $f$, until $m$ ceases to increase.

This recursive extrapolation method builds a function whose minimum over positive $x$ provides an explicit, iteration-improving lower bound for the absolute trace. Refinements, such as systematically extending the degree search window, result in sharper bounds, as demonstrated by the improvement from $1.7928$ to $1.792812$ for the totally positive case. Reciprocal integers and related corollaries are handled through structure-preserving transformations that admit similar recursive analysis.

5. Wavefunction and Correlator Recursion in Quantum Dynamics

In the context of matrix product state (MPS) simulations of quantum dynamics, recursive extrapolation reconstructs long-time real-time correlation functions from shorter numerically accessible intervals (Tian et al., 2020). For a Green’s function $G_{kj}(t)$, the algorithm is as follows:

• Noninteracting case: The time-evolved state or correlator can be exactly expressed as a linear combination of states/correlators at earlier times; recursion gives exact extrapolation.
• Interacting case: Expand the wavefunction $|\psi_i(t)\rangle$ at $t>t_1$ as

$$|\psi_i(t)\rangle = \sum_j C_{ij} |\psi_j(t-t_1)\rangle + |R_i(t)\rangle,$$

where coefficients $C_{ij}$ are obtained by minimizing the residual $|R_i(t)\rangle$ using data at $t_1$ and earlier.

• Multi-step recursion: The process is iterated for several time steps $t_1, t_2, \dots, t_M$, each time minimizing and removing the residuals in sequence, yielding an extrapolated correlator series:

$$G_{ki}(t) \simeq \sum_{m=1}^M \sum_j G_{kj}(t-t_m) C_{ji}^{(m)}, \qquad t>t_M.$$

• Matrix iteration: The recursion is recast as $G(t) = A \cdot G(t-t_s)$ for stability and efficient iteration.

The method is exact for noninteracting Fermi systems and exhibits marked superiority over linear prediction in the strongly correlated regime, with quantified control over error propagation and convergence. Extension to more general basis sets (“multi-time basis”) further refines the early-time behavior and continuity at recursion points.

6. Error Analysis, Convergence, and Theoretical Significance

The accuracy and convergence of trace-by-trace recursive extrapolation are determined by the structural properties of the underlying equations and the completeness of the recursion basis at each step:

• Spectral traces: For heat kernels, truncating after $N$ steps yields an error of $O(t^{N+1})$, and in the large-radius limit the summation is exact (Avramidi, 2014).
• Amplitude recursion: Each iteration reduces the trace or gluon content, with complete reconstruction following from the universal soft limit factors and known seeds (Du et al., 2024).
• Number-theoretic recursion: The algorithm converges once the minimum $m$ stabilizes under further addition of polynomials; theoretical upper limits demonstrate near-optimality for the auxiliary function approach (Flammang, 2019).
• Quantum dynamics: The residual norm typically decays exponentially with the number of recursion steps $M$; slope discontinuities and instabilities are suppressed by construction, ensuring reliable extrapolation to late times (Tian et al., 2020).

These properties underscore the method’s practical and analytic power: it delivers not only stepwise approximations but, under suitable limits and summations, exact or closed representations with controlled errors.

7. Connections to Integrability and Hierarchical Structures

In the case of spectral trace recursion, the coefficient recurrence is intimately related to the generalized Korteweg–de Vries (KdV) integrable hierarchy. The operators governing the recursive step (e.g., $D$ and $E$) form a bi-Hamiltonian structure, with heat invariants $A_k$ serving as Hamiltonians for two compatible Poisson bracket flows (Avramidi, 2014). This reveals the underlying algebraic symmetry and establishes direct links between trace expansion, integrable flows, and the algebraic geometry of the underlying operators.

Similar multi-level or hierarchical elements can be identified in the quantum many-body and amplitude recursion contexts, where hierarchy is realized in either trace allocation, time steps, or recursive amplitude assembly, and the universal building blocks propagate structural consistency at all levels.

---

In sum, trace-by-trace recursive extrapolation is a foundational paradigm in modern computational mathematics and theoretical physics, facilitating rigorous, hierarchical construction and projection of observables ranging from spectral traces to scattering amplitudes and quantum correlators, with quantifiable accuracy and deep connections to integrable and algebraic structures (Avramidi, 2014, Du et al., 2024, Flammang, 2019, Tian et al., 2020).