{
 "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. These are loaded from an ``fcidump`` file with standard chemistry software.\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": [
      "Parsing ../molecules/n2_fci.txt\n"
     ]
    }
   ],
   "source": [
    "import warnings\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "from pyscf import ao2mo, tools\n",
    "\n",
    "# Specify molecule properties\n",
    "num_orbitals = 16\n",
    "num_elec_a = num_elec_b = 5\n",
    "open_shell = False\n",
    "spin_sq = 0\n",
    "\n",
    "# Read in molecule from disk\n",
    "mf_as = tools.fcidump.to_scf(\"../molecules/n2_fci.txt\")\n",
    "hcore = mf_as.get_hcore()\n",
    "eri = ao2mo.restore(1, mf_as._eri, num_orbitals)\n",
    "nuclear_repulsion_energy = mf_as.mol.energy_nuc()"
   ]
  },
  {
   "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": [
      "converged SCF energy = -108.867773675638\n",
      "E(CCSD) = -109.0935188821144  E_corr = -0.2257452064762984\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Overwritten attributes  get_ovlp get_hcore  of <class 'pyscf.scf.hf_symm.SymAdaptedRHF'>\n"
     ]
    }
   ],
   "source": [
    "from pyscf import cc\n",
    "\n",
    "mf_as.kernel()\n",
    "mc = cc.CCSD(mf_as)\n",
    "mc.kernel()\n",
    "t1 = mc.t1\n",
    "t2 = mc.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 = 2\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': 7419, 'sx': 6016, 'ecr': 2240, 'x': 323, 'measure': 32, 'barrier': 1})\n",
      "Gate counts (w/ pre-init passes): OrderedDict({'rz': 4158, 'sx': 3186, 'ecr': 1262, 'x': 210, '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": [
    "# 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",
    "from qiskit_addon_sqd.counts import generate_counts_uniform\n",
    "\n",
    "rand_seed = 42\n",
    "counts = generate_counts_uniform(10_000, num_orbitals * 2, rand_seed=rand_seed)"
   ]
  },
  {
   "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": [
    "import numpy as np\n",
    "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=rand_seed,\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=rand_seed,\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 ``~200 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",
    "n2_exact = -109.10288938\n",
    "x1 = range(iterations)\n",
    "e_diff = [abs(np.min(energies) - n2_exact) 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 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
}