ffsim 0.0.82__tar.gz → 0.0.84__tar.gz

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

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

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

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

{ffsim-0.0.82 → ffsim-0.0.84}/docs/explanations/lucj.ipynb

@@ -48,10 +48,10 @@
     "With this setup, orbitals with the same spin are connected with a line topology, while orbitals with different spins are connected when they share the same spatial orbital. This yields the following index constraints on the $\\mathbf{J}$ matrices:\n",
     "\n",
     "$$\n",
-    "\\begin{align*}\n",
+    "\\begin{aligned}\n",
     "\\mathbf{J}^{\\alpha\\alpha} &: \\set{(p, p+1) \\; , \\; p = 0, \\ldots, N-2} \\\\\n",
     "\\mathbf{J}^{\\alpha\\beta} &: \\set{(p, p) \\;, \\; p = 0, \\ldots, N-1}\n",
-    "\\end{align*}\n",
+    "\\end{aligned}\n",
     "$$\n",
     "\n",
     "In other words, if the $\\mathbf{J}$ matrices are nonzero only at the specified indices in the upper triangle, then the $e^{i \\mathcal{J}_k}$ term can be implemented on a square topology without using any swap gates, in constant depth. Of course, imposing such constraints on the ansatz makes it less expressive, so more ansatz repetitions may be required.\n"
@@ -121,10 +121,10 @@
     "\n",
     "The LUCJ ansatz specifies connectivity constraints described by index sets $S_{\\alpha \\alpha}$ and $S_{\\alpha \\beta}$. For example, for square lattice connectivity, the sets are\n",
     "$$\n",
-    "\\begin{align*}\n",
+    "\\begin{aligned}\n",
     "S_{\\alpha \\alpha} &= \\set{(p, p+1) \\; , \\; p = 0, \\ldots, N-2} \\\\\n",
     "S_{\\alpha \\beta} &= \\set{(p, p) \\;, \\; p = 0, \\ldots, N-1}\n",
-    "\\end{align*}\n",
+    "\\end{aligned}\n",
     "$$\n",
     "The index sets specify which diagonal Coulomb interactions are permitted, corresponding to which entries of the $Z^{(k)}$ matrices are allowed to be nonzero. Because the expression for the $t_2$-amplitudes does not distinguish separate $Z^{(k)}$ matrices for same-spin and opposite-spin interactions, we use a heuristic in which, during the optimization, entries of the $Z^{(k)}$ matrices with indices that appear in either set are allowed to be nonzero. As a result, some interactions still need to be discarded when constructing the LUCJ ansatz, but fewer than if no constraints were considered at all.\n",
     "\n",

{ffsim-0.0.82 → ffsim-0.0.84}/docs/explanations/orbital-rotation.ipynb

@@ -13,9 +13,9 @@
     "An orbital rotation is described by an $N \\times N$ unitary matrix $\\mathbf{U}$ (here $N$ is the number spatial orbitals), and we denote the corresponding operator as $\\mathcal{U}$. This operator has the following action on the fermionic creation operators $\\set{a^\\dagger_{i\\sigma}}$:\n",
     "\n",
     "$$\n",
-    "\\begin{align*}\n",
+    "\\begin{aligned}\n",
     "    \\mathcal{U} a^\\dagger_{i\\sigma} \\mathcal{U}^\\dagger = \\sum_j \\mathbf{U}_{ji} a^\\dagger_{j\\sigma}.\n",
-    "\\end{align*}\n",
+    "\\end{aligned}\n",
     "$$\n",
     "\n",
     "That is, $a^\\dagger_{i\\sigma}$ is mapped to a new operator $b^\\dagger_{i\\sigma}$ where $b^\\dagger_{i\\sigma}$ is a linear combination of the operators $\\set{a^\\dagger_{i\\sigma}}$ with coefficients given by the $i$-th column of $\\mathbf{U}$. The fact that $\\mathbf{U}$ is unitary can be used, together with the fermionic anticommutation relations, to show that the $\\set{b^\\dagger_{i\\sigma}}$ also satisfy the fermionic anticommutation relations. Thus, the $b^\\dagger_{i\\sigma}$ are creation operators in a rotated basis of orbitals.\n",
@@ -25,10 +25,10 @@
     "It is a theorem that $\\mathcal{U}$ can be written explicitly as\n",
     "\n",
     "$$\n",
-    "\\begin{align*}\n",
+    "\\begin{aligned}\n",
     "    \\mathcal{U} = \\prod_{\\sigma}\n",
-    "    \\exp\\left[\\sum_{ij} \\log\\left(\\mathbf{U}\\right)_{ij} a^\\dagger_{i\\sigma} a_{j\\sigma}\\right]\n",
-    "\\end{align*}.\n",
+    "    \\exp\\left[\\sum_{ij} \\log\\left(\\mathbf{U}\\right)_{ij} a^\\dagger_{i\\sigma} a_{j\\sigma}\\right] .\n",
+    "\\end{aligned}\n",
     "$$\n",
     "Sometimes, it is useful to specify the orbital rotation via the antihermitian matrix $\\mathbf{K} = \\log(\\mathbf{U})$ rather than $\\mathbf{U}$ itself. However, ffsim generally represents orbital rotations using the unitary matrix $\\mathbf{U}$.\n",
     "\n",
@@ -37,10 +37,10 @@
     "The mapping $\\mathbf{U} \\mapsto \\mathcal{U}$ satisfies the important homomorphism property:\n",
     "\n",
     "$$\n",
-    "\\begin{align*}\n",
+    "\\begin{aligned}\n",
     "    \\mathbf{U}^\\dagger &\\mapsto \\mathcal{U}^\\dagger, \\\\\n",
     "    \\mathbf{U}_1 \\mathbf{U}_2 &\\mapsto \\mathcal{U}_1 \\mathcal{U}_2\n",
-    "\\end{align*}\n",
+    "\\end{aligned}\n",
     "$$\n",
     "\n",
     "for any unitary matrices $\\mathbf{U}$, $\\mathbf{U}_1$, and $\\mathbf{U}_2$.\n",
@@ -50,11 +50,11 @@
     "The definitions given above assume that the same orbital rotation applies to both the spin-up and spin-down orbitals. However, it is possible for each spin sector to have an independent orbital rotation, in which case a pair of unitary matrices $(\\mathbf{U}^\\alpha, \\mathbf{U}^\\beta)$ needs to be specified. Letting $\\mathbf{K}^\\sigma = \\log(\\mathbf{U}^\\sigma)$, the definitions above then become\n",
     "\n",
     "$$\n",
-    "\\begin{align*}\n",
+    "\\begin{aligned}\n",
     "    \\mathcal{U} a^\\dagger_{i\\sigma} \\mathcal{U}^\\dagger &= \\sum_j \\mathbf{U}^{\\sigma}_{ji} a^\\dagger_{j\\sigma}, \\\\\n",
     "    \\mathcal{U} &= \\prod_{\\sigma}\n",
     "    \\exp\\left[\\sum_{ij} \\log\\left(\\mathbf{U}^{\\sigma}\\right)_{ij} a^\\dagger_{i\\sigma} a_{j\\sigma}\\right].\n",
-    "\\end{align*}\n",
+    "\\end{aligned}\n",
     "$$\n",
     "\n",
     "## Application to time evolution by a quadratic Hamiltonian\n",

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

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

{ffsim-0.0.82 → 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.82 → 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.82 → 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.82 → 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",
 ]