{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": "![(book cover)](https://covers.oreillystatic.com/images/0636920167433/cat.gif \"(book cover)\")\n### **Programming Quantum Computers** by O'Reilly Media -  [**book Info**](http://shop.oreilly.com/product/0636920167433.do)  - [**all code samples**](https://oreilly-qc.github.io)\n\n#### **Code samples for Chapter 4**\nThese code samples were written by Eric Johnston, Nic Harrigan, and Mercedes Gimeno-Segovia."
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ, BasicAer\nimport math\nimport time\n%matplotlib inline"
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "counts: {'0 1 0': 1}\n[0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]\n"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": "<Figure size 1384.6x800.66 with 1 Axes>"
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": "## Example 4-1: Basic Teleportation\n\n# Set up the program\nalice = QuantumRegister(1, name='alice')\nep    = QuantumRegister(1, name='ep')\nbob   = QuantumRegister(1, name='bob')\nalice_c = ClassicalRegister(1, name='alicec')\nep_c    = ClassicalRegister(1, name='epc')\nbob_c   = ClassicalRegister(1, name='bobc')\nqc = QuantumCircuit(alice, ep, bob, alice_c, ep_c, bob_c)\n\n# entangle\nqc.h(ep)\nqc.cx(ep, bob)\nqc.barrier()\n\n# prep payload\nqc.reset(alice)\nqc.h(alice)\nqc.rz(math.radians(45), alice)\nqc.h(alice)\nqc.barrier()\n\n# send\nqc.cx(alice, ep)\nqc.h(alice)\nqc.measure(alice, alice_c)\nqc.measure(ep, ep_c)\nqc.barrier()\n\n# receive\nqc.z(bob).c_if(alice_c, 1)\nqc.x(bob).c_if(ep_c, 1)\n\n# verify\nqc.h(bob)\nqc.rz(math.radians(-45), bob)\nqc.h(bob)\nqc.measure(bob, bob_c)\n\n## That's the program. Everything below runs and draws it.\n\nbackend = BasicAer.get_backend('statevector_simulator')\njob = execute(qc, backend)\nresult = job.result()\n\ncounts = result.get_counts(qc)\nprint('counts:',counts)\n\noutputstate = result.get_statevector(qc, decimals=3)\nprint(outputstate)\nqc.draw()        # draw the circuit"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": "#######################################################\n## Example 4-2: A Fly in the Teleporter\n##\n## This is a fun and horrifying example from the\n## teleportation chapter.\n\n#######################################################\n## UNDER CONSTRUCTION // UNDER CONSTRUCTION // \n## I'm still working on porting this sample. - ej\n\n#### CAUTION: This sample is big, and may take several seconds to execute.\n####          It may even fail on some smaller devices (e-readers, etc.)\n\n## This is the left half of the pixels of the fly,\n## encoded as an 8x16 array:\nnum_fly_qubits = 8\nimage = [ '........',\n          '...X....',\n          '....X.XX',\n          '.....XXX',\n          '....XXXX',\n          'XX...XXX',\n          '..XXX.XX',\n          '...X....',\n          '..X...XX',\n          '.X...XXX',\n          'X....XXX',\n          'X..XXXXX',\n          '.XXX.XXX',\n          '...X..XX',\n          '..X.....',\n          '........']\n\n## This is the classic teleport example, but with an interesting\n## payload, and some controllable error.\nteleport_error = 0.0   ## <--- change this number to 0.1 or more\ndo_teleport = False     ## Enables the teleporter\n\n# Set up the program\nfly     = QuantumRegister(8, name='fly')\nepair1  = QuantumRegister(8, name='epair1')\nepair2  = QuantumRegister(8, name='epair2')\nscratch = QuantumRegister(4, name='scratch')\nsend0_c = ClassicalRegister(8, name='send0c')\nsend1_c = ClassicalRegister(8, name='send1c')\nqc = QuantumCircuit(fly, epair1, epair2, send0_c, send1_c)\n\nlast_not = 0\n\ndef main():\n    prepare_fly(fly)\n    if do_teleport:\n        entangle_pair(epair1, epair2)\n        send_payload(fly, epair1, [send0_c, send1_c])\n        apply_error(epair2, teleport_error)\n        receive_payload(epair2, [send0_c, send1_c])\n\ndef entangle_pair(ep1, ep2):\n    ## Create all the entangled qubits we need to teleport this object.    \n    qc.h(ep1)\n    qc.cx(ep1, ep2)\n    qc.barrier()\n\ndef prepare_fly(fly):\n    ## Encode the fly pixels into relative phases in a\n    ## quantum superposition\n    global last_not\n    qc.h(fly)\n    for y in range(len(image)):\n        for x in range(len(image[0])):\n            if (image[y][x] == 'X'):\n                pixel(fly, x + 0, y)\n    # TODO: translate these lines\n    for i in range(num_fly_qubits):\n        if (1 << i) & last_not:\n            qc.x(fly[i])\n    # Reflect to get both halves\n    qc.cx(fly[3], fly[0])\n    qc.cx(fly[3], fly[1])\n    qc.cx(fly[3], fly[2])\n\n    # Grover to turn the phase diffs into amp diffs\n    Grover(fly)\n\n    ## At this point, reading the \"fly\" register would be very likely\n    ## to return the coordinates of one of the pixels in the fly.\n    qc.barrier()\n\ndef pixel(obj, x, y):\n    ## Given x and y, flip the phase of one term\n    ## Note: last_not is used to avoid redundant NOT gates\n    global last_not\n    val = ~((y << 4) | x)\n    for i in range(num_fly_qubits):\n        if (1 << i) & (val ^ last_not):\n            qc.x(obj[i])\n    last_not = val\n    multi_cz([obj[0], obj[1], obj[2], obj[3], obj[5], obj6], obj[7]])\n#    obj.cphase(180, ~0x8) # TODO: Translate this line\n\ndef send_payload(payload, ep, digital_bits):\n    ## Entangle the payload with half of the e-pair, and then vaporize it!\n    qc.cx(payload, ep)\n    qc.h(payload)\n    qc.measure(payload, digital_bits[0])\n    qc.measure(ep, digital_bits[1])\n    qc.barrier()\n\ndef apply_error(qubits, error_severity):\n    ## Apply some unpredictable noise to the system\n    qc.rx(error_severity, qubits);\n    qc.barrier();\n\ndef receive_payload(ep, digital_bits):\n    ## Teleport receiver applies the correct operations based on\n    ## the digital data. Note that in this example we *could*\n    ## use postselection, but would only succeed once every 65,536\n    ## tries, on average.\n    for i in range(num_fly_qubits):\n        qc.x(ep[i]).c_if(digital_bits[1][i], 1)\n        qc.z(ep[i]).c_if(digital_bits[0][i], 1)\n    qc.barrier()\n\ndef Grover(qreg, condition_qubits=None):\n    if condition_qubits is None:\n        condition_qubits = []\n    qc.h(qreg)\n    qc.x(qreg)\n    multi_cz([x for x in qreg] + condition_qubits)\n    qc.x(qreg)\n    qc.h(qreg)\n\ndef multi_cz(qubits):\n    ## This will perform a CCCCCZ on as many qubits as we want,\n    ## as long as we have enough scratch qubits\n    multi_cx(qubits, do_cz=True)\n\ndef multi_cx(qubits, do_cz=False):\n    ## This will perform a CCCCCX with as many conditions as we want,\n    ## as long as we have enough scratch qubits\n    ## The last qubit in the list is the target.\n    target = qubits[-1]\n    conds = qubits[:-1]\n    scratch_index = 0\n    ops = []\n    while len(conds) > 2:\n        new_conds = []\n        for i in range(len(conds)//2):\n            ops.append((conds[i * 2], conds[i * 2 + 1], scratch[scratch_index]))\n            new_conds.append(scratch[scratch_index])\n            scratch_index += 1\n        if len(conds) & 1:\n            new_conds.append(conds[-1])\n        conds = new_conds\n    for op in ops:\n        qc.ccx(op[0], op[1], op[2])\n    if do_cz:\n        qc.h(target)\n    if len(conds) == 0:\n        qc.x(target)\n    elif len(conds) == 1:\n        qc.cx(conds[0], target)\n    else:\n        qc.ccx(conds[0], conds[1], target)\n    if do_cz:\n        qc.h(target)\n    ops.reverse()\n    for op in ops:\n        qc.ccx(op[0], op[1], op[2])\n\nmain()\n\n## That's the program. Everything below runs and draws it.\n## TODO: A nice way to draw the fly here.\n\nbackend = BasicAer.get_backend('statevector_simulator')\ntic = time.time()\njob = execute(qc, backend)\nresult = job.result()\ntoc = time.time()\nprint('Finished in {} seconds'.format(toc - tic))\n\ncounts = result.get_counts(qc)\nprint('counts:',counts)\n\noutputstate = result.get_statevector(qc, decimals=3)\nprint(outputstate)\nqc.draw()        # draw the circuit"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "trusted": true
      },
      "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": 2
}