other/QTensorImplementationNotes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e6e6177a",
   "metadata": {},
   "source": [
    "## The need and implementation of QTensor class\n",
    "\n",
    "With only tequila objectives defined, it was a time-consuming process for the user to implement a vector, matrix or a tensor of expectation values (or tequila objectives) and manipulate it.\n",
    "Thus there was a need of a new class that gives the ease of creating these objects and doing operations with them efficiently. \n",
    "We call this new class as `QTensor`.<br>\n",
    "Below we first demonstrate how, without the QTensor, one could create the above mentioned mathematical objects and do operations with them. Thereafter, we show using QTensor class the ease of doing the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e739ae51",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Qibo 0.1.6|INFO|2022-01-14 10:46:45]: Using numpy backend on /CPU:0\n",
      "[Qibo 0.1.6|WARNING|2022-01-14 10:46:45]: numpy backend uses `np.einsum` and supports CPU only. Consider installing the qibojit or qibotf backends for increased performance and to enable GPU acceleration.\n"
     ]
    }
   ],
   "source": [
    "import tequila as tq\n",
    "import numpy as np\n",
    "from numpy import pi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b8341c8",
   "metadata": {},
   "source": [
    "Without the QTensor class, the usual strategy would be to create a class with tequila objectives as primitives and initialize it with a desired shape. To this class then, we will add methods to access the elements given the index number.\n",
    "Let's say we we call this new class `tequialTensor`. We can define it as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ac08c5a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class tequilaTensor:\n",
    "    def __init__(self,objective_list,shape):\n",
    "        self.shape = shape\n",
    "        self.objective_list = objective_list\n",
    "\n",
    "    def access(self, idx): \n",
    "        if len(idx) != len(self.shape):\n",
    "            raise Exception(\"access: shapes don't match {} vs {}\".format(idx, self.shape))\n",
    "        else:\n",
    "            for j in range(len(idx)):\n",
    "                if idx[j] >= self.shape[j]:\n",
    "                    raise ValueError(\"no such matrix cell exists\")\n",
    "            list_index = 0\n",
    "            for i in range(len(idx)):\n",
    "                if i != len(idx) -1 :\n",
    "                    list_index += idx[i]*(self._prod(self.shape,i))\n",
    "                else:\n",
    "                    list_index += (idx[i] + 1)\n",
    "            return self.objective_list[list_index-1]\n",
    "\n",
    "    def _prod(self, any_list, integer):\n",
    "        prod = 1\n",
    "        for i in range(integer+1, len(any_list)):\n",
    "            prod = prod * any_list[i]\n",
    "        return prod\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dec1d48c",
   "metadata": {},
   "source": [
    "Using the above `access` method, one can access any element of the given tensor. \n",
    "Let us briefly see how it works. First, this method checks whether we the index that we have provided exists in that tensor or not. Once it's confirmed if there is the index number provided is correct, we then run a small loop to output the element at the desired index number."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "962f70dd",
   "metadata": {},
   "source": [
    "To make accessing elements easier for the user, we add another method `__getitem__` which essentially calls `access`. This gives us the priviledge of using `[]` to access the elements.<br>\n",
    "Next, we want `tequilaTensor` class to be able to add two tensors of the same shape and return an error if the shapes are not same. Thus, we do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "efb6bcb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class tequilaTensor:\n",
    "    def __init__(self,objective_list,shape):\n",
    "        self.shape = shape\n",
    "        self.objective_list = objective_list\n",
    "\n",
    "    def access(self, idx): \n",
    "        if len(idx) != len(self.shape):\n",
    "            raise Exception(\"access: shapes don't match {} vs {}\".format(idx, self.shape))\n",
    "        else:\n",
    "            for j in range(len(idx)):\n",
    "                if idx[j] >= self.shape[j]:\n",
    "                    raise ValueError(\"no such matrix cell exists\")\n",
    "            list_index = 0\n",
    "            for i in range(len(idx)):\n",
    "                if i != len(idx) -1 :\n",
    "                    list_index += idx[i]*(self._prod(self.shape,i))\n",
    "                else:\n",
    "                    list_index += (idx[i] + 1)\n",
    "            return self.objective_list[list_index-1]\n",
    "    \n",
    "    def __getitem__(self,item):\n",
    "        return self.access(item)\n",
    "\n",
    "    def __add__(self, other):\n",
    "        if self.shape != other.shape:\n",
    "            raise Exception(\"shapes don't match\")\n",
    "        added_list = []\n",
    "        for i in range(len(self.objective_list)):\n",
    "            added_list.append(self.objective_list[i] + other.objective_list[i])\n",
    "        return tequilaTensor(objective_list=added_list, shape=self.shape)\n",
    "\n",
    "    def _prod(self, any_list, integer):\n",
    "        prod = 1\n",
    "        for i in range(integer+1, len(any_list)):\n",
    "            prod = prod * any_list[i]\n",
    "        return prod"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a32439b4",
   "metadata": {},
   "source": [
    "In the above code, we first compare the shapes of the two tensors to be added. If the shapes are same, we do element-wise addition, and return the resultant tequilaTensor."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d558951",
   "metadata": {},
   "source": [
    "The next desired operation is scalar multiplication and element-wise multiplication. \n",
    "We want that our class should be able to perform both left and right multiplications. To do this, we add a `__mul__` method in the following way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5ce161f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class tequilaTensor:\n",
    "    def __init__(self,objective_list,shape):\n",
    "        self.shape = shape\n",
    "        self.objective_list = objective_list\n",
    "\n",
    "    def access(self, idx): \n",
    "        if len(idx) != len(self.shape):\n",
    "            raise Exception(\"access: shapes don't match {} vs {}\".format(idx, self.shape))\n",
    "        else:\n",
    "            for j in range(len(idx)):\n",
    "                if idx[j] >= self.shape[j]:\n",
    "                    raise ValueError(\"no such matrix cell exists\")\n",
    "            list_index = 0\n",
    "            for i in range(len(idx)):\n",
    "                if i != len(idx) -1 :\n",
    "                    list_index += idx[i]*(self._prod(self.shape,i))\n",
    "                else:\n",
    "                    list_index += (idx[i] + 1)\n",
    "            return self.objective_list[list_index-1]\n",
    "    \n",
    "    def __getitem__(self,item):\n",
    "        return self.access(item)\n",
    "\n",
    "    def __add__(self, other):\n",
    "        if self.shape != other.shape:\n",
    "            raise Exception(\"shapes don't match\")\n",
    "        added_list = []\n",
    "        for i in range(len(self.objective_list)):\n",
    "            added_list.append(self.objective_list[i] + other.objective_list[i])\n",
    "        return tequilaTensor(objective_list=added_list, shape=self.shape)\n",
    "\n",
    "    def __mul__(self,other):\n",
    "        if isinstance(other,float) or isinstance(other, int) or isinstance(other, complex):\n",
    "            multiplied_list = []\n",
    "            for i in range(len(self.objective_list)):\n",
    "                multiplied_list.append(self.objective_list[i] * other)\n",
    "            return tequilaTensor(objective_list=multiplied_list, shape=self.shape)            \n",
    "        if self.shape != other.shape:\n",
    "            raise Exception(\"shapes don't match\")\n",
    "        multiplied_list = []\n",
    "        for i in range(len(self.objective_list)):\n",
    "            multiplied_list.append(self.objective_list[i] * other.objective_list[i])\n",
    "        return tequilaTensor(objective_list=multiplied_list, shape=self.shape)\n",
    "\n",
    "    def __rmul__(self,other):\n",
    "        return self.__mul__(other)\n",
    "\n",
    "    def _prod(self, any_list, integer):\n",
    "        prod = 1\n",
    "        for i in range(integer+1, len(any_list)):\n",
    "            prod = prod * any_list[i]\n",
    "        return prod"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cb977bd",
   "metadata": {},
   "source": [
    "In the above `__mul__` method, we first check whether the `other` - which is being multiplied to our original `tequilaTensor` object - is an `int`, `float`,`complex`, or a `tequilaTensor` itself. If the `other` is a `tequilaTensor`, we check whether it has the same shape, and if it does, we then do an element-wise multiplication and return the resultant tequilaTensor. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98289b5d",
   "metadata": {},
   "source": [
    "Having defined these basic operations, let us first test the above class using numbers and then we will test it with tequila objectives."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ee26cbf3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A[3,1]:  8\n",
      "after right multiplication with 2, A[3,1]:  16\n",
      "after a left multiplication with 2, A[3,1]:  32\n",
      "Let A = A*A. Then A[3,1]:  1024\n",
      "objective list of A:  [16, 64, 144, 256, 400, 576, 784, 1024]\n",
      "objective list of B:  [3, 4, 2, 3.4, 5, 6.7, 8, 9.0]\n",
      "objective list of C:  [19, 68, 146, 259.4, 405, 582.7, 792, 1033.0]\n",
      "[4, 2]\n",
      "[4, 2]\n",
      "3\n",
      "\n",
      "16 64 \n",
      "144 256 \n",
      "400 576 \n",
      "784 1024 "
     ]
    }
   ],
   "source": [
    "# Let us first initialize a tequilaTensor with numbers\n",
    "A = tequilaTensor(objective_list=[1,2,3,4,5,6,7,8],shape=[4,2]) \n",
    "\n",
    "# Now let's access and print an element of this tequilaTensor\n",
    "print('A[3,1]: ', A[3,1])\n",
    "\n",
    "# Right multiplication\n",
    "A = A*2\n",
    "print('after right multiplication with 2, A[3,1]: ', A[3,1])\n",
    "\n",
    "# Left multiplication\n",
    "A = 2*A\n",
    "print('after a left multiplication with 2, A[3,1]: ', A[3,1])\n",
    "\n",
    "# Product of two objects of tequilaTensor class.\n",
    "A = A*A\n",
    "print('Let A = A*A. Then A[3,1]: ', A[3,1])\n",
    "\n",
    "## If we try to add two objects with wrong, it gives an error as desired.\n",
    "## To check, uncomment the two lines below and run.\n",
    "# B = tequilaTensor(objective_list=[3,4],shape=[2])\n",
    "\n",
    "B = tequilaTensor(objective_list=[3,4,2,3.4, 5,6.7, 8,9.0],shape=[4,2])\n",
    "\n",
    "C = A+B\n",
    "\n",
    "print('objective list of A: ',A.objective_list)\n",
    "print('objective list of B: ',B.objective_list)\n",
    "print('objective list of C: ',C.objective_list)\n",
    "\n",
    "\n",
    "C = B*2 \n",
    "print(B.shape)\n",
    "print(C.shape)\n",
    "print(B[0,0])\n",
    "for i in range(A.shape[0]):\n",
    "    print(end='\\n')\n",
    "    for j in range(A.shape[1]):\n",
    "        print(A[i,j],end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af4e5ab0",
   "metadata": {},
   "source": [
    "So we verify that our class works well with numbers, and we can initialize a tequilaTensor, access its elements, add two tequilaTensors of same shape, and do scalar multiplication."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6917467b",
   "metadata": {},
   "source": [
    "After testing the `tequilatensor` class with numbers, now let us test it with `objectives`.\n",
    "Below we define some basic expectation values which we will use to define an object of `tequilaTensor` class and use the methods we defined in this class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a82e6576",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+2.0000X(0)\n",
      "Objective with 1 unique expectation values\n",
      "total measurements = 1\n",
      "variables          = []\n",
      "types              = not compiled\n"
     ]
    }
   ],
   "source": [
    "# the circuit\n",
    "U0 = tq.gates.Ry(angle = pi/2,target = 0)\n",
    "H0 = 2*tq.paulis.X(0)\n",
    "E0 = tq.ExpectationValue(H=H0, U = U0)\n",
    "\n",
    "print(H0)\n",
    "print(E0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "eed2ef1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "U = tq.gates.H(0) + tq.gates.X(target=1,control=0)\n",
    "\n",
    "H1 = tq.paulis.X(0)\n",
    "H2 = tq.paulis.X([0,1])\n",
    "H3 = tq.paulis.Z([0,1])\n",
    "H4 = tq.paulis.Z(1)\n",
    "\n",
    "E1 = tq.ExpectationValue(H = H1, U=U)\n",
    "E2 = tq.ExpectationValue(H = H2, U=U)\n",
    "E3 = tq.ExpectationValue(H = H3, U=U)\n",
    "E4 = tq.ExpectationValue(H = H4, U=U)\n",
    "# print(H1)\n",
    "# print(H2)\n",
    "# print(H3)\n",
    "# print(H4)\n",
    "# print(E2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0093cc4",
   "metadata": {},
   "source": [
    "Now let us construct some `tequilaTensor` objects of various shapes and use the methods on them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "77be9780",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = tequilaTensor(objective_list=[E1,E2],shape=[2,1])\n",
    "Y = tequilaTensor(objective_list=[E1,E2,E3,E4],shape=[2,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "79d75339",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "0.9999999999999998\n",
      "0.9999999999999998\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "print(tq.simulate(X.objective_list[0]))\n",
    "print(tq.simulate(Y.objective_list[1]))\n",
    "print(tq.simulate(Y.objective_list[2]))\n",
    "print(tq.simulate(Y.objective_list[3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "fd66a4c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Objective with 1 unique expectation values\n",
      "total measurements = 1\n",
      "variables          = []\n",
      "types              = not compiled\n",
      "0.0\n",
      "<class 'tequila.objective.objective.Objective'>\n",
      "<class '__main__.tequilaTensor'>\n"
     ]
    }
   ],
   "source": [
    "print(Y[0,0])\n",
    "print(tq.simulate(Y[0,0]))\n",
    "print(type(X[0,0]))\n",
    "print(type(Y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f685edbe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Objective with 1 unique expectation values\n",
      "total measurements = 1\n",
      "variables          = []\n",
      "types              = not compiled Objective with 1 unique expectation values\n",
      "total measurements = 1\n",
      "variables          = []\n",
      "types              = not compiled \n",
      "Objective with 1 unique expectation values\n",
      "total measurements = 1\n",
      "variables          = []\n",
      "types              = not compiled Objective with 1 unique expectation values\n",
      "total measurements = 1\n",
      "variables          = []\n",
      "types              = not compiled "
     ]
    }
   ],
   "source": [
    "# Addition\n",
    "Z = Y+Y \n",
    "\n",
    "# Scalar multiplication and element-wise multiplication of two tequilaTensors\n",
    "Z1 = 2*Y\n",
    "Z2 = Y*2\n",
    "Z3 = Y*Y\n",
    "for i in range(Z3.shape[0]):\n",
    "    print(end='\\n')\n",
    "    for j in range(Z3.shape[1]):\n",
    "        print(Z3[i,j],end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "983d21c0",
   "metadata": {},
   "source": [
    "So, in the above examples we see that we are able to do basic operations by forming our own tensor class. \n",
    "Now, we want to add more functions and it would be good to have all the operations that can be performed on an `numpy.ndarray` object. Apart from that, we would like to also have `compile` and `simulate`.<br>\n",
    "Now if we keep adding methods to perform compilation, simulation, more linear algebraic functions, or even applying a function to all elements of the defined tensor, it will become harder or inefficient, and time-consuming for the user."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62dbe4dc",
   "metadata": {},
   "source": [
    "With this idea, we introduce the `QTensor` class using which the user can easily define and initialize a tensor with tequila objectives as its elements. Moreover, we derive this class from numpy.ndarray class. This means that we are inheriting the properties of numpy.ndarray and don't need to redefine all those linear algbraic functions again.\n",
    "Besides, using this QTensor class, the user is able to apply any function to the whole QTensor object in the same way as one can apply the function to a tequila objective using the `apply` method. Lastly, we can apply, `grad`, `compile`, and `simulate` in the same way as we do for tequila objectives. <br>\n",
    "Below we justify this by constructing simple QTensor objects (a (2,2) matrix and a (2,1) vector) and performing some operations on it. More details and usage of QTensor have been provided in the `QTensorTutorial`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4b355987",
   "metadata": {},
   "outputs": [],
   "source": [
    "V = tq.QTensor(shape=[2,2])\n",
    "W = tq.QTensor(shape=[2])\n",
    "V[0,0] = E1\n",
    "V[0,1] = E2\n",
    "V[1,0] = E3\n",
    "V[1,1] = E4\n",
    "W[0] = E1\n",
    "W[1] = E2\n",
    "\n",
    "## An alternate way to define and initialize QTensor is\n",
    "## V = tq.QTensor(objective_list=[E1,E2,E3,E4], shape = [2,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbfc9f1c",
   "metadata": {},
   "source": [
    "Using the `print` command, we can get the details of the desired QTensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "012956ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QTensor of shape (2, 2) with 4 unique expectation values\n",
      "total measurements = 4\n",
      "variables          = []\n",
      "types              = not compiled\n",
      "QTensor of shape (2,) with 2 unique expectation values\n",
      "total measurements = 2\n",
      "variables          = []\n",
      "types              = not compiled\n"
     ]
    }
   ],
   "source": [
    "print(V)\n",
    "print(W)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4fce5ba",
   "metadata": {},
   "source": [
    "For linear algebraic operations, we can treat the QTensor object as an ndarray and use all the numpy linear algebra functions. An example is given below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "54ae43fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tequila.objective.qtensor.QTensor'>\n",
      "QTensor of shape (2,) with 4 unique expectation values\n",
      "total measurements = 4\n",
      "variables          = []\n",
      "types              = not compiled\n"
     ]
    }
   ],
   "source": [
    "U = np.dot(V,W)\n",
    "print(type(U))\n",
    "print(U)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a77cbf33",
   "metadata": {},
   "source": [
    "We can comile and simulate the QTensor objects in the same way we compile tequila objectives."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a17458b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "V = \n",
      " [[0. 1.]\n",
      " [1. 0.]]\n",
      "W = \n",
      " [0. 1.]\n",
      "U = V*W = \n",
      " [1. 0.]\n"
     ]
    }
   ],
   "source": [
    "print('V = \\n',tq.simulate(V))\n",
    "print('W = \\n',tq.simulate(W))\n",
    "print('U = V*W = \\n',tq.simulate(U))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9dedae0",
   "metadata": {},
   "source": [
    "Lastly, for applying a function on a QTensor object, the same convention that is used for applying a function on a tequila objective, can be used. For instance, if we want to apply exponential over all elements of the QTensor `V`, then we simply do the following"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "cb60fbfe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.71828183]\n",
      " [2.71828183 1.        ]]\n"
     ]
    }
   ],
   "source": [
    "V1 = V.apply(np.exp)\n",
    "print(tq.simulate(V1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e665ab8b",
   "metadata": {},
   "source": [
    "Thus, `QTensor` class provides an easy and efficient way to create vectors, matrices and tensors of tequila objectives, and perform operations on it. We can perform all the operations that one can do on a numpy.ndarray object. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tequila_devel",
   "language": "python",
   "name": "tequila_devel"
  },
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}