ffsim 0.0.78__tar.gz → 0.0.80__tar.gz

{ffsim-0.0.78 → ffsim-0.0.80}/CONTRIBUTING.md

@@ -7,7 +7,7 @@ The instructions on this page won't work natively on Windows. For ffsim developm
 To set up ffsim for development, install it from source in editable mode along with the development requirements:
 
 ```bash
-pip install -e ".[dev]"
+pip install -e . --group dev
 ```
 
 To install the git pre-commit hooks, run
@@ -57,10 +57,7 @@ substituting `<environment name>` with the name of the tox environment for the c
 
 ## Run code checks directly
 
-Running the code checks directly using the corresponding software tool can be useful and allows you to:
-
-- Automatically fix lint and formatting errors.
-- Build the documentation without deleting cached files.
+Running the code checks directly using the corresponding software tool gives you more flexibility and allows you to automatically fix lint and formatting errors.
 
 ### Run tests
 
@@ -101,6 +98,4 @@ sphinx-build -b html -W docs/ docs/_build/html
 
 ## View locally built documentation
 
-After building the docs using either the [tox command](#run-code-checks-using-tox) or the [sphinx command](#build-documentation), open the file `docs/_build/html/index.html` in your web browser. For rapid iterations, the sphinx command is preferred because it retains cached files.
-Building the documentation can consume significant CPU because the tutorial notebooks are executed.
-The tox command deletes cached files so it will execute all the notebooks every time, while the sphinx command only executes notebooks if they were modified from the previous run.
+After building the documentation, open the file `docs/_build/html/index.html` in your web browser.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffsim
-Version: 0.0.78
+Version: 0.0.80
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -32,25 +32,25 @@ 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
 
 <!-- start installation -->
 
-We recommend installing ffsim using pip when possible:
+On Linux and macOS, you can install ffsim using pip:
 
 ```bash
 pip install ffsim
 ```
 
-This method won't work natively on Windows, however. Refer to the [installation instructions](https://qiskit-community.github.io/ffsim/install.html) for information about using ffsim on Windows, as well as instructions for installing from source and running ffsim in a container.
+See the [installation instructions](https://qiskit-community.github.io/ffsim/install.html) for information about using ffsim on Windows, as well as instructions for installing from source and running ffsim in a container.
 
 <!-- end 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.78 → ffsim-0.0.80}/README.md

@@ -2,25 +2,25 @@
 
 <!-- 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
 
 <!-- start installation -->
 
-We recommend installing ffsim using pip when possible:
+On Linux and macOS, you can install ffsim using pip:
 
 ```bash
 pip install ffsim
 ```
 
-This method won't work natively on Windows, however. Refer to the [installation instructions](https://qiskit-community.github.io/ffsim/install.html) for information about using ffsim on Windows, as well as instructions for installing from source and running ffsim in a container.
+See the [installation instructions](https://qiskit-community.github.io/ffsim/install.html) for information about using ffsim on Windows, as well as instructions for installing from source and running ffsim in a container.
 
 <!-- end 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.78 → 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,20 +41,15 @@
    {%- for item in ns.protocol_methods if item not in inherited_members %}
       ~{{ name }}.{{ item }}
    {%- endfor %}
-   {% endif %}
-   {%- for item in ns.protocol_methods %}
+
+   {%- for item in methods if item not in inherited_members and item != '__init__' %}
 
    .. automethod:: {{ item }}
    {%- endfor %}
-   {% endblock %}
-
-   {% block attributes %}
-   {% if attributes %}
-   .. rubric:: {{ _('Attributes') }}
+   {%- for item in ns.protocol_methods %}
 
-   .. autosummary::
-   {% for item in attributes if item not in inherited_members %}
-      ~{{ name }}.{{ item }}
+   .. automethod:: {{ item }}
    {%- endfor %}
    {% endif %}
    {% endblock %}
+

{ffsim-0.0.78 → ffsim-0.0.80}/docs/conf.py

@@ -24,7 +24,6 @@ extensions = [
     "sphinx.ext.intersphinx",
     "sphinx.ext.mathjax",
     "sphinx.ext.viewcode",
-    "sphinx.ext.extlinks",
     "sphinx_autodoc_typehints",
     "myst_parser",
     "nbsphinx",

{ffsim-0.0.78 → 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.78 → ffsim-0.0.80}/docs/install.md

@@ -15,6 +15,8 @@ ffsim is available on [PyPI](https://pypi.org/project/ffsim/). You can install i
 pip install ffsim
 ```
 
+For improved performance on [x86](https://en.wikipedia.org/wiki/X86) systems, considering [installing from source](#install-from-source).
+
 ## Install from source
 
 You can use pip to install ffsim from source. For example:
@@ -25,6 +27,10 @@ cd ffsim
 pip install .
 ```
 
+Installing from source may improve performance on x86 systems because the Rust extensions in the PyPI wheels are compiled with `-C target-cpu=x86-64`, which targets the baseline x86-64 instruction set for broad compatibility. When you build from source, ffsim is configured to compile its Rust extensions with `-C target-cpu=native`, so the Rust compiler can emit optimized instructions (e.g., AVX2, AVX-512) for your specific CPU.
+
+Similarly, you can install [PySCF](https://pyscf.org/) from source with `-DBUILD_MARCH_NATIVE=ON` to enable CPU-specific optimizations in PySCF's C extensions. See [PySCF's installation instructions](https://pyscf.org/user/install.html#build-from-source) for details.
+
 ## Use within Docker
 
 We provide a [Dockerfile](https://github.com/qiskit-community/ffsim/blob/main/Dockerfile) and a [compose.yaml](https://github.com/qiskit-community/ffsim/blob/main/compose.yaml) file, which you can use to build a [Docker](https://www.docker.com/) image with just a few simple commands:

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

@@ -5,7 +5,7 @@ build-backend = "maturin"
 [project]
 name = "ffsim"
 requires-python = ">=3.10"
-version = "0.0.78"
+version = "0.0.80"
 description = "Faster simulation of fermionic quantum circuits."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -45,17 +45,19 @@ dev = [
     "coverage",
     "maturin",
     "mypy",
+    "pre-commit",
+    "pytest",
+    "ruff",
+    "typos",
+]
+docs = [
     "myst-parser",
     "nbmake",
     "nbsphinx",
-    "pre-commit",
-    "pytest",
     "qiskit[visualization]",
     "qiskit-sphinx-theme",
-    "ruff",
     "sphinx",
     "sphinx-autodoc-typehints",
-    "typos",
 ]
 
 [tool.maturin]
@@ -140,7 +142,7 @@ commands = [["pytest"]]
 
 [tool.tox.env.coverage]
 description = "check test coverage"
-dependency_groups = ["dev"]
+deps = ["coverage", "pytest"]
 commands = [
     [
         "coverage",
@@ -157,48 +159,43 @@ commands = [
     ],
 ]
 
-[tool.tox.env.type]
-description = "run type check"
-dependency_groups = ["dev"]
-commands = [["mypy"]]
-
-[tool.tox.env.lint]
-description = "check for lint"
+[tool.tox.env.format]
+description = "check formatting"
 skip_install = true
 deps = ["ruff"]
 allowlist_externals = ["cargo"]
 commands = [
     [
         "ruff",
-        "check",
+        "format",
+        "--check",
     ],
     [
         "cargo",
-        "clippy",
+        "fmt",
         "--all",
         "--",
-        "-D",
-        "warnings",
+        "--check",
     ],
 ]
 
-[tool.tox.env.format]
-description = "check formatting"
+[tool.tox.env.lint]
+description = "check for lint"
 skip_install = true
 deps = ["ruff"]
 allowlist_externals = ["cargo"]
 commands = [
     [
         "ruff",
-        "format",
-        "--check",
+        "check",
     ],
     [
         "cargo",
-        "fmt",
+        "clippy",
         "--all",
         "--",
-        "--check",
+        "-D",
+        "warnings",
     ],
 ]
 
@@ -208,10 +205,14 @@ skip_install = true
 deps = ["typos"]
 commands = [["typos"]]
 
+[tool.tox.env.type]
+description = "run type check"
+deps = ["mypy"]
+commands = [["mypy"]]
+
 [tool.tox.env.docs]
 description = "build docs"
-dependency_groups = ["dev"]
-set_env = { SPHINX_APIDOC_OPTIONS = "members,show-inheritance" }
+dependency_groups = ["docs"]
 commands = [
     [
         "python",

{ffsim-0.0.78 → 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.78 → 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.78 → 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.78 → 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.78 → 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.78 → ffsim-0.0.80}/python/ffsim/linalg/__init__.py

@@ -16,11 +16,7 @@ from ffsim.linalg.double_factorized_decomposition import (
     double_factorized_t2_alpha_beta,
     modified_cholesky,
 )
-from ffsim.linalg.givens import (
-    GivensRotation,
-    apply_matrix_to_slices,
-    givens_decomposition,
-)
+from ffsim.linalg.givens import apply_matrix_to_slices, givens_decomposition
 from ffsim.linalg.linalg import (
     expm_multiply_taylor,
     lup,
@@ -38,7 +34,6 @@ from ffsim.linalg.predicates import (
 )
 
 __all__ = [
-    "GivensRotation",
     "apply_matrix_to_slices",
     "double_factorized",
     "double_factorized_t2",

{ffsim-0.0.78 → ffsim-0.0.80}/python/ffsim/linalg/givens.py

@@ -12,37 +12,11 @@
 
 from __future__ import annotations
 
-import cmath
-from typing import NamedTuple
-
 import numpy as np
-from scipy.linalg.blas import zrotg as zrotg_
 
 from ffsim import _lib
 
 
-class GivensRotation(NamedTuple):
-    r"""A Givens rotation.
-
-    A Givens rotation acts on the two-dimensional subspace spanned by the :math:`i`-th
-    and :math:`j`-th basis vectors as
-
-    .. math::
-
-        \begin{pmatrix}
-            c & s \\
-            -s^* & c \\
-        \end{pmatrix}
-
-    where :math:`c` is a real number and :math:`s` is a complex number.
-    """
-
-    c: float
-    s: complex
-    i: int
-    j: int
-
-
 def apply_matrix_to_slices(
     target: np.ndarray,
     mat: np.ndarray,
@@ -73,24 +47,6 @@ def apply_matrix_to_slices(
     return out
 
 
-def zrotg(a: complex, b: complex, tol=1e-12) -> tuple[float, complex]:
-    r"""Safe version of the zrotg BLAS function.
-
-    The BLAS implementation of zrotg can return NaN values if either a or b is very
-    close to zero. This function detects if either a or b is close to zero up to the
-    specified tolerance, in which case it behaves as if it were exactly zero.
-
-    Note that in contrast to ``scipy.linalg.blas.zrotg``, this function returns c as a
-    float rather than a complex.
-    """
-    if cmath.isclose(b, 0.0, abs_tol=tol):
-        return 1.0, 0j
-    if cmath.isclose(a, 0.0, abs_tol=tol):
-        return 0.0, 1 + 0j
-    c, s = zrotg_(a, b)
-    return c.real, s
-
-
 def givens_decomposition(
     mat: np.ndarray, tol: float = 1e-12
 ) -> tuple[list[tuple[float, complex, int, int]], np.ndarray]: