docs/tutorials/01_chemistry_hamiltonian.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9e40af77-7f0f-4dd6-ab0a-420cf396050e",
   "metadata": {},
   "source": [
    "# Improving energy estimation of a Fermionic 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 the $N_2$ molecule at equilibrium in the 6-31G basis set. We will follow a sample-based quantum diagonalization approach [[1]](https://arxiv.org/abs/2405.05068) to process samples taken from a ``36``-qubit quantum circuit. In order to account for the effect of quantum noise, the self-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 used in [[2]](https://pubs.rsc.org/en/content/articlehtml/2023/sc/d3sc02516k) for qubit interactions. 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."
   ]
  },
  {
   "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 less 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': 4530, 'sx': 3435, 'ecr': 1366, 'x': 224, 'measure': 32, 'barrier': 1})\n",
      "Gate counts (w/ pre-init passes): OrderedDict({'rz': 2455, 'sx': 2151, 'ecr': 730, 'x': 83, '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",
    "\n",
    "# from qiskit_ibm_runtime import SamplerV2 as Sampler\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",
    "from qiskit_addon_sqd.counts import generate_counts_uniform\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": [
    "### 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",
      "Starting configuration recovery iteration 1\n",
      "Starting configuration recovery iteration 2\n",
      "Starting configuration recovery iteration 3\n",
      "Starting configuration recovery iteration 4\n"
     ]
    }
   ],
   "source": [
    "from qiskit_addon_sqd.configuration_recovery import recover_configurations\n",
    "from qiskit_addon_sqd.fermion import (\n",
    "    flip_orbital_occupancies,\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 = 10\n",
    "samples_per_batch = 300\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 = np.zeros((iterations, 2 * num_orbitals))\n",
    "occupancies_bitwise = None  # orbital i corresponds to column i in bitstring matrix\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 just post-select from the full bitstring set based on hamming weight.\n",
    "    if occupancies_bitwise 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",
    "            occupancies_bitwise,\n",
    "            num_elec_a,\n",
    "            num_elec_b,\n",
    "            rand_seed=rng,\n",
    "        )\n",
    "\n",
    "    # Throw out configurations with incorrect particle number in either the spin-up or spin-down systems\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 = np.zeros((n_batches, 2 * num_orbitals))\n",
    "    coeffs = []\n",
    "    for j in range(n_batches):\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[j, :num_orbitals] = avg_occs[0]\n",
    "        occs_tmp[j, num_orbitals:] = avg_occs[1]\n",
    "        coeffs.append(coeffs_sci)\n",
    "\n",
    "    # Combine batch results\n",
    "    avg_occupancy = np.mean(occs_tmp, axis=0)\n",
    "    # The occupancies from the solver should be flipped to match the bits in the bitstring matrix.\n",
    "    occupancies_bitwise = flip_orbital_occupancies(avg_occupancy)\n",
    "\n",
    "    # Track optimization history\n",
    "    e_hist[i, :] = e_tmp\n",
    "    s_hist[i, :] = s_tmp\n",
    "    occupancy_hist[i, :] = avg_occupancy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d78906b-4759-4506-9c69-85d4e67766b3",
   "metadata": {},
   "source": [
    "### Visualize the results\n",
    "\n",
    "The first plot shows that after a couple of iterations we estimate the ground state energy within ``~40 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": [
    {
     "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",
    "e_diff = [abs(np.min(energies) - exact_energy) for energies in e_hist]\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 = avg_occupancy[:num_orbitals] + avg_occupancy[num_orbitals:]\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",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0264e5a8-6581-43f9-b13b-b9cfef3830bd",
   "metadata": {},
   "source": [
    "### References\n",
    "\n",
    "[1] Robledo-Moreno, Javier, et al. [\"Chemistry beyond exact solutions on a quantum-centric supercomputer.\"](https://arxiv.org/abs/2405.05068) arXiv preprint arXiv:2405.05068 (2024).\n",
    "\n",
    "[2] Motta, Mario, et al. [\"Bridging physical intuition and hardware efficiency for correlated electronic states: the local unitary cluster Jastrow ansatz for electronic structure.\"](https://pubs.rsc.org/en/content/articlelanding/2023/sc/d3sc02516k) Chemical Science 14.40 (2023): 11213-11227."
   ]
  }
 ],
 "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
}