symvb 2.0.0__py3-none-any.whl

symvb/orbital_permutations.py

@@ -0,0 +1,49 @@
+import itertools
+
+import sys
+
+sys.setrecursionlimit(30000)
+
+
+class OrbitalPermutations:
+    # will return permutations of vector [0,1,..,n-1] together with parity signs
+    def __init__(self, n):
+        self.n = n
+        self.permutations = []
+        self.permutation_signs = []
+
+        self.get_permutation_indices(n)
+
+    def __iter__(self):
+        return zip(self.permutations, self.permutation_signs)
+
+    def N_flips(self, v):
+        # Computes the number of permutations from the consecutive order
+        if len(v) == 0:
+            return 0
+        v2 = list(v).copy()
+
+        # find 1 and swap elements
+        i1 = v2.index(0)
+        v2[i1] = v2[0]
+        v2[0] = 1
+
+        v2 = [x - 1 for x in v2]
+        add_perm = 0 if i1 == 0 else 1
+
+        return self.N_flips(v2[1:]) + add_perm
+
+    def parity_sign(self, v):
+        # Returns the parity (+1/-1) of a given permutation vector
+        n = self.N_flips(v)
+        if (n % 2) == 0:
+            return 1
+        else:
+            return -1
+
+    def get_permutation_indices(self, n):
+        # gets the permutation indices and permutation signs
+        if n == 0:
+            n = 1
+        self.permutations = list(itertools.permutations(range(n)))
+        self.permutation_signs = [self.parity_sign(v) for v in self.permutations]

symvb/slaterdet.py

@@ -0,0 +1,142 @@
+from symvb.functions import sorti
+from symvb.orbital_permutations import OrbitalPermutations
+import symvb
+import logging
+
+logging.basicConfig(format=('%(levelname)-8s: %(message)s'))
+
+
+class SlaterDet:
+    """
+    Parses the Slater determinant string |s| and computes the <det1|O|det2> elements
+    """
+    def __init__(self, s=""):
+        self.det_string = s
+        self.alpha_indices = []
+        self.alpha_string = ''
+        self.beta_indices = []
+        self.beta_string = ''
+        self.spins = ''
+        self.Nel = 0
+        if len(self.det_string) > 0:
+            self.parse_det()
+
+    def __repr__(self):
+        s = '|%s|' % self.det_string
+        return s
+
+    # Description of the magic functions: https://docs.python.org/3/reference/datamodel.html
+    def __add__(self, other):
+        return symvb.FixedPsi(self) + other
+
+    def __sub__(self, other):
+        if other.__class__.__name__ == 'SlaterDet' and self.det_string == other.det_string:
+            return SlaterDet()
+        return symvb.FixedPsi(self) + (-1) * other
+
+    def __rsub__(self, other):
+        return symvb.FixedPsi(other) + (-1) * symvb.FixedPsi(self)
+
+    def __neg__(self):
+        return (-1) * symvb.FixedPsi(self)
+
+    def __mul__(self, other):
+        if isinstance(other, int) or isinstance(other, float):
+            return symvb.FixedPsi(self) * other
+        if other.__class__.__name__ == 'SlaterDet':
+            # make sure we do not place two electrons on the same orbital
+            if len(set(self.alpha_string).intersection(set(other.alpha_string))) > 0:
+                return SlaterDet()
+            if len(set(self.beta_string).intersection(set(other.beta_string))) > 0:
+                return SlaterDet()
+            return SlaterDet(self.det_string + other.det_string)
+        if other.__class__.__name__ == 'FixedPsi':
+            return symvb.FixedPsi(self) * other
+        return NotImplemented
+
+    def __rmul__(self, other):
+        if isinstance(other, int) or isinstance(other, float):
+            return symvb.FixedPsi(self) * other
+
+    def parse_det(self):
+        s = self.det_string
+        if len(s) == 0:
+            return
+
+        i = 0
+        for c in s:
+            if c.islower():
+                assert c not in self.alpha_string # two electrons cannot occupy the same spinorbital
+                self.alpha_indices.append(i)
+                self.spins += '+'
+                self.alpha_string += c
+            else:
+                assert c not in self.beta_string # two electrons cannot occupy the same spinorbital
+                self.beta_indices.append(i)
+                self.spins += '-'
+                self.beta_string += c
+            i = i + 1
+        self.Nel = i
+
+    def get_orbital_permutations(self):
+        # gets all spin-restricted permutations of orbital products
+        A = OrbitalPermutations(len(self.alpha_indices))
+        B = OrbitalPermutations(len(self.beta_indices))
+
+        dets = []
+        signs = []
+        for a_orbs, a_sign in A:
+            for b_orbs, b_sign in B:
+                i_a = 0
+                i_b = 0
+                s = ''
+                for i in range(len(self.det_string)):
+                    if self.spins[i] == '+':
+                        c = self.alpha_string[a_orbs[i_a]]
+                        i_a += 1
+                    else:
+                        c = self.beta_string[b_orbs[i_b]]
+                        i_b += 1
+                    s = s + c
+                dets.append(s)
+                signs.append(a_sign * b_sign)
+
+        return [dets, signs]
+
+    def is_compatible(self, R):
+        if self.Nel != R.Nel:
+            # logging.warning('Different number of electrons: %i vs %i' % (self.Nel, R.Nel))
+            return False
+        if self.spins != R.spins:
+            # logging.warning('The determinant spins are incompatible: %s vs %s' % (self.spins, R.spins))
+            return False
+        return True
+
+    def get_sorted(self):
+        # Sorts orbital labels within alpha and beta blocks into alphabetic order
+        # (spin pattern unchanged). Returns FixedPsi with the sign from the
+        # required orbital permutation folded into the coefficient.
+        sa, ia = sorti(self.alpha_string)
+        sb, ib = sorti(self.beta_string)
+
+        s = self.det_string
+        for i in range(len(self.alpha_indices)):
+            j = self.alpha_indices[i]
+            s = s[:j] + sa[i] + s[j + 1:]
+
+        for i in range(len(self.beta_indices)):
+            j = self.beta_indices[i]
+            s = s[:j] + sb[i] + s[j + 1:]
+
+        # Construct a fresh SlaterDet from the sorted string so internal
+        # fields (alpha_indices / alpha_string / etc.) reflect the new ordering.
+        d = SlaterDet(s)
+
+        coef = 1 if (ia + ib) % 2 == 0 else -1
+        fp = symvb.FixedPsi()
+        fp.add_det(d, coef=coef)
+        return fp
+
+
+if __name__ == '__main__':
+    print(SlaterDet('AbCd').spins)

symvb/spin.py

@@ -0,0 +1,233 @@
+"""
+Total-spin (S^2) machinery: construct the S^2 matrix over a Slater-det
+basis with fixed Sz and project onto a chosen total-spin eigenspace.
+
+For the Sz = 0 subspace,
+
+    S^2  =  S_+ S_-                (the S_z^2 - S_z piece vanishes)
+         =  sum_{i, j}  c^+_{i alpha} c_{i beta} c^+_{j beta} c_{j alpha}.
+
+The action of S^2 on a Slater det |D> is computed by applying the four
+second-quantized operators in sequence, tracking fermion signs through
+a canonical spin-orbital ordering (alpha_1, beta_1, alpha_2, beta_2, ...).
+The resulting matrix element <D'|S^2|D> is summed over all orbital
+pairs (i, j) to build the full S^2 matrix.
+
+Given an S^2 matrix over any Slater-det basis, `project_onto_S(H, S2, S)`
+returns the Hamiltonian block projected onto the S(S+1) eigenspace.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+
+def _canon_det(alpha_set, beta_set):
+    """
+    Canonical det string: sort alpha and beta sets, interleave in pairs
+    matching symvb.functions.generate_det_strings.  Returns None if
+    n_alpha != n_beta (our caller will work with balanced dets only).
+    """
+    a = sorted(alpha_set)
+    b = sorted(beta_set)
+    if len(a) != len(b):
+        return None
+    return ''.join(a[k] + b[k].upper() for k in range(len(a)))
+
+
+def _spin_orbital_list(alpha_set, beta_set):
+    """Canonical ordering: alpha_1, beta_1, alpha_2, beta_2, ... sorted by orbital."""
+    orbs = sorted(alpha_set | beta_set)
+    return [(orb, s) for orb in orbs for s in (0, 1) if
+            (s == 0 and orb in alpha_set) or (s == 1 and orb in beta_set)]
+
+
+def _apply_c(alpha, beta, orb, spin, create):
+    """
+    Apply c_{orb, spin} or c^+_{orb, spin} to the det specified by the
+    alpha/beta orbital sets.  Returns (new_alpha, new_beta, sign) or
+    (None, None, 0) if annihilated.  sign = (-1)^{# occupied spin-orbitals
+    before (orb, spin) in the canonical ordering}.
+
+    Canonical ordering: for each orbital in alphabetical order, alpha first
+    then beta.
+    """
+    present = (orb in alpha) if spin == 0 else (orb in beta)
+    if create == present:   # trying to create an occupied slot, or annihilate empty
+        return None, None, 0
+
+    # Jordan-Wigner sign: count occupied spin-orbitals strictly before (orb, spin)
+    count = 0
+    for x in sorted(alpha | beta):
+        if x < orb:
+            count += int(x in alpha) + int(x in beta)
+        elif x == orb:
+            if spin == 1 and x in alpha:
+                count += 1
+    sign = 1 if count % 2 == 0 else -1
+
+    new_alpha = alpha.copy()
+    new_beta  = beta.copy()
+    if spin == 0:
+        if create:
+            new_alpha.add(orb)
+        else:
+            new_alpha.discard(orb)
+    else:
+        if create:
+            new_beta.add(orb)
+        else:
+            new_beta.discard(orb)
+    return new_alpha, new_beta, sign
+
+
+def _apply_s_pl_s_mi(orbs, alpha, beta):
+    """
+    Apply S_+ S_- = sum_{i, j} c^+_{i a} c_{i b} c^+_{j b} c_{j a}  to |D>.
+    Returns a dict  { canonical_det_string : signed_coefficient, ... }.
+    `orbs` is the list of orbital labels to iterate over.
+    """
+    out = {}
+    for j in orbs:
+        # c_{j alpha}
+        a1, b1, s1 = _apply_c(alpha, beta, j, 0, create=False)
+        if a1 is None:
+            continue
+        for i in orbs:
+            # c^+_{j beta}
+            a2, b2, s2 = _apply_c(a1, b1, j, 1, create=True)
+            if a2 is None:
+                continue
+            # c_{i beta}
+            a3, b3, s3 = _apply_c(a2, b2, i, 1, create=False)
+            if a3 is None:
+                continue
+            # c^+_{i alpha}
+            a4, b4, s4 = _apply_c(a3, b3, i, 0, create=True)
+            if a4 is None:
+                continue
+            sign = s1 * s2 * s3 * s4
+            key = _canon_det(a4, b4)
+            if key is None:
+                continue
+            out[key] = out.get(key, 0) + sign
+    return out
+
+
+def _symvb_to_canonical_sign(det_string, orbital_index):
+    """
+    Sign relating the symvb Slater det (creation order = det_string order)
+    to the canonical Jordan-Wigner ordering (alphabetical orbital, alpha
+    before beta for each orbital).
+
+    For det_string 'x0 X1 x2 X3 ...' the creation order is
+        (x0, alpha), (X1, beta), (x2, alpha), (X3, beta), ...
+    To put in canonical ascending order we count inversions in the list
+    of spin-orbital indices  (2 * orb_index + spin).
+    """
+    indices = []
+    for pos, c in enumerate(det_string):
+        orb = c.lower()
+        spin = 0 if c.islower() else 1
+        indices.append(2 * orbital_index[orb] + spin)
+    inv = 0
+    for a in range(len(indices)):
+        for b in range(a + 1, len(indices)):
+            if indices[a] > indices[b]:
+                inv += 1
+    return 1 if inv % 2 == 0 else -1
+
+
+def s_squared_matrix(det_strings, orbs=None):
+    """
+    Build the S^2 matrix in a Slater-det basis at Sz = 0.
+
+    Thin wrapper around `symvb.operators.s_squared(orbs).matrix(...)`;
+    kept for backward compatibility. Returns a numpy float ndarray with
+    eigenvalues S(S+1).
+    """
+    from symvb import operators as _op
+    if orbs is None:
+        orbs = sorted({ch.lower() for ds in det_strings for ch in ds})
+    return np.array(_op.s_squared(orbs).matrix(det_strings), dtype=float)
+
+
+def _apply_eta_pl_eta_mi(orbs, site_sign, alpha, beta):
+    """
+    Apply  eta_+ eta_-  =  sum_{i,j} s_i s_j c^+_{i alpha} c^+_{i beta}
+                                            c_{j beta} c_{j alpha}
+    to |D> (alpha, beta occupation sets), where s_i = site_sign[i] = +/-1.
+    Returns a dict { canonical_det_string : signed_coefficient, ... }.
+    """
+    out = {}
+    for j in orbs:
+        # c_{j alpha}
+        a1, b1, s1 = _apply_c(alpha, beta, j, 0, create=False)
+        if a1 is None:
+            continue
+        # c_{j beta}
+        a2, b2, s2 = _apply_c(a1, b1, j, 1, create=False)
+        if a2 is None:
+            continue
+        for i in orbs:
+            # c^+_{i beta}
+            a3, b3, s3 = _apply_c(a2, b2, i, 1, create=True)
+            if a3 is None:
+                continue
+            # c^+_{i alpha}
+            a4, b4, s4 = _apply_c(a3, b3, i, 0, create=True)
+            if a4 is None:
+                continue
+            sign = s1 * s2 * s3 * s4 * site_sign[i] * site_sign[j]
+            key = _canon_det(a4, b4)
+            if key is None:
+                continue
+            out[key] = out.get(key, 0) + sign
+    return out
+
+
+def eta_squared_matrix(det_strings, site_signs, orbs=None):
+    """
+    Build the eta-pseudospin squared matrix  eta^2  in a Slater-det basis
+    at eta_z = (N - L) / 2 = 0  (half-filling on a bipartite lattice).
+
+    The eta operators are
+        eta_+ = sum_i  s_i  c^+_{i alpha} c^+_{i beta}
+        eta_- = (eta_+)^dagger
+        eta_z = (N_total - L) / 2
+    where s_i = +/-1 is the sublattice sign.  On a bipartite nearest-
+    neighbor hopping lattice at half-filling, [H, eta_+-] = 0; on adding
+    Hubbard U this reduces to [H, eta_z] = 0 only.
+
+    Parameters
+    ----------
+    det_strings : list of symvb Slater-det strings, all at N = L.
+    site_signs : dict {orbital_label: +1 or -1} encoding the bipartition.
+    orbs : optional list of orbital labels (inferred from site_signs if
+           omitted).
+
+    Returns
+    -------
+    eta2 : (N, N) ndarray.  Eigenvalues are eta(eta+1) for eta = 0, 1, 2, ...
+
+    Thin wrapper around `symvb.operators.eta_squared(...).matrix(...)`.
+    """
+    from symvb import operators as _op
+    return np.array(_op.eta_squared(site_signs).matrix(det_strings), dtype=float)
+
+
+def project_onto_S(H, S2, target_S, tol=1e-8):
+    """
+    Project H onto the eigenspace of S^2 with eigenvalue target_S * (target_S + 1).
+
+    Returns (H_block, U) where U has orthonormal columns spanning the
+    target-S subspace and H_block = U^T H U.
+    """
+    target = target_S * (target_S + 1)
+    evals, evecs = np.linalg.eigh((S2 + S2.T) / 2)
+    mask = np.abs(evals - target) < tol
+    if not mask.any():
+        raise ValueError(f'no S^2 eigenvalues near S(S+1) = {target} '
+                         f'(spectrum: {sorted(set(round(e, 6) for e in evals))})')
+    U = evecs[:, mask]
+    H_block = U.T @ H @ U
+    return H_block, U