vqe_from_scratch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# QOSF - TASK 4\n",
    "# Variational Quantum Eigensolver"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The aim of the task is to find the lowest eigenvalue of the following unitary matrix\n",
    "\n",
    "$$\n",
    "U = \n",
    "\\begin{bmatrix}\n",
    "1 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & -1 & 0 \\\\\n",
    "0 & -1 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 1\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "using VQE-like circuits. In order to do so, one must find a decomposition of the unitary $U$ in terms of Pauli operators $\\{\\mathbb{1}, X, Y, Z\\}$:\n",
    "\n",
    "$$\n",
    "\\mathbb{1} =\n",
    "\\begin{bmatrix}\n",
    "1 & 0  \\\\\n",
    "0 & 1\n",
    "\\end{bmatrix}\\quad\n",
    "X =\n",
    "\\begin{bmatrix}\n",
    "0 & 1 \\\\\n",
    "1& 0\n",
    "\\end{bmatrix}\\quad\n",
    "Y =\n",
    "\\begin{bmatrix}\n",
    "0 & -i \\\\\n",
    "i & 0\n",
    "\\end{bmatrix}\\quad\n",
    "z =\n",
    "\\begin{bmatrix}\n",
    "1 & 0 \\\\\n",
    "0 & -1\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "in order to be implemented on a quantum computer. In particular, since we are dealing with a $4\\times4$ matrix, two qubits are needed, thus the desired decomposition will be made of *tensor products* of two Pauli operators (e.g. $X_1 \\otimes Y_2$, where the subscript denotes the system on which the operator acts).\n",
    "\n",
    "### Decomposition in terms of Pauli operators\n",
    "\n",
    "Given that:\n",
    "\n",
    "$$\n",
    "X_1\\otimes X_2 = \n",
    "\\begin{bmatrix} 0 & 1\\\\ 1 & 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 0 & 1\\\\ 1 & 0 \\end{bmatrix} =\n",
    "\\begin{bmatrix} 0 \\cdot \\begin{bmatrix} 0 & 1\\\\ 1 & 0 \\end{bmatrix} & 1 \\cdot \\begin{bmatrix} 0 & 1\\\\ 1 & 0 \\end{bmatrix}\\\\ 1 \\cdot \\begin{bmatrix} 0 & 1\\\\ 1 & 0 \\end{bmatrix} & 0 \\cdot \\begin{bmatrix} 0 & 1\\\\ 1 & 0 \\end{bmatrix} \\end{bmatrix} = \\begin{bmatrix} 0 &  0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 1 & 0 & 0 & 0 \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "$$\n",
    "Y_1\\otimes Y_2 = \n",
    "\\begin{bmatrix} 0 & -i\\\\ i & 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 0 & -i\\\\ i & 0 \\end{bmatrix} = \\begin{bmatrix} 0 &  0 & 0 & -1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ -1 & 0 & 0 & 0 \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "$$\n",
    "Z_1\\otimes Z_2 = \n",
    "\\begin{bmatrix} 1 & 0\\\\ 0 & 1 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 & 0\\\\ 0 & 1 \\end{bmatrix} = \\begin{bmatrix} 1 &  0 & 0 & 0 \\\\ 0 & -1 & 0 & 0 \\\\ 0 & 0 & -1 & 0 \\\\ 0 & 0 & 0 & 1 \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\mathbb{1}_{4\\times4} = \\begin{bmatrix} 1 &  0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 0 & 0 & 1 \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "by inspection, it can be seen that \n",
    "\n",
    "$$\n",
    "U = \\frac{1}{2}(I_1\\otimes I_2+Z_1\\otimes Z_2)-\\frac{1}{2}(X_1 \\otimes X_2+Y_1\\otimes Y_2)\n",
    "$$\n",
    "\n",
    "that is, we found the desired decomposition of matrix $U$ in terms of Pauli operators. Since in VQE algorithms one usually deals with the minimization of the energy of a system, from now on we call the unitary matrix *Hamiltonian* $U \\rightarrow \\mathcal{H}$ of the system, and *energy* its mean value when evaluated on a given state $|\\psi(\\theta)\\rangle$, that is $E(\\theta) = \\langle \\mathcal{H} \\rangle_{\\theta}=\\langle \\psi(\\theta) | \\mathcal{H}|\\psi(\\theta)\\rangle$.  \n",
    "Notice that, $|\\psi(\\theta)$ is an *eigenvector* of the unitary $\\mathcal{H}$, with the energy $E(\\theta)$ being the corresponding *eigenvalue*. Our task is then to find the lowest eigenvalue of $\\mathcal{H}$. \n",
    "\n",
    "### Variational Quantum Eigensolver\n",
    "\n",
    "The idea behind VQE, is to use a quantum computer to evaluate the mean value of the *Hamiltonian* on a trial state $|\\psi(\\theta)\\rangle$ parametrized by $\\theta$, and then slowly change this parameter in order to find lower and lower values for the energy $E(\\theta)$.  \n",
    "\n",
    "Given that $\\langle \\mathbb{1} \\rangle = 1$, it holds that (from now on we omit the $\\otimes$ symbol for readibility)\n",
    "\n",
    "$$\n",
    "\\langle \\mathcal{H} \\rangle = \\frac{1}{2}(1 + \\langle Z_1 Z_2\\rangle)-\\frac{1}{2}(\\langle X_1 X_2\\rangle+\\langle Y_1 Y_2\\rangle) \\\\\n",
    "$$  \n",
    "\n",
    "\n",
    "which means we have to use some quantum circuits to estimate the mean value of the operators $X_1 X_2,\\ Y_1 Y_2,\\ Z_1 Z_2$, and then combine them back toether to find the eigenvalue $E = \\langle \\mathcal{H} \\rangle $.  \n",
    "\n",
    "Measurements in quantum computers generally happens along the $Z$ basis (known as *computational basis*), which means that we can only measure eigevectors and eigenvalues of $Z$. In order to measure other different observables, we need to change basis, and this can be done introducing some gate before the measurement happens. \n",
    "\n",
    "### Change of basis\n",
    "\n",
    "Noticing that:\n",
    "$$\n",
    "X=HZH\\quad Y=(HS^\\dagger)^\\dagger Z(HS^\\dagger)\n",
    "$$\n",
    "we can measure along the X basis by introducing an Hadamard $H$ gate before the measurement. Same happens with $Y$, by using a combination of Hadamard and Phase gates $HS^\\dagger$.  \n",
    "\n",
    "However, in our case we wish to measure two-qubits observables. \n",
    "\n",
    "#### Observable $Z_1 Z_2$\n",
    "  \n",
    "The operator $Z_1 Z_2$ acts like: \n",
    "$$\n",
    "Z_1 Z_2|00\\rangle = +1 |00\\rangle \\\\\n",
    "Z_1 Z_2|11\\rangle = +1 |11\\rangle \\\\\n",
    "Z_1 Z_2|01\\rangle = -1 |01\\rangle \\\\\n",
    "Z_1 Z_2|10\\rangle = 1 |10\\rangle \\\\\n",
    "$$\n",
    "that is, it checks whether the two qubits are in the same state (both $0$ or both $1$), in which case it has eigenvalue $1$, otherwise it has eigenvalue $-1$. A similar action can be implemented using a CNOT, in fact this gates loads on the second qubit the binary sum of the two qubits $\\text{CNOT}|q_1\\rangle|q_2\\rangle=|q_1\\rangle|q_1\\oplus q_2\\rangle$.   \n",
    "Infact, if\n",
    "* $q_1 = q_2$ (qubits are in the same state), it holds that $|q_1\\oplus q_2\\rangle = |0\\rangle$ and a measurement of the second qubit in the computational basis ($Z$ basis) yields result $+1$, \n",
    "* $q_1\\neq q_2$, then $|q_1\\oplus q_2\\rangle=|1\\rangle$ and a measurement would yield result $-1$, as desired.\n",
    "\n",
    "> Remember that, given a general qubit state $|\\psi\\rangle=\\alpha |0\\rangle + \\beta |1\\rangle$, it holds $\\langle Z \\rangle = \\langle \\psi | Z | \\psi \\rangle = |\\alpha|^2-|\\beta|^2$.\n",
    "\n",
    "In this way, we can measure the observable $Z_1 Z_2$ by introducing a CNOT gate and then measuring the second qubit in the usual $Z$ basis, as reported in the following circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measurement in the ZZ basis\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 321.232x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import qiskit as qk\n",
    "\n",
    "qc = qk.QuantumCircuit(2,1)\n",
    "qc.barrier()\n",
    "qc.cx(0,1)\n",
    "qc.measure(1,0)\n",
    "print(\"Measurement in the ZZ basis\")\n",
    "qc.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other two-qubit observables can be reducted to a measurement of $Z_1 Z_2$ by means of appropriate unitary transofmations (change of basis)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Observable $X_1 X_2$\n",
    "\n",
    "Using $X=HZH$ and the CNOT for measuring $Z_1 Z_2$, we have that the measurement in the $X_1 X_2$ can be achieved using the following circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measurement in the XX basis\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 381.432x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = qk.QuantumCircuit(2,1)\n",
    "qc.barrier()\n",
    "qc.h(0)\n",
    "qc.h(1)\n",
    "qc.cx(0,1)\n",
    "qc.measure(1,0)\n",
    "print(\"Measurement in the XX basis\")\n",
    "qc.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Observable $Y_1 Y_2$\n",
    "\n",
    "Using $Y=(HS^\\dagger)^\\dagger Z(HS^\\dagger)$ and the CNOT for measuring $Z_1 Z_2$, we have that the measurement in the $X_1 X_2$ can be achieved using the following circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measurement in the YY basis\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 441.632x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = qk.QuantumCircuit(2,1)\n",
    "qc.barrier()\n",
    "qc.sdg(0)\n",
    "qc.sdg(1)\n",
    "qc.h(0)\n",
    "qc.h(1)\n",
    "qc.cx(0,1)\n",
    "qc.measure(1,0)\n",
    "print(\"Measurement in the YY basis\")\n",
    "qc.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## VQE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now proceed implementing the VQE architecure, which works as follows:\n",
    "* choose an ansatz for a trial state $|\\psi(\\theta)\\rangle$, parametrized by the parameter $\\theta$\n",
    "* use three different quantum circuits to estimate the mean values $\\langle X_1 X_2 \\rangle_\\theta$, $\\langle Y_1 Y_2 \\rangle_\\theta$ and $\\langle Z_1 Z_2 \\rangle_\\theta$, where the subscript indicate the dependece on $\\theta$. \n",
    "* compute the energy $E(\\theta)=\\langle \\mathcal{H} \\rangle_\\theta$\n",
    "* change $\\theta$ in order to reach a lower energy\n",
    "\n",
    "As suggested, we use the ansatz $|\\psi(\\theta)\\rangle = [(RX(\\theta)_1\\otimes \\mathbb{1}_2) \\ \\text{CNOT}\\ (H_1\\otimes \\mathbb{1}_2)]|00\\rangle$.\n",
    "\n",
    "The quantum circuits are built with **Qiskit**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Importation of packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import Aer\n",
    "import numpy as np\n",
    "from scipy.optimize import minimize_scalar, minimize\n",
    "from numpy import pi\n",
    "\n",
    "sim_bknd = qk.Aer.get_backend('qasm_simulator')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Functions declaration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ansatz(qc, qr, theta):\n",
    "    \"\"\"\n",
    "    Builds the trial state using the ansatz: (RX I) CX (H I)|00>\n",
    "    \n",
    "    Arguments\n",
    "    -----------\n",
    "    qc: is a QuantumCircuit object from Qiskit\n",
    "    qr: is a QuantumRegister object used in the quantum circuit qc\n",
    "    theta (real): is the parameter parametrizing the trial state\n",
    "    \n",
    "    Return\n",
    "    ---------\n",
    "    qc: returns the input quantum circuit added with the gates creating the trial state\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    qc.h(qr[0])\n",
    "    qc.cx(qr[0],qr[1])\n",
    "    qc.rx(theta, qr[0])\n",
    "    \n",
    "    return qc\n",
    "\n",
    "def measurements(qc, qr, cr, op):\n",
    "    \"\"\"\n",
    "    Implements the quantum measurements in different basis: XX, YY and ZZ.\n",
    "    \n",
    "    Arguments\n",
    "    -----------\n",
    "    qc: is a QuantumCircuit object from Qiskit\n",
    "    qr: is a QuantumRegister object used in the quantum circuit qc\n",
    "    cr: is a ClassicalRegister object used in the quantum circuit qc\n",
    "    op (str): is a string with possible values: XX, YY and ZZ.\n",
    "    \n",
    "    \n",
    "    Return\n",
    "    ---------\n",
    "    qc: returns the input quantum circuit added with the appropriate gates to measure in the selected basis.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    if op == \"XX\":\n",
    "        # Change of basis, since X = HZH\n",
    "        qc.h(qr[0])\n",
    "        qc.h(qr[1])\n",
    "        \n",
    "        # CNOT used to measure ZZ operator\n",
    "        qc.cx(qr[0],qr[1])\n",
    "        \n",
    "        # Measurement of qubit 1 on classical register 0\n",
    "        qc.measure(qr[1],cr[0])\n",
    "        \n",
    "    elif op == \"YY\":\n",
    "        # Change of basis, since Y = (HS†)Z(HS†)\n",
    "        qc.sdg(qr[0])\n",
    "        qc.sdg(qr[1])\n",
    "        qc.h(qr[0])\n",
    "        qc.h(qr[1])\n",
    "        \n",
    "        # CNOT used to measure ZZ operator\n",
    "        qc.cx(qr[0],qr[1])\n",
    "        \n",
    "        # Measurement of qubit 1 on classical register 0\n",
    "        qc.measure(qr[1],cr[0])\n",
    "        \n",
    "    elif op == \"ZZ\":\n",
    "        # CNOT used to measure ZZ operator\n",
    "        qc.cx(qr[0],qr[1])\n",
    "        \n",
    "        # Measurement of qubit 1 on classical register 0\n",
    "        qc.measure(qr[1],cr[0])\n",
    "    \n",
    "    else:\n",
    "        print(f\"WARNING: Measurement on the {op} basis not supported\")\n",
    "        return \n",
    "        \n",
    "    return qc\n",
    "\n",
    "def hamiltonian(params):\n",
    "    \"\"\"\n",
    "    Evaulates the Energy of the trial state using the mean values of the operators XX, YY and ZZ.\n",
    "    \n",
    "    Arguments\n",
    "    -----------\n",
    "    params (dict): is an dictionary containing the mean values form the measurements of the operators XX, YY, ZZ;\n",
    "    \n",
    "    Return\n",
    "    ---------\n",
    "    en (real): energy of the system\n",
    "    \n",
    "    \"\"\"\n",
    "    # H = 1/2 * (Id + ZZ - XX - YY)\n",
    "    en = (1 + params['ZZ'] - params['XX'] - params['YY']) / 2\n",
    "    return en\n",
    "\n",
    "def vqe_step(theta, verbose = True):\n",
    "    \"\"\"\n",
    "    Executes the VQE algorithm. \n",
    "    Creates and executes three quantum circuits (one for each of the observables XX, YY and ZZ), then evaluates the energy.\n",
    "    \n",
    "    Arguments\n",
    "    -----------\n",
    "    theta (real): is the parameter parametrizing the trial state\n",
    "    \n",
    "    Return\n",
    "    --------\n",
    "    energy (real): the energy of the system\n",
    "    qc_list (dict): a dictionary containing the three quantum circuits for the observables XX, YY and ZZ\n",
    "    \n",
    "    \"\"\"\n",
    "    # Number of executions for each quantum circuit\n",
    "    shots=8192\n",
    "    \n",
    "    vqe_res = dict()\n",
    "    qc_list = dict()\n",
    "    \n",
    "    for op in [\"XX\", \"YY\", \"ZZ\"]:\n",
    "        qr = qk.QuantumRegister(2, \"qr\")\n",
    "        cr = qk.ClassicalRegister(1, \"cr\")\n",
    "        qc = qk.QuantumCircuit(qr, cr)\n",
    "\n",
    "        # Implementation of the ansatz\n",
    "        qc = ansatz(qc, qr, theta)\n",
    "\n",
    "        # Just for plotting purposes\n",
    "        qc.barrier()\n",
    "\n",
    "        # Measurements in the appropriate basis (XX, YY, ZZ) are implemented\n",
    "        qc = measurements(qc, qr, cr, op)\n",
    "                \n",
    "        # Get the measurements results\n",
    "        counts = qk.execute(qc, sim_bknd, shots=shots).result().get_counts()\n",
    "\n",
    "        # Check the results, and evaluate the mean value dividing by the number of shots\n",
    "        if len(counts) == 1: \n",
    "            try:\n",
    "                counts['0']\n",
    "                mean_val = 1\n",
    "            except:\n",
    "                mean_val = -1\n",
    "        else:\n",
    "            # Evaluates the mean value of Z operator, as the difference in the number of \n",
    "            # 0s and 1s in the measurement outcomes\n",
    "            mean_val = (counts['0']-counts['1'])/shots\n",
    "            \n",
    "        vqe_res[op] = mean_val\n",
    "        qc_list[op] = qc\n",
    "        \n",
    "    energy = hamiltonian(vqe_res)\n",
    "    \n",
    "    if verbose: \n",
    "        print(\"Mean values from measurement results:\\n\", vqe_res) \n",
    "        print(f\"\\n{'Theta':<10} {'Energy':<10} {'<XX>':<10} {'<YY>':<10} {'<ZZ>':<10}\")\n",
    "        print(f\"{theta:<10f} {energy:<10f} {vqe_res['XX']:<10f} {vqe_res['YY']:<10f} {vqe_res['ZZ']:<10f}\")\n",
    "    \n",
    "        return energy, qc_list\n",
    "    \n",
    "    else: \n",
    "        return energy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try if it all works properly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean values from measurement results:\n",
      " {'XX': 1, 'YY': -0.980224609375, 'ZZ': 0.980224609375}\n",
      "\n",
      "Theta      Energy     <XX>       <YY>       <ZZ>      \n",
      "0.200000   0.980225   1.000000   -0.980225  0.980225  \n",
      "\n",
      "Quantum circuit for the measurement of YY\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 630.886x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set the value of theta\n",
    "theta = 0.2\n",
    "\n",
    "# Run the VQE step to evaluate the energy (eigenvalue of the Hamiltonian) of the state with given theta\n",
    "energy, qc_list = vqe_step(theta)\n",
    "\n",
    "# Plot the circuit used for the measurement of YY\n",
    "op = 'YY'\n",
    "print(f\"\\nQuantum circuit for the measurement of {op}\")\n",
    "qc_list[op].draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that for $\\theta=0.2$, the energy $E(0.2)=\\langle\\mathcal{H}\\rangle_{0.2} \\sim 0.98$. Our aim is to find a value for the parameter that yields the lowest possible energy, and that is the desired lowest eigenvalue for the Task.  \n",
    "The minimization procedure can be done by hand, or by setting up an optimizator. \n",
    "\n",
    "##### Using an optimizator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -1.0\n",
       " message: 'Solution found.'\n",
       "    nfev: 27\n",
       "  status: 0\n",
       " success: True\n",
       "       x: 3.141586540251999"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minimize_scalar(vqe_step, args=(False), bounds = (0, pi), method = \"bounded\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Conclusion\n",
    "We see that the optimizator succeds in finding a solution. In particular, the optimal value seems to be $\\theta \\sim \\pi$, and its energy is close to unity. \n",
    "We can then check this result directly feeding $\\theta = \\pi$ to the `vqe_step` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean values from measurement results:\n",
      " {'XX': 1, 'YY': 1, 'ZZ': -1}\n",
      "\n",
      "Theta      Energy     <XX>       <YY>       <ZZ>      \n",
      "3.141593   -1.000000  1.000000   1.000000   -1.000000 \n"
     ]
    }
   ],
   "source": [
    "lowest, _ = vqe_step(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can actually see that our desired result is indeed given by:\n",
    "\n",
    "$$\n",
    "\\langle \\mathcal{H} \\rangle_{\\theta = \\pi} = \\frac{1}{2}(1 + \\langle Z Z\\rangle)-\\frac{1}{2}(\\langle X X\\rangle+\\langle Y Y\\rangle) \\\\\n",
    " = -1\n",
    "$$  \n",
    "\n",
    "with $\\langle XX \\rangle = 1$, $\\langle YY \\rangle = 1$, $\\langle ZZ \\rangle = -1$.  \n",
    "\n",
    "**Thus, we found the solution to the Task, that is the lowest eigenvalue of $\\mathcal{H}$ (formerly $U$), which amounts to $-1$.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Final (classical) check\n",
    "As a final step, we can check the result of our calculation with Scipy's eigensolver."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Desired Hamiltionian H = \n",
      " [[ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]\n",
      " [ 0.+0.j  0.+0.j -1.+0.j  0.+0.j]\n",
      " [ 0.+0.j -1.+0.j  0.+0.j  0.+0.j]\n",
      " [ 0.+0.j  0.+0.j  0.+0.j  1.+0.j]]\n"
     ]
    }
   ],
   "source": [
    "# Definition of one qubit Pauli matrices\n",
    "I = np.array([[1,0],[0,1]])\n",
    "X = np.array([[0,1],[1,0]])\n",
    "Y = np.array([[0,-1j],[1j,0]])\n",
    "Z = np.array([[1,0],[0,-1]])\n",
    "\n",
    "# Evaluation of two qubit Pauli matrices\n",
    "II = np.kron(I,I)\n",
    "XX = np.kron(X,X)\n",
    "YY = np.kron(Y,Y)\n",
    "ZZ = np.kron(Z,Z)\n",
    "\n",
    "# Calculation of the Hamiltonian\n",
    "H = (1/2) * (II+ZZ) - (1/2) * (XX+YY)\n",
    "\n",
    "print(\"Desired Hamiltionian H = \\n\", H)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which is the same as $U$. Now we proceed calculating the eigenvalues:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eigenvalues: [ 1.+0.j -1.+0.j  1.+0.j  1.+0.j]\n"
     ]
    }
   ],
   "source": [
    "import scipy\n",
    "\n",
    "# Calculate eigenvalues and eigenvectors of H\n",
    "eigenvalues, eigenvectors = scipy.linalg.eig(H)\n",
    "print(\"Eigenvalues:\", eigenvalues)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that $-1$ is actually the lowest eigenvalue, as we found with VQE."
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}