ipynb/3.2-Cascadar.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cc49178e",
   "metadata": {},
   "source": [
    "##### A Tale of Timbits\n",
    "\n",
    "# Cascadar (200 points)\n",
    "\n",
    "### Backstory\n",
    "\n",
    "Zenda and Reece have determined Doc Trine's cell number in hyperjail. Searching through Trine's notebooks, they find another note, explaining how the hypercube is patrolled by a fearsome quantum warden, which is able to place itself in a superposition and inspect multiple cells at once. To avoid detection and rescue Doc Trine, they need to build a quantum radar!\n",
    "\n",
    "### A quantum radar\n",
    "\n",
    "The quantum guard can place itself in a superposition\n",
    "\n",
    "$$|\\text{guard}\\rangle = \\sum_x g_x |x\\rangle$$\n",
    "\n",
    "where $x \\in \\{0,1\\}^5$ ranges over all cell numbers, and $g_x$ are complex-valued amplitudes. Seen in this way, $|g_x|^2$ is the probability that the guard is at position $|x\\rangle$ They know that Doc Trine is located in a cell $c=(1,1,0,0,1)$. Ideally, they would like to wait until the guard's attention, captured by the probability $|g_c|^2$, is sufficiently low.\n",
    "\n",
    "In this challenge, we will look for a way to be able to measure $|g_c|^2$. Unfortunately, there isn't much equipment in the office, and what is there is noisy! But Trine has left a collection of \"Toffoli cascades\" lying around, circuits made from a string of noisy Toffoli gates. Here is an example for three input qubits $|x_1\\rangle |x_2\\rangle |x_3\\rangle$:\n",
    "\n",
    "![Tiffoli Cascade Circuit](../img/prod.png)\n",
    "\n",
    "Measuring the last qubit in the computational basis gives $|(x_1 \\cdot x_2 \\cdot x_3)\\rangle$ with probability $1$, where $x_1 \\cdot x_2 \\cdot x_3$ indicates the product of classical bits $x_1$, $x_2$, and $x_3$. There is a Toffoli cascade acting on 5 input qubits (and with four auxiliary qubits) that Zenda and Reece can use, as well as some Pauli-$X$ gates. All are subject to depolarizing noise, such that after each gate, the state on each qubit is replaced with something random with probability $\\lambda$.\n",
    "\n",
    "Your task: use noisy Toffoli cascades and noisy-Pauli X gates to build a quantum radar, which outputs $|g_c|^2$, the guard's attention on Trine's cell. The guard state will be an input, along with four auxiliary qubits starting in the $|0\\rangle$ state.\n",
    "\n",
    "## Challenge code\n",
    "\n",
    "In the code below, you are given various functions:\n",
    "\n",
    "- `noisy_PauliX`: which applies the Pauli-X gate and then a layer of depolarizing noise with parameter lmbda. (The noise is added for you.)\n",
    "- `Toffoli_cascade`: a cascade of noisy Toffoli gates (noise parameter `lmbda`) which help compute a product, as in the circuit pictured above, with the input qubits on `in_wires` and auxiliary system a`ux_wires`. (The noise is added for you.)\n",
    "- `cascadar`: which takes a `guard_state` (`numpy.tensor`) and returns $|g_c|^2$, using noisy equipment with parameter `lmbda`. **You must complete this function**.\n",
    "\n",
    "### Inputs\n",
    "\n",
    "The noisy quantum radar `cascadar` takes as input the guard state `guard_state` (`numpy.tensor`), and a noise parameter `lmbda` (`float`) controlling the depolarizing noise.\n",
    "\n",
    "### Output\n",
    "\n",
    "Your `cascadar` function should gives the correct probability $|g_c|^2$ for test cases, including the effects of noise.\n",
    "\n",
    "If your solution matches the correct one within the given tolerance specified in `check` (in this case it's a `1e-4` relative 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": "2dc26169",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pennylane as qml\n",
    "import pennylane.numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5794a7e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def noisy_PauliX(wire, lmbda):\n",
    "    \"\"\"A Pauli-X gate followed by depolarizing noise.\n",
    "\n",
    "    Args:\n",
    "        lmbda (float): The parameter defining the depolarizing channel.\n",
    "        wire (int): The wire the depolarizing channel acts on.\n",
    "    \"\"\"\n",
    "    qml.PauliX(wire)\n",
    "    qml.DepolarizingChannel(lmbda, wires=wire)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6992498f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Toffoli_cascade(in_wires, aux_wires, lmbda):\n",
    "    \"\"\"A cascade of noisy Toffolis to help compute the product.\n",
    "    \n",
    "    Args:\n",
    "        in_wires (list(int)): The input qubits.\n",
    "        aux_wires (list(int)): The auxiliary qubits.\n",
    "        lmbda (float): The probability of erasing the state of a qubit.\n",
    "    \"\"\"\n",
    "    n = len(in_wires)\n",
    "    qml.Toffoli(wires=[in_wires[0], in_wires[1], aux_wires[0]])\n",
    "    qml.DepolarizingChannel(lmbda, wires=in_wires[0])\n",
    "    qml.DepolarizingChannel(lmbda, wires=in_wires[1])\n",
    "    qml.DepolarizingChannel(lmbda, wires=aux_wires[0])\n",
    "    for i in range(n - 2):\n",
    "        qml.Toffoli(wires=[in_wires[i + 2], aux_wires[i], aux_wires[i + 1]])\n",
    "        qml.DepolarizingChannel(lmbda, wires=in_wires[i + 2])\n",
    "        qml.DepolarizingChannel(lmbda, wires=aux_wires[i])\n",
    "        qml.DepolarizingChannel(lmbda, wires=aux_wires[i + 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ea00bab6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build a quantum radar to check how much attention is on Trine's cell\n",
    "def cascadar(guard_state, lmbda):\n",
    "    \"\"\"Return the squared amplitude |g_c|^2 of the guard state, for c = (1, 1, 0, 0, 1).\n",
    "\n",
    "    Args:\n",
    "        guard_state (numpy.tensor): A 2**5 = 32 component vector encoding the guard state.\n",
    "        lmbda (float): The probability of erasing the state of a qubit.\n",
    "\n",
    "    Returns:\n",
    "        (float): The squared amplitude of the guard state on the cell c.\n",
    "    \"\"\"\n",
    "    dev = qml.device(\"default.mixed\", wires = 5 + 4)\n",
    "    \n",
    "    @qml.qnode(dev)\n",
    "    def circuit():\n",
    "        \"\"\"\n",
    "        Circuit that will use the Toffoli_cascade and the noisy_PauliX.\n",
    "        It will return a measurement on the last qubit.\n",
    "        \"\"\"\n",
    "\n",
    "        qml.QubitStateVector(guard_state, range(5))\n",
    "        \n",
    "        # Put your code here #\n",
    "        \n",
    "        noisy_PauliX(2, lmbda) # bit flip guard state to |11111>\n",
    "        noisy_PauliX(3, lmbda)\n",
    "        Toffoli_cascade(range(5), range(5,9), lmbda)\n",
    "\n",
    "        return qml.probs(wires=8)\n",
    "\n",
    "    output = circuit()\n",
    "    \n",
    "    # if you want to post-process the output, put code here also #\n",
    "\n",
    "    return output[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "99e51af5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# These functions are responsible for testing the solution.\n",
    "def run(test_case_input: str) -> str:\n",
    "\n",
    "    guard_state, lmbda = json.loads(test_case_input)\n",
    "    output = cascadar(guard_state, lmbda)\n",
    "\n",
    "    return str(output)\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, rtol=1e-4\n",
    "    ), \"Your quantum radar isn't quite working properly!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1131b5b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = [['[[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 0.0]', '1']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "129f351b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running test case 0 with input '[[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 0.0]'...\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
}