IsingModel.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\mattm\\Anaconda3\\lib\\site-packages\\qiskit\\providers\\ibmq\\ibmqfactory.py:192: UserWarning: Timestamps in IBMQ backend properties, jobs, and job results are all now in local time instead of UTC.\n",
      "  warnings.warn('Timestamps in IBMQ backend properties, jobs, and job results '\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      "Job Status: job has successfully run\n",
      "[0.876953125]\n"
     ]
    }
   ],
   "source": [
    "%reset -f\n",
    "#%matplotlib inline\n",
    "# Importing standard Qiskit libraries and configuring account\n",
    "from qiskit import QuantumCircuit, execute, Aer, IBMQ, QuantumRegister\n",
    "from qiskit.providers.aer import QasmSimulator, StatevectorSimulator, UnitarySimulator\n",
    "from qiskit.compiler import transpile, assemble\n",
    "from qiskit.tools.monitor import job_monitor\n",
    "import matplotlib.pyplot as plt\n",
    "from qiskit.tools.jupyter import *\n",
    "from qiskit.visualization import *\n",
    "from qiskit.quantum_info import *\n",
    "import numpy as np\n",
    "provider = IBMQ.load_account()\n",
    "\n",
    "    \n",
    "# Loading your IBM Q account(s)\n",
    "#provider = IBMQ.load_account()\n",
    "\n",
    "#constants\n",
    "n = 4\n",
    "lambd = 1.2\n",
    "\n",
    "def thetak(k,lamb):\n",
    "    num = lamb - np.cos(2*np.pi*k/n)\n",
    "    denom = np.sqrt( (lamb-np.cos(2*np.pi*k/n))**2 + np.sin(2*np.pi*k/n)**2)\n",
    "    theta = np.arccos(num/denom)\n",
    "    return theta\n",
    "\n",
    "#Create functions based on the decomposition included in appendix of Ising paper\n",
    "def bog(qcirc, q1, q2, theta):\n",
    "    qcirc.x(q2)\n",
    "    qcirc.cx(q2, q1)\n",
    "    #Controlled RX gate\n",
    "    qcirc.rz(np.pi/2, q2)\n",
    "    qcirc.ry(theta/2, q2)\n",
    "    qcirc.cx(q1, q2)\n",
    "    qcirc.ry(-theta/2, q2)\n",
    "    qcirc.cx(q1, q2) #changed from qc to qcirc here - Bruna\n",
    "    qcirc.rz(-np.pi/2, q2)\n",
    "    #####################\n",
    "    qcirc.cx(q2, q1)\n",
    "    qcirc.x(q2)\n",
    "    qcirc.barrier()\n",
    "    return qcirc\n",
    "    \n",
    "def fourier(qcirc, q1, q2, phase):\n",
    "    qcirc.rz(phase, q1)\n",
    "    qcirc.cx(q1, q2)\n",
    "    #Controlled Hadamard\n",
    "    qcirc.sdg(q1)\n",
    "    qcirc.h(q1)\n",
    "    qcirc.tdg(q1)\n",
    "    qcirc.cx(q2, q1)\n",
    "    qcirc.t(q1)\n",
    "    qcirc.h(q1)\n",
    "    qcirc.s(q1)\n",
    "    ####################\n",
    "    qcirc.cx(q1, q2)\n",
    "    qcirc.cz(q1, q2)\n",
    "    qcirc.barrier()\n",
    "    return qcirc\n",
    "\n",
    "def digit_sum(n):\n",
    "    num_str = str(n)\n",
    "    sum = 0\n",
    "    for i in range(0, len(num_str)):\n",
    "        sum += int(num_str[i])\n",
    "    return sum\n",
    "\n",
    "def ground_state(lamb, backend_name): # backend is now an imput, so we can plot \n",
    "                                      # different ones easily - Bruna\n",
    "    qc = QuantumCircuit(4, 4)\n",
    "    #Set correct ground state if lambda < 1\n",
    "    if lamb < 1:\n",
    "        qc.x(3)\n",
    "        qc.barrier()\n",
    "    #magnetization\n",
    "    mag = []\n",
    "    \n",
    "    #Apply disentangling gates\n",
    "    qc = bog(qc, 0, 1, thetak(1.,lamb))\n",
    "    qc = fourier(qc, 0, 1, 2*np.pi/n)\n",
    "    qc = fourier(qc, 2, 3, 0.)\n",
    "    qc = fourier(qc, 0, 1, 0.)\n",
    "    qc = fourier(qc, 2, 3, 0.)\n",
    "    #Set measurement step\n",
    "    for i in range(0,4):\n",
    "        qc.measure(i,i)\n",
    "        \n",
    "    backend = Aer.get_backend(backend_name)\n",
    "    shots = 1024\n",
    "    max_credits = 10 #Max number of credits to spend on execution\n",
    "    job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)\n",
    "    job_monitor(job)\n",
    "    result = job.result()\n",
    "    counts = result.get_counts(qc)\n",
    "    ##while not '0000' in counts:\n",
    "    #    job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)\n",
    "    #    job_monitor(job)\n",
    "    #    result = job.result()\n",
    "    #    counts = result.get_counts(qc)\n",
    "    #Check what ground state is based on lambda\n",
    "    \n",
    "    r1=list(counts.keys())\n",
    "    r2=list(counts.values())\n",
    "    M=0\n",
    "    for j in range(0,len(r1)):\n",
    "        M=M+(4-2*digit_sum(r1[j]))*r2[j]/shots\n",
    "    #print(\"$\\lambda$: \",lam,\", $<\\sigma_{z}>$: \",M/4)\n",
    "    mag.append(M/4)\n",
    "    return mag\n",
    "    \n",
    "   # if lamb < 1:\n",
    "   #     return counts['0001']\n",
    "   # return counts['0000']/shots # it does not always works, sometimes it returns keyword error \n",
    "                                # maybe we can add another else for the possibility of other states, but \n",
    "                                # do not use it for plotting - Bruna\n",
    "\n",
    "\n",
    "print(ground_state(lambd, 'qasm_simulator'))\n",
    "\n",
    "#print(ground_state(.8,'statevector_simulator'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "[[0.083984375], [0.15234375], [0.17578125], [0.251953125], [0.25390625], [0.2841796875], [0.32421875], [0.3291015625], [0.845703125], [0.8759765625], [0.892578125], [0.8896484375], [0.8974609375], [0.9267578125], [0.9228515625], [0.931640625]]\n"
     ]
    }
   ],
   "source": [
    "lmbd = np.arange(.2, 1.75, 0.1)\n",
    "sigmaz = []\n",
    "for l in lmbd:\n",
    "    sigmaz.append(ground_state(l, 'qasm_simulator'))\n",
    "    \n",
    "print(sigmaz)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 1.8)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "plt.plot(lmbd, sigmaz,'bo')\n",
    "plt.ylabel(\"$\\sigma_z$\")\n",
    "plt.xlabel(\"$\\lambda$\")\n",
    "plt.ylim(0., 1.1)\n",
    "plt.xlim(0., 1.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ \\newcommand{\\ket}[1]{\\left|{#1}\\right\\rangle}$\n",
    "$ \\newcommand{\\bra}[1]{\\left\\langle{#1}\\right|}$\n",
    "$$ \\newcommand{\\braket}[2]{\\left\\langle{#1}\\middle|{#2}\\right\\rangle}$$\n",
    "\n",
    "The following code initializes the state to $ \\ket{0000}  $ and $\\ket{ 1100} $. It then applies the disentangling gates specified above using the backend of choice. The counts are plotted as a histogram."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Status: job has successfully run\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Start up and initialize circuit\n",
    "#Measurement\n",
    "qc = QuantumCircuit(4, 4)\n",
    "    #Set correct ground state if lambda < 1\n",
    "if lambd < 1:\n",
    "    qc.x(3)\n",
    "    qc.barrier()\n",
    "\n",
    "    #Apply disentangling gates\n",
    "qc = bog(qc, 0, 1, thetak(1.,1.2))\n",
    "qc = fourier(qc, 0, 1, 2*np.pi/n)\n",
    "qc = fourier(qc, 2, 3, 0.)\n",
    "qc = fourier(qc, 0, 1, 0.)\n",
    "qc = fourier(qc, 2, 3, 0.)\n",
    "    #Set measurement step\n",
    "for i in range(0,4):\n",
    "    qc.measure(i,i)\n",
    "    \n",
    "\n",
    "    \n",
    "    #Choose provider and backend\n",
    "#provider = IBMQ.get_provider()\n",
    "#provider = AerProvider()\n",
    "#backend = Aer.get_backend('statevector_simulator')\n",
    "backend = Aer.get_backend('qasm_simulator')\n",
    "#backend = provider.get_backend('ibmq_qasm_simulator')\n",
    "#backend = provider.get_backend('ibmqx4')\n",
    "#backend = provider.get_backend('ibmqx2')\n",
    "#backend = provider.get_backend('ibmq_16_melbourne')\n",
    "\n",
    "shots = 1024\n",
    "max_credits = 10 #Max number of credits to spend on execution\n",
    "job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)  \n",
    "job_monitor(job)\n",
    "result = job.result()\n",
    "counts = result.get_counts(qc)\n",
    "#print(counts['0000'])\n",
    "plot_histogram(counts)\n",
    "\n",
    "# had to comment this part because qc is a local variable in groundstate function now - Bruna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|0000> probability should be:  0.8841106397986879\n",
      "|0011> probability should be:  0.11588936020131207\n"
     ]
    }
   ],
   "source": [
    "phi = np.arccos(lambd/np.sqrt(1+lambd**2))/2\n",
    "#print(result.get_statevector(qc))\n",
    "print(\"|0000> probability should be: \",np.cos(phi)**2)\n",
    "print(\"|0011> probability should be: \",np.sin(phi)**2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(counts['0000'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# lets try the time evolution\n",
    "\n",
    "$\\newcommand{\\bra}[1]{\\left\\langle{#1}\\right|}$\n",
    "$$\\newcommand{\\braket}[2]{\\left\\langle{#1}\\middle|{#2}\\right\\rangle}$$\n",
    "\n",
    "Steps (as listed in the tutorial):\n",
    "\n",
    " - 1) choose an initial state in computational basis\n",
    " - 2) apply time evolution operator $e^{-H_{comp}}t$ to the initial state. \n",
    "\n",
    "\\begin{equation} e^{-H_{comp}t} \\ket{\\Psi(t)} = e^{2it(\\lambda + \\sqrt{1 +\\lambda^2})} \\big ( \\cos{\\phi} \\ket{00} + ie^{4it\\sqrt{1 + \\lambda^2}}\\sin{phi} \\ket{11} \\big ) \\otimes \\ket{00}\n",
    "\\end{equation}\n",
    "\n",
    "to do this we use a U3 gate defined as \n",
    "\n",
    "\\begin{equation} U3(a, b, c) = \\begin{bmatrix}  \\cos{a} & e^{-ic}\\sin{a \\over 2} \\\\ e^{-ib}\\sin{a \\over 2} & e^{i(b+c)}\\cos{a \\over 2} \\end{bmatrix}\\end{equation}\n",
    "\n",
    "\n",
    "overall phase is arbitrary \n",
    "\n",
    "$$ a = \\phi = {\\cos({\\lambda \\over \\sqrt{1 +\\lambda^2}})^{-1} \\over 2}  $$\n",
    "and \n",
    "$ b = {\\pi \\over 2} + 4t\\sqrt{1 +\\lambda^2} $ for some reason and finally\n",
    "$c = 0$\n",
    "\n",
    "  - 3) apply disentangle gate. a.k.a apply our ground_state function to see what the ground state is at some time t>0\n",
    "  - 4) then plot for multiple times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\mattm\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:7: DeprecationWarning: The QuantumCircuit.u3 method is deprecated as of 0.16.0. It will be removed no earlier than 3 months after the release date. You should use QuantumCircuit.u instead, which acts identically. Alternatively, you can decompose u3 in terms of QuantumCircuit.p and QuantumCircuit.sx: u3(ϴ,φ,λ) = p(φ+π) sx p(ϴ+π) sx p(λ) (2 pulses on hardware).\n",
      "  import sys\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n",
      "Job Status: job has successfully run\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "def Time_Evo(t, lamb, backend_name):\n",
    "    quc = QuantumCircuit(4, 4)\n",
    "    \n",
    "    #step 1. we are already in the |111> state\n",
    "        \n",
    "    # time evolution of computational basis, step 2\n",
    "    quc.u3(np.arccos(lamb/np.sqrt(1+lamb**2)), np.pi/2 + 4*t*np.sqrt(1+lamb**2),0,0)\n",
    "    quc.cx(0,1)\n",
    "    \n",
    "\n",
    "    #magnetization\n",
    "    mag = []\n",
    "    #step 3\n",
    "    #Apply disentangling gates\n",
    "    quc = bog(quc, 0, 1, thetak(1.,lamb))\n",
    "    quc = fourier(quc, 0, 1, 2*np.pi/n)\n",
    "    quc = fourier(quc, 2, 3, 0.)\n",
    "    quc = fourier(quc, 0, 1, 0.)\n",
    "    quc = fourier(quc, 2, 3, 0.)\n",
    "    #Set measurement step\n",
    "    for i in range(0,4):\n",
    "        quc.measure(i,i)\n",
    "        \n",
    "    \n",
    "    #provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')\n",
    "    backend = provider.get_backend(backend_name)\n",
    "    #backend = Aer.get_backend('statevector_simulator')\n",
    "    #backend = Aer.get_backend('qasm_simulator')\n",
    "    #backend = provider.get_backend('ibmq_qasm_simulator')\n",
    "    #backend = provider.get_backend('ibmqx4')\n",
    "    #backend = provider.get_backend('ibmqx2')\n",
    "    #backend = provider.get_backend('ibmq_16_melbourne')\n",
    "    shots = 1024\n",
    "    max_credits = 10 #Max number of credits to spend on execution\n",
    "    job = execute(quc, backend=backend, shots=shots, max_credits=max_credits)\n",
    "    job_monitor(job)\n",
    "    result = job.result()\n",
    "    counts = result.get_counts(quc)\n",
    "    ##while not '0000' in counts:\n",
    "    #    job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)\n",
    "    #    job_monitor(job)\n",
    "    #    result = job.result()\n",
    "    #    counts = result.get_counts(qc)\n",
    "    #Check what ground state is based on lambda\n",
    "    \n",
    "    r1=list(counts.keys())\n",
    "    r2=list(counts.values())\n",
    "    M=0\n",
    "    for j in range(0,len(r1)):\n",
    "        M=M+(4-2*digit_sum(r1[j]))*r2[j]/shots\n",
    "    #print(\"$\\lambda$: \",lam,\", $<\\sigma_{z}>$: \",M/4)\n",
    "    mag.append(M/4)\n",
    "    return mag\n",
    "\n",
    "#f = Time_Evo(qc,1,lambd,'qasm_simulator')\n",
    "#print(f)\n",
    "\n",
    "#\n",
    "ti = 0\n",
    "tf = 2\n",
    "time = np.arange(ti,tf,(tf-ti)/10)\n",
    "f = []\n",
    "for t in time:\n",
    "    f.append(Time_Evo(t,0.5,'ibmq_athens'))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'time' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-e48d7caa240c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#step 4\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mylim\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0.\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mxlim\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0.\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1.8\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mylabel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Magnetization\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'time' is not defined"
     ]
    }
   ],
   "source": [
    "#step 4\n",
    "plt.plot(time, f)\n",
    "plt.ylim(0., 1)\n",
    "plt.xlim(0., 1.8)\n",
    "plt.ylabel(\"Magnetization\")\n",
    "plt.xlabel(\"t\")\n",
    "plt.show()"
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}