solutions_tutorial_IV_qpu.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tutorial 4: Advanced features\n",
    "In this tutorial, you will learn:\n",
    "* _How to intspect Rigetti's devices using Forest API_\n",
    "* _Extract and interpret the information about decoherence of the qubits_\n",
    "* _Usage of the server-side compiler_\n",
    "* _How to incorporate noise models to estimate performance of the circuit on the real chip_\n",
    "\n",
    "$$\\newcommand{\\ket}[1]{\\left|{#1}\\right\\rangle}\n",
    "\\newcommand{\\bra}[1]{\\left\\langle{#1}\\right|}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting https://github.com/rigetticomputing/pyquil/archive/master.zip\n",
      "  Downloading https://github.com/rigetticomputing/pyquil/archive/master.zip (45.0MB)\n",
      "\u001b[K    100% |████████████████████████████████| 45.0MB 16kB/s  eta 0:00:01    75% |████████████████████████        | 33.9MB 23.2MB/s eta 0:00:01\n",
      "\u001b[?25hRequirement already up-to-date: networkx in /opt/conda/lib/python3.6/site-packages\n",
      "Requirement already up-to-date: matplotlib in /opt/conda/lib/python3.6/site-packages\n",
      "Requirement already up-to-date: numpy in /opt/conda/lib/python3.6/site-packages (from pyquil==2.0.0.dev0)\n",
      "Requirement already up-to-date: antlr4-python3-runtime in /opt/conda/lib/python3.6/site-packages (from pyquil==2.0.0.dev0)\n",
      "Requirement already up-to-date: requests in /opt/conda/lib/python3.6/site-packages (from pyquil==2.0.0.dev0)\n",
      "Requirement already up-to-date: contextvars in /opt/conda/lib/python3.6/site-packages (from pyquil==2.0.0.dev0)\n",
      "Requirement already up-to-date: six in /opt/conda/lib/python3.6/site-packages (from pyquil==2.0.0.dev0)\n",
      "Requirement already up-to-date: decorator>=4.1.0 in /opt/conda/lib/python3.6/site-packages (from networkx)\n",
      "Requirement already up-to-date: python-dateutil>=2.1 in /opt/conda/lib/python3.6/site-packages (from matplotlib)\n",
      "Requirement already up-to-date: cycler>=0.10 in /opt/conda/lib/python3.6/site-packages (from matplotlib)\n",
      "Requirement already up-to-date: kiwisolver>=1.0.1 in /opt/conda/lib/python3.6/site-packages (from matplotlib)\n",
      "Requirement already up-to-date: pytz in /opt/conda/lib/python3.6/site-packages (from matplotlib)\n",
      "Requirement already up-to-date: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /opt/conda/lib/python3.6/site-packages (from matplotlib)\n",
      "Requirement already up-to-date: chardet<3.1.0,>=3.0.2 in /opt/conda/lib/python3.6/site-packages (from requests->pyquil==2.0.0.dev0)\n",
      "Requirement already up-to-date: idna<2.8,>=2.5 in /opt/conda/lib/python3.6/site-packages (from requests->pyquil==2.0.0.dev0)\n",
      "Requirement already up-to-date: urllib3<1.24,>=1.21.1 in /opt/conda/lib/python3.6/site-packages (from requests->pyquil==2.0.0.dev0)\n",
      "Requirement already up-to-date: certifi>=2017.4.17 in /opt/conda/lib/python3.6/site-packages (from requests->pyquil==2.0.0.dev0)\n",
      "Requirement already up-to-date: immutables==0.5 in /opt/conda/lib/python3.6/site-packages (from contextvars->pyquil==2.0.0.dev0)\n",
      "Requirement already up-to-date: setuptools in /opt/conda/lib/python3.6/site-packages (from kiwisolver>=1.0.1->matplotlib)\n",
      "Installing collected packages: pyquil\n",
      "  Found existing installation: pyquil 2.0.0.dev0\n",
      "    Uninstalling pyquil-2.0.0.dev0:\n",
      "      Successfully uninstalled pyquil-2.0.0.dev0\n",
      "  Running setup.py install for pyquil ... \u001b[?25ldone\n",
      "\u001b[?25hSuccessfully installed pyquil-2.0.0.dev0\n",
      "\u001b[33mYou are using pip version 9.0.3, however version 10.0.1 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "!pip install --upgrade https://github.com/rigetticomputing/pyquil/archive/master.zip networkx matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "API_KEY = ''\n",
    "USER_ID = ''\n",
    "\n",
    "PYQUIL_CONFIG = f\"\"\"\n",
    "[Rigetti Forest]\n",
    "url: https://api.rigetti.com/qvm\n",
    "key: {API_KEY}\n",
    "user_id: {USER_ID}\n",
    "\"\"\"\n",
    "\n",
    "with open(os.path.expanduser('~/.pyquil_config'), 'w') as f:\n",
    "    f.write(PYQUIL_CONFIG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### QPU status\n",
    "\n",
    "The QPU devices can have different status and are not always immediatelly accessible. Luckily, you can inspect this information via Forest API."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4.1\n",
    "Use `pyquil.api` module to obtain list of available devices. Only list the devices that are currently online. What other states can devices be in?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All devices: [<Device 8Q-Agave online>, <Device 19Q-Acorn offline>]\n",
      "Online devices: [<Device 8Q-Agave online>]\n"
     ]
    }
   ],
   "source": [
    "import pyquil\n",
    "devices = list(pyquil.api.get_devices(as_dict=True).values())\n",
    "online_devices = [device for device in devices if device.is_online()]\n",
    "\n",
    "print(f\"All devices: {devices}\")\n",
    "print(f\"Online devices: {online_devices}\")\n",
    "\n",
    "# Device can be in the online, offline or retuning state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chip topology\n",
    "\n",
    "Knowing qubit topology of the chip you're working with is an important requirement to be able to design efficient circuits. Forest API provides an interface that exposes this information as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "#### Exercise 4.2\n",
    "Use <a href=\"https://pyquil.readthedocs.io/en/latest\">Rigetti's documentation</a> to obtain and plot the topology of the `8Q-Agave` chip."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyquil\n",
    "device = pyquil.api.get_devices(as_dict=True)['8Q-Agave']\n",
    "data = device.isa.to_dict()\n",
    "nodes = [key for key, value in data['1Q'].items()]\n",
    "edges = [tuple(key.split('-')) for key, value in data['2Q'].items()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import networkx\n",
    "G = networkx.Graph()\n",
    "G.add_nodes_from(nodes)\n",
    "G.add_edges_from(edges)\n",
    "networkx.draw(G, with_labels=True, font_weight='bold')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4.3\n",
    "Rigetti also has a newer chip, called `19Q-Acorn`, which is currently offline (as you learned in the exercise 4.1) due to high number of malfunctioning qubits/couplings after a power outage incident. Obtain and plot the topology of the `19Q-Acorn` chip. Note that malfunctioning parts of the chip are marked as \"dead\", make sure to exclude those."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyquil\n",
    "device = pyquil.api.get_devices(as_dict=True)['19Q-Acorn']\n",
    "data = device.isa.to_dict()\n",
    "nodes = [key for key, value in data['1Q'].items() if 'dead' not in value]\n",
    "edges = [tuple(key.split('-')) for key, value in data['2Q'].items() if 'dead' not in value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import networkx\n",
    "G = networkx.Graph()\n",
    "G.add_nodes_from(nodes)\n",
    "G.add_edges_from(edges)\n",
    "networkx.draw(G, with_labels=True, font_weight='bold')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decoherence and circuit depth\n",
    "\n",
    "One of the main limiting factors if current near-term devices is actual decoherence of the qubits in the device. Decoherence can be loosely interpreted as loss of the quantum information in the qubit, and is caused by imperfections in the implementations of the quantum gates, or due to simple time-evolution of the system, as any current quantum chip is necessarily an open quantum system to a certain degree.\n",
    "\n",
    "Generally, there are three sources of errors in the implementation of a given quantum circuit:\n",
    "* actual qubit decoherence due to time-evolution (i.e. noise, interactions with environment)\n",
    "* imprecise gate implementations (gates that do not have fidelities of 1)\n",
    "* readout errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### T_1 and T_2 times\n",
    "$T_1$ and $T_2$ relaxation times are one of the basic measures of performance of qubits in terms of decoherence. Roughly speaking:\n",
    "\n",
    "* $T_1$ relaxation time (also called the \"amplitude damping\") is time during which the qubit decoheres from its excited state $\\ket{1}$ to relaxed state $\\ket{0}$.\n",
    "* $T_2$ relaxation time (also called the \"phase damping\") can be measured using the following experiment: First you put the qubit into the superposition state $\\frac{\\ket{0}+\\ket{1}}{\\sqrt{2}}$ using a Hadamard gate, then you wait for $t_2$ and apply a Hadamard gate again. Without any noise, you would expect the state to be $\\ket{0}$ again (remember $H^2 = I$), but if something caused the qubit to decohere to either $\\ket{0}$ or $\\ket{1}$ in the meantime, you will obtain the $\\frac{\\ket{0}\\pm\\ket{1}}{\\sqrt{2}}$ instead.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4.4\n",
    "\n",
    "Use the device specifications of the $T_1$ times `8Q-Agave` chip obtained via the API, determine a simple upper bound on the single-qubit and two-qubit circuit depth on qubit 7 (assuming zero readout error and perfect-fidelity gates).\n",
    "\n",
    "The average gate execution time of single qubit gate is 50ns and 150ns for the case of two-qubit gate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Single qubit gate depth: 264\n",
      "Two qubit gate depth: 88\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import pyquil\n",
    "device = pyquil.api.get_devices(as_dict=True)['8Q-Agave']\n",
    "single_qubit_depth = device.specs.T1s()[7] / 50e-9\n",
    "two_qubit_depth = device.specs.T1s()[7] / 150e-9\n",
    "print(f\"\"\"\n",
    "Single qubit gate depth: {single_qubit_depth:.0f}\n",
    "Two qubit gate depth: {two_qubit_depth:.0f}\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Noise models\n",
    "Simple estimation as given in the previous exercise provide a generous upper bound, since they neglect other source of errors in the computation, such as the readout errors or gate fidelities. To use a noise model, simply specify a device during definition of the QVMConnection object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4.5\n",
    "\n",
    "Implement a simple circuit consisting of 20 alternating CNOT gates (swtiching between control qubit on 0 and 1). Empirically measure its performance (how many runs out of 1000 did not end up in the expected state)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.174"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pyquil\n",
    "from pyquil.quil import Program\n",
    "from pyquil.gates import CNOT, MEASURE\n",
    "program = Program(\n",
    "    CNOT(i%2, (i+1)%2) for i in range(20)\n",
    ") + Program(MEASURE(0, 0), MEASURE(1, 1))\n",
    "\n",
    "device = pyquil.api.get_devices(as_dict=True)['8Q-Agave']\n",
    "qvm = pyquil.api.QVMConnection(device=device)\n",
    "results = qvm.run(program, trials=1000)\n",
    "incorrect_results = [r for r in results if r != [0, 0]]\n",
    "len(incorrect_results) / 1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Increase the number of gates to 100 and then 200. How do you interpret the results?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manually triggered compilation\n",
    "\n",
    "In the usual setting of submitting jobs to the QPU, the compilation is happening transparently, without the user of the Forest API needing to know that the circuit they constructed is decomposed into sequence of gate operations that are actually implemented on the hardware.\n",
    "\n",
    "Similiarly, in order to accurately simulate the device with the noise, the circuits also have to be compiled to the fundamental gate set implemented by the chip, since those gates are the ones we have experimental information about.\n",
    "\n",
    "Given both these cases, it is useful to be able to actually inspect and analyze the compiled version of the circuit - since that is what is exactly being run on the device."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4.6\n",
    "\n",
    "Compile circuit from the previous exercise using the CompilerConnection object. Inspect the compiler circuit, and figure out if anything is surprising. Contrast with the result of the previous exercise. Does this explain any surprising results?\n",
    "\n",
    "Additionally, figure out the following parameters of the compiled circuit:\n",
    "* gate depth\n",
    "* two-qubit gate depth\n",
    "* total number of gates used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "job joxFSjiarDSkhPSu is currently compiling\n",
      "PRAGMA EXPECTED_REWIRING \"#(0 1 2 3 4 5 6 7)\"\n",
      "RZ(-1.5707963267948992) 0\n",
      "RX(pi/2) 0\n",
      "RZ(2.888982866515854) 0\n",
      "RX(pi/2) 0\n",
      "RZ(2.7749508004150574) 1\n",
      "RX(1.5707963267948946) 1\n",
      "CZ 0 1\n",
      "RX(pi/2) 0\n",
      "RX(-1.570796326794895) 1\n",
      "CZ 0 1\n",
      "RX(-pi/2) 0\n",
      "RZ(-2.7749508004150574) 0\n",
      "RZ(3.141592653589791) 1\n",
      "RX(pi/2) 1\n",
      "RZ(0.25260978707393816) 1\n",
      "RX(-pi/2) 1\n",
      "RZ(1.5707963267948977) 1\n",
      "PRAGMA CURRENT_REWIRING \"#(0 1 2 3 4 5 6 7)\"\n",
      "PRAGMA EXPECTED_REWIRING \"#(0 1 2 3 4 5 6 7)\"\n",
      "PRAGMA CURRENT_REWIRING \"#(0 1 2 3 4 5 6 7)\"\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import pyquil\n",
    "from pyquil.api import CompilerConnection, get_devices\n",
    "from pyquil.gates import CNOT\n",
    "\n",
    "device = pyquil.api.get_devices(as_dict=True)['8Q-Agave']\n",
    "compiler = pyquil.api.CompilerConnection(device=device)\n",
    "\n",
    "program = Program(CNOT(i%2, (i+1)%2) for i in range(20))\n",
    "job_id = compiler.compile_async(program)\n",
    "job = compiler.wait_for_job(job_id)\n",
    "\n",
    "print(job.compiled_quil())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Gate depth: 12\n",
      "Multi-qubit gate depth: 2\n",
      "Program fidelity: 0.703\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(f'''\n",
    "Gate depth: {job.gate_depth()}\n",
    "Multi-qubit gate depth: {job.multiqubit_gate_depth()}\n",
    "Program fidelity: {job.program_fidelity():.3f}\n",
    "''')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4.7\n",
    "Inspect the following circuit. Compile it to the `8Q-Agave` device. How does the compiled version differ from the uncompiled one?\n",
    "\n",
    "```\n",
    "H 2\n",
    "H 4\n",
    "H 7\n",
    "CNOT 2 4\n",
    "CNOT 4 7\n",
    "CNOT 2 4\n",
    "H 7\n",
    "H 4\n",
    "H 2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "job lHgXqzpnChxVdpEz is currently compiling\n",
      "PRAGMA EXPECTED_REWIRING \"#(0 1 3 2 4 6 7 5)\"\n",
      "RZ(pi/2) 3\n",
      "RX(pi/2) 3\n",
      "RX(-pi) 4\n",
      "CZ 4 3\n",
      "RZ(-pi/2) 4\n",
      "RX(-pi/2) 4\n",
      "RX(-pi) 5\n",
      "CZ 5 4\n",
      "RZ(-pi) 4\n",
      "RX(pi/2) 4\n",
      "CZ 4 3\n",
      "RZ(-pi) 3\n",
      "RX(pi/2) 3\n",
      "RZ(pi/2) 3\n",
      "RZ(pi/2) 4\n",
      "RX(-pi) 4\n",
      "RX(-pi) 5\n",
      "PRAGMA CURRENT_REWIRING \"#(0 1 3 2 4 6 7 5)\"\n",
      "PRAGMA EXPECTED_REWIRING \"#(0 1 3 2 4 6 7 5)\"\n",
      "PRAGMA CURRENT_REWIRING \"#(0 1 3 2 4 6 7 5)\"\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import pyquil\n",
    "from pyquil.api import CompilerConnection, get_devices\n",
    "\n",
    "device = pyquil.api.get_devices(as_dict=True)['8Q-Agave']\n",
    "compiler = pyquil.api.CompilerConnection(device=device)\n",
    "\n",
    "program = Program(\"\"\"\n",
    "H 2\n",
    "H 4\n",
    "H 7\n",
    "CNOT 2 4\n",
    "CNOT 4 7\n",
    "CNOT 2 4\n",
    "H 7\n",
    "H 4\n",
    "H 2\n",
    "\"\"\")\n",
    "job_id = compiler.compile_async(program, isa=device.isa)\n",
    "job = compiler.wait_for_job(job_id)\n",
    "\n",
    "print(job.compiled_quil())"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}