QuantumKitHub · lkdvos · May 8, 2026 · May 7, 2026 · May 7, 2026 · May 8, 2026
diff --git a/docs/src/changelog.md b/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

diff --git a/docs/src/examples/bose_hubbard/index.md b/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.

diff --git a/docs/src/examples/bose_hubbard/main.ipynb b/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",

diff --git a/docs/src/examples/c4v_ctmrg/index.md b/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;
 ````

diff --git a/docs/src/examples/c4v_ctmrg/main.ipynb b/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;"
    ],

diff --git a/docs/src/examples/fermi_hubbard/index.md b/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

diff --git a/docs/src/examples/fermi_hubbard/main.ipynb b/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)"
    ]
   },
   {

diff --git a/docs/src/examples/heisenberg/index.md b/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

diff --git a/docs/src/examples/heisenberg/main.ipynb b/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

diff --git a/docs/src/examples/heisenberg_su/index.md b/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,
 );

diff --git a/docs/src/examples/heisenberg_su/main.ipynb b/docs/src/examples/heisenberg_su/main.ipynb
@@ -152,8 +152,8 @@
     "env, = leading_boundary(\n",
     "    env₀,\n",
     "    peps;\n",
-    "    alg = :sequential,\n",
-    "    projector_alg = :fullinfinite,\n",
+    "    alg = :SequentialCTMRG,\n",
+    "    projector_alg = :FullInfiniteProjector,\n",
     "    tol = 1.0e-10,\n",
     "    trunc = trunc_env,\n",
     ");"

diff --git a/docs/src/examples/hubbard_su/index.md b/docs/src/examples/hubbard_su/index.md
@@ -133,7 +133,7 @@ normalize!.(peps.A, Inf)
 env = CTMRGEnv(wts)
 for χ in [χenv₀, χenv]
     global env, = leading_boundary(
-        env, peps; alg = :sequential, tol = 1.0e-8, maxiter = 50, trunc = truncrank(χ)
+        env, peps; alg = :SequentialCTMRG, tol = 1.0e-8, maxiter = 50, trunc = truncrank(χ)
     )
 end
 ````

diff --git a/docs/src/examples/hubbard_su/main.ipynb b/docs/src/examples/hubbard_su/main.ipynb
@@ -143,7 +143,7 @@
     "env = CTMRGEnv(wts)\n",
     "for χ in [χenv₀, χenv]\n",
     "    global env, = leading_boundary(\n",
-    "        env, peps; alg = :sequential, tol = 1.0e-8, maxiter = 50, trunc = truncrank(χ)\n",
+    "        env, peps; alg = :SequentialCTMRG, tol = 1.0e-8, maxiter = 50, trunc = truncrank(χ)\n",
     "    )\n",
     "end"
    ],

diff --git a/docs/src/examples/j1j2_su/index.md b/docs/src/examples/j1j2_su/index.md
@@ -314,7 +314,7 @@ normalize!.(peps.A, Inf) ## normalize each PEPS tensor by largest element
 trunc_env = truncerror(; atol = 1.0e-10) & truncrank(χenv)
 Espace = Vect[U1Irrep](0 => χenv ÷ 2, 1 // 2 => χenv ÷ 4, -1 // 2 => χenv ÷ 4)
 env₀ = CTMRGEnv(rand, Float64, peps, Espace)
-env, = leading_boundary(env₀, peps; tol = 1.0e-10, alg = :sequential, trunc = trunc_env);
+env, = leading_boundary(env₀, peps; tol = 1.0e-10, alg = :SequentialCTMRG, trunc = trunc_env);
 E = expectation_value(peps, H, env) / (Nr * Nc)
 ````
 

diff --git a/docs/src/examples/j1j2_su/main.ipynb b/docs/src/examples/j1j2_su/main.ipynb
@@ -144,7 +144,7 @@
     "trunc_env = truncerror(; atol = 1.0e-10) & truncrank(χenv)\n",
     "Espace = Vect[U1Irrep](0 => χenv ÷ 2, 1 // 2 => χenv ÷ 4, -1 // 2 => χenv ÷ 4)\n",
     "env₀ = CTMRGEnv(rand, Float64, peps, Espace)\n",
-    "env, = leading_boundary(env₀, peps; tol = 1.0e-10, alg = :sequential, trunc = trunc_env);\n",
+    "env, = leading_boundary(env₀, peps; tol = 1.0e-10, alg = :SequentialCTMRG, trunc = trunc_env);\n",
     "E = expectation_value(peps, H, env) / (Nr * Nc)"
    ]
   },

diff --git a/docs/src/examples/xxz/index.md b/docs/src/examples/xxz/index.md
@@ -84,9 +84,9 @@ From this point onwards it's business as usual: Create an initial PEPS and envir
 (using the symmetric spaces), specify the algorithmic parameters and optimize:
 
 ````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 = 85, 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 = 85, ls_maxiter = 3, ls_maxfg = 3)
 
 peps₀ = InfinitePEPS(randn, ComplexF64, physical_spaces, virtual_spaces)
 env₀, = leading_boundary(CTMRGEnv(peps₀, V_env), peps₀; boundary_alg...);

diff --git a/docs/src/examples/xxz/main.ipynb b/docs/src/examples/xxz/main.ipynb
@@ -130,9 +130,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 = 85, ls_maxiter = 3, ls_maxfg = 3)\n",
+    "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 = 85, ls_maxiter = 3, ls_maxfg = 3)\n",
     "\n",
     "peps₀ = InfinitePEPS(randn, ComplexF64, physical_spaces, virtual_spaces)\n",
     "env₀, = leading_boundary(CTMRGEnv(peps₀, V_env), peps₀; boundary_alg...);"

diff --git a/docs/src/man/multithreading.md b/docs/src/man/multithreading.md
@@ -15,6 +15,6 @@ set_scheduler!
 By default, the OhMyThreads machinery will be used to parallelize certain parts of the code, if Julia started with multiple threads.
 Cases where PEPSKit can leverage parallel threads are:
 
-- CTMRG steps using the `:simultaneous` scheme, where we parallelize over all unit cell coordinates and spatial directions
+- CTMRG steps using the `:SimultaneousCTMRG` scheme, where we parallelize over all unit cell coordinates and spatial directions
 - The reverse pass of these parallelized CTMRG steps
 - Evaluating expectation values of observables, where we parallelize over the terms contained in the [`LocalOperator`](@ref PEPSKit.LocalOperator)
diff --git a/docs/src/man/precompilation.md b/docs/src/man/precompilation.md
@@ -58,8 +58,8 @@ using PrecompileTools
 
     # Algorithmic settings
     ctmrg_algs = [
-        SimultaneousCTMRG(; maxiter, projector_alg=:halfinfinite, verbosity),
-        SequentialCTMRG(; maxiter, projector_alg=:halfinfinite, verbosity),
+        SimultaneousCTMRG(; maxiter, projector_alg=:HalfInfiniteProjector, verbosity),
+        SequentialCTMRG(; maxiter, projector_alg=:HalfInfiniteProjector, verbosity),
     ]
     gradient_algs = [
         LinSolver(; solver_alg=BiCGStab(; tol=gradtol)),

diff --git a/examples/bose_hubbard/main.jl b/examples/bose_hubbard/main.jl
@@ -87,9 +87,9 @@ optimization framework in the usual way to find the ground state. So, we first s
 algorithms and their tolerances:
 """
 
-boundary_alg = (; tol = 1.0e-8, alg = :simultaneous, trunc = (; alg = :fixedspace))
-gradient_alg = (; tol = 1.0e-6, maxiter = 10, alg = :linsolver)
-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)
+optimizer_alg = (; tol = 1.0e-4, alg = :LBFGS, maxiter = 150, ls_maxiter = 2, ls_maxfg = 2);
 
 md"""
 !!! note
@@ -98,7 +98,7 @@ md"""
     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.