🔢 mathematics

Coordinate-wise splitting algorithms for ODE simulation via Koopman-Lie product formulas

This paper introduces a model-based computational framework for simulating finite-dimensional ordinary differential equations by decomposing Koopman-Lie generators into coordinate-wise frozen subflows, enabling efficient high-order splitting algorithms that are validated against standard benchmarks on nonlinear systems like Lotka-Volterra, Van der Pol, and Lorenz.

Original authors: Arun Banjara, Ibrahem AlJabea, Theodore Papamarkou, Frank Neubrander

Published 2026-06-03

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Arun Banjara, Ibrahem AlJabea, Theodore Papamarkou, Frank Neubrander

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to predict the path of a complex object, like a leaf swirling in a storm or a planet orbiting a star. In the world of mathematics, this is called solving an Ordinary Differential Equation (ODE). The problem is that these paths are often too twisty and complicated to calculate all at once in a single step.

This paper introduces a clever way to solve these problems by breaking them down into tiny, manageable pieces. Here is the simple breakdown of their method, using everyday analogies.

The Big Idea: The "Freeze and Move" Strategy

Usually, to predict where something is going, you have to account for every force acting on it simultaneously. The authors propose a different approach: Coordinate-wise Splitting.

Think of it like navigating a car in a city with heavy traffic. Instead of trying to steer, accelerate, and brake all at the same time to follow a perfect curve, you do it in a sequence:

Freeze the steering wheel and just drive straight for a split second.
Freeze the gas pedal and just turn the wheel for a split second.
Repeat this pattern very quickly.

If you do this fast enough, the result looks just like a smooth curve, even though you were actually moving in a jagged, step-by-step fashion.

The "Koopman" Connection: The Movie Director

The paper uses a mathematical concept called the Koopman operator. You can think of this as a "Movie Director" who doesn't track the car itself, but rather tracks the view from the car's window.

The Old Way: Data-driven methods try to guess how the movie plays out by watching thousands of clips (data) and learning patterns.
This Paper's Way: The authors say, "We already have the script!" (The vector field is known). They don't need to guess or learn from data. Instead, they use a mathematical tool called the Koopman-Lie product formula to organize the "Freeze and Move" steps. It's like having a precise recipe that tells you exactly how to combine the "straight" moves and the "turn" moves to get the perfect result.

The Three Ingredients of the Method

Freezing the Variables:
Imagine a 3D maze. To move through it, you can only move North-South, East-West, or Up-Down. The algorithm "freezes" two directions and only moves in the third. Then it freezes the others and moves in the next direction.
- Analogy: It's like climbing a ladder. You don't move your whole body diagonally; you move your feet up one rung, then your hands, then your feet again.
The "Frozen" Math:
When you freeze the other variables, the math for that single direction often becomes very simple (like a straight line or a simple curve). The authors show that for many famous problems (like the Lotka-Volterra predator-prey model, the Van der Pol oscillator, and the Lorenz weather system), these "frozen" steps can be solved instantly with a simple formula, like a calculator button.
Mixing the Steps (Splitting):
The paper tests different ways to mix these steps:
- Lie-Trotter: Just do Step A, then Step B, then Step A, then Step B. (Simple, but a bit rough).
- Strang: Do half of Step A, then all of Step B, then the other half of Step A. (Smoother, like a better dance step).
- High-Order: They use complex, recursive recipes (like a fractal pattern) to mix the steps even more finely. This is like taking a very rough sketch and adding layers of detail until it looks like a photograph.

What They Found (The Results)

The authors tested this "Freeze and Move" method on three famous mathematical systems:

Predator and Prey (Lotka-Volterra): Animals chasing each other.
The Oscillator (Van der Pol): A system that swings back and forth.
Chaos (Lorenz): A system that models weather and is very sensitive to tiny changes.

They compared their method against a standard, high-precision computer solver (RK45).

The Trade-off: The "High-Order" methods (the complex recipes) were much more accurate than the simple ones. They could reach a very high level of precision with fewer steps.
The Catch: The more complex the recipe, the more "ingredients" (calculations) you need.
- Analogy: A high-order method is like ordering a gourmet meal. It tastes amazing (very accurate), but it takes a long time to cook (more calculations). A simple method is like fast food—it's quick, but not as precise.
The Sweet Spot: For 2D problems (like the predator-prey model), the high-order methods were incredibly efficient. For 3D problems (like the Lorenz system), the "ingredients" count exploded, making the complex recipes very expensive to compute, though they still offered better accuracy for the same amount of time.

The Bottom Line

This paper doesn't invent a new way to guess the future from data. Instead, it provides a highly organized, mathematical "recipe book" for solving known physics problems.

By breaking a complex 3D movement into a series of simple 1D movements (freezing two dimensions to solve the third), and then recombining them in clever patterns, they can simulate complex systems very accurately. The main takeaway is that if you know the rules of the game (the equations), you can simulate the outcome very efficiently by taking tiny, frozen steps and mixing them together smartly.

The paper concludes that while these methods are powerful, the "cost" (number of calculations) grows very fast as you try to make the steps more complex or as the system gets more complicated (more dimensions). Therefore, the best method depends on how much accuracy you need versus how much computing power you have.

Technical Summary: Coordinate-wise Splitting Algorithms for ODE Simulation via Koopman-Lie Product Formulas

Problem Statement
The paper addresses the numerical simulation of finite-dimensional autonomous ordinary differential equations (ODEs) of the form $u'(t) = F(u(t))$ , where the vector field $F$ is known (the "model-known" setting). While classical methods like Runge-Kutta (RK45) approximate the flow directly, this work explores an operator-theoretic approach. The goal is to construct state-update algorithms that exploit the structure of the vector field by decomposing the full dynamics into simpler, coordinate-wise subproblems. The specific challenge is to leverage the Koopman operator framework—typically associated with data-driven approximations—to derive exact or semi-exact splitting schemes without constructing a finite-dimensional dictionary or approximating the Koopman operator from data.

Methodology
The proposed framework combines classical Koopman-Lie product formulas with coordinate-wise "frozen" subflows. The core methodology proceeds as follows:

Koopman-Lie Generator Decomposition:
The authors utilize the Koopman generator $K$ , which acts on observables $g$ as $Kg = \nabla g \cdot F$ . For smooth finite-dimensional systems, this generator admits a coordinate decomposition:
$Kg(u) = \sum_{i=1}^N F_i(u) \frac{\partial g}{\partial u_i}(u) = \sum_{i=1}^N K_i g(u)$
Here, each partial generator $K_i$ corresponds to a "frozen" subproblem where all state variables except the $i$ -th are held constant.
Bi-continuous Semigroup Framework:
To rigorously justify the splitting on spaces of bounded continuous functions ( $C_b(\Omega)$ ), the authors employ the theory of bi-continuous semigroups. They establish that the Koopman operators associated with jointly continuous flows form bi-continuous contraction semigroups. This framework allows for the handling of flows where strong continuity in the sup-norm may fail, ensuring the validity of the generator decomposition and product formulas.
Coordinate-wise Splitting Algorithms:
The full flow $\phi_t$ is approximated by composing the flows of the frozen coordinate subproblems, $\Phi_i(t, \cdot)$ . The paper implements several splitting orders:
- Lie-Trotter (First-order): Sequential application of frozen flows $\Phi_1(h) \circ \Phi_2(h) \circ \dots \circ \Phi_N(h)$ .
- Strang (Second-order): Symmetric composition, e.g., $\Phi_1(h/2) \circ \Phi_2(h) \circ \Phi_1(h/2)$ .
- Higher-Order Schemes: The authors utilize recursive exponential compositions (based on Hansen and Ostermann) involving complex coefficients to achieve orders 3, 4, 6, 8, etc. These schemes are adapted to the coordinate-wise setting by recursively substituting two-operator compositions with multi-coordinate blocks.
Implementation and Cost Analysis:
The algorithms advance points in the state space directly. If the frozen scalar subproblems admit closed-form solutions (or cheap numerical solves), the method is efficient. The paper provides a recursive algorithm (Algorithm 1) and a table (Table 1) to count the number of elementary frozen-flow factors required for higher-order schemes in dimensions $N \ge 2$ . This count serves as a proxy for implementation cost.

Key Contributions

Computational Framework: The paper presents a purely computational framework that uses Koopman-Lie notation to organize coordinate-wise splitting algorithms for ODEs, distinct from data-driven Koopman methods.
Theoretical Justification: It provides a rigorous background using bi-continuous semigroup theory to justify the decomposition of the Koopman generator and the convergence of product formulas for state maps.
Recursive Construction and Cost Metrics: The authors derive and record the specific number of exponential factors (frozen-flow evaluations) required for higher-order splitting schemes in dimensions $N=2$ through $N=8$ . This quantifies the trade-off between splitting order and computational complexity.
Numerical Benchmarking: The study implements Lie-Trotter, Strang, and higher-order schemes for the Lotka-Volterra, Van der Pol, and Lorenz systems. These are compared against high-accuracy RK45 reference solutions using Root-Mean-Square Error (RMSE) and work-precision curves.

Results
Numerical experiments on the three test systems yield the following observations:

Accuracy vs. Step Count: Higher-order compositions (e.g., 6th, 8th, 10th order) achieve significantly lower RMSE with fewer time steps compared to Lie-Trotter and Strang splitting, particularly in the regime where the number of steps is small.
Machine Precision Limits: In two-dimensional systems (Lotka-Volterra, Van der Pol), higher-order methods can reach errors close to machine precision ( $10^{-11}$ to $10^{-13}$ ) with relatively few steps. However, once this limit is reached, increasing the order does not necessarily reduce the error further due to roundoff and reference solution limitations.
Dimensionality Constraints: For the three-dimensional Lorenz system, the number of required frozen-flow factors grows rapidly with the splitting order (as shown in Table 1). Consequently, the experiments were restricted to lower orders (up to 6th order) to remain computationally feasible.
Work-Precision Trade-off: Higher-order schemes are shown to be advantageous when frozen maps are cheap to evaluate and a small number of time steps is desired. However, the "work" (runtime) increases with the number of factors, and the benefit diminishes if the cost of evaluating the frozen maps is high or if the method hits numerical precision limits.

Significance and Claims
The paper claims that its primary contribution is computational: demonstrating that classical Koopman-Lie product formulas can be effectively repurposed to create practical, coordinate-wise splitting algorithms for known vector fields. The significance lies in:

Avoiding Data-Driven Approximation: Unlike many modern Koopman applications, this method does not require learning an operator from data; it relies on the analytical structure of the vector field.
Exploiting Frozen Subflows: The method is specifically designed for systems where the vector field decomposes into coordinate mechanisms that are solvable in closed form or via cheap 1D solves.
Practical Trade-offs: The results illustrate a clear practical trade-off between splitting order, the number of time steps, the number of exponential factors (computational cost), and runtime. The authors modestly conclude that while higher-order compositions can substantially reduce finite-time RMSE, their effectiveness depends heavily on the availability of closed-form frozen maps and the specific dimensionality of the system.

The paper does not claim to solve the general ODE problem for arbitrary vector fields but rather provides a specialized, high-accuracy tool for systems with exploitable coordinate structures. Future work is identified as needing separate order analysis for recursive $N$ -coordinate constructions and extensions to cases where frozen subproblems must be solved numerically rather than in closed form.