community/terra/qis_adv/vaidman_detection_test.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../../../images/qiskit-heading.gif\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" width=\"500 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _*The Vaidman Detection Test: Interaction Free Measurement*_ \n",
    "\n",
    "The latest version of this notebook is available on https://github.com/Qiskit/qiskit-tutorial.\n",
    "\n",
    "***\n",
    "### Contributors\n",
    "Alex Breitweiser"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "One surprising result of quantum mechanics is the ability to measure something without ever directly \"observing\" it. This interaction-free measurement cannot be reproduced in classical mechanics. The prototypical example is the [Elitzur–Vaidman Bomb Experiment](https://en.wikipedia.org/wiki/Elitzur%E2%80%93Vaidman_bomb_tester) - in which one wants to test whether bombs are active without detonating them. In this example we will test whether an unknown operation is null (the identity) or an X gate, corresponding to a dud or a live bomb.\n",
    "\n",
    "### The Algorithm\n",
    "The algorithm will use two qubits, $q_1$ and $q_2$, as well as a small parameter, $\\epsilon = \\frac{\\pi}{n}$ for some integer $n$. Call the unknown gate, which is either the identity or an X gate, $G$, and assume we have it in a controlled form. The algorithm is then:\n",
    "1. Start with both $q_1$ and $q_2$ in the $|0\\rangle$ state\n",
    "2. Rotate $q_1$ by $\\epsilon$ about the Y axis\n",
    "3. Apply a controlled $G$ on $q_2$, conditioned on $q_1$\n",
    "4. Measure $q_2$\n",
    "5. Repeat (2-4) $n$ times\n",
    "6. Measure $q_1$\n",
    "\n",
    "![Algorithm Depiction](http://i.imgur.com/sG8Pa3J.jpg)\n",
    "\n",
    "### Explanation and proof of correctness\n",
    "There are two cases: Either the gate is the identity (a dud), or it is an X gate (a live bomb).\n",
    "#### Case 1: Dud\n",
    "After rotation, $q_1$ is now approximately\n",
    "$$q_1 \\approx |0\\rangle + \\frac{\\epsilon}{2} |1\\rangle$$\n",
    "Since the unknown gate is the identity, the controlled gate leaves the two qubit state separable,\n",
    "$$q_1 \\times q_2 \\approx (|0\\rangle + \\frac{\\epsilon}{2} |1\\rangle) \\times |0\\rangle$$\n",
    "and measurement is trivial (we will always measure $|0\\rangle$ for $q_2$).\n",
    "Repetition will not change this result - we will always keep separability and $q_2$ will remain in $|0\\rangle$.\n",
    "After n steps, $q_1$ will flip by $\\pi$ to $|1\\rangle$, and so measuring it will certainly yield $1$. Therefore, the output register for a dud bomb will read:\n",
    "$$000...01$$\n",
    "#### Case 2: Live\n",
    "Again, after rotation, $q_1$ is now approximately\n",
    "$$q_1 \\approx |0\\rangle + \\frac{\\epsilon}{2} |1\\rangle$$\n",
    "But, since the unknown gate is now an X gate, the combined state after $G$ is now\n",
    "$$q_1 \\times q_2 \\approx |00\\rangle + \\frac{\\epsilon}{2} |11\\rangle$$\n",
    "Measuring $q_2$ now might yield $1$, in which case we have \"measured\" the live bomb (obtained a result which differs from that of a dud) and it explodes. However, this only happens with a probability proportional to $\\epsilon^2$. In the vast majority of cases, we will measure $0$ and the entire system will collapse back to\n",
    "$$q_1 \\times q_2 = |00\\rangle$$\n",
    "After every step, the system will most likely return to the original state, and the final measurement of $q_1$ will yield $0$. Therefore, the most likely outcome of a live bomb is\n",
    "$$000...00$$\n",
    "which will identify a live bomb without ever \"measuring\" it. If we ever obtain a 1 in the bits preceding the final bit, we will have detonated the bomb, but this will only happen with probability of order\n",
    "$$P \\propto n \\epsilon^2 \\propto \\epsilon$$\n",
    "This probability may be made arbitrarily small at the cost of an arbitrarily long circuit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generating Random Bombs\n",
    "A test set must be generated to experiment on - this can be done by classical (pseudo)random number generation, but as long as we have access to a quantum computer we might as well take advantage of the ability to generate true randomness."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# useful additional packages \n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "from collections import Counter #Use this to convert results from list to dict for histogram\n",
    "\n",
    "# importing QISKit\n",
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "from qiskit import execute, Aer, IBMQ\n",
    "from qiskit.backends.ibmq import least_busy\n",
    "\n",
    "# import basic plot tools\n",
    "from qiskit.tools.visualization import plot_histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To use IBMQ Quantum Experience\n",
    "IBMQ.load_accounts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will generate a test set of 50 \"bombs\", and each \"bomb\" will be run through a 20-step measurement circuit. We set up the program as explained in previous examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use local qasm simulator\n",
    "backend = Aer.get_backend('qasm_simulator')\n",
    "\n",
    "# Use the IBMQ Quantum Experience\n",
    "# backend = least_busy(IBMQ.backends())\n",
    "\n",
    "N = 50 # Number of bombs\n",
    "steps = 20 # Number of steps for the algorithm, limited by maximum circuit depth\n",
    "eps = np.pi / steps # Algorithm parameter, small\n",
    "\n",
    "# Prototype circuit for bomb generation\n",
    "q_gen = QuantumRegister(1, name='q_gen')\n",
    "c_gen = ClassicalRegister(1, name='c_gen')\n",
    "IFM_gen = QuantumCircuit(q_gen, c_gen, name='IFM_gen')\n",
    "\n",
    "# Prototype circuit for bomb measurement\n",
    "q = QuantumRegister(2, name='q')\n",
    "c = ClassicalRegister(steps+1, name='c')\n",
    "IFM_meas = QuantumCircuit(q, c, name='IFM_meas')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generating a random bomb is achieved by simply applying a Hadamard gate to a $q_1$, which starts in $|0\\rangle$, and then measuring. This randomly gives a $0$ or $1$, each with equal probability. We run one such circuit for each bomb, since circuits are currently limited to a single measurement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Quantum circuits to generate bombs\n",
    "qc = []\n",
    "circuits = [\"IFM_gen\"+str(i) for i in range(N)]\n",
    "# NB: Can't have more than one measurement per circuit\n",
    "for circuit in circuits:\n",
    "    IFM = QuantumCircuit(q_gen, c_gen, name=circuit)\n",
    "    IFM.h(q_gen[0]) #Turn the qubit into |0> + |1>\n",
    "    IFM.measure(q_gen[0], c_gen[0])\n",
    "    qc.append(IFM)\n",
    "_ = [i.qasm() for i in qc] # Suppress the output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that, since we want to measure several discrete instances, we do *not* want to average over multiple shots. Averaging would yield partial bombs, but we assume bombs are discretely either live or dead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11bc24208>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "result = execute(qc, backend=backend, shots=1).result() # Note that we only want one shot\n",
    "bombs = []\n",
    "for circuit in qc:\n",
    "    for key in result.get_counts(circuit): # Hack, there should only be one key, since there was only one shot\n",
    "        bombs.append(int(key))\n",
    "#print(', '.join(('Live' if bomb else 'Dud' for bomb in bombs))) # Uncomment to print out \"truth\" of bombs\n",
    "plot_histogram(Counter(('Live' if bomb else 'Dud' for bomb in bombs))) #Plotting bomb generation results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing the Bombs\n",
    "\n",
    "Here we implement the algorithm described above to measure the bombs. As with the generation of the bombs, it is currently impossible to take several measurements in a single circuit - therefore, it must be run on the simulator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use local qasm simulator\n",
    "backend = Aer.get_backend('qasm_simulator')\n",
    "\n",
    "qc = []\n",
    "circuits = [\"IFM_meas\"+str(i) for i in range(N)]\n",
    "#Creating one measurement circuit for each bomb\n",
    "for i in range(N):\n",
    "    bomb = bombs[i]\n",
    "    IFM = QuantumCircuit(q, c, name=circuits[i])\n",
    "    for step in range(steps):\n",
    "        IFM.ry(eps, q[0]) #First we rotate the control qubit by epsilon\n",
    "        if bomb: #If the bomb is live, the gate is a controlled X gate\n",
    "            IFM.cx(q[0],q[1])\n",
    "        #If the bomb is a dud, the gate is a controlled identity gate, which does nothing\n",
    "        IFM.measure(q[1], c[step]) #Now we measure to collapse the combined state\n",
    "    IFM.measure(q[0], c[steps])\n",
    "    qc.append(IFM)\n",
    "_ = [i.qasm() for i in qc] # Suppress the output\n",
    "result = execute(qc, backend=backend, shots=1, max_credits=5).result()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xa1f25ae48>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def get_status(counts):\n",
    "    # Return whether a bomb was a dud, was live but detonated, or was live and undetonated\n",
    "    # Note that registers are returned in reversed order\n",
    "    for key in counts:\n",
    "        if '1' in key[1:]:\n",
    "             #If we ever measure a '1' from the measurement qubit (q1), the bomb was measured and will detonate\n",
    "            return '!!BOOM!!'\n",
    "        elif key[0] == '1':\n",
    "            #If the control qubit (q0) was rotated to '1', the state never entangled because the bomb was a dud\n",
    "            return 'Dud'\n",
    "        else:\n",
    "            #If we only measured '0' for both the control and measurement qubit, the bomb was live but never set off\n",
    "            return 'Live'\n",
    "\n",
    "results = {'Live': 0, 'Dud': 0, \"!!BOOM!!\": 0}\n",
    "for circuit in qc:\n",
    "    status = get_status(result.get_counts(circuit))\n",
    "    results[status] += 1\n",
    "plot_histogram(results)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda env:qiskit]",
   "language": "python",
   "name": "conda-env-qiskit-py"
  },
  "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": 1
}