Commutator-Free Methods

Commutator-free (CF) methods for Lie group integration.

A CF method with s stages and J exponentials per step is specified by:

An s x s coefficient matrix A (typically strictly lower triangular for explicit methods).
J weight vectors beta_1, …, beta_J, each of length s.

Update rule (applied right-to-left on the manifold):

y_{n+1} = exp(h * sum_i beta_{J,i} F_i) ... exp(h * sum_i beta_{1,i} F_i) y_n

The LB-series character is the MKW convolution:

alpha = alpha_J *_MKW ... *_MKW alpha_1

where alpha_l is the elementary-weight character of the RK method (A, beta_l). Base exponential characters extend to ordered forests via the shuffle-symmetric 1/k! rule; convolution results extend via the paper’s forest coproduct (see kauri.mkw.forest_coproduct_impl), and the combined construction gives associative composition on the MKW Hopf algebra — the correct Lie-group LB-series character of the method.

Lie-Butcher substitution

Kauri represents Lie-Butcher (LB) substitution and composition through MKW convolution of basis-aware Map objects. A commutator-free method with exponentials applied right-to-left has

\[\alpha = \alpha_J *_\mathrm{MKW} \cdots *_\mathrm{MKW} \alpha_1,\]

where each \(\alpha_l\) is the elementary-weight character of the Runge–Kutta method (A, beta_l).

Use CFMethod.lb_character() for the numerical LB character and CFMethod.symbolic_lb_character() for an exact symbolic character. Both return Map instances using the MKW extension="shuffle" convention.

class CFMethod(a, betas, name=None)[source]

A commutator-free Lie group integrator.

Parameters:

a – Explicit s x s coefficient matrix.
betas – List of J weight vectors, each of length s. betas[0] is the innermost (first-applied) exponential.
name – Optional name for display.

exponential_rk(l: int) → RK[source]: The RK method (A, beta_l) for the l-th exponential (0-indexed).

lb_character() → Map[source]

The LB-series character on ordered trees.

Computed as alpha_J *_MKW ... *_MKW alpha_1 with each alpha_l wrapped as a shuffle-symmetric base character on the MKW Hopf algebra (the returned Map carries extension="shuffle"). This is the correct LB-series character for a Lie-group integrator: the tree values are the RK elementary weights of the individual exponentials, and composition via the MKW convolution captures the non-abelian Lie-group flow.

The result is cached on first call.

Return type:: Map

planar_antisymmetric_order(tol: float = 1e-10, limit: int = 10) → int[source]

Planar antisymmetric order of the CF method.

Parameters:

tol – Tolerance for evaluating conditions.
limit – Maximum order to check.

Return type:

int

planar_order(tol: float = 1e-10, limit: int = 10) → int[source]

Order of the CF method on ordered trees.

Parameters:

tol – Tolerance for evaluating conditions.
limit – Maximum order to check.

Return type:

int

projected_rk() → RK[source]: The projected RK method with b = sum_l beta_l.

symbolic_lb_character() → Map[source]

Symbolic LB-series character: same algebra as lb_character() but each tree is mapped to an exact sympy.Expr (typically a sympy.Rational) instead of a float.

Builds the same MKW basis-aware character as lb_character(), but with exact symbolic elementary weights. Forest values of convolution results are therefore evaluated through the MKW forest coproduct, not by reusing the base prod/k! extension.

Return type:: Map

symmetry_defect_map() → Map[source]

Symmetry defect D = (sign . alpha) *_MKW alpha.

D(tau) = epsilon(tau) for all |tau| <= q iff the CF method has planar antisymmetric order >= q.

The result is cached on first call.

Return type:: Map

class ReusedStageCFMethod(a, b, name=None)[source]

Low-storage reused-stage CF method.

This class models the explicit low-storage coefficients as the commutator-free row scheme

g_r = exp(sum_k alpha^k_{r,J_r} F_k) ... exp(sum_k alpha^k_{r,1} F_k)(p), F_r = h F_{g_r}, y_1 = exp(sum_k beta^k_{J} F_k) ... exp(sum_k beta^k_1 F_k)(p),

where the low-storage A_i, B_i recurrence only describes how exponential prefixes are reused in an implementation. Each stage row starts from the step base point p; it is not a single accumulating stage state. The returned LB character is basis-aware for MKW: on an ordered forest omega it evaluates the row B-series coefficient g_final(B_+(omega)).

lb_character() → Map[source]: Numerical LB character of the reused-stage method.

mkw_composition_symmetry_defect_map() → Map[source]: Compatibility alias for the MKW/LB symmetry defect.

projected_rk() → RK[source]: Projected RK tableau induced by the low-storage recurrence.

symbolic_lb_character() → Map[source]: Symbolic LB character with exact SymPy coefficients.

symmetry_defect_map() → Map[source]: MKW/LB symmetry defect D = (sign . alpha) *_MKW alpha.

Named methods

The kauri.cf_methods module provides named commutator-free methods as ready-to-use CFMethod instances.

Named commutator-free (CF) Lie group integrators.

Every method is a CFMethod instance with a published Butcher-like tableau. Use method.lb_character() for the numerical Lie-Butcher character and method.symbolic_lb_character() for the same character expressed in sympy rationals.

lie_euler, lie_midpoint, cfree_rk3 and cfree_rk4 follow the classical RKMK family with a single exponential per step (J = 1); their LB characters coincide with the elementary weights of the underlying Runge–Kutta method on planar trees. These are the order-1, 2, 3 and 4 “base” commutator-free methods that fit the single-exponential-per-stage structure of CFMethod.

The genuinely multi-exponential schemes introduced in Celledoni, Marthinsen and Owren (2003) “Commutator-free Lie group methods” rely on flow reuse across stages (e.g. \(Y_4 = \exp(k_3 - \tfrac{1}{2}k_1) \circ Y_2\)), which the current CFMethod API does not model: every stage is assumed to use a single exponential applied to \(y_n\). Users who need those methods should construct a bespoke CFMethod with a larger stage count or wait for multi-exponential stage support.

lie_euler

y_{n+1} = exp(h f(y_n)) . y_n.

One stage, one exponential (J = 1). Planar order 1.

Type:: Lie-Euler method

lie_midpoint

evaluate f at a half-step and take one full-step exponential.

Two stages, one exponential (J = 1). Planar order 2.

Type:: Implicit Lie-midpoint in its explicit RKMK form

cfree_rk3

RKMK variant of Kutta’s third-order Runge–Kutta method.

Three stages, one exponential (J = 1). Planar order 3.

cfree_rk4

RKMK variant of the classical fourth-order Runge–Kutta method.

Four stages, one exponential (J = 1). Planar order 4.

Lie-Butcher substitution helpers

Ordered-forest substitution for Lie–Butcher series.

The core operation implemented here is the ordered-forest coaction Delta_W from Lundervold–Munthe-Kaas: given a logarithmic linear map psi on ordered forests and a basis-aware outer character beta, substitute(psi, beta) returns the substituted character psi star_W beta = (psi tensor beta) Delta_W.

This is the LB-series analogue of ordinary B-series substitution used by the reused-stage CF methods.

delta_w_terms(forest: NoncommutativeForest)[source]

Return terms of the ordered-forest contraction coaction Delta_W.

Each term is (coeff, left_factors, right_forest), where left_factors is the symmetric product of admissible subforests.

substitute(logarithmic: Map, character: Map) → Map[source]: Return the substituted character logarithmic star_W character.

frozen_exponential_character(weight) → Map[source]

The pullback character of one frozen exponential exp(weight * F).

On ordered trees this is the bullet-only character:

alpha(empty) = 1,
alpha(bullet) = weight,
alpha(t) = 0 for every tree with more than one node.