Trying the new glossary in a slightly larger scale, it seems to work …

…well.

ext/ManoptManifoldsExt/ManoptManifoldsExt.jl

@@ -3,11 +3,11 @@ module ManoptManifoldsExt
 using ManifoldsBase: exp, log, ParallelTransport, vector_transport_to
 using Manopt
 using Manopt:
+    _tex,
+    _var,
     _l_refl,
-    _l_retr,
     _kw_retraction_method_default,
-    _kw_inverse_retraction_method_default,
-    _kw_X_default
+    _kw_inverse_retraction_method_default
 import Manopt:
     max_stepsize,
     alternating_gradient_descent,

ext/ManoptManifoldsExt/manifold_functions.jl

@@ -118,7 +118,7 @@ Reflect the point `x` from the manifold `M` at point `p`, given by
 $_l_refl
 ```
 
-where ``$_l_retr`` and ``$_l_retr^{-1}`` denote a retraction and an inverse
+where ``$(_tex(:retr))`` and ``$(_tex(:invretr))`` denote a retraction and an inverse
 retraction, respectively.
 This can also be done in place of `q`.
 
@@ -131,8 +131,8 @@ This can also be done in place of `q`.
 
 and for the `reflect!` additionally
 
-* $_kw_X_default
-  a temporary memory to compute the inverse retraction in place.
+$(_var(:Keyword, :X))
+  as temporary memory to compute the inverse retraction in place.
   otherwise this is the memory that would be allocated anyways.
 """
 function reflect(

src/documentation_glossary.jl

@@ -49,11 +49,18 @@ end
 
 # ---
 # LaTeX
-define!(:LaTeX, :Cal, (letter) -> raw"\mathcal " * "$letter")
-define!(:LaTeX, :frac, (a, b) -> raw"\frac" * "{$a}{$b}")
+define!(:LaTeX, :argmin, raw"\operatorname{arg\,min}")
 define!(:LaTeX, :bar, (letter) -> raw"\bar" * "$(letter)")
 define!(:LaTeX, :bigl, raw"\bigl")
 define!(:LaTeX, :bigr, raw"\bigr")
+define!(:LaTeX, :Cal, (letter) -> raw"\mathcal " * "$letter")
+define!(:LaTeX, :displaystyle, raw"\displaystyle")
+define!(:LaTeX, :frac, (a, b) -> raw"\frac" * "{$a}{$b}")
+define!(:LaTeX, :grad, raw"\operatorname{grad}")
+define!(:LaTeX, :Hess, raw"\operatorname{Hess}")
+define!(:LaTeX, :retr, raw"\operatorname{retr}")
+define!(:LaTeX, :invretr, raw"\operatorname{retr}^{-1}")
+define!(:LaTeX, :text, (letter) -> raw"\text{"*"$letter"*"}")
 _tex(args...; kwargs...) = glossary(:LaTeX, args...; kwargs...)
 # ---
 # Mathematics and semantic symbols
@@ -91,6 +98,11 @@ define!(
     (; M="M") ->
         "[`manifold_dimension`](@extref `ManifoldsBase.manifold_dimension-Tuple{AbstractManifold}`)$(length(M) > 0 ? "`($M)`" : "")",
 )
+define!(
+    :Link,
+    :AbstractManifold,
+    "[`AbstractManifold`](@extref `ManifoldsBase.AbstractManifold`)",
+)
 # ---
 # Variables
 # in fields, keyword arguments, parameters
@@ -106,8 +118,8 @@ _var(args...; kwargs...) = glossary(:Variable, args...; kwargs...)
 define!(
     :Variable,
     :Argument,
-    (s::Symbol, display="$s"; kwargs...) ->
-        "* `$(display)`: $(_var(s, :description;kwargs...))",
+    (s::Symbol, display="$s"; type=false, kwargs...) ->
+        "* `$(display)$(type ? "::$(_var(s, :type))" : "")`: $(_var(s, :description;kwargs...))",
 )
 define!(
     :Variable,
@@ -119,10 +131,28 @@ define!(
     :Variable,
     :Keyword,
     (s::Symbol, display="$s"; type=false, description::Bool=true, kwargs...) ->
-        "* `$(display)$(type ? _var(s, :type) : "")=`$(_var(s, :default;kwargs...))$(description ? ": $(_var(s, :description; kwargs...))" : "")",
+        "* `$(display)$(type ? "::$(_var(s, :type))" : "")=`$(_var(s, :default;kwargs...))$(description ? ": $(_var(s, :description; kwargs...))" : "")",
 )
 #
 # Actual variables
+
+define!(
+    :Variable,
+    :f,
+    :description,
+    (; M="M", p="p") ->
+        "a cost function ``f: $(_tex(:Cal, M))→ ℝ`` implemented as `($M, $p) -> v`",
+)
+
+define!(
+    :Variable,
+    :M,
+    :description,
+    (; M="M") ->
+        "a Riemannian manifold ``$(_tex(:Cal, M))``",
+)
+define!(:Variable, :M, :type, "`$(_link(:AbstractManifold))` ")
+
 define!(
     :Variable, :p, :description, (; M="M") -> "a point on the manifold ``$(_tex(:Cal, M))``"
 )
@@ -173,14 +203,17 @@ define!(
 """,
 )
 
+#
+#
+# Stopping Criteria
+define!(:StoppingCriterion, :Any, "[` | `](@ref StopWhenAny)")
+define!(:StoppingCriterion, :All, "[` & `](@ref StopWhenAll)")
+_sc(args...; kwargs...) = glossary(:StoppingCriterion, args...; kwargs...)
+
 # ---
 # Old strings
 
 # LateX symbols
-_l_ds = raw"\displaystyle"
-_l_argmin = raw"\operatorname{arg\,min}"
-_l_grad = raw"\operatorname{grad}"
-_l_Hess = raw"\operatorname{Hess}"
 _l_log = raw"\log"
 _l_prox = raw"\operatorname{prox}"
 _l_refl = raw"\operatorname{refl}_p(x) = \operatorname{retr}_p(-\operatorname{retr}^{-1}_p x)"
@@ -193,17 +226,12 @@ _l_Manifold(M="M") = _tex(:Cal, "M")
 _l_M = "$(_l_Manifold())"
 _l_TpM(p="p") = "T_{$p}$_l_M"
 _l_DΛ = "DΛ: T_{m}$(_math(:M)) → T_{Λ(m)}$(_l_Manifold("N"))"
-_l_grad_long = raw"\operatorname{grad} f: \mathcal M → T\mathcal M"
-_l_Hess_long = "$_l_Hess f(p)[⋅]: $(_l_TpM()) → $(_l_TpM())"
-_l_retr = raw"\operatorname{retr}"
-_l_retr_long = raw"\operatorname{retr}: T\mathcal M \to \mathcal M"
 _l_C_subset_M = "$(_tex(:Cal, "C")) ⊂ $(_tex(:Cal, "M"))"
-_l_txt(s) = "\\text{$s}"
 
 # Math terms
 _math_VT = raw"a vector transport ``T``"
-_math_inv_retr = "an inverse retraction ``$_l_retr^{-1}``"
-_math_retr = " a retraction $_l_retr"
+_math_inv_retr = "an inverse retraction ``$(_tex(:invretr))``"
+_math_retr = " a retraction $(_tex(:retr))"
 _math_reflect = raw"""
 ```math
   \operatorname{refl}_p(x) = \operatorname{retr}_p(-\operatorname{retr}^{-1}_p x),
@@ -241,19 +269,15 @@ the [`AbstractManifoldGradientObjective`](@ref) `gradient_objective` directly.
 """
 
 # Arguments
-_arg_f = raw"* `f`: a cost function ``f: \mathcal M→ℝ`` implemented as `(M, p) -> v`"
 _arg_grad_f = raw"""
 * `grad_f`: the gradient ``\operatorname{grad}f: \mathcal M → T\mathcal M`` of f
   as a function `(M, p) -> X` or a function `(M, X, p) -> X` computing `X` in-place
 """
 _arg_Hess_f = """
-* `Hess_f`: the Hessian ``$_l_Hess_long`` of f
+* `Hess_f`: the Hessian ``$(_tex(:Hess))_long`` of f
   as a function `(M, p, X) -> Y` or a function `(M, Y, p, X) -> Y` computing `Y` in-place
 """
-_arg_p = raw"* `p` an initial value `p` ``= p^{(0)} ∈ \mathcal M``"
-_arg_M = "* `M` a manifold ``$_l_M``"
 _arg_inline_M = "the manifold `M`"
-_arg_X = "* `X` a tangent vector"
 _arg_sub_problem = "* `sub_problem` a [`AbstractManoptProblem`](@ref) to specify a problem for a solver or a closed form solution function."
 _arg_sub_state = "* `sub_state` a [`AbstractManoptSolverState`](@ref) for the `sub_problem`."
 _arg_subgrad_f = raw"""
@@ -270,17 +294,13 @@ The obtained approximate minimizer ``p^*``.
 To obtain the whole final state of the solver, see [`get_solver_return`](@ref) for details, especially the `return_state=` keyword.
 """
 
-_sc_any = "[` | `](@ref StopWhenAny)"
-_sc_all = "[` & `](@ref StopWhenAll)"
-
 # Fields
 _field_at_iteration = "`at_iteration`: an integer indicating at which the stopping criterion last indicted to stop, which might also be before the solver started (`0`). Any negative value indicates that this was not yet the case; "
 _field_iterate = "`p`: the current iterate ``p=p^{(k)} ∈ $(_math(:M))``"
-_field_gradient = "`X`: the current gradient ``$(_l_grad)f(p^{(k)}) ∈ T_p$(_math(:M))``"
+_field_gradient = "`X`: the current gradient ``$(_tex(:grad))f(p^{(k)}) ∈ T_p$(_math(:M))``"
 _field_subgradient = "`X` : the current subgradient ``$(_l_subgrad)f(p^{(k)}) ∈ T_p$_l_M``"
-_field_inv_retr = "`inverse_retraction_method::`[`AbstractInverseRetractionMethod`](@extref `ManifoldsBase.AbstractInverseRetractionMethod`) : an inverse retraction ``$(_l_retr)^{-1}``"
-_field_p = raw"`p`, an initial value `p` ``= p^{(0)} ∈ \mathcal M``"
-_field_retr = "`retraction_method::`[`AbstractRetractionMethod`](@extref `ManifoldsBase.AbstractRetractionMethod`) : a retraction ``$(_l_retr_long)``"
+_field_inv_retr = "`inverse_retraction_method::`[`AbstractInverseRetractionMethod`](@extref `ManifoldsBase.AbstractInverseRetractionMethod`) : an inverse retraction ``$(_tex(:invretr))``"
+_field_retr = "`retraction_method::`[`AbstractRetractionMethod`](@extref `ManifoldsBase.AbstractRetractionMethod`) : a retraction ``$(_tex(:retr))``"
 _field_sub_problem = "`sub_problem::Union{`[`AbstractManoptProblem`](@ref)`, F}`: a manopt problem or a function for a closed form solution of the sub problem"
 _field_sub_state = "`sub_state::Union{`[`AbstractManoptSolverState`](@ref)`,`[`AbstractEvaluationType`](@ref)`}`: for a sub problem state which solver to use, for the closed form solution function, indicate, whether the closed form solution function works with [`AllocatingEvaluation`](@ref)) `(M, p, X) -> q` or with an [`InplaceEvaluation`](@ref)) `(M, q, p, X) -> q`"
 _field_stop = "`stop::`[`StoppingCriterion`](@ref) : a functor indicating when to stop and whether the algorithm has stopped"
@@ -296,7 +316,7 @@ _kw_evaluation = "specify whether the functions that return an array, for exampl
 _kw_evaluation_example = "For example `grad_f(M,p)` allocates, but `grad_f!(M, X, p)` computes the result in-place of `X`."
 
 _kw_inverse_retraction_method_default = "`inverse_retraction_method=`[`default_inverse_retraction_method`](@extref `ManifoldsBase.default_inverse_retraction_method-Tuple{AbstractManifold}`)`(M, typeof(p))`"
-_kw_inverse_retraction_method = "an inverse retraction ``$(_l_retr)^{-1}`` to use, see [the section on retractions and their inverses](@extref ManifoldsBase :doc:`retractions`)."
+_kw_inverse_retraction_method = "an inverse retraction ``$(_tex(:invretr))`` to use, see [the section on retractions and their inverses](@extref ManifoldsBase :doc:`retractions`)."
 
 _kw_others = raw"""
 All other keyword arguments are passed to [`decorate_state!`](@ref) for state decorators or
@@ -307,7 +327,7 @@ _kw_p_default = "`p=`$(Manopt._link(:rand))"
 _kw_p = raw"specify an initial value for the point `p`."
 
 _kw_retraction_method_default = raw"`retraction_method=`[`default_retraction_method`](@extref `ManifoldsBase.default_retraction_method-Tuple{AbstractManifold}`)`(M, typeof(p))`"
-_kw_retraction_method = "a retraction ``$(_l_retr)`` to use, see [the section on retractions](@extref ManifoldsBase :doc:`retractions`)."
+_kw_retraction_method = "a retraction ``$(_tex(:retr))`` to use, see [the section on retractions](@extref ManifoldsBase :doc:`retractions`)."
 
 _kw_stepsize = raw"a functor inheriting from [`Stepsize`](@ref) to determine a step size"
 

src/helpers/checks.jl

@@ -91,7 +91,7 @@ no plot is generated.
 # Keyword arguments
 
 * `check_vector=true`:
-  verify that ``$_l_grad f(p) ∈ $(_l_TpM())`` using `is_vector`.
+  verify that ``$(_tex(:grad))f(p) ∈ $(_l_TpM())`` using `is_vector`.
 * `exactness_tol=1e-12`:
   if all errors are below this tolerance, the gradient is considered to be exact
 * `io=nothing`:
@@ -170,13 +170,13 @@ no plot is generated.
 # Keyword arguments
 
 * `check_grad=true`:
-  verify that ``$_l_grad f(p) ∈ $(_l_TpM())``.
+  verify that ``$(_tex(:grad))f(p) ∈ $(_l_TpM())``.
 * `check_linearity=true`:
   verify that the Hessian is linear, see [`is_Hessian_linear`](@ref) using `a`, `b`, `X`, and `Y`
 * `check_symmetry=true`:
   verify that the Hessian is symmetric, see [`is_Hessian_symmetric`](@ref)
 * `check_vector=false`:
-  verify that `$_l_Hess f(p)[X] ∈ $(_l_TpM())`` using `is_vector`.
+  verify that `$(_tex(:Hess)) f(p)[X] ∈ $(_l_TpM())`` using `is_vector`.
 * `mode=:Default`:
   specify the mode for the verification; the default assumption is,
   that the retraction provided is of second order. Otherwise one can also verify the Hessian
@@ -194,7 +194,7 @@ no plot is generated.
 * `gradient=grad_f(M, p)`:
   instead of the gradient function you can also provide the gradient at `p` directly
 * `Hessian=Hess_f(M, p, X)`:
-  instead of the Hessian function you can provide the result of ``$_l_Hess f(p)[X]`` directly.
+  instead of the Hessian function you can provide the result of ``$(_tex(:Hess)) f(p)[X]`` directly.
   Note that evaluations of the Hessian might still be necessary for checking linearity and symmetry and/or when using `:CriticalPoint` mode.
 * `limits=(1e-8,1)`:
   specify the limits in the `log_range`

src/plans/augmented_lagrangian_plan.jl

@@ -69,7 +69,7 @@ additionally this gradient does accept a positional last argument to specify the
 for the internal gradient call of the constrained objective.
 
 based on the internal [`ConstrainedManifoldObjective`](@ref) and computes the gradient
-`$_l_grad $(_tex(:Cal, "L"))_{ρ}(p, μ, λ)``, see also [`AugmentedLagrangianCost`](@ref).
+`$(_tex(:grad))$(_tex(:Cal, "L"))_{ρ}(p, μ, λ)``, see also [`AugmentedLagrangianCost`](@ref).
 
 ## Fields
 

src/plans/cache.jl

@@ -5,7 +5,7 @@
      SimpleManifoldCachedObjective{O<:AbstractManifoldGradientObjective{E,TC,TG}, P, T,C} <: AbstractManifoldGradientObjective{E,TC,TG}
 
 Provide a simple cache for an [`AbstractManifoldGradientObjective`](@ref) that is for a given point `p` this cache
-stores a point `p` and a gradient ``$(_l_grad) f(p)`` in `X` as well as a cost value ``f(p)`` in `c`.
+stores a point `p` and a gradient ``$(_tex(:grad)) f(p)`` in `X` as well as a cost value ``f(p)`` in `c`.
 
 Both `X` and `c` are accompanied by booleans to keep track of their validity.
 

src/plans/conjugate_gradient_plan.jl

@@ -27,8 +27,8 @@ specify options for a conjugate gradient descent algorithm, that solves a
 
 # Fields
 
-* $_field_p
-* $_field_X
+$(_var(:Field, :p))
+$(_var(:Field, :X))
 * `δ`:                       the current descent direction, also a tangent vector
 * `β`:                       the current update coefficient rule, see .
 * `coefficient`:             function to determine the new `β`
@@ -52,7 +52,7 @@ The following fields from above <re keyword arguments
 * $(_kw_p_default): $(_kw_p)
 * `coefficient=[`ConjugateDescentCoefficient`](@ref)`()`
 * `stepsize=[`default_stepsize`](@ref)`(M, ConjugateGradientDescentState; retraction_method=retraction_method)`)
-* `stop=[`StopAfterIteration`](@ref)`(500)`$_sc_any[`StopWhenGradientNormLess`](@ref)`(1e-8)`)
+* `stop=[`StopAfterIteration`](@ref)`(500)`$(_sc(:Any))[`StopWhenGradientNormLess`](@ref)`(1e-8)`)
 * $_kw_retraction_method_default
 * $_kw_vector_transport_method_default
 

src/plans/conjugate_residual_plan.jl

@@ -106,7 +106,7 @@ evaluate the gradient of
 
 $(_doc_CR_cost)
 
-Which is ``$(_l_grad) f(X) = $(_tex(:Cal, "A"))[X]+b``. This can be computed in-place of `Y`.
+Which is ``$(_tex(:grad)) f(X) = $(_tex(:Cal, "A"))[X]+b``. This can be computed in-place of `Y`.
 """
 function get_gradient(TpM::TangentSpace, slso::SymmetricLinearSystemObjective, X)
     p = base_point(TpM)
@@ -141,7 +141,7 @@ evaluate the Hessian of
 
 $(_doc_CR_cost)
 
-Which is ``$(_l_Hess) f(X)[Y] = $(_tex(:Cal, "A"))[V]``. This can be computed in-place of `W`.
+Which is ``$(_tex(:Hess)) f(X)[Y] = $(_tex(:Cal, "A"))[V]``. This can be computed in-place of `W`.
 """
 function get_hessian(
     TpM::TangentSpace, slso::SymmetricLinearSystemObjective{AllocatingEvaluation}, X, V
@@ -204,7 +204,7 @@ Initialise the state with default values.
 * `Ad=copy(TpM, Ar)`
 * `α::R=0.0`
 * `β::R=0.0`
-* `stopping_criterion=`[`StopAfterIteration`](@ref)`($(_link(:manifold_dimension)))`$(_sc_any)[`StopWhenGradientNormLess`](@ref)`(1e-8)`
+* `stopping_criterion=`[`StopAfterIteration`](@ref)`($(_link(:manifold_dimension)))`$(_sc(:Any))[`StopWhenGradientNormLess`](@ref)`(1e-8)`
 
 # See also
 
@@ -292,7 +292,7 @@ Stop when re relative residual in the [`conjugate_residual`](@ref)
 is below a certain threshold, i.e.
 
 ```math
-$(_l_ds)$(_tex(:frac, _l_norm("r^{(k)"),"c")) ≤ ε,
+$(_tex(:displaystyle))$(_tex(:frac, _l_norm("r^{(k)"),"c")) ≤ ε,
 ```
 
 where ``c = $(_l_norm("b"))`` of the initial vector from the vector field in ``$(_tex(:Cal, "A"))(p)[X] + b(p) = 0_p``,

src/plans/gradient_plan.jl

@@ -557,12 +557,12 @@ This compute a Nesterov type update using the following steps, see [ZhangSra:201
 
 1. Compute the positive root ``α_k∈(0,1)`` of ``α^2 = h_k$(_tex(:bigl))((1-α_k)γ_k+α_k μ$(_tex(:bigr)))``.
 2. Set ``$(_tex(:bar, "γ"))_k+1 = (1-α_k)γ_k + α_kμ``
-3. ``y_k = $(_l_retr)_{p_k}\\Bigl(\\frac{α_kγ_k}{γ_k + α_kμ}$(_l_retr)^{-1}_{p_k}v_k \\Bigr)``
-4. ``x_{k+1} = $(_l_retr)_{y_k}(-h_k $(_l_grad)f(y_k))``
-5. ``v_{k+1} = $(_l_retr)_{y_k}\\Bigl(\\frac{(1-α_k)γ_k}{$(_tex(:bar, "γ"))_k}$(_l_retr)_{y_k}^{-1}(v_k) - \\frac{α_k}{$(_tex(:bar, "γ"))_{k+1}}$(_l_grad)f(y_k) \\Bigr)``
+3. ``y_k = $(_tex(:retr))_{p_k}\\Bigl(\\frac{α_kγ_k}{γ_k + α_kμ}$(_tex(:retr))^{-1}_{p_k}v_k \\Bigr)``
+4. ``x_{k+1} = $(_tex(:retr))_{y_k}(-h_k $(_tex(:grad))f(y_k))``
+5. ``v_{k+1} = $(_tex(:retr))_{y_k}\\Bigl(\\frac{(1-α_k)γ_k}{$(_tex(:bar, "γ"))_k}$(_tex(:retr))_{y_k}^{-1}(v_k) - \\frac{α_k}{$(_tex(:bar, "γ"))_{k+1}}$(_tex(:grad))f(y_k) \\Bigr)``
 6. ``γ_{k+1} = \\frac{1}{1+β_k}$(_tex(:bar, "γ"))_{k+1}``
 
-Then the direction from ``p_k`` to ``p_k+1`` by ``d = $(_l_retr)^{-1}_{p_k}p_{k+1}`` is returned.
+Then the direction from ``p_k`` to ``p_k+1`` by ``d = $(_tex(:invretr))_{p_k}p_{k+1}`` is returned.
 
 # Input
 

src/plans/hessian_plan.jl

@@ -216,7 +216,7 @@ _doc_ApproxHessian_step = raw"\operatorname{retr}_p(\frac{c}{\lVert X \rVert_p}X
 
 A functor to approximate the Hessian by a finite difference of gradient evaluation.
 
-Given a point `p` and a direction `X` and the gradient ``$(_l_grad) f(p)``
+Given a point `p` and a direction `X` and the gradient ``$(_tex(:grad)) f(p)``
 of a function ``f`` the Hessian is approximated as follows:
 let ``c`` be a stepsize, ``X ∈ $(_l_TpM())`` a tangent vector and ``q = $_doc_ApproxHessian_step``
 be a step in direction ``X`` of length ``c`` following a retraction

src/plans/interior_point_Newton_plan.jl

@@ -66,7 +66,7 @@ are used to fill in reasonable defaults for the keywords.
 
 # Input
 
-$(_arg_M)
+$(_var(:Argument, :M; type=true))
 * `cmo`:         a [`ConstrainedManifoldObjective`](@ref)
 $(_arg_sub_problem)
 $(_arg_sub_state)

src/plans/nonlinear_least_squares_plan.jl

@@ -172,7 +172,7 @@ The following fields are keyword arguments
 * `expect_zero_residual=false`
 * `initial_gradient=`$(_link(:zero_vector))
 * $_kw_retraction_method_default
-* `stopping_criterion=`[`StopAfterIteration`](@ref)`(200)`$_sc_any[`StopWhenGradientNormLess`](@ref)`(1e-12)`$_sc_any[`StopWhenStepsizeLess`](@ref)`(1e-12)`
+* `stopping_criterion=`[`StopAfterIteration`](@ref)`(200)`$(_sc(:Any))[`StopWhenGradientNormLess`](@ref)`(1e-12)`$(_sc(:Any))[`StopWhenStepsizeLess`](@ref)`(1e-12)`
 
 # See also
 

src/plans/proximal_plan.jl

@@ -139,7 +139,7 @@ stores options for the [`cyclic_proximal_point`](@ref) algorithm. These are the
 
 # Fields
 
-* $_field_p
+$(_var(:Field, :p))
 * $_field_stop
 * `λ`:         a function for the values of ``λ_k`` per iteration(cycle ``ì``
 * `oder_type`: whether to use a randomly permuted sequence (`:FixedRandomOrder`),

src/plans/quasi_newton_plan.jl

@@ -316,7 +316,7 @@ a basis ``$(_math_sequence("b", "i", "1", "n"))`` are determined by solving a li
 $_doc_QN_H_full_system
 
 where ``H_k`` is the matrix representing the operator with respect to the basis ``$(_math_sequence("b", "i", "1", "n"))``
-and ``\\widehat{$_l_grad} f(p_k)}`` represents the coordinates of the gradient of
+and ``\\widehat{$(_tex(:grad))} f(p_k)}`` represents the coordinates of the gradient of
 the objective function ``f`` in ``x_k`` with respect to the basis ``$(_math_sequence("b", "i", "1", "n"))``.
 If a method is chosen where Hessian inverse is approximated, the coordinates of the search
 direction ``η_k`` with respect to a basis ``$(_math_sequence("b", "i", "1", "n"))`` are obtained simply by
@@ -325,7 +325,7 @@ matrix-vector multiplication
 $_doc_QN_B_full_system
 
 where ``B_k`` is the matrix representing the operator with respect to the basis ``$(_math_sequence("b", "i", "1", "n"))``
-and `\\widehat{$_l_grad} f(p_k)}``. In the end, the search direction ``η_k`` is
+and `\\widehat{$(_tex(:grad))} f(p_k)}``. In the end, the search direction ``η_k`` is
 generated from the coordinates ``\\hat{eta_k}`` and the vectors of the basis ``$(_math_sequence("b", "i", "1", "n"))``
 in both variants.
 The [`AbstractQuasiNewtonUpdateRule`](@ref) indicates which quasi-Newton update rule is used.