ipynb/0.5-Hi,_Hydrogen!.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "933bb54c",
   "metadata": {},
   "source": [
    "##### Tutorial Challenges\n",
    "\n",
    "# 5. Hi, Hydrogen! (0 points)\n",
    "\n",
    "Welcome to the QHack 2023 daily challenges! Every day for the next four days, you will receive two new challenges to complete. These challenges are worth no points — they are specifically designed to get your brain active and into the right mindset for the competition. You will also learn about various aspects of PennyLane that are essential to quantum computing, quantum machine learning, and quantum chemistry. Have fun!\n",
    "\n",
    "## Tutorial \\#5 — Hi, Hydrogen!\n",
    "\n",
    "The Variational Quantum Eigensolver (VQE) algorithm has been touted as a game-changing near-term quantum algorithm. In particular, VQE is able to efficiently simulate low-energy properties of small molecules. In this challenge, you will calculate the energy of the hydrogen molecule for various molecular charges and bond length combinations.\n",
    "\n",
    "![Hydrogen Molecule Energy Levels](../img/daily5_2.png)\n",
    "\n",
    "## Challenge code\n",
    "\n",
    "In the code below, you are given a few functions:\n",
    "\n",
    "- `hydrogen_hamiltonian`: This function will return the qubit Hamiltonian of the hydrogen molecule, $H_2$, given the coordinates of both hydrogen atoms and the net molecular `charge`. You'll usually find $H_2$ with a charge of 0, but here we'll spice it up with a non-zero charge!\n",
    "- `num_electrons`: In subsequent functions, we'll need the total number of electrons in the hydrogen molecule we're looking at. With a charge of 0, H\n",
    "usually has just 2 electrons, one per hydrogen atom. Given the charge, how many electrons should $H_2$ have? **You must complete this function.**\n",
    "- `hf`: The \"HF\" stands for Hartree–Fock. This function's purpose is calculate the HF approximation — treat every electron as independent, electrons move under a Coulomb potential from the positively charged nuclei, and there's a mean field from the other electrons — for the ground state of the hydrogen molecule we're interested in. We'll use this later, so **you must complete this function.**\n",
    "- `run_VQE`: This function takes the `coordinates`, `charge`, generates the HF state, defines a `cost` function and minimizes it. You must complete this function by:\n",
    "    - defining the gates within the `cost` function, using the [`qml.AllSinglesDoubles`](https://docs.pennylane.ai/en/stable/code/api/pennylane.AllSinglesDoubles.html) template with `singles` and `doubles` arguments defined below; and\n",
    "    - returning what we want to minimize, namely the expectation value of the hydrogen Hamiltonian!\n",
    "\n",
    "Here are some helpful resources:\n",
    "\n",
    "- [Building molecular Hamiltonians](https://pennylane.ai/qml/demos/tutorial_quantum_chemistry.html)\n",
    "- [A brief overview of VQE](https://pennylane.ai/qml/demos/tutorial_vqe.html)\n",
    "- [Variational Quantum Eigensolver](https://youtu.be/4Xnxa6tzPeA)\n",
    "- [Quantum Chemistry documentation](https://docs.pennylane.ai/en/stable/introduction/chemistry.html)\n",
    "\n",
    "### Input\n",
    "\n",
    "As input to this problem, you are given:\n",
    "\n",
    "- `coordinates` (`list(float)`): the $x$, $y$, and $z$ coordinates of each hydrogen atom\n",
    "- `charge` (`int`): the charge of the hydrogen molecule. It could be positive, negative, or zero!\n",
    "\n",
    "### Output\n",
    "\n",
    "This code must output the ground state `energy` (`float`) of the hydrogen molecule in question.\n",
    "\n",
    "If your solution matches the correct one within the given tolerance specified in `check` (in this case it's a `1e-3` relative error tolerance), the output will be `\"Correct!\"` Otherwise, you will receive a `\"Wrong answer\"` prompt.\n",
    "\n",
    "Good luck!\n",
    "\n",
    "### Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "79f407bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pennylane as qml\n",
    "import pennylane.numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3c1b0fee",
   "metadata": {},
   "outputs": [],
   "source": [
    "def hydrogen_hamiltonian(coordinates, charge):\n",
    "    \"\"\"Calculates the qubit Hamiltonian of the hydrogen molecule.\n",
    "    \n",
    "    Args:\n",
    "        coordinates (list(float)): Cartesian coordinates of each hydrogen molecule.\n",
    "        charge (int): The electric charge given to the hydrogen molecule.\n",
    "\n",
    "    Returns:\n",
    "        (qml.Hamiltonian): A PennyLane Hamiltonian.\n",
    "    \"\"\"\n",
    "    return qml.qchem.molecular_hamiltonian(\n",
    "        [\"H\", \"H\"], coordinates, charge, basis=\"STO-3G\"\n",
    "    )[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f6c5dabc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def num_electrons(charge):\n",
    "    \"\"\"The total number of electrons in the hydrogen molecule.\n",
    "    \n",
    "    Args:\n",
    "        charge (int): The electric charge given to the hydrogen molecule.\n",
    "\n",
    "    Returns: \n",
    "        (int): The number of electrons.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your solution here #\n",
    "    \n",
    "    return 2 - charge\n",
    "\n",
    "num_electrons(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "421057f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 1, 1, 0], requires_grad=True)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def hf(electrons, num_qubits):\n",
    "    \"\"\"Calculates the Hartree-Fock state of the hydrogen molecule.\n",
    "    \n",
    "    Args:\n",
    "        electrons (int): The number of electrons in the hydrogen molecule.\n",
    "        num_qubits (int): The number of qubits needed to represent the hydrogen molecule Hamiltonian.\n",
    "\n",
    "    Returns:\n",
    "        (numpy.tensor): The HF state.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your solution here #\n",
    "    \n",
    "    return qml.qchem.hf_state(electrons, num_qubits)\n",
    "\n",
    "hf(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e3f14ab1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(-0.53168366, requires_grad=True)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def run_VQE(coordinates, charge):\n",
    "    \"\"\"Performs a VQE routine for the given hydrogen molecule.\n",
    "\n",
    "    Args:\n",
    "        coordinates (list(float)): Cartesian coordinates of each hydrogen molecule.\n",
    "        charge (int): The electric charge given to the hydrogen molecule.:\n",
    "\n",
    "    Returns:\n",
    "        (float): The expectation value of the hydrogen Hamiltonian.\n",
    "    \"\"\"\n",
    "\n",
    "    hamiltonian = hydrogen_hamiltonian(np.array(coordinates), charge)\n",
    "\n",
    "    electrons = num_electrons(charge)\n",
    "    num_qubits = len(hamiltonian.wires)\n",
    "\n",
    "    hf_state = hf(electrons, num_qubits)\n",
    "    # singles and doubles are used to make the AllSinglesDoubles template\n",
    "    singles, doubles = qml.qchem.excitations(electrons, num_qubits)\n",
    "\n",
    "    dev = qml.device(\"default.qubit\", wires=num_qubits)\n",
    "\n",
    "    @qml.qnode(dev)\n",
    "    def cost(weights):\n",
    "        \"\"\"A circuit with tunable parameters/weights that measures the expectation value of the hydrogen Hamiltonian.\n",
    "        \n",
    "        Args:\n",
    "            weights (numpy.array): An array of tunable parameters.\n",
    "\n",
    "        Returns:\n",
    "            (float): The expectation value of the hydrogen Hamiltonian.\n",
    "        \"\"\"\n",
    "        \n",
    "        # Put your solution here #\n",
    "        \n",
    "        qml.templates.AllSinglesDoubles(weights, dev.wires, hf_state, \n",
    "                                        singles, doubles)\n",
    "        \n",
    "        return qml.expval(hamiltonian)\n",
    "    \n",
    "    np.random.seed = 1234\n",
    "    weights = np.random.normal(\n",
    "        0, np.pi, len(singles) + len(doubles), requires_grad=True\n",
    "    )\n",
    "    opt = qml.AdamOptimizer(0.5)\n",
    "\n",
    "    for _ in range(200):\n",
    "        weights = opt.step(cost, weights)\n",
    "\n",
    "    return cost(weights)\n",
    "\n",
    "run_VQE([0.0, 0.0, -0.8, 0.0, 0.0, 0.8], -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a4a71003",
   "metadata": {},
   "outputs": [],
   "source": [
    "# These functions are responsible for testing the solution.\n",
    "def run(test_case_input: str) -> str:\n",
    "    coordinates, charge = json.loads(test_case_input)\n",
    "    energy = run_VQE(coordinates, charge)\n",
    "\n",
    "    return str(energy)\n",
    "\n",
    "def check(solution_output: str, expected_output: str) -> None:\n",
    "    solution_output = json.loads(solution_output)\n",
    "    expected_output = json.loads(expected_output)\n",
    "    assert np.allclose(solution_output, expected_output, rtol=1e-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7ed1a65f",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = [['[[0.0, 0.0, -0.8, 0.0, 0.0, 0.8], -1]', '-0.53168359'], ['[[0.0, 0.0, -0.6614, 0.0, 0.0, 0.6614], 0]', '-1.13618883']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2d17f6be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running test case 0 with input '[[0.0, 0.0, -0.8, 0.0, 0.0, 0.8], -1]'...\n",
      "Correct!\n",
      "Running test case 1 with input '[[0.0, 0.0, -0.6614, 0.0, 0.0, 0.6614], 0]'...\n",
      "Correct!\n"
     ]
    }
   ],
   "source": [
    "for i, (input_, expected_output) in enumerate(test_cases):\n",
    "    print(f\"Running test case {i} with input '{input_}'...\")\n",
    "\n",
    "    try:\n",
    "        output = run(input_)\n",
    "\n",
    "    except Exception as exc:\n",
    "        print(f\"Runtime Error. {exc}\")\n",
    "\n",
    "    else:\n",
    "        if message := check(output, expected_output):\n",
    "            print(f\"Wrong Answer. Have: '{output}'. Want: '{expected_output}'.\")\n",
    "\n",
    "        else:\n",
    "            print(\"Correct!\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pennylane",
   "language": "python",
   "name": "pennylane"
  },
  "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.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}