data/varipeps/ctmrg/routine.py

from functools import partial
import enum

import numpy as np
from scipy.sparse.linalg import LinearOperator, eigs

import jax
import jax.numpy as jnp
import jax.scipy as jsp
from jax import jit, custom_vjp, vjp, tree_util
from jax.lax import cond, while_loop
import jax.debug as jdebug

from varipeps import varipeps_config, varipeps_global_state
from varipeps.config import Grad_Fixed_Point_Method
from varipeps.peps import PEPS_Tensor, PEPS_Tensor_Split_Transfer, PEPS_Unit_Cell
from varipeps.utils.debug_print import debug_print
from .absorption import do_absorption_step, do_absorption_step_split_transfer
from .triangular_absorption import do_absorption_step_triangular

from typing import Sequence, Tuple, List, Optional


@enum.unique
class CTM_Enum(enum.IntEnum):
    C1 = enum.auto()
    C2 = enum.auto()
    C3 = enum.auto()
    C4 = enum.auto()
    T1 = enum.auto()
    T2 = enum.auto()
    T3 = enum.auto()
    T4 = enum.auto()
    T1_ket = enum.auto()
    T1_bra = enum.auto()
    T2_ket = enum.auto()
    T2_bra = enum.auto()
    T3_ket = enum.auto()
    T3_bra = enum.auto()
    T4_ket = enum.auto()
    T4_bra = enum.auto()
    C5 = enum.auto()
    C6 = enum.auto()
    T1a = enum.auto()
    T1b = enum.auto()
    T2a = enum.auto()
    T2b = enum.auto()
    T3a = enum.auto()
    T3b = enum.auto()
    T4a = enum.auto()
    T4b = enum.auto()
    T5a = enum.auto()
    T5b = enum.auto()
    T6a = enum.auto()
    T6b = enum.auto()


class CTMRGNotConvergedError(Exception):
    """
    Exception if the CTM routine does not converge.
    """

    pass


class CTMRGGradientNotConvergedError(Exception):
    """
    Exception if the custom rule for the gradient of the the CTM routine does
    not converge.
    """

    pass


@partial(jit, static_argnums=(2,), inline=True)
def _calc_corner_svds(
    peps_tensors: List[PEPS_Tensor],
    old_corner_svd: jnp.ndarray,
    tensor_shape: Optional[Tuple[int, int, int]],
) -> jnp.ndarray:
    if tensor_shape is None:
        step_corner_svd = jnp.zeros_like(old_corner_svd)
    else:
        step_corner_svd = jnp.zeros(tensor_shape, dtype=jnp.float64)

    for ti, t in enumerate(peps_tensors):
        C1_svd = jnp.linalg.svd(t.C1, full_matrices=False, compute_uv=False)
        step_corner_svd = step_corner_svd.at[ti, 0, : C1_svd.shape[0]].set(
            C1_svd, indices_are_sorted=True, unique_indices=True
        )

        C2_svd = jnp.linalg.svd(t.C2, full_matrices=False, compute_uv=False)
        step_corner_svd = step_corner_svd.at[ti, 1, : C2_svd.shape[0]].set(
            C2_svd, indices_are_sorted=True, unique_indices=True
        )

        C3_svd = jnp.linalg.svd(t.C3, full_matrices=False, compute_uv=False)
        step_corner_svd = step_corner_svd.at[ti, 2, : C3_svd.shape[0]].set(
            C3_svd, indices_are_sorted=True, unique_indices=True
        )

        C4_svd = jnp.linalg.svd(t.C4, full_matrices=False, compute_uv=False)
        step_corner_svd = step_corner_svd.at[ti, 3, : C4_svd.shape[0]].set(
            C4_svd, indices_are_sorted=True, unique_indices=True
        )

    return step_corner_svd


@partial(jit, static_argnums=(2,), inline=True)
def _calc_corner_svds_triangular(
    peps_tensors: List[PEPS_Tensor],
    old_corner_svd: jnp.ndarray,
    tensor_shape: Optional[Tuple[int, int, int]],
) -> jnp.ndarray:
    if tensor_shape is None:
        step_corner_svd = jnp.zeros_like(old_corner_svd)
    else:
        step_corner_svd = jnp.zeros(tensor_shape, dtype=jnp.float64)

    for ti, t in enumerate(peps_tensors):
        for ni, name in enumerate(
            (
                "C1",
                "C2",
                "C3",
                "C4",
                "C5",
                "C6",
                "T1a",
                "T1b",
                "T2a",
                "T2b",
                "T3a",
                "T3b",
                "T4a",
                "T4b",
                "T5a",
                "T5b",
                "T6a",
                "T6b",
            )
        ):
            # get environment tensor and reshape it into a matrix
            env_tensor = getattr(peps_tensors[ti], name)
            env_matrix = env_tensor.reshape(
                (
                    env_tensor.shape[0] * env_tensor.shape[1],
                    env_tensor.shape[2] * env_tensor.shape[3],
                )
            )

            # compute singular values
            singular_values = jnp.linalg.svd(
                env_matrix, full_matrices=False, compute_uv=False
            )
            step_corner_svd = step_corner_svd.at[
                ti, ni, : singular_values.shape[0]
            ].set(singular_values, indices_are_sorted=True, unique_indices=True)

    return step_corner_svd


@partial(jit, static_argnums=(3,), inline=True)
def _is_element_wise_converged(
    old_peps_tensors: List[PEPS_Tensor],
    new_peps_tensors: List[PEPS_Tensor],
    eps: float,
    split_transfer: bool = False,
) -> Tuple[bool, float, Optional[List[Tuple[int, CTM_Enum, float]]]]:
    result = 0

    if split_transfer:
        measure = jnp.zeros((len(old_peps_tensors), 12), dtype=jnp.float64)
    else:
        measure = jnp.zeros((len(old_peps_tensors), 8), dtype=jnp.float64)

    verbose_data = []

    for ti in range(len(old_peps_tensors)):
        old_shape = old_peps_tensors[ti].C1.shape
        new_shape = new_peps_tensors[ti].C1.shape
        diff = jnp.abs(
            new_peps_tensors[ti].C1[: old_shape[0], : old_shape[1]]
            - old_peps_tensors[ti].C1[: new_shape[0], : new_shape[1]]
        )
        result += jnp.sum(diff > eps)
        measure = measure.at[ti, 0].set(
            jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
        )
        verbose_data.append((ti, CTM_Enum.C1, jnp.amax(diff)))

        old_shape = old_peps_tensors[ti].C2.shape
        new_shape = new_peps_tensors[ti].C2.shape
        diff = jnp.abs(
            new_peps_tensors[ti].C2[: old_shape[0], : old_shape[1]]
            - old_peps_tensors[ti].C2[: new_shape[0], : new_shape[1]]
        )
        result += jnp.sum(diff > eps)
        measure = measure.at[ti, 1].set(
            jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
        )
        verbose_data.append((ti, CTM_Enum.C2, jnp.amax(diff)))

        old_shape = old_peps_tensors[ti].C3.shape
        new_shape = new_peps_tensors[ti].C4.shape
        diff = jnp.abs(
            new_peps_tensors[ti].C3[: old_shape[0], : old_shape[1]]
            - old_peps_tensors[ti].C3[: new_shape[0], : new_shape[1]]
        )
        result += jnp.sum(diff > eps)
        measure = measure.at[ti, 2].set(
            jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
        )
        verbose_data.append((ti, CTM_Enum.C3, jnp.amax(diff)))

        old_shape = old_peps_tensors[ti].C4.shape
        new_shape = new_peps_tensors[ti].C4.shape
        diff = jnp.abs(
            new_peps_tensors[ti].C4[: old_shape[0], : old_shape[1]]
            - old_peps_tensors[ti].C4[: new_shape[0], : new_shape[1]]
        )
        result += jnp.sum(diff > eps)
        measure = measure.at[ti, 3].set(
            jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
        )
        verbose_data.append((ti, CTM_Enum.C4, jnp.amax(diff)))

        if split_transfer:
            old_shape = old_peps_tensors[ti].T1_ket.shape
            new_shape = new_peps_tensors[ti].T1_ket.shape
            diff = jnp.abs(
                new_peps_tensors[ti].T1_ket[
                    : old_shape[0], : old_shape[1], : old_shape[2]
                ]
                - old_peps_tensors[ti].T1_ket[
                    : new_shape[0], : new_shape[1], : new_shape[2]
                ]
            )
            result += jnp.sum(diff > eps)
            measure = measure.at[ti, 4].set(
                jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
            )
            verbose_data.append((ti, CTM_Enum.T1_ket, jnp.amax(diff)))

            old_shape = old_peps_tensors[ti].T1_bra.shape
            new_shape = new_peps_tensors[ti].T1_bra.shape
            diff = jnp.abs(
                new_peps_tensors[ti].T1_bra[
                    : old_shape[0], : old_shape[1], : old_shape[2]
                ]
                - old_peps_tensors[ti].T1_bra[
                    : new_shape[0], : new_shape[1], : new_shape[2]
                ]
            )
            result += jnp.sum(diff > eps)
            measure = measure.at[ti, 5].set(
                jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
            )
            verbose_data.append((ti, CTM_Enum.T1_bra, jnp.amax(diff)))

            old_shape = old_peps_tensors[ti].T2_ket.shape
            new_shape = new_peps_tensors[ti].T2_ket.shape
            diff = jnp.abs(
                new_peps_tensors[ti].T2_ket[
                    : old_shape[0], : old_shape[1], : old_shape[2]
                ]
                - old_peps_tensors[ti].T2_ket[
                    : new_shape[0], : new_shape[1], : new_shape[2]
                ]
            )
            result += jnp.sum(diff > eps)
            measure = measure.at[ti, 6].set(
                jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
            )
            verbose_data.append((ti, CTM_Enum.T2_ket, jnp.amax(diff)))

            old_shape = old_peps_tensors[ti].T2_bra.shape
            new_shape = new_peps_tensors[ti].T2_bra.shape
            diff = jnp.abs(
                new_peps_tensors[ti].T2_bra[
                    : old_shape[0], : old_shape[1], : old_shape[2]
                ]
                - old_peps_tensors[ti].T2_bra[
                    : new_shape[0], : new_shape[1], : new_shape[2]
                ]
            )
            result += jnp.sum(diff > eps)
            measure = measure.at[ti, 7].set(
                jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
            )
            verbose_data.append((ti, CTM_Enum.T2_bra, jnp.amax(diff)))

            old_shape = old_peps_tensors[ti].T3_ket.shape
            new_shape = new_peps_tensors[ti].T3_ket.shape
            diff = jnp.abs(
                new_peps_tensors[ti].T3_ket[
                    : old_shape[0], : old_shape[1], : old_shape[2]
                ]
                - old_peps_tensors[ti].T3_ket[
                    : new_shape[0], : new_shape[1], : new_shape[2]
                ]
            )
            result += jnp.sum(diff > eps)
            measure = measure.at[ti, 8].set(
                jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
            )
            verbose_data.append((ti, CTM_Enum.T3_ket, jnp.amax(diff)))

            old_shape = old_peps_tensors[ti].T3_bra.shape
            new_shape = new_peps_tensors[ti].T3_bra.shape
            diff = jnp.abs(
                new_peps_tensors[ti].T3_bra[
                    : old_shape[0], : old_shape[1], : old_shape[2]
                ]
                - old_peps_tensors[ti].T3_bra[
                    : new_shape[0], : new_shape[1], : new_shape[2]
                ]
            )
            result += jnp.sum(diff > eps)
            measure = measure.at[ti, 9].set(
                jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
            )
            verbose_data.append((ti, CTM_Enum.T3_bra, jnp.amax(diff)))

            old_shape = old_peps_tensors[ti].T4_ket.shape
            new_shape = new_peps_tensors[ti].T4_ket.shape
            diff = jnp.abs(
                new_peps_tensors[ti].T4_ket[
                    : old_shape[0], : old_shape[1], : old_shape[2]
                ]
                - old_peps_tensors[ti].T4_ket[
                    : new_shape[0], : new_shape[1], : new_shape[2]
                ]
            )
            result += jnp.sum(diff > eps)
            measure = measure.at[ti, 10].set(
                jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
            )
            verbose_data.append((ti, CTM_Enum.T4_ket, jnp.amax(diff)))

            old_shape = old_peps_tensors[ti].T4_bra.shape
            new_shape = new_peps_tensors[ti].T4_bra.shape
            diff = jnp.abs(
                new_peps_tensors[ti].T4_bra[
                    : old_shape[0], : old_shape[1], : old_shape[2]
                ]
                - old_peps_tensors[ti].T4_bra[
                    : new_shape[0], : new_shape[1], : new_shape[2]
                ]
            )
            result += jnp.sum(diff > eps)
            measure = measure.at[ti, 11].set(
                jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
            )
            verbose_data.append((ti, CTM_Enum.T4_bra, jnp.amax(diff)))
        else:
            old_shape = old_peps_tensors[ti].T1.shape
            new_shape = new_peps_tensors[ti].T1.shape
            diff = jnp.abs(
                new_peps_tensors[ti].T1[
                    : old_shape[0], : old_shape[1], : old_shape[2], : old_shape[3]
                ]
                - old_peps_tensors[ti].T1[
                    : new_shape[0], : new_shape[1], : new_shape[2], : new_shape[3]
                ]
            )
            result += jnp.sum(diff > eps)
            measure = measure.at[ti, 4].set(
                jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
            )
            verbose_data.append((ti, CTM_Enum.T1, jnp.amax(diff)))

            old_shape = old_peps_tensors[ti].T2.shape
            new_shape = new_peps_tensors[ti].T2.shape
            diff = jnp.abs(
                new_peps_tensors[ti].T2[
                    : old_shape[0], : old_shape[1], : old_shape[2], : old_shape[3]
                ]
                - old_peps_tensors[ti].T2[
                    : new_shape[0], : new_shape[1], : new_shape[2], : new_shape[3]
                ]
            )
            result += jnp.sum(diff > eps)
            measure = measure.at[ti, 5].set(
                jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
            )
            verbose_data.append((ti, CTM_Enum.T2, jnp.amax(diff)))

            old_shape = old_peps_tensors[ti].T3.shape
            new_shape = new_peps_tensors[ti].T3.shape
            diff = jnp.abs(
                new_peps_tensors[ti].T3[
                    : old_shape[0], : old_shape[1], : old_shape[2], : old_shape[3]
                ]
                - old_peps_tensors[ti].T3[
                    : new_shape[0], : new_shape[1], : new_shape[2], : new_shape[3]
                ]
            )
            result += jnp.sum(diff > eps)
            measure = measure.at[ti, 6].set(
                jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
            )
            verbose_data.append((ti, CTM_Enum.T3, jnp.amax(diff)))

            old_shape = old_peps_tensors[ti].T4.shape
            new_shape = new_peps_tensors[ti].T4.shape
            diff = jnp.abs(
                new_peps_tensors[ti].T4[
                    : old_shape[0], : old_shape[1], : old_shape[2], : old_shape[3]
                ]
                - old_peps_tensors[ti].T4[
                    : new_shape[0], : new_shape[1], : new_shape[2], : new_shape[3]
                ]
            )
            result += jnp.sum(diff > eps)
            measure = measure.at[ti, 7].set(
                jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
            )
            verbose_data.append((ti, CTM_Enum.T4, jnp.amax(diff)))

    return result == 0, jnp.linalg.norm(measure), verbose_data


@partial(jit, inline=True)
def _is_element_wise_converged_triangular(
    old_peps_tensors: List[PEPS_Tensor],
    new_peps_tensors: List[PEPS_Tensor],
    eps: float,
):
    result = 0

    measure = jnp.zeros((len(old_peps_tensors), 18), dtype=jnp.float64)

    verbose_data = []

    for ti in range(len(old_peps_tensors)):
        for ni, name in enumerate(
            (
                "C1",
                "C2",
                "C3",
                "C4",
                "C5",
                "C6",
                "T1a",
                "T1b",
                "T2a",
                "T2b",
                "T3a",
                "T3b",
                "T4a",
                "T4b",
                "T5a",
                "T5b",
                "T6a",
                "T6b",
            )
        ):
            old_shape = getattr(old_peps_tensors[ti], name).shape
            new_shape = getattr(new_peps_tensors[ti], name).shape
            diff = jnp.abs(
                getattr(new_peps_tensors[ti], name)[
                    : old_shape[0], : old_shape[1], : old_shape[2], : old_shape[3]
                ]
                - getattr(old_peps_tensors[ti], name)[
                    : new_shape[0], : new_shape[1], : new_shape[2], : new_shape[3]
                ]
            )
            result += jnp.sum(diff > eps)
            measure = measure.at[ti, ni].set(
                jnp.linalg.norm(diff), indices_are_sorted=True, unique_indices=True
            )
            verbose_data.append((ti, getattr(CTM_Enum, name), jnp.amax(diff)))

    return result == 0, jnp.linalg.norm(measure), verbose_data


def print_verbose(verbose_data, *, ad=False):
    if ad:
        message = "Custom VJP: Verbose: ti {}, CTM tensor {}, Diff {}"
    else:
        message = "CTMRG: Verbose: ti {}, CTM tensor {}, Diff {}"
    for ti, ctm_enum_i, diff in verbose_data:
        debug_print(
            message,
            ti,
            CTM_Enum(ctm_enum_i).name,
            diff,
        )


@jit
def _ctmrg_body_func(carry):
    (
        w_tensors,
        w_unitcell_last_step,
        converged,
        last_corner_svd,
        eps,
        count,
        elementwise_conv,
        norm_smallest_S,
        state,
        config,
    ) = carry

    if w_unitcell_last_step.is_triangular_peps():
        w_unitcell, norm_smallest_S = do_absorption_step_triangular(
            w_tensors, w_unitcell_last_step, config, state
        )
    elif w_unitcell_last_step.is_split_transfer():
        w_unitcell, norm_smallest_S = do_absorption_step_split_transfer(
            w_tensors, w_unitcell_last_step, config, state
        )
    else:
        w_unitcell, norm_smallest_S = do_absorption_step(
            w_tensors, w_unitcell_last_step, config, state
        )

    def elementwise_func(old, new, old_corner, conv_eps, config):
        if w_unitcell_last_step.is_triangular_peps():
            converged, measure, verbose_data = _is_element_wise_converged_triangular(
                old,
                new,
                conv_eps,
            )
            return converged, measure, verbose_data, old_corner

        converged, measure, verbose_data = _is_element_wise_converged(
            old,
            new,
            conv_eps,
            split_transfer=w_unitcell.is_split_transfer(),
        )
        return converged, measure, verbose_data, old_corner

    def corner_svd_func(old, new, old_corner, conv_eps, config):
        if w_unitcell_last_step.is_triangular_peps():
            verbose_data = (
                [(jnp.array(0), jnp.array(0), jnp.array(0.0))] * 18 * len(w_tensors)
            )
        elif w_unitcell_last_step.is_split_transfer():
            verbose_data = (
                [(jnp.array(0), jnp.array(0), jnp.array(0.0))] * 12 * len(w_tensors)
            )
        else:
            verbose_data = (
                [(jnp.array(0), jnp.array(0), jnp.array(0.0))] * 8 * len(w_tensors)
            )

        if old_corner is None:
            return (
                False,
                jnp.nan,
                verbose_data,
                old_corner,
            )

        if w_unitcell_last_step.is_triangular_peps():
            corner_svd = _calc_corner_svds_triangular(new, old_corner, None)
        else:
            corner_svd = _calc_corner_svds(new, old_corner, None)

        measure = jnp.linalg.norm(corner_svd - old_corner)
        converged = measure < conv_eps
        return (
            converged,
            measure,
            verbose_data,
            corner_svd,
        )

    converged, measure, verbose_data, corner_svd = cond(
        elementwise_conv,
        elementwise_func,
        corner_svd_func,
        w_unitcell_last_step.get_unique_tensors(),
        w_unitcell.get_unique_tensors(),
        last_corner_svd,
        eps,
        config,
    )

    if config.ctmrg_print_steps:
        debug_print("CTMRG: {}: {}", count, measure)
        if config.ctmrg_verbose_output:
            jax.debug.callback(print_verbose, verbose_data, ordered=True)

    count += 1

    return (
        w_tensors,
        w_unitcell,
        converged,
        corner_svd,
        eps,
        count,
        elementwise_conv,
        norm_smallest_S,
        state,
        config,
    )


@jit
def _ctmrg_while_wrapper(start_carry):
    def cond_func(carry):
        _, _, converged, _, _, count, _, _, _, config = carry
        return jnp.logical_not(converged) & (count < config.ctmrg_max_steps)

    (
        _,
        working_unitcell,
        converged,
        _,
        _,
        end_count,
        _,
        norm_smallest_S,
        _,
        _,
    ) = while_loop(cond_func, _ctmrg_body_func, start_carry)

    return working_unitcell, converged, end_count, norm_smallest_S


def calc_ctmrg_env(
    peps_tensors: Sequence[jnp.ndarray],
    unitcell: PEPS_Unit_Cell,
    *,
    eps: Optional[float] = None,
    enforce_elementwise_convergence: Optional[bool] = None,
    _return_truncation_eps: bool = False,
) -> PEPS_Unit_Cell:
    """
    Calculate the new converged CTMRG tensors for the unit cell. The function
    updates the environment all iPEPS tensors in the unit cell according to the
    periodic structure.

    Args:
      peps_tensors (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        The sequence of unique PEPS tensors the unitcell consists of.
      unitcell (:obj:`~varipeps.peps.PEPS_Unit_Cell`):
        The unitcell to work on.
    Keyword args:
      eps (:obj:`float`):
        The convergence criterion.
      enforce_elementwise_convergence (obj:`bool`):
        Enforce elementwise convergence of the CTM tensors instead of only
        convergence of the singular values of the corners.
    Returns:
      :obj:`~varipeps.peps.PEPS_Unit_Cell`:
        New instance of the unitcell with all updated converged CTMRG tensors of
        all elements of the unitcell.
    """
    eps = eps if eps is not None else varipeps_config.ctmrg_convergence_eps
    enforce_elementwise_convergence = (
        enforce_elementwise_convergence
        if enforce_elementwise_convergence is not None
        else varipeps_config.ctmrg_enforce_elementwise_convergence
    )
    init_corner_singular_vals = None

    if enforce_elementwise_convergence:
        last_step_tensors = unitcell.get_unique_tensors()
    else:
        if unitcell.is_triangular_peps():
            shape_corner_svd = (
                unitcell.get_len_unique_tensors(),
                18,
                unitcell[0, 0][0][0].chi * unitcell[0, 0][0][0].D[0],
            )
            init_corner_singular_vals = _calc_corner_svds_triangular(
                unitcell.get_unique_tensors(), None, shape_corner_svd
            )
        else:
            shape_corner_svd = (
                unitcell.get_len_unique_tensors(),
                4,
                unitcell[0, 0][0][0].chi,
            )
            init_corner_singular_vals = _calc_corner_svds(
                unitcell.get_unique_tensors(), None, shape_corner_svd
            )

    initial_unitcell = unitcell
    working_unitcell = unitcell
    varipeps_global_state.ctmrg_effective_truncation_eps = None

    norm_smallest_S = jnp.nan
    already_tried_chi = {working_unitcell[0, 0][0][0].chi}

    best_chi = 0
    best_result = None
    best_norm_smallest_S = None
    best_truncation_eps = None
    have_been_increased = False

    while True:
        tmp_count = 0
        corner_singular_vals = None

        while tmp_count < varipeps_config.ctmrg_max_steps and (
            (
                not working_unitcell.is_triangular_peps()
                and any(
                    getattr(i, j).shape[0] != i.chi or getattr(i, j).shape[1] != i.chi
                    for i in working_unitcell.get_unique_tensors()
                    for j in ("C1", "C2", "C3", "C4")
                )
            )
            or (
                working_unitcell.is_split_transfer()
                and any(
                    getattr(i, j).shape[0] != i.interlayer_chi
                    for i in working_unitcell.get_unique_tensors()
                    for j in ("T1_bra", "T2_ket", "T3_bra", "T4_ket")
                )
            )
            or (
                working_unitcell.is_triangular_peps()
                and any(
                    getattr(i, j).shape[0] != i.chi or getattr(i, j).shape[3] != i.chi
                    for i in working_unitcell.get_unique_tensors()
                    for j in (
                        "C1",
                        "C2",
                        "C3",
                        "C4",
                        "C5",
                        "C6",
                        "T1a",
                        "T1b",
                        "T2a",
                        "T2b",
                        "T3a",
                        "T3b",
                        "T4a",
                        "T4b",
                        "T5a",
                        "T5b",
                        "T6a",
                        "T6b",
                    )
                )
            )
        ):
            (
                _,
                working_unitcell,
                _,
                corner_singular_vals,
                _,
                tmp_count,
                _,
                norm_smallest_S,
                _,
                _,
            ) = _ctmrg_body_func(
                (
                    peps_tensors,
                    working_unitcell,
                    False,
                    init_corner_singular_vals,
                    eps,
                    tmp_count,
                    enforce_elementwise_convergence,
                    jnp.inf,
                    varipeps_global_state,
                    varipeps_config,
                )
            )

        if tmp_count < varipeps_config.ctmrg_max_steps:
            working_unitcell, converged, end_count, norm_smallest_S = (
                _ctmrg_while_wrapper(
                    (
                        peps_tensors,
                        working_unitcell,
                        False,
                        (
                            corner_singular_vals
                            if corner_singular_vals is not None
                            else init_corner_singular_vals
                        ),
                        eps,
                        tmp_count,
                        enforce_elementwise_convergence,
                        jnp.inf,
                        varipeps_global_state,
                        varipeps_config,
                    )
                )
            )
        else:
            converged = False
            end_count = tmp_count

        if converged and (
            working_unitcell[0, 0][0][0].chi > best_chi or best_result is None
        ):
            best_chi = working_unitcell[0, 0][0][0].chi
            best_result = working_unitcell
            best_norm_smallest_S = norm_smallest_S
            best_truncation_eps = varipeps_global_state.ctmrg_effective_truncation_eps

        current_truncation_eps = (
            varipeps_config.ctmrg_truncation_eps
            if varipeps_global_state.ctmrg_effective_truncation_eps is None
            else varipeps_global_state.ctmrg_effective_truncation_eps
        )

        if (
            varipeps_config.ctmrg_heuristic_increase_chi
            and norm_smallest_S > varipeps_config.ctmrg_heuristic_increase_chi_threshold
            and working_unitcell[0, 0][0][0].chi < working_unitcell[0, 0][0][0].max_chi
        ):
            new_chi = (
                working_unitcell[0, 0][0][0].chi
                + varipeps_config.ctmrg_heuristic_increase_chi_step_size
            )
            if new_chi > working_unitcell[0, 0][0][0].max_chi:
                new_chi = working_unitcell[0, 0][0][0].max_chi

            if not new_chi in already_tried_chi:
                working_unitcell = working_unitcell.change_chi(new_chi)
                initial_unitcell = initial_unitcell.change_chi(new_chi)

                # reinitialize corner singular values
                if not enforce_elementwise_convergence:
                    if working_unitcell.is_triangular_peps():
                        shape_corner_svd = (
                            working_unitcell.get_len_unique_tensors(),
                            18,
                            working_unitcell[0, 0][0][0].chi
                            * working_unitcell[0, 0][0][0].D[0],
                        )
                        init_corner_singular_vals = _calc_corner_svds_triangular(
                            working_unitcell.get_unique_tensors(),
                            None,
                            shape_corner_svd,
                        )
                    else:
                        shape_corner_svd = (
                            working_unitcell.get_len_unique_tensors(),
                            4,
                            working_unitcell[0, 0][0][0].chi,
                        )
                        init_corner_singular_vals = _calc_corner_svds(
                            working_unitcell.get_unique_tensors(),
                            None,
                            shape_corner_svd,
                        )

                if varipeps_config.ctmrg_print_steps:
                    debug_print(
                        "CTMRG: Increasing chi to {} since smallest SVD Norm was {}.",
                        new_chi,
                        norm_smallest_S,
                    )

                already_tried_chi.add(new_chi)

                have_been_increased = True

                continue
        elif varipeps_config.ctmrg_heuristic_decrease_chi and (
            (
                norm_smallest_S < current_truncation_eps
                and working_unitcell[0, 0][0][0].chi > 2
            )
            or (
                not converged
                and not have_been_increased
                and norm_smallest_S
                < varipeps_config.ctmrg_heuristic_increase_chi_threshold
            )
        ):
            new_chi = (
                working_unitcell[0, 0][0][0].chi
                - varipeps_config.ctmrg_heuristic_decrease_chi_step_size
            )
            if new_chi < 2:
                new_chi = 2

            if not new_chi in already_tried_chi:
                working_unitcell = working_unitcell.change_chi(new_chi)

                if varipeps_config.ctmrg_print_steps:
                    debug_print(
                        "CTMRG: Decreasing chi to {} since smallest SVD Norm was {} or routine did not converge.",
                        new_chi,
                        norm_smallest_S,
                    )

                already_tried_chi.add(new_chi)

                continue

        if (
            varipeps_config.ctmrg_increase_truncation_eps
            and end_count == varipeps_config.ctmrg_max_steps
            and not converged
        ):
            new_truncation_eps = (
                current_truncation_eps
                * varipeps_config.ctmrg_increase_truncation_eps_factor
            )
            if (
                new_truncation_eps
                <= varipeps_config.ctmrg_increase_truncation_eps_max_value
            ):
                if varipeps_config.ctmrg_print_steps:
                    debug_print(
                        "CTMRG: Increasing SVD truncation eps to {}.",
                        new_truncation_eps,
                    )
                varipeps_global_state.ctmrg_effective_truncation_eps = (
                    new_truncation_eps
                )
                working_unitcell = initial_unitcell
                already_tried_chi = {working_unitcell[0, 0][0][0].chi}
                continue

        break

    if _return_truncation_eps:
        last_truncation_eps = varipeps_global_state.ctmrg_effective_truncation_eps

    varipeps_global_state.ctmrg_effective_truncation_eps = None

    if not converged and best_result is not None:
        working_unitcell = best_result
        norm_smallest_S = best_norm_smallest_S
        converged = True
        last_truncation_eps = best_truncation_eps

    if (
        varipeps_config.ctmrg_fail_if_not_converged
        and end_count == varipeps_config.ctmrg_max_steps
        and not converged
    ):
        raise CTMRGNotConvergedError

    if _return_truncation_eps:
        return working_unitcell, last_truncation_eps, norm_smallest_S

    return working_unitcell, norm_smallest_S


@custom_vjp
def calc_ctmrg_env_custom_rule(
    peps_tensors: Sequence[jnp.ndarray],
    unitcell: PEPS_Unit_Cell,
    _return_truncation_eps: bool = False,
) -> PEPS_Unit_Cell:
    """
    Wrapper function of :obj:`~varipeps.ctmrg.routine.calc_ctmrg_env` which
    enables the use of the custom VJP for the calculation of the gradient.

    Args:
      peps_tensors (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        The sequence of unique PEPS tensors the unitcell consists of.
      unitcell (:obj:`~varipeps.peps.PEPS_Unit_Cell`):
        The unitcell to work on.
    Returns:
      :obj:`~varipeps.peps.PEPS_Unit_Cell`:
        New instance of the unitcell with all updated converged CTMRG tensors of
        all elements of the unitcell.
    """
    return calc_ctmrg_env(
        peps_tensors,
        unitcell,
        enforce_elementwise_convergence=True,
        _return_truncation_eps=_return_truncation_eps,
    )


def calc_ctmrg_env_fwd(
    peps_tensors: Sequence[jnp.ndarray],
    unitcell: PEPS_Unit_Cell,
    _return_truncation_eps: bool = False,
) -> Tuple[PEPS_Unit_Cell, Tuple[Sequence[jnp.ndarray], PEPS_Unit_Cell]]:
    """
    Internal helper function of custom VJP to calculate the values in
    the forward sweep.
    """
    new_unitcell, last_truncation_eps, norm_smallest_S = calc_ctmrg_env_custom_rule(
        peps_tensors, unitcell, _return_truncation_eps=True
    )
    return (new_unitcell, norm_smallest_S), (
        peps_tensors,
        new_unitcell,
        unitcell,
        last_truncation_eps,
    )


def _ctmrg_rev_while_body(carry):
    (
        vjp_env,
        initial_bar,
        bar_fixed_point_last_step,
        converged,
        count,
        config,
        state,
    ) = carry

    new_env_bar = vjp_env((bar_fixed_point_last_step, jnp.array(0, dtype=jnp.float64)))[
        0
    ]

    bar_fixed_point = bar_fixed_point_last_step.replace_unique_tensors(
        [
            t_old.__add__(t_new, checks=False)
            for t_old, t_new in zip(
                initial_bar.get_unique_tensors(),
                new_env_bar.get_unique_tensors(),
                strict=True,
            )
        ]
    )

    if bar_fixed_point_last_step.is_triangular_peps():
        converged, measure, verbose_data = _is_element_wise_converged_triangular(
            bar_fixed_point_last_step.get_unique_tensors(),
            bar_fixed_point.get_unique_tensors(),
            config.ad_custom_convergence_eps,
        )
    else:
        converged, measure, verbose_data = _is_element_wise_converged(
            bar_fixed_point_last_step.get_unique_tensors(),
            bar_fixed_point.get_unique_tensors(),
            config.ad_custom_convergence_eps,
            split_transfer=bar_fixed_point.is_split_transfer(),
        )

    count += 1

    if config.ad_custom_print_steps:
        debug_print("Custom VJP: {}: {}", count, measure)
        if config.ad_custom_verbose_output:
            jax.debug.callback(print_verbose, verbose_data, ordered=True, ad=True)

    return vjp_env, initial_bar, bar_fixed_point, converged, count, config, state


@jit
def _ctmrg_rev_workhorse(peps_tensors, new_unitcell, new_unitcell_bar, config, state):
    if new_unitcell.is_triangular_peps():
        _, vjp_peps_tensors = vjp(
            lambda t: do_absorption_step_triangular(t, new_unitcell, config, state),
            peps_tensors,
        )

        vjp_env = tree_util.Partial(
            vjp(
                lambda u: do_absorption_step_triangular(peps_tensors, u, config, state),
                new_unitcell,
            )[1]
        )
    elif new_unitcell.is_split_transfer():
        _, vjp_peps_tensors = vjp(
            lambda t: do_absorption_step_split_transfer(t, new_unitcell, config, state),
            peps_tensors,
        )

        vjp_env = tree_util.Partial(
            vjp(
                lambda u: do_absorption_step_split_transfer(
                    peps_tensors, u, config, state
                ),
                new_unitcell,
            )[1]
        )
    else:
        _, vjp_peps_tensors = vjp(
            lambda t: do_absorption_step(t, new_unitcell, config, state), peps_tensors
        )

        vjp_env = tree_util.Partial(
            vjp(
                lambda u: do_absorption_step(peps_tensors, u, config, state),
                new_unitcell,
            )[1]
        )

    if config.ad_custom_fixed_point_method is Grad_Fixed_Point_Method.ITERATIVE:

        def cond_func(carry):
            _, _, _, converged, count, config, state = carry

            return jnp.logical_not(converged) & (count < config.ad_custom_max_steps)

        _, _, env_fixed_point, converged, end_count, _, _ = while_loop(
            cond_func,
            _ctmrg_rev_while_body,
            (vjp_env, new_unitcell_bar, new_unitcell_bar, False, 0, config, state),
        )
    else:
        real = jax.dtypes.result_type(
            *jax.tree.leaves(new_unitcell_bar)
        ) == jax.dtypes.canonicalize_dtype(jnp.float64)
        if config.ad_custom_fixed_point_method is Grad_Fixed_Point_Method.EIGEN_SOLVER:

            def f_arnoldi(x):
                w = x[0]
                if not real:
                    w = jax.tree.map(lambda x, y: x + 1j * y, w[0], w[1])

                w = vjp_env((w, jnp.array(0, dtype=jnp.float64)))[0]
                w = jax.tree.map(lambda v1, v2: v1 + x[1] * v2, w, new_unitcell_bar)

                if not real:
                    w = (
                        jax.tree.map(lambda x: jnp.real(x), w),
                        jax.tree.map(lambda x: jnp.imag(x), w),
                    )

                return (w, x[1])

            if real:
                eigval, eigvec = jsp.sparse.linalg.eigs(
                    f_arnoldi, 1, (new_unitcell_bar, 1.0)
                )
            else:
                eigval, eigvec = jsp.sparse.linalg.eigs(
                    f_arnoldi,
                    1,
                    (
                        (
                            jax.tree.map(lambda x: jnp.real(x), new_unitcell_bar),
                            jax.tree.map(lambda x: jnp.imag(x), new_unitcell_bar),
                        ),
                        1.0,
                    ),
                )

            converged = cond(
                jnp.logical_and(
                    jnp.abs(jnp.real(eigval[0]))
                    < (1 + 1e-2 * config.ad_custom_convergence_eps),
                    jnp.abs(jnp.imag(eigval[0]))
                    < 1e-2 * config.ad_custom_convergence_eps,
                ),
                lambda: True,
                lambda: False,
            )

            if config.ad_custom_verbose_output:
                debug_print(
                    "AD: Converged: {}, Eigval: {}, Eigvec[1]: {}",
                    converged,
                    eigval[0],
                    eigvec[1][0],
                )

            if real:
                env_fixed_point = jax.tree.map(lambda v: jnp.real(v[..., 0]), eigvec[0])
                env_fixed_point, arnoldi_worked = cond(
                    jnp.logical_and(
                        converged,
                        jnp.abs(eigvec[1][0])
                        >= 1e-2 * config.ad_custom_convergence_eps,
                    ),
                    lambda x: (
                        jax.tree.map(lambda v: v / jnp.real(eigvec[1][0]), x),
                        True,
                    ),
                    lambda x: (x, False),
                    env_fixed_point,
                )
            else:
                env_fixed_point = jax.tree.map(
                    lambda v, w: v[..., 0] + 1j * w[..., 0], eigvec[0][0], eigvec[0][1]
                )
                env_fixed_point, arnoldi_worked = cond(
                    jnp.logical_and(
                        converged,
                        jnp.abs(eigvec[1][0])
                        >= 1e-2 * config.ad_custom_convergence_eps,
                    ),
                    lambda x: (
                        jax.tree.map(lambda v: v / jnp.real(eigvec[1][0]), x),
                        True,
                    ),
                    lambda x: (x, False),
                    env_fixed_point,
                )
        else:
            env_fixed_point = new_unitcell_bar
            arnoldi_worked = False
            converged = True

        end_count = 0

        def run_gmres(v, e):
            if config.ad_custom_verbose_output:
                debug_print("AD: Computing gradient with GMRES")

            def f_gmres(w):
                if not real:
                    w = jax.tree.map(lambda x, y: x + 1j * y, w[0], w[1])

                new_w = vjp_env((w, jnp.array(0, dtype=jnp.float64)))[0]

                new_w = new_w.replace_unique_tensors(
                    [
                        t_old.__sub__(t_new, checks=False)
                        for t_old, t_new in zip(
                            w.get_unique_tensors(),
                            new_w.get_unique_tensors(),
                            strict=True,
                        )
                    ]
                )

                if not real:
                    new_w = (
                        jax.tree.map(lambda x: jnp.real(x), new_w),
                        jax.tree.map(lambda x: jnp.imag(x), new_w),
                    )

                return new_w

            is_gpu = jax.default_backend() == "gpu"

            if real:
                v0 = new_unitcell_bar
            else:
                v0 = (
                    jax.tree.map(lambda x: jnp.real(x), new_unitcell_bar),
                    jax.tree.map(lambda x: jnp.imag(x), new_unitcell_bar),
                )

            v, e = jax.scipy.sparse.linalg.gmres(
                f_gmres,
                v0,
                v0,
                solve_method="batched" if is_gpu else "incremental",
                atol=config.ad_custom_convergence_eps,
                # maxiter=config.ad_custom_max_steps,
            )

            if not real:
                v = jax.tree.map(lambda x, y: x + 1j * y, v[0], v[1])

            return v, e

        env_fixed_point, end_count, converged = jax.lax.cond(
            jnp.logical_and(converged, jnp.logical_not(arnoldi_worked)),
            lambda x, ec, c: (*run_gmres(x, ec), True),
            lambda x, ec, c: (x, ec, c),
            env_fixed_point,
            end_count,
            converged,
        )

    (t_bar,) = vjp_peps_tensors((env_fixed_point, jnp.array(0, dtype=jnp.float64)))

    return t_bar, converged, end_count


def calc_ctmrg_env_rev(
    res: Tuple[Sequence[jnp.ndarray], PEPS_Unit_Cell],
    input_bar: Tuple[PEPS_Unit_Cell, float],
) -> Tuple[Sequence[jnp.ndarray], PEPS_Unit_Cell]:
    """
    Internal helper function of custom VJP to calculate the gradient in
    the backward sweep.
    """
    unitcell_bar, _ = input_bar
    peps_tensors, new_unitcell, input_unitcell, last_truncation_eps = res

    varipeps_global_state.ctmrg_effective_truncation_eps = last_truncation_eps

    t_bar, converged, end_count = _ctmrg_rev_workhorse(
        peps_tensors, new_unitcell, unitcell_bar, varipeps_config, varipeps_global_state
    )

    varipeps_global_state.ctmrg_effective_truncation_eps = None

    if not converged:
        raise CTMRGGradientNotConvergedError

    empty_t = [t.zeros_like_self() for t in input_unitcell.get_unique_tensors()]

    return (
        t_bar,
        input_unitcell.replace_unique_tensors(empty_t),
        jnp.zeros((), dtype=bool),
    )


calc_ctmrg_env_custom_rule.defvjp(calc_ctmrg_env_fwd, calc_ctmrg_env_rev)