symvb 2.0.0__py3-none-any.whl

symvb/__init__.py

@@ -0,0 +1,18 @@
+from symvb.slaterdet import SlaterDet
+from symvb.fixed_psi import FixedPsi
+from symvb.molecule import Molecule
+from symvb import symmetry
+from symvb import spin
+from symvb import huckel
+from symvb import mo_projection
+from symvb import operators
+from symvb import system
+from symvb.system import (System, hamiltonian, ground_state,
+                          chirgwin_coulson, structure_vector)
+from symvb.mo_projection import verify_eigenpair, EigenpairResidualError
+
+import logging
+
+logging.basicConfig(format='%(levelname)-8s: %(message)s')
+
+__version__ = "2.0.0"

symvb/_o2_benchmark.py

@@ -0,0 +1,163 @@
+"""
+Benchmark the two o2_det implementations on a fixed system battery.
+
+Runs each (system, method) combination N_TRIALS times, reports the median
+of wall-time and peak memory, plus the total SymPy-op count of the
+resulting matrix as a proxy for output expression complexity.
+
+Usage:
+    cd vbt-3-repo
+    PYTHONPATH=. python3 -m symvb._o2_benchmark
+"""
+from __future__ import annotations
+
+import gc
+import time
+import tracemalloc
+
+import sympy as sp
+
+from symvb import Molecule
+
+
+# --- Cases ---------------------------------------------------------------
+
+_PPP_2E = {'U': ('1111',), 'J': ('1212',), 'K': ('1122',),
+           'M': ('1112', '1121', '1222')}
+
+
+def _h2(cutoff):
+    return dict(
+        label='H2',
+        Na=1, Nb=1, Norbs=2,
+        kwargs=dict(subst_2e=_PPP_2E,
+                    interacting_orbs=['ab'],
+                    max_2e_centers=cutoff),
+    )
+
+
+def _allyl(cutoff):
+    return dict(
+        label='allyl-3c4e',
+        Na=2, Nb=2, Norbs=3,
+        kwargs=dict(subst_2e=_PPP_2E,
+                    interacting_orbs=['ab', 'bc'],
+                    max_2e_centers=cutoff),
+    )
+
+
+def _benzene_ppp():
+    return dict(
+        label='benzene-PPP',
+        Na=3, Nb=3, Norbs=6,
+        kwargs=dict(
+            zero_ii=True,
+            interacting_orbs=['ab', 'bc', 'cd', 'de', 'ef', 'af'],
+            subst={'h': ('H_ab', 'H_bc', 'H_cd', 'H_de', 'H_ef', 'H_af'),
+                   's': ('S_ab', 'S_bc', 'S_cd', 'S_de', 'S_ef', 'S_af')},
+            subst_2e=_PPP_2E,
+            max_2e_centers=2,
+        ),
+    )
+
+
+CASES = [
+    (_h2(cutoff=1), 5),
+    (_h2(cutoff=2), 5),
+    (_allyl(cutoff=1), 5),
+    (_allyl(cutoff=2), 5),
+    (_allyl(cutoff=3), 3),
+    (_allyl(cutoff=4), 3),
+    (_benzene_ppp(), 1),  # 1 trial; if blocked is fast we can rerun with more
+]
+
+
+# --- Bench runner --------------------------------------------------------
+
+def _build_matrix_o2(method, case):
+    m = Molecule(o2_method=method, **case['kwargs'])
+    m.generate_basis(case['Na'], case['Nb'], case['Norbs'])
+    return m.o2_matrix(m.basis)
+
+
+def _count_ops(matrix):
+    return sum(int(matrix[i, j].count_ops())
+               for i in range(matrix.rows) for j in range(matrix.cols))
+
+
+def _trial(method, case):
+    gc.collect()
+    tracemalloc.start()
+    t0 = time.perf_counter()
+    H2 = _build_matrix_o2(method, case)
+    wall = time.perf_counter() - t0
+    _, peak = tracemalloc.get_traced_memory()
+    tracemalloc.stop()
+    ops = _count_ops(H2)
+    n = H2.rows
+    return dict(wall=wall, peak_mb=peak / (1024 * 1024), ops=ops, dim=n)
+
+
+def _median(xs):
+    xs = sorted(xs)
+    n = len(xs)
+    if n == 0:
+        return float('nan')
+    if n % 2 == 1:
+        return xs[n // 2]
+    return 0.5 * (xs[n // 2 - 1] + xs[n // 2])
+
+
+def benchmark():
+    print('=' * 78)
+    print('Two-electron matrix benchmark: direct vs blocked')
+    print('=' * 78)
+    print()
+    header = ('| %-15s | %-7s | %-7s | dim   | wall (s)   | peak (MB)  '
+              '| ops      | speedup |')
+    sep = ('|-----------------|---------|---------|-------'
+           '|------------|------------|----------|---------|')
+    print(header % ('system', 'cutoff', 'method'))
+    print(sep)
+    for case, n_trials in CASES:
+        cutoff = case['kwargs'].get('max_2e_centers', 4)
+        results = {}
+        for method in ('direct', 'blocked'):
+            print('  ... %s cutoff=%d %s (n=%d)'
+                  % (case['label'], cutoff, method, n_trials), flush=True)
+            trials = []
+            for ti in range(n_trials):
+                t = _trial(method, case)
+                trials.append(t)
+                print('      trial %d: wall=%.3fs peak=%.1fMB'
+                      % (ti, t['wall'], t['peak_mb']), flush=True)
+            results[method] = dict(
+                wall=_median([t['wall'] for t in trials]),
+                peak_mb=_median([t['peak_mb'] for t in trials]),
+                ops=trials[0]['ops'],
+                dim=trials[0]['dim'],
+            )
+        # Print rows; speedup column shown on the blocked row only.
+        for method in ('direct', 'blocked'):
+            r = results[method]
+            speedup = ''
+            if method == 'blocked' and results['direct']['wall'] > 0:
+                speedup = '%.2fx' % (results['direct']['wall'] / r['wall'])
+            print('| %-15s | %-7d | %-7s | %-5d | %-10.3f | %-10.2f '
+                  '| %-8d | %-7s |'
+                  % (case['label'], cutoff, method, r['dim'],
+                     r['wall'], r['peak_mb'], r['ops'], speedup))
+        # Sanity: ops should agree (modulo chemist-symmetry symbol naming).
+        ops_diff = results['direct']['ops'] - results['blocked']['ops']
+        if ops_diff != 0:
+            print('|   ^ ops differ by %+d (chemist-symbol naming, not '
+                  'a correctness issue)' % ops_diff)
+    print()
+    print('Notes:')
+    print(' - wall and peak_mb are medians across N_TRIALS runs.')
+    print(' - ops = sum of sympy.count_ops() over all matrix entries.')
+    print(' - speedup > 1 means blocked is faster.')
+
+
+if __name__ == '__main__':
+    benchmark()

symvb/_o2_blocked.py

@@ -0,0 +1,301 @@
+"""
+Spin-block-aware two-electron matrix element (Phase 1.5: half-pair cache).
+
+The historical o2_det in molecule.py expands <D_A | H_2 | D_B> via Loewdin's
+cofactor formula on the full spin-mixed (N-2)-electron overlap and recomputes
+that overlap determinant for every (i, k, j, l) electron-position quadruple.
+Because the AO overlap is spin-diagonal, the (N-2)-electron overlap is itself
+block-diagonal in spin: it factors into per-spin-block determinants. Exploiting
+that structure lets the matrix element be assembled from a small per-pair
+precompute (per-spin-block 1-row and 2-row cofactor tables) plus three spin-
+channel contractions (alpha-alpha, beta-beta, alpha-beta).
+
+Half-pair caching (Phase 1.5)
+-----------------------------
+Per-spin-block cofactor tables depend only on the half-string of D_A and the
+half-string of D_B for that spin. Across the basis, many (D_A, D_B) pairs
+share their (alpha-half-pair, beta-half-pair) decomposition: for benzene
+3a+3b in 6 orbitals, there are C(6,3)^2 = 400 dets but only C(6,3)^2 = 400
+distinct alpha-half-strings and 400 distinct beta-half-strings, hence at
+most 400 * 400 = 160,000 (D_A, D_B) full-pair entries spread across only
+20*20 = 400 unique alpha-half-pairs and 400 unique beta-half-pairs. The
+per-half-pair cofactor tables are therefore evaluated once and reused
+~400-fold rather than rebuilt at every full-pair call.
+
+The cache is lazy: built on demand inside o2_det_blocked, keyed on the
+sorted (alphabetised-within-block) half-strings, attached to the Molecule
+instance as ._o2_blocked_cache. It populates as the caller walks the basis
+and hits all needed entries naturally during one m.o2_matrix(m.basis) sweep.
+
+Algorithm
+---------
+With the user's det_string in possibly-arbitrary creation order, fold the
+parities of (i) the spin-block permutation, (ii) the within-alpha sort,
+and (iii) the within-beta sort into an overall sign and work in canonical
+layout (alpha block first sorted alphabetically, then beta block likewise).
+For the canonical layout:
+
+  - alpha-alpha pair: D^{AB}_{ik,jl} = det(S_beta) * Gamma^alpha_{ik,jl}
+  - beta-beta pair:   D^{AB}_{ik,jl} = det(S_alpha) * Gamma^beta_{ik,jl}
+  - alpha-beta pair:  D^{AB}_{ik,jl} = gamma^alpha_{ij} * gamma^beta_{kl}
+
+where gamma^sigma_{ij} = (-1)^{i+j} det(S^sigma with row i col j removed) and
+Gamma^sigma_{ik,jl} = (-1)^{i+k+j+l} det(S^sigma with rows i,k cols j,l
+removed). The cofactor tables are looked up from the half-pair cache;
+the contraction loops then sum over per-block index ranges directly.
+
+The Phase 2 agreement-test harness in symvb/test_o2_agreement.py validates
+symbolic parity with the direct path on a battery of cases; that harness
+re-runs unchanged after this refactor because the algorithmic content is
+identical.
+"""
+from __future__ import annotations
+
+import sympy as sp
+
+from symvb.functions import sorti
+
+
+_SP_ZERO = sp.Integer(0)
+_SP_ONE = sp.Integer(1)
+
+
+def o2_det_blocked(molecule, D1, D2):
+    """Two-electron matrix element via the spin-block-aware path with
+    half-pair caching.
+
+    Must agree symbolically with Molecule.o2_det(D1, D2) in 'direct' mode
+    on every input. See module docstring for algorithm.
+    """
+    # --- Sz selection ----------------------------------------------------
+    if D1.Nel != D2.Nel:
+        return _SP_ZERO
+    if (len(D1.alpha_string) != len(D2.alpha_string) or
+            len(D1.beta_string) != len(D2.beta_string)):
+        return _SP_ZERO
+
+    # --- Bring each det to canonical (spin-block + alphabetical within
+    #     block) and capture all three sign contributions per det. -------
+    A_alpha_s, A_alpha_inv = sorti(D1.alpha_string)
+    A_beta_s, A_beta_inv = sorti(D1.beta_string)
+    B_alpha_s, B_alpha_inv = sorti(D2.alpha_string)
+    B_beta_s, B_beta_inv = sorti(D2.beta_string)
+
+    sigma_A = (_spin_block_parity(D1.spins) *
+               (1 if A_alpha_inv % 2 == 0 else -1) *
+               (1 if A_beta_inv % 2 == 0 else -1))
+    sigma_B = (_spin_block_parity(D2.spins) *
+               (1 if B_alpha_inv % 2 == 0 else -1) *
+               (1 if B_beta_inv % 2 == 0 else -1))
+    overall_sign = sigma_A * sigma_B
+
+    # --- Half-pair cache lookup (lazy; builds on first request) ---------
+    alpha_data = _get_half_pair(molecule, 'alpha', A_alpha_s, B_alpha_s)
+    beta_data = _get_half_pair(molecule, 'beta', A_beta_s, B_beta_s)
+
+    # Lowercase canonical strings for integral-symbol queries.
+    A_alpha = A_alpha_s.lower()
+    A_beta = A_beta_s.lower()
+    B_alpha = B_alpha_s.lower()
+    B_beta = B_beta_s.lower()
+
+    n_a = len(A_alpha)
+    n_b = len(A_beta)
+
+    det_S_alpha = alpha_data['det']
+    det_S_beta = beta_data['det']
+    gamma_alpha = alpha_data['gamma']
+    gamma_beta = beta_data['gamma']
+    Gamma_alpha = alpha_data['Gamma']
+    Gamma_beta = beta_data['Gamma']
+
+    # --- alpha-alpha channel ---------------------------------------------
+    # Bucket Gamma cofactors by their (int_d - int_x) integrand. Skip
+    # quadruples whose Gamma cofactor is structurally zero (common when
+    # the spin-block overlap has zero rows from non-interacting AOs):
+    # iv-tuple construction and integral lookup avoided entirely.
+    T_aa = _SP_ZERO
+    if n_a >= 2:
+        aa_groups = {}
+        for i in range(n_a):
+            for k in range(i + 1, n_a):
+                for j in range(n_a):
+                    for l in range(j + 1, n_a):
+                        cof = Gamma_alpha[(i, k, j, l)]
+                        if cof == _SP_ZERO:
+                            continue
+                        iv_d = (A_alpha[i], A_alpha[k], B_alpha[j], B_alpha[l])
+                        iv_x = (A_alpha[i], A_alpha[k], B_alpha[l], B_alpha[j])
+                        int_d = molecule.get_o2_expr(iv_d)
+                        int_x = molecule.get_o2_expr(iv_x)
+                        integrand = int_d - int_x
+                        if integrand == _SP_ZERO:
+                            continue
+                        prev = aa_groups.get(integrand)
+                        aa_groups[integrand] = cof if prev is None else prev + cof
+        for integrand, coef in aa_groups.items():
+            T_aa = T_aa + integrand * coef
+        T_aa = T_aa * det_S_beta
+
+    # --- beta-beta channel -----------------------------------------------
+    T_bb = _SP_ZERO
+    if n_b >= 2:
+        bb_groups = {}
+        for i in range(n_b):
+            for k in range(i + 1, n_b):
+                for j in range(n_b):
+                    for l in range(j + 1, n_b):
+                        cof = Gamma_beta[(i, k, j, l)]
+                        if cof == _SP_ZERO:
+                            continue
+                        iv_d = (A_beta[i], A_beta[k], B_beta[j], B_beta[l])
+                        iv_x = (A_beta[i], A_beta[k], B_beta[l], B_beta[j])
+                        int_d = molecule.get_o2_expr(iv_d)
+                        int_x = molecule.get_o2_expr(iv_x)
+                        integrand = int_d - int_x
+                        if integrand == _SP_ZERO:
+                            continue
+                        prev = bb_groups.get(integrand)
+                        bb_groups[integrand] = cof if prev is None else prev + cof
+        for integrand, coef in bb_groups.items():
+            T_bb = T_bb + integrand * coef
+        T_bb = T_bb * det_S_alpha
+
+    # --- alpha-beta channel (direct only; exchange forbidden by spin) ----
+    # The integral set in symvb is small (5-10 distinct symbols at typical
+    # PPP scale), so many AO quadruples in this 4-loop share the same
+    # integral. Two-tier sparse iteration:
+    #
+    #   (a) Reorder loops so gamma_alpha[i][j] sits in the outer pair,
+    #       letting us skip the entire (k, l) inner loop when gamma_alpha
+    #       is structurally zero (common when the alpha overlap has zero
+    #       rows from non-interacting AOs).
+    #   (b) Same for gamma_beta inside.
+    #
+    # Then accumulate the gamma_alpha * gamma_beta products per integral-
+    # symbol bucket and multiply once at the end: replaces ~n_a^2 * n_b^2
+    # three-way SymPy multiplies with the same number of two-way multiplies
+    # plus a handful of final symbol-bucket multiplies.
+    T_ab = _SP_ZERO
+    if n_a >= 1 and n_b >= 1:
+        ab_groups = {}
+        for i in range(n_a):
+            ai = A_alpha[i]
+            for j in range(n_a):
+                gA = gamma_alpha[i][j]
+                if gA == _SP_ZERO:
+                    continue
+                bj = B_alpha[j]
+                for k in range(n_b):
+                    ak = A_beta[k]
+                    for l in range(n_b):
+                        gB = gamma_beta[k][l]
+                        if gB == _SP_ZERO:
+                            continue
+                        iv = (ai, ak, bj, B_beta[l])
+                        int_d = molecule.get_o2_expr(iv)
+                        if int_d == _SP_ZERO:
+                            continue
+                        product = gA * gB
+                        prev = ab_groups.get(int_d)
+                        ab_groups[int_d] = product if prev is None else prev + product
+        for int_sym, coef in ab_groups.items():
+            T_ab = T_ab + int_sym * coef
+
+    result = overall_sign * (T_aa + T_bb + T_ab)
+    if result == 0:
+        return _SP_ZERO
+    return result
+
+
+# --- Half-pair cache -----------------------------------------------------
+
+def _get_half_pair(molecule, spin, A_sorted, B_sorted):
+    """Return cached cofactor tables for the (A_sorted, B_sorted) half-pair
+    in the given spin block. Builds on demand; subsequent calls hit the
+    cache. The cache is attached to the molecule instance and persists for
+    its lifetime."""
+    if not hasattr(molecule, '_o2_blocked_cache') or molecule._o2_blocked_cache is None:
+        molecule._o2_blocked_cache = {'alpha': {}, 'beta': {}}
+    bucket = molecule._o2_blocked_cache[spin]
+    key = (A_sorted, B_sorted)
+    hit = bucket.get(key)
+    if hit is not None:
+        return hit
+    S = _build_overlap(molecule, A_sorted.lower(), B_sorted.lower())
+    n = S.rows
+    entry = {
+        'det': _safe_det(S),
+        'gamma': _one_row_cofactor_table(S) if n >= 1 else None,
+        'Gamma': _two_row_cofactor_dict(S) if n >= 2 else None,
+    }
+    bucket[key] = entry
+    return entry
+
+
+# --- helpers -------------------------------------------------------------
+
+def _spin_block_parity(spins):
+    """Sign of the permutation that brings a spin pattern (string of '+' for
+    alpha and '-' for beta) into canonical (all '+' first, then all '-')
+    order. Equals (-1)^(number of beta-before-alpha inversions)."""
+    inv = 0
+    n = len(spins)
+    for i in range(n):
+        if spins[i] == '-':
+            for j in range(i + 1, n):
+                if spins[j] == '+':
+                    inv += 1
+    return 1 if inv % 2 == 0 else -1
+
+
+def _build_overlap(molecule, A_orbs, B_orbs):
+    """Per-spin-block overlap matrix of pairwise AO overlaps. Both lists
+    must be lowercase spatial-orbital labels of equal length."""
+    n = len(A_orbs)
+    if n == 0:
+        return sp.zeros(0, 0)
+    return sp.Matrix(n, n, lambda i, j: molecule.get_o1_expr(A_orbs[i], B_orbs[j], 'S'))
+
+
+def _safe_det(M):
+    """det() that returns 1 for the empty (0x0) matrix without invoking
+    sympy.det on it (which can be quirky on degenerate sizes)."""
+    if M.rows == 0:
+        return _SP_ONE
+    return M.det()
+
+
+def _one_row_cofactor_table(S):
+    """gamma[i][j] = (-1)^{i+j} det(S with row i, col j removed)."""
+    n = S.rows
+    table = [[None] * n for _ in range(n)]
+    for i in range(n):
+        for j in range(n):
+            sign = 1 if (i + j) % 2 == 0 else -1
+            table[i][j] = sign * _minor(S, [i], [j])
+    return table
+
+
+def _two_row_cofactor_dict(S):
+    """Gamma[(i,k,j,l)] = (-1)^{i+k+j+l} det(S with rows i,k, cols j,l removed)
+    for i<k, j<l. Keys are quadruples of block-internal indices."""
+    n = S.rows
+    table = {}
+    for i in range(n):
+        for k in range(i + 1, n):
+            for j in range(n):
+                for l in range(j + 1, n):
+                    sign = 1 if (i + k + j + l) % 2 == 0 else -1
+                    table[(i, k, j, l)] = sign * _minor(S, [i, k], [j, l])
+    return table
+
+
+def _minor(S, rows_to_remove, cols_to_remove):
+    """Determinant of S with the given rows and columns deleted. Returns 1
+    for the resulting empty matrix."""
+    rows_keep = [r for r in range(S.rows) if r not in rows_to_remove]
+    cols_keep = [c for c in range(S.cols) if c not in cols_to_remove]
+    if not rows_keep:
+        return _SP_ONE
+    return S.extract(rows_keep, cols_keep).det()

symvb/_o2_symmetric.py

@@ -0,0 +1,124 @@
+"""
+Symmetry-projected two-electron matrix construction.
+
+Build H_2 directly in the totally-symmetric (orbit-sum) SALC basis, without
+materialising the full determinant-basis matrix first. The infrastructure
+in symvb.symmetry (apply_orbital_permutation, generate_group,
+totally_symmetric_basis) supplies the orbit decomposition; this module
+contracts the matrix elements using G-invariance of H_2 to skip redundant
+det-pair calls.
+
+Algorithm
+---------
+A totally-symmetric SALC over orbit `orb_a` of size `s_a` is the uniform sum
+
+    psi_a = (1/sqrt(s_a)) * sum_{i in orb_a} D_i
+
+Because H_2 commutes with every group element (a precondition the user
+asserts implicitly through their `subst` and `subst_2e` dictionaries
+grouping equivalent integrals), the matrix element between SALCs
+
+    <psi_a | H_2 | psi_b> = (1/sqrt(s_a s_b)) * sum_{i,j} <D_i | H_2 | D_j>
+
+reduces via group invariance to a single sum:
+
+    <psi_a | H_2 | psi_b> = sqrt(s_a / s_b) * sum_{m in orb_b} <D_seed_a | H_2 | D_m>
+
+where seed_a is any representative of orb_a. The double sum collapses from
+s_a * s_b det-pair calls to s_b (or s_a if we pick the other side as seed).
+
+For benzene's A_{1g} block (38 orbits, 400 dets), this drops the work from
+~80k det-pair calls (full upper-triangle build) to ~8k (single-orbit-side
+sums per SALC pair).
+
+Preconditions
+-------------
+1. The user's subst dictionaries must make H_2 commute with every generator
+   in the supplied group. For uniformly-substituted PPP-type Hamiltonians
+   on regular topologies (benzene ring, allyl chain), this is automatic.
+   If the user uses inequivalent integrals on equivalent atoms, the
+   resulting block matrix will silently differ from the U^T H_full U form.
+
+2. `orbits` must come from `symvb.symmetry.totally_symmetric_basis(generators, N)`
+   on the same `full_basis` length. Signed orbit sums (from
+   `signed_totally_symmetric_basis`) are not supported in this routine
+   yet -- the formula above assumes uniform +1 weights.
+
+Validation against the full build is done by
+test_o2_symmetric.TestSymmetricO2Agreement on small systems where both
+paths are tractable: it constructs the full o2_matrix, projects via
+U^T H U using the unsigned projector, and compares element-wise against
+the direct symmetric build.
+"""
+from __future__ import annotations
+
+import sympy as sp
+
+
+def o2_matrix_symmetric(molecule, full_basis, orbits):
+    """Build the o2 matrix in the totally-symmetric (orbit-sum) SALC basis.
+
+    Parameters
+    ----------
+    molecule : symvb.Molecule
+        Provides o2_det / o2 (works in either 'direct' or 'blocked' o2_method).
+    full_basis : list of FixedPsi
+        The full Sz-sector basis, typically `m.basis` after
+        `m.generate_basis(Na, Nb, Norbs)`.
+    orbits : list of list of int
+        Orbit decomposition of full_basis under the symmetry group.
+        Output of `symvb.symmetry.totally_symmetric_basis(generators, N)[1]`.
+
+    Returns
+    -------
+    H : sympy.Matrix of shape (k, k) with k = len(orbits).
+        Element [a, b] equals <psi_a | H_2 | psi_b> where psi_a is the
+        unit-normalised orbit-sum SALC for orbit a. Equals U^T @ H_full @ U
+        with U from totally_symmetric_basis.
+
+    Notes
+    -----
+    The symmetric upper triangle is computed and mirrored. Each off-diagonal
+    pair costs min(|orb_a|, |orb_b|) det-pair calls; the diagonal costs
+    |orb_a|. For benzene A_{1g} (38 orbits, mean orbit size ~10): ~8k
+    det-pair calls total versus ~80k for the full upper-triangle basis
+    build.
+    """
+    k = len(orbits)
+    H = sp.zeros(k)
+    sizes = [len(orb) for orb in orbits]
+
+    # Cache the seed SlaterDet for each orbit to avoid repeated FixedPsi -> det.
+    def _seed_det(idx):
+        fp = full_basis[orbits[idx][0]]
+        return fp.dets[0]
+
+    seeds = [_seed_det(a) for a in range(k)]
+
+    for a in range(k):
+        size_a = sizes[a]
+        for b in range(a, k):
+            size_b = sizes[b]
+            # Pick the orbit with fewer elements for the inner sum to
+            # minimise det-pair calls. Both choices yield the same value
+            # by Hermiticity; we pick the cheaper one.
+            if size_b <= size_a:
+                # Sum over orb_b, fix seed_a; factor sqrt(size_a / size_b).
+                seed = seeds[a]
+                inner = sp.S.Zero
+                for m in orbits[b]:
+                    other = full_basis[m].dets[0]
+                    inner = inner + molecule.o2_det(seed, other)
+                factor = sp.sqrt(sp.Rational(size_a, size_b))
+            else:
+                # Sum over orb_a, fix seed_b; factor sqrt(size_b / size_a).
+                seed = seeds[b]
+                inner = sp.S.Zero
+                for m in orbits[a]:
+                    other = full_basis[m].dets[0]
+                    inner = inner + molecule.o2_det(other, seed)
+                factor = sp.sqrt(sp.Rational(size_b, size_a))
+            H[a, b] = factor * inner
+            if a != b:
+                H[b, a] = H[a, b]
+    return H

symvb/data.py

@@ -0,0 +1,24 @@
+hperm = {(1, 2, 3, 4): (1, 2, 3, 4),
+         (3, 2, 1, 4): (1, 2, 3, 4),
+         (1, 4, 3, 2): (1, 2, 3, 4),
+         (3, 4, 1, 2): (1, 2, 3, 4),
+         (2, 1, 4, 3): (1, 2, 3, 4),
+         (4, 1, 2, 3): (1, 2, 3, 4),
+         (2, 3, 4, 1): (1, 2, 3, 4),
+         (4, 3, 2, 1): (1, 2, 3, 4),
+         (1, 2, 4, 3): (1, 2, 4, 3),
+         (4, 2, 1, 3): (1, 2, 4, 3),
+         (1, 3, 4, 2): (1, 2, 4, 3),
+         (4, 3, 1, 2): (1, 2, 4, 3),
+         (2, 1, 3, 4): (1, 2, 4, 3),
+         (3, 1, 2, 4): (1, 2, 4, 3),
+         (2, 4, 3, 1): (1, 2, 4, 3),
+         (3, 4, 2, 1): (1, 2, 4, 3),
+         (1, 3, 2, 4): (1, 3, 2, 4),
+         (2, 3, 1, 4): (1, 3, 2, 4),
+         (1, 4, 2, 3): (1, 3, 2, 4),
+         (2, 4, 1, 3): (1, 3, 2, 4),
+         (3, 1, 4, 2): (1, 3, 2, 4),
+         (4, 1, 3, 2): (1, 3, 2, 4),
+         (3, 2, 4, 1): (1, 3, 2, 4),
+         (4, 2, 3, 1): (1, 3, 2, 4)}