Circuit Decomposition for Hardware-Efficient VQE-2020-02-02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Circuit Decomposition for Hardware-Efficient VQE#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quantum computing is a promising technology for various applications like quantum optimization, quantum machine learning, and quantum chemistry. However, with the limited number of qubits, the limited depth of circuit, and high error rate in the two-qubit gate, near-term quantum circuits can be challenging to maintain the resultant quantum state meaningful. Such limitations severely hinders the practical applications and commercialization of quantum technology. Therefore, it's ideal to reduce the number of qubits requirement for quantum algorithms to run on the near term quantum device. In this project, we apply the quantum circuit decomposition in IBM Q Experience to demonstrate the idea of reducing the qubit number requirement for realizing the quantum optimization with VQE solver. With max-cut problem to solve, we successfully run the VQE solver on a 3 qubits circuit that, in essence, requires 4 qubits. Our circuit decomposition method is general, not bounded by the algorithms to run or number of qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Credentials are already in use. The existing account in the session will be replaced.\n"
     ]
    }
   ],
   "source": [
    "# import qiskit and other useful python modules\n",
    "%matplotlib inline\n",
    "\n",
    "#import math tools\n",
    "import numpy as np\n",
    "# We import the tools to handle general Graphs\n",
    "import networkx as nx\n",
    "# We import plotting tools \n",
    "import matplotlib.pyplot as plt \n",
    "from   matplotlib import cm\n",
    "from   matplotlib.ticker import LinearLocator, FormatStrFormatter\n",
    "# importing Qiskit\n",
    "import qiskit as qk\n",
    "import collections\n",
    "import time\n",
    "from qiskit.visualization import plot_histogram\n",
    "\n",
    "\n",
    "# get simularto and IBMQ backends\n",
    "qk.IBMQ.load_account()\n",
    "provider = qk.IBMQ.get_provider(group='open')\n",
    "# Run the quantum circuit on a specific backend\n",
    "# BACKEND1 = provider.get_backend('ibmq_burlington')\n",
    "BACKEND1 = qk.Aer.get_backend('qasm_simulator')\n",
    "BACKEND2 = qk.Aer.get_backend('qasm_simulator')\n",
    "backend = qk.Aer.get_backend('qasm_simulator')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Config Parameters and Constants##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "PI = np.pi\n",
    "NSHOTS = 1024 # number of measurements for each quantum circuit\n",
    "SEED = int(time.time()) # Random seed for running cicuits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function Definitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the projective ZmZn measurement value on result string qbs\n",
    "def get_ZZ(qbs, pair):\n",
    "    '''\n",
    "    qbs: qubit string i.e. \"0010\"\n",
    "    pair: ZmZn i.e. (0,1)\n",
    "    '''\n",
    "    qbs_r = qbs[::-1]\n",
    "    return -((qbs_r[pair[0]] != qbs_r[pair[1]])-.5) * 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the objective value of the edge pair on result string qbs\n",
    "def get_max_cut_value(qbs, pair):\n",
    "    '''\n",
    "    qbs: qubit string i.e. \"0010\"\n",
    "    pair: ZmZn i.e. (0,1)\n",
    "    '''\n",
    "    qbs_r = qbs[::-1]\n",
    "    return (qbs_r[pair[0]] != qbs_r[pair[1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate the original, unreduced version of the max-cut quantum circuit for VQE\n",
    "def make_maxcut_circuit(n, depth, thetas):\n",
    "    '''\n",
    "    n: number of qubits:\n",
    "    depth: number of entanglements; \n",
    "    thetas: the control parameters for VQE; dimension = (n,depth)\n",
    "    '''\n",
    "    # parameter sanity check: check if the dimension is okay\n",
    "    if isinstance(thetas, collections.Iterable) and len(thetas) >= n:\n",
    "        for idx in range(n):\n",
    "            if isinstance(thetas[idx], collections.Iterable) and len(thetas) >= depth: \n",
    "                pass\n",
    "            else:\n",
    "                raise TypeError(\"thetas[%d] is not an iterable or it has dimension smaller than depth = %d\" % (idx,depth))\n",
    "    else:\n",
    "        raise TypeError(\"thetas is not an iterable or it has dimension smaller than n = %d\" % n)\n",
    "        \n",
    "    # construct qubits and classical bits    \n",
    "    qr = qk.QuantumRegister(n, 'q')\n",
    "    cr = qk.ClassicalRegister(n, 'c')\n",
    "    qc = qk.QuantumCircuit(qr, cr)\n",
    "    \n",
    "    for d in range(depth):\n",
    "        # assign parameterized U3\n",
    "        for qb in range(n):\n",
    "            qc.u3(thetas[qb][d],0,0, qr[qb])\n",
    "        # add barrier\n",
    "        qc.barrier(qr)\n",
    "        \n",
    "        # pairwise control Z\n",
    "        for cqb in range(n-1):\n",
    "            qc.cz(qr[cqb],qr[cqb + 1])\n",
    "        pass\n",
    "        # add barrier\n",
    "        qc.barrier(qr)\n",
    "    \n",
    "    # measure z\n",
    "    for qb in range(n):\n",
    "        qc.measure(qr[qb],cr[qb])\n",
    "    return qc,qr,qc\n",
    "\n",
    "# obtain sampling distribution from the original, unreduced version of the max-cut quantum circuit for VQE\n",
    "def get_orig_maxcut_result(n,depth,default_thetas):\n",
    "    '''\n",
    "    n: number of qubits:\n",
    "    depth: number of entanglements; \n",
    "    default_thetas: the control parameters for VQE; dimension = (n,depth)\n",
    "    '''\n",
    "    cc,qr,qc = make_maxcut_circuit(n,depth,default_thetas)\n",
    "    {qr[0]: 0,\n",
    "                     qr[1]: 1,\n",
    "                     qr[2]: 2}\n",
    "    job = qk.execute(cc, BACKEND1,shots=NSHOTS, seed_simulator=SEED, \n",
    "                     initial_layout={qr[0]: 0, qr[1] : 1, qr[2] : 3, qr[3] : 4})\n",
    "    result = job.result()\n",
    "    ddict = result.get_counts(0)\n",
    "    for idx in range(2 ** n):\n",
    "        if not (format(idx, \"0%db\" % n) in ddict):\n",
    "            ddict[format(idx,'0%db'% n)] = 0\n",
    "    return ddict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# obtain sampling distribution from the reduced version of the max-cut quantum circuit for VQE\n",
    "def get_reduced_maxcut_result(n, depth, thetas):\n",
    "    '''\n",
    "    returns the result in n qubit space\n",
    "    by default the qubit to be disconnected is the last qubit with index n-1\n",
    "    n: number of qubits:\n",
    "    depth: number of entanglements; \n",
    "    default_thetas: the control parameters for VQE; dimension = (n,depth)\n",
    "    '''\n",
    "    # parameter sanity check: check if the dimension is okay\n",
    "    if isinstance(thetas, collections.Iterable) and len(thetas) >= n:\n",
    "        for idx in range(n):\n",
    "            if isinstance(thetas[idx], collections.Iterable) and len(thetas) >= depth: \n",
    "                pass\n",
    "            else:\n",
    "                raise TypeError(\"thetas[%d] is not an iterable or it has dimension smaller than depth = %d\" % (idx,depth))\n",
    "    else:\n",
    "        raise TypeError(\"thetas is not an iterable or it has dimension smaller than n = %d\" % n)\n",
    "        \n",
    "    # construct container for n-1 qubit results\n",
    "    final_result = {}\n",
    "    for idx in range(2 ** n):\n",
    "        final_result[format(idx,'0%db'% n)] = 0\n",
    "  \n",
    "    counts = [0 for i in range(6 ** depth)] # keeps track of all the counts of all the power of \n",
    "    for runid in range(6 ** depth):\n",
    "        # the index of the version at each two qubit gate we split\n",
    "        cc_cnts = [ (runid % (6 ** (idx + 1))) // (6 ** idx) for idx in range(depth)]\n",
    "        # construct qubits and classical bits\n",
    "        qr = qk.QuantumRegister(n-1, 'q')\n",
    "        cr = qk.ClassicalRegister(n-1+depth, 'c')\n",
    "        qc = qk.QuantumCircuit(qr, cr)\n",
    "        qc2 =qk.QuantumCircuit(1, 1+depth) \n",
    "      \n",
    "        #coef for each runid\n",
    "        coef = 1\n",
    "\n",
    "        for d in range(depth):\n",
    "            # assign parameterized U3\n",
    "            for qb in range(n-1):\n",
    "                qc.u3(thetas[qb][d],0,0, qr[qb])\n",
    "            qc2.u3(thetas[-1][d],0,0, 0)\n",
    "            \n",
    "            # add barrier\n",
    "            qc.barrier(qr)\n",
    "            qc2.barrier([0])\n",
    "\n",
    "            # pairwise control Z\n",
    "            for cqb in range(n-2):\n",
    "                qc.cz(qr[cqb],qr[cqb + 1])\n",
    "            \n",
    "            # add the virtual two qubit gate on the last qubit\n",
    "            gate_ver = cc_cnts[d] + 1\n",
    "            qa = qr[-1]\n",
    "            qb = 0\n",
    "            if gate_ver == 1:\n",
    "                coef *= 1/2\n",
    "            elif gate_ver == 2:\n",
    "                qc.z(qa)\n",
    "                qc2.z(qb)\n",
    "                coef *= 1/2\n",
    "            elif gate_ver == 3:\n",
    "                qc.measure(qa, cr[n-1+d])\n",
    "                qc2.rz(-np.pi * 1 / 2, qb)\n",
    "    \n",
    "                coef *= -1/2*1\n",
    "            elif gate_ver == 4:\n",
    "                qc.measure(qa, cr[n-1+d])\n",
    "                qc2.rz(-np.pi * -1 / 2, qb)\n",
    "    \n",
    "                coef *= -1/2*-1\n",
    "            elif gate_ver == 5:\n",
    "                qc2.measure(qb, 1+d)\n",
    "                qc.rz(-np.pi * 1 / 2, qa)\n",
    "    \n",
    "                coef *= -1/2*1\n",
    "            elif gate_ver == 6:\n",
    "                qc2.measure(qb, 1+d)\n",
    "                qc.rz(-np.pi * -1 / 2, qa)\n",
    "    \n",
    "                coef *= -1/2*-1\n",
    "            \n",
    "            qc.rz(-np.pi/2,qa)\n",
    "            qc2.rz(-np.pi/2,qb)\n",
    "            qc.barrier(qr)\n",
    "            qc2.barrier([0])\n",
    "    \n",
    "        # measure z\n",
    "        for qb in range(n-1):\n",
    "            qc.measure(qr[qb],cr[qb])\n",
    "        qc2.measure([0], [0])\n",
    "    \n",
    "        # execute experiments\n",
    "        job_tmp_1 = qk.execute(qc, BACKEND1,shots=NSHOTS, seed_simulator=SEED)\n",
    "        job_tmp_2 = qk.execute(qc2, BACKEND2,shots=NSHOTS, seed_simulator=SEED)\n",
    "        result_tmp_2 = job_tmp_2.result()\n",
    "        result_tmp_1 = job_tmp_1.result()\n",
    "        dict_1 = result_tmp_1.get_counts(0)\n",
    "        dict_2 = result_tmp_2.get_counts(0)\n",
    "        \n",
    "        # post-process six individual measurement results and tensor two subcircuit results\n",
    "        for key1 in dict_1:\n",
    "            coef1 = 1\n",
    "            for i in key1[0:depth]:\n",
    "                coef1 *= 1-int(i)*2\n",
    "            for key2 in dict_2:\n",
    "                coef2 = 1\n",
    "                for i in key2[0:depth]:\n",
    "                    coef2 *= 1-int(i)*2\n",
    "                key = key2[depth:] + key1[depth:]\n",
    "                final_result[key] += coef*coef1*coef2*dict_1[key1]*dict_2[key2]\n",
    "    return final_result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the cost function/ising Hamiltonian value used for the SPSA algorithm\n",
    "def get_cost(data, w):\n",
    "    '''\n",
    "    data: sampling distribution of the circuit\n",
    "    w: weights for the max cut problem\n",
    "    '''\n",
    "    d = len(w)\n",
    "    cnt = np.sum(list(data.values()))\n",
    "    cost = 0\n",
    "    for mm in range(d):\n",
    "        for nn in range(mm+1,d):\n",
    "            cost += w[mm][nn] * np.sum([get_max_cut_value(val,(mm,nn)) * data[val] for val in data])\n",
    "    return cost / cnt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is a modifed version of the get_reduced_maxcut_result function for the IBM Q Chips; \n",
    "# we have to do this because the current IBMQ devices does not allow gates to occur\n",
    "# after measurement. This function can work for circuit of depth 1 on real IBM Q chips\n",
    "def get_real_device_reduced_maxcut_result(n, depth, thetas):\n",
    "    '''\n",
    "        returns the result in n qubit space\n",
    "        by default the qubit to be disconnected is the last qubit with index n-1\n",
    "        n: number of qubits:\n",
    "        depth: number of entanglements; \n",
    "        default_thetas: the control parameters for VQE; dimension = (n,depth)\n",
    "    '''\n",
    "    # parameter sanity check: check if the dimension is okay\n",
    "    if isinstance(thetas, collections.Iterable) and len(thetas) >= n:\n",
    "        for idx in range(n):\n",
    "            if isinstance(thetas[idx], collections.Iterable) and len(thetas) >= depth: \n",
    "                pass\n",
    "            else:\n",
    "                raise TypeError(\"thetas[%d] is not an iterable or it has dimension smaller than depth = %d\" % (idx,depth))\n",
    "    else:\n",
    "        raise TypeError(\"thetas is not an iterable or it has dimension smaller than n = %d\" % n)\n",
    "        \n",
    "    # construct container for n-1 qubit results\n",
    "    final_result = {}\n",
    "    for idx in range(2 ** n):\n",
    "        final_result[format(idx,'0%db'% n)] = 0\n",
    "  \n",
    "    counts = [0 for i in range(6 ** depth)] # keeps track of all the counts of all the power of \n",
    "    for runid in range(6 ** depth):\n",
    "        # the index of the version at each two qubit gate we split\n",
    "        cc_cnts = [ (runid % (6 ** (idx + 1))) // (6 ** idx) for idx in range(depth)]\n",
    "        # construct qubits and classical bits\n",
    "        qr = qk.QuantumRegister(n-1, 'q')\n",
    "        cr = qk.ClassicalRegister(n-1, 'c')\n",
    "        qc = qk.QuantumCircuit(qr, cr)\n",
    "        qc2 =qk.QuantumCircuit(1, 1) \n",
    "      \n",
    "        #coef for each runid\n",
    "        coef = 1\n",
    "\n",
    "        for d in range(depth):\n",
    "            # assign parameterized U3\n",
    "            for qb in range(n-1):\n",
    "                qc.u3(thetas[qb][d],0,0, qr[qb])\n",
    "            qc2.u3(thetas[-1][d],0,0, 0)\n",
    "            \n",
    "            # add barrier\n",
    "            qc.barrier(qr)\n",
    "            qc2.barrier([0])\n",
    "\n",
    "            # pairwise control Z\n",
    "            for cqb in range(n-2):\n",
    "                qc.cz(qr[cqb],qr[cqb + 1])\n",
    "            \n",
    "            # add the virtual two qubit gate on the last qubit\n",
    "            gate_ver = cc_cnts[d] + 1\n",
    "            qa = qr[-1]\n",
    "            qb = 0\n",
    "            if gate_ver == 1:\n",
    "                coef *= 1/2\n",
    "            elif gate_ver == 2:\n",
    "                qc.z(qa)\n",
    "                qc2.z(qb)\n",
    "                coef *= 1/2\n",
    "            elif gate_ver == 3:\n",
    "                #qc.measure(qa, cr[n-1+d])\n",
    "                qc2.rz(-np.pi * 1 / 2, qb)\n",
    "    \n",
    "                coef *= -1/2*1\n",
    "            elif gate_ver == 4:\n",
    "                #qc.measure(qa, cr[n-1+d])\n",
    "                qc2.rz(-np.pi * -1 / 2, qb)\n",
    "    \n",
    "                coef *= -1/2*-1\n",
    "            elif gate_ver == 5:\n",
    "                #qc2.measure(qb, 1+d)\n",
    "                qc.rz(-np.pi * 1 / 2, qa)\n",
    "    \n",
    "                coef *= -1/2*1\n",
    "            elif gate_ver == 6:\n",
    "                #qc2.measure(qb, 1+d)\n",
    "                qc.rz(-np.pi * -1 / 2, qa)\n",
    "    \n",
    "                coef *= -1/2*-1\n",
    "            \n",
    "            qc.rz(-np.pi/2,qa)\n",
    "            qc2.rz(-np.pi/2,qb)\n",
    "            qc.barrier(qr)\n",
    "            qc2.barrier([0])\n",
    "    \n",
    "        # measure z\n",
    "        for qb in range(n-1):\n",
    "            qc.measure(qr[qb],cr[qb])\n",
    "        qc2.measure([0], [0])\n",
    "    \n",
    "        # execute experiments\n",
    "        job_tmp_1 = qk.execute(qc, BACKEND1,shots=NSHOTS, seed_simulator=SEED)\n",
    "        job_tmp_2 = qk.execute(qc2, BACKEND2,shots=NSHOTS, seed_simulator=SEED)\n",
    "        result_tmp_2 = job_tmp_2.result()\n",
    "        result_tmp_1 = job_tmp_1.result()\n",
    "        dict_1 = result_tmp_1.get_counts(0)\n",
    "        dict_2 = result_tmp_2.get_counts(0)\n",
    "        \n",
    "        \n",
    "        gate_ver = runid + 1\n",
    "        for key1 in dict_1:\n",
    "            coef1 = 1\n",
    "            if gate_ver == 3 or gate_ver == 4:\n",
    "                coef1 = 1-int(key1[0])*2\n",
    "            for key2 in dict_2:\n",
    "                coef2 = 1\n",
    "                if gate_ver == 5 or gate_ver == 6:\n",
    "                    coef1 = 1-int(key2[0])*2\n",
    "                #print(key2[depth:], ' ', key2[-1])\n",
    "                key = key2 + key1\n",
    "                #print(key)\n",
    "                final_result[key] += coef*coef1*coef2*dict_1[key1]*dict_2[key2]\n",
    "    #print(final_result)\n",
    "    return final_result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Single-Shot Sampling Distribution Comparison of the Two Algorithsm##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "default_thetas = [[ np.random.rand()*5 for j in range(4)] for i in range(4)]\n",
    "SEED = 11312\n",
    "NSHOTS = 1024\n",
    "final_result = get_orig_maxcut_result(4, 1, default_thetas)\n",
    "final_result_reduced = get_real_device_reduced_maxcut_result(4,1,default_thetas)\n",
    "from qiskit.visualization import plot_histogram\n",
    "plot_histogram([final_result_reduced,final_result], legend=[\"reduced\",\"original\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SPSA Optimization Utility ## "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the simultaneous perturbation stochastic approximation (SPSA) method\n",
    "# described in https://en.wikipedia.org/wiki/Simultaneous_perturbation_stochastic_approximation \n",
    "def SPSA_optimization(n, depth, total_test, w,get_result_func):\n",
    "    '''\n",
    "    n: number of qubits\n",
    "    depth: depth of the circuit\n",
    "    total_test: the number of iterations\n",
    "    w: the weights of the max-cut graph\n",
    "    get_result_func: a function reference for choosing the appropriate algorithms\n",
    "    '''\n",
    "    \n",
    "    # the following global definitions are in place because\n",
    "    # we still want to access the last running result\n",
    "    # in case any error occurs during optimizatrion\n",
    "    global F\n",
    "    global results \n",
    "    L = n*depth\n",
    "    beta = np.ones((L, 1))\n",
    "    for i in range(0, L):\n",
    "        beta[i] = 1\n",
    "    param = [[np.random.rand()*5 for j in range(depth)] for i in range(n)]\n",
    "    for T in range(1, total_test+1):\n",
    "        an = 1.2 / np.power(T, 0.6)\n",
    "        cn = 0.3 / np.power(T, 1)\n",
    "        delta = np.random.binomial(1, 0.5, L)*2-1\n",
    "        #print(delta)\n",
    "        total = 0 \n",
    "        for i in range(n):\n",
    "            for j in range(depth):\n",
    "                param[i][j] = beta[total] + delta[total]*cn\n",
    "                total = total + 1\n",
    "        \n",
    "        final_result = get_result_func(n, depth, param)\n",
    "        F_plus = get_cost(final_result, w)\n",
    "        \n",
    "        total = 0\n",
    "        for i in range(n):\n",
    "            for j in range(depth):\n",
    "                param[i][j] = beta[total] - delta[total]*cn\n",
    "                total = total + 1\n",
    "        \n",
    "        final_result = get_result_func(n, depth, param)\n",
    "        F_minus = get_cost(final_result, w)\n",
    "        \n",
    "        for i in range(L):\n",
    "            beta[i] += an * (F_plus - F_minus) / (2*cn*delta[i])\n",
    "        F.append(F_minus)\n",
    "        print(T, \": \", F_minus)\n",
    "        results = final_result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 :  1.359466552734375\n",
      "2 :  2.1685791015625\n",
      "3 :  2.09417724609375\n",
      "4 :  2.4033584594726562\n",
      "5 :  3.2052841186523438\n",
      "6 :  3.2914505004882812\n",
      "7 :  3.2616653442382812\n",
      "8 :  3.3887939453125\n",
      "9 :  3.4315872192382812\n",
      "10 :  3.8064002990722656\n"
     ]
    }
   ],
   "source": [
    "SEED = int(time.time())\n",
    "w = [[0., 1., 1., 1.],[1., 0., 1., 0.],[1., 1., 0., 1.],[1., 0., 1., 0.]]\n",
    "F = []\n",
    "results = []\n",
    "SPSA_optimization(4, 1, 10, w, get_real_device_reduced_maxcut_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'0000': 986.0, '0001': 10846.0, '0010': 0, '0011': 0, '0100': 73950.0, '0101': 903176.0, '0110': 2958.0, '0111': 17748.0, '1000': 38.0, '1001': 418.0, '1010': 0, '1011': 0, '1100': 2850.0, '1101': 34808.0, '1110': 114.0, '1111': 684.0}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(results)\n",
    "plot_histogram(results)"
   ]
  }
 ],
 "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
}