ipynb/2.4-A_Halfway-Decent_Photocopier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "391364ec",
   "metadata": {},
   "source": [
    "##### Bending Bennett's Laws\n",
    "\n",
    "# A Halfway-Decent Photocopier (400 points)\n",
    "\n",
    "### Backstory\n",
    "\n",
    "Trine is getting bored. \"*So, we've finished the usual [Laws of Infodynamics](https://en.wikipedia.org/wiki/Bennett%27s_laws). Let's make things more interesting!*\" She shows Zenda and Reece to the office photocopier. \"*I figured out a way to turn this into a quantum resource! Pretty cool huh?*\" Zenda and Reece look at each other, puzzled as ever by Trine's unconventional ideas about office equipment. Trine pats the photocopier. \"*Yup, this old thang can photocopy a basis state. You can use it to make Bell pairs! In fact, we can introduce the photocopier into our superdense and teleportation protocols in such a way that it turns infodynamic inequalities into equalities. We'll find that a photocopier is halfway between a qubit and an entangled bit! I always said this was a halfway-decent photocopier.*\" Zenda and Reece shrug and start feeding qubits into the machine.\n",
    "\n",
    "### Coherent protocols\n",
    "\n",
    "Zenda and Reece are having a bit too much fun feeding qubits into the photocopy machine. It's not very good at photocopying qubits, but it can copy basis states into new registers in the following way\n",
    "\n",
    "$$|j\\rangle \\mapsto |j\\rangle |j\\rangle$$\n",
    "\n",
    "and extending linearly to the whole space. From linearity, you can prove yourself that the operator the photocopy machine is applying does not allow for copying arbitrary states!\n",
    "\n",
    "Zenda ponders the meaning of Trine's words. She wonders if she can use the photocopy machine as a quantum fax machine instead. *That should be equivalent to quantum teleportation... except that I wouldn't need to do mid-circuit measurements*. She convinces Reece to join on the mischief, sharing with him half of the Bell state\n",
    "\n",
    "$$|\\Phi\\rangle = \\frac{1}{\\sqrt{2}} \\left( |0\\rangle_{Z_1} |0\\rangle_{R_1} + |1\\rangle_{Z_1} |1\\rangle_{R_1} \\right)$$\n",
    "\n",
    "Let's see how Zenda and Reece get away with this. Zenda has a state $|\\psi\\rangle$ that she wants to transfer to Reece, and half of the Bell pair above. After doing some operations $Z$ on her two qubits, she can perform the `copier` operation that copies basis states into two registers inside the copy machine's server. That information is then transfered to Reece's printer where, after performing the `print` operation with his states, he prints the state $|\\psi\\rangle$ into his half of the entangled pair.\n",
    "\n",
    "Zenda shows Reece the schematics for the above:\n",
    "\n",
    "![Photocopier Circuit](../img/circuit_copy.jpeg)\n",
    "\n",
    "Your task is to build the operator $Z$ that Zenda must perform on her qubit, as well as the copier and printer operators needed to teleport the state. For the copier operator, the simplest way is to use the basis copying operator introduced at the beginning:\n",
    "\n",
    "$$|j\\rangle |0\\rangle \\mapsto |j\\rangle |j\\rangle$$\n",
    "\n",
    "Which well-known gate achieves this?\n",
    "\n",
    "#### Laws of Infodyamics Part IV: Coherent versions of the Third and Fourth Laws\n",
    "\n",
    "This box contains some interesting but nonessential details.\n",
    "\n",
    "The operation\n",
    "\n",
    "$$|j\\rangle |0\\rangle \\mapsto |j\\rangle |j\\rangle$$\n",
    "\n",
    "we introduced in this challenge is knows as a **cobit**.\n",
    "\n",
    "As a simple application of cobits, we can make a Bell pair by applying the photocopier to the $|+\\rangle$ state:\n",
    "\n",
    "$$\\frac{1}{\\sqrt{2}} (|0\\rangle + |1\\rangle) \\mapsto \\frac{1}{\\sqrt{2}} (|00\\rangle + |11\\rangle)$$\n",
    "\n",
    "But cobits are much more interesting! As a first example, one can modify superdense coding so that Zenda and Reece can copy two bits:\n",
    "\n",
    "$$|j,k\\rangle_Z \\mapsto |j,k\\rangle_Z |j,k\\rangle_R$$\n",
    "\n",
    "The basic idea is to replace the act of sending two classical bits, $j$ and $k$, with the act of copying two basis states:\n",
    "\n",
    "$$|j,k\\rangle_Z \\mapsto |j,k\\rangle_Z |j,k\\rangle_R$$\n",
    "\n",
    "We can rewrite the Third Law of Infodynamics (superdense coding) in terms of cobits as\n",
    "\n",
    "$$1 \\text{ qubit} + 1 \\text{ ebit} \\geq 2 \\text{ cobits} \\tag{3'}$$\n",
    "\n",
    "where $x \\geq y$ means having resource $x$ also provide resource $y$, and \"ebit\" means \"entangled bit\", i.e. half a Bell pair. Similarly, it is possible to perform teleportation coherently, so that sending random bits $j,k$ to correct the teleported state is instead a unitary involving $|j,k\\rangle$. This leads to a new version of the Fourth Law of Infodynamics (teleportation):\n",
    "\n",
    "$$1 \\text{ ebit} + 2 \\text{ cobits} \\geq 1 \\text{ qubit} + 2 \\text{ ebits} \\tag{4'}$$\n",
    "\n",
    "If we subtract an ebit from both sides and combine with the modified Third Law, we obtain the *equality*\n",
    "\n",
    "$$2 \\text{ cobits} = 1 \\text{ qubit} + 1 \\text{ ebit}$$\n",
    "\n",
    "Photocopying basis states is precisely halfway between an ebit and a qubit!\n",
    "\n",
    "## Challenge code\n",
    "\n",
    "In this challenge, you will be asked to complete the `zenda_operator`, `copier` and `printer` functions. All of them are quantum functions where you will only have to place the necessary gates.\n",
    "\n",
    "### Inputs\n",
    "\n",
    "The inputs of this challenge correspond to the three coefficients of a $U3$ gate in charge of encoding the state $|\\Phi\\rangle$ that Zenda wants to send.\n",
    "\n",
    "### Outputs\n",
    "\n",
    "To check the solution, we will calculate the expected value with respect to a particular observable to see that it coincides with the same one generated by Zenda. If your solution matches the correct one within the given tolerance specified in `check` (in this case it's a `1e-2` absolute error tolerance), the output will be `\"Correct!\"` Otherwise, you will receive a `\"Wrong answer\"` prompt.\n",
    "\n",
    "### Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a50f4beb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pennylane as qml\n",
    "import pennylane.numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1e8e5887",
   "metadata": {},
   "outputs": [],
   "source": [
    "def zenda_operator():\n",
    "    \"\"\"\n",
    "    Quantum function corresponding to the operator to be applied by\n",
    "    Zenda on her qubits. This function does not return anything,\n",
    "    you must simply write the necessary gates.\n",
    "    \"\"\"\n",
    "    # Put your code here #\n",
    "    \n",
    "    # Bell measuerement part of quantum teleportation\n",
    "    qml.CNOT(wires=[\"z0\", \"z1\"])\n",
    "    qml.Hadamard(wires=\"z0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1a24ee15",
   "metadata": {},
   "outputs": [],
   "source": [
    "def copier():\n",
    "    \"\"\"\n",
    "    Quantum function encoding the copy operation cone by Zenda, on each qubit.\n",
    "    This function does not return anything, you must simply write the necessary gates.\n",
    "    \"\"\"\n",
    "    # Put your code here #\n",
    "    \n",
    "    # measurement part of quantum teleporation\n",
    "    # 2 classical bits are sent through the 2 qubits\n",
    "    qml.CNOT(wires=[\"z0\", \"s0\"])\n",
    "    qml.CNOT(wires=[\"z1\", \"s1\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "06dea7f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def printer():\n",
    "    \"\"\"\n",
    "    Quantum function encoding the print operation done by Reece's printer.\n",
    "    This function does not return anything, you must simply write the necessary gates.\n",
    "    \"\"\"\n",
    "    # Put your code here #\n",
    "    \n",
    "    # controlled rotation part of quantum teleporation\n",
    "    qml.CZ(wires=[\"s0\", \"r1\"])\n",
    "    qml.CNOT(wires=[\"s1\", \"r1\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5d99375a",
   "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\", \"s0\", \"s1\"])\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def circuit(alpha, beta, gamma):\n",
    "\n",
    "    # we encode the initial state\n",
    "    qml.U3(alpha, beta, gamma, wires = \"z0\")\n",
    "\n",
    "    bell_generator()\n",
    "\n",
    "    # Zenda acts on her qubits and establishes and copies them.\n",
    "    zenda_operator()\n",
    "    copier()\n",
    "\n",
    "\n",
    "    # Reece programs his printer\n",
    "    printer()\n",
    "\n",
    "    # Here we are returning the expected value with respect to any observable,\n",
    "    # the choice of observable is not important in this exercise.\n",
    "\n",
    "    return qml.expval(0.25 * qml.PauliX(\"r1\") + qml.PauliY(\"r1\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6d1e0a5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# These functions are responsible for testing the solution.\n",
    "def run(test_case_input: str) -> str:\n",
    "    angles = json.loads(test_case_input)\n",
    "    output = circuit(*angles)\n",
    "    return str(output)\n",
    "\n",
    "\n",
    "def check(solution_output: str, expected_output: str) -> None:\n",
    "\n",
    "    solution_output = json.loads(solution_output)\n",
    "    expected_output = json.loads(expected_output)\n",
    "    assert np.allclose(\n",
    "        solution_output, expected_output, atol=2e-1\n",
    "    ), \"The expected output is not quite right.\"\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",
    "        dev1 = qml.device(\"default.qubit\", wires = [\"z0\", \"z1\", \"s0\", \"s1\"])\n",
    "        @qml.qnode(dev1)\n",
    "        def circuit1():\n",
    "            copier()\n",
    "            return qml.probs(dev1.wires)\n",
    "        circuit1()\n",
    "    except:\n",
    "        assert False, \"copy can only act on z0, z1, s0 and s1 wires\"\n",
    "\n",
    "\n",
    "    try:\n",
    "        dev1 = qml.device(\"default.qubit\", wires = [\"s0\", \"s1\", \"r1\"])\n",
    "        @qml.qnode(dev1)\n",
    "        def circuit1():\n",
    "            printer()\n",
    "            return qml.probs(dev1.wires)\n",
    "        circuit1()\n",
    "    except:\n",
    "        assert False, \"Reece's printer can only act on s0, s1 and r1 wires\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7c152da8",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = [['[1,1,1]', '0.8217355966267811'], ['[1.2,1.3,1.4]', '0.9604037313446201']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "edf288cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running test case 0 with input '[1,1,1]'...\n",
      "Correct!\n",
      "Running test case 1 with input '[1.2,1.3,1.4]'...\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
}