qiskit/advanced/aer/6_extended_stabilizer_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../../../images/qiskit_header.png\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" align=\"middle\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Qiskit Aer: The Extended Stabilizer Simulator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Extended Simulator is a new method for classically simulating quantum circuits available in the latest release of [Qiskit-Aer](https://github.com/qiskit/qiskit-aer). \n",
    "\n",
    "This method is an implementation of the ideas published in the paper _Simulation of quantum circuits by low-rank stabilizer decompositions_ by Bravyi, Browne, Calpin, Campbell, Gosset & Howard, 2018, [**arXiv:1808.00128**](https://arxiv.org/abs/1808.00128).\n",
    "\n",
    "It uses a different representation of a quantum circuit, that gives it some unique capabilities. This notebook will give some examples of what the extended stabilizer method can do.\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:17:32.305227Z",
     "start_time": "2019-08-19T17:17:32.300959Z"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "from qiskit.compiler import assemble\n",
    "from qiskit.providers.aer import AerError, QasmSimulator\n",
    "from qiskit.tools.visualization import plot_histogram\n",
    "\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:21:43.756467Z",
     "start_time": "2019-08-19T17:21:43.742436Z"
    }
   },
   "outputs": [],
   "source": [
    "circ = QuantumCircuit(40, 40)\n",
    "\n",
    "# Initialise with a Hadamard layer\n",
    "circ.h(range(40))\n",
    "# Apply some random CNOT and T gates\n",
    "qubit_indices = [i for i in range(40)]\n",
    "for i in range(10):\n",
    "    control, target, t = random.sample(qubit_indices, 3)\n",
    "    circ.cx(control, target)\n",
    "    circ.t(t)\n",
    "circ.measure(range(40), range(40))\n",
    "\n",
    "qobj = assemble(circ, backend=QasmSimulator(), shots=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've created a random circuit with just 60 gates, that acts on 40 qubits. But, because of the number of qubits, if we wanted to run this with say the statevector simulator then I hope you have access to terabytes of RAM!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:21:58.295935Z",
     "start_time": "2019-08-19T17:21:58.246239Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "qasm_simulator: simulation failed\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'ERROR: AER::Base::Controller: State statevector has insufficient memory to run the circuit circuit2'\n"
     ]
    }
   ],
   "source": [
    "statevector_job = QasmSimulator().run(qobj, backend_options={\n",
    "    'method': 'statevector'\n",
    "})\n",
    "# This should error!\n",
    "try:\n",
    "    statevector_job.result()\n",
    "except AerError as err:\n",
    "    print(err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Extended Stabilizer method, in contrast, handles this circuit just fine. (Though it needs a couple of minutes!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:22:26.158636Z",
     "start_time": "2019-08-19T17:22:22.534910Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This succeeded?: True\n"
     ]
    }
   ],
   "source": [
    "es_job = QasmSimulator().run(qobj, backend_options={\n",
    "    'method': 'extended_stabilizer'\n",
    "})\n",
    "result = es_job.result()\n",
    "print('This succeeded?: {}'.format(result.success))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How does this work?\n",
    "If you're interested in how exactly we can handle such large circuits, then for a detailed explanation you can [read the paper!](https://arxiv.org/abs/1808.00128)\n",
    "\n",
    "For running circuits, however, it's important to just understand the basics.\n",
    "\n",
    "The Extended Stabilizer method is made up of two parts. The first is a method of decomposing quantum circuits into _stabilizer circuits_, a special class of circuit that can be efficiently simulated classically. The second is then a way of combining these circuits to perform measurements.\n",
    "\n",
    "The number of terms you need scales with the number of what we call _non-Clifford Gates_. At the moment, the method knows how to handle the following methods:\n",
    "```python\n",
    "circ.t(qr[qubit])\n",
    "circ.tdg(qr[qubit])\n",
    "circ.ccx(qr[control_1], qr[control_2], qr[target])\n",
    "circ.u1(rotation_angle, qr[qubit])\n",
    "```\n",
    "\n",
    "The simulator is also able to handle circuits of up to 63 qubits.\n",
    "     \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One thing that's important to note is these decompositions are approximate. This means that the results aren't exactly the same as with the State Vector simulator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:23:52.873028Z",
     "start_time": "2019-08-19T17:23:52.863305Z"
    }
   },
   "outputs": [],
   "source": [
    "small_qr = QuantumRegister(2)\n",
    "small_cr = ClassicalRegister(2)\n",
    "small_circ = QuantumCircuit(small_qr, small_cr)\n",
    "small_circ.h(small_qr[0])\n",
    "small_circ.cx(small_qr[0], small_qr[1])\n",
    "small_circ.t(small_qr[0])\n",
    "small_circ.measure(small_qr, small_cr)\n",
    "small_qobj = assemble(small_circ, backend=QasmSimulator(), shots=100)\n",
    "# This circuit should give 00 or 11 with equal probability...\n",
    "expected_results ={'00': 50, '11': 50}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:23:54.879606Z",
     "start_time": "2019-08-19T17:23:53.249255Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 shots in 1.6204757690429688s\n"
     ]
    }
   ],
   "source": [
    "es_job = QasmSimulator().run(small_qobj, backend_options={'method':'extended_stabilizer'})\n",
    "es_result = es_job.result()\n",
    "es_counts = es_result.get_counts(small_circ)\n",
    "print('100 shots in {}s'.format(es_result.time_taken))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:23:55.222602Z",
     "start_time": "2019-08-19T17:23:55.101958Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnEAAAE6CAYAAAB5+gQKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3deXxV1b3//9eHBAhDAgkGSCKYMMigNBzBAaEIAjI4AxcpWLSAVktBL18HHKv9KVSc9eIAtSqlglZprQrqpXEEaxVCAMEUCARDEoQwhSFkWr8/zkluDElIJDnJxvfz8TiPnL332ut8TnDjm7X3Xtucc4iIiIiItzSq7wJEREREpOYU4kREREQ8SCFORERExIMU4kREREQ8SCFORERExIMU4kREREQ8KLS+C6hPbdq0cR07dqzvMkREpAFZu3btHudcdMny6tWr24aGhv4ROBsNfkjwFAMbCgsLp/bp0+f7ihr8pENcx44dSUpKqu8yRESkAYmKikovuxwaGvrH9u3b94iOjt7XqFEjTa4qQVFcXGy7d+/umZ2d/Ufgiora6F8UIiIiVTs7Ojr6oAKcBFOjRo1cdHT0AfwjwBW3CWI9IiIiXtRIAU7qQ+C/u0qzmkKciIiIiAcpxImIiEi9e+aZZ9r06dOnW33X4SU/6RsbREREfowbnqJPXfa/4FZWV6ddXFxcr5ycnMZlT/eOHTs2Z+HChTvqrrqKnXfeed3Gjx+fM3PmzD3B/uyfKoU4ERERD1uyZMnmq666Kre+65Dg0+lUERGRU8zEiRM7jhgxolPJ8s033xzXr1+/M4uLi3n33XfD27Vr97NZs2a1j4yMTIyLi+v1/PPPR5W0PXr0qN14442nx8TE9GrTpk3ihAkTOh46dMhKti9atKh19+7de7Zs2dLXoUOHs998882I6dOnx61evbrlXXfd1bF58+a+SZMmdQRITk4Ou/DCC7u2atWqd3x8/Nl//OMfI0v6yc7ODrn44ou7tGzZ0terV68eW7dubRqs38+pQiFORETkFPPCCy9kfPvtt82feeaZNu+//37LJUuWnLZo0aJtjRr5/7efk5PTeM+ePaGZmZnr5s+fv23mzJlnpKSkNAWYNm3a6Vu2bAlbu3btxi1btqzPzs5ucuedd8YCfPTRR81vvvnm+Dlz5mQcOHAg+dNPP03t3Llz/rPPPruzT58+h+bMmbPjyJEjyQsXLtxx8ODBRiNHjjzzmmuu2btnz561ixYtSrv99ts7fv3112EAU6dOPSMsLKw4MzMz5U9/+tO2xYsXn1ZvvzCPUogTERHxsAkTJnQJDw/vXfJ6/PHHTwsPDy9++eWX0+67774OkydPTvjDH/7wXefOnQvK7vfEE09kNmvWzF166aWHBg8efGDRokVRxcXFLF68+LRnn332u3bt2hVFRkYW33333Vl///vfowAWLFgQPW7cuJyrr776YEhICAkJCQU+ny+vorpef/31VnFxccduueWWnMaNGzNgwIAjI0eO3L948eLIwsJC3n///dYPP/xwZkRERPG5556bN27cuJxg/L5OJbomTkRExMNee+21LRVdEzd48OAjHTp0OJaTkxM6ZcqUvWW3hYeHF0ZERBSXLHfo0CE/MzOzcVZWVmheXl6jCy64oEfZ9kVFRQawc+fOxsOHDz9QnbrS09ObrFu3rkV4eHjvsv1cffXVOZmZmaFFRUXWuXPn/JJtZ5xxxrEvvviiZfW/uSjEiYiInILmzJkTnZ+fb23bti2477772s+ZMye7ZFtubm7owYMHG5UEuYyMjCY9e/Y82r59+8KwsLDidevWfZOQkFBQvs+4uLiCrVu3hlX0eWb2gwmRO3ToUHDuuefmrlq1anP5toWFhYSEhLitW7c2KRnJ27Fjh66JqyGdThURETnFrFu3rumcOXPiXn311W2LFi3aNm/evParVq1qVrbNbbfdFpuXl2fvv/9+y6SkpFYTJkzYFxISwvjx4/dMmzatw86dO0MBtm3b1vitt96KALjhhht2v/HGG23efvvt8KKiIrZt29Y4OTk5DCA6OrowLS2tNIiNGzdu//bt28PmzZsXdezYMTt27Jh98sknzdesWRMWGhrK8OHD9993332xubm5jVavXh32xhtvtAnm7+hUoJE4ERGRGqruPG7BMH78+K5l54nr37//wezs7Ca//e1vs/v163cU4J577tl5/fXXJ6SkpGwCaNOmTUFkZGRhTEzMz8LCwoofe+yx9JIRsXnz5mXccccdseeff36P/fv3h7Zt2zZ/8uTJu4GDgwcPPjJv3rztt99+e4cJEyY0bdOmTcGTTz65w+fz5d166627pk6dmrBw4cLo0aNH57zyyivfLV++/D+33HJLh3vvvbeDc866d+9+5IknnvgOYMGCBTsmTpwYHxMTk5iQkJA3fvz4PZ9//nl4PfwKPcuc++k+Ds7n87mkpKT6LkNERBqQqKio1c65viXLKSkp2xMTE0+ZCWzffffd8ClTpiTs2rVrXX3XIieWkpJyWmJiYnxF23Q6VURERMSDFOJEREREPEghTkRE5Cfksssuy9Wp1FODQpyIiIiIBwU9xJnZb8xsm5nlmdlqM/v5Cdo3MbPfB/Y5ZmY7zGxGuTZjzGxjYPtGM7u6br+FiIiISP0Kaogzs2uAp4HZgA9YBSw3s45V7LYYGAHcCHQD/gsoHQY2s37A68BfgN6Bn381s/Pr4juIiIiINATBniduJvCKc25BYHm6mY0AbgbuKt/YzC4BhgKdnXMlt3dvL9fsVuAj59zDgeWHzWxwYP0varl+ERERkQYhaCNxZtYE6AN8WG7Th8CFlex2FfAVMNPMMsxss5k9Y2Zln63Wr4I+P6iiTxERERHPC+ZI3GlACLCr3Ppd+EfbKtIJGAAcA8YArYFngVhgbKBN+0r6bF9Rh2Z2I/5Ts8TExLBmzRoAYmNjad68OVu2bAGgVatWdOrUieTkZABCQkJITEwkNTWVw4cPA9CjRw/27t3Lrl3+jz/99NNp0qQJaWlpAERGRtKxY0dSUlIAaNy4Mb169WLTpk0cPXoUgJ49e7J79252794NwBlnnIGZsX37dgDatGlDTEwMGzZsAKBp06acddZZfPPNNxw7dgyAs88+m6ysLHJycgCIj4/HOUd6ejoA0dHRREdHs3HjRgCaNWtGjx49WL9+PQUF/kfjJSYmsmPHDvbt2+f/xXfqRH5+PhkZGQC0a9eOqKgoNm3aBECLFi3o1q0bKSkpFBUVAeDz+UhLS+PAAf+zkbt06cKRI0fIzMyk5PcdERFBamoqAOHh4XTt2pXk5GScc5gZPp+PzZs3k5vrf5Zzt27dOHjwIFlZWfpz0p+T/pzq+M/pm2++4ZlnnuHo0aOMHDmSa6+99gd/Th988AEvvfQS0dHRFBYWcuWVV3LjjTfSpEkTunTpQkJCAiEhISQkJHD77bcDsGfPHubOncv3339P586dmTVrFomJiQ36z0lO3slMKBzMyYhP9FkTJkzoGBcXV/Doo49mlW/bpUuXs5566qkdl112WW5d11mZoD2xwcxigZ3AQOfcZ2XW/w74hXOuewX7fAj8HGjvnDsQWHcJ/pG29s65XWaWD0xxzv25zH7XAS865yp8SG8JPbFBRMSvqKiIc889l6VLlxIbG8uQIUNYsGAB3bv/31/Nr732GmvXrmXu3LnH7d+hQwe+++6749b/6le/4rLLLmPMmDHMnDmTs88+m8mTJ9fpdzlZ1Xliw9ZuD/Spyxo6pz5Qrcd6xcXF9crJyWlc9rFbY8eOzVm4cOGOqvar66BUlyFu0aJFrR966KHYjIyMpo0bNy7u3r370VdeeWV7t27d8mfOnBm7devWpm+//fa22q6zvp500VCe2LAHKOL4EbK2HD+SViIL2FkS4AI2BX6W3AyRXcM+RUSknNWrV5OQkEB8fDxNmjRh9OjRLF++/KT6dM7x2WefceWVVwIwfvx43nvvvdooV8pYsmTJ5iNHjiSXvE4U4Lxsw4YNTW+++eb4Rx555LuDBw8mp6Wlrf/1r3/9faNG3p8xrWSEuCaC9q2dc/nAamBYuU3D8N+lWpGVQGy5a+DODPxMD/z8ooZ9iohIOVlZWcTFxZUux8bGlp52Leudd95hwIABXHfddaWnhwHy8vK4+OKLGTZsWGlQ27t3L61atSI0NLTKPqVuTJw4seOIESM6lSzffPPNcf369Tvz4MGDjcaOHdt19+7djZs3b+5r3ry5b/v27Y2Lioq4++6723fo0OHs1q1b9x41alSnXbt2hQCkpqY2MbM+zz77bJuYmJhekZGRiXfeeWfpAMqhQ4dszJgx8REREb07d+581pdfftm8bC3bt29vPHz48M6RkZGJcXFxvR566KG21d23rK+++qp5XFxc/pVXXpnbqFEjIiMji6+//vr9Xbt2zX/zzTcjnn322fbvvfdeZPPmzX3dunXrCfD000+36dSp01ktWrTwnX766b0effTR08r3O2vWrPYltT3//PNRJevHjBkTP2PGjNiKaomLi+v197//PRwgPDy8d8nvslmzZj4z65OamtoEYPHixa26d+/eMzw8vLfP5+v+5ZdfNivbxz333NP+zDPP7NmiRYtzahrkgh1dnwCuN7OpZtbDzJ7Gf33bCwBmttDMFpZp/xqQA7xsZmeZWX/8U5S86Zz7PtDmaeBiM7vLzLqb2V3AYOCpYH0pERGvq+jSGjP7wfKIESNYu3Ytn3/+OYMGDWLatGml29atW0dSUhILFizg7rvvZtu2bdXqU+rOCy+8kPHtt982f+aZZ9q8//77LZcsWXLaokWLtkVERBS/+eabm6OjowtKRu/i4+MLHn744bbvvfde648//jg1KysrpXXr1kVTp079wRRgK1eubLl58+YNy5Yt+8+TTz4Zu2bNmjCAO+64I3b79u1NN2/evP6DDz74z5IlS0qDUlFREZdeemmXXr16HcnKylr3v//7v6kvvPBCu7feeiviRPuWd/755x/etm1b2JQpUzq888474QcOHCjNMWPHjj04ffr07EsvvXTfkSNHklNTUzcCtGvXrvCdd97Zkpubm/ziiy9uu//++zt8/vnnpUExJyen8Z49e0IzMzPXzZ8/f9vMmTPPSElJaVqT33Vubu7akt/llClTvu/Tp8+h+Pj4gs8//7z5tGnT4p977rn0ffv2rZ08efLu0aNHdzl69GjpgfDWW29FLVu2bPPevXuTGzduXJOPDW6Ic869jn/qj3uBtfhvWhjlnCsZVevI/50mxTl3CP9ND63w36X6BvAJMLlMm1XAeOA6/PPHTQKucc59WdffR0TkVBEbG8vOnTtLlzMzM2nf/odXqkRFRdG0qf//bZMmTWLt2rWl22JiYgD/DQYDBgxg3bp1tGnThgMHDlBYWFhpn3LyJkyY0CU8PLx3yevxxx8/DSA8PLz45ZdfTrvvvvs6TJ48OeEPf/jDd507d650qOeVV16J/v3vf7+zc+fOBc2aNXNz5szJXL58eWTZ0aGHH344s2XLlq5fv35Hu3XrdvTrr79uBvCPf/wj6q677spq165dUZcuXQp+/etfl17S9Mknn7TYu3dv6GOPPZYVFhbmevbsmf/LX/5y9+LFi6NOtG95PXv2zF+2bFlqVlZW40mTJnVq27Zt7zFjxsSXDXPljR8//sBZZ511rFGjRlx66aWH+vfvf/Cjjz4qe4aPJ554IrNZs2bu0ksvPTR48OADixYtiqqsv6osWLAg8m9/+1vUP/7xj61NmzZ1zz///Gm//OUvd1988cWHQ0NDmT59ek7jxo1dUlJSi5J9brrppl1dunQpaNmyZY1vUgj2PHE4554Dnqtk26AK1qUCl5ygzzeBN2ujPhGRn6JzzjmHtLQ00tPTiYmJYenSpcyfP/8HbbKzs0tD2PLlyznzTP/VLfv376dZs2Y0bdqUnJwcvvzyS6ZPn46ZMWDAAN5++23GjBnDkiVLGDVqVNC/26nutdde23LVVVdVeIfk4MGDj3To0OFYTk5O6JQpU/ZW1U9WVlaTiRMndjGz0jAREhJCRkZG6fBQx44dSxNds2bNig8dOhQCsHv37sbx8fGlt/YmJCSUvk9LS2uye/fuJuHh4b1L1hUXF1vfvn1zT7RvRYYMGXJ4yJAhaQCffPJJ84kTJ3a+++67Y+bNm7ezovZvvPFGxMMPPxy7ffv2sOLiYvLy8hqdddZZR0u2h4eHF0ZERBSXLHfo0CE/MzOzZkNiwMqVK5vdcccdHd99993/xMbGFgJkZGQ0Wbp0aZs//elPpaePCwsLLSMjo0nJ8hlnnFHzi+ECgh7iRESk4QkNDWXu3LmMHTuWoqIiJk6cSI8ePZg9ezY+n4+RI0cyf/58li9fTmhoKJGRkcybNw+A1NRUZs6cSaNGjSguLuaWW24pvav1gQceYOrUqcyePZtevXpx7bXX1ufX/MmZM2dOdH5+vrVt27bgvvvuaz9nzpxsgLJBrUS7du0K5s+fv+2SSy45XH5byfVdlTnttNMKtm/f3qRv3755ANu3by9tHx8fnx8XF3csPT19Q033PZGLLrroyKhRo/Zt2rSpWUXf6+jRo3bdddd1fu6557ZPmDBhf9OmTd3QoUM7lz3Vn5ubG3rw4MFGJUEuIyOjSc+ePY9SA5mZmaHjxo3rMnfu3B39+/cv3TcuLq5gxowZWY888kh2ZftW9GdRXQpxIiICwLBhwxg27If3id19992l7++//37uv//+4/Y7//zzWblyZYV9xsfHs2LFitotVKpl3bp1TefMmRP3wQcfpLZs2bK4f//+PS6//PIDF1544dHY2NjCAwcOhObk5IS0adOmCOBXv/rV9/fee+/p8fHx284888z8zMzM0KSkpJbXXnvt/hN91hVXXLH3kUceibnooosOHzx4sNGLL75YOvI0aNCgwy1btiy655572t911127wsLCXHJyctiRI0caXXTRRUeq2re8Dz74oOWGDRvCxo8fvz8uLq4wOTk57MMPP2x9zTXX7AH/9W8ff/xxk6KiIkJCQsjLy7P8/PxGbdu2LWjcuLF74403IlauXBlRPqTddtttsc8888zOjz/+uEVSUlKrhx56KLO6v+eCggKuuOKKzqNHj957ww037Cu77aabbto9bty4LsOHD88dNGjQ4UOHDjVatmxZ+PDhw3MjIyOLK+uzuhTiREREaqi687gFw/jx47uWnSeuf//+B5ctW7Z14sSJnX77299m9+vX7yjAPffcs/P6669PSElJ2eTz+fIuv/zyvZ07d+5VVFTE+vXrv7n33nu/d87ZJZdccubu3bsbR0VFFVx55ZX7qhPi5s6dmzVp0qSOnTp16tW2bduCCRMm7Jk/f3478I/yvvfee1umT59+enx8/M/y8/MtISEh78EHH9x5on3Li4qKKnzvvfdaz549O+7o0aONIiMjC6+44oq9v//973cBTJo0ae/rr78eFRkZ2fv0008/tnHjxk0PPfTQjkmTJnXOz8+3IUOGHBgyZEjZacto06ZNQWRkZGFMTMzPwsLCih977LF0n8+XV93ff1paWpPVq1e3/Oabb5q/9NJLpQE0JSXlm4EDBx75n//5n+0zZszomJ6e3jQsLKy4b9++h4YPH14rEwQHbbLfhkiT/YqISHnVmexXJFgaymS/IiIiIlJLFOJEREREPEghTkRERMSDFOJEREREPEghTkREpGrFxcXFel6YBF3gv7tKpyJRiBMREanaht27d7dSkJNgKi4utt27d7cCKpwkGTRPnIiISJUKCwunZmdn/zE7O/tsNPghwVMMbCgsLJxaWQOFOBERkSr06dPne+CK+q5DpDz9i0JERETEgxTiRERERDxIp1NFRDxk7wVP13cJDVbUv26p7xJEgkojcQ3cihUrOO+88+jTpw9PPfXUcdtfe+01unbtysCBAxk4cCALFy4s3bZ48WL69u1L3759Wbx4cen6tWvX0r9/f/r06cOsWbP4KT8/V356dEyJyKlCI3ENWFFREXfccQdLly4lNjaWIUOGMGLECLp37/6DdldffTVz5879wbp9+/Yxd+5ckpKSMDMGDx7MyJEjad26NbfddhtPPvkk5557LuPGjWPFihUMGzYsmF9NpF7omBKRU4lG4hqw1atXk5CQQHx8PE2aNGH06NEsX768WvsmJSUxaNAgIiMjad26NYMGDeKf//wn2dnZ5Obmct5552FmjB8/nmXLltXxNxFpGHRMicipRCGuAcvKyiIuLq50OTY2lqysrOPavfPOOwwYMIDrrruOjIwMADIzM4/bNzMzk6ysLGJjY0/Yp8ipSMeUiJxKFOIasIquqzH74YThI0aMYO3atXz++ecMGjSIadOmVblvdfoUOVXpmBKRU4lCXAMWGxvLzp07S5czMzNp3779D9pERUXRtGlTACZNmsTatWsBiIuLO27fmJiY0tGDqvoUOVXpmBKRU4lCXAN2zjnnkJaWRnp6Ovn5+SxdupQRI0b8oE12dnbp++XLl3PmmWcCcPHFF/PRRx+xf/9+9u/fz0cffcTFF19M+/btadmyJV999RXOOZYsWcKoUaOC+r1E6ouOKRE5leju1AYsNDSUuXPnMnbsWIqKipg4cSI9evRg9uzZ+Hw+Ro4cyfz581m+fDmhoaFERkYyb948ACIjI7ntttsYMmQIALfffjuRkZEAPPbYY0ybNo28vDyGDh3K0KFD6+07igSTjikROZXYT3k+I5/P55KSkuq7DBGRatNkv5Wrrcl+o6KiVjvn+tZKZyJ1SKdTRURERDxIIU5ERETEgxTiRERERDxIIU5ERETEgxTiRERERDxIIU5ERETEgxTiRERERDxIIU5ERETEgxTiRERERDxIIU5ERETEg/Ts1Fpwx6uR9V1CgzX3un31XYJ4kI6pys2q7wJEpMHQSJyIiIiIBynEiWetWLGC8847jz59+vDUU09V2u7tt98mKiqK5ORkAHbs2EFsbCwDBw5k4MCBzJw5s7Tt2rVr6d+/P3369GHWrFk45+r8e4iIiPwYOp0qnlRUVMQdd9zB0qVLiY2NZciQIYwYMYLu3bv/oF1ubi7z58+nT58+P1gfHx/Pp59+ely/t912G08++STnnnsu48aNY8WKFQwbNqxOv4uIiMiPoZE48aTVq1eTkJBAfHw8TZo0YfTo0Sxfvvy4drNnz2bGjBmEhYWdsM/s7Gxyc3M577zzMDPGjx/PsmXL6qJ8ERGRk6YQJ56UlZVFXFxc6XJsbCxZWVk/aLNu3Tp27tzJ8OHDj9t/x44dXHTRRVx22WV88cUXpX3GxsZW2aeIiEhDodOp4kkVXatmZqXvi4uLueeee5g3b95x7dq1a8e6deuIiopi7dq1XHvttaxateqEfYqIiDQkCnHiSbGxsezcubN0OTMzk/bt25cuHzp0iE2bNnH55ZcD8P333zNx4kT+8pe/4PP5aNq0KQC9e/cmISGBrVu3EhsbS2ZmZqV9ioiINCQ6nSqedM4555CWlkZ6ejr5+fksXbqUESNGlG6PiIhgy5YtpKSkkJKSQt++fUsD3J49eygqKgJg+/btpKWlER8fT/v27WnZsiVfffUVzjmWLFnCqFGj6usrioiIVEkjceJJoaGhzJ07l7Fjx1JUVMTEiRPp0aMHs2fPxufzMXLkyEr3XbVqFXPmzCE0NJSQkBAef/xxIiP9k8s+9thjTJs2jby8PIYOHcrQoUOD9ZVERERqxH7K82D5fD6XlJR00v1odvnK6YkN8mPomKrcrOcfqO8SGqyof91SO/1ERa12zvWtlc5E6pBOp4qIiIh4kEKciIiIiAcpxImIiIh4kEKciIiIiAcpxImIiIh4kEKciIiIiAcFPcSZ2W/MbJuZ5ZnZajP7eTX3G2BmhWa2odz6683MVfA68RPPRURERDwqqCHOzK4BngZmAz5gFbDczDqeYL9IYCHwz0qaHAFiyr6cc3m1VbeIiIhIQxPskbiZwCvOuQXOuU3OuelAFnDzCfZ7CXgV+KKS7c45l132VYs1i4iIiDQ4QQtxZtYE6AN8WG7Th8CFVez3G6A98FAV3Tczs3QzyzCzd83Md9IFi4iIiDRgwXx26mlACLCr3PpdQIUPqDSzXsDvgAucc0VmVlGzVGAykAKEA7cAK80s0Tm3uYI+bwRuBIiJiWHNmjUAxMbG0rx5c7Zs2QJAq1at6NSpE8nJyQCEhISQmJhIamoqhw8fBqBHjx7s3bsX0COCKrP3gqfru4SGa9kvcc6Rnp4OQHR0NNHR0WzcuBGAZs2a0aNHD9avX09BQQEAiYmJ7Nixg337/I8z69SpE/n5+WRkZADQrl07oqKi2LRpEwAtWrSgW7dupKSkUFRUBIDP5yMtLY0DBw4A0KVLF44cOUJmZibgPy4iIiJITU0FIDw8nK5du5KcnIxzDjPD5/OxefNmcnNzAejWrRsHDx4kKysLOLnjadeuXcCQuviNyykuJyenVo4nEa8I2rNTzSwW2AkMdM59Vmb974BfOOe6l2vfFFgD/ME59+fAugeAsc65s6v4nBBgLfCRc25GVTXp2al1T895rFxtPefxVKRjqnI6piqnZ6fKT00wR+L2AEX4T42W1ZbjR+fAf4NCT+BlM3s5sK4RYGZWCIxyzpU/NUtgxO5roGutVS4iIiLSwATtmjjnXD6wGhhWbtMw/HeplrcT6AX0LvN6AdgSeF/RPpj/nOvP8N8wISIiInJKCuZIHMATwJ/N7N/ASuAmIBZ/OMPMFgI45yY55wqA8nPCfQ8cc85tKLPud8C/gM1ABDADf4g70R2vIiIiIp4V1BDnnHvdzNoA9+I/XboB/2nR9ECTKueLq0RrYD7+07QHgGT81939uxZKFhEREWmQgj0Sh3PuOeC5SrYNOsG+DwAPlFv338B/1051IiIiIt6gZ6eKiIiIeJBCnIiIiIgHKcSJiIiIeFCNQpyZjTOzS8os3x941NUHZhZT++WJiIiISEVqOhL3QMkbMzsHuBt4BmgMPF57ZYmIiIhIVWp6d+oZ+J9VCnA18Hfn3Fwz+xD4oFYrExEREZFK1XQkLg//Q+bB/4TqFYH3B8qsFxEREZE6VkpdUdkAABS3SURBVNORuM+Ax83sc6AvMDaw/kzgu9osTEREREQqV9ORuN8C+fjD203OuczA+pHodKqIiIhI0NRoJM45lwFcXsH6W2utIhERERE5oRrPE2dmYWY21szuNLPWgXWdzSyq9ssTERERkYrUaCTOzLrgv5mhJf4Hz/8V2A/cHFieWtsFioiIiMjxajoS9xTwIdAOOFpm/T+AwbVVlIiIiIhUraZ3p14IXOCcKzKzsut3ALG1VpWIiIiIVOnHPDu1cQXrOuKfK05EREREgqCmIe5DYGaZZWdmEcCDwHu1VpWIiIiIVKmmp1NnAh+ZWSoQBrwOdAF2AeNquTYRERERqURN54nLNLPewC+Ac/CP5M0H/uKcO1rlziIiIiJSa2o6EkcgrP0p8BIRERGRenDCEGdmo4F3nHMFgfeVcs4trbXKRERERKRS1RmJexNoD3wfeF8ZB4TURlEiIiIiUrUThjjnXKOK3ouIiIhI/alRKDOzgWZ2XPAzsxAzG1h7ZYmIiIhIVWo6svYRUNGD7lsHtomIiIhIENQ0xBn+a9/KawMcPvlyRERERKQ6qjXFiJn9I/DWAYvM7FiZzSHA2cCqWq5NRERERCpR3XnicgI/DdgHlJ3YNx/4HFhQi3WJiIiISBWqFeKcc78CMLPtwGPOOZ06FREREalHNX3s1oN1VYiIiIiIVF91ntiwDrjIObfPzNZT8Y0NADjnflabxYmIiIhIxaozEvcWUHIjQ1VPbBARERGRIKnOExserOi9iIiIiNQfPUZLRERExIOqc01cldfBlaVr4kRERESCozrXxOk6OBEREZEGpkbXxImIiIhIw6Br4kREREQ8SPPEiYiIiHiQ5okTERER8SDNEyciIiLiQTV6dmoJM+sM9AgsbnLOba29kkRERETkRGoU4sysDfAScAVQ/H+r7V1gsnMup5brExEREZEK1PTu1D8CXYCfA2GB10AgAVhQu6WJiIiISGVqejp1ODDEOfdFmXUrzezXwIraK0tEREREqlLTkbjdwOEK1h8BdCpVREREJEhqGuJ+DzxlZnElKwLvHw9sExEREZEgqM5kv+Un+E0AtpvZzsByHJAHtMV/zZyIiIiI1LHqXBOnCX5FREREGpgaTfYrIiIiIg1DTa+JExEREZEGoEYhzsyamNmDZvYfM8szs6Kyr7oqUkRERER+qKYjcf8fcB3+u1GLgduBefinF/lNdTows9+Y2bZACFxtZj+vou1FZrbKzHLM7KiZfWtmt1XQboyZbTSzY4GfV9fwe4mIiIh4Sk1D3DjgJufci0AR8LZzbgbwO2DYiXY2s2uAp4HZgA9YBSw3s46V7HIIeAb/UyF6Ag8BD5pZaWA0s37A68BfgN6Bn381s/Nr+N1EREREPKOmIa4dsDHw/hDQOvD+feCSauw/E3jFObfAObfJOTcdyAJurqixc261c26Jc+4b59w259wi4AP8j/0qcSvwkXPu4UCfDwMfB9aLiIiInJJqGuJ2ALGB91vwP4YLoB9wtKodzawJ0Af4sNymD4ELq/PhZuYLtP2kzOp+FfT5QXX7FBEREfGimj479W/AEOBf+E+LLjazG/BP+PvoCfY9DQgBdpVbvwsYWtWOZpYBRAfqfdA590KZze0r6bN9JX3dCNwIEBMTw5o1awCIjY2lefPmbNmyBYBWrVrRqVMnkpOTAQgJCSExMZHU1FQOH/Y/eaxHjx7s3bsXiKyqfJEK7d27F+cc6enpAERHRxMdHc3Gjf7B7mbNmtGjRw/Wr19PQUEBAImJiezYsYN9+/YB0KlTJ/Lz88nIyACgXbt2REVFsWnTJgBatGhBt27dSElJoajIf++Rz+cjLS2NAwcOANClSxeOHDlCZmYm4D8uIiIiSE1NBSA8PJyuXbuSnJyMcw4zw+fzsXnzZnJzcwHo1q0bBw8eJCsrCzi542nXrl34/5oRqZmcnJxaOZ5EvMKccyduVdnOZhfgH/H6j3Pu3RO0jQV2AgOdc5+VWf874BfOue5V7JsAtAQuAB4BbnHO/TmwLR+YUrIcWHcd8KJzLqyqmnw+n0tKSjrBtzyxO15ViKvMrOcfqO8SGqyof91S3yU0WDqmKqdjqnK1dUxFRUWtds71rZXOROpQTUfifsA59y/8o3LVsQf/zRDlR8jacvxIWvnP2RZ4u97M2gEPACWhLfvH9CkiIiLiZTWe7NfMzjGzhWb2deD1ZzM750T7OefygdUcfxfrMPx3qVZXI6BpmeUvaqFPEREREU+p0UicmU0EFgJJwLLA6guAf5vZ9YG7R6vyBPBnM/s3sBK4Cf+NEi8E+l8I4JybFFieDmwDUgP7DwRuA54r0+fTwKdmdhf+a/auBgYDA2ry3URERES8pKanUx8G7nPOzS67MhCgHgKqDHHOudfNrA1wLxADbABGOefSA03KzxcXgv8auHigENgKzCIQ+gJ9rjKz8YHPfzDQ5hrn3Jc1/G4iIiIinlHTEBcNvFHB+r8C91WnA+fcc/xwJK3stkHllp8CnqpGn28Cb1bn80VEREROBTW9Ju4jYFAF6wfxw7nbRERERKQOnXAkzsxGl1lcDswxs778312pFwCj8d8xKiIiIiJBUJ3TqRWdpiydMLeMZ6nkNKmIiIiI1K4ThjjnXI2nIRERERGRuqWAJiIiIuJBP2ay30vN7FMz22Nmu83sEzMbVRfFiYiIiEjFahTizGwq/gl1twJ34p+zbRvwNzObXPvliYiIiEhFajpP3J3ATOfc/5RZ95KZrcYf6P5Ua5WJiIiISKVqejq1I/B+BeuXA2ecfDkiIiIiUh01DXE7OP5h8wCXAOkVrBcRERGROlDT06mPAc+a2TnAKsDhf9D8L4HptVybiIiIiFSiRiHOOfeimX0P/D/8T2kA2ASMc869XdvFiYiIiEjFqh3izCwU/2nTT51zf6u7kkRERETkRKp9TZxzrhBYCoTXXTkiIiIiUh01vbEhBehSF4WIiIiISPXVNMQ9ADxuZleZWQcziyr7qoP6RERERKQCNb079b3Az6X470wtYYHlkNooSkRERESqVtMQN7hOqhARERGRGqlWiDOz5sCjwFVAY2AFMMM5t6cOaxMRERGRSlT3mrgHgevxn05djP+pDc/XUU0iIiIicgLVPZ06GpjinFsCYGZ/AVaaWYhzrqjOqhMRERGRClV3JK4D8FnJgnPu30AhEFsXRYmIiIhI1aob4kKA/HLrCqn5jREiIiIiUguqG8IMWGRmx8qsCwMWmNmRkhXOuStqszgRERERqVh1Q9yrFaxbVJuFiIiIiEj1VSvEOed+VdeFiIiIiEj11fSxWyIiIiLSACjEiYiIiHiQQpyIiIiIBynEiYiIiHiQQpyIiIiIBynEiYiIiHiQQpyIiIiIBynEiYiIiHiQQpyIiIiIBynEiYiIiHiQQpyIiIiIBynEiYiIiHiQQpyIiIiIBynEiYiIiHiQQpyIiIiIBynEiYiIiHiQQpyIiIiIBynEiYiIiHiQQpyIiIiIBynEiYiIiHiQQpyIiIiIBynEiYiIiHiQQpyIiIiIBynEiYiIiHiQQpyIiIiIBwU9xJnZb8xsm5nlmdlqM/t5FW1jzOw1M/vWzIrM7JUK2lxvZq6CV1idfhERERGRehTUEGdm1wBPA7MBH7AKWG5mHSvZpSmwB/gD8GUVXR8BYsq+nHN5tVW3iIiISEMT7JG4mcArzrkFzrlNzrnpQBZwc0WNnXPbnXMznHOvAHur6Nc557LLvmq/dBEREZGGI2ghzsyaAH2AD8tt+hC48CS7b2Zm6WaWYWbvmpnvJPsTERERadBCg/hZpwEhwK5y63cBQ0+i31RgMpAChAO3ACvNLNE5t7l8YzO7EbgRICYmhjVr1gAQGxtL8+bN2bJlCwCtWrWiU6dOJCcnAxASEkJiYiKpqakcPnwYgB49erB3714g8iTKl5+qvXv34pwjPT0dgOjoaKKjo9m4cSMAzZo1o0ePHqxfv56CggIAEhMT2bFjB/v27QOgU6dO5Ofnk5GRAUC7du2Iiopi06ZNALRo0YJu3bqRkpJCUVERAD6fj7S0NA4cOABAly5dOHLkCJmZmYD/uIiIiCA1NRWA8PBwunbtSnJyMs45zAyfz8fmzZvJzc0FoFu3bhw8eJCsrCzg5I6nXbt2AUPq4lcup7icnJxaOZ5EvMKcc8H5ILNYYCcw0Dn3WZn1vwN+4ZzrfoL93wX2OOeuP0G7EGAt8JFzbkZVbX0+n0tKSqrmN6jcHa8qxFVm1vMP1HcJDVbUv26p7xIaLB1TldMxVbnaOqaioqJWO+f61kpnInUomNfE7QGKgPbl1rfl+NG5H805VwR8DXStrT5FREREGpqghTjnXD6wGhhWbtMw/Hep1gozM+Bn+G+YEBERETklBfOaOIAngD+b2b+BlcBNQCzwAoCZLQRwzk0q2cHMegfeRgDFgeV859zGwPbfAf8CNgfazMAf4iq841VERETkVBDUEOece93M2gD34p/PbQMwyjmXHmhS0XxxyeWWLwfSgfjAcmtgPv7TtAcC7Qc65/5du9WLiIiINBzBHonDOfcc8Fwl2wZVsM5O0N9/A/9dK8WJiIiIeISenSoiIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQQpxIiIiIh6kECciIiLiQUEPcWb2GzPbZmZ5ZrbazH5+gvYXBdrlmVmamd10sn2KiIiIeF1QQ5yZXQM8DcwGfMAqYLmZdaykfQKwLNDOB8wBnjWzMT+2TxEREZFTQbBH4mYCrzjnFjjnNjnnpgNZwM2VtL8JyHTOTQ+0XwC8Ctx2En2KiIiIeJ4554LzQWZNgCPAL5xzfy2zfh5wtnPuogr2+RRY75ybVmbdfwGvAc0B+xF93gjcGFjsBqTWwteTyp0G7KnvIkROITqm6t4Zzrno+i5C5ERCg/hZpwEhwK5y63cBQyvZpz2wooL2oYH+rKZ9OufmA/OrXbWcFDP72jnXt77rEDlV6JgSkRL1cXdq+aE/q2DdidqXX1/TPkVEREQ8LZgjcXuAIvyja2W15fiRtBLZlbQvBHLwh7Wa9ikiIiLieUEbiXPO5QOrgWHlNg3Df0dpRb7g+NOiw4CvnXMFP7JPCS6duhapXTqmRAQI4o0NUDodyJ+B3wAr8d99OgU4yzmXbmYLAZxzkwLtE4ANwALgRaA/8Bz+Gxneqk6fQftyIiIiIkEUzNOpOOdeN7M2wL1ADP6ANqpM2OpYrv02MxsFPIl/ypBMYEZJgKtmnyIiIiKnnKCOxImIiIhI7dCzU0VEREQ8SCFORERExIMU4kREREQ8KKg3NshPg5mdDnTBP49fMZDqnMuu36pEREROLbqxQWqVmd0MTAYSgcPAFiAD/5x/bzvnUs2skXOuuB7LFBER8TydTpVaE5jqZTbwNv7pXvoBr+IfjbsOeNbMejrnis3MKu9JRADMrLGZnWlmTeu7FhFpeDQSJ7XGzKYD1zrnzq9g2wBgDhAHnOec2xPs+kS8xsxuBR4G3gCWAl8Bu51zRWXaROCfCH2Fc66gXgoVkXqhkTipTflAuJmdDWBmTc2sCYBz7nNgIpAHXFJ/JYp4yjXAv/FfY/p3/JclPGpmA8ysVaDNBOB3CnAiPz0KcVKb3sR/6vRWMwt3zh1zzuWbWSMA59wOYD9wen0WKeIFZhYNFAALnHM/B84AXgIuAz4FkszsTuBW4Mt6K1RE6o1Op0qtKHON25XA00AU/lNAzwHJ+IPbQOB5oJdzbns9lCniGWYWA4wHNjrnPii3zQdMDWyPBDo453YGv0oRqU8KcVKrzKw1/mfgXghcjf9aHYBs/CO/C51zD9RPdSLeYmbNAOecyyt7M5AL/MVtZg/jf1a0r75qFJH6o3ni5KSZWVvgl8D/A/YAR/GfNv0MeAxoDHQGPgA211OZIp7jnDtaEt5cuX9xm1lzYAzwcn3UJiL1TyNxctLM7BXgLOAdYC/+U6m9gDOB74F7nXO6ZkekmgJ3nOaWD27l2oThv/FhsXMuP2jFiUiDoRAnJyUwSpCL/5TOp2XWdQQuAKYAnYBxzrk19VaoiIeY2Yv470r9N5DunDtYQZvWzrn9QS9ORBoM3Z0qJ6snsA3/9CKA/7SPcy7dOfc6cDn+U6v/VU/1iXiKmf0CuAF4HP/E2Y+a2dVm1jlwjVzJtXKvlkznIyI/TRqJk5MS+J/Ju0BzYBKwtfwjtQKTAE9xzvWuhxJFPMXMFgBFwFxgNP6nnXQGUoFlwD+BbsDTzrkm9VWniNQ/jcTJSXHOHQXuAZoBC4FJZtbBzFpA6cXXFwEb6q9KEW8ws1D8I9v7nXNpzrnHnHO9gHOBT/AHujeAZ4E/11+lItIQaCROakXgtM59wBX4H3z/BbAbGApkAVOdc+vrr0IRbzCzSKCdc+7bwBNPCsre4GBm1wCLgXOcc2vrq04RqX8KcVKrAtONXApchf8RWxuAvzrnvq3XwkQ8LPDUE3POFZnZDfhPpTav77pEpH4pxEmdMbNG5a+PE5GTY2YzgRDn3KP1XYuI1C+FOBERDzGzxkCR/oEkIgpxIiIiIh6ku1NFREREPEghTkRERMSDFOJEREREPEghTkRERMSDFOJEREREPEghTkRERMSD/n+0vomB/1Rr7QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histogram([expected_results, es_counts], legend=['Expected', 'Extended Stabilizer'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can control this approximation error using the `backend_options` in Qiskit Aer. The default error is 0.05. The smaller the error, the more precise the results, but also the longer your simulation will take and the more memory it will require."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:24:01.638958Z",
     "start_time": "2019-08-19T17:23:57.206364Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 shots in 4.334500074386597s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "es_job = QasmSimulator().run(small_qobj, backend_options={\n",
    "    'method':'extended_stabilizer',\n",
    "    'extended_stabilizer_approximation_error': 0.03\n",
    "})\n",
    "es_result = es_job.result()\n",
    "es_counts = es_result.get_counts(small_circ)\n",
    "print('100 shots in {}s'.format(es_result.time_taken))\n",
    "plot_histogram([expected_results, es_counts], legend=['Expected', 'Extended Stabilizer'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulator Options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several other options you can tweak to control how the extended stabilizer method performs. What these options are and their explanation can all be found in the Qiskit Aer documentation. However, I want to highlight two important ones that can help to optimize your simulations.\n",
    "\n",
    "To perform measurements, the extended stabilizer method uses a Markov chain method to sample outcomes at random. This Markov chain has to be run for some time we call the 'mixing time' before it will start sampling, and has to be re-mixed for every circuit shot.\n",
    "\n",
    "If you expect your circuit output to be concentrated on just a few output states, then you can likely optimize your simulations by reducing the `extended_stabilizer_mixing_time` option.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:24:03.270544Z",
     "start_time": "2019-08-19T17:24:03.132881Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The circuit above, with 100 shots at precision 0.03 and default mixing time, needed 4s\n",
      "Dialing down the mixing time, we completed in just 0.12828803062438965s\n"
     ]
    }
   ],
   "source": [
    "print(\"The circuit above, with 100 shots at precision 0.03 \"\n",
    "      \"and default mixing time, needed {}s\".format(int(es_result.time_taken)))\n",
    "optimised_job = QasmSimulator().run(small_qobj, backend_options={\n",
    "    'method': 'extended_stabilizer',\n",
    "    'extended_stabilizer_approximation_error': 0.03,\n",
    "    'extended_stabilizer_mixing_time': 100\n",
    "})\n",
    "optimised_result = optimised_job.result()\n",
    "print('Dialing down the mixing time, we completed in just {}s'.format(optimised_result.time_taken))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, if your circuit has some non-zero probability on all amplitudes (e.g. if it's a random circuit), then you can avoid this expensive re-mixing step to take multiple shots from the output at once. This can be enabled by setting `extended_stabilizer_measure_sampling=True` in the `backend_options`.\n",
    "\n",
    "For example, let's look again at the random circuit from the start of the tutorial, running for 100 shots:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:24:03.961088Z",
     "start_time": "2019-08-19T17:24:03.951284Z"
    }
   },
   "outputs": [],
   "source": [
    "multishot_qobj = assemble(circ, backend=QasmSimulator(), shots=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:24:20.656799Z",
     "start_time": "2019-08-19T17:24:04.332417Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 shots took 16.27883291244507 s\n"
     ]
    }
   ],
   "source": [
    "# It's a 40 qubit circuit so we use Extended Stabilizer automatically\n",
    "multishot_job = QasmSimulator().run(multishot_qobj, backend_options={\n",
    "    'extended_stabilizer_mixing_time': 100 # We set this here only to make the example run more quickly.\n",
    "})\n",
    "result = multishot_job.result()\n",
    "print(\"100 shots took {} s\".format(result.time_taken))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:24:21.070233Z",
     "start_time": "2019-08-19T17:24:20.918300Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "With the optimization, 50 shots took 0.11262798309326172 s\n"
     ]
    }
   ],
   "source": [
    "multishot_job = QasmSimulator().run(multishot_qobj, backend_options={\n",
    "    'extended_stabilizer_measure_sampling': True,\n",
    "    'extended_stabilizer_mixing_time': 100 # We set this here only to make the example run more quickly.\n",
    "})\n",
    "result = multishot_job.result()\n",
    "print(\"With the optimization, 50 shots took {} s\".format(result.time_taken))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How can I use it?\n",
    "\n",
    "In the latest release of Qiskit Aer, if you try to run a circuit on more qubits than can be handled by the state vector simulator, then Aer will automatically switch to using the extended stabilizer method. You can also force circuits to run on this method using the `backend_options` keyword argument to `QasmSimulator().run`. \n",
    "\n",
    "It's worth bearing in mind: if you have smaller circuits with lots of non-Clifford gates, then the statevector method will likely perform better than the extended stabilizer. If however you want to look at circuits on many qubits, without needing access to high performance computation, then give this method a try!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:24:45.930560Z",
     "start_time": "2019-08-19T17:24:45.920568Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td>Qiskit</td><td>None</td></tr><tr><td>Terra</td><td>0.9.0</td></tr><tr><td>Aer</td><td>0.3.0</td></tr><tr><td>Ignis</td><td>0.2.0</td></tr><tr><td>Aqua</td><td>0.5.6</td></tr><tr><td>IBM Q Provider</td><td>0.3.2rc1</td></tr><tr><th>System information</th></tr><tr><td>Python</td><td>3.7.3 (default, Mar 27 2019, 16:54:48) \n",
       "[Clang 4.0.1 (tags/RELEASE_401/final)]</td></tr><tr><td>OS</td><td>Darwin</td></tr><tr><td>CPUs</td><td>4</td></tr><tr><td>Memory (Gb)</td><td>16.0</td></tr><tr><td colspan='2'>Mon Aug 19 13:24:45 2019 EDT</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2019.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import qiskit.tools.jupyter\n",
    "%qiskit_version_table\n",
    "%qiskit_copyright"
   ]
  },
  {
   "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"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}