ipynb/2.5-The_Itch_to_Switch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8a9033a0",
   "metadata": {},
   "source": [
    "##### Bending Bennett's Laws\n",
    "\n",
    "# The Itch to Switch (500 points)\n",
    "\n",
    "### Backstory\n",
    "\n",
    "Zenda and Reece have been busy photocopying qubits and making their old communication protocols coherent. Zenda asks Trine what this has to do with timbits. Trine replies: \"*Timbits? I forgot all about them. I suppose I wanted to show you there is more in heaven and earth than qubits and entangled pairs!*\" Reece objects: \"*But why did you get us to do all those protocols with photocopiers?*\" Trine looks confused for a moment, then a smile spreads over her face. \"*That's right! We can use them to implement a SWAP gate using two CNOTs as opposed to the usual three. Let's do that as a warm-up for timbits!*\"\n",
    "\n",
    "### Exchanging qubits\n",
    "\n",
    "Did you know that there is no way for us to clone a quantum state? The no-cloning theorem states that there is no gate $U$ such that\n",
    "\n",
    "$$U |\\psi\\rangle |0\\rangle = |\\psi\\rangle |\\psi\\rangle$$\n",
    "\n",
    "for all states $|\\psi\\rangle$. However, if we only work with basis states $|j\\rangle$, there exist operations such that\n",
    "\n",
    "$$|j\\rangle |0\\rangle \\mapsto |j\\rangle |j\\rangle$$\n",
    "\n",
    "Zenda and Reece are each in possession of one basis state, which we denote $|j\\rangle_{Z_0}$ and $|k\\rangle_{R_0}$ respectively. Trine tells them to send each other their basis state to each other without losing their own. \"*If basis states can be cloned, then surely we can do this*\", claims Zenda confidently. \"*Just give us two qubits in the $|0\\rangle$ state to each of us and we're good to go.*\"\n",
    "\n",
    "Trine thinks about this... \"*It's too easy if I allow you to do whatever you want*\"—she concludes. \"*Let's make it more fun. I'll give you each one qubit from a Bell state*\n",
    "\n",
    "$$|\\Phi\\rangle_{Z_1 R_1} = \\frac{1}{\\sqrt{2}} \\left( |0\\rangle_{Z_1} |0\\rangle_{R_1} + |1\\rangle_{Z_1} |1\\rangle_{R_1} \\right)$$\n",
    "\n",
    "\"*Then you'll have to send your qubit to each other by acting only on the qubits in your possession.*\"\n",
    "\n",
    "Zenda and Reece try and try, but it seems like a futile task. \"*We need more resources*\"—mumbles Reece. \"*Mmm... disappointing*\" says Trine. \"*Then, I'll allow you to use a magic gate between your initially entangled qubits, but figure it out fast!*\"\n",
    "\n",
    "In this challenge, you will help Zenda and Reece figure out a quantum circuit that performs the operation\n",
    "\n",
    "$$|j\\rangle_{Z_0} |\\Phi\\rangle_{Z_1 R_1} |k\\rangle_{R_0} \\mapsto |j\\rangle_{Z_0} |k\\rangle_{Z_1} |j\\rangle_{R_1} |k\\rangle_{R_0}$$\n",
    "\n",
    "with the constraints imposed by Trine. This means that the circuit must be of the form shown in the image below.\n",
    "\n",
    "![Switching Circuit](../img/magic_zr.jpeg)\n",
    "\n",
    "In the above, $Z$ is the operator Zenda applies on her qubits, $R$ is the operator Reece applies on his qubits, and $M$ is the magic operator provided by Trine. This operation is one of the building blocks you need to master to build a SWAP gate with only two CNOTs, without counting the distributed CNOTs (contained in the magic gate). See the optional reading below for more about this!\n",
    "\n",
    "#### Laws of Infodynamics Part V: From three to two CNOTs\n",
    "\n",
    "This box contains some interesting but nonessential details. As with previous Laws of Infodynamics, we can write the ability to perform one task in terms of others as an inequality:\n",
    "\n",
    "$$1 \\text{ CNOT} + 1 \\text{ ebit} \\geq 1 \\text{ cobit}_{Z \\to R} + 1 \\text{ cobit}_{R \\to z} \\tag{$\\geq$} \\label{geq}$$\n",
    "\n",
    "where the subscripts denote the source and target of copying. Similarly, it's possible to simulate a distributed CNOT gate from Zenda (control) to Reece (target) using a shared ebit and cobit exchange. This leads to an inequality\n",
    "\n",
    "$$1 \\text{ CNOT}_{Z \\to R} + 1 \\text{ ebit} \\leq 1 \\text{ cobit}_{Z \\to R} + 1 \\text{ cobit}_{R \\to Z} \\tag{$\\leq$} \\label{leq}$$\n",
    "\n",
    "We can combine the inequalities $\\eqref{geq}$ and $\\eqref{leq}$ into an *equality* for cobit swapping:\n",
    "\n",
    "$$1 \\text{ CNOT}_{Z \\to R} + 1 \\text{ ebit} = 1 \\text{ cobit}_{Z \\to R} + 1 \\text{ cobit}_{R \\to Z} \\tag{=} \\label{=}$$\n",
    "\n",
    "This means that the resources on either side are equivalent! But this isn't just theoretical; it leads to a neat computational insight. We know that three zigzag CNOTs are equivalent to a swap gate:\n",
    "\n",
    "$$\\text{SWAP}_{Z \\to R} = \\text{CNOT}_{Z \\to R} \\cdot \\text{CNOT}_{R \\to Z} \\cdot \\text{CNOT}_{Z \\to R}$$\n",
    "\n",
    "We previously learnt that a cobit is the average of a qubit and an ebit:\n",
    "\n",
    "$$2 \\text{ cobit}_{Z \\to R} = 1 \\text{ qubit}_{Z \\to R} + 1 \\text{ ebit}_{Z \\to R}$$\n",
    "\n",
    "If we double the equation $\\eqref{=}$ and use this average property, we find that\n",
    "\n",
    "$$2 \\text{ CNOTs} + 2 \\text{ ebits} = 1 \\text{ qubit}_{A \\to B} + 1 \\text{ qubit}_{B \\to A} + 2 \\text{ ebits}$$\n",
    "\n",
    "Subtracting two ebits from each side, the LHS is two distributed CNOTs (one from Reece to Zenda and vice-versa) and the RHS is a qubit sent in either direction. This is fancy terminology for a SWAP gate! Thus, we learn that only *two* CNOTs are needed to perform a SWAP:\n",
    "\n",
    "$$2 \\text{ CNOTs} = 1 \\text{ SWAP}$$\n",
    "\n",
    "Pretty nifty huh! Note that we've subtracted four ebits in total from both sides, so we don't count the four CNOTs used to prepare these.\n",
    "\n",
    "#### Epilogue\n",
    "\n",
    "Trine looks pleased. \"*But all of this is merely an amusing diversion. Let's finally talk about timbits...*\" At this very moment, Doc Trine, and the equipment she has been using to demonstrate the Laws of Infodynamics, disappear in a puff of sparkling purple smoke. Instead of lab equipment, there is only a business card, reading:\n",
    "\n",
    "<center>\n",
    "<img src=\"../img/ove-hat.png\" alt=\"Ove A Heard\"><br>\n",
    "<i>Ove A. Heard: Freelance Data Security Analyst</i><br>\n",
    "'We're Always Watching'\n",
    "</center>\n",
    "\n",
    "On the reverse, an elegant handwritten note:\n",
    "\n",
    "<center>\n",
    "Trine and the timbits are in hyperjail.<br>\n",
    "— Ove A. and OWT.<br>\n",
    "</center>\n",
    "\n",
    "How can they rescue Doc Trine? Where is this hyperjail? And when will they learn the secret of timbits?!\n",
    "\n",
    "*Read on in* **A Tale of Timbits**.\n",
    "\n",
    "## Challenge code\n",
    "\n",
    "In the code below, you are given a number of functions:\n",
    "\n",
    "- `zenda_operator`: Quantum function corresponding to the operator to be applied by Zenda on her qubits. **You must complete this function**.\n",
    "- `reece_operator`: Quantum function corresponding to the operator to be applied by Reece on his qubits. **You must complete this function**.\n",
    "- `magic_operator`: The magic operator provided by Trine to be applied on the initially entangled qubits $Z_1$ and $R_1$. **You must complete this function**.\n",
    "\n",
    "### Inputs and outputs\n",
    "\n",
    "There are no inputs nor outputs for this challenge. You answer will be judged based on the fact that your circuit produces the correct final state for any combination of basis states $|j\\rangle_{Z_0}$ and $|k\\rangle_{R_0}$. This will be verified in the `check` function.\n",
    "\n",
    "### Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ccc55a9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pennylane as qml\n",
    "import pennylane.numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "db1c1ec8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def zenda_operator():\n",
    "    \"\"\"\n",
    "    Quantum function corresponding to the operator to be applied by\n",
    "    Zenda in her qubits.This function does not return anything, \n",
    "    you must simply write the necessary gates.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your code here #\n",
    "    \n",
    "    # if z0=1, |\\phi> = |00> + |11>\n",
    "    # if z0=1, |\\phi> = |10> + |01>\n",
    "    qml.CNOT(wires=[\"z0\", \"z1\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "46694258",
   "metadata": {},
   "outputs": [],
   "source": [
    "def reece_operator():\n",
    "    \"\"\"\n",
    "    Quantum function corresponding to the operator to be applied by\n",
    "    Reece in his qubits.This function does not return anything, \n",
    "    you must simply write the necessary gates.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your code here #\n",
    "    \n",
    "    # if r0=0, |\\phi> = |00> + |11>\n",
    "    # elif r0=1, |\\phi> = |00> - |11>\n",
    "    qml.CZ(wires=[\"r0\", \"r1\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "79168027",
   "metadata": {},
   "outputs": [],
   "source": [
    "def magic_operator():\n",
    "    \"\"\"\n",
    "    Quantum function corresponding to the operator to be applied on the \"z1\"\n",
    "    and \"r1\" qubits. This function does not return anything, you must\n",
    "    simply write the necessary gates.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your code here #\n",
    "    \n",
    "    # the above rotates the given Bell state into one of the 4 Bell states\n",
    "    # so we just have to decode which exact Bell state it is here\n",
    "    # note: z0 bitflips and r0 phaseflips, but z1 haseflips and r1 bitflips for swap\n",
    "    qml.CNOT(wires=[\"z1\", \"r1\"])\n",
    "    qml.Hadamard(wires=[\"z1\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "dbba7748",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bell_generator():\n",
    "    \"\"\"\n",
    "    Quantum function preparing bell state shared by Reece and Zenda.\n",
    "    \"\"\"\n",
    "\n",
    "    qml.Hadamard(wires=[\"z1\"])\n",
    "    qml.CNOT(wires=[\"z1\", \"r1\"])\n",
    "\n",
    "\n",
    "dev = qml.device(\"default.qubit\", wires=[\"z0\", \"z1\", \"r1\", \"r0\"])\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def circuit(j, k):\n",
    "    bell_generator()\n",
    "\n",
    "    # j encoding and Zenda operation\n",
    "    qml.BasisEmbedding([j], wires=\"z0\")\n",
    "    zenda_operator()\n",
    "\n",
    "    # k encoding and Reece operation\n",
    "    qml.BasisEmbedding([k], wires=\"r0\")\n",
    "    reece_operator()\n",
    "\n",
    "    magic_operator()\n",
    "\n",
    "    return qml.probs(wires=dev.wires)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "969ee803",
   "metadata": {},
   "outputs": [],
   "source": [
    "# These functions are responsible for testing the solution.\n",
    "def run(test_case_input: str) -> str:\n",
    "    return None\n",
    "\n",
    "\n",
    "def check(solution_output: str, expected_output: str) -> None:\n",
    "\n",
    "    try:\n",
    "        dev1 = qml.device(\"default.qubit\", wires = [\"z0\", \"z1\"])\n",
    "        @qml.qnode(dev1)\n",
    "        def circuit1():\n",
    "            zenda_operator()\n",
    "            return qml.probs(dev1.wires)\n",
    "        circuit1()\n",
    "    except:\n",
    "        assert False, \"zenda_operator can only act on z0 and z1 wires\"\n",
    "\n",
    "    try:\n",
    "        dev2 = qml.device(\"default.qubit\", wires = [\"r0\", \"r1\"])\n",
    "        @qml.qnode(dev2)\n",
    "        def circuit2():\n",
    "            reece_operator()\n",
    "            return qml.probs(dev2.wires)\n",
    "        circuit2()\n",
    "    except:\n",
    "        assert False, \"reece_operator can only act on r0 and r1 wires\"\n",
    "    try:\n",
    "        dev3 = qml.device(\"default.qubit\", wires = [\"z1\", \"r1\"])\n",
    "        @qml.qnode(dev3)\n",
    "        def circuit3():\n",
    "            magic_operator()\n",
    "            return qml.probs(dev3.wires)\n",
    "        circuit3()\n",
    "    except:\n",
    "        assert False, \"magic_operator can only act on r1 and z1 wires\"\n",
    "\n",
    "\n",
    "    for j in range(2):\n",
    "        for k in range(2):\n",
    "            assert np.isclose(circuit(j, k)[10 * j + 5 * k], 1), \"The output is not correct\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "131a0828",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = [['No input', 'No output']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cc3ab96f",
   "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
}