Reference

findAllSaddles(f)

All critical points of the multivariate polynomial f (HomotopyContinuation, double precision), sorted by the imaginary part of the first coordinate.

refineSaddle(f, x0, tol = 10 * eps(BigFloat), max_iterations = 100)

Refine the critical point x0 of f by Newton's method in Complex{BigFloat}. Returns (x, residual).

GaussManin(f)

Gauss-Manin system of the tame polynomial f (Singular's gmspoly.lib, see goodBasis): the matrices M and B of the connection in a good basis of the Brieskorn lattice, the critical values λs (eigenvalues of M), the eigenvectors V, the spectral projectors Πs and the residues Rs of the Borel-plane Fuchsian system.

Expansion(x, f₀, μ, Ts)

Asymptotic expansion of a saddle point x: the exponent f₀ (Borel singularity), the exponent μ of the prefactor and the coefficients Ts. Returned by transseries, and used by the Borel-Padé functions (findPoles, findStokesConstants, BorelPadeResum) and by superasymptotic and hyperasymptotic.

asymptotic(j, GM::GaussManinSystem, order)

Asymptotic series of saddle point j (ordered as GM.λs) to order, from the recursion of the Gauss-Manin system. Returns (λ, μ, Ts): the critical value, the exponent of the prefactor and the (components × orders) coefficient matrix, normalised such that Ts[1, 1] = 1.

transseries(f, GM, M; saddles = nothing, component = 1)

Asymptotic series of every saddle point to order M, ordered as GM.λs, as a vector of Expansions (x, f₀, μ, Ts): the critical point x, the Borel singularity f₀ = t = -iλ, the exponent μ and the coefficients Ts of the series of the basis element component of the Gauss-Manin system (1 = Ψ itself). The series are normalised such that the leading coefficient of the first component is T0 = 1/√det H, with the branch fixed by morse_normalisation (principal branch for complex critical points, Morse convention for real ones, so that real critical points enter with n = +1). For component = 1, T0 = Ts[1]: pass the same T0 to stokes_constants and relevance. The critical points are found with findAllSaddles unless saddles is given.

singulants(Σ, K)

Distance Fj = min{l: K[l, j] ≠ 0} |tl - tj| from every Borel singularity to the nearest adjacent one (Inf for a saddle without adjacent saddles, whose series then converges).

divergence_rate(T; tail = 10, component = 1)

Estimate of the singulant |F| from the late terms of a series, (Γ(m)/|T_m|)^{1/m}, averaged over the last tail orders (row component when T is a coefficient matrix). Compare with singulants to check the adjacency of a saddle point; the estimate approaches F slowly, with O(log m/m) corrections.

Stokes constant K{j←i} for the Laplace contour of saddle i crossing the Borel singularity σj, from the keyhole contour around σj. vs[a] is the leading vector of Φ̂a; by default it is T0[a] times the eigenvector of Ra with unit first entry. For integer Stokes constants, T0[a] should be the normalisation of the asymptotic series of saddle a, T0[a] = 1/√det H(xa), ordered like Σ. Returns (K, S, relresidual) with S = U₋⁻¹U₊ the keyhole holonomy and relresidual the part of the jump not proportional to Φ̂_j (should be ≈ 0).

method = :hyperlog evaluates the free hyperlogarithm series truncated at weight N (giving access to the weight expansion); method = :matrix transports the matrices directly, with no weight truncation (N is then ignored). Use :matrix for more than a few saddles. method = :loop uses the single-loop formula U₊ - U₋ = Uarc₊ (I - L) Ustem: the two paths share their stem and differ by one loop around σj, whose monodromy L = G(p) e^{2πi Rj} G(p)⁻¹ follows from the Frobenius normal form at σj (`localmonodromy`). It avoids subtracting two transported propagators; the second return value is then L instead of the keyhole holonomy.

N is either an integer (used as given) or :auto. With :auto (hyperlog only) the smallest N with certified truncation error |KN - K| < 1/2 is used (`sufficientN, keywordsNmax,sharp,aposteriori), so thatround(K)is exact when the Stokes constants are integers. The bound assumes nilpotent residues (ρ = 0, the package convention). If it certifies no N ≤ Nmax, or the certified N would need more thanmaxwordswords (about n^N for n letters), it falls back tostokesconstantincrement` within that budget.

Matrix of Stokes constants K[j, i] = K_{j←i} for all ordered pairs i ≠ j (zero on the diagonal); N may be :auto.

plotStokesGraphGM(Σ, K; plotRange = nothing, from = :column, orient = :positive, atol = 1e-6, ...)

Plot the Stokes graph in the Borel plane: the singularities Σ as points and one edge for every adjacent pair, labelled by its Stokes constant. K is antisymmetric (K{i←j} = -K{j←i}), so an edge carries a single number once it is given a direction.

• from = :column reads K[j, i] as K{j←i}, the constant of the edge i → j (convention of `stokesconstants);from = :rowreads K[i, j] as the edge i → j (as infindStokesConstants`).
• orient = :positive: each edge is drawn as an arrow i → j along the direction in which the Stokes constant is positive, labelled by |K|. The sign is carried by the arrow.
• orient = :index: each edge points from the lower to the higher index, i → j with i < j. It is labelled by the signed constant, and the colour gives the sign (poscolor, negcolor; cplxcolor when the constant is not real).
• The line width grows with |K|. A warning is issued if K is not antisymmetric within atol.
• Each singularity is labelled in the widest angular gap between its edges, so the labels do not overlap the graph.
• plotRange = nothing fits the limits to Σ; a number r gives the square [-r, r]².

Returns (fig, ax). Requires a Makie backend: load CairoMakie (or GLMakie) first.

plotAdjacencyGM(Σ, K, plotRange = 3)

Plot the adjacency graph of the Borel singularities Σ: an edge for every K[i, j] ≠ 0, without the values of the Stokes constants (see plotStokesGraphGM). Returns (fig, ax). Requires a Makie backend: load CairoMakie (or GLMakie) first.

findPoles(trans)

Poles of the diagonal Padé approximant of the Borel transform of trans.Ts (an Expansion), relative to the Borel singularity trans.f₀.

findStokesConstants(transseries, ϵ = 1e-2)

Stokes constants from conformally mapped Borel-Padé approximants of the series transseries (a vector of Expansions). K[j, k] is the constant with which the series of j sees the Borel singularity of k, zero when no Padé pole lies within ϵ of the singularity in the mapped variable. With the same normalisation of the series, K == -transpose(stokes_constants(...)), i.e. transpose(K) follows the paper convention of southeast(Σ, transpose(K), n0; convention = :paper).

BorelPadeResum(trans, k; ϵ = 0.01, side = :above, rtol = sqrt(eps(real(float(k)))))

Borel-Padé sum of the series Σₘ Tₘ/kᵐ (trans.Ts): the Borel transform Φ(t) = Σₘ Tₘ tᵐ/m! is replaced by its diagonal Padé approximant and Laplace transformed, k ∫₀^∞ e^{-kt} Φ(t) dt, which reproduces Σₘ Tₘ/kᵐ term by term. The Laplace ray runs in the Borel direction arg t = -arg k, unless it meets Padé's cut system, the rows of poles along which the approximant imitates the branch cuts of Φ (laplace_direction). Beyond such a cut the approximant converges to the wrong branch of Φ and the error stalls at e^{-Re(k tc)}, with tc the crossing point. The ray is then rotated to side (:above or :below), halfway to the next blocked direction (at most π/4 beyond the edge):

• a radial cut along the ray (a Stokes line) gives the lateral sum from that side;
• a band of curved arcs (Chebotarev cuts between several singularities) gives the Borel sum of the neighbouring sector, which differs from the Borel sum in the direction -arg k by the Stokes jumps of the singularities in between (a warning is issued). The method BorelPadeResum(transseries, j, K, k) adds these jumps.

The Laplace integral is computed in the precision of k (pass k::BigFloat for results beyond double precision). Returns (integral, error).

BorelPadeResum(transseries, j, K, k; ϵ = 0.01, side = :above, depth = 3,
               rtol = sqrt(eps(real(float(k)))))

Borel sum of the series of saddle point j in the Borel direction arg t = -arg k, from the Borel-Padé sums of all series (transseries, a vector of Expansions) and the Stokes constants K (stokes_constants convention). The series of j is summed as by BorelPadeResum(trans, k); when its Laplace ray has to bend around Padé's cut system from -arg k to θ, the Stokes jumps of the adjacent singularities in between are added:

S_j(-arg k) = S_j(θ) - σ Σ_l K[l, j] e^{-k F_l} S_l(k),     F_l = t_l - t_j,

with σ = +1 for side = :above (counter-clockwise rotation) and σ = -1 for :below. The sum runs over the l with K[l, j] ≠ 0 whose directions arg Fl lie strictly between -arg k and θ (more than ϵ from -arg k; a singularity on the ray itself gives the lateral sum, as for a single series). The Sl are computed in the same way, recursively up to depth levels. Returns (integral, error).

plotAdjacencyPoles(transseries, K, poles, plotRange = 3)

Plot the adjacency graph (an edge for every K[i, j] ≠ 0) of the expansions transseries together with their shifted Padé poles (findPoles). Returns (fig, ax). Requires a Makie backend: load CairoMakie (or GLMakie) first.

relevance(f, Σ, K, T0; saddles = nothing, convention = :package, kwargs...)

South-East rule from start to finish for a polynomial f bounded from below on ℝᵈ: matches the critical points (saddles, by default findAllSaddles(f)) to the Borel singularities Σ[a] = -i f(xa), determines the intersection numbers at θ = π/2 and applies southeast. T0[a] must be the normalisation used in `stokesconstantsfor Σ[a]. Returns(n = n, n0 = n0, saddles = xs)withxs[a]` the critical point of Σ[a].

southeast(Σ, K, n0; convention = :package, include_vertical = false, verbose = false, atol = 1e-9)

Apply the South-East rule to the Borel singularities Σ (tj = -iλj), the Stokes constants K and the intersection numbers n0 at θ = π/2 (see initial_intersection_numbers); returns the intersection numbers n at θ = 0, i.e. Ψ = Σj nj Ψ^(j).

• convention = :package: K[l, j] as returned by stokes_constants (update nl -= nj K[l, j]); convention = :paper: K[l, j] = Klj of the paper (update nl += nj K[l, j]). The output of findStokesConstants equals -transpose of `stokesconstants, i.e. the paper convention transposed: passtranspose(K)withconvention = :paper`.
• K is rounded to integers (with a warning when it is not close to integers).
• A warning is issued when a firing edge is horizontal (the integral lies on a Stokes line, where the jump is only half) or when two firing edges at the same angle share a saddle.

For f unbounded from below the Euclidean integral diverges; n0 must then be supplied by other means (e.g. from a regulated exponent f + ε‖x‖⁴, see Aniceto, Feldbrugge & Howls).

superasymptotic(transseries, n, Σ, K, k; component = 1, truncation = :singulant)

Superasymptotic approximation Σj nj e^{ikλj} (ik)^{μj} Σ{m<Nj} Tm^(j)/k^m, with the Expansions transseries from transseries (a named tuple (λ, μ, T) per saddle point is accepted as well; component selects a row when T is a matrix), intersection numbers n (from relevance), Borel singularities Σ and Stokes constants K (`stokesconstants` convention, only adjacency K[l, j] ≠ 0 is used).

truncation: :singulant truncates at Nj = ⌈|k| Fj⌉, :smallest at the smallest term of each series, an Int at a fixed order (fixed-order asymptotics, for comparison).

Returns (value, N, error, terms): the approximation, the truncation orders, the size of the first omitted terms Σj |nj e^{ikλj} T{Nj}/k^{Nj}| as an error estimate, and the contribution of every saddle point.

hyperasymptotic(transseries, n, Σ, K, k; level = 1, component = 1, N = nothing,
                truncation = :daalhuis, rtol = 1e-10)

Hyperasymptotic approximation of the integral,

Σ_j n_j e^{ikλ_j} (ik)^{μ_j} [ Σ_{m<N_j} T_m^(j)/k^m + R_{N_j}^(j)(k) ],

with the remainders re-expanded level times in terms of the series of the adjacent saddle points (level = 0 is the superasymptotic approximation). transseries is the vector of Expansions from transseries (a named tuple (λ, μ, T) per saddle point is accepted as well; component selects a row when T is a matrix), n from relevance, Σ are the Borel singularities and K the Stokes constants of stokes_constants (package convention K[l, j] = K_{l←j}, computed with the normalisation of transseries).

Truncation (truncation = :daalhuis, the default): the series of saddle j is truncated at Nj = ⌈αj^(level) |k|⌉, with αj^(level) the shortest path of level + 1 steps from tj in the adjacency graph (path_lengths), and every re-expanded series at Nchild = max(0, Nparent - ⌈|k Fedge|⌉). truncation = :uniform uses Nj = ⌈(level + 1)|k| Fj⌉ instead, with Fj the distance to the nearest adjacent singularity. Pass a vector N to set the top-level truncations directly.

Level one is evaluated in closed form; level L nests L - 1 quadratures, so levels beyond 2 become expensive. The computation runs in the precision of k: pass k::BigFloat (with the series in BigFloat, as returned by transseries, and a matching rtol) for results beyond double precision. The relation used assumes μ_j = 0 (non-degenerate saddle points in the normalisation of the package). Returns (value, N, terms) with terms[j] the contribution of saddle j.

hyperterminant(M, w; method = :closed, rtol = 1e-10)

Normalised level-one hyperterminant

h(M, w) = Γ(M)⁻¹ ∫_0^∞ v^{M-1} e^{-v} / (1 - v/w) dv = -w e^{-w} E_M(-w),       M > 0,

so that h → 1 for |w| → ∞, with EM the generalised exponential integral (method = :closed, the default) or by quadrature (method = :quadrature). The integral has a pole at v = w when w lies on the positive real axis (a Stokes line), the branch cut of EM(-w): off the cut h is the analytic continuation from either side, and exactly on it the average of both sides (the median value) is returned.

path_lengths(Σ, K, steps)

Olde Daalhuis' numbers αj^(steps-1): for every Borel singularity tj, the length of the shortest path of steps steps tj → t{j0} → … in the adjacency graph (edges j → l with K[l, j] ≠ 0, revisits allowed). For steps = 1 this is the distance to the nearest adjacent singularity (singulants). The minimal remainder at hyperasymptotic level L is of the order e^{-α^(L) |k|}, attained for Nj = α_j^(L) |k| (Proc. R. Soc. Lond. A 454 (1998) 1, eqs. (2.14), (4.15)).

Names of the plotting functions provided by the Makie extension.

Capture all the relevant variables of the Gauss-Manin system.

‖A(t)‖ over the letters s ≠ skip: operator norm of the full sum (sharp) or sum of residue norms.

Borel transform: Σₘ Tₘ / kᵐ ↦ Σₘ Tₘ / Γ(m + α) tᵐ

PadeEvaluate(num, den, x)

Evaluate the rational approximant.

TaylorToPade(a, m, n)

Compute the [m/n] Padé approximant from Taylor coefficients a, where a[k+1] is the coefficient of x^k.

Returns (num, den) where

• num are numerator coefficients in increasing order
• den are denominator coefficients in increasing order, with den[1] == 1

Approximation of the remainder RN^(j)(κ) with L levels of re-expansion. The re-expanded series of the adjacent saddle point l is truncated at Nl = max(0, N - ⌈scale |F_jl|⌉), with scale = |k| of the top level (Olde Daalhuis 1998, eq. (4.18)). The re-expanded series contributes a closed-form sum of level-one hyperterminants; for L > 1 the remainder of saddle l, one level deeper, is integrated against the level-one kernel,

w^{-N} ∫_0^∞ v^{N-1} e^{-v}/(1 - v/w) R_{N_l}^(l)(v/F) dv,       w = κF.

L(z0) on the principal branch: straight path from the (tangential) base point 0.

Permutation that sorts the basis by the leading monomial of its s = 0 part (degrevlex).

L^γ(z0) for a sequence of loops, e.g. [(2,+1),(3,-1)] = around σ2 ccw, then σ3 cw.

cut_poles(poles, zeros; doublet = 1e-6)

Poles of a Padé approximant that lie on its cut system: poles within a relative distance doublet of a zero (Froissart doublets, which nearly cancel) are dropped.

a < b in degree reverse lexicographical order.

Loop factor M = L(z0)⁻¹ L^γ(z0) from explicit transport around loop_path (straight stem, circle, back). An independent check of monodromy_factor, which uses C⁻¹ exp(2πi x_j) C instead.

Distance function

Dyson tail Σ_{r>N} Λ^r/r! ≤ e^Λ Λ^{N+1}/(N+1)!.

evaluateAdjacency(transseries, ϵ = 0.1)

Adjacency matrix (0/1) from the Padé poles of the Borel transforms, without Stokes constants.

Evaluate a free series in the residue matrices: [i1,...,in] ↦ Ri1 ⋯ Rin (no reversal).

Weight-resolved evaluation: D[r+1] is the contribution of the words of length r.

frobenius_gauge(Σ, Rs, j, z; K = 40)

Holomorphic factor G(z) of the Frobenius normal form Y(t) = G(t) (t - σj)^{Rj} C of the Fuchsian system at σj, with G(σj) = I. With A(t) = Rj/(t - σj) + Σm Am (t - σj)^m, the coefficients of G(t) = Σm Gm (t - σj)^m solve m Gm + Gm Rj - Rj Gm = Σ{i<m} Ai G{m-1-i}, which is uniquely solvable when no two eigenvalues of Rj differ by a positive integer (e.g. Rj nilpotent). Needs |z - σj| < distance from σj to the other letters.

Saddle solution Φ̂j(z) = (z - σj)^ρ Σk ck (z - σj)^k with c0 = v, Rj v = ρ v (principal branch), from the Frobenius recursion ((ρ + k) I - Rj) ck = Σ{m<k} Am c{k-1-m}. Needs |z - σ_j| < distance to the other letters, and ρ not a negative integer.

goodBasis(f; check_tame = true)

Good basis of the Brieskorn lattice of the tame polynomial f (Singular's gmspoly.lib, patched to keep resonant terms in A). Returns the basis elements b as lists of (coefficient, exponents [s, x...]) and the matrices A0 and A1 with t[b] = [b](A0 + s A1 + s^2 d/ds).

initial_intersection_numbers(f, xs, T0; atol = 1e-8) -> Vector{Int}

Intersection numbers at θ = π/2 for the critical points xs of the polynomial f (bounded from below on ℝᵈ): morse_orientation for the real critical points, 0 for the complex ones. T0[a] is the normalisation of the series of xs[a], as passed to stokes_constants.

isTame(f)

Test whether the polynomial f is tame in the sense of Broughton (Singular's gmspoly.lib).

Keyhole paths (γ₊, γ₋) from a = σi + ri e to b = σj + rj e, e = (σj - σi)/|σj - σi|. Singular points σk close to the segment σi → σj are avoided by half-circles on the side on which the segment passes them: on the left of the directed line when σk lies to its right, and vice versa, so that the path stays homotopic to the segment and K{j←i} = -K{i←j}. Only a σk on the line itself (a degenerate Stokes line) is passed on the left (side = +1) or right (side = -1). γ₊ and γ₋ differ only around σj.

Direction (angle) for the label of point i: the bisector of the widest angular gap between the edges to nbrs (or, without edges, between the directions to all other points).

laplace_direction(poles, zeros, θ₀; ϵ = 0.01, side = :above, maxangle = π/4, step = 0.002)

Rotation δθ of the Laplace ray, relative to the Borel direction θ₀, that clears Padé's cut system (cut_poles, pole_links, ray_blocked): 0 if the ray arg t = θ₀ is free, otherwise halfway from the edge of the blocked window to the next blocked direction on side (:above or :below), at most maxangle beyond the edge. Returns (δθ, width) with the width of the blocked window around θ₀ (0 if free): a radial cut (Stokes line) blocks a window of width ≈ 2ϵ, curved arcs a wider one.

Image of the (rank-one) residue R, normalised to unit first entry: the leading vector v with R v = tr(R) v. Taken from the SVD rather than an eigen-decomposition, which is ill-conditioned (≈ √eps) when R is nilpotent (tr R = 0).

Local constants (αs, λs) = (‖Rs‖, rs max‖Âs‖) of the stem from σs to z, Âs = Σ{u≠s} Ru/(t-σu).

local_monodromy(Σ, Rs, j, p; K = 40)

Monodromy L = G(p) e^{2πi Rj} G(p)⁻¹ of the counterclockwise loop around σj based at p (in the Frobenius disk of σj): a solution Y continued once around σj becomes L Y. For nilpotent Rj, e^{2πi Rj} = I + 2πi Rj and L - I has the rank of Rj.

Local solution at the singular point σj: Lj(z) = H(z-σj) exp(xj log(z-σj)), H holomorphic with H(0) = 1 (principal branch of log). Needs |z-σj| < dist to other letters. Solves k hk - [xj, hk] = Σm Am h{k-1-m} order by order.

Tail of the local majorant exp(λ(g + αg²)) at g = 1, by the Chernoff bound inf_{G>1} e^{λ(G+αG²)}/(G^{N+1}(1-1/G)).

Polyline for the loop: z0 → straight to radius r around σ_i → circle (ccw if orient=+1) → back.

Propagator U(b ← a) of Y' = A Y for one step, by Taylor expansion at a (needs |b-a| < dist(a, Σ)).

Propagator U with Y(path[end]) = U Y(path[1]) along the polyline path (same steps as transport).

Largest weight N whose words (Σ{r≤N} n^r for n letters) fit in `maxwords`.

Monodromy factor M with L^γ(z0) = L(z0) · M for the loop around σi based at z0 (straight segment z0 → σi, one turn, back). Returns (M, C), C the regularised value at σi. A different (homotopy class of) stem can be given as a polyline stem from z0 to a point q close to σi (within the local disk, |q - σ_i| < distance to the other letters).

Based monodromy matrices T[j] of Y' = Σs Rs/(z-σs) Y for the ccw loops around σj (base point z0, straight stems), weight-resolved: T[j][r+1] is the weight-r part.

morse_normalisation(H; atol = 1e-8)

Leading coefficient T0 = 1/√det H of the series of a critical point with Hessian H. For a complex critical point, the principal branch is used. For a real critical point with Morse index ν (the number of negative eigenvalues of H), the branch is fixed by stationary phase, √det H = e^{iπν/2} √|det H|, such that T0 = (-i)^ν / √|det H| is the contribution of the real critical point to the integral: real critical points then enter with intersection number n = +1 (see morse_orientation). For det H < 0 the principal branch would be ambiguous, as it depends on the sign of the rounding error in the imaginary part of det H.

morse_orientation(H, T0; atol = 1e-6) -> Int

Intersection number n = ±1 of a real non-degenerate critical point in the Euclidean integral, relative to the normalisation T0 (leading coefficient of its series, 1/√det H in the package). Stationary phase gives the contribution e^{-iπν/2}/√|det H| (ν the Morse index), so n = e^{-iπν/2}/(√|det H| T0).

DynamicPolynomials variables [s, x...] for the good basis, named after the variables of f.

Concatenation product, truncated at weight N.

Parse a Singular rational number such as -25/8.

Midpoint quadrature nodes and weights |dt| on the polyline path, refined near the letters Σ.

Path strength Λγ = ∫γ ‖A(t)‖ |dt| (numerical quadrature).

plotPoles(poles, transseries, plotRange = 3)

Plot the Padé poles of the Borel transforms (findPoles), shifted to the Borel singularity of each series, together with the singularities themselves. Returns (fig, ax). Requires a Makie backend: load CairoMakie (or GLMakie) first.

pole_links(p; ρ = 0.75)

Segments joining every pole to its two nearest neighbours, when closer than ρ times the smaller of their moduli: a polyline approximation of Padé's cut system, which follows curved arcs as well.

polyEvaluate(c, x)

Evaluate polynomial with coefficients in increasing order.

Transport series Ga(b) = Σw L^{(a)}_w(b) w with base point a (a regular point), by Taylor expansion in u = t-a. Needs |b-a| < dist(a, Σ).

Run a Singular script with the Singular executable and return everything it prints. Each call is a separate process, so Singular uses its own memory management (much faster than running it inside Julia).

Evaluate the x-exponent vector of the leading monomial (degrevlex) of the s = 0 part of p

exp(A) for A without constant term.

Singular header that loads the patched gmspoly.lib and defines the polynomial f.

Collect the lines printed with the given tag, or report the Singular output if the script did not finish.

Write the polynomial f in Singular syntax, with the variables named x(1), ..., x(n).

Inverse of a series with invertible constant term.

southeast_edges(Σ, K; include_vertical = false, atol = 1e-9)

Edges j → l of the adjacency graph (K[l, j] ≠ 0) pointing South-East in the Borel plane, arg(tl - tj) ∈ [-π/2, 0], ordered from steep to shallow. Exactly vertical edges, crossed at the Euclidean point θ = π/2 itself, are left out unless include_vertical = true. Returns a vector of named tuples (from = j, to = l, angle = θ, K = K[l, j]).

Practical stopping rule (not a certificate): increase N from Nmin until KN and K{N+1} round to the same integer and differ by less than tol. Returns ((K, S, residual), N).

Format a Stokes constant: integers without decimals, otherwise rounded to digits.

Smallest N ≤ Nmax with certified |KN - K{j←i}| < 1/2 (see truncation_bound), or nothing.

Taylor coefficients Am of A(a+u) = Σm A_m u^m, over the letters s ≠ skip.

Convert a basis element, given as a list of (coefficient, exponents), to a polynomial.

Weight-resolved tr((Ti - I)(Tj - I)): entry r-1 is the total-weight-r contribution Σ{p=1}^{r-1} tr(Di[p+1] Dj[r-p+1]), r = 2..N, with Di the weight pieces of Ti (e.g. from `monodromypieces`). The leading entry is (2πi)² tr(Ri Rj).

Continue a solution L (given at path[1]) along the polyline path, left-multiplying transports.

Certified bound N ↦ B(N) ≥ |KN - K{j←i}| for the hyperlogarithm back-end truncated at weight N, valid for nilpotent residues (ρ = 0). sharp uses ‖Σs Rs/(t - σs)‖ instead of Σs ‖Rs‖/|t - σs|; a_posteriori takes ‖Φ̂a‖, ‖Φ̂b‖, ‖U₊ - U₋‖ and |K| from the matrix back-end instead of a-priori bounds.

Truncation order: :singulant (N = ⌈|k| F⌉), :smallest (index of the smallest term) or an Int.