QAOA_5Qubit_EXPERIMENT.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import time\n",
    "from collections import namedtuple\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import qiskit as q\n",
    "import qiskit.tools.jupyter\n",
    "from qiskit.pulse import pulse_lib as _  # only want to call pulse_lib as q.pulse.pulse_lib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pulse_compiler_helper_fns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AccountProvider for IBMQ(hub='ibm-q', group='open', project='main')>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.IBMQ.load_account() # Load account from disk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/alijavadi/Desktop/ajavadia-terra/qiskit/pulse/channels/pulse_channel_spec.py:87: DeprecationWarning: The PulseChannelSpec is deprecated. Use backend.configuration() instead. The supported methods require some migrations; check out the release notes for the complete details.\n",
      "  DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "provider = q.IBMQ.get_provider(group='qiskit-terra', project='pulse-testing')\n",
    "backend = provider.get_backend('alt_almaden')\n",
    "system = q.pulse.PulseChannelSpec.from_backend(backend)\n",
    "config = backend.configuration()\n",
    "cmd_def = q.pulse.CmdDef.from_defaults(backend.defaults().cmd_def, backend.defaults().pulse_library)\n",
    "measure = cmd_def.get('measure', qubits=backend.configuration().meas_map[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "beta = 3 * np.pi / 4\n",
    "gamma = np.pi / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "schedules = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "H = cmd_def.get('u2', qubits=[0], P0=0, P1=np.pi) | cmd_def.get('u2', qubits=[1], P0=0, P1=np.pi) | cmd_def.get('u2', qubits=[2], P0=0, P1=np.pi) | cmd_def.get('u2', qubits=[3], P0=0, P1=np.pi) | cmd_def.get('u2', qubits=[4], P0=0, P1=np.pi)\n",
    "\n",
    "CNOT_RZ_CNOT_01 = cmd_def.get('cx', qubits=[0, 1])\n",
    "CNOT_RZ_CNOT_01 |= cmd_def.get('u1', qubits=[1], P0=gamma) << CNOT_RZ_CNOT_01.duration\n",
    "CNOT_RZ_CNOT_01 |= cmd_def.get('cx', qubits=[0, 1]) << CNOT_RZ_CNOT_01.duration\n",
    "\n",
    "CNOT_RZ_CNOT_12 = cmd_def.get('cx', qubits=[1, 2])\n",
    "CNOT_RZ_CNOT_12 |= cmd_def.get('u1', qubits=[2], P0=gamma) << CNOT_RZ_CNOT_12.duration\n",
    "CNOT_RZ_CNOT_12 |= cmd_def.get('cx', qubits=[1, 2]) << CNOT_RZ_CNOT_12.duration\n",
    "\n",
    "CNOT_RZ_CNOT_23 = cmd_def.get('cx', qubits=[2, 3])\n",
    "CNOT_RZ_CNOT_23 |= cmd_def.get('u1', qubits=[3], P0=gamma) << CNOT_RZ_CNOT_23.duration\n",
    "CNOT_RZ_CNOT_23 |= cmd_def.get('cx', qubits=[2, 3]) << CNOT_RZ_CNOT_23.duration\n",
    "\n",
    "CNOT_RZ_CNOT_34 = cmd_def.get('cx', qubits=[3, 4])\n",
    "CNOT_RZ_CNOT_34 |= cmd_def.get('u1', qubits=[4], P0=gamma) << CNOT_RZ_CNOT_34.duration\n",
    "CNOT_RZ_CNOT_34 |= cmd_def.get('cx', qubits=[3, 4]) << CNOT_RZ_CNOT_34.duration\n",
    "\n",
    "# RX(beta) = U3(beta, 3*pi/2, pi/2), hence line below\n",
    "RX = cmd_def.get('u3', qubits=[0], P0=beta, P1=3*np.pi/2, P2=np.pi/2) | cmd_def.get('u3', qubits=[1], P0=beta, P1=3*np.pi/2, P2=np.pi/2) | cmd_def.get('u3', qubits=[2], P0=beta, P1=3*np.pi/2, P2=np.pi/2) | cmd_def.get('u3', qubits=[3], P0=beta, P1=3*np.pi/2, P2=np.pi/2) | cmd_def.get('u3', qubits=[4], P0=beta, P1=3*np.pi/2, P2=np.pi/2)\n",
    "\n",
    "schedule = H\n",
    "schedule |= CNOT_RZ_CNOT_01 << schedule.duration\n",
    "schedule |= CNOT_RZ_CNOT_12 << schedule.duration\n",
    "schedule |= CNOT_RZ_CNOT_23 << schedule.duration\n",
    "schedule |= CNOT_RZ_CNOT_34 << schedule.duration\n",
    "schedule |= RX << schedule.duration\n",
    "schedule |= measure << schedule.duration\n",
    "\n",
    "schedules.append(schedule)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Optimized Way: zz_interaction decomposes directly to cross resonancefor theta in thetas:\n",
    "circuit = q.QuantumCircuit(5)\n",
    "circuit.h(0)\n",
    "circuit.h(1)\n",
    "circuit.h(2)\n",
    "circuit.h(3)\n",
    "circuit.h(4)\n",
    "\n",
    "circuit.zz_interaction(gamma, 0, 1)\n",
    "circuit.zz_interaction(gamma, 1, 2)\n",
    "circuit.zz_interaction(gamma, 2, 3)\n",
    "circuit.zz_interaction(gamma, 3, 4)\n",
    "\n",
    "circuit.rx(beta, 0)\n",
    "circuit.rx(beta, 1)\n",
    "circuit.rx(beta, 2)\n",
    "circuit.rx(beta, 3)\n",
    "circuit.rx(beta, 4)\n",
    "\n",
    "decomposed_circuit = circuit.decompose()\n",
    "\n",
    "pulse_compiler_helper_fns.update_basis_gates_and_cmd_def(decomposed_circuit, backend, system, cmd_def)\n",
    "transpiled_circuit = q.transpile(decomposed_circuit, backend, optimization_level=1)\n",
    "\n",
    "schedule = q.schedule(transpiled_circuit, backend=backend, cmd_def=cmd_def)\n",
    "schedule |= measure << schedule.duration\n",
    "schedules.append(schedule)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "job is 5dda0e668aa7e00018b8fc54\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/ipywidgets/widgets/widget_layout.py:84: DeprecationWarning: Layout properties overflow_x and overflow_y have been deprecated and will be dropped in a future release. Please use the overflow shorthand property instead\n",
      "  warnings.warn(\"Layout properties overflow_x and overflow_y have been deprecated and will be dropped in a future release. Please use the overflow shorthand property instead\", DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "shots = 8000\n",
    "job = q.execute(schedules, backend=backend, shots=shots)\n",
    "print('job is %s' % job.job_id())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<JobStatus.DONE: 'job has successfully run'>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job.status()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run a mitigation cal job"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/ipywidgets/widgets/widget_layout.py:84: DeprecationWarning: Layout properties overflow_x and overflow_y have been deprecated and will be dropped in a future release. Please use the overflow shorthand property instead\n",
      "  warnings.warn(\"Layout properties overflow_x and overflow_y have been deprecated and will be dropped in a future release. Please use the overflow shorthand property instead\", DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "import qiskit.ignis.mitigation.measurement as mit\n",
    "meas_qcs, meas_labels = mit.complete_meas_cal(qubit_list=[0,1,2,3,4])\n",
    "meas_qcs_transpiled = q.transpile(meas_qcs, backend, basis_gates=['x'])\n",
    "meas_schedules = q.schedule(meas_qcs_transpiled, backend=backend, cmd_def=cmd_def)\n",
    "job_mit = q.execute(meas_schedules, backend, shots=shots)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<JobStatus.DONE: 'job has successfully run'>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job_mit.status()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----\n",
    "## Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.result import marginal_counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = job.result()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9.17125e-01, 7.68750e-02, 6.70000e-02, ..., 0.00000e+00,\n",
       "        0.00000e+00, 0.00000e+00],\n",
       "       [2.48750e-02, 8.66375e-01, 2.50000e-03, ..., 2.50000e-04,\n",
       "        0.00000e+00, 1.25000e-04],\n",
       "       [1.66250e-02, 1.87500e-03, 8.64000e-01, ..., 0.00000e+00,\n",
       "        3.75000e-04, 1.25000e-04],\n",
       "       ...,\n",
       "       [0.00000e+00, 0.00000e+00, 0.00000e+00, ..., 6.97125e-01,\n",
       "        1.75000e-03, 5.02500e-02],\n",
       "       [0.00000e+00, 0.00000e+00, 0.00000e+00, ..., 1.75000e-03,\n",
       "        7.05000e-01, 7.08750e-02],\n",
       "       [0.00000e+00, 0.00000e+00, 0.00000e+00, ..., 1.00000e-02,\n",
       "        2.01250e-02, 6.62250e-01]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mitigate results\n",
    "result_mit = marginal_counts(job_mit.result(), [0,1,2,3,4])\n",
    "readout_fitter = mit.CompleteMeasFitter(result_mit, meas_labels)\n",
    "readout_fitter.cal_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before mitigation:\n",
      "{'00000': 164, '00001': 164, '00010': 336, '00011': 115, '00100': 519, '00101': 410, '00110': 233, '00111': 298, '01000': 321, '01001': 674, '01010': 606, '01011': 142, '01100': 144, '01101': 91, '01110': 333, '01111': 157, '10000': 194, '10001': 305, '10010': 692, '10011': 172, '10100': 397, '10101': 368, '10110': 127, '10111': 161, '11000': 86, '11001': 112, '11010': 59, '11011': 34, '11100': 187, '11101': 112, '11110': 150, '11111': 137}\n",
      "\n",
      "\n",
      "\n",
      " after mitigation:\n",
      "{'00000': 73.94759199923955, '00001': 52.54881494049934, '00010': 246.61233017315266, '00011': 76.54636554893855, '00100': 502.98842129484694, '00101': 422.76416480593656, '00110': 181.1370116592928, '00111': 346.1019888084021, '01000': 245.57265258929428, '01001': 803.6477688297599, '01010': 702.1454816996077, '01011': 146.8753727776203, '01100': 110.75884864311479, '01101': 66.9421552034904, '01110': 382.8956728785569, '01111': 192.0042067884139, '10000': 85.34274306674088, '10001': 303.45093628342903, '10010': 791.5749341592119, '10011': 179.61143657197357, '10100': 401.13600383272933, '10101': 413.94108032533273, '10110': 87.80932793167389, '10111': 187.18205043008425, '11000': 70.16541711830234, '11001': 124.03586223906025, '11010': 46.82375542935432, '11011': 26.428537249373623, '11100': 218.413980785087, '11101': 131.11281133813605, '11110': 184.54604326708943, '11111': 194.93623133225395}\n"
     ]
    }
   ],
   "source": [
    "standard_counts = marginal_counts(result.get_counts(0), [0,1,2,3,4])\n",
    "print('before mitigation:')\n",
    "print(standard_counts)\n",
    "\n",
    "standard_counts = readout_fitter.filter.apply(standard_counts)\n",
    "print('\\n\\n\\n after mitigation:')\n",
    "print(standard_counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before mitigation:\n",
      "{'00000': 117, '00001': 390, '00010': 189, '00011': 70, '00100': 97, '00101': 198, '00110': 275, '00111': 90, '01000': 149, '01001': 671, '01010': 480, '01011': 96, '01100': 218, '01101': 371, '01110': 431, '01111': 198, '10000': 197, '10001': 337, '10010': 758, '10011': 213, '10100': 250, '10101': 873, '10110': 274, '10111': 110, '11000': 84, '11001': 294, '11010': 80, '11011': 41, '11100': 58, '11101': 101, '11110': 218, '11111': 72}\n",
      "\n",
      "\n",
      "\n",
      " after mitigation:\n",
      "{'00000': 64.31836727224682, '00001': 342.48789420516823, '00010': 88.92461530463044, '00011': 46.18446098380638, '00100': 41.71832442734677, '00101': 118.13220927356623, '00110': 250.63734268255885, '00111': 73.88916755483336, '01000': 48.20881623716803, '01001': 763.0900811585608, '01010': 542.621438365874, '01011': 82.86262196968067, '01100': 189.37167982351284, '01101': 439.99231512975155, '01110': 502.7120907277713, '01111': 252.68151359864967, '10000': 98.22639233689812, '10001': 263.68596468088134, '10010': 849.3561519756636, '10011': 234.3982505349286, '10100': 179.2605198330568, '10101': 1069.2856657864045, '10110': 273.91248613341645, '10111': 111.3078200817481, '11000': 62.60329054289367, '11001': 367.8758406018258, '11010': 66.34082890921485, '11011': 39.36920338890298, '11100': 38.60367935148936, '11101': 112.46687321069714, '11110': 291.8200175525248, '11111': 93.65407636432755}\n"
     ]
    }
   ],
   "source": [
    "optimized_counts = marginal_counts(result.get_counts(1), [0,1,2,3,4])\n",
    "print('before mitigation:')\n",
    "print(optimized_counts)\n",
    "\n",
    "optimized_counts = readout_fitter.filter.apply(optimized_counts)\n",
    "print('\\n\\n\\n after mitigation:')\n",
    "print(optimized_counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sanitize data and plot\n",
    "for key in standard_counts:\n",
    "    standard_counts[key] = int(standard_counts[key])\n",
    "for key in optimized_counts:\n",
    "    optimized_counts[key] = int(optimized_counts[key])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'00000': 73,\n",
       " '00001': 52,\n",
       " '00010': 246,\n",
       " '00011': 76,\n",
       " '00100': 502,\n",
       " '00101': 422,\n",
       " '00110': 181,\n",
       " '00111': 346,\n",
       " '01000': 245,\n",
       " '01001': 803,\n",
       " '01010': 702,\n",
       " '01011': 146,\n",
       " '01100': 110,\n",
       " '01101': 66,\n",
       " '01110': 382,\n",
       " '01111': 192,\n",
       " '10000': 85,\n",
       " '10001': 303,\n",
       " '10010': 791,\n",
       " '10011': 179,\n",
       " '10100': 401,\n",
       " '10101': 413,\n",
       " '10110': 87,\n",
       " '10111': 187,\n",
       " '11000': 70,\n",
       " '11001': 124,\n",
       " '11010': 46,\n",
       " '11011': 26,\n",
       " '11100': 218,\n",
       " '11101': 131,\n",
       " '11110': 184,\n",
       " '11111': 194}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "standard_counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'00000': 64,\n",
       " '00001': 342,\n",
       " '00010': 88,\n",
       " '00011': 46,\n",
       " '00100': 41,\n",
       " '00101': 118,\n",
       " '00110': 250,\n",
       " '00111': 73,\n",
       " '01000': 48,\n",
       " '01001': 763,\n",
       " '01010': 542,\n",
       " '01011': 82,\n",
       " '01100': 189,\n",
       " '01101': 439,\n",
       " '01110': 502,\n",
       " '01111': 252,\n",
       " '10000': 98,\n",
       " '10001': 263,\n",
       " '10010': 849,\n",
       " '10011': 234,\n",
       " '10100': 179,\n",
       " '10101': 1069,\n",
       " '10110': 273,\n",
       " '10111': 111,\n",
       " '11000': 62,\n",
       " '11001': 367,\n",
       " '11010': 66,\n",
       " '11011': 39,\n",
       " '11100': 38,\n",
       " '11101': 112,\n",
       " '11110': 291,\n",
       " '11111': 93}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "optimized_counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Note, use qiskit-terra master before running cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "circuit = q.QuantumCircuit(5)\n",
    "circuit.h(0)\n",
    "circuit.h(1)\n",
    "circuit.h(2)\n",
    "circuit.h(3)\n",
    "circuit.h(4)\n",
    "\n",
    "circuit.cx(0, 1); circuit.rz(gamma, 1); circuit.cx(0, 1);\n",
    "circuit.cx(1, 2); circuit.rz(gamma, 2); circuit.cx(1, 2);\n",
    "circuit.cx(2, 3); circuit.rz(gamma, 3); circuit.cx(2, 3);\n",
    "circuit.cx(3, 4); circuit.rz(gamma, 4); circuit.cx(3, 4);\n",
    "\n",
    "circuit.rx(beta, 0)\n",
    "circuit.rx(beta, 1)\n",
    "circuit.rx(beta, 2)\n",
    "circuit.rx(beta, 3)\n",
    "circuit.rx(beta, 4)\n",
    "\n",
    "backend = q.Aer.get_backend('statevector_simulator')\n",
    "job = q.execute(circuit, backend=backend)\n",
    "statevector = job.result().get_statevector()\n",
    "\n",
    "\n",
    "ideal_counts = {}\n",
    "for i in range(2**5):\n",
    "    ideal_counts[format(i, 'b').zfill(5)] = np.abs(statevector[i]) ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "circuit = q.QuantumCircuit(5)\n",
    "circuit.h(0)\n",
    "circuit.h(1)\n",
    "circuit.h(2)\n",
    "circuit.h(3)\n",
    "circuit.h(4)\n",
    "\n",
    "circuit.cx(0, 1); circuit.rz(gamma, 1); circuit.cx(0, 1);\n",
    "circuit.cx(1, 2); circuit.rz(gamma, 2); circuit.cx(1, 2);\n",
    "circuit.cx(2, 3); circuit.rz(gamma, 3); circuit.cx(2, 3);\n",
    "circuit.cx(3, 4); circuit.rz(gamma, 4); circuit.cx(3, 4);\n",
    "\n",
    "circuit.rx(beta, 0)\n",
    "circuit.rx(beta, 1)\n",
    "circuit.rx(beta, 2)\n",
    "circuit.rx(beta, 3)\n",
    "circuit.rx(beta, 4)\n",
    "\n",
    "backend = q.Aer.get_backend('statevector_simulator')\n",
    "job = q.execute(circuit, backend=backend)\n",
    "statevector = job.result().get_statevector()\n",
    "\n",
    "\n",
    "ideal_counts = {}\n",
    "for i in range(2**5):\n",
    "    ideal_counts[format(i, 'b').zfill(5)] = np.abs(statevector[i]) ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "ideal_counts = {'00000': 0.007812499999999986, '00001': 0.03906249999999999, '00010': 0.007812500000000002, '00011': 0.007812500000000002, '00100': 0.007812500000000005, '00101': 0.007812499999999994, '00110': 0.03906249999999999, '00111': 0.007812500000000005, '01000': 0.0078124999999999965, '01001': 0.07031249999999999, '01010': 0.10156250000000003, '01011': 0.007812500000000005, '01100': 0.039062499999999986, '01101': 0.07031249999999999, '01110': 0.039062500000000014, '01111': 0.039062500000000014, '10000': 0.039062499999999986, '10001': 0.03906249999999999, '10010': 0.07031249999999999, '10011': 0.03906250000000003, '10100': 0.007812499999999991, '10101': 0.10156250000000006, '10110': 0.07031249999999999, '10111': 0.007812499999999998, '11000': 0.007812499999999994, '11001': 0.039062500000000014, '11010': 0.007812500000000002, '11011': 0.007812500000000005, '11100': 0.007812500000000003, '11101': 0.007812500000000002, '11110': 0.03906249999999999, '11111': 0.007812500000000005}\n",
    "standard_counts = {'00000': 73, '00001': 52, '00010': 246, '00011': 76, '00100': 502, '00101': 422, '00110': 181, '00111': 346, '01000': 245, '01001': 803, '01010': 702, '01011': 146, '01100': 110, '01101': 66, '01110': 382, '01111': 192, '10000': 85, '10001': 303, '10010': 791, '10011': 179, '10100': 401, '10101': 413, '10110': 87, '10111': 187, '11000': 70, '11001': 124, '11010': 46, '11011': 26, '11100': 218, '11101': 131, '11110': 184, '11111': 194}\n",
    "optimized_counts = {'00000': 64, '00001': 342, '00010': 88, '00011': 46, '00100': 41, '00101': 118, '00110': 250, '00111': 73, '01000': 48, '01001': 763, '01010': 542, '01011': 82, '01100': 189, '01101': 439, '01110': 502, '01111': 252, '10000': 98, '10001': 263, '10010': 849, '10011': 234, '10100': 179, '10101': 1069, '10110': 273, '10111': 111, '11000': 62, '11001': 367, '11010': 66, '11011': 39, '11100': 38, '11101': 112, '11110': 291, '11111': 93}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4738975949183563\n",
      "0.08700067793414468\n"
     ]
    }
   ],
   "source": [
    "print(pulse_compiler_helper_fns.kl_divergence(ideal_counts, standard_counts))\n",
    "print(pulse_compiler_helper_fns.kl_divergence(ideal_counts, optimized_counts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.5582664236832167\n",
      "3.1713695066990053\n"
     ]
    }
   ],
   "source": [
    "print(pulse_compiler_helper_fns.cross_entropy(ideal_counts, standard_counts))\n",
    "print(pulse_compiler_helper_fns.cross_entropy(ideal_counts, optimized_counts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6627697370128571\n",
      "0.8552290613698698\n"
     ]
    }
   ],
   "source": [
    "print(q.quantum_info.hellinger_fidelity(ideal_counts, standard_counts))\n",
    "print(q.quantum_info.hellinger_fidelity(ideal_counts, optimized_counts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x576 with 1 Axes>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.visualization import plot_histogram\n",
    "plot_histogram([standard_counts, optimized_counts, ideal_counts], legend=['standard', 'optimized', 'ideal'], figsize=(20,8))"
   ]
  },
  {
   "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
}