Trajectree 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

trajectree/quimb/quimb/tensor/tensor_1d_compress.py

@@ -1,1854 +0,0 @@
-"""Generic methods for compressing 1D-like tensor networks, where the tensor
-network can locally have arbitrary structure and outer indices.
-
-- [x] the direct method
-- [x] the density matrix method
-- [x] the zip-up method
-- [x] the zip-up first method
-- [x] the 1-site variational fit method, including sums of tensor networks
-- [x] the 2-site variational fit method, including sums of tensor networks
-- [x] the local projector method (CTMRG and HOTRG style)
-- [x] the autofit method (via non-1d specific ALS or autodiff)
-
-"""
-
-import collections
-import functools
-import itertools
-import warnings
-
-from autoray import do
-
-from .tensor_arbgeom import tensor_network_apply_op_vec
-from .tensor_arbgeom_compress import tensor_network_ag_compress
-from .tensor_builder import TN_matching
-from .tensor_core import (
-    Tensor,
-    TensorNetwork,
-    ensure_dict,
-    rand_uuid,
-    tensor_contract,
-)
-
-
-def enforce_1d_like(tn, site_tags=None, fix_bonds=True, inplace=False):
-    """Check that ``tn`` is 1D-like with OBC, i.e. 1) that each tensor has
-    exactly one of the given ``site_tags``. If not, raise a ValueError. 2) That
-    there are no hyper indices. And 3) that there are only bonds within sites
-    or between nearest neighbor sites. This issue can be optionally
-    automatically fixed by inserting a string of identity tensors.
-
-    Parameters
-    ----------
-    tn : TensorNetwork
-        The tensor network to check.
-    site_tags : sequence of str, optional
-        The tags to use to group and order the tensors from ``tn``. If not
-        given, uses ``tn.site_tags``.
-    fix_bonds : bool, optional
-        Whether to fix the bond structure by inserting identity tensors.
-    inplace : bool, optional
-        Whether to perform the fix inplace or not.
-
-    Raises
-    ------
-    ValueError
-        If the tensor network is not 1D-like.
-    """
-    tn = tn if inplace else tn.copy()
-
-    if site_tags is None:
-        site_tags = tn.site_tags
-
-    tag_to_site = {tag: i for i, tag in enumerate(site_tags)}
-    tid_to_site = {}
-
-    def _check_tensor_site(tid, t):
-        if tid in tid_to_site:
-            return tid_to_site[tid]
-
-        sites = []
-        for tag in t.tags:
-            site = tag_to_site.get(tag, None)
-            if site is not None:
-                sites.append(site)
-        if len(sites) != 1:
-            raise ValueError(
-                f"{t} does not have one site tag, it has {sites}."
-            )
-
-        return sites[0]
-
-    for ix, tids in list(tn.ind_map.items()):
-        if len(tids) == 1:
-            # assume outer
-            continue
-        elif len(tids) != 2:
-            raise ValueError(
-                f"TN has a hyper index, {ix}, connecting more than 2 tensors."
-            )
-
-        tida, tidb = tids
-        ta = tn.tensor_map[tida]
-        tb = tn.tensor_map[tidb]
-
-        # get which single site each tensor belongs too
-        sa = _check_tensor_site(tida, ta)
-        sb = _check_tensor_site(tidb, tb)
-        if sa > sb:
-            sa, sb = sb, sa
-
-        if sb - sa > 1:
-            if not fix_bonds:
-                raise ValueError(
-                    f"Tensor {ta} and {tb} are not nearest "
-                    "neighbors, and `fix_bonds=False`."
-                )
-
-            # not 1d like: bond is not nearest neighbor
-            # but can insert identites along string to fix
-            data = do("eye", ta.ind_size(ix), like=ta.data)
-
-            ixl = ix
-            for i in range(sa + 1, sb):
-                ixr = rand_uuid()
-                tn |= Tensor(
-                    data=data,
-                    inds=[ixl, ixr],
-                    tags=site_tags[i],
-                )
-                ixl = ixr
-
-            tb.reindex_({ix: ixl})
-
-    return tn
-
-
-def possibly_permute_(tn, permute_arrays):
-    # possibly put the array indices in canonical order (e.g. when MPS or MPO)
-    if permute_arrays and hasattr(tn, "permute_arrays"):
-        if permute_arrays is True:
-            # use default order
-            tn.permute_arrays()
-        else:
-            # use given order
-            tn.permute_arrays(permute_arrays)
-
-
-def tensor_network_1d_compress_direct(
-    tn,
-    max_bond=None,
-    cutoff=1e-10,
-    site_tags=None,
-    normalize=False,
-    canonize=True,
-    cutoff_mode="rsum2",
-    permute_arrays=True,
-    optimize="auto-hq",
-    sweep_reverse=False,
-    equalize_norms=False,
-    inplace=False,
-    **compress_opts,
-):
-    """Compress a 1D-like tensor network using the 'direct' or 'naive' method,
-    that is, explicitly contracting site-wise to form a MPS-like TN,
-    canonicalizing in one direction, then compressing in the other. This has
-    the same scaling as the density matrix (dm) method, but a larger prefactor.
-    It can still be faster for small bond dimensions however, and is
-    potentially higher precision since it works in the space of singular values
-    directly rather than singular values squared. It is not quite optimal in
-    terms of error due to the compounding errors of the SVDs.
-
-    Parameters
-    ----------
-    tn : TensorNetwork
-        The tensor network to compress. Every tensor should have exactly one of
-        the site tags. Each site can have multiple tensors and output indices.
-    max_bond : int
-        The maximum bond dimension to compress to.
-    cutoff : float, optional
-        A dynamic threshold for discarding singular values when compressing.
-    site_tags : sequence of str, optional
-        The tags to use to group and order the tensors from ``tn``. If not
-        given, uses ``tn.site_tags``. The tensor network built will have one
-        tensor per site, in the order given by ``site_tags``.
-    normalize : bool, optional
-        Whether to normalize the final tensor network, making use of the fact
-        that the output tensor network is in right canonical form.
-    canonize : bool, optional
-        Whether to canonicalize the network in one direction before compressing
-        in the other.
-    cutoff_mode : {"rsum2", "rel", ...}, optional
-        The mode to use when truncating the singular values of the decomposed
-        tensors. See :func:`~quimb.tensor.tensor_split`.
-    permute_arrays : bool or str, optional
-        Whether to permute the array indices of the final tensor network into
-        canonical order. If ``True`` will use the default order, otherwise if a
-        string this specifies a custom order.
-    optimize : str, optional
-        The contraction path optimizer to use.
-    sweep_reverse : bool, optional
-        Whether to sweep in the reverse direction, resulting in a left
-        canonical form instead of right canonical.
-    equalize_norms : bool, optional
-        Whether to renormalize the tensors during the compression procedure.
-        If ``True`` the gathered exponent will be redistributed equally among
-        the tensors. If a float, all tensors will be renormalized to this
-        value, and the gathered exponent is tracked in ``tn.exponent`` of the
-        returned tensor network.
-    inplace : bool, optional
-        Whether to perform the compression inplace or not.
-    compress_opts
-        Supplied to :func:`~quimb.tensor.tensor_split`.
-
-    Returns
-    -------
-    TensorNetwork
-        The compressed tensor network, with canonical center at
-        ``site_tags[0]`` ('right canonical' form) or ``site_tags[-1]`` ('left
-        canonical' form) if ``sweep_reverse``.
-    """
-    if site_tags is None:
-        site_tags = tn.site_tags
-    if sweep_reverse:
-        site_tags = tuple(reversed(site_tags))
-
-    new = enforce_1d_like(tn, site_tags=site_tags, inplace=inplace)
-
-    # contract the first site group
-    new.contract_tags_(site_tags[0], optimize=optimize)
-
-    # sweep right
-    for i in range(1, len(site_tags)):
-        # contract the next site group
-        new.contract_tags_(site_tags[i], optimize=optimize)
-        #     │ │ │ │ │ │ │ │ │ │
-        #     ▶━▶━▶━▶═○─○─○─○─○─○
-        #              ╲│ │ │ │ │
-        #           : : ○─○─○─○─○
-        #         i-1 i
-
-        if canonize:
-            # shift canonical center rightwards
-            new.canonize_between(
-                site_tags[i - 1], site_tags[i], equalize_norms=equalize_norms
-            )
-            #     │ │ │ │ │ │ │ │ │ │
-            #     ▶━▶━▶━▶━▶─○─○─○─○─○
-            #              ╲│ │ │ │ │
-            #           : : ○─○─○─○─○
-            #         i-1 i
-
-    # sweep left
-    for i in range(len(site_tags) - 1, 0, -1):
-        # compress and shift canonical center leftwards
-        new.compress_between(
-            site_tags[i - 1],
-            site_tags[i],
-            absorb="left",
-            reduced="right",
-            max_bond=max_bond,
-            cutoff=cutoff,
-            cutoff_mode=cutoff_mode,
-            equalize_norms=equalize_norms,
-            **compress_opts,
-        )
-        #     │ │ │ │ │ │ │ │ │ │
-        #     ▶━▶━▶━▶━▶━▶━○─◀─◀─◀
-        #                      :
-        #                 : :  max_bond
-        #               i-1 i
-
-    if normalize:
-        # make use of the fact that the output is in right canonical form
-        t0 = new[site_tags[0]]
-        t0.normalize_()
-        new.exponent = 0.0
-    elif equalize_norms is True:
-        # redistribute the exponent equally among the tensors
-        new.equalize_norms_()
-
-    # possibly put the array indices in canonical order (e.g. when MPS or MPO)
-    possibly_permute_(new, permute_arrays)
-
-    return new
-
-
-def tensor_network_1d_compress_dm(
-    tn,
-    max_bond=None,
-    cutoff=1e-10,
-    site_tags=None,
-    normalize=False,
-    cutoff_mode="rsum1",
-    permute_arrays=True,
-    optimize="auto-hq",
-    sweep_reverse=False,
-    canonize=True,
-    equalize_norms=False,
-    inplace=False,
-    **compress_opts,
-):
-    """Compress any 1D-like tensor network using the 'density matrix' method
-    (https://tensornetwork.org/mps/algorithms/denmat_mpo_mps/).
-
-    While this has the same scaling as the direct method, in practice it can
-    often be faster, especially at large bond dimensions. Potentially there are
-    some situations where the direct method is more stable with regard to
-    precision, since the density matrix method works in the 'squared' picture.
-
-    Parameters
-    ----------
-    tn : TensorNetwork
-        The tensor network to compress. Every tensor should have exactly one of
-        the site tags. Each site can have multiple tensors and output indices.
-    max_bond : int
-        The maximum bond dimension to compress to.
-    cutoff : float, optional
-        The truncation error to use when compressing the double layer tensor
-        network.
-    site_tags : sequence of str, optional
-        The tags to use to group and order the tensors from ``tn``. If not
-        given, uses ``tn.site_tags``. The tensor network built will have one
-        tensor per site, in the order given by ``site_tags``.
-    normalize : bool, optional
-        Whether to normalize the final tensor network, making use of the fact
-        that the output tensor network is in right canonical form.
-    cutoff_mode : {"rsum1", "rel", ...}, optional
-        The mode to use when truncating the singular values of the decomposed
-        tensors. See :func:`~quimb.tensor.tensor_split`. Note for the density
-        matrix method the default 'rsum1' mode acts like 'rsum2' for the direct
-        method due to truncating in the squared space.
-    permute_arrays : bool or str, optional
-        Whether to permute the array indices of the final tensor network into
-        canonical order. If ``True`` will use the default order, otherwise if a
-        string this specifies a custom order.
-    optimize : str, optional
-        The contraction path optimizer to use.
-    sweep_reverse : bool, optional
-        Whether to sweep in the reverse direction, resulting in a left
-        canonical form instead of right canonical.
-    canonize : bool, optional
-        Dummy argument to match the signature of other compression methods.
-    equalize_norms : bool or float, optional
-        Whether to equalize the norms of the tensors after compression. If an
-        explicit value is give, then the norms will be set to that value, and
-        the overall scaling factor will be accumulated into `.exponent`.
-    inplace : bool, optional
-        Whether to perform the compression inplace or not.
-    compress_opts
-        Supplied to :func:`~quimb.tensor.tensor_split`.
-
-    Returns
-    -------
-    TensorNetwork
-        The compressed tensor network, with canonical center at
-        ``site_tags[0]`` ('right canonical' form) or ``site_tags[-1]`` ('left
-        canonical' form) if ``sweep_reverse``.
-    """
-    if not canonize:
-        warnings.warn("`canonize=False` is ignored for the `dm` method.")
-
-    if site_tags is None:
-        site_tags = tn.site_tags
-    if sweep_reverse:
-        site_tags = tuple(reversed(site_tags))
-    N = len(site_tags)
-
-    ket = enforce_1d_like(tn, site_tags=site_tags, inplace=inplace)
-
-    # partition outer indices, and create conjugate bra indices
-    ket_site_inds = []
-    bra_site_inds = []
-    ketbra_indmap = {}
-    for tag in site_tags:
-        k_inds_i = []
-        b_inds_i = []
-        for kix in ket.select(tag)._outer_inds & ket._outer_inds:
-            bix = rand_uuid()
-            k_inds_i.append(kix)
-            b_inds_i.append(bix)
-            ketbra_indmap[kix] = bix
-        ket_site_inds.append(tuple(k_inds_i))
-        bra_site_inds.append(tuple(b_inds_i))
-
-    bra = ket.H
-    # doing this means forming the norm doesn't do its own mangling
-    bra.mangle_inner_()
-    # form the overlapping double layer TN
-    norm = bra & ket
-    # open the bra's indices back up
-    bra.reindex_(ketbra_indmap)
-
-    # construct dense left environments
-    left_envs = {}
-    left_envs[1] = norm.select(site_tags[0]).contract(
-        optimize=optimize, drop_tags=True
-    )
-    for i in range(2, N):
-        left_envs[i] = tensor_contract(
-            left_envs[i - 1],
-            *norm.select_tensors(site_tags[i - 1]),
-            optimize=optimize,
-            drop_tags=True,
-        )
-
-    # build projectors and right environments
-    Us = []
-    right_env_ket = None
-    right_env_bra = None
-    new_bonds = collections.defaultdict(rand_uuid)
-
-    for i in range(N - 1, 0, -1):
-        # form the reduced density matrix
-        rho_tensors = [
-            left_envs[i],
-            *ket.select_tensors(site_tags[i]),
-            *bra.select_tensors(site_tags[i]),
-        ]
-        left_inds = list(ket_site_inds[i])
-        right_inds = list(bra_site_inds[i])
-        if right_env_ket is not None:
-            rho_tensors.extend([right_env_ket, right_env_bra])
-            left_inds.append(new_bonds["k", i + 1])
-            right_inds.append(new_bonds["b", i + 1])
-
-        # contract and then split it
-        rhoi = tensor_contract(
-            *rho_tensors,
-            preserve_tensor=True,
-            optimize=optimize,
-        )
-        U, s, UH = rhoi.split(
-            left_inds=left_inds,
-            right_inds=right_inds,
-            method="eigh",
-            max_bond=max_bond,
-            cutoff=cutoff,
-            cutoff_mode=cutoff_mode,
-            get="tensors",
-            absorb=None,
-            **compress_opts,
-        )
-
-        # turn bond into 'virtual right' indices
-        (bix,) = s.inds
-        U.reindex_({bix: new_bonds["k", i]})
-        UH.reindex_({bix: new_bonds["b", i]})
-        Us.append(U)
-
-        # attach the unitaries to the right environments and contract
-        right_ket_tensors = [*ket.select_tensors(site_tags[i]), U.H]
-        right_bra_tensors = [*bra.select_tensors(site_tags[i]), UH.H]
-        if right_env_ket is not None:
-            # we have already done one move -> have right envs
-            right_ket_tensors.append(right_env_ket)
-            right_bra_tensors.append(right_env_bra)
-
-        right_env_ket = tensor_contract(
-            *right_ket_tensors, optimize=optimize, drop_tags=True
-        )
-        # TODO: could compute this just as conjugated and relabelled ket env
-        right_env_bra = tensor_contract(
-            *right_bra_tensors, optimize=optimize, drop_tags=True
-        )
-
-    # form the final site
-    U0 = tensor_contract(
-        *ket.select_tensors(site_tags[0]), right_env_ket, optimize=optimize
-    )
-
-    if normalize:
-        # in right canonical form already
-        U0.normalize_()
-
-    # form the final TN
-    if inplace:
-        # simply replace all tensors
-        new = tn
-        new.remove_all_tensors()
-        new |= U0
-        for t in Us[::-1]:
-            new |= t
-    else:
-        new = TensorNetwork([U0] + Us[::-1])
-        # cast as whatever the input was e.g. MPS, MPO
-        new.view_like_(tn)
-
-    # possibly put the array indices in canonical order (e.g. when MPS or MPO)
-    possibly_permute_(new, permute_arrays)
-
-    # XXX: do better than simply waiting til the end to equalize norms
-    if equalize_norms is True:
-        new.equalize_norms_()
-    elif equalize_norms:
-        new.equalize_norms_(value=equalize_norms)
-
-    return new
-
-
-def tensor_network_1d_compress_zipup(
-    tn,
-    max_bond=None,
-    cutoff=1e-10,
-    site_tags=None,
-    canonize=True,
-    normalize=False,
-    cutoff_mode="rsum2",
-    permute_arrays=True,
-    optimize="auto-hq",
-    sweep_reverse=False,
-    equalize_norms=False,
-    inplace=False,
-    **compress_opts,
-):
-    """Compress a 1D-like tensor network using the 'zip-up' algorithm due to
-    'Minimally Entangled Typical Thermal State Algorithms', E.M. Stoudenmire &
-    Steven R. White (https://arxiv.org/abs/1002.1305). The returned tensor
-    network will have one tensor per site, in the order given by ``site_tags``,
-    with canonical center at ``site_tags[0]`` ('right' canonical form).
-
-    The zipup algorithm scales better than the direct and density matrix
-    methods when multiple tensors are present at each site (such as MPO-MPS
-    multiplication), but is less accurate due to the compressions taking place
-    in an only pseudo-canonical gauge. It generally also only makes sense in
-    the fixed bond dimension case, as opposed to relying on a specific
-    `cutoff` only.
-
-    Parameters
-    ----------
-    tn : TensorNetwork
-        The tensor network to compress. Every tensor should have exactly one of
-        the site tags. Each site can have multiple tensors and output indices.
-    max_bond : int
-        The maximum bond dimension to compress to.
-    cutoff : float, optional
-        A dynamic threshold for discarding singular values when compressing.
-    site_tags : sequence of str, optional
-        The tags to use to group and order the tensors from ``tn``. If not
-        given, uses ``tn.site_tags``. The tensor network built will have one
-        tensor per site, in the order given by ``site_tags``.
-    canonize : bool, optional
-        Whether to pseudo canonicalize the initial tensor network.
-    normalize : bool, optional
-        Whether to normalize the final tensor network, making use of the fact
-        that the output tensor network is in right canonical form.
-    cutoff_mode : {"rsum2", "rel", ...}, optional
-        The mode to use when truncating the singular values of the decomposed
-        tensors. See :func:`~quimb.tensor.tensor_split`.
-    permute_arrays : bool or str, optional
-        Whether to permute the array indices of the final tensor network into
-        canonical order. If ``True`` will use the default order, otherwise if a
-        string this specifies a custom order.
-    optimize : str, optional
-        The contraction path optimizer to use.
-    sweep_reverse : bool, optional
-        Whether to sweep in the reverse direction, resulting in a left
-        canonical form instead of right canonical.
-    equalize_norms : bool or float, optional
-        Whether to equalize the norms of the tensors after compression. If an
-        explicit value is give, then the norms will be set to that value, and
-        the overall scaling factor will be accumulated into `.exponent`.
-    inplace : bool, optional
-        Whether to perform the compression inplace or not.
-    compress_opts
-        Supplied to :func:`~quimb.tensor.tensor_split`.
-
-    Returns
-    -------
-    TensorNetwork
-        The compressed tensor network, with canonical center at
-        ``site_tags[0]`` ('right canonical' form) or ``site_tags[-1]`` ('left
-        canonical' form) if ``sweep_reverse``.
-    """
-    if site_tags is None:
-        site_tags = tn.site_tags
-    if sweep_reverse:
-        site_tags = tuple(reversed(site_tags))
-    N = len(site_tags)
-
-    tn = enforce_1d_like(tn, site_tags=site_tags, inplace=inplace)
-
-    # calculate the local site (outer) indices
-    site_inds = [
-        tuple(tn.select(tag)._outer_inds & tn._outer_inds) for tag in site_tags
-    ]
-
-    if canonize:
-        # put in 'pseudo' left canonical form:
-        # (NB: diagrams assume MPO-MPS but algorithm is agnostic)
-        #
-        #     │ │ │ │ │ │ │ │ │ │
-        #     ▶─▶─▶─▶─▶─▶─▶─▶─▶─○  MPO
-        #     │ │ │ │ │ │ │ │ │ │
-        #     ▶─▶─▶─▶─▶─▶─▶─▶─▶─○  MPS
-        #
-        tn = tn.canonize_around_(site_tags[-1])
-
-    # zip along the bonds
-    ts = []
-    bix = None
-    Us = None
-    for i in range(N - 1, 0, -1):
-        #          U*s VH
-        #      │ │     │ │
-        #     ─▶─▶──□━━◀━◀━
-        #      │ │ ╱    :
-        #     ─▶─▶    max_bond
-        #        i
-        #        .... contract
-        if Us is None:
-            # first site
-            C = tensor_contract(
-                *tn.select_tensors(site_tags[i]), optimize=optimize
-            )
-        else:
-            C = tensor_contract(
-                Us, *tn.select_tensors(site_tags[i]), optimize=optimize
-            )
-        #         i
-        #      │  │    │ │
-        #     ─▶──□━━━━◀━◀━
-        #      │ ╱   :
-        #     ─▶  :  bix
-        #         C
-        right_inds = list(site_inds[i])
-        if bix is not None:
-            right_inds.append(bix)
-
-        # the new bond index, keep track for above
-        bix = rand_uuid()
-
-        Us, VH = C.split(
-            left_inds=None,
-            right_inds=right_inds,
-            max_bond=max_bond,
-            cutoff=cutoff,
-            cutoff_mode=cutoff_mode,
-            absorb="left",
-            bond_ind=bix,
-            get="tensors",
-            **compress_opts,
-        )
-        Us.drop_tags()
-        ts.append(VH)
-        #           i
-        #      │    │  │ │
-        #     ─▶──□━◀━━◀━◀━
-        #      │ ╱
-        #     ─▶  : :
-        #       U*s VH
-
-    U0 = tensor_contract(
-        Us, *tn.select_tensors(site_tags[0]), optimize=optimize
-    )
-
-    if normalize:
-        # in right canonical form already
-        U0.normalize_()
-
-    ts.append(U0)
-
-    if inplace:
-        new = tn
-        new.remove_all_tensors()
-        for t in ts:
-            new |= t
-    else:
-        new = TensorNetwork(ts)
-        # cast as whatever the input was e.g. MPS
-        new.view_like_(tn)
-
-    # possibly put the array indices in canonical order (e.g. when MPS or MPO)
-    possibly_permute_(new, permute_arrays)
-
-    # XXX: do better than simply waiting til the end to equalize norms
-    if equalize_norms is True:
-        new.equalize_norms_()
-    elif equalize_norms:
-        new.equalize_norms_(value=equalize_norms)
-
-    return new
-
-
-def tensor_network_1d_compress_zipup_first(
-    tn,
-    max_bond=None,
-    max_bond_zipup=None,
-    cutoff=1e-10,
-    cutoff_zipup=None,
-    site_tags=None,
-    canonize=True,
-    normalize=False,
-    cutoff_mode="rsum2",
-    permute_arrays=True,
-    optimize="auto-hq",
-    sweep_reverse=False,
-    equalize_norms=False,
-    inplace=False,
-    **compress_opts,
-):
-    """Compress this 1D-like tensor network using the 'zip-up first' algorithm,
-    that is, first compressing the tensor network to a larger bond dimension
-    using the 'zip-up' algorithm, then compressing to the desired bond
-    dimension using a direct sweep.
-
-    Depending on the value of ``max_bond`` and ``max_bond_zipup``, this can be
-    scale better than the direct and density matrix methods, but reach close to
-    the same accuracy. As with the 'zip-up' method, there is no advantage
-    unless there are multiple tensors per site, and it generally only makes
-    sense in the fixed bond dimension case, as opposed to relying on a
-    specific `cutoff` only.
-
-    Parameters
-    ----------
-    tn : TensorNetwork
-        The tensor network to compress. Every tensor should have exactly one of
-        the site tags. Each site can have multiple tensors and output indices.
-    max_bond : int
-        The final maximum bond dimension to compress to.
-    max_bond_zipup : int, optional
-        The intermediate maximum bond dimension to compress to using the
-        'zip-up' algorithm. If not given and `max_bond` is, this is set as
-        twice the target bond dimension, ``2 * max_bond``.
-    cutoff : float, optional
-        A dynamic threshold for discarding singular values when compressing.
-    cutoff_zipup : float, optional
-        A dynamic threshold for discarding singular values when compressing to
-        the intermediate bond dimension using the 'zip-up' algorithm. If not
-        given, this is set to the same as ``cutoff`` if a maximum bond is
-        given, else ``cutoff / 10``.
-    site_tags : sequence of str, optional
-        The tags to use to group and order the tensors from ``tn``. If not
-        given, uses ``tn.site_tags``. The tensor network built will have one
-        tensor per site, in the order given by ``site_tags``.
-    canonize : bool, optional
-        Whether to pseudo canonicalize the initial tensor network.
-    normalize : bool, optional
-        Whether to normalize the final tensor network, making use of the fact
-        that the output tensor network is in right canonical form.
-    cutoff_mode : {"rsum2", "rel", ...}, optional
-        The mode to use when truncating the singular values of the decomposed
-        tensors. See :func:`~quimb.tensor.tensor_split`.
-    permute_arrays : bool or str, optional
-        Whether to permute the array indices of the final tensor network into
-        canonical order. If ``True`` will use the default order, otherwise if a
-        string this specifies a custom order.
-    optimize : str, optional
-        The contraction path optimizer to use.
-    sweep_reverse : bool, optional
-        Whether to sweep in the reverse direction, resulting in a left
-        canonical form instead of right canonical.
-    equalize_norms : bool or float, optional
-        Whether to equalize the norms of the tensors after compression. If an
-        explicit value is give, then the norms will be set to that value, and
-        the overall scaling factor will be accumulated into `.exponent`.
-    inplace : bool, optional
-        Whether to perform the compression inplace or not.
-    compress_opts
-        Supplied to :func:`~quimb.tensor.tensor_split`.
-
-    Returns
-    -------
-    TensorNetwork
-        The compressed tensor network, with canonical center at
-        ``site_tags[0]`` ('right canonical' form) or ``site_tags[-1]`` ('left
-        canonical' form) if ``sweep_reverse``.
-    """
-    if max_bond_zipup is None:
-        if max_bond is not None:
-            max_bond_zipup = 2 * max_bond
-
-    if cutoff_zipup is None:
-        if max_bond is not None:
-            # assume max_bond limited
-            cutoff_zipup = cutoff
-        else:
-            # fully dynamic mode
-            cutoff_zipup = cutoff / 10
-
-    if site_tags is None:
-        site_tags = tn.site_tags
-    if sweep_reverse:
-        site_tags = tuple(reversed(site_tags))
-
-    # is now in right canonical form
-    tn = tensor_network_1d_compress_zipup(
-        tn,
-        max_bond=max_bond_zipup,
-        cutoff=cutoff_zipup,
-        site_tags=site_tags,
-        canonize=canonize,
-        cutoff_mode=cutoff_mode,
-        optimize=optimize,
-        sweep_reverse=True,
-        equalize_norms=equalize_norms,
-        inplace=inplace,
-        **compress_opts,
-    )
-
-    for i in range(len(site_tags) - 1, 0, -1):
-        # compress and shift canonical center
-        tn.compress_between(
-            site_tags[i - 1],
-            site_tags[i],
-            absorb="left",
-            reduced="right",
-            max_bond=max_bond,
-            cutoff=cutoff,
-            cutoff_mode=cutoff_mode,
-            equalize_norms=equalize_norms,
-            **compress_opts,
-        )
-
-    if normalize:
-        # make use of the fact that the output is in right canonical form
-        tn[site_tags[-1]].normalize_()
-
-    # possibly put the array indices in canonical order (e.g. when MPS or MPO)
-    possibly_permute_(tn, permute_arrays)
-
-    if equalize_norms is True:
-        tn.equalize_norms_()
-    elif equalize_norms:
-        tn.equalize_norms_(value=equalize_norms)
-
-    return tn
-
-
-def _tn1d_fit_sum_sweep_1site(
-    tn_fit,
-    tn_overlaps,
-    site_tags,
-    max_bond=None,
-    cutoff=0.0,
-    envs=None,
-    prepare=True,
-    reverse=False,
-    compute_tdiff=True,
-    optimize="auto-hq",
-):
-    """Core sweep of the 1-site 1D fit algorithm."""
-
-    if cutoff != 0.0:
-        raise ValueError("Non-zero `cutoff` not supported for 1-site fit.")
-
-    N = len(site_tags)
-    K = len(tn_overlaps)
-
-    if max_bond is not None:
-        current_bond_dim = tn_fit.max_bond()
-        if current_bond_dim < max_bond:
-            tn_fit.expand_bond_dimension_(max_bond)
-            prepare = True
-
-    if envs is None:
-        envs = {}
-        prepare = True
-
-    if prepare:
-        for k in range(K):
-            envs.setdefault(("L", 0, k), TensorNetwork())
-            envs.setdefault(("R", N - 1, k), TensorNetwork())
-
-        if not reverse:
-            # move canonical center to left
-            tn_fit.canonize_around_(site_tags[0])
-            # compute each of K right environments
-            for i in reversed(range(N - 1)):
-                site_r = site_tags[i + 1]
-                for k, tn_overlap in enumerate(tn_overlaps):
-                    tni = envs["R", i + 1, k] | tn_overlap.select(site_r)
-                    envs["R", i, k] = tni.contract(all, optimize=optimize)
-        else:
-            # move canonical center to right
-            tn_fit.canonize_around_(site_tags[-1])
-            # compute each of K left environments
-            for i in range(1, N):
-                site_l = site_tags[i - 1]
-                for k, tn_overlap in enumerate(tn_overlaps):
-                    tni = envs["L", i - 1, k] | tn_overlap.select(site_l)
-                    envs["L", i, k] = tni.contract(all, optimize=optimize)
-
-    # track the maximum change in any tensor norm
-    max_tdiff = -1.0
-
-    sweep = range(N)
-    if reverse:
-        sweep = reversed(sweep)
-
-    for i in sweep:
-        site = site_tags[i]
-
-        if not reverse:
-            if i > 0:
-                # move canonical center
-                site_l = site_tags[i - 1]
-                tn_fit.canonize_between(site_l, site)
-
-                # recalculate K left environments
-                for k, tn_overlap in enumerate(tn_overlaps):
-                    tni = envs["L", i - 1, k] | tn_overlap.select(site_l)
-                    envs["L", i, k] = tni.contract(all, optimize=optimize)
-        else:
-            if i < N - 1:
-                # move canonical center
-                site_r = site_tags[i + 1]
-                tn_fit.canonize_between(site_r, site)
-
-                # recalculate right environment
-                for k, tn_overlap in enumerate(tn_overlaps):
-                    tni = envs["R", i + 1, k] | tn_overlap.select(site_r)
-                    envs["R", i, k] = tni.contract(all, optimize=optimize)
-
-        tfi = tn_fit[site_tags[i]]
-        tfinew = None
-
-        for k, tn_overlap in enumerate(tn_overlaps):
-            # form local overlap
-            tnik = (
-                envs["L", i, k]
-                | tn_overlap.select_any(site_tags[i])
-                | envs["R", i, k]
-            )
-
-            # remove old tensor
-            del tnik["__FIT__", site]
-
-            # contract its new value, maintaining index order
-            tfiknew = tnik.contract(
-                all, optimize=optimize, output_inds=tfi.inds
-            )
-
-            # sum into fitted tensor
-            if tfinew is None:
-                tfinew = tfiknew
-            else:
-                tfinew += tfiknew
-
-        tfinew.conj_()
-
-        if compute_tdiff:
-            # track change in tensor norm
-            dt = tfi.distance_normalized(tfinew)
-            max_tdiff = max(max_tdiff, dt)
-
-        # reinsert into all viewing tensor networks
-        tfi.modify(data=tfinew.data)
-
-    return max_tdiff
-
-
-def _tn1d_fit_sum_sweep_2site(
-    tn_fit,
-    tn_overlaps,
-    site_tags,
-    max_bond=None,
-    cutoff=1e-10,
-    envs=None,
-    prepare=True,
-    reverse=False,
-    optimize="auto-hq",
-    compute_tdiff=True,
-    **compress_opts,
-):
-    """Core sweep of the 2-site 1D fit algorithm."""
-
-    N = len(site_tags)
-    K = len(tn_overlaps)
-
-    if envs is None:
-        envs = {}
-        prepare = True
-
-    if prepare:
-        for k in range(K):
-            envs.setdefault(("L", 0, k), TensorNetwork())
-            envs.setdefault(("R", N - 1, k), TensorNetwork())
-
-        if not reverse:
-            # move canonical center to left
-            tn_fit.canonize_around_(site_tags[0])
-            # compute each of K right environments
-            for i in range(N - 2, 0, -1):
-                site_r = site_tags[i + 1]
-                for k, tn_overlap in enumerate(tn_overlaps):
-                    tni = envs["R", i + 1, k] | tn_overlap.select(site_r)
-                    envs["R", i, k] = tni.contract(all, optimize=optimize)
-        else:
-            # move canonical center to right
-            tn_fit.canonize_around_(site_tags[-1])
-            # compute each of K left environments
-            for i in range(1, N - 1):
-                site_l = site_tags[i - 1]
-                for k, tn_overlap in enumerate(tn_overlaps):
-                    tni = envs["L", i - 1, k] | tn_overlap.select(site_l)
-                    envs["L", i, k] = tni.contract(all, optimize=optimize)
-
-    # track the maximum change in any tensor norm
-    max_tdiff = -1.0
-
-    sweep = range(N - 1)
-    if reverse:
-        sweep = reversed(sweep)
-
-    for i in sweep:
-        site0 = site_tags[i]
-        site1 = site_tags[i + 1]
-
-        if not reverse:
-            if i > 0:
-                site_l = site_tags[i - 1]
-                # recalculate K left environments
-                for k, tn_overlap in enumerate(tn_overlaps):
-                    tni = envs["L", i - 1, k] | tn_overlap.select(site_l)
-                    envs["L", i, k] = tni.contract(all, optimize=optimize)
-        else:
-            if i < N - 2:
-                site_r = site_tags[i + 2]
-                # recalculate right environment
-                for k, tn_overlap in enumerate(tn_overlaps):
-                    tni = envs["R", i + 2, k] | tn_overlap.select(site_r)
-                    envs["R", i + 1, k] = tni.contract(all, optimize=optimize)
-
-        tfi0 = tn_fit[site0]
-        tfi1 = tn_fit[site1]
-        (bond,) = tfi0.bonds(tfi1)
-        left_inds = tuple(ix for ix in tfi0.inds if ix != bond)
-        right_inds = tuple(ix for ix in tfi1.inds if ix != bond)
-        tfinew = None
-
-        for k, tn_overlap in enumerate(tn_overlaps):
-            # form local overlap
-            tnik = (
-                envs["L", i, k]
-                | tn_overlap.select_any((site0, site1))
-                | envs["R", i + 1, k]
-            )
-
-            # remove old tensors
-            del tnik["__FIT__", site0]
-            del tnik["__FIT__", site1]
-
-            # contract its new value, maintaining index order
-            tfiknew = tnik.contract(
-                all, optimize=optimize, output_inds=left_inds + right_inds
-            )
-
-            # sum into fitted tensor
-            if tfinew is None:
-                tfinew = tfiknew
-            else:
-                tfinew += tfiknew
-
-        tfinew.conj_()
-
-        tfinew0, tfinew1 = tfinew.split(
-            max_bond=max_bond,
-            cutoff=cutoff,
-            absorb="left" if reverse else "right",
-            left_inds=left_inds,
-            right_inds=right_inds,
-            bond_ind=bond,
-            get="tensors",
-            **compress_opts,
-        )
-
-        if compute_tdiff:
-            # track change in tensor norm
-            dt = (tfi0 | tfi1).distance_normalized(tfinew0 | tfinew1)
-            max_tdiff = max(max_tdiff, dt)
-
-        # reinsert into all viewing tensor networks
-        tfinew0.transpose_like_(tfi0)
-        tfinew1.transpose_like_(tfi1)
-        tfi0.modify(data=tfinew0.data, left_inds=tfinew0.left_inds)
-        tfi1.modify(data=tfinew1.data, left_inds=tfinew1.left_inds)
-
-    return max_tdiff
-
-
-def tensor_network_1d_compress_fit(
-    tns,
-    max_bond=None,
-    cutoff=None,
-    tn_fit=None,
-    bsz="auto",
-    initial_bond_dim=8,
-    max_iterations=10,
-    tol=0.0,
-    site_tags=None,
-    cutoff_mode="rsum2",
-    sweep_sequence="RL",
-    normalize=False,
-    permute_arrays=True,
-    optimize="auto-hq",
-    canonize=True,
-    sweep_reverse=False,
-    equalize_norms=False,
-    inplace_fit=False,
-    inplace=False,
-    progbar=False,
-    **compress_opts,
-):
-    """Compress any 1D-like (can have multiple tensors per site) tensor network
-    or sum of tensor networks to an exactly 1D (one tensor per site) tensor
-    network of bond dimension `max_bond` using the 1-site or 2-site variational
-    fitting (or 'DMRG-style') method. The tensor network(s) can have arbitrary
-    inner and outer structure.
-
-    This method has the lowest scaling of the standard 1D compression methods
-    and can also provide the most accurate compression, but the actual speed
-    and accuracy depend on the number of iterations required and initial guess,
-    making it a more 'hands-on' method.
-
-    It's also the only method to support fitting to a sum of tensor networks
-    directly, rather than having to forming the explicitly summed TN first.
-
-    Parameters
-    ----------
-    tns : TensorNetwork or Sequence[TensorNetwork]
-        The tensor network or tensor networks to compress. Each tensor network
-        should have the same outer index structure, and within each tensor
-        network every tensor should have exactly one of the site tags.
-    max_bond : int
-        The maximum bond dimension to compress to. If not given, this is set
-        as the maximum bond dimension of the initial guess tensor network, if
-        any, else infinite for ``bsz=2``.
-    cutoff : float, optional
-        A dynamic threshold for discarding singular values when compressing.
-        This is only relevant for the 2-site sweeping algorithm (``bsz=2``),
-        where it defaults to 1e-10.
-    tn_fit : TensorNetwork, dict, or str, optional
-        An initial guess for the compressed tensor network. It should matching
-        outer indices and site tags with ``tn``. If a `dict`, this is assumed
-        to be options to supply to `tensor_network_1d_compress` to construct
-        the initial guess, inheriting various defaults like `initial_bond_dim`.
-        If a string, e.g. ``"zipup"``, this is shorthand for that compression
-        method with default settings. If not given, a random 1D tensor network
-        will be used.
-    bsz : {"auto", 1, 2}, optional
-        The size of the block to optimize while sweeping. If ``"auto"``, this
-        will be inferred from the value of ``max_bond`` and ``cutoff``.
-    initial_bond_dim : int, optional
-        The initial bond dimension to use when creating the initial guess. This
-        is only relevant if ``tn_fit`` is not given. For each sweep the allowed
-        bond dimension is doubled, up to ``max_bond``. For 1-site this occurs
-        via explicit bond expansion, while for 2-site it occurs during the
-        2-site tensor decomposition.
-    max_iterations : int, optional
-        The maximum number of variational sweeps to perform.
-    tol : float, optional
-        The convergence tolerance, in terms of local tensor distance
-        normalized. If zero, there will be exactly ``max_iterations`` sweeps.
-    site_tags : sequence of str, optional
-        The tags to use to group and order the tensors from ``tn``. If not
-        given, uses ``tn.site_tags``. The tensor network built will have one
-        tensor per site, in the order given by ``site_tags``.
-    cutoff_mode : {"rsum2", "rel", ...}, optional
-        The mode to use when truncating the singular values of the decomposed
-        tensors. See :func:`~quimb.tensor.tensor_split`, if using the 2-site
-        sweeping algorithm.
-    sweep_sequence : str, optional
-        The sequence of sweeps to perform, e.g. ``"LR"`` means first sweep left
-        to right, then right to left. The sequence is cycled.
-    normalize : bool, optional
-        Whether to normalize the final tensor network, making use of the fact
-        that the output tensor network is in left or right canonical form.
-    permute_arrays : bool or str, optional
-        Whether to permute the array indices of the final tensor network into
-        canonical order. If ``True`` will use the default order, otherwise if a
-        string this specifies a custom order.
-    optimize : str, optional
-        The contraction path optimizer to use.
-    canonize : bool, optional
-        Dummy argument to match the signature of other compression methods.
-    sweep_reverse : bool, optional
-        Whether to sweep in the reverse direction, swapping whether the final
-        tensor network is in right or left canonical form, which also depends
-        on the last sweep direction.
-    equalize_norms : bool or float, optional
-        Whether to equalize the norms of the tensors after compression. If an
-        explicit value is give, then the norms will be set to that value, and
-        the overall scaling factor will be accumulated into `.exponent`.
-    inplace_fit : bool, optional
-        Whether to perform the compression inplace on the initial guess tensor
-        network, ``tn_fit``, if supplied.
-    inplace : bool, optional
-        Whether to perform the compression inplace on the target tensor network
-        supplied, or ``tns[0]`` if a sequence to sum is supplied.
-    progbar : bool, optional
-        Whether to show a progress bar. Note the progress bar shows the maximum
-        change of any single tensor norm, *not* the global change in norm or
-        truncation error.
-    compress_opts
-        Supplied to :func:`~quimb.tensor.tensor_split`, if using the 2-site
-        sweeping algorithm.
-
-    Returns
-    -------
-    TensorNetwork
-        The compressed tensor network. Depending on ``sweep_reverse`` and the
-        last sweep direction, the canonical center will be at either L:
-        ``site_tags[0]`` or R: ``site_tags[-1]``, or the opposite if
-        ``sweep_reverse``.
-    """
-    if not canonize:
-        warnings.warn("`canonize=False` is ignored for the `fit` method.")
-
-    if isinstance(tns, TensorNetwork):
-        # fit to single tensor network
-        tns = (tns,)
-    else:
-        # fit to sum of tensor networks
-        tns = tuple(tns)
-
-    # how to partition the tensor network(s)
-    if site_tags is None:
-        site_tags = next(
-            tn.site_tags for tn in tns if hasattr(tn, "site_tags")
-        )
-
-    tns = tuple(
-        enforce_1d_like(tn, site_tags=site_tags, inplace=inplace) for tn in tns
-    )
-
-    # choose the block size of the sweeping function
-    if bsz == "auto":
-        if max_bond is not None:
-            if (cutoff is None) or (cutoff == 0.0):
-                # max_bond specified, no cutoff -> 1-site
-                bsz = 1
-            else:
-                # max_bond and cutoff specified -> 2-site
-                bsz = 2
-        else:
-            if cutoff == 0.0:
-                # no max_bond or cutoff -> 1-site
-                bsz = 1
-            else:
-                # no max_bond, but cutoff -> 2-site
-                bsz = 2
-    f_sweep = {
-        1: _tn1d_fit_sum_sweep_1site,
-        2: _tn1d_fit_sum_sweep_2site,
-    }[bsz]
-
-    if cutoff is None:
-        # set default cutoff
-        cutoff = 1e-10 if bsz == 2 else 0.0
-
-    if bsz == 2:
-        compress_opts["cutoff_mode"] = cutoff_mode
-
-    # choose our initial guess
-    if not isinstance(tn_fit, TensorNetwork):
-        if max_bond is None:
-            if bsz == 1:
-                raise ValueError(
-                    "Need to specify at least one of `max_bond` "
-                    "or `tn_fit` when using 1-site sweeping."
-                )
-            max_bond = float("inf")
-            current_bond_dim = initial_bond_dim
-        else:
-            # don't start larger than the target bond dimension
-            current_bond_dim = min(initial_bond_dim, max_bond)
-
-        if tn_fit is None:
-            # random initial guess
-            tn_fit = TN_matching(
-                tns[0], max_bond=current_bond_dim, site_tags=site_tags
-            )
-        else:
-            if isinstance(tn_fit, str):
-                tn_fit = {"method": tn_fit}
-            tn_fit.setdefault("max_bond", current_bond_dim)
-            tn_fit.setdefault("cutoff", cutoff)
-            tn_fit.setdefault("site_tags", site_tags)
-            tn_fit.setdefault("optimize", optimize)
-            tn_fit = tensor_network_1d_compress(tns[0], **tn_fit)
-            inplace_fit = True
-    else:
-        # a guess was supplied
-        current_bond_dim = tn_fit.max_bond()
-        if max_bond is None:
-            # assume we want to limit bond dimension to the initial guess
-            max_bond = current_bond_dim
-
-    # choose to conjugte the smaller fitting network
-    tn_fit = tn_fit.conj(inplace=inplace_fit)
-    tn_fit.add_tag("__FIT__")
-    # note these are all views of `tn_fit` and thus will update as it does
-    tn_overlaps = [(tn_fit | tn) for tn in tns]
-
-    if any(tn_overlap.outer_inds() for tn_overlap in tn_overlaps):
-        raise ValueError(
-            "The outer indices of one or more of "
-            "`tns` and `tn_fit` don't seem to match."
-        )
-
-    sweeps = itertools.cycle(sweep_sequence)
-    if max_iterations is None:
-        its = itertools.count()
-    else:
-        its = range(max_iterations)
-
-    envs = {}
-    old_direction = ""
-
-    if progbar:
-        from quimb.utils import progbar as ProgBar
-
-        its = ProgBar(its, total=max_iterations)
-
-    # whether to compute the maximum change in tensor norm
-    compute_tdiff = (tol != 0.0) or progbar
-
-    try:
-        for i in its:
-            next_direction = next(sweeps)
-            reverse = {"R": False, "L": True}[next_direction]
-            if sweep_reverse:
-                reverse = not reverse
-
-            if current_bond_dim < max_bond:
-                # double bond dimension, up to max_bond
-                current_bond_dim = min(2 * current_bond_dim, max_bond)
-
-            # perform a single sweep
-            max_tdiff = f_sweep(
-                tn_fit,
-                tn_overlaps,
-                max_bond=current_bond_dim,
-                cutoff=cutoff,
-                envs=envs,
-                prepare=(i == 0) or (next_direction == old_direction),
-                site_tags=site_tags,
-                reverse=reverse,
-                optimize=optimize,
-                compute_tdiff=compute_tdiff,
-                **compress_opts,
-            )
-
-            if progbar:
-                its.set_description(f"max_tdiff={max_tdiff:.2e}")
-            if tol != 0.0 and max_tdiff < tol:
-                # converged
-                break
-
-            old_direction = next_direction
-    except KeyboardInterrupt:
-        pass
-    finally:
-        if progbar:
-            its.close()
-
-    tn_fit.drop_tags("__FIT__")
-    tn_fit.conj_()
-
-    if normalize:
-        if reverse:
-            tn_fit[site_tags[0]].normalize_()
-        else:
-            tn_fit[site_tags[-1]].normalize_()
-
-    if inplace:
-        tn0 = tns[0]
-        tn0.remove_all_tensors()
-        tn0.add_tensor_network(
-            tn_fit, virtual=not inplace_fit, check_collisions=False
-        )
-        tn_fit = tn0
-
-    # possibly put the array indices in canonical order (e.g. when MPS or MPO)
-    possibly_permute_(tn_fit, permute_arrays)
-
-    # XXX: do better than simply waiting til the end to equalize norms
-    if equalize_norms is True:
-        tn_fit.equalize_norms_()
-    elif equalize_norms:
-        tn_fit.equalize_norms_(value=equalize_norms)
-
-    return tn_fit
-
-
-def tensor_network_1d_compress_fit_guess(
-    tn,
-    guess,
-    max_bond=None,
-    cutoff=1e-10,
-    cutoff_fit=0.0,
-    bsz=1,
-    max_iterations=8,
-    canonize=True,
-    **kwargs,
-):
-    """Compress any 1D-like (can have multiple tensors per site) tensor network
-    to an exactly 1D (one tensor per site) tensor network of bond dimension
-    `max_bond` using by default 1-site variational fitting (or 'DMRG-style')
-    method starting with a non-random guess tensor network, e.g. from the cheap
-    zip-up or projector methods.
-    """
-    tn_fit = {
-        "method": guess,
-        # use cutoff in guess, but not in fitting
-        "cutoff": cutoff,
-        "canonize": canonize,
-    }
-
-    return tensor_network_1d_compress_fit(
-        tn,
-        max_bond=max_bond,
-        cutoff=cutoff_fit,
-        tn_fit=tn_fit,
-        bsz=bsz,
-        max_iterations=max_iterations,
-        inplace_fit=True,
-        **kwargs,
-    )
-
-
-tensor_network_1d_compress_fit_zipup = functools.partial(
-    tensor_network_1d_compress_fit_guess, guess="zipup"
-)
-tensor_network_1d_compress_fit_projector = functools.partial(
-    tensor_network_1d_compress_fit_guess, guess="projector"
-)
-
-
-_TN1D_COMPRESS_METHODS = {
-    "direct": tensor_network_1d_compress_direct,
-    "dm": tensor_network_1d_compress_dm,
-    "zipup": tensor_network_1d_compress_zipup,
-    "zipup-first": tensor_network_1d_compress_zipup_first,
-    "fit": tensor_network_1d_compress_fit,
-    "fit-zipup": tensor_network_1d_compress_fit_zipup,
-    "fit-projector": tensor_network_1d_compress_fit_projector,
-}
-
-
-def tensor_network_1d_compress(
-    tn,
-    max_bond=None,
-    cutoff=1e-10,
-    method="dm",
-    site_tags=None,
-    canonize=True,
-    permute_arrays=True,
-    optimize="auto-hq",
-    sweep_reverse=False,
-    equalize_norms=False,
-    compress_opts=None,
-    inplace=False,
-    **kwargs,
-):
-    """Compress a 1D-like tensor network using the specified method.
-
-    Parameters
-    ----------
-    tn : TensorNetwork
-        The tensor network to compress. Every tensor should have exactly one of
-        the site tags. Each site can have multiple tensors and output indices.
-    max_bond : int
-        The maximum bond dimension to compress to.
-    cutoff : float, optional
-        A dynamic threshold for discarding singular values when compressing.
-    method : {"direct", "dm", "zipup", "zipup-first", "fit", "projector", ...}
-        The compression method to use.
-    site_tags : sequence of str, optional
-        The tags to use to group and order the tensors from ``tn``. If not
-        given, uses ``tn.site_tags``. The tensor network built will have one
-        tensor per site, in the order given by ``site_tags``.
-    canonize : bool, optional
-        Whether to perform canonicalization, pseudo or otherwise depending on
-        the method, before compressing. Ignored for ``method='dm'`` and
-        ``method='fit'``.
-    permute_arrays : bool or str, optional
-        Whether to permute the array indices of the final tensor network into
-        canonical order. If ``True`` will use the default order, otherwise if a
-        string this specifies a custom order.
-    optimize : str, optional
-        The contraction path optimizer to use.
-    sweep_reverse : bool, optional
-        Whether to sweep in the reverse direction, resulting in a left
-        canonical form instead of right canonical (for the fit method, this
-        also depends on the last sweep direction).
-    equalize_norms : bool or float, optional
-        Whether to equalize the norms of the tensors after compression. If an
-        explicit value is give, then the norms will be set to that value, and
-        the overall scaling factor will be accumulated into `.exponent`.
-    inplace : bool, optional
-        Whether to perform the compression inplace.
-    kwargs
-        Supplied to the chosen compression method.
-
-    Returns
-    -------
-    TensorNetwork
-    """
-    compress_opts = compress_opts or {}
-
-    f_tn1d = _TN1D_COMPRESS_METHODS.get(method, None)
-    if f_tn1d is not None:
-        # 1D specific compression methods
-        return f_tn1d(
-            tn,
-            max_bond=max_bond,
-            cutoff=cutoff,
-            site_tags=site_tags,
-            canonize=canonize,
-            permute_arrays=permute_arrays,
-            optimize=optimize,
-            sweep_reverse=sweep_reverse,
-            equalize_norms=equalize_norms,
-            inplace=inplace,
-            **compress_opts,
-            **kwargs,
-        )
-
-    # generic tensor network compression methods
-    if sweep_reverse:
-        warnings.warn(
-            "sweep_reverse has no effect for arbitrary geometry (AG) methods."
-        )
-
-    tnc = tensor_network_ag_compress(
-        tn,
-        max_bond=max_bond,
-        cutoff=cutoff,
-        method=method,
-        site_tags=site_tags,
-        canonize=canonize,
-        optimize=optimize,
-        equalize_norms=equalize_norms,
-        inplace=inplace,
-        **compress_opts,
-        **kwargs,
-    )
-
-    if permute_arrays:
-        possibly_permute_(tnc, permute_arrays)
-
-    return tnc
-
-
-# --------------- MPO-MPS gating using 1D compression methods --------------- #
-
-
-def mps_gate_with_mpo_lazy(mps, mpo, inplace=False):
-    """Apply an MPO to an MPS lazily, i.e. nothing is contracted, but the new
-    TN object has the same outer indices as the original MPS.
-    """
-    return tensor_network_apply_op_vec(
-        A=mpo, x=mps, contract=False, inplace=inplace
-    )
-
-
-def mps_gate_with_mpo_direct(
-    mps,
-    mpo,
-    max_bond=None,
-    cutoff=1e-10,
-    inplace=False,
-    **compress_opts,
-):
-    """Apply an MPO to an MPS using the boundary compression method, that is,
-    explicitly contracting site-wise to form a MPS-like TN, canonicalizing in
-    one direction, then compressing in the other. This has the same scaling as
-    the density matrix (dm) method, but a larger prefactor. It can still be
-    faster for small bond dimensions however, and is potentially higher
-    precision since it works in the space of singular values directly rather
-    than singular values squared. It is not quite optimal in terms of error due
-    to the compounding errors of the SVDs.
-
-    Parameters
-    ----------
-    mps : MatrixProductState
-        The MPS to gate.
-    mpo : MatrixProductOperator
-        The MPO to gate with.
-    max_bond : int
-        The maximum bond dimension to compress to.
-    cutoff : float, optional
-        A dynamic threshold for discarding singular values when compressing.
-    compress_opts
-        Supplied to :func:`~quimb.tensor.tensor_split`.
-    """
-    # form the double layer tensor network
-    tn = mps_gate_with_mpo_lazy(mps, mpo, inplace=inplace)
-
-    # directly compress it without first contracting site-wise
-    return tensor_network_1d_compress_direct(
-        tn,
-        max_bond=max_bond,
-        cutoff=cutoff,
-        inplace=inplace,
-        **compress_opts,
-    )
-
-
-def mps_gate_with_mpo_dm(
-    mps,
-    mpo,
-    max_bond=None,
-    cutoff=1e-10,
-    inplace=False,
-    **compress_opts,
-):
-    """Gate this MPS with an MPO, using the density matrix compression method.
-
-    Parameters
-    ----------
-    mps : MatrixProductState
-        The MPS to gate.
-    mpo : MatrixProductOperator
-        The MPO to gate with.
-    max_bond : int, optional
-        The maximum bond dimension to keep when compressing the double layer
-        tensor network, if any.
-    cutoff : float, optional
-        The truncation error to use when compressing the double layer tensor
-        network, if any.
-    compress_opts
-        Supplied to :func:`~quimb.tensor.tensor_split`.
-    """
-    # form the double layer tensor network
-    tn = mps_gate_with_mpo_lazy(mps, mpo, inplace=inplace)
-
-    # directly compress it without first contracting site-wise
-    return tensor_network_1d_compress_dm(
-        tn, max_bond, cutoff, inplace=inplace, **compress_opts
-    )
-
-
-def mps_gate_with_mpo_zipup(
-    mps,
-    mpo,
-    max_bond=None,
-    cutoff=1e-10,
-    canonize=True,
-    optimize="auto-hq",
-    **compress_opts,
-):
-    """Apply an MPO to an MPS using the 'zip-up' algorithm due to
-    'Minimally Entangled Typical Thermal State Algorithms', E.M. Stoudenmire &
-    Steven R. White (https://arxiv.org/abs/1002.1305).
-
-    Parameters
-    ----------
-    mps : MatrixProductState
-        The MPS to gate.
-    mpo : MatrixProductOperator
-        The MPO to gate with.
-    max_bond : int
-        The maximum bond dimension to compress to.
-    cutoff : float, optional
-        A dynamic threshold for discarding singular values when compressing.
-    site_tags : sequence of str, optional
-        The tags to use to group and order the tensors from ``tn``. If not
-        given, uses ``tn.site_tags``. The tensor network built will have one
-        tensor per site, in the order given by ``site_tags``.
-    canonize : bool, optional
-        Whether to pseudo canonicalize the initial tensor network.
-    normalize : bool, optional
-        Whether to normalize the final tensor network, making use of the fact
-        that the output tensor network is in right canonical form.
-    permute_arrays : bool or str, optional
-        Whether to permute the array indices of the final tensor network into
-        canonical order. If ``True`` will use the default order, otherwise if a
-        string this specifies a custom order.
-    optimize : str, optional
-        The contraction path optimizer to use.
-    compress_opts
-        Supplied to :func:`~quimb.tensor.tensor_split`.
-
-    Returns
-    -------
-    MatrixProductState
-        The compressed MPS, in right canonical form.
-    """
-    # form double layer
-    tn = mps_gate_with_mpo_lazy(mps, mpo)
-
-    # compress it using zip-up
-    return tensor_network_1d_compress_zipup(
-        tn,
-        max_bond=max_bond,
-        cutoff=cutoff,
-        canonize=canonize,
-        optimize=optimize,
-        **compress_opts,
-    )
-
-
-def mps_gate_with_mpo_zipup_first(
-    mps,
-    mpo,
-    max_bond=None,
-    max_bond_zipup=None,
-    cutoff=1e-10,
-    cutoff_zipup=None,
-    canonize=True,
-    optimize="auto-hq",
-    **compress_opts,
-):
-    """Apply an MPO to an MPS by first using the zip-up method with a larger
-    bond dimension, then doing a regular compression sweep to the target final
-    bond dimension. This avoids forming an intermediate MPS with bond dimension
-    ``mps.max_bond() * mpo.max_bond()``.
-
-    Parameters
-    ----------
-    mps : MatrixProductState
-        The MPS to gate.
-    mpo : MatrixProductOperator
-        The MPO to gate with.
-    max_bond : int
-        The target final bond dimension.
-    max_bond_zipup : int, optional
-        The maximum bond dimension to use when zip-up compressing the double
-        layer tensor network. If not given, defaults to ``2 * max_bond``.
-        Needs to be smaller than ``mpo.max_bond()`` for any savings.
-    cutoff : float, optional
-        The truncation error to use when performing the final regular
-        compression sweep.
-    cutoff_zipup : float, optional
-        The truncation error to use when performing the zip-up compression.
-    canonize : bool, optional
-        Whether to pseudo canonicalize the initial tensor network.
-    optimize : str, optional
-        The contraction path optimizer to use.
-    compress_opts
-        Supplied to :func:`~quimb.tensor.tensor_split` (both the zip-up and
-        final sweep).
-
-    Returns
-    -------
-    MatrixProductState
-        The compressed MPS, in right canonical form.
-    """
-    new = mps_gate_with_mpo_lazy(mps, mpo)
-    return tensor_network_1d_compress_zipup_first(
-        new,
-        max_bond=max_bond,
-        max_bond_zipup=max_bond_zipup,
-        cutoff=cutoff,
-        cutoff_zipup=cutoff_zipup,
-        canonize=canonize,
-        optimize=optimize,
-        **compress_opts,
-    )
-
-
-def mps_gate_with_mpo_fit(mps, mpo, max_bond, **kwargs):
-    """Gate an MPS with an MPO using the variational fitting or DMRG-style
-    method.
-
-    Parameters
-    ----------
-    mps : MatrixProductState
-        The MPS to gate.
-    mpo : MatrixProductOperator
-        The MPO to gate with.
-    max_bond : int
-        The maximum bond dimension to compress to.
-
-    Returns
-    -------
-    MatrixProductState
-        The gated MPS.
-    """
-    tn = mps_gate_with_mpo_lazy(mps, mpo)
-    return tensor_network_1d_compress_fit(tn, max_bond, **kwargs)
-
-
-def mps_gate_with_mpo_autofit(
-    self,
-    mpo,
-    max_bond,
-    cutoff=0.0,
-    init_guess=None,
-    **fit_opts,
-):
-    """Fit a MPS to a MPO applied to an MPS using geometry generic versions
-    of either ALS or autodiff. This is usually much less efficient that using
-    the 1D specific methods.
-
-    Some nice alternatives to the default fit_opts:
-
-        - method="autodiff"
-        - method="als", solver="lstsq"
-
-    """
-    if cutoff != 0.0:
-        raise ValueError("cutoff must be zero for fitting")
-
-    target = mps_gate_with_mpo_lazy(self, mpo)
-
-    if init_guess is None:
-        ansatz = self.copy()
-        ansatz.expand_bond_dimension_(max_bond)
-    else:
-        raise NotImplementedError
-
-    return ansatz.fit_(target, **fit_opts)
-
-
-def mps_gate_with_mpo_projector(
-    self,
-    mpo,
-    max_bond,
-    cutoff=1e-10,
-    canonize=True,
-    canonize_opts=None,
-    inplace=False,
-    **compress_opts,
-):
-    """Apply an MPO to an MPS using local projectors, in the style of CTMRG
-    or HOTRG, without using information beyond the neighboring 4 tensors.
-    """
-    tn = mps_gate_with_mpo_lazy(self, mpo)
-
-    if canonize:
-        # precondition
-        canonize_opts = ensure_dict(canonize_opts)
-        tn.gauge_all_(**canonize_opts)
-
-    tn_calc = tn.copy()
-
-    for i in range(tn.L - 1):
-        ltags = (tn.site_tag(i),)
-        rtags = (tn.site_tag(i + 1),)
-
-        tn_calc.insert_compressor_between_regions_(
-            ltags,
-            rtags,
-            new_ltags=ltags,
-            new_rtags=rtags,
-            max_bond=max_bond,
-            cutoff=cutoff,
-            insert_into=tn,
-            bond_ind=self.bond(i, i + 1),
-            **compress_opts,
-        )
-
-    if inplace:
-        for i in range(tn.L):
-            ti = self[i]
-            data = tensor_contract(
-                *tn[i], output_inds=ti.inds, optimize="auto-hq"
-            ).data
-            ti.modify(data=data)
-
-    else:
-        for i in range(tn.L):
-            tn.contract_tags_(
-                tn.site_tag(i),
-                output_inds=self[i].inds,
-                optimize="auto-hq",
-            )
-
-        tn.view_like_(self)
-
-    return tn