Pennylane I.01. All About Qubits.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "be948e8b-9284-428b-b4c2-48c7526be95e",
   "metadata": {},
   "source": [
    "# Pennylane: I. Introduction to Quantum Computing\n",
    "## I.1. All About Qubits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fe0a4670-a3d1-407e-b2db-76804e190d76",
   "metadata": {},
   "outputs": [],
   "source": [
    "# preparation\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8b5042e-088a-4cdf-a26a-dc44c586d3d5",
   "metadata": {},
   "source": [
    "### Codercise I.1.1 - Normalization of quantum states\n",
    "Given a quantum superposition $|\\psi\\rangle$ with unnormalized amplitudes, the aim is to produce a valid quantum state $|\\psi'\\rangle$.\n",
    "\n",
    "**Initial state**:  $|\\psi\\rangle=\\alpha|0\\rangle+\\beta|1\\rangle$ with $|\\alpha|^2+|\\beta|^2\\neq1$\n",
    "\n",
    "**Desired state**: $|\\psi'\\rangle=\\alpha'|0\\rangle+\\beta'|1\\rangle$ with $|\\alpha'|^2+|\\beta'|^2=1$\n",
    "\n",
    "**Solution**:\n",
    "- To get that, we must normalize the amplitudes with a constant $K$ such that $\\alpha'=\\alpha*K$ and $\\beta'=\\beta*K$. \n",
    "\n",
    "- While considering the potential value of $K$, we must note that the sum of squares of new amplitudes should be 1.\n",
    "\n",
    "- To set a relation between two amplitudes, $\\alpha$ and $\\beta$, the sum of squared-amplitudes is applied in normalization, i.e., $\\alpha^2 + \\beta^2$. \n",
    "\n",
    "- But we still need to square the new values afterwards, so we find its root: $\\sqrt{\\alpha^2 + \\beta^2}$.\n",
    "\n",
    "- Finally, we can divide the old amplitudes by that constant to get two new amplitudes, $\\alpha'$ and $\\beta'$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "347c0bad-a990-41c3-babb-dd7934553cd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here are the vector representations of |0> and |1>, for convenience\n",
    "ket_0 = np.array([1, 0])\n",
    "ket_1 = np.array([0, 1])\n",
    "\n",
    "\n",
    "def normalize_state(alpha, beta):\n",
    "    \"\"\"Compute a normalized quantum state given arbitrary amplitudes.\n",
    "\n",
    "    Args:\n",
    "        alpha (complex): The amplitude associated with the |0> state.\n",
    "        beta (complex): The amplitude associated with the |1> state.\n",
    "\n",
    "    Returns:\n",
    "        np.array[complex]: A vector (numpy array) with 2 elements that represents\n",
    "        a normalized quantum state.\n",
    "    \"\"\"\n",
    "\n",
    "    ##################\n",
    "    # YOUR CODE HERE #\n",
    "    ##################\n",
    "\n",
    "    # CREATE A VECTOR [a', b'] BASED ON alpha AND beta SUCH THAT |a'|^2 + |b'|^2 = 1.\n",
    "    k = 1 / (((abs(alpha)**2) + (abs(beta)**2))**0.5)\n",
    "    a_prime = alpha * k\n",
    "    b_prime = beta * k\n",
    "    normalized_vector = np.array([a_prime, b_prime])\n",
    "\n",
    "    # RETURN A VECTOR\n",
    "    return normalized_vector"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1626a1e7-99a2-4697-bf4d-8116e37f61d8",
   "metadata": {},
   "source": [
    "### Codercise I.1.2 - Inner product and orthonormal states\n",
    "Given two arbitary states, we need to find the inner product. If they are orthogonal, the inner product should be zero. \n",
    "\n",
    "The two states are orthonormal if they are orthogonal and normalized. Example $|0\\rangle$ and $|1\\rangle$.\n",
    "\n",
    "**Initial state**:  $|\\psi_0\\rangle$ and $|\\psi_1\\rangle$\n",
    "\n",
    "**Desired state**: $\\langle\\psi_0|\\psi_1\\rangle$\n",
    "\n",
    "**Solution**: Luckily, we have `vdot()` function from the numpy library. It takes two parameters and returns the dot product. The difference between `dot()` and `vdot()` is that the latter does not require us to manually compute the conjugate of the first state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7864295f-b459-4125-b06e-498b677a61c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<0|0> = 1\n",
      "<0|1> = 0\n",
      "<1|0> = 0\n",
      "<1|1> = 1\n"
     ]
    }
   ],
   "source": [
    "def inner_product(state_1, state_2):\n",
    "    \"\"\"Compute the inner product between two states.\n",
    "\n",
    "    Args:\n",
    "        state_1 (np.array[complex]): A normalized quantum state vector\n",
    "        state_2 (np.array[complex]): A second normalized quantum state vector\n",
    "\n",
    "    Returns:\n",
    "        complex: The value of the inner product <state_1 | state_2>.\n",
    "    \"\"\"\n",
    "\n",
    "    ##################\n",
    "    # YOUR CODE HERE #\n",
    "    ##################\n",
    "\n",
    "    # COMPUTE AND RETURN THE INNER PRODUCT\n",
    "\n",
    "    return np.vdot(state_1, state_2)\n",
    "\n",
    "\n",
    "# Test your results with this code\n",
    "ket_0 = np.array([1, 0])\n",
    "ket_1 = np.array([0, 1])\n",
    "\n",
    "print(f\"<0|0> = {inner_product(ket_0, ket_0)}\")\n",
    "print(f\"<0|1> = {inner_product(ket_0, ket_1)}\")\n",
    "print(f\"<1|0> = {inner_product(ket_1, ket_0)}\")\n",
    "print(f\"<1|1> = {inner_product(ket_1, ket_1)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8b2631d-1b56-4e79-8ecb-8ff8e98685f3",
   "metadata": {},
   "source": [
    "### Codercise I.1.3 - Sampling measurement outcomes\n",
    "Given a quantum state vector, we need to simulate the outcomes for N times.\n",
    "\n",
    "**Initial state**:  $|\\psi\\rangle=\\alpha|0\\rangle+\\beta|1\\rangle$\n",
    "\n",
    "**Desired state**: Outcomes of executions\n",
    "\n",
    "**Solution**:\n",
    "- Squaring the amplitudes give us respective probabilities. Example- $P(0)$ and $P(1)$.\n",
    "- These probabilities must persist in any outcome with an arbitary number of executions.\n",
    "- We can use `np.random.choice()` with three parameters for\n",
    "  1. Possible choices a collapsed quantum state can be in\n",
    "  2. Number of executions\n",
    "  3. Probabilities for each choice above\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b27cd54c-7df6-4f78-be5b-e5980486bc2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def measure_state(state, num_meas):\n",
    "    \"\"\"Simulate a quantum measurement process.\n",
    "\n",
    "    Args:\n",
    "        state (np.array[complex]): A normalized qubit state vector.\n",
    "        num_meas (int): The number of measurements to take\n",
    "\n",
    "    Returns:\n",
    "        np.array[int]: A set of num_meas samples, 0 or 1, chosen according to the probability\n",
    "        distribution defined by the input state.\n",
    "    \"\"\"\n",
    "\n",
    "    ##################\n",
    "    # YOUR CODE HERE #\n",
    "    ##################\n",
    "\n",
    "    # COMPUTE THE MEASUREMENT OUTCOME PROBABILITIES\n",
    "\n",
    "    # get probabilities\n",
    "    P = abs(state)**2\n",
    "    \n",
    "    # get valid quantum states\n",
    "    choices = np.arange(len(state))\n",
    "\n",
    "    # get outcome\n",
    "    outcomes_list = np.random.choice(choices, size=num_meas, p=P)\n",
    "    \n",
    "    # RETURN A LIST OF SAMPLE MEASUREMENT OUTCOMES\n",
    "\n",
    "    return outcomes_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86e5b689-fc65-4405-a41e-52e30d825c81",
   "metadata": {},
   "source": [
    "### Codercise I.1.4 - Applying a quantum operation\n",
    "To preserve normalization, quantum operations are represented as **unitary** matrices. A matrix is unitary if $UU'=I$ where $U'$ is a complex conjugate transpose of $U$.\n",
    "Performing a unitary operation on a quantum state gives us a new quantum state.\n",
    "$$|\\psi'\\rangle=U|\\psi\\rangle$$\n",
    "**Initial state**:  $|\\psi\\rangle=\\alpha|0\\rangle+\\beta|1\\rangle$\n",
    "\n",
    "**Desired state**: $U|\\psi\\rangle$\n",
    "\n",
    "**Solution**:\n",
    "- First, we calculate the qubit state after applying $U$.\n",
    "- This can be done with `np.matmul()` function which takes two matrices and multiply them.\n",
    "- Although it is not necessary, we may compute probabilities to verify whether the state is valid (normalized)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f72b9a4c-91fe-4cd4-83e5-0915d8583751",
   "metadata": {},
   "outputs": [],
   "source": [
    "U = np.array([[1, 1], [1, -1]]) / np.sqrt(2)\n",
    "\n",
    "\n",
    "def apply_u(state):\n",
    "    \"\"\"Apply a quantum operation.\n",
    "\n",
    "    Args:\n",
    "        state (np.array[complex]): A normalized quantum state vector.\n",
    "\n",
    "    Returns:\n",
    "        np.array[complex]: The output state after applying U.\n",
    "    \"\"\"\n",
    "\n",
    "    ##################\n",
    "    # YOUR CODE HERE #\n",
    "    ##################\n",
    "\n",
    "    # APPLY U TO THE INPUT STATE AND RETURN THE NEW STATE\n",
    "    new_state = np.matmul(s,U)    \n",
    "    return new_state"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "314ae9f4-1bf9-4177-ae37-6b9d42efab57",
   "metadata": {},
   "source": [
    "### Codercise I.1.5 - A simple quantum algorithm\n",
    "Putting everything together can give us a simple quantum algorithm that can simulate the outcome of running algorithms on a single qubit.\n",
    "\n",
    "1. Initialize a qubit in state $|0\\rangle$\n",
    "2. Apply the provided operation $U$\n",
    "3. Simulate measuring the output state 100 times\n",
    "\n",
    "**Solution**:\n",
    "We can simply reuse solutions from above exercises."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "03b1b8e4-7361-4448-972b-d659f754deaf",
   "metadata": {},
   "outputs": [],
   "source": [
    "U = np.array([[1, 1], [1, -1]]) / np.sqrt(2)\n",
    "\n",
    "\n",
    "def initialize_state():\n",
    "    \"\"\"Prepare a qubit in state |0>.\n",
    "\n",
    "    Returns:\n",
    "        np.array[float]: the vector representation of state |0>.\n",
    "    \"\"\"\n",
    "\n",
    "    ##################\n",
    "    # YOUR CODE HERE #\n",
    "    ##################\n",
    "\n",
    "    # PREPARE THE STATE |0>\n",
    "    return np.array([1, 0])\n",
    "\n",
    "\n",
    "def apply_u(state):\n",
    "    \"\"\"Apply a quantum operation.\"\"\"\n",
    "    return np.dot(U, state)\n",
    "\n",
    "\n",
    "def measure_state(state, num_meas):\n",
    "    \"\"\"Measure a quantum state num_meas times.\"\"\"\n",
    "    p_alpha = np.abs(state[0]) ** 2\n",
    "    p_beta = np.abs(state[1]) ** 2\n",
    "    meas_outcome = np.random.choice([0, 1], p=[p_alpha, p_beta], size=num_meas)\n",
    "    return meas_outcome\n",
    "\n",
    "\n",
    "def quantum_algorithm():\n",
    "    \"\"\"Use the functions above to implement the quantum algorithm described above.\n",
    "\n",
    "    Try and do so using three lines of code or less!\n",
    "\n",
    "    Returns:\n",
    "        np.array[int]: the measurement results after running the algorithm 100 times\n",
    "    \"\"\"\n",
    "\n",
    "    ##################\n",
    "    # YOUR CODE HERE #\n",
    "    ##################\n",
    "\n",
    "    # PREPARE THE STATE, APPLY U, THEN TAKE 100 MEASUREMENT SAMPLES\n",
    "    q_state = initialize_state()\n",
    "    new_q_state = apply_u(q_state)\n",
    "    result = measure_state(new_q_state, 100)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fb1aa887-665f-440e-b067-a84cf0973119",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 1 1 1 1 1 1 1 0 1 1 1 0 0 1 1 1 0 0 0 1 1 0 0 1 0 0 0 1 1 1 1 0 0 1 1\n",
      " 0 0 1 1 0 0 1 1 0 0 1 0 1 1 1 1 1 0 0 0 1 1 0 1 1 0 0 1 1 0 0 0 0 1 1 1 0\n",
      " 0 0 1 0 0 1 1 0 1 1 0 0 0 1 1 1 1 1 1 1 1 1 0 1 0 0]\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "print(quantum_algorithm())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa0c59fb-9aa7-431f-9bcf-1d5f7cea093b",
   "metadata": {},
   "source": [
    "This notebook is done by `Myanmar Youths` for `Womanium Quantum + AI 2024` program.\n",
    "- <a href=\"https://www.linkedin.com/in/la-wun-nannda-b047681b5/\"><u>La Wun Nannda</u></a>\n",
    "- <a href=\"https://www.linkedin.com/in/chit-zin-win-46a2a3263/\"><u>Chit Zin Win</u></a>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}