ipynb/1.3-The_Change_of_Qubit.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "86253d59",
   "metadata": {},
   "source": [
    "##### Office Hijinks\n",
    "\n",
    "# The Change of Qubit (300 points)\n",
    "\n",
    "### Backstory\n",
    "\n",
    "Zenda needs to send an email to Reece through Trine's Designs' Quantum Area Network. The network is a quantum circuit that simply swaps qubits between wires. However, a virus seems to be interfering with proper communication within the network. Zenda can't get rid of the virus, but she has figured out what it's doing. Let's help her reprogram the network to get around the issue.\n",
    "\n",
    "### More than just a SWAP\n",
    "\n",
    "This challenge's statement is very simple, but solving it may not be so easy. The goal will be to move a state\n",
    "\n",
    "from one qubit to another, as shown in the figure:\n",
    "\n",
    "![swap_circuit](../img/image1_qubit_change.jpeg)\n",
    "\n",
    "Easy, isn't it? Well, we are going to complicate it a little bit. We will not allow any direct connections between the first and last qubits, so you will have to use the middle qubit to pass the information from one qubit to another.\n",
    "\n",
    "The exercise has become more challenging, but we still want to complicate it further! In addition to all of the above, we are going to generate a virus operator $U$ and place it in the middle of the circuit, like so:\n",
    "\n",
    "![swap_circuit_virus](../img/image2_qubit_change.jpeg)\n",
    "\n",
    "In this case, $U$ consists of one `PauliX` gate that we place randomly in one of the three qubits (each time, the gate is generated in a different wire). You should be able to complete the circuit so that, regardless of the randomly generated operator $U$, you are able to move the state from the first qubit to the last qubit.\n",
    "\n",
    "## Challenge code\n",
    "\n",
    "In this challenge, you will only be asked to complete the `circuit_left` and `circuit_right` operators to meet the objective of the statement.\n",
    "\n",
    "### Input\n",
    "\n",
    "To encode the initial state $|\\psi\\rangle$, we will use a $U3$ gate. The input will be the three parameters (`alpha`, `beta`, `gamma`) associated with this gate.\n",
    "\n",
    "### Output\n",
    "\n",
    "In this case, the output is the measurement result of the last qubit with respect to an observable. In this way, we check if it coincides with the expected state. Good luck!\n",
    "\n",
    "### Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "42c8e9e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pennylane as qml\n",
    "import pennylane.numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "00aeb4de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.75, 0.25], requires_grad=True)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def circuit_left():\n",
    "    \"\"\"\n",
    "    This function corresponds to the circuit on the left-hand side of the diagram in the \n",
    "    description. Simply place the necessary operations, you do not have to return anything.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your code here #\n",
    "    \n",
    "    # swap wire 0 to wire 2\n",
    "    qml.SWAP(wires=[0,1])\n",
    "    qml.SWAP(wires=[1,2])\n",
    "\n",
    "def circuit_right():\n",
    "    \"\"\"\n",
    "    This function corresponds to the circuit on the right-hand side of the diagram in the \n",
    "    description. Simply place the necessary operations, you do not have to return anything.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your code here #\n",
    "    \n",
    "    # check is wires 0 or 1 has bitflip/PauliX error\n",
    "    # if either has error, dont touch wire 2 \n",
    "    # if none has error, bitflip wire 2 back to original\n",
    "    qml.PauliX(wires=2)\n",
    "    qml.CNOT(wires=[0, 1])\n",
    "    qml.CNOT(wires=[1, 2])\n",
    "\n",
    "@qml.qnode(qml.device(\"default.qubit\", wires=3))\n",
    "def test():\n",
    "    qml.RX(np.pi/3, wires=0) # state prep\n",
    "    circuit_left() # left circuit\n",
    "    qml.PauliX(wires=2) # error\n",
    "    circuit_right() # right circuit\n",
    "    return qml.probs(wires=2)\n",
    "test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9eb4d762",
   "metadata": {},
   "outputs": [],
   "source": [
    "def U():\n",
    "    \"\"\"This operator generates a PauliX gate on a random qubit\"\"\"\n",
    "    qml.PauliX(wires=np.random.randint(3))\n",
    "\n",
    "\n",
    "dev = qml.device(\"default.qubit\", wires=3)\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def circuit(alpha, beta, gamma):\n",
    "    \"\"\"Total circuit joining each block.\n",
    "\n",
    "    Args: \n",
    "        alpha (float): The first parameter of a U3 gate.\n",
    "        beta (float):The second parameter of a U3 gate. \n",
    "        gamma (float): The third parameter of a U3 gate. \n",
    "    \n",
    "    Returns:\n",
    "        (float): The expectation value of an observable.\n",
    "    \"\"\"\n",
    "    qml.U3(alpha, beta, gamma, wires=0)\n",
    "    circuit_left()\n",
    "    U()\n",
    "    circuit_right()\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.5 * qml.PauliZ(2) - qml.PauliY(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "670449d5",
   "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",
    "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",
    "    ops = circuit.tape.operations\n",
    "\n",
    "    for op in ops:\n",
    "        assert not (0 in op.wires and 2 in op.wires), \"Invalid connection between qubits.\"\n",
    "\n",
    "    assert circuit.tape.observables[0].wires == qml.wires.Wires(2), \"Measurement on wrong qubit.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "72a8b858",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = [['[2.0,1.0,3.0]', '-0.97322'], ['[-0.5,1.2,-1.2]', '0.88563'], ['[0.22,3.0,2.1]', '0.457152'], ['[2.22,3.1,-3.3]', '-0.335397'], ['[-0.2,-0.1,3.4]', '0.470199'], ['[-1.2,-1.1,0.4]', '-0.6494612']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0cdf4d6c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running test case 0 with input '[2.0,1.0,3.0]'...\n",
      "Correct!\n",
      "Running test case 1 with input '[-0.5,1.2,-1.2]'...\n",
      "Correct!\n",
      "Running test case 2 with input '[0.22,3.0,2.1]'...\n",
      "Correct!\n",
      "Running test case 3 with input '[2.22,3.1,-3.3]'...\n",
      "Correct!\n",
      "Running test case 4 with input '[-0.2,-0.1,3.4]'...\n",
      "Correct!\n",
      "Running test case 5 with input '[-1.2,-1.1,0.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
}