temfpy 0.1.0__py3-none-any.whl

temfpy/__init__.py

@@ -0,0 +1,14 @@
+import logging as _logging
+
+# Try to get version from hatch-vcs generated file first, then fallback
+try:
+    from ._version import __version__
+except ImportError:
+    from importlib.metadata import version
+    __version__ = version("temfpy")
+        
+
+def setup_logging(level=_logging.INFO):
+    _logging.basicConfig(
+        level=level,
+    )

temfpy/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

temfpy/gutzwiller.py

@@ -0,0 +1,186 @@
+# Copyright (C) TeMFPy Developers, MIT license
+r"Tools for Gutzwiller projecting MPS to a smaller on-site Hilbert space."
+
+import logging
+import warnings
+
+import numpy as np
+
+from tenpy import networks
+import tenpy.linalg as npc
+
+logger = logging.getLogger(__name__)
+
+
+def abrikosov_ph(
+    mps: networks.MPS,
+    *,
+    inplace: bool = False,
+    return_canonical: bool = True,
+    cutoff: float = 1e-12,
+) -> None | networks.MPS:
+    r"""Gutzwiller projection from Abrikosov fermions to a spin-1/2 Hilbert space.
+
+    The input MPS is assumed to describe  Abrikosov fermions, with the down
+    spins particle-hole transformed; i.e.:
+
+    .. math::
+
+        c_{i,\uparrow} := f_{i,\uparrow},
+        \qquad \qquad
+        c_{i,\downarrow} := f_{i,\downarrow}^\dagger.
+
+    Therefore, it must contain an even number of spinless fermion sites:
+    sites :math:`2i` and :math:`2i+1` represent modes :math:`c_{i\uparrow}` and
+    :math:`c_{i\downarrow}`, respectively.
+    These pairs are projected to a spin-1/2 Hilbert space using the following rules:
+
+    - Zero occupation → spin-down state
+    - Single occupation → unphysical states, dropped
+    - Double occupation → spin-up state
+
+    Therefore, depending on the conserved charge of the input MPS, only the following charge blocks
+    of the virtual legs are kept:
+
+    - ``'N'`` (particle number) → even ``'N'`` blocks → ``'S_z'`` conserved
+    - ``'parity'`` → even ``'parity'`` blocks → no conserved charge
+
+    Parameters
+    ----------
+    mps:
+        MPS representing the wave function to be projected.
+        Must be of even length and every site must be an instance
+        of :class:`~tenpy.networks.site.FermionSite`.
+    inplace:
+        Whether to transform the original MPS in place.
+    return_canonical:
+        Whether to transform the output MPS to right canonical form.
+    cutoff:
+        Cutoff for Schmidt values to keep in the canonical form.
+
+    Returns
+    -------
+        The Gutzwiller projected ``mps``, if ``inplace`` is :obj:`False`.
+
+    Note
+    ----
+        Currently, no symmetry quantum numbers other than fermion
+        number or parity can be handled.
+    """
+
+    assert (
+        mps.L % 2 == 0
+    ), "Odd-length MPS cannot represent an Abrikosov fermion Hilbert space"
+    # TODO: allow grouped sites which include a FermionicSite
+    assert isinstance(
+        mps.sites[0], networks.FermionSite
+    ), f"All sites must be fermionic, found: {mps.sites[0]}"
+
+    def gen_leg_mask(leg: npc.charges.LegCharge) -> np.ndarray:
+        """Generates a mask selecting the physical charge blocks for a given
+        fermionic leg.
+
+        The physical charge blocks depend on the conserved charge of the
+        given ``leg``:
+
+        - ``'N'`` → even particle charge blocks
+        - ``'parity'`` → even parity charge block
+
+
+        Parameters
+        ----------
+        leg:
+            The fermionic leg for which the mask is generated.
+
+        Returns
+        -------
+            A boolean mask selecting the physical charge blocks
+            that can be used by :class:`~tenpy.networks.Array.iproject`.
+
+        """
+        mask = (leg.to_qflat() % 2 == 0).ravel()
+
+        return mask
+
+    if not inplace:
+        mps = mps.copy()
+        logger.debug(f"Deep copied MPS before Gutzwiller projection.")
+
+    conserved_fermion = mps.sites[0].conserve
+    if conserved_fermion == "N":
+        conserved_spin = "Sz"
+    elif conserved_fermion == "parity":
+        conserved_spin = None
+    else:
+        raise ValueError(
+            f"FermionSite must conserve either 'N' or 'parity', found {conserved_fermion}"
+        )
+
+    # TeNPy bindings
+    spin_site = networks.SpinHalfSite(conserved_spin)
+    spin_leg = spin_site.leg
+    chinfo_s = spin_leg.chinfo
+
+    # We start by grouping neighboring sites
+    # This will result in LegPipe objects for all physical legs
+    mps.group_sites(2)
+
+    # The mask for the physical leg is independent of the site
+    mask_p = gen_leg_mask(mps._B[0].get_leg("p"))
+
+    for idx, B in enumerate(mps._B):
+        # Remove LegPipe structure
+        B.legs[B.get_leg_index("p")] = B.get_leg("p").to_LegCharge()
+
+        mask_vL = gen_leg_mask(B.get_leg("vL"))
+        mask_vR = gen_leg_mask(B.get_leg("vR"))
+
+        # Change the occupation number leg charges to spin charges
+        # --------------------------------------------------------
+
+        B.iproject([mask_vL, mask_p, mask_vR], ["vL", "p", "vR"])
+
+        # Change the occupation number leg charges to spin charges,
+        # if conserved.
+        # ------------------------------------------------------------
+        if conserved_spin is "Sz":
+            B.chinfo = chinfo_s
+
+            leg_vL, leg_p, leg_vR = [B.get_leg(label) for label in ["vL", "p", "vR"]]
+
+            leg_p.chinfo = chinfo_s
+            leg_p.charges = spin_leg.charges
+
+            leg_vL.chinfo = chinfo_s
+            leg_vL.charges -= idx
+
+            leg_vR.chinfo = chinfo_s
+            leg_vR.charges -= idx + 1
+
+        else:  # None
+            B = B.drop_charge(charge="parity_N", chinfo=chinfo_s)
+
+    mps.chinfo = chinfo_s
+    mps.grouped = 1
+    mps.sites = [spin_site] * mps.L
+
+    # Transform into right canoncial form
+    mps.form = [None] * mps.L
+    mps._S = [None] * (mps.L + 1)
+
+    logger.info(
+        "Completed projection to spin-1/2 space. Conserved charge is now %s",
+        conserved_spin,
+    )
+
+    if return_canonical:
+        mps.canonical_form(cutoff=cutoff)
+        logger.info("Transformed MPS to right canonical form")
+    else:
+        warnings.warn(
+            "The MPS is not in canonical form after Gutzwiller projection.\n"
+            "Consider setting 'return_canonical=True'",
+        )
+
+    if not inplace:
+        return mps

temfpy/iMPS.py

@@ -0,0 +1,304 @@
+# Copyright (C) TeMFPy Developers, MIT license
+r"""Tools for converting finite to infinite MPS."""
+
+import logging
+import warnings
+from typing import NamedTuple
+
+import numpy as np
+
+import tenpy.linalg.np_conserved as npc
+from tenpy import networks as nw
+
+logger = logging.getLogger(__name__)
+
+_UNITARY_TOL = 1e-6
+_SCHMIDT_TOL = 1e-6
+
+
+def overlap_schmidt(bra: nw.mps.MPS, ket: nw.mps.MPS, mode: str) -> npc.Array:
+    r"""Overlap or optimal basis rotation between two sets of Schmidt vectors.
+
+    Parameters
+    ----------
+    bra:
+        Bra Schmidt vectors.
+    ket:
+        Ket Schmidt vectors.
+    mode:
+        If the overlap is between "left" or "right" Schmidt vectors.
+
+    Returns
+    -------
+    overlap: :class:`~tenpy.linalg.np_conserved.Array`
+        The overlaps :math:`(C_0)_{\alpha\beta} = \langle L_\alpha'|L_\beta \rangle`
+        or :math:`(D_0)_{\alpha\beta} = \langle R_\beta'|R_\alpha \rangle`,
+        depending on ``mode``.
+
+        Legs are labelled ``"vL"`` (incoming) and ``"vR"`` (outgoing).
+    """
+    assert bra.L == ket.L, "The two MPS have different lengths."
+    mode = mode.lower()
+
+    # ---- Compute overlap ----
+    if mode == "left":
+        TM = nw.TransferMatrix(bra, ket, transpose=True, form="A")
+    elif mode == "right":
+        TM = nw.TransferMatrix(bra, ket, transpose=False, form="B", charge_sector=None)
+    else:
+        raise ValueError("`mode` must be either 'left' or 'right', got " + repr(mode))
+
+    # Identity matrix with legs matching the input legs of the transfer matrix
+    Id = npc.Array.from_ndarray([[1.0]], TM.pipe.legs, labels=TM.label_split)
+
+    # nw.TransferMatrix makes sure that the first legtwo_leg is always ingoing and
+    # the second leg is always outgoing.
+    # Therefore, it is safe to just set the labels here instead of using
+    # ireplace_labels.
+    overlap = TM.matvec(Id).iset_leg_labels(["vL", "vR"])
+
+    return overlap
+
+
+def basis_rotation(
+    overlap: npc.Array,
+    Schmidt_bra: np.ndarray,
+    Schmidt_ket: np.ndarray,
+    mode: str,
+    form: str = "B",
+    unitary_tol: float = _UNITARY_TOL,
+    schmidt_tol: float = _SCHMIDT_TOL,
+) -> tuple[npc.Array, float, float]:
+    r"""Overlap or optimal basis rotation between two sets of Schmidt vectors.
+
+    Parameters
+    ----------
+    overlap:
+        The overlaps :math:`(C_0)_{\alpha\beta} = \langle L_\alpha'|L_\beta \rangle`
+        or :math:`(D_0)_{\alpha\beta} = \langle R_\beta'|R_\alpha \rangle`,
+        depending on ``mode``.
+
+        Legs should be labelled ``"vL"`` (incoming) and ``"vR"`` (outgoing).
+    Schmidt_bra:
+        Schmidt values corresponding to the bra Schmidt vectors :math:`\langle L'|`
+        or :math:`\langle R'|`.
+    Schmidt_ket:
+        Schmidt values corresponding to the ket Schmidt vectors :math:`|L \rangle`
+        or :math:`|R \rangle`.
+    mode:
+        If the overlap is between "left" or "right" Schmidt vectors.
+    form:
+        Whether the basis rotation is to be used for a left ("A")
+        or a right ("B", default) canonical MPS tensor.
+    unitary_tol:
+        Highest allowed deviation from unitarity (weighted with Schmidt values)
+        in the overlaps before a warning is raised.
+    schmidt_tol:
+        Highest allowed mixing between unequal Schmidt value sectors
+        before a warning is raised.
+
+    Returns
+    -------
+    rotation_matrix: :class:`~tenpy.linalg.np_conserved.Array`
+        If :obj:`True`, the optimal unitary basis rotation matrix :math:`C` that
+        minimises the iMPS conversion error.
+
+        Legs are labelled ``"vL"`` (incoming) and ``"vR"`` (outgoing).
+    unitary_error: float
+        Deviation of the overlap matrix from unitarity,
+        measured as the square root of the trace of
+        :math:`S_{\rm ket} (C_0^\dagger C_0 - \mathbb{I}) S_{\rm ket}`.
+    schmidt_error: float
+        Degree of mixing of Schmidt vectors with unequal Schmidt values,
+        measured as the norm of either :math:`S_{\rm bra} C - C_0 S_{\rm ket}`
+        or :math:`(C - C_0) S_{\rm ket}`, depending on ``mode`` and ``form``.
+    """
+    mode = mode.lower()
+    err = f"`mode` must be either 'left' or 'right', got {mode!r}"
+    assert mode in ["left", "right"], err
+
+    form = form.upper()
+    assert form in ["A", "B"], f"`form` must be either 'A' or 'B', got {form!r}"
+
+    # make what follows independent of mode
+    v_bra, v_ket = ("vL", "vR") if mode == "left" else ("vR", "vL")
+
+    # ---- Test unitarity ----
+    # C @ S_ket
+    C_Sk = overlap.scale_axis(Schmidt_ket, v_ket)
+    # unitary_error^2 = tr(S_ket^2 - S_ket @ C^dagger @ C @ S_ket)
+    unitary_error = (
+        np.sum(Schmidt_ket**2) - npc.inner(C_Sk, C_Sk, do_conj=True)
+    ) ** 0.5
+    logging.info(f"{mode.capitalize()} deviation from unitary: {unitary_error:.4e}")
+    if unitary_error > unitary_tol:
+        warnings.warn(
+            f"\n{mode.capitalize()} overlap matrix deviates from unitarity by "
+            f"{unitary_error}.\n"
+            "Increasing the bond dimension may be useful."
+        )
+
+    # ---- Convert to unitary rotation matrix ----
+    if (mode, form) in [("left", "A"), ("right", "B")]:
+        # Schmidt values are inserted into the mixed canonical form
+        # at this entanglement cut. => Orthogonal Procustes for S_bra @ C @ S_ket
+        U, _, V = npc.svd(C_Sk.scale_axis(Schmidt_bra, v_bra))
+    else:
+        # Schmidt values are inserted into the mixed canonical form
+        # far from this entanglement cut. => Orthogonal Procustes for C @ S_ket^2
+        U, _, V = npc.svd(C_Sk.scale_axis(Schmidt_ket, v_ket))
+    overlap = npc.tensordot(U, V, 1)
+
+    # ---- Test Schmidt value deviations ----
+    # As above, the difference is due to whether Schmidt values appear in
+    # the mixed canonical form at this cut or far away
+    if (mode, form) in [("left", "A"), ("right", "B")]:
+        Sb_C = overlap.scale_axis(Schmidt_bra, v_bra)
+    else:
+        # not just C_Sk bc `overlap` has changed
+        Sb_C = overlap.scale_axis(Schmidt_ket, v_ket)
+
+    schmidt_error = npc.norm(Sb_C - C_Sk)
+    logging.info(f"{mode.capitalize()} Schmidt value mixing:   {schmidt_error:.4e}")
+    if schmidt_error > schmidt_tol:
+        warnings.warn(
+            f"\nMixing between unequal Schmidt value sectors on the {mode} side is\n"
+            f"{schmidt_error}. Increasing the number of sites may help."
+        )
+
+    return overlap, unitary_error, schmidt_error
+
+
+class iMPSError(NamedTuple):
+    """Container of the approximation errors accrued by :func:`MPS_to_iMPS`."""
+
+    left_unitary: float
+    """Deviation of left environment from unitarity."""
+    left_schmidt: float
+    """Mixing between unequal Schmidt values by the left environment."""
+    right_unitary: float
+    """Deviation of left environment from unitarity."""
+    right_schmidt: float
+    """Mixing between unequal Schmidt values by the right environment."""
+
+    @property
+    def left_total(self) -> float:
+        """Total approximation error of the left environment."""
+        return (self.left_schmidt**2 + self.left_unitary**2) ** 0.5
+
+    @property
+    def right_total(self) -> float:
+        """Total approximation error of the right environment."""
+        return (self.right_schmidt**2 + self.right_unitary**2) ** 0.5
+
+    @property
+    def total_error(self) -> float:
+        """Total approximation error."""
+        return np.linalg.norm(self)
+
+    def __repr__(self) -> str:
+        fields = [f"    {f}={x:.8e}" for f, x in zip(self._fields, self) if x != 0]
+        if len(fields) == 0:
+            return "iMPSError()"
+        else:
+            return "iMPSError(\n" + (",\n".join(fields)) + "\n)"
+
+
+def MPS_to_iMPS(
+    mps_short: nw.MPS,
+    mps_long: nw.MPS,
+    sites_per_cell: int,
+    cut: int,
+    unitary_tol: float = _UNITARY_TOL,
+    schmidt_tol: float = _SCHMIDT_TOL,
+) -> tuple[nw.MPS, iMPSError]:
+    """Constructs an iMPS by comparing two finite MPS.
+
+    The two MPS are expected to represent the ground states of a gapped,
+    translation invariant Hamiltonian on two system sizes that differ by
+    one repeating unit cell.
+
+    For sufficiently large systems, therefore, they are of the form
+
+    .. code::
+
+        ...(A...B)(A...B)...
+        ...(A...B)(A...B)(A...B)...
+
+    up to gauge transformations. The repeating unit cell ``(A...B)`` is
+    extracted from the longer chain, and its gauge is fixed by comparing its
+    left and right environments to the Schmidt vectors of the shorter chain.
+
+    Parameters
+    ----------
+    mps_short:
+        MPS of the shorter chain.
+    mps_long:
+        MPS of the longer chain.
+    sites_per_cell:
+        Size of the iMPS unit cell.
+    cut:
+        First site of the repeating unit cell in ``mps_long``.
+    unitary_tol:
+        Maximum deviation of the gauge rotation matrices from unitarity
+        before a warning is raised.
+    schmidt_tol:
+        Maximum mixing of unequal Schmidt values by the gauge rotation matrices
+        before a warning is raised.
+
+    Returns
+    -------
+    iMPS: :class:`~tenpy.networks.mps.MPS`
+        iMPS with unit cell size ``sites_per_cell``, constructed from the
+        additional unit cell of ``mps_long``.
+    validation_metric: :class:`iMPSError`
+        Errors introduced during the conversion.
+    """
+    # preliminary checks
+    L_short, L_long = mps_short.L, mps_long.L
+    if L_short + sites_per_cell != L_long:
+        raise ValueError(
+            "The given two MPS must differ by one unit cell, got "
+            f"{L_long} - {L_short} != {sites_per_cell}"
+        )
+    if mps_short.chinfo != mps_long.chinfo:
+        raise ValueError("Incompatible ChargeInfo in the two MPS")
+    assert all(x is not None for x in mps_short.form), "mps_short is not canonical"
+    assert all(x is not None for x in mps_long.form), "mps_long is not canonical"
+
+    # Schmidt values in the short chain at the reference cut
+    S0 = mps_short.get_SL(cut)
+
+    # Left gauge fixing matrix C
+    bra = mps_short.extract_segment(0, cut - 1)
+    ket = mps_long.extract_segment(0, cut - 1)
+    S_ket = mps_long.get_SL(cut)
+    C = overlap_schmidt(bra, ket, mode="left")
+    C, left_unitary, left_schmidt = basis_rotation(
+        C, S0, S_ket, mode="left", unitary_tol=unitary_tol, schmidt_tol=schmidt_tol
+    )
+
+    # Right gauge fixing matrix D
+    bra = mps_short.extract_segment(cut, L_short - 1)
+    ket = mps_long.extract_segment(cut + sites_per_cell, L_long - 1)
+    S_ket = mps_long.get_SL(cut + sites_per_cell)
+    D = overlap_schmidt(bra, ket, mode="right")
+    D, right_unitary, right_schmidt = basis_rotation(
+        D, S0, S_ket, mode="right", unitary_tol=unitary_tol, schmidt_tol=schmidt_tol
+    )
+
+    # Extract middle section of MPS in right canonical form
+    sites = mps_long.sites[cut : cut + sites_per_cell]
+    tensors = [mps_long.get_B(cut + i, form="B") for i in range(sites_per_cell)]
+    schmidt_values = mps_long._S[cut + 1 : cut + sites_per_cell]
+
+    # Apply gauge unitaries to first and last tensor
+    tensors[0] = npc.tensordot(C, tensors[0], axes=["vR", "vL"])
+    tensors[-1] = npc.tensordot(tensors[-1], D, axes=["vR", "vL"])
+
+    # Set Schmidt values on both ends to that of the reference MPS
+    schmidt_values = [S0] + schmidt_values + [S0]
+
+    iMPS = nw.MPS(sites, tensors, schmidt_values, bc="infinite", form="B")
+    error = iMPSError(left_unitary, left_schmidt, right_unitary, right_schmidt)
+    return iMPS, error