solutions/lab_2/lab2_solution.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0ac9dd0b-210c-470e-8313-5cf7f7c57b65",
   "metadata": {},
   "source": [
    "# Lab 2: Quantum teleportation\n",
    "\n",
    "Welcome to this lab on quantum teleportation in which you'll solve a problem that Alice and Bob have been having. Relax, it's not a relationship problem! Alice possesses a qubit in an unknown state $\\lvert \\psi \\rangle$ and she wishes to transfer this quantum state to Bob. However, they are very far apart and lack any means to transfer quantum information directly, only classical information. Is it possible to achieve their goal?\n",
    "\n",
    "It turns out that if Alice and Bob share an entangled qubit pair, she can transfer her qubit state to Bob by sending two bits of classical information. This process is known as teleportation because, at the end, Bob will possess |ψ⟩, and Alice will no longer have it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11a966b2-a7c1-4584-87b2-1b8e4277f997",
   "metadata": {},
   "source": [
    "## Background\n",
    "\n",
    "Quantum teleportation is a protocol that allows the transfer of quantum information from one qubit to another using entanglement and classical communication. It was proposed by Charles Bennett, Gilles Brassard, Claude Crépeau, Richard Jozsa, Asher Peres, and William Wootters in 1993. The process does not transmit the qubit itself but rather transfers the quantum state from the source qubit to the target qubit.\n",
    "\n",
    "The protocol requires three qubits:\n",
    "\n",
    "1. The qubit to be teleported (Alice's qubit)\n",
    "2. One half of an entangled pair of qubits (Alice's second qubit)\n",
    "3. The other half of the entangled pair (Bob's qubit)\n",
    "\n",
    "The protocol can be summarized in the following steps:\n",
    "\n",
    "1. Create an entangled pair of qubits (Bell pair) shared between Alice and Bob.\n",
    "2. Alice performs a Bell basis measurement on her two qubits.\n",
    "3. Alice sends the classical results of her measurement to Bob.\n",
    "4. Bob applies appropriate quantum gates based on Alice's measurement results to obtain the teleported state."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a26fb942-ca66-4bea-85f5-f8f13d013d5e",
   "metadata": {},
   "source": [
    "## Implementation\n",
    "\n",
    "In order to transfer a quantum bit, Alice and Bob require the help of a third party who provides them with a pair of entangled qubits. Next, Alice carries out certain operations on her qubit and shares the results with Bob through a classical communication channel. Finally, Bob performs a series of operations on his end to successfully obtain Alice's qubit. Now, let's delve deeper into each of these steps."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "71cdf58d-0d4d-43f0-b427-3a3ebca842f5",
   "metadata": {
    "tags": []
   },
   "source": [
    "Our quantum circuit will consist of 3 qubits and 3 classical bits. The qubits will be named as follows:\n",
    "- $s$: The \"source\" qubit containing the state $\\lvert \\psi \\rangle$ which Alice wishes to transmit to Bob.\n",
    "- $a$: The qubit which will initially store Alice's half of the entangled Bell pair.\n",
    "- $b$: The qubit which will initially store Bob's half of the entangled Bell pair.\n",
    "\n",
    "The teleportation protocol itself requires 2 classical bits, and we include a third one to use for measuring Bob's final state. The classical bits will be named as follows:\n",
    "- $c0$: The classical bit that Alice uses to measure $a$.\n",
    "- $c1$: The classical bit that Alice uses to measure $s$.\n",
    "- $c2$: The classical bit that Bob uses to measure $b$."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "bad695dc",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "\n",
    "Utilize two qubits to generate an entangled Bell pair. Qubit 𝑎 is allocated to Alice, while qubit 𝑏 is designated for Bob."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9a9810a-8ec5-4e0e-823d-6865e810b34d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "from qiskit.circuit import Qubit, Clbit\n",
    "\n",
    "\n",
    "def create_bell_pair(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
    "    \"\"\"Creates a bell pair between qubits a and b.\"\"\"\n",
    "    qc = QuantumCircuit(qr, cr)\n",
    "    # unpack qubits\n",
    "    # the first qubit is s but we won't be using it in this exercise\n",
    "    s, a, b = qr\n",
    "\n",
    "    # ENTER YOUR CODE BELOW EACH COMMENT\n",
    "    # Put qubit a into state |+>\n",
    "    qc.h(a)\n",
    "    # CNOT with a as control and b as target\n",
    "    qc.cx(a, b)\n",
    "    # ENTER YOUR CODE ABOVE\n",
    "\n",
    "    return qc  # For the grader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7897fcca-e31a-4b44-9e19-16fbeb85a20d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "qr = QuantumRegister(3, name=\"q\")\n",
    "cr = ClassicalRegister(3, name=\"c\")\n",
    "qc = create_bell_pair(qr, cr)\n",
    "\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d00f07df-5245-47c7-858b-3ae6cbafc475",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Submit your circuit\n",
    "\n",
    "from qc_grader.challenges.spring_2023 import grade_ex2a\n",
    "\n",
    "grade_ex2a(qc)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b6b5ec32-e8ae-4475-a0ea-5314acf49a4f",
   "metadata": {},
   "source": [
    "Let's assume Alice has qubit $a$ and Bob has qubit $b$ once they separate. Perhaps they really are having a relationship issue 😉."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6ba11110",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "\n",
    "In this step, Alice applies a CNOT gate to qubit $a$, with $s$ (the qubit containing $\\lvert \\psi \\rangle$,  the state she intends to send to Bob) as the control. Following this, Alice applies a Hadamard gate to $s$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34d7bcd6-166b-4745-8ede-f8aa1872d434",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def alice_gates(qr: QuantumRegister, cr: ClassicalRegister):\n",
    "    \"\"\"Creates Alices's gates\"\"\"\n",
    "    qc = create_bell_pair(qr, cr)\n",
    "    qc.barrier()  # Use barrier to separate steps\n",
    "    s, a, b = qr\n",
    "\n",
    "    # ENTER YOUR CODE BELOW EACH COMMENT\n",
    "    # CNOT with source as control and a as target\n",
    "    qc.cx(s, a)\n",
    "    # Apply Hadamard on qubit s\n",
    "    qc.h(s)\n",
    "    # ENTER YOUR CODE ABOVE\n",
    "\n",
    "    return qc  # For the grader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a5096db-1b92-45df-ac1b-52392356b543",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "qc = alice_gates(qr, cr)\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66cead66-9c0e-4e7c-a196-efa456e6764b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Submit your circuit\n",
    "\n",
    "from qc_grader.challenges.spring_2023 import grade_ex2b\n",
    "\n",
    "grade_ex2b(qc)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2d45bf84-f32b-4dd9-8e73-b8ec920e8b39",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Exercise 3\n",
    "\n",
    "In this step, Alice performs a measurement on both qubits in her possession and saves the results in two classical bits. Afterward, she sends these two bits to Bob. She will measure qubit $a$ into classical bit $c0$ and qubit $s$ into classical bit $c1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "345bc52c-7745-46a3-90e7-a0e6a03604d5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def measure_and_send(qr: QuantumRegister, cr: ClassicalRegister):\n",
    "    \"\"\"Measures qubits a & b and 'sends' the results to Bob\"\"\"\n",
    "    qc = alice_gates(qr, cr)\n",
    "    qc.barrier()  # Use barrier to separate steps\n",
    "    s, a, b = qr\n",
    "    c0, c1, c2 = cr\n",
    "\n",
    "    # ENTER YOUR CODE BELOW EACH COMMENT\n",
    "    # Measure qubit a into classical bit 0\n",
    "    qc.measure(a, c0)\n",
    "    # Measure qubit s into classical bit 1\n",
    "    qc.measure(s, c1)\n",
    "    # ENTER YOUR CODE ABOVE\n",
    "\n",
    "    return qc  # For the grader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1c3ec5d-ce66-455c-a2fe-6cca03dd87f4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "qc = measure_and_send(qr, cr)\n",
    "qc.draw(\"mpl\", cregbundle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76b0c0b2-ed71-4eb7-b4d9-9b725a22fccb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Submit your circuit\n",
    "\n",
    "from qc_grader.challenges.spring_2023 import grade_ex2c\n",
    "\n",
    "grade_ex2c(qc)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1fec0216-f312-430e-9940-0ab0ffd1beca",
   "metadata": {},
   "source": [
    "### Exercise 4\n",
    "\n",
    "In this step, Bob, who is already in possession of qubit $b$, dynamically adds specific gates to the circuit based on the state of the classical bits received from Alice:\n",
    "\n",
    "If the bits are `00`, no action is required. If they are `01`, an 𝑋 gate (also known as a Pauli-X or a bit-flip gate) should be applied. For bits `10`, a 𝑍 gate (also known as a Pauli-Z or a phase-flip gate) should be applied. Lastly, if the classical bits are `11`, a combined 𝑍𝑋 gate should be applied, which involves applying both the 𝑍 and 𝑋 gates in sequence. Please note that this information transfer occurs solely through classical means."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e61ddfa4-e536-46dd-b5a7-efe15f3ad617",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# This function takes a QuantumCircuit (qc), integer (qubit)\n",
    "# and ClassicalRegisters (crz & crx) to decide which gates to apply\n",
    "def bob_gates(qr: QuantumRegister, cr: ClassicalRegister):\n",
    "    \"\"\"Uses qc.if_test to control which gates are dynamically added\"\"\"\n",
    "    qc = measure_and_send(qr, cr)\n",
    "    qc.barrier()  # Use barrier to separate steps\n",
    "    s, a, b = qr\n",
    "    c0, c1, c2 = cr\n",
    "\n",
    "    # ENTER YOUR CODE BELOW EACH COMMENT\n",
    "    # Add an X gate to the qubit wire if c0 measures 1\n",
    "    with qc.if_test((c0, 1)):\n",
    "        qc.x(b)\n",
    "    # Add a Z gate to the qubit wire if c1 measures 1\n",
    "    with qc.if_test((c1, 1)):\n",
    "        qc.z(b)\n",
    "    # ENTER YOUR CODE ABOVE\n",
    "\n",
    "    return qc  # For the grader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff619db6-282a-450e-9b7c-38b2838cfdeb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "qc = bob_gates(qr, cr)\n",
    "qc.draw(\"mpl\", cregbundle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ab0270f-f909-4239-bb52-e36410497c21",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Submit your circuit\n",
    "\n",
    "from qc_grader.challenges.spring_2023 import grade_ex2d\n",
    "\n",
    "grade_ex2d(qc)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "74dc4ac1-d643-468e-a13c-509e2a12d77b",
   "metadata": {},
   "source": [
    "We will now have Bob measure his qubit into classical bit $c2$. After repeating the entire experiment multiple times, we can gather statistics on the measurement results to confirm that the teleportation worked correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6223a197-48b8-4b7b-889c-4bf317793a27",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "teleportation_circuit = bob_gates(qr, cr)\n",
    "s, a, b = qr\n",
    "c0, c1, c2 = cr\n",
    "teleportation_circuit.measure(b, c2)\n",
    "teleportation_circuit.draw(\"mpl\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3780a15e-4a86-4d5a-af4c-8662f4462fb9",
   "metadata": {},
   "source": [
    "Now that we have a teleportation circuit, let's ~~beam Captain Kirk to the surface of a strange planet~~ create and teleport a quantum state, and then run the circuit on a simulator."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "977a9fe6",
   "metadata": {},
   "source": [
    "### Exercise 5\n",
    "\n",
    "In the following code cell, construct a full quantum teleportation circuit into the `teleport_superposition_circuit` variable. Prepare the qubit $s$ by applying an $R_x$ rotation with angle $\\pi / 4$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89fa5bdb-eb09-4fb8-9913-6fd6bb9f8ad2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "teleport_superposition_circuit: QuantumCircuit\n",
    "\n",
    "########## your code goes here #######\n",
    "\n",
    "# Create a circuit that has the same structure as our teleportation circuit\n",
    "state_prep = QuantumCircuit(qr, cr)\n",
    "\n",
    "# Prepare the qubit\n",
    "state_prep.rx(math.pi / 4, s)\n",
    "\n",
    "# Put a barrier across all of the wires\n",
    "state_prep.barrier()\n",
    "# Add the teleportation circuit to the superposition circuit\n",
    "teleport_superposition_circuit = state_prep.compose(teleportation_circuit)\n",
    "\n",
    "teleport_superposition_circuit.draw(\"mpl\", cregbundle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e0ef91c-964a-4fd6-ab52-36c859b69b13",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from qiskit import transpile\n",
    "from qiskit_aer import AerSimulator\n",
    "from qiskit.visualization import plot_histogram\n",
    "\n",
    "sim = AerSimulator()\n",
    "transpiled_circuit = transpile(teleport_superposition_circuit, sim)\n",
    "\n",
    "# run job\n",
    "shots = 1000\n",
    "job = sim.run(transpiled_circuit, shots=shots, dynamic=True)\n",
    "\n",
    "# Get the results and display them\n",
    "exp_result = job.result()\n",
    "exp_counts = exp_result.get_counts()\n",
    "plot_histogram(exp_counts)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "80e72c0a-8a4e-4d29-92a7-022d3882552a",
   "metadata": {},
   "source": [
    "Let's compute the distribution of just Bob's measurement by marginalizing over the other measured bits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96a1fd3b-693b-4cd4-bb51-96f676dd1759",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# trace out Bob's results on qubit 2\n",
    "from qiskit.result import marginal_counts\n",
    "\n",
    "bobs_counts = marginal_counts(exp_counts, [qr.index(b)])\n",
    "plot_histogram(bobs_counts)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6a33717b",
   "metadata": {},
   "source": [
    "The marginal distribution should be somewhat close to the ideal probabilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "475e3774-da15-483b-9d2d-af54a8e0e568",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from qc_grader.challenges.spring_2023 import grade_ex2e\n",
    "\n",
    "grade_ex2e(bobs_counts)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9baa3099-7577-4bf9-9d1f-e0c54dc384b8",
   "metadata": {},
   "source": [
    "Now that we're fairly certain that ~~Captain Kirk~~ Alice's qubit will teleport safely, let's execute the quantum teleportation circuit on real hardware."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca2f737c-a21f-4727-b14d-0e7e315631ba",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from qiskit_ibm_provider import IBMProvider\n",
    "\n",
    "provider = IBMProvider()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da33a9fb-6b6c-48a4-a1b0-dfca70474e22",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "hub = \"ibm-q-internal\"\n",
    "group = \"deployed\"\n",
    "project = \"default\"\n",
    "\n",
    "backend_name = \"ibm_peekskill\"\n",
    "backend = provider.get_backend(backend_name, instance=f\"{hub}/{group}/{project}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe48f446-849f-46e9-b0a4-1dd5225db403",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# backend.target.add_instruction(IfElseOp, name=\"if_else\") # Uncomment if necessary\n",
    "qc_transpiled = transpile(teleport_superposition_circuit, backend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cee84182-a90d-44b7-b44d-87309202cbc3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "job = backend.run(qc_transpiled, shots=1000, dynamic=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc8458f1-43fd-48b2-a50c-65771262cbf1",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Get the results and display them\n",
    "exp_result = job.result()\n",
    "exp_counts = exp_result.get_counts()\n",
    "plot_histogram(exp_counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88ddf3c8-732f-4825-a1b1-376bce0ab614",
   "metadata": {},
   "outputs": [],
   "source": [
    "# trace out Bob's results on qubit 2\n",
    "from qiskit.result import marginal_counts\n",
    "\n",
    "bobs_qubit = 2\n",
    "bobs_counts = marginal_counts(exp_counts, [bobs_qubit])\n",
    "plot_histogram(bobs_counts)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "spring-challenge-2023",
   "language": "python",
   "name": "spring-challenge-2023"
  },
  "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.9.15"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}