ffsim 0.0.83__tar.gz → 0.0.84__tar.gz

{ffsim-0.0.83 → ffsim-0.0.84}/.gitignore

@@ -134,6 +134,9 @@ dmypy.json
 # VS Code
 .vscode/
 
+# macOS
+.DS_Store
+
 # cibuildwheel
 wheelhouse/
 

{ffsim-0.0.83 → ffsim-0.0.84}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffsim
-Version: 0.0.83
+Version: 0.0.84
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only

{ffsim-0.0.83 → ffsim-0.0.84}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "maturin"
 [project]
 name = "ffsim"
 requires-python = ">=3.11"
-version = "0.0.83"
+version = "0.0.84"
 description = "Faster simulation of fermionic quantum circuits."
 readme = "README.md"
 license = { file = "LICENSE" }

{ffsim-0.0.83 → ffsim-0.0.84}/python/ffsim/__init__.py

@@ -31,6 +31,7 @@ from ffsim.hamiltonians import (
     DoubleFactorizedHamiltonian,
     MolecularHamiltonian,
     MolecularHamiltonianSpinless,
+    MolecularHamiltonianUnrestricted,
     SingleFactorizedHamiltonian,
 )
 from ffsim.init_cache import init_cache
@@ -133,6 +134,7 @@ __all__ = [
     "MolecularData",
     "MolecularHamiltonian",
     "MolecularHamiltonianSpinless",
+    "MolecularHamiltonianUnrestricted",
     "NumNumAnsatzOpSpinBalanced",
     "ProductStateSum",
     "ReducedDensityMatrix",

{ffsim-0.0.83 → ffsim-0.0.84}/python/ffsim/contract/__init__.py

@@ -13,7 +13,7 @@
 from ffsim.contract.diag_coulomb import contract_diag_coulomb, diag_coulomb_linop
 from ffsim.contract.num_op_sum import contract_num_op_sum, num_op_sum_linop
 from ffsim.contract.one_body import contract_one_body, one_body_linop
-from ffsim.contract.two_body import two_body_linop
+from ffsim.contract.two_body import two_body_linop, two_body_linop_unrestricted
 
 __all__ = [
     "contract_diag_coulomb",
@@ -23,4 +23,5 @@ __all__ = [
     "num_op_sum_linop",
     "one_body_linop",
     "two_body_linop",
+    "two_body_linop_unrestricted",
 ]

{ffsim-0.0.83 → ffsim-0.0.84}/python/ffsim/contract/two_body.py

@@ -25,6 +25,12 @@ from pyscf.fci.direct_spin1 import (
 from pyscf.fci.direct_spin1 import (
     contract_2e as contract_2e_spin1,
 )
+from pyscf.fci.direct_uhf import (
+    absorb_h1e as absorb_h1e_uhf,
+)
+from pyscf.fci.direct_uhf import (
+    contract_2e as contract_2e_uhf,
+)
 from scipy.sparse.linalg import LinearOperator
 
 from ffsim import states
@@ -139,7 +145,6 @@ def _two_body_linop_complex(
 
     def rmatvec(vec: np.ndarray):
         result = contract_2e_nosym(
-            # TODO come up with a way to test this transpose
             two_body_tensor.transpose(1, 0, 3, 2).conj(),
             vec,
             norb,
@@ -154,3 +159,108 @@ def _two_body_linop_complex(
     return LinearOperator(
         shape=(dim_, dim_), matvec=matvec, rmatvec=rmatvec, dtype=complex
     )
+
+
+def two_body_linop_unrestricted(
+    two_body_tensors: np.ndarray,
+    norb: int,
+    nelec: tuple[int, int],
+    one_body_tensors: np.ndarray | None = None,
+    constant: float = 0,
+) -> LinearOperator:
+    r"""Convert spin-unrestricted two-body tensors to a linear operator.
+
+    The operator has the form
+
+    .. math::
+
+        \frac12 \sum_{pqrs} h^{\alpha\alpha}_{pqrs}
+        a^\dagger_{p\alpha} a^\dagger_{r\alpha} a_{s\alpha} a_{q\alpha}
+        + \sum_{pqrs} h^{\alpha\beta}_{pqrs}
+        a^\dagger_{p\alpha} a^\dagger_{r\beta} a_{s\beta} a_{q\alpha}
+        + \frac12 \sum_{pqrs} h^{\beta\beta}_{pqrs}
+        a^\dagger_{p\beta} a^\dagger_{r\beta} a_{s\beta} a_{q\beta}
+
+    where :math:`h^{\alpha\alpha}`, :math:`h^{\alpha\beta}`, and
+    :math:`h^{\beta\beta}` are tensors of coefficients in chemist ordering, whose spin
+    labels refer to the two *pairs* of indices: in :math:`h^{\alpha\beta}_{pqrs}`, the
+    indices :math:`pq` belong to spin alpha and the indices :math:`rs` belong to spin
+    beta. The alpha-beta term appears with coefficient 1 rather than :math:`\frac12`
+    because the beta-alpha term, whose tensor is
+    :math:`h^{\beta\alpha}_{pqrs} = h^{\alpha\beta}_{rspq}`, contributes the other half.
+    Consequently, the alpha-beta tensor need not be symmetric under exchanging its two
+    index pairs. See :class:`~ffsim.MolecularHamiltonianUnrestricted`.
+
+    Each tensor is assumed to be symmetric within each of its index pairs, that is,
+    :math:`h_{pqrs} = h_{qprs} = h_{pqsr}`.
+
+    Args:
+        two_body_tensors: The two-body tensors
+            :math:`(h^{\alpha\alpha}, h^{\alpha\beta}, h^{\beta\beta})`, as a single
+            Numpy array of shape ``(3, norb, norb, norb, norb)``.
+        norb: The number of spatial orbitals.
+        nelec: The number of alpha and beta electrons.
+        one_body_tensors: Optional one-body tensors
+            :math:`(h^{\alpha}, h^{\beta})`, as a single Numpy array of shape
+            ``(2, norb, norb)``, to absorb into the two-body operator.
+        constant: Optional constant to add to the operator.
+
+    Returns:
+        A LinearOperator that implements the action of the two-body tensors.
+
+    Raises:
+        NotImplementedError: The tensors have a complex data type. PySCF does not
+            provide a spin-unrestricted FCI contraction for complex integrals.
+    """
+    if np.iscomplexobj(two_body_tensors) or (
+        one_body_tensors is not None and np.iscomplexobj(one_body_tensors)
+    ):
+        raise NotImplementedError(
+            "The unrestricted two-body linear operator is not implemented for complex "
+            "tensors."
+        )
+    if one_body_tensors is None:
+        one_body_tensors = np.zeros((2, norb, norb))
+
+    n_alpha, n_beta = nelec
+    linkstr_index_a = gen_linkstr_index_trilidx(range(norb), n_alpha)
+    linkstr_index_b = gen_linkstr_index_trilidx(range(norb), n_beta)
+    link_index = (linkstr_index_a, linkstr_index_b)
+    absorbed_tensors = absorb_h1e_uhf(
+        tuple(np.ascontiguousarray(mat) for mat in one_body_tensors),
+        tuple(np.ascontiguousarray(tensor) for tensor in two_body_tensors),
+        norb,
+        nelec,
+        0.5,
+    )
+
+    def matvec(vec: np.ndarray):
+        # Unlike direct_spin1.contract_2e, direct_uhf.contract_2e does not handle
+        # complex vectors, so the real and imaginary parts are contracted separately.
+        if np.iscomplexobj(vec):
+            result = contract_2e_uhf(
+                absorbed_tensors,
+                np.ascontiguousarray(vec.real),
+                norb,
+                nelec,
+                link_index=link_index,
+            ).astype(complex)
+            result.imag = contract_2e_uhf(
+                absorbed_tensors,
+                np.ascontiguousarray(vec.imag),
+                norb,
+                nelec,
+                link_index=link_index,
+            )
+        else:
+            result = contract_2e_uhf(
+                absorbed_tensors, vec, norb, nelec, link_index=link_index
+            )
+        if constant:
+            result += constant * vec
+        return result
+
+    dim_ = states.dim(norb, nelec)
+    return LinearOperator(
+        shape=(dim_, dim_), matvec=matvec, rmatvec=matvec, dtype=complex
+    )

{ffsim-0.0.83 → ffsim-0.0.84}/python/ffsim/hamiltonians/__init__.py

@@ -18,6 +18,7 @@ from ffsim.hamiltonians.double_factorized_hamiltonian import DoubleFactorizedHam
 from ffsim.hamiltonians.molecular_hamiltonian import (
     MolecularHamiltonian,
     MolecularHamiltonianSpinless,
+    MolecularHamiltonianUnrestricted,
 )
 from ffsim.hamiltonians.single_factorized_hamiltonian import SingleFactorizedHamiltonian
 
@@ -26,5 +27,6 @@ __all__ = [
     "DoubleFactorizedHamiltonian",
     "MolecularHamiltonian",
     "MolecularHamiltonianSpinless",
+    "MolecularHamiltonianUnrestricted",
     "SingleFactorizedHamiltonian",
 ]