ipynb/4.2-Unitary_Operators_and_Beyond.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f46e52d8",
   "metadata": {},
   "source": [
    "##### Fall of Sqynet\n",
    "\n",
    "# Unitary Operators and Beyond (200 points)\n",
    "\n",
    "### Backstory\n",
    "\n",
    "Zenda and Reece try to figure out Sqynet's Hamiltonian, before this eerie conscious quantum computer conquers the entirety of sector III. For this, they need to use their own (non-sentient) quantum computer to simulate the action of a Hamiltonian on a quantum state. How do they do this, if a Hamiltonian is, in general, not a unitary?\n",
    "\n",
    "### Linear combination of unitaries\n",
    "\n",
    "Zenda and Reece know that the Hamiltonian that describes Sqynet is a linear combination of unitaries, that is\n",
    "\n",
    "$$H = \\sum_i \\alpha_i U_i$$\n",
    "\n",
    "We know that quantum circuits can implement unitary operations really easily, but is there a way to implement a sum of unitaries? Note that the sum of unitaries is not always a unitary, so how can we even do this? We can use measurements!\n",
    "\n",
    "A circuit of the form\n",
    "\n",
    "![Sum fof Unitaries Circuit](../img/spaceship_2.png)\n",
    "\n",
    "will probabilistically implement the combination of unitaries $\\alpha U + \\beta V$ on the bottom (main) register, where $\\alpha$ and $\\beta$ are **positive real numbers**, without loss of generality. Here, the single-qubit unitary $W(\\alpha, \\beta)$ is represented by the matrix\n",
    "\n",
    "$$W(\\alpha, \\beta) = \\frac{1}{\\sqrt{\\alpha + \\beta}} \\left(\\begin{array}{cc} \\sqrt{\\alpha} & -\\sqrt{\\beta} \\\\ \\sqrt{\\beta} & \\sqrt{\\alpha} \\end{array}\\right)$$\n",
    "\n",
    "The combination will only be applied on the bottom (main) register when we measure the state of the of the top (auxiliary) register to be $|0\\rangle$.\n",
    "\n",
    "Your task is to calculate the probability that this the linear combination of unitaries is implemented with the circuit above.\n",
    "\n",
    "This algorithm is often used for Hamiltonian simulation. Check out the [Xanadu Quantum Codebook](https://codebook.xanadu.ai/H.6) to learn more!\n",
    "\n",
    "## Challenge code\n",
    "\n",
    "You must complete the `linear_combination` function to build the above circuit that implements the linear combination\n",
    "\n",
    "$$\\alpha U + \\beta V$$\n",
    "\n",
    "of two single-qubit unitaries U and V, and returns the probabilities on the auxiliary register. For simplicity, we take $\\alpha$ and $\\beta$ to be positive real numbers.\n",
    "\n",
    "As a helper function, you are also asked to complete the W function, which returns the unitary $W(\\alpha, \\beta)$\n",
    "\n",
    "### Input\n",
    "\n",
    "As input to this problem, you are given:\n",
    "\n",
    "- `U` (`list(list(float))`): A 2x2 matrix representing the single-qubit unitary operator $U$.\n",
    "- `V` (`list(list(float))`): A 2x2 matrix representing the single-qubit unitary operator $V$.\n",
    "- `alpha` (`float`): The prefactor $\\alpha$ of $U$ in the linear combination, as above.\n",
    "- `beta` (`float`): The prefactor $\\beta$ of $U$ in the linear combination, as above.\n",
    "\n",
    "### Output\n",
    "\n",
    "The output used to test your solution is a `float` corresponding to the probability of measuring $|0\\rangle$ on the main register. This is the first element of your output of `linear_combination`. We will extract this element for you in our testing functions!\n",
    "\n",
    "If your solution matches the correct one within the given tolerance specified in `check` (in this case it's an absolute tolerance of `0.001`), 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": "644ab697",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pennylane as qml\n",
    "import pennylane.numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1fc85e9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 2., -1.],\n",
       "        [ 1.,  2.]], requires_grad=True)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def W(alpha, beta):\n",
    "    \"\"\" This function returns the matrix W in terms of\n",
    "    the coefficients alpha and beta\n",
    "\n",
    "    Args:\n",
    "        - alpha (float): The prefactor alpha of U in the linear combination, as in the\n",
    "        challenge statement.\n",
    "        - beta (float): The prefactor beta of V in the linear combination, as in the\n",
    "        challenge statement.\n",
    "    Returns \n",
    "        -(numpy.ndarray): A 2x2 matrix representing the operator W,\n",
    "        as defined in the challenge statement\n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your code here #\n",
    "    \n",
    "    out = np.sqrt(\n",
    "        np.array([[alpha, beta], \n",
    "                  [beta, alpha]]) \n",
    "        / (alpha + beta)\n",
    "    )\n",
    "    out[0,1] = -out[0,1]\n",
    "    return out\n",
    "\n",
    "W(4, 1) * np.sqrt(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c858665a",
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device('default.qubit', wires = 2)\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def linear_combination(U, V,  alpha, beta):\n",
    "    \"\"\"This circuit implements the circuit that probabilistically calculates the linear combination \n",
    "    of the unitaries.\n",
    "\n",
    "    Args:\n",
    "        - U (list(list(float))): A 2x2 matrix representing the single-qubit unitary operator U.\n",
    "        - V (list(list(float))): A 2x2 matrix representing the single-qubit unitary operator U.\n",
    "        - alpha (float): The prefactor alpha of U in the linear combination, as above.\n",
    "        - beta (float): The prefactor beta of V in the linear combination, as above.\n",
    "\n",
    "    Returns:\n",
    "        -(numpy.tensor): Probabilities of measuring the computational\n",
    "        basis states on the auxiliary wire. \n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your code here #\n",
    "    \n",
    "    qml.QubitUnitary(W(alpha, beta), wires=0)\n",
    "    qml.ctrl(qml.QubitUnitary, control=0)(U, wires=1)\n",
    "    qml.PauliX(wires=0)\n",
    "    qml.ctrl(qml.QubitUnitary, control=0)(V, wires=1)\n",
    "    qml.PauliX(wires=0)\n",
    "    qml.QubitUnitary(W(alpha, beta).conj().transpose(), wires=0)\n",
    "    return qml.probs(wires=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c8a8b6c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# These functions are responsible for testing the solution.\n",
    "\n",
    "def run(test_case_input: str) -> str:\n",
    "    dev = qml.device('default.qubit', wires = 2)\n",
    "    ins = json.loads(test_case_input)\n",
    "    output = linear_combination(*ins)[0].numpy()\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(\n",
    "        solution_output, expected_output, rtol=1e-4\n",
    "    ), \"Your circuit doesn't look quite right \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "721d27d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = [['[[[ 0.70710678,  0.70710678], [ 0.70710678, -0.70710678]],[[1, 0], [0, -1]], 1, 3]', '0.8901650422902458']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "92ef83da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running test case 0 with input '[[[ 0.70710678,  0.70710678], [ 0.70710678, -0.70710678]],[[1, 0], [0, -1]], 1, 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
}