hhl_3q.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from logicqubit.logic import *\n",
    "from cmath import *\n",
    "import numpy as np\n",
    "import sympy as sp\n",
    "from scipy.linalg import expm, sinm, cosm, logm, sqrtm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def qft(qr):\n",
    "    for i in range(len(qr)):\n",
    "        for j in range(i):\n",
    "            qr[i].CU1(qr[j], pi/float(2**(i-j)))\n",
    "        qr[i].H()\n",
    "        \n",
    "def iqft(qr):\n",
    "    for i in range(len(qr)):\n",
    "        for j in range(i):\n",
    "            qr[i].CU1(qr[j], -pi/float(2**(i-j)))\n",
    "        qr[i].H()\n",
    "        \n",
    "def swap(s1, s2):\n",
    "    s2.CX(s1)\n",
    "    s1.CX(s2)\n",
    "    s2.CX(s1)\n",
    "    \n",
    "def ancilla_rotation(k, C, N, t):\n",
    "    if k == 0:\n",
    "        k = 3\n",
    "    theta = 2*asin(C*N*t / (2*pi*k))\n",
    "    return theta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.+4.4408921e-16j 0.+0.0000000e+00j]\n",
      " [0.+0.0000000e+00j 1.+4.4408921e-16j]]\n"
     ]
    }
   ],
   "source": [
    "# Ax=b, x=3/8=0.375 e -1/8=-0.125\n",
    "\n",
    "#A = np.matrix([[1.5,0.5],[0.5,1.5]])\n",
    "A = np.matrix([[3,1],[1,3]])\n",
    "t0 = 2*pi\n",
    "#t0 = 0.358166*pi\n",
    "register_size = 3\n",
    "\n",
    "# Set C to be the smallest eigenvalue that can be represented by the\n",
    "C = 2*pi / (2**register_size * t0)\n",
    "\n",
    "U = np.matrix(expm(1j*A*t0/2))\n",
    "U_A_div2 = np.matrix(expm(1j*A*t0/2)) \n",
    "U_A_div4 = np.matrix(expm(1j*A*t0/4))\n",
    "U_A_div8 = np.matrix(expm(1j*A*t0/8))\n",
    "U_A_inv_div2 = np.matrix(expm(-1j*A*t0/2)) \n",
    "U_A_inv_div4 = np.matrix(expm(-1j*A*t0/4))\n",
    "U_A_inv_div8 = np.matrix(expm(-1j*A*t0/8))\n",
    "print(U_A_div2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.375 -0.125]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([1,0])\n",
    "x = np.linalg.solve(A, b)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "logicQuBit  = LogicQuBit(5)\n",
    "\n",
    "m = 1\n",
    "\n",
    "a = Qubit()\n",
    "c1 = Qubit()\n",
    "c2 = Qubit()\n",
    "c3 = Qubit()\n",
    "b = Qubit()\n",
    "\n",
    "c1.H()\n",
    "c2.H()\n",
    "c3.H()\n",
    "\n",
    "#logicQuBit.PrintState() # a,c1,c2,c3,b\n",
    "#b.X()\n",
    "#b.H()\n",
    "\n",
    "# phase estimation\n",
    "b.CU(c3, U_A_div8)\n",
    "b.CU(c2, U_A_div4)\n",
    "b.CU(c1, U_A_div2)\n",
    "\n",
    "#b.CU(c3, U_A_div8)\n",
    "#c3.CU(c2, U_A_div4)\n",
    "#b.CU(c1, U_A_div2)\n",
    "\n",
    "b.CU(c1, U)\n",
    "\n",
    "b.CU(c2, U)\n",
    "b.CU(c2, U)\n",
    "\n",
    "b.CU(c3, U)\n",
    "b.CU(c3, U)\n",
    "b.CU(c3, U)\n",
    "\n",
    "iqft([c1,c2,c3])\n",
    "\n",
    "#logicQuBit.PrintState()\n",
    "\n",
    "swap(c1,c2)\n",
    "\n",
    "#a.CRY(c1, ancilla_rotation(1,C,register_size,t0))\n",
    "#a.CRY(c2, ancilla_rotation(2,C,register_size,t0))\n",
    "#a.CRY(c3, ancilla_rotation(3,C,register_size,t0))\n",
    "\n",
    "a.CRY(c1, 4*pi/(2**(m-1)))\n",
    "a.CRY(c2, 2*pi/(2**(m-1)))\n",
    "a.CRY(c3, 1*pi/(2**(m-1)))\n",
    "\n",
    "swap(c1,c2)\n",
    "\n",
    "qft([c1,c2,c3])\n",
    "\n",
    "# reverse phase estimation\n",
    "b.CU(c1, U_A_inv_div2)\n",
    "b.CU(c2, U_A_inv_div4)\n",
    "b.CU(c3, U_A_inv_div8)\n",
    "\n",
    "#b.CU(c1, U_A_div2.conj().T)\n",
    "#c3.CU(c2, U_A_div4.conj().T)\n",
    "#b.CU(c3, U_A_div8.conj().T)\n",
    "\n",
    "c1.H()\n",
    "c2.H()\n",
    "c3.H()\n",
    "#logicQuBit.PrintState()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'00000': (0.2500000000000002+3.2131722973884535e-16j),\n",
       " '00001': (-0.2500000000000003-3.2550159356878817e-16j),\n",
       " '00010': (-7.321690718642148e-16+0.24999999999999983j),\n",
       " '00011': (-7.093930911542993e-17-0.25000000000000067j),\n",
       " '00100': (-1.1865859033808e-16-1.5047887589474974e-16j),\n",
       " '00101': (1.3947527204980168e-16+1.377916140651098e-16j),\n",
       " '00110': (3.478463511321582e-16-9.11918847638287e-17j),\n",
       " '00111': (7.920201690584587e-17+1.358190860390403e-16j),\n",
       " '01000': (3.6672643306195197e-16-0.25000000000000017j),\n",
       " '01001': (-3.8635258879549916e-16+0.2500000000000002j),\n",
       " '01010': (0.2500000000000002+4.641375235333216e-16j),\n",
       " '01011': (-0.2500000000000002-3.4736685314507324e-16j),\n",
       " '01100': (5.341896931628643e-17+1.440331139973599e-16j),\n",
       " '01101': (-9.267128078338084e-17-1.4928834991657525e-16j),\n",
       " '01110': (-3.6825450891360043e-16+3.0221235648215795e-17j),\n",
       " '01111': (-2.229607773127381e-17-1.5799550988141224e-16j),\n",
       " '10000': (0.1249999999999997+0.30177669529663737j),\n",
       " '10001': (0.12499999999999983+0.30177669529663737j),\n",
       " '10010': (-6.138599005560863e-17-8.902191178233562e-17j),\n",
       " '10011': (-1.0432680771909032e-17+5.312328226519268e-17j),\n",
       " '10100': (0.3017766952966376-0.12499999999999997j),\n",
       " '10101': (0.30177669529663725-0.12499999999999967j),\n",
       " '10110': (-1.6276443080382638e-16-1.1159322553555473e-16j),\n",
       " '10111': (1.512540609329286e-16+1.602141626950017e-16j),\n",
       " '11000': (0.1250000000000003-0.05177669529663665j),\n",
       " '11001': (0.1250000000000001-0.051776695296636414j),\n",
       " '11010': (-2.3186449980152103e-16-9.676033064046987e-17j),\n",
       " '11011': (2.503711036136993e-16+1.0218867159906065e-16j),\n",
       " '11100': (-0.05177669529663725-0.1250000000000003j),\n",
       " '11101': (-0.05177669529663658-0.12500000000000014j),\n",
       " '11110': (-7.214302789729803e-17+3.2662796249987326e-16j),\n",
       " '11111': (9.395712073440904e-17-3.2550841057850427e-16j)}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logicQuBit.getDictPsi()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#res_a = logicQuBit.Measure_One(a)\n",
    "#print(res_a)\n",
    "res = logicQuBit.Measure([b], True)\n",
    "logicQuBit.Plot()\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Text2List(table):\n",
    "    list = [int(i, base=2) for i in table]\n",
    "    size = len(table[0])\n",
    "    tmp = sorted(list, key=int, reverse=False)  # values in ascending order\n",
    "    result = [[int(bin(j)[2:].zfill(size)[i]) for i in range(size)] for j in tmp]\n",
    "    return result\n",
    "\n",
    "def BinList(n):\n",
    "    blist = []\n",
    "    for i in iter(range(2 ** n)):\n",
    "        b = bin(i)[2:].zfill(n)  # value in binary, ex: i=1, n=4 -> '0001'\n",
    "        blist.append(b)\n",
    "    return Text2List(blist)\n",
    "\n",
    "#size=3\n",
    "#blist = [value for i,value in enumerate(BinList(size)) if res[i]>0.1] \n",
    "#results = [sum([value/2**(i+1) for i,value in enumerate(j)]) for j in blist]\n",
    "#print(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0,\n",
       " 0.7853981633974483,\n",
       " 1.5707963267948966,\n",
       " 2.356194490192345,\n",
       " 3.141592653589793,\n",
       " 3.9269908169872414,\n",
       " 4.71238898038469,\n",
       " 5.497787143782138]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# todos possíveis valores\n",
    "size = 3\n",
    "blist = [[i >> bl & 0x1 for bl in range(size)][::-1] for i in range(2**size)]\n",
    "results = [2*pi*sum([value/2**(i+1) for i,value in enumerate(j)]) for j in blist]\n",
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}