Qiskit_VQE.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Qiskit_VQE.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "P2Ufk0eZN0Lc"
      },
      "source": [
        "%%capture\n",
        "\n",
        "!pip install qiskit[visualization]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tqe00C-LOUTl"
      },
      "source": [
        "import qiskit\n",
        "import numpy as np\n",
        "\n",
        "from qiskit import Aer, QuantumCircuit, ClassicalRegister, QuantumRegister, IBMQ\n",
        "from qiskit.circuit import QuantumCircuit, ParameterVector\n",
        "from qiskit.algorithms.optimizers import COBYLA\n",
        "from qiskit.providers.ibmq import least_busy\n",
        "\n",
        "from qiskit.aqua import QuantumInstance\n",
        "from qiskit.aqua.algorithms import VQE, NumPyMinimumEigensolver\n",
        "from qiskit.aqua.operators import I, Z, X, Y\n",
        "\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d2f39vDPy0R1",
        "outputId": "1b21e012-c9ae-4335-d5f0-48a67d5fa040"
      },
      "source": [
        "IBMQ.enable_account(\"8ee0cdbd442f6bb654b16a42a75546db448bed4a29f8874f7a3c96e4ba6381db750772327bbc111999756c30f142b957e3f6de4fb20c7622cf177b54c1df38c8\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<AccountProvider for IBMQ(hub='ibm-q', group='open', project='main')>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VrFx4ETmp-9L"
      },
      "source": [
        "## Functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EvAhWLCSCWj4"
      },
      "source": [
        "def calculateOverlap(stateCoordinates1,stateCoordinates2):\n",
        "    '''\n",
        "    Calculates the overlap between two states, given their coordinates.\n",
        "\n",
        "    Arguments:\n",
        "      stateCoordinates1 (np.ndarray): the coordinates of one of the states in \n",
        "        some orthonormal basis,\n",
        "      stateCoordinates2 (np.ndarray): the coordinates of the other state, in \n",
        "        the same basis\n",
        "\n",
        "    Returns: \n",
        "      overlap (float): the overlap between two states (absolute value of the \n",
        "        inner product).\n",
        "    '''\n",
        "\n",
        "    bra = np.conj(stateCoordinates1)\n",
        "    ket = stateCoordinates2\n",
        "    overlap = np.abs(np.dot(bra,ket))\n",
        "    \n",
        "    return overlap\n",
        "\n",
        "def callback(nfev, parameters, energy, stddev):\n",
        "    '''\n",
        "    Function to keep intermediary data from the optimization done by running\n",
        "    the instance of the VQE class. Called at the end of each optimization run.\n",
        "\n",
        "    Arguments:\n",
        "      nfev (int): the number of function evaluations performed so far\n",
        "      parameters (list): the parameters found by the optimizer in this \n",
        "        iteration\n",
        "      energy (float):\n",
        "      stddev (float):\n",
        "\n",
        "    Returns: \n",
        "      No return value. Just fills the dictionary 'evolution', assumed to be \n",
        "        defined, with the data.\n",
        "    '''\n",
        "\n",
        "    evolution['nfev'].append(nfev)\n",
        "    evolution['parameters'].append(parameters.copy())\n",
        "    evolution['energy'].append(energy)\n",
        "    evolution['stddev'].append(stddev)\n",
        "    \n",
        "    print(\"{}: {}\".format(nfev,energy))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ier9DQiA9m68"
      },
      "source": [
        "## Defining the Hamiltonian in Qiskit Aqua"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rJEPp-N59sS0"
      },
      "source": [
        "def toAquaObservable(operator):\n",
        "  '''\n",
        "  Transforms a Hamiltonian so that it's suitable for use\n",
        "  with Qiskit Aqua\n",
        "\n",
        "  Arguments:\n",
        "    operator (dict): the Hamiltonian as a sum of Pauli strings,\n",
        "      represented by a dictionary\n",
        "\n",
        "  Returns:\n",
        "    observable (qiskit.aqua.operators.OperatorBase): the observable\n",
        "      as required by Aqua\n",
        "  '''\n",
        "\n",
        "  observable = 0\n",
        "\n",
        "  for pauliString in operator:\n",
        "\n",
        "    transformedPauli = 1\n",
        "    for pauli in pauliString:\n",
        "      if pauli == \"I\":\n",
        "        transformedPauli = transformedPauli ^ I\n",
        "      elif pauli == \"X\":\n",
        "        transformedPauli = transformedPauli ^ X\n",
        "      elif pauli == \"Y\":\n",
        "        transformedPauli = transformedPauli ^ Y\n",
        "      elif pauli == \"Z\":\n",
        "        transformedPauli = transformedPauli ^ Z\n",
        "\n",
        "\n",
        "    coefficient = operator[pauliString]\n",
        "    observable += transformedPauli * coefficient\n",
        "\n",
        "  return observable"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-GJdSY32wS9z",
        "outputId": "c70acdcb-e94d-49b9-95d8-85c1906d771b"
      },
      "source": [
        "# Hamiltonian for HeH+ at r=90pm, from table 2 of the supplementary section\n",
        "#of the original article.\n",
        "hamiltonian90={\n",
        "    \"II\": -3.8505,\n",
        "    \"IX\": -0.2288,\n",
        "    \"IZ\": -1.0466,\n",
        "    \"XI\": -0.2288,\n",
        "    \"XX\": +0.2613,\n",
        "    \"XZ\": +0.2288,\n",
        "    \"ZI\": -1.0466,\n",
        "    \"ZX\": +0.2288,\n",
        "    \"ZZ\": +0.2356\n",
        "    }\n",
        "\n",
        "# There's a strange factor of two in the table of the original article, that \n",
        "#causes the energy to be double what it should.\n",
        "for key in hamiltonian90.keys():\n",
        "  hamiltonian90[key] = hamiltonian90[key] / 2\n",
        "\n",
        "hamiltonian = hamiltonian90\n",
        "\n",
        "observable = toAquaObservable(hamiltonian)\n",
        "\n",
        "print(observable)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "SummedOp([\n",
            "  -1.92525 * II,\n",
            "  -0.1144 * IX,\n",
            "  -0.5233 * IZ,\n",
            "  -0.1144 * XI,\n",
            "  0.13065 * XX,\n",
            "  0.1144 * XZ,\n",
            "  -0.5233 * ZI,\n",
            "  0.1144 * ZX,\n",
            "  0.1178 * ZZ\n",
            "])\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/qiskit/aqua/operators/operator_base.py:46: DeprecationWarning: The package qiskit.aqua.operators is deprecated. It was moved/refactored to qiskit.opflow (pip install qiskit-terra). For more information see <https://github.com/Qiskit/qiskit-aqua/blob/master/README.md#migration-guide>\n",
            "  warn_package('aqua.operators', 'qiskit.opflow', 'qiskit-terra')\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mrF3X5mjqBeh"
      },
      "source": [
        "## Ansatz (Full 2-qubit Hilbert Space)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 140
        },
        "id": "K8VetVtazP7d",
        "outputId": "d3c640c5-12ca-45b1-be09-8f754f6ea197"
      },
      "source": [
        "# Define the parameter vector\n",
        "params = ParameterVector(\"Params\",6)\n",
        "\n",
        "ansatz = QuantumCircuit(2)\n",
        "\n",
        "# Apply parameterized gates\n",
        "ansatz.ry(params[0],0)\n",
        "ansatz.cx(0,1)\n",
        "ansatz.rz(params[1],0)\n",
        "ansatz.ry(params[2],0)\n",
        "ansatz.rz(params[3],0)\n",
        "ansatz.ry(params[4],1)\n",
        "ansatz.rz(params[5],1)\n",
        "\n",
        "ansatz.draw(\"mpl\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 628.252x144.48 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z9P0c-_g8In3"
      },
      "source": [
        "## Choosing the Backend"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cThBylHU3xht"
      },
      "source": [
        "# Check the accessible backends\n",
        "provider = IBMQ.get_provider(hub='ibm-q-minho')\n",
        "provider.backends()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cJnNyd6i5KRG"
      },
      "source": [
        "# Filter the backends that aren't simulators, have at least two qubits and\n",
        "#are available\n",
        "\n",
        "devices = provider.backends(filters=lambda x: x.configuration().n_qubits >= 2\n",
        "                                    and not x.configuration().simulator\n",
        "                                    and x.status().operational==True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HsfpGLkP9pHC",
        "outputId": "d492e388-a2cc-41fc-bc75-1f0d99ae41f7"
      },
      "source": [
        "# Check which one is the least busy\n",
        "least_busy(devices)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<IBMQBackend('ibmq_manhattan') from IBMQ(hub='ibm-q-minho', group='academicprojects', project='quantalab')>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VGreXH8E8dIj"
      },
      "source": [
        "# Choose\n",
        "\n",
        "backend = Aer.get_backend('statevector_simulator')\n",
        "#backend = provider.get_backend('ibmq_lima')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a7MOAJNh8kxF"
      },
      "source": [
        "## Running VQE"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "otrFoe8guiSW",
        "outputId": "a0892040-a2ac-4e6a-e18f-4631708b6be1"
      },
      "source": [
        "# Create empty evolution dictionary, to be filled with the data from each\n",
        "#iteration\n",
        "evolution = {\n",
        "    'nfev': [],\n",
        "    'parameters': [],\n",
        "    'energy': [],\n",
        "    'stddev': []\n",
        "}\n",
        "\n",
        "shots = 2**13\n",
        "tol = 10**-2\n",
        "qinstance = QuantumInstance(backend, shots = shots)\n",
        "\n",
        "randomState = [np.random.rand() * np.pi for _ in range(6)]\n",
        "randomState = [0.58871762, 2.52740039, 0.95600407, 2.65695065, 1.47913046, 2.58053004]\n",
        "\n",
        "\n",
        "vqe = VQE(observable,\n",
        "          var_form = ansatz, \n",
        "          optimizer = COBYLA(tol = tol), \n",
        "          quantum_instance = qinstance,\n",
        "          callback = callback,\n",
        "          initial_point = randomState)\n",
        "\n",
        "result = vqe.run()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/qiskit/aqua/quantum_instance.py:137: DeprecationWarning: The class qiskit.aqua.QuantumInstance is deprecated. It was moved/refactored to qiskit.utils.QuantumInstance (pip install qiskit-terra). For more information see <https://github.com/Qiskit/qiskit-aqua/blob/master/README.md#migration-guide>\n",
            "  'qiskit-terra')\n",
            "/usr/local/lib/python3.7/dist-packages/qiskit/aqua/algorithms/vq_algorithm.py:72: DeprecationWarning: The class qiskit.aqua.algorithms.VQAlgorithm is deprecated. It was moved/refactored to qiskit.algorithms.VariationalAlgorithm (pip install qiskit-terra). For more information see <https://github.com/Qiskit/qiskit-aqua/blob/master/README.md#migration-guide>\n",
            "  'qiskit-terra')\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "1: -2.059527479020077\n",
            "2: -1.9266433196018105\n",
            "3: -2.1432981237452164\n",
            "4: -1.5707029189685622\n",
            "5: -2.1544142917301117\n",
            "6: -1.7224534628015689\n",
            "7: -2.0841625824774455\n",
            "8: -2.6824744349729253\n",
            "9: -2.8247430800233264\n",
            "10: -2.517855497384611\n",
            "11: -2.7603692771144144\n",
            "12: -2.7982651215240613\n",
            "13: -2.8211975326207015\n",
            "14: -2.781712688425788\n",
            "15: -2.761572960304558\n",
            "16: -2.675581473228312\n",
            "17: -2.8378883906648826\n",
            "18: -2.840007085629539\n",
            "19: -2.835909354720178\n",
            "20: -2.84271608596779\n",
            "21: -2.7798312531832656\n",
            "22: -2.843114215639516\n",
            "23: -2.8545041282439496\n",
            "24: -2.838315971765259\n",
            "25: -2.845043173065518\n",
            "26: -2.8575990197792533\n",
            "27: -2.859582339071141\n",
            "28: -2.859193153467056\n",
            "29: -2.8569688401880584\n",
            "30: -2.85435633251592\n",
            "31: -2.861159460160705\n",
            "32: -2.860107272939235\n",
            "33: -2.8609449879324043\n",
            "34: -2.860020565216155\n",
            "35: -2.8610250221971896\n",
            "36: -2.859825957226935\n",
            "37: -2.86110535242687\n",
            "38: -2.859818603062794\n",
            "39: -2.862283048069578\n",
            "40: -2.8623218160901756\n",
            "41: -2.8623282278839404\n",
            "42: -2.86216627069302\n",
            "43: -2.8622083975699035\n",
            "44: -2.862237099438743\n",
            "45: -2.8623351272997968\n",
            "46: -2.862389409964385\n",
            "47: -2.8622976592224987\n",
            "48: -2.8623901727057453\n",
            "49: -2.862347102480051\n",
            "50: -2.8623850939613917\n",
            "51: -2.8623585164447753\n",
            "52: -2.862380959205568\n",
            "53: -2.8623720735442797\n",
            "54: -2.8623871077154672\n",
            "55: -2.8623899637174035\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zcQO1hCU8v2h"
      },
      "source": [
        "## Checking the Result"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r9R1rYgs80bx"
      },
      "source": [
        "### Calculating Overlaps"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MB6N2HZs_vIV",
        "outputId": "1d126c4b-0e58-4592-b821-544605f221d6"
      },
      "source": [
        "# Use Numpy to find the exact result\n",
        "solver = NumPyMinimumEigensolver()\n",
        "exactResult = solver.compute_minimum_eigenvalue(observable)\n",
        "\n",
        "exactState = exactResult.eigenstate.to_matrix()\n",
        "exactEnergy = exactResult.eigenvalue.real\n",
        "\n",
        "# Use Aer to get the final state produced by the optimized\n",
        "#ansatz circuit\n",
        "finalParameters = evolution[\"parameters\"][-1]\n",
        "finalCircuit = ansatz.assign_parameters(finalParameters)\n",
        "simulator = Aer.get_backend(\"statevector_simulator\")\n",
        "\n",
        "job = qiskit.execute(finalCircuit,simulator)\n",
        "result = job.result()\n",
        "finalState = result.get_statevector(finalCircuit, decimals=3)\n",
        "\n",
        "# Check the overlap between the exact state and the final\n",
        "#VQE state\n",
        "print(calculateOverlap(exactState,finalState))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.9998819363679626\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/qiskit/aqua/algorithms/minimum_eigen_solvers/minimum_eigen_solver.py:38: DeprecationWarning: The package qiskit.aqua.algorithms.minimum_eigen_solvers is deprecated. It was moved/refactored to qiskit.algorithms.minimum_eigen_solvers (pip install qiskit-terra). For more information see <https://github.com/Qiskit/qiskit-aqua/blob/master/README.md#migration-guide>\n",
            "  'qiskit-terra')\n",
            "/usr/local/lib/python3.7/dist-packages/qiskit/aqua/algorithms/eigen_solvers/eigen_solver.py:38: DeprecationWarning: The package qiskit.aqua.algorithms.eigen_solvers is deprecated. It was moved/refactored to qiskit.algorithms.eigen_solvers (pip install qiskit-terra). For more information see <https://github.com/Qiskit/qiskit-aqua/blob/master/README.md#migration-guide>\n",
            "  'qiskit-terra')\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8lvWYquVCga-"
      },
      "source": [
        "overlaps = []\n",
        "\n",
        "# Calculate the overlap with the ground state at each\n",
        "#optimization step\n",
        "for parameters in evolution[\"parameters\"]:\n",
        "\n",
        "  finalCircuit = ansatz.assign_parameters(parameters)\n",
        "  simulator = Aer.get_backend(\"statevector_simulator\")\n",
        "\n",
        "  job = qiskit.execute(finalCircuit,simulator)\n",
        "  result = job.result()\n",
        "  finalState = result.get_statevector(finalCircuit, decimals=3)\n",
        "\n",
        "  overlap = calculateOverlap(exactState,finalState)\n",
        "  overlaps.append(overlap)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NX1-4xjQTSnH"
      },
      "source": [
        "# Attributing a name to the backend for the title of the plot\n",
        "\n",
        "if backend.name() == \"statevector_simulator\":\n",
        "  backendName = \"Aer State Vector Simulator\"\n",
        "\n",
        "elif backend.name() == \"qasm_simulator\":\n",
        "  backendName = \"Aer QASM Simulator\"\n",
        "\n",
        "else:\n",
        "  backendName = backend.name()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ehbSJUPV84J6"
      },
      "source": [
        "### Plotting Results"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 545
        },
        "id": "kcodhYed-nR_",
        "outputId": "390ecbb9-27c0-4a9d-93c8-6669d57ab6f0"
      },
      "source": [
        "fig, ax1 = plt.subplots(figsize=[8,8])\n",
        "\n",
        "nfev = evolution[\"nfev\"][-1]\n",
        "\n",
        "title = \"Evolution of the Optimization\\nHe-H+, \"\n",
        "\n",
        "if backendName != \"Aer State Vector Simulator\":\n",
        "  title += \"{} shots, \".format(shots)\n",
        "title += \"{}\".format(backendName)\n",
        "\n",
        "ax1.set_title(title)\n",
        "\n",
        "color1 = 'b'\n",
        "ax1.plot(range(1,nfev+1), evolution[\"energy\"], '--o', color = color1)\n",
        "ax1.set_xlabel(\"VQE Iteration\")\n",
        "ax1.tick_params(axis='y', labelcolor = color1)\n",
        "ax1.set_ylabel(\"Energy (au)\", \n",
        "               color = color1)\n",
        "\n",
        "plt.axhline(y = exactEnergy, color = 'cornflowerblue' , linestyle = '-')\n",
        "\n",
        "color2 = 'r'\n",
        "ax2 = ax1.twinx()\n",
        "ax2.plot(range(1,nfev+1), overlaps, '--o', color = color2)\n",
        "ax2.tick_params(axis='y', labelcolor = color2)\n",
        "ax2.set_ylabel(\"Overlap with the ground state\",\n",
        "               color = color2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Overlap with the ground state')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x576 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}