Qiskit-QPEStandalone.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Load all necessary qiskit and generic libraries\n",
    "\n",
    "from qiskit import Aer, transpile, assemble\n",
    "from qiskit.circuit.library import QFT\n",
    "from qiskit.aqua import QuantumInstance, aqua_globals\n",
    "from qiskit.quantum_info import state_fidelity\n",
    "from qiskit.aqua.algorithms import HHL, NumPyLSsolver\n",
    "from qiskit.aqua.components.eigs import EigsQPE\n",
    "from qiskit.aqua.components.reciprocals import LookupRotation\n",
    "from qiskit.aqua.operators import MatrixOperator\n",
    "from qiskit.aqua.components.initial_states import Custom\n",
    "from qiskit.tools.visualization import circuit_drawer\n",
    "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit\n",
    "from qiskit.visualization import plot_histogram\n",
    "from qiskit.tools.visualization import circuit_drawer\n",
    "from qiskit import execute\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "\n",
    "#Initliaze Simulator\n",
    "from qiskit import BasicAer\n",
    "backend = BasicAer.get_backend('statevector_simulator')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def binaryToPhase(binary):\n",
    "    binary=list(binary[::-1])\n",
    "    length = len(binary)\n",
    "    res=0\n",
    "    \n",
    "    for i in range(length):\n",
    "        digit=int(binary.pop())\n",
    "        if digit==1:\n",
    "            res=res+pow(2,i)  \n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Function for calling the EigsQpe with minimal values and default most of the values\n",
    "\n",
    "def create_eigs(matrix, num_ancillae, negative_evals, evo_time=None):\n",
    "    ne_qfts = [None, None]\n",
    "    if negative_evals:\n",
    "        num_ancillae += 1\n",
    "        ne_qfts = [QFT(num_ancillae - 1), QFT(num_ancillae - 1).inverse()]\n",
    "\n",
    "    return EigsQPE(MatrixOperator(matrix=matrix),\n",
    "                   QFT(num_ancillae).inverse(),\n",
    "                   num_time_slices=1,\n",
    "                   num_ancillae=num_ancillae,\n",
    "                   expansion_mode='trotter',\n",
    "                   expansion_order=1,\n",
    "                   evo_time=evo_time,\n",
    "                   negative_evals=negative_evals,\n",
    "                   ne_qfts=ne_qfts)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_results(circuit,scale,nqbit,cdict,plothist=True):\n",
    "    \n",
    "    ndict={}\n",
    "    \n",
    "    for kval in cdict.keys():\n",
    "        nkey=kval[1:]\n",
    "        ndict[nkey]=cdict[kval]\n",
    "    \n",
    "    print('\\nCounts:',ndict)\n",
    "    print('\\nActual Eigen Value from Circuit:')\n",
    "    \n",
    "    for kval in ndict.keys():\n",
    "        theta=binaryToPhase(kval)\n",
    "        \n",
    "        eigen=(2*np.pi*theta)/((2**nqbit)*scale)\n",
    "        print('Binary:',kval,' Corresponding Eigen Value:',eigen)\n",
    "        \n",
    "    return ndict,circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def execute_eigs(matrix,nqubits,negativeEigen):\n",
    "    #Initialize circuit\n",
    "    q = QuantumRegister(1)\n",
    "    qc = QuantumCircuit(q)\n",
    "    \n",
    "    # State preparation\n",
    "    qc.x(q[0])\n",
    "    qc.h(q[0])\n",
    "    \n",
    "    e,v=np.linalg.eig(matrix)\n",
    "    print('Expected Eigen Values:',e)\n",
    "    \n",
    "    eigs = create_eigs(matrix, nqubits, negativeEigen)\n",
    "    num_q, num_a = eigs.get_register_sizes()\n",
    "    qc += eigs.construct_circuit(\"circuit\", q)\n",
    "    \n",
    "    qc.draw(fold=-1)\n",
    "    \n",
    "    print(eigs._num_ancillae)\n",
    "    print(eigs._operator.paulis)\n",
    "    print(sum([abs(p[0]) for p in eigs._operator.paulis]))\n",
    "    \n",
    "    scale=eigs.get_scaling()\n",
    "    \n",
    "    print(scale)\n",
    "    \n",
    "    result = execute(qc,backend).result()\n",
    "    counts = result.get_counts()\n",
    "\n",
    "    res=sorted(counts.items(), key = lambda kv:(kv[1], kv[0]),reverse=True)\n",
    "    \n",
    "    \n",
    "    rdict=dict(res)\n",
    "   \n",
    "    return process_results(qc,scale,nqubits,rdict,plothist=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expected Eigen Values: [1.33333333 0.66666667]\n",
      "7\n",
      "[[(1+0j), Pauli(z=[False], x=[False])], [(-0.3333333333333333+0j), Pauli(z=[False], x=[True])]]\n",
      "1.3333333333333333\n",
      "4.675573441475435\n",
      "\n",
      "Counts: {'1111111': 0.499999999999994, '1111110': 0.499999999999994}\n",
      "\n",
      "Actual Eigen Value from Circuit:\n",
      "Binary: 1111111  Corresponding Eigen Value: 1.3333333333333333\n",
      "Binary: 1111110  Corresponding Eigen Value: 0.6614173228346456\n"
     ]
    }
   ],
   "source": [
    "A=[[1,-1/3],[-1/3,1]]\n",
    "count,circuit=execute_eigs(matrix=A,nqubits=7,negativeEigen=False)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histogram(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌───┐┌───┐┌─────────────────────────┐             ┌─────────────────────────┐             ┌─────────────────────────┐             ┌─────────────────────────┐             ┌──────────────────────────┐             ┌──────────────────────────┐             ┌──────────────────────────┐                      \n",
       "q141_0: ┤ X ├┤ H ├┤0                        ├─────────────┤0                        ├─────────────┤0                        ├─────────────┤0                        ├─────────────┤0                         ├─────────────┤0                         ├─────────────┤0                         ├──────────────────────\n",
       "        ├───┤└───┘│  Controlled-Evolution^1 │┌───────────┐│                         │             │                         │             │                         │             │                          │             │                          │             │                          │             ┌───────┐\n",
       "q142_0: ┤ H ├─────┤1                        ├┤ P(4.6756) ├┤  Controlled-Evolution^2 ├─────────────┤                         ├─────────────┤                         ├─────────────┤                          ├─────────────┤                          ├─────────────┤                          ├─────────────┤0      ├\n",
       "        ├───┤     └─────────────────────────┘└───────────┘│                         │┌───────────┐│  Controlled-Evolution^4 │             │                         │             │                          │             │                          │             │                          │             │       │\n",
       "q142_1: ┤ H ├─────────────────────────────────────────────┤1                        ├┤ P(9.3511) ├┤                         ├─────────────┤  Controlled-Evolution^8 ├─────────────┤                          ├─────────────┤                          ├─────────────┤                          ├─────────────┤1      ├\n",
       "        ├───┤                                             └─────────────────────────┘└───────────┘│                         │┌───────────┐│                         │             │  Controlled-Evolution^16 │             │                          │             │                          │             │       │\n",
       "q142_2: ┤ H ├─────────────────────────────────────────────────────────────────────────────────────┤1                        ├┤ P(18.702) ├┤                         ├─────────────┤                          ├─────────────┤  Controlled-Evolution^32 ├─────────────┤                          ├─────────────┤2      ├\n",
       "        ├───┤                                                                                     └─────────────────────────┘└───────────┘│                         │┌───────────┐│                          │             │                          │             │  Controlled-Evolution^64 │             │       │\n",
       "q142_3: ┤ H ├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤1                        ├┤ P(37.405) ├┤                          ├─────────────┤                          ├─────────────┤                          ├─────────────┤3 iqft ├\n",
       "        ├───┤                                                                                                                             └─────────────────────────┘└───────────┘│                          │┌───────────┐│                          │             │                          │             │       │\n",
       "q142_4: ┤ H ├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤1                         ├┤ P(74.809) ├┤                          ├─────────────┤                          ├─────────────┤4      ├\n",
       "        ├───┤                                                                                                                                                                     └──────────────────────────┘└───────────┘│                          │┌───────────┐│                          │             │       │\n",
       "q142_5: ┤ H ├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤1                         ├┤ P(149.62) ├┤                          ├─────────────┤5      ├\n",
       "        ├───┤                                                                                                                                                                                                              └──────────────────────────┘└───────────┘│                          │┌───────────┐│       │\n",
       "q142_6: ┤ H ├───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤1                         ├┤ P(299.24) ├┤6      ├\n",
       "        └───┘                                                                                                                                                                                                                                                       └──────────────────────────┘└───────────┘└───────┘</pre>"
      ],
      "text/plain": [
       "        ┌───┐┌───┐┌─────────────────────────┐             ┌─────────────────────────┐             ┌─────────────────────────┐             ┌─────────────────────────┐             ┌──────────────────────────┐             ┌──────────────────────────┐             ┌──────────────────────────┐                      \n",
       "q141_0: ┤ X ├┤ H ├┤0                        ├─────────────┤0                        ├─────────────┤0                        ├─────────────┤0                        ├─────────────┤0                         ├─────────────┤0                         ├─────────────┤0                         ├──────────────────────\n",
       "        ├───┤└───┘│  Controlled-Evolution^1 │┌───────────┐│                         │             │                         │             │                         │             │                          │             │                          │             │                          │             ┌───────┐\n",
       "q142_0: ┤ H ├─────┤1                        ├┤ P(4.6756) ├┤  Controlled-Evolution^2 ├─────────────┤                         ├─────────────┤                         ├─────────────┤                          ├─────────────┤                          ├─────────────┤                          ├─────────────┤0      ├\n",
       "        ├───┤     └─────────────────────────┘└───────────┘│                         │┌───────────┐│  Controlled-Evolution^4 │             │                         │             │                          │             │                          │             │                          │             │       │\n",
       "q142_1: ┤ H ├─────────────────────────────────────────────┤1                        ├┤ P(9.3511) ├┤                         ├─────────────┤  Controlled-Evolution^8 ├─────────────┤                          ├─────────────┤                          ├─────────────┤                          ├─────────────┤1      ├\n",
       "        ├───┤                                             └─────────────────────────┘└───────────┘│                         │┌───────────┐│                         │             │  Controlled-Evolution^16 │             │                          │             │                          │             │       │\n",
       "q142_2: ┤ H ├─────────────────────────────────────────────────────────────────────────────────────┤1                        ├┤ P(18.702) ├┤                         ├─────────────┤                          ├─────────────┤  Controlled-Evolution^32 ├─────────────┤                          ├─────────────┤2      ├\n",
       "        ├───┤                                                                                     └─────────────────────────┘└───────────┘│                         │┌───────────┐│                          │             │                          │             │  Controlled-Evolution^64 │             │       │\n",
       "q142_3: ┤ H ├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤1                        ├┤ P(37.405) ├┤                          ├─────────────┤                          ├─────────────┤                          ├─────────────┤3 iqft ├\n",
       "        ├───┤                                                                                                                             └─────────────────────────┘└───────────┘│                          │┌───────────┐│                          │             │                          │             │       │\n",
       "q142_4: ┤ H ├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤1                         ├┤ P(74.809) ├┤                          ├─────────────┤                          ├─────────────┤4      ├\n",
       "        ├───┤                                                                                                                                                                     └──────────────────────────┘└───────────┘│                          │┌───────────┐│                          │             │       │\n",
       "q142_5: ┤ H ├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤1                         ├┤ P(149.62) ├┤                          ├─────────────┤5      ├\n",
       "        ├───┤                                                                                                                                                                                                              └──────────────────────────┘└───────────┘│                          │┌───────────┐│       │\n",
       "q142_6: ┤ H ├───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤1                         ├┤ P(299.24) ├┤6      ├\n",
       "        └───┘                                                                                                                                                                                                                                                       └──────────────────────────┘└───────────┘└───────┘"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit.draw(fold=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix:\n",
      " [[1, -0.5], [-0.5, 1]] \n",
      "\n",
      "Expected Eigen Values: [1.5 0.5]\n",
      "\n",
      "Counts: {'11': 0.500000000000001, '10': 0.500000000000001}\n",
      "\n",
      "Actual Eigen Value from Circuit:\n",
      "Binary: 11  Corresponding Eigen Value: 1.5\n",
      "Binary: 10  Corresponding Eigen Value: 0.5\n"
     ]
    }
   ],
   "source": [
    "A=[[1,-1/2],[-1/2,1]]\n",
    "\n",
    "print('Matrix:\\n',A,'\\n')\n",
    "count,circuit=execute_eigs(matrix=A,nqubits=2,negativeEigen=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc0AAAFACAYAAADeaycbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAezElEQVR4nO3dfZiV9X3n8ffXGRlR4BKIgAhWUCQRI4rjRcYQTLYSY7aaxrgxtrvGpNXLmGqN222SbeJDm6d2m6wmWWPU1Mc0cfOgcdOobLoRgiJ2oMUAKVAFAwShAg0gMMj43T/OGTsMM8N94MyZA/N+Xde5OOd3/+7ffI/Dzcf76XdHZiJJkvbviP4uQJKkQ4WhKUlSQYamJEkFGZqSJBVkaEqSVJChKUlSQYamJEkF1Tw0I+LaiFgVEbsiYmFEvGM//QdFxJ+X12mLiF9FxPVd+nwgIpaVly+LiPf37beQJA1ENQ3NiLgMuB34AnAW8AzweESc2Mtq3wHeA1wNTAb+E/B8pzFbgIeBbwNnlv/8XkRM74vvIEkauKKWMwJFxALg+cy8qlPbSuD7mfnpbvq/G/gecHJmvtLDmA8DIzJzVqe2nwL/mpmXV/s7SJIGrprtaUbEIOBsYHaXRbOBc3tY7XeBfwBujIi1EbEyIr4aEUM69WnpZswnexlTkqQD0ljDn/UmoAHY0KV9A3B+D+tMBGYAbcAHgGOBrwFjgUvLfcb0MOaYgy9ZkqR/V8vQ7ND1eHB009bhiPKy38vM3wBExB8BT0bE6MzsCMvCY0bE1ZTOj3L00UefPW7cOACamppoaGhgx44dADQ2NjJ48GC2bdvWsR5Dhgxhx44dtLe3A3DMMcfw2muvsXv3bgCOOuooIoKdO3cCcOSRR9LU1MT27dtLX+aIIzjmmGOqMsarr77K66+/DsCQIUNoa2vjtddeA2Dw4MFkJrt27QJg0KBBHHnkkbz66qsANDQ0cPTRR1dljO3bt9NxiH/o0KHs3LmTPXv2UP7vS3t7O21tbYX+G1djDH9P/p78Pfl7Otjf0/PPP/9KZh5HN2oZmq8A7ey7BziKffcUO6wH1nUEZtkvy3+eWF7v5UrGzMy7gLsAmpubs7W1tWj9kqQBICJe6mlZzc5pZuZuYCEwq8uiWZSuou3O08DYLucwTy3/2fGl5lc4piRJB6TW92l+BbgyIv4wIt4SEbdTOj95J0BEPBARD3Tq/7fAJuDeiJgSEW+ndMvK9zNzY7nP7cB/iIhPR8SbI+LTwLuA22r1pSRJA0NNz2lm5sMRMRL4DHA8sAR4b2Z27DWe2KX/9og4n9LFP/8AbAEeBT7Vqc8zEfEh4HPArcALwGWZuaCvv48kaWCp6X2a9cZzmpKkriJiYWY2d7fMuWclSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDc4B74oknmDx5Mqeccgpf+tKX9ll+3333cdxxx3HmmWdy5plncs8997yx7P7772fSpElMmjSJ+++//432hQsX8ta3vpVTTjmF66+/nsysyXeRDndur3UgMwfs6+yzz86BbM+ePTlx4sR84YUXsq2tLc8444xcunTpXn3uvffe/PjHP77Pups2bcoJEybkpk2bcvPmzTlhwoTcvHlzZmaec845+cwzz+Trr7+e73nPe/InP/lJTb6PdDhze60doDV7yA33NAew5557jlNOOYWJEycyaNAgPvShD/GjH/2o0LpPPvkks2bNYsSIEQwfPpxZs2bxxBNPsH79erZu3UpLSwsRwRVXXMGjjz7ax99EOvy5vdYHQ3MAW7duHePHj3/j87hx41i3bt0+/X7wgx9wxhlncOmll7JmzZpe1123bh3jxo3b75iSKuP2Wh8MzQEsuzl3ERF7fb7oootYvXo1zz//POeffz4f/vCHe123yJiSKuf2Wh8MzQFs3Lhxb/yfKMDatWsZO3bsXn1GjhxJU1MTAFdddRULFy7sdd1x48axdu3aXseUVDm31/pgaA5g55xzDitXrmTVqlXs3r2b7373u1x88cV79Vm/fv0b7x977DHe8pa3AHDBBRcwe/ZstmzZwpYtW5g9ezYXXHABxx9/PEOHDuXZZ58lM3nggQd43/veV9PvJR2O3F7rQ2N/F6D+09jYyNe//nUuuOAC2tvb+ehHP8qUKVO46aabaG5u5uKLL+arX/0qjz32GI2NjYwYMYL77rsPgBEjRvDZz36Wc845B4CbbrqJESNGAPCNb3yDK6+8kp07d3LhhRdy4YUX9tdXlA4bbq/1Ibo7pj1QNDc3Z2tra3+XIUmqIxGxMDObu1vm4VlJkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCfMpJFVx1W39XoL5w9w39XYH6itvs4akW26x7mpIkFWRoSpJUkKEpSVJBhqYkSQUZmpIkFWRoSpJUkKEpSVJBhqYkSQUZmpIkFWRoSpJUkKEpSVJBhqYkSQUZmpIkFWRoSpJUkKEpSVJBhqYkSQUZmpIkFVTz0IyIayNiVUTsioiFEfGOguvNiIg9EbGkS/uVEZHdvI7qm28gSRqoahqaEXEZcDvwBeAs4Bng8Yg4cT/rDQceAP6+hy47gOM7vzJzV7XqliQJar+neSNwX2benZm/zMzrgPXAx/az3reA+4H5PSzPzHy586uKNUuSBNQwNCNiEHA2MLvLotnAub2sdy0wBvhcL8MPjoiXImJtRPw4Is466IIlSeqisYY/601AA7ChS/sG4PzuVoiItwI3A2/LzPaI6K7bcuCjwGJgKPDHwNMRMTUzV3Yz5tXA1QBjx47lqaeeAmDixIkMHTqUxYsXAzBy5EimTJnC3LlzAWhsbGTGjBksWrSIrVu3AtDc3MyGDRuAk4v+N9AhpLW1le3btwMwffp01q5dy7p16wCYPHkyDQ0NLFu2DIAxY8YwYcIE5s8vHQwZPHgw06dPZ8GCBezcuROAlpYWVq1axcsvlw6EnHbaabS3t7N8+XIATjjhBMaNG8eCBQsAGDJkCM3NzcyfP5+2tjYAZsyYwYoVK9i4cSMAp59+Om1tbaxcWfqrPn78eEaPHk1raysAw4YNY9q0acybN489e/YAMHPmTJYuXcqmTZsAmDp1Ktu2bePFF18E4KSTTmLEiBEsWrQIgOHDhzN16lTmzJlDZhIRnHfeeSxevJgtW7YAMG3aNDZv3szq1auBg9ue1qxZA8CkSZNoampiyZLSZQyjRo3i1FNPZd68eQA0NTXR0tJyQL8naKrwb4MOBevXr6/K9tSbyMw+/AqdflDEWGAdMDMzf96p/Wbg8sx8c5f+TcAi4EuZ+WC57Rbg0sw8vZef0wD8E/CzzLy+t5qam5uz4x+Xg3HVbQc9hOrQ3Tf0dwXqK26zh6dqbbMRsTAzm7tbVss9zVeAdkqHWjsbxb57n1C6oOc04N6IuLfcdgQQEbEHeG9mdj3US3mPtBWYVLXKJUmihuc0M3M3sBCY1WXRLEpX0Xa1DngrcGan153Av5Tfd7cOUTqGewalC4wkSaqaWu5pAnwFeDAingOeBq4BxlIKQyLiAYDMvCIzXwO63pO5EWjLzCWd2m4GngVWAsOA6ymF5v6uyJUkqSI1Dc3MfDgiRgKfoXT4dQmlw6wvlbv0er9mD44F7qJ02Pc3wD9SOm/6XBVKliTpDbXe0yQz7wDu6GHZO/ez7i3ALV3aPgF8ojrVSZLUM+eelSSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCKgrNiPhgRLy70+ebImJtRDwZEcdXvzxJkupHpXuat3S8iYhpwH8HvgocCXy5emVJklR/Givs/1vA8vL79wOPZuZfRcRs4MmqViZJUp2pdE9zFzC0/P63gZ+W3/+mU7skSYelSvc0fw58OSLmAc3ApeX2U4E11SxMkqR6U+me5h8BuymF5TWZ+ety+4V4eFaSdJiraE8zM9cCF3XTfkPVKpIkqU5VfJ9mRBwVEZdGxCcj4thy28kRMaL65UmSVD8q2tOMiFMoXfwzBDgW+B7wb8DHyp//sNoFSpJULyrd07wNmA2MBnZ2an8MeFe1ipIkqR5VevXsucDbMrM9Ijq3/woYW7WqJEmqQwcy9+yR3bSdSOleTUmSDluVhuZs4MZOnzMihgG3An9XtaokSapDlR6evRH4WUQsB44CHgZOATYAH6xybZIk1ZVK79P8dUScCVwOTKO0p3oX8O3M3NnrypIkHeIq3dOkHI5/U35JkjRg7Dc0I+IS4P9k5mvl9z3KzB9WrTJJkupMkT3N7wNjgI3l9z1JoKEaRUmSVI/2G5qZeUR37yVJGmgqCsGImBkR+wRtRDRExMzqlSVJUv2pdM/xZ0B3E7MfW14mSdJhq9LQDErnLrsaCbx68OVIklS/Ct1yEhGPld8m8FBEtHVa3ACcDjxT5dokSaorRe/T3FT+M4At7P2Ek93APODuKtYlSVLdKRSamfkRgIhYDfx1ZnooVpI04FQ6jd6tfVWIJEn1rsiMQM8D52Xmloj4Bd1fCARAZp5RzeIkSaonRfY0fwB0XPjT24xAkiQd1orMCHRrd+8lSRponBZPkqSCipzT7PU8Zmee05QkHc6KPuVEkqQBr6JzmpIkDWSe05QkqSDv05QkqaCa36cZEdcC/w04HlgK3JCZP++h73nAF4HJwNHAS8A9mfnXXfp9APgL4GTgBeDPMvORg61VkqTOanqfZkRcBtwOXEtpkvdrgccj4rTM/FU3q2wHvgr8AtgBvB34ZkTsyMw7ymO2AA8DNwM/BC4BvhcRb8/MBQdTryRJnR3QOc2IODkifqf8OrmCVW8E7svMuzPzl5l5HbAe+Fh3nTNzYWZ+NzOXZuaqzHwIeBJ4R6duNwA/y8zPl8f8PPBUuV2SpKqpKDQjYmREPAqsBB4tv1ZExI8iYuR+1h0EnA3M7rJoNnBuwZ9/VrnvnE7NLd2M+WTRMSVJKqqip5wA9wCnUNrT6zj0OR34BqXnaV7Sy7pvovTA6g1d2jcA5/f2QyNiLXBcud5bM/POTovH9DDmmB7Guhq4GmDs2LE89dRTAEycOJGhQ4eyePFiAEaOHMmUKVOYO3cuAI2NjcyYMYNFixaxdetWAJqbm9mwYQOlU6k63LS2trJ9+3YApk+fztq1a1m3bh0AkydPpqGhgWXLlgEwZswYJkyYwPz58wEYPHgw06dPZ8GCBezcWXr8bEtLC6tWreLll18G4LTTTqO9vZ3ly5cDcMIJJzBu3DgWLChtWkOGDKG5uZn58+fT1la6rGDGjBmsWLGCjRs3AnD66afT1tbGypUrARg/fjyjR4+mtbUVgGHDhjFt2jTmzZvHnj17AJg5cyZLly5l06bSY3KnTp3Ktm3bePHFFwE46aSTGDFiBIsWLQJg+PDhTJ06lTlz5pCZRATnnXceixcvZsuWLQBMmzaNzZs3s3r1auDgtqc1a9YAMGnSJJqamliyZAkAo0aN4tRTT2XevHkANDU10dLSckC/J2iq8G+DDgXr16+vyvbUm8gsNNlPqXPEDuC3M3N+l/YW4KeZeUwv644F1gEzO1/4ExE3A5dn5pt7WXcCMAR4G/CXwB9n5oPlZbuBP+j4XG77MPDNzDyqt+/T3NycHf+4HIyrbjvoIVSH7vYA/2HLbfbwVK1tNiIWZmZzd8sq3dP8V6C7B1DvADbtZ91XgHb23QMcxb57invJzFXlt7+IiNHALUBHSL58IGNKklSpSi8E+nPgtog4oaOh/P7L5WU9yszdwEJgVpdFs4BnKqjhCPY+tjK/CmNKkrRfBzJh+wRgdUSsK38+AdhFae/unv0M9xXgwYh4DngauAYYC9xZ/lkPAGTmFeXP1wGrgOXl9WcCfwLc0WnM24G5EfFp4BHg/cC7gBn7+26SJFWiphO2Z+bD5atsP0NpcoMlwHsz86VylxO7rNJA6RzmScAeShMXfIpyyJbHfCYiPgR8Dri13Ocy79GUJFVbzSdsL09KcEcPy97Z5fNtwH5P2Wfm9/FpLJKkPuaE7ZIkFVTp5AaDIuLWiFgREbsior3zq6+KlCSpHlS6p/kXwIcpXS37OqWJ1/8XpdtNrq1uaZIk1ZdKQ/ODwDWZ+U1K91z+KDOvpzRZetfbPiRJOqxUGpqjgWXl99uBY8vvnwDeXa2iJEmqR5WG5q8o3VcJ8C/ABeX3LcDOahUlSVI9qjQ0HwF+u/z+duDWiFgF3Mf+JzaQJOmQVtHcs5n56U7vv19++si5wIrM/HG1i5MkqZ5UOmH7XjLzWeDZKtUiSVJdq3hyg4iYFhEPRERr+fVgREzri+IkSaonlU5u8PvAP1CaN/Yn5ddo4LmI+M/VL0+SpPpR6eHZzwOfzcwvdG4sP2Hkc8BD1SpMkqR6U+nh2eOA/91N+/coPRpMkqTDVqWh+TPgnd20vxOYc7DFSJJUz4o8hPqSTh8fB74YEc38+1WzbwMuAW6penWSJNWRA30I9dXlV2dfo4fnZEqSdDgo8hBqn7kpSRI+hFqSpMIOZHKD/xgRcyPilYj414iYExHv7YviJEmqJ5VObvCHlCZtfwH4JPApYBXwSER8tPrlSZJUPyqd3OCTwI2Z+fVObd+KiIWUAvRvqlaZJEl1ptLDsydSeuB0V48Dv3Xw5UiSVL8O5CHUs7ppfzfw0sGXI0lS/ar08OxfA18rP9XkGSCBGcB/Aa6rcm2SJNWVSh9C/c2I2Aj8V0qzAAH8EvhgZv6o2sVJklRPCodmRDRSOgw7NzMf6buSJEmqT4XPaWbmHuCHwNC+K0eSpPpV6YVAi4FT+qIQSZLqXaWheQvw5Yj43YgYHxEjOr/6oD5JkupGpVfP/l35zx9SunK2Q5Q/N1SjKEmS6lGlofmuPqlCkqRDQKHQjIijgf8B/C5wJPBT4PrMfKUPa5Mkqa4UPad5K3AlpcOz36E0K9A3+qgmSZLqUtHDs5cAf5CZ3wWIiG8DT0dEQ2a291l1kiTVkaJ7muOBn3d8yMzngD3A2L4oSpKkelQ0NBuA3V3a9lD5hUSSJB2yioZeAA9FRFuntqOAuyNiR0dDZl5czeIkSaonRUPz/m7aHqpmIZIk1btCoZmZH+nrQiRJqneVTqMnSdKAZWhKklSQoSlJUkGGpiRJBRmakiQVZGhKklSQoSlJUkGGpiRJBRmakiQVZGhKklSQoSlJUkGGpiRJBRmakiQVZGhKklSQoSlJUkGGpiRJBRmakiQVZGhKklRQzUMzIq6NiFURsSsiFkbEO3rpe3xE/G1E/HNEtEfEfd30uTIispvXUX36RSRJA05NQzMiLgNuB74AnAU8AzweESf2sEoT8ArwJWBBL0PvAI7v/MrMXdWqW5IkqP2e5o3AfZl5d2b+MjOvA9YDH+uuc2auzszrM/M+YHMv42Zmvtz5Vf3SJUkDXc1CMyIGAWcDs7ssmg2ce5DDD46IlyJibUT8OCLOOsjxJEnaR2MNf9abgAZgQ5f2DcD5BzHucuCjwGJgKPDHwNMRMTUzV3btHBFXA1cDjB07lqeeegqAiRMnMnToUBYvXgzAyJEjmTJlCnPnzgWgsbGRGTNmsGjRIrZu3QpAc3MzGzZsAE4+iPJVr1pbW9m+fTsA06dPZ+3ataxbtw6AyZMn09DQwLJlywAYM2YMEyZMYP78+QAMHjyY6dOns2DBAnbu3AlAS0sLq1at4uWXSwdCTjvtNNrb21m+fDkAJ5xwAuPGjWPBgtKZiCFDhtDc3Mz8+fNpa2sDYMaMGaxYsYKNGzcCcPrpp9PW1sbKlaW/6uPHj2f06NG0trYCMGzYMKZNm8a8efPYs2cPADNnzmTp0qVs2rQJgKlTp7Jt2zZefPFFAE466SRGjBjBokWLABg+fDhTp05lzpw5ZCYRwXnnncfixYvZsmULANOmTWPz5s2sXr0aOLjtac2aNQBMmjSJpqYmlixZAsCoUaM49dRTmTdvHgBNTU20tLQc0O+pdOZHh5v169dXZXvqTWRmH36FTj8oYiywDpiZmT/v1H4zcHlmvnk/6/8YeCUzr9xPvwbgn4CfZeb1vfVtbm7Ojn9cDsZVtx30EKpDd9/Q3xWor7jNHp6qtc1GxMLMbO5uWS3Pab4CtANjurSPYt+9zwOWme1AKzCpWmNKkgQ1DM3M3A0sBGZ1WTSL0lW0VRERAZxB6QIjSZKqppbnNAG+AjwYEc8BTwPXAGOBOwEi4gGAzLyiY4WIOLP8dhjwevnz7sxcVl5+M/AssLLc53pKodntFbmSJB2omoZmZj4cESOBz1C6n3IJ8N7MfKncpbv7Nf+xy+eLgJeAk8qfjwXuonTY9zfl/jMz87nqVi9JGuhqvadJZt4B3NHDsnd20xb7Ge8TwCeqUpwkSb1w7llJkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgqqeWhGxLURsSoidkXEwoh4x376n1futysiXoyIaw52TEmSDkRNQzMiLgNuB74AnAU8AzweESf20H8C8JNyv7OALwJfi4gPHOiYkiQdqFrvad4I3JeZd2fmLzPzOmA98LEe+l8D/Dozryv3vxu4H/iTgxhTkqQDUrPQjIhBwNnA7C6LZgPn9rBaSzf9nwSaI+LIAxxTkqQD0ljDn/UmoAHY0KV9A3B+D+uMAX7aTf/G8nhR6ZgRcTVwdfnj9ohYXqR4veFNwCv9XUQt3POJ/q5Aqgq32cr9Vk8LahmaHbLL5+imbX/9O9qjlz7djpmZdwF37b9MdSciWjOzub/rkFSM22x11TI0XwHaKe09djaKffcUO7zcQ/89wCZK4VjpmJIkHZCandPMzN3AQmBWl0WzKF3x2p357HuYdRbQmpmvHeCYkiQdkFofnv0K8GBEPAc8Tenq2LHAnQAR8QBAZl5R7n8n8EcRcRvwTeDtwJXA5UXHVNV5aFs6tLjNVlFk9nY6sQ9+YMS1wJ8CxwNLgE9k5tzysqcAMvOdnfqfB/xPYArwa+AvM/POomNKklQtNQ9NSZIOVc49K0lSQYamJEkFGZqSJBVkaKqQiIjOf0rSQOSFQDogHeGZ/gWSNID0xzR6OoRExBHA+4DjgKOBdcCczNzYr4VJUj9wT1M9ioihwLeAdwGvA2spzem7E5gDPJSZ/xwR4R6n1P8i4khgAvBSZrb1dz2HI89pqjfXA5OB92bmaOD3gduApcAFwF9FxHEGplQ3Pg78I3BnRFwUEWMioqFzh4gYFhEXlgNWFXJPUz2KiJ8Dj2TmV7q0N1Ca0vBbwAuZ+Z7+qE/S3iJiPrCL0qm3c4FfAY8APwR+kZm/iYhrgCsz8239V+mhyz1NdSsiGilNSfiBiDiu3NYQEQ2Z2V6epvAaYFxETO3PWiVBeTt9Dbg7M99B6ZmQ3wJ+B5gL/L+I+CRwA7Cg3wo9xBma6lZm7gHup/TYtT+JiNHlsGzv1G0FcBID5AG3Up1rpLRXuQkgM9dm5ucy81TgbOBZSnN0nwr8Vb9VeYjz8Ky6Vb5q9gjgI8AXKG2Q3wceBtYAZwAXAW/JzHP6q05J/y4iBlO6E2xX53uqO647iIjPU7pG4az+qvFQZ2hqvyLiWEqPZPs94ExgG9AGPAd8MTM91CPViZ6uZo+Io4FFwL2Z+Ze1r+zwYGhqHxExDNjWecMr73keBQwBTgdeNSyl+tDdNttNn6OAy4DvZObumhV3mDE0tY+I+CalvcjnKN3vtbWbPsMzc4v3aEr9r+A2e2xm/lvNizvMGJraS0RcDnwb2ApsBv4v8CTwPLAuM3dGxBDgIeCzmfmLfitWUk/b7BOUttlfl7fZwcB3gT/LzCX9VuxhwNDUXiLibqCd0tV1lwAfBk4GlgM/Af6e0oQHt2fmoP6qU1KJ22xtGZp6Q/nezD8FhmXmpzq1TwGuAi6ldF7zWOD+zPyDfilUEuA22x8MTe0lIoYDo8tzyg4CXutyQdBlwHeAaZn5T/1Vp6QSt9na8ikn2ktmbgG2lN/vhjeunI3yxAbDgF1ufFJ9cJutLUNT+5WZr3f6OBS4ub9qkbR/brN9x8Ozqkj5yQjtXTZKSXXKbba6DE1JkgpywnZJkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKuj/A4CycoE0drCIAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histogram(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌───┐┌───┐┌─────────────────────────┐        ┌─────────────────────────┐                  \n",
       "q162_0: ┤ X ├┤ H ├┤0                        ├────────┤0                        ├──────────────────\n",
       "        ├───┤└───┘│  Controlled-Evolution^1 │┌──────┐│                         │         ┌───────┐\n",
       "q163_0: ┤ H ├─────┤1                        ├┤ P(π) ├┤  Controlled-Evolution^2 ├─────────┤0      ├\n",
       "        ├───┤     └─────────────────────────┘└──────┘│                         │┌───────┐│  iqft │\n",
       "q163_1: ┤ H ├────────────────────────────────────────┤1                        ├┤ P(2π) ├┤1      ├\n",
       "        └───┘                                        └─────────────────────────┘└───────┘└───────┘</pre>"
      ],
      "text/plain": [
       "        ┌───┐┌───┐┌─────────────────────────┐        ┌─────────────────────────┐                  \n",
       "q162_0: ┤ X ├┤ H ├┤0                        ├────────┤0                        ├──────────────────\n",
       "        ├───┤└───┘│  Controlled-Evolution^1 │┌──────┐│                         │         ┌───────┐\n",
       "q163_0: ┤ H ├─────┤1                        ├┤ P(π) ├┤  Controlled-Evolution^2 ├─────────┤0      ├\n",
       "        ├───┤     └─────────────────────────┘└──────┘│                         │┌───────┐│  iqft │\n",
       "q163_1: ┤ H ├────────────────────────────────────────┤1                        ├┤ P(2π) ├┤1      ├\n",
       "        └───┘                                        └─────────────────────────┘└───────┘└───────┘"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit.draw(fold=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix:\n",
      " [[1.5, 0.5], [0.5, 1.5]] \n",
      "\n",
      "Expected Eigen Values: [2. 1.]\n",
      "\n",
      "Counts: {'11': 0.036611652351682, '10': 0.036611652351682, '01': 0.036611652351682, '00': 0.036611652351682}\n",
      "\n",
      "Actual Eigen Value from Circuit:\n",
      "Binary: 11  Corresponding Eigen Value: 2.0\n",
      "Binary: 10  Corresponding Eigen Value: 0.6666666666666666\n",
      "Binary: 01  Corresponding Eigen Value: 1.3333333333333333\n",
      "Binary: 00  Corresponding Eigen Value: 0.0\n"
     ]
    }
   ],
   "source": [
    "A = [[1.5, 0.5], [0.5, 1.5]]\n",
    "\n",
    "print('Matrix:\\n',A,'\\n')\n",
    "count,circuit=execute_eigs(matrix=A,nqubits=2,negativeEigen=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc0AAAFACAYAAADeaycbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dfZxWdZ3/8ddHEO+An4CJIrg4Yneigzg9Mn8ItkZbtrrdmGbbmrulmbuW67bbr9/WlqV27+pWrGXtmtq6breaZvLwZ4AoYYBLiQYmoGkECrriDYPg5/fHOUMXw8xwrmFuLmZez8djHlzne77nXN+L78y853tuvicyE0mStHN79HcDJEnaXRiakiRVZGhKklSRoSlJUkWGpiRJFRmakiRVZGhKklRRn4dmRJwfEasiYlNELI6IE7qoOyMi7omI9RHxQkT8OiI+0kG9d0TEAxHRWv77tt79FJKkwahPQzMizgCuBC4DjgHuAW6LiEM72eRZ4F+A6cCrgUuAiyPi/Jp9vg64EfgOMKX897sR8dre+hySpMEp+nJGoIhYCPwyM8+pKXsI+F5mfqziPn4AtGbmmeXyjcDozJxZU+cO4Im2OpIk9YQ+G2lGxDDgWGB2u1WzgeMr7uOYsu7cmuLXdbDP26vuU5Kkqvry8OwBwBBgbbvytcBBXW0YEY9FRCuwCJiVmVfVrD6oO/uUJKleQ/vhPdsfD44Oyto7ARgOHAd8PiJWZeZ13dlnRJwLnAuw7777Hjt+/HgA9tprL4YMGcLzzz8PwNChQ9lnn33YuHFj23YMHz6c559/nq1btwKw33778eKLL7J582YA9t57byKCF154AYA999yTvfbai2effRaAPfbYg/32269H9vHcc8/x0ksvATB8+HBaW1t58cUXAdhnn33ITDZt2gTAsGHD2HPPPXnuuecAGDJkCPvuu2+P7OPZZ5+l7RD/iBEjeOGFF9iyZQvl/y9bt26ltbW10v9xT+zDfrKf7Cf7aVf76Ze//OWTmfkyOtCXofkksJUdR4AHsuNIcTuZuap8+auIGAt8CmgLzd/Xs8/M/AbwDYCWlpZctGhRxeZLkgaDiHiks3V9dng2MzcDi4GZ7VbNpLiKtqo9gL1qlhf0wD4lSdqpvj48ezlwXUTcC9wNnAeMA64CiIhrATLzrHL5AmAVsLzcfjrwEWBWzT6vBOZFxMeAHwJvA14PTOvtDyNJGlz6NDQz88aIGAN8HDgYuB84OTPbhsLt79ccAnwemAhsAR4G/g9lyJb7vCci3kV5D2dZ54zMXNiLH0WSNAj16X2ajcZzmpKk9iJicWa2dLTOuWclSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDs5/89Kc/5RWveAWTJk3ic5/73A7rL7/8cl796ldz9NFHc9JJJ/HII49sWzdkyBCmTJnClClTOPXUU7eVr1q1ite+9rUcccQRnHHGGWzevLlPPstAYZ80Jvul8QzqPsnMQft17LHHZn/YsmVLNjU15cMPP5ytra159NFH57Jly7arc+edd+Zzzz2XmZmzZs3K008/fdu6/fbbr8P9vvOd78wbbrghMzM/8IEP5KxZs3rpEww89kljsl8az2DoE2BRdpIbjjT7wb333sukSZNoampi2LBhvOtd7+Kmm27ars7rX/969t13XwCOO+44HnvssS73mZnceeednHbaaQC8973v5Uc/+lHvfIAByD5pTPZL4xnsfWJo9oPHH3+cCRMmbFseP348jz/+eKf1v/Wtb/HmN7952/KmTZtoaWnhuOOO2/aNtX79evbff3+GDh1aaZ/ann3SmOyXxjPY+2RofzdgMCpG/9uLiA7rXn/99SxatIi5c+duK3v00UcZN24cK1eu5I//+I856qijGDlyZOV9akf2SWOyXxrPYO8TR5r9YPz48fz2t7/dtvzYY48xbty4HerdcccdXHrppdx8883stdde28rb6jY1NXHiiSdy3333ccABB/D000+zZcuWLvepjtknjcl+aTyDvk86O9k5GL7660KgF198MQ877LBcuXLlthPp999//3Z1lixZkk1NTblixYrtyjds2JCbNm3KzMwnnngiJ02atO0k/GmnnbbdifSvfe1rffBpBgb7pDHZL41nMPQJXVwI1O/B1Z9f/RWamZm33nprHnHEEdnU1JSXXHJJZmZ+4hOfyJtuuikzM0866aQ88MADs7m5OZubm/OUU07JzMy77747J0+enEcffXROnjw5v/nNb27b58MPP5yvec1r8vDDD8/TTjtt2zenqrFPGpP90ngGep90FZpRrB+cWlpactGiRf3dDElSA4mIxZnZ0tE6z2lKklSRoSlJUkWGpiRJFRmakiRVZGhKklSRoSlJUkWGpiRJFRmakiRVZGhKklSRoSlJUkWGpiRJFRmakiRV5EOoe8A5V/R3C3rO1Rf2dwt6hn3SmOyXxmOf1MeRpiRJFRmakiRVZGhKklSRoSlJUkV9HpoRcX5ErIqITRGxOCJO6KLu2yNidkQ8EREbI2JhRJzaRf0zIyIj4pbeab0kaTDr09CMiDOAK4HLgGOAe4DbIuLQTjaZAdwJvKWs/xPghx0FbUQ0AV8E7uqFpkuS1OcjzYuAazLz6sx8MDMvANYAH+yocmZ+ODM/l5n3ZuZvMvNiYDHw1tp6EbEncAPwj8DK3v0IkqTBqs9CMyKGAccCs9utmg0cX8euRgBPtSu7FFidmd/ufgslSepaX05ucAAwBFjbrnwt8IYqO4iIvwbGA9fVlL0ROAOYUnEf5wLnAowbN445c+YA0NTUxIgRI1i6dCkAY8aM4cgjj2TevHkADB06lGnTprFkyRKeeeYZAFpaWli7di1weJW33i20/X9MnjyZ1tZWHnroIQAmTJjA2LFjWbRoEQAjR45k6tSpzJ8/ny1btgAwffp0li1bxvr16wFobm5m48aNrFxZDP4nTpzI6NGjWbJkCQCjRo2iubmZuXPnkplEBDNmzGDp0qU89VTxd9HUqVPZsGEDq1evBqr300CyYMECWltbAZg2bRorVqxg3bp1wO7XTwPp2sO2n5Xhw4fT0tKy2/YTdHZ2bPezZs0ali9fDsAhhxzC+PHjWbhwIVBfP3UlMrMXP0LNG0WMAx4HpmfmXTXlnwTOzMxX7mT7d1CE5bsy8+ay7ADgl8C7M3NOWXYNcEBm/unO2tTS0pJt37S7whk1Go990pjsl8Zjn+woIhZnZktH6/pypPkksBU4qF35gew4+txOTWCe1RaYpcnAwcAdEdFWtke5zRbgyMxcvutNlySpD4+VZOZmiot4ZrZbNZPiKtoORcTpwPXA2Zn5vXarfwEcRXFotu3rZooraKcAq3qk8ZIk0fcTtl8OXBcR9wJ3A+cB44CrACLiWoDMPKtcfhfFCPMjwLyIaBulbs7MDZn5HHB/7RtExNPA0MzcrlySpF3Vp6GZmTdGxBjg4xSHVe8HTs7MR8oq7c9In0fRxivKrzZzgRN7t7WSJG2vzx8NlpmzgFmdrDuxq+WK+z+7O+2SJGlnBs7135Ik9TJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqqis0I+L0iHhjzfI/RcRjEXF7RBzc882TJKlx1DvS/FTbi4iYCvxf4F+APYEv91yzJElqPEPrrP9HwPLy9duAH2XmFyJiNnB7j7ZMkqQGU+9IcxMwonx9EnBH+fp/asolSRqQ6h1p3gV8OSLmAy3AaWX5y4Hf9mTDJElqNPWONP8G2EwRludl5u/K8jfj4VlJ0gBX10gzMx8DTumg/MIea5EkSQ2q7vs0I2LviDgtIj4aEfuXZYdHxOieb54kSY2j3vs0JwG/Bq4CLgXagvKDwBcq7uP8iFgVEZsiYnFEnNBF3YMj4j8i4tcRsTUirumk3ofLOi+U941+LSKG1/PZJEnamXpHmlcAs4GxwAs15TcDr9/ZxhFxBnAlcBlwDHAPcFtEHNrJJnsBTwKfAxZ2ss93UwT2pcCrgLOAk8v3kSSpx9R79ezxwHGZuTUiassfBcZV2P4i4JrMvLpcviAi3kQxUv1Y+8qZuRr4EEBEnNZ+fU2bfp6Z15XLqyPiWuAdFdojSVJl3Zl7ds8Oyg6luFezUxExDDiWYqRaazZF8HXXfGBKRBxXvs+hwKnAT3Zhn5Ik7aDekeZsitHi+8rljIiRwMXArTvZ9gBgCLC2Xfla4A11tmObzPzPiBgDzIti+DsUuA74aEf1I+Jc4FyAcePGMWfOHACampoYMWIES5cuBWDMmDEceeSRzJs3D4ChQ4cybdo0lixZwjPPPANAS0sLa9euBQ7vbvMbTtv/x+TJk2ltbeWhhx4CYMKECYwdO5ZFixYBMHLkSKZOncr8+fPZsmULANOnT2fZsmWsX78egObmZjZu3MjKlSsBmDhxIqNHj2bJkiUAjBo1iubmZubOnUtmEhHMmDGDpUuX8tRTTwEwdepUNmzYwOrVq4Hq/TSQLFiwgNbWVgCmTZvGihUrWLduHbD79dNAekZE28/K8OHDaWlp2W37qRjzDAxr1qxh+fJi0rpDDjmE8ePHs3BhcWavnn7qSmRm5QZFxDjgZ+ViE3AfMIki+KZn5hM72fbxst5dNeWfBM7MzFfu5L1vAZ7MzLPblc8AbgQ+TnHecxLF+cxrMvOfutpnS0tLtn3T7opzrtjlXTSMqwfIzUP2SWOyXxqPfbKjiFicmS0drav3Ps3fRcQU4ExgKsWfjd8AvpOZL3S5cXFBz1bgoHblB7Lj6LMelwA3ZOY3y+VfRcR+wDcj4tOZuWUX9i1J0jb1Hp6lDMd/K7/q2W5zRCwGZgLfrVk1E/h+ve2osS9FGNfaCkQHdSVJ6radhmZEvB34cWa+WL7uVGb+YCe7uxy4LiLuBe4GzqO46vaq8r2uLfdzVs37TylfjgReKpc3Z+YDZfmPgYsiYhF/ODz7GeAWR5mSpJ5UZaT5PYpDquvK151Jigt9Oq+QeWN50c7HgYOB+4GTM/ORskpHZ6Tva7d8CvAIMLFcvqR8788A4ykOA/8Y+Meu2iJJUr12GpqZuUdHr7srM2cBszpZd2IHZV0eZi1HkxeXX5Ik9Zp6p9GbHhE7BG1EDImI6T3XLEmSGk+9I8ef8Yf5Zmvtzx9uRZEkaUCqNzSD4vxhe2OA53a9OZIkNa5Kt5xExM3lywSuj4jaKROGAJMpJl+XJGnAqnqf5vry3wCeYvsnnGymmP/16vYbSZI0kFQKzcz8S4CIWA18KTM9FCtJGnTqnUbP2zokSYNWlRmBfgnMyMynIuJXdHwhEACZeXRPNk6SpEZSZaT5faDtwp+uZgSSJGlAqzIj0MUdvZYkabAZOE+ElSSpl1U5p9nlecxantOUJA1kVZ9yIknSoFfXOU1JkgYzz2lKklSR92lKklSR92lKklSR92lKklRRXXPPtomIw4FXlYsPZubDPdckSZIaU12hGRFjgG8BpwIv/aE4bgH+KjPXd7qxJEm7uXqvnv0mMAk4Adi7/JoOHIbP05QkDXD1Hp79E+CkzFxQU3Z3RHwAuKPnmiVJUuOpd6T5BNDRA6ifBzw0K0ka0OoNzU8DV0TEIW0F5esvl+skSRqwujNh+2HA6oh4vFw+BNgEHEhxzlOSpAHJCdslSarICdslSarICdslSaqortCMiGERcXFErIiITRGxtfartxopSVIjqHek+RngvRRXy74E/D3wNYrbTc7v2aZJktRY6g3N04HzMvPrwFbgpsz8EPBJYGZPN06SpEZSb2iOBR4oXz8L7F++/inwxp5qlCRJjaje0HwUGFe+/g3FtHoArwNe6KlGSZLUiOoNzR8CJ5WvrwQujohVwDU4sYEkaYCra8L2zPxYzevvRcRjwPHAisy8pacbJ0lSI+nWQ6jbZObPgZ/3UFskSWpodU9uEBFTI+LaiFhUfl0XEVN7o3GSJDWSeic3+HPgF8DBwE/Kr7HAvRHxnp5vniRJjaPew7OXAp/IzMtqCyPiY8AlwPU91TBJkhpNvYdnXwb8Vwfl36V4NJgkSQNWvaH5M+DEDspPBObuamMkSWpkVR5C/faaxduAz0ZEC3+4avY44O3Ap3q8dZIkNZDuPoT63PKr1leAWbvcIkmSGtROD89m5h4Vv4ZUecOIOD8iVpWPFlscESd0UffgiPiPiPh1+fixazqoc05E3BURGyLi6Yj4WURMq9IWSZLq0acPoY6IMyim37sMOAa4B7gtIg7tZJO9gCeBzwELO6lzInAjxfR+rwWWA7dHxBE913JJkro3ucFbImJeRDwZEU9ExNyIOLni5hcB12Tm1Zn5YGZeAKwBPthR5cxcnZkfysxrgA2d1PnzzPxqZt6XmcvLfW0E3lTvZ5MkqSv1Tm7wfopJ2x8GPgr8H2AV8MOI+KudbDsMOBaY3W7VbIr5a3vKMGBv4Kke3KckSXVPbvBR4KLM/GpN2bciYjFFgP5bF9seAAwB1rYrXwu8oc52dOUSimd93tyD+5Qkqe7QPJTigdPt3QZ8qeI+st1ydFDWLRHxYeADwBsy85lO6my78nfcuHHMmTMHgKamJkaMGMHSpUsBGDNmDEceeSTz5s0DYOjQoUybNo0lS5bwzDPFrltaWli7di1weE80vyG0/X9MnjyZ1tZWHnroIQAmTJjA2LFjWbRoEQAjR45k6tSpzJ8/ny1btgAwffp0li1bxvr16wFobm5m48aNrFy5EoCJEycyevRolixZAsCoUaNobm5m7ty5ZCYRwYwZM1i6dClPPVUcKJg6dSobNmxg9erVQPV+GkgWLFhAa2srANOmTWPFihWsW7cO2P36qY8vo+hVbT8rw4cPp6WlZbftp+LX+sCwZs0ali9fDsAhhxzC+PHjWbiwuBymnn7qSmRWz6uIeAi4PDP/tV35+cCFmfnyLrYdBjwPnJmZ360p/xowOTNn7OS9bwGezMyzO1n/YYpR5pszc36Vz9PS0pJt37S74pwrdnkXDePqC/u7BT3DPmlM9kvjsU92FBGLM7Olo3X1jjS/BHylfKrJPRQjxGnAXwAXdLVhZm4uD+POpJh2r81M4Pt1tmM7EXER8Gng5KqBKUlSvep9CPXXI2Id8HcUswABPAicnpk3VdjF5cB1EXEvcDdwHjAOuAogIq4t3+estg0iYkr5ciTwUrm8OTMfKNf/PcVE8u8BVkTEQWX9FzLzf+r5fJIkdaVyaEbEUOCNwLzM/GF33iwzb4yIMcDHKR4vdj/F6PCRskpHB9fva7d8CvAIMLFc/mtgT4p7NWt9Gzi7O+2UJKkjlUMzM7dExA+AVwLru/uGmTmLTqbby8wTOyiLnexvYnfbIklSPeq9lG0pMKk3GiJJUqOrNzQ/BXw5It4aERMiYnTtVy+0T5KkhlHv1bO3lv/+gO3vrWy717LSpO2SJO2O6g3N1/dKKyRJ2g1UCs2I2Bf4IvBWiitV7wA+lJlP9mLbJElqKFXPaV5McfvGrcANFBMS/GtXG0iSNNBUPTz7duB9mfmfABHxHeDuiBiSmVt7rXWSJDWQqiPNCcBdbQuZeS+whWI2H0mSBoWqoTkE2NyubAv1X0gkSdJuq2roBXB9RNQ+M2Vv4OqIeL6tIDNP7cnGSZLUSKqG5rc7KLu+JxsiSVKjqxSamfmXvd0QSZIa3cB5jLokSb3M0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5KkigxNSZIq6vPQjIjzI2JVRGyKiMURccJO6s8o622KiJURcV4HdQ6OiG9HxBNlvQciYkbvfQpJ0mDUp6EZEWcAVwKXAccA9wC3RcShndQ/DPhJWe8Y4LPAVyLiHTV19gfuBgJ4C/Aq4AJgXe99EknSYDS0j9/vIuCazLy6XL4gIt4EfBD4WAf1zwN+l5kXlMsPRsRrgY8A3y/L/gFYk5ln1Wy3quebLkka7PpspBkRw4BjgdntVs0Gju9ks9d1UP92oCUi9iyX3wosjIgbI2JdRPx3RPxNRERPtV2SJOjbkeYBwBBgbbvytcAbOtnmIOCODuoPLfe3BmgCzgf+GfgcMAX4Sln3q+13GBHnAucCjBs3jjlz5gDQ1NTEiBEjWLp0KQBjxozhyCOPZN68eQAMHTqUadOmsWTJEp555hkAWlpaWLt2LXD4zj/9bqLt/2Py5Mm0trby0EMPATBhwgTGjh3LokWLABg5ciRTp05l/vz5bNmyBYDp06ezbNky1q9fD0BzczMbN25k5cqVAEycOJHRo0ezZMkSAEaNGkVzczNz584lM4kIZsyYwdKlS3nqqacAmDp1Khs2bGD16tVA9X4aSBYsWEBraysA06ZNY8WKFaxbV5x92N36aSBde9j2szJ8+HBaWlp2236CDs+O7ZbWrFnD8uXLATjkkEMYP348CxcuBOrrp65EZvbiR6h5o4hxwOPA9My8q6b8k8CZmfnKDrZZAVyXmZ+pKZsBzAEOzszfR8RmYFFmHl9T5zLgbZn5qq7a1NLSkm3ftLvinCt2eRcN4+oL+7sFPcM+aUz2S+OxT3YUEYszs6WjdX35Z9+TwFaK0WOtA9lx9Nnm953U3wKsL5fXAA+0q/MgA+nPJ0lSQ+iz0MzMzcBiYGa7VTMpro7tyAJ2PHQ7k2Jk+WK5fDfwinZ1Xg480v3WSpK0o74+wXA5cHZEvD8iXhURVwLjgKsAIuLaiLi2pv5VwPiIuKKs/37gbOBLNXX+GTguIv4xIiZFxDuBDwFf64sPJEkaPPr0lpPMvDEixgAfBw4G7gdOzsy2UeGh7eqvioiTKYLxg8DvgA9l5vdr6vwiIt5Kce/nJ4BHy39n9fbnkSQNLn19nyaZOYtOAi0zT+ygbC4wdSf7vBW4tSfaJ0lSZwbO9d+SJPUyQ1OSpIoMTUmSKjI0JUmqyNCUJKkiQ1OSpIoMTUmSKjI0JUmqyNCUJKkiQ1OSpIoMTUmSKjI0JUmqyNCUJKkiQ1OSpIoMTUmSKjI0JUmqyNCUJKkiQ1OSpIoMTUmSKjI0JUmqyNCUJKkiQ1OSpIoMTUmSKjI0JUmqyNCUJKkiQ1OSpIoMTUmSKjI0JUmqyNCUJKkiQ1OSpIoMTUmSKjI0JUmqyNCUJKkiQ1OSpIoMTUmSKjI0JUmqyNCUJKkiQ1OSpIoMTUmSKjI0JUmqyNCUJKkiQ1OSpIoMTUmSKurz0IyI8yNiVURsiojFEXHCTurPKOttioiVEXHeru5TkqTu6NPQjIgzgCuBy4BjgHuA2yLi0E7qHwb8pKx3DPBZ4CsR8Y7u7lOSpO7q65HmRcA1mXl1Zj6YmRcAa4APdlL/POB3mXlBWf9q4NvAR3Zhn5IkdUufhWZEDAOOBWa3WzUbOL6TzV7XQf3bgZaI2LOb+5QkqVuG9uF7HQAMAda2K18LvKGTbQ4C7uig/tByf1HvPiPiXODccvHZiFhepfEN4ADgyd5+k2/+bW+/w4DT6/1in9TNn5XGtDv9rPxRZyv6MjTbZLvl6KBsZ/XbyqOLOh3uMzO/AXxj581sLBGxKDNb+rsd2p790njsk8Y0UPqlL0PzSWArxeix1oHsOFJs8/tO6m8B1lOEY737lCSpW/rsnGZmbgYWAzPbrZpJccVrRxaw42HWmcCizHyxm/uUJKlb+vrw7OXAdRFxL3A3xdWx44CrACLiWoDMPKusfxXwNxFxBfB14H8DZwNnVt3nALLbHVIeJOyXxmOfNKYB0S+R2dXpxF54w4jzgX8ADgbuB/42M+eV6+YAZOaJNfVnAP8MHAn8Dvh8Zl5VdZ+SJPWUPg9NSZJ2V849K0lSRYamJEkVGZqSJFVkaEoaMCIiav+VepoXAjWwiBgPTKKYxOElYHlm/r5/WyXtPtrCM/1Fpx5iaDaoiPgg8FdAM/Ac8BvgMYoJH27KzOURsUdmvtSPzRxUImKfzHyhv9uhHUXEHsCfAS8D9gUeB+Zm5rp+bZgGHEOzAUXEGIqQ/DLwrxS/CN4AvB54JcUvhAsz84GICP+K7n0RMQpYCtwKXA/c0/b/XtsHEfFKisfZPdNvjR1kImIE8C2Kn4+XKP64TOAFYC5wfWb+2p+VvhMRewKHAY9kZmt/t6cneU6zMb0bWJGZl2Tm+sz8dWZ+NTPfAXwA2Ae4JSIO8JdAn3kPMJbiUXTzgN9ExKcj4hU1gTkBuIHiaQ7qOx8CXgGcnJljgT8HrgCWAX8CfCEiXubPSp/6a+A+4KqIOCUiDoqIIbUVImJkRLy5DNjdhqHZmDYDIyJiMkBE7FU+O5TMnE/xS2ET8Mb+a+KgczTw78CfAscA/0UxneMDEfHz8pFz7wGOyMyV/dfMQelNwLcz8xcA5R+Z11P84v474FXAdf3YvsHoDOBeimsyfkRxWumLETEtIv5XWefdwCcz88V+amO3GJqN6XsUh5kujIgRmdmamZvL8zZk5qPA08D4/mzkYBERewEPAL/NzHWZ+cvM/BjQQjGSeQD4FHAp8Pl+a+ggFBFDKabOfEdEvKwsGxIRQzJzazmd5nnA+Iho7s+2DhZlP7wIXJ2ZJ1A8m/JbFH9wzgPujIiPAhcCC/utod3kOc0GU3Op/J8BVwKjKUY1sygOd4wHplOc6zwqM1f3QzMHnTI4R2Xm78vDTFl7EVZEnAjcCRyamY/1UzMHpYg4DvgOxR+bl+OoNGAAAANOSURBVGfm2nbrJwAPAq/IzMf7oYmDSkQcDLwLeCAzb2+37hjg/eX6UcCE3a1PDM0GFRH7A4cCxwNvo3jCCxTPGN0DuDYzP9U/rRtc2i4giYgm4LnaX8o16/4JODszm/qvpYNPefRlD+Avgcsontz0PeBG4LcUh9VPAV6Vma/pr3YONhGxD8Uflptq75mtOf9/KcU56GP6q43dZWg2kIg4EPgLivMwT1Jc/fc0cBfFYYw9gcOB24GHvLCh99X0yUXAOooHoK8Bvgv8IDOfK38pnENx1ewt/dbYQa78Q/NsinNlU4CNQCvFubXPZuZudyhwd9bZ1coRsS+wBPj3zNztTmcYmg0kIq6heATaj4ENFIdmjwJeTvEL++P+4PetTvrkGIpbfx4DvpiZs/utgYNYRIwENtb+Yi5HnnsDw4HJFEcG/JnpIx31SQd19qa4UOiGzNzcZ43rIYZmgyhHKxspDlnMqyk7FDgOeB/QBJyemUv6raGDSBd9MgF4LcXo8o+AM+2TvhcRX6cYRd5LcT/gDvfGRsSozHzKezT7RsU+2T8zn+7zxvUQr55tHK8GVlHcbgIUx/8z85HMvJHivMzTwDv7qX2DUWd98mhmfpfiasCN2Cd9LiLOpPij5cvATRS3M7w9IiaV59OIiOHAv0fEUQZm7+ukT94WEYfX9Mk+wLfbbqfbHTnSbBDlN9MtFFOAnQU83H6KvIi4AHhfZk7phyYOOvZJ44qIq4GtwBeAtwPvpTjfvxz4CfD/KCY8uDIzh/VXOweTwdInjjQbRDmn6T9SzPZzLXBWREyIiP1g28nzGRT3pKkP2CeNqbw3cxXwdGauzMwvZeZRwGsops17L8VtWl/BSQ36xGDqE0eaDaY8bPEJ4FSKidoXAE9QzD27Bnh/Zv6q/1o4+NgnjaecC3hsOafsMODFdhcEnUExpeHUzPzv/mrnYDJY+sTQbFDlrQ5vAd5KMWXe/cB3M/PX/dqwQcw+aWzllbORmVsj4hyKw4D79ne7BrOB2CeG5m4gfARYw7FPGltEXAQMycwv9ndbVBgofWJoShpwyidnbPUPm8YxUPrE0JQkqSKvnpUkqSJDU5KkigxNSZIqMjQlSarI0JQkqSJDU5Kkiv4/Jia34UdHB+oAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histogram(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix:\n",
      " [[1, 1], [0, 2]] \n",
      "\n",
      "Expected Eigen Values: [1. 2.]\n",
      "\n",
      "Counts: {'00': 0.03125, '01': 0.005361652351682, '11': 0.005361652351682, '10': 0.016084957055045}\n",
      "\n",
      "Actual Eigen Value from Circuit:\n",
      "Binary: 00  Corresponding Eigen Value: 0.0\n",
      "Binary: 01  Corresponding Eigen Value: 2.0\n",
      "Binary: 11  Corresponding Eigen Value: 3.0\n",
      "Binary: 10  Corresponding Eigen Value: 1.0\n"
     ]
    }
   ],
   "source": [
    "A = [[1, 1], [0, 2]]\n",
    "\n",
    "print('Matrix:\\n',A,'\\n')\n",
    "count,circuit=execute_eigs(matrix=A,nqubits=2,negativeEigen=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix:\n",
      " [[1.5, 0], [0, 0.5]] \n",
      "\n",
      "Expected Eigen Values: [1.5 0.5]\n",
      "\n",
      "Counts: {'10': 0.5, '01': 0.5}\n",
      "\n",
      "Actual Eigen Value from Circuit:\n",
      "Binary: 10  Corresponding Eigen Value: 0.5\n",
      "Binary: 01  Corresponding Eigen Value: 1.0\n"
     ]
    }
   ],
   "source": [
    "A = [[1.5, 0], [0, 0.5]]\n",
    "\n",
    "print('Matrix:\\n',A,'\\n')\n",
    "count,circuit=execute_eigs(matrix=A,nqubits=2,negativeEigen=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix:\n",
      " [[1, -0.5], [-0.5, 1]] \n",
      "\n",
      "Expected Eigen Values: [1.5 0.5]\n",
      "\n",
      "Counts: {'11': 0.500000000000001, '10': 0.500000000000001}\n",
      "\n",
      "Actual Eigen Value from Circuit:\n",
      "Binary: 11  Corresponding Eigen Value: 1.5\n",
      "Binary: 10  Corresponding Eigen Value: 0.5\n"
     ]
    }
   ],
   "source": [
    "A = [[1, -0.5], [-0.5, 1]]\n",
    "\n",
    "print('Matrix:\\n',A,'\\n')\n",
    "count,circuit=execute_eigs(matrix=A,nqubits=2,negativeEigen=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix:\n",
      " [[0.69, 0.49], [0.49, 0.92]] \n",
      "\n",
      "Expected Eigen Values: [0.30168598 1.30831402]\n",
      "\n",
      "Counts: {'101': 0.023635946863532, '100': 0.025764378057297, '001': 0.029359074130578, '000': 0.01045216143069, '110': 0.003574353083768, '111': 0.005822658642364, '010': 0.012212043999822, '011': 0.004488579357237}\n",
      "\n",
      "Actual Eigen Value from Circuit:\n",
      "Binary: 101  Corresponding Eigen Value: 1.0071428571428571\n",
      "Binary: 100  Corresponding Eigen Value: 0.20142857142857143\n",
      "Binary: 001  Corresponding Eigen Value: 0.8057142857142857\n",
      "Binary: 000  Corresponding Eigen Value: 0.0\n",
      "Binary: 110  Corresponding Eigen Value: 0.6042857142857142\n",
      "Binary: 111  Corresponding Eigen Value: 1.41\n",
      "Binary: 010  Corresponding Eigen Value: 0.40285714285714286\n",
      "Binary: 011  Corresponding Eigen Value: 1.2085714285714284\n"
     ]
    }
   ],
   "source": [
    "A = [[0.69, 0.49], [0.49, 0.92]]\n",
    "\n",
    "print('Matrix:\\n',A,'\\n')\n",
    "count,circuit=execute_eigs(matrix=A,nqubits=3,negativeEigen=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## QPE for finite difference matrix 2*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix:\n",
      " [[2, -1], [-1, 2]] \n",
      "\n",
      "Expected Eigen Values: [3. 1.]\n",
      "\n",
      "Counts: {'11': 0.500000000000001, '10': 0.500000000000001}\n",
      "\n",
      "Actual Eigen Value from Circuit:\n",
      "Binary: 11  Corresponding Eigen Value: 3.0\n",
      "Binary: 10  Corresponding Eigen Value: 1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [[2, -1], [-1, 2]]\n",
    "\n",
    "print('Matrix:\\n',A,'\\n')\n",
    "count,circuit=execute_eigs(matrix=A,nqubits=2,negativeEigen=False)\n",
    "plot_histogram(count)"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}