data/varipeps/ctmrg/absorption.py

import collections.abc
from dataclasses import dataclass, field
from operator import itemgetter

import jax.numpy as jnp
from jax import jit
from jax.lax import scan, cond

from varipeps.peps import PEPS_Tensor, PEPS_Unit_Cell
from varipeps.contractions import apply_contraction, apply_contraction_jitted
from varipeps.utils.svd import gauge_fixed_svd
from varipeps.utils.periodic_indices import calculate_periodic_indices
from varipeps.utils.projector_dict import Projector_Dict
from .projectors import (
    calc_left_projectors,
    calc_right_projectors,
    calc_top_projectors,
    calc_bottom_projectors,
    calc_left_projectors_split_transfer,
    calc_right_projectors_split_transfer,
    calc_top_projectors_split_transfer,
    calc_bottom_projectors_split_transfer,
)
from varipeps.expectation.one_site import calc_one_site_single_gate_obj
from varipeps.config import VariPEPS_Config
from varipeps.global_state import VariPEPS_Global_State

from typing import Sequence, Tuple, List, Dict, Literal

CTMRG_Orientation = Literal["top-left", "top-right", "bottom-left", "bottom-right"]


def _tensor_list_from_indices(
    peps_tensors: Sequence[jnp.ndarray], indices: Sequence[Sequence[int]]
) -> List[List[jnp.ndarray]]:
    return [[peps_tensors[ty] for ty in tx] for tx in indices]


def _get_ctmrg_2x2_structure(
    peps_tensors: Sequence[jnp.ndarray],
    view: PEPS_Unit_Cell,
    orientation: CTMRG_Orientation,
) -> Tuple[List[List[jnp.ndarray]], List[List[PEPS_Tensor]]]:
    if orientation == "top-left":
        x_slice = slice(0, 2, None)
        y_slice = slice(0, 2, None)
    elif orientation == "top-right":
        x_slice = slice(0, 2, None)
        y_slice = slice(-1, 1, None)
    elif orientation == "bottom-left":
        x_slice = slice(-1, 1, None)
        y_slice = slice(0, 2, None)
    elif orientation == "bottom-right":
        x_slice = slice(-1, 1, None)
        y_slice = slice(-1, 1, None)
    else:
        raise ValueError("Invalid orientation.")

    indices = view.get_indices((x_slice, y_slice))
    view_tensors = _tensor_list_from_indices(peps_tensors, indices)

    view_tensor_objs = view[x_slice, y_slice]

    return view_tensors, view_tensor_objs


def _get_ctmrg_2x1_structure(
    peps_tensors: Sequence[jnp.ndarray],
    view: PEPS_Unit_Cell,
) -> Tuple[List[List[jnp.ndarray]], List[List[PEPS_Tensor]]]:
    x_slice = slice(0, 2, None)
    y_slice = slice(0, 1, None)

    indices = view.get_indices((x_slice, y_slice))
    view_tensors = _tensor_list_from_indices(peps_tensors, indices)

    view_tensor_objs = view[x_slice, y_slice]

    return view_tensors, view_tensor_objs


def _get_ctmrg_1x2_structure(
    peps_tensors: Sequence[jnp.ndarray],
    view: PEPS_Unit_Cell,
) -> Tuple[List[List[jnp.ndarray]], List[List[PEPS_Tensor]]]:
    x_slice = slice(0, 1, None)
    y_slice = slice(0, 2, None)

    indices = view.get_indices((x_slice, y_slice))
    view_tensors = _tensor_list_from_indices(peps_tensors, indices)

    view_tensor_objs = view[x_slice, y_slice]

    return view_tensors, view_tensor_objs


def _post_process_CTM_tensors(a: jnp.ndarray, config: VariPEPS_Config) -> jnp.ndarray:
    a = a / jnp.linalg.norm(a)
    a_abs = jnp.abs(a)
    a_abs_max = jnp.max(a_abs)

    def scan_max_element(carry, x):
        x_a, x_a_abs = x
        found, phase = carry

        def new_phase(ph, curr_x, curr_x_abs):
            return cond(
                curr_x_abs >= (config.svd_sign_fix_eps * a_abs_max),
                lambda p, c_x, c_x_a: c_x / c_x_a,
                lambda p, c_x, c_x_a: p,
                ph,
                curr_x,
                curr_x_abs,
            )

        phase = cond(
            found, lambda ph, curr_x, curr_x_abs: ph, new_phase, phase, x_a, x_a_abs
        )

        return (jnp.logical_not(jnp.isnan(phase)), phase), None

    (_, phase), _ = scan(
        scan_max_element,
        (jnp.array(False), jnp.array(jnp.nan, dtype=a.dtype)),
        (a.flatten(), a_abs.flatten()),
    )

    return a * phase.conj()


def do_left_absorption(
    peps_tensors: Sequence[jnp.ndarray],
    unitcell: PEPS_Unit_Cell,
    config: VariPEPS_Config,
    state: VariPEPS_Global_State,
) -> PEPS_Unit_Cell:
    """
    Calculate the left CTMRG tensors after one absorption step and returns
    the updated unitcell.

    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.
      config (:obj:`~varipeps.config.VariPEPS_Config`):
        Global configuration object of the variPEPS library. Please see its
        class definition for details.
      state (:obj:`~varipeps.global_state.VariPEPS_Global_State`):
        Global state object of the variPEPS library. It is used to transport
        a common state across different parts of the framework. Please see its
        class definition for details.
    Returns:
      :obj:`~varipeps.peps.PEPS_Unit_Cell`:
        New instance of the unitcell with the updated left CTMRG tensors of
        all elements of the unitcell.
    """
    max_x, max_y = unitcell.get_size()
    left_projectors = Projector_Dict(max_x=max_x, max_y=max_y)

    working_unitcell = unitcell.copy()

    smallest_S_list = []

    for y, iter_columns in working_unitcell.iter_all_columns(only_unique=True):
        column_views = [view for view in iter_columns]

        for x, view in column_views:
            left_proj, smallest_S = calc_left_projectors(
                *_get_ctmrg_2x2_structure(peps_tensors, view, "top-left"), config, state
            )
            left_projectors[(x, y)] = left_proj
            smallest_S_list.append(smallest_S)

        new_C1 = []
        new_T4 = []
        new_C4 = []

        for x, view in column_views:
            working_tensor = peps_tensors[view.get_indices((0, 0))[0][0]]
            working_tensor_obj = view[0, 0][0][0]

            C1_projector = left_projectors.get_projector(x, y, -1, 0).bottom
            new_C1_tmp = apply_contraction_jitted(
                "ctmrg_absorption_left_C1",
                [working_tensor],
                [working_tensor_obj],
                [C1_projector],
            )
            new_C1.append(_post_process_CTM_tensors(new_C1_tmp, config))

            T4_projector_top = left_projectors.get_projector(x, y, -1, 0).top
            T4_projector_bottom = left_projectors.get_projector(x, y, 0, 0).bottom

            if (
                working_tensor_obj.d > working_tensor_obj.chi
                or working_tensor_obj.d > working_tensor_obj.D[0] ** 2
            ):
                new_T4_tmp = apply_contraction_jitted(
                    "ctmrg_absorption_left_T4_large_d",
                    [working_tensor],
                    [working_tensor_obj],
                    [T4_projector_top, T4_projector_bottom],
                )
            else:
                new_T4_tmp = apply_contraction_jitted(
                    "ctmrg_absorption_left_T4",
                    [working_tensor],
                    [working_tensor_obj],
                    [T4_projector_top, T4_projector_bottom],
                )
            new_T4.append(_post_process_CTM_tensors(new_T4_tmp, config))

            C4_projector = left_projectors.get_projector(x, y, 0, 0).top
            new_C4_tmp = apply_contraction_jitted(
                "ctmrg_absorption_left_C4",
                [working_tensor],
                [working_tensor_obj],
                [C4_projector],
            )
            new_C4.append(_post_process_CTM_tensors(new_C4_tmp, config))

        for x, view in column_views:
            view[0, 1] = view[0, 1][0][0].replace_left_env_tensors(
                new_C1[x], new_T4[x], new_C4[x]
            )

    return working_unitcell, smallest_S_list


def do_right_absorption(
    peps_tensors: Sequence[jnp.ndarray],
    unitcell: PEPS_Unit_Cell,
    config: VariPEPS_Config,
    state: VariPEPS_Global_State,
) -> PEPS_Unit_Cell:
    """
    Calculate the right CTMRG tensors after one absorption step and returns
    the updated unitcell.

    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.
      config (:obj:`~varipeps.config.VariPEPS_Config`):
        Global configuration object of the variPEPS library. Please see its
        class definition for details.
      state (:obj:`~varipeps.global_state.VariPEPS_Global_State`):
        Global state object of the variPEPS library. It is used to transport
        a common state across different parts of the framework. Please see its
        class definition for details.
    Returns:
      :obj:`~varipeps.peps.PEPS_Unit_Cell`:
        New instance of the unitcell with the updated right CTMRG tensors of
        all elements of the unitcell.
    """
    max_x, max_y = unitcell.get_size()
    right_projectors = Projector_Dict(max_x=max_x, max_y=max_y)

    working_unitcell = unitcell.copy()

    smallest_S_list = []

    for y, iter_columns in working_unitcell.iter_all_columns(
        reverse=True, only_unique=True
    ):
        column_views = [view for view in iter_columns]

        for x, view in column_views:
            right_proj, smallest_S = calc_right_projectors(
                *_get_ctmrg_2x2_structure(peps_tensors, view, "top-right"),
                config,
                state,
            )
            right_projectors[(x, y)] = right_proj
            smallest_S_list.append(smallest_S)

        new_C2 = []
        new_T2 = []
        new_C3 = []

        for x, view in column_views:
            working_tensor = peps_tensors[view.get_indices((0, 0))[0][0]]
            working_tensor_obj = view[0, 0][0][0]

            C2_projector = right_projectors.get_projector(x, y, -1, 0).bottom
            new_C2_tmp = apply_contraction_jitted(
                "ctmrg_absorption_right_C2",
                [working_tensor],
                [working_tensor_obj],
                [C2_projector],
            )
            new_C2.append(_post_process_CTM_tensors(new_C2_tmp, config))

            T2_projector_top = right_projectors.get_projector(x, y, -1, 0).top
            T2_projector_bottom = right_projectors.get_projector(x, y, 0, 0).bottom
            if (
                working_tensor_obj.d > working_tensor_obj.chi
                or working_tensor_obj.d > working_tensor_obj.D[2] ** 2
            ):
                new_T2_tmp = apply_contraction_jitted(
                    "ctmrg_absorption_right_T2_large_d",
                    [working_tensor],
                    [working_tensor_obj],
                    [T2_projector_top, T2_projector_bottom],
                )
            else:
                new_T2_tmp = apply_contraction_jitted(
                    "ctmrg_absorption_right_T2",
                    [working_tensor],
                    [working_tensor_obj],
                    [T2_projector_top, T2_projector_bottom],
                )
            new_T2.append(_post_process_CTM_tensors(new_T2_tmp, config))

            C3_projector = right_projectors.get_projector(x, y, 0, 0).top
            new_C3_tmp = apply_contraction_jitted(
                "ctmrg_absorption_right_C3",
                [working_tensor],
                [working_tensor_obj],
                [C3_projector],
            )
            new_C3.append(_post_process_CTM_tensors(new_C3_tmp, config))

        for x, view in column_views:
            view[0, -1] = view[0, -1][0][0].replace_right_env_tensors(
                new_C2[x], new_T2[x], new_C3[x]
            )

    return working_unitcell, smallest_S_list


def do_top_absorption(
    peps_tensors: Sequence[jnp.ndarray],
    unitcell: PEPS_Unit_Cell,
    config: VariPEPS_Config,
    state: VariPEPS_Global_State,
) -> PEPS_Unit_Cell:
    """
    Calculate the top CTMRG tensors after one absorption step and returns
    the updated unitcell.

    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.
      config (:obj:`~varipeps.config.VariPEPS_Config`):
        Global configuration object of the variPEPS library. Please see its
        class definition for details.
      state (:obj:`~varipeps.global_state.VariPEPS_Global_State`):
        Global state object of the variPEPS library. It is used to transport
        a common state across different parts of the framework. Please see its
        class definition for details.
    Returns:
      :obj:`~varipeps.peps.PEPS_Unit_Cell`:
        New instance of the unitcell with the updated top CTMRG tensors of
        all elements of the unitcell.
    """
    max_x, max_y = unitcell.get_size()
    top_projectors = Projector_Dict(max_x=max_x, max_y=max_y)

    working_unitcell = unitcell.copy()

    smallest_S_list = []

    for x, iter_rows in working_unitcell.iter_all_rows(only_unique=True):
        row_views = [view for view in iter_rows]

        for y, view in row_views:
            top_proj, smallest_S = calc_top_projectors(
                *_get_ctmrg_2x2_structure(peps_tensors, view, "top-left"), config, state
            )
            top_projectors[(x, y)] = top_proj
            smallest_S_list.append(smallest_S)

        new_C1 = []
        new_T1 = []
        new_C2 = []

        for y, view in row_views:
            working_tensor = peps_tensors[view.get_indices((0, 0))[0][0]]
            working_tensor_obj = view[0, 0][0][0]

            C1_projector = top_projectors.get_projector(x, y, 0, -1).right  # type: ignore
            new_C1_tmp = apply_contraction_jitted(
                "ctmrg_absorption_top_C1",
                [working_tensor],
                [working_tensor_obj],
                [C1_projector],
            )
            new_C1.append(_post_process_CTM_tensors(new_C1_tmp, config))

            T1_projector_left = top_projectors.get_projector(x, y, 0, -1).left  # type: ignore
            T1_projector_right = top_projectors.get_projector(x, y, 0, 0).right  # type: ignore
            if (
                working_tensor_obj.d > working_tensor_obj.chi
                or working_tensor_obj.d > working_tensor_obj.D[3] ** 2
            ):
                new_T1_tmp = apply_contraction_jitted(
                    "ctmrg_absorption_top_T1_large_d",
                    [working_tensor],
                    [working_tensor_obj],
                    [T1_projector_left, T1_projector_right],
                )
            else:
                new_T1_tmp = apply_contraction_jitted(
                    "ctmrg_absorption_top_T1",
                    [working_tensor],
                    [working_tensor_obj],
                    [T1_projector_left, T1_projector_right],
                )
            new_T1.append(_post_process_CTM_tensors(new_T1_tmp, config))

            C2_projector = top_projectors.get_projector(x, y, 0, 0).left  # type: ignore
            new_C2_tmp = apply_contraction_jitted(
                "ctmrg_absorption_top_C2",
                [working_tensor],
                [working_tensor_obj],
                [C2_projector],
            )
            new_C2.append(_post_process_CTM_tensors(new_C2_tmp, config))

        for y, view in row_views:
            view[1, 0] = view[1, 0][0][0].replace_top_env_tensors(
                new_C1[y], new_T1[y], new_C2[y]
            )

    return working_unitcell, smallest_S_list


def do_bottom_absorption(
    peps_tensors: Sequence[jnp.ndarray],
    unitcell: PEPS_Unit_Cell,
    config: VariPEPS_Config,
    state: VariPEPS_Global_State,
) -> PEPS_Unit_Cell:
    """
    Calculate the bottom CTMRG tensors after one absorption step and returns
    the updated unitcell.

    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.
      config (:obj:`~varipeps.config.VariPEPS_Config`):
        Global configuration object of the variPEPS library. Please see its
        class definition for details.
      state (:obj:`~varipeps.global_state.VariPEPS_Global_State`):
        Global state object of the variPEPS library. It is used to transport
        a common state across different parts of the framework. Please see its
        class definition for details.
    Returns:
      :obj:`~varipeps.peps.PEPS_Unit_Cell`:
        New instance of the unitcell with the updated bottom CTMRG tensors of
        all elements of the unitcell.
    """
    max_x, max_y = unitcell.get_size()
    bottom_projectors = Projector_Dict(max_x=max_x, max_y=max_y)

    working_unitcell = unitcell.copy()

    smallest_S_list = []

    for x, iter_rows in working_unitcell.iter_all_rows(reverse=True, only_unique=True):
        row_views = [view for view in iter_rows]

        for y, view in row_views:
            bottom_proj, smallest_S = calc_bottom_projectors(
                *_get_ctmrg_2x2_structure(peps_tensors, view, "bottom-left"),
                config,
                state,
            )
            bottom_projectors[(x, y)] = bottom_proj
            smallest_S_list.append(smallest_S)

        new_C4 = []
        new_T3 = []
        new_C3 = []

        for y, view in row_views:
            working_tensor = peps_tensors[view.get_indices((0, 0))[0][0]]
            working_tensor_obj = view[0, 0][0][0]

            C4_projector = bottom_projectors.get_projector(x, y, 0, -1).right  # type: ignore
            new_C4_tmp = apply_contraction_jitted(
                "ctmrg_absorption_bottom_C4",
                [working_tensor],
                [working_tensor_obj],
                [C4_projector],
            )
            new_C4.append(_post_process_CTM_tensors(new_C4_tmp, config))

            T3_projector_left = bottom_projectors.get_projector(x, y, 0, -1).left  # type: ignore
            T3_projector_right = bottom_projectors.get_projector(x, y, 0, 0).right  # type: ignore
            if (
                working_tensor_obj.d > working_tensor_obj.chi
                or working_tensor_obj.d > working_tensor_obj.D[1] ** 2
            ):
                new_T3_tmp = apply_contraction_jitted(
                    "ctmrg_absorption_bottom_T3_large_d",
                    [working_tensor],
                    [working_tensor_obj],
                    [T3_projector_left, T3_projector_right],
                )
            else:
                new_T3_tmp = apply_contraction_jitted(
                    "ctmrg_absorption_bottom_T3",
                    [working_tensor],
                    [working_tensor_obj],
                    [T3_projector_left, T3_projector_right],
                )
            new_T3.append(_post_process_CTM_tensors(new_T3_tmp, config))

            C3_projector = bottom_projectors.get_projector(x, y, 0, 0).left  # type: ignore
            new_C3_tmp = apply_contraction_jitted(
                "ctmrg_absorption_bottom_C3",
                [working_tensor],
                [working_tensor_obj],
                [C3_projector],
            )
            new_C3.append(_post_process_CTM_tensors(new_C3_tmp, config))

        for y, view in row_views:
            view[-1, 0] = view[-1, 0][0][0].replace_bottom_env_tensors(
                new_C4[y], new_T3[y], new_C3[y]
            )

    return working_unitcell, smallest_S_list


def gauge_fix_ctmrg_tensors(
    peps_tensors: Sequence[jnp.ndarray], unitcell: PEPS_Unit_Cell
) -> PEPS_Unit_Cell:
    left_unitaries = []
    right_unitaries = []
    top_unitaries = []
    bottom_unitaries = []

    working_unitcell = unitcell.copy()

    for ti, working_tensor_obj in enumerate(working_unitcell.get_unique_tensors()):
        C1_U, C1_S, C1_Vh = gauge_fixed_svd(working_tensor_obj.C1)
        C3_U, C3_S, C3_Vh = gauge_fixed_svd(working_tensor_obj.C3)

        left_unitaries.append(C1_U)
        top_unitaries.append(C1_Vh)
        bottom_unitaries.append(C3_U)
        right_unitaries.append(C3_Vh)

        working_unitcell.data.peps_tensors[ti] = working_tensor_obj.replace_C1_C3(
            jnp.diag(C1_S), jnp.diag(C3_S)
        )

    for x, iter_rows in working_unitcell.iter_all_rows(only_unique=True):
        for y, view in iter_rows:
            working_tensor = peps_tensors[view.get_indices((0, 0))[0][0]]
            working_tensor_obj = view[0, 0][0][0]

            i_0_0 = calculate_periodic_indices((0, 0), view.data.structure, x, y)[0][0]
            i_0_1 = calculate_periodic_indices((0, 1), view.data.structure, x, y)[0][0]
            i_0_neg1 = calculate_periodic_indices((0, -1), view.data.structure, x, y)[
                0
            ][0]
            i_1_0 = calculate_periodic_indices((1, 0), view.data.structure, x, y)[0][0]
            i_neg1_0 = calculate_periodic_indices((-1, 0), view.data.structure, x, y)[
                0
            ][0]

            T1_left_unitary = top_unitaries[i_0_0]
            T1_right_unitary = top_unitaries[i_0_1].conj()
            new_T1 = apply_contraction_jitted(
                "ctmrg_gauge_fix_T1",
                [working_tensor],
                [working_tensor_obj],
                [T1_left_unitary, T1_right_unitary],
            )

            C2_left_unitary = top_unitaries[i_0_1]
            C2_bottom_unitary = right_unitaries[i_neg1_0]
            new_C2 = apply_contraction_jitted(
                "ctmrg_gauge_fix_C2",
                [working_tensor],
                [working_tensor_obj],
                [C2_left_unitary, C2_bottom_unitary],
            )

            T2_top_unitary = right_unitaries[i_neg1_0].conj()
            T2_bottom_unitary = right_unitaries[i_0_0]
            new_T2 = apply_contraction_jitted(
                "ctmrg_gauge_fix_T2",
                [working_tensor],
                [working_tensor_obj],
                [T2_top_unitary, T2_bottom_unitary],
            )

            T3_left_unitary = bottom_unitaries[i_0_neg1].conj()
            T3_right_unitary = bottom_unitaries[i_0_0]
            new_T3 = apply_contraction_jitted(
                "ctmrg_gauge_fix_T3",
                [working_tensor],
                [working_tensor_obj],
                [T3_left_unitary, T3_right_unitary],
            )

            C4_top_unitary = left_unitaries[i_1_0]
            C4_right_unitary = bottom_unitaries[i_0_neg1]
            new_C4 = apply_contraction_jitted(
                "ctmrg_gauge_fix_C4",
                [working_tensor],
                [working_tensor_obj],
                [C4_top_unitary, C4_right_unitary],
            )

            T4_top_unitary = left_unitaries[i_0_0]
            T4_bottom_unitary = left_unitaries[i_1_0].conj()
            new_T4 = apply_contraction_jitted(
                "ctmrg_gauge_fix_T4",
                [working_tensor],
                [working_tensor_obj],
                [T4_top_unitary, T4_bottom_unitary],
            )

            view[0, 0] = working_tensor_obj.replace_T1_C2_T2_T3_C4_T4(
                new_T1, new_C2, new_T2, new_T3, new_C4, new_T4
            )

    return working_unitcell


def do_absorption_step(
    peps_tensors: Sequence[jnp.ndarray],
    unitcell: PEPS_Unit_Cell,
    config: VariPEPS_Config,
    state: VariPEPS_Global_State,
) -> PEPS_Unit_Cell:
    """
    Calculate the all CTMRG tensors after one absorption step and returns
    the updated unitcell.

    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.
      config (:obj:`~varipeps.config.VariPEPS_Config`):
        Global configuration object of the variPEPS library. Please see its
        class definition for details.
      state (:obj:`~varipeps.global_state.VariPEPS_Global_State`):
        Global state object of the variPEPS library. It is used to transport
        a common state across different parts of the framework. Please see its
        class definition for details.
    Returns:
      :obj:`~varipeps.peps.PEPS_Unit_Cell`:
        New instance of the unitcell with the all updated CTMRG tensors of
        all elements of the unitcell.
    """
    result, left_smallest_S = do_left_absorption(peps_tensors, unitcell, config, state)
    result, top_smallest_S = do_top_absorption(peps_tensors, result, config, state)
    result, right_smallest_S = do_right_absorption(peps_tensors, result, config, state)
    result, bottom_smallest_S = do_bottom_absorption(
        peps_tensors, result, config, state
    )
    # result = gauge_fix_ctmrg_tensors(peps_tensors, result)
    norm_smallest_S = jnp.linalg.norm(
        jnp.asarray(
            left_smallest_S + top_smallest_S + right_smallest_S + bottom_smallest_S
        ),
        ord=jnp.inf,
    )
    return result, norm_smallest_S


def do_left_absorption_split_transfer(
    peps_tensors: Sequence[jnp.ndarray],
    unitcell: PEPS_Unit_Cell,
    config: VariPEPS_Config,
    state: VariPEPS_Global_State,
) -> PEPS_Unit_Cell:
    """
    Calculate the left CTMRG tensors after one absorption step and returns
    the updated unitcell. This functions uses the CTMRG method with split
    transfer matrices for the bra and ket layer.

    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 the updated left CTMRG tensors of
        all elements of the unitcell.
    """
    max_x, max_y = unitcell.get_size()
    left_projectors = Projector_Dict(max_x=max_x, max_y=max_y)

    working_unitcell = unitcell.copy()

    smallest_S_list = []

    for y, iter_columns in working_unitcell.iter_all_columns(only_unique=True):
        column_views = [view for view in iter_columns]

        for x, view in column_views:
            (
                left_proj,
                smallest_S_ket,
                smallest_S_bra,
                smallest_S_phys_ket,
                smallest_S_phys_bra,
            ) = calc_left_projectors_split_transfer(
                *_get_ctmrg_2x2_structure(peps_tensors, view, "top-left"), config, state
            )
            left_projectors[(x, y)] = left_proj
            smallest_S_list.append(smallest_S_ket)
            smallest_S_list.append(smallest_S_bra)
            smallest_S_list.append(smallest_S_phys_ket)
            smallest_S_list.append(smallest_S_phys_bra)

        new_C1_list = []
        new_T4_ket_list = []
        new_T4_bra_list = []
        new_C4_list = []
        new_T4_tmp_list = []

        for x, view in column_views:
            working_tensor = peps_tensors[view.get_indices((0, 0))[0][0]]
            working_tensor_obj = view[0, 0][0][0]

            C1_ket_projector = left_projectors.get_projector(x, y, -1, 0).bottom_ket
            C1_bra_projector = left_projectors.get_projector(x, y, -1, 0).bottom_bra
            new_C1_tmp = apply_contraction(
                "ctmrg_split_transfer_absorption_left_C1",
                [working_tensor],
                [working_tensor_obj],
                [C1_ket_projector, C1_bra_projector],
            )
            new_C1_list.append(_post_process_CTM_tensors(new_C1_tmp, config))

            T4_ket_projector_top = left_projectors.get_projector(x, y, -1, 0).top_ket
            T4_bra_projector_top = left_projectors.get_projector(x, y, -1, 0).top_bra
            T4_phys_ket_projector_top = left_projectors.get_projector(
                x, y, 0, 0
            ).top_phys_ket
            T4_phys_bra_projector_top = left_projectors.get_projector(
                x, y, 0, 0
            ).top_phys_bra
            T4_ket_projector_bottom = left_projectors.get_projector(
                x, y, 0, 0
            ).bottom_ket
            T4_bra_projector_bottom = left_projectors.get_projector(
                x, y, 0, 0
            ).bottom_bra
            T4_phys_ket_projector_bottom = left_projectors.get_projector(
                x, y, 0, 0
            ).bottom_phys_ket
            T4_phys_bra_projector_bottom = left_projectors.get_projector(
                x, y, 0, 0
            ).bottom_phys_bra

            new_T4_ket = apply_contraction_jitted(
                "ctmrg_split_transfer_absorption_left_T4_ket",
                [working_tensor],
                [working_tensor_obj],
                [
                    T4_ket_projector_top,
                    T4_bra_projector_top,
                    T4_phys_ket_projector_bottom,
                    T4_phys_bra_projector_bottom,
                ],
            )

            new_T4_bra = apply_contraction_jitted(
                "ctmrg_split_transfer_absorption_left_T4_bra",
                [working_tensor],
                [working_tensor_obj],
                [
                    T4_phys_ket_projector_top,
                    T4_phys_bra_projector_top,
                    T4_ket_projector_bottom,
                    T4_bra_projector_bottom,
                ],
            )

            new_T4_ket_list.append(_post_process_CTM_tensors(new_T4_ket, config))
            new_T4_bra_list.append(_post_process_CTM_tensors(new_T4_bra, config))

            C4_ket_projector = left_projectors.get_projector(x, y, 0, 0).top_ket
            C4_bra_projector = left_projectors.get_projector(x, y, 0, 0).top_bra
            new_C4_tmp = apply_contraction_jitted(
                "ctmrg_split_transfer_absorption_left_C4",
                [working_tensor],
                [working_tensor_obj],
                [C4_ket_projector, C4_bra_projector],
            )
            new_C4_list.append(_post_process_CTM_tensors(new_C4_tmp, config))

        for x, view in column_views:
            view[0, 1] = view[0, 1][0][0].replace_left_env_tensors(
                new_C1_list[x], new_T4_ket_list[x], new_T4_bra_list[x], new_C4_list[x]
            )

    return working_unitcell, smallest_S_list  # , new_T4_tmp_list


def do_right_absorption_split_transfer(
    peps_tensors: Sequence[jnp.ndarray],
    unitcell: PEPS_Unit_Cell,
    config: VariPEPS_Config,
    state: VariPEPS_Global_State,
) -> PEPS_Unit_Cell:
    """
    Calculate the right CTMRG tensors after one absorption step and returns
    the updated unitcell. This functions uses the CTMRG method with split
    transfer matrices for the bra and ket layer.

    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 the updated right CTMRG tensors of
        all elements of the unitcell.
    """
    max_x, max_y = unitcell.get_size()
    right_projectors = Projector_Dict(max_x=max_x, max_y=max_y)

    working_unitcell = unitcell.copy()

    smallest_S_list = []

    for y, iter_columns in working_unitcell.iter_all_columns(
        reverse=True, only_unique=True
    ):
        column_views = [view for view in iter_columns]

        for x, view in column_views:
            (
                right_proj,
                smallest_S_ket,
                smallest_S_bra,
                smallest_S_phys_ket,
                smallest_S_phys_bra,
            ) = calc_right_projectors_split_transfer(
                *_get_ctmrg_2x2_structure(peps_tensors, view, "top-right"),
                config,
                state,
            )
            right_projectors[(x, y)] = right_proj
            smallest_S_list.append(smallest_S_ket)
            smallest_S_list.append(smallest_S_bra)
            smallest_S_list.append(smallest_S_phys_ket)
            smallest_S_list.append(smallest_S_phys_bra)

        new_C2_list = []
        new_T2_ket_list = []
        new_T2_bra_list = []
        new_C3_list = []

        for x, view in column_views:
            working_tensor = peps_tensors[view.get_indices((0, 0))[0][0]]
            working_tensor_obj = view[0, 0][0][0]

            C2_ket_projector = right_projectors.get_projector(x, y, -1, 0).bottom_ket
            C2_bra_projector = right_projectors.get_projector(x, y, -1, 0).bottom_bra
            new_C2_tmp = apply_contraction(
                "ctmrg_split_transfer_absorption_right_C2",
                [working_tensor],
                [working_tensor_obj],
                [C2_ket_projector, C2_bra_projector],
            )
            new_C2_list.append(_post_process_CTM_tensors(new_C2_tmp, config))

            T2_ket_projector_top = right_projectors.get_projector(x, y, -1, 0).top_ket
            T2_bra_projector_top = right_projectors.get_projector(x, y, -1, 0).top_bra
            T2_phys_ket_projector_top = right_projectors.get_projector(
                x, y, 0, 0
            ).top_phys_ket
            T2_phys_bra_projector_top = right_projectors.get_projector(
                x, y, 0, 0
            ).top_phys_bra
            T2_ket_projector_bottom = right_projectors.get_projector(
                x, y, 0, 0
            ).bottom_ket
            T2_bra_projector_bottom = right_projectors.get_projector(
                x, y, 0, 0
            ).bottom_bra
            T2_phys_ket_projector_bottom = right_projectors.get_projector(
                x, y, 0, 0
            ).bottom_phys_ket
            T2_phys_bra_projector_bottom = right_projectors.get_projector(
                x, y, 0, 0
            ).bottom_phys_bra

            new_T2_ket = apply_contraction_jitted(
                "ctmrg_split_transfer_absorption_right_T2_ket",
                [working_tensor],
                [working_tensor_obj],
                [
                    T2_ket_projector_top,
                    T2_bra_projector_top,
                    T2_phys_ket_projector_bottom,
                    T2_phys_bra_projector_bottom,
                ],
            )

            new_T2_bra = apply_contraction_jitted(
                "ctmrg_split_transfer_absorption_right_T2_bra",
                [working_tensor],
                [working_tensor_obj],
                [
                    T2_phys_ket_projector_top,
                    T2_phys_bra_projector_top,
                    T2_ket_projector_bottom,
                    T2_bra_projector_bottom,
                ],
            )

            new_T2_ket_list.append(_post_process_CTM_tensors(new_T2_ket, config))
            new_T2_bra_list.append(_post_process_CTM_tensors(new_T2_bra, config))

            C3_ket_projector = right_projectors.get_projector(x, y, 0, 0).top_ket
            C3_bra_projector = right_projectors.get_projector(x, y, 0, 0).top_bra
            new_C3_tmp = apply_contraction_jitted(
                "ctmrg_split_transfer_absorption_right_C3",
                [working_tensor],
                [working_tensor_obj],
                [C3_ket_projector, C3_bra_projector],
            )
            new_C3_list.append(_post_process_CTM_tensors(new_C3_tmp, config))

        for x, view in column_views:
            view[0, -1] = view[0, -1][0][0].replace_right_env_tensors(
                new_C2_list[x], new_T2_ket_list[x], new_T2_bra_list[x], new_C3_list[x]
            )

    return working_unitcell, smallest_S_list


def do_top_absorption_split_transfer(
    peps_tensors: Sequence[jnp.ndarray],
    unitcell: PEPS_Unit_Cell,
    config: VariPEPS_Config,
    state: VariPEPS_Global_State,
) -> PEPS_Unit_Cell:
    """
    Calculate the top CTMRG tensors after one absorption step and returns
    the updated unitcell. This functions uses the CTMRG method with split
    transfer matrices for the bra and ket layer.

    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 the updated top CTMRG tensors of
        all elements of the unitcell.
    """
    max_x, max_y = unitcell.get_size()
    top_projectors = Projector_Dict(max_x=max_x, max_y=max_y)

    working_unitcell = unitcell.copy()

    smallest_S_list = []

    for x, iter_rows in working_unitcell.iter_all_rows(only_unique=True):
        row_views = [view for view in iter_rows]

        for y, view in row_views:
            (
                top_proj,
                smallest_S_ket,
                smallest_S_bra,
                smallest_S_phys_ket,
                smallest_S_phys_bra,
            ) = calc_top_projectors_split_transfer(
                *_get_ctmrg_2x2_structure(peps_tensors, view, "top-left"), config, state
            )
            top_projectors[(x, y)] = top_proj
            smallest_S_list.append(smallest_S_ket)
            smallest_S_list.append(smallest_S_bra)
            smallest_S_list.append(smallest_S_phys_ket)
            smallest_S_list.append(smallest_S_phys_bra)

        new_C1_list = []
        new_T1_ket_list = []
        new_T1_bra_list = []
        new_C2_list = []

        for y, view in row_views:
            working_tensor = peps_tensors[view.get_indices((0, 0))[0][0]]
            working_tensor_obj = view[0, 0][0][0]

            C1_ket_projector = top_projectors.get_projector(x, y, 0, -1).right_ket
            C1_bra_projector = top_projectors.get_projector(x, y, 0, -1).right_bra
            new_C1_tmp = apply_contraction(
                "ctmrg_split_transfer_absorption_top_C1",
                [working_tensor],
                [working_tensor_obj],
                [C1_ket_projector, C1_bra_projector],
            )
            new_C1_list.append(_post_process_CTM_tensors(new_C1_tmp, config))

            T1_ket_projector_left = top_projectors.get_projector(x, y, 0, -1).left_ket
            T1_bra_projector_left = top_projectors.get_projector(x, y, 0, -1).left_bra
            T1_phys_ket_projector_left = top_projectors.get_projector(
                x, y, 0, 0
            ).left_phys_ket
            T1_phys_bra_projector_left = top_projectors.get_projector(
                x, y, 0, 0
            ).left_phys_bra
            T1_ket_projector_right = top_projectors.get_projector(x, y, 0, 0).right_ket
            T1_bra_projector_right = top_projectors.get_projector(x, y, 0, 0).right_bra
            T1_phys_ket_projector_right = top_projectors.get_projector(
                x, y, 0, 0
            ).right_phys_ket
            T1_phys_bra_projector_right = top_projectors.get_projector(
                x, y, 0, 0
            ).right_phys_bra

            new_T1_ket = apply_contraction_jitted(
                "ctmrg_split_transfer_absorption_top_T1_ket",
                [working_tensor],
                [working_tensor_obj],
                [
                    T1_ket_projector_left,
                    T1_bra_projector_left,
                    T1_phys_ket_projector_right,
                    T1_phys_bra_projector_right,
                ],
            )

            new_T1_bra = apply_contraction_jitted(
                "ctmrg_split_transfer_absorption_top_T1_bra",
                [working_tensor],
                [working_tensor_obj],
                [
                    T1_phys_ket_projector_left,
                    T1_phys_bra_projector_left,
                    T1_ket_projector_right,
                    T1_bra_projector_right,
                ],
            )

            new_T1_ket_list.append(_post_process_CTM_tensors(new_T1_ket, config))
            new_T1_bra_list.append(_post_process_CTM_tensors(new_T1_bra, config))

            C2_ket_projector = top_projectors.get_projector(x, y, 0, 0).left_ket
            C2_bra_projector = top_projectors.get_projector(x, y, 0, 0).left_bra
            new_C2_tmp = apply_contraction_jitted(
                "ctmrg_split_transfer_absorption_top_C2",
                [working_tensor],
                [working_tensor_obj],
                [C2_ket_projector, C2_bra_projector],
            )
            new_C2_list.append(_post_process_CTM_tensors(new_C2_tmp, config))

        for y, view in row_views:
            view[1, 0] = view[1, 0][0][0].replace_top_env_tensors(
                new_C1_list[y], new_T1_ket_list[y], new_T1_bra_list[y], new_C2_list[y]
            )

    return working_unitcell, smallest_S_list


def do_bottom_absorption_split_transfer(
    peps_tensors: Sequence[jnp.ndarray],
    unitcell: PEPS_Unit_Cell,
    config: VariPEPS_Config,
    state: VariPEPS_Global_State,
) -> PEPS_Unit_Cell:
    """
    Calculate the left CTMRG tensors after one absorption step and returns
    the updated unitcell. This functions uses the CTMRG method with split
    transfer matrices for the bra and ket layer.

    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 the updated left CTMRG tensors of
        all elements of the unitcell.
    """
    max_x, max_y = unitcell.get_size()
    bottom_projectors = Projector_Dict(max_x=max_x, max_y=max_y)

    working_unitcell = unitcell.copy()

    smallest_S_list = []

    for x, iter_rows in working_unitcell.iter_all_rows(reverse=True, only_unique=True):
        row_views = [view for view in iter_rows]

        for y, view in row_views:
            (
                bottom_proj,
                smallest_S_ket,
                smallest_S_bra,
                smallest_S_phys_ket,
                smallest_S_phys_bra,
            ) = calc_bottom_projectors_split_transfer(
                *_get_ctmrg_2x2_structure(peps_tensors, view, "bottom-left"),
                config,
                state,
            )
            bottom_projectors[(x, y)] = bottom_proj
            smallest_S_list.append(smallest_S_ket)
            smallest_S_list.append(smallest_S_bra)
            smallest_S_list.append(smallest_S_phys_ket)
            smallest_S_list.append(smallest_S_phys_bra)

        new_C4_list = []
        new_T3_ket_list = []
        new_T3_bra_list = []
        new_C3_list = []

        for y, view in row_views:
            working_tensor = peps_tensors[view.get_indices((0, 0))[0][0]]
            working_tensor_obj = view[0, 0][0][0]

            C4_ket_projector = bottom_projectors.get_projector(x, y, 0, -1).right_ket
            C4_bra_projector = bottom_projectors.get_projector(x, y, 0, -1).right_bra
            new_C4_tmp = apply_contraction(
                "ctmrg_split_transfer_absorption_bottom_C4",
                [working_tensor],
                [working_tensor_obj],
                [C4_ket_projector, C4_bra_projector],
            )
            new_C4_list.append(_post_process_CTM_tensors(new_C4_tmp, config))

            T3_ket_projector_left = bottom_projectors.get_projector(
                x, y, 0, -1
            ).left_ket
            T3_bra_projector_left = bottom_projectors.get_projector(
                x, y, 0, -1
            ).left_bra
            T3_phys_ket_projector_left = bottom_projectors.get_projector(
                x, y, 0, 0
            ).left_phys_ket
            T3_phys_bra_projector_left = bottom_projectors.get_projector(
                x, y, 0, 0
            ).left_phys_bra
            T3_ket_projector_right = bottom_projectors.get_projector(
                x, y, 0, 0
            ).right_ket
            T3_bra_projector_right = bottom_projectors.get_projector(
                x, y, 0, 0
            ).right_bra
            T3_phys_ket_projector_right = bottom_projectors.get_projector(
                x, y, 0, 0
            ).right_phys_ket
            T3_phys_bra_projector_right = bottom_projectors.get_projector(
                x, y, 0, 0
            ).right_phys_bra

            new_T3_ket = apply_contraction_jitted(
                "ctmrg_split_transfer_absorption_bottom_T3_ket",
                [working_tensor],
                [working_tensor_obj],
                [
                    T3_ket_projector_left,
                    T3_bra_projector_left,
                    T3_phys_ket_projector_right,
                    T3_phys_bra_projector_right,
                ],
            )

            new_T3_bra = apply_contraction_jitted(
                "ctmrg_split_transfer_absorption_bottom_T3_bra",
                [working_tensor],
                [working_tensor_obj],
                [
                    T3_phys_ket_projector_left,
                    T3_phys_bra_projector_left,
                    T3_ket_projector_right,
                    T3_bra_projector_right,
                ],
            )

            new_T3_ket_list.append(_post_process_CTM_tensors(new_T3_ket, config))
            new_T3_bra_list.append(_post_process_CTM_tensors(new_T3_bra, config))

            C3_ket_projector = bottom_projectors.get_projector(x, y, 0, 0).left_ket
            C3_bra_projector = bottom_projectors.get_projector(x, y, 0, 0).left_bra
            new_C3_tmp = apply_contraction_jitted(
                "ctmrg_split_transfer_absorption_bottom_C3",
                [working_tensor],
                [working_tensor_obj],
                [C3_ket_projector, C3_bra_projector],
            )
            new_C3_list.append(_post_process_CTM_tensors(new_C3_tmp, config))

        for y, view in row_views:
            view[-1, 0] = view[-1, 0][0][0].replace_bottom_env_tensors(
                new_C4_list[y], new_T3_ket_list[y], new_T3_bra_list[y], new_C3_list[y]
            )

    return working_unitcell, smallest_S_list


def do_absorption_step_split_transfer(
    peps_tensors: Sequence[jnp.ndarray],
    unitcell: PEPS_Unit_Cell,
    config: VariPEPS_Config,
    state: VariPEPS_Global_State,
) -> PEPS_Unit_Cell:
    """
    Calculate the all CTMRG tensors after one absorption step and returns
    the updated unitcell. This functions uses the CTMRG method with split
    transfer matrices for the bra and ket layer.

    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 the all updated CTMRG tensors of
        all elements of the unitcell.
    """
    result, left_smallest_S = do_left_absorption_split_transfer(
        peps_tensors, unitcell, config, state
    )
    result, top_smallest_S = do_top_absorption_split_transfer(
        peps_tensors, result, config, state
    )
    result, right_smallest_S = do_right_absorption_split_transfer(
        peps_tensors, result, config, state
    )
    result, bottom_smallest_S = do_bottom_absorption_split_transfer(
        peps_tensors, result, config, state
    )
    norm_smallest_S = jnp.linalg.norm(
        jnp.asarray(
            left_smallest_S + top_smallest_S + right_smallest_S + bottom_smallest_S
        ),
        ord=jnp.inf,
    )

    return result, norm_smallest_S