ipynb/3.4-Entangled_Robot_Swarms.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "869f6c01",
   "metadata": {},
   "source": [
    "##### A Tale of Timbits\n",
    "\n",
    "# Entangled Robot Swarms (400 points)\n",
    "\n",
    "### Backstory\n",
    "\n",
    "Zenda and Reece have sore fingers from pushing buttons on the mystery boxes exponentially many times, but they finally have a catalogue of states. They can return to the fun problem of designing their robot swarm to explore the galaxy! The basic idea is that the robots share a state that allows them to move in a coordinated but random way (to avoid being Ove. A. Heard), and for individual robots to abort movement if they suspect (from their quantum radar) that they are being watched.\n",
    "\n",
    "### Robot swarms and multipartite entanglement\n",
    "\n",
    "At this point, Zenda and Reece decide to build a swarm of robots to facilitate the search and exploration of space. Not only that, but they decide to use these robots to transport states in a secure way. In this case, they want to transport the \"canonical\" Bell state\n",
    "\n",
    "$$|\\Phi\\rangle = \\frac{|0\\rangle_H |000\\rangle + |1\\rangle_H |111\\rangle}{\\sqrt{2}}$$\n",
    "\n",
    "![Hub-Swarm Bell State](../img/hub.jpeg)\n",
    "\n",
    "The first qubit will remain in the Hub with Reece and Zenda, while the other three qubits will each be transported by a different robot. The problem is that space is not a safe place, and robots can be intercepted. If this happens, the qubit being transported will collapse, altering — due to entanglement — the state of all the other qubits carried by the remaining robots. For example, if the first robot is intercepted and its qubit collapses to $|1\\rangle$, then all remaining qubits will collapse to $|1\\rangle$ as well, and our Bell state will be destroyed.\n",
    "\n",
    "For that reason, a security protocol has been designed in which a robot, when it feels threatened, will apply an emergency gate $U$ on its qubit that somehow does not totally destroy the Bell state that we had initially when it is measured.\n",
    "\n",
    "After $U$ has been applied, the qubit will collapse and the robot will tell the Hub which state it is observing — 0 or 1. Immediately after sending the message, the robot self-destructs. With the information received from the destroyed robot, Zenda and Reece should be able to send a new robot with a certain state from the Hub such that the initial Bell state $|\\Phi\\rangle$ is restored and shared between the hub and the existing robots.\n",
    "\n",
    "The following diagram offers a summary:\n",
    "\n",
    "![Hub-Swarm Quantum Circuit](../img/swarm.jpeg)\n",
    "\n",
    "We will use five qubits: `hub`, `robot1`, `robot2`, `robot3`, and `auxiliary_robot`. The three robots with the hub — `robot1`, `robot2`, and `robot3` — create the desired Bell state and then take off to begin their journey. In the diagram above, `robot1` detects a threat, so it applies $U$ and collapses its qubit. Knowing the `output`, the Hub configures the `auxiliary_robot` with a new gate so that now the `hub`, `robot2`, `robot3`, and the `auxiliary_robot` restore the desired state.\n",
    "\n",
    "Your goals in this challenge are threefold. First, you will devise the Bell preparation gate that outputs the Bell state $|\\Phi\\rangle$ between the Hub and the robots. Next, you will decide on a good emergency gate $U$ that allows for the subsequent reconstruction of the Bell state. Finally, you will code the circuit that Zenda and Reece need to build in order to reconstruct the Bell state between the Hub, the new robot, and the surviving robots.\n",
    "\n",
    "## Challenge code\n",
    "\n",
    "In the code below, you are given a few functions:\n",
    "\n",
    "- `bell_prearation`: creates the state $\\frac{1}{\\sqrt{2}} (|0000\\rangle + |1111\\rangle)$. This gate will act on the first 3 robots and the hub — `hub`, `robot1`, `robot2`, and `robot3`. **You must complete this function**.\n",
    "- `emergency_gate_U`: the gate, $U$, that somehow manages to save the total state after one of the robots is threatened and its qubit collapses. It will act only on one qubit. **You must complete this function**.\n",
    "- `setting_new_robot`: takes care of defining a new auxiliary robot configuration. It will only act on the `hub` and `auxiliary_robot` qubits. **You must complete this function**.\n",
    "\n",
    "### Input\n",
    "\n",
    "In this challenge, there is no input. Our grader will simply check that the final state of the `hub`, `robot2`, `robot3`, and `auxiliary_robot` qubits is correct.\n",
    "\n",
    "### Output\n",
    "\n",
    "This code will output the density matrix (`numpy.tensor`) of the `hub`, `robot2`, `robot3`, and `auxiliary_robot` system.\n",
    "\n",
    "If your solution matches the correct one within the given tolerance specified in `check` (in this case, it's a relative tolerance of `1e-5`), the output will be `\"Correct!\"` Otherwise, you will receive a `\"Wrong answer\"` prompt.\n",
    "\n",
    "Good luck!\n",
    "\n",
    "### Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "96744095",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pennylane as qml\n",
    "import pennylane.numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "46ed4781",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bell_preparation(wires):\n",
    "    \"\"\"\n",
    "    Quantum function in charge of generating the bell state of 4 qubits.\n",
    "    You simply add the necessary gates, do not return anything.\n",
    "\n",
    "    Args:\n",
    "        wires (list(str)): list of the 4 wires where the gate will run\n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your code here #\n",
    "    \n",
    "    # preps |00...0> + |11...1>\n",
    "    qml.Hadamard(wires[0])\n",
    "    for wire in wires[1:]:\n",
    "        qml.CNOT([wires[0], wire])\n",
    "\n",
    "def emergency_gate_U(wire):\n",
    "    \"\"\"\n",
    "    Quantum function that will define the emergency protocol in a qubit.\n",
    "    You simply add the necessary gates, do not return anything.\n",
    "\n",
    "    Args:\n",
    "        wire(str): name of the wire where the emergency gate will be apply.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your code here #\n",
    "    \n",
    "    # after measurement, |0..0..0> + |1..0..1> or |0..1..0> - |1..1..1>\n",
    "    qml.Hadamard(wire)\n",
    "\n",
    "def setting_new_robot(output, wires):\n",
    "    \"\"\"\n",
    "    Quantum function that defines the operation between the hub and the auxiliary robot.\n",
    "\n",
    "    Args:\n",
    "        output (int): 0 or 1, indicates the measurement output of robot1 after collapsing.\n",
    "                    Take a look at qml.cond to see how to condition operators to this value.\n",
    "\n",
    "        wires(list(str)): name of the wires where the gate will be apply.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your code here #\n",
    "    \n",
    "    qml.cond(output, qml.PauliZ)(wires[0]) # remove phase from emergency_gate\n",
    "    qml.CNOT(wires=wires) # prep new bell state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5c221000",
   "metadata": {},
   "outputs": [],
   "source": [
    "wires = [\"hub\", \"robot1\", \"robot2\", \"robot3\", \"auxiliary_robot\"]\n",
    "dev = qml.device(\"default.qubit\", wires=wires)\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def circuit():\n",
    "    bell_preparation(wires=[\"hub\", \"robot1\", \"robot2\", \"robot3\"])\n",
    "    emergency_gate_U(wire=\"robot1\")\n",
    "    output = qml.measure(wires=\"robot1\")\n",
    "    setting_new_robot(output, wires=[\"hub\", \"auxiliary_robot\"])\n",
    "    return qml.density_matrix(wires=[\"hub\", \"robot2\", \"robot3\", \"auxiliary_robot\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c53ee806",
   "metadata": {},
   "outputs": [],
   "source": [
    "# These functions are responsible for testing the solution.\n",
    "def run(test_case_input: str) -> str:\n",
    "    return None\n",
    "\n",
    "def check(solution_output: str, expected_output: str) -> None:\n",
    "\n",
    "    dev = qml.device(\"default.qubit\", wires = 4)\n",
    "    @qml.qnode(dev)\n",
    "    def circuit2():\n",
    "        bell_preparation(wires = range(4))\n",
    "        return qml.state()\n",
    "\n",
    "    bell = np.zeros(16)\n",
    "    bell[0] = 1 / np.sqrt(2)\n",
    "    bell[-1] = 1 / np.sqrt(2)\n",
    "\n",
    "    assert np.allclose(circuit2(), bell), \"The bell preparation is not correct!\"\n",
    "\n",
    "    dev = qml.device(\"default.qubit\", wires=4)\n",
    "\n",
    "    @qml.qnode(dev)\n",
    "    def circuit3():\n",
    "        bell_preparation(wires=range(4))\n",
    "        return qml.density_matrix(wires = range(4))\n",
    "\n",
    "    assert np.allclose(circuit3(), circuit()), \"The final state is not correct!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "dd78ce10",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = [['No input', 'No output']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5a6b2a33",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running test case 0 with input 'No input'...\n",
      "Correct!\n"
     ]
    }
   ],
   "source": [
    "for i, (input_, expected_output) in enumerate(test_cases):\n",
    "    print(f\"Running test case {i} with input '{input_}'...\")\n",
    "\n",
    "    try:\n",
    "        output = run(input_)\n",
    "\n",
    "    except Exception as exc:\n",
    "        print(f\"Runtime Error. {exc}\")\n",
    "\n",
    "    else:\n",
    "        if message := check(output, expected_output):\n",
    "            print(f\"Wrong Answer. Have: '{output}'. Want: '{expected_output}'.\")\n",
    "\n",
    "        else:\n",
    "            print(\"Correct!\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pennylane",
   "language": "python",
   "name": "pennylane"
  },
  "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.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}