ffsim 0.0.79__tar.gz → 0.0.80__tar.gz

{ffsim-0.0.79 → ffsim-0.0.80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffsim
-Version: 0.0.79
+Version: 0.0.80
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -32,13 +32,13 @@ Project-URL: Homepage, https://github.com/qiskit-community/ffsim
 
 <!-- start introduction -->
 
-ffsim is a software library for simulating fermionic quantum circuits that conserve particle number and the Z component of spin. This category includes many quantum circuits used for quantum chemistry simulations. By exploiting the symmetries and using specialized algorithms, ffsim can simulate these circuits much faster than a generic quantum circuit simulator.
+ffsim is a software library for simulating fermionic quantum circuits that conserve particle number and the *z* component of spin. This category includes many quantum circuits used for quantum chemistry simulations. By exploiting the symmetries and using specialized algorithms, ffsim can simulate these circuits much faster than a generic quantum circuit simulator.
 
 <!-- end introduction -->
 
 ## Documentation
 
-Documentation is located at the [project website](https://qiskit-community.github.io/ffsim/).
+Documentation is located at the [project website](https://qiskit-community.github.io/ffsim/). You might also be interested in the [paper about ffsim](https://arxiv.org/abs/2605.03123).
 
 ## Installation
 
@@ -112,10 +112,14 @@ print(energy)  # prints -104.17181289596
 You can cite ffsim using the following BibTeX:
 
 ```bibtex
-@misc{ffsim,
-  author = {{The ffsim developers}},
-  title = {ffsim: Faster simulations of fermionic quantum circuits},
-  howpublished = {\url{https://github.com/qiskit-community/ffsim}},
+@misc{sung2026ffsim,
+      title={ffsim: Faster simulation of fermionic quantum circuits},
+      author={Kevin J. Sung and Inho Choi and Mirko Amico and Bartholomew Andrews and Esra Ayantuna and Yukio Kawashima and Wan-Hsuan Lin and David Omanovic and Samuele Piccinelli and Javier Robledo Moreno and Abdullah Ash Saki and James Shee and Soyoung Shin and Minh C. Tran and Kento Ueda and Haimeng Zhang and Mario Motta},
+      year={2026},
+      eprint={2605.03123},
+      archivePrefix={arXiv},
+      primaryClass={quant-ph},
+      url={https://arxiv.org/abs/2605.03123},
 }
 ```
 

{ffsim-0.0.79 → ffsim-0.0.80}/README.md

@@ -2,13 +2,13 @@
 
 <!-- start introduction -->
 
-ffsim is a software library for simulating fermionic quantum circuits that conserve particle number and the Z component of spin. This category includes many quantum circuits used for quantum chemistry simulations. By exploiting the symmetries and using specialized algorithms, ffsim can simulate these circuits much faster than a generic quantum circuit simulator.
+ffsim is a software library for simulating fermionic quantum circuits that conserve particle number and the *z* component of spin. This category includes many quantum circuits used for quantum chemistry simulations. By exploiting the symmetries and using specialized algorithms, ffsim can simulate these circuits much faster than a generic quantum circuit simulator.
 
 <!-- end introduction -->
 
 ## Documentation
 
-Documentation is located at the [project website](https://qiskit-community.github.io/ffsim/).
+Documentation is located at the [project website](https://qiskit-community.github.io/ffsim/). You might also be interested in the [paper about ffsim](https://arxiv.org/abs/2605.03123).
 
 ## Installation
 
@@ -82,10 +82,14 @@ print(energy)  # prints -104.17181289596
 You can cite ffsim using the following BibTeX:
 
 ```bibtex
-@misc{ffsim,
-  author = {{The ffsim developers}},
-  title = {ffsim: Faster simulations of fermionic quantum circuits},
-  howpublished = {\url{https://github.com/qiskit-community/ffsim}},
+@misc{sung2026ffsim,
+      title={ffsim: Faster simulation of fermionic quantum circuits},
+      author={Kevin J. Sung and Inho Choi and Mirko Amico and Bartholomew Andrews and Esra Ayantuna and Yukio Kawashima and Wan-Hsuan Lin and David Omanovic and Samuele Piccinelli and Javier Robledo Moreno and Abdullah Ash Saki and James Shee and Soyoung Shin and Minh C. Tran and Kento Ueda and Haimeng Zhang and Mario Motta},
+      year={2026},
+      eprint={2605.03123},
+      archivePrefix={arXiv},
+      primaryClass={quant-ph},
+      url={https://arxiv.org/abs/2605.03123},
 }
 ```
 

{ffsim-0.0.79 → ffsim-0.0.80}/docs/_templates/autosummary/class.rst

@@ -5,6 +5,22 @@
 .. autoclass:: {{ objname }}
    :show-inheritance:
 
+   {% block attributes %}
+   {% if attributes %}
+   .. rubric:: {{ _('Attributes') }}
+
+   .. autosummary::
+   {% for item in attributes if item not in inherited_members %}
+      ~{{ name }}.{{ item }}
+   {%- endfor %}
+
+   {%- for item in attributes if item not in inherited_members %}
+
+   .. autoattribute:: {{ item }}
+   {%- endfor %}
+   {% endif %}
+   {% endblock %}
+
    {% block methods %}
    {%- set is_protocol = '__protocol_attrs__' in members and '__protocol_attrs__' not in inherited_members %}
    {%- set ns = namespace(protocol_methods=[]) %}
@@ -25,7 +41,7 @@
    {%- for item in ns.protocol_methods if item not in inherited_members %}
       ~{{ name }}.{{ item }}
    {%- endfor %}
-   {% endif %}
+
    {%- for item in methods if item not in inherited_members and item != '__init__' %}
 
    .. automethod:: {{ item }}
@@ -34,15 +50,6 @@
 
    .. automethod:: {{ item }}
    {%- endfor %}
-   {% endblock %}
-
-   {% block attributes %}
-   {% if attributes %}
-   .. rubric:: {{ _('Attributes') }}
-
-   .. autosummary::
-   {% for item in attributes if item not in inherited_members %}
-      ~{{ name }}.{{ item }}
-   {%- endfor %}
    {% endif %}
    {% endblock %}
+

{ffsim-0.0.79 → ffsim-0.0.80}/docs/how-to-guides/qiskit-circuits-sim.ipynb

@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Simulate excitation-preserving Qiskit circuits\n",
+    "# Simulate Hamming weight-preserving Qiskit circuits\n",
     "\n",
     "ffsim supports the simulation of a restricted class of Qiskit circuits built from gates in the Qiskit circuit library. The simulation is accomplished by mapping the qubits to fermions. The circuits that can be simulated are those whose gates, except for state preparation and measurement, are \"excitation-preserving,\" that is, they do not alter the Hamming weight of computational basis states. Concretely, the circuit should have the following structure:\n",
     "\n",
@@ -25,6 +25,7 @@
     "- GlobalPhaseGate\n",
     "- IGate\n",
     "- InnerProductGate\n",
+    "- iSwapGate\n",
     "- MCPhaseGate\n",
     "- PermutationGate\n",
     "- PhaseGate\n",
@@ -39,9 +40,8 @@
     "- UCRZGate\n",
     "- XXPlusYYGate\n",
     "- ZGate\n",
-    "- iSwapGate\n",
     "\n",
-    "Currently, simulations are limited to 63 qubits (or 126 qubits for circuits with \"spin Z symmetry,\" see [below](#circuits-with-spin-z-symmetry)).\n",
+    "Currently, simulations are limited to 63 qubits (or 126 qubits for circuits with \"spin *z* symmetry,\" see [below](#circuits-with-spin-z-symmetry)).\n",
     "\n",
     "The following code cell constructs an example of a 63-qubit circuit that would be difficult for a generic quantum circuit simulator, but is easy for ffsim because it only contains 2 excitations."
    ]
@@ -277,9 +277,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Circuits with spin Z symmetry\n",
+    "## Circuits with spin *z* symmetry\n",
     "\n",
-    "In addition to being excitation-preserving, circuits with so-called spin Z symmetry have an even number of qubits, and excitations do not pass between the first half of the qubits and the second half. Such circuits arise naturally in many fermionic systems, where the first half of the qubits represent spin-up orbitals and the second half of the qubits represent spin-down orbitals. For example, the spinful variants of the [local unitary cluster Jastrow (LUCJ) ansatz](../explanations/lucj.ipynb) have this symmetry.\n",
+    "In addition to being excitation-preserving, circuits with so-called spin *z* symmetry have an even number of qubits, and excitations do not pass between the first half of the qubits and the second half. Such circuits arise naturally in many fermionic systems, where the first half of the qubits represent spin-up orbitals and the second half of the qubits represent spin-down orbitals. For example, the spinful variants of the [local unitary cluster Jastrow (LUCJ) ansatz](../explanations/lucj.ipynb) have this symmetry.\n",
     "\n",
     "The following code cell constructs a 126-qubit LUCJ circuit with 2 electrons in each spin sector. While the number of qubits in this circuit is well beyond the capabilities of a generic state vector simulator, ffsim can easily simulate it by taking advantage of both the particle number conservation and spin Z symmetries."
    ]
@@ -375,7 +375,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.13.7"
+   "version": "3.13.12"
   }
  },
  "nbformat": 4,

{ffsim-0.0.79 → ffsim-0.0.80}/pyproject.toml

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

{ffsim-0.0.79 → ffsim-0.0.80}/python/ffsim/_slow/fermion_operator.py

@@ -176,10 +176,10 @@ class FermionOperator(MutableMapping):
         if not (self.conserves_particle_number() and self.conserves_spin_z()):
             raise ValueError(
                 "The given FermionOperator could not be converted to a LinearOperator "
-                "because it does not conserve particle number and the Z component "
+                "because it does not conserve particle number and the z component "
                 "of spin. "
                 f"Conserves particle number: {self.conserves_particle_number()} "
-                f"Conserves spin Z: {self.conserves_spin_z()}"
+                f"Conserves spin z: {self.conserves_spin_z()}"
             )
 
         dim_ = dim(norb, nelec)

{ffsim-0.0.79 → ffsim-0.0.80}/python/ffsim/hamiltonians/diagonal_coulomb_hamiltonian.py

@@ -49,19 +49,16 @@ class DiagonalCoulombHamiltonian(
     :math:`J^{\alpha\alpha}=J^{\beta\beta}` and
     :math:`J^{\alpha\beta}=J^{\beta\alpha}`, so only two matrices are needed to describe
     the Hamiltonian.
-
-    Attributes:
-        one_body_tensor (np.ndarray): The one-body tensor :math:`h`.
-        diag_coulomb_mats (np.ndarray): The diagonal Coulomb matrices
-            :math:`J^{\alpha\alpha}` and :math:`J^{\alpha\beta}`, given as a pair
-            of Numpy arrays specifying independent coefficients for alpha-alpha and
-            alpha-beta interactions (in that order).
-        constant (float): The constant.
     """
 
     one_body_tensor: np.ndarray
+    r"""The one-body tensor :math:`h`."""
     diag_coulomb_mats: np.ndarray
+    r"""The diagonal Coulomb matrices :math:`J^{\alpha\alpha}` and
+    :math:`J^{\alpha\beta}`, given as a pair of Numpy arrays specifying independent
+    coefficients for alpha-alpha and alpha-beta interactions (in that order)."""
     constant: float = 0.0
+    """The constant."""
 
     @property
     def norb(self) -> int:

{ffsim-0.0.79 → ffsim-0.0.80}/python/ffsim/hamiltonians/double_factorized_hamiltonian.py

@@ -82,24 +82,22 @@ class DoubleFactorizedHamiltonian(
         - `Motta et al., "Low rank representations for quantum simulation of electronic structure" (2021)`_
         - `Cohn, Motta, and Parrish, "Quantum Filter Diagonalization with Double-Factorized Hamiltonians" (2021)`_
 
-    Attributes:
-        one_body_tensor (np.ndarray): The one-body tensor :math:`\kappa`.
-        diag_coulomb_mats (np.ndarray): The diagonal Coulomb matrices.
-        orbital_rotations (np.ndarray): The orbital rotations.
-        constant (float): The constant.
-        z_representation (bool): Whether the Hamiltonian is in the "Z" representation
-            rather than the "number" representation.
-
     .. _Motta et al., "Low rank representations for quantum simulation of electronic structure" (2021): https://arxiv.org/abs/1808.02625
     .. _Cohn, Motta, and Parrish, "Quantum Filter Diagonalization with Double-Factorized Hamiltonians" (2021): https://arxiv.org/abs/2104.08957
     .. _scipy.optimize.minimize: https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html
     """  # noqa: E501
 
     one_body_tensor: np.ndarray
+    r"""The one-body tensor :math:`\kappa`."""
     diag_coulomb_mats: np.ndarray
+    """The diagonal Coulomb matrices."""
     orbital_rotations: np.ndarray
+    """The orbital rotations."""
     constant: float = 0.0
+    """The constant."""
     z_representation: bool = False
+    """Whether the Hamiltonian is in the "Z" representation rather than the "number"
+    representation."""
 
     @property
     def norb(self) -> int:

{ffsim-0.0.79 → ffsim-0.0.80}/python/ffsim/hamiltonians/molecular_hamiltonian.py

@@ -45,16 +45,14 @@ class MolecularHamiltonian(
 
     Here :math:`h_{pq}` is called the one-body tensor and :math:`h_{pqrs}` is called
     the two-body tensor.
-
-    Attributes:
-        one_body_tensor (np.ndarray): The one-body tensor.
-        two_body_tensor (np.ndarray): The two-body tensor.
-        constant (float): The constant.
     """
 
     one_body_tensor: np.ndarray
+    """The one-body tensor."""
     two_body_tensor: np.ndarray
+    """The two-body tensor."""
     constant: float = 0.0
+    """The constant."""
 
     @property
     def norb(self) -> int:
@@ -275,15 +273,14 @@ class MolecularHamiltonianSpinless(
     Here :math:`h_{pq}` is called the one-body tensor and :math:`h_{pqrs}` is called
     the two-body tensor.
 
-    Attributes:
-        one_body_tensor (np.ndarray): The one-body tensor.
-        two_body_tensor (np.ndarray): The two-body tensor.
-        constant (float): The constant.
     """
 
     one_body_tensor: np.ndarray
+    """The one-body tensor."""
     two_body_tensor: np.ndarray
+    """The two-body tensor."""
     constant: float = 0.0
+    """The constant."""
 
     @property
     def norb(self) -> int:

{ffsim-0.0.79 → ffsim-0.0.80}/python/ffsim/hamiltonians/single_factorized_hamiltonian.py

@@ -47,16 +47,15 @@ class SingleFactorizedHamiltonian(protocols.SupportsLinearOperator):
 
     where each :math:`M^{(t)}` is a Hermitian matrix.
 
-    Attributes:
-        one_body_tensor (np.ndarray): The one-body tensor :math:`\kappa`.
-        one_body_squares (np.ndarray): The one-body tensors :math:`M^{(t)}` whose
-            squares are summed in the Hamiltonian.
-        constant (float): The constant.
     """
 
     one_body_tensor: np.ndarray
+    r"""The one-body tensor :math:`\kappa`."""
     one_body_squares: np.ndarray
+    r"""The one-body tensors :math:`M^{(t)}` whose squares are summed in the
+    Hamiltonian."""
     constant: float = 0.0
+    """The constant."""
 
     @property
     def norb(self) -> int:

{ffsim-0.0.79 → ffsim-0.0.80}/python/ffsim/molecular_data.py

@@ -41,87 +41,78 @@ from ffsim.hamiltonians import MolecularHamiltonian
 
 @dataclasses.dataclass(kw_only=True)
 class MolecularData:
-    """Class for storing molecular data.
-
-    Attributes:
-        core_energy (float): The core energy.
-        one_body_integrals (np.ndarray): The one-body integrals.
-        two_body_integrals (np.ndarray): The two-body integrals in compressed format.
-        norb (int): The number of spatial orbitals.
-        nelec (tuple[int, int]): The number of alpha and beta electrons.
-        atom (list[tuple[str, list[float]]] | None): The coordinates of the atoms in
-            the molecule.
-        basis (str | None): The basis set, e.g. "sto-6g".
-        spin (int | None): The spin of the molecule.
-        symmetry (str | None): The symmetry of the molecule.
-        mo_coeff (np.ndarray | None): Molecular orbital coefficients in the AO basis.
-        mo_occ (np.ndarray | None): Molecular orbital occupancies.
-        active_space (list[int] | None): The molecular orbitals included in the active
-            space.
-        hf_energy (float | None): The Hartree-Fock energy.
-        hf_mo_coeff (np.ndarray | None): Hartree-Fock canonical orbital coefficients in
-            the AO basis.
-        hf_mo_occ (np.ndarray | None): Hartree-Fock canonical orbital occupancies.
-        mp2_energy (float | None): The MP2 energy.
-        mp2_t2 (np.ndarray | tuple[np.ndarray, np.ndarray, np.ndarray] | None): The
-            MP2 t2 amplitudes.
-        ccsd_energy (float | None): The CCSD energy.
-        ccsd_t1 (np.ndarray | tuple[np.ndarray, np.ndarray] | None): The CCSD t1
-            amplitudes.
-        ccsd_t2 (np.ndarray | tuple[np.ndarray, np.ndarray, np.ndarray] | None): The
-            CCSD t2 amplitudes.
-        cisd_energy (float | None): The CISD energy.
-        cisd_vec (np.ndarray | None): The CISD state vector.
-        sci_energy (float | None): The SCI energy.
-        sci_vec (tuple[np.ndarray, np.ndarray, np.ndarray] | None): The SCI state
-            vector coefficients, spin alpha strings, and spin beta strings.
-        fci_energy (float | None): The FCI energy.
-        fci_vec (np.ndarray | None): The FCI state vector.
-        dipole_integrals (np.ndarray | None): The dipole integrals.
-        orbital_symmetries (list[str] | None): The orbital symmetries.
-    """
+    """Class for storing molecular data."""
 
     # Molecular integrals
     core_energy: float
+    """The core energy."""
     one_body_integrals: np.ndarray
+    """The one-body integrals."""
     two_body_integrals: np.ndarray
+    """The two-body integrals in compressed format."""
     # Number of orbitals and numbers of alpha and beta electrons
     norb: int
+    """The number of spatial orbitals."""
     nelec: tuple[int, int]
+    """The numbers of alpha and beta electrons."""
     # Molecule information corresponding to attributes of pyscf.gto.Mole
     atom: list[tuple[str, list[float]]] | None = None
+    """The coordinates of the atoms in the molecule."""
     basis: str | None = None
+    """The basis set, e.g. ``"sto-6g"``."""
     spin: int | None = None
+    """The spin of the molecule."""
     symmetry: str | None = None
+    """The symmetry of the molecule."""
     # active space information
     mo_coeff: np.ndarray | None = None
+    """Molecular orbital coefficients in the AO basis."""
     mo_occ: np.ndarray | None = None
+    """Molecular orbital occupancies."""
     active_space: list[int] | None = None
+    """The molecular orbitals included in the active space."""
     # Hartree-Fock data
     hf_energy: float | None = None
+    """The Hartree-Fock energy."""
     hf_mo_coeff: np.ndarray | None = None
+    """Hartree-Fock canonical orbital coefficients in the AO basis."""
     hf_mo_occ: np.ndarray | None = None
+    """Hartree-Fock canonical orbital occupancies."""
     # MP2 data
     mp2_energy: float | None = None
+    """The MP2 energy."""
     mp2_t2: np.ndarray | tuple[np.ndarray, np.ndarray, np.ndarray] | None = None
+    """The MP2 t2 amplitudes."""
     # CCSD data
     ccsd_energy: float | None = None
+    """The CCSD energy."""
     ccsd_t1: np.ndarray | tuple[np.ndarray, np.ndarray] | None = None
+    """The CCSD t1 amplitudes."""
     ccsd_t2: np.ndarray | tuple[np.ndarray, np.ndarray, np.ndarray] | None = None
+    """The CCSD t2 amplitudes."""
     # CISD data
     cisd_energy: float | None = None
+    """The CISD energy."""
     cisd_vec: np.ndarray | None = None
+    """The CISD state vector."""
     # SCI data
     sci_energy: float | None = None
+    """The SCI energy."""
     sci_vec: tuple[np.ndarray, np.ndarray, np.ndarray] | None = None
+    """The SCI state vector coefficients, spin alpha strings, and spin beta strings."""
     # FCI data
     fci_energy: float | None = None
+    """The FCI energy."""
     fci_vec: np.ndarray | None = None
+    """The FCI state vector."""
     # DMRG data
     dmrg_energy: float | None = None
+    """The DMRG energy."""
     # other information
     dipole_integrals: np.ndarray | None = None
+    """The dipole integrals."""
     orbital_symmetries: list[str] | None = None
+    """The orbital symmetries."""
 
     @cached_property
     def hamiltonian(self) -> MolecularHamiltonian:

{ffsim-0.0.79 → ffsim-0.0.80}/python/ffsim/operators/common_operators.py

@@ -62,9 +62,9 @@ def s_minus_operator(norb: int) -> FermionOperator:
 
 
 def s_x_operator(norb: int) -> FermionOperator:
-    r"""Spin X operator.
+    r"""Spin :math:`x` operator.
 
-    The spin X operator is defined as
+    The spin :math:`x` operator is defined as
 
     .. math::
 
@@ -79,7 +79,7 @@ def s_x_operator(norb: int) -> FermionOperator:
         norb: The number of spatial orbitals.
 
     Returns:
-        The spin X operator.
+        The spin :math:`x` operator.
     """
     coeffs: dict[tuple[tuple[bool, bool, int], ...], complex] = {}
     for i in range(norb):
@@ -89,9 +89,9 @@ def s_x_operator(norb: int) -> FermionOperator:
 
 
 def s_y_operator(norb: int) -> FermionOperator:
-    r"""Spin Y operator.
+    r"""Spin :math:`y` operator.
 
-    The spin Y operator is defined as
+    The spin :math:`y` operator is defined as
 
     .. math::
 
@@ -106,7 +106,7 @@ def s_y_operator(norb: int) -> FermionOperator:
         norb: The number of spatial orbitals.
 
     Returns:
-        The spin Y operator.
+        The spin :math:`y` operator.
     """
     coeffs: dict[tuple[tuple[bool, bool, int], ...], complex] = {}
     for i in range(norb):
@@ -116,9 +116,9 @@ def s_y_operator(norb: int) -> FermionOperator:
 
 
 def s_z_operator(norb: int) -> FermionOperator:
-    r"""Spin Z operator.
+    r"""Spin :math:`z` operator.
 
-    The spin Z operator is defined as
+    The spin :math:`z` operator is defined as
 
     .. math::
 
@@ -132,7 +132,7 @@ def s_z_operator(norb: int) -> FermionOperator:
         norb: The number of spatial orbitals.
 
     Returns:
-        The spin Z operator.
+        The spin :math:`z` operator.
     """
     coeffs: dict[tuple[tuple[bool, bool, int], ...], complex] = {}
     for i in range(norb):

{ffsim-0.0.79 → ffsim-0.0.80}/python/ffsim/protocols/linear_operator_protocol.py

@@ -68,9 +68,9 @@ def _fermion_operator_to_linear_operator(
     if not (operator.conserves_particle_number() and operator.conserves_spin_z()):
         raise ValueError(
             "The given FermionOperator could not be converted to a LinearOperator "
-            "because it does not conserve particle number and the Z component of spin. "
+            "because it does not conserve particle number and the z component of spin. "
             f"Conserves particle number: {operator.conserves_particle_number()} "
-            f"Conserves spin Z: {operator.conserves_spin_z()}"
+            f"Conserves spin z: {operator.conserves_spin_z()}"
         )
 
     if isinstance(nelec, int):
@@ -105,9 +105,9 @@ def _apply_fermion_term(
     """Apply a product of ladder operators to a state vector.
 
     Given a state vector and a string of ladder operators that conserves particle number
-    and total spin Z, return the state vector that results from applying the ladder
-    operators to the given state vector. The string of ladder operators is represented
-    as a sequence of (``action``, ``spin``, ``orbital``) tuples, where:
+    and the z component of spin, return the state vector that results from applying the
+    ladder operators to the given state vector. The string of ladder operators is
+    represented as a sequence of (``action``, ``spin``, ``orbital``) tuples, where:
 
     - ``action`` is a bool. False indicates a destruction operator and True indicates
       a creation operator.

{ffsim-0.0.79 → ffsim-0.0.80}/python/ffsim/random/random.py

@@ -858,9 +858,9 @@ def random_diagonal_coulomb_hamiltonian(
         one_body_tensor = random_real_symmetric_matrix(norb, seed=rng)
     else:
         one_body_tensor = random_hermitian(norb, seed=rng)
-    diag_coulomb_mat_a = random_real_symmetric_matrix(norb, seed=rng)
-    diag_coulomb_mat_b = random_real_symmetric_matrix(norb, seed=rng)
-    diag_coulomb_mats = np.stack([diag_coulomb_mat_a, diag_coulomb_mat_b])
+    mat_aa = random_real_symmetric_matrix(norb, seed=rng)
+    mat_ab = random_real_symmetric_matrix(norb, seed=rng)
+    diag_coulomb_mats = np.stack([mat_aa, mat_ab])
     constant = rng.standard_normal()
     return hamiltonians.DiagonalCoulombHamiltonian(
         one_body_tensor, diag_coulomb_mats, constant=constant
@@ -956,7 +956,7 @@ def random_fermion_hamiltonian(
 ) -> operators.FermionOperator:
     """Sample a random fermion Hamiltonian.
 
-    A fermion Hamiltonian is hermitian and conserves particle number and spin Z.
+    A fermion Hamiltonian is hermitian and conserves particle number and spin :math:`z`.
 
     Args:
         norb: The number of spatial orbitals.

{ffsim-0.0.79 → ffsim-0.0.80}/python/ffsim/states/rdm.py

@@ -36,15 +36,12 @@ if TYPE_CHECKING:
 
 @dataclasses.dataclass
 class ReducedDensityMatrix:
-    r"""Class to store one- and two-body reduced density matrices.
-
-    Attributes:
-        one_rdm (np.ndarray): The one-body reduced density matrix.
-        two_rdm (np.ndarray): The two-body reduced density matrix.
-    """
+    """Class to store one- and two-body reduced density matrices."""
 
     one_rdm: np.ndarray
+    """The one-body reduced density matrix."""
     two_rdm: np.ndarray
+    """The two-body reduced density matrix."""
 
     def rotated(self, orbital_rotation: np.ndarray) -> ReducedDensityMatrix:
         r"""Apply an orbital rotation to the reduced density matrices.

{ffsim-0.0.79 → ffsim-0.0.80}/python/ffsim/states/states.py

@@ -32,19 +32,16 @@ from ffsim.states.dimensions import dim
 
 @dataclass
 class StateVector:
-    """A state vector in the FCI representation.
-
-    Attributes:
-        vec: Array of state vector coefficients.
-        norb: The number of spatial orbitals.
-        nelec: Either a single integer representing the number of fermions for a
-            spinless system, or a pair of integers storing the numbers of spin alpha
-            and spin beta fermions.
-    """
+    """A state vector in the FCI representation."""
 
     vec: np.ndarray
+    """Array of state vector coefficients."""
     norb: int
+    """The number of spatial orbitals."""
     nelec: int | tuple[int, int]
+    """Either a single integer representing the number of fermions for a spinless
+    system, or a pair of integers storing the numbers of spin alpha and spin beta
+    fermions."""
 
     def __array__(self, dtype=None, copy=None):
         # TODO in Numpy 2.0 this can be simplified to

{ffsim-0.0.79 → ffsim-0.0.80}/python/ffsim/variational/givens.py

@@ -37,23 +37,19 @@ class GivensAnsatzOp(
     Note that this ansatz does not implement any interactions between spin alpha and
     spin beta orbitals.
 
-    Attributes:
-        norb (int): The number of spatial orbitals.
-        interaction_pairs (list[tuple[int, int]]): The orbital pairs to apply the Givens
-            rotations to.
-        thetas (np.ndarray): The angles for the Givens rotations.
-        phis (np.ndarray | None): The optional phase angles for the Givens rotations.
-        phase_angles (np.ndarray | None): The optional phase angles for the layer of
-            single-orbital phase gates.
-
     .. _Givens rotations: ffsim.html#ffsim.apply_givens_rotation
     """
 
     norb: int
+    """The number of spatial orbitals."""
     interaction_pairs: list[tuple[int, int]]
+    """The orbital pairs to apply the Givens rotations to."""
     thetas: np.ndarray
+    """The angles for the Givens rotations."""
     phis: np.ndarray | None
+    """The optional phase angles for the Givens rotations."""
     phase_angles: np.ndarray | None
+    """The optional phase angles for the layer of single-orbital phase gates."""
 
     def __post_init__(self):
         if len(self.thetas) != len(self.interaction_pairs):

{ffsim-0.0.79 → ffsim-0.0.80}/python/ffsim/variational/hopgate.py

@@ -35,14 +35,6 @@ class HopGateAnsatzOperator(
     spin beta orbitals. It was designed to be used with entanglement forging (see
     the references).
 
-    Attributes:
-        norb (int): The number of spatial orbitals.
-        interaction_pairs (list[tuple[int, int]]): The orbital pairs to apply the hop
-            gates to.
-        thetas (np.ndarray): The rotation angles for the hop gates.
-        final_orbital_rotation (np.ndarray): An optional final orbital rotation to
-            append to the ansatz, used to optimize the orbital basis.
-
     References:
         - `Eddins et al., "Doubling the Size of Quantum Simulators by Entanglement Forging" (2022)`_
 
@@ -51,9 +43,14 @@ class HopGateAnsatzOperator(
     """  # noqa: E501
 
     norb: int
+    """The number of spatial orbitals."""
     interaction_pairs: list[tuple[int, int]]
+    """The orbital pairs to apply the hop gates to."""
     thetas: np.ndarray
+    """The rotation angles for the hop gates."""
     final_orbital_rotation: np.ndarray | None = None
+    """An optional final orbital rotation to append to the ansatz, used to optimize
+    the orbital basis."""
 
     def _apply_unitary_(
         self, vec: np.ndarray, norb: int, nelec: int | tuple[int, int], copy: bool