ipynb/1.1-Tick-Tock_Bloch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3483e1eb",
   "metadata": {},
   "source": [
    "##### Office Hijinks\n",
    "\n",
    "# Tick-Tock Bloch (100 points)\n",
    "\n",
    "### Backstory\n",
    "\n",
    "Zenda and Reece work at a firm, Trine's Designs, that uses quantum devices for very silly things. Their job as physicists is fun, since they get to program and fix quantum devices of all sorts, such as clocks, coffee machines, and lazy-worker detectors. The office has purchased a new quantum clock. To tell time, one has to read quantum states. They'd better get used to it, or they'll be late for their meetings!\n",
    "\n",
    "### The clock and the Bloch circumference\n",
    "\n",
    "The Bloch sphere is the most widespread representation of a qubit. However, if we only consider states whose amplitudes are real, you could represent what we will call the *Bloch circumference*.\n",
    "\n",
    "![Bloch Circle](../img/clock1.jpeg)\n",
    "\n",
    "In the figure above, we are representing the state $|+\\rangle$ on our circle, since the arrow points in this direction. This circumference is completely equivalent to the blue one, shown below inside the Bloch sphere.\n",
    "\n",
    "![Bloch Sphere](../img/clock2.jpeg)\n",
    "\n",
    "In Zenda and Reece's office, the new way to tell the time is to read two states in Bloch's circumference. The state $|0\\rangle$ corresponds to 12h on a clock, $|1\\rangle$ would be equivalent to 6h, $|+\\rangle$would be 9h, and so on. In this challenge we are going to work with 2 qubits. The first one corresponds to the hour hand and the second one to the minutes. You will be given the time of the day as the input and you will have to generate the quantum states equivalent to such time.\n",
    "\n",
    "![Bloch Clock](../img/clock3.jpeg)\n",
    "\n",
    "Here's an example of a clock striking 1:30. The qubit on the first wire of your circuit will be the small hand, and the qubit on the second wire, the big hand.\n",
    "\n",
    "## Challenge code\n",
    "\n",
    "You must complete the `time` function that will take the hour and minutes as an argument and generate the two-qubit state associated to the indicated time.\n",
    "\n",
    "### Input\n",
    "\n",
    "The input will be two integers. The one corresponding to the hours will take values from 1 to 12 and the one corresponding to the minutes will range from 0 to 59.\n",
    "\n",
    "### Output\n",
    "\n",
    "The output will be the vector of probabilities of the two-qubit state, measured in the computational basis. You are only asked to complete the gates, we'll handle the rest. Good luck!\n",
    "\n",
    "### Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b8892d6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pennylane as qml\n",
    "import pennylane.numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8c3322f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device(\"default.qubit\", wires=[\"hour\", \"minute\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6109a7e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0., 0., 0., 1.], requires_grad=True)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@qml.qnode(dev)\n",
    "def time(hour, minute):\n",
    "    \"\"\"Generates the quantum state associated with the time passed as argument.\n",
    "\n",
    "    Args:\n",
    "        hour (int): Hour associated with the requested time\n",
    "        minute (int): Minutes associated with the requested time\n",
    "\n",
    "    Returns:\n",
    "        (numpy.tensor): Probabilities associated with the state created.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your code here #\n",
    "    \n",
    "    qml.RX(hour / 12 * 2 * np.pi, wires=\"hour\")\n",
    "    qml.RX(minute / 60 * 2 * np.pi, wires=\"minute\")\n",
    "    \n",
    "    return qml.probs(wires=[\"hour\", \"minute\"])\n",
    "\n",
    "np.round(time(6, 30), 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a98011a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# These functions are responsible for testing the solution.\n",
    "def run(test_case_input: str) -> str:\n",
    "    hour, minute = json.loads(test_case_input)\n",
    "    state = [float(x) for x in time(hour, minute)]\n",
    "    return str(state)\n",
    "\n",
    "def check(solution_output, expected_output: str) -> None:\n",
    "\n",
    "    solution_output = json.loads(solution_output)\n",
    "    expected_output = json.loads(expected_output)\n",
    "\n",
    "    assert np.allclose(\n",
    "        solution_output, expected_output, atol=0.1\n",
    "    ), \"The solution does not seem to be correct.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "76e6076d",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = [['[12, 0]', '[1.0, 0.0, 0.0, 0.0]'], ['[1, 30]', '[0.0, 0.85355339, 0.0, 1.46446609e-01]']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "464971c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running test case 0 with input '[12, 0]'...\n",
      "Correct!\n",
      "Running test case 1 with input '[1, 30]'...\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
}