endpoints(S::Dynamic)

Endpoints of the branches, in increasing order (returned as a vector of intervals)

Maximum of

$\frac{|T''|}{(T')^2}$

over all branches

Maximum of

$|\frac{1}{T'}|$

over all branches

Return a non-interval version of the map as a function. This can be used, for instance, for plot(plottable(D)).

preim(S::Dynamic, k, y, ϵ)

Computes the preim of y in branch k of a dynamic, with accuracy ϵ

Type used to represent a "branch" of a dynamic. The branch is represented by a map f with domain X=(a,b). X[1] and X[2] are interval enclosures of a,b.

The map must be monotonic on [a,b]. Note that this is not the same thing as being monotonic on hull(X[1], X[2]): for instance, take the map x → (x-√2)^2 on [√2, 1]: the left endpoint X[1] will be prevfloat(√2)..nextfloat(√2), but then the map is not monotonic on the whole hull(X[1], X[2]) because it also contains points that lie left of √2. This is a tricky case that must be dealt with.

Enclosures Y[1], Y[2] for f(a), f(b) and increasing may be provided (for instance if we know that Y=(0,1)), otherwise they are computed automatically.

Dynamic based on a piecewise monotonic map.

The map is defined as T(x) = Ts[k](x) if $x \in [endpoints[k], endpoints[k+1])$.

y_endpoints ($k \times 2$ matrix) contains the result of applying Ts to the endpoints of each interval. These can be filled in automatically from endpoints, but sometimes they are known to higher accuracy, for instance for x -> mod(3x, 1) we know that it is full-branch exactly. It is assumed that the map will send its domain hull(endpoints[begin],endpoints[end]) into itself.

the array branches is guaranteed to satisfy branches[i].X[end]==branches[i+1].X[begin]

Function call, and Taylor expansion, of a PwMap. Note that this ignores discontinuities; users are free to shoot themselves in the foot and call this on a non-smooth piecewise map. No better solutions for now.

Base.reverse(br:MonotonicBranch)

"Reverses" the x-axis of a branch: given $f:[a,b] -> R$, creates a branch with the function $g:[-b,-a] -> R$ defined as $g(x) = f(-x)$

bound_branch_distortion(br::MonotonicBranch; tol = 0.01)

Compute a rigorous bound for the distortion of a branch on an interval I, defaults to the domain of the branch

function that evaluates the k-th branch of a dynamic on a point x (assuming it's in its domain, otherwise ∅)

branch_inverse_derivative(br::MonotonicBranch; tol = 0.01)

Compute a rigorous bound for the inverse_derivative of a branch

Create explicitly D1 ∘ D2 as a PwMap; remark that the endpoints 
of D1 must be ordered with respect to the canonical order on R.

dfly inequality for maps with infinite derivatives.

The strategy to compute it follows a variant of Lemma 9.1 in the GMNP paper:

• we find a "problematic set" I by taking a small interval of size radius(branch domain)/2^3 around each endpoint with infinite derivative;
• we find l such that T >= l for each point in I
• we compute the dfly coefficients as in the lemma.
• we repeat the computation replacing 2^3 with 2^4, 2^5, ... 2^15 and take the best estimate among these.

has_infinite_derivative_at_endpoints(b::MonotonicBranch)

Returns a pair (left::Bool, right::Bool) that tells if a branch has infinite derivative at any of its endpoints

hasinfinitederivativeatendpoints(D::PwMap)

Returns a single bool to tell whether the dynamic has infinite derivative at any of its endpoint

max_distortion(D::PwMap; tol=1e-3)

Compute a rigorous bound for the distortion of a PwMap

Example

julia> using RigorousInvariantMeasures;

julia> D0 = mod1_dynamic(x->2*x+0.5*x*(1-x), full_branch = true)
Piecewise-defined dynamic with 2 branches

julia> max_distortion(D0)
[0.444269, 0.444444]

inverse_derivative(D::PwMap; tol=1e-3)

Compute a rigorous bound for the inverse_derivative of a PwMap

mod1_dynamic(f::Function, ε = 0.0; full_branch = false)

Utility constructor for dynamics Mod 1 on the torus [0,1]. We assume that f is monotonic and differentiable, for now (this is not restrictive, for our purposes)

Example

julia> using RigorousInvariantMeasures;

julia> D0 = mod1_dynamic(x->2*x+0.5*x*(1-x), full_branch = true)
Piecewise-defined dynamic with 2 branches

Deprecated, but still used in C2Basis

Intersect an Interval or TaylorSeries with I

This class introduces an ApproximatedLSV the induced map for the Liverani-Saussol-Vaienti maps on the interval I = [0.5, 1]. The interval I is then mapped to [0,1]

This constructor builds the induced LSV map on [0.5, 1], truncated with k branches

Return (in an iterator) the pairs (i, (x, |T'(x)|)) where x is a preimage of p[i], which describe the "dual" L* evaluation(p[i])

Return (in an iterator) the pairs (i, (x, |T'(x)|)) where x is a preimage of p[i], which describe the "dual" L* evaluation(p[i])

ShootingLSV(n, y, α, rigstep = 10; T = Float64)

This method returns the preimages of y in the right branch domain after n-1 preimages through the left branch through the LSV map with exponent α