docs/tutorials/01_chemistry_hamiltonian.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9e40af77-7f0f-4dd6-ab0a-420cf396050e",
   "metadata": {},
   "source": [
    "# Improving energy estimation of a chemistry Hamiltonian with SQD\n",
    "\n",
    "In this tutorial we implement a [Qiskit pattern](https://docs.quantum.ibm.com/guides/intro-to-patterns) showing how to post-process noisy quantum samples to find an approximation to the ground state of a chemistry Hamiltonian: the $N_2$ molecule at equilibrium in the 6-31G basis set. We will follow a [sample-based quantum diagonalization approach](https://arxiv.org/abs/2405.05068) to process samples taken from a ``36``-qubit quantum circuit ansatz (in this case, an LUCJ circuit). In order to account for the effect of quantum noise, the configuration recovery technique is used.\n",
    "\n",
    "The pattern can be described in four steps:\n",
    "\n",
    "1. **Step 1: Map to quantum problem**\n",
    "    - Generate an ansatz for estimating the ground state\n",
    "2. **Step 2: Optimize the problem**\n",
    "    - Transpile the ansatz for the backend\n",
    "3. **Step 3: Execute experiments**\n",
    "    - Draw samples from the ansatz using the ``Sampler`` primitive\n",
    "4. **Step 4: Post-process results**\n",
    "   - Self-consistent configuration recovery loop\n",
    "       - Post-process the full set of bitstring samples, using prior knowledge of particle number and the average orbital occupancy calculated on the most recent iteration.\n",
    "       - Probabilistically create batches of subsamples from recovered bitstrings.\n",
    "       - Project and diagonalize the molecular Hamiltonian over each sampled subspace.\n",
    "       - Save the minimum ground state energy found across all batches and update the avg orbital occupancy.\n",
    "\n",
    "\n",
    "For this example, the interacting-electron Hamiltonian takes the generic form:\n",
    "\n",
    "$$\n",
    "\\hat{H} = \\sum_{ \\substack{pr\\\\\\sigma} } h_{pr} \\, \\hat{a}^\\dagger_{p\\sigma} \\hat{a}_{r\\sigma}\n",
    "+ \n",
    "\\sum_{ \\substack{prqs\\\\\\sigma\\tau} }\n",
    "\\frac{(pr|qs)}{2} \\, \n",
    "\\hat{a}^\\dagger_{p\\sigma}\n",
    "\\hat{a}^\\dagger_{q\\tau}\n",
    "\\hat{a}_{s\\tau}\n",
    "\\hat{a}_{r\\sigma}\n",
    "$$\n",
    "\n",
    "$\\hat{a}^\\dagger_{p\\sigma}$/$\\hat{a}_{p\\sigma}$ are the fermionic creation/annihalation operators associated to the $p$-th basis set element and the spin $\\sigma$. $h_{pr}$ and $(pr|qs)$ are the one- and two-body electronic integrals.\n",
    "\n",
    "The SQD workflow with  self-consistent configuration recovery is depicted in the following diagram.\n",
    "\n",
    "![SQD diagram](../_static/images/sqd_diagram.png)\n",
    "\n",
    "SQD is known to work well when the target eigenstate is sparse: the wave function is supported in a set of basis states $\\mathcal{S} = \\{|x\\rangle \\}$ whose size does not increase exponentially with the size of the problem. In this scenario, the diagonalization of the Hamiltonian projected into the subspace defined by $\\mathcal{S}$:\n",
    "$$\n",
    "H_\\mathcal{S} = P_\\mathcal{S} H  P_\\mathcal{S} \\textrm{ with } P_\\mathcal{S} = \\sum_{x \\in \\mathcal{S}} |x \\rangle \\langle x |;\n",
    "$$\n",
    "yields a good approximation to the target eigenstate. The role of the quantum device is to produce samples of the members of $\\mathcal{S}$ only. First, a quantum circuit prepares the state $|\\Psi\\rangle$ in the quantum device. The Jordan-Wigner encoding is used. Consequently, members of the computational basis represent Fock states (electronic configurations/determinants). The circuit is sampled in the computational basis, yielding the set of noisy configurations $\\tilde{\\mathcal{X}}$. The configurations are represented by bitstrings. The set $\\tilde{\\mathcal{X}}$ is then passed into the classical post-processing block, where the [self-consistent configuration recovery technique](https://arxiv.org/abs/2405.05068) is used. In the SQD framework, the role of the quantum device is to produce a probability distribution."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afeb054c",
   "metadata": {},
   "source": [
    "### Step 1: Map problem to a quantum circuit\n",
    "\n",
    "In this tutorial, we will approximate the ground state energy of an $N_2$ molecule. First, we will specify the molecule and its properties. Next, we will create a [local unitary cluster Jastrow (LUCJ)](https://pubs.rsc.org/en/content/articlelanding/2023/sc/d3sc02516k) ansatz (quantum circuit) to generate samples from a quantum computer for ground state energy estimation.\n",
    "\n",
    "First, we will specify the molecule and its properties."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "677f54ac-b4ed-47e3-b5ba-5366d3a520f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "converged SCF energy = -108.835236570775\n",
      "CASCI E = -109.046671778080  E(CI) = -32.8155692383188  S^2 = 0.0000000\n"
     ]
    }
   ],
   "source": [
    "import warnings\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import pyscf\n",
    "import pyscf.cc\n",
    "import pyscf.mcscf\n",
    "\n",
    "# Specify molecule properties\n",
    "open_shell = False\n",
    "spin_sq = 0\n",
    "\n",
    "# Build N2 molecule\n",
    "mol = pyscf.gto.Mole()\n",
    "mol.build(\n",
    "    atom=[[\"N\", (0, 0, 0)], [\"N\", (1.0, 0, 0)]],\n",
    "    basis=\"6-31g\",\n",
    "    symmetry=\"Dooh\",\n",
    ")\n",
    "\n",
    "# Define active space\n",
    "n_frozen = 2\n",
    "active_space = range(n_frozen, mol.nao_nr())\n",
    "\n",
    "# Get molecular integrals\n",
    "scf = pyscf.scf.RHF(mol).run()\n",
    "num_orbitals = len(active_space)\n",
    "n_electrons = int(sum(scf.mo_occ[active_space]))\n",
    "num_elec_a = (n_electrons + mol.spin) // 2\n",
    "num_elec_b = (n_electrons - mol.spin) // 2\n",
    "cas = pyscf.mcscf.CASCI(scf, num_orbitals, (num_elec_a, num_elec_b))\n",
    "mo = cas.sort_mo(active_space, base=0)\n",
    "hcore, nuclear_repulsion_energy = cas.get_h1cas(mo)\n",
    "eri = pyscf.ao2mo.restore(1, cas.get_h2cas(mo), num_orbitals)\n",
    "\n",
    "# Compute exact energy\n",
    "exact_energy = cas.run().e_tot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96bfe018",
   "metadata": {},
   "source": [
    "Next, we will create the ansatz. The ``LUCJ`` ansatz is a parameterized quantum circuit, and we will initialize it with `t2` and `t1` amplitudes obtained from a CCSD calculation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "66270387",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "E(CCSD) = -109.0398256929734  E_corr = -0.2045891221988317\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<class 'pyscf.cc.ccsd.CCSD'> does not have attributes  converged\n"
     ]
    }
   ],
   "source": [
    "# Get CCSD t2 amplitudes for initializing the ansatz\n",
    "ccsd = pyscf.cc.CCSD(scf, frozen=[i for i in range(mol.nao_nr()) if i not in active_space]).run()\n",
    "t1 = ccsd.t1\n",
    "t2 = ccsd.t2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f4d882fa",
   "metadata": {},
   "source": [
    "We will use the [ffsim](https://github.com/qiskit-community/ffsim/tree/main) package to create and initialize the ansatz with `t2` and `t1` amplitudes computed above. Since our molecule has a closed-shell Hartree-Fock state, we will use the spin-balanced variant of the UCJ ansatz, [UCJOpSpinBalanced](https://qiskit-community.github.io/ffsim/api/ffsim.html#ffsim.UCJOpSpinBalanced).\n",
    "\n",
    "As our target IBM hardware has a heavy-hex topology, we will adopt the [_zig-zag_ pattern for qubit interactions](https://pubs.rsc.org/en/content/articlehtml/2023/sc/d3sc02516k). In this pattern, orbitals (represented by qubits) with the same spin are connected with a line topology (red and blue circles) where each line take a zig-zag shape due the heavy-hex connectivity of the target hardware. Again, due to the heavy-hex topology, orbitals for different spins have connections between every 4th orbital (0, 4, 8, etc.) (purple circles).\n",
    "\n",
    "![lucj_ansatz](../_static/images/lucj_ansatz_zig_zag_pattern.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "dd69a86c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import ffsim\n",
    "from qiskit import QuantumCircuit, QuantumRegister\n",
    "\n",
    "n_reps = 1\n",
    "alpha_alpha_indices = [(p, p + 1) for p in range(num_orbitals - 1)]\n",
    "alpha_beta_indices = [(p, p) for p in range(0, num_orbitals, 4)]\n",
    "\n",
    "ucj_op = ffsim.UCJOpSpinBalanced.from_t_amplitudes(\n",
    "    t2=t2,\n",
    "    t1=t1,\n",
    "    n_reps=n_reps,\n",
    "    interaction_pairs=(alpha_alpha_indices, alpha_beta_indices),\n",
    ")\n",
    "\n",
    "nelec = (num_elec_a, num_elec_b)\n",
    "\n",
    "# create an empty quantum circuit\n",
    "qubits = QuantumRegister(2 * num_orbitals, name=\"q\")\n",
    "circuit = QuantumCircuit(qubits)\n",
    "\n",
    "# prepare Hartree-Fock state as the reference state and append it to the quantum circuit\n",
    "circuit.append(ffsim.qiskit.PrepareHartreeFockJW(num_orbitals, nelec), qubits)\n",
    "\n",
    "# apply the UCJ operator to the reference state\n",
    "circuit.append(ffsim.qiskit.UCJOpSpinBalancedJW(ucj_op), qubits)\n",
    "circuit.measure_all()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db11bf6d",
   "metadata": {},
   "source": [
    "### Step 2: Optimize the problem"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0760b3f3",
   "metadata": {},
   "source": [
    "Next, we will optimize our circuit for a target hardware. We need to choose the hardware device to use before optimizing our circuit. We will use a fake 127-qubit backend from ``qiskit_ibm_runtime`` to emulate a real device. To run on a real QPU, just replace the fake backend with a real backend. 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": 4,
   "id": "53a039d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_ibm_runtime.fake_provider import FakeSherbrooke\n",
    "\n",
    "backend = FakeSherbrooke()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "057ebbf6",
   "metadata": {},
   "source": [
    "Next, we recommend the following steps to optimize the ansatz and make it hardware-compatible.\n",
    "\n",
    "- Select physical qubits (`initial_layout`) from the target hardware that adheres to the zig-zag pattern described above. Laying out qubits in this pattern leads to an efficient hardware-compatible circuit with fewer gates.\n",
    "- Generate a staged pass manager using the [generate_preset_pass_manager](https://docs.quantum.ibm.com/api/qiskit/transpiler_preset#generate_preset_pass_manager) function from Qiskit with your choice of `backend` and `initial_layout`.\n",
    "- Set the `pre_init` stage of your staged pass manager to `ffsim.qiskit.PRE_INIT`. `ffsim.qiskit.PRE_INIT` includes Qiskit transpiler passes that decompose gates into orbital rotations and then merges the orbital rotations, resulting in fewer gates in the final circuit.\n",
    "- Run the pass manager on your circuit. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7d554aa5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gate counts (w/o pre-init passes): OrderedDict({'rz': 4473, 'sx': 3427, 'ecr': 1366, 'x': 203, 'measure': 32, 'barrier': 1})\n",
      "Gate counts (w/ pre-init passes): OrderedDict({'rz': 2467, 'sx': 2147, 'ecr': 730, 'x': 57, 'measure': 32, 'barrier': 1})\n"
     ]
    }
   ],
   "source": [
    "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
    "\n",
    "spin_a_layout = [0, 14, 18, 19, 20, 33, 39, 40, 41, 53, 60, 61, 62, 72, 81, 82]\n",
    "spin_b_layout = [2, 3, 4, 15, 22, 23, 24, 34, 43, 44, 45, 54, 64, 65, 66, 73]\n",
    "initial_layout = spin_a_layout + spin_b_layout\n",
    "\n",
    "pass_manager = generate_preset_pass_manager(\n",
    "    optimization_level=3, backend=backend, initial_layout=initial_layout\n",
    ")\n",
    "\n",
    "# without PRE_INIT passes\n",
    "isa_circuit = pass_manager.run(circuit)\n",
    "print(f\"Gate counts (w/o pre-init passes): {isa_circuit.count_ops()}\")\n",
    "\n",
    "# with PRE_INIT passes\n",
    "# We will use the circuit generated by this pass manager for hardware execution\n",
    "pass_manager.pre_init = ffsim.qiskit.PRE_INIT\n",
    "isa_circuit = pass_manager.run(circuit)\n",
    "print(f\"Gate counts (w/ pre-init passes): {isa_circuit.count_ops()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cc1edef",
   "metadata": {},
   "source": [
    "### Step 3: Execute experiments"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbf7ef9f",
   "metadata": {},
   "source": [
    "After optimizing the circuit for hardware execution, we are ready to run it on the target hardware and collect samples for ground state energy estimation. As we only have one circuit, we will use Qiskit Runtime's [Job execution mode](https://docs.quantum.ibm.com/guides/execution-modes) and execute our circuit.\n",
    "\n",
    "***Note: We have commented out the code for running the circuit on a QPU and left it for the user's reference. Instead of running on real hardware in this guide, we will just generate random samples drawn from the uniform distribution.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3da09100",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from qiskit_addon_sqd.counts import generate_counts_uniform\n",
    "\n",
    "# from qiskit_ibm_runtime import SamplerV2 as Sampler\n",
    "\n",
    "# sampler = Sampler(mode=backend)\n",
    "# job = sampler.run([isa_circuit], shots=10_000)\n",
    "# primitive_result = job.result()\n",
    "# pub_result = primitive_result[0]\n",
    "# counts = pub_result.data.meas.get_counts()\n",
    "\n",
    "rng = np.random.default_rng(24)\n",
    "counts = generate_counts_uniform(10_000, num_orbitals * 2, rand_seed=rng)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6df05b6e",
   "metadata": {},
   "source": [
    "### Step 4: Post-process results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "851bc98e-9c08-4e78-9472-36301abc11d8",
   "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 alpha particles are represented in the column index range ``(N, N/2]``, and the beta particles are represented in the column range ``(N/2, 0]``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7a102a7f-aae6-4583-ab82-ae40fcb5496a",
   "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": "eb704101-0fe8-4d12-b572-b1d844e35a90",
   "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": 8,
   "id": "b72c048e-fe8e-4fc2-b28b-03138249074e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting configuration recovery iteration 0\n",
      "Batch 0 subspace dimension: 6400\n",
      "Starting configuration recovery iteration 1\n",
      "Batch 0 subspace dimension: 555025\n",
      "Starting configuration recovery iteration 2\n",
      "Batch 0 subspace dimension: 577600\n",
      "Starting configuration recovery iteration 3\n",
      "Batch 0 subspace dimension: 556516\n",
      "Starting configuration recovery iteration 4\n",
      "Batch 0 subspace dimension: 556516\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",
    "# SQD options\n",
    "iterations = 5\n",
    "\n",
    "# Eigenstate solver options\n",
    "n_batches = 1\n",
    "samples_per_batch = 500\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",
    "            num_elec_a,\n",
    "            num_elec_b,\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=num_elec_a,\n",
    "        hamming_left=num_elec_b,\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",
    "            hcore,\n",
    "            eri,\n",
    "            open_shell=open_shell,\n",
    "            spin_sq=spin_sq,\n",
    "            max_davidson=max_davidson_cycles,\n",
    "        )\n",
    "        energy_sci += nuclear_repulsion_energy\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 = tuple(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": "9d78906b-4759-4506-9c69-85d4e67766b3",
   "metadata": {},
   "source": [
    "The first plot shows that after a few iterations we estimate the ground state energy within ``~31 mH`` (chemical accuracy is typically accepted to be ``1 kcal/mol`` $\\approx$ ``1.6 mH``). Remember, the quantum samples in this demo were pure noise. The signal here comes from *a priori* knowledge of the electronic structure and molecular Hamiltonian.\n",
    "\n",
    "The second plot shows the average occupancy of each spatial orbital after the final iteration. We can see that both the spin-up and spin-down electrons occupy the first five orbitals with high probability in our solutions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "caffd888-e89c-4aa9-8bae-4d1bb723b35e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exact energy: -109.04667 Ha\n",
      "SQD energy: -109.01736 Ha\n",
      "Absolute error: 0.02931 Ha\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Data for energies plot\n",
    "x1 = range(iterations)\n",
    "min_e = [np.min(e) for e in e_hist]\n",
    "e_diff = [abs(e - exact_energy) for e in min_e]\n",
    "yt1 = [1.0, 1e-1, 1e-2, 1e-3, 1e-4]\n",
    "\n",
    "# Chemical accuracy (+/- 1 milli-Hartree)\n",
    "chem_accuracy = 0.001\n",
    "\n",
    "# Data for avg spatial orbital occupancy\n",
    "y2 = occupancy_hist[-1][0] + occupancy_hist[-1][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, e_diff, label=\"energy error\", marker=\"o\")\n",
    "axs[0].set_xticks(x1)\n",
    "axs[0].set_xticklabels(x1)\n",
    "axs[0].set_yticks(yt1)\n",
    "axs[0].set_yticklabels(yt1)\n",
    "axs[0].set_yscale(\"log\")\n",
    "axs[0].set_ylim(1e-4)\n",
    "axs[0].axhline(y=chem_accuracy, color=\"#BF5700\", linestyle=\"--\", label=\"chemical accuracy\")\n",
    "axs[0].set_title(\"Approximated Ground State Energy Error vs SQD Iterations\")\n",
    "axs[0].set_xlabel(\"Iteration Index\", fontdict={\"fontsize\": 12})\n",
    "axs[0].set_ylabel(\"Energy Error (Ha)\", 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\"Exact energy: {exact_energy:.5f} Ha\")\n",
    "print(f\"SQD energy: {min_e[-1]:.5f} Ha\")\n",
    "print(f\"Absolute error: {e_diff[-1]:.5f} Ha\")\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}