ipynb/1.5-The_False_Proof.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3c6c5e46",
   "metadata": {},
   "source": [
    "##### Office Hijinks\n",
    "\n",
    "# The False Proof (500 points)\n",
    "\n",
    "### Backstory\n",
    "\n",
    "Trine's Designs is very community-oriented, and customers like to write letters to the staff to get help with a variety of issues. A mysterious person has sent a non-sensical mathematical proof about complex numbers. No one at the company is good at complex analysis, but Zenda and Reece set out to use a quantum circuit to prove the anonymous customer wrong.\n",
    "\n",
    "### One-shot proof\n",
    "\n",
    "In the 17th century, a nice custom spread among intellectuals: challenging each other to solve numerical problems and puzzles. These challenges were sent through letters and, thanks to this, mathematics expanded and gained a lot of popularity.\n",
    "\n",
    "It seems that this tradition is making a comeback because the other day Reece received the following letter at the office:\n",
    "\n",
    "\"Hello Trine team, I have just come to a discovery of great importance, I have just proved that $\\frac{2\\pi}{3} = \\frac{4\\pi}{3}$. I attach a simple proof. If you think I'm wrong, prove it!*\"\n",
    "\n",
    "![proof](../img/2is4.jpeg)\n",
    "\n",
    "Actually, the proof is very convincing, but Reece turns to quantum computing to show that this is not so (for fun, if you like math: find the line where the mistake is!). To do this, Reece manages to show that $R_Y(\\frac{2\\pi}{3})$ is different from $R_Y(\\frac{4\\pi}{3})$. In fact, they are so different that a single shot is enough to distinguish them!\n",
    "\n",
    "This will be your objetive for this challenge! We are going to give you a gate $U$, which you know is either $R_Y(\\frac{2\\pi}{3})$ or $R_Y(\\frac{4\\pi}{3})$. Your task will be to build a quantum circuit containing $U$ to unambiguously determine which of the two gates it is using only *one shot*.\n",
    "\n",
    "To do this, you will have access to a two-qubit circuit. You can use $U$ as many times as you want, but one thing is important: the solution must guarantee with **100% probability** which of the two options it is.\n",
    "\n",
    "Note: even if you do not know $U$, you are allowed to use `qml.ctrl` over $U$ if necessary.\n",
    "\n",
    "#### Epilogue\n",
    "\n",
    "After successfully debunking the proof, Zenda and Reece are enjoying a well-deserved rest from office hijinks when Doc Trine, the boss herself, appears from the basement laboratory. \"Well, it seems you have passed my little math test! Please, step into my office.\" Her office is the basement, and they filled with all sorts of odds and ends: a machine whose only function is to turn itself off, an anti-toaster for making old bread fresh, some sort of tiny imp lugging around two chambers and looking for work. Trine looks at them: \"I think you might be excited by my latest invention. It promises to save us all a lot of time!\"\n",
    "\n",
    "Read on in **Bending Bennett's Laws**.\n",
    "\n",
    "## Challenge code\n",
    "\n",
    "On one hand you are asked to complete `circuit` (you only need to apply gates). On the other hand you must complete `process_output`, which will take the output of `circuit` (a vector of dimension two where each term can take the value 0 or 1) and will return 2 if $U = RY(2\\pi/3)$ or 4 if $U = RY(4\\pi/3)$.\n",
    "\n",
    "### Output\n",
    "\n",
    "The circuit function will receive the gate $U$ that you are asked to determine. To judge whether your circuit works as expected, we will randomly send 5000 different examples and check that they always classified correctly. Therefore, in this question there are no public or private test cases. They are randomly generated. Good luck!\n",
    "\n",
    "### Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0db22b9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pennylane as qml\n",
    "import pennylane.numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e48930be",
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device(\"default.qubit\", wires=2, shots=1)\n",
    "dev.operations.add(\"op\")\n",
    "dev.operations.add(\"C(op)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ff4d2726",
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qnode(dev)\n",
    "def circuit(U):\n",
    "    \"\"\"This will be the circuit you will use to determine which of the two angles we have.\n",
    "    Remember that only a single shot will be executed.\n",
    "\n",
    "    Args:\n",
    "        U (qml.ops): It is the gate to discriminate between  RY(2pi/3) or RY(4pi/3).\n",
    "\n",
    "    Returns:\n",
    "        (numpy.tensor): Vector of two elements representing the output measured in each of the qubits.\n",
    "    \"\"\"\n",
    "    # to use U,  call 'U(wires = <wire where you want to apply the gate>)'\n",
    "    # to use Control-U, call 'qml.ctrl(U, control = <control wire>)(wires = <wire where you want to apply the gate>)'\n",
    "    \n",
    "    # Put your code here #\n",
    "    \n",
    "    qml.Hadamard(wires=0) # |00> + |10>\n",
    "    for _ in range(3): # |00>+|10> for 4pi/3 or |00>-|10> for 2pi/3\n",
    "        qml.ctrl(U, control=0)(wires=1)\n",
    "    qml.Hadamard(wires=0) # |00> or |10>\n",
    "    \n",
    "    return qml.sample(wires=range(2))\n",
    "\n",
    "def process_output(measurement):\n",
    "    \"\"\"This function processes the output of the circuit to discriminate between gates.\n",
    "\n",
    "    Args:\n",
    "        measurement (numpy.array): Output of the previous circuit a vector of dimension 2.\n",
    "\n",
    "    Returns:\n",
    "        (int): return 2 or 4 depending on the associated RY gate.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your code here #\n",
    "    \n",
    "    if measurement[0] == 0:\n",
    "        return 4\n",
    "    else:\n",
    "        return 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e14d04f5",
   "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",
    "    numbers = 2 * np.random.randint(1, 3, 5000)\n",
    "\n",
    "    def U2(wires):\n",
    "        class op(qml.operation.Operator):\n",
    "            num_wires = 1\n",
    "\n",
    "            def compute_decomposition(self, wires):\n",
    "                raise ValueError(\"You cannot decompose this gate\")\n",
    "\n",
    "            def matrix(self):\n",
    "                return qml.matrix(qml.RY(2 * np.pi / 3, wires=3))\n",
    "\n",
    "        op(wires=wires)\n",
    "        return None\n",
    "\n",
    "    def U4(wires):\n",
    "        class op(qml.operation.Operator):\n",
    "            num_wires = 1\n",
    "\n",
    "            def compute_decomposition(self, wires):\n",
    "                raise ValueError(\"You cannot decompose this gate\")\n",
    "\n",
    "            def matrix(self):\n",
    "                return qml.matrix(qml.RY(4 * np.pi / 3, wires=3))\n",
    "\n",
    "        op(wires=wires)\n",
    "        return None\n",
    "\n",
    "    output = []\n",
    "    for i in numbers:\n",
    "        if i == 2:\n",
    "            U = U2\n",
    "        else:\n",
    "            U = U4\n",
    "        out = circuit(U)\n",
    "        output.append(process_output(out))\n",
    "\n",
    "    assert np.allclose(\n",
    "        output, numbers, rtol=1e-4\n",
    "    ), \"Your circuit does not give the correct output.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fabf6f39",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = [['No input', 'No output']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ab991267",
   "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
}