Update prox-grad backtracking condition

Changelog.md

@@ -6,6 +6,12 @@ The file was started with Version `0.4`.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.38] May 19, 2026
+
+### Changed
+
+* the `:convex` backtracking strategy for `proximal_gradient_method` now entails a slightly different condition whenever the upper bound on the sectional curvature of the manifold, input via the `k_max` kwarg, is positive. This comes with a "tolerance" type parameter, `δ`, which must be positive.
+
 ## [0.5.37] May 5, 2026
 
 ### Changed
@@ -99,7 +105,6 @@ so it can be easier reused by others as well (#550)
   This also allows finally to run single test files without installing all packages manually, but instead just switching to and instantiating the test environment. (#550)
 * for compatibility, state also `[source]` entries consistently in the sub `Project.toml` files. (#550)
 
-
 ## [0.5.28] November 17, 2025
 
 ### Changed

Project.toml

@@ -1,6 +1,6 @@
 name = "Manopt"
 uuid = "0fc0a36d-df90-57f3-8f93-d78a9fc72bb5"
-version = "0.5.37"
+version = "0.5.38"
 authors = [{family-names = "Bergmann", given-names = "Ronny", alias = "kellertuer", city = "Trondheim", affiliation = "Norwegian University of Science and Technology", country = "NO", email = "manopt@ronnybergmann.net", orcid = "https://orcid.org/0000-0001-8342-7218", website = "https://ronnybergmann.net"}]
 
 [workspace]

src/plans/proximal_gradient_plan.jl

@@ -403,6 +403,8 @@ A functor for backtracking line search in proximal gradient methods.
 * `sufficient_decrease=0.5`: sufficient decrease parameter
 * `contraction_factor=0.5`: step size reduction factor
 * `strategy=:nonconvex`: backtracking strategy, either `:convex` or `:nonconvex`
+* `k_max=0.0`: an upper bound to the sectional curvatures of the manifold, only for the `:convex` strategy
+* `δ=1e-2`: parameter for backtracking in case `k_max > 0`, only for the `:convex` strategy
 """
 mutable struct ProximalGradientMethodBacktrackingStepsize{P, T} <: Stepsize
     initial_stepsize::T
@@ -413,6 +415,8 @@ mutable struct ProximalGradientMethodBacktrackingStepsize{P, T} <: Stepsize
     last_stepsize::T
     stop_when_stepsize_less::T
     warm_start_factor::T
+    k_max::T
+    δ::T
 
     function ProximalGradientMethodBacktrackingStepsize(
             M::AbstractManifold;
@@ -422,6 +426,8 @@ mutable struct ProximalGradientMethodBacktrackingStepsize{P, T} <: Stepsize
             strategy::Symbol = :nonconvex,
             stop_when_stepsize_less::T = 1.0e-8,
             warm_start_factor::T = 1.0,
+            k_max::T = 0.0,
+            δ::T = 1.0e-2,
         ) where {T}
         0 < sufficient_decrease < 1 ||
             throw(DomainError(sufficient_decrease, "sufficient_decrease must be in (0, 1)"))
@@ -439,6 +445,9 @@ mutable struct ProximalGradientMethodBacktrackingStepsize{P, T} <: Stepsize
         warm_start_factor > 0 ||
             throw(DomainError(warm_start_factor, "warm_start_factor must be positive"))
 
+        (k_max > 0 && δ ≤ 0) &&
+            throw(DomainError(δ, "the tolerance parameter δ must be positive if k_max > 0"))
+
         p = rand(M)
         return new{typeof(p), T}(
             initial_stepsize,
@@ -449,6 +458,8 @@ mutable struct ProximalGradientMethodBacktrackingStepsize{P, T} <: Stepsize
             initial_stepsize,
             stop_when_stepsize_less,
             warm_start_factor,
+            k_max,
+            δ
         )
     end
 end
@@ -465,6 +476,8 @@ function Base.show(io::IO, pgb::ProximalGradientMethodBacktrackingStepsize)
         sufficient_decrease=$(pgb.sufficient_decrease),
         strategy=$(pgb.strategy),
         warm_start_factor=$(pgb.warm_start_factor),
+        k_max=$(pgb.k_max),
+        δ=$(pgb.δ)
     )
     """
     return print(io, s)
@@ -522,8 +535,11 @@ function (s::ProximalGradientMethodBacktrackingStepsize)(
             g_p = get_cost_smooth(M, objective, p)
             g_q = get_cost_smooth(M, objective, candidate_point)
 
+
+            ζ_δ = s.k_max ≤ zero(eltype(s.k_max)) ? one(eltype(s.k_max)) : π / (2 + s.δ) * cot(π / (2 + s.δ))
+
             # Convex descent condition
-            if g_q <= g_p + inner(M, p, X, log_p_q) + (1 / 2λ) * squared_distance
+            if g_q <= g_p + inner(M, p, X, log_p_q) + (ζ_δ / 2λ) * squared_distance
                 s.last_stepsize = λ
                 return λ
             end
@@ -552,7 +568,7 @@ where ``G_{λ}(p) = (1/λ) * $(_tex(:log))_p(T_{λ}(p))`` is the gradient mappin
 For the convex case, the condition is:
 
 ```math
-g(T_{λ}(p)) ≤ g(p) + ⟨$(_tex(:grad)) g(p), $(_tex(:log))_p T_{λ}(p)⟩ + $(_tex(:frac, "1", "2λ")) $(_math(:distance))^2(p, T_{λ}(p))
+g(T_{λ}(p)) ≤ g(p) + ⟨$(_tex(:grad)) g(p), $(_tex(:log))_p T_{λ}(p)⟩ + $(_tex(:frac, "ζ_δ", "2λ")) $(_math(:distance))^2(p, T_{λ}(p))
 ```
 
 Returns a stepsize `λ` that satisfies the specified condition.

src/solvers/convex_bundle_method.jl

@@ -337,6 +337,7 @@ function show(io::IO, cbms::ConvexBundleMethodState)
     * bundle cap size:                                  $(cbms.bundle_cap)
     * current bundle size:                              $(length(cbms.bundle))
     * curvature upper bound:                            $(cbms.k_max)
+    * curvature lower bound:                            $(cbms.k_min)
     * descent test parameter:                           $(cbms.m)
     * diameter:                                         $(cbms.diameter)
     * inverse retraction:                               $(cbms.inverse_retraction_method)

test/solvers/test_proximal_gradient_method.jl

@@ -22,6 +22,20 @@ using Manopt, Manifolds, Test, ManifoldDiff
         # Trigger manually
         sc1.at_iteration = 2
         @test length(get_reason(sc1)) > 0
+
+        pgms.last_stepsize = 1.0
+        g(M, q) = distance(M, q, p)^2
+        grad_g(M, q) = -2 * log(M, q, p)
+        h(M, q) = distance(M, q, p)
+        prox_h(M, λ, q) = ManifoldDiff.prox_distance(M, λ, p, q, 1)
+        f(M, q) = g(M, q) + h(M, q)
+        ob = ManifoldProximalGradientObjective(f, g, grad_g, prox_h)
+        mp = DefaultManoptProblem(M, ob)
+
+        @test sc1.last_change < sc1.threshold
+        @test sc1.at_iteration == 2
+        @test sc1(mp, pgms, 2) == true
+        pgms.last_stepsize = 0.0
     end
     @testset "Proximal Gradient Backtracking" begin
         pgb = Manopt.ProximalGradientMethodBacktrackingStepsize(M)
@@ -84,6 +98,9 @@ using Manopt, Manifolds, Test, ManifoldDiff
         @test_throws DomainError Manopt.ProximalGradientMethodBacktrackingStepsize(
             M; warm_start_factor = -1.0
         )
+        @test_throws DomainError Manopt.ProximalGradientMethodBacktrackingStepsize(
+            M; initial_stepsize = 1.0, strategy = :convex, stop_when_stepsize_less = 2.0, k_max = 1.0, δ = -1.0
+        )
 
         @testset "Backtracking Warnings" begin
             dw1 = DebugWarnIfStepsizeCollapsed(:Once)
@@ -233,7 +250,9 @@ using Manopt, Manifolds, Test, ManifoldDiff
             inverse_retraction_method = ProjectionInverseRetraction(),
             stepsize = ProximalGradientMethodBacktracking(;
                 initial_stepsize = 1.0,
-                strategy = :convex
+                strategy = :convex,
+                k_max = 1.0,
+                δ = 1.0e-2,
             ),
             return_state = true
         )