Notebooks/HHL_algorithm-Cao-2x2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solving linear system of equations\n",
    "\n",
    "The algorithm tries to solve the system of linear equations that can be represented as:\n",
    "\n",
    "$$A\\vec{x}=\\vec{b}$$\n",
    "\n",
    "The algorithm was proposed by [Aram W. Harrow, Avinatan Hassidim, and Seth Lloyd](https://arxiv.org/abs/0811.3171). It assumes that the eigenvalues ($\\{\\lambda_j,j=1,N\\}$) and eigenstates ($\\{u_j,j=1,N\\}$) of matrix A of dimension $NxN$ are known. \n",
    "\n",
    "If $$\\vec{b}=\\sum_{j=1}^{M}\\beta_j|u_j\\rangle$$\n",
    "and $C$ is a constant such as $C<\\lambda_j$, then $\\vec{x}$ can be approximated as\n",
    "\n",
    "$$|x\\rangle \\approx C \\sum_{j=1}^M \\frac{\\beta_j}{\\lambda_j}|u_j\\rangle$$\n",
    "\n",
    "The algorithm uses three registers:\n",
    "\n",
    "1. C or clock register\n",
    "2. I to store $\\vec{b}$\n",
    "3. An ancilla qubit to get the solution\n",
    "\n",
    "The steps of algorithm are:\n",
    "\n",
    "1. Prepare an initial state $|\\Psi_0\\rangle^{c}\\otimes|b\\rangle^{I}$ with:$$|\\Psi_0\\rangle = \\sqrt{\\frac{2}{T}}\\sum_{\\tau=0}^{T-1}\\sin\\frac{\\pi(\\tau+\\frac{1}{2})}{T}|\\tau\\rangle^C$$ and $$|b\\rangle=\\sum_{j=1}^{N-1}\\beta_j|u_j>$$\n",
    "2. Apply the conditonal Hamiltonian evolution $\\sum_{\\tau=0}^{T-1}|\\tau\\rangle\\langle\\tau|^C\\otimes e^{iA\\tau t_0/T}$, where $t_0=O(\\kappa/\\epsilon)$, being $\\kappa$ the condition number of A (or the ratio between A’s largest and smallest eigenvalues) and $\\epsilon$ the additive error achieved in the output state $|x\\rangle$\n",
    "3. Apply the QFT to register C, denoting the new basis sets as $|k\\rangle$, for $k\\in{0,...,T-1}$. Define $\\hat{\\lambda}:=2\\pi k/t_0$ \n",
    "4. Append an ancilla register, S, and apply a controled rotation on S with C as the control. The rotation is defined so $|0\\rangle$ is mapped for each $\\lambda_j$ to $\\sqrt{1-\\frac{C^2}{\\lambda_j^2}}|0\\rangle+\\frac{C}{\\lambda_j}|1\\rangle$\n",
    "5. Uncompute the operations on C\n",
    "6. Measure S. if result is $|1>$ then return the register I, else goto step 1.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, the original HHL algorithm can be symplified as shown in [Cao et al.](https://arxiv.org/abs/1110.2232v2) and [Cao et al.](https://arxiv.org/abs/1110.2232v3). The state preparation of step 1 is changed to a Wals-Hadamard initialization of the Clock register and step 3 is calculated automatically, so the neither the eigenvectors or eigenvalues of the matrix is needed previously. But it needs ad additional quantum register to calculate the angles for the controled rotations (step 4) and two additional ancilla qubits. The general scheme is now (figure from [Cao et al.](https://arxiv.org/abs/1110.2232v3)):\n",
    "\n",
    "<img src=\"Images/Cole.jpg\"/>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cole's algorithm steps are:\n",
    "\n",
    "1. Prepare an initial state $(H|0\\rangle)^{\\otimes c}\\otimes|b\\rangle^{I}$\n",
    "2. Make a Quanthum Phase Estimation of A on state $|b>$ and store it on register C\n",
    "3. Calculate the rotations to apply from register C to register L using an unitary transformation $U_\\lambda$\n",
    "4. Apply a controled rotation on ancolla qubit S with L as the control.\n",
    "5. Uncompute all the operations on ancillas and registers, except for ancilla qubit S\n",
    "6. Measure S. if result is $|1>$ then return the register I, else goto step 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The system of linear equations to solve is\n",
    "\n",
    "$\\frac{1}{2}\\begin{bmatrix}3&1\\\\1&3\\end{bmatrix}\\vec{x}=\\begin{bmatrix}1\\\\0\\end{bmatrix}$\n",
    "\n",
    "The eigenvalues of this matrix are $\\lambda_1=1$ and $\\lambda_2=2$, with eigenvectors $|-\\rangle=\\frac{1}{\\sqrt{2}}(|0\\rangle-|1\\rangle)$ and $|+\\rangle=\\frac{1}{\\sqrt{2}}(|0\\rangle+|1\\rangle)$ \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from projectq.cengines import MainEngine\n",
    "import numpy as np\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from projectq.ops import TimeEvolution,QubitOperator,_state_prep,get_inverse,Ry,Measure,QFT,All,H,X,Swap,Y,Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from projectq.meta import Compute,Uncompute,Control,Dagger"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are helper functions to print the final state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Display(string):\n",
    "    from IPython.display import display, Markdown\n",
    "    display(Markdown(string))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_state_as_str(eng,qubits,cheat=False):\n",
    "    import numpy as np\n",
    "    s=\"$\"\n",
    "    if (cheat):\n",
    "        print(\"Cheat: \", eng.backend.cheat())\n",
    "    if (len(qubits)==2):\n",
    "        for i in range(4):\n",
    "            #print(\"bits:%d%s\"%(i,bits))\n",
    "            a=eng.backend.get_amplitude(\"%d\"%(i),qubits)\n",
    "            if (abs(a.real)>0.0000001)|(abs(a.imag)>0.000001):\n",
    "                if s!=\"$\":\n",
    "                    s=s+\"+\"\n",
    "                a=\"({:.3f})\".format(a)\n",
    "                s=s+\"%s|%d>\"%(a,i)\n",
    "\n",
    "    else:\n",
    "        for j in range(2**(len(qubits)-1)):\n",
    "            bits=np.binary_repr(j,width=len(qubits)-1)\n",
    "            #print(\"Bits:\",j,bits)\n",
    "            for i in range(2):\n",
    "                #print(\"bits:%d%s\"%(i,bits))\n",
    "                a=eng.backend.get_amplitude(\"%d%s\"%(i,bits[-1::-1]),qubits)\n",
    "                if (abs(a.real)>0.0000001)|(abs(a.imag)>0.000001):\n",
    "                    if s!=\"$\":\n",
    "                        s=s+\"+\"\n",
    "                    a=\"({:.3f})\".format(a)\n",
    "                    s=s+\"%s|%s>_S|%s>_C|%d>_b\"%(a,bits[0],bits[1:],i)\n",
    "                #print(s)\n",
    "    s=s+\"$\"\n",
    "    #Display(s)\n",
    "    return(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Helper funcion to solve the classical system and return the expectation values of Pauli's matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solve(A,b):\n",
    "    import numpy as np\n",
    "    a = np.array(A)\n",
    "    b = np.array(b)\n",
    "    x = np.linalg.solve(a, b)\n",
    "    sigmax=np.array([[0,1],[1,0]])\n",
    "    sigmay=np.array([[0,-1j],[1j,0]])\n",
    "    sigmaz=np.array([[1,0],[0,-1]])\n",
    "    norm=np.linalg.norm(x)\n",
    "    Esx=np.dot(x,np.dot(sigmax,x.T))/norm**2\n",
    "    Esy=np.dot(x,np.dot(sigmay,x.T))/norm**2\n",
    "    Esz=np.dot(x,np.dot(sigmaz,x.T))/norm**2\n",
    "    return Esx,Esy,Esz,x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def DisplayResults(eng, Qureg,B,A,b):\n",
    "    Display(\"After Measure:%s\"%get_state_as_str(eng,Qureg))\n",
    "    amplitude1=eng.backend.get_amplitude(\"0001\",Qureg)\n",
    "    amplitude2=eng.backend.get_amplitude(\"1001\",Qureg)\n",
    "    Esx,Esy,Esz,x = solve(A, b)\n",
    "    amplitude1=\"({:.3f})\".format(amplitude1)\n",
    "    amplitude2=\"({:.3f})\".format(amplitude2)\n",
    "    Display(\"Result: (%s,%s). Classical: (%.3f,%.3f)\"%(amplitude1,amplitude2,x[0],x[1]))\n",
    "    Display(\"Calculated expectation value of $\\sigma_X$:%.3f. Should be %.3f\"%(eng.backend.get_expectation_value(QubitOperator(\"X0\"),B).real,Esx))  \n",
    "    Display(\"Calculated expectation value of $\\sigma_Y$:%.3f. Should be %.3f\"%(eng.backend.get_expectation_value(QubitOperator(\"Y0\"),B).real,Esy)) \n",
    "    Display(\"Calculated expectation value of $\\sigma_Z$:%.3f. Should be %.3f\"%(eng.backend.get_expectation_value(QubitOperator(\"Z0\"),B).real,Esz)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The matrix $A=\\frac{1}{2}\\begin{bmatrix}3&1\\\\1&3\\end{bmatrix}$ can be decomposed on Pauli's matrices as:\n",
    "\n",
    "$$ A=\\frac{1}{2}(3I+\\sigma_x)$$\n",
    "\n",
    "So, to make the Hamiltonian time evolution (step 2), construct the Hamiltonian\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5 I +\n",
      "0.5 X0\n",
      "[[1.5 0.5]\n",
      " [0.5 1.5]]\n"
     ]
    }
   ],
   "source": [
    "Ham=QubitOperator(\"\",1.5)\n",
    "Ham=Ham+QubitOperator(\"X0\",0.5)\n",
    "print(Ham)\n",
    "\n",
    "A=  np.array([[1.5,0.5], [0.5,1.5]])\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The time step for the Hamiltonian time evolution in the Quantum Phase Estimation routine is selected to $t_0=2\\pi$ and the total time is $T=4$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "t0=2*math.pi\n",
    "T=4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, design this circuit\n",
    "\n",
    "<img src=\"Images/Cole2.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initialize the Engine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "eng=MainEngine()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Allocate the quantum registers. Three are needed:\n",
    "\n",
    "1. A register to store the value of $\\vec{b}$. In this case, only 1 qubit is needed.\n",
    "2. A clock register, which needs only 2 qubits (one for each eigenvalue)\n",
    "3. An ancilla qubit\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=eng.allocate_qureg(1)\n",
    "C=eng.allocate_qureg(2)\n",
    "S=eng.allocate_qureg(1)\n",
    "Qureg=B+C+S"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a Quantum Phase Estimation routine. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def QPE(eng,C,b,Ham,t0,T):\n",
    "        \"\"\"\n",
    "        Initiallise register C to Walsh-Hadamard state\n",
    "        \"\"\"\n",
    "        All(H) |C\n",
    "        \"\"\"\n",
    "        Apply the Hamiltonian time evolution. Take into account that ProjectQ adds a minus sign to the Time evolution (-i)\n",
    "        \"\"\"\n",
    "        with Control(eng,C[0]):\n",
    "            TimeEvolution(time=-1.*t0/T,hamiltonian=Ham) | b\n",
    "        with Control(eng,C[1]):\n",
    "            TimeEvolution(time=-2.*t0/T,hamiltonian=Ham) | b\n",
    "        \"\"\"\n",
    "        And now, the inverse of the QFT \n",
    "        \"\"\"\n",
    "        Swap | (C[0],C[1])\n",
    "        get_inverse(QFT)|C\n",
    "        #QFT|C\n",
    "        #Swap | (C[0],C[1])\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the operator to calculate the rotations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def U_l(C):\n",
    "        \"\"\"\n",
    "        The trick here is that U_l is only is swaping qubits on register C\n",
    "        \"\"\"\n",
    "        Swap | (C[0],C[1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the funtion to apply the controlled rotations on **S**.Parameter *r* must be calibrated, but Cole did it for r=4 to get good results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ControlledRotations(eng,S,C,r):\n",
    "    import math\n",
    "    #Theta_1=math.pi\n",
    "    #Theta_2=math.pi/3\n",
    "    Theta_1=2*math.pi/(2**r)\n",
    "    with Control(eng,C[1]):\n",
    "        Ry(Theta_1) | S\n",
    "    Theta_2=math.pi/(2**r)\n",
    "    with Control(eng,C[0]):\n",
    "        Ry(Theta_2) |S\n",
    "    import math\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, compose the full circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_state(state,b):\n",
    "    from projectq.ops._state_prep import StatePreparation\n",
    "    StatePreparation(state)|b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "$(1.000+0.000j)|0>_S|00>_C|0>_b$"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"Prepare state b on register B\n",
    "\"\"\"\n",
    "b=[1,0]\n",
    "prepare_state(b,B)\n",
    "eng.flush()\n",
    "Display(get_state_as_str(eng,Qureg))\n",
    "with Compute(eng):\n",
    "        \"\"\"\n",
    "        Apply QPE\n",
    "        \"\"\"\n",
    "        QPE(eng,C,B,Ham,t0,T)\n",
    "        #eng.flush()\n",
    "        #Display(\"After QPE:%s\"%get_state_as_str(eng,Qureg))\n",
    "\n",
    "\n",
    "        \"\"\"\n",
    "        Apply U_l\n",
    "        \"\"\"\n",
    "        U_l(C)\n",
    "        #eng.flush()\n",
    "        #Display(\"After Ul:%s\"%get_state_as_str(eng,Qureg))\n",
    "        \n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, apply the Controlled rotations. Parameter r must be calibrated, but Cole did it for r=4 to get good results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "r=4\n",
    "ControlledRotations(eng,S,C,r)\n",
    "    \n",
    "#eng.flush()\n",
    "#print(\"After CR:\",get_state_as_str(eng,Qureg))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "After Uncompute:$(0.988+0.000j)|0>_S|00>_C|0>_b+(0.007-0.000j)|0>_S|00>_C|1>_b+(0.147+0.000j)|1>_S|00>_C|0>_b+(-0.049-0.000j)|1>_S|00>_C|1>_b$"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Uncompute(eng)\n",
    "\n",
    "eng.flush()\n",
    "Display(\"After Uncompute:%s\"%get_state_as_str(eng,Qureg))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uncompute all the operations we did on C and B. projectQ will calculate automatically all the gates to apply"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    "And measure. If the result for qubit S is 1, register B contains the solution\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "After Uncompute:$(1.000+0.000j)|0>_S|00>_C|0>_b+(0.007-0.000j)|0>_S|00>_C|1>_b$"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Measure | S\n",
    "eng.flush()\n",
    "Display(\"After Uncompute:%s\"%get_state_as_str(eng,Qureg))\n",
    "result=int(S)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ohhh!!!! Bad luck! You have to reset and execute again. Or continue with the loop behind\n"
     ]
    }
   ],
   "source": [
    "if result==0:\n",
    "    All(Measure) | C\n",
    "    Measure |B\n",
    "    eng.flush()\n",
    "    del eng\n",
    "    print(\"Ohhh!!!! Bad luck! You have to reset and execute again. Or continue with the loop behind\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the measurment of S is 1, register B has collapsed to the solution. Instead of multiples executions, using ProjectQ simulator it is possible to calculate the probabilitities (because the solution is real, they are the squared of the solution)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "if (int(S)):\n",
    "    DisplayResults(eng,Qureg,B,A,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the previous exercise does not work well, execute the loop until the measurement of **S** is **1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "if result!=0:\n",
    "    All(Measure) | C\n",
    "    Measure | B\n",
    "    eng.flush()\n",
    "    del eng\n",
    "result=0\n",
    "while (result==0):\n",
    "    eng=MainEngine()\n",
    "    \"\"\"\n",
    "    Allocate the registers\n",
    "    \"\"\"\n",
    "    B=eng.allocate_qureg(1)\n",
    "    C=eng.allocate_qureg(2)\n",
    "    S=eng.allocate_qureg(1)\n",
    "    \"\"\"Prepare state b on register B\n",
    "    \"\"\"\n",
    "    Qureg=B+C+S\n",
    "    \n",
    "    prepare_state(b,B)\n",
    "    with Compute(eng):\n",
    "        \"\"\"\n",
    "        Apply QPE\n",
    "        \"\"\"\n",
    "        QPE(eng,C,B,Ham,t0,T)\n",
    "        \"\"\"\n",
    "        Apply U_l\n",
    "        \"\"\"\n",
    "        U_l(C)\n",
    "    eng.flush()\n",
    "    r=4\n",
    "    ControlledRotations(eng,S,C,r)\n",
    "    eng.flush()\n",
    "    Uncompute(eng)\n",
    "    eng.flush()\n",
    "    Measure | S\n",
    "    eng.flush()\n",
    "    result=int(S)\n",
    "    if result==0:\n",
    "        All(Measure) | C\n",
    "        Measure |B\n",
    "        eng.flush()\n",
    "        del eng"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "After Measure:$(0.949+0.000j)|1>_S|00>_C|0>_b+(-0.314-0.000j)|1>_S|00>_C|1>_b$"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Result: ((0.949+0.000j),(-0.314-0.000j)). Classical: (0.750,-0.250)"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Calculated expectation value of $\\sigma_X$:-0.597. Should be -0.600"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/agomez/.conda/envs/cursoQC/lib/python3.5/site-packages/ipykernel_launcher.py:10: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  # Remove the CWD from sys.path while we load stuff.\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Calculated expectation value of $\\sigma_Y$:-0.000. Should be 0.000"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Calculated expectation value of $\\sigma_Z$:0.802. Should be 0.800"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if (int(S)):\n",
    "    DisplayResults(eng,Qureg,B,A,b)    "
   ]
  },
  {
   "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.5.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}