Rename algorithm symbols (#376)

* Rename all algorithm symbols with correct capitalization according to their structs

* Rename `:iterative` to `:GKL`

Author: pbrehmer

docs/src/changelog.md

@@ -52,7 +52,7 @@ When releasing a new version, move the "Unreleased" changes to a new version sec
 ### Changed
 
 - A unified interface for Trotter-based time evolution algorithms. The old `su_iter`, `simpleupdate` functions should be replaced by `timestep`, `time_evolve` respectively
-- Default fixed-point gradient algorithm changed to `:eigsolver`
+- Default fixed-point gradient algorithm changed to `:EigSolver`
 - BoundaryMPS methods now have their own custom transfer functions, avoiding a double conjugation and twist issues for fermions
 - `physicalspace` and related functions now correctly handle periodic indexing for infinite networks
 - Updated compatibility with TensorKit v0.15

docs/src/examples/bose_hubbard/index.md

@@ -99,9 +99,9 @@ optimization framework in the usual way to find the ground state. So, we first s
 algorithms and their tolerances:
 
 ````julia
-boundary_alg = (; tol = 1.0e-8, alg = :simultaneous, trunc = (; alg = :fixedspace))
-gradient_alg = (; tol = 1.0e-6, maxiter = 10, alg = :linsolver, iterscheme = :fixed)
-optimizer_alg = (; tol = 1.0e-4, alg = :lbfgs, maxiter = 150, ls_maxiter = 2, ls_maxfg = 2);
+boundary_alg = (; tol = 1.0e-8, alg = :SimultaneousCTMRG, trunc = (; alg = :FixedSpaceTruncation))
+gradient_alg = (; tol = 1.0e-6, maxiter = 10, alg = :LinSolver, iterscheme = :fixed)
+optimizer_alg = (; tol = 1.0e-4, alg = :LBFGS, maxiter = 150, ls_maxiter = 2, ls_maxfg = 2);
 ````
 
 !!! note
@@ -110,7 +110,7 @@ optimizer_alg = (; tol = 1.0e-4, alg = :lbfgs, maxiter = 150, ls_maxiter = 2, ls
     the `boundary_alg`, `gradient_alg` and `optimizer_alg` settings. There rarely is a
     general-purpose set of settings which will always work, so instead one has to adjust
     the simulation settings for each specific application. For example, it might help to
-    switch between the CTMRG flavors `alg=:simultaneous` and `alg=:sequential` to
+    switch between the CTMRG flavors `alg=:SimultaneousCTMRG` and `alg=:SequentialCTMRG` to
     improve convergence. Of course the tolerances of the algorithms and their subalgorithms
     also have to be compatible. For more details on the available options, see the
     [`fixedpoint`](@ref) docstring.

docs/src/examples/bose_hubbard/main.ipynb

@@ -156,9 +156,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "boundary_alg = (; tol = 1.0e-8, alg = :simultaneous, trunc = (; alg = :fixedspace))\n",
-    "gradient_alg = (; tol = 1.0e-6, maxiter = 10, alg = :linsolver, iterscheme = :fixed)\n",
-    "optimizer_alg = (; tol = 1.0e-4, alg = :lbfgs, maxiter = 150, ls_maxiter = 2, ls_maxfg = 2);"
+    "boundary_alg = (; tol = 1.0e-8, alg = :SimultaneousCTMRG, trunc = (; alg = :FixedSpaceTruncation))\n",
+    "gradient_alg = (; tol = 1.0e-6, maxiter = 10, alg = :LinSolver, iterscheme = :fixed)\n",
+    "optimizer_alg = (; tol = 1.0e-4, alg = :LBFGS, maxiter = 150, ls_maxiter = 2, ls_maxfg = 2);"
    ]
   },
   {
@@ -171,7 +171,7 @@
     "    the `boundary_alg`, `gradient_alg` and `optimizer_alg` settings. There rarely is a\n",
     "    general-purpose set of settings which will always work, so instead one has to adjust\n",
     "    the simulation settings for each specific application. For example, it might help to\n",
-    "    switch between the CTMRG flavors `alg=:simultaneous` and `alg=:sequential` to\n",
+    "    switch between the CTMRG flavors `alg=:SimultaneousCTMRG` and `alg=:SequentialCTMRG` to\n",
     "    improve convergence. Of course the tolerances of the algorithms and their subalgorithms\n",
     "    also have to be compatible. For more details on the available options, see the\n",
     "    [`fixedpoint`](@ref) docstring.\n",

docs/src/examples/c4v_ctmrg/index.md

@@ -87,10 +87,10 @@ env_random_c4v = initialize_random_c4v_env(peps₀, ComplexSpace(χ));
 ````
 
 Then contracting the PEPS using $C_{4v}$ CTMRG is as easy as just calling [`leading_boundary`](@ref)
-but passing the initial PEPS and environment as well as the `alg = :c4v` keyword argument:
+but passing the initial PEPS and environment as well as the `alg = :C4vCTMRG` keyword argument:
 
 ````julia
-env₀, = leading_boundary(env_random_c4v, peps₀; alg = :c4v, tol = 1.0e-10);
+env₀, = leading_boundary(env_random_c4v, peps₀; alg = :C4vCTMRG, tol = 1.0e-10);
 ````
 
 ````
@@ -103,13 +103,13 @@ env₀, = leading_boundary(env_random_c4v, peps₀; alg = :c4v, tol = 1.0e-10);
 
 We now take `peps₀` and `env₀` as a starting point for a gradient-based energy
 minimization where we contract using $C_{4v}$ CTMRG such that the energy gradient will also
-exhibit $C_{4v}$ symmetry. For that, we call `fixedpoint` and specify `alg = :c4v`
+exhibit $C_{4v}$ symmetry. For that, we call `fixedpoint` and specify `alg = :C4vCTMRG`
 as the boundary contraction algorithm:
 
 ````julia
 H = real(heisenberg_XYZ_c4v(InfiniteSquare())) # make Hamiltonian real-valued
 peps, env, E, = fixedpoint(
-    H, peps₀, env₀; optimizer_alg = (; tol = 1.0e-4), boundary_alg = (; alg = :c4v),
+    H, peps₀, env₀; optimizer_alg = (; tol = 1.0e-4), boundary_alg = (; alg = :C4vCTMRG),
 );
 ````
 
@@ -184,13 +184,13 @@ and optimization times, and also has vastly improved GPU performance. Notably, i
 that QR-CTMRG converges to the same fixed point as regular $C_{4v}$ CTMRG.
 
 In PEPSKit terms, using QR-CTMRG just amounts to switching out the projector algorithm that is
-used by the [`C4vCTMRG`](@ref) algorithm to `projector_alg = :c4v_qr` (as opposed to `:c4v_eigh`).
+used by the [`C4vCTMRG`](@ref) algorithm to `projector_alg = :C4vQRProjector` (as opposed to `:C4vEighProjector`).
 QR-CTMRG tends to need significantly more iterations to converge while still being much faster,
 hence we need to increase `maxiter`:
 
 ````julia
 env_qr₀, = leading_boundary(
-    env_random_c4v, peps; alg = :c4v, projector_alg = :c4v_qr, maxiter = 500,
+    env_random_c4v, peps; alg = :C4vCTMRG, projector_alg = :C4vQRProjector, maxiter = 500,
 );
 ````
 
@@ -201,7 +201,7 @@ env_qr₀, = leading_boundary(
 
 ````
 
-To optimize using QR-CTMRG we proceed analogously by specifiying `projector_alg = :c4v_qr` and
+To optimize using QR-CTMRG we proceed analogously by specifiying `projector_alg = :C4vQRProjector` and
 increasing the `maxiter` when setting the boundary algorithm parameters. We make sure to supply
 the `env_qr₀` initial environment because it does not use `DiagonalTensorMap`s as its corner
 type (only regular `eigh`-based $C_{4v}$ CTMRG produces diagonal corners):
@@ -210,8 +210,8 @@ type (only regular `eigh`-based $C_{4v}$ CTMRG produces diagonal corners):
 peps_qr, env_qr, E_qr, = fixedpoint(
     H, peps₀, env_qr₀;
     optimizer_alg = (; tol = 1.0e-4),
-    boundary_alg = (; alg = :c4v, projector_alg = :c4v_qr, maxiter = 500),
-    gradient_alg = (; alg = :linsolver)
+    boundary_alg = (; alg = :C4vCTMRG, projector_alg = :C4vQRProjector, maxiter = 500),
+    gradient_alg = (; alg = :LinSolver)
 );
 @show (E_qr - E_ref) / E_ref;
 ````

docs/src/examples/c4v_ctmrg/main.ipynb

@@ -132,15 +132,15 @@
    "cell_type": "markdown",
    "source": [
     "Then contracting the PEPS using $C_{4v}$ CTMRG is as easy as just calling `leading_boundary`\n",
-    "but passing the initial PEPS and environment as well as the `alg = :c4v` keyword argument:"
+    "but passing the initial PEPS and environment as well as the `alg = :C4vCTMRG` keyword argument:"
    ],
    "metadata": {}
   },
   {
    "outputs": [],
    "cell_type": "code",
    "source": [
-    "env₀, = leading_boundary(env_random_c4v, peps₀; alg = :c4v, tol = 1.0e-10);"
+    "env₀, = leading_boundary(env_random_c4v, peps₀; alg = :C4vCTMRG, tol = 1.0e-10);"
    ],
    "metadata": {},
    "execution_count": null
@@ -152,7 +152,7 @@
     "\n",
     "We now take `peps₀` and `env₀` as a starting point for a gradient-based energy\n",
     "minimization where we contract using $C_{4v}$ CTMRG such that the energy gradient will also\n",
-    "exhibit $C_{4v}$ symmetry. For that, we call `fixedpoint` and specify `alg = :c4v`\n",
+    "exhibit $C_{4v}$ symmetry. For that, we call `fixedpoint` and specify `alg = :C4vCTMRG`\n",
     "as the boundary contraction algorithm:"
    ],
    "metadata": {}
@@ -163,7 +163,7 @@
    "source": [
     "H = real(heisenberg_XYZ_c4v(InfiniteSquare())) # make Hamiltonian real-valued\n",
     "peps, env, E, = fixedpoint(\n",
-    "    H, peps₀, env₀; optimizer_alg = (; tol = 1.0e-4), boundary_alg = (; alg = :c4v),\n",
+    "    H, peps₀, env₀; optimizer_alg = (; tol = 1.0e-4), boundary_alg = (; alg = :C4vCTMRG),\n",
     ");"
    ],
    "metadata": {},
@@ -226,7 +226,7 @@
     "that QR-CTMRG converges to the same fixed point as regular $C_{4v}$ CTMRG.\n",
     "\n",
     "In PEPSKit terms, using QR-CTMRG just amounts to switching out the projector algorithm that is\n",
-    "used by the `C4vCTMRG` algorithm to `projector_alg = :c4v_qr` (as opposed to `:c4v_eigh`).\n",
+    "used by the `C4vCTMRG` algorithm to `projector_alg = :C4vQRProjector` (as opposed to `:C4vEighProjector`).\n",
     "QR-CTMRG tends to need significantly more iterations to converge while still being much faster,\n",
     "hence we need to increase `maxiter`:"
    ],
@@ -237,7 +237,7 @@
    "cell_type": "code",
    "source": [
     "env_qr₀, = leading_boundary(\n",
-    "    env_random_c4v, peps; alg = :c4v, projector_alg = :c4v_qr, maxiter = 500,\n",
+    "    env_random_c4v, peps; alg = :C4vCTMRG, projector_alg = :C4vQRProjector, maxiter = 500,\n",
     ");"
    ],
    "metadata": {},
@@ -246,7 +246,7 @@
   {
    "cell_type": "markdown",
    "source": [
-    "To optimize using QR-CTMRG we proceed analogously by specifiying `projector_alg = :c4v_qr` and\n",
+    "To optimize using QR-CTMRG we proceed analogously by specifiying `projector_alg = :C4vQRProjector` and\n",
     "increasing the `maxiter` when setting the boundary algorithm parameters. We make sure to supply\n",
     "the `env_qr₀` initial environment because it does not use `DiagonalTensorMap`s as its corner\n",
     "type (only regular `eigh`-based $C_{4v}$ CTMRG produces diagonal corners):"
@@ -260,8 +260,8 @@
     "peps_qr, env_qr, E_qr, = fixedpoint(\n",
     "    H, peps₀, env_qr₀;\n",
     "    optimizer_alg = (; tol = 1.0e-4),\n",
-    "    boundary_alg = (; alg = :c4v, projector_alg = :c4v_qr, maxiter = 500),\n",
-    "    gradient_alg = (; alg = :linsolver)\n",
+    "    boundary_alg = (; alg = :C4vCTMRG, projector_alg = :C4vQRProjector, maxiter = 500),\n",
+    "    gradient_alg = (; alg = :LinSolver)\n",
     ");\n",
     "@show (E_qr - E_ref) / E_ref;"
    ],

docs/src/examples/fermi_hubbard/index.md

@@ -81,13 +81,13 @@ Again, the procedure of ground state optimization is very similar to before. Fir
 define all algorithmic parameters:
 
 ````julia
-boundary_alg = (; tol = 1.0e-8, alg = :simultaneous, trunc = (; alg = :fixedspace))
-gradient_alg = (; tol = 1.0e-6, alg = :eigsolver, maxiter = 10, iterscheme = :fixed)
-optimizer_alg = (; tol = 1.0e-4, alg = :lbfgs, maxiter = 80, ls_maxiter = 3, ls_maxfg = 3)
+boundary_alg = (; tol = 1.0e-8, alg = :SimultaneousCTMRG, trunc = (; alg = :FixedSpaceTruncation))
+gradient_alg = (; tol = 1.0e-6, alg = :EigSolver, maxiter = 10, iterscheme = :fixed)
+optimizer_alg = (; tol = 1.0e-4, alg = :LBFGS, maxiter = 80, ls_maxiter = 3, ls_maxfg = 3)
 ````
 
 ````
-(tol = 0.0001, alg = :lbfgs, maxiter = 80, ls_maxiter = 3, ls_maxfg = 3)
+(tol = 0.0001, alg = :LBFGS, maxiter = 80, ls_maxiter = 3, ls_maxfg = 3)
 ````
 
 Second, we initialize a PEPS state and environment (which we converge) constructed from

docs/src/examples/fermi_hubbard/main.ipynb

@@ -129,9 +129,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "boundary_alg = (; tol = 1.0e-8, alg = :simultaneous, trunc = (; alg = :fixedspace))\n",
-    "gradient_alg = (; tol = 1.0e-6, alg = :eigsolver, maxiter = 10, iterscheme = :fixed)\n",
-    "optimizer_alg = (; tol = 1.0e-4, alg = :lbfgs, maxiter = 80, ls_maxiter = 3, ls_maxfg = 3)"
+    "boundary_alg = (; tol = 1.0e-8, alg = :SimultaneousCTMRG, trunc = (; alg = :FixedSpaceTruncation))\n",
+    "gradient_alg = (; tol = 1.0e-6, alg = :EigSolver, maxiter = 10, iterscheme = :fixed)\n",
+    "optimizer_alg = (; tol = 1.0e-4, alg = :LBFGS, maxiter = 80, ls_maxiter = 3, ls_maxfg = 3)"
    ]
   },
   {

docs/src/examples/heisenberg/index.md

@@ -74,7 +74,7 @@ arguments. To see a description of all arguments, see the docstring of
 specific tolerance and during the CTMRG run keep all index dimensions fixed:
 
 ````julia
-boundary_alg = (; tol = 1.0e-10, trunc = (; alg = :fixedspace));
+boundary_alg = (; tol = 1.0e-10, trunc = (; alg = :FixedSpaceTruncation));
 ````
 
 Let us also configure the optimizer algorithm. We are going to optimize the PEPS using the
@@ -83,7 +83,7 @@ the convergence tolerance (for the gradient norm) as well as the maximal number
 and the BFGS memory size (which is used to approximate the Hessian):
 
 ````julia
-optimizer_alg = (; alg = :lbfgs, tol = 1.0e-4, maxiter = 100, lbfgs_memory = 16);
+optimizer_alg = (; alg = :LBFGS, tol = 1.0e-4, maxiter = 100, lbfgs_memory = 16);
 ````
 
 Additionally, during optimization, we want to reuse the previous CTMRG environment to

docs/src/examples/heisenberg/main.ipynb

@@ -120,7 +120,7 @@
    "outputs": [],
    "cell_type": "code",
    "source": [
-    "boundary_alg = (; tol = 1.0e-10, trunc = (; alg = :fixedspace));"
+    "boundary_alg = (; tol = 1.0e-10, trunc = (; alg = :FixedSpaceTruncation));"
    ],
    "metadata": {},
    "execution_count": null
@@ -139,7 +139,7 @@
    "outputs": [],
    "cell_type": "code",
    "source": [
-    "optimizer_alg = (; alg = :lbfgs, tol = 1.0e-4, maxiter = 100, lbfgs_memory = 16);"
+    "optimizer_alg = (; alg = :LBFGS, tol = 1.0e-4, maxiter = 100, lbfgs_memory = 16);"
    ],
    "metadata": {},
    "execution_count": null

docs/src/examples/heisenberg_su/index.md

@@ -142,8 +142,8 @@ trunc_env = truncerror(; atol = 1.0e-10) & truncrank(χenv)
 env, = leading_boundary(
     env₀,
     peps;
-    alg = :sequential,
-    projector_alg = :fullinfinite,
+    alg = :SequentialCTMRG,
+    projector_alg = :FullInfiniteProjector,
     tol = 1.0e-10,
     trunc = trunc_env,
 );