From 426028dae006a38bc25f376ff0300fd0e923c8db Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Wed, 16 Apr 2025 12:02:58 -0400 Subject: [PATCH 1/8] add skqd tutorial --- ...f-a-fermionic-lattice-model-with-sqd.ipynb | 743 ++++++++++++++++++ 1 file changed, 743 insertions(+) create mode 100644 docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb diff --git a/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb b/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb new file mode 100644 index 00000000000..235a0bea27c --- /dev/null +++ b/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb @@ -0,0 +1,743 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f5789cd6-7bbb-4413-b238-877f88d5bda6", + "metadata": {}, + "source": [ + "# Improving energy estimation of a fermionic lattice model with SQD\n", + "\n", + "*Usage estimate: 9 seconds on IBM Aachen (NOTE: This is an estimate only. Your runtime may vary.)*" + ] + }, + { + "cell_type": "markdown", + "id": "fe417f6d-c514-4ac9-a756-ef911eaa292d", + "metadata": {}, + "source": [ + "## Background\n", + "\n", + "In this tutorial, we show how to use sample-based quantum diagonalization (SQD) to estimate the ground state energy of a fermionic lattice model. Specifically, we study the one-dimensional single-impurity Anderson model (SIAM), which is used to describe magnetic impurities embedded in metals.\n", + "\n", + "This tutorial follows a similar workflow to the related tutorial [*Improving energy estimation of a chemistry Hamiltonian with SQD*](https://learning.quantum.ibm.com/tutorial/improving-energy-estimation-of-a-fermionic-hamiltonian-with-sqd). However, a key difference lies in how the quantum circuits are built. Whereas the other tutorial uses a heuristic variational ansatz, this tutorial uses circuits that approximate time evolution by the Hamiltonian. The state vectors prepared by these circuits form the basis for a [Krylov subspace](https://en.wikipedia.org/wiki/Krylov_subspace), and as a result, the algorithm provably and efficiently converges to the ground state, under suitable assumptions. This tutorial is based on the work [Quantum-Centric Algorithm for Sample-Based Krylov Diagonalization](https://arxiv.org/abs/2501.09702), which can be referred to for more details.\n", + "\n", + "### Single-impurity Anderson model (SIAM)\n", + "\n", + "The one-dimensional SIAM Hamiltonian is a sum of three terms:\n", + "\n", + "$$\n", + "H = H_{\\textrm{imp}}+ H_\\textrm{bath} + H_\\textrm{hyb},\n", + "$$\n", + "\n", + "where\n", + "\n", + "$$\n", + "\\begin{align*}\n", + " H_\\textrm{imp} &= \\varepsilon \\left( \\hat{n}_{d\\uparrow} + \\hat{n}_{d\\downarrow} \\right) + U \\hat{n}_{d\\uparrow}\\hat{n}_{d\\downarrow}, \\\\\n", + " H_\\textrm{bath} &= -t \\sum_{\\substack{\\mathbf{j} = 0\\\\ \\sigma\\in \\{\\uparrow, \\downarrow\\}}}^{L-1} \\left(\\hat{c}^\\dagger_{\\mathbf{j}, \\sigma}\\hat{c}_{\\mathbf{j}+1, \\sigma} + \\hat{c}^\\dagger_{\\mathbf{j}+1, \\sigma}\\hat{c}_{\\mathbf{j}, \\sigma} \\right), \\\\\n", + " H_\\textrm{hyb} &= V\\sum_{\\sigma \\in \\{\\uparrow, \\downarrow \\}} \\left(\\hat{d}^\\dagger_\\sigma \\hat{c}_{0, \\sigma} + \\hat{c}^\\dagger_{0, \\sigma} \\hat{d}_{\\sigma} \\right).\n", + "\\end{align*}\n", + "$$\n", + "\n", + "Here, $c^\\dagger_{\\mathbf{j},\\sigma}/c_{\\mathbf{j},\\sigma}$ are the fermionic creation/annihilation operators for the $\\mathbf{j}^{\\textrm{th}}$ bath site with spin $\\sigma$, $\\hat{d}^\\dagger_{\\sigma}/\\hat{d}_{\\sigma}$ are creation/annihilation operators for the impurity mode, and $\\hat{n}_{d\\sigma} = \\hat{d}^\\dagger_{\\sigma} \\hat{d}_{\\sigma}$. $t$, $U$, and $V$ are real numbers describing the hopping, on-site, hybridization interactions, and $\\varepsilon$ is a real number specifying the chemical potential.\n", + "\n", + "Note that the Hamiltonian is a specific instance of the generic interaction-electron Hamiltonian,\n", + "\n", + "$$\n", + "\\begin{align*}\n", + " H &= \\sum_{\\substack{p, q \\\\ \\sigma}} h_{pq} \\hat{a}^\\dagger_{p\\sigma} \\hat{a}_{q\\sigma} + \\sum_{\\substack{p, q, r, s \\\\ \\sigma \\tau}} \\frac{h_{pqrs}}{2} \\hat{a}^\\dagger_{p\\sigma} \\hat{a}^\\dagger_{q\\tau} \\hat{a}_{s\\tau} \\hat{a}_{r\\sigma} \\\\\n", + " &= H_1 + H_2,\n", + "\\end{align*}\n", + "$$\n", + "\n", + "where $H_1$ consists of one-body terms, which are quadratic in the fermionic creation and annihilation operators, and $H_2$ consists of two-body terms, which are quartic. For the SIAM,\n", + "$$\n", + "H_2 = U \\hat{n}_{d\\uparrow}\\hat{n}_{d\\downarrow}\n", + "$$\n", + "\n", + "and $H_1$ contains the rest of the terms in the Hamiltonian. In order to represent the Hamiltonian programmatically, we store the matrix $h_{pq}$ and the tensor $h_{pqrs}$.\n", + "\n", + "### Position and momentum bases\n", + "\n", + "Due to the approximate translational symmetry in $H_\\textrm{bath}$, we don't expect the ground state to be sparse in the position basis (the orbital basis in which the Hamiltonian is specified above). The performance of SQD is guaranteed only if the ground state is sparse, that is, it has significant weight on only a small number of computational basis states. To improve the sparsity of the ground state, we perform the simulation in the orbital basis in which $H_\\textrm{bath}$ is diagonal. We call this basis the *momentum basis*. Because $H_\\textrm{bath}$ is a quadratic fermionic Hamiltonian, it can be efficiently diagonalized by an orbital rotation.\n", + "\n", + "### Approximate time evolution by the Hamiltonian\n", + "\n", + "To approximate time evolution by the Hamiltonian, we use a second order Trotter-Suzuki decomposition,\n", + "\n", + "$$\n", + " e^{-i \\Delta t H} \\approx e^{-i\\frac{\\Delta t}{2} H_2} e^{-i\\Delta t H_1} e^{-i\\frac{\\Delta t}{2} H_2}.\n", + "$$\n", + "\n", + "Under the [Jordan-Wigner transformation](https://en.wikipedia.org/wiki/Jordan%E2%80%93Wigner_transformation), time evolution by $H_2$ amounts to a single [CPhase](https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.library.CPhaseGate) gate between the spin-up and spin-down orbitals at the impurity site. Because $H_1$ is a quadratic fermionic Hamiltonian, time evolution by $H_1$ amounts to an orbital rotation.\n", + "\n", + "The Krylov basis states $\\{ |\\psi_k\\rangle \\}_{k=0}^{D-1}$, where $D$ is the dimension of the Krylov subspace, are formed by repeated application of a single Trotter step, so\n", + "\n", + "$$\n", + " |\\psi_k\\rangle \\approx \\left[e^{-i\\frac{\\Delta t}{2} H_2} e^{-i\\Delta t H_1} e^{-i\\frac{\\Delta t}{2} H_2} \\right]^k\\ket{\\psi_0}.\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "3f93b656-2105-4d71-aaa0-b4652d0972b8", + "metadata": {}, + "source": [ + "## Step 1: Map problem to a quantum circuit" + ] + }, + { + "cell_type": "markdown", + "id": "ee397740-5202-44bb-ba4c-ea8bf38f23a7", + "metadata": {}, + "source": [ + "First, we generate the SIAM Hamiltonian in the position basis. The Hamiltonian is represented by the matrix $h_{pq}$ and the tensor $h_{pqrs}$. Then, we rotate it to the momentum basis. In the position basis, we place the impurity at the first site. However, when we rotate to the momentum basis, we move the impurity to a central site to faciliate interactions with other orbitals." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "86229d6d-7d24-4e0f-ac56-6b7238aa9db9", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "\n", + "def siam_hamiltonian(\n", + " norb: int,\n", + " hopping: float,\n", + " onsite: float,\n", + " hybridization: float,\n", + " chemical_potential: float,\n", + ") -> tuple[np.ndarray, np.ndarray]:\n", + " \"\"\"Hamiltonian for the single-impurity Anderson model.\"\"\"\n", + " # Place the impurity on the first site\n", + " impurity_orb = 0\n", + "\n", + " # One body matrix elements in the \"position\" basis\n", + " h1e = np.zeros((norb, norb))\n", + " np.fill_diagonal(h1e[:, 1:], -hopping)\n", + " np.fill_diagonal(h1e[1:, :], -hopping)\n", + " h1e[impurity_orb, impurity_orb + 1] = -hybridization\n", + " h1e[impurity_orb + 1, impurity_orb] = -hybridization\n", + " h1e[impurity_orb, impurity_orb] = chemical_potential\n", + "\n", + " # Two body matrix elements in the \"position\" basis\n", + " h2e = np.zeros((norb, norb, norb, norb))\n", + " h2e[impurity_orb, impurity_orb, impurity_orb, impurity_orb] = onsite\n", + "\n", + " return h1e, h2e\n", + "\n", + "\n", + "def momentum_basis(norb: int) -> np.ndarray:\n", + " \"\"\"Get the orbital rotation to change from the position to the momentum basis.\"\"\"\n", + " n_bath = norb - 1\n", + "\n", + " # Orbital rotation that diagonalizes the bath (non-interacting system)\n", + " hopping_matrix = np.zeros((n_bath, n_bath))\n", + " np.fill_diagonal(hopping_matrix[:, 1:], -1)\n", + " np.fill_diagonal(hopping_matrix[1:, :], -1)\n", + " _, vecs = np.linalg.eigh(hopping_matrix)\n", + "\n", + " # Expand to include impurity\n", + " orbital_rotation = np.zeros((norb, norb))\n", + " # Impurity is on the first site\n", + " orbital_rotation[0, 0] = 1\n", + " orbital_rotation[1:, 1:] = vecs\n", + "\n", + " # Move the impurity to the center\n", + " new_index = n_bath // 2\n", + " perm = np.r_[1 : (new_index + 1), 0, (new_index + 1) : norb]\n", + " orbital_rotation = orbital_rotation[:, perm]\n", + "\n", + " return orbital_rotation\n", + "\n", + "\n", + "def rotated(\n", + " h1e: np.ndarray, h2e: np.ndarray, orbital_rotation: np.ndarray\n", + ") -> tuple[np.ndarray, np.ndarray]:\n", + " \"\"\"Rotate the orbital basis of a Hamiltonian.\"\"\"\n", + " h1e_rotated = orbital_rotation.T @ h1e @ orbital_rotation\n", + " h2e_rotated = np.einsum(\n", + " \"pqrs,pi,qj,rk,sl->ijkl\",\n", + " h2e,\n", + " orbital_rotation,\n", + " orbital_rotation,\n", + " orbital_rotation,\n", + " orbital_rotation,\n", + " optimize=True,\n", + " )\n", + " return h1e_rotated, h2e_rotated\n", + "\n", + "\n", + "# Total number of spatial orbitals, including the bath sites and the impurity\n", + "# This should be an even number\n", + "norb = 20\n", + "\n", + "# System is half-filled\n", + "nelec = (norb // 2, norb // 2)\n", + "# One orbital is the impurity, the rest are bath sites\n", + "n_bath = norb - 1\n", + "\n", + "# Hamiltonian parameters\n", + "hybridization = 1.0\n", + "hopping = 1.0\n", + "onsite = 10.0\n", + "chemical_potential = -0.5 * onsite\n", + "\n", + "# Generate Hamiltonian in position basis\n", + "h1e, h2e = siam_hamiltonian(\n", + " norb=norb,\n", + " hopping=hopping,\n", + " onsite=onsite,\n", + " hybridization=hybridization,\n", + " chemical_potential=chemical_potential,\n", + ")\n", + "\n", + "# Rotate to momentum basis\n", + "orbital_rotation = momentum_basis(norb)\n", + "h1e_momentum, h2e_momentum = rotated(h1e, h2e, orbital_rotation)\n", + "# In the momentum basis, the impurity is placed in the center\n", + "impurity_index = n_bath // 2" + ] + }, + { + "cell_type": "markdown", + "id": "69749eef-df77-42d3-9506-654f59089ee1", + "metadata": {}, + "source": [ + "Next, we generate the circuits to produce the Krylov basis states.\n", + "For each spin species, the initial state $\\ket{\\psi_0}$ is given by the superposition of all possible excitations of the three electrons closest to the Fermi level into the 4 closest empty modes starting from the state $|00\\cdots 0011 \\cdots 11\\rangle$, and realized by the application of 7 [XXPlusYYGate](https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.library.XXPlusYYGate)s.\n", + "The time-evolved states are produced by successive applications of a second-order Trotter step.\n", + "\n", + "For a more detailed description of this model and how the circuits are designed, please refer to [the paper](https://arxiv.org/abs/2501.09702)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b6597c5b-a691-4de6-ba5d-7791e0f66f89", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Sequence\n", + "\n", + "import ffsim\n", + "import scipy\n", + "from qiskit import QuantumCircuit, QuantumRegister\n", + "from qiskit.circuit import CircuitInstruction, Qubit\n", + "from qiskit.circuit.library import CPhaseGate, XGate, XXPlusYYGate\n", + "\n", + "\n", + "def prepare_initial_state(qubits: Sequence[Qubit], norb: int, nocc: int):\n", + " \"\"\"Prepare initial state.\"\"\"\n", + " x_gate = XGate()\n", + " rot = XXPlusYYGate(0.5 * np.pi, -0.5 * np.pi)\n", + " for i in range(nocc):\n", + " yield CircuitInstruction(x_gate, [qubits[i]])\n", + " yield CircuitInstruction(x_gate, [qubits[norb + i]])\n", + " for i in range(3):\n", + " for j in range(nocc - i - 1, nocc + i, 2):\n", + " yield CircuitInstruction(rot, [qubits[j], qubits[j + 1]])\n", + " yield CircuitInstruction(rot, [qubits[norb + j], qubits[norb + j + 1]])\n", + " yield CircuitInstruction(rot, [qubits[j + 1], qubits[j + 2]])\n", + " yield CircuitInstruction(rot, [qubits[norb + j + 1], qubits[norb + j + 2]])\n", + "\n", + "\n", + "def trotter_step(\n", + " qubits: Sequence[Qubit],\n", + " time_step: float,\n", + " one_body_evolution: np.ndarray,\n", + " h2e: np.ndarray,\n", + " impurity_index: int,\n", + " norb: int,\n", + "):\n", + " \"\"\"A Trotter step.\"\"\"\n", + " # Assume the two-body interaction is just the on-site interaction of the impurity\n", + " onsite = h2e[impurity_index, impurity_index, impurity_index, impurity_index]\n", + " # Two-body evolution for half the time\n", + " yield CircuitInstruction(\n", + " CPhaseGate(-0.5 * time_step * onsite),\n", + " [qubits[impurity_index], qubits[norb + impurity_index]],\n", + " )\n", + " # One-body evolution for the full time\n", + " yield CircuitInstruction(\n", + " ffsim.qiskit.OrbitalRotationJW(norb, one_body_evolution), qubits\n", + " )\n", + " # Two-body evolution for half the time\n", + " yield CircuitInstruction(\n", + " CPhaseGate(-0.5 * time_step * onsite),\n", + " [qubits[impurity_index], qubits[norb + impurity_index]],\n", + " )\n", + "\n", + "\n", + "# Time step\n", + "time_step = 0.2\n", + "# Number of Krylov basis states\n", + "krylov_dim = 8\n", + "\n", + "# Initialize circuit\n", + "qubits = QuantumRegister(2 * norb, name=\"q\")\n", + "circuit = QuantumCircuit(qubits)\n", + "\n", + "# Generate initial state\n", + "for instruction in prepare_initial_state(qubits, norb=norb, nocc=norb // 2):\n", + " circuit.append(instruction)\n", + "circuit.measure_all()\n", + "\n", + "# Create list of circuits, starting with the initial state circuit\n", + "circuits = [circuit.copy()]\n", + "\n", + "# Add time evolution circuits to the list\n", + "one_body_evolution = scipy.linalg.expm(-1j * time_step * h1e_momentum)\n", + "for i in range(krylov_dim - 1):\n", + " # Remove measurements\n", + " circuit.remove_final_measurements()\n", + " # Append another Trotter step\n", + " for instruction in trotter_step(\n", + " qubits, time_step, one_body_evolution, h2e_momentum, impurity_index, norb\n", + " ):\n", + " circuit.append(instruction)\n", + " # Measure qubits\n", + " circuit.measure_all()\n", + " # Add a copy of the circuit to the list\n", + " circuits.append(circuit.copy())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0bbe074b-3b4d-4032-8260-64580d7d1ddf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "circuits[0].draw(\"mpl\", scale=0.4, fold=-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6297de03-ad25-4327-b876-24b401f9cf96", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "circuits[-1].draw(\"mpl\", scale=0.4, fold=-1)" + ] + }, + { + "cell_type": "markdown", + "id": "804110ce-2b92-45b8-85d9-d68ddec072a0", + "metadata": {}, + "source": [ + "## Step 2: Optimize problem for quantum execution" + ] + }, + { + "cell_type": "markdown", + "id": "19c33102-7826-4ad8-842e-8318ed0d0966", + "metadata": {}, + "source": [ + "Now that we have created the circuits, we can optimize them for a target hardware. We pick the leasy busy QPU with at least 127 qubits. Check out the [Qiskit IBM Runtime docs](https://docs.quantum.ibm.com/guides/get-started-with-primitives#get-started-with-sampler) for more info." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3e91ccfe-fde5-497c-8254-f8e3a711bc86", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using backend ibm_aachen\n" + ] + } + ], + "source": [ + "from qiskit_ibm_runtime import QiskitRuntimeService\n", + "\n", + "service = QiskitRuntimeService(channel=\"ibm_quantum\")\n", + "# backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)\n", + "backend = service.least_busy(\n", + " operational=True,\n", + " simulator=False,\n", + " min_num_qubits=127,\n", + " filters=lambda x: x.configuration().processor_type[\"family\"] == \"Heron\",\n", + ")\n", + "print(f\"Using backend {backend.name}\")" + ] + }, + { + "cell_type": "markdown", + "id": "4c06752b-27d9-486f-8303-1410f8fa8089", + "metadata": {}, + "source": [ + "Now, we transpile the circuits to the target backend using Qiskit." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "34b19fa6-6f5f-40f9-99ed-202646e3e9d4", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.transpiler import generate_preset_pass_manager\n", + "\n", + "pass_manager = generate_preset_pass_manager(optimization_level=3, backend=backend)\n", + "isa_circuits = pass_manager.run(circuits)" + ] + }, + { + "cell_type": "markdown", + "id": "fe7df315-0340-492e-b6c3-52ab90408b4f", + "metadata": {}, + "source": [ + "## Step 3: Execute using Qiskit Primitives" + ] + }, + { + "cell_type": "markdown", + "id": "357779ad-3c37-4806-a07f-b2557eff331d", + "metadata": {}, + "source": [ + "After optimizing the circuits for hardware execution, we are ready to run them on the target hardware and collect samples for ground state energy estimation. After using the Sampler primtive to sample bitstrings from each circuit, we combine all of the results into a single counts dictionary and plot the top 20 most commonly sampled bitstrings." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9daafa8a-81d1-4788-856c-f917299bb17a", + "metadata": {}, + "outputs": [], + "source": [ + "from collections import Counter\n", + "\n", + "from qiskit.visualization import plot_histogram\n", + "from qiskit_ibm_runtime import SamplerV2 as Sampler\n", + "\n", + "# Sample from the circuits\n", + "noisy_sampler = Sampler(backend)\n", + "job = noisy_sampler.run(isa_circuits, shots=500)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "03853b6f-7f6d-45c3-be3d-da66616f91d7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Combine the counts from the individual Trotter circuits\n", + "counts = Counter(job.result()[0].data.meas.get_counts())\n", + "for i in range(1, len(job.result())):\n", + " counts += Counter(job.result()[i].data.meas.get_counts())\n", + "counts = dict(counts)\n", + "\n", + "plot_histogram(counts, number_to_keep=20)" + ] + }, + { + "cell_type": "markdown", + "id": "d986aebc-42a7-45d8-b1f4-890e58555608", + "metadata": {}, + "source": [ + "## Step 4: Post-process and return result to desired classical format" + ] + }, + { + "cell_type": "markdown", + "id": "5acca74a-4f57-4aee-89cc-142edb4e3bfe", + "metadata": {}, + "source": [ + "First, we will transform the counts into a bitstring matrix and probability array for post-processing.\n", + "\n", + "Each row in the matrix represents one unique bitstring. Since qubits are indexed from the right of a bitstring in Qiskit, column ``0`` represents qubit ``N-1``, and column ``N-1`` represents qubit ``0``, where ``N`` is the number of qubits.\n", + "\n", + "The spin-up sites are represented in the column index range ``(N, N/2]``, and the spin-down sites are represented in the column range ``(N/2, 0]``." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1d99d696-15ff-469f-bbab-8621ef3c21a2", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_addon_sqd.counts import counts_to_arrays\n", + "\n", + "# Convert counts into bitstring and probability arrays\n", + "bitstring_matrix_full, probs_arr_full = counts_to_arrays(counts)" + ] + }, + { + "cell_type": "markdown", + "id": "14b89b1e-3727-408a-a2be-532db9fb66f6", + "metadata": {}, + "source": [ + "Next, we iteratively refine the samples using configuration recovery and approximate the ground state at each iteration\n", + "\n", + "There are a few user-controlled options which are important for this technique:\n", + "\n", + "- ``iterations``: Number of self-consistent configuration recovery iterations\n", + "- ``n_batches``: Number of batches of configurations used by the different calls to the eigenstate solver\n", + "- ``samples_per_batch``: Number of unique configurations to include in each batch\n", + "- ``max_davidson_cycles``: Maximum number of Davidson cycles run by each eigensolver" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d304c375-3dc8-4af1-bbac-4e303f54682d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting configuration recovery iteration 0\n", + "Batch 0 subspace dimension: 47961\n", + "Batch 1 subspace dimension: 47961\n", + "Batch 2 subspace dimension: 48841\n", + "Starting configuration recovery iteration 1\n", + "Batch 0 subspace dimension: 106276\n", + "Batch 1 subspace dimension: 108900\n", + "Batch 2 subspace dimension: 111556\n", + "Starting configuration recovery iteration 2\n", + "Batch 0 subspace dimension: 114921\n", + "Batch 1 subspace dimension: 103041\n", + "Batch 2 subspace dimension: 104976\n", + "Starting configuration recovery iteration 3\n", + "Batch 0 subspace dimension: 110889\n", + "Batch 1 subspace dimension: 106276\n", + "Batch 2 subspace dimension: 104976\n", + "Starting configuration recovery iteration 4\n", + "Batch 0 subspace dimension: 116964\n", + "Batch 1 subspace dimension: 116281\n", + "Batch 2 subspace dimension: 95481\n" + ] + } + ], + "source": [ + "from qiskit_addon_sqd.configuration_recovery import recover_configurations\n", + "from qiskit_addon_sqd.fermion import (\n", + " bitstring_matrix_to_ci_strs,\n", + " solve_fermion,\n", + ")\n", + "from qiskit_addon_sqd.subsampling import postselect_and_subsample\n", + "\n", + "# Set a seed for reproducability\n", + "rng = np.random.default_rng(24)\n", + "\n", + "# SQD options\n", + "iterations = 5\n", + "\n", + "# Eigenstate solver options\n", + "n_batches = 3\n", + "samples_per_batch = 200\n", + "max_davidson_cycles = 200\n", + "\n", + "# Self-consistent configuration recovery loop\n", + "e_hist = np.zeros((iterations, n_batches)) # energy history\n", + "s_hist = np.zeros((iterations, n_batches)) # spin history\n", + "occupancy_hist = []\n", + "avg_occupancy = None\n", + "for i in range(iterations):\n", + " print(f\"Starting configuration recovery iteration {i}\")\n", + " # On the first iteration, we have no orbital occupancy information from the\n", + " # solver, so we begin with the full set of noisy configurations.\n", + " if avg_occupancy is None:\n", + " bs_mat_tmp = bitstring_matrix_full\n", + " probs_arr_tmp = probs_arr_full\n", + "\n", + " # If we have average orbital occupancy information, we use it to refine the full set of noisy configurations\n", + " else:\n", + " bs_mat_tmp, probs_arr_tmp = recover_configurations(\n", + " bitstring_matrix_full,\n", + " probs_arr_full,\n", + " avg_occupancy,\n", + " nelec[0],\n", + " nelec[1],\n", + " rand_seed=rng,\n", + " )\n", + "\n", + " # Create batches of subsamples. We post-select here to remove configurations\n", + " # with incorrect hamming weight during iteration 0, since no config recovery was performed.\n", + " batches = postselect_and_subsample(\n", + " bs_mat_tmp,\n", + " probs_arr_tmp,\n", + " hamming_right=nelec[0],\n", + " hamming_left=nelec[1],\n", + " samples_per_batch=samples_per_batch,\n", + " num_batches=n_batches,\n", + " rand_seed=rng,\n", + " )\n", + "\n", + " # Run eigenstate solvers in a loop. This loop should be parallelized for larger problems.\n", + " e_tmp = np.zeros(n_batches)\n", + " s_tmp = np.zeros(n_batches)\n", + " occs_tmp = []\n", + " coeffs = []\n", + " for j in range(n_batches):\n", + " strs_a, strs_b = bitstring_matrix_to_ci_strs(batches[j])\n", + " print(f\"Batch {j} subspace dimension: {len(strs_a) * len(strs_b)}\")\n", + " energy_sci, coeffs_sci, avg_occs, spin = solve_fermion(\n", + " batches[j],\n", + " h1e_momentum,\n", + " h2e_momentum,\n", + " max_davidson=max_davidson_cycles,\n", + " )\n", + " e_tmp[j] = energy_sci\n", + " s_tmp[j] = spin\n", + " occs_tmp.append(avg_occs)\n", + " coeffs.append(coeffs_sci)\n", + "\n", + " # Combine batch results\n", + " avg_occupancy = np.mean(occs_tmp, axis=0)\n", + "\n", + " # Track optimization history\n", + " e_hist[i, :] = e_tmp\n", + " s_hist[i, :] = s_tmp\n", + " occupancy_hist.append(avg_occupancy)" + ] + }, + { + "cell_type": "markdown", + "id": "68292a3b-19ac-4cdd-a7cc-675eb2c462b9", + "metadata": {}, + "source": [ + "The following code cell plots the results. The first plot shows the computed energy as a function of the number of configuration recovery iterations, and the second plot shows the average occupancy of each spatial orbital after the final iteration. For the reference energy, we use the results of a [DMRG](https://en.wikipedia.org/wiki/Density_matrix_renormalization_group) calculation that was performed separately." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a2a78556-2a67-4861-a3a1-d7cd76e1e65b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reference (DMRG) energy: -28.70660\n", + "SQD energy: -28.69066\n", + "Absolute error: 0.01594\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "dmrg_energy = -28.70659686\n", + "\n", + "min_es = [np.min(e) for e in e_hist]\n", + "min_id, min_e = min(enumerate(min_es), key=lambda x: x[1])\n", + "\n", + "# Data for energies plot\n", + "x1 = range(iterations)\n", + "\n", + "# Data for avg spatial orbital occupancy\n", + "avg_occupancy = occupancy_hist[min_id]\n", + "y2 = avg_occupancy[0] + avg_occupancy[1]\n", + "x2 = range(len(y2))\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(12, 6))\n", + "\n", + "# Plot energies\n", + "axs[0].plot(x1, min_es, label=\"energy\", marker=\"o\")\n", + "axs[0].set_xticks(x1)\n", + "axs[0].set_xticklabels(x1)\n", + "axs[0].axhline(y=dmrg_energy, color=\"#BF5700\", linestyle=\"--\", label=\"DMRG energy\")\n", + "axs[0].set_title(\"Approximated Ground State Energy vs SQD Iterations\")\n", + "axs[0].set_xlabel(\"Iteration Index\", fontdict={\"fontsize\": 12})\n", + "axs[0].set_ylabel(\"Energy\", fontdict={\"fontsize\": 12})\n", + "axs[0].legend()\n", + "\n", + "# Plot orbital occupancy\n", + "axs[1].bar(x2, y2, width=0.8)\n", + "axs[1].set_xticks(x2)\n", + "axs[1].set_xticklabels(x2)\n", + "axs[1].set_title(\"Avg Occupancy per Spatial Orbital\")\n", + "axs[1].set_xlabel(\"Orbital Index\", fontdict={\"fontsize\": 12})\n", + "axs[1].set_ylabel(\"Avg Occupancy\", fontdict={\"fontsize\": 12})\n", + "\n", + "print(f\"Reference (DMRG) energy: {dmrg_energy:.5f}\")\n", + "print(f\"SQD energy: {min_e:.5f}\")\n", + "print(f\"Absolute error: {abs(min_e - dmrg_energy):.5f}\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "description": "Use the sample-based quantum diagonalization algorithm to simulate the single-impurity Anderson model using noisy quantum hardware.", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3" + }, + "title": "Improving energy estimation of a fermionic lattice model with SQD" + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 76236b83a1ecea49fda94d653fddf6e87e3ebd11 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Wed, 16 Apr 2025 12:15:40 -0400 Subject: [PATCH 2/8] spelling and comment --- ...f-a-fermionic-lattice-model-with-sqd.ipynb | 22 ++++++++----------- 1 file changed, 9 insertions(+), 13 deletions(-) diff --git a/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb b/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb index 235a0bea27c..9bb4f5f6efb 100644 --- a/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb +++ b/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb @@ -5,6 +5,8 @@ "id": "f5789cd6-7bbb-4413-b238-877f88d5bda6", "metadata": {}, "source": [ + "{/* cspell:ignore textrm varepsilon vecs pqrs ijkl */}\n", + "\n", "# Improving energy estimation of a fermionic lattice model with SQD\n", "\n", "*Usage estimate: 9 seconds on IBM Aachen (NOTE: This is an estimate only. Your runtime may vary.)*" @@ -91,7 +93,7 @@ "id": "ee397740-5202-44bb-ba4c-ea8bf38f23a7", "metadata": {}, "source": [ - "First, we generate the SIAM Hamiltonian in the position basis. The Hamiltonian is represented by the matrix $h_{pq}$ and the tensor $h_{pqrs}$. Then, we rotate it to the momentum basis. In the position basis, we place the impurity at the first site. However, when we rotate to the momentum basis, we move the impurity to a central site to faciliate interactions with other orbitals." + "First, we generate the SIAM Hamiltonian in the position basis. The Hamiltonian is represented by the matrix $h_{pq}$ and the tensor $h_{pqrs}$. Then, we rotate it to the momentum basis. In the position basis, we place the impurity at the first site. However, when we rotate to the momentum basis, we move the impurity to a central site to facilitate interactions with other orbitals." ] }, { @@ -362,12 +364,12 @@ "id": "19c33102-7826-4ad8-842e-8318ed0d0966", "metadata": {}, "source": [ - "Now that we have created the circuits, we can optimize them for a target hardware. We pick the leasy busy QPU with at least 127 qubits. Check out the [Qiskit IBM Runtime docs](https://docs.quantum.ibm.com/guides/get-started-with-primitives#get-started-with-sampler) for more info." + "Now that we have created the circuits, we can optimize them for a target hardware. We pick the least busy QPU with at least 127 qubits. Check out the [Qiskit IBM Runtime docs](https://docs.quantum.ibm.com/guides/get-started-with-primitives#get-started-with-sampler) for more info." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "3e91ccfe-fde5-497c-8254-f8e3a711bc86", "metadata": {}, "outputs": [ @@ -383,13 +385,7 @@ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService(channel=\"ibm_quantum\")\n", - "# backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)\n", - "backend = service.least_busy(\n", - " operational=True,\n", - " simulator=False,\n", - " min_num_qubits=127,\n", - " filters=lambda x: x.configuration().processor_type[\"family\"] == \"Heron\",\n", - ")\n", + "backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)\n", "print(f\"Using backend {backend.name}\")" ] }, @@ -427,7 +423,7 @@ "id": "357779ad-3c37-4806-a07f-b2557eff331d", "metadata": {}, "source": [ - "After optimizing the circuits for hardware execution, we are ready to run them on the target hardware and collect samples for ground state energy estimation. After using the Sampler primtive to sample bitstrings from each circuit, we combine all of the results into a single counts dictionary and plot the top 20 most commonly sampled bitstrings." + "After optimizing the circuits for hardware execution, we are ready to run them on the target hardware and collect samples for ground state energy estimation. After using the Sampler primitive to sample bitstrings from each circuit, we combine all of the results into a single counts dictionary and plot the top 20 most commonly sampled bitstrings." ] }, { @@ -525,7 +521,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "d304c375-3dc8-4af1-bbac-4e303f54682d", "metadata": {}, "outputs": [ @@ -564,7 +560,7 @@ ")\n", "from qiskit_addon_sqd.subsampling import postselect_and_subsample\n", "\n", - "# Set a seed for reproducability\n", + "# Set a seed for reproducibility\n", "rng = np.random.default_rng(24)\n", "\n", "# SQD options\n", From e4649dadff8ae1ba8ae714bfe3249fa957f236a1 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Wed, 16 Apr 2025 12:21:33 -0400 Subject: [PATCH 3/8] add owner --- qiskit_bot.yaml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/qiskit_bot.yaml b/qiskit_bot.yaml index 2bb1bb24b14..66c0cf5486f 100644 --- a/qiskit_bot.yaml +++ b/qiskit_bot.yaml @@ -558,6 +558,8 @@ notifications: - "@miamico" "docs/tutorials/improving-energy-estimation-of-a-fermionic-hamiltonian-with-sqd": - "@miamico" + "docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd": + - "@miamico" "docs/tutorials/krylov-subspace-expansion": - "@miamico" "docs/tutorials/compute-dissociation-curves-for-strong-coupling-systems-with-quna-sys-qsci": From 3a04517b004f99d03444f7e14154a8ce9ea62812 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Wed, 16 Apr 2025 14:53:51 -0400 Subject: [PATCH 4/8] ruff --- ...f-a-fermionic-lattice-model-with-sqd.ipynb | 31 ++++++++++++++----- 1 file changed, 24 insertions(+), 7 deletions(-) diff --git a/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb b/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb index 9bb4f5f6efb..64014c90592 100644 --- a/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb +++ b/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb @@ -242,9 +242,13 @@ " for i in range(3):\n", " for j in range(nocc - i - 1, nocc + i, 2):\n", " yield CircuitInstruction(rot, [qubits[j], qubits[j + 1]])\n", - " yield CircuitInstruction(rot, [qubits[norb + j], qubits[norb + j + 1]])\n", + " yield CircuitInstruction(\n", + " rot, [qubits[norb + j], qubits[norb + j + 1]]\n", + " )\n", " yield CircuitInstruction(rot, [qubits[j + 1], qubits[j + 2]])\n", - " yield CircuitInstruction(rot, [qubits[norb + j + 1], qubits[norb + j + 2]])\n", + " yield CircuitInstruction(\n", + " rot, [qubits[norb + j + 1], qubits[norb + j + 2]]\n", + " )\n", "\n", "\n", "def trotter_step(\n", @@ -257,7 +261,9 @@ "):\n", " \"\"\"A Trotter step.\"\"\"\n", " # Assume the two-body interaction is just the on-site interaction of the impurity\n", - " onsite = h2e[impurity_index, impurity_index, impurity_index, impurity_index]\n", + " onsite = h2e[\n", + " impurity_index, impurity_index, impurity_index, impurity_index\n", + " ]\n", " # Two-body evolution for half the time\n", " yield CircuitInstruction(\n", " CPhaseGate(-0.5 * time_step * onsite),\n", @@ -298,7 +304,12 @@ " circuit.remove_final_measurements()\n", " # Append another Trotter step\n", " for instruction in trotter_step(\n", - " qubits, time_step, one_body_evolution, h2e_momentum, impurity_index, norb\n", + " qubits,\n", + " time_step,\n", + " one_body_evolution,\n", + " h2e_momentum,\n", + " impurity_index,\n", + " norb,\n", " ):\n", " circuit.append(instruction)\n", " # Measure qubits\n", @@ -385,7 +396,9 @@ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService(channel=\"ibm_quantum\")\n", - "backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)\n", + "backend = service.least_busy(\n", + " operational=True, simulator=False, min_num_qubits=127\n", + ")\n", "print(f\"Using backend {backend.name}\")" ] }, @@ -406,7 +419,9 @@ "source": [ "from qiskit.transpiler import generate_preset_pass_manager\n", "\n", - "pass_manager = generate_preset_pass_manager(optimization_level=3, backend=backend)\n", + "pass_manager = generate_preset_pass_manager(\n", + " optimization_level=3, backend=backend\n", + ")\n", "isa_circuits = pass_manager.run(circuits)" ] }, @@ -691,7 +706,9 @@ "axs[0].plot(x1, min_es, label=\"energy\", marker=\"o\")\n", "axs[0].set_xticks(x1)\n", "axs[0].set_xticklabels(x1)\n", - "axs[0].axhline(y=dmrg_energy, color=\"#BF5700\", linestyle=\"--\", label=\"DMRG energy\")\n", + "axs[0].axhline(\n", + " y=dmrg_energy, color=\"#BF5700\", linestyle=\"--\", label=\"DMRG energy\"\n", + ")\n", "axs[0].set_title(\"Approximated Ground State Energy vs SQD Iterations\")\n", "axs[0].set_xlabel(\"Iteration Index\", fontdict={\"fontsize\": 12})\n", "axs[0].set_ylabel(\"Energy\", fontdict={\"fontsize\": 12})\n", From 325aade9750fd78940b208d2cfc80cc169c3aee4 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Wed, 16 Apr 2025 14:55:18 -0400 Subject: [PATCH 5/8] add to notebook-testing.toml --- scripts/config/notebook-testing.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/config/notebook-testing.toml b/scripts/config/notebook-testing.toml index 2c5d3d9211a..a078067c3c9 100644 --- a/scripts/config/notebook-testing.toml +++ b/scripts/config/notebook-testing.toml @@ -159,6 +159,7 @@ notebooks = [ "docs/tutorials/real-time-benchmarking-for-qubit-selection.ipynb", "docs/tutorials/scaling-periodic-boundary-problems-with-circuit-cutting.ipynb", "docs/tutorials/improving-energy-estimation-of-a-fermionic-hamiltonian-with-sqd.ipynb", + "docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb", "docs/tutorials/krylov-subspace-expansion.ipynb", "docs/tutorials/compute-dissociation-curves-for-strong-coupling-systems-with-quna-sys-qsci.ipynb", "docs/tutorials/solve-higher-order-binary-optimization-problems-with-q-ctrls-optimization-solver.ipynb", From c11c604641be63acfc676fb384917422a83ecb2e Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Wed, 16 Apr 2025 14:58:41 -0400 Subject: [PATCH 6/8] add kevinsung as reviewers to sqd notebooks --- qiskit_bot.yaml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/qiskit_bot.yaml b/qiskit_bot.yaml index 66c0cf5486f..b7f103a1ffa 100644 --- a/qiskit_bot.yaml +++ b/qiskit_bot.yaml @@ -558,8 +558,10 @@ notifications: - "@miamico" "docs/tutorials/improving-energy-estimation-of-a-fermionic-hamiltonian-with-sqd": - "@miamico" + - "`@kevinsung`" "docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd": - "@miamico" + - "`@kevinsung`" "docs/tutorials/krylov-subspace-expansion": - "@miamico" "docs/tutorials/compute-dissociation-curves-for-strong-coupling-systems-with-quna-sys-qsci": From 3240a127899c971e13ffc773329d5cea89802bc0 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Wed, 16 Apr 2025 15:03:55 -0400 Subject: [PATCH 7/8] spelling --- ...nergy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb b/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb index 64014c90592..03660505bff 100644 --- a/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb +++ b/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb @@ -5,7 +5,7 @@ "id": "f5789cd6-7bbb-4413-b238-877f88d5bda6", "metadata": {}, "source": [ - "{/* cspell:ignore textrm varepsilon vecs pqrs ijkl */}\n", + "{/* cspell:ignore DMRG textrm varepsilon vecs pqrs ijkl */}\n", "\n", "# Improving energy estimation of a fermionic lattice model with SQD\n", "\n", From 931468f7585ef7b5f535472127501cd620632004 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Fri, 18 Apr 2025 16:03:17 -0400 Subject: [PATCH 8/8] change orbital rotation convention to match ffsim --- ...f-a-fermionic-lattice-model-with-sqd.ipynb | 20 ++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb b/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb index 03660505bff..2b0bd3435e9 100644 --- a/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb +++ b/docs/tutorials/improving-energy-estimation-of-a-fermionic-lattice-model-with-sqd.ipynb @@ -98,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "86229d6d-7d24-4e0f-ac56-6b7238aa9db9", "metadata": {}, "outputs": [], @@ -160,15 +160,21 @@ " h1e: np.ndarray, h2e: np.ndarray, orbital_rotation: np.ndarray\n", ") -> tuple[np.ndarray, np.ndarray]:\n", " \"\"\"Rotate the orbital basis of a Hamiltonian.\"\"\"\n", - " h1e_rotated = orbital_rotation.T @ h1e @ orbital_rotation\n", + " h1e_rotated = np.einsum(\n", + " \"ab,Aa,Bb->AB\",\n", + " h1e,\n", + " orbital_rotation,\n", + " orbital_rotation.conj(),\n", + " optimize=\"greedy\",\n", + " )\n", " h2e_rotated = np.einsum(\n", - " \"pqrs,pi,qj,rk,sl->ijkl\",\n", + " \"abcd,Aa,Bb,Cc,Dd->ABCD\",\n", " h2e,\n", " orbital_rotation,\n", + " orbital_rotation.conj(),\n", " orbital_rotation,\n", - " orbital_rotation,\n", - " orbital_rotation,\n", - " optimize=True,\n", + " orbital_rotation.conj(),\n", + " optimize=\"greedy\",\n", " )\n", " return h1e_rotated, h2e_rotated\n", "\n", @@ -199,7 +205,7 @@ "\n", "# Rotate to momentum basis\n", "orbital_rotation = momentum_basis(norb)\n", - "h1e_momentum, h2e_momentum = rotated(h1e, h2e, orbital_rotation)\n", + "h1e_momentum, h2e_momentum = rotated(h1e, h2e, orbital_rotation.T.conj())\n", "# In the momentum basis, the impurity is placed in the center\n", "impurity_index = n_bath // 2" ]