symvb 2.0.0__py3-none-any.whl

symvb/fixed_psi.py

@@ -0,0 +1,272 @@
+import symvb
+from symvb.functions import generate_det_strings, standardize_det, standardize_det_2
+from symvb.functions import attempt_int
+import copy
+
+
+class FixedPsi:
+    # Linear combination of determinants
+    def __init__(self, x=None, coupled_pairs=None):
+        """
+
+        """
+        self.Nel = 0
+
+        self.dets = []
+        self.coefs = []
+
+        if x is None:
+            return
+        self.__iadd__(x)
+
+        if coupled_pairs is not None:
+            for i, j in coupled_pairs:
+                self.couple_orbitals(i, j)
+
+    def __iadd__(self, other):
+        if other.__class__.__name__ == 'str':
+            self.add_str_det(other)
+        elif other.__class__.__name__ == 'SlaterDet':
+            self.add_det(other)
+        elif other.__class__.__name__ == 'FixedPsi':
+            self.add_fixedpsi(other)
+        return self
+
+    def __add__(self, other):
+        result = FixedPsi(self)
+        result += other
+        return result
+
+    def __sub__(self, other):
+        result = FixedPsi(self)
+        result += (-1)*other
+        return result
+
+    def __rsub__(self, other):
+        result = (-1) * FixedPsi(self)
+        result += other
+        return result
+
+    def __neg__(self):
+        return (-1) * FixedPsi(self)
+
+    def __mul__(self, other):
+        if isinstance(other, int) or isinstance(other, float):
+            result = FixedPsi(self)
+            for i in range(len(result)):
+                result.coefs[i] = attempt_int(result.coefs[i]*other)
+            return result
+
+        if other.__class__.__name__ == 'SlaterDet':
+            result = FixedPsi()
+            for d, c in self:
+                result.add_det(d * other, c)
+            return result
+
+        if other.__class__.__name__ == 'FixedPsi':
+            result = FixedPsi()
+            for dS, cS in self:
+                for dO, cO in other:
+                    d = dS * dO
+                    if d.Nel == 0:
+                        continue
+                    fp1 = d.get_sorted()
+                    c1, d1 = fp1.coefs[0], fp1.dets[0]
+                    fp2 = standardize_det_2(d1)
+                    result = result + (c1*cS*cO)*fp2
+                    # result.add_det(d, coef = cS * cO)
+            return result
+        return NotImplemented
+
+    def __rmul__(self, other):
+        if isinstance(other, int) or isinstance(other, float):
+            result = FixedPsi(self)
+            for i in range(len(result)):
+                result.coefs[i] = attempt_int(result.coefs[i]*other)
+            return result
+
+    def __getitem__(self, item):
+        return self.dets[item]
+
+    def __len__(self):
+        return len(self.dets)
+
+    def __contains__(self, item):
+        for d, c in self:
+            if d.det_string == item:
+                return True
+        return False
+
+    def __iter__(self):
+        return zip(self.dets, self.coefs)
+
+    def add_det(self, det, coef=+1):
+        assert det.__class__.__name__ == 'SlaterDet'
+        if det.Nel == 0:
+            return
+
+        # Note: mixed-Nel FixedPsis are allowed (used by N-changing
+        # second-quantized operators like η± and bare c/c†). `self.Nel`
+        # records the Nel of the first non-zero det added; callers that
+        # require a uniform-N state should check this themselves.
+
+        for i in range(len(self)):
+            if det.det_string == self.dets[i].det_string:
+                self.coefs[i] += coef
+                return
+
+        self.dets.append(det)
+        cf = attempt_int(coef)
+        self.coefs.append(cf)
+        if self.Nel == 0:
+            self.Nel = det.Nel
+
+    def add_str_det(self, det_string, coef=+1):
+        sd = symvb.SlaterDet(det_string)
+        self.add_det(sd, coef=coef)
+
+    def add_fixedpsi(self, p, coef=1.0):
+        for d, c in p:
+            merged = False
+            # check if d is already in self
+            for i in range(len(self)):
+                if self.dets[i].det_string == d.det_string:
+                    self.coefs[i] += c
+                    # if it turns to 0, shift left the remaining dets
+                    if self.coefs[i] == 0:
+                        for j in range(i, len(self) - 1):
+                            self.dets[j] = self.dets[j + 1]
+                            self.coefs[j] = self.coefs[j + 1]
+                        self.dets = self.dets[:-1]
+                        self.coefs = self.coefs[:-1]
+                    merged = True
+                    break
+            if not merged:
+                self.add_det(d, c * coef)
+
+    def canonicalize(self):
+        """
+        Rewrite self so that every Slater determinant has its alpha- and beta-
+        orbital labels in alphabetic order. The permutation sign is folded into
+        the coefficient, and dets that collapse to identical canonical strings
+        are merged. Determinants whose coefficients cancel to zero are dropped.
+
+        After canonicalize(), every alpha_string matches a key produced by
+        generate_det_strings, so the precomputed-half-dets fast path in
+        Molecule.op_det works on this FixedPsi.
+        """
+        new_dets = []
+        new_coefs = []
+        for d, c in zip(self.dets, self.coefs):
+            sorted_fp = d.get_sorted()
+            cd = sorted_fp.dets[0]
+            cc = sorted_fp.coefs[0]
+            signed = attempt_int(c * cc)
+
+            merged = False
+            for i, existing in enumerate(new_dets):
+                if existing.det_string == cd.det_string:
+                    new_coefs[i] = attempt_int(new_coefs[i] + signed)
+                    merged = True
+                    break
+            if not merged:
+                new_dets.append(cd)
+                new_coefs.append(signed)
+
+        self.dets = [d for d, c in zip(new_dets, new_coefs) if c != 0]
+        self.coefs = [c for c in new_coefs if c != 0]
+        if not self.dets:
+            self.Nel = 0
+        return self
+
+    def standardize(self):
+        """Rewrite self so that every determinant is in symvb's canonical
+        creation order (the interleaved ``uLuL...`` form of
+        :func:`symvb.functions.standardize_det`). The permutation sign is
+        folded into the coefficient and determinants that collapse to identical
+        canonical strings are merged; determinants whose coefficients cancel to
+        zero are dropped.
+
+        This is the transformation matrix construction needs. Unlike
+        :meth:`canonicalize` (which only sorts orbital labels *within* the alpha
+        and beta blocks and leaves the spin pattern alone), this also brings the
+        spin pattern to the standard alpha-before-beta interleaving. A structure
+        written in a natural creation order, e.g. the alpha-alpha-beta-beta
+        pattern produced by ``coupled_pairs`` on a long bond, therefore ends up
+        in the same convention as the determinant basis, so its couplings are no
+        longer silently dropped by the spin-pattern matching in
+        :meth:`Molecule.build_matrix` / :meth:`Molecule.o2_matrix`.
+
+        On a determinant that is already in canonical order this is a no-op
+        (zero flips, unchanged string).
+        """
+        new_dets = []
+        new_coefs = []
+        for d, c in zip(self.dets, self.coefs):
+            std, flips = standardize_det(d.det_string)
+            signed = attempt_int(c * ((-1) ** flips))
+
+            merged = False
+            for i, existing in enumerate(new_dets):
+                if existing.det_string == std:
+                    new_coefs[i] = attempt_int(new_coefs[i] + signed)
+                    merged = True
+                    break
+            if not merged:
+                new_dets.append(symvb.SlaterDet(std))
+                new_coefs.append(signed)
+
+        self.dets = [d for d, c in zip(new_dets, new_coefs) if c != 0]
+        self.coefs = [c for c in new_coefs if c != 0]
+        if not self.dets:
+            self.Nel = 0
+        return self
+
+    def couple_orbitals(self, o1, o2):
+        # generate determinants that represent a singlet bonding coupling between two orbitals.
+        # Orbital numbering starts from 0
+        determinants = self.dets.copy()
+        coefs = self.coefs.copy()
+        for d, coef in zip(determinants, coefs):
+            # Flip spins
+            ds = d.det_string
+            c1, c2 = [c.lower() if c.isupper() else c.upper() for c in [ds[o1], ds[o2]]]
+            assert c1.lower() != c2.lower(), 'Cannot couple the same orbital'
+            # Flip positions
+            ds2 = ds[:o1] + c2 + ds[(o1 + 1):o2] + c1 + ds[(o2 + 1):]
+            self.add_str_det(ds2, coef=coef)
+
+    def __repr__(self):
+        s = ''
+        for d, cf in self:
+            dc = attempt_int(cf)
+
+            if dc > 0:
+                if dc == 1.0:
+                    s += '+'
+                else:
+                    s += '+%s' % dc
+            elif dc < 0:
+                if dc == -1.0:
+                    s += '-'
+                else:
+                    s += '%s' % dc
+            s += str(d)
+        if len(s) > 0 and s[0] == '+':
+            s = s[1:]
+        return s
+
+
+def generate_dets(Nela, Nelb, Norb):
+    """
+    Generate all possible determinants for a given number of electrons and atomic orbitals.
+    :param Nela: Number of alpha electrons
+    :param Nelb: Number of beta electrons
+    :param Norb: Number of atomic orbitals
+    :return: List of FixedPsi objects, each containing one determinant
+    """
+    L = generate_det_strings(Nela, Nelb, Norb)
+    PP = [None,]*len(L)
+    for i in range(len(L)):
+        PP[i] = FixedPsi(L[i])
+    return PP

symvb/functions.py

@@ -0,0 +1,231 @@
+import string
+from itertools import combinations
+
+from scipy.stats import rankdata
+import sympy
+
+import symvb
+from symvb.data import hperm
+
+
+def generate_det_strings(Na, Nb, Norbs):
+    """
+    Generate all possible determinant strings for a given number of electrons and atomic orbitals.
+    :param Na: Number of alpha electrons
+    :param Nb: Number of beta electrons
+    :param Norbs: Number of atomic orbitals
+    :return: list of determinant strings
+    """
+    result = []
+    for a in combinations(string.ascii_lowercase[:Norbs], Na):
+        for b in combinations(string.ascii_uppercase[:Norbs], Nb):
+            s = ''
+            for i in range(min(Na, Nb)):
+                s += a[i] + b[i]
+            for i in range(Nb, Na): # if Na > Nb
+                s += a[i]
+            for i in range(Na, Nb): # if Nb > Na
+                s += b[i]
+            result.append(s)
+    return result
+
+
+def attempt_int(x):
+    """
+    Convert a float to int if it is numerically equivalent
+    Parameters
+    ----------
+    x: a number (float)
+    Returns
+    -------
+    int or float
+    """
+    try:
+        if x == int(x):
+            return int(x)
+    except TypeError:
+        # symbolic (sympy) coefficients pass through unchanged
+        pass
+    return x
+
+
+def place_low(s, i):
+    """
+    Flips two characters in the string to place the next available lower-case character at i-th position.
+    E.g. place_low('aBcD',1) will return 'acBD'
+    Parameters
+    ----------
+    s: a string containing upper and lower case characters
+    i: position in the string
+
+    Returns
+    -------
+    a list containing two elements:
+    1) new string
+    2) 1 if the flip was performed; 0 otherwise
+    """
+    new_s = s
+    if new_s[i].islower():  # alpha-orbital, no swap needed;
+        return new_s, 0
+    else:
+        j = 1
+        while new_s[i + j].isupper():
+            j += 1
+        new_s = new_s[:i] + new_s[i + j] + new_s[i + 1:i + j] + new_s[i] + new_s[i + j + 1:]
+        return new_s, 1
+
+
+def place_high(s, i):
+    """
+    Flips two characters in the string to place the next available upper-case character at i-th position.
+    E.g. place_low('aBcD',0) will return 'BacD'
+    Parameters
+    ----------
+    s: a string containing upper and lower case characters
+    i: position in the string
+
+    Returns
+    -------
+    a list containing two elements:
+    1) new string
+    2) 1 if the flip was performed; 0 otherwise
+    """
+    new_s = s
+    if new_s[i].isupper():  # beta-orbital, no swap needed;
+        return new_s, 0
+    else:
+        j = 1
+        while new_s[i + j].islower():
+            j += 1
+        new_s = new_s[:i] + new_s[i + j] + new_s[i + 1:i + j] + new_s[i] + new_s[i + j + 1:]
+        return new_s, 1
+
+
+def standardize_det(s):
+    """
+    Rearranges the orbitals in a given determinat string to the standard format,
+    that is 'uLuLuL', 'uLuLuLuuu' or 'uLuLuLLLL'
+    Parameters
+    ----------
+    s: determinant string
+
+    Returns
+    -------
+    1) Determinant string in a standard format
+    2) Number of pairwise flips required to obtain the standard format
+    """
+    new_s = s
+    Nup, Ndown = 0, 0
+    for i in range(len(s)):
+        if s[i].isupper():
+            Ndown += 1
+        else:
+            Nup += 1
+
+    arr_up = 0
+    arr_down = 0
+    complete = False
+    i = 0
+    flips = 0
+    while arr_down < Ndown and arr_up < Nup:
+        new_s, flip = place_low(new_s, i)
+        flips += flip
+        arr_up += 1
+        i += 1
+
+        new_s, flip = place_high(new_s, i)
+        flips += flip
+        i += 1
+        arr_down += 1
+    return new_s, flips
+
+
+def standardize_det_2(d):
+    s, nflips = standardize_det(d.det_string)
+    result = symvb.FixedPsi()
+    if nflips % 2 ==0:
+        coeff = 1
+    else:
+        coeff = -1
+    # store the STANDARDIZED determinant with the fold sign; keeping the
+    # original string here (pre-2026-07-04 behavior) double-counted the
+    # permutation sign and returned sign-flipped products from FixedPsi.__mul__
+    result.add_det(symvb.SlaterDet(s), coef=coeff)
+    return result
+
+
+def sort_ind(v):
+    z = rankdata(v, method='ordinal')
+    h = {}
+    for i in range(len(z)):
+        h[z[i]] = v[i]
+    z2 = hperm[tuple(z)]
+
+    result = [0, ] * len(z2)
+    for i in range(len(z2)):
+        result[i] = h[z2[i]]
+    return result
+
+
+def canonical_chemist_iv(iv):
+    """Canonicalise a 4-AO physicist-notation tuple <i j | k l> under the
+    8-fold permutational symmetry of the corresponding chemist integral
+    (ik|jl), valid for real orbitals:
+
+        (ik|jl) = (ki|jl) = (ik|lj) = (ki|lj)
+                = (jl|ik) = (lj|ik) = (jl|ki) = (lj|ki)
+
+    The corresponding action on the physicist iv = (i, j, k, l) is
+    generated by:
+        alpha: swap slots 0 and 2 (within chemist bra-pair)
+        beta : swap slots 1 and 3 (within chemist ket-pair)
+        gamma: swap (slot 0, slot 1) with (slot 2, slot 3), i.e. (01)(23)
+               (chemist bra-pair <-> ket-pair)
+
+    The 8 group elements yield the same orbit structure as the existing
+    `symvb.data.hperm` table (which encodes the same group). This function
+    returns the lex-smallest of the 8 equivalent iv tuples.
+
+    Unlike `sort_ind`, this works correctly for tuples with repeated AO
+    labels: e.g. (a, a, b, c) and (a, a, c, b) both map to the same
+    canonical tuple, so they receive the same default integral symbol
+    name. `sort_ind`'s ordinal rankdata path assigns distinct ranks to
+    repeated values, missing some chemist orbit identifications.
+    """
+    i, j, k, l = iv
+    forms = (
+        (i, j, k, l),  # identity
+        (k, j, i, l),  # alpha: swap slots 0, 2
+        (i, l, k, j),  # beta : swap slots 1, 3
+        (k, l, i, j),  # alpha * beta
+        (j, i, l, k),  # gamma: (01)(23)
+        (l, i, j, k),  # alpha * gamma
+        (j, k, l, i),  # beta  * gamma
+        (l, k, j, i),  # alpha * beta * gamma
+    )
+    return min(forms)
+
+
+def simplify_matrix(mtx, factor=False):
+    result = sympy.zeros(mtx.shape[0])
+    for i in range(mtx.shape[0]):
+        for j in range(mtx.shape[0]):
+            if factor:
+                result[i, j] = sympy.factor(mtx[i, j])
+            else:
+                result[i, j] = sympy.simplify(mtx[i, j])
+    return result
+
+
+def sorti(s):
+    s2 = s
+    nperms = 0
+    for i in range(len(s) - 1):
+        jmin = i
+        for j in range(i + 1, len(s)):
+            if s2[j] < s2[jmin]:
+                jmin = j
+        if jmin != i:
+            s2 = s2[:i] + s2[jmin] + s2[i + 1:jmin] + s2[i] + s2[jmin + 1:]
+            nperms += 1
+    return s2, nperms