problem-5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "27716ce5",
   "metadata": {},
   "source": [
    "# Problem 5 - QRAM \n",
    "\n",
    "Almost all of us have heard about Random Access Memory (RAM). It is one of the most important components of a computer system which allows *stored information processing*. A computer's CPU directly interacts with RAM to access and process information. \n",
    "\n",
    "A property for data which is present in RAM is that it will have an **address** and a **value**. These properties are essential for the common operations which are required for data storage and processing.\n",
    "\n",
    "<img src = 'resources/problem-5/ram-vector.jpg' width = 50%>\n",
    "\n",
    "That's all fine but how do we define the concept of **memory** in quantum computing? How do you represent data in quantum bits? Let's constrain ourselves to the simple concept of arrays and see how we may store an array into qubits.\n",
    "\n",
    "#### Example \n",
    "\n",
    "```python\n",
    "arr = [3, 4, 5, 6]\n",
    "``` \n",
    "\n",
    "Each element **value** needs to be encoded into some qubits and there needs to be some notion of **indexing** present with our encoding. \n",
    "\n",
    "While a classical RAM would encode the data into bits, a **qRAM** would encode the data into a quantum state like the following - \n",
    "\n",
    "$$ |\\Psi \\rangle = \\frac{|0\\rangle V_0|0\\rangle^{\\otimes n} + |1\\rangle V_1|0\\rangle^{\\otimes n} + |2\\rangle V_2|0\\rangle^{\\otimes n} + |3\\rangle V_3|0\\rangle^{\\otimes n}}{\\sqrt{4}}$$\n",
    "\n",
    "Here we can have two registers - one for the **indexing** and one for the **storage**. \n",
    "\n",
    "The first *ket* represents the **index qubits**. The numbers $0,1,2,3$ are indices and written in shorthand decimal format. Actually, the quantum state in the binary format they would be something like - \n",
    "    $$ |2\\rangle \\equiv |10\\rangle $$\n",
    "    \n",
    "The operator $V_i$ represents the operator which would encode the $i^{th}$ value of the array into the **value qubits**\n",
    "\n",
    "The second *ket* represents the **value qubits**. These qubits would store the values of the array elements. Note that the number of qubits, $n$ would be - \n",
    "    $$ n = \\lfloor log_2(m) \\rfloor + 1$$\n",
    "    \n",
    "where $\\lfloor x \\rfloor$ represents the [floor function](https://en.wikipedia.org/wiki/Floor_and_ceiling_functions) and $m$ is the maximum value available in the array. In the above example, $m$ would be just $6$ and we could use $3$ qubits for the value qubits. Note that value qubits are also encoded in the *binary* format.\n",
    "\n",
    "Finally, the complete **qRAM** state for the array `[3, 4, 5, 6]` would be - \n",
    "\n",
    "$$ |\\Psi \\rangle = \\frac{|00\\rangle |011\\rangle + |01\\rangle |100\\rangle + |10\\rangle |101\\rangle + |11\\rangle |110\\rangle}{\\sqrt{4}}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41019e91",
   "metadata": {},
   "source": [
    "## Task\n",
    "- Given different types of arrays and even quantum states, implement a **qRAM** which encodes the data into qubits\n",
    "- Each level of this problem contains a different version of this task, with varying difficulty levels"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1315c5a",
   "metadata": {},
   "source": [
    "### Level 1 - 75 points \n",
    "- You are given a $4$ element array with `1<=array[i]<m`\n",
    "- `m` ranges from $[1,16]$\n",
    "- You need to create a `QuantumCircuit` which encodes this array into qubits\n",
    "\n",
    "#### Constraints\n",
    "- The `QuantumCircuit` size should be equal to $\\lfloor log_2(m)\\rfloor + 3$ qubits \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14fe62a9",
   "metadata": {},
   "source": [
    "#### To submit \n",
    "- Create a function which would accept parameters `m` and `array`\n",
    "\n",
    "- `array` will contain only $4$ elements where each element `1<=arr[i]<m` \n",
    "\n",
    "- You need to return a `QuantumCircuit` object which would contain the encoded array as a *quantum state*\n",
    "\n",
    "\n",
    "**NOTE** \n",
    "1. Please refrain from adding any kinds of statements other than comments in the designated code block, this may result in wrong output \n",
    "2. You can assume that the input params m and the array consist only of positive integers \n",
    "3. Note that the circuit **should not contain any measurement operations** as the full statevector of your quantum state would be compared "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2eafa45f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-10-12T15:36:30.945856Z",
     "start_time": "2022-10-12T15:36:30.779259Z"
    }
   },
   "outputs": [],
   "source": [
    "def qram_4q(m, array):\n",
    "    \n",
    "    ### your code here\n",
    "    \n",
    "    ### your code here \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96714843",
   "metadata": {},
   "source": [
    "### Testing\n",
    "- Test your function before submitting to the grader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f192ed8e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-10-12T15:36:33.204406Z",
     "start_time": "2022-10-12T15:36:30.949151Z"
    }
   },
   "outputs": [],
   "source": [
    "def test_function_1():\n",
    "    m = 2\n",
    "    array = [1, 2, 1, 1]\n",
    "    qram = qram_4q(m, array)\n",
    "    return qram \n",
    "\n",
    "test_function_1().draw('mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d831af03",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-10-12T15:36:38.104233Z",
     "start_time": "2022-10-12T15:36:34.834488Z"
    }
   },
   "outputs": [],
   "source": [
    "from src.grader.graders.problem_5.grader import grader1 \n",
    "grader1.evaluate(qram_4q)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18f53617",
   "metadata": {},
   "source": [
    "### Level 2 - 125 points \n",
    "- You are given an `n` element array with `1<=array[i]<m`\n",
    "- `n` is selected from one of ${2, 4, 8, 16}$\n",
    "- `m` is an integer ranging from $[1,128]$\n",
    "- You need to create a `QuantumCircuit` which encodes this array into qubits\n",
    "\n",
    "#### Constraints\n",
    "- The `QuantumCircuit` size should be equal to  ($\\lceil log_2(n)\\rceil + \\lfloor log_2(m)\\rfloor + 1$) qubits \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a45e1fa",
   "metadata": {},
   "source": [
    "#### To submit \n",
    "- Create a function which would accept parameters `n`, `m` and `array`\n",
    "\n",
    "- Array will contain `n` elements where each element `1<=arr[i]<m` \n",
    "\n",
    "\n",
    "- You need to return a `QuantumCircuit` object which would contain the encoded array as a *quantum state*\n",
    "\n",
    "\n",
    "**NOTE** \n",
    "1. Please refrain from adding any kinds of statements other than comments in the designated code block, this may result in wrong output \n",
    "2. You can assume that the input params m and array consist only of positive integers \n",
    "3. Note that the circuit should not contain any measurement operations as the full statevector of your quantum state would be compared "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "185f10f6",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-10-12T15:36:51.115648Z",
     "start_time": "2022-10-12T15:36:51.110780Z"
    }
   },
   "outputs": [],
   "source": [
    "def qram_general(n, m, array):\n",
    "    \n",
    "    ### your code here \n",
    "    ### your code here \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad3ef10e",
   "metadata": {},
   "source": [
    "### Testing\n",
    "- Test your function before submitting to the grader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebe219c5",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-10-12T15:36:51.954239Z",
     "start_time": "2022-10-12T15:36:51.694421Z"
    }
   },
   "outputs": [],
   "source": [
    "def test_function_2():\n",
    "    n = 2\n",
    "    m = 2\n",
    "    array = [1, 2]\n",
    "    qram = qram_general(n, m, array)\n",
    "    return qram \n",
    "\n",
    "\n",
    "test_function_2().draw('mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f3439ce",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-10-12T15:37:01.142609Z",
     "start_time": "2022-10-12T15:36:56.259615Z"
    }
   },
   "outputs": [],
   "source": [
    "from src.grader.graders.problem_5.grader import grader2 \n",
    "grader2.evaluate(qram_general)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbf6852c",
   "metadata": {},
   "source": [
    "### Level 3 - 200 points\n",
    "- Here we transform the problem a little!\n",
    "- You are again given an array with sizes from one of $\\{2, 4, 8, 16, 32\\}$\n",
    "- But now, you need to encode **quantum states** instead of integer values \n",
    "- Each of the given array element would be something like the following - \n",
    "```python \n",
    "array = [('x', 0.123), ('x', 0.912), ('z', -0.12), ('y', -0.36)]\n",
    "```\n",
    "- **Explanation** \n",
    "    - `('x', num_1)` means : \n",
    "        - State : $R_x(\\theta_1)|0\\rangle$ and $\\theta_1 = 2\\pi*num\\_1$\n",
    "    - `('y', num_2)` means : \n",
    "        - State : $R_y(\\theta_2)|0\\rangle$ and $\\theta_2 = 2\\pi*num\\_2$\n",
    "    - `('z', num_3)` means :\n",
    "        - State : $R_z(\\theta_3)|0\\rangle$ and $\\theta_3 = 2\\pi*num\\_3$\n",
    "    \n",
    "    \n",
    "- The final qubits' state for the above example would be something like - \n",
    "\n",
    "$$ |qRAM\\rangle = \\frac{|0\\rangle R_x(0.123*2\\pi)|0\\rangle + |1\\rangle R_x(0.912*2\\pi)|0\\rangle + |2\\rangle R_z(-0.12*2\\pi)|0\\rangle + |3\\rangle R_y(-0.36*2\\pi)|0\\rangle}{\\sqrt{4}}$$\n",
    "\n",
    "#### Constraints \n",
    "- The size of the `QuantumCircuit` should be equal to $\\lceil log_2(n) \\rceil + 1$ qubits"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d92386b4",
   "metadata": {},
   "source": [
    "#### To submit \n",
    "- Create a function which should accept the parameters `n` and `rotations`\n",
    "- `n` would represent the number of elements present in the array \n",
    "- `rotations` array would be a list of 2-tuples as explained in the above cell\n",
    "- Your function should return a `QuantumCircuit` which will encode the given `rotations` array into a quantum state\n",
    "\n",
    "\n",
    "\n",
    "**NOTE** \n",
    "1. Please refrain from adding any kinds of statements other than comments in the designated code block, this may result in wrong output \n",
    "2. You can assume that the input params m and array consist only of positive integers \n",
    "3. Note that the circuit should not contain any measurement operations as the full statevector of your quantum state would be compared "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f622f124",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-10-12T15:37:14.617017Z",
     "start_time": "2022-10-12T15:37:14.612801Z"
    }
   },
   "outputs": [],
   "source": [
    "def qram_rotations(n, rotations):\n",
    "    \n",
    "    ### your code here \n",
    "    \n",
    "    ### your code here "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a50b3e83",
   "metadata": {},
   "source": [
    "### Testing\n",
    "- Test your function before submitting to the grader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91355421",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-10-12T15:37:15.748824Z",
     "start_time": "2022-10-12T15:37:15.533440Z"
    }
   },
   "outputs": [],
   "source": [
    "def test_function_3():\n",
    "    n = 2\n",
    "    rotations = [('x', 0.122334), ('y', -0.342)]\n",
    "    \n",
    "    qram = qram_rotations(n, rotations)\n",
    "    return qram \n",
    "\n",
    "\n",
    "test_function_3().draw('mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "265732f1",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-10-12T15:37:37.194047Z",
     "start_time": "2022-10-12T15:37:18.756343Z"
    }
   },
   "outputs": [],
   "source": [
    "from src.grader.graders.problem_5.grader import grader3 \n",
    "grader3.evaluate(qram_rotations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e3e9c7c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}