Quantum_Subset_Sum_Problem.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.axes as axes\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import networkx as nx\n",
    "from qiskit import BasicAer\n",
    "from qiskit.tools.visualization import plot_histogram\n",
    "from qiskit.aqua import run_algorithm\n",
    "from qiskit.aqua.input import EnergyInput\n",
    "from qiskit.aqua.translators.ising import max_cut, tsp\n",
    "from qiskit.aqua.algorithms import VQE, ExactEigensolver, QAOA\n",
    "from qiskit.aqua.components.optimizers import SPSA\n",
    "from qiskit.aqua.components.variational_forms import RY\n",
    "from qiskit.aqua import QuantumInstance\n",
    "from docplex.mp.model import Model\n",
    "from qiskit.aqua.translators.ising import docplex\n",
    "from pyqubo import Binary, solve_ising,Constraint\n",
    "import numpy as np\n",
    "# setup aqua logging\n",
    "import logging\n",
    "from qiskit.aqua import set_qiskit_aqua_logging\n",
    "import time\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function to take input and return the qubo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quboformation():\n",
    "    # # Define hamiltonian\n",
    "    k=int(input(\"enter required sum : \"))\n",
    "    n=int(input(\"enter # of elements in set : \"))\n",
    "    a=np.zeros((n))\n",
    "    q=0\n",
    "    s={i:'s%d' %i for i in range (n)}\n",
    "    z={i:'s%d' %i for i in range (n)}\n",
    "    for i in range(0,n):\n",
    "        a[i]=int(input(\"element \" + str(i+1)+ \" : \"))\n",
    "        s[i]=Binary(\"s{}\".format(i))\n",
    "    for i in range(0,n):\n",
    "        q=q+s[i]*a[i]\n",
    "    H=(k-q)**2\n",
    "\n",
    "    # Create Ising model\n",
    "    model = H.compile()\n",
    "    linear, quad,offset = model.to_ising()\n",
    "\n",
    "    # Solve Ising model\n",
    "    solution = solve_ising(linear, quad)\n",
    "    solution \n",
    "\n",
    "    model = H.compile()\n",
    "\n",
    "    qubo, offset = model.to_qubo()\n",
    "    i=0\n",
    "    j=1\n",
    "    z=-1\n",
    "    arr = np.zeros((n,n))\n",
    "    for x in qubo:\n",
    "        if(j<n and z==-1):\n",
    "            arr[i][j] = qubo[x]\n",
    "            j=j+1\n",
    "        elif (i<n-2 and z==-1):\n",
    "            i = i+1\n",
    "            j=i+1\n",
    "            arr[i][j] = qubo[x]\n",
    "            j=j+1\n",
    "        else:\n",
    "            z=z+1\n",
    "            arr[z][z] = qubo[x]        \n",
    "    return arr,offset,n,k,a,qubo\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Qubo Formation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter required sum : 4\n",
      "enter # of elements in set : 3\n",
      "element 1 : 2\n",
      "element 2 : 2\n",
      "element 3 : 4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<qiskit.aqua.operators.weighted_pauli_operator.WeightedPauliOperator at 0x1a2ee97630>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create an instance of a model and variables.\n",
    "mdl = Model(name='max_cut')\n",
    "arr,offset,n,k,a,qubo = quboformation()\n",
    "s={i:'s%d' %i for i in range (n)}\n",
    "for i in range(n):\n",
    "    s[i]=mdl.binary_var(\"s{}\".format(i))\n",
    "subset_sum_func=offset\n",
    "for i in range(n):\n",
    "    for j in range(n):\n",
    "        subset_sum_func=subset_sum_func+s[i]*s[j]*arr[i][j]\n",
    "mdl.minimize(subset_sum_func) \n",
    "qubitOp, offset = docplex.get_qubitops(mdl)  \n",
    "qubitOp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# VQE Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "Objective -6.0\n",
      "solution [0. 0. 1.]\n",
      "energy: -6.0\n",
      "obj sol 0.0\n",
      "\n",
      "\n",
      "Objective -6.0\n",
      "solution [1. 1. 0.]\n",
      "energy: -6.0\n",
      "obj sol 0.0\n",
      "\n",
      "\n",
      "Objective -6.0\n",
      "solution [0. 1. 1.]\n",
      "energy: -6.0\n",
      "obj sol 4.0\n",
      "\n",
      "\n",
      "Objective -6.0\n",
      "solution [1. 0. 1.]\n",
      "energy: -6.0\n",
      "obj sol 4.0\n",
      "\n",
      "\n",
      "Objective -6.0\n",
      "solution [0. 1. 0.]\n",
      "energy: -6.0\n",
      "obj sol 4.0\n",
      "\n",
      "\n",
      "Objective -6.0\n",
      "solution [1. 0. 0.]\n",
      "energy: -6.0\n",
      "obj sol 4.0\n",
      "\n",
      "\n",
      "Objective -6.0\n",
      "solution [1. 1. 1.]\n",
      "energy: -6.0\n",
      "obj sol 16.0\n",
      "\n",
      "\n",
      "Objective -6.0\n",
      "solution [0. 0. 0.]\n",
      "energy: -6.0\n",
      "obj sol 16.0\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "ee = ExactEigensolver(qubitOp, k=70)\n",
    "result = ee.run()\n",
    "\n",
    "\"\"\"\n",
    "algorithm_cfg = {\n",
    "    'name': 'ExactEigensolver',\n",
    "}\n",
    "\n",
    "params = {\n",
    "    'problem': {'name': 'ising'},\n",
    "    'algorithm': algorithm_cfg\n",
    "}\n",
    "result = run_algorithm(params,algo_input)\n",
    "\"\"\"\n",
    "print(2^n)\n",
    "for i in range(0,(2**n)):\n",
    "    x = max_cut.sample_most_likely(result['eigvecs'][i])\n",
    "    obj=0\n",
    "    for i in range(n):\n",
    "        obj=obj+ a[i]*x[i]\n",
    "    obj=(k-obj)**2\n",
    "    print('Objective',result['energy'])\n",
    "    print('solution',max_cut.get_graph_solution(x))\n",
    "    print('energy:', result['energy'])\n",
    "    print('obj sol',obj)\n",
    "    print('\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Choosing the Best Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "energy: -5.999999999809184\n",
      "time: 4.745990037918091\n",
      "max-cut objective: 1.908162516883749e-10\n",
      "solution: [1. 1. 0.]\n",
      "solution objective:  0.0\n",
      "energy: -5.987014432589905\n",
      "time: 10.774800777435303\n",
      "max-cut objective: 0.012985567410095378\n",
      "solution: [0. 0. 1.]\n",
      "solution objective:  0.0\n",
      "energy: -5.999912477412746\n",
      "time: 15.86035418510437\n",
      "max-cut objective: 8.752258725408524e-05\n",
      "solution: [0. 0. 1.]\n",
      "solution objective:  0.0\n",
      "energy: -5.999979471956303\n",
      "time: 21.133850812911987\n",
      "max-cut objective: 2.052804369689909e-05\n",
      "solution: [0. 0. 1.]\n",
      "solution objective:  0.0\n",
      "energy: -5.999941929938581\n",
      "time: 26.602831840515137\n",
      "max-cut objective: 5.807006141900217e-05\n",
      "solution: [1. 1. 0.]\n",
      "solution objective:  0.0\n",
      "energy: -5.999931187075165\n",
      "time: 32.392581939697266\n",
      "max-cut objective: 6.8812924834738e-05\n",
      "solution: [1. 1. 0.]\n",
      "solution objective:  0.0\n",
      "energy: -5.999801385459059\n",
      "time: 38.71550178527832\n",
      "max-cut objective: 0.00019861454094094455\n",
      "solution: [0. 0. 1.]\n",
      "solution objective:  0.0\n",
      "energy: -5.999725046878155\n",
      "time: 43.49963116645813\n",
      "max-cut objective: 0.0002749531218446677\n",
      "solution: [0. 0. 1.]\n",
      "solution objective:  0.0\n",
      "energy: -5.999889391540685\n",
      "time: 50.34232687950134\n",
      "max-cut objective: 0.00011060845931520902\n",
      "solution: [1. 1. 0.]\n",
      "solution objective:  0.0\n",
      "energy: -5.999646485354692\n",
      "time: 54.77347707748413\n",
      "max-cut objective: 0.000353514645308195\n",
      "solution: [0. 0. 1.]\n",
      "solution objective:  0.0\n"
     ]
    }
   ],
   "source": [
    "var = 10\n",
    "arr1 = []\n",
    "arr2 =[]\n",
    "for i in range(var):\n",
    "    seed = 10598\n",
    "\n",
    "    spsa = SPSA(max_trials=300)\n",
    "    ry = RY(qubitOp.num_qubits, depth=i, entanglement='linear')\n",
    "    vqe = VQE(qubitOp, ry, spsa)\n",
    "\n",
    "    backend = BasicAer.get_backend('statevector_simulator')\n",
    "    quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed)\n",
    "\n",
    "    result = vqe.run(quantum_instance)\n",
    "\n",
    "    \"\"\"declarative approach\n",
    "    algorithm_cfg = {\n",
    "        'name': 'VQE'\n",
    "    }\n",
    "\n",
    "    optimizer_cfg = {\n",
    "        'name': 'SPSA',\n",
    "        'max_trials': 300\n",
    "    }\n",
    "\n",
    "    var_form_cfg = {\n",
    "        'name': 'RY',\n",
    "        'depth': 5,\n",
    "        'entanglement': 'linear'\n",
    "    }\n",
    "\n",
    "    params = {\n",
    "        'problem': {'name': 'ising', 'random_seed': seed},\n",
    "        'algorithm': algorithm_cfg,\n",
    "        'optimizer': optimizer_cfg,\n",
    "        'variational_form': var_form_cfg,\n",
    "        'backend': {provider': 'qiskit.BasicAer', 'name': 'statevector_simulator'}\n",
    "    }\n",
    "\n",
    "    result = run_algorithm(params, algo_input)\n",
    "    \"\"\"\n",
    "\n",
    "    x = max_cut.sample_most_likely(result['eigvecs'][0])\n",
    "    obj=0\n",
    "    for i in range(n):\n",
    "        obj=obj+ a[i]*x[i]\n",
    "    obj=(k-obj)**2\n",
    "    print('energy:', result['energy'])\n",
    "    print('time:', result['eval_time'])\n",
    "    print('max-cut objective:', result['energy'] + offset)\n",
    "    print('solution:', max_cut.get_graph_solution(x))\n",
    "    print('solution objective: ', obj)\n",
    "    arr1.append(result['eval_time'])\n",
    "    arr2.append(result['energy'] + offset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting Graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'SubSet-Sum Objective')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(arr2)\n",
    "plt.xlabel(\"Depth\")\n",
    "plt.ylabel(\"SubSet-Sum Objective\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Drawing Circuit (Depth =10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "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",
       "q_0: |0>┤ U3(-3.8375,0,0) ├─░───────────────■────────────────────────────────░─»\n",
       "        ├─────────────────┤ ░ ┌──────────┐┌─┴─┐┌──────────┐                  ░ »\n",
       "q_1: |0>┤ U3(-4.5651,0,0) ├─░─┤ U2(0,pi) ├┤ X ├┤ U2(0,pi) ├──■───────────────░─»\n",
       "        ├─────────────────┤ ░ ├──────────┤└───┘└──────────┘┌─┴─┐┌──────────┐ ░ »\n",
       "q_2: |0>┤ U3(-2.4803,0,0) ├─░─┤ U2(0,pi) ├─────────────────┤ X ├┤ U2(0,pi) ├─░─»\n",
       "        └─────────────────┘ ░ └──────────┘                 └───┘└──────────┘ ░ »\n",
       "«      ┌────────────────┐  ░                                                ░ »\n",
       "«q_0: ─┤ U3(1.9027,0,0) ├──░───────────────■────────────────────────────────░─»\n",
       "«     ┌┴────────────────┴┐ ░ ┌──────────┐┌─┴─┐┌──────────┐                  ░ »\n",
       "«q_1: ┤ U3(-0.57048,0,0) ├─░─┤ U2(0,pi) ├┤ X ├┤ U2(0,pi) ├──■───────────────░─»\n",
       "«     └┬────────────────┬┘ ░ ├──────────┤└───┘└──────────┘┌─┴─┐┌──────────┐ ░ »\n",
       "«q_2: ─┤ U3(0.7902,0,0) ├──░─┤ U2(0,pi) ├─────────────────┤ X ├┤ U2(0,pi) ├─░─»\n",
       "«      └────────────────┘  ░ └──────────┘                 └───┘└──────────┘ ░ »\n",
       "«     ┌─────────────────┐ ░                                                ░ »\n",
       "«q_0: ┤ U3(0.93171,0,0) ├─░───────────────■────────────────────────────────░─»\n",
       "«     ├─────────────────┤ ░ ┌──────────┐┌─┴─┐┌──────────┐                  ░ »\n",
       "«q_1: ┤ U3(-5.0044,0,0) ├─░─┤ U2(0,pi) ├┤ X ├┤ U2(0,pi) ├──■───────────────░─»\n",
       "«     └┬────────────────┤ ░ ├──────────┤└───┘└──────────┘┌─┴─┐┌──────────┐ ░ »\n",
       "«q_2: ─┤ U3(3.8371,0,0) ├─░─┤ U2(0,pi) ├─────────────────┤ X ├┤ U2(0,pi) ├─░─»\n",
       "«      └────────────────┘ ░ └──────────┘                 └───┘└──────────┘ ░ »\n",
       "«      ┌────────────────┐ ░                                                ░ »\n",
       "«q_0: ─┤ U3(2.7544,0,0) ├─░───────────────■────────────────────────────────░─»\n",
       "«      ├────────────────┤ ░ ┌──────────┐┌─┴─┐┌──────────┐                  ░ »\n",
       "«q_1: ─┤ U3(1.4167,0,0) ├─░─┤ U2(0,pi) ├┤ X ├┤ U2(0,pi) ├──■───────────────░─»\n",
       "«     ┌┴────────────────┤ ░ ├──────────┤└───┘└──────────┘┌─┴─┐┌──────────┐ ░ »\n",
       "«q_2: ┤ U3(-2.4245,0,0) ├─░─┤ U2(0,pi) ├─────────────────┤ X ├┤ U2(0,pi) ├─░─»\n",
       "«     └─────────────────┘ ░ └──────────┘                 └───┘└──────────┘ ░ »\n",
       "«      ┌───────────────┐   ░                                                ░ »\n",
       "«q_0: ─┤ U3(1.755,0,0) ├───░───────────────■────────────────────────────────░─»\n",
       "«     ┌┴───────────────┴─┐ ░ ┌──────────┐┌─┴─┐┌──────────┐                  ░ »\n",
       "«q_1: ┤ U3(-0.35261,0,0) ├─░─┤ U2(0,pi) ├┤ X ├┤ U2(0,pi) ├──■───────────────░─»\n",
       "«     ├─────────────────┬┘ ░ ├──────────┤└───┘└──────────┘┌─┴─┐┌──────────┐ ░ »\n",
       "«q_2: ┤ U3(-5.6528,0,0) ├──░─┤ U2(0,pi) ├─────────────────┤ X ├┤ U2(0,pi) ├─░─»\n",
       "«     └─────────────────┘  ░ └──────────┘                 └───┘└──────────┘ ░ »\n",
       "«      ┌────────────────┐ ░                                                ░ »\n",
       "«q_0: ─┤ U3(1.0826,0,0) ├─░───────────────■────────────────────────────────░─»\n",
       "«     ┌┴────────────────┤ ░ ┌──────────┐┌─┴─┐┌──────────┐                  ░ »\n",
       "«q_1: ┤ U3(-0.4697,0,0) ├─░─┤ U2(0,pi) ├┤ X ├┤ U2(0,pi) ├──■───────────────░─»\n",
       "«     └┬────────────────┤ ░ ├──────────┤└───┘└──────────┘┌─┴─┐┌──────────┐ ░ »\n",
       "«q_2: ─┤ U3(3.2919,0,0) ├─░─┤ U2(0,pi) ├─────────────────┤ X ├┤ U2(0,pi) ├─░─»\n",
       "«      └────────────────┘ ░ └──────────┘                 └───┘└──────────┘ ░ »\n",
       "«      ┌────────────────┐ ░                                                ░ »\n",
       "«q_0: ─┤ U3(-4.384,0,0) ├─░───────────────■────────────────────────────────░─»\n",
       "«     ┌┴────────────────┤ ░ ┌──────────┐┌─┴─┐┌──────────┐                  ░ »\n",
       "«q_1: ┤ U3(-1.0967,0,0) ├─░─┤ U2(0,pi) ├┤ X ├┤ U2(0,pi) ├──■───────────────░─»\n",
       "«     └┬────────────────┤ ░ ├──────────┤└───┘└──────────┘┌─┴─┐┌──────────┐ ░ »\n",
       "«q_2: ─┤ U3(-2.807,0,0) ├─░─┤ U2(0,pi) ├─────────────────┤ X ├┤ U2(0,pi) ├─░─»\n",
       "«      └────────────────┘ ░ └──────────┘                 └───┘└──────────┘ ░ »\n",
       "«      ┌────────────────┐ ░                                                ░ »\n",
       "«q_0: ─┤ U3(1.8841,0,0) ├─░───────────────■────────────────────────────────░─»\n",
       "«     ┌┴────────────────┤ ░ ┌──────────┐┌─┴─┐┌──────────┐                  ░ »\n",
       "«q_1: ┤ U3(-5.0478,0,0) ├─░─┤ U2(0,pi) ├┤ X ├┤ U2(0,pi) ├──■───────────────░─»\n",
       "«     ├─────────────────┤ ░ ├──────────┤└───┘└──────────┘┌─┴─┐┌──────────┐ ░ »\n",
       "«q_2: ┤ U3(0.11969,0,0) ├─░─┤ U2(0,pi) ├─────────────────┤ X ├┤ U2(0,pi) ├─░─»\n",
       "«     └─────────────────┘ ░ └──────────┘                 └───┘└──────────┘ ░ »\n",
       "«     ┌─────────────────┐ ░                                                ░ »\n",
       "«q_0: ┤ U3(-6.2084,0,0) ├─░───────────────■────────────────────────────────░─»\n",
       "«     ├─────────────────┤ ░ ┌──────────┐┌─┴─┐┌──────────┐                  ░ »\n",
       "«q_1: ┤ U3(0.94353,0,0) ├─░─┤ U2(0,pi) ├┤ X ├┤ U2(0,pi) ├──■───────────────░─»\n",
       "«     ├─────────────────┤ ░ ├──────────┤└───┘└──────────┘┌─┴─┐┌──────────┐ ░ »\n",
       "«q_2: ┤ U3(-2.0448,0,0) ├─░─┤ U2(0,pi) ├─────────────────┤ X ├┤ U2(0,pi) ├─░─»\n",
       "«     └─────────────────┘ ░ └──────────┘                 └───┘└──────────┘ ░ »\n",
       "«     ┌──────────────────┐ ░ \n",
       "«q_0: ┤ U3(-0.21523,0,0) ├─░─\n",
       "«     ├─────────────────┬┘ ░ \n",
       "«q_1: ┤ U3(-3.4164,0,0) ├──░─\n",
       "«     └┬────────────────┤  ░ \n",
       "«q_2: ─┤ U3(1.1595,0,0) ├──░─\n",
       "«      └────────────────┘  ░ </pre>"
      ],
      "text/plain": [
       "<qiskit.visualization.text.TextDrawing at 0x1a2f09b128>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cct = vqe.construct_circuit(result['opt_params'], statevector_mode=True)[0]\n",
    "cct.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DWAVE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chain Strength :  4\n",
      "{'s0': 0, 's1': 0, 's2': 1} Energy:  -16.0 Occurrences:  3106\n",
      "{'s0': 1, 's1': 1, 's2': 0} Energy:  -16.0 Occurrences:  1888\n",
      "{'s0': 0, 's1': 1, 's2': 0} Energy:  -12.0 Occurrences:  2\n",
      "{'s0': 1, 's1': 0, 's2': 1} Energy:  -12.0 Occurrences:  1\n",
      "{'s0': 0, 's1': 1, 's2': 1} Energy:  -12.0 Occurrences:  2\n",
      "{'s0': 1, 's1': 0, 's2': 1} Energy:  -12.0 Occurrences:  1\n"
     ]
    }
   ],
   "source": [
    "from dwave.system.samplers import DWaveSampler\n",
    "from dwave.system.composites import EmbeddingComposite\n",
    "sampler = DWaveSampler(endpoint='https://cloud.dwavesys.com/sapi', solver='DW_2000Q_2_1')\n",
    "sampler_embedded = EmbeddingComposite(sampler)\n",
    "\n",
    "Q = qubo\n",
    "total_occur = []\n",
    "time_sec = []\n",
    "\n",
    "for c in range(10):\n",
    "    total_occur.append(0)\n",
    "    t1 = time.time()\n",
    "    response = sampler_embedded.sample_qubo(Q, num_reads=5000,chain_strength=c)\n",
    "    time_sec.append(time.time()-t1)\n",
    "    x=[]\n",
    "    ene = []\n",
    "    occ=[]\n",
    "    if(c==4):\n",
    "        print(\"Chain Strength : \",c)\n",
    "    for datum in response.data(['sample', 'energy', 'num_occurrences']):   \n",
    "        x.append(datum.sample)\n",
    "        ene.append(datum.energy)\n",
    "        occ.append(datum.num_occurrences)\n",
    "        if (c==4):\n",
    "            print(datum.sample, \"Energy: \", datum.energy, \"Occurrences: \", datum.num_occurrences)\n",
    "    z={i:'s%d' %i for i in range (n)}\n",
    "    sum =[]\n",
    "    for i in range(len(x)):\n",
    "        sum.append(0)\n",
    "        for j in range(n):\n",
    "            if(x[i][z[j]]==1):\n",
    "                sum[i]+= a[j]\n",
    "        if(sum[i]==k):\n",
    "            total_occur[c]+=occ[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting Graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Number of Occurances')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(total_occur)\n",
    "plt.xlabel(\"Chain Strength\")\n",
    "plt.ylabel(\"Number of Occurances\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Processing Time')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(time_sec)\n",
    "plt.xlabel(\"Chain Strength\")\n",
    "plt.ylabel(\"Processing Time\")"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}