ipynb/0.3-A_Shor_Thing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dcbb26ed",
   "metadata": {},
   "source": [
    "##### Tutorial Challenges\n",
    "\n",
    "# 3. A Shor Thing (0 points)\n",
    "\n",
    "Welcome to the QHack 2023 daily challenges! Every day for the next four days, you will receive two new challenges to complete. These challenges are worth no points — they are specifically designed to get your brain active and into the right mindset for the competition. You will also learn about various aspects of PennyLane that are essential to quantum computing, quantum machine learning, and quantum chemistry. Have fun!\n",
    "\n",
    "\n",
    "## Tutorial \\#3 — Shor's 9-qubit-code\n",
    "\n",
    "Quantum computational advantage — the ability of quantum computers to perform certain tasks faster than the best classical computers — has now been demonstrated in a number of cases. Arguably, the next big milestone in quantum computing is *fault-tolerance* for large-scale devices, allowing them to correct errors that crop up as a result of noisy interactions with the environment or between parts of the computer.\n",
    "\n",
    "The early years of quantum error correction yielded several ground-breaking protocols, none more famous than Peter Shor's 9-qubit-code, pictured below.\n",
    "\n",
    "![Shor's 9-qubit Code](../img/daily3.png)\n",
    "\n",
    "In this challenge, you will implement Shor's code for an arbitrary initial state $|\\psi\\rangle$ that is subject to an error.\n",
    "\n",
    "## Challenge code\n",
    "\n",
    "In the code below, you are given a couple functions:\n",
    "\n",
    "- `shor`: a QNode that contains the operations required to define Shor's code given an initial `state` and an `error` occuring in the middle of the circuit. It must output the expectation value of the Pauli Z operator on each qubit. **You must complete this function.**\n",
    "- `error`: this function contains the error operator that will be introduced into the circuit you create with `shor`. The possible errors are Pauli X, Y, and Z errors (see `error_dict`). To call this within `shor`, simply write `error(error_key, qubit)` and it will apply the error!\n",
    "\n",
    "Here are some helpful resources:\n",
    "\n",
    "- [Shor code](https://en.wikipedia.org/wiki/Quantum_error_correction#Shor_code)\n",
    "- [Quantum error correction](https://en.wikipedia.org/wiki/Quantum_error_correction)\n",
    "\n",
    "### Input\n",
    "\n",
    "As input to this problem, you are given:\n",
    "\n",
    "- `state` (`list(float)`): defines the initial one-qubit state $|\\psi\\rangle$. The remaining 8 qubits are initialized in the $|0\\rangle$ state.\n",
    "- `error_key` (`int`): an integer corresponding to a Pauli X, Y, or Z error. See `error_dict`.\n",
    "- `qubit` (`int`): an integer corresponding to which qubit the error will occur on.\n",
    "\n",
    "### Output\n",
    "\n",
    "This code must output a `ist(float)` corresponding to the expectation values of the Pauli Z operator on every qubit.\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",
    "Good luck!\n",
    "\n",
    "### Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8598a6be",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pennylane as qml\n",
    "import pennylane.numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d7a2884a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(8))[::3][1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "15d038c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ──QubitStateVector(M0)─╭●─╭●──H─╭●─╭●──X─╭●─╭●─╭X──H─╭●─╭●─╭X─┤  <Z>\n",
      "1: ───────────────────────│──│─────╰X─│─────╰X─│──├●────│──│──│──┤  <Z>\n",
      "2: ───────────────────────│──│────────╰X───────╰X─╰●────│──│──│──┤  <Z>\n",
      "3: ───────────────────────╰X─│───H─╭●─╭●─╭●─╭●─╭X──H────╰X─│──├●─┤  <Z>\n",
      "4: ──────────────────────────│─────╰X─│──╰X─│──├●──────────│──│──┤  <Z>\n",
      "5: ──────────────────────────│────────╰X────╰X─╰●──────────│──│──┤  <Z>\n",
      "6: ──────────────────────────╰X──H─╭●─╭●─╭●─╭●─╭X──H───────╰X─╰●─┤  <Z>\n",
      "7: ────────────────────────────────╰X─│──╰X─│──├●────────────────┤  <Z>\n",
      "8: ───────────────────────────────────╰X────╰X─╰●────────────────┤  <Z>\n"
     ]
    }
   ],
   "source": [
    "n_qubits = 9\n",
    "dev = qml.device(\"default.qubit\", wires=n_qubits)\n",
    "error_dict = {0: 'PauliX', 1: 'PauliY', 2: 'PauliZ'}\n",
    "\n",
    "def error(error_key, qubit):\n",
    "    \"\"\"Defines the error that is induced in the circuit.\n",
    "\n",
    "    Args:\n",
    "        error_key (int): An integer associated to the type of error (Pauli X, Y, or Z)\n",
    "        qubit (int): The qubit that the error occurs on.\n",
    "    \"\"\"\n",
    "    getattr(qml, error_dict[error_key])(qubit)\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def shor(state, error_key, qubit):\n",
    "    \"\"\"A circuit defining Shor's code for error correction.\n",
    "\n",
    "    Args:\n",
    "        state (list(float)): The quantum state of the first qubit in the circuit.\n",
    "        error_key (int): An integer associated to the type of error (Pauli X, Y, or Z)\n",
    "        qubit (int): The qubit that the error occurs on.\n",
    "\n",
    "    Returns:\n",
    "        (list(float)): The expectation value of the Pauli Z operator on every qubit.\n",
    "    \"\"\"\n",
    "    qml.QubitStateVector(np.array(state), wires=0)\n",
    "    \n",
    "    # Put your code here #\n",
    "    \n",
    "    for i in dev.wires[::3][1:]:\n",
    "        qml.CNOT(wires=[0,i])\n",
    "    for i in dev.wires[::3]:\n",
    "        qml.Hadamard(wires=i)\n",
    "        qml.CNOT(wires=[i,i+1])\n",
    "        qml.CNOT(wires=[i,i+2])\n",
    "        \n",
    "    error(error_key, qubit)\n",
    "    \n",
    "    for i in dev.wires[::3]:\n",
    "        qml.CNOT(wires=[i,i+1])\n",
    "        qml.CNOT(wires=[i,i+2])\n",
    "        qml.Toffoli(wires=[i+2,i+1,i])\n",
    "        qml.Hadamard(wires=i)\n",
    "    for i in dev.wires[::3][1:]:\n",
    "        qml.CNOT(wires=[0,i])\n",
    "    qml.MultiControlledX(wires=[*dev.wires[::3][1:], 0])\n",
    "\n",
    "    return [qml.expval(qml.PauliZ(i)) for i in dev.wires]\n",
    "\n",
    "print(qml.draw(shor)([0.5, 0.5], 0, 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "79f9b61b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# These functions are responsible for testing the solution.\n",
    "def run(test_case_input: str) -> str:\n",
    "    state, error_key, qubit = json.loads(test_case_input)\n",
    "    output = shor(state, error_key, qubit).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",
    "\n",
    "    assert np.allclose(solution_output, expected_output, rtol=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b7f2c104",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = [['[[0, 1], 0, 3]', '[-1.0,  1.0,  1.0,  1.0, -1.0, -1.0,  1.0,  1.0,  1.0]']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "358c6b0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running test case 0 with input '[[0, 1], 0, 3]'...\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
}