TaylorModels.jl

RTaylorModel1{T,S}

Relative Taylor model in 1 variable, providing a rigurous polynomial approximation given by a Taylor polynomial pol (around x0) and a relative remainder rem for a function f(x) in one variable, valid in the interval dom. This corresponds to definition 2.3.2 of Mioara Joldes' thesis.

Fields:

• pol: polynomial approximation, represented as TaylorSeries.Taylor1
• rem: the interval bound
• x0 : expansion point
• dom: domain, interval over which the Taylor model is defined / valid

The approximation $f(x) = p(x) + \delta (x - x_0)^{n+1}$ is satisfied for all $x\in \mathcal{D}$; n is the order (degree) of the polynomial $p(x)=\sum_{i=0}^n p_i (x - x_0)^i$.

TaylorModel1{T,S}

Absolute Taylor model in 1 variable, providing a rigurous polynomial approximation given by a Taylor polynomial pol (around x0) and an absolute remainder rem for a function f(x) in one variable, valid in the interval dom. This corresponds to definition 2.1.3 of Mioara Joldes' thesis.

Fields:

• pol: polynomial approximation, represented as TaylorSeries.Taylor1
• rem: the interval bound
• x0 : expansion point
• dom: domain, interval over which the Taylor model is defined / valid

The approximation $f(x) = p(x) + \Delta$ is satisfied for all $x\in \mathcal{D}$ ($0\in \Delta$); n is the order (degree) of the polynomial $p(x)=\sum_{i=0}^n p_i (x - x_0)^i$.

TaylorModelN{N,T,S}

Taylor Models with absolute remainder for N independent variables.

__evaluate!(tmn, tm::TaylorModel1{TaylorModelN}, dx[, aux]) -> tmn

In-place rigorous evaluation: tmn ⊇ tm(dx) (all remainders included), dx an S or an Interval{S} within the centred domain of tm. aux is an optional TaylorN{Interval{S}} workspace (see _aux_horner); without it, one is allocated.

_horner!(tmn, a::Taylor1{TaylorModelN}, dx, aux) -> tmn

Rigorous tmn ⊇ Σ_k a[k] dx^k, including the remainders of the TMN coefficients, for dx an S or an Interval{S} (a displacement of the Taylor1 variable). Horner's scheme runs coefficientwise in Interval{S}, accumulated in the workspace aux::TaylorN{Interval{S}} (same structure as the coefficients of a); coefficients are stored in tmn with _split, the residuals are kept in aux and bounded over centered_dom(tmn) (as in fp_rpa). No allocations besides the evaluation of the residual polynomial. tmn provides expansion point and domain; it must not alias any a[k], and aux must not alias anything.

_monot_bound_remainder(::Type{TaylorModel1}, ::Val{false}, f::Function, polf::Taylor1, polfI::Taylor1, x0, I::Interval)

Computes the remainder using Lagrange bound

_monot_bound_remainder(::Type{RTaylorModel1}, ::Val{true}, f::Function, polf::Taylor1, polfI::Taylor1, x0, I::Interval)

Computes the remainder exploiting monotonicity; see Prop 2.3.7 in Mioara Joldes' PhD thesis (pp 67).

_monot_bound_remainder(::Type{TaylorModel1}, ::Val{true}, f::Function,
    polf::Taylor1, polfI::Taylor1, x0, I::Interval)

Computes the remainder exploiting monotonicity; see Prop 2.2.1 in Mioara Joldes' PhD thesis (pp 52).

   _rpa(::Type{TaylorModel1}, f::Function, x0::Interval, I::Interval, _order::Integer)
   _rpa(::Type{RTaylorModel1}, f::Function, x0::Interval, I::Interval, _order::Integer)

Rigurous polynomial approximation (RPA) with absolute/relative remainder for the function f on the interval I, using a Taylor expansion around the interval x0 of order _order. The bound is computed by bound_remainder(@ref) exploiting monotonicity if possible, otherwise, it uses Lagrange bound.

bound_integration(xTM::TaylorModel1{T,S}, δ)
bound_integration(xTM::Vector{TaylorModel1{T,S}}, δ)

Bound the remainder of the integration of a xTM::TaylorModel1, where δ is the domain used to bound the integration. The remainder corresponds to $δ * remainder(a) + a.pol[order] * δ^(order+1) / (order+1)$. This is tighter that the one used by Berz+Makino, which corresponds to $Δ = δ * remainder(a) + a.pol[order] * δ^(order+1)$.

bound_integration(xTM::RTaylorModel1{T,S}, δ)
bound_integration(xTM::Vector{RTaylorModel1{T,S}, δ)

Remainder bound for the integration of a xTM::RTaylorModel1, where δ is the domain used to bound the integration. The remainder corresponds to $Δ = δ * remainder(a)/(order+2) + getcoeff(polynomial(a), order)/(order+1)$.

bound_remainder(::Type{RTaylorModel1}, f::Function, polf::Taylor1, polfI::Taylor1,
    x0::Interval, I::Interval)

Bound the relative remainder of the polynomial approximation of f given by the Taylor polynomial polf around x0 on the interval I. It requires an the interval extension polfI of a polynomial that approximates f for the whole interval I, in order to compute the Lagrange remainder.

If polfI[end] has a definite sign, then it is monotonic in the interval I, which is exploited; otherwise, the last coefficients bounds the relative remainder. This corresponds to Prop 2.3.7 in Mioara Joldes' PhD thesis (pp 67).

bound_remainder(::Type{TaylorModel1}f::Function, polf::Taylor1, polfI::Taylor1,
    x0::Interval, I::Interval)

Bound the absolute remainder of the polynomial approximation of f given by the Taylor polynomial polf around x0 on the interval I. It requires the interval extension polfI of the polynomial that approximates f for the whole interval I, in order to compute the Lagrange remainder.

If polfI[end] has a definite sign, then it is monotonic in the intervals [inf(I), x0] and [sup(x0), sup(I)], which is exploited; otherwise, it is used to compute the Lagrange remainder. This corresponds to Prop 2.2.1 in Mioara Joldes PhD thesis (pp 52).

bound_taylor1(fT::TaylorModel1, I=centered_dom(fT)::Interval)

Compute a tight polynomial bound for the Taylor model fT in the interval I, considering whether its derivative ftd has a definite sign.

bound_taylor1(fT::Taylor1, I::Interval)

Compute a tight polynomial bound for the Taylor polynomial fT in the interval I.

Note: Algorithm 2.1.1 corresponds to evaluate(fT, I) or simply fT(I). This function uses the roots of the derivative offt` to obtain a tighter bound.

bound_taylor1(fT::Taylor1, fTd::Taylor1, I::Interval)

Compute a tight polynomial bound for the Taylor polynomial fT in the interval I, considering whether its derivative ftd has a definite sign.

fp_rpa(tm::TaylorModel1{Interval{T},T})
fp_rpa(tm::RTaylorModel1{Interval{T},T})

Convert a tm TaylorModel1 to a TaylorModel1 whose polynomial coefficients are Float64. The accumulated error is added to the remainder. The mid point of the expansion interval is preferentially rounded down if it is not an exactly representable value.

linear_dominated_bounder(fT::TaylorModelN, ϵ=1e-3::Float64, max_iter=5::Int)

Compute a tighter polynomial bound for the Taylor model fT by the linear dominated bounder algorithm. The linear dominated algorithm is applied until the bound of fT gets tighter than ϵ or the number of steps reachs max_iter. The returned bound corresponds to the improved polynomial bound with the remainder of the TaylorModelN included.

linear_dominated_bounder(fT::TaylorModel1, ϵ=1e-3::Float64, max_iter=5::Int)

Compute a tighter polynomial bound for the Taylor model fT by the linear dominated bounder algorithm. The linear dominated algorithm is applied until the bound of fT gets tighter than ϵ or the number of steps reachs max_iter. The returned bound corresponds to the improved polynomial bound with the remainder of the TaylorModel1 included.

monotonicity_bounder(tm::TaylorModelN, box = centered_dom(tm)) -> Interval

Rigorous enclosure of the range of tm over box, a box of displacements from the expansion point (box ⊆ centered_dom(tm)), never wider than plain interval evaluation evaluate(tm, box).

Monotonicity test per variable: if 0 ∉ ∂_j p(box_lo), p is monotone in σ_j on box_lo, so its minimum lies on the face σ_j = inf(box_j) (increasing) or σ_j = sup(box_j) (decreasing); σ_j is fixed there and the test continues with the remaining variables. Likewise box_hi for the maximum. The result, [inf p(box_lo), sup p(box_hi)] + Δ, is intersected with p(box) + Δ. Only interval evaluations are used (two-sided, rigorous). In 1D, when p is monotone on box, it is the exact range of p plus Δ; this is the N-dimensional version of the monotone branch of bound_taylor1.

pol_remainder(tm::TaylorModel1{TaylorModelN{N,T,S}, S}) :: TaylorModel1{Interval{S},S}

TaylorModel1 formed by the TaylorModelN remainders.

pure_polynomial(tm)

Return the pure polynomial part of a tm::TaylorModel1{TaylorModelN{N,T,S},S} as a Taylor1{TaylorN{T}}.

quadratic_fast_bounder(fT::TaylorModel1)

Compute a tighter polynomial bound by the quadratic fast bounder. The returned bound corresponds to the "improved" polynomial bound with the remainder of the TaylorModel1 included. This "improved" bound can be one of the following two: 1) An improved bound: if the domain of fT has a local minimizer, then an improved bound is returned. 2) Original TaylorModel bound: if the local minimizer criteria is not satisfied, then the original bound of fT is returned.

This algorithm is a slight modification to the Makino & Berz algorithm. For this algorithm the linear part is bounded by solving a simple set of linear equations (compared to the iterative procedure by Makino & Berz).

quadratic_fast_bounder(fT::TaylorModelN)

Compute a tighter polynomial bound by the quadratic fast bounder. The returned bound corresponds to the "improved" polynomial bound with the remainder of the TaylorModelN included. This "improved" bound can be one of the following two: 1) An improved bound: if the domain of fT has a local minimizer, then an improved bound is returned. 2) Original TaylorModel bound: if the local minimizer criteria is not satisfied, then the original bound of fT is returned.

This algorithm is a slight modification to the Makino & Berz algorithm. For this algorithm the linear part is bounded by solving a simple set of linear equations (compared to the iterative procedure by Makino & Berz).

rpa(g::Function, tmf::TaylorModel1) rpa(g::Function, tmf::RTaylorModel1) rpa(g::Function, tmf::TaylorModelN)

Rigurous polynomial approximation (RPA) for the function g using the Taylor Model with absolute/relative remainder tmf. The bound is computed exploiting monotonicity if possible, otherwise, it uses Lagrange bound.

shift_remainder(tm::TaylorModel1{TaylorModelN{N,T,S}, S})

Returns a TaylorModel1{TaylorModelN} with null remainder for the TaylorModelN part, and the total remainder in the TaylorModel1.

symmetric_box(N::Int, [Type{T} = Float64])
symmetric_box(::Type{T})

Create the interval box [-1, 1]^N as a SVector, with elements of type T. If N is omitted, it corresponds to get_numvars().

total_remainder(tm::TaylorModel1{TaylorModelN{N,T,S}, S})

Computes de total reminder of a TaylorModel1{TaylorModelN} by computing the polynomial associated to the TaylorModelN reminders, evaluated in the centered domain, and adding the remainder of the TaylorModel1.

truncate_taylormodel(a::RTaylorModel1, m::Integer)

Truncates a::RTaylorModel1 to order m.

integrate(a::TM{T,S}, c0)
integrate(a::TM{TaylorN{T},S}, c0, cc0)

Integrates the one-variable Taylor Model (TaylorModel1 or RTaylorModel1) with respect to the independent variable. c0 is the integration constant; if omitted it is taken as zero. When the coefficients of a are TaylorN variables, the domain is specified by cc0::AbstractVector{<:Interval}.

integrate(fT, which)

Integrates a fT::TaylorModelN with respect to which variable. The returned TaylorModelN corresponds to the Taylor Model of the definite integral ∫f(x) - ∫f(expansion_point).

TMSol{T,V1,V2,M}

Structure containing the solution of a validated integration (methods validated_integ, validated_integ2).

Fields

`time :: AbstractVector{T}`: Vector containing the expansion time of the
`TaylorModel1` solutions

`fp   :: AbstractVector{Vector{N,Interval{T}}}`: Vector of interval vectors
representing the flowpipe

`xTMv :: AbstractMatrix{TaylorModel1{TaylorN{T},T}}`: Matrix whose entry `xTMv[i,t]`
represents the `TaylorModel1` of the i-th dependent variable, obtained at time time[t].

TMSol3{N,T<:Real,U<:IANumTypes}

Structure containing the solution of a validated integration (method validated_integ3).

Fields

`time :: Vector{T}`: Vector containing the expansion time of the
`TaylorModel1` solutions

`fp   :: Vector{Vector{Interval{T}}}`: Vector of interval vectors
representing the flowpipe

`xTMv :: Matrix{TaylorModel1{TaylorModelN{N,T,T},T}}`: Matrix whose
entry `xTMv[i,t]` represents the `TaylorModel1` of the i-th dependent variable,
obtained at time time[t].

_guess_rem(r, δt, δt_prev)

First guess of the Picard remainder of a step of size δt, from the accepted remainder r of the previous step (size δt_prev): _GUESS_FACTOR * (δt/δt_prev)^_GUESS_POWER * r; zero for the first step (δt_prev == 0). It is only a guess: the validation is done afterwards.

_imatvec_tmn!(out, G, vTMN, c)

out[i] ⊇ Σ_j G[i,j] * (vTMN[j] - c[j]) on B, with c::Vector{U}. Coefficients are accumulated in Interval{U} and stored with _split; any residual, times a monomial bounded by 1 on B, goes into the remainder.

picard(dx, x0, box)

Computes the picard (integral) operator for the initial condition x0. dx must be the rhs of the differential equation.

_picard_pass!(f!, x2N, dx1N, x1N, x1NI, t1N, auxI, rem1, rem2, params)

One interval Picard pass from the candidate remainders rem1 (the candidate is p₁ + rem1, p₁ the polynomial in x1N); the image remainders (including the rounding R(p₂ - p₁)) are stored in rem2.

_poldiff_bound(a, b, aux) -> Interval

Rigorous enclosure of the range of polynomial(a) - polynomial(b) (Taylor1 in τ with TaylorN coefficients in σ) for τ ∈ centered_dom(a) and σ ∈ centered_dom(a[0]); the remainders are not included. Interval Horner in τ, coefficientwise in the workspace aux::TaylorN{Interval{U}} (structure of the TMN coefficients), then evaluation over the σ-box.

_polish_rem!(f!, x2N, dx1N, x1N, x1NI, t1N, auxI, rem1, rem2, rem3, params)

On entry rem2 ⊆ rem1 (a validated step) and x1N[i].rem == rem2[i]. If the candidate was loose (diam(rem2) < _POLISH_TOL * diam(rem1) in some component), repeat the pass with rem2 as the candidate, at most _NPOLISH[] times; a pass that is not self-mapping is discarded (the previous, valid, rem2 is kept). The accepted remainder is the image, so it depends on the candidate only through the contraction factor: a loose guess would otherwise widen the result.

_right_in_box(rightTMN) -> Bool

true iff the range enclosure monotonicity_bounder of each rightTMN[i] is contained in [-1,1]. Must use the same bounder as qrprecondition!.

_update_inicond!(x, dx, x1N, vTMN)

In-place update the initial conditions in x and dx (the latter reset to zero) from vTMN; x1N stores the remainder.

_update_output!(xTM1v::AbstractVector{TaylorModel1{TaylorModelN{N,T,U}, U}},
    x1N::AbstractVector{TaylorModel1{TaylorModelN{N,T,U}, U}})

In-place update of xTM1v with the contents of x1N, to avoid deepcopy. Assumes same shape of both entries.

_validate_step(xTM1K, f!, dx, x0, params, t, box, dof; ε=1e-10, maxsteps=20, extrasteps=50)

Validate the Taylor Model solution for the current integration time step. This function implements the epsilon inflation algorithm proposed by Bünger with some custom adaptations.

Ref: Florian B"unger, A Taylor model toolbox for solving ODEs implemented in MATLAB/INTLAB, J. Comput. Appl. Math. 368, 112511, https://doi.org/10.1016/j.cam.2019.112511

_validation3!(f!, t, x, t1NI, x1N, x1NI, dx1NI, x2NI, z1NI, auxI, δt, δt_prev,
    tmax, sign_tstep, rem1, rem2, rem0, zbox, abstol, params, adaptive, minabstol)

Picard validation of the candidate x1N = p₁ + Δ₁, p₁ the (floating-point) Taylor polynomial x of TaylorIntegration. The Picard operator is evaluated on x1NI (p₁ with Interval coefficients) in the Interval workspaces, so the arithmetic of f! and the integration enclose every rounding; its result is p₂ + Δ₂ with an interval polynomial p₂ ≠ p₁ in general. Self-map condition: Δ₂ + R(p₂ - p₁) ⊆ Δ₁, R a rigorous range over the τ-domain and the σ-box (_poldiff_bound). On success x1N.rem is that enclosure. The iteration starts from _guess_rem(rem0, δt, δt_prev), rem0 being the accepted remainder of the previous step (zero in the first step); a loose accepted candidate is polished (_polish_rem!).

_verified_inv(M, P)

Rigorous enclosure of inv(M) (M a float or interval matrix; for an interval matrix, the enclosure holds for every point matrix in M) from an approximate inverse P. With E = I - P*M (interval) and δ = ‖E‖∞ < 1: inv(M) = (I-E)^{-1} P ∈ (I + E + [-r,r]) P, r = δ²/(1-δ), since each entry of Σ_{m≥2} E^m is bounded by ‖E‖∞^m. Returns nothing if δ ≥ 1.

Refs: A. Neumaier, Interval Methods for Systems of Equations, Cambridge Univ. Press (1990); S. M. Rump, Acta Numerica 19, 287-449 (2010).

absorb_remainder(a::TaylorModelN)

Returns a TaylorModelN, equivalent to a, such that the remainder is mostly absorbed in the constant and linear coefficients. The linear shift assumes that a is normalized to the interval box (-1..1)^N.

Ref: Xin Chen, Erika Abraham, and Sriram Sankaranarayanan, "Taylor Model Flowpipe Construction for Non-linear Hybrid Systems", in Real Time Systems Symposium (RTSS), pp. 183-192 (2012), IEEE Press.

initcacheVI(t0::T, x0::Array{Interval{U},1}, maxsteps::Int, orderT::Int, orderQ::Int, f!::F, params = nothing; parseeqs::Bool = true) initcacheVI(t0::T, x0::Array{TaylorModel1{TaylorN{U},U},1}, maxsteps::Int, orderT::Int, ::Int, f!::F, params = nothing; parseeqs::Bool = true)

Initialize the internal integration variables and normalize the given interval box to the domain [-1, 1]^n. If x0 corresponds to a vector of TaylorModel1, it is assumed that the domain of the TaylorN variables is normalized to the domain [-1, 1]^n.

iscontractive(Δ, Δx)

Checks if Δ .⊆ Δx is satisfied.

mince_in_time(sol; var=0, timediv=1) --> ::Vector{Interval}

For var=0, this function divides the time domain of each entry of sol in timediv parts (timediv==1 is the initial domain), and returns the time intervals where the solution holds. This is useful for plotting or finding specific events. For var ≥ 1, this function evaluates the flowpipes at the split domain intervals, which is useful to decrease the overapproximations associated to the whole time domain.

mince_in_time(sol; var=0, timediv=1) --> ::Vector{Interval}

For var=0, this function divides the time domain of each entry of sol in timediv parts (timediv==1 is the initial domain), and returns the time intervals where the solution holds. This is useful for plotting or finding specific events. For var ≥ 1, this function evaluates the flowpipes at the split domain intervals, which is useful to decrease the overapproximations associated to the whole time domain.

normalize_taylorNs!

Convert the x0::Vector{Interval{T}} to a q0::Vector{TaylorN{T}} inplace. Evaluating each component of q0 in the interval(-1,1) yields the corresponding component of x0.

picard_iteration(f!, dx, xTM1K, params, t, x0, box)

Computes the picard (integral) operator for the set of equations f! and the initial conditionx0. This method returns the remainder of the resulting Taylor Model without the remainder of the initial condition.

picard_iteration(f!, dx, xTM1K, params, t, x0, box, ::Val{true})

Computes the picard (integral) operator for the set of equations f! and the initial conditionx0. The Val parameter enables the selection of the desired method. This one returns the remainder of the resulting Taylor Model with the remainder of the initial condition included.

picard_lindelof(f!, dxTM1TMN::Vector{TaylorModel1{T,S}},
    xTM1TMN::Vector{TaylorModel1{T,S}}, t, params)

Compute the Picard-Lindelof operator to validate a solution of a differential equation.

picard_remainder!(f!, t, x, dx, xxI, dxxI, δI, δt, Δx, Δ0, params)

Return the remainder of Picard operator

qrprecondition!(leftTMN, rightTMN, linTN, rems, scaleV, vTMN;
                    maxiter=4, verbose=false) -> Bool

Rigorous QR preconditioning of vTMN::Vector{TaylorModelN{N,T,U}}, T ∈ {U, Interval{U}}.

On success (true):

• leftTMN[i] = c_i + Σ_j M_L[i,j] σ_j, zero remainder; c = mid(v(0)), or, with recenter = true (default), c shifted so that the computed ranges of Q^{-1}(v - c) are centred (tighter scales; ρ then has a small constant term); M_L = fl(Q*S) (stored as thin coefficients of type T);
• rightTMN = ρ ⊇ M_L^{-1}(v - c), with ρ(B) ⊆ B verified;

hence v(ξ) ∈ L(ρ(ξ)) and v(B) ⊆ L(B). On exit, linTN holds M_L. Q comes from the QR factorization of mid of the linear coefficients of v; it only needs to be a good frame, rigor comes from the verified inverses. Returns false if a verified inverse cannot be obtained or ρ(B) ⊆ B cannot be verified in maxiter inflations of scaleV.

References

• R. J. Lohner, "Enclosing the solutions of ordinary initial and boundary value problems", in E. Kaucher, U. Kulisch, Ch. Ullrich (eds.), Computer Arithmetic: Scientific Computation and Programming Languages, Teubner, Stuttgart (1987), pp. 255-286. [QR method against the wrapping effect]
• K. Makino, M. Berz, "Suppression of the wrapping effect by Taylor model-based verified integrators: long-term stabilization by preconditioning", Int. J. Differ. Equ. Appl. 10(4), 353-384 (2005). [left/right TM factorization, QR preconditioning]
• M. Neher, K. R. Jackson, N. S. Nedialkov, "On Taylor model based integration of ODEs", SIAM J. Numer. Anal. 45(1), 236-262 (2007). https://doi.org/10.1137/050638448
• F. Bünger, "Preconditioning of Taylor models, implementation and test cases", Nonlinear Theory and Its Applications, IEICE 12(1), 2-40 (2021). https://doi.org/10.1587/nolta.12.2 [explicit rigorous implementation, INTLAB]
• S. M. Rump, "Verification methods: Rigorous results using floating-point arithmetic", Acta Numerica 19, 287-449 (2010). [verified inverse]

qrprecondition(vTMN::Vector{TaylorModelN{N,T,S}})

Returns the left and right preconditioned TaylorModelN's from vTMN, following the explanation of Neher et al (2007).

Ref: M. Neher, K.R. Jackson and N.S. Nedialkov, "On Taylor Model based integration of ODEs", SIAM J. NUMER. ANAL. 45 (1), pp. 236-262 (2007). https://doi.org/10.1137/050638448

reconstruct_rho(sol::TMSol3) -> Matrix{TaylorModelN}

Returns ρ (size N × length(sol)) with ρ[:,k] the right factor of step k: Φ_k(h_k, σ) ⊆ L_{k+1}(ρ[:,k](σ)), σ ∈ B, ρ[:,k](B) ⊆ B. Column 1 is the identity.

It recomputes v_k = Φ_k(h_k, ·) with __evaluate! (h_k exact, from domain(sol, k)) and calls qrprecondition! with its default keywords — the same calls, with the same keywords, as validated_integ3 (consistency: if the integrator ever passes non-default keywords, they must be passed here too). It asserts ρ[:,k](B) ⊆ B and that L_{k+1} equals, bit-wise, the τ^0 coefficient stored in sol[k+1].

Composition (dependence on the initial variables): σ_2 = ξ, σ_{k+1} = ρ[:,k](σ_k), x(t_k + τ) ∈ Φ_k(τ, σ_k(ξ)). With re-centring, ρ[:,k](0) ≠ 0: the constant term of L_k is the centre of the enclosing box, not the trajectory from mid(X0), which is Φ_k(τ, σ_k(0)).

remainder_taylorstep!(f!, t, x, dx, xI, dxI, δI, δt, params)

Returns a remainder for the integration step for the dependent variables (x) checking that the solution satisfies the criteria for existence and uniqueness.

shrink_wrapping!(xTMN::TaylorModelN)

Inplace modification of xTMN, which has absorbed the remainder by the modified shrink-wrapping method of Florian Bünger. The domain of xTMN is the normalized interval box [-1,1]^N.

Ref: Florian B"unger, Shrink wrapping for Taylor models revisited, Numer Algor 78:1001–1017 (2018), https://doi.org/10.1007/s11075-017-0410-1

validated_step!

validated_step!