The_Third_Kind.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QmxEttcelQz_"
      },
      "source": [
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qEmJ1iv4Jn5_"
      },
      "source": [
        "# Welcome Alice!\n",
        "\n",
        "Let's start your journey! Read the challenge descriptions and follow the instructions in each **task** to finish the challenge. Be sure to complete the **task** in the marked area! You can check if you completed all the **tasks** successfully by checking if the **tests** run successfully. Passing a **test** means that you have completed the challenge successfully! \n",
        "\n",
        "Now, let's start with...\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a9wLtw2kK8W_"
      },
      "source": [
        "<h1>Quantum Teleportation</h1>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J0N488w4cXa9"
      },
      "source": [
        "In this challenge, you will create a quantum teleportation circuit. First, complete the setup in the code block below. You will only need to do this once! If done correctly, we can use this to prove that the message has arrived from Bob's spaceship!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JETyhMPQ5nmH",
        "outputId": "9a9b6fab-1219-4cc0-d2dc-a42725041a23"
      },
      "outputs": [],
      "source": [
        "# Setup\n",
        "# Uncomment if you don't have these installed!\n",
        "# %pip install qiskit\n",
        "# %pip install pylatexenc\n",
        "# %pip install ibm_quantum_widgets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1J1HwEG_LS8s"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "\n",
        "from pylatexenc import *\n",
        "from ibm_quantum_widgets import *\n",
        "from numpy.random import randint\n",
        "\n",
        "from qiskit import *\n",
        "from qiskit.visualization import *\n",
        "from qiskit.result import marginal_counts\n",
        "from qiskit.quantum_info import Operator\n",
        "from qiskit.tools.jupyter import *\n",
        "from qiskit.providers.aer import QasmSimulator\n",
        "from qiskit.tools.visualization import plot_histogram, plot_bloch_multivector,  array_to_latex\n",
        "from qiskit.quantum_info import Statevector"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JuQZG2rFLBsX"
      },
      "outputs": [],
      "source": [
        "qr = QuantumRegister(3)\n",
        "cr = ClassicalRegister(3)\n",
        "qc = QuantumCircuit(qr,cr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 231
        },
        "id": "lNOiHmzQ_QXz",
        "outputId": "5c7bda87-b0d7-422f-e8cb-ff2f4f7dbb95"
      },
      "outputs": [],
      "source": [
        "# TASK:\n",
        "# Initialise qubit 0 to |1>\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "qc.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 231
        },
        "id": "8bRLbNKs_VRw",
        "outputId": "dea6fcac-bafe-4e2f-a86e-759ef519c325"
      },
      "outputs": [],
      "source": [
        "# TASK:\n",
        "# Create a Bell state between qubits 1 and 2\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "qc.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 231
        },
        "id": "0c_ZARtY_YgH",
        "outputId": "e43086fc-bc08-4931-8c75-5956b41df740"
      },
      "outputs": [],
      "source": [
        "qc.barrier()\n",
        "\n",
        "# TASK:\n",
        "# Establish the teleportation protocol between qubits 0 and 1.\n",
        "# This involves creating a controlled not gate between qubits 0 and 1,\n",
        "# followed by a Hadamard gate on qubit 0.\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "qc.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 231
        },
        "id": "lMHt3je3_bGn",
        "outputId": "310968fd-0eac-4e35-a50b-a9ea09b3b78f"
      },
      "outputs": [],
      "source": [
        "qc.barrier()\n",
        "\n",
        "# TASK:\n",
        "# Measure qubits 0 and 1\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "qc.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 231
        },
        "id": "gIAilgGt_dfy",
        "outputId": "53b2e728-2dc9-4063-f42f-99707975515a"
      },
      "outputs": [],
      "source": [
        "# Decoding\n",
        "\n",
        "qc.barrier()\n",
        "\n",
        "# TASK:\n",
        "# Now, let us decode the message!\n",
        "# If qubit 0 is in state |1>, apply a Z gate on qubit 2.\n",
        "# If qubit 1 is in state |1>, apply a X gate on qubit 2.\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "qc.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 231
        },
        "id": "gPXLC5Tx3RiE",
        "outputId": "d90d416e-71dd-4003-8f3e-cfbb01883753"
      },
      "outputs": [],
      "source": [
        "# TASK:\n",
        "# Measure qubit 2\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "qc.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 340
        },
        "id": "Eq6iz6s6_kx1",
        "outputId": "15cc5a0b-3451-498b-b076-9076ae05e566"
      },
      "outputs": [],
      "source": [
        "backend=Aer.get_backend('qasm_simulator')\n",
        "outputs=execute(qc,backend,shots=1000).result()\n",
        "results=outputs.get_counts()\n",
        "plot_histogram(results)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Eysk3wvg3Ywj",
        "outputId": "f8d8757a-7b6e-4e6f-b80a-eb1cfc9f9d5e"
      },
      "outputs": [],
      "source": [
        "sim = Aer.get_backend('aer_simulator')\n",
        "t_qc = transpile(qc, sim)\n",
        "counts = sim.run(t_qc).result().get_counts()\n",
        "# Showing only second qubit as result\n",
        "qubit_counts = [marginal_counts(counts, [qubit]) for qubit in range(2,3)]\n",
        "\n",
        "# TEST!\n",
        "assert qubit_counts[0][\"1\"] == 1024, \"Your circuit is incorrect!\"\n",
        "\n",
        "plot_histogram(qubit_counts)\n",
        "\n",
        "print(\"The signal originated from Bob's ship!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HtU_Qv4rw7PJ"
      },
      "source": [
        "Great job! However, just because we know that the message came from Bob's spaceship $\\gamma$ does not mean that the message came from Bob himself! After all, Eve is a very cunning enemy. To prove that it really is Bob, we need the next algorithm, which is..."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ik9xBiGhxDj1"
      },
      "source": [
        "<h1>Bernstein-Vazirani Algorithm</h1>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IYx7cYyr3SB_"
      },
      "source": [
        "All of the commanders have their own secret code, and we will now use the Bernstein-Vazirani algorithm to receive the secret code from $\\gamma$. If this matches Bob's secret code, we will know for sure that it is Bob who is contacting us!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 276
        },
        "id": "nQIPoj2lREda",
        "outputId": "6f5a2b7b-281a-47bd-9072-41e65d8874b4"
      },
      "outputs": [],
      "source": [
        "n = 3\n",
        "circuit = QuantumCircuit(n+1,n)\n",
        "circuit.x(n) \n",
        "circuit.barrier() \n",
        "circuit.h(range(n+1)) \n",
        "circuit.barrier() \n",
        "\n",
        "circuit.cx(1,3)\n",
        "    \n",
        "circuit.barrier() \n",
        "\n",
        "# Bob has sent you a secret message!\n",
        "\n",
        "# TASK:\n",
        "# Apply a Hadamard Gate to all the qubits and then measure qubits 0 through 2 to decode the secret message.\n",
        "\n",
        "# Enter your code below this line \n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "circuit.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b-R2zmhfDS-m",
        "outputId": "8cbaf7ce-762b-4c9c-8f5d-e90f906a32b0"
      },
      "outputs": [],
      "source": [
        "simulator = Aer.get_backend('qasm_simulator')\n",
        "result = execute(circuit, backend=simulator, shots=1).result()\n",
        "plot_histogram(result.get_counts(circuit))\n",
        "\n",
        "counts = result.get_counts(circuit)\n",
        "Signal = str(list(counts)[0])\n",
        "print(f'The sent signal was {Signal}.')\n",
        "\n",
        "ids = {\"001\": \"Alice\", \"010\": \"Bob\", \"111\": \"Charlie\", \"101\": \"Danielle\", \"000\": \"Ethan\", \"100\": \"Freya\", \"011\": \"Grace\"}\n",
        "\n",
        "# TEST!\n",
        "assert ids[Signal] == \"Bob\", \"Your code is incorrect!\"\n",
        "\n",
        "print(\"The signal was sent by \" + ids[Signal] + \".\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vlq_4aofwt5l"
      },
      "source": [
        "<h1> Quantum Key Distribution </h1>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ITbNfsfnqrVa"
      },
      "source": [
        "As great as the Bernstein-Vazirani algorithm is, it has its flaws. If Bob sends us a message, Eve can read that message too!\n",
        "\n",
        "If done correctly, we can create a secret key with which we can encrypt messages, and we can do so over classical channels! If Eve is intercepting our secret key, we will know in advance!\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dHcSeK8JKr7T"
      },
      "outputs": [],
      "source": [
        "def encode_message(bits, bases):\n",
        "  \n",
        "    message = []\n",
        "    n = len(bits)\n",
        "    assert n == len(bases), \"Bits and Bases must be the same length!\"\n",
        "    for i in range(n):\n",
        "        qc = QuantumCircuit(1,1)\n",
        "\n",
        "        # TASK:\n",
        "        # Fill in the blanks to create ground and excited states for the given basis\n",
        "\n",
        "        if bases[i] == 0: # Prepare qubit in Z-basis\n",
        "            if bits[i] == 0:\n",
        "                # Prepare the ground state\n",
        "                # Enter your code below this line \n",
        "                \n",
        "                # Enter your code above this line\n",
        "            else:\n",
        "                # Prepare the excited state\n",
        "                # Enter your code below this line \n",
        "                \n",
        "                # Enter your code above this line\n",
        "        else: # Prepare qubit in X-basis\n",
        "            if bits[i] == 0:\n",
        "               # Prepare the ground state\n",
        "                # Enter your code below this line \n",
        "                \n",
        "                # Enter your code above this line\n",
        "            else:\n",
        "                # Prepare the excited state\n",
        "                # Enter your code below this line \n",
        "                \n",
        "                # Enter your code above this line\n",
        "        qc.barrier()\n",
        "        message.append(qc)\n",
        "    return message\n",
        "for message in encode_message([0,1,0,1], [0,0,1,1]):\n",
        "  message.draw(output = 'mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KQAHjry_LBjI"
      },
      "outputs": [],
      "source": [
        "def measure_message(message, bases): \n",
        "  \n",
        "    backend = Aer.get_backend('aer_simulator')\n",
        "    measurements = []\n",
        "    n = len(bases)\n",
        "    assert n == len(message), \"Message and bases must be the same size!\"\n",
        "    for q in range(n):\n",
        "\n",
        "        # TASK:\n",
        "        # Measure the qth message in the qth basis.\n",
        "\n",
        "        if bases[q] == 0: \n",
        "            # Measuring in the Z-basis.\n",
        "            # Enter your code below this line \n",
        "            \n",
        "            # Enter your code above this line\n",
        "        if bases[q] == 1: \n",
        "            # Measuring in the X-basis.\n",
        "            # Enter your code below this line \n",
        "            \n",
        "            # Enter your code above this line\n",
        "        aer_sim = Aer.get_backend('aer_simulator')\n",
        "        qobj = assemble(message[q], shots=1, memory=True)\n",
        "        result = aer_sim.run(qobj).result()\n",
        "        measured_bit = int(result.get_memory()[0])\n",
        "        measurements.append(measured_bit)\n",
        "    return measurements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "B3v5nadG9kd1"
      },
      "outputs": [],
      "source": [
        "# TEST!\n",
        "bits = randint(2, size=10) \n",
        "bases = randint(2, size=10) \n",
        "assert np.array_equal(measure_message(encode_message(bits, bases), bases),bits), \"Your code is incorrect!\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KLDEYH9aKnno"
      },
      "source": [
        "Did the tests succeed? Great! Now, watch how we can use this to create a secret key between you and Bob!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "29daMY3BLLQ3"
      },
      "outputs": [],
      "source": [
        "def remove_garbage(a_bases, b_bases, bits):\n",
        "  \n",
        "    good_bits = []\n",
        "    for q in range(n):\n",
        "        if a_bases[q] == b_bases[q]:\n",
        "            # If both used the same basis, add\n",
        "            # this to the list of 'good' bits\n",
        "            good_bits.append(bits[q])\n",
        "    return good_bits"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3dpaaTxDL1Ug"
      },
      "outputs": [],
      "source": [
        "def sample_bits(bits, selection):\n",
        "  \n",
        "    sample = []\n",
        "    for i in selection:\n",
        "        # use np.mod to make sure the\n",
        "        # bit we sample is always in \n",
        "        # the list range\n",
        "        i = np.mod(i, len(bits))\n",
        "        # pop(i) removes the element of the\n",
        "        # list at index 'i'\n",
        "        sample.append(bits.pop(i))\n",
        "    return sample"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M3lR-zdDKuzv",
        "outputId": "a1ee9739-7aaf-431a-9b36-df09db486572"
      },
      "outputs": [],
      "source": [
        "np.random.seed(seed=376)\n",
        "n = 100 # Length of our initial message\n",
        "alice_bits = randint(2, size=n) # Intruder Eve does not know alice_bits\n",
        "alice_bases = randint(2, size=n)\n",
        "message = encode_message(alice_bits, alice_bases)\n",
        "\n",
        "# Now we send the message to Bob\n",
        "bob_bases = randint(2, size=n)\n",
        "bob_results = measure_message(message, bob_bases) # Intruder Eve does not know bob_results\n",
        "\n",
        "# Now Alice and Bob share their respective bases\n",
        "alice_key = remove_garbage(alice_bases, bob_bases, alice_bits) # Eve can only know 2 of the 3, hence she can never know alice_key\n",
        "bob_key = remove_garbage(alice_bases, bob_bases, bob_results)  # Eve can only know 2 of the 3, hence she can never know bob_key\n",
        "\n",
        "# Now we test to see if this worked properly\n",
        "sample_size = 15\n",
        "bit_selection = randint(n, size=sample_size)\n",
        "\n",
        "bob_sample = sample_bits(bob_key, bit_selection)\n",
        "alice_sample = sample_bits(alice_key, bit_selection)\n",
        "\n",
        "if bob_sample == alice_sample:\n",
        "  print(\"Keys distributed successfully\")\n",
        "else:\n",
        "  print(\"Key distribution unsuccessful! Eve is intercepting your messages!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GTFuZ08VKxJP"
      },
      "source": [
        "Great! Eve is not eavesdropping on your conversation so far.\n",
        "\n",
        "We can now use this to communicate securely with Bob!\n",
        "\n",
        "Wait, what's this!\n",
        "\n",
        "Bob has found a habitable planet!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TwOGmgKfxOut"
      },
      "source": [
        "<h1> Grover's algorithm </h1>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cC5Oapxg4is_"
      },
      "source": [
        "We have a large, unstructured database of possible habitable exoplanets. Now, we can use Grover's algorithm to search for the planet. Doing so provides us with a quadratic speedup over the classical method!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "o2xFMSqY7OUb"
      },
      "outputs": [],
      "source": [
        "def phase_oracle(N, i, name = 'Oracle'):\n",
        "    \n",
        "    qc = QuantumCircuit(N, name=name)\n",
        "    oracle_matrix = np.identity(2**N)\n",
        "    \n",
        "    for i in i:\n",
        "        oracle_matrix[i, i] = -1\n",
        "        \n",
        "    qc.unitary(Operator(oracle_matrix), range(N))\n",
        "    \n",
        "    return qc"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4CpuBRqDvj0M"
      },
      "outputs": [],
      "source": [
        "def diffuser(N):\n",
        "  \n",
        "    qc = QuantumCircuit(N, name='Diffuser')\n",
        "    # TASK:\n",
        "    # Apply a Hadamard Gate to N-qubits\n",
        "\n",
        "    # Enter your code below this line\n",
        "    \n",
        "    # Enter your code above this line\n",
        "\n",
        "    qc.append(phase_oracle(N, [0]), range(N))\n",
        "\n",
        "    # TASK:\n",
        "    # Apply a Hadamard Gate to N-qubits\n",
        "    # Enter your code below this line\n",
        "    \n",
        "    # Enter your code above this line\n",
        "        \n",
        "    return qc"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "A2C12VzGvm1K"
      },
      "outputs": [],
      "source": [
        "def Grover(N, j):\n",
        "    \n",
        "    qc = QuantumCircuit(N, N)\n",
        "    r = int(np.floor(np.pi/4*np.sqrt(2**N/len(j))))    \n",
        "    print(f'{r} rounds to get the index of the habitable planet')\n",
        "\n",
        "    # TASK:\n",
        "    # Apply a Hadamard Gate to N-qubits\n",
        "\n",
        "    # Enter your code below this line\n",
        "    \n",
        "    # Enter your code above this line\n",
        "    \n",
        "    for _ in range(r):\n",
        "        qc.append(phase_oracle(N, j), range(N))\n",
        "        qc.append(diffuser(N), range(N))\n",
        "\n",
        "    # TASK:\n",
        "    # Measure the N-qubits and store the result in N classical bits\n",
        "    \n",
        "    # Enter your code below this line\n",
        "    \n",
        "    # Enter your code above this line\n",
        "    \n",
        "    return qc"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 248
        },
        "id": "0puBvnNxvsKj",
        "outputId": "6e81d4c0-fc30-4157-ac02-2d5bf008b09c"
      },
      "outputs": [],
      "source": [
        "N = 3\n",
        "G_ship = int(str(Signal[0]) ,2)\n",
        "mycircuit = Grover(N, [G_ship])\n",
        "mycircuit.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 340
        },
        "id": "7uwIuBDJz9SR",
        "outputId": "69d37a79-ab48-4768-efdc-19d2764987d7"
      },
      "outputs": [],
      "source": [
        "from qiskit import Aer, execute\n",
        "simulator = Aer.get_backend('qasm_simulator')\n",
        "mycounts = execute(mycircuit, backend=simulator, shots=1024).result().get_counts(mycircuit)\n",
        "\n",
        "H_Planets = {'000':'Kepler-283 c' , '001':'Kepler-438 b' , '010':'Kepler-62 e' , '011':'Gliese 667C c' , '100':'Kepler-442 b' , '101':'Kepler-296 e' , '110':'Kepler-452 b' , '111':'Gliese 832 c' }\n",
        "\n",
        "plot_histogram(mycounts)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xojmXQLp0DIF",
        "outputId": "addbd3ec-f9a5-4ec6-9fb4-491eb20c8785"
      },
      "outputs": [],
      "source": [
        "mycounts_keys = list(mycounts.keys())\n",
        "mycounts_values = list(mycounts.values())\n",
        "prob = mycounts_values.index(max(mycounts_values))\n",
        "\n",
        "Planet_index = mycounts_keys[prob]\n",
        "assert Planet_index == \"000\", \"Your code is incorrect!\"\n",
        "\n",
        "Planet_name = H_Planets.get(Planet_index)\n",
        "print('The habitable planet that Bob has discovered is',Planet_name + '.')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XeIpO3BYnr_O"
      },
      "source": [
        "Congratulations! Well done! We have found a habitable planet!\n",
        "\n",
        "With this, your journey comes to an end! You can return to your cryosleep, as I, Hal, your AI companion through this journey take you to your new home!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IZBRtBnwnoj3"
      },
      "source": [
        "<h1>Bonus Challenge!</h1>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XsdZ2jkVBt-S"
      },
      "source": [
        "Alice's journey may have come to an end, but your quantum journey is just starting! \n",
        "\n",
        "Did you like solving these challenges? If so, here is a **Bonus Challenge** for you!\n",
        "\n",
        "Do you still remember the **quantum teleportation** circuit? What about the **encryption** and **decryption**? What if I told you we can combine the two?\n",
        "\n",
        "This is what you will be doing in this challenge! Fair warning: this is a lot harder than the last ones. But the reward is just that much sweeter!\n",
        "\n",
        "Now, onwards!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4Th0sNPMD7Yb"
      },
      "source": [
        "For this challenge, we will use the following encoding. Of course, we can use any encoding we want, as long as both the sender and receiver know it. We will then use this encoding to teleport **two** qubits. \n",
        "\n",
        "Are you ready?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z8lxP4vTGhtZ"
      },
      "source": [
        "| Qubit $1$ | Qubit $2$ | &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; Result &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; |\n",
        "| :-: | :-: | :-: |\n",
        "| $0$ | $0$ | $\\tfrac 1{\\sqrt 2}\\left(-\\mid 00\\rangle-\\mid 10\\rangle\\right)$ |\n",
        "| $0$ | $1$ | $\\tfrac 1{\\sqrt 2}\\left(-\\mid 01\\rangle-\\mid 11\\rangle\\right)$ |\n",
        "| $1$ | $0$ | $\\tfrac 1{\\sqrt 2}\\left(-\\mid 00\\rangle-\\mid 10\\rangle\\right)$ |\n",
        "| $1$ | $1$ | $\\tfrac 1{\\sqrt 2}\\left(-\\mid 01\\rangle-\\mid 11\\rangle\\right)$ |"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 367
        },
        "id": "N-_gWzwF3r4K",
        "outputId": "f88673c9-5723-4d37-81d2-bbbf27437390"
      },
      "outputs": [],
      "source": [
        "# Initializing Quantum Circuit\n",
        "qc = QuantumCircuit(6,6) # Defining 6 quantum register and 6 classical registers for our purpose\n",
        "\n",
        "# TASK: \n",
        "# Setting Input |11>\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "qc.barrier()\n",
        "\n",
        "# Drawing our Input Circuit\n",
        "qc.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B14zSADoGBBC"
      },
      "source": [
        "As per the encoding mentioned in the data sheet, the encoding required is $(XZXH|q0\\rangle)(|q1\\rangle)$\n",
        "\n",
        "There is a catch, as for the state where the $q0$ is $|1\\rangle$, there should be a phase change.\n",
        "\n",
        "So, for cases where $q0$ is $|1\\rangle$, we will invert it before applying the encoding."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 367
        },
        "id": "puqDP13u3uPH",
        "outputId": "e9ac8b96-a4bc-41a7-9ffb-2c034c606c3c"
      },
      "outputs": [],
      "source": [
        "# Encoding the data\n",
        "\n",
        "qc.measure(0,0) # To know the status of |q0>\n",
        "\n",
        "qc.x(0).c_if(0,1) # Phase correction\n",
        "\n",
        "# TASK:\n",
        "# Apply the XZXH encoding to qubit 0\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "qc.barrier()\n",
        "qc.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 367
        },
        "id": "OQzABN9M312j",
        "outputId": "e3858aae-1f72-4f6e-a641-ddd53f0f2529"
      },
      "outputs": [],
      "source": [
        "# Teleporting Protocol\n",
        "\n",
        "# Entagling qubits to be sent i.e |q2> with |q4> and |q3> with |q5>\n",
        "\n",
        "# TASK:\n",
        "# Entangle q2 with q4\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "# TASK:\n",
        "# Entangle q3 with q5\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "qc.barrier()\n",
        "qc.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 367
        },
        "id": "jNiNuVx334tp",
        "outputId": "39b977d5-6367-4003-9a76-a4d201c0172f"
      },
      "outputs": [],
      "source": [
        "# Bell measurement on the information to be teleported\n",
        "\n",
        "# TASK:\n",
        "# Establish the teleportation protocol between qubits 0 and 2.\n",
        "# If you have forgotten, you can scroll to the teleportation section to check it out!\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "\n",
        "# TASK:\n",
        "# Establish the teleportation protocol between qubits 1 and 3.\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "qc.barrier()\n",
        "qc.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 367
        },
        "id": "0nYBa3HG37Jj",
        "outputId": "976af126-4636-467c-8224-8eb3119f1bc3"
      },
      "outputs": [],
      "source": [
        "# Completing the protocol by measurement to send to other end using cx and cz gate\n",
        "\n",
        "# TASK:\n",
        "# Teleport |q0> to |q4> using |q2>\n",
        "# We can this by applying a controlled not gate between qubits 2 and 4,\n",
        "# followed by a controlled z gate between qubits 0 and 4.\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "# TASK:\n",
        "# Teleport |q1> to |q5> using |q3>\n",
        "# Use the hint above if you are struggling with this\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "qc.barrier()\n",
        "qc.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k8-5PrS8700s"
      },
      "source": [
        "Now as the information is been succesfully teleported, now we will decrypt the information.\n",
        "\n",
        "This is done by applying the gates in reverse order than that of encryption."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 731
        },
        "id": "eibdOZpy3932",
        "outputId": "88ad0fde-58cf-4341-e904-3f1cd6eb3837"
      },
      "outputs": [],
      "source": [
        "# Applying the decoding\n",
        "\n",
        "# TASK:\n",
        "# Apply the XZXH encoding in reverse order to qubit 4\n",
        "\n",
        "# Enter your code below this line\n",
        "\n",
        "# Enter your code above this line\n",
        "\n",
        "qc.x(4).c_if(0,1) # Phase correction\n",
        "\n",
        "\n",
        "qc.barrier()\n",
        "\n",
        "#Now lets measure our state and see its final state\n",
        "\n",
        "qc.measure([4,5],[4,5])\n",
        "qc.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 381
        },
        "id": "mv0TKwUr4Dza",
        "outputId": "7222a555-9f0d-44c6-9a03-0b0177deba65"
      },
      "outputs": [],
      "source": [
        "simulator = Aer.get_backend('qasm_simulator')\n",
        "result = execute(qc, backend=simulator, shots=1024).result()\n",
        "# TEST!\n",
        "assert result.get_counts(qc)[\"110001\"] == 1024, \"Your code is incorrect!\"\n",
        "\n",
        "print(\"Well done! You have successfully passed the Bonus Challenge! The teleported message was \" + list(result.get_counts(qc).keys())[0][:2] + \".\")\n",
        "plot_histogram(result.get_counts(qc))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ddjjMBroIGHt"
      },
      "source": [
        "Thank you very much for going through our challenges!\n",
        "\n",
        "Did you have fun? If you are still hungry for more, you can play around with the initialization steps and check how our circuits behave with different initial states! What happens if we teleport $\\mid 00\\rangle$ in the bonus challenge? What about $\\mid 01\\rangle$? \n",
        "\n",
        "Still interested? You can check how we solved this notebook over [here](https://colab.research.google.com/drive/1PD1N7WQFhTS0uf_n_6IIrsxqwz0qz3Vt?usp=sharing). Have fun comparing answers!\n",
        "\n",
        "Yours Truly,\n",
        "\n",
        "Rihab, Rishi and Zuhair\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.11.0 (main, Oct 24 2022, 18:26:48) [MSC v.1933 64 bit (AMD64)]"
    },
    "vscode": {
      "interpreter": {
        "hash": "e9708f88ac315f08dffb5ff62e80bacf8db92a3b1d43aadf54fb64c6cd39003a"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}