Address remaining review comments

Author: leburgel

src/algorithms/optimization/peps_optimization.jl

@@ -195,9 +195,9 @@ function fixedpoint(
     if isnothing(alg.symmetrization)
         retract = peps_retract
     else
-        retract, symm_finalize! = symmetrize_retract_and_finalize!(alg.symmetrization)
-        fin! = finalize!  # Previous finalize!
-        finalize! = (x, f, g, numiter) -> fin!(symm_finalize!(x, f, g, numiter)..., numiter)
+        retract, finalize! = symmetrize_retract_and_finalize!(
+            alg.symmetrization, retract, finalize!
+        )
     end
 
     # :fixed mode compatibility
@@ -282,19 +282,19 @@ end
 Performs a norm-preserving retraction of an infinite PEPS `A = x[1]` along `η` with step
 size `α`, giving a new PEPS `A´`,
 ```math
-A' \\leftarrow \\cos \\left( α \\frac{||η||}{||A||} \\right) A + \\sin \\left( α \\frac{||η||}{||A||} \\right) ||A|| \\frac{η}{||η||},
+A' ← \\cos ( α ‖η‖ / ‖A‖ ) A + \\sin ( α ‖η‖ / ‖A‖ ) ‖A‖ η / ‖η‖,
 ```
 and corresponding directional derivative `ξ`,
 ```math
-ξ = \\cos \\left( α \\frac{||η||}{||A||} \\right) η - \\sin \\left( α \\frac{||η||}{||A||} \\right) ||η|| \\frac{A}{||A||},
+ξ = \\cos ( α ‖η‖ / ‖A‖ ) η - \\sin ( α ‖η‖ / ‖A‖ ) ‖η‖ A / ‖A‖,
 ```
-such that ``\\langle A', ξ \\rangle = 0`` and ``||A'|| = ||A||``.
+such that ``⟨ A', ξ ⟩ = 0`` and ``‖A'‖ = ‖A‖``.
 """
 function peps_retract(x, η, α)
     peps = x[1]
     env = deepcopy(x[2])
 
-    retractions = vector_retract.(unitcell(peps), unitcell(η), α)
+    retractions = norm_preserving_retract.(unitcell(peps), unitcell(η), α)
     peps´ = InfinitePEPS(map(first, retractions))
     ξ = InfinitePEPS(map(last, retractions))
 
@@ -308,19 +308,21 @@ Transports a direction at `A = x[1]` to a valid direction at `A´ = x´[1]` corr
 the norm-preserving retraction of `A` along `η` with step size `α`. In particular, starting
 from a direction `η` of the form
 ```math
-ξ = \\left\\langle \\frac{η}{||η||}, ξ \\right\\rangle \\frac{η}{||η||} + Δξ
+ξ = ⟨ η / ‖η‖, ξ ⟩ η / ‖η‖ + Δξ
 ```
-where ``\\langle Δξ, A \\rangle = \\langle Δξ, η \\rangle = 0``, it returns
+where ``⟨ Δξ, A ⟩ = ⟨ Δξ, η ⟩ = 0``, it returns
 ```math
-ξ(α) = \\left\\langle \\frac{η}{||η||}, ξ \\right \\rangle \\left( \\cos \\left( α \\frac{||η||}{||A||} \\right) \\frac{η}{||η||} - \\sin( \\left( α \\frac{||η||}{||A||} \\right) \\frac{A}{||A||} \\right) + Δξ
+ξ(α) = ⟨ η / ‖η‖, ξ ⟩ ( \\cos ( α ‖η‖ / ‖A‖ ) η / ‖η‖ - \\sin( ( α ‖η‖ / ‖A‖ ) A / ‖A‖ ) + Δξ
 ```
-such that ``||ξ(α)|| = ||ξ||, \\langle A', ξ(α) \\rangle = 0``.
+such that ``‖ξ(α)‖ = ‖ξ‖, ⟨ A', ξ(α) ⟩ = 0``.
 """
 function peps_transport!(ξ, x, η, α, x´)
     peps = x[1]
     peps´ = x´[1]
 
-    vector_transport!.(unitcell(ξ), unitcell(peps), unitcell(η), α, unitcell(peps´))
+    norm_preserving_transport!.(
+        unitcell(ξ), unitcell(peps), unitcell(η), α, unitcell(peps´)
+    )
 
     return ξ
 end
@@ -333,17 +335,22 @@ real_inner(_, η₁, η₂) = real(dot(η₁, η₂))
 
 Return the `retract` and `finalize!` function for symmetrizing the `peps` and `grad` tensors.
 """
-function symmetrize_retract_and_finalize!(symm::SymmetrizationStyle)
-    finf = function symmetrize_finalize!((peps, env), E, grad, _)
+function symmetrize_retract_and_finalize!(
+    symm::SymmetrizationStyle, retract=peps_retract, (finalize!)=OptimKit._finalize!
+)
+    function symmetrize_then_finalize!((peps, env), E, grad, numiter)
+        # symmetrize the gradient
         grad_symm = symmetrize!(grad, symm)
-        return (peps, env), E, grad_symm
+        # then finalize
+        return finalize!((peps, env), E, grad_symm, numiter)
     end
-    retf = function symmetrize_retract((peps, env), η, α)
-        peps_symm = deepcopy(peps)
-        peps_symm.A .+= η.A .* α
-        env′ = deepcopy(env)
-        symmetrize!(peps_symm, symm)
-        return (peps_symm, env′), η
+    function retract_then_symmetrize((peps, env), η, α)
+        # retract
+        (peps´, env´), ξ = retract((peps, env), η, α)
+        # symmetrize retracted point and directional derivative
+        peps´_symm = symmetrize!(peps´, symm)
+        ξ_symm = symmetrize!(ξ, symm)
+        return (peps´_symm, env′), ξ_symm
     end
-    return retf, finf
+    return retract_then_symmetrize, symmetrize_then_finalize!
 end

src/utility/retractions.jl

@@ -3,20 +3,25 @@ Utilities for preserving the norm of (VectorInterface-compliant) vectors during
 =#
 
 """
-    vector_retract(A, η, α)
+    norm_preserving_retract(A, η, α)
 
 Performs a norm-preserving retraction of vector `A` along the direction `η` with step size
 `α`, giving a new vector `A´`,
 ```math
-A' \\leftarrow \\cos \\left( α \\frac{||η||}{||A||} \\right) A + \\sin \\left( α \\frac{||η||}{||A||} \\right) ||A|| \\frac{η}{||η||},
+A' ← \\cos ( α ‖η‖ / ‖A‖ ) A + \\sin ( α ‖η‖ / ‖A‖ ) ‖A‖ η / ‖η‖,
 ```
 and corresponding directional derivative `ξ`,
 ```math
-ξ = \\cos \\left( α \\frac{||η||}{||A||} \\right) η - \\sin \\left( α \\frac{||η||}{||A||} \\right) ||η|| \\frac{A}{||A||},
+ξ = \\cos ( α ‖η‖ / ‖A‖ ) η - \\sin ( α ‖η‖ / ‖A‖ ) ‖η‖ A / ‖A‖,
 ```
-such that ``\\langle A', ξ \\rangle = 0`` and ``||A'|| = ||A||``.
+such that ``⟨ A', ξ ⟩ = 0`` and ``‖A'‖ = ‖A‖``.
+
+!!! note
+    The vectors `A` and `η` should satisfy the interface specified by
+    [VectorInterface.jl](https://github.com/Jutho/VectorInterface.jl)
+
 """
-function vector_retract(A, η, α)
+function norm_preserving_retract(A, η, α)
     n_A = norm(A)
     n_η = norm(η)
     sn, cs = sincos(α * n_η / n_A)
@@ -28,21 +33,26 @@ function vector_retract(A, η, α)
 end
 
 """
-    vector_transport!(ξ, A, η, α, A′)
+    norm_preserving_transport!(ξ, A, η, α, A′)
 
 Transports a direction `ξ` at `A` to a valid direction at `A´` corresponding to
 the norm-preserving retraction of `A` along `η` with step size `α`. In particular, starting
 from a direction `η` of the form
 ```math
 ξ = ⟨ η / ‖η‖, ξ ⟩ η / ‖η‖ + Δξ
 ```
-where ``\\langle Δξ, A \\rangle = \\langle Δξ, η \\rangle = 0``, it returns
+where ``⟨ Δξ, A ⟩ = ⟨ Δξ, η ⟩ = 0``, it returns
 ```math
-ξ(α) = \\left\\langle \\frac{η}{||η||}, ξ \\right \\rangle \\left( \\cos \\left( α \\frac{||η||}{||A||} \\right) \\frac{η}{||η||} - \\sin( \\left( α \\frac{||η||}{||A||} \\right) \\frac{A}{||A||} \\right) + Δξ
+ξ(α) = ⟨ η / ‖η‖, ξ ⟩ ( \\cos ( α ‖η‖ / ‖A‖ ) η / ‖η‖ - \\sin( ( α ‖η‖ / ‖A‖ ) A / ‖A‖ ) + Δξ
 ```
-such that ``||ξ(α)|| = ||ξ||, \\langle A', ξ(α) \\rangle = 0``.
+such that ``‖ξ(α)‖ = ‖ξ‖, ⟨ A', ξ(α) ⟩ = 0``.
+
+!!! note
+    The vectors `A` and `η` should satisfy the interface specified by
+    [VectorInterface.jl](https://github.com/Jutho/VectorInterface.jl)
+
 """
-function vector_transport!(ξ, A, η, α, A´)
+function norm_preserving_transport!(ξ, A, η, α, A´)
     n_A = norm(A)
     n_η = norm(η)
     sn, cs = sincos(α * n_η / n_A)

test/utility/retractions.jl

@@ -25,9 +25,9 @@ Vpepss = [ℂ^4, U1Space(0 => 2, -1 => 1, 1 => 1)]
     add!(η, normalized_A, -inner(normalized_A, η))
     add!(ζ, normalized_A, -inner(normalized_A, ζ))
 
-    A´, ξ = PEPSKit.vector_retract(A, η, α)
+    A´, ξ = PEPSKit.norm_preserving_retract(A, η, α)
     @test norm(A´) ≈ norm(A) rtol = 1e-12
 
-    PEPSKit.vector_transport!(ζ, A, η, α, A´)
+    PEPSKit.norm_preserving_transport!(ζ, A, η, α, A´)
     @test inner(ζ, A´) ≈ 0 atol = 1e-12
 end