ipynb/2.1-Ctrl-Z.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "117f9426",
   "metadata": {},
   "source": [
    "##### Bending Bennett's Laws\n",
    "\n",
    "# Ctrl-Z (100 points)\n",
    "\n",
    "### Backstory\n",
    "\n",
    "Zenda and Reece work at Trine's Designs, a startup run by the eccentric inventor Doc Trine. Trine promises to tell Zenda and Reece about a revolutionary new type of quantum resource she has invented called \"*timbits*\". Before explaining timbits, she insists on demonstrating [Bennett's Laws of Infodynamics](https://en.wikipedia.org/wiki/Bennett%27s_laws), governing the behaviour of quantum information. \"*Only then,*\" she says, \"*will the power of timbits be revealed in their full glory.*\"\n",
    "\n",
    "### Reversible computation\n",
    "\n",
    "#### Laws of Infodynamics Part I: The First Law\n",
    "\n",
    "This box contains some interesting but nonessential details. A qubit can be used to imitate a classical bit (which we'll call cbits), since instead of sending a cbit $j$, we can send a basis state $|j\\rangle$. We can write this as an inequality, the First Law of Infodynamics:\n",
    "\n",
    "$$1 \\text{ qubit} \\geq 1 \\text{ cbit} \\tag{1}$$\n",
    "\n",
    "But although we can encode classical data into qubits, it's not obvious we can always compute in the same way.\n",
    "\n",
    "#### Reversible computation\n",
    "\n",
    "Some classical logical operations are *irreversible*. For instance,\n",
    "\n",
    "$$\\mathrm{AND}(0,0) = \\mathrm{AND}(0,1) = \\mathrm{AND}(1,0) = 0$$\n",
    "\n",
    "so given that $\\mathrm{AND}(j,k)$, we can't tell the values of $j$ and $k$.\n",
    "\n",
    "![AND Gate](../img/and.png)\n",
    "\n",
    "Put differently, there is no way to press `ctrl-Z` and learn what went in! In contrast, quantum circuits are built out of unitary gates, which are always reversible. We can always press `ctrl-Z`! How can we encode something irreversible, like an AND gate, into a quantum circuit? Aptly, the answer is a controlled $Z$ gate! It encodes the classical operation into a phase:\n",
    "\n",
    "$$\\mathrm{CZ} |j,k\\rangle \\mapsto (-1)^{\\mathrm{AND}(j,k)} |j,k\\rangle$$\n",
    "\n",
    "A phase by itself is unobservable, so we need to interfere this state with some others to detect it. A simple way to do this is to use a controlled controlled $Z$ gate, with some extra operations on either side:\n",
    "\n",
    "![CCZ Gate](../img/ctrl-Z.png)\n",
    "\n",
    "Your job: figure out which operations to apply so that measurement on the first qubit is guaranteed to be in state $|\\mathrm{AND}(j,k)\\rangle$.\n",
    "\n",
    "## Challenge code\n",
    "\n",
    "In the code below, you are given a function called `AND(j, k)`. **You must complete this circuit** and provide gates which implement a classical AND gate. More precisely, if the second and third qubits are in states $|j\\rangle$ and $|k\\rangle$, the circuit should place the first qubit in state $|\\mathrm{AND}(j,k)\\rangle$.\n",
    "\n",
    "### Inputs\n",
    "\n",
    "As input to this problem, you are given two bits `j` (`int`) and `k` (`int`), encoded onto the second and third qubits for you.\n",
    "\n",
    "### Output\n",
    "\n",
    "Your circuit must place the first qubit in basis state `AND(j, k)`. This will be checked using `qml.probs(wires = 0)`, which gives `[1, 0]` for $|0\\rangle$ and `[0, 1]` for $|1\\rangle$.\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": "4a7bde58",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pennylane as qml\n",
    "import pennylane.numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "68919c8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device(\"default.qubit\", wires=3)\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def AND(j, k):\n",
    "    \"\"\"Implements the AND gate using quantum gates and computes j AND k.\n",
    "\n",
    "    Args:\n",
    "        j (int): A classical bit, either 0 or 1. \n",
    "        k (int): A classical bit, either 0 or 1. \n",
    "\n",
    "    Returns:\n",
    "        float: The probabilities of measurement on wire 0.\n",
    "    \"\"\"\n",
    "    \n",
    "    if j == 1: # |0jk>\n",
    "        qml.PauliX(wires=1)\n",
    "    if k == 1:\n",
    "        qml.PauliX(wires=2)\n",
    "        \n",
    "    # Put your code here #\n",
    "    \n",
    "    qml.Hadamard(wires=0)\n",
    "    \n",
    "    qml.ctrl(qml.PauliZ, control =[0, 1])(wires = [2]) \n",
    "\n",
    "    # Your code here #\n",
    "    \n",
    "    qml.Hadamard(wires=0) \n",
    "\n",
    "    return qml.probs(wires=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fd5bb02d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# These functions are responsible for testing the solution.\n",
    "def run(test_case_input: str) -> str:\n",
    "    j, k = json.loads(test_case_input)\n",
    "    output = AND(j, k).tolist()\n",
    "\n",
    "    return str(output)\n",
    "\n",
    "def check(solution_output: str, expected_output: str) -> None:\n",
    "    solution_output = json.loads(solution_output)\n",
    "    expected_output = json.loads(expected_output)\n",
    "    assert np.allclose(solution_output, expected_output, rtol=1e-4), \"Your classical operation isn't behaving correctly!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "03243c57",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = [['[0, 0]', '[1, 0]'], ['[1, 1]', '[0, 1]']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9c3c242e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running test case 0 with input '[0, 0]'...\n",
      "Correct!\n",
      "Running test case 1 with input '[1, 1]'...\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
}