Quantum Chemistry for HIV.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=center class=\"alert alert-block alert-info\">\n",
    "    <h1>IBM Quantum Challenge Africa:</h1>\n",
    "        <h1>Quantum Chemistry for HIV</h1>\n",
    "</div>\n",
    "\n",
    "<img src=\"HIV-1_capsid_wikipedia.png\"/>\n",
    "\n",
    "<div align=center class=\"alert alert-block alert-info\">\n",
    "    <h1>Table of Contents</h1>\n",
    "</div>\n",
    "\n",
    "| Walk-through |\n",
    "|:-|\n",
    "|[Preface](#preface)|\n",
    "|[Introduction](#intro)|\n",
    "|[Step 1 : Defining the Molecular Geometry](#step_1)|\n",
    "|[Step 2 : Calculating the Qubit Hamiltonian](#step_2)|\n",
    "|[Step 2a: Constructing the Fermionic Hamiltonion](#step_3)|\n",
    "|[Step 2b: Getting Ready to Convert to a Qubit Hamiltonian](#step_2b)|\n",
    "|[Step 3 : Setting up the Variational Quantum Eigensolver (VQE)](#step_3)|\n",
    "|[Step 3a: The V in VQE (i.e. the Variational form, a Trial state)](#step_3a)|\n",
    "|[Step 3b: The Q in VQE: the Quantum environment](#step_3b)|\n",
    "|[Step 3c: Initializing VQE](#step_3c)|\n",
    "|[Step 4 : Solving for the Ground-state](#step_4)|\n",
    "||\n",
    "|[The HIV Challenge](#challenge)|\n",
    "|[1. Refining Step 1: Varying the Molecule](#refine_step_1)|\n",
    "|[2. Refining Step 2: Reducing the quantum workload](#refine_step_2)|\n",
    "|[3. Refining Step 4: Energy Surface](#refine_step_4)|\n",
    "|[4. Refining Step 3a](#refine_step_3a)|\n",
    "|Exercises|\n",
    "|[Exercise 3a: Molecular Definition of Macromolecule with Blocking Approach](#exercise_3a)|\n",
    "|[Exercise 3b: Classical-Quantum Treatment Conceptual Questions (Multiple-Choice)](#exercise_3b)|\n",
    "|[Exercise 3c: Energy Landscape, To bind or not to bind?](#exercise_3c)|\n",
    "|[Exercise 3d: The effect of more repetitions](#exercise_3d)|\n",
    "|[Exercise 3e: Open-ended: Find the best hardware_inspired_trial to minimize the Energy Error for the Macromolecule](#exercise_3e)|\n",
    "|[Quantum Chemistry Resources](#qresource)|\n",
    "\n",
    "<h2><a id='preface'>Preface</a></h2>\n",
    "\n",
    "\n",
    "**HIV is a virus that has presented an immense challenge for public health, globally**. The ensuing disease dynamics touch on multiple societal dimensions including nutrition, access to health, education and research funding. To compound the difficulties, the virus mutates rapidly with different strains having different geographic footprints. In particular, the HIV-1-C and HIV-2 strains predominate mostly in Africa. Due to disparities in funding, research for treatments of the African strains lags behind other programmes. African researchers are striving to address this imbalance and should consider adding the latest technologies such as quantum computing to their toolkits.\n",
    "\n",
    "**Quantum computing promises spectacular improvements in drug-design**. In particular, in order to design new anti-retrovirals it is important to perform **chemical simulations** to confirm that the anti-retroviral binds with the virus protein. Such simulations are notoriously hard and sometimes ineffective on classical supercomputers. Quantum computers promise more accurate simulations allowing for a better drug-design workflow.\n",
    "\n",
    "In detail: anti-retrovirals are drugs that bind with and block a virus protein, called protease, that cleaves virus polyproteins into smaller proteins, ready for packaging. The protease can be thought of as a chemical scissor. The anti-retroviral can be thought of as a sticky obstacle that disrupts the ability of the scissor to cut. With the protease blocked, the virus cannot make more copies of itself.\n",
    "\n",
    "Mutations in the viral protease changes the binding propensity of a given anti-retroviral. Hence, when a mutation occurs and an anti-retroviral no longer binds well, the goal becomes to adjust the anti-retroviral molecule to again bind strongly.\n",
    "\n",
    "**The main goal of this challenge is to explore whether a toy anti-retroviral molecule binds with a toy virus protease.**\n",
    "\n",
    "Along the way, this challenge introduces **state-of-the-art hybrid classical-quantum embedded chemistry modelling** allowing the splitting of the work-load between classical approximations and more accurate quantum calculations.\n",
    "\n",
    "Finally, you need to tweak the setup of the quantum chemistry algorithm (without having to understand the nuts and bolts of quantum computing) to achieve the best performance for ideal quantum computing conditions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*A video explaining how HIV infects and how anti-retroviral treatment works*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEABALDBoYFhsaGBoeHRofICUlIh8fHyUnJSUlLicxMC0nLS01PVBCNThLOS0tRWFFS1NWW1xbMkFlbWRYbFBZW1cBERISGRYYLxsZLWE2LTZaV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV//AABEIAWgB4AMBIgACEQEDEQH/xAAbAAEAAwEBAQEAAAAAAAAAAAAAAQIDBgQFB//EAEAQAAICAQEGAgUKAwgDAQEAAAABAhEDBAUSEyExYUFRBiJxgZEWMkJTkqGxwdHSFFLwByMzYnKC4fFDorKTJP/EABkBAQEAAwEAAAAAAAAAAAAAAAABAgMEBf/EACURAQACAgICAwADAAMAAAAAAAABAgMREiExUQQTQSIyYRRxgf/aAAwDAQACEQMRAD8A/PwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAacF9hwn2DLhb0zBpwn2HBfYHC3pmDTgvsOC+wOFvTMGnBfYcF9gcLemYNOC+w4L7A4W9MwacF9hwX2Bwt6Zg04L7DgvsDhb0zBpwX2HBfYHC3pmDTgvsOC+wOFvTMGnBfYcF9ho4W9MwacF9hwX2Gjhb0zBpwX2HBfYHC3pmDTgvsOC+w0cLemYNOC+w4L7DRwt6Zg04L7DgvsNHC3pmDTgvsOC+wOFvTMGnBfYcF9gcLemYNOC+w4L7A4W9MwacF9hwX2Bwt6Zg04L7DgvsDhb0zBpwX2HBfYHC3pmDTgvsOC+wOFvTMGnBfYcF9gcLemYNOC+w4L7A4W9MwacF9hwX2Bwt6Zg04L7DgvsDhb0zBpwX2HBfYHC3pmDThPsOC+wOFvTMGnBfYcF9gcLemYNOE+w4T7A4W9NqFFhRk61aJJAEAlIlgVoUWSFA0rRJNEpAUomi1WAK0KJomiioLNACtCi1chRBUF37CGBUUX3SEiqrQou0HEgrRBZItu9CozJLfeRRBWhReg4gUJondJKKUSXSIaArQomgwqoLNBRCKii7XkQBWhRegkRVBRdoigiootQoCtAtXkEgqtEFqJcQigou0QBUF6IAqGi7RUCpNE0AIBNCgLOIouiUveFU3Q4ln4E14AVrzISLxj5Ddf/AFGunkWos0RuAVURRfd8Akq7FFOgovQceZBXwG6Xolx8UEZ7toJGiuiFFV4BVEuQ6sv2JoCjiKsvuj3BFKFfEtGP3ktBVIrn+oovRCQFWq/QlLkW3TfHpZSU+T34pPcp20/LkSZiPKTOnlSG6e7LoZRlVNJR3nKUWl0uvyPI4ckItE+CJ2ovgdNsrR4c2k3d1b3NSdespXyd+yjnEj27M10tPk3usH85dvNdytWak2r/Hy8r0uR5eFuviJ1S/rofV1ew44tM5ym+JFW19G/JH3tVnhhi8sl4JWlzfkjldo7QnqJc+UE/Vj5d35srTTJkyzGuojy8G78RXLmaOPcU6I7Gajy5BRNEiFECjgRSNKRDgEUcRu8zUigrPqKLpfeSo+QGbXMhmiiFEChCX/AEa0Ru2wMkid0vQf3AUoUXoJeAFKFF93yYqu4FFHsGveSkEvYBG6RRehu9gMxul1VhxZRSuZNFmiEgNKFF6JogzJosS/vCM6LNdi7iR0Cq126Bry5e8tu8yd3kEUoJWXSJUQM1Emi4cQKJBItuss4gUcf6obpNFkgKNDcNEhRFZqJNf1RYUVF9NpJZZqEFcuvsRbV6KeGW7Nexro/eTpNRLDkU49eleDT8DpcOfDqobr5+cJdV/Xmg58uS2Od63Vz+yNHxctSVwj60vyR6dv6fFjlDhxUZNO0uSrwZ9rDp8emxyq1FW227fI5jWah5skpvx6LyXggwx3nLk5R/WEaLS8ScY7rak6tfRfW/8Ag7PS6SOOKS60lb6ul1bOc2DjfGUlJUrTirvpydJVXdnVbjdc66f9HB8jle8VqyzW7Vnji000mn1T5r4HwNfsXLPJGGFLhJNpXSi/L3nSqKu659C5lh+Pek7mWmMvGenK4vRTK/nZIR9ib/Q1+Sdc+P4rlw+q8vnHSg7T7r+3xdr6DJnxbuOr3k2m65HK6rR5MTrJBw7tUn7H0Z+iUVnjUk4ySkn4NWgmHJOOOL83omvedPtP0bXz9Py88bf/AMv8jnZxatNU+jTXO/IO2t4tHTLdFFwohmooiviXaDQFGiKNKIqgM2KNehDQGaRP3l6Cj8AKNCvaXoNAZxXuI3S9dCaAz9wS8/YXcehK6AZpEJGnMndAyoKNF3yJqgM2u/IV3LqI3QIZSi+7zISCqvsQ0XrqKA0aCLbpO7zCKV/0PcXa95Ph+YFEvgKL0KArQot07k0BVLyFFqJrkQZpE7pdIUBfSYVPLCMuUW0mfR2vs2GOMZY01zp87XYpsvTz34Txyj4qXO91d0dMsafU58vyIpOv1zZLTF4mJ6cTlwbsYN/SjfSq5tfkX1GneOe62m6vkdnPDGSppNeTSZ4Z7HxSy77vn9G+V+f/AAasfy4mdWhlGaP1zGHTznyhGUn5RVnqhsTVP/wuu8or8ztMeKMIqMEkl4JJIsdzXPyJ/IcY9g6r6r/3h+pR7F1S/wDDL4x/U7YBP+RZxK2NqfqZV/t/UvDYeqtNYmu7nBNfedmAf8iz5f8ADylh4eTlJw3Zc751VmOk9G8MKeRyyPy+bH4I+tPFbuy6Dnra1ZnX6rixRhHdhFRXklSLNEo0jiYPLKiTdYkWUUvAGmEcbZaWLyNyCLp5QTLq6IKgfK21shZ1vwVZUvtdn37n1QFraazuH564U2mqa5NP8CGdN6Q7M3k80FzS9dJdV/N7jnKD0KXi8bhSg0Xond8gzZpcugovuigKURXiXSJoDOid3kWoJAUUSKfijShQFKDX/ZdIhgUoijSiHECtCuZahugZ0TXMu0GgM90j8TSiKArREVSoukAM2hRegBcJFq5ksCiRaiUiaAqKLUTQFUC1CgIoUWSAFaPobIyYoylxKTdbra5dzwgMb15Rp1ullCfODTV1aPTJpfgfH2Jq3Jzi0k7tUqR9jcUuqtJ2eTkpNs3Gf1xzXh0nhu+xqkvAiud3yrp4ExPQxYK0j/Wq1tpBINyIAAAAAAABeGSvAtxuxkANeN2HG7GQC7aPMyrm2VAQAAAAADk9s7P4E7iv7ub9Xs/GJ1hjrMEcmKUZK12634NBsxX4WcdptLLLLdi1dXzdG2z9HxMu7K6j873eBpDZeVZlFpxp3v8AkvP2nRQx/wDfmceb5HCeu3Ve/XT42r2Q5yuDjFV05/kjPXbNyOUXFRaUYx5Py6ujoVGPjYlGL6WckfIv59NUZJhyOrxQjPdhdqk137GM8bi2pJprwZ1Gq0qk1NJcSPzW+l+F+Zz2THlyOc5Jvd+c328EduHPzhupfbytCiwOptVBYAVogsSBTdIovQaApRFGjQSAzoNci9CgKUQ0XoSQFKIovQrzAoiGi9EU/eBokKJJIIBIKISJAIAoAAAAAAKr04M+T1McHXrcqXNvv5nX4I1FX1Zz3o5g3sryfyLl7Xy/CzpTDhG+Tiz270il5EgGbnCSAAAAAAAAAAAAAAAAAAAAAgkgAASBnmg20/IobmbjdvxtnF8j4/L+dfLKLfjBylvpKFx8ZWatFISdu1XPkN6TlbPPtO+vTbFeiXQ+BtmMll5OW7JdFdX48joH0Ph7Z1MoTiozapW6ffkbvj7+3pli8vkNEFpSbbbdtu2yp6zrAAVQAMAQSAIBIAgEgBRFE2CCKIaLEAVaFFgVEoBAgAElVBJAAkgEkAAtirejvfNtX7Akqg+3tDQweJyxxScVa3VVo+GVrxZIyRuHT+jmKtO5fzyb9y5fqfVPLsuG7p8S/wAqfx5nqDiyTu0hJADBIIAAAAABYAFJ5EvEyepXkxuGUVmfEN7I3jKOVPx+JciTEx5TYBBWKSAAJJTKgirpgpZeLKBIZAEkNPqiQBSSvworKDRqDRlwVv8A5KxOnkzZFFNt0lzbOeltNvJKUopxvly5pH39oYHwpuPNrm4tWnFdY/A5bUSg5vhpqPKk2acPx+E/y/XVh1ZkyCQdjqQCQUQSABBJBIEAAAAAAAIBBIAgEkASASUQCQREEkElUABECCToMOXTwinFwXL3/qVqy5OEeNp2Y5cFKcWq5K/FHytbs7JBycY3HnTXOvae3U7YirWNW/5pLl8DbZuveaW5uNSq7XSkVyV+2kzkivU/j7WOO7FR8kl8EWM8KaXM0I1b32AAACCQoCGzLLlr2hYiZ8LzmkuZ5552+nIylJvmyDCZb644jyAkGLaF8WSnT6FCAkxuNS9oKw6L2FjY458gACAAABABWhAiSUAQAJAAD2nEZ8e5knHyk18GducttLSZJanLuQk1vXftSDo+PaImYl4MOKU5KMer/qz6Wr2bDHhck3vRXW+TflR6tmaN4otyVTl9y8j5e0dW8k6XzItpL8ws5LZMnGk9Q8gADrAAQCCQUQSQSFQAAAAAAAACCSAACgACCQQSVAEEkUABUDptgaTcxb7VSn8d3w/U+Hs3S8bNGH0esv8ASup2NeXJeAc+e/XEAAcYQSABBJllnSBHfSubLXJdTy2S2Qa5nbrrWKwAkEZAAAF8WO32LY8V830N0qVIyiGq+TXUJIAM3MAHx9oekmDBNwqWSS+duVS7W3zYZVrNvD7AK45qUVJdGk17GWIgAALRJM8mTcxzlV7sZSrzpN/kcxs/0uk51qIRUH9KCdx9q8UVnWlrRuHWAiLTSadpq010aJDAAAFZK1R8jW7Qhim4STclXTuj7Jye23//AFZP9q/9UGePHXJbUvXh2xGUqlHcXnd/E21Ogx5VvLlJ/Sj4+3zOfNsOqyY/mSa7dUNt9vjaneOdSrqMLxzcHza8UZkyk5Ntu2+rII6Y3rvyAAKAAqgAIgCAAABVCSAAADICFhgIAEFVYEAiBJBrg088jqCuupSZiI3LMgtODi3GSprqi+mwPJkhBfSaX6v4A3Gtui9H9JuYuI/nZOf+1dP1PqlYRUUox5JJJLsiwebe3K2wABiAACGePNK37D05HSfsPEY2bsUd7CSAYN6SCSABrhx3zfQzSt0eyMaSRlWGvJbUAPZs/DGblvK1yPTPZ0H0bX3mTnisy+UUz5444SnOSjGKttn03szyn/6nn1/o/HUYZ4p5GlKuaXNNO0/igsVnfbi9s+k/Ei8enuKdqU2qdeUV4e0+XsPY89ZmWKFqK5znXKMf1Oqwf2eRUv7zUuUfKOPdb97kzrNnbNw6XGseGCjHx82/NvxZHXFq0jVHyIwUUopUoqq8q5Es31sd3LJe8wK4p8gBIR9DZmH1XJ+PJHAelvo9LSZZZccb083aa+hJ/RfbyZ+l6aG7CK7ItkxxlFxlFSi1TTSaa8miOnHbg/JtkekGXTLcpTx/yt017H4ew7XQa2OoxRywupeD6prk0aar0K0WRtxhLG/KEml8DXFs1abGscI1CPSufvZTNNbdxHYACucON2jk3s+WX+d/dy/I6/PlUISm+kYt/BHD3fN9XzDp+NHcyBgEdYQSCqgEkAAABJABEAAFBQIKJoAgCQCCCETZWxYRawVTFgXBTeJsCx7Nmavh5OfzZUn28meJc2kurPp6fY0n/iNRXkubK15bUiurz5ejbOmuKyLquT7rzI9G9PeSWR/RVL2v/j8T3ZMuPGlGcklVetzv2m+kUca9RJRk75dG/MOGuaa04zH/AE9wIT5WSGIAAIJIJAw1D9VnlPVqPm+88xhZ0YvAADFtCCSANcC9b2Hpsw066mxnHhy5J3Z9LZXSftR7z5ezJ1NrzX4H1Ayr4Dnds+mGn0uR4kpZci+coVUezb8T6O39c9Po82WPzox9X/U+S+9n49Yb8dOXl+q7E9K9PrJ8NKWPL4RnXrf6Wup90/D8WRwlGcXUotOL8mnaZ+zbM1XH0+LL/PCMvigZKcfD5O2H/fv2I8kMjXsNtfk38033r4cjzmJERrt7IytWSzzYJU68GelmcS5b14y+/DovYixhpJ72OL7UbkbIefW6zHgxyy5ZKMI9Wzlpf2g6ffpYMrh/N6t/Zv8AM+b/AGia6Us+PTp+pCCm15yk2l8EvvOPK6KYomNy/YtHk0+qxrLidxl4rk78U14MnNoYqLak+SOF/s/10oat4b9TLB8v80eafwtH6FrZ1jffkGnJSKy5X0gz7uDdXWbr3Lm/y+Jy59b0jyN51HwjFV7+v5HySt+GNUSCAG5JAAAAAAAQQALAkEWRYEhkWN4CRZWxZUSwyu8RZBWyWyrYZRa6JKWG+fIDSyLKt2GwNIZN1prqmme/JtnLJUt2PdLn958xslSDC1K2/tDSeRttybb827Z22hxpYca8oR/A4Vs7vQy3sON+cI/gGn5H9YbgAORAJAAAgDPIrTPGe5o8mSNSaMLN2GfxQkAxbwAAb4OnvNTPB833mhsjw5L/ANpWxzcZKS8D7mLIpRTXRnwT0aXVPG/OL6oFZ0v6U6R5tBnhFXLd3kvNxd19x+Rn7bizxmri/d4nI7a9BVkyPJpZxx73N453u2+rTV17KDrxXiOpcAk/Dmz9a016TQYcb+fHHGPvrmz4OyPRbHpJrNqZxy5Ic444fNUl4tvqe3U6iWSTlL3LyRJlb2i89MiQDBBM9l2eI9mP5q9hlVpzfj6Ozs1Pdfj09p9E+Ej6Gm1qqp8n5mTCtvxwn9oemlHWQyV6mTGlf+aLdr4Ucqfse1tl4tZheLJ06xkusZeaOLn/AGf51P8Ax8XD/malvV/p6feHXjyREal5PQLTOevU0vVxwlJvu+SX3v4Hd67NvSpdF+J49m6PFosPCwW23c8j6yZYObNk5T05z0mw1khPwkmr7r/hnxUzrdsYOLhlBfPTTj7V4HOR2XmclFxq/pN8kVtw5a8dTPh5Q+XXkzosWnw6eO86XnKXX3Hxtp6uObJcFSSq31fMMsefnbVY69vM2LKWN4N61jeKWEwLbwsq2LAtYspfwAFrFlLAFkwmVvyIsCwsqEBNiytkKQFULKqYTILWTZTe8wUaJjeKCwLqRN+Bnvf1ZLl7ALqR1/o1qVPTbvjjbXu6p/15HHJn0NibQ4GdN/4c/Vlz5LyfuYa8teVXbgAPPAABAJAEM8+ojyvyPSyjQlazxnbxAtkhuuipqdcTvsAJxwtgmdN8C9X3mgBsckzudgQAYhbffm/iyockupVUzOonmLZMm8UNcy6cdeMdpIInNRi5SdJK2+xx20dp5dVPdhvKH0YRu2vNpdWIhuiu3Yxkn0afsZ74LwPzjg6jT7uTcyY+fKW61z8v+Dvdka1ajTxy8rfKSXhJdf67mURpqz11G48PaQSDJyibXRslu+pAAAEgZTwpnxcO1IyzPFJbrTaTvk2n0PuZcihFyk6jFNt9kfn2XO5Tc+jcpP2c7DZiw1vvb7W3tNK1lTbglTXl3Pio+7o9swljrPyklz5WpI+BOSttKk26XbwQdGDlEcLR4WTFlN4Jh0LWCjlzFgXvkRfIrYTAvJ+ZDl5FL5hsC9kN/oVbIflYF2QmVsX/AF4gWsjeKpksCzZCkV8CN4Cm8TZTeJcgq1/AlspvDe5gWT7FrM7tewMI0T8g5Gbdk9egGkehFlLQcu4HXeje1d6KwZH6yXqN+K/l9qOgPzGORppxtNNNNeDXijvdl67Jkwxllhuz/wDr/NXgHHnpFf5PogIBzgIJAENEgDOcLR5pYmvCz2EUSY2zreavJHE32PRCKiqRZogRGi15sAANYAAIbrmeWcm3bPVJWqPLKLT5ks34tf8AqpICTfQwb3zPSBTemkoJybcU1FW6v/o02Bsrg4k5Kskucn4ryifVx4PGRukZxDXbNqNVeXX6RZcGTEl86LS9vh95870QwTx6fIpxlG8rpSVP5qT/AK7H3kgZNMXnjMewABgAAAAfK2/tX+HxpQf97P5q8l4yCxE2nUPl+k+1d6XAxvlF+u/Nr6Pu8Tn22Ucn1vuLD0aVisahZsOX4Fd7xfiRf4hk0UiN4zbJteBBe/67EKRXesKRRfeIUr5FN6uQsC/gJMrveQcgLN2yE/Ir5FU/ADXrzIszTJ3uQVdukQ37io3mBZtkWVshMIq2E/MrYQVZEtlLFlFxZRsNkGl+8grYTAv7Dp9JtPRxxRjUYtJWnjvn4865nKpkBryY4vGpl3Glhpcz38ccUpRrmoq0/A+Ztjbkoyliw3FxdOfjfZfmb+i+HdwSm/pyv3Ll+pzWszb+Wc/5pN+6yuTFiicsxPcQ7bYW3I6hbmSo5l4dFNV1j+h9g/LIZHGSlFtNO011TO89Htr/AMVjqX+NCt7/ADLwkvzIyzYtdx4fXAAc4AAAAAEUSAK7pFFwBnQL0KAqVcU+qNKFAYrDEulXRF6BNLMzPlCRZIgFRIBFASAAAAAyzahQjJ03SbpK2+y7n55r9ZLNllkycpN9P5V4RXsOg13pJCGplBR3sUeTknz3vFrt4e49rhp5r+IcYP1b33Hw62Gyl7Yu7R5cYot9It+5srJ+R1EvSPTx5RWR+yKS+9nNazPxMs5pbqlK0iuvHe1p7rpVsje5Fd7kQRuXvoL6FFKhYFr+BL+JSyEwLthSKNkMqNPw7C7/AE8DOyQq1kWVsmwJJsomGyC1kp/ApYsosRZFkAQLIsWRjtNiyLAEk2VAFkwVsBdrJiypINvfg2tlx4Xhi1uO105pPrTPCytkhjERHhNnp2drZafNDLH6L5rzj4o8oCz3Hb9UwZo5IRnB3GSTT7Mucn6G7U66ab85Y/xcfz+J1gefevG2gABgAAAAADIJAAEEgQCQBBIAEAkAQSAAAAA+P6S7T/h9O1F/3mS4x80vGXuv7z7Fn536Q7R/idTKUX6kfVh7F1fvYbcVOVnzkdd6PZVl0m4/o3B+x9Px+45A30mvy4G3im42ufRph1ZsfOuo8qZsbhOUH1jJx+DopZEpuTbbttttvxb6sgNsf6tvC/IiyLAmw2RYsCbG8QQBYWQQBZsgiwBayGyAEWsWVANpFkAG0iyABAMeKxxX2Jtq+yGwMeK+xPFfYbPshqLMeK+w4r7DZ9kNrFmPFfYcV9htfshtYsx4r7DivsNn2Q2sWY8V9hxX2Gz7Ib2DDivsbaXWcOVvHjn2mm0vcmhtJyQvjyShJSi2pJ2mvBn6Ns3aTz4IZHFxlJc01XvXZnBvbr6fw2m//N/qbv0s1PKljjTT5RfPtzfQbc+WZv4jT9ETJOC+W2q+rw/Zn+4fLfVfV4fsz/cNtfCXeg4L5b6r6vB9mf7h8t9V9Xg+zP8AcXZxl3oOC+W+q+rwfZn+4fLfVfV4Psz/AHE2cZd6Dgvltqv5MP2Z/uHy21X8mH7M/wBw2cZd5RJwXy31X1eD7M/3D5b6r6vB9mf7hs4y70HBfLfVfV4Psz/cPlvqvq8H2Z/uGzjLvKFHB/LfVfV4Psz/AHD5b6r6vB9mf7hs4y7ygcGvTfVfV4Psz/cT8udT9Vg+zP8AcNnGXdknBv041P1WD7M/3Ffltqvq8P2Z/uGzjLviEzgpemuqarcw/Zn+4pH0y1Suo4l/tl+4bTjZ970r2zwoPT43/eTXrNfRi/D2v8DijKeplJuUncm7bfVsjivsNuuk1rGmxFmPFfYcV9htn9kNwYcV9hxX2Gz7Ibgw4r7DivsNn2Q3FmHFfYcV9hs+yGwMeK+w4r7A+yG4MOK+w4r7DZ9kNyDHivsOK+w2n2Q2BjxX2HFfYbPshsGY8V9hxX2Gz7IakmPEfYcV9hs+yGwMeK+w4r7DZ9kKAAjQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/Z\n",
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"400\"\n",
       "            height=\"300\"\n",
       "            src=\"https://www.youtube.com/embed/cSNaBui2IM8\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x7f0374580df0>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import display, YouTubeVideo\n",
    "YouTubeVideo('cSNaBui2IM8')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=center class=\"alert alert-block alert-success\">\n",
    "    <h1>Walk-through: Calculating the Ground-state Energy for the Simplest Molecule in the Universe</h1>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Import relevant packages*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.8/site-packages/pyscf/lib/misc.py:47: H5pyDeprecationWarning: Using default_file_mode other than 'r' is deprecated. Pass the mode to h5py.File() instead.\n",
      "  h5py.get_config().default_file_mode = 'a'\n"
     ]
    }
   ],
   "source": [
    "from qiskit import Aer\n",
    "\n",
    "from qiskit_nature.drivers import PySCFDriver, UnitsType, Molecule\n",
    "from qiskit_nature.problems.second_quantization.electronic import ElectronicStructureProblem\n",
    "from qiskit_nature.mappers.second_quantization import JordanWignerMapper, BravyiKitaevMapper\n",
    "from qiskit_nature.converters.second_quantization import QubitConverter\n",
    "\n",
    "from qiskit_nature.transformers import ActiveSpaceTransformer\n",
    "from qiskit_nature.algorithms import GroundStateEigensolver, BOPESSampler\n",
    "from qiskit.algorithms import NumPyMinimumEigensolver\n",
    "\n",
    "from qiskit.utils import QuantumInstance\n",
    "\n",
    "from qiskit_nature.circuit.library.ansatzes import UCCSD\n",
    "from qiskit_nature.circuit.library.initial_states import HartreeFock\n",
    "from qiskit.circuit.library import TwoLocal\n",
    "\n",
    "from qiskit.algorithms import VQE\n",
    "from qiskit.algorithms.optimizers import COBYLA\n",
    "\n",
    "from functools import partial as apply_variation_to_atom_pair\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id='intro'>Introduction</a></h2>\n",
    "\n",
    "In the HIV Challenge, we are tasked with investigating whether the toy anti-retroviral molecule binds with and therefore, disrupts the toy protease molecule. Successful binding is determined by a lower total ground-state energy for the molecules when they are close together (forming a single macromolecule) compared to far apart.\n",
    "\n",
    "Total ground-state energy refers to the sum of the energies concerning the arrangement of the electrons and the nuclei. The nuclear energy is easy to calculate classically. It is the energy of the electron distribution (i.e. molecular spin-orbital occupation) that is extremely difficult and requires a quantum computer.\n",
    "\n",
    "We start with a walk-through tutorial, where we calculate the ground-state energy of a simple molecule and leave the more complicated set-up to the challenge section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ground-state of a molecule in some configuration consists of the locations of the nuclei, together with some distribution of electrons around the nuclei. The nucleus-nucleus, nuclei-electron and electron-electron forces/energy of attraction and repulsion are captured in a matrix called the **Hamiltonian**. Since the nuclei are relatively massive compared to the electrons, they move at a slower time-scale than the electrons. This allows us to split the calculation into two parts: placing the nuclei and calculating the electron distribution, followed by moving the nuclei and recalculating the electron distribution until a minimum total energy distribution is reached:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Algorithm: Find_total_ground_state</b>\n",
    "\n",
    "Place nuclei\n",
    "    \n",
    "Repeat until grid completed or no change in total_energy:\n",
    "    \n",
    "  - calculate electronic ground-state\n",
    "    \n",
    "  - total_energy = (nuclei repulsion + electronic energy)\n",
    "    \n",
    "  - move nuclei (either in grid or following gradient)\n",
    "\n",
    "return total_energy\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the walk-through, we simply fix the nuclei positions; however, later, in the challenge section, we allow for a varying one-dimensional intermolecular distance between the anti-retroviral and the protease molecules, which represents the anti-retroviral approaching the protease molecule in an attempt to bind."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id='step_1'>Step 1: Defining the Molecular Geometry</a></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this walk-through, we work with the simplest non-trivial molecule possible: H$_2$, the hydrogen gas molecule.\n",
    "\n",
    "<img src=\"h2.png\"/>\n",
    "\n",
    "*The first thing to do is to fix the location of each nucleus. This is specified as a python list of nuclei, where each nucleus (as a list) contains a string corresponding to the atomic species and its 3D co-ordinates (as another list). We also specify the overall charge, which tells Qiskit to automatically calculate the number of needed electrons to produce that charge:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "hydrogen_molecule = Molecule(geometry=\n",
    "                             [['H', [0., 0., 0.]],\n",
    "                              ['H', [0., 0., 0.735]]],\n",
    "                     charge=0, multiplicity=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id='step_2'>Step 2: Calculating the Qubit Hamiltonian</a></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once nuclei positions are fixed (the nucleus-nucleus forces are temporarily irrelevant), the only part of the Hamiltonian that then needs to be calculated on the quantum computer is the detailed electron-electron interaction. The nuclei-electron and a rough mean field electron-electron interaction can be pre-computed as *allowed molecular orbitals* on a classical computer via the, so called, Hartree-Fock approximation. With these allowed molecular orbitals and their pre-calculated overlaps, Qiskit automatically produces an interacting electron-electron **fermionic molecular-orbital Hamiltonian** (called Second Quantization). The molecular orbital and overlap pre-calculation are provided by classical packages, e.g. PySCF, and connected to Qiskit via a so-called *driver*, in particular, we use the PySCFDriver."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><a id='step_3'>Step 2a: Constructing the Fermionic Hamiltonion</a></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*We specify the driver to the classical software package that is to be used to calculate the resulting orbitals of the provided molecule after taking into account the nuclei-electron and mean-field interactions. The `basis` option selects the basis set in which the molecular orbitals are to be expanded in. `sto3g` is the smallest available basis set:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "molecular_hydrogen_orbital_maker = PySCFDriver(molecule=hydrogen_molecule, unit=UnitsType.ANGSTROM, basis='sto3g')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Qiskit provides a helpful Class named the ElectronicStructureProblem, which calls the driver in the right way to construct the molecular orbitals. We initialise ElectronicStructureProblem with the driver (which already has the molecular information stored in it from the previous step):*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "hydrogen_fermionic_hamiltonian = ElectronicStructureProblem(molecular_hydrogen_orbital_maker)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Here, we instruct the ElectronicStructureProblem object to go ahead and create the fermionic molecular-orbital Hamiltonian (which gets stored internally):*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Completed running classical package.\n",
      "Fermionic molecular-orbital Hamiltonian calculated and stored internally.\n",
      "An example of HF info available: Orbital Energies [-0.58062892  0.67633625]\n"
     ]
    }
   ],
   "source": [
    "hydrogen_fermionic_hamiltonian.second_q_ops()\n",
    "print(\"Completed running classical package.\\nFermionic molecular-orbital Hamiltonian calculated and stored internally.\")\n",
    "print(\"An example of HF info available: Orbital Energies\", hydrogen_fermionic_hamiltonian._molecule_data_transformed.orbital_energies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(If this step is not run explicitly, and its outputs are not used in an intermediary step, the final ground_state solving step would run it automatically.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><a id='step_2b'>Step 2b: Getting Ready to Convert to a Qubit Hamiltonian</a></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, *fermionic* is a term to describe the behaviour of electrons (having an anti-symmetric wave-function obeying the Pauli Exclusion principle). In order to use the quantum computer we need to map the electrons (which exhibit fermionic behavior) to the quantum computer's qubits (which have closely related spin behaviour: Pauli Exclusion but not necessarily anti-symmetric). This mapping is a generic process, independent of the driver above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are multiple mapping methods available, each with pros and cons, and constitutes something to experiment with."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*For now, we select the simplest qubit mapper/converter called the Jordan-Wigner Mapper:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "map_fermions_to_qubits = QubitConverter(JordanWignerMapper())\n",
    "# e.g. alternative:\n",
    "# map_fermions_to_qubits = QubitConverter(BravyiKitaevMapper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Note, we have just chosen the mapper above, it has not yet been applied to the fermionic Hamiltonian.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id='step_3'>Step 3: Setting up the Variational Quantum Eigensolver (VQE)</a></h2>\n",
    "\n",
    "Now that we have defined the molecule and its mapping onto a quantum computer, we need to select an algorithm to solve for the ground state. There are two well-known approaches: Quantum Phase Estimation (QPE) and VQE. The first requires fault-tolerant quantum computers that have not yet been built. The second is suitable for current day, noisy **depth**-restricted quantum computers, because it is a hybrid quantum-classical method with short-depth quantum circuits. By *depth* of the circuit, it suffices to know that quantum computers can only be run for a short while, before noise completely scrambles the results.\n",
    "\n",
    "Therefore, for now, we only explore the VQE method. Furthermore, VQE offers many opportunities to tweak its configuration; thus, as an end-user you gain experience in quantum black-box tweaking.\n",
    "\n",
    "<img src=\"vqe_method_NB.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "VQE is an algorithm for finding the ground-state of a molecule (or any Hamiltonian in general). It is a hybrid quantum-classical algorithm, which means that the algorithm consists of two interacting stages, a quantum stage and a classical stage. \n",
    "\n",
    "During the quantum stage, a trial molecular state is created on the quantum computer. The trial state is specified by a collection of **parameters** which are provided and adjusted by the classical stage. After the trial state is created, its energy is calculated on the quantum computer (by a few rounds of quantum-classical measurements). The result is finally available classically. \n",
    "\n",
    "At this stage, a classical optimization algorithm looks at the previous energy levels and the new energy level and decides how to adjust the trial state parameters. This process repeats until the energy essentially stops decreasing. The output of the whole algorithm is the final set of parameters that produced the winning approximation to the ground-state and its energy level."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><a id='step_3a'>Step 3a: The V in VQE (i.e. the Variational form, a Trial state)</a></h3>\n",
    "\n",
    "VQE works by 'searching' for the electron orbital occupation distribution with the lowest energy, called the ground-state. The quantum computer is repeatedly used to calculate the energy of the search trial state.\n",
    "\n",
    "The trial state is specified by a collection of (randomly initialized) parameters that move the state around, in our search for the ground-state (we're minimizing the energy cost-function). The form of the 'movement' is something that can be tweaked (i.e., the definition of the structure of the *ansatz*/trial). There are two broad approaches we could follow. The first, let's call it *Chemistry-Inspired Trial-states*, is to use domain knowledge of what we expect the ground-state to look like from a chemistry point of view and build that into our trial state. The second, let's call it *Hardware-Inspired Trial-states*, is to simply try and create trial states that have as wide a reach as possible while taking into account the architecure of the available quantum computers.\n",
    "\n",
    "#### *Chemistry-Inspired Trial-states*\n",
    "\n",
    "Since chemistry gives us domain-specific prior information (e.g., the number of orbitals and electrons and the actual Hartree-Fock approximation), it makes sense to guide the trial state by baking this knowledge into the form of the trial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*From the HF approximation we get the number of orbitals and from that we can calculate the number of spin orbitals:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "hydrogen_molecule_info          = hydrogen_fermionic_hamiltonian.molecule_data_transformed\n",
    "num_hydrogen_molecular_orbitals = hydrogen_molecule_info.num_molecular_orbitals\n",
    "num_hydrogen_spin_orbitals      = 2 * num_hydrogen_molecular_orbitals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Furthermore, we can also extract the number of electrons (spin up and spin down):*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_hydrogen_electrons_spin_up_spin_down = (hydrogen_molecule_info.num_alpha, hydrogen_molecule_info.num_beta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*With the number of spin orbitals, the number of electrons able to fill them and the mapping from fermions to qubits, we can construct an initial quantum computing state for our trial state:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "hydrogen_initial_state = HartreeFock(num_hydrogen_spin_orbitals,\n",
    "                                     num_hydrogen_electrons_spin_up_spin_down,\n",
    "                                     map_fermions_to_qubits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Finally, Qiskit provides a Class (Unitary Coupled Cluster Single and Double excitations, `UCCSD`) that takes the above information and creates a parameterised state inspired by the HF approximation, that can be iteratively adjusted in our attempt to find the ground-state:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "hydrogen_chemistry_inspired_trial = UCCSD(map_fermions_to_qubits,\n",
    "                                          num_hydrogen_electrons_spin_up_spin_down,\n",
    "                                          num_hydrogen_spin_orbitals,\n",
    "                                          initial_state=hydrogen_initial_state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *Hardware-Inspired Trial-states*\n",
    "\n",
    "The problem with the above \"chemistry-inspired\" trial-states, is that they are quite deep, quickly using up the available depth of current-day quantum computers. A potential solution is to forgo this chemistry knowledge and try to represent arbitrary states with trial states that are easy to prepare and parametrically \"move\" around on current hardware. There are two quantum operations that can be used to try and reach arbitrary states: mixing (our term for *conditional sub-space rotation*) and rotating (*unconditional rotation*). Detailed knowledge of how these operations and their sub-options work are not really needed, especially because it is not immediately obvious which settings produce the best results.\n",
    "\n",
    "##### Mixing (also called Entanglement maps)\n",
    "\n",
    "There are a set of available mixing strategies, that you may experiment with. This is specified with two arguments, *`entanglement`* (choosing what to mix) and *`entanglement_blocks`* (choosing how to mix):\n",
    "\n",
    "Possible *`entanglement`* values: `'linear'`, `'full'`, `'circular'`, `'sca'`\n",
    "\n",
    "Possible *`entanglement_blocks`* values: `'cz'`, `'cx'`\n",
    "\n",
    "For our purposes, it is acceptable to simply choose the first option for each setting.\n",
    "  \n",
    "##### Rotation\n",
    "\n",
    "There are a set of available *parameterized* rotation strategies. The rotation strategies are specified as a single argument, *`rotation_blocks`*, in the form of a list of any combination of the following possibilities:\n",
    "\n",
    "Possible *`rotation_blocks`*: `'ry'`, `'rx'`,`'rz'`,`'h'`, ...\n",
    "\n",
    "Typically, this is the only place that parameters are introduced in the trial state. One parameter is introduced for every rotation, corresponding to the angle of rotation around the associated axis. (Note, `'h'` does not have any parameters and so can not be selected alone.)\n",
    "\n",
    "Again, for our purposes, an acceptable choice is the first option alone in the list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Qiskit provides a Class called `TwoLocal` for creating random trial states by local operations only. The number of **rounds** of the local operations is specified by the argument `reps`:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "hardware_inspired_trial = TwoLocal(rotation_blocks = ['ry'], entanglement_blocks = 'cz',\n",
    "                                   entanglement='linear', reps=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Note, this trial state does not depend on the molecule.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Just for convenience, let's choose between the two approaches by assiging the choice to a variable:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "hydrogen_trial_state = hydrogen_chemistry_inspired_trial\n",
    "# OR\n",
    "# hydrogen_trial_state = hardware_inspired_trial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><a id='step_3b'>Step 3b: The Q in VQE: the Quantum environment</a></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since VQE runs on a quantum computer, it needs information about this stage. For testing purposes, this can even be a simulation, both in the form of noise-free or noisy simulations. Ultimately, we would want to run VQE an actual (albeit noisy) quantum hardware and hopefully, in the not-too-distant future, achieve results unattainable classically. For this challenge, let us pursue noise-free simulation only."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Noise-Free Simulation\n",
    "\n",
    "*To set up a noise-free simulation:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "noise_free_quantum_environment = QuantumInstance(Aer.get_backend('statevector_simulator'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><a id='step_3c'>Step 3c: Initializing VQE</a></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Qiskit Nature provides a class called VQE, that implements the VQE algorithm. *It is initialized in a generic way (without reference to the molecule or the Hamiltonian) and requires the two pieces of information from above: the trial state and the quantum environment:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "hydrogen_vqe_solver = VQE(ansatz=hydrogen_trial_state, quantum_instance=noise_free_quantum_environment)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Note, the vqe solver is only tailored to hydrogen if the trial state is the hydrogen_chemistry_inspired_trial.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id='step_4'>Step 4: Solving for the Ground-state</a></h4>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Qiskit Nature provides a class called GroundStateEigensolver to calculate the ground-state of a molecule.**\n",
    "\n",
    "This class first gets initialised with information that is independent of any molecule. It can then be applied to specific molecules using the same generic setup.\n",
    "\n",
    "To initialise a GroundStateEigensolver object, we need to provide the two generic algorithmic sub-components from above, the mapping method (Step 2b) and the solving method (Step 3). For testing purposes, an alternative to the VQE solver is a classical solver (see numpy_solver below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "hydrogen_ground_state = GroundStateEigensolver(map_fermions_to_qubits, hydrogen_vqe_solver)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are finally ready to solve for the ground-state energy of our molecule.\n",
    "\n",
    "We apply the GroundStateEigensolver to the fermionic Hamiltonian (Step 2a) which has encoded in it the molecule (Step 1). The already specified mapper and VQE solver is then automatically applied for us to produce the ground-state (approximation)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=== GROUND STATE ENERGY ===\n",
      " \n",
      "* Electronic ground state energy (Hartree): -1.857275030145\n",
      "  - computed part:      -1.857275030145\n",
      "~ Nuclear repulsion energy (Hartree): 0.719968994449\n",
      "> Total ground state energy (Hartree): -1.137306035696\n",
      " \n",
      "=== MEASURED OBSERVABLES ===\n",
      " \n",
      "  0:  # Particles: 2.000 S: 0.000 S^2: 0.000 M: -0.000\n",
      " \n",
      "=== DIPOLE MOMENTS ===\n",
      " \n",
      "~ Nuclear dipole moment (a.u.): [0.0  0.0  1.3889487]\n",
      " \n",
      "  0: \n",
      "  * Electronic dipole moment (a.u.): [0.0  0.0  1.38894841]\n",
      "    - computed part:      [0.0  0.0  1.38894841]\n",
      "  > Dipole moment (a.u.): [0.0  0.0  0.00000029]  Total: 0.00000029\n",
      "                 (debye): [0.0  0.0  0.00000074]  Total: 0.00000074\n",
      " \n"
     ]
    }
   ],
   "source": [
    "hydrogen_ground_state_info = hydrogen_ground_state.solve(hydrogen_fermionic_hamiltonian)\n",
    "\n",
    "print(hydrogen_ground_state_info)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, we have calculated the Ground-state energy of the electron distribution: -1.85 Hartree\n",
    "\n",
    "From the placement of the nuclei, we are also conveniently given the repulsion energy (a simple classical calculation).\n",
    "\n",
    "Finally, when it comes to the ground-state of the overall molecule it is the total ground state energy that we are trying to minimise.\n",
    "\n",
    "So the next step would be to move the nuclei and recalculate the **total ground state energy** in search of the stable nuclei positions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To end our discussion, let us compare the quantum-calculated energy to an accuracy-equivalent (but slower) classical calculation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ground-state electronic energy (via classical calculations):  -1.857275030145182 Hartree\n"
     ]
    }
   ],
   "source": [
    "#Alternative Step 3b\n",
    "numpy_solver = NumPyMinimumEigensolver()\n",
    "\n",
    "#Alternative Step 4\n",
    "ground_state_classical = GroundStateEigensolver(map_fermions_to_qubits, numpy_solver)\n",
    "hydrogen_ground_state_info_classical = ground_state_classical.solve(hydrogen_fermionic_hamiltonian)\n",
    "\n",
    "hydrogen_energy_classical = hydrogen_ground_state_info.computed_energies[0]\n",
    "print(\"Ground-state electronic energy (via classical calculations): \", hydrogen_energy_classical, \"Hartree\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The agreement to so many decimal places tells us that, for this particular Hamiltonian, the VQE process is accurately finding the lowest eigenvalue (and interestingly, the ansatz/trial does not fail to capture the ground-state, probably because it spans the entire Hilbert space). However, when comparing to nature or very accurate classical simulations of $H_2$, we find that the energy is only accurate to two decimal places, e.g. total energy VQE: -1.137 Hartree vs highly accurate classical simulation: -1.166 Hartree, which only agrees two decimal places. The reason for this is that in our above treatment there are sources of modelling error including: the placement of nuclei and a number of approximations that come with the Hartree-Fock expansion. For $H_2$ these can be addressed, but ultimately, in general, the more tricky of these sources can never be fully handled because finding the perfect ground-state is QMA-complete, i.e. the quantum version of NP-complete (i.e. 'unsolvable' for certain Hamiltonians). Then again, nature itself is not expected to be finding this perfect ground-state, so future experimention is needed to see how close a given quantum computing solution approximates nature's solution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=center class=\"alert alert-block alert-success\">\n",
    "<h1>Walk-through Finished</h1>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=center class=\"alert alert-block alert-success\">\n",
    "    <h1><a id='challenge'>The HIV Challenge</a></h1>\n",
    "</div>\n",
    "\n",
    "Now that we have completed the walk-through, we frame the challenge as the task to refine steps 1-4 while answering related questions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id='refine_step_1'>1. Refining Step 1: Varying the Molecule</a></h2>\n",
    "\n",
    "In Step 1, we defined our molecule. For the challenge, we need to firstly define a new molecule, corresponding to our toy protease molecule (the *scissor*) with an approaching toy anti-retroviral (the *blocker*), forming a *macromolecule*. Secondly, we need to instruct Qiskit to vary the approach distance. Let's learn how to do the second step with the familiar hydrogen molecule."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Here is how to specify the type of molecular variation we are interested in (namely, changing the approach distance in absolute steps)*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "molecular_variation = Molecule.absolute_stretching\n",
    "\n",
    "#Other types of molecular variation:\n",
    "#molecular_variation = Molecule.relative_stretching\n",
    "#molecular_variation = Molecule.absolute_bending\n",
    "#molecular_variation = Molecule.relative_bending"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Here is how we specify which atoms the variation applies to. The numbers refer to the index of the atom in the geometric definition list. The first atom of the specified atom_pair, is moved closer to the left-alone second atom:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "specific_molecular_variation = apply_variation_to_atom_pair(molecular_variation, atom_pair=(1, 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Finally, here is how we alter the original molecular definition that you have already seen in the walk-through:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "hydrogen_molecule_stretchable = Molecule(geometry=\n",
    "                                 [['H', [0., 0., 0.]],\n",
    "                                  ['H', [0., 0., 0.735]]],\n",
    "                                  charge=0, multiplicity=1,\n",
    "                                  degrees_of_freedom=[specific_molecular_variation])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we wanted to test that the variation is working, we could manually specify a given amount of variation (Qiskit calls it a *perturbation*) and then see what the new geometry is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "hydrogen_molecule_stretchable.perturbations = [0.1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(If the above were not specified, a perturbation of zero would be assumed, defaulting to the original geometry.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['H', [0.0, 0.0, 0.0]], ('H', [0.0, 0.0, 0.835])]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hydrogen_molecule_stretchable.geometry"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how only the second atom of our geometry list (index 1, specified first in the atom_pair) has moved closer to the other atom by the amount we specified. When it comes time to scanning across different approach distances this is very helpfully automated by Qiskit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Specifying the Protease+Anti-retroviral Macromolecule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Protease\n",
    "A real protease molecule is made up of two polypeptide chains of around one hundred amino-acids in each chain (the two chains are folded together), with neighbouring pairs connected by the so-called *peptide-bond*.\n",
    "\n",
    "<img src=\"peptide_bond_wikipedia.png\" title=\"Amino Acid bonding\"/>\n",
    "\n",
    "For our toy protease molecule, we have decided to take inspiration from this peptide bond since it is the basic building structure holding successive amino acids in proteins together. It is one of the most important factors in determining the chemistry of proteins, including protein folding in general and the HIV protease's cleaving ability, in particular.\n",
    "\n",
    "To simplify the calculations, let us choose to focus on the O=C-N part of molecule. We keep and also add enough hydrogen atoms to try and make the molecule as realistic as possible (indeed, HCONH$_2$, Formamide, is a stable molecule, which, incidentally, is an ionic solvent, so it does \"cut\" ionic bonds).\n",
    "\n",
    "Making O=C-N our toy protease molecule is an extreme simplification, but nevertheless biologically motivated.\n",
    "\n",
    "\n",
    "Here is our toy protease:\n",
    "\n",
    "<img width=50% src=\"protease.png\"/>\n",
    "\n",
    "```\n",
    "\"O\":  (1.1280, 0.2091, 0.0000)\n",
    "\"N\": (-1.1878, 0.1791, 0.0000)\n",
    "\"C\": (0.0598, -0.3882, 0.0000)\n",
    "\"H\": (-1.3085, 1.1864, 0.0001)\n",
    "\"H\": (-2.0305, -0.3861, -0.0001)\n",
    "\"H\": (-0.0014, -1.4883, -0.0001)\n",
    "```\n",
    "\n",
    "Just for fun, you may imagine that this molecule is a pair of scissors, ready to cut the HIV master protein (Gag-Pol polyprotein), in the process of making copies of the HI virus:\n",
    "\n",
    "<img width=30% src=\"carpet_scissors_wikipedia_cropped.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Anti-retroviral\n",
    "The anti-retroviral is a molecule that binds with the protease to **inhibit/block the cleaving mechanism**. For this challenge, we select a single carbon atom to be our stand-in for the anti-retroviral molecule.\n",
    "\n",
    "<img width=10% src=\"arv.png\"/>\n",
    "\n",
    "### Macromolecule\n",
    "Even though the two molecules are separate in our minds, when they approach, they form a single macro-molecule, with the outer-electrons forming molecular orbitals around all the atoms.\n",
    "\n",
    "As explained in the walk-through, the quantum electronic distribution is calculated for fixed atom positions, thus we have to separately place the atoms. For the first and second task, let us fix the protease's co-ordinates and only vary the anti-retroviral's position along a straight line.\n",
    "\n",
    "We arbitrarily select a line of approach passing through a given point and approaching the nitrogen atom. This \"blocking\" approach tries to obstruct the scissor from cutting. If it \"sticks\", it's working and successfully disrupts the duplication efforts of the HIV.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id='exercise_3a'>Exercise 3a: Molecular Definition of Macromolecule with Blocking Approach</a></h2>\n",
    "\n",
    "Construct the molecular definition and molecular variation to represent the anti-retroviral approaching the nitrogen atom, between the \"blades\":\n",
    "<img width=50% src=\"arv_approaches_protease.png\"/>\n",
    " ```\n",
    " \"C\": (-0.1805, 1.3955, 0.0000)\n",
    " ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Write your answer code here:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a your molecule in the cell below. Make sure to name the molecule `macromolecule`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Add your code here\n",
    "molecular_variation = Molecule.absolute_stretching\n",
    "specific_molecular_variation = apply_variation_to_atom_pair(molecular_variation, atom_pair=(6, 1))\n",
    "macromolecule = Molecule(geometry=\n",
    "                                  [['O', [1.1280, 0.2091, 0.0000]],\n",
    "                                   ['N', [-1.1878, 0.1791, 0.0000]],\n",
    "                                   ['C', [0.0598, -0.3882, 0.0000]],\n",
    "                                   ['H', [-1.3085, 1.1864, 0.0001]],\n",
    "                                   ['H', [-2.0305, -0.3861, -0.0001]],\n",
    "                                   ['H', [-0.0014, -1.4883, -0.0001]],\n",
    "                                  ['C', [-0.1805, 1.3955, 0.0000]]],\n",
    "                                  charge=0, multiplicity=1,\n",
    "                                  degrees_of_freedom=[specific_molecular_variation])\n",
    "\n",
    "##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To submit your molecule to the grader, run the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer for ex3/partA. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "from qc_grader import grade_ex3a\n",
    "\n",
    "grade_ex3a(molecule=macromolecule)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id='refine_step_2'>2. Refining Step 2: Reducing the quantum workload</a></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Step 2, we constructed the qubit Hamiltonian. If we tried to apply Step 2 and beyond to our macromolecule above, the ground state calculation simulation would fail. The reason is because since we specified a zero charge, Qiskit knows that it must work with 30 (= 2\\*6+7+8+3\\*1) electrons. After second quantization, this translates into, say, 60 spin-orbitals which requires 60 qubits. 60 qubits is beyond our ability to simulate classically and while there are IBM Quantum systems with more than 60 qubits available, the noise levels are currently too high to produce accurate results when using that many qubits. Thus, for the purpose of this Challenge we need to reduce the number of qubits. Fortunately, this is well-motivated from a chemistry point of view as well: the classical Hartree-Fock approximation for core-electrons is sometimes sufficient to obtain accurate chemical results. Doubly fortunately, Qiskit has just recently been extended to seamlessly allow for users to specify that certain electrons should receive quantum-computing treatment while the remaining electrons should be classically approximated. Even as more qubits come on online, this facility may prove very useful in allowing near-term quantum computers to tackle very large molecules that would otherwise be out of reach."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Therefore, we next demonstrate how to instruct Qiskit to give a certain number of electrons quantum-computing treatment:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "macro_molecular_orbital_maker = PySCFDriver(molecule=macromolecule, unit=UnitsType.ANGSTROM, basis='sto3g')\n",
    "split_into_classical_and_quantum = ActiveSpaceTransformer(num_electrons=2, num_molecular_orbitals=2)\n",
    "macro_fermionic_hamiltonian = ElectronicStructureProblem(macro_molecular_orbital_maker, [split_into_classical_and_quantum])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, Qiskit provides a class called **ActiveSpaceTransformer** that takes in two arguments. The first is the number of electrons that should receive quantum-computing treatment (selected from the outermost electrons, counting inwards). The second is the number of orbitals to allow those electrons to roam over (around the so-called Fermi level). It is the second number that determines how many qubits are needed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id='exercise_3b'>Exercise 3b: Classical-Quantum Treatment Conceptual Questions (Multiple-Choice)</a></h2>\n",
    "\n",
    "Q1: Why does giving quantum treatment to outer electrons of the macromolecule first, make more heuristic sense?\n",
    "\n",
    "```\n",
    "A: Outer electrons have higher binding energies and therefore swing the ground state energy more, therefore requiring quantum treatment.\n",
    "B: Outer electrons exhibit more quantum interference because their orbitals are more spread out.\n",
    "C: Inner core-electrons typically occupy orbitals more straightforwardly, because they mostly orbit a single nucleus and therefore do not lower the energy much by interacting/entangling with outer electrons.\n",
    "```\n",
    "\n",
    "Q2: For a fixed number of quantum-treatment electrons, as you increase the number of orbitals that those electrons roam over (have access to), does the calculated ground-state energy approach the asymptotic energy from above or below?\n",
    "\n",
    "```\n",
    "A: The asymptotic energy is approached from above, because as you increase the possible orbitals that the electrons have access to, the lower the ground state could be.\n",
    "B: The asymptotic energy is approached from below, because as you increase the possible orbitals the more accurate is your simulation, adding energy that was left out before.\n",
    "C: The asymptotic energy is approached from below, because as you increase the possible orbitals that the electrons have access to, the lower the ground state could be.\n",
    "D: The asymptotic energy is approached from above, because as you increase the possible orbitals the more accurate is your simulation, adding energy that was left out before.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Uncomment your answers to these multiple choice questions in the code-cell below. Run the cell to submit your answers.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer for ex3/partB. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "from qc_grader import grade_ex3b\n",
    "\n",
    "## Q1\n",
    "#answer_for_ex3b_q1 = 'A'\n",
    "# answer_for_ex3b_q1 = 'B'\n",
    "#answer_for_ex3b_q1 = 'C'\n",
    "##\n",
    "answer_for_ex3b_q1 = 'C'\n",
    "## Q2\n",
    "# answer_for_ex3b_q2 = 'A'\n",
    "# answer_for_ex3b_q2 = 'B'\n",
    "# answer_for_ex3b_q2 = 'C'\n",
    "#answer_for_ex3b_q2 = 'D'\n",
    "##\n",
    "answer_for_ex3b_q2 = 'A'\n",
    "\n",
    "grade_ex3b(answer_for_ex3b_q1, answer_for_ex3b_q2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id='refine_step_4'>3. Refining Step 4: Energy Surface</a></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Step 4, we ran the ground_state solver on a given molecule once only and we haven't yet explained how to instruct Qiskit to vary the molecular geometry using the specification introduced above. As explained in the introduction, changing the nuclei positions and comparing the total energy levels, is a method for finding the nuclei arrangement with the lowest energy. If the lowest energy is **not** at \"infinity\", this corresponds to a \"stable\" bound state of the molecule at the energy minimum. The energy as a function of atomic separation is thus a crucial object of study. This function is called the **Born-Oppenheimer Potential Energy Surface (BOPES)**. Qiskit provides a helpful python Class that manages this process of varying the geometry and repeatedly calling the ground_state solver: **BOPESSampler**.\n",
    "\n",
    "Let's demonstrate BOPESSampler for the hydrogen molecule.\n",
    "\n",
    "*The only steps of the hydrogen molecule walk-through that need to be re-run are Steps 1 and 2a:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "hydrogen_stretchable_molecular_orbital_maker = PySCFDriver(molecule=hydrogen_molecule_stretchable, unit=UnitsType.ANGSTROM, basis='sto3g')\n",
    "hydrogen_stretchable_fermionic_hamiltonian = ElectronicStructureProblem(hydrogen_stretchable_molecular_orbital_maker)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Secondly, here is how to call the sampler:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#energy_surface = BOPESSampler(gss=hydrogen_ground_state, bootstrap=False) # same solver suffices, since the trial is the same\n",
    "#perturbation_steps = np.linspace(-0.5, 2, 25) # 25 equally spaced points from -0.5 to 2, inclusive.\n",
    "#energy_surface_result = energy_surface.sample(hydrogen_stretchable_fermionic_hamiltonian, perturbation_steps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Thirdly, here is how to produce the famous energy landscape plot:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_energy_landscape(energy_surface_result):\n",
    "    if len(energy_surface_result.points) > 1:\n",
    "        plt.plot(energy_surface_result.points, energy_surface_result.energies, label=\"VQE Energy\")\n",
    "        plt.xlabel('Atomic distance Deviation(Angstrom)')\n",
    "        plt.ylabel('Energy (hartree)')\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "    else:\n",
    "        print(\"Total Energy is: \", energy_surface_result.energies[0], \"hartree\")\n",
    "        print(\"(No need to plot, only one configuration calculated.)\")\n",
    "    \n",
    "#plot_energy_landscape(energy_surface_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For extra intuition, you may think of the energy landscape as a mountain, next to a valley, next to a plateau that a ball rolls on (the x co-ordinate of the ball corresponds the separation between the two hydrogen atoms). If the ball is not rolling too fast down the plateau (right to left) it may settle in the valley. The ball slowly rolls down the plateau because the slope is positive (representing a force of attraction between the two hydrogen atoms). If the ball overshoots the minimum point of the valley, it meets the steep negative slope of the mountain and quickly rolls back (the hydrogen atoms repell each other).\n",
    "\n",
    "Notice the minimum is at zero. This is because we defined the hydrogen molecule's nuclei positions at the known ground state positions.\n",
    "\n",
    "By the way, if we had used the hardware_inspired_trial we would have produced a similiar plot, however it would have had bumps because the anzatz does not capture the electronic ground state equally well at different bond lengths."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id='exercise_3c'>Exercise 3c: Energy Landscape, To bind or not to bind?</a></h2>\n",
    "\n",
    "The million-dollar question: Does our toy anti-retrovial bind and thus block the protease?\n",
    "\n",
    " - Search for the minimum from -0.5 to 5 for 30 points.\n",
    " - Give quantum-computing treatment to 2 electrons roaming over 2 orbitals\n",
    "\n",
    "Q1. Submit the energy landscape for the anti-retroviral approaching the protease.\n",
    "\n",
    "Q2. Is there a clear minimum at a finite separation? Does binding occur?\n",
    "\n",
    "```\n",
    "A. Yes, there is a clear minimum at 0, so binding does occur.\n",
    "B. Yes, there is a clear minimum at infinity, so binding only happens at infinity.\n",
    "C. No, there is no clear minimum for any separation, so binding occurs because there is no seperation.\n",
    "D. No, there is no clear minimum for any separation, so there is no binding.\n",
    "```\n",
    "\n",
    "(Don't preempt the answer. Furthermore, the answer might change for other approaches and other settings, so please stick to the requested settings.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Feel free to use the following function, which collects the entire walk-through and refinements to Step 2 and 4. It takes in a Molecule (of refinement Step 1 type), the inputs for the other refinements and boolean choice of whether to use VQE or the numpy solver:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def construct_hamiltonian_solve_ground_state(\n",
    "    molecule,\n",
    "    num_electrons=2,\n",
    "    num_molecular_orbitals=2,\n",
    "    chemistry_inspired=True,\n",
    "    hardware_inspired_trial=None,\n",
    "    vqe=True,\n",
    "    perturbation_steps=np.linspace(-1, 1, 3),\n",
    "):\n",
    "    \"\"\"Creates fermionic Hamiltonion and solves for the energy surface.\n",
    "\n",
    "    Args:\n",
    "        molecule (Union[qiskit_nature.drivers.molecule.Molecule, NoneType]): The molecule to simulate.\n",
    "        num_electrons (int, optional): Number of electrons for the `ActiveSpaceTransformer`. Defaults to 2.\n",
    "        num_molecular_orbitals (int, optional): Number of electron orbitals for the `ActiveSpaceTransformer`. Defaults to 2.\n",
    "        chemistry_inspired (bool, optional): Whether to create a chemistry inspired trial state. `hardware_inspired_trial` must be `None` when used. Defaults to True.\n",
    "        hardware_inspired_trial (QuantumCircuit, optional): The hardware inspired trial state to use. `chemistry_inspired` must be False when used. Defaults to None.\n",
    "        vqe (bool, optional): Whether to use VQE to calculate the energy surface. Uses `NumPyMinimumEigensolver if False. Defaults to True.\n",
    "        perturbation_steps (Union(list,numpy.ndarray), optional): The points along the degrees of freedom to evaluate, in this case a distance in angstroms. Defaults to np.linspace(-1, 1, 3).\n",
    "\n",
    "    Raises:\n",
    "        RuntimeError: `chemistry_inspired` and `hardware_inspired_trial` cannot be used together. Either `chemistry_inspired` is False or `hardware_inspired_trial` is `None`.\n",
    "\n",
    "    Returns:\n",
    "        qiskit_nature.results.BOPESSamplerResult: The surface energy as a BOPESSamplerResult object.\n",
    "    \"\"\"\n",
    "    # Verify that `chemistry_inspired` and `hardware_inspired_trial` do not conflict\n",
    "    if chemistry_inspired and hardware_inspired_trial is not None:\n",
    "        raise RuntimeError(\n",
    "            (\n",
    "                \"chemistry_inspired and hardware_inspired_trial\"\n",
    "                \" cannot both be set. Either chemistry_inspired\"\n",
    "                \" must be False or hardware_inspired_trial must be none.\"\n",
    "            )\n",
    "        )\n",
    "\n",
    "    # Step 1 including refinement, passed in\n",
    "\n",
    "    # Step 2a\n",
    "    molecular_orbital_maker = PySCFDriver(\n",
    "        molecule=molecule, unit=UnitsType.ANGSTROM, basis=\"sto3g\"\n",
    "    )\n",
    "\n",
    "    # Refinement to Step 2a\n",
    "    split_into_classical_and_quantum = ActiveSpaceTransformer(\n",
    "        num_electrons=num_electrons, num_molecular_orbitals=num_molecular_orbitals\n",
    "    )\n",
    "\n",
    "    fermionic_hamiltonian = ElectronicStructureProblem(\n",
    "        molecular_orbital_maker, [split_into_classical_and_quantum]\n",
    "    )\n",
    "    fermionic_hamiltonian.second_q_ops()\n",
    "\n",
    "    # Step 2b\n",
    "    map_fermions_to_qubits = QubitConverter(JordanWignerMapper())\n",
    "\n",
    "    # Step 3a\n",
    "    if chemistry_inspired:\n",
    "        molecule_info = fermionic_hamiltonian.molecule_data_transformed\n",
    "        num_molecular_orbitals = molecule_info.num_molecular_orbitals\n",
    "        num_spin_orbitals = 2 * num_molecular_orbitals\n",
    "        num_electrons_spin_up_spin_down = (\n",
    "            molecule_info.num_alpha,\n",
    "            molecule_info.num_beta,\n",
    "        )\n",
    "        initial_state = HartreeFock(\n",
    "            num_spin_orbitals, num_electrons_spin_up_spin_down, map_fermions_to_qubits\n",
    "        )\n",
    "\n",
    "        chemistry_inspired_trial = UCCSD(\n",
    "            map_fermions_to_qubits,\n",
    "            num_electrons_spin_up_spin_down,\n",
    "            num_spin_orbitals,\n",
    "            initial_state=initial_state,\n",
    "        )\n",
    "\n",
    "        trial_state = chemistry_inspired_trial\n",
    "    else:\n",
    "        if hardware_inspired_trial is None:\n",
    "            hardware_inspired_trial = TwoLocal(\n",
    "                rotation_blocks=[\"ry\"],\n",
    "                entanglement_blocks=\"cz\",\n",
    "                entanglement=\"linear\",\n",
    "                reps=2,\n",
    "            )\n",
    "\n",
    "        trial_state = hardware_inspired_trial\n",
    "\n",
    "    # Step 3b and alternative\n",
    "    if vqe:\n",
    "        noise_free_quantum_environment = QuantumInstance(Aer.get_backend('statevector_simulator'))\n",
    "        solver = VQE(ansatz=trial_state, quantum_instance=noise_free_quantum_environment)\n",
    "    else:\n",
    "        solver = NumPyMinimumEigensolver()\n",
    "\n",
    "    # Step 4 and alternative\n",
    "    ground_state = GroundStateEigensolver(map_fermions_to_qubits, solver)\n",
    "\n",
    "    # Refinement to Step 4\n",
    "    energy_surface = BOPESSampler(gss=ground_state, bootstrap=False)\n",
    "    energy_surface_result = energy_surface.sample(\n",
    "        fermionic_hamiltonian, perturbation_steps\n",
    "    )\n",
    "\n",
    "    return energy_surface_result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Traceback \u001b[1;36m(most recent call last)\u001b[0m:\n",
      "\u001b[1;36m  File \u001b[1;32m\"/opt/conda/lib/python3.8/site-packages/IPython/core/compilerop.py\"\u001b[1;36m, line \u001b[1;32m101\u001b[1;36m, in \u001b[1;35mast_parse\u001b[1;36m\u001b[0m\n",
      "\u001b[1;33m    return compile(source, filename, symbol, self.flags | PyCF_ONLY_AST, 1)\u001b[0m\n",
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-32-b367d856506e>\"\u001b[1;36m, line \u001b[1;32m4\u001b[0m\n",
      "\u001b[1;33m    num_molecular_orbitals=2,\u001b[0m\n",
      "\u001b[1;37m    ^\u001b[0m\n",
      "\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m unexpected indent\n",
      "\n",
      "Use %tb to get the full traceback.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       ".button {\n",
       "  border: none;\n",
       "  color: white;\n",
       "  padding: 4px 8px;\n",
       "  text-align: center;\n",
       "  text-decoration: none;\n",
       "  display: inline-block;\n",
       "  font-size: 12px;\n",
       "  margin: 4px 2px;\n",
       "  transition-duration: 0.2s;\n",
       "  cursor: pointer;\n",
       "}\n",
       ".iqx-button {\n",
       "  background-color: #0f62fe; \n",
       "  color: white; \n",
       "}\n",
       ".iqx-button:hover {\n",
       "  background-color: #0043ce;\n",
       "  color: white;\n",
       "}\n",
       "</style>\n",
       "<a href=\"https://stackoverflow.com/search?q=IndentationError: unexpected indent\" target='_blank'><button class='button iqx-button'>Search for solution online</button></a>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#macromolecule_energy_surface = construct_hamiltonian_solve_ground_state(\n",
    "    #molecule = macromolecule,\n",
    "    #num_electrons=2,\n",
    "    num_molecular_orbitals=2,\n",
    "    chemistry_inspired=True,\n",
    "    hardware_inspired_trial=None,\n",
    "    vqe=True,\n",
    "    perturbation_steps=np.linspace(-0.5, 5, 30),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plot_energy_landscape(macromolecule_energy_surface)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code cells give a skeleton to call `construct_hamiltonian_solve_ground_state` and plot the results. Once you are confident with your results, submit them in the code-cell that follows.\n",
    "\n",
    "**Note: `construct_hamiltonian_solve_ground_state` will take some time to run (approximately 2 minutes). Do not worry if it doesn't return a result immediately.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Q2\n",
    "# answer_for_ex3c_q2 = 'A'\n",
    "# answer_for_ex3c_q2 = 'B'\n",
    "# answer_for_ex3c_q2 = 'C'\n",
    "# answer_for_ex3c_q2 = 'D'\n",
    "answer_for_ex3c_q2 = 'D'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you are happy with the results you have acquired, submit the energies and parameters for `construct_hamiltonian_solve_ground_state` in the following cell. Change the values for all parameters, except `energy_surface`, to have the same value that you used in your call of `construct_hamiltonian_solve_ground_state`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Traceback \u001b[1;36m(most recent call last)\u001b[0m:\n",
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-34-c9a5e67f10f8>\"\u001b[1;36m, line \u001b[1;32m4\u001b[1;36m, in \u001b[1;35m<module>\u001b[1;36m\u001b[0m\n",
      "\u001b[1;33m    energy_surface=macromolecule_energy_surface.energies, #q1_energy_surface_result.energies,\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m\u001b[1;31m:\u001b[0m name 'macromolecule_energy_surface' is not defined\n",
      "\n",
      "Use %tb to get the full traceback.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       ".button {\n",
       "  border: none;\n",
       "  color: white;\n",
       "  padding: 4px 8px;\n",
       "  text-align: center;\n",
       "  text-decoration: none;\n",
       "  display: inline-block;\n",
       "  font-size: 12px;\n",
       "  margin: 4px 2px;\n",
       "  transition-duration: 0.2s;\n",
       "  cursor: pointer;\n",
       "}\n",
       ".iqx-button {\n",
       "  background-color: #0f62fe; \n",
       "  color: white; \n",
       "}\n",
       ".iqx-button:hover {\n",
       "  background-color: #0043ce;\n",
       "  color: white;\n",
       "}\n",
       "</style>\n",
       "<a href=\"https://stackoverflow.com/search?q=NameError: name 'macromolecule_energy_surface' is not defined\" target='_blank'><button class='button iqx-button'>Search for solution online</button></a>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from qc_grader import grade_ex3c\n",
    "\n",
    "grade_ex3c(\n",
    "    energy_surface=macromolecule_energy_surface.energies, #q1_energy_surface_result.energies,\n",
    "    molecule=macromolecule,\n",
    "    num_electrons=2,\n",
    "    num_molecular_orbitals=2,\n",
    "    chemistry_inspired=True,\n",
    "    hardware_inspired_trial=None,\n",
    "    vqe=True,\n",
    "    perturbation_steps=np.linspace(-0.5, 5, 30),\n",
    "    q2_multiple_choice=answer_for_ex3c_q2\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id='refine_step_3a'>4. Refining Step 3a</a></h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the energies to visualize the results\n",
    "#plot_energy_landscape(energy_surface_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last refinement is a lesson in how black-box tweaking can improve results.\n",
    "\n",
    "In Step 3a, the hardware_inspired_trial is designed to run on actual current-day hardware. Recall this line from the walk-through:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "hardware_inspired_trial = TwoLocal(rotation_blocks = ['ry'], entanglement_blocks = 'cz',\n",
    "                                   entanglement='linear', reps=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us get a feel for the `reps` (repetition) parameter. This parameter controls how many rounds of mix and rotate are applied in the trial state. In more detail: there is an initial round of rotations, before mix (often containing no parameters) and another round of rotations are repeated. Certain gates don't generate parameters (e.g. `h`, `cz`). Each round of rotations adds an extra set of parameters that the classical optimizer adjusts in the search for the ground state.\n",
    "\n",
    "Let's relook at the simple hydrogen molecule and compute the \"ideal\" lowest energy electronic energy using the chemistry trial, the numpy solver and a single zero perturbation (i.e., no perturbations):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Energy is:  -1.137306035753395 hartree\n",
      "(No need to plot, only one configuration calculated.)\n"
     ]
    }
   ],
   "source": [
    "true_total_energy = construct_hamiltonian_solve_ground_state(\n",
    "                                molecule=hydrogen_molecule_stretchable,  # Step 1\n",
    "                                num_electrons=2,                         # Step 2a\n",
    "                                num_molecular_orbitals=2,                # Step 2a\n",
    "                                chemistry_inspired=True,                 # Step 3a\n",
    "                                vqe=False,                               # Step 3b\n",
    "                                perturbation_steps = [0])                # Step 4\n",
    "plot_energy_landscape(true_total_energy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We take this as the true value for the rest of our experiment.\n",
    "\n",
    "*Next, select `chemistry_inspired=False`, `vqe=True` and pass in a hardware trial with 1 round*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Energy is:  -1.1169841439047947 hartree\n",
      "(No need to plot, only one configuration calculated.)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.8/site-packages/qiskit_nature/algorithms/pes_samplers/bopes_sampler.py:192: DeprecationWarning: \n",
      "The VQE.optimal_params property is deprecated as of Qiskit Terra 0.18.0\n",
      "and will be removed no sooner than 3 months after the releasedate.\n",
      "This information is part of the returned result object and can be\n",
      "queried as VQEResult.optimal_point.\n",
      "  optimal_params = self._gss.solver.optimal_params  # type: ignore\n"
     ]
    }
   ],
   "source": [
    "hardware_inspired_trial = TwoLocal(rotation_blocks = ['ry'], entanglement_blocks = 'cz',\n",
    "                                   entanglement='linear', reps=1)\n",
    "\n",
    "quantum_calc_total_energy = construct_hamiltonian_solve_ground_state(\n",
    "                                molecule=hydrogen_molecule_stretchable,           # Step 1\n",
    "                                num_electrons=2,                                  # Step 2a\n",
    "                                num_molecular_orbitals=2,                         # Step 2a\n",
    "                                chemistry_inspired=False,                         # Step 3a\n",
    "                                hardware_inspired_trial=hardware_inspired_trial,  # Step 3a\n",
    "                                vqe=True,                                         # Step 3b\n",
    "                                perturbation_steps = [0])                         # Step 4\n",
    "plot_energy_landscape(quantum_calc_total_energy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Notice the difference is small and positive:*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.020321891848600337"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quantum_calc_total_energy.energies[0] - true_total_energy.energies[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Let's see how many parameters are used to specify the trial state:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of adjustable parameters:  8\n"
     ]
    }
   ],
   "source": [
    "total_number_of_parameters = len(hardware_inspired_trial._ordered_parameters)\n",
    "print(\"Total number of adjustable parameters: \", total_number_of_parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id='exercise_3d'>Exercise 3d: The effect of more repetitions</a></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1: Try reps equal to 1 (done for you) and 2 and compare the errors. What happens to the error? Does it increase, decrease, or stay the same?\n",
    "Be aware that:\n",
    " - VQE is a statistical algorithm, so run it a few times before observing the pattern.\n",
    " - Going beyond 2 may not continue the pattern.\n",
    " - Note that `reps` is defined in `TwoLocal`\n",
    "\n",
    "Q2: Check the total number of parameters for reps equal 1 and 2. How many parameters are introduced per round of rotations?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Write your answer here:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Enter your answer to the first multiple choice question in the code-cell below and add your answer for Q2. Run the cell to submit your answers.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer for ex3/partD. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "from qc_grader import grade_ex3d\n",
    "\n",
    "## Q1\n",
    "# answer_for_ex3d_q1 = 'decreases'\n",
    "# answer_for_ex3d_q1 = 'increases'\n",
    "# answer_for_ex3d_q1 = 'stays the same'\n",
    "##\n",
    "answer_for_ex3d_q1 = 'decreases'\n",
    "\n",
    "## Q2\n",
    "answer_for_ex3d_q2 = 4\n",
    "##\n",
    "\n",
    "grade_ex3d(answer_for_ex3d_q1, answer_for_ex3d_q2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id='exercise_3e'>Exercise 3e: Open-ended: Find the best hardware_inspired_trial to minimize the Energy Error for the Macromolecule</a></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Turning to the macromolecule again. Using, `chemistry_inspired=False`, `vqe=True`, `perturbation_steps = [0]`, a maximum of 8 qubits, and your own hardware_inspired_trial with any combination of options from the walk-through; find the lowest energy. Your answer to this exercise includes all parameters passed to `construct_hamiltonian_solve_ground_state` and the result object it returns. This exercise is scored based on how close your computed energy $E_{computed}$ is to the \"true\" minimum energy of the macromolecule $E_{true}$. This score is calculated as shown below, rounded to the nearest integer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\text{score} = -10 \\times \\log_{10}{\\left(\\left\\lvert{\\frac{E_{true} - E_{computed}}{E_{true}}}\\right\\rvert\\right)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Achieving a smaller error in your computed energy will increase your score. For example, if the true energy is -42.141 and you compute -40.0, you would have a score of 13. Use the following code cell to trial different `hardware_inspired_trial`s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modify the following variables\n",
    "num_electrons = 2\n",
    "num_molecular_orbitals = 2\n",
    "hardware_inspired_trial = TwoLocal(rotation_blocks = ['ry', 'rz'],\n",
    "                                   entanglement_blocks = 'cz',\n",
    "                                   entanglement = 'linear',\n",
    "                                   reps = 2,\n",
    "                                  )\n",
    "                                   \n",
    "#\n",
    "\n",
    "computed_macromolecule_energy_result = construct_hamiltonian_solve_ground_state(\n",
    "    molecule=macromolecule,\n",
    "    num_electrons=num_electrons,\n",
    "    num_molecular_orbitals=num_molecular_orbitals,\n",
    "    chemistry_inspired=False,\n",
    "    hardware_inspired_trial=hardware_inspired_trial,\n",
    "    vqe=True,\n",
    "    perturbation_steps=[0],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you are ready to submit your answer, run the following code cell to have your computed energy scored. You can submit multiple times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qc_grader import grade_ex3e\n",
    "\n",
    "grade_ex3e(\n",
    "    energy_surface_result=computed_macromolecule_energy_result,\n",
    "    molecule=macromolecule,\n",
    "    num_electrons=num_electrons,\n",
    "    num_molecular_orbitals=num_molecular_orbitals,\n",
    "    chemistry_inspired=False,\n",
    "    hardware_inspired_trial=hardware_inspired_trial,\n",
    "    vqe=True,\n",
    "    perturbation_steps=[0],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <a id='qresource'>Quantum Chemistry Resources</a>\n",
    "*Videos*\n",
    "- *Quantum Chemistry I: Obtaining the Qubit Hamiltonian* \n",
    "    - https://www.youtube.com/watch?v=2XEjrwWhr88\n",
    "- *Quantum Chemistry II: Finding the Ground States* \n",
    "    - https://www.youtube.com/watch?v=_UW6puuGa5E \n",
    "    - https://www.youtube.com/watch?v=o4BAOKbcd3o\n",
    "*Tutorials*\n",
    "- https://qiskit.org/documentation/nature/tutorials/01_electronic_structure.html \n",
    "- https://qiskit.org/documentation/nature/tutorials/03_ground_state_solvers.html \n",
    "- https://qiskit.org/documentation/nature/tutorials/05_Sampling_potential_energy_surfaces.html\n",
    "*Code References*\n",
    "- UCCSD : https://qiskit.org/documentation/stubs/qiskit.chemistry.components.variational_forms.UCCSD.html\n",
    "- ActiveSpaceTransformer: https://qiskit.org/documentation/nature/stubs/qiskit_nature.transformers.second_quantization.electronic.ActiveSpaceTransformer.html?highlight=activespacetransformer#qiskit_nature.transformers.second_quantization.electronic.ActiveSpaceTransformer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Licensing and notes:\n",
    "- All images used, with gratitude, are listed below with their respective licenses:\n",
    "  - https://de.wikipedia.org/wiki/Datei:Teppichschere.jpg by CrazyD is licensed under CC BY-SA 3.0\n",
    "  - https://commons.wikimedia.org/wiki/File:The_structure_of_the_immature_HIV-1_capsid_in_intact_virus_particles.png by MarinaVladivostok is licensed under CC0 1.0\n",
    "  - https://commons.wikimedia.org/wiki/File:Peptidformationball.svg by YassineMrabet is licensed under the public domain\n",
    "  - The remaining images are either IBM-owned, or hand-generated by the authors of this notebook.\n",
    "\n",
    "- HCONH2 (Formamide) co-ordinates kindly provided by the National Library of Medicine:\n",
    "  - `National Center for Biotechnology Information (2021). PubChem Compound Summary for CID 713, Formamide. https://pubchem.ncbi.nlm.nih.gov/compound/Formamide.`\n",
    "- For further information about the Pauli exclusion principle:\n",
    "https://en.wikipedia.org/wiki/Pauli_exclusion_principle\n",
    "- We would like to thank collaborators, Prof Yasien and Prof Munro from Wits for extensive assistance.\n",
    "- We would like to thank all the testers and feedback providers for their valuable input.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import qiskit.tools.jupyter\n",
    "%qiskit_version_table\n",
    "%qiskit_copyright"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}