vectorbundle_newton(M, E, NE, p; kwargs...)
vectorbundle_newton!(M, E, NE, p; kwargs...)

Perform Newton's method for finding a zero of a mapping $F:\mathcal M → \mathcal E$ where $\mathcal M$ is a manifold and $\mathcal E$ is a vector bundle. In each iteration the Newton equation

\[Q_{F(p)} ∘ F'(p) X + F(p) = 0\]

is solved to compute a Newton direction $X$. The next iterate is then computed by applying a retraction.

For more details see [WS24, WBS25].

Arguments

• M::AbstractManifold: a Riemannian manifold $\mathcal M$
• E: range vector bundle
• p: a point on the manifold $\mathcal M$
• NE: functor representing the Newton equation. It has at least fields $A$ and $b$ to store a representation of the Newton matrix $Q_{F(p)}∘ F'(p)$ (covariant derivative of $F$ at $p$) and the right hand side $F(p)$ at a point $p ∈ \mathcal M$. The point $p$ denotes the starting point. The algorithm can be run in-place of $p$.

Keyword arguments

• sub_problem=nothing: specify a problem for a solver or a closed form solution function, which can be allocating or in-place., i.e. you have to provide a method for solving the Newton equation. Currently only the closed form solution is implemented, that is, this is a functor that maps either (problem::VectorBundleManoptProblem, state::VectorBundleNewtonState) -> X or (problem, X, state) -> X to compute the Newton direction.
• sub_state=AllocatingEvaluation: a state to specify the sub solver to use. For a closed form solution, this indicates the type of function.
• retraction_method=default_retraction_method(M, typeof(p)): a retraction $\operatorname{retr}$ to use, see the section on retractions
• stepsize=default_stepsize(M, VectorBundleNewtonState): a functor inheriting from Stepsize to determine a step size
• stopping_criterion=StopAfterIteration(1000): a functor indicating that the stopping criterion is fulfilled
• X=zero_vector(M, p): a tangent vector at the point $p$ on the manifold $\mathcal M$to specify the representation of a tangent vector

vectorbundle_newton(M, E, NE, p; kwargs...)
vectorbundle_newton!(M, E, NE, p; kwargs...)

Perform Newton's method for finding a zero of a mapping $F:\mathcal M → \mathcal E$ where $\mathcal M$ is a manifold and $\mathcal E$ is a vector bundle. In each iteration the Newton equation

\[Q_{F(p)} ∘ F'(p) X + F(p) = 0\]

is solved to compute a Newton direction $X$. The next iterate is then computed by applying a retraction.

For more details see [WS24, WBS25].

Arguments

• M::AbstractManifold: a Riemannian manifold $\mathcal M$
• E: range vector bundle
• p: a point on the manifold $\mathcal M$
• NE: functor representing the Newton equation. It has at least fields $A$ and $b$ to store a representation of the Newton matrix $Q_{F(p)}∘ F'(p)$ (covariant derivative of $F$ at $p$) and the right hand side $F(p)$ at a point $p ∈ \mathcal M$. The point $p$ denotes the starting point. The algorithm can be run in-place of $p$.

Keyword arguments

• sub_problem=nothing: specify a problem for a solver or a closed form solution function, which can be allocating or in-place., i.e. you have to provide a method for solving the Newton equation. Currently only the closed form solution is implemented, that is, this is a functor that maps either (problem::VectorBundleManoptProblem, state::VectorBundleNewtonState) -> X or (problem, X, state) -> X to compute the Newton direction.
• sub_state=AllocatingEvaluation: a state to specify the sub solver to use. For a closed form solution, this indicates the type of function.
• retraction_method=default_retraction_method(M, typeof(p)): a retraction $\operatorname{retr}$ to use, see the section on retractions
• stepsize=default_stepsize(M, VectorBundleNewtonState): a functor inheriting from Stepsize to determine a step size
• stopping_criterion=StopAfterIteration(1000): a functor indicating that the stopping criterion is fulfilled
• X=zero_vector(M, p): a tangent vector at the point $p$ on the manifold $\mathcal M$to specify the representation of a tangent vector

VectorBundleManoptProblem{M<:AbstractManifold,TV<:AbstractManifold,O} <: AbstractManoptProblem{M}

Model a vector bundle problem, that consists of the domain manifold $\mathcal M$ that is a AbstractManifold, the range vector bundle $\mathcal E$ and the Newton equation $Q_{F(x)}∘ F'(x) δ x + F(x) = 0_{p(F(x))}$. The Newton equation should be implemented as a functor that computes a representation of the Newton matrix and the right hand side. It needs to have a field $A$ to store a representation of the Newton matrix $Q_{F(x)}∘ F'(x)$ and a field $b$ to store a representation of the right hand side $F(x)$.

VectorBundleNewtonState{P,T} <: AbstractManoptSolverState

Is state for the vector bundle Newton method

Fields

• p::P: a point on the manifold $\mathcal M$as current point
• p_trial::P: a point on the manifold $\mathcal M$next iterate needed for simplified Newton
• X::T: a tangent vector at the point $p$ on the manifold $\mathcal M$as current Newton direction
• sub_problem::Union{AbstractManoptProblem, F}: specify a problem for a solver or a closed form solution function, which can be allocating or in-place. currently only the closed form solution is implemented, that is, this is a functor that maps either (problem::VectorBundleManoptProblem, state::VectorBundleNewtonState) -> X or (problem, X, state) -> X to compute the Newton direction.
• sub_state::Union{AbstractManoptProblem, F}: a state to specify the sub solver to use. For a closed form solution, this indicates the type of function. specify how the sub_problem is evaluated, e.g. AllocatingEvaluation or InplaceEvaluation
• stop::StoppingCriterion: a functor indicating that the stopping criterion is fulfilled
• stepsize::Stepsize: a functor inheriting from Stepsize to determine a step size
• retraction_method::AbstractRetractionMethod: a retraction $\operatorname{retr}$ to use, see the section on retractions

Constructor

VectorBundleNewtonState(M, E, p, sub_problem, sub_state; kwargs...)

Input

• M::AbstractManifold: a Riemannian manifold $\mathcal M$
• E: range vector bundle
• p: a point on the manifold $\mathcal M$
• sub_state: a state to specify the sub solver to use. For a closed form solution, this indicates the type of function.
• sub_problem: specify a problem for a solver or a closed form solution function, which can be allocating or in-place.

Keyword arguments

• X=zero_vector(M, p): a tangent vector at the point $p$ on the manifold $\mathcal M$to specify the representation of a tangent vector
• stepsize=default_stepsize(M, VectorBundleNewtonState): a functor inheriting from Stepsize to determine a step size
• retraction_method=default_retraction_method(M, typeof(p)): a retraction $\operatorname{retr}$ to use, see the section on retractions
• stopping_criterion=StopAfterIteration(1000): a functor indicating that the stopping criterion is fulfilled

AffineCovariantStepsize <: Stepsize

A functor to provide an affine covariant stepsize generalizing the idea of following Newton paths introduced by [WBS25, Section 4]. It can be used to derive a damped Newton method. The stepsizes (damping factors) are computed by a predictor-corrector-loop using an affine covariant quantity $θ$ to measure local convergence.

Fields

• α: stepsize (damping factor)
• θ: quantity that measures local convergence of Newton's method
• θ_des: desired θ
• θ_acc: acceptable θ
• last_stepsize: last computed stepsize (this is an auxiliary variable used within the algorithm)
• outer_norm: if M is a manifold with components, this is used to specify the norm, that is used to compute the overall distance based on the element-wise distance.

Example

On an AbstractPowerManifold like $\mathcal M = \mathcal N^n$ any point $p = (p_1,…,p_n) ∈ \mathcal M$ is a vector of length $n$ with of points $p_i ∈ \mathcal N$. Then, denoting the outer_norm by $r$, the distance of two points $p,q ∈ \mathcal M$ is given by

\[\mathrm{d}(p,q) = \Bigl( \sum_{k=1}^n \mathrm{d}(p_k,q_k)^r \Bigr)^{\frac{1}{r}},\]

where the sum turns into a maximum for the case $r=∞$. The outer_norm has no effect on manifolds that do not consist of components.

If the manifold does not have components, the outer norm is ignored.

Constructor

AffineCovariantStepsize(
    M::AbstractManifold=DefaultManifold(2);
    α=1.0, θ=1.3, θ_des=0.5, θ_acc=1.1*θ_des, outer_norm::Real=missing
)

Initializes all fields, where none of them is mandatory. The length is set to $1.0$.

Since the computation of the convergence monitor $θ$ requires simplified Newton directions a method for computing them has to be provided. This should be implemented as a method of the newton_equation(M, VB, p, p_trial) as parameters and returning a representation of the (transported) $F(p_{\mathrm{trial}})$.

get_vectorbundle(vbp::VectorBundleManoptProblem)

returns the range vector bundle stored within a VectorBundleManoptProblem