Hybrid Trajectory Anchors

• Hybrid trajectory anchors are a set of techniques for accurately computing continuous trajectories and identifying discrete guard events based on Taylor series expansion and holomorphic flow properties.
• The algorithm adapts between small steps for local accuracy and big steps for re-centering the Taylor series to precisely detect crossings in hybrid systems.
• By leveraging arbitrarily high-precision arithmetic and rigorous error bounds derived via the Cauchy integral, the method achieves robust performance compared to conventional ODE solvers.

Hybrid trajectory anchors are pivotal constructs in the computational and numerical analysis of hybrid systems, particularly in the context of initial value problems (IVPs) involving differential equations subject to discrete transitions or discontinuities (“guards”). In the context of “Making big steps in trajectories” (Müller et al., 2010), hybrid trajectory anchors refer to algorithmic and representational techniques that enable both highly accurate computation of continuous trajectories and precise localization—and handling—of discrete jump events, achieved via a rigorous combination of Taylor series expansion, exact real arithmetic, and advanced step-size adaptation mechanisms.

1. Mathematical Foundations: Taylor Expansion and Holomorphic Flow

Hybrid trajectory computation targets the solution of IVPs for differential equations of the form: $\bar{y}'(t) = F(t, y(t)),\qquad y(t_0) = w_0$ where the flow function $F$ is holomorphic in its arguments. The algorithm constructs the solution $y(t)$ as a power series: $y(t) = \sum_{n=0}^{\infty} a_n (t-t_0)^n$ For a polynomial (or more generally, holomorphic) flow, the power series coefficients $a_n$ are recursively determined based on the derivatives of $F$, through explicit formulas. In the multidimensional case, the core recursion reads: $$a_{\nu,\ell+1} = \frac{1}{\ell+1} \sum_{k, n_1, \dots, n_d,\atop n_1+\cdots+n_d + k = \ell} \sum_{i_1, \dots, i_d} c_{\nu,k,i_1,\dots,i_d} \prod_{j=1}^d a_{j, n_j}^{(i_j)}$$ where the “powered” series $a_{j, n}^{(i)}$ themselves arise from a nested convolution (polynomial multiplication) (cf. formulas (4)–(5) in the paper).

For autonomous linear flows, this recursion simplifies dramatically, yielding only a finite number of nonzero coefficients and making the stepwise expansion highly efficient.

2. Detection and Handling of Discrete Jumps (“Guards”)

In hybrid systems, a trajectory follows the continuous flow up to a “guard”—a surface in state-time space where a discrete transition (jump) is triggered. Precisely detecting the guard crossing is critical, as naive time-stepping may “overshoot” and miss the exact crossing time, leading to spurious solutions.

The algorithm monitors a differentiable distance-to-guard function: $\Delta(t) = d_G(t, y(t))$ and locates the guard crossing time as: $$t_G = \sup \{t \geq t_0\ |\ \forall t' \in [t_0, t],\ \Delta(t') > 0 \}$$ To approach $F$0 without crossing the guard, the algorithm employs two nested step strategies:

• Small Steps: Use the local Taylor expansion to estimate $F$1 for $F$2 close to the expansion center; the step size $F$3 is conservatively chosen as: $F$4 where $F$5 is a computable bound on the vector field’s speed and $F$6 is a fraction of the current convergence radius.
• Big Steps (Re-centering): As the step size or Taylor convergence deteriorates, or as the distance to the guard shrinks, the method re-centers the Taylor expansion at the new point and recomputes all coefficients to maintain high local accuracy.

When $F$7 changes sign, root-finding or extrapolation is employed. For sufficiently regular $F$8, the root estimate is refined as: $F$9 which enables accurate bracketing of $y(t)$0 from both sides. Iterated multi-valued tests with progressively higher precision “trap” the true transition time.

3. Arbitrarily High-Precision Real Arithmetic

A core innovation is the use of exact real arithmetic (iRRAM or similar libraries) allowing the dynamic computation of arbitrarily many significant digits. Unlike finite-precision solvers, all operations, including Taylor coefficient recursion and function evaluation, are implemented in software supporting arbitrary-precision rationals or reals.

Truncation of Taylor series is managed by the Cauchy integral formula, quantifying the error as: $y(t)$1 with algorithmic construction of safe radii $y(t)$2 and bounds $y(t)$3 to guarantee the prescribed accuracy for every step.

Step or Quantity	Numerical Value or Result (Example)	Comments
Final guard time $y(t)$4 (high precision)	73.5422061995…	iRRAM-based, > 12 decimals
Small steps (for 1000 bits)	2200	Taylor sum evaluations
Big steps (recenterings)	12	Taylor expansion re-centers
Max Taylor order	430	High precision requirement
Computation time	5.42 s	AMD processor

4. Implementation Workflow: Algorithmic Structure

The hybrid trajectory anchoring algorithm proceeds according to the following workflow:

1. Initial Value Expansion: Compute and store Taylor coefficients up to the desired accuracy at $y(t)$5.
2. Small Step: Use local Taylor expansion and truncation bounds to proceed forward in time, monitoring proximity to guard surfaces and reducing the step size as needed.
3. Big Step/Recursion: When the convergence radius is exhausted or higher-order terms dominate (costly evaluations), re-center the expansion at the current state, and recompute all Taylor coefficients from new local data.
4. Guard Detection: Track the distance-to-guard function. If a sign change is detected, invoke extrapolation, root-finding, and precision-refinement routines to identify the guard-crossing time to arbitrary accuracy.
5. Error Control: Employ a rigorously derived truncation error bound (via Cauchy integration, using majorants on the solution) to guarantee that each local sum meets the prescribed error bound before step acceptance.
6. Iterate: Alternate between small and big steps, as dictated by local truncation error, Taylor convergence, and guard proximity, until the guard is reached.

5. Performance Analysis and Benchmarking

Empirical results show that the hybrid approach:

• Achieves arbitrarily high precision in both smooth and near-discontinuous regimes, as quantified by the number of correct decimals for transition times.
• Remains competitive with (and can surpass) conventional ODE solvers, especially in problems requiring precise discontinuity detection.
• Keeps computational cost nearly linear in the number of precision bits over significant portions of the integration domain.

For instance, in the two-dimensional linear oscillator example with a perturbed damping term, the iRRAM-based high-precision solver outperformed tuned Octave runs in reliable digits (computing $y(t)$6 to 12+ decimals vs. 6–7) at moderate runtimes.

6. Structural Advantages and Theoretical Implications

Unlike fixed-step solvers or simple adaptive schemes, the hybrid trajectory anchoring method:

• Avoids mislocalization of discontinuous transitions by construction, as the event detection and local time adaptation are tightly controlled by Taylor expansion geometry and guard-function monitoring.
• Admits global theoretical guarantees for accuracy, given holomorphicity of the flow and computability of local majorants.
• Is especially suitable for hybrid systems, embedded real arithmetic, and reachability analysis in formal verification, as every step is accompanied by quantifiable error bounds.

7. Limitations and Extensions

This algorithm is optimized for systems with holomorphic (or at least analytic) flow functions, as the recursive computation of Taylor coefficients and truncation error bounds rely crucially on analyticity. For stiff systems or those with discontinuous right-hand sides, modifications may be required. Computational cost grows with required precision, but the method scales efficiently relative to the unavoidable complexity imposed by high-accuracy demands. The framework is generalizable to higher-dimensional systems, provided suitable software support for exact real arithmetic and symbolic differentiation.

---

By anchoring continuous propagation in recursively constructed power series and dynamically adapting both step size and expansion center, the high-precision hybrid trajectory anchoring algorithm offers a robust, theoretically sound, and numerically superior alternative for trajectory computation in hybrid systems, particularly when discontinuities must be resolved to arbitrary accuracy. This methodology is central to reliable reachability analysis, verification, and simulation of hybrid dynamical systems with complex guard structures (Müller et al., 2010).