examples/pennylane/3_Hydrogen_Molecule_geometry_with_VQE/3_Hydrogen_Molecule_geometry_with_VQE.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hydrogen Molecule geometry with VQE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial will show you how to solve an important problem for quantum chemistry using PennyLane on Amazon Braket: finding the ground-state energy of a molecule. The problem can be tackled using near-term quantum hardware by implementing the variational quantum eigensolver (VQE) algorithm. You can find further details on quantum chemistry and VQE in both the [Braket VQE](../../hybrid_quantum_algorithms/VQE_Chemistry/VQE_chemistry_braket.ipynb) notebook and PennyLane [tutorials](https://pennylane.ai/qml/demos/tutorial_qubit_rotation.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note</b> This notebook requires pennylane>=0.32 and amazon-braket-pennylane-plugin>=1.5.0\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## From quantum chemistry to quantum circuits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our first step is to convert our chemistry problem into something that can be tackled with a quantum computer. To do this, we will use PennyLane's ``qchem`` package. If running on a local machine, the ``qchem`` package must be installed separately by following [these](https://pennylane.readthedocs.io/en/stable/introduction/chemistry.html) instructions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pennylane as qml\n",
    "from pennylane import qchem\n",
    "from pennylane import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The input chemistry data is often provided in the form of a geometry file containing details about the molecule. Here, we consider the hydrogen molecule $\\mathrm{H}_2$ whose atomic structure is stored in the [h2.xyz](./hydrogen_molecule/h2.xyz) file. The qubit Hamiltonian for $\\mathrm{H}_2$ is built using the ``qchem`` package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  (-0.24274280046588792) [Z2]\n",
      "+ (-0.24274280046588792) [Z3]\n",
      "+ (-0.04207898539364302) [I0]\n",
      "+ (0.17771287502681438) [Z0]\n",
      "+ (0.1777128750268144) [Z1]\n",
      "+ (0.12293305045316086) [Z0 Z2]\n",
      "+ (0.12293305045316086) [Z1 Z3]\n",
      "+ (0.16768319431887935) [Z0 Z3]\n",
      "+ (0.16768319431887935) [Z1 Z2]\n",
      "+ (0.1705973836507714) [Z0 Z1]\n",
      "+ (0.1762764072240811) [Z2 Z3]\n",
      "+ (-0.044750143865718496) [Y0 Y1 X2 X3]\n",
      "+ (-0.044750143865718496) [X0 X1 Y2 Y3]\n",
      "+ (0.044750143865718496) [Y0 X1 X2 Y3]\n",
      "+ (0.044750143865718496) [X0 Y1 Y2 X3]\n"
     ]
    }
   ],
   "source": [
    "symbols, coordinates = qchem.read_structure(\"hydrogen_molecule/h2.xyz\")\n",
    "h, qubits = qchem.molecular_hamiltonian(symbols, coordinates, name=\"h2\")\n",
    "print(h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the VQE algorithm, we compute the energy of the $\\mathrm{H}_2$ molecule by measuring the expectation value of the above Hamiltonian on a variational quantum circuit. Our objective is to train the parameters of the circuit so that the expectation value of the Hamiltonian is minimized, thereby finding the ground state energy of the molecule.\n",
    "\n",
    "In this tutorial, we also want to compute the total spin. To that aim, we use the ``qchem`` package to build the total-spin operator $S^2$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  ((0.375+0j)) [Z0]\n",
      "+ ((0.375+0j)) [Z1]\n",
      "+ ((0.375+0j)) [Z2]\n",
      "+ ((0.375+0j)) [Z3]\n",
      "+ ((0.75+0j)) [I0]\n",
      "+ ((-0.375+0j)) [Z0 Z1]\n",
      "+ ((-0.375+0j)) [Z2 Z3]\n",
      "+ ((-0.125+0j)) [Z0 Z3]\n",
      "+ ((-0.125+0j)) [Z1 Z2]\n",
      "+ ((0.125+0j)) [Z0 Z2]\n",
      "+ ((0.125+0j)) [Z1 Z3]\n",
      "+ ((-0.125+0j)) [Y0 X1 X2 Y3]\n",
      "+ ((-0.125+0j)) [X0 Y1 Y2 X3]\n",
      "+ ((0.125+0j)) [Y0 X1 Y2 X3]\n",
      "+ ((0.125+0j)) [Y0 Y1 X2 X3]\n",
      "+ ((0.125+0j)) [Y0 Y1 Y2 Y3]\n",
      "+ ((0.125+0j)) [X0 X1 X2 X3]\n",
      "+ ((0.125+0j)) [X0 X1 Y2 Y3]\n",
      "+ ((0.125+0j)) [X0 Y1 X2 Y3]\n"
     ]
    }
   ],
   "source": [
    "electrons = 2  # Molecular hydrogen has two electrons\n",
    "\n",
    "S2 = qchem.spin2(electrons, qubits)\n",
    "print(S2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining an ansatz circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now set up the ansatz circuit that will be trained to prepare the ground state of the Hamiltonian.\n",
    "\n",
    "This tutorial uses a chemically-inspired circuit, the [`AllSinglesDoubles`](https://docs.pennylane.ai/en/stable/code/api/pennylane.AllSinglesDoubles.html) ansatz of [Delgado et al. (2020)](https://arxiv.org/abs/2106.13840). To use this, we must define some additional inputs from quantum chemistry."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hartree-Fock state\n",
    "hf_state = qchem.hf_state(electrons, qubits)\n",
    "# generate single- and double-excitations\n",
    "singles, doubles = qchem.excitations(electrons, qubits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note</b> A variety of alternative ansätze and templates are <a href=\"https://pennylane.readthedocs.io/en/stable/introduction/templates.html#quantum-chemistry-templates\">available</a> and different choices will result in varying circuit depth and number of trainable parameters.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our ansatz circuit is then simple to define:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def circuit(params, wires):\n",
    "    qml.templates.AllSinglesDoubles(params, wires, hf_state, singles, doubles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that an output measurement has not yet been defined! This is the next step."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Measuring the energy and total spin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we instantiate a device to run our circuits; we will use the Braket local simulator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device(\"lightning.qubit\", wires=qubits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We discussed earlier that we want to minimize the expectation value of the qubit Hamiltonian, corresponding to the energy of $\\mathrm{H}_2$. The expectation values of this Hamiltonian and the total spin $\\hat{S}^2$ operator can be defined using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "wires = dev.wires.tolist()\n",
    "\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def energy_expval(params):\n",
    "    circuit(params, wires)\n",
    "    return qml.expval(h)\n",
    "\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def S2_expval(params):\n",
    "    circuit(params, wires)\n",
    "    return qml.expval(S2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that `dev` was created without a `shots` argument. This means it will calculate the exact expectation value of the Hamiltonian, and can do so in a single evaluation.\n",
    "\n",
    "Let's now initialize some random values and evaluate the energy and spin. The total spin $S$ of the prepared state can be obtained from the expectation value $\\langle \\hat{S}^2 \\rangle$ using $S=-\\frac{1}{2} + \\sqrt{\\frac{1}{4} + \\langle \\hat{S}^2 \\rangle}$. We can define a function to compute $S$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def spin(params):\n",
    "    return -0.5 + np.sqrt(1 / 4 + S2_expval(params))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(1967)\n",
    "params = np.random.normal(0, np.pi, len(singles) + len(doubles))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The energy and total spin are then"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Energy: -0.2730496738441154\n",
      "Spin:   0.11000908988780544\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/drbeach/miniconda3/envs/decorator/lib/python3.10/site-packages/pennylane_lightning/core/_serialize.py:133: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  coeffs = np.array(unwrap(observable.coeffs)).astype(self.rtype)\n"
     ]
    }
   ],
   "source": [
    "print(\"Energy:\", float(energy_expval(params)))\n",
    "print(\"Spin:  \", float(spin(params)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we have picked random parameters, the measured energy does not correspond to the ground state energy and the prepared state is not an eigenstate of the total-spin operator. We must now train the parameters to find the minimum energy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Minimizing the energy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The energy can be minimized by choosing an optimizer and running the standard optimization loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lets choose RMSPropOptimizer.\n",
    "# Other alternatives: GradientDescentOptimizer, AdagradOptimizer, AdamOptimizer, ...\n",
    "opt = qml.RMSPropOptimizer(stepsize=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "iterations = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from braket.jobs.metrics import log_metric\n",
    "\n",
    "\n",
    "def run_vqe(energy_expval, spin, opt, initial_params, iterations):\n",
    "    energies = []\n",
    "    spins = []\n",
    "    params = initial_params\n",
    "\n",
    "    start = time.time()\n",
    "    for i in range(iterations):\n",
    "        params = opt.step(energy_expval, params)\n",
    "\n",
    "        e = energy_expval(params)\n",
    "        s = spin(params)\n",
    "\n",
    "        energies.append(e)\n",
    "        spins.append(s)\n",
    "\n",
    "        log_metric(metric_name=\"energy\", value=e, iteration_number=i)\n",
    "\n",
    "        print(f\"Completed iteration {i + 1}\")\n",
    "        print(\"Energy:\", e)\n",
    "        print(\"Total spin:\", s)\n",
    "        print(\"----------------\")\n",
    "\n",
    "    print(f\"Optimized energy: {e} Ha\")\n",
    "    print(f\"Corresponding total spin: {s}\")\n",
    "    print(f\"Elapsed: {time.time()-start} s\")\n",
    "    return energies, spins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/drbeach/miniconda3/envs/decorator/lib/python3.10/site-packages/pennylane_lightning/core/_serialize.py:133: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  coeffs = np.array(unwrap(observable.coeffs)).astype(self.rtype)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metrics - timestamp=1697139811.2718408; energy=-0.5602851198326602; iteration_number=0;\n",
      "Completed iteration 1\n",
      "Energy: -0.5602851198326602\n",
      "Total spin: 0.13287789321454435\n",
      "----------------\n",
      "Metrics - timestamp=1697139811.3152246; energy=-0.7773309017116151; iteration_number=1;\n",
      "Completed iteration 2\n",
      "Energy: -0.7773309017116151\n",
      "Total spin: 0.09488198120583491\n",
      "----------------\n",
      "Metrics - timestamp=1697139811.3421786; energy=-1.0083677187505569; iteration_number=2;\n",
      "Completed iteration 3\n",
      "Energy: -1.0083677187505569\n",
      "Total spin: 0.04940760029256386\n",
      "----------------\n",
      "Metrics - timestamp=1697139811.369656; energy=-1.1060574430621748; iteration_number=3;\n",
      "Completed iteration 4\n",
      "Energy: -1.1060574430621748\n",
      "Total spin: 0.01902625475224251\n",
      "----------------\n",
      "Metrics - timestamp=1697139811.3969185; energy=-1.1301112509281241; iteration_number=4;\n",
      "Completed iteration 5\n",
      "Energy: -1.1301112509281241\n",
      "Total spin: 0.0056347819636390906\n",
      "----------------\n",
      "Metrics - timestamp=1697139811.424453; energy=-1.1351064397742514; iteration_number=5;\n",
      "Completed iteration 6\n",
      "Energy: -1.1351064397742514\n",
      "Total spin: 0.0012625902560892133\n",
      "----------------\n",
      "Metrics - timestamp=1697139811.4511507; energy=-1.136021579371058; iteration_number=6;\n",
      "Completed iteration 7\n",
      "Energy: -1.136021579371058\n",
      "Total spin: 0.00022566866798245933\n",
      "----------------\n",
      "Metrics - timestamp=1697139811.4915578; energy=-1.1361670884772965; iteration_number=7;\n",
      "Completed iteration 8\n",
      "Energy: -1.1361670884772965\n",
      "Total spin: 3.215466396355726e-05\n",
      "----------------\n",
      "Metrics - timestamp=1697139811.5190527; energy=-1.1361867905470242; iteration_number=8;\n",
      "Completed iteration 9\n",
      "Energy: -1.1361867905470242\n",
      "Total spin: 3.626608394258213e-06\n",
      "----------------\n",
      "Metrics - timestamp=1697139811.5578496; energy=-1.1361890094090557; iteration_number=9;\n",
      "Completed iteration 10\n",
      "Energy: -1.1361890094090557\n",
      "Total spin: 3.158279299197986e-07\n",
      "----------------\n",
      "Optimized energy: -1.1361890094090557 Ha\n",
      "Corresponding total spin: 3.158279299197986e-07\n",
      "Elapsed: 0.35576891899108887 s\n"
     ]
    }
   ],
   "source": [
    "energies, spins = run_vqe(energy_expval, spin, opt, params, iterations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The exact value for the ground state energy of molecular hydrogen has been theoretically calculated as ``-1.136189454088`` Hartrees (Ha). Notice that the optimized energy is off by less than $10^{-5}$ of a Hartree. Furthermore, the optimized state is an eigenstate of the total-spin operator with eigenvalue $S=0$ as expected for the ground state of the $\\mathrm{H}_2$ molecule. Hence, our above results look very promising! We would get even closer to the theory values if we increase the number of iterations.\n",
    "\n",
    "Let's visualize how the two quantities evolved during optimization:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "theory_energy = -1.136189454088\n",
    "theory_spin = 0\n",
    "\n",
    "plt.hlines(theory_energy, 0, iterations, colors=\"black\")\n",
    "plt.plot(energies, \"o-\")\n",
    "plt.xlabel(\"Steps\")\n",
    "plt.ylabel(\"Energy\")\n",
    "\n",
    "axs = plt.gca()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have learned how to efficiently find the ground state energy of a molecule using the PennyLane/Braket pipeline!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scaling up with hybrid jobs\n",
    "\n",
    "Next, we scale up the experiment using Amazon Braket [Hybrid Jobs](https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs.html). \n",
    "You can do this by annotating your code with the `@hybrid_job` decorator. We set `device=\"local:pennylane/lightning\"` since we are using the lightning.qubit simulator. \n",
    "We also change the classical instance to a larger instance called \"ml.c5.xlarge\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from braket.jobs import hybrid_job, InstanceConfig\n",
    "from braket.tracking import Tracker\n",
    "\n",
    "large_instance = InstanceConfig(instanceType=\"ml.c5.xlarge\")\n",
    "\n",
    "\n",
    "@hybrid_job(\n",
    "    device=\"local:pennylane/lightning\",\n",
    "    instance_config=large_instance,\n",
    ")\n",
    "def run_large_vqe(iterations):\n",
    "    task_tracker = Tracker().start()  # track Braket quantum tasks costs\n",
    "\n",
    "    energies, spins = run_vqe(energy_expval, spin, opt, params, iterations)\n",
    "\n",
    "    return {\n",
    "        \"energies\": energies,\n",
    "        \"spins\": spins,\n",
    "        \"braket_tasks_cost\": task_tracker.qpu_tasks_cost() + task_tracker.simulator_tasks_cost(),\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following cell, we create the hybrid job by calling the function normally. \n",
    "Note that the function returns the handle to the hybrid job which runs asynchronously. \n",
    "Once the hybrid job has completed, we retrieve the results.  \n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Caution:</b> Running the following cell  will result in <a href=\"https://aws.amazon.com/braket/pricing/\">usage fees</a> charged to your AWS account. We recommend monitoring the Billing & Cost Management Dashboard on the AWS console.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AwsQuantumJob('arn':'arn:aws:braket:us-west-1:961591465522:job/run-large-vqe-1697139811768')\n"
     ]
    }
   ],
   "source": [
    "job = run_large_vqe(iterations=30)\n",
    "print(job)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You retrieve the results when the algorithm is complete with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'energies': [array(-0.55187225), array(-0.70005221), array(-0.89729232), array(-1.03687194), array(-1.09926479), array(-1.1235433), array(-1.13217906), array(-1.1350177), array(-1.13587664), array(-1.13611398), array(-1.13617316), array(-1.13618628), array(-1.1361888), array(-1.1361891), array(-1.13618883), array(-1.13618784), array(-1.13618452), array(-1.13617163), array(-1.13611418), array(-1.13582078), array(-1.13416153), array(-1.12555889), array(-1.10835438), array(-1.11654572), array(-1.12851297), array(-1.13326765), array(-1.13489124), array(-1.13548314), array(-1.13571512), array(-1.13579802), array(-1.13579607), array(-1.13571334), array(-1.13550525), array(-1.13504536), array(-1.13403895), array(-1.1319386), array(-1.12839979), array(-1.12513719), array(-1.12533626), array(-1.12823079), array(-1.1310321), array(-1.13281667), array(-1.13379207), array(-1.13427242), array(-1.13444455), array(-1.13438512), array(-1.13409575), array(-1.13352525), array(-1.13260457), array(-1.13134793), array(-1.13003231), array(-1.12921109), array(-1.1288403), array(-1.11658034), array(-1.11047216), array(-1.12219718), array(-1.10627973), array(-1.1236975), array(-1.13135412), array(-1.13243005), array(-1.13244886), array(-1.13202399), array(-1.13149092), array(-1.13098935), array(-1.13070568), array(-1.13068291), array(-1.13087401), array(-1.13099708), array(-1.13071549), array(-1.12901891), array(-1.1259372), array(-1.12274542), array(-1.12239518), array(-1.12201351), array(-1.12577647), array(-1.12791115), array(-1.12943676), array(-1.12956896), array(-1.12972941), array(-1.12965116), array(-1.12982715), array(-1.12971169), array(-1.12954916), array(-1.12859317), array(-1.12765628), array(-1.12607814), array(-1.12582959), array(-1.12546759), array(-1.12678979), array(-1.12732392), array(-1.12836158), array(-1.12843569), array(-1.1288221), array(-1.12868107), array(-1.12889865), array(-1.12861641), array(-1.12861102), array(-1.12794607), array(-1.12775452), array(-1.1269936)], 'spins': [0.15969152963337319, 0.14300644899470527, 0.10138139829601989, 0.05841186821393585, 0.029397735445742645, 0.012683239937044788, 0.004709419412889271, 0.0015356565172549574, 0.0004406833589031267, 0.00011150185434460891, 2.4696881266605963e-05, 4.754753258340294e-06, 7.841747289294432e-07, 1.0911400150082073e-07, 1.2487133216332325e-08, 1.1431044999454798e-09, 7.994138684352947e-11, 4.0460967909439205e-12, 1.354472090042691e-13, 2.55351295663786e-15, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.1102230246251565e-16, 1.2212453270876722e-15, 1.2989609388114332e-14, 2.1038726316646716e-13, 2.903122187092322e-12, 6.226463789005265e-11, 1.0713994136324345e-09, 3.111918500664501e-08, 6.453371255155105e-07, 2.5295425650662118e-05, 0.0006400722119676017, 0.022025029044442035, 0.023385561885357342, 0.00014311106120790118, 0.021705432372581934, 0.008924076514024493, 0.0011652488654905202, 0.0002831588044178712, 4.200450060132255e-05, 9.251351257621998e-06, 1.8141004576310849e-07, 1.6834871601201229e-06, 7.732131861448721e-06, 3.198347546606861e-05, 7.046684828326821e-05, 0.00026530689107850947, 0.0006129610537283225, 0.002087209960787595, 0.00290374071321875, 0.0020472894698817523, 2.360806709422736e-05, 0.0017449222730436809, 0.0014809373925386282, 0.0009302646937726644, 0.00023724624727050614, 8.150100063286647e-05, 4.984330999269204e-06, 4.925328396909734e-06, 3.6265129713664024e-05, 0.00013657677273337665, 0.00022008908595805288, 0.00044302657230532727, 0.0003533976575068598, 0.00020351535710572133, 5.43610939485184e-07, 0.00011382311021634894, 0.00019422317002082412, 0.00021497283602989192, 8.70192302054873e-05, 4.1234804362910715e-05, 4.038649503712577e-06, 1.124619311898556e-06, 1.3053006908458897e-05, 4.337371918849975e-05, 5.271085643610007e-05, 7.287264124733461e-05, 3.572624691072779e-05, 1.0876786015745488e-05], 'braket_tasks_cost': Decimal('0')}\n",
      "CPU times: user 118 ms, sys: 8.17 ms, total: 126 ms\n",
      "Wall time: 1min 55s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "result = job.result()\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we plot the results from the hybrid job"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Energy')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "theory_energy = -1.136189454088\n",
    "theory_spin = 0\n",
    "\n",
    "plt.hlines(theory_energy, 0, iterations, colors=\"black\")\n",
    "plt.plot(result[\"energies\"], \"o-\")\n",
    "plt.xlabel(\"Steps\")\n",
    "plt.ylabel(\"Energy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running VQE with `shots>0`\n",
    "\n",
    "In the above example, we computed exact expectation values of our Hamiltonians, and were able to do so with a single evaluation each. This relies on the simulator having access to the exact state, and isn't possible if the device estimates the expectation with shots, like in the case of a QPU.\n",
    "\n",
    "Suppose we want to estimate the expectation value of the electronic Hamiltonian `h` with a finite number of shots. This Hamiltonian is composed of 15 individual observables that are tensor products of Pauli operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of Pauli terms in h: 15\n"
     ]
    }
   ],
   "source": [
    "print(\"Number of Pauli terms in h:\", len(h.ops))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A straightforward approach to measuring the expectation value would be to run the circuit 15 times, each time measuring one of the Pauli terms that form part of the Hamiltonian `h`. However, we can be more efficient. The Pauli terms can be separated into groups (see PennyLane's [grouping](https://pennylane.readthedocs.io/en/stable/code/qml_grouping.html) module) that share a basis, and thus can be measured concurrently on a single circuit. Elements of each group are known as qubit-wise commuting observables. The Hamiltonian `h` can be split into 5 groups:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of qubit-wise commuting groups: 5\n"
     ]
    }
   ],
   "source": [
    "groups, coeffs = qml.pauli.group_observables(h.ops, h.coeffs)\n",
    "print(\"Number of qubit-wise commuting groups:\", len(groups))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Practically, this means that instead of executing 15 separate circuits, we just need to execute 5. This saving can become even more pronounced as the number of Pauli terms in the Hamiltonian increases. For example, switching to a larger molecule or a different chemical basis set can increase both the number of qubits and the number of terms.\n",
    "\n",
    "Fortunately, the PennyLane/Braket pipeline has builtin support for pre-grouping the observables in a Hamiltonian to minimize the number of device executions, saving both runtime and simulation fees when using remote devices."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"center\"><img src=\"grouping.png\"/></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To take advantage of grouping, we must instruct PennyLane to break up each Hamiltonian into qubit-wise commuting groups. We do this by computing the groups and storing them with the Hamiltonian; the device will use this information when to create the circuits to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "h.compute_grouping()\n",
    "S2.compute_grouping()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we instantiate the device, but this time with nonzero `shots`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device(\"braket.local.qubit\", wires=qubits, shots=5000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And redefine our cost functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "wires = dev.wires.tolist()\n",
    "\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def energy_expval(params):\n",
    "    circuit(params, wires)\n",
    "    return qml.expval(h)\n",
    "\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def S2_expval(params):\n",
    "    circuit(params, wires)\n",
    "    return qml.expval(S2)\n",
    "\n",
    "\n",
    "def spin(params):\n",
    "    return -0.5 + np.sqrt(1 / 4 + S2_expval(params))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we run the VQE experiment and get our expectation estimates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metrics - timestamp=1697139937.3019145; energy=-0.5412825955158931; iteration_number=0;\n",
      "Completed iteration 1\n",
      "Energy: -0.5412825955158931\n",
      "Total spin: (0.15326105042318272+0j)\n",
      "----------------\n",
      "Metrics - timestamp=1697139944.412684; energy=-0.6936120312135796; iteration_number=1;\n",
      "Completed iteration 2\n",
      "Energy: -0.6936120312135796\n",
      "Total spin: (0.1396092557178953+0j)\n",
      "----------------\n",
      "Metrics - timestamp=1697139951.4129083; energy=-0.8906199472711986; iteration_number=2;\n",
      "Completed iteration 3\n",
      "Energy: -0.8906199472711986\n",
      "Total spin: (0.09703433737097567+0j)\n",
      "----------------\n",
      "Metrics - timestamp=1697139958.4950173; energy=-1.0433105151800557; iteration_number=3;\n",
      "Completed iteration 4\n",
      "Energy: -1.0433105151800557\n",
      "Total spin: (0.05785302723925401+0j)\n",
      "----------------\n",
      "Metrics - timestamp=1697139965.4518325; energy=-1.0992473165501542; iteration_number=4;\n",
      "Completed iteration 5\n",
      "Energy: -1.0992473165501542\n",
      "Total spin: (0.024499761677734266+0j)\n",
      "----------------\n",
      "Metrics - timestamp=1697139972.4262433; energy=-1.1281011541233785; iteration_number=5;\n",
      "Completed iteration 6\n",
      "Energy: -1.1281011541233785\n",
      "Total spin: (0.012347538297979854+0j)\n",
      "----------------\n",
      "Metrics - timestamp=1697139979.4071403; energy=-1.132303797965168; iteration_number=6;\n",
      "Completed iteration 7\n",
      "Energy: -1.132303797965168\n",
      "Total spin: (-0.007658654996353209+0j)\n",
      "----------------\n",
      "Metrics - timestamp=1697139986.409697; energy=-1.1349500459612611; iteration_number=7;\n",
      "Completed iteration 8\n",
      "Energy: -1.1349500459612611\n",
      "Total spin: (0.0019462122578475238+0j)\n",
      "----------------\n",
      "Metrics - timestamp=1697139993.3897896; energy=-1.1356074477133202; iteration_number=8;\n",
      "Completed iteration 9\n",
      "Energy: -1.1356074477133202\n",
      "Total spin: (0.0023445033042561736+0j)\n",
      "----------------\n",
      "Metrics - timestamp=1697140000.283897; energy=-1.1373271109993635; iteration_number=9;\n",
      "Completed iteration 10\n",
      "Energy: -1.1373271109993635\n",
      "Total spin: (-0.0016527315214822647+0j)\n",
      "----------------\n",
      "Optimized energy: -1.1373271109993635 Ha\n",
      "Corresponding total spin: (-0.0016527315214822647+0j)\n",
      "Elapsed: 69.98771715164185 s\n"
     ]
    }
   ],
   "source": [
    "energies, spins = run_vqe(energy_expval, spin, opt, params, iterations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that we get pretty close to the values found through exact calculation! In this experiment, we used the local simulator, but the same steps apply for QPUs, or any simulator that uses a nonzero number of shots!\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>What's next?</b> The <code>hydrogen_molecule</code> folder contains additional molecular structure files for different atomic separations of molecular hydrogen. Pick one of the separations and find the ground state energy. How does the ground state energy change with atomic separation? \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n",
      "Estimated cost to run this example: 0.000 USD\n"
     ]
    }
   ],
   "source": [
    "job_cost = job.result()[\"braket_tasks_cost\"]\n",
    "\n",
    "print(\n",
    "    \"Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\"\n",
    ")\n",
    "print(f\"Estimated cost to run this example: {job_cost:.3f} USD\")"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "4737fd5cefc361def96fec082a94ffa1860819024319231e0688a4bd6d8b89cd"
  },
  "kernelspec": {
   "display_name": "conda_braket",
   "language": "python",
   "name": "conda_braket"
  },
  "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}