Task-1_Quantum Multiplier.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "c3a35659",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pennylane as qml\n",
    "from pennylane import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "04b2fba6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BasisStatePreparation([0, 0, 0, 1, 1], wires=[0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Basis State preparation \n",
    "def state_preparation(basis_id, n_qubits):\n",
    "    bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]\n",
    "    return qml.BasisStatePreparation(bits, wires=range(n_qubits))\n",
    "\n",
    "#Testing\n",
    "state_preparation(3,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "32315d83",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Swappping of quantum circuits \n",
    "def swap_bits(n_qubits):\n",
    "    \"\"\"A circuit that reverses the order of qubits, i.e.,\n",
    "    performs a SWAP such that [q1, q2, ..., qn] -> [qn, ... q2, q1].\n",
    "    \n",
    "    Args:\n",
    "        n_qubits (int): An integer value identifying the number of qubits.\n",
    "    \"\"\"\n",
    "    for i in range(int(n_qubits/2)):\n",
    "        qml.SWAP(wires=[i,n_qubits-1-i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "2c0a4433",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conditional Rotation matrix\n",
    "def qft_rotations(n_qubits):\n",
    "    \"\"\"A circuit performs the QFT rotations on the specified qubits.\n",
    "    \n",
    "    Args:\n",
    "        n_qubits (int): An integer value identifying the number of qubits.\n",
    "    \"\"\"\n",
    "    n = n_qubits\n",
    "    for i in range(n):\n",
    "        qml.Hadamard(wires=i)\n",
    "        for jj in range(i+1,n,1):\n",
    "            qml.ControlledPhaseShift(np.pi/(2**(jj-i)), wires=[jj,i])\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d0d5cf3",
   "metadata": {},
   "source": [
    "# Quantum Adder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "7875936b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number a: 3\n",
      "Enter number b: 4\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "def qft_node(basis_id, basis_id2, n_qubits):\n",
    "    ''' A circuit performs addition of two numbers \n",
    "    \n",
    "    Args:\n",
    "        basis_id (int): An integer value specifying the first number to be added.\n",
    "        basis_id2 (int): An integer value specifying the second number to be added.\n",
    "        n_qubits (int): An integer value identifying the number of qubits.\n",
    "    '''\n",
    "    \n",
    "    # Prepare the basis state |basis_id>\n",
    "    bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]\n",
    "    qml.BasisStatePreparation(bits, wires=range(n_qubits))\n",
    "    \n",
    "    bits2 = [int(x) for x in np.binary_repr(basis_id2, width=n_qubits)]\n",
    "    qml.BasisStatePreparation(bits2, wires=range(n_qubits, 2*(n_qubits),1))\n",
    "    qft_rotations(n_qubits)\n",
    "    for i in range(0,n_qubits,1):\n",
    "        k=0\n",
    "        for j in range(i+n_qubits,(2*n_qubits),1):\n",
    "            qml.ControlledPhaseShift((np.pi/(2**(k))), wires=[j,i])\n",
    "            k+=1\n",
    "    (qml.adjoint)(qft_rotations)(n_qubits)\n",
    "    return qml.sample(wires=[x for x in range(n_qubits)])\n",
    "\n",
    "# basis_id stores a, basis_id2 stores b\n",
    "basis_id = int(input(\"Enter number a: \"))\n",
    "basis_id2 = int(input(\"Enter number b: \"))\n",
    "if len(np.binary_repr(basis_id))>len(np.binary_repr(basis_id2)):\n",
    "    n_qubits = len(np.binary_repr(basis_id)) + 1\n",
    "else:\n",
    "    n_qubits = len(np.binary_repr(basis_id2)) + 1\n",
    "dev = qml.device('default.qubit', wires=(2*n_qubits), shots=10)\n",
    "qnode = qml.QNode(qft_node, dev)\n",
    "\n",
    "k = qnode(basis_id, basis_id2, n_qubits)\n",
    "poww, summ = 0, 0\n",
    "for l in reversed(k[0]):\n",
    "    summ = summ + (2**poww)*l\n",
    "    poww+=1\n",
    "print(summ)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75dc08d5",
   "metadata": {},
   "source": [
    "# Quantum Multiplier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "7d7f744c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number a: 5\n",
      "Enter number b: 8\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "def multiplier(basis_id, basis_id2, n_qubits):\n",
    "    ''' A circuit performs multiplication of two numbers \n",
    "    \n",
    "    Args:\n",
    "        basis_id (int): An integer value specifying the first number to be multiplied.\n",
    "        basis_id2 (int): An integer value specifying the second number to be multiplied.\n",
    "        n_qubits (int): An integer value identifying the number of qubits.\n",
    "    '''\n",
    "    \n",
    "    # Basis state preparation for 0, a, b respectively\n",
    "    \n",
    "    bits1 = [int(x) for x in np.binary_repr(0, width=2*n_qubits)]\n",
    "    qml.BasisStatePreparation(bits1, wires=range(2*(n_qubits)))\n",
    "    \n",
    "    bits2 = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]\n",
    "    qml.BasisStatePreparation(bits2, wires=range(2*n_qubits, 3*n_qubits))\n",
    "    \n",
    "    bits3 = [int(x) for x in np.binary_repr(basis_id2, width=n_qubits)]\n",
    "    qml.BasisStatePreparation(bits3, wires=range(3*n_qubits, 4*(n_qubits),1))\n",
    "       \n",
    "    # Applying QFT on first 2*n_qubits as they store the basis state for |0>\n",
    "    qft_rotations(2*n_qubits)\n",
    "    \n",
    "    # Applying Conditional Rotation operator with controls a_j and b_m and target as |0>\n",
    "    for i in range(3*n_qubits, 4*n_qubits,1):\n",
    "        for j in range(2*n_qubits, 3*n_qubits,1):\n",
    "            for m in range(2*n_qubits):\n",
    "                qml.ctrl(qml.PhaseShift(np.pi/(2**(-(5*n_qubits)-m+j+i+1)), wires=m),control=[j,i])\n",
    "    \n",
    "    # Applying inverse QFT 2*n_qubits\n",
    "    (qml.adjoint)(qft_rotations)(2*n_qubits)\n",
    "    \n",
    "    return qml.sample(wires=[x for x in range(2*n_qubits)])\n",
    "\n",
    "# basis_id stores a, basis_id2 stores b\n",
    "basis_id = int(input(\"Enter number a: \"))\n",
    "basis_id2 = int(input(\"Enter number b: \"))\n",
    "\n",
    "# n_qubits takes the value of the number whose binary representation is the greatest among the two\n",
    "if len(np.binary_repr(basis_id))>len(np.binary_repr(basis_id2)):\n",
    "    n_qubits = len(np.binary_repr(basis_id)) \n",
    "else:\n",
    "    n_qubits = len(np.binary_repr(basis_id2))\n",
    "\n",
    "# Creating QNode\n",
    "dev = qml.device('default.qubit', wires=(4*n_qubits), shots=10)\n",
    "qnode = qml.QNode(multiplier, dev)\n",
    "\n",
    "# Below code returns the sample containing measurements on the wires\n",
    "# print(qnode(basis_id,basis_id2,n_qubits))  \n",
    "# Below prints quantum circuit\n",
    "# print(qml.draw(qnode)(basis_id,basis_id2,n_qubits))\n",
    "\n",
    "# k stores the sample of measurement values on each wire\n",
    "k = qnode(basis_id, basis_id2, n_qubits)\n",
    "\n",
    "# Converting k[0] to integer value\n",
    "# Considering only k[0] as all elements of the sample are identical\n",
    "poww, summ = 0, 0\n",
    "for l in reversed(k[0]):\n",
    "    summ = summ + (2**poww)*l\n",
    "    poww+=1\n",
    "print(summ)"
   ]
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}