ffsim 0.0.85__tar.gz → 0.0.86__tar.gz

{ffsim-0.0.85 → ffsim-0.0.86}/.github/workflows/build-and-release.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, ubuntu-24.04-arm, macos-latest]
+        os: [ubuntu-latest, ubuntu-24.04-arm, macos-latest, windows-latest]
 
     steps:
       - uses: actions/checkout@v6

{ffsim-0.0.85 → ffsim-0.0.86}/.github/workflows/test-latest-versions.yml

@@ -67,3 +67,21 @@ jobs:
       - name: Run tests
         run: |
           tox run -e test-${{ matrix.python-version }}
+  test-windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.14"]
+    steps:
+      - uses: actions/checkout@v6
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install tox
+        run: |
+          python -m pip install --upgrade pip
+          pip install tox
+      - name: Run tests
+        run: |
+          tox run -e test-${{ matrix.python-version }}

{ffsim-0.0.85 → ffsim-0.0.86}/CONTRIBUTING.md

@@ -1,7 +1,5 @@
 # Developer guide
 
-The instructions on this page won't work natively on Windows. For ffsim development on Windows, we recommend using [Windows Subsystem for Linux (WSL)](https://learn.microsoft.com/en-us/windows/wsl/) and doing development within the WSL.
-
 ## Setup
 
 To set up ffsim for development, install it from source in editable mode along with the development requirements:

{ffsim-0.0.85 → ffsim-0.0.86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffsim
-Version: 0.0.85
+Version: 0.0.86
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -16,9 +16,8 @@ Requires-Dist: jax
 Requires-Dist: numpy
 Requires-Dist: opt-einsum
 Requires-Dist: orjson
-Requires-Dist: pyscf>=2.12
+Requires-Dist: pyscf>=2.15
 Requires-Dist: scipy
-Requires-Dist: typing-extensions
 Requires-Dist: jax[cuda12] ; extra == 'cuda12'
 Requires-Dist: jax[cuda13] ; extra == 'cuda13'
 Requires-Dist: qiskit>=2.0,<3 ; extra == 'qiskit'
@@ -48,13 +47,13 @@ Documentation is located at the [project website](https://qiskit-community.githu
 
 <!-- start installation -->
 
-On Linux and macOS, you can install ffsim using pip:
+You can install ffsim using pip:
 
 ```bash
 pip install ffsim
 ```
 
-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.
+See the [installation instructions](https://qiskit-community.github.io/ffsim/install.html) for more details, including instructions for installing from source and running ffsim in a container.
 
 <!-- end installation -->
 

{ffsim-0.0.85 → ffsim-0.0.86}/README.md

@@ -14,13 +14,13 @@ Documentation is located at the [project website](https://qiskit-community.githu
 
 <!-- start installation -->
 
-On Linux and macOS, you can install ffsim using pip:
+You can install ffsim using pip:
 
 ```bash
 pip install ffsim
 ```
 
-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.
+See the [installation instructions](https://qiskit-community.github.io/ffsim/install.html) for more details, including instructions for installing from source and running ffsim in a container.
 
 <!-- end installation -->
 

{ffsim-0.0.85 → ffsim-0.0.86}/docs/explanations/fermionic-fft.ipynb

@@ -6,13 +6,15 @@
    "source": [
     "# Fermionic fast Fourier transform\n",
     "\n",
-    "The discrete Fourier transform on fermionic creation operators is defined as:\n",
+    "This page explains the fermionic fast Fourier transform, an efficient quantum circuit for the discrete Fourier transform on fermionic modes.\n",
+    "\n",
+    "The discrete Fourier transform on fermionic creation operators is defined as\n",
     "\n",
     "$$\n",
     "a^\\dagger_k \\mapsto \\frac{1}{\\sqrt{N}} \\sum_{n=0}^{N-1} e^{-i 2\\pi k n / N} a^\\dagger_n\n",
     "$$\n",
     "\n",
-    "This is an [orbital rotation](orbital-rotation.ipynb) whose matrix is the unitary DFT matrix $F_N$ with entries $(F_N)_{kn} = \\omega_N^{kn} / \\sqrt{N}$, where $\\omega_N = e^{-i 2\\pi / N}$. Rather than decomposing $F_N$ directly into Givens rotations, the **fermionic fast Fourier transform (FFFT)** uses the [Cooley-Tukey](https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm) algorithm to break it into DFTs of prime size."
+    "This is an [orbital rotation](orbital-rotation.ipynb) whose matrix is the unitary DFT matrix $\\mathbf{F}_N$ with entries $(\\mathbf{F}_N)_{kn} = \\omega_N^{kn} / \\sqrt{N}$, where $\\omega_N = e^{-i 2\\pi / N}$. Rather than decomposing $\\mathbf{F}_N$ directly into Givens rotations, the **fermionic fast Fourier transform (FFFT)** uses the [Cooley-Tukey](https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm) algorithm to break it into DFTs of prime size."
    ]
   },
   {
@@ -21,7 +23,7 @@
    "source": [
     "## Mixed-radix Cooley-Tukey algorithm\n",
     "\n",
-    "The circuit follows the general factorization described in the [Variations](https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm#Variations) section of the Cooley-Tukey FFT algorithm Wikipedia page. First, $N$ is factored into primes using trial division (this is the simple method, which might be improved in future). Writing $N = N_1 N_2$, where $N_2$ is the smallest prime factor, and splitting the input index as $n = N_1 n_2 + n_1$ and the output index as $k = N_2 k_1 + k_2$, the DFT becomes\n",
+    "The circuit follows the general factorization described in the [Variations](https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm#Variations) section of the Cooley-Tukey FFT algorithm Wikipedia page. First, $N$ is factored into primes using trial division. Writing $N = N_1 N_2$, where $N_2$ is the smallest prime factor, and splitting the input index as $n = N_1 n_2 + n_1$ and the output index as $k = N_2 k_1 + k_2$, the DFT becomes\n",
     "\n",
     "$$\n",
     "X_{N_2 k_1 + k_2} =\n",
@@ -42,7 +44,7 @@
     "\n",
     "The recursion ends when the size is prime, in which case the DFT is implemented directly as an orbital rotation.\n",
     "\n",
-    "Under the Jordan-Wigner transformation, a gate implementing an orbital rotation must act on a contiguous block of qubits, because a hopping term between two modes carries a string of $Z$ operators on all the qubits in between. The DFTs in steps 1 and 3 act on strided subsets of modes, so the circuit inserts fermionic mode permutations (themselves orbital rotations by permutation matrices) that bring each subset onto adjacent qubits before the DFTs are applied."
+    "Under the [Jordan-Wigner transformation](https://en.wikipedia.org/wiki/Jordan%E2%80%93Wigner_transformation), a gate implementing an orbital rotation must act on a contiguous block of qubits, because a hopping term between two modes carries a string of $Z$ operators on all the qubits in between. The DFTs in steps 1 and 3 act on strided subsets of modes, so the circuit inserts fermionic mode permutations (themselves orbital rotations by permutation matrices) that bring each subset onto adjacent qubits before the DFTs are applied."
    ]
   },
   {
@@ -51,7 +53,7 @@
    "source": [
     "## Quantum circuit implementation\n",
     "\n",
-    "Under the [Jordan-Wigner transformation](https://en.wikipedia.org/wiki/Jordan%E2%80%93Wigner_transformation), `FermionicFFTSpinlessJW` and `FermionicFFTJW` construct quantum circuits for single-spin and spinful systems, respectively.\n",
+    "ffsim implements the FFFT under the Jordan-Wigner transformation with the [FermionicFFTSpinlessJW](../api/stubs/ffsim.qiskit.FermionicFFTSpinlessJW.rst#ffsim.qiskit.FermionicFFTSpinlessJW) gate for spinless fermions and the [FermionicFFTJW](../api/stubs/ffsim.qiskit.FermionicFFTJW.rst#ffsim.qiskit.FermionicFFTJW) gate for spinful fermions.\n",
     "\n",
     "The following code cell constructs and displays a Qiskit circuit for implementing the fermionic fast Fourier transform on $N = 6$ spatial orbitals, so $N_2 = 2$ and $N_1 = 3$. In the decomposed circuit you can see the mode permutations, the three size-2 DFTs of step 1 and the two size-3 DFTs of step 3 (as orbital rotations), and the twiddle-factor phase gates of step 2."
    ]
@@ -93,32 +95,20 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can check that the circuit implements the DFT orbital rotation by comparing it against `ffsim.apply_orbital_rotation` with the DFT matrix on a random state."
+    "We can check that the circuit implements the DFT orbital rotation by comparing it against [apply_orbital_rotation](../api/stubs/ffsim.apply_orbital_rotation.rst#ffsim.apply_orbital_rotation) with the DFT matrix on a random state."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "import numpy as np\n",
     "import scipy.linalg\n",
     "from qiskit.quantum_info import Statevector\n",
     "\n",
-    "nocc = 3\n",
-    "nelec = (nocc, 0)\n",
+    "nelec = 3  # spinless, so nelec is an integer\n",
     "vec = ffsim.random.random_state_vector(ffsim.dim(norb, nelec), seed=1234)\n",
     "\n",
     "# Apply the FFFT circuit to the state\n",
@@ -130,14 +120,14 @@
     "dft_mat = scipy.linalg.dft(norb, scale=\"sqrtn\")\n",
     "expected = ffsim.apply_orbital_rotation(vec, dft_mat, norb=norb, nelec=nelec)\n",
     "\n",
-    "np.allclose(result, expected)"
+    "np.testing.assert_allclose(result, expected)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "For spinful systems across $2 \\times \\text{norb}$ qubits, `FermionicFFTJW` applies independent sub-circuits for spin alpha (first `norb` qubits) and spin beta (last `norb` qubits)."
+    "For spinful fermions, `FermionicFFTJW` acts on $2N$ qubits and applies the FFFT independently to the spin $\\alpha$ orbitals (the first $N$ qubits) and the spin $\\beta$ orbitals (the last $N$ qubits). The following code cell applies it to the Hartree-Fock state."
    ]
   },
   {
@@ -175,7 +165,7 @@
    "source": [
     "## Cost compared with a direct orbital rotation\n",
     "\n",
-    "The DFT could also be implemented as a single orbital rotation by passing the DFT matrix to `OrbitalRotationSpinlessJW`, which decomposes it directly into Givens rotations. The following code cell compiles both circuits to a basis of CX, $R_Z$, and Clifford single-qubit gates. For each one it reports the number of CX gates, the number of $R_Z$ rotations whose angle is not a multiple of $\\pi/2$ (that is, the non-Clifford rotations), and how many distinct angles those rotations use, each as FFFT / direct."
+    "The DFT could also be implemented as a single orbital rotation by passing the DFT matrix to [OrbitalRotationSpinlessJW](../api/stubs/ffsim.qiskit.OrbitalRotationSpinlessJW.rst#ffsim.qiskit.OrbitalRotationSpinlessJW), which decomposes it directly into Givens rotations. The following code cell compiles both circuits to a basis of CZ, $R_Z$, $\\sqrt{X}$, and $X$ gates. For each one it reports the number of CZ gates, the number of $R_Z$ rotations whose angle is not a multiple of $\\pi/2$ (that is, the non-Clifford rotations), and how many distinct angles those rotations use."
    ]
   },
   {
@@ -187,28 +177,32 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "  N          CX   non-Clifford Rz   distinct angles\n",
-      "  4     28 / 24            8 / 18             1 / 6\n",
-      "  8   144 / 112          26 / 111            2 / 58\n",
-      " 16   656 / 480          74 / 479           5 / 226\n",
-      "  6     72 / 60           34 / 60            8 / 31\n",
-      " 12   348 / 264          84 / 263           8 / 129\n"
+      "        CZ gates      non-Clifford Rz   distinct angles  \n",
+      "  N     FFFT   direct     FFFT   direct     FFFT   direct\n",
+      "  4       14       12        8       18        1        6\n",
+      "  8       72       56       26      105        3       49\n",
+      " 16      328      240       74      465        7      175\n",
+      "  6       36       30       32       56        6       28\n",
+      " 12      174      132       80      253        7      104\n"
      ]
     }
    ],
    "source": [
     "import math\n",
     "\n",
-    "from qiskit import transpile\n",
+    "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
     "\n",
-    "basis_gates = [\"cx\", \"rz\", \"h\", \"s\", \"sdg\", \"x\", \"sx\"]\n",
+    "basis_gates = [\"cz\", \"id\", \"rz\", \"sx\", \"x\"]\n",
+    "pass_manager = generate_preset_pass_manager(\n",
+    "    optimization_level=1, basis_gates=basis_gates\n",
+    ")\n",
     "\n",
     "\n",
     "def cost(gate) -> tuple[int, int, int]:\n",
-    "    \"\"\"Return CX count, non-Clifford Rz count, and number of distinct angles.\"\"\"\n",
+    "    \"\"\"Return CZ count, non-Clifford Rz count, and number of distinct angles.\"\"\"\n",
     "    circuit = QuantumCircuit(gate.num_qubits)\n",
     "    circuit.append(gate, range(gate.num_qubits))\n",
-    "    transpiled = transpile(circuit, basis_gates=basis_gates, optimization_level=1)\n",
+    "    transpiled = pass_manager.run(circuit)\n",
     "    angles = []\n",
     "    for instruction in transpiled.data:\n",
     "        if instruction.operation.name == \"rz\":\n",
@@ -216,17 +210,18 @@
     "            remainder = angle % (math.pi / 2)\n",
     "            if min(remainder, math.pi / 2 - remainder) > 1e-8:\n",
     "                angles.append(round(angle, 8))\n",
-    "    return transpiled.count_ops().get(\"cx\", 0), len(angles), len(set(angles))\n",
+    "    return transpiled.count_ops().get(\"cz\", 0), len(angles), len(set(angles))\n",
     "\n",
     "\n",
-    "print(f\"{'N':>3} {'CX':>11} {'non-Clifford Rz':>17} {'distinct angles':>17}\")\n",
+    "print(f\"{'':>3}{'CZ gates':^18}{'non-Clifford Rz':^18}{'distinct angles':^18}\")\n",
+    "print(f\"{'N':>3}\" + f\"{'FFFT':>9}{'direct':>9}\" * 3)\n",
+    "# List powers of 2 first, then sizes with an odd prime factor\n",
     "for n in [4, 8, 16, 6, 12]:\n",
     "    ffft = cost(ffsim.qiskit.FermionicFFTSpinlessJW(n))\n",
     "    direct = cost(\n",
     "        ffsim.qiskit.OrbitalRotationSpinlessJW(n, scipy.linalg.dft(n, scale=\"sqrtn\"))\n",
     "    )\n",
-    "    cx, rz, angles = (f\"{f} / {d}\" for f, d in zip(ffft, direct))\n",
-    "    print(f\"{n:>3} {cx:>11} {rz:>17} {angles:>17}\")"
+    "    print(f\"{n:>3}\" + \"\".join(f\"{f:>9}{d:>9}\" for f, d in zip(ffft, direct)))"
    ]
   },
   {
@@ -235,13 +230,13 @@
    "source": [
     "The FFFT needs far fewer non-Clifford rotations than the direct orbital rotation, and those rotations use only a handful of distinct angles. This is most pronounced when $N$ is a power of 2. Then every Givens rotation is either a mode permutation (angle $\\pi/2$) or a DFT of size 2 (angle $\\pi/4$), and the only other angles come from twiddle factors, which are multiples of $2\\pi/N$. The direct orbital rotation, by contrast, needs a generic angle for almost every rotation. On fault-tolerant hardware, where each arbitrary-angle rotation must be synthesized from many expensive non-Clifford gates, this makes the FFFT much cheaper.\n",
     "\n",
-    "The price is more CX gates, since the mode permutations add two-qubit gates that the direct decomposition doesn't need. When CX count is the main cost, as on current noisy hardware, the direct orbital rotation is the better choice."
+    "The price is more CZ gates, since the mode permutations add two-qubit gates that the direct decomposition doesn't need. When CZ count is the main cost, as on current noisy hardware, the direct orbital rotation is the better choice."
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },

{ffsim-0.0.85 → ffsim-0.0.86}/docs/install.md

@@ -1,11 +1,6 @@
 # Installation
 
-ffsim is supported directly on Linux and macOS.
-
-ffsim is not supported directly on Windows. Windows users have two main options:
-
-- Use [Windows Subsystem for Linux (WSL)](https://learn.microsoft.com/en-us/windows/wsl/). WSL provides a Linux environment where ffsim can be pip installed from PyPI or from source.
-- Use ffsim within Docker. See [Use within Docker](#use-within-docker).
+ffsim is supported on Linux, macOS, and Windows. On Windows, only x86-64 is supported, because [PySCF](https://pyscf.org/) does not publish wheels for Windows on ARM.
 
 ## Pip install
 
@@ -15,7 +10,7 @@ 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).
+For improved performance on [x86-64](https://en.wikipedia.org/wiki/X86-64) systems, consider [installing from source](#install-from-source).
 
 ### Qiskit interoperability
 
@@ -48,7 +43,7 @@ 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.
+Installing from source may improve performance on x86-64 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.
 

{ffsim-0.0.85 → ffsim-0.0.86}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "maturin"
 [project]
 name = "ffsim"
 requires-python = ">=3.11"
-version = "0.0.85"
+version = "0.0.86"
 description = "Faster simulation of fermionic quantum circuits."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -27,9 +27,8 @@ dependencies = [
     "numpy",
     "opt_einsum",
     "orjson",
-    "pyscf>=2.12",
+    "pyscf>=2.15",
     "scipy",
-    "typing-extensions",
 ]
 
 [project.optional-dependencies]
@@ -70,7 +69,7 @@ python-source = "python"
 module-name = "ffsim._lib"
 
 [tool.cibuildwheel]
-build = "cp311-macosx* cp311-manylinux_x86_64 cp311-manylinux_aarch64"
+build = "cp311-macosx* cp311-manylinux_x86_64 cp311-manylinux_aarch64 cp311-win_amd64"
 test-requires = "pytest"
 test-extras = ["qiskit"]
 test-command = "pytest {project}/tests"
@@ -79,7 +78,7 @@ test-command = "pytest {project}/tests"
 before-all = "dnf install -y openssl-devel"
 
 [[tool.cibuildwheel.overrides]]
-select = "*-manylinux_x86_64"
+select = "*-manylinux_x86_64 *-win_amd64"
 environment = { RUSTFLAGS = "-C target-cpu=x86-64" }
 
 [tool.pytest.ini_options]

{ffsim-0.0.85 → ffsim-0.0.86}/python/ffsim/_cistring.py

@@ -27,7 +27,7 @@ def make_strings(orbitals: range, nocc: int) -> np.ndarray:
 @cache
 def gen_occslst(orbitals: range, nocc: int) -> np.ndarray:
     """Cached version of pyscf.fci.cistring.gen_occslst."""
-    return cistring.gen_occslst(orbitals, nocc).astype(np.uint, copy=False)
+    return cistring.gen_occslst(orbitals, nocc).astype(np.uintp, copy=False)
 
 
 @cache

{ffsim-0.0.85 → ffsim-0.0.86}/python/ffsim/gates/orbital_rotation.py

@@ -209,7 +209,7 @@ def _zero_one_subspace_indices(
     indices = np.argsort(strings)
     n00 = math.comb(norb - 2, nocc)
     n11 = math.comb(norb - 2, nocc - 2) if nocc >= 2 else 0
-    return indices[n00 : len(indices) - n11].astype(np.uint, copy=False)
+    return indices[n00 : len(indices) - n11].astype(np.uintp, copy=False)
 
 
 @cache
@@ -223,7 +223,7 @@ def _one_subspace_indices(
     n0 = math.comb(norb, nocc)
     if nocc >= len(target_orbs):
         n0 -= math.comb(norb - len(target_orbs), nocc - len(target_orbs))
-    return indices[n0:].astype(np.uint, copy=False)
+    return indices[n0:].astype(np.uintp, copy=False)
 
 
 @cache

{ffsim-0.0.85 → ffsim-0.0.86}/python/ffsim/hamiltonians/molecular_hamiltonian.py

@@ -18,7 +18,6 @@ import scipy.linalg
 from pyscf.fci.direct_nosym import make_hdiag
 from pyscf.fci.direct_uhf import make_hdiag as make_hdiag_uhf
 from scipy.sparse.linalg import LinearOperator
-from typing_extensions import deprecated
 
 from ffsim import protocols
 from ffsim.contract.two_body import two_body_linop, two_body_linop_unrestricted
@@ -63,36 +62,6 @@ class MolecularHamiltonian(
         """The number of spatial orbitals."""
         return self.one_body_tensor.shape[0]
 
-    @property
-    @deprecated(
-        "The MolecularHamiltonian.one_body_tensor_spinless property is deprecated. "
-        "Instead, use the to_spinless method and access the one_body_tensor "
-        "attribute of the returned MolecularHamiltonianSpinless."
-    )
-    def one_body_tensor_spinless(self) -> np.ndarray:
-        """The one-body tensor in spinless format.
-
-        .. warning::
-            This property is deprecated. Use
-            :meth:`MolecularHamiltonian.to_spinless` instead.
-        """
-        return self.to_spinless().one_body_tensor
-
-    @property
-    @deprecated(
-        "The MolecularHamiltonian.two_body_tensor_spinless property is deprecated. "
-        "Instead, use the to_spinless method and access the two_body_tensor "
-        "attribute of the returned MolecularHamiltonianSpinless."
-    )
-    def two_body_tensor_spinless(self) -> np.ndarray:
-        """The two-body tensor in spinless format.
-
-        .. warning::
-            This property is deprecated. Use
-            :meth:`MolecularHamiltonian.to_spinless` instead.
-        """
-        return self.to_spinless().two_body_tensor
-
     def to_spinless(self) -> MolecularHamiltonianSpinless:
         """Convert to a spinless molecular Hamiltonian.