Project_Swapping_Quantum_States-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://qworld.net\" target=\"_blank\" align=\"left\"><img src=\"../qworld/images/header.jpg\"  align=\"left\"></a>\n",
    "$ \\newcommand{\\bra}[1]{\\langle #1|} $\n",
    "$ \\newcommand{\\ket}[1]{|#1\\rangle} $\n",
    "$ \\newcommand{\\braket}[2]{\\langle #1|#2\\rangle} $\n",
    "$ \\newcommand{\\dot}[2]{ #1 \\cdot #2} $\n",
    "$ \\newcommand{\\biginner}[2]{\\left\\langle #1,#2\\right\\rangle} $\n",
    "$ \\newcommand{\\mymatrix}[2]{\\left( \\begin{array}{#1} #2\\end{array} \\right)} $\n",
    "$ \\newcommand{\\myvector}[1]{\\mymatrix{c}{#1}} $\n",
    "$ \\newcommand{\\myrvector}[1]{\\mymatrix{r}{#1}} $\n",
    "$ \\newcommand{\\mypar}[1]{\\left( #1 \\right)} $\n",
    "$ \\newcommand{\\mybigpar}[1]{ \\Big( #1 \\Big)} $\n",
    "$ \\newcommand{\\sqrttwo}{\\frac{1}{\\sqrt{2}}} $\n",
    "$ \\newcommand{\\dsqrttwo}{\\dfrac{1}{\\sqrt{2}}} $\n",
    "$ \\newcommand{\\onehalf}{\\frac{1}{2}} $\n",
    "$ \\newcommand{\\donehalf}{\\dfrac{1}{2}} $\n",
    "$ \\newcommand{\\hadamard}{ \\mymatrix{rr}{ \\sqrttwo & \\sqrttwo \\\\ \\sqrttwo & -\\sqrttwo }} $\n",
    "$ \\newcommand{\\vzero}{\\myvector{1\\\\0}} $\n",
    "$ \\newcommand{\\vone}{\\myvector{0\\\\1}} $\n",
    "$ \\newcommand{\\stateplus}{\\myvector{ \\sqrttwo \\\\  \\sqrttwo } } $\n",
    "$ \\newcommand{\\stateminus}{ \\myrvector{ \\sqrttwo \\\\ -\\sqrttwo } } $\n",
    "$ \\newcommand{\\myarray}[2]{ \\begin{array}{#1}#2\\end{array}} $\n",
    "$ \\newcommand{\\X}{ \\mymatrix{cc}{0 & 1 \\\\ 1 & 0}  } $\n",
    "$ \\newcommand{\\I}{ \\mymatrix{rr}{1 & 0 \\\\ 0 & 1}  } $\n",
    "$ \\newcommand{\\Z}{ \\mymatrix{rr}{1 & 0 \\\\ 0 & -1}  } $\n",
    "$ \\newcommand{\\Htwo}{ \\mymatrix{rrrr}{ \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} } } $\n",
    "$ \\newcommand{\\CNOT}{ \\mymatrix{cccc}{1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0} } $\n",
    "$ \\newcommand{\\norm}[1]{ \\left\\lVert #1 \\right\\rVert } $\n",
    "$ \\newcommand{\\pstate}[1]{ \\lceil \\mspace{-1mu} #1 \\mspace{-1.5mu} \\rfloor } $\n",
    "$ \\newcommand{\\greenbit}[1] {\\mathbf{{\\color{green}#1}}} $\n",
    "$ \\newcommand{\\bluebit}[1] {\\mathbf{{\\color{blue}#1}}} $\n",
    "$ \\newcommand{\\redbit}[1] {\\mathbf{{\\color{red}#1}}} $\n",
    "$ \\newcommand{\\brownbit}[1] {\\mathbf{{\\color{brown}#1}}} $\n",
    "$ \\newcommand{\\blackbit}[1] {\\mathbf{{\\color{black}#1}}} $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font style=\"font-size:28px;\" align=\"left\"><b> Project | Swapping Quantum States</b></font>\n",
    "<br>\n",
    "_prepared by Abuzer Yakaryilmaz_\n",
    "\n",
    "_solution by Ege Erdem_\n",
    "<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We swap the states of the qubits placed on a two dimensinal graph.\n",
    "\n",
    "We use a single quantum operator: Controlled-NOT ($CNOT$).\n",
    "\n",
    "- _Please do not use any quantum programming library or any scientific python library such as `NumPy`._\n",
    "- _Please write your own codes for matrix-vector multiplication._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a python class called `SwappingGame()`\n",
    "\n",
    "<img src=\"images/seven_qubits.png\" width=\"200px\" align=\"right\" style=\"margin:20px;\">\n",
    "\n",
    "We have 7 qubits placed on a graph as shown on the right: $ q_{-3} $, $q_{-2}$, $q_{-1}$, $q_{0}$, $q_{+1}$, $q_{+2}$, and $q_{+3} $.\n",
    "\n",
    "We are allowed to implement only $ CNOT $ operators, and a $ CNOT $ operator is directly applicable to the neighbor qubits, i.e., two qubits are neighbors if  there is an edge (line) between them. For example a $ CNOT $ operator can be applied to the qubits $q_{-3}$ and $ q_{-1} $ or $q_0$ and $q_{+1}$ or $q_{+1}$ and $q_{+2}$, but a $ CNOT $ operator cannot be directly applied to the qubits $q_{-1}$ and $q_{+1}$. \n",
    "\n",
    "#### The quantum system\n",
    "\n",
    "These 7 qubits form a single quantum system. Then, the quantum state of the system is represented by a $2^7$-dimensional vector (list) and so each quantum operator is represented by a ($2^7 \\times 2^7$)-dimensional matrix (double dimensinal list).\n",
    "\n",
    "The system should be simulated as a whole:\n",
    "- The simulation of the whole system should not be done by separately simulating each qubit or pairs of qubits and then combine them.\n",
    "- The aim here is to experience the simultion of generic quantum systems.\n",
    "    \n",
    "There are 6 pairs of the neighbor qubits, and so 12 different $ CNOT $ operators should be applied to this system:\n",
    "- $ CNOT(i,j) $ is the $ CNOT $ operator applied to the control qubit $ q_i $ and the target qubit $q_j $.\n",
    "\n",
    "#### Initialization\n",
    "\n",
    "When an instance of the class is created, an angle, say $\\theta$, is randomly picked in the interval $(0,\\pi/6)$. \n",
    "\n",
    "The quantum state of the qubit $ q_i $, say $\\ket{v_i}$, is set to the state $ \\myvector{\\cos \\theta \\\\ \\sin \\theta} $."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The main method `swap(*,*)`\n",
    "\n",
    "This class has one main method called `swap(i,j)` for $i,j \\in \\{-3,\\ldots,3\\} $, which swaps the states of the qubits $ q_i $ and $ q_j $."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The auxiliary method `swap_neighbors(*,*)`\n",
    "\n",
    "An auxiliary method called `swap_neighbors(i,j)` is defined to swap the states of the neighbor qubits $ q_i $ and $ q_j $. This method gives a warning message whenever the qubits $ q_i $ and $ q_j $ are not neighbors.\n",
    "\n",
    "Whenever two qubits are not neighbor, we will use a series of `swap_neighbors(*,*)` to the qubits on a path connecting them. For example, the states of the qubits $ q_{+2} $ and $ q_{-3} $ can be swaped as described below. Assume that the state of $ q_{i} $ is $ \\ket{v_i} $ before starting.\n",
    "-  After `swap_neighbors(2,1)`, the states of $ q_{+2} $ and $ q_{+1} $ are $ \\ket{v_1} $ and $ \\ket{v_2} $, respectively.\n",
    "-  After `swap_neighbors(1,0)`, the states of $ q_{+1} $ and $ q_{0} $ are $ \\ket{v_0} $ and $ \\ket{v_2} $, respectively.\n",
    "-  After `swap_neighbors(0,-1)`, the states of $ q_{0} $ and $ q_{-1} $ are $ \\ket{v_{-1}} $ and $ \\ket{v_2} $, respectively.\n",
    "-  After `swap_neighbors(-1,-3)`, the states of $ q_{-1} $ and $ q_{-3} $ are $ \\ket{v_{-3}} $ and $ \\ket{v_2} $, respectively.\n",
    "\\\n",
    "Now, the current state of qubit $q_{-3}$ is $ \\ket{v_{2}} $ as desired. \n",
    "-  After `swap_neighbors(-1,0)`, the states of $ q_{-1} $ and $ q_{0} $ are $ \\ket{v_{-1}} $ and $ \\ket{v_{-3}} $, respectively.\n",
    "-  After `swap_neighbors(0,1)`, the states of $ q_{0} $ and $ q_{1} $ are $ \\ket{v_{0}} $ and $ \\ket{v_{-3}} $, respectively.\n",
    "-  After `swap_neighbors(1,2)`, the states of $ q_{1} $ and $ q_{2} $ are $ \\ket{v_{1}} $ and $ \\ket{v_{-3}} $, respectively.\n",
    "\\\n",
    "And now, the current state of qubit $ q_2 $ is $ \\ket{v_{-3}} $.\n",
    "\\\n",
    "Besides, the state of each other qubit is the same as in the beginning.\n",
    "\n",
    "\n",
    "#### Implementing `swap_neighbors(*,*)`\n",
    "\n",
    "The swap operator between two neighbor qubits, say $q_i$ and $q_j$ is implemented by three $ CNOT $ operators:\n",
    "\n",
    "    CNOT(i,j)\n",
    "    CNOT(j,i)\n",
    "    CNOT(i,j)\n",
    "\n",
    "*You may verify the correctness of this method by using the basis states $ \\ket{00} $, $ \\ket{01} $, $ \\ket{10} $, and $ \\ket{11} $.*\n",
    "\n",
    "This method multiplies the current quantum state with the three matrices representing these $ CNOT $ operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"1-Linear algebra functions\"\n",
    "\n",
    "# Tensor multiplication of vector a with vector b\n",
    "def tensor_mul_vec(a, b):\n",
    "    ab = []\n",
    "    for ai in a:\n",
    "        for bi in b:\n",
    "            ab.append(ai*bi)\n",
    "    return ab\n",
    "\n",
    "\n",
    "\"2-Helper functions for creating states\"\n",
    "\n",
    "# Expands the current basis by 1 bit (e.g. [0 1] --> [00 01 10 11])\n",
    "def create_basis(curr_basis):\n",
    "    bits = [\"0\", \"1\"]\n",
    "    basis_states = []\n",
    "    for basis in curr_basis:\n",
    "        for i in range(2):\n",
    "            basis_states.append(basis+bits[i])\n",
    "    return basis_states\n",
    "\n",
    "# Expands & reorders the state vector itself to represent all basis (to show 0 valued states and print in correct order)\n",
    "def organize_state(n, current_state):\n",
    "    basis_states = [\"\"]\n",
    "    for bit in range(n): # Create a basis state with n bits\n",
    "        basis_states = create_basis(basis_states)\n",
    "    \n",
    "    state = {}\n",
    "    for basis in basis_states:\n",
    "        if basis in current_state.keys():\n",
    "            state[basis] = current_state[basis]\n",
    "        else:\n",
    "            state[basis] = 0\n",
    "    \n",
    "    return state\n",
    "\n",
    "# Deletes states with 0 probability\n",
    "def get_nonzero_states(state):\n",
    "    nonzero_state = {}\n",
    "    for key in state.keys():\n",
    "        if state[key] != 0:\n",
    "            nonzero_state[key] = state[key]\n",
    "    return nonzero_state\n",
    "\n",
    "# Creates the state vector by applying tensor multiplication to the qubits\n",
    "def get_state_vector(qubits):\n",
    "    n = len(qubits)\n",
    "    state_vector = qubits[0]\n",
    "    for i in range(n-1):\n",
    "        state_vector = tensor_mul_vec(state_vector, qubits[i+1])\n",
    "        \n",
    "    return state_vector\n",
    "\n",
    "# Creates the state using the state vector\n",
    "def get_state_from_statevec(state_vector, n=7):\n",
    "    basis_states = [\"\"]\n",
    "    for bit in range(n): # Create a basis state with n bits\n",
    "        basis_states = create_basis(basis_states)\n",
    "    \n",
    "    state = {}\n",
    "    for i, basis in enumerate(basis_states):\n",
    "        state[basis] = state_vector[i]\n",
    "        \n",
    "    return state\n",
    "\n",
    "\n",
    "\"3-Path related function\"\n",
    "\n",
    "# Finds the path of neighboring nodes between node i and j\n",
    "def find_path(i, j): # i!=j\n",
    "    if i>j:\n",
    "        increasing = False\n",
    "    elif i<j:\n",
    "        increasing = True\n",
    "\n",
    "    diagram = [[2], [2], [0,1,3], [2,4], [3,5,6], [4], [4]] # The map of the diagram showing connections\n",
    "    path = [i]\n",
    "    pos = i\n",
    "    choices = diagram[pos]\n",
    "    while pos != j:\n",
    "        if len(choices) == 1:\n",
    "            pos = choices[0]\n",
    "            choices = diagram[pos]\n",
    "            path.append(pos)\n",
    "        elif j in choices:\n",
    "            pos = j\n",
    "            choices = diagram[pos]\n",
    "            path.append(pos)\n",
    "        else:\n",
    "            if increasing:\n",
    "                choices = [e for e in choices if e>pos]\n",
    "            else:\n",
    "                choices = [e for e in choices if e<pos]\n",
    "    \n",
    "    path_go = path\n",
    "    path_back = list(reversed(path[:-1]))\n",
    "    return path_go, path_back"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randrange\n",
    "from math import pi, cos, sin\n",
    "\n",
    "class SwappingGame():\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.n = 7\n",
    "        self.qubits = []\n",
    "        for i in range(self.n):\n",
    "            theta = (randrange(3000)/3000)*pi/6\n",
    "            q = [cos(theta), sin(theta)]\n",
    "            self.qubits.append(q)\n",
    "        \n",
    "        self.state_vector = get_state_vector(self.qubits)\n",
    "        self.state = get_state_from_statevec(self.state_vector, n=self.n)\n",
    "    \n",
    "    def print_state(self):\n",
    "        #print(self.state)\n",
    "        print(get_nonzero_states(self.state))\n",
    "    \n",
    "    def print_state_vector(self):\n",
    "        print(self.state_vector)\n",
    "    \n",
    "    # Its difficult to write the tensor form of the CNOT gate applied on the whole circuit when ∣i-j∣ > 1.\n",
    "    # Since we are swapping neighbors, it is guaranteed that ∣i-j∣ <= 2 for this map, which makes it simpler.\n",
    "    # But I did it bitwise instead of using matrix vector multiplication since it was easier.\n",
    "    def cx(self, control_bit, target_bit):\n",
    "        if (self.n >= 2) and (self.n > control_bit) and (self.n > target_bit) and (control_bit != target_bit):\n",
    "            new_state = {}\n",
    "            \n",
    "            for i, key in enumerate(self.state.keys()):\n",
    "                if key[control_bit] == \"1\":\n",
    "                    new_key = key                    \n",
    "                    new_bit = str(1- int(key[target_bit]))\n",
    "                    new_key = new_key[:target_bit] + new_bit + new_key[target_bit+1:]\n",
    "                    new_state[new_key] = self.state[key]\n",
    "                else:\n",
    "                    new_state[key] = self.state[key]\n",
    "                    \n",
    "            self.state = organize_state(self.n, new_state)\n",
    "            self.state_vector = list( self.state.values() )\n",
    "        else:\n",
    "            print(\"Invalid indexes\")\n",
    "    \n",
    "    def swap(self, i, j):\n",
    "        i, j = i+3, j+3\n",
    "        if i!=j:\n",
    "            path_go, path_back = find_path(i, j) # Get the correct order of swapping the neighbors\n",
    "            \n",
    "            for step in range(len(path_go)-1):\n",
    "                self.swap_neighbors(path_go[step], path_go[step+1])\n",
    "            \n",
    "            for step in range(len(path_back)-1):\n",
    "                self.swap_neighbors(path_back[step], path_back[step+1])            \n",
    "\n",
    "        else:\n",
    "            print(\"Same node\")\n",
    "    \n",
    "    def swap_neighbors(self, i, j):\n",
    "        diagram = [[2], [2], [0,1,3], [2,4], [3,5,6], [4], [4]] # The map of the diagram showing connections\n",
    "        \n",
    "        if j in diagram[i]:\n",
    "            # Swap using CNOT gates\n",
    "            self.cx(i, j)\n",
    "            self.cx(j, i)\n",
    "            self.cx(i, j)\n",
    "            \n",
    "            # Manually swap on the qubits list for later verification\n",
    "            val1, val2 = self.qubits[i], self.qubits[j]\n",
    "            self.qubits[i] = val2\n",
    "            self.qubits[j] = val1\n",
    "        else:\n",
    "            print(\"Nodes are not neighbors\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Verify the calculations\n",
    "\n",
    "One way to verify the correctness of the operators is to keep the current quantum state of each qubit separately in a list, say `list_of_states`. Then, after each swap operator on the neighbors, the state of system is compared with the tensor product of the states of qubits in the appropriate order. \n",
    "\n",
    "For auto verification, the class can have additional methods such as printing the content of `list_of_states`, tensoring the states in `list_of_states`, making the aforementioned comparisons, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lengths: 128 and 128\n",
      "Difference: \n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "-0.00000\n",
      "-0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "-0.00000\n",
      "-0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "-0.00000\n",
      "-0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "-0.00000\n",
      "-0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "-0.00000\n",
      "-0.00000\n",
      "-0.00000\n",
      "-0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "-0.00000\n",
      "-0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "-0.00000\n",
      "-0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n",
      "0.00000\n"
     ]
    }
   ],
   "source": [
    "game = SwappingGame()\n",
    "\n",
    "game.swap(2,-3)\n",
    "resulting_vector = game.state_vector # State vector obtained by using CNOT gates\n",
    "predicted_vector = get_state_vector(game.qubits) # State vector obtained by swapping the order in the list manually\n",
    "\n",
    "print(f'Lengths: {len(resulting_vector)} and {len(predicted_vector)}')\n",
    "print(\"Difference: \")\n",
    "for i in range(len(resulting_vector)):\n",
    "    print(f'{predicted_vector[i]-resulting_vector[i]:.5f}')"
   ]
  }
 ],
 "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.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}