Splitting based objectives

ManifoldDifferenceOfConvexObjective{E} <: AbstractManifoldCostObjective{E}

Specify an objective for a difference_of_convex_algorithm.

The objective $f: \mathcal{M} → ℝ$ is given as

\[ f(p) = g(p) - h(p)\]

where both $g$ and $h$ are convex, lower semicontinuous and proper. Furthermore the subdifferential $∂h$ of $h$ is required.

Fields

• cost: an implementation of $f(p) = g(p)-h(p)$ as a function f(M,p).
• gradient!! a gradient of the smooth component g
• ∂h!!: a deterministic version of $∂h: \mathcal{M}→ T\mathcal{M})$, in the sense that calling ∂h(M, p) returns a subgradient of $h$ at p and if there is more than one, it returns a deterministic choice.

Note that the gradient and the subdifferential might be given in two possible signatures

• (M,p) -> X which does an AllocatingEvaluation
• (M, X, p) -> X which does an InplaceEvaluation in place of X.

Constructor

ManifoldDifferenceOfConvexObjective(cost, ∂h; gradient = nothing, evaluation = AllocatingEvaluation())

Create the difference of convex objective given a cost function and the subdifferential ∂h of the non-smooth part The gradient of the smooth part and the evaluation = type are keywords.

ManifoldProximalGradientObjective{E,<:AbstractEvaluationType, TC, TG, TGG, TP} <: AbstractManifoldObjective{E,TC,TGG}

Model an objective of the form

\[f(p) = g(p) + h(p), \qquad p ∈ \mathcal{M},\]

where $g: \mathcal{M} → \bar{\mathbb R}$ is a differentiable function and $h: → \bar{\mathbb R}$ is a (possibly) lower semicontinous, and proper function.

This objective provides the total cost $f$, its smooth component $g$, as well as $\operatorname{grad} g$ and $\operatorname{prox}_{λ h}$.

Fields

• cost: the overall cost $f = g + h$
• cost_smooth: the smooth cost component $g$
• gradient_g!!: the gradient $\operatorname{grad} g$
• proximal_map_h!!: the proximal map $\operatorname{prox}_{λ h}$

Constructor

ManifoldProximalGradientObjective(f, g, grad_g, prox_h;
    evalauation=AllocatingEvaluation()
)

Generate the proximal gradient objective given the total cost $f = g + h$, smooth cost $g$, the gradient of the smooth component $\operatorname{grad} g$, and the proximal map of the nonsmooth component $\operatorname{prox}_{λ h}$.

Keyword arguments

• evaluation=AllocatingEvaluation: whether the gradient and proximal map is given as an allocation function or an in-place (InplaceEvaluation).

AbstractPrimalDualManifoldObjective{E<:AbstractEvaluationType,C,P} <: AbstractManifoldCostObjective{E,C}

A common abstract super type for objectives that consider primal-dual problems.

PrimalDualManifoldObjective{T<:AbstractEvaluationType} <: AbstractPrimalDualManifoldObjective{T}

Describes an Objective linearized or exact Chambolle-Pock algorithm, cf. [BHS+21], [CP11]

Fields

All fields with !! can either be in-place or allocating functions, which should be set depending on the evaluation= keyword in the constructor and stored in T <: AbstractEvaluationType.

• cost: $F + G(Λ(⋅))$ to evaluate interim cost function values
• linearized_forward_operator!!: linearized operator for the forward operation in the algorithm $DΛ$
• linearized_adjoint_operator!!: the adjoint differential $(DΛ)^* : \mathcal{N} → T\mathcal{M}$
• prox_f!!: the proximal map belonging to $f$
• prox_G_dual!!: the proximal map belonging to $g_n^*$
• Λ!!: the forward operator (if given) $Λ: \mathcal{M} → \mathcal{N}$

Either the linearized operator $DΛ$ or $Λ$ are required usually.

Constructor

PrimalDualManifoldObjective(cost, prox_f, prox_G_dual, adjoint_linearized_operator;
    linearized_forward_operator::Union{Function,Missing}=missing,
    Λ::Union{Function,Missing}=missing,
    evaluation::AbstractEvaluationType=AllocatingEvaluation()
)

The last optional argument can be used to provide the 4 or 5 functions as allocating or mutating (in place computation) ones. Note that the first argument is always the manifold under consideration, the mutated one is the second.

PrimalDualManifoldSemismoothNewtonObjective{E<:AbstractEvaluationType, TC, LO, TALO, PF, DPF, PG, DPG, L} <: AbstractPrimalDualManifoldObjective{E, TC, PF}

Describes a Problem for the Primal-dual Riemannian semismooth Newton algorithm. [DL21]

Fields

• cost: $F + G(Λ(⋅))$ to evaluate interim cost function values
• linearized_operator: the linearization $DΛ(⋅)[⋅]$ of the operator $Λ(⋅)$.
• linearized_adjoint_operator: the adjoint differential $(DΛ)^* : \mathcal{N} → T\mathcal{M}$
• prox_F: the proximal map belonging to $F$
• diff_prox_F: the (Clarke Generalized) differential of the proximal maps of $F$
• prox_G_dual: the proximal map belonging to G^\ast_n`
• diff_prox_dual_G: the (Clarke Generalized) differential of the proximal maps of $G^\ast_n$
• Λ: the exact forward operator. This operator is required if Λ(m)=n does not hold.

Constructor

PrimalDualManifoldSemismoothNewtonObjective(cost, prox_F, prox_G_dual, forward_operator, adjoint_linearized_operator,Λ)

X = adjoint_linearized_operator(N::AbstractManifold, apdmo::AbstractPrimalDualManifoldObjective, m, n, Y)
adjoint_linearized_operator(N::AbstractManifold, X, apdmo::AbstractPrimalDualManifoldObjective, m, n, Y)

Evaluate the adjoint of the linearized forward operator of $(DΛ(m))^*[Y]$ stored within the AbstractPrimalDualManifoldObjective (in place of X). Since $Y∈T_{n}\mathcal{N}$, both $m$ and $n=Λ(m)$ are necessary arguments, mainly because the forward operator $Λ$ might be missing in p.

q = forward_operator(M::AbstractManifold, N::AbstractManifold, apdmo::AbstractPrimalDualManifoldObjective, p)
forward_operator!(M::AbstractManifold, N::AbstractManifold, q, apdmo::AbstractPrimalDualManifoldObjective, p)

Evaluate the forward operator of $Λ(x)$ stored within the TwoManifoldProblem (in place of q).

η = get_differential_dual_prox(N::AbstractManifold, pdsno::PrimalDualManifoldSemismoothNewtonObjective, n, τ, X, ξ)
get_differential_dual_prox!(N::AbstractManifold, pdsno::PrimalDualManifoldSemismoothNewtonObjective, η, n, τ, X, ξ)

Evaluate the differential proximal map of $G_n^*$ stored within PrimalDualManifoldSemismoothNewtonObjective

\[D\operatorname{prox}_{τG_n^*}(X)[ξ]\]

which can also be computed in place of η.

y = get_differential_primal_prox(M::AbstractManifold, pdsno::PrimalDualManifoldSemismoothNewtonObjective σ, x)
get_differential_primal_prox!(p::TwoManifoldProblem, y, σ, x)

Evaluate the differential proximal map of $F$ stored within AbstractPrimalDualManifoldObjective

\[D\operatorname{prox}_{σF}(x)[X]\]

which can also be computed in place of y.

Y = get_dual_prox(N::AbstractManifold, apdmo::AbstractPrimalDualManifoldObjective, n, τ, X)
get_dual_prox!(N::AbstractManifold, apdmo::AbstractPrimalDualManifoldObjective, Y, n, τ, X)

Evaluate the proximal map of $g_n^*$ stored within AbstractPrimalDualManifoldObjective

\[ Y = \operatorname{prox}}_{τG_n^*}(X)\]

which can also be computed in place of Y.

q = get_primal_prox(M::AbstractManifold, p::AbstractPrimalDualManifoldObjective, σ, p)
get_primal_prox!(M::AbstractManifold, p::AbstractPrimalDualManifoldObjective, q, σ, p)

Evaluate the proximal map of $F$ stored within AbstractPrimalDualManifoldObjective

\[\operatorname{prox}_{σF}(x)\]

which can also be computed in place of y.

Y = linearized_forward_operator(M::AbstractManifold, N::AbstractManifold, apdmo::AbstractPrimalDualManifoldObjective, m, X, n)
linearized_forward_operator!(M::AbstractManifold, N::AbstractManifold, Y, apdmo::AbstractPrimalDualManifoldObjective, m, X, n)

Evaluate the linearized operator (differential) $DΛ(m)[X]$ stored within the AbstractPrimalDualManifoldObjective (in place of Y), where n = Λ(m).